🧜🏻 👋🏻 🤽🏾 CortexM3 / M4 (ARM) हार्डवेयर बिट बैंडिंग, कर्नेल आर्किटेक्चर, कोडांतरक, C / C ++ 14 और मेटाप्रोग्रामिंग की एक बूंद ❄️ ⚛️ 🐱

परिचय

ध्यान दें, यह एक और "हैलो वर्ल्ड" लेख नहीं है कि कैसे एलईडी को ब्लिंक किया जाए या एसटीएम 32 पर इसकी पहली बाधा हो। हालांकि, मैंने उठाए गए सभी मुद्दों पर व्यापक स्पष्टीकरण देने की कोशिश की, इसलिए यह लेख न केवल कई पेशेवर और ऐसे डेवलपर्स बनने के सपने देखने के लिए उपयोगी होगा (जैसा कि मुझे आशा है), बल्कि माइक्रोकंट्रोलर प्रोग्रामर्स को भी नौसिखिया बनाने के लिए, क्योंकि कुछ विषयों के लिए यह विषय अनगिनत साइटों पर मिलता है / ब्लॉग "एमके प्रोग्रामिंग शिक्षक।"

मैंने इसे लिखने का फैसला क्यों किया?

हालाँकि मैंने अतिशयोक्ति की है, पहले कहा था कि कॉर्टेक्स-एम परिवार के हार्डवेयर बिट बैंडिंग को विशेष संसाधनों पर वर्णित नहीं किया गया है, फिर भी ऐसी जगहें हैं जहां यह सुविधा शामिल है (और यहां एक लेख भी मिला है), लेकिन इस विषय को स्पष्ट रूप से पूरक और आधुनिकीकरण करने की आवश्यकता है। मैं ध्यान देता हूं कि यह अंग्रेजी-भाषा के संसाधनों पर भी लागू होता है। अगले भाग में, मैं बताऊंगा कि यह कर्नेल विशेषता अत्यंत महत्वपूर्ण क्यों हो सकती है।

सिद्धांत

(और जो लोग उसे जानते हैं वे तुरंत अभ्यास में कूद सकते हैं)
हार्डवेयर बिट बैंडिंग स्वयं कोर की एक विशेषता है, और इसलिए माइक्रोकंट्रोलर्स के निर्माता के परिवार और कंपनी पर निर्भर नहीं करता है, मुख्य बात यह है कि कोर उपयुक्त है। हमारे मामले में, इसे Cortex-M3 होने दें। इसलिए, इस मुद्दे पर जानकारी कोर पर ही एक आधिकारिक दस्तावेज में मांगी जानी चाहिए, और इस तरह का एक दस्तावेज है, यहां यह है , खंड 4.2 में विस्तार से वर्णन किया गया है कि इस उपकरण का उपयोग कैसे किया जाए।

यहाँ मैं प्रोग्रामर के लिए एक छोटा सा तकनीकी विषयांतर बनाना चाहूंगा जो कि असेंबलर से परिचित नहीं हैं, जिनमें से अधिकांश अब ऐसे "गंभीर" STM32, LPC, आदि के लिए कोडांतरक की प्रसार जटिलता और बेकारता के कारण हैं, इसके अलावा, एसटीएम 32, एलपीसी आदि। इस क्षेत्र में असेंबलर के उपयोग के लिए सेंसर, यहां तक कि हैबर पर भी। इस खंड में मैं एमके मेमोरी को लिखने के तंत्र का संक्षेप में वर्णन करना चाहता हूं, जिसे बिट बैंडिंग के फायदे स्पष्ट करना चाहिए।

मैं सबसे STM32 के लिए एक विशिष्ट सरल उदाहरण की व्याख्या करूंगा। मान लीजिए कि मुझे PB0 को एक सामान्य-उद्देश्य आउटपुट में बदलने की आवश्यकता है। एक विशिष्ट समाधान इस तरह दिखेगा:

GPIOB->MODER |= GPIO_MODER_MODER0_0;

जाहिर है, हम रजिस्टर के शेष बिट्स को अधिलेखित नहीं करने के लिए बिटवाइज़ “OR” का उपयोग करते हैं।

कंपाइलर के लिए, यह 4 निर्देशों के निम्नलिखित सेट में अनुवाद करता है:

