🏢 💦 🤹🏿 एक AVR माइक्रोकंट्रोलर और एक TWI बस के उदाहरण का उपयोग करके ओएस के बाहर म्यूटेक्स का कार्यान्वयन 👇🏼 🏀 🙏🏽

एक बार मैंने खुद के लिए एक मौसम स्टेशन बनाने का फैसला किया। सेंसर वहां अलग हैं, जिनमें I2C बस शामिल है। और कितना अच्छा, आमतौर पर पहली बार में, उम्मीद के झंडे पर सब कुछ किया। लेकिन असली जेडी का रास्ता अलग है, और रुकावट के लिए सब कुछ लटका देने का फैसला किया गया था। यहीं से बवासीर की शुरुआत हुई। मुझे जो समस्या आई वह लगातार कई अनुरोधों को संसाधित कर रही है। उदाहरण के लिए, इसके साथ आगे के काम के लिए BMP085 दबाव सेंसर को इसके EEPROM से 11 अंशांकन स्थिरांक खींचने की आवश्यकता है:

मैं निर्णय पर कैसे आया और विचारों का क्रम नीचे उल्लिखित है।

इंतजार के झंडे

कार्यों को परिभाषित करें get_AC1, get_AC2, ..., get_MD । उनमें से प्रत्येक I2C बस के माध्यम से EEPROM सेंसर से संबंधित निरंतर प्राप्त करता है। डेटाशीट से पार्सल प्रारूप:

और get_AC1 फ़ंक्शन के लिए नमूना कोड:

get_AC1

