🎄 🏗️ 🧑🏼 STM8L051F3 के लिए C ++ ड्राइवर 👩🏽‍🔧 👩🏼‍⚕️ 🏿

समस्याओं और ड्राइवर की आवश्यकताएं

प्रत्येक अनुभवी माइक्रोप्रोसेसर प्रोग्रामर ने ड्राइवरों को लिखने का अनुभव किया है। छोटी परियोजनाओं को लागू करते समय या तैयार किए गए डिबग कोड को किसी अन्य प्रोसेसर में स्थानांतरित करते समय, लेखन और डिबगिंग ड्राइवरों को 50% या अधिक विकास का समय लग सकता है। इसके अलावा, ड्राइवर में संरचना और व्यापकता की कमी के कारण एक नए प्रोसेसर के लिए ड्राइवर लिखने और मौजूदा कोड से मेल खाने की प्रक्रिया बहुत अप्रिय हो सकती है। एक प्रोग्रामर के लिए, यह एक नर्वस रूटीन बन जाता है। ड्राइवर लिखते समय हम महत्वपूर्ण मुद्दों की पहचान करेंगे:

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

इस पोस्ट में मैं दिखाऊंगा कि कैसे आप इन समस्याओं को खत्म कर सकते हैं और एक उदाहरण के रूप में C ++ में लागू किए गए दो UART और DMA ड्राइवरों का उपयोग करके ड्राइवर को लिखने का एक और अधिक मनोरंजक कार्य बना सकते हैं। इसके लिए, मैंने ड्राइवर के लिए आवश्यकताओं को तैयार किया:

ड्राइवर को संरचित होना चाहिए। ड्राइवर को C ++ क्लास के रूप में लागू किया जाएगा, जो आपको ड्राइवर ऑब्जेक्ट बनाने की अनुमति देगा। यह सुविधाजनक और तार्किक है, यदि प्रोसेसर, उदाहरण के लिए, तीन UART और चार DMA चैनल हैं, तो आप प्रत्येक UART के लिए तीन ड्राइवर ऑब्जेक्ट और प्रत्येक DMA चैनल के लिए चार ड्राइवर ऑब्जेक्ट बना सकते हैं। यदि प्रोजेक्ट केवल एक UART का उपयोग करता है, तो आप संबंधित UART के लिए केवल एक ऑब्जेक्ट बना सकते हैं, आदि।
ड्राइवर के पास कई प्रोसेसर के लिए एक ही इंटरफ़ेस होना चाहिए। इस आवश्यकता को पूरा करना बहुत मुश्किल है, क्योंकि एक सामान्य इंटरफ़ेस को एकल करने के लिए जो कई प्रोसेसर के लिए सुविधाजनक है, आपको इस कई प्रोसेसर को काम करने की आवश्यकता है, जिसमें बहुत समय लगेगा। इसलिए, मैंने STM8L051F3 के लिए एक इंटरफ़ेस सुविधाजनक बनाया, और फिर, जैसा कि परियोजना नए प्रोसेसर पर दिखाई देती है, मैं इस इंटरफ़ेस को समायोजित करूंगा। इस प्रकार, हम समय के साथ सभी प्रोसेसर के लिए सबसे सामान्य और इष्टतम इंटरफ़ेस को एकल कर सकते हैं।
ड्राइवर को यथासंभव कुशल होना चाहिए। आदर्श रूप से, निष्पादन की गति और कब्जे वाली मेमोरी की मात्रा इससे अधिक नहीं होनी चाहिए यदि आप इस ड्राइवर को सीधे रजिस्टरों तक पहुंचते हुए लिखते हैं। गौरतलब है कि C ++ टेम्प्लेट का उपयोग करके ड्राइवर के निष्पादन की गति को बढ़ाया जा सकता है। C ++ टेम्प्लेट मेमोरी में सीधे प्रवेश की अनुमति देता है, जिससे पॉइंटर्स को प्रतिस्थापित किया जा सकता है जो कि डेरीफेरिंग में समय लेते हैं। लेकिन ड्राइवर इंटरफ़ेस फ़ंक्शन को कॉल करने की लागत भी है। इनलाइन ऑपरेटर का उपयोग करते हुए, फ़ंक्शन कॉल को समाप्त नहीं किया जा सकता है, यह कोडांतरक कोड में देखा जा सकता है। हो सकता है कि जब आप कंपाइलर ऑप्टिमाइज़र को चालू करते हैं, तो यह ऑपरेटर प्रभावित करेगा ... चूंकि ड्राइवर एक बार या धीमी आवृत्ति के साथ कॉन्फ़िगर किया गया है, इसलिए फ़ंक्शन को कॉल करने की लागत महत्वपूर्ण नहीं है।