सामान्य प्रयोजन रजिस्टर (RON) के लिए GPIOB-> MODER डाउनलोड करें
P1 से RON में इंगित पते पर अन्य RON के मानों को अपलोड करें।
GPIO_MODER_MODER0_0 के साथ इस मान का एक बिटवाइस या बनाएं।
परिणाम GPIOB-> MODER पर वापस डाउनलोड करें।

इसके अलावा, किसी को यह नहीं भूलना चाहिए कि यह कर्नेल थंब 2 निर्देश सेट का उपयोग करता है, जिसका अर्थ है कि वे वॉल्यूम में भिन्न हो सकते हैं। मैं यह भी ध्यान देता हूं कि हर जगह हम अनुकूलन ओ 3 के स्तर के बारे में बात कर रहे हैं।

विधानसभा भाषा में, यह इस तरह दिखता है:

यह देखा जा सकता है कि बहुत पहले निर्देश एक ऑफसेट के साथ एक छद्म निर्देश से अधिक कुछ नहीं है, हम पीसी पते पर कोड का पता (कन्वेयर बेल्ट को देखते हुए) + 0x58 पाते हैं।

यह पता चलता है कि हमारे पास प्रति ऑपरेशन में 4 चरण (और अधिक घड़ी चक्र) और कब्जे वाली मेमोरी के 14 बाइट्स हैं।
यदि आप इसके बारे में अधिक जानना चाहते हैं, तो मैं पुस्तक [2] की सिफारिश करता हूं, वैसे, रूसी में भी है।

हम बिट_बैंडिंग विधि से गुजरते हैं।

सार, किसान के अनुसार, प्रोसेसर में एक विशेष रूप से आवंटित मेमोरी क्षेत्र है, जिसमें उन मानों को लिखना है जो हम परिधीय रजिस्टर या रैम के अन्य बिट्स को नहीं बदलते हैं। यही है, हमें ऊपर वर्णित बिंदुओं 2) और 3) को पूरा करने की आवश्यकता नहीं है, और इसके लिए यह केवल [1] से सूत्रों के अनुसार पते को याद करने के लिए पर्याप्त है।

हम एक समान ऑपरेशन करने की कोशिश कर रहे हैं, इसके असेंबलर:

पुनर्गणित पता:

यहां हमने RON में एक लिखित निर्देश # 1 जोड़ा है, लेकिन वैसे भी, परिणाम 14 के बजाय 10 बाइट्स है, और घड़ी चक्र का एक जोड़ा कम है।

लेकिन क्या होगा अगर अंतर हास्यास्पद है?

एक तरफ, बचत महत्वपूर्ण नहीं है, खासकर जब यह पहले से ही 168 मेगाहर्ट्ज के नियंत्रक को ओवरक्लॉक करने की आदत है, तो चक्रों में। एक औसत परियोजना में, जिन क्षणों में आप इस विधि को लागू कर सकते हैं वे क्रमशः बाइट्स में 40 - 80 होंगे, यदि पते भिन्न होते हैं तो बचत 250 बाइट्स तक पहुंच सकती है। और अगर हम मानते हैं कि प्रोग्रामिंग एमके सीधे रजिस्टरों पर "ज़शकार" माना जाता है, और यह सभी प्रकार के पासा-क्यूब्स का उपयोग करने के लिए "शांत" है, तो बचत बहुत अधिक हो सकती है।

इसके अलावा, 250 बाइट्स का आंकड़ा इस तथ्य से विकृत है कि समुदाय में उच्च-स्तरीय पुस्तकालयों का सक्रिय रूप से उपयोग किया जाता है, फर्मवेयर अशोभनीय आकारों को बढ़ाता है। जब निम्न स्तर पर प्रोग्रामिंग होती है, तो यह एक औसत परियोजना के लिए कम से कम 2 - 5% सॉफ़्टवेयर वॉल्यूम, सक्षम वास्तुकला और O3 अनुकूलन के साथ होता है।

फिर से, मैं यह नहीं कहना चाहता कि यह किसी प्रकार का सुपर-डुपर-मेगा कूल टूल है जिसे हर स्वाभिमानी एमके प्रोग्रामर उपयोग कर सकते हैं। लेकिन अगर मैं इतने कम हिस्से से भी लागत में कटौती कर सकता हूं, तो क्यों नहीं?

कार्यान्वयन

सभी विकल्प केवल बाह्य उपकरणों को कॉन्फ़िगर करने के लिए दिए जाएंगे, क्योंकि मैं ऐसी स्थिति में नहीं आया था जहां यह रैम के लिए आवश्यक होगा। रैम के लिए सख्ती से बोलना, सूत्र समान है, बस गणना के लिए आधार पते बदलें। तो आप इसे कैसे लागू करते हैं?

