रूसी माइक्रोकंट्रोलर K1986BE92QI पर मोडबस

मैं 32-बिट RISC कोर ARM Cortex-M3 128kB Flash और 32kB RAM के साथ PKK मिलेंडर JSC द्वारा निर्मित रूसी माइक्रोकंट्रोलर K1986BE92QI के हाथों में गिर गया, मैं तुरंत कार्रवाई में इसका अध्ययन और परीक्षण करना चाहता था।

माइक्रोकंट्रोलर एक पैकेज में आता है जो चीनी AliExpress के साथ ईर्ष्या करता है। चिप मोटी एल्यूमीनियम पन्नी के एक कैसेट में निहित है, जिसे पन्नी कागज में लपेटा जाता है, फोम रबर के साथ रखी जाती है, और यह पूरा "सैंडविच" एक गत्ता बॉक्स में होता है जिसमें पन्नी के साथ कवर किया जाता है। सामान्य तौर पर, ऊंचाई पर स्थैतिक बिजली से सुरक्षा।

माइक्रोकंट्रोलर के लिए एक लेबल और एक उत्पाद चयन प्रोटोकॉल है, जो बहुत अच्छा है।

इसके साथ शुरू करने के लिए, डिबग बोर्ड के एक सर्किट आरेख को विकसित करना और घटकों को निर्धारित करना आवश्यक था। वह कम से कम घटकों पर रुक गया: USB पोर्ट से बिजली के लिए 3.3v स्टेबलाइजर, 8MHz क्वार्ट्ज रेज़ोनेटर, एक miniUSB कनेक्टर, एक रीसेट बटन, पुल-अप रेसिस्टर्स और सिप कनेक्टर। मुझे लगता है कि माइक्रोकंट्रोलर के साथ शुरुआती प्रयोगों के लिए पर्याप्त है। अंतर्निहित बूटलोडर के मोड का चयन करने के लिए smd स्विच भी सेट करें। माइक्रोकंट्रोलर आपको दो सीरियल इंटरफेस UART या JTAG / SWD में से एक का उपयोग करके प्रोग्राम को डाउनलोड करने की विधि चुनने की अनुमति देता है, जबकि JTAG आपको माइक्रोकंट्रोलर में प्रोग्राम को डीबग करने की अनुमति देता है। कार्यक्रम लोडिंग विधि का विकल्प आउटपुट पीएफ 4, पीएफ 5, पीएफ 6 पर तर्क के स्तर से निर्धारित होता है। सभी संभावित विकल्प तालिका में प्रस्तुत किए गए हैं:

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

और इसलिए बोर्ड बनाया जाता है, सभी घटकों को मिलाप किया जाता है, यह प्रोग्राम के लिए रहता है। हम केइल - एमडीके एआरएम uVision 5.0 से विकास पर्यावरण का उपयोग करेंगे, मानक पेरिफेरल लाइब्रेरी + सॉफ्टवेयर पैक को माइक्रोकंट्रोलर निर्माता द्वारा इसे वितरित किया जाता है। मैं UART में प्रोग्राम नहीं करना चाहता था, इसलिए मैंने एसटी-लिंक v2 इन-सर्किट प्रोग्रामर / डीबगर, या किसी अज्ञात चीनी निर्माता से इसके क्लोन का उपयोग करने का निर्णय लिया। केइल इसे बॉक्स से बाहर का समर्थन करता है, लेकिन माइक्रोकंट्रोलर, हालांकि प्रलेखन कहता है कि यह SWD इंटरफ़ेस का समर्थन करता है, यह भूल गया कि इसे कैसे और कहां से कनेक्ट करना है। "JTAG - SWD एडाप्टर" के लिए इंटरनेट पर खोज करने के बाद, यह पाया गया कि SWDIO लाइन JTAG-TMS से जुड़ती है, और SWTK से JTAG-TCK और "ओह चमत्कार!" सब कुछ काम किया, एक परीक्षण कार्यक्रम को माइक्रोकंट्रोलर में फ्लैश किया गया था।

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

खुद के लिए निर्धारित पहला कार्य नियंत्रक को मोडासा प्रोटोकॉल का उपयोग करके SCADA प्रणाली से जोड़ना था। पहिया को सुदृढ़ नहीं करने के लिए, हम क्रॉस-प्लेटफॉर्म फ्रीमोडबस फ्रीमोडबस लाइब्रेरी लेते हैं और इसे हमारे माइक्रोकंट्रोलर के लिए पोर्ट करते हैं।