ड्राइवर का उपयोग

इसलिए, शुरुआत के लिए, एक डीएमए चालक का उपयोग करने पर विचार करें, और फिर एक कार्यान्वयन। डीएमए का उपयोग करते हुए, हम रैम को शिफ्ट रजिस्टर यूएआरटी से डेटा स्थानांतरित करते हैं और शिफ्ट रजिस्टर यूएआरटी से रैम में डेटा प्राप्त करते हैं।

#include "iostm8l051f3.h" #include "Driver_DMA.hpp" char UartBuffer[128]; //    DMA DriverDMA<EnumDMA::DMA1,EnumDMA::CHANNEL1> DMAChannelTX; // DMA1  1 DriverDMA<EnumDMA::DMA1,EnumDMA::CHANNEL2> DMAChannelRX; // DMA1  2 void func() { DMAChannelTX.global_disable(); //    //    DMA DMAChannelTX.set_periph_addr(&USART1_DR); //    DMAChannelTX.set_memory0_addr(UartBuffer); //     DMAChannelTX = EnumDMA::DATABLOCK_8bit; //  - DMAChannelTX = EnumDMA::PRIORITY_MEDIUM; //   DMAChannelTX = EnumDMA::MEMPNT_INCREMENT; //     DMAChannelTX = EnumDMA::MEMORY_TO_PHERIPH; //       UART DMAChannelTX = EnumDMA::CIRCULAR_DISABLE; //    //    DMA DMAChannelRX.set_periph_addr(&USART1_DR); DMAChannelRX.set_memory0_addr(UartBuffer); DMAChannelRX = EnumDMA::DATABLOCK_8bit; DMAChannelRX = EnumDMA::PRIORITY_MEDIUM; DMAChannelRX = EnumDMA::MEMPNT_INCREMENT; DMAChannelRX = EnumDMA::PHERIPH_TO_MEMORY; //     UART   DMAChannelRX = EnumDMA::CIRCULAR_DISABLE; DMAChannelRX.set_number_of_transfers(sizeof(UartBuffer)); DMAChannelRX.channel_enable(); //    DMAChannelTX.global_enable(); //    }

जैसा कि आप पिछली लिस्टिंग से देख सकते हैं, कोड अधिक समझने योग्य, पठनीय और स्व-दस्तावेजीकरण बन जाता है।

ड्राइवर इंटरफ़ेस