कोडांतरक

आइए नीचे से चलते हैं, मेरे प्यारे असेम्बलर से।

असेंबलर परियोजनाओं पर, मैं आमतौर पर पूरे प्रोजेक्ट के लिए # 0 और # 1 के तहत 2-बाइट (उनके साथ काम करने वाले निर्देशों के अनुसार) के एक जोड़े को आवंटित करता हूं, और उन्हें मैक्रोज़ में भी उपयोग करता हूं, जो मुझे एक निरंतर आधार पर 2 बाइट्स कम कर देता है। रिमार्क, मुझे एसटीएम के लिए असेंबलर में सीएमएसआईएस नहीं मिला, क्योंकि मैंने बिट नंबर को तुरंत मैक्रो में डाल दिया, न कि इसके रजिस्टर मूल्य पर।

जीएनयू असेंबलर के लिए कार्यान्वयन

 @  . MOVW R0, 0x0000 MOVW R1, 0x0001 @   .macro PeriphBitSet PerReg, BitNum LDR R3, =(BIT_BAND_ALIAS+(((\PerReg) - BIT_BAND_REGION) * 32) + ((\BitNum) * 4)) STR R1, [R3] .endm @   .macro PeriphBitReset PerReg, BitNum LDR R3, =(BIT_BAND_ALIAS+((\PerReg - BIT_BAND_REGION) * 32) + (\BitNum * 4)) STR R0, [R3] .endm

उदाहरण:

असेंबलर उदाहरण

 PeriphSet TIM2_CCR2, 0 PeriphBitReset USART1_SR, 5

इस विकल्प का निस्संदेह लाभ यह है कि हमारे पास पूर्ण नियंत्रण है, जिसे आगे के विकल्पों के बारे में नहीं कहा जा सकता है। और जैसा कि लेख का अंतिम भाग दिखाएगा, प्लस यह बहुत महत्वपूर्ण है।

हालांकि, किसी को भी एंबेलर में एमके के लिए परियोजनाओं की आवश्यकता नहीं है, शून्य के अंत से, जिसका अर्थ है कि आपको एसआई पर स्विच करने की आवश्यकता है।

सादा सी

ईमानदारी से, एक सरल Sishny विकल्प मेरे द्वारा पथ की शुरुआत में पाया गया, कहीं विशाल नेटवर्क में। उस समय, मैंने पहले ही असेंबलर में बिट बैंडिंग को लागू कर दिया, और गलती से सी फाइल पर ठोकर खाई, यह तुरंत काम कर गया और मैंने कुछ भी आविष्कार नहीं करने का फैसला किया।