मिलेंडर के एक माइक्रोकंट्रोलर पर केइल में परियोजनाएं बनाने के लिए, आपको पहले सॉफ्टवेयर पैक को स्थापित करना होगा। यह फ़ाइल पर एक साधारण डबल क्लिक द्वारा किया जाता है। आगे केएल खुद सबकुछ करेगा।

और इसलिए हम एक नई परियोजना बनाते हैं। हम अपने माइक्रोकंट्रोलर और लाइब्रेरी घटकों का चयन करते हैं जिनकी हमें आवश्यकता है:

प्रोजेक्ट ट्री में, मोडबस स्लेव समूह बनाएं और वहां फ्रीमोडबस लाइब्रेरी से निम्न फाइलें जोड़ें:

और पुस्तकालय निर्देशिकाओं के लिए निम्नलिखित पथ संकलक को इंगित करने के लिए परियोजना विकल्पों में मत भूलना।

अब आप विशेष रूप से फ्रीमोडबस लाइब्रेरी को स्टैंडर्ड पेरीफेरल्स लाइब्रेरी का उपयोग करके हमारे माइक्रोकंट्रोलर में पोर्ट करना शुरू कर सकते हैं। ऐसा करने के लिए, आपको पोर्ट पोर्ट फ़ाइल में UART पोर्ट xMBPortSerialInit के आरंभीकरण फ़ंक्शन को निर्दिष्ट करने की आवश्यकता है

