स्विफ्ट में बिट ऑपरेशंस के साथ कैसे काम करें?

Question

मैं एक 20 बाइट डाटा पैकेट के लिए फार्म और ब्लूटूथ पर एक हार्डवेयर परिधीय के लिए पेलोड भेजने की जरूरत है।

यह 20 बाइट डाटा पैकेट आंतरिक रूप से 14 डेटा सेट, 11 बिट से प्रत्येक में बांटा गया है, पिछले 6 बिट्स अशक्त चरित्र होना चाहिए।

इसलिए, कुल: 160 बिट्स (20 बाइट्स) = 14 (सेट) * 11 (बिट) + 6 (शून्य अक्षर)

11 बिट फिर से 2 बिट के 3 सेट, 3 में बांटा जाता है बिट और 6 बिट प्रत्येक। हालांकि यह मुख्य प्रश्न के लिए महत्वपूर्ण नहीं है, मैं वर्तमान में, 11 बिट के रूप में एक 'int16' लेने से कर रहा हूँ। मैं 11 बिट्स को फ़िल्टर करने के लिए शिफ्ट ऑपरेशन करूंगा, मुझे पता है।

यदि मेरे पास केवल एक डेटा सेट है तो मुझे शून्य के चरित्र के साथ पहले 11 बिट्स को छोड़कर सभी 20 बाइट भरना चाहिए, यदि दो डेटा सेट तो 22 बिट्स को छोड़कर सभी को शून्य वर्ण और क्रमशः होना चाहिए।

जिस मुद्दे का मैं सामना कर रहा हूं वह 11 अनुक्रमित बिट्स की वजह से इस अनुक्रमिक 160 बिट्स का निर्माण करना है। मैंने 'इंट' लेने और शिफ्ट (< <) ऑपरेशन करने के बारे में सोचा और फिर bitwise OR (|) लेकिन एक इंट 64 बिट्स है।

वर्तमान में मैं 20 की एक निश्चित आकार चरित्र सरणी लेने इस स्थिति फिट के बारे में सोच। हालांकि धारणात्मक मुझे लगता है कि यह सबसे अच्छा संभव तरीका है, प्रोग्राम के रूप में मैं सभी शर्तों इस लक्ष्य को हासिल करने के लिए के साथ तर्क बनाने में सक्षम नहीं हूँ। मुझे लगता है कि मुझे सभी लॉजिक को लूप में रखना होगा।

क्या कोई यह बता सकता है कि यह इसे प्राप्त करने का सही तरीका है, और इसे हल करने पर मुझे मार्गदर्शन करें, अगर यह सबसे अच्छा तरीका है। या उपलब्ध होने पर किसी अन्य तरीके से इंगित करें।

Answer 1

आपको सभी डेटासेट को 20-बाइट सरणी में बहुत अंत तक पैक करने की आवश्यकता नहीं है, इसलिए उन्हें लंबाई Int लंबाई 14 में रखें। इस तरह से काम करना आसान है। जब आप हार्डवेयर के लिए इस पर भेजने की जरूरत है, यह लंबाई 20 की UInt8 सरणी में बदलने का:

struct DataPacket { 
    var dataSets = [Int](count: 14, repeatedValue: 0) 

    func toCArray() -> [UInt8] { 
     var result = [UInt8](count: 20, repeatedValue: 0) 
     var index = 0 
     var bitsRemaining = 8 
     var offset = 0 

     for value in self.dataSets { 
      offset = 10 

      while offset >= 0 { 
       let mask = 1 << offset 
       let bit = ((value & mask) >> offset) << (bitsRemaining - 1) 
       result[index] |= UInt8(bit) 

       offset -= 1 
       bitsRemaining -= 1 
       if bitsRemaining == 0 { 
        index += 1 
        bitsRemaining = 8 
       } 
      } 
     } 

     return result 
    } 
} 

// Usage: 
var packet = DataPacket() 
packet.dataSets[0] = 0b11111111111 
packet.dataSets[1] = 0b00000000011 
// etc... 

let arr = packet.toCArray() 

वहाँ तो मैं उन सब को व्याख्या नहीं कर सकते चल रहा आपरेशन स्थानांतरण का एक बहुत है। सामान्य आदर्श बाइट्स में उन 11-बिट डाटासेट में से प्रत्येक के लिए आवंटित, अगले बाइट के रूप में आवश्यक के लिए खत्म हो फैलने है।

Answer 2

समाधान संहिता विभिन्न द्वारा प्रस्तावित का एक प्रकार:

struct DataPacket { 
    var dataSets = [Int16](count: 14, repeatedValue: 0) 

    func getPacket() -> [UInt8] { 
     var packet = [UInt8](count: 20, repeatedValue: 0) 
     var idxPacket = 0 

     for dataSet in dataSets { 
      for idxBit in 1...11 { 
       if dataSet & 1 << (11 - idxBit) != 0 { 
        packet[idxPacket/8] |= UInt8(0b1000_0000 >> (idxPacket % 8)) 
       } 
       idxPacket += 1 
      } 
     } 

     return packet 
    } 
}