सादे सी के लिए कार्यान्वयन

 /*!<=================PLAIN C SECTION========================>!*/ #define MASK_TO_BIT31(A) (A==0x80000000)? 31 : 0 #define MASK_TO_BIT30(A) (A==0x40000000)? 30 : MASK_TO_BIT31(A) #define MASK_TO_BIT29(A) (A==0x20000000)? 29 : MASK_TO_BIT30(A) #define MASK_TO_BIT28(A) (A==0x10000000)? 28 : MASK_TO_BIT29(A) #define MASK_TO_BIT27(A) (A==0x08000000)? 27 : MASK_TO_BIT28(A) #define MASK_TO_BIT26(A) (A==0x04000000)? 26 : MASK_TO_BIT27(A) #define MASK_TO_BIT25(A) (A==0x02000000)? 25 : MASK_TO_BIT26(A) #define MASK_TO_BIT24(A) (A==0x01000000)? 24 : MASK_TO_BIT25(A) #define MASK_TO_BIT23(A) (A==0x00800000)? 23 : MASK_TO_BIT24(A) #define MASK_TO_BIT22(A) (A==0x00400000)? 22 : MASK_TO_BIT23(A) #define MASK_TO_BIT21(A) (A==0x00200000)? 21 : MASK_TO_BIT22(A) #define MASK_TO_BIT20(A) (A==0x00100000)? 20 : MASK_TO_BIT21(A) #define MASK_TO_BIT19(A) (A==0x00080000)? 19 : MASK_TO_BIT20(A) #define MASK_TO_BIT18(A) (A==0x00040000)? 18 : MASK_TO_BIT19(A) #define MASK_TO_BIT17(A) (A==0x00020000)? 17 : MASK_TO_BIT18(A) #define MASK_TO_BIT16(A) (A==0x00010000)? 16 : MASK_TO_BIT17(A) #define MASK_TO_BIT15(A) (A==0x00008000)? 15 : MASK_TO_BIT16(A) #define MASK_TO_BIT14(A) (A==0x00004000)? 14 : MASK_TO_BIT15(A) #define MASK_TO_BIT13(A) (A==0x00002000)? 13 : MASK_TO_BIT14(A) #define MASK_TO_BIT12(A) (A==0x00001000)? 12 : MASK_TO_BIT13(A) #define MASK_TO_BIT11(A) (A==0x00000800)? 11 : MASK_TO_BIT12(A) #define MASK_TO_BIT10(A) (A==0x00000400)? 10 : MASK_TO_BIT11(A) #define MASK_TO_BIT09(A) (A==0x00000200)? 9 : MASK_TO_BIT10(A) #define MASK_TO_BIT08(A) (A==0x00000100)? 8 : MASK_TO_BIT09(A) #define MASK_TO_BIT07(A) (A==0x00000080)? 7 : MASK_TO_BIT08(A) #define MASK_TO_BIT06(A) (A==0x00000040)? 6 : MASK_TO_BIT07(A) #define MASK_TO_BIT05(A) (A==0x00000020)? 5 : MASK_TO_BIT06(A) #define MASK_TO_BIT04(A) (A==0x00000010)? 4 : MASK_TO_BIT05(A) #define MASK_TO_BIT03(A) (A==0x00000008)? 3 : MASK_TO_BIT04(A) #define MASK_TO_BIT02(A) (A==0x00000004)? 2 : MASK_TO_BIT03(A) #define MASK_TO_BIT01(A) (A==0x00000002)? 1 : MASK_TO_BIT02(A) #define MASK_TO_BIT(A) (A==0x00000001)? 0 : MASK_TO_BIT01(A) #define BIT_BAND_PER(reg, reg_val) (*(volatile uint32_t*)(PERIPH_BB_BASE+32*((uint32_t)(&(reg))-PERIPH_BASE)+4*((uint32_t)(MASK_TO_BIT(reg_val)))))

जैसा कि आप देख सकते हैं, प्रोसेसर की भाषा में लिखा गया एक बहुत ही सरल और सीधा कोड। यहां मुख्य काम बिट संख्या में सीएमएसआईएस मूल्यों का अनुवाद है, जो एक असेंबलर संस्करण की आवश्यकता के रूप में अनुपस्थित था।

अरे हाँ, इस विकल्प का इस तरह उपयोग करें:

सादे सी के उदाहरण

 BIT_BAND_PER(GPIOB->MODER, GPIO_MODER_MODER0_0) = 0; // BIT_BAND_PER(GPIOB->MODER, GPIO_MODER_MODER0_0) = 1; // (!0)

हालांकि, आधुनिक (बड़े पैमाने पर, मेरी टिप्पणियों के अनुसार, लगभग 2015 से) रुझान सी के साथ सी की जगह लेने के पक्ष में हैं यहां तक कि एमके के लिए भी। और मैक्रोज़ सबसे विश्वसनीय उपकरण नहीं हैं, इसलिए अगले संस्करण का जन्म होना तय था।

Cpp03

यहां, एक बहुत ही रोचक और चर्चा की गई, लेकिन इसकी जटिलता को देखते हुए बहुत कम उपयोग किया जाता है, एक गुट के एक हैकनेड उदाहरण के साथ, उपकरण मेटाप्रोग्रामिंग है।

आखिरकार, एक चर के मूल्य को थोड़ी संख्या में अनुवाद करने का कार्य आदर्श है (सीएमएसआईएस में पहले से ही मूल्य हैं), और इस मामले में यह संकलन समय के लिए व्यावहारिक है।

मैंने इसे टेम्प्लेट का उपयोग करते हुए कार्यान्वित किया:

C ++ 03 के लिए कार्यान्वयन

 template<uint32_t val, uint32_t comp_val, uint32_t cur_bit_num> struct bit_num_from_value { enum { bit_num = (val == comp_val) ? cur_bit_num : bit_num_from_value<val, 2 * comp_val, cur_bit_num + 1>::bit_num }; }; template<uint32_t val> struct bit_num_from_value<val, static_cast<uint32_t>(0x80000000), static_cast<uint32_t>(31)> { enum { bit_num = 31 }; }; #define BIT_BAND_PER(reg, reg_val) *(reinterpret_cast<volatile uint32_t *>(PERIPH_BB_BASE + 32 * (reinterpret_cast<uint32_t>(&(reg)) - PERIPH_BASE) + 4 * (bit_num_from_value<static_cast<uint32_t>(reg_val), static_cast<uint32_t>(0x01), static_cast<uint32_t>(0)>::bit_num)))

आप इसे उसी तरह से उपयोग कर सकते हैं:

C ++ 03 के उदाहरण

 BIT_BAND_PER(GPIOB->MODER, GPIO_MODER_MODER0_0) = false; // BIT_BAND_PER(GPIOB->MODER, GPIO_MODER_MODER0_0) = true; //

और मैक्रो क्यों छोड़ा गया था? तथ्य यह है कि मुझे प्रोग्राम कोड के किसी अन्य क्षेत्र में जाने के बिना इस ऑपरेशन को गारंटीकृत करने के लिए एक और तरीके का पता नहीं है। मुझे बहुत खुशी होगी अगर उन्होंने मुझे टिप्पणियों में प्रेरित किया। न तो टेम्पलेट और न ही इनलाइन फ़ंक्शन ऐसी गारंटी प्रदान करते हैं। हाँ, और यहाँ मैक्रो अपने कार्य को पूरी तरह से अच्छी तरह से करता है, इसे सिर्फ इसलिए बदलने का कोई मतलब नहीं है कि ~~अनुरूपतावादी~~ इसे "सुरक्षित नहीं" मानता है।

हैरानी की बात है, समय अभी भी स्थिर नहीं हुआ, कंपाइलरों ने तेजी से C ++ 14 / C ++ 17 का समर्थन किया, क्यों न नवाचारों का लाभ उठाया जाए, जिससे कोड अधिक समझ में आता है।

Cpp14 / cpp17

C ++ 14 के लिए कार्यान्वयन

 constexpr uint32_t bit_num_from_value_cpp14(uint32_t val, uint32_t comp_val, uint32_t bit_num) { return bit_num = (val == comp_val) ? bit_num : bit_num_from_value_cpp14(val, 2 * comp_val, bit_num + 1); } #define BIT_BAND_PER(reg, reg_val) *(reinterpret_cast<volatile uint32_t *>(PERIPH_BB_BASE + 32 * (reinterpret_cast<uint32_t>(&(reg)) - PERIPH_BASE) + 4 * (bit_num_from_value_cpp14(static_cast<uint32_t>(reg_val), static_cast<uint32_t>(0x01), static_cast<uint32_t>(0)))))

जैसा कि आप देख सकते हैं, मैंने सिर्फ एक पुनरावर्ती कॉन्स्ट्रेक्स फ़ंक्शन के साथ टेम्पलेट्स को बदल दिया, जो कि, मेरी राय में, मानव आंख के लिए अधिक स्पष्ट है।

उसी तरह उपयोग करें। वैसे, C ++ 17 में, सिद्धांत रूप में, आप पुनरावर्ती लंबो कॉन्स्टैक्सप्र फ़ंक्शन का उपयोग कर सकते हैं, लेकिन मुझे यकीन नहीं है कि इससे कम से कम कुछ सरलीकरण हो जाएंगे, और कोडांतरक ऑर्डर को भी जटिल नहीं किया जाएगा।

सारांश में, सभी तीन सी / सीपीपी कार्यान्वयन थ्योरी अनुभाग के अनुसार निर्देशों का एक समान रूप से सही सेट देते हैं। मैं लंबे समय से IAR ARM 8.30 और gcc 7.2.0 पर सभी कार्यान्वयनों के साथ काम कर रहा हूं।

अभ्यास एक कुतिया है

यह सब, ऐसा लगता है, हुआ। मेमोरी बचत की गणना की गई, कार्यान्वयन को चुना गया, प्रदर्शन में सुधार के लिए तैयार। यहाँ नहीं, यह केवल सिद्धांत और व्यवहार के विचलन का मामला था। और यह कब अलग था?

अगर मैंने इसका परीक्षण नहीं किया होता, तो मैंने इसे कभी प्रकाशित नहीं किया होता, लेकिन परियोजनाओं पर वास्तविक रूप से कब्जा की गई मात्रा कितनी कम है। मैं विशेष रूप से पुराने प्रोजेक्टों के एक जोड़े पर एक मुखौटा के बिना एक नियमित कार्यान्वयन के साथ इस मैक्रो को बदल दिया, और अंतर को देखा। परिणाम अप्रिय रूप से हैरान कर गया।