BOOL xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity ) { //    F RST_CLK_PCLKcmd(RST_CLK_PCLK_PORTF, ENABLE); //      PORT_InitTypeDef uart2_port_set; //   F   UART //     PORT_StructInit(&uart2_port_set); //    uart2_port_set.PORT_FUNC = PORT_FUNC_OVERRID; //    uart2_port_set.PORT_SPEED = PORT_SPEED_MAXFAST; //     uart2_port_set.PORT_MODE = PORT_MODE_DIGITAL; //   PF1  UART_TX () uart2_port_set.PORT_Pin = PORT_Pin_1; uart2_port_set.PORT_OE = PORT_OE_OUT; PORT_Init(MDR_PORTF, &uart2_port_set); //   PF0  UART_RX () uart2_port_set.PORT_Pin = PORT_Pin_0; uart2_port_set.PORT_OE = PORT_OE_IN; //    UART //   UART2 RST_CLK_PCLKcmd(RST_CLK_PCLK_UART2, ENABLE); //      UART UART_InitTypeDef UART_InitStructure; //    UART = 1 UART_BRGInit(MDR_UART2,UART_HCLKdiv1); //  UART //    – 115200  UART_InitStructure.UART_BaudRate = ulBaudRate; //     – 8 UART_InitStructure.UART_WordLength = UART_WordLength8b; //  - UART_InitStructure.UART_StopBits = UART_StopBits1; //    UART_InitStructure.UART_Parity = UART_Parity_No; //    FIFO   , // ..      UART_InitStructure.UART_FIFOMode = UART_FIFO_OFF; //      UART_InitStructure.UART_HardwareFlowControl = UART_HardwareFlowControl_RXE | UART_HardwareFlowControl_TXE; //  UART2    UART_Init(MDR_UART2, &UART_InitStructure); //   UART UART_Cmd(MDR_UART2, ENABLE); return TRUE; } 

लिखने और पढ़ने समारोह:

 BOOL xMBPortSerialPutByte( CHAR ucByte ) { //  UART_SendData(MDR_UART2,ucByte); return TRUE; } BOOL xMBPortSerialGetByte( CHAR * pucByte ) { //  *pucByte = (uint8_t) UART_ReceiveData(MDR_UART2); return TRUE; } 

यूएआरटी बाधा हैंडलर

  void USART2_IRQHandler(void) { /*     ---------------------------------------------------*/ if((UART_GetITStatus(MDR_UART2,UART_IT_RX)) != RESET) { prvvUARTRxISR( ); } /*     ------------------------------------------------*/ if((UART_GetITStatus(MDR_UART2,UART_IT_TX)) !=RESET) { prvvUARTTxReadyISR( ); } } 

इसके बाद, हम portimer.c फ़ाइल को संपादित करते हैं जिसमें एक टाइमर कॉन्फ़िगर किया गया है जो मोडबस प्रोटोकॉल ब्रैकेट के अंत को ट्रैक करने के लिए अस्थायी रिपोर्ट उत्पन्न करता है।

 BOOL xMBPortTimersInit( USHORT usTim1Timerout50us ) { MDR_RST_CLK->PER_CLOCK |= (1<<14); //   TIM1 MDR_RST_CLK->TIM_CLOCK = 0x0; MDR_RST_CLK->TIM_CLOCK |= (1<<24); // TIM1_CLK_EN MDR_RST_CLK->TIM_CLOCK |= 0x07; // HCLK/8   MDR_TIMER1->CNTRL = 0x00000002; //   MDR_TIMER1->CNT = 0x00000000; //  MDR_TIMER1->PSG = 0x2; //f/1   while((MDR_TIMER1->CNTRL & 0x004) != 0) {__NOP();} //    MDR_TIMER1->ARR = usTim1Timerout50us; //     while((MDR_TIMER1->CNTRL & 0x004) != 0) {__NOP();} //     MDR_TIMER1->IE = 0x00000002; //(CNT==ARR)->IE      NVIC->ISER[0] = (1<<14); // Global EN for IRQ14   MDR_TIMER1->CNTRL |= (1<<0); //Timer1 ON   return TRUE; } inline void vMBPortTimersEnable( ) { /*    */ MDR_TIMER1->CNTRL |= (1<<0); //Timer1 ON } inline void vMBPortTimersDisable( ) { /*    */ MDR_TIMER1->CNTRL &= ~(1<<0); //Timer1 OFF } static void prvvTIMERExpiredISR( void ) { ( void )pxMBPortCBTimerExpired( ); } void Timer1_IRQHandler(void) { //   MDR_TIMER1->STATUS &= ~0x002; //IE FLAG=0 prvvTIMERExpiredISR( ); } 

Main.c में हम मोडबस रजिस्टर प्रोसेसिंग फंक्शन्स जोड़ेंगे, हम अप्रयुक्त रजिस्टरों को स्टब्स के साथ मफल करेंगे

 /* ----------------------- Defines ------------------------------------------*/ #define REG_INPUT_START 1000 #define REG_INPUT_NREGS 4 /* ----------------------- Static variables ---------------------------------*/ static USHORT usRegInputStart = REG_INPUT_START; static USHORT usRegInputBuf[REG_INPUT_NREGS]; eMBErrorCode eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs ) { eMBErrorCode eStatus = MB_ENOERR; int iRegIndex; if( ( usAddress >= REG_INPUT_START ) && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) ) { iRegIndex = ( int )( usAddress - usRegInputStart ); while( usNRegs > 0 ) { *pucRegBuffer++ = ( unsigned char )( usRegInputBuf[iRegIndex] >> 8 ); *pucRegBuffer++ = ( unsigned char )( usRegInputBuf[iRegIndex] & 0xFF ); iRegIndex++; usNRegs--; } } else { eStatus = MB_ENOREG; } return eStatus; } eMBErrorCode eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode ) { return MB_ENOREG; } eMBErrorCode eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode ) { return MB_ENOREG; } eMBErrorCode eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete ) { return MB_ENOREG; } 

यह पोर्टिंग का अंत है, यह लूप में इनिशियलाइज़ और कॉल eMBPoll () को शुरू करने के लिए केवल मुख्य मुख्य (शून्य) फ़ंक्शन में रहता है;

 int main (void) { eMBErrorCode eStatus; // UART    ,   portserial.c  xMBPortSerialInit    eStatus = eMBInit( MB_RTU, 0x0A, 0, 19200, MB_PAR_NONE ); /* Enable the Modbus Protocol Stack. */ eStatus = eMBEnable( ); while(1) { eStatus = eMBPoll( ); //  if (eStatus!= MB_ENOREG){}; /* Here we simply count the number of poll cycles. */ usRegInputBuf[0]++; } } 

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

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

खैर, इससे कोई फर्क नहीं पड़ता, हम देख रहे हैं कि ट्रांसफर कहां से शुरू होता है, mbrtu.c फाइल में हमें कोड की लाइनें मिल जाती हैं

 /* Activate the transmitter. */ eSndState = STATE_TX_XMIT; vMBPortSerialEnable( FALSE, TRUE ); 

और UART ट्रांसमीटर को जबरन बाइट भेजें, इसके लिए हम लाइन जोड़ते हैं: "xMBRTUTransmitFSM ();" और सब कुछ ठीक काम करना शुरू कर देता है, पैकेट चलता है, रजिस्टर पढ़ा जाता है, और फिर यह तकनीक का मामला है।