इंटरफ़ेस EnumDMA संरचना में परिभाषित किया गया है, जो ड्राइवर विधियों के तर्क के रूप में उपयोग किए जाने वाले गणना को परिभाषित करता है।

 struct EnumDMA { enum DMASel{ DMA1 = 0x5070 }; enum ChannelSel{ CHANNEL0 = 0x05, CHANNEL1 = 0x0F, CHANNEL2 = 0x19, CHANNEL3 = 0x23 }; enum DataBlock{ DATABLOCK_8bit, DATABLOCK_16bit }; enum ChannelPriority{ PRIORITY_LOW, PRIORITY_MEDIUM, PRIORITY_HIGH, PRIORITY_VERYHIGH }; enum MemoryPointerMode{ MEMPNT_DECREMENT, MEMPNT_INCREMENT }; enum CircularBufferMode{ CIRCULAR_DISABLE, CIRCULAR_ENABLE }; enum TransferType{ //    3 TRANS_TYPE_PHERIPH_TO_MEMORY, TRANS_TYPE_MEMORY0_TO_MEMORY1 }; enum TransferDirection{ PHERIPH_TO_MEMORY, MEMORY_TO_PHERIPH }; enum InterruptSelection{ INTERRUPT_HALF_TRANSACTION_COMPLETE, INTERRUPT_TRANSACTION_COMPLETE }; enum InterruptVectors{ VECTOR_DMA1_CHANNEL0_HALF_TRANSACTION_COMPLETE = DMA1_CH0_HT_vector, VECTOR_DMA1_CHANNEL0_TRANSACTION_COMPLETE = DMA1_CH0_TC_vector, VECTOR_DMA1_CHANNEL1_HALF_TRANSACTION_COMPLETE = DMA1_CH1_HT_vector, VECTOR_DMA1_CHANNEL1_TRANSACTION_COMPLETE = DMA1_CH1_TC_vector, VECTOR_DMA1_CHANNEL2_HALF_TRANSACTION_COMPLETE = DMA1_CH2_HT_vector, VECTOR_DMA1_CHANNEL2_TRANSACTION_COMPLETE = DMA1_CH2_TC_vector, VECTOR_DMA1_CHANNEL3_HALF_TRANSACTION_COMPLETE = DMA1_CH3_HT_vector, VECTOR_DMA1_CHANNEL3_TRANSACTION_COMPLETE = DMA1_CH3_TC_vector, }; };

DMASel गणन आपको DMA मॉड्यूल का चयन करने की अनुमति देता है, और ChannelSel गणन DMA चैनलों के बीच मेमोरी ऑफसेट निर्धारित करता है। STM8L051F3 प्रोसेसर में एक डीएमए मॉड्यूल है, इसलिए चुनाव बढ़िया नहीं है। DMA1 गणन को DMA1 मॉड्यूल का पता सौंपा गया है।

DriverDMA वर्ग डिजाइन:

 template <EnumDMA::DMASel DMA, EnumDMA::ChannelSel DMAChannel> class DriverDMA { private: ... struct DMA_struct //   DMA     { volatile GCSR_REG GCSR; /*!< Global configuration and status register */ volatile GIR_REG GIR1; /*!< Global interrupt register 1 */ }; ... struct DMA_Channel_struct //    DMA { volatile CCR_REG CCR; /*!< CHx Control register */ volatile CSPR_REG CSPR; /*!< CHx Status & Priority register */ volatile unsigned char CNDTR; /*!< CHx Number of Bytes to Tranfer register */ volatile unsigned char CPARH; /*!< Peripheral Address High register */ volatile unsigned char CPARL; /*!< Peripheral Address Low register */ volatile unsigned char CM0EAR; /*!< Memory 0 Extended Address register (for channel3)*/ volatile unsigned char CM0ARH; /*!< Memory 0 Address High register */ volatile unsigned char CM0ARL; /*!< Memory 0 Address Low register */ }; u8 number_of_transfers; u8 NumChannel; public: DriverDMA(); void operator= (EnumDMA::DataBlock); void operator= (EnumDMA::ChannelPriority); void operator= (EnumDMA::MemoryPointerMode); void operator= (EnumDMA::CircularBufferMode); void operator= (EnumDMA::TransferDirection); void operator= (EnumDMA::TransferType); //    3 void global_enable(); void global_disable(); void channel_enable(); void channel_disable(); void set_number_of_transfers(const u16 trans_num); void set_periph_addr(u8 volatile* addr); void set_memory0_addr(u8* addr); //    00000  01FFF void set_memory1_addr(u8* addr); //    3 bool is_busy(); u16 get_amount_of_last_transation(); void interrupt_enable(EnumDMA::InterruptSelection); void interrupt_disable(EnumDMA::InterruptSelection); void interrupt_clear_pending_flag(EnumDMA::InterruptSelection); };

डीएमए मॉड्यूल रजिस्टरों को निजी अनुभाग में परिभाषित किया गया है, सी ++ टेम्पलेट का उपयोग करते हुए, डीएमए मॉड्यूल और मॉड्यूल चैनल का चयन किया जाता है।

ड्राइवर कार्यान्वयन का विवरण

क्लास कंस्ट्रक्टर और दो तरीकों का कार्यान्वयन:

 //---------------------------------------------------------------------------------------------- template <EnumDMA::DMASel DMA, EnumDMA::ChannelSel DMAChannel> DriverDMA<DMA,DMAChannel>::DriverDMA() { CLK_PCKENR2_bit.PCKEN24 = 1; // DMA clock enable __DMA->GCSR.bit.TO = 31; NumChannel = (u8)DMAChannel; } //---------------------------------------------------------------------------------------------- template <EnumDMA::DMASel DMA, EnumDMA::ChannelSel DMAChannel> void DriverDMA<DMA,DMAChannel>::operator= (EnumDMA::DataBlock db) { __DMACHANNEL->CSPR.bit.TSIZE = db; } //---------------------------------------------------------------------------------------------- template <EnumDMA::DMASel DMA, EnumDMA::ChannelSel DMAChannel> void DriverDMA<DMA,DMAChannel>::global_enable() { __DMA->GCSR.bit.GEN = 1; // Global enable of DMA1 }

जहां __DMA और __DMACHANNEL को निम्नानुसार परिभाषित किया गया है:

 #define __DMA ((DMA_struct*) DMA) #define __DMACHANNEL ((DMA_Channel_struct*) ((u32)DMA + (u32)DMAChannel))

पहली नज़र में, एक जटिल डिजाइन:

 __DMACHANNEL->CSPR.bit.TSIZE = db;

कंपाइलर द्वारा 3 कोडांतरक कमांड और कमांड के रूप में व्याख्या की गई:

 __DMA->GCSR.bit.GEN = 1;

एक असेंबलर कमांड पर कब्जा करता है।

बीच में आता है

एक रुकावट बनाने के लिए, आपको इसे सक्षम करना होगा, एक बाधा फ़ंक्शन लिखना चाहिए जिसमें आप स्वीकार करना चाहते हैं। उदाहरण के लिए, डीएमए लेन-देन के अंत में एक बाधा बनाएं:

 void func() { //      DMAChannelTX.interrupt_enable(EnumDMA::INTERRUPT_TRANSACTION_COMPLETE) } #pragma vector = EnumDMA::VECTOR_DMA1_CHANNEL1_TRANSACTION_COMPLETE __interrupt void DMA_transaction_complete() { //    DMAChannelTX.interrupt_clear_pending_flag(EnumDMA::INTERRUPT_TRANSACTION_COMPLETE) }

एक DMA ड्राइवर का उपयोग करके UART ड्राइवर को लागू करना

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

 class DriverUART { private: ... u8 UartBuffer[128]; DriverDMA<EnumDMA::DMA1,EnumDMA::CHANNEL1> DMAChannelTX; DriverDMA<EnumDMA::DMA1,EnumDMA::CHANNEL2> DMAChannelRX; ...

UMA ड्राइवर कंस्ट्रक्टर में DMA कॉन्फ़िगरेशन किया जा सकता है, इसलिए जब आप UART ऑब्जेक्ट बनाते हैं, तो DMA ड्राइवर तुरंत इनिशियलाइज़ हो जाएगा और काम करने के लिए तैयार होगा।

 //----------------------------------------------------------------------- // Main DriverUART Constructor //----------------------------------------------------------------------- DriverUART::DriverUART(SELECTUART uart, u32 baud_rate, u32 sys_clock, PinconfigUART confPin) { CLK_PCKENR1_bit.PCKEN15 = 1; // UART clock enable USART1_CR1_bit.USARTD = 0; USART1_CR5_bit.DMAT = 1; // DMA enable transmitter USART1_CR5_bit.DMAR = 1; // DMA enable receiver DMAChannelTX.global_disable(); DMAChannelTX.set_periph_addr(&USART1_DR); DMAChannelTX.set_memory0_addr(UartBuffer); DMAChannelTX = EnumDMA::DATABLOCK_8bit; DMAChannelTX = EnumDMA::PRIORITY_MEDIUM; DMAChannelTX = EnumDMA::MEMPNT_INCREMENT; DMAChannelTX = EnumDMA::MEMORY_TO_PHERIPH; DMAChannelTX = EnumDMA::CIRCULAR_DISABLE; DMAChannelRX.set_periph_addr(&USART1_DR); DMAChannelRX.set_memory0_addr(UartBuffer); DMAChannelRX = EnumDMA::DATABLOCK_8bit; DMAChannelRX = EnumDMA::PRIORITY_MEDIUM; DMAChannelRX = EnumDMA::MEMPNT_INCREMENT; DMAChannelRX = EnumDMA::PHERIPH_TO_MEMORY; DMAChannelRX = EnumDMA::CIRCULAR_DISABLE; DMAChannelRX.set_number_of_transfers(sizeof(UartBuffer)); DMAChannelRX.channel_enable(); DMAChannelTX.global_enable(); set_sysclock(sys_clock, baud_rate); USART1_CR2_bit.TCIEN = 1; // .     USART1_CR2_bit.ILIEN = 1; // .    USART1_CR5_bit.EIE = 1; // .     __enable_interrupt(); close(); }

डेटा ट्रांसफर कार्यान्वयन:

 void DriverUART::transmit(u8 * source, u16 size) { while(DMAChannelTX.is_busy()) ; select_direction(TRANSMITION); __disable_interrupt(); DMAChannelTX.global_disable(); DMAChannelTX.channel_disable(); DMAChannelTX.set_number_of_transfers(size); DMAChannelTX.set_memory0_addr(source); DMAChannelTX.global_enable(); DMAChannelTX.channel_enable(); __enable_interrupt(); }

उपयोग उदाहरण:

 u8 buffer[] = "hello world!" Uart1.transmit(buffer, sizeof(buffer));

प्राप्त होने पर, एक अवरोध उत्पन्न होता है जिसमें डीएमए चैनल प्राप्त करना आवश्यक होता है:

 void DriverUART::reception_handshake() { __disable_interrupt(); DMAChannelRX.global_disable(); DMAChannelRX.channel_disable(); received_size = DMAChannelRX.get_amount_of_last_transation(); DMAChannelRX.set_number_of_transfers(sizeof(UartBuffer)); DMAChannelRX.global_enable(); DMAChannelRX.channel_enable(); __enable_interrupt(); }

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

 //-------------------------------------------------------------------------- //    //-------------------------------------------------------------------------- void DriverUART::receive_handle() { u16 size; u8* pnt; Uart1.reception_handshake(); size = Uart1.get_received_size(); pnt = Uart1.get_pointer_on_internal_buffer(); //      }

निष्कर्ष

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

C ++ सूचियों के रूप में एक इंटरफ़ेस बनाया गया है, जो ड्राइवर की संपत्तियों और क्षमताओं को बेहतर ढंग से समझने और प्रोसेसर की तारीख के साथ संचार को कम करने में मदद करता है। इस इंटरफ़ेस के लिए धन्यवाद, कोड स्व-दस्तावेजीकरण बन जाता है। यह सब आपको जल्दी से चालक में शुरुआती को समझने और एक अनुभवी प्रोग्रामर को अपने स्वयं के कोड का सार याद करने की अनुमति देता है।

ड्राइवर कोड को ड्राइवर या अन्य निर्माताओं की इस पंक्ति के किसी अन्य प्रोसेसर के लिए समान ड्राइवर लिखने के लिए एक टेम्पलेट के रूप में उपयोग किया जा सकता है, बिना इंटरफ़ेस को बदलने के।

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

DMA और UART ड्राइवर फ़ाइलों को इस लिंक STM8L051F3_Drivers से डाउनलोड किया जा सकता है।

फ़ाइल "Init_UART.cpp" में UART ड्राइवर का उपयोग करने का एक उदाहरण है।

STM8L051F3 के लिए C ++ ड्राइवर