जैसा कि यह निकला, वॉल्यूम लगभग अपरिवर्तित रहता है। मैंने विशेष रूप से उन परियोजनाओं को चुना जहां बिल्कुल 40-50 ऐसे निर्देशों का उपयोग किया गया था। सिद्धांत के अनुसार, मुझे कम से कम 100 बाइट्स, और अधिकतम 200 बाइट्स बचाने थे। व्यवहार में, अंतर 24 - 32 बाइट्स निकला। लेकिन क्यों?

आमतौर पर, जब आप बाह्य उपकरणों को सेट करते हैं, तो आप लगभग 5-10 पंक्तियों को एक पंक्ति में सेट करते हैं। और अनुकूलन के उच्च स्तर पर, कंपाइलर निर्देशों को वास्तव में रजिस्टरों के क्रम में व्यवस्थित नहीं करता है, लेकिन निर्देशों को व्यवस्थित करता है जैसा कि यह सही लगता है, कभी-कभी उनके साथ प्रतीत होता है कि निष्क्रिय स्थानों में हस्तक्षेप करते हैं।

मुझे दो विकल्प दिखाई देते हैं (यहाँ मेरी अटकलें हैं):

या कंपाइलर इतना स्मार्ट है कि यह आपके लिए जानता है कि निर्देशों के सेट को अनुकूलित करना बेहतर कैसे होगा
या कंपाइलर अभी भी एक व्यक्ति से अधिक चालाक नहीं है, और जब वह इस तरह के निर्माण का सामना करता है तो खुद को भ्रमित करता है

यही है, यह पता चला है कि अनुकूलन के उच्च स्तर पर "उच्च-स्तरीय" भाषाओं में यह विधि केवल सही ढंग से काम करती है अगर इस तरह के एक ऑपरेशन के लिए निकटता में समान संचालन नहीं हैं।

संयोग से, O0 स्तर पर, सिद्धांत और व्यवहार किसी भी मामले में अभिसरण होते हैं, लेकिन मुझे इस स्तर के अनुकूलन में कोई दिलचस्पी नहीं है।

मैं संक्षेप में बताता हूं

एक नकारात्मक परिणाम भी एक परिणाम है। मुझे लगता है कि हर कोई अपने लिए निष्कर्ष निकालेगा। व्यक्तिगत रूप से, मैं इस तकनीक का उपयोग करना जारी रखूंगा, यह निश्चित रूप से इससे खराब नहीं होगा।

मुझे उम्मीद है कि यह दिलचस्प था और मैं उन लोगों के लिए एक बड़ा सम्मान व्यक्त करना चाहता हूं जिन्होंने अंत तक पढ़ा है।

साहित्य की सूची

"कॉर्टेक्स-एम 3 तकनीकी संदर्भ मैनुअल", धारा 4.2, एआरएम 2005।
एआरएम कॉर्टेक्स-एम 3, जोसेफ यियू के लिए निश्चित गाइड।

पी एस मैं अपने बैग में एम्बेडेड इलेक्ट्रॉनिक्स के विकास से संबंधित विषयों का एक छोटा सा कवरेज है। मुझे पता है, अगर दिलचस्पी है, तो मैं धीरे-धीरे उन्हें प्राप्त करूंगा।

किसी तरह पीपीएस कोड के वर्गों को सम्मिलित करने के लिए टेढ़ा हो गया, कृपया मुझे बताएं कि यदि संभव हो तो सुधार कैसे करें। सामान्य तौर पर, आप नोटपैड के ब्याज के टुकड़े को कॉपी कर सकते हैं और विश्लेषण में अप्रिय भावनाओं से बच सकते हैं।

युपीडी:

पाठकों के अनुरोध पर, मैं इंगित करता हूं कि बिट बैंडिंग ऑपरेशन स्वयं परमाणु है, जो हमें रजिस्टरों के साथ काम करते समय कुछ सुरक्षा देता है। यह इस पद्धति की सबसे महत्वपूर्ण विशेषताओं में से एक है।

CortexM3 / M4 (ARM) हार्डवेयर बिट बैंडिंग, कर्नेल आर्किटेक्चर, कोडांतरक, C / C ++ 14 और मेटाप्रोग्रामिंग की एक बूंद