int get_AC1(void) { union { unsigned int Word; unsigned char Byte[2]; } AC1; //  AC1 // ---------------------------------------- TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(1<<TWSTA)|(0<<TWSTO)| //  START  (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- TWDR = 0xEE; //  SLA+W TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //  SLA+W (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- TWDR = 0xAA; //  0xAA TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //  0xAA (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(1<<TWSTA)|(0<<TWSTO)| //  REPEATED START  (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- TWDR = 0xEF; //  SLA+R TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //  SLA+R (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //       ACK (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- AC1.Byte[1] = TWDR; //  MSB TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //       NACK (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- AC1.Byte[0] = TWDR; //  LSB TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(0<<TWSTA)|(1<<TWSTO)| //  STOP  (0<<TWWC); // ---------------------------------------- return AC1.Word; }

और यहाँ उसकी तरंग है:

एसी 1 के लिए संघ का उपयोग बाइट क्रम में अंतर के कारण है। TWI के लिए यह बड़ा-एंडियन है, AVR के लिए यह थोड़ा-एंडियन है। Get_AC2 फ़ंक्शन केवल SLA + W कमांड के बाद 0xAA के बजाय बाइट 0xAC (डेटाशीट पर देखें) भेजने में भिन्न होता है। अन्य सभी मामलों में, कार्य बिल्कुल समान हैं। इसलिए, हम एक get_Data को परिभाषित कर सकते हैं, जो डेटासेट के अनुसार मापदंडों के रूप में एक ही रजिस्टर पते को स्वीकार करेगा:

get_Data

 int get_Data(unsigned char Register_adress) { union { unsigned int Word; unsigned char Byte[2]; } Data; //  Data // ---------------------------------------- TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(1<<TWSTA)|(0<<TWSTO)| //  START  (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- TWDR = 0xEE; //  SLA+W TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //  SLA+W (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- TWDR = Register_adress; //  Register_adress TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //  Register_adress (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(1<<TWSTA)|(0<<TWSTO)| //  REPEATED START  (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- TWDR = 0xEF; //  SLA+R TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //  SLA+R (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //       ACK (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- Data.Byte[1] = TWDR; //  MSB TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //       NACK (0<<TWWC); while (!(TWCR & (1<<TWINT))) //    TWINT ; // ---------------------------------------- Data.Byte[0] = TWDR; //  LSB TWCR = (1<<TWEN)| //  TWI  (0<<TWIE)|(1<<TWINT)| //   (0<<TWEA)|(0<<TWSTA)|(1<<TWSTO)| //  STOP  (0<<TWWC); // ---------------------------------------- return Data.Word; }

और फिर बस:

 struct { short AC1; short AC2; short AC3; unsigned short AC4; unsigned short AC5; unsigned short AC6; short B1; short B2; short MB; short MC; short MD; } BMP085_EEPROM; ... static void get_EEPROM(void) { BMP085_EEPROM.AC1 = get_Data(0xAA); BMP085_EEPROM.AC2 = get_Data(0xAC); BMP085_EEPROM.AC3 = get_Data(0xAE); BMP085_EEPROM.AC4 = get_Data(0xB0); BMP085_EEPROM.AC5 = get_Data(0xB2); BMP085_EEPROM.AC6 = get_Data(0xB4); BMP085_EEPROM.B1 = get_Data(0xB6); BMP085_EEPROM.B2 = get_Data(0xB8); BMP085_EEPROM.MB = get_Data(0xBA); BMP085_EEPROM.MC = get_Data(0xBC); BMP085_EEPROM.MD = get_Data(0xBE); }

यहाँ परिणाम है:

बाधा डालने का काम

प्रस्तावना

जैसा कि ऊपर दिए गए आंकड़े से देखा जा सकता है, एक ऑपरेशन की अवधि 100 kHz की बस ट्रांसफर आवृत्ति के लिए 488 μs है , जो 8 मेगाहर्ट्ज की आवृत्ति पर 3094 प्रोसेसर चक्र है । खैर यह कोई तरीका नहीं है दोस्तों। बेशक, आप आवृत्ति बढ़ा सकते हैं यदि लक्ष्य डिवाइस अनुमति देता है। उदाहरण के लिए, 400 किलोहर्ट्ज़ के लिए, अवधि 128 μs या 1024 चक्र है

झंडे के उठने का इंतजार एक ऑपरेशन पूरी तरह से बेकार है। हजारों घड़ी चक्रों के लिए, प्रोसेसर बहुत उपयोगी काम कर सकता है, उदाहरण के लिए, फ़्लोटिंग पॉइंट संख्याओं को विभाजित करने का संचालन करें। इसलिए, इस स्थिति से बाहर निकलने का एकमात्र पर्याप्त तरीका एक बाधा का उपयोग करना है।

बाधा डालने का काम

संरचना को परिभाषित करें:

 struct { unsigned char SLA; // Slave address unsigned char *pW; // ? unsigned char nW; // ? unsigned char *pR; // ? unsigned char nR; // ? } TWI;

और अब हमारा get_AC1 फ़ंक्शन:

 unsigned char Register_address; ... void get_AC1(void) { Register_address = 0xAA; //  Register address TWI.SLA = 0x77; // Slave address  BMP085 TWI.pW = &Register_address; //       TWI.nW = 1; //   ? TWI.pR = &BMP085_EEPROM.AC1; //   ? TWI.nR = 2; //   ? TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(1<<TWSTA)|(0<<TWSTO)| //  START  (0<<TWWC); }

बाधा हैंडलर के बारे में कुछ शब्द। यदि nW = n , nR = 0 , फ्रेम प्रारूप है:

यदि nW = 0 , nR = m :

और अगर nW = n , nR = m :

वैसे, बाधा हैंडलर कुछ भी हो सकता है। राज्य मशीन तर्क को विभिन्न तरीकों से लागू किया जा सकता है। मेरा एक उदाहरण नीचे दिखाया गया है:

बाधा डालनेवाला

 ISR(TWI_vect) { /* ----------------------------------------------------------------------------------- Jump table which is stored in flash ------------------------------------------------------------------------------------*/ static const void * const twi_list[] PROGMEM = {&&TWI_00, &&TWI_08, &&TWI_10, &&TWI_18, &&TWI_20, &&TWI_28, &&TWI_30, &&TWI_38, &&TWI_40, &&TWI_48, &&TWI_50, &&TWI_58, &&TWI_60, &&TWI_68, &&TWI_70, &&TWI_78, &&TWI_80, &&TWI_88, &&TWI_90, &&TWI_98, &&TWI_A0, &&TWI_A8, &&TWI_B0, &&TWI_B8, &&TWI_C0, &&TWI_C8, &&TWI_F8}; /* ----------------------------------------------------------------------------------- Jump to label, address of which is in twi_list[TWSR>>3] ------------------------------------------------------------------------------------*/ goto *(pgm_read_word(&(twi_list[TWSR>>3]))); /* ----------------------------------------------------------------------------------- Bus error handler ------------------------------------------------------------------------------------*/ TWI_00: // STOP condition will be generated goto STOP; /* ----------------------------------------------------------------------------------- A START condition has been transmitted A repeated START condition has been transmitted nW = nR = 0: STOP condition will be generated nW > 0, nR - don't care: SLA+W will be send nW = 0, nR > 0: SLA+R will be send ------------------------------------------------------------------------------------*/ TWI_08: TWI_10: if (TWI.nW != 0) // SLA+W will be send TWDR = (TWI.SLA)<<1; else if (TWI.nR != 0) // SLA+R will be send TWDR = (TWI.SLA)<<1 | 1<<0; else // STOP condition will be generated goto STOP; TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //  SLA+R/W (0<<TWWC); return; /* ----------------------------------------------------------------------------------- SLA+W has been transmitted; ACK has been received Data byte has been transmitted; ACK has been received nW > 0, nR - don't care: Data byte will be transmitted and ACK or NOT ACK will be received nW = 0, nR > 0: Repeated START will be transmitted nW = nR = 0: STOP condition will be generated ------------------------------------------------------------------------------------*/ TWI_18: TWI_28: if (TWI.nW != 0) { // Data byte will be transmitted and ACK or NOT ACK will be received TWDR = *TWI.pW++; TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //   (0<<TWWC); TWI.nW--; } else if (TWI.nR != 0) // Repeated START will be transmitted TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(1<<TWSTA)|(0<<TWSTO)| //  START  (0<<TWWC); else // STOP condition will be generated goto STOP; return; /* ----------------------------------------------------------------------------------- SLA+W has been transmitted; NOT ACK has been received ------------------------------------------------------------------------------------*/ TWI_20: // STOP condition will be generated goto STOP; /* ----------------------------------------------------------------------------------- Data byte has been transmitted; NOT ACK has been received ------------------------------------------------------------------------------------*/ TWI_30: // STOP condition will be generated goto STOP; /* ----------------------------------------------------------------------------------- Arbitration lost in SLA+W or data bytes Arbitration lost in SLA+R or NOT ACK bit ------------------------------------------------------------------------------------*/ TWI_38: // STOP condition will be generated goto STOP; /* ----------------------------------------------------------------------------------- SLA+R has been transmitted; ACK has been received nR = 1: Data byte will be received and NOT ACK will be returned nR > 1: Data byte will be received and ACK will be returned ------------------------------------------------------------------------------------*/ TWI_40: if (TWI.nR == 1) // Data byte will be received and NOT ACK will be returned TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //    + NACK (0<<TWWC); else // Data byte will be received and ACK will be returned TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //    + ACK (0<<TWWC); return; /* ----------------------------------------------------------------------------------- SLA+R has been transmitted; NOT ACK has been received ------------------------------------------------------------------------------------*/ TWI_48: // STOP condition will be generated goto STOP; /* ----------------------------------------------------------------------------------- Data byte has been received; ACK has been returned nR = 2: Data byte will be received and NOT ACK will be returned nR > 2: Data byte will be received and ACK will be returned ------------------------------------------------------------------------------------*/ TWI_50: // Read data *TWI.pR++ = TWDR; if (TWI.nR-- == 2) // Data byte will be received and NOT ACK will be returned TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //    + NACK (0<<TWWC); else // Data byte will be received and ACK will be returned TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //    + ACK (0<<TWWC); return; /* ----------------------------------------------------------------------------------- Data byte has been received; NOT ACK has been returned Repeated START will be transmitted STOP condition will be transmitted and TWSTO Flag will be reset STOP condition followed by a START condition will be transmitted and TWSTO Flag will be reset ------------------------------------------------------------------------------------*/ TWI_58: // Read data *TWI.pR = TWDR; TWI_60: TWI_68: TWI_70: TWI_78: TWI_80: TWI_88: TWI_90: TWI_98: TWI_A0: TWI_A8: TWI_B0: TWI_B8: TWI_C0: TWI_C8: TWI_F8: // STOP condition will be transmitted and TWSTO Flag will be reset STOP: TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(0<<TWSTA)|(1<<TWSTO)| //    + NACK (0<<TWWC); }

खैर, काम का परिणाम:

जैसा कि हम देखते हैं, रनटाइम 488 μs से बढ़कर 538 μs हो गया । यह हैंडलर से संक्रमण और लौटने के साथ-साथ लुकअप टेबल पर जंप एड्रेस की गणना के कारण है। लेकिन सबसे महत्वपूर्ण बात यह है कि संपूर्ण ट्रांसमिशन हार्डवेयर है। इसलिए, छोटे फ़ंक्शन get_AC1 को निष्पादित करने के बाद, जो केवल 3.5 μs या 28 घड़ी चक्र तक रहता है , हम सुरक्षित रूप से अन्य काम कर सकते हैं, और प्रतीक्षा चक्र में फंस नहीं सकते हैं।

आइए देखें कि क्या होता है यदि आप get_AC1 , get_AC2 , ..., get_MD फ़ंक्शंस को कॉल करते हैं:

केवल एक ही निष्पादित होगा, get_MD , और सभी क्योंकि:

अंतिम कार्य SLA + W पूरा होने से पहले संरचना में डेटा लोड करता है, इसलिए Register_address इसके अनुरूप है और 0-0BE के बराबर है। वास्तव में, यह संभवतः सबसे हानिरहित परिदृश्य है। आखिरकार, यदि स्थानांतरण Register_address की तुलना में थोड़ा तेज़ था, तो यह get_AC5 फ़ंक्शन के अनुरूप होगा , उदाहरण के लिए, और हमने इसे BMP085_EEPROM.MD में बिल्कुल लिखा होगा। यही है, हम AC1 की अपेक्षा करते हैं, हम AC5 को MD में संग्रहीत करते हैं। और अगर get_AC5 के बजाय अपने SLA के साथ एक और एक होगा, तो हम एक का आधा पता भेज सकते हैं, और दूसरे का दूसरा और NACK प्राप्त कर सकते हैं, और फिर व्यवधान हैंडलर से तर्क या तो प्रोग्राम को लूप करेंगे या STOP फेंक देंगे। इस स्थिति से बाहर आने का एक स्पष्ट तरीका है। अगला फ़ंक्शन तब तक न चलाएं जब तक कि पिछला समाप्त न हो जाए। यही है, get_AC1 चलाकर हम ध्वज को 1 पर सेट करते हैं, और हैंडलर, STOP पूरा होने के बाद, इसे रीसेट कर देगा। और get_AC2 तब तक शुरू नहीं होगा जब तक कि यह झंडा साफ नहीं हो जाता। हां, यह एक तरीका है, लेकिन रुकावट के सभी आकर्षण खो जाते हैं, जो इस मामले में 0% के रूप में उपयोग किया जाता है। बेहतर झंडा मशीन। लेकिन एक और सुंदर उपाय है।

म्यूटेक्स एनालॉग

Get_AC1 , ..., get_MD फ़ंक्शंस सीधे डेटा संचारित नहीं करते हैं। वे एक अन्य फ़ंक्शन को कॉल करते हैं जो उन्हें कतार में रखता है और यदि कतार खाली नहीं है, तो वह स्थानांतरण की शुरुआत को प्रारंभ करता है। हम संरचनाओं की एक सरणी बनाकर अपनी संरचना को फिर से लिखते हैं:

 #define size 8 ... typedef struct { unsigned char SLA; // Slave address unsigned char *pW; // ? unsigned char nW; // ? unsigned char *pR; // ? unsigned char nR; // ? } twi; twi TWI[size];

आइए देखें कि अब get_AC1 फ़ंक्शन कैसे दिखेगा:

 unsigned char buf[size]; ... void get_AC1(void) { volatile twi *pl; //     twi buf[0] = 0xAA; //  Register address pl->SLA = 0x77; // Slave address  BMP085 pl->pW = buf; //       pl->nW = 1; //   ? pl->pR = buf; //   ? pl->nR = 2; //   ? Scheduler(pl); //    }

व्यावहारिक रूप से भी, केवल स्टार्ट स्टेट को इनिशियलाइज़ करने के बजाय, हम शेड्यूलर फ़ंक्शन को कॉल करते हैं, इसे पॉइंटर को एक दो प्रकार की संरचना में पास करते हैं , जिसमें TWI फ़्रेम के लिए आवश्यक सभी डेटा होते हैं। अनुसूचक के बुनियादी कार्यों और हैंडलर में कुछ बदलावों पर विचार करें:

सूचक प्राप्त करने के बाद, फ़ंक्शन सभी डेटा को TWI [i] संरचना में कॉपी करता है, जहां मैं संरचनाओं के सरणी के तत्व की वर्तमान संख्या है, जिसके बाद यह 1 से बढ़ता है; अगर मैं सरणी आयाम से बाहर आता हूं, तो यह रीसेट हो जाता है; इस तरह हम संरचनाओं के एक सरणी को एक परिपत्र बफर में बदल देते हैं;
j वैरिएबल उस तत्व को इंगित करता है जिसे इंटरप्ट हैंडलर में संसाधित किया जाएगा, जिसके बाद यह 1 से बढ़ता है; यदि j सरणी के आयाम की सीमा के बाहर है, तो यह रीसेट हो गया है;
अगर मैं j (क्यू अतिप्रवाह) के साथ पकड़ता हूं - संरचनाओं की सरणी के लिए लेखन संभव नहीं है;
ध्वज चर को 0 से प्रारंभ किया जाता है;
अगर मैं j के बराबर नहीं हूँ (कतार खाली नहीं है) और झंडा = 0, तो झंडा = 1, स्टार्ट अवस्था शुरू करें;
हैंडलर में, फ्रेम को संसाधित करने के बाद, हम 1 से j बढ़ाते हैं, इसलिए यह अगले फ्रेम को इंगित करेगा;
हैंडलर में, फ्रेम को संसाधित करने और j बदलने के बाद, यदि मैं j के बराबर नहीं हूं, तो हम STOP-START को स्थिति देते हैं, अन्यथा STOP और ध्वज = 0;

यह ध्यान में रखने योग्य नहीं है कि ऊपर क्या लिखा गया है। एक छोटी प्रस्तुति देखना बेहतर है जो ऊपर दिए गए कुछ बिंदुओं को स्पष्ट करेगा:

शेड्यूलर शेड्यूलर फ़ंक्शन :

 void Scheduler(twi *pl) { if (tail-head !=1 && head-tail != size-1) //    ,  { twi *pg = &TWI[head]; //      pg->SLA = pl->SLA; //  SLA pg->pW = pl->pW; //  *pW pg->nW = pl->nW; //  nW pg->pR = pl->pR; //  *pR pg->nR = pl->nR; //  nR head = (head+1)&(size-1); //       -  if (!flag.twi_run) //   TWI    (  0) { flag.twi_run = 1; //    1 TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| (0<<TWEA)|(1<<TWSTA)|(0<<TWSTO)| (0<<TWWC); } } }

खैर, हैंडलर ही:

बाधित हैंडलर को फिर से डिज़ाइन किया गया

 ISR(TWI_vect) { twi *p = &TWI[tail]; /* ----------------------------------------------------------------------------------- Jump table which is stored in flash ------------------------------------------------------------------------------------*/ static const void * const twi_list[] PROGMEM = {&&TWI_00, &&TWI_08, &&TWI_10, &&TWI_18, &&TWI_20, &&TWI_28, &&TWI_30, &&TWI_38, &&TWI_40, &&TWI_48, &&TWI_50, &&TWI_58, &&TWI_60, &&TWI_68, &&TWI_70, &&TWI_78, &&TWI_80, &&TWI_88, &&TWI_90, &&TWI_98, &&TWI_A0, &&TWI_A8, &&TWI_B0, &&TWI_B8, &&TWI_C0, &&TWI_C8, &&TWI_F8}; /* ----------------------------------------------------------------------------------- Jump to label, address of which is in twi_list[TWSR>>3] ------------------------------------------------------------------------------------*/ goto *(pgm_read_word(&(twi_list[TWSR>>3]))); /* ----------------------------------------------------------------------------------- Bus error handler ------------------------------------------------------------------------------------*/ TWI_00: // STOP condition will be generated goto STOP; /* ----------------------------------------------------------------------------------- A START condition has been transmitted A repeated START condition has been transmitted nW = nR = 0: STOP condition will be generated nW > 0, nR - don't care: SLA+W will be send nW = 0, nR > 0: SLA+R will be send ------------------------------------------------------------------------------------*/ TWI_08: TWI_10: if (p->nW != 0) // SLA+W will be send TWDR = p->SLA<<1; else if (p->nR != 0) // SLA+R will be send TWDR = p->SLA<<1 | 1<<0; else // STOP condition will be generated goto STOP; TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //  SLA+R/W (0<<TWWC); return; /* ----------------------------------------------------------------------------------- SLA+W has been transmitted; ACK has been received Data byte has been transmitted; ACK has been received nW > 0, nR - don't care: Data byte will be transmitted and ACK or NOT ACK will be received nW = 0, nR > 0: Repeated START will be transmitted nW = nR = 0: STOP condition will be generated ------------------------------------------------------------------------------------*/ TWI_18: TWI_28: if (p->nW != 0) { // Data byte will be transmitted and ACK or NOT ACK will be received TWDR = *p->pW; p->pW++; TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //   (0<<TWWC); p->nW--; } else if (p->nR != 0) // Repeated START will be transmitted TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(1<<TWSTA)|(0<<TWSTO)| //  START  (0<<TWWC); else // STOP condition will be generated goto STOP; return; /* ----------------------------------------------------------------------------------- SLA+W has been transmitted; NOT ACK has been received ------------------------------------------------------------------------------------*/ TWI_20: // STOP condition will be generated goto STOP; /* ----------------------------------------------------------------------------------- Data byte has been transmitted; NOT ACK has been received ------------------------------------------------------------------------------------*/ TWI_30: // STOP condition will be generated goto STOP; /* ----------------------------------------------------------------------------------- Arbitration lost in SLA+W or data bytes Arbitration lost in SLA+R or NOT ACK bit ------------------------------------------------------------------------------------*/ TWI_38: // STOP condition will be generated goto STOP; /* ----------------------------------------------------------------------------------- SLA+R has been transmitted; ACK has been received nR = 1: Data byte will be received and NOT ACK will be returned nR > 1: Data byte will be received and ACK will be returned ------------------------------------------------------------------------------------*/ TWI_40: if (p->nR == 1) // Data byte will be received and NOT ACK will be returned TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //    + NACK (0<<TWWC); else // Data byte will be received and ACK will be returned TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //    + ACK (0<<TWWC); return; /* ----------------------------------------------------------------------------------- SLA+R has been transmitted; NOT ACK has been received ------------------------------------------------------------------------------------*/ TWI_48: // STOP condition will be generated goto STOP; /* ----------------------------------------------------------------------------------- Data byte has been received; ACK has been returned nR = 2: Data byte will be received and NOT ACK will be returned nR > 2: Data byte will be received and ACK will be returned ------------------------------------------------------------------------------------*/ TWI_50: // Read data *p->pR = TWDR; p->pR++; if (p->nR-- == 2) // Data byte will be received and NOT ACK will be returned TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //    + NACK (0<<TWWC); else // Data byte will be received and ACK will be returned TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| //    + ACK (0<<TWWC); return; /* ----------------------------------------------------------------------------------- Data byte has been received; NOT ACK has been returned Repeated START will be transmitted STOP condition will be transmitted and TWSTO Flag will be reset STOP condition followed by a START condition will be transmitted and TWSTO Flag will be reset ------------------------------------------------------------------------------------*/ TWI_58: // Read data *p->pR = TWDR; TWI_60: TWI_68: TWI_70: TWI_78: TWI_80: TWI_88: TWI_90: TWI_98: TWI_A0: TWI_A8: TWI_B0: TWI_B8: TWI_C0: TWI_C8: TWI_F8: // STOP condition will be transmitted and TWSTO Flag will be reset STOP: tail = (tail+1)&(size-1); //  tail  1,    ,   if (head != tail) //  head  tail  ,  TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(1<<TWSTA)|(1<<TWSTO)| // - (0<<TWWC); else //  { TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| //  !   (0<<TWEA)|(0<<TWSTA)|(1<<TWSTO)| //  (0<<TWWC); flag.twi_run = 0; //   } }

खैर, get_AC1 का परिणाम:

अंतभाषण

वास्तव में, अगर, get_AC1 के साथ सादृश्य द्वारा, get_AC2 बनाते हैं और एक पंक्ति में 2 फ़ंक्शन चलाते हैं, तो केवल अंतिम एक को दो बार निष्पादित किया जाएगा। यह इस तथ्य के कारण है कि हम लगातार buf में संचरण के लिए डेटा संग्रहीत करते हैं [0]। इससे बचने के लिए, हम डेटा को buf [1] में लिख सकते हैं और सब कुछ वैसा ही काम करेगा जैसा कि इसे करना चाहिए। लेकिन ऐसा नहीं किया जाता है। डेटा कहां से और कितना प्राप्त करना है, इसके लिए एक पॉइंटर को ट्रांसफर करना सही है और कुछ थर्ड-पार्टी फंक्शन इसे TWI के लिए बफर में डाल देगा और हैंडलर में जहां से डेटा मिलेगा, वहां से एक पॉइंटर लौटाएगा। सामान्य तौर पर, उदाहरण के लिए कोड:

कोड

 unsigned char bufTx[size]; unsigned char pos = 0; ... void get_AC1(void) { volatile twi *pl; //     twi volatile uint8_t buf[] = {0xAA}; //  Register address  buf pl->SLA = 0x77; // Slave address  BMP085 pl->pW = buf; //       pl->nW = 1; //   ? pl->pR = buf; //   ? pl->nR = 2; //   ? Scheduler(pl); //    } // ============================================ void get_AC2(void) { volatile twi *pl; //     twi volatile uint8_t buf[] = {0xAC}; //  Register address  buf pl->SLA = 0x77; // Slave address  BMP085 pl->pW = buf; //       pl->nW = 1; //   ? pl->pR = buf; //   ? pl->nR = 2; //   ? Scheduler(pl); //    } // ============================================ void Scheduler(volatile twi *pl) { if (tail-head !=1 && head-tail != size-1) //    ,  { twi *pg = &TWI[head]; //      pg->SLA = pl->SLA; //  SLA pg->pW = pushToBuf(pl->pW,pl->nW); //  ,    //  buf  bufTX    pg->nW = pl->nW; //  nW pg->pR = pl->pR; //  *pR pg->nR = pl->nR; //  nR head = (head+1)&(size-1); //       -  if (!flag.twi_run) //   TWI    (  0) { flag.twi_run = 1; //    1 TWCR = (1<<TWEN)| //  TWI  (1<<TWIE)|(1<<TWINT)| (0<<TWEA)|(1<<TWSTA)|(0<<TWSTO)| (0<<TWWC); } } } // ============================================ unsigned char *pushToBuf(unsigned char *buf, unsigned char n) { unsigned char *p = &bufTx[pos]; //      do { bufTx[pos++] = *buf++; //   buf  bufTx pos &= size-1; //   -  } while (--n); //  n  return p; //   p }

तस्वीर को देखो:

कृपया, सादृश्य द्वारा, एक ही फ़ंक्शन को प्राप्त बफर के लिए किया जाना चाहिए। आप उसे बताएं, और वह आपको कहां भेजती है। आप TWI की संरचना को भी संशोधित कर सकते हैं, उदाहरण के लिए, मेमोरी को अनुकूलित करने के लिए पॉइंटर्स को स्थानांतरित नहीं करते हैं, बल्कि अनुक्रमित करते हैं।
यदि किसी के पास यह सवाल है कि कोड को रीसेट करने के लिए उपयोग क्यों किया जाता है:

 head = (head+1)&(size-1); tail = (tail+1)&(size-1); pos &= size-1;

मैं इसे तेज और कम कोड कहूंगा। केवल शर्त यह है कि मान 2 ^{n है} ।
सुविधाओं में से, यह TWI के लिए अधिकतम आकार के आकार को भी ध्यान देने योग्य है । यदि यह लगातार अनुरोधों की अधिकतम संभव संख्या से कम है, तो हम निश्चित रूप से उनमें से कुछ को खो देंगे। इसलिए, इस पर जोर देना महत्वपूर्ण है। हमेशा समवर्ती अनुरोधों की अधिकतम संख्या से कम से कम 1 अधिक के आकार के मूल्य का उपयोग करें ।
फ़ंक्शन को पूरा करने के बाद, प्राप्त डेटा के लिए हैंडलर जोड़ना संभव होगा। हमारे उदाहरण के लिए, यह प्राप्त एसी 1 और एसी 2 का प्रसंस्करण है, जिसे हम बिग-एंडियन में प्राप्त करते हैं और इसे लिटिल-एंडियन में परिवर्तित किया जाना चाहिए, और फिर उपयुक्त स्थान पर संग्रहीत किया जाना चाहिए। ऐसा करने के लिए, TWI संरचना में, फ़ंक्शन हैंडलर के लिए एक पॉइंटर को स्टोर करना और यह पता लगाना संभव होगा कि वर्कआउट करने के बाद इसे कैसे कॉल किया जाए।
प्रक्रियाओं के बारे में उल्लेख के लायक कुछ शब्द। मेरी योजना के संबंध में, टीडब्लूआई बस में 2 सेंसर, दबाव, 1 टाइम चिप और 1 मेमोरी चिप हैं। और उन तक पहुंच को परमाणु के रूप में माना जा सकता है, उदाहरण के लिए, एक दबाव सेंसर के लिए:

यदि हम असम्पीडित दबाव के लिए संचरण खो देते हैं, तो हमें असम्पीडित तापमान के प्राप्त मूल्य की आवश्यकता नहीं है और हमें फिर से शुरू करना होगा, क्योंकि हमें अमान्य डेटा मिल सकता है।
इसके अलावा, TWI के माध्यम से संचारित होने पर विफलता का कोई मामला नहीं है। चूंकि हम मूल TWI [i] को हैंडलर में बदल रहे हैं, हम फिर से स्थानांतरण शुरू नहीं कर सकते। ऐसा करने के लिए, आप टाइप टवी की वैश्विक संरचना की घोषणा कर सकते हैं, और प्रत्येक शुरुआत से पहले, TWI [टेल] से डेटा कॉपी करें, और प्रोसेसर को कॉपी को खराब करने दें। विफलता की स्थिति में, हम डेटा को मूल से पुनर्स्थापित कर सकते हैं।

निष्कर्ष

कई लोग पूछेंगे: “क्यों? दरअसल, संरचना के 16 तत्वों को संग्रहीत करने के लिए, आपको 16 * (1 + 2 + 1 + 2 + 1) = SRAM के 112 बाइट्स की आवश्यकता है! आरटीओएस का उपयोग क्यों नहीं? उन्हें कहते हैं कि 1 तत्व के साथ एक संरचना होगी, और अगर यह इसमें फिट नहीं होता है, तो हम n एमएस के लिए कतार लगाते हैं। ”मेरा मानना है कि इस तरह का समाधान ऑपरेटिंग सिस्टम के लिए बहुत उपयोगी है। इस बारे में सोचें कि इस हस्तांतरण में कितना समय लगेगा? यदि हम कतार लगाते हैं, तो प्रत्येक अगला ट्रांसमिशन n ms में होगा, और पूरा n * m ms में समाप्त हो जाएगा। हां, और क्यों अनावश्यक एम निर्देशों के साथ कतार को भरें, क्योंकि वास्तव में एक महत्वपूर्ण कार्य को याद करने का मौका है। और OS कर्नेल अनलोड किया गया है, कतार में m * (m + 1) / 2 कार्य नहीं डाल रहा है।

एक AVR माइक्रोकंट्रोलर और एक TWI बस के उदाहरण का उपयोग करके ओएस के बाहर म्यूटेक्स का कार्यान्वयन

इंतजार के झंडे

बाधा डालने का काम

प्रस्तावना

बाधा डालने का काम

म्यूटेक्स एनालॉग

अंतभाषण

निष्कर्ष

More articles: