Cosm c और stvd का उपयोग करके stm8 पर सीरियल यूरेट संचार

एक नया माइक्रोकंट्रोलर प्रोग्रामिंग करना अक्सर नए रजिस्टर हैंडलिंग तरीकों के कारण अधिक समय लेता है और यह नहीं जानता कि बिट क्या वास्तव में करता है। वही डिबगिंग के लिए भी जाता है और बिना कहे। यही कारण है कि प्रोग्रामर अक्सर अपने कोड में ब्रेकपॉइंट का उपयोग करते हैं और डिबगर का उपयोग करके इसके माध्यम से कदम बढ़ाते हैं। लेकिन डीबगर का उपयोग करने के लिए अतिरिक्त हार्डवेयर (अधिकांश बार महंगा) और अतिरिक्त समय की आवश्यकता हो सकती है। एक Arduino प्रशंसक लड़का होने के नाते, एक बात जो हम सभी सहमत हो सकते हैं, डिबगिंग के लिए सीरियल प्रिंट स्टेटमेंट का उपयोग कर रहा है और हमारे कोड को समझना जीवन को बहुत आसान बनाता है। हम ब्रह्मांडीय सी संकलक और एसपीएल पुस्तकालयों के साथ एसटीएम 8 पर समान रूप से दोहरा सकते हैं। खैर, यह बहुत संभव है, और यही वह है जो हम अपनी ट्यूटोरियल श्रृंखला के इस तीसरे ट्यूटोरियल में करने जा रहे हैं।यदि आप पूरी तरह से यहाँ हैं, तो आप STM8S (ट्यूटोरियल 1) और STM8S GPIO नियंत्रण (ट्यूटोरियल 2) के साथ शुरुआत कर रहे हैं। इसके अलावा, हमने शुरुआती शुरुआत के लिए Arduino के साथ STM8S प्रोग्रामिंग की संभावना भी खोजी है। कहा जा रहा है कि सभी ट्यूटोरियल में मिलता है।

STM8S103F3P6 पर सीरियल कम्युनिकेशन

STM8S103F3P6 की डेटशीट से, हम देख सकते हैं कि हमारा 8-बिट नियंत्रक कई अलग-अलग मोड में UART संचार का समर्थन करता है। नियंत्रक में सिंक्रोनस UART संचार के लिए क्लॉक आउटपुट पिन भी है और यह स्मार्कार्ड, इरडा और लिन का भी समर्थन कर सकता है। लेकिन हम इस ट्यूटोरियल में कुछ भी नहीं खोज रहे हैं, सिर्फ जटिलता से दूर रहने के लिए। हम सीखेंगे कि सरल UART कैसे पढ़ें और लिखें।

ट्यूटोरियल एक हेडर फाइल भी प्रदान करता है जिसे stm8s103 serial.h कहा जाता है, जिसके उपयोग से आप सरल UART कमांड जैसे कि सीरियल आरंभ, सीरियल रीड, सीरियल प्रिंट इत्यादि का प्रदर्शन कर सकते हैं। मूल रूप से, आप धारावाहिक मॉनीटर पर char, int, और string प्रिंट कर सकेंगे। और धारावाहिक मॉनीटर से चार भी पढ़ें। इस ट्यूटोरियल के अंत में, आप सीरियल मॉनिटर से एक एलईडी को नियंत्रित करने और एलईडी की स्थिति के बारे में प्रतिक्रिया प्राप्त करने में सक्षम होंगे। ऊपर उल्लिखित हेडर फ़ाइल एसपीएल पुस्तकालयों पर निर्भर करती है, इसलिए सुनिश्चित करें कि आपने शुरू किए गए ट्यूटोरियल का पालन किया है।

STM8S103F3P6 पर सीरियल कम्युनिकेशन पिन

चलो हार्डवेयर पक्ष से शुरू करते हैं। नीचे दिए गए STM8S103F3P6 माइक्रोकंट्रोलर पर पिनआउट्स पर एक त्वरित नज़र डालते हुए, हम देख सकते हैं कि पिन 1, 2, और 3 का उपयोग UART संचार के लिए किया जाएगा।

तीन में से, पिन 1 UART क्लॉक पिन है जो केवल सिंक्रोनस UART संचार के दौरान उपयोग किया जाएगा, इसलिए हमें यहां इसकी आवश्यकता नहीं होगी। पिन 2 UART ट्रांसमीटर पिन है और पिन 3 UART रिसीवर पिन है। ध्यान दें कि ये पिन एनालॉग पिन या सामान्य GPIO पिन के रूप में भी दोगुना हो सकता है।

STM8S सीरियल कम्युनिकेशन के लिए सर्किट आरेख

सर्किट आरेख यहां बहुत सरल है, हमें प्रोग्रामिंग के लिए अपने एसटी-लिंक 2 और धारावाहिक डेटा पढ़ने के लिए टीटीएल कनवर्टर के लिए एक यूएसबी कनेक्ट करने की आवश्यकता है। ध्यान दें कि हमारा STM8S कंट्रोलर 3.3V लॉजिक लेवल में काम करता है, इसलिए सुनिश्चित करें कि आपका USB TTL कन्वर्टर भी 3.3V लॉजिक को सपोर्ट करता है। पूरा सर्किट आरेख नीचे दिखाया गया है।

आपको अपने एसटी-लिंक को एक यूएसबी पोर्ट और यूएसबी को अपने लैपटॉप के दूसरे यूएसबी पोर्ट में टीटीएल कनवर्टर से कनेक्ट करना होगा, ताकि आप एक ही समय में डेटा को प्रोग्राम और मॉनिटर कर सकें। UART कनेक्शन सरल है, बस अपने STM8S माइक्रोकंट्रोलर की जमीन और Rx / Tx पिन को USB के TT / Rx पिन से TTL कनवर्टर से कनेक्ट करें। यहां मैंने नियंत्रक को ST-Link के Vcc पिन के साथ संचालित किया है और TTL कनवर्टर के वीएस पिन को खुला छोड़ दिया है, आप इसे दूसरे तरीके से भी कर सकते हैं। बाजार में कई प्रकार के यूएसबी से टीटीएल कनवर्टर हैं बस यह सुनिश्चित करें कि यह 3.3V लॉजिक सिग्नल और टीएक्स, आरएक्स और जीएनडी पिन के लिए सरल लुक पर काम कर सकता है और ऊपर दिखाए गए कनेक्शन को बना सकता है। मेरा हार्डवेयर सेट-अप नीचे दिखाया गया है।

एक धारावाहिक संचार रास्ता बनाने के लिए, हमने STM8S_Serial.h हैडर फ़ाइल प्रदान की है । इस हेडर फ़ाइल का उपयोग करके, आप साधारण Arduino जैसे सीरियल संचार के लिए कार्य कर सकते हैं।

आप हमारे STM8S103F3_SPL Github पृष्ठ पर इस परियोजना के लिए सभी आवश्यक फाइलें पा सकते हैं। यदि आपको केवल इस विशेष हेडर फ़ाइल की आवश्यकता है, तो आप इसे नीचे दिए गए लिंक से डाउनलोड कर सकते हैं।

STM8S_Serial.h डाउनलोड करें

सीरियल कम्युनिकेशन के लिए STVD की स्थापना

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

सुनिश्चित करें कि आपने सभी एसपीएल स्रोत फ़ाइलों को शामिल किया है और फ़ाइल शामिल करें जैसे हमने अपने पहले ट्यूटोरियल में किया था। और यह भी सुनिश्चित करें कि आपने stm8s103_serial.h हैडर फ़ाइल जोड़ी है । इस हेडर के लिए कोई C फाइल नहीं है।

सीरियल कम्युनिकेशन के लिए प्रोग्रामिंग एसटीएम 8 एस

STVD प्रोजेक्ट सेटअप तैयार हो जाने के बाद, हम अपना कोड main.c फाइल में लिखना शुरू कर सकते हैं । इस ट्यूटोरियल का पूरा कोड इस पेज के नीचे पाया जा सकता है। स्पष्टीकरण इस प्रकार है।

पहला कदम आवश्यक हेडर फ़ाइलों को शामिल करना है, यहाँ मैंने मुख्य हेडर फाइल (stm8s) और stm8s_103_serial हेडर फाइल को जोड़ा है जिसे हमने अभी डाउनलोड किया है।

// आवश्यक हेडर्स #include "STM8S.h" #include "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3-SPL/blob/master/stm8s103%20Lbooks/stm8s103_erialh

अगला, हम इनपुट और आउटपुट पिन निर्दिष्ट करने के लिए डिज़ाइन मैक्रोज़ का उपयोग कर रहे हैं। यहां केवल ऑन-बोर्ड एलईडी को नियंत्रित किया जाएगा जो कि पोर्ट बी के पिन 5 से जुड़ा है, इसलिए हम इसे test_LED नाम देते हैं ।

#define test_LED GPIOB, GPIO_PIN_5 // परीक्षण एलईडी PB5 से जुड़ा है

मुख्य फ़ंक्शन के अंदर आगे बढ़ते हुए, हम पिन को आउटपुट के रूप में परिभाषित करेंगे। यदि आप बुनियादी GPIO कार्यों से परिचित नहीं हैं, तो STM8S GPIO ट्यूटोरियल पर वापस जाएँ।

// पिन डिफेंसिशन // पीबी 5 को पुश पुल आउटपुट पिन GPIO_Init (test_LED, GPIO_MODE_OUT_PP_LOW_SLOW) के रूप में घोषित करें;

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

सीरियल_बेगिन (9600); // 9600 बॉड दर पर सीरियल संचार आरंभ करें Serial_print_string ("कमांड दर्ज करें"); // एक स्ट्रिंग प्रिंट करें Serial_newline (); // अगली पंक्ति में जाएं

लूप करते समय अनंत पर आगे बढ़ते हुए, हम सीरियल- अवेलेबल फंक्शन का उपयोग करके यह जांचते हैं कि कोई आने वाला सीरियल डेटा है या नहीं। यदि हाँ, तो हम इसे ch नामक एक चर में पढ़ते और सहेजते हैं और Serial_print का उपयोग करके इसे प्रिंट भी करते हैं । फिर यदि प्राप्त मान 0 है, तो हम एलईडी को बंद कर देंगे और यदि यह 1 है, तो हम एलईडी को चालू करेंगे

if (Serial_available ()) {Serial_print_string ("आपने दबाया है:"); ch = Serial_read_char (); सीरियल_प्रिंट_चर (ch); सीरियल_न्यूलाइन (); अगर (ch == '0') GPIO_WriteHigh (test_LED); // LED OFF अगर (ch == '1') GPIO_WriteLow (test_LED); //नेतृत्व }

इसके साथ, इस ट्यूटोरियल के लिए प्रोग्रामिंग पूरी हो गई है, बस इस पृष्ठ के नीचे दिए गए कोड को अपलोड करें और आपको सीरियल मॉनिटर से एलईडी को नियंत्रित करने में सक्षम होना चाहिए।

सीरियल मॉनिटर से एलईडी को नियंत्रित करना

एक बार कोड अपलोड करने के बाद, आप 9600 बॉड दरों पर किसी भी सीरियल मॉनिटर को खोल सकते हैं। मैंने इसका उपयोग करने में आसानी के लिए खुद Arduino सीरियल मॉनिटर का उपयोग किया है। रीसेट बटन दबाएं और आपको संदेश "एक कमांड दर्ज करें" देखना चाहिए। फिर यदि आप 1 दर्ज करते हैं और एंटर दबाते हैं, तो ऑन-बोर्ड एलईडी को चालू करना चाहिए, इसी तरह 0 के लिए, इसे बंद करना चाहिए।

इस पृष्ठ के निचले भाग से जुड़े वीडियो में पूरा काम किया जा सकता है। यदि आपके कोई प्रश्न हैं, तो कृपया उन्हें टिप्पणी अनुभाग में छोड़ दें। अन्य तकनीकी प्रश्नों को पोस्ट करने के लिए आप हमारे मंचों का भी उपयोग कर सकते हैं।

STM8S सीरियल लाइब्रेरी डीपर लुक

उन जिज्ञासु दिमागों के लिए जो जानना चाहते हैं कि वास्तव में STM8S103F3_Serial हैडर फ़ाइल के अंदर क्या होता है… पर पढ़ें।

यह हेडर फ़ाइल शुरुआती स्तर की प्रोग्रामिंग के लिए अच्छी तरह से काम करती है, लेकिन यदि आप STM8S नियंत्रक के किसी भिन्न संस्करण का उपयोग कर रहे हैं या कुछ उन्नत विकल्पों की तलाश कर रहे हैं, तो आप इस हेडर को थोड़ा या सीधे एसपीएल पुस्तकालयों के साथ काम करना चाहते हैं। मैंने इस हेडर फ़ाइल को UART1 हेडर फ़ाइल से एक पके के रूप में लिखा है, मेरी हेडर फ़ाइल की व्याख्या इस प्रकार है।

सीरियल मॉनिटर से एक चरित्र पढ़ना

यह फ़ंक्शन एक एकल चरित्र को पढ़ने में मदद करता है जिसे सीरियल मॉनिटर से माइक्रोकंट्रोलर को भेजा गया है।

char Serial_read_char (शून्य) {जबकि (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); वापसी (UART1_ReceiveData8 ()); }

हम तब तक प्रतीक्षा करते हैं जब तक कि RXE ध्वज रिसेप्शन को पूरा करने के लिए सेट नहीं हो जाता है और फिर फ्लैग को रिसेप्शन को स्वीकार करने के लिए साफ़ कर देता है। अंत में, हम इस फ़ंक्शन के परिणाम के रूप में प्राप्त 8-बिट डेटा भेजते हैं।

सीरियल मॉनीटर के लिए एक चरित्र मुद्रण

यह फ़ंक्शन एक एकल चरित्र को माइक्रोकंट्रोलर से सीरियल मॉनिटर तक पहुंचाता है।

शून्य Serial_print_char (चार मूल्य) {UART1_SendData8 (मूल्य); जबकि (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // भेजने के लिए प्रतीक्षा करें}

फ़ंक्शन केवल 8-बिट मान लिखता है और तब तक इंतजार करता है जब तक कि SARTET को UART1_FLAG_TXE चेक करके ट्रांसमिशन पूरा नहीं हो जाता है

प्रारंभिक संचार

यह फ़ंक्शन आवश्यक बॉड दर पर धारावाहिक संचार को आरंभ करता है।

शून्य सीरियल_बेगिन (uint32_t baud_rate) {GPIO_Init (GPIOD, GPIO_PIN_5, GPIO_MODE_OUT_PP_HIGH_FAST); GPIO_Init (GPIOD, GPIO_PIN_6, GPIO_MODE_IN_PU_NO_IT); UART1_DeInit (); // Deinitialize UART के परिधीय UART1_Init (baud_rate, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO, UART1 -SYNCMODE_CLOCK_DISABLE, UART1_MODE_TXRX_ENABLE) // (BaudRate, Wordlegth, StopBits, Parity, SyncMode, Mode) UART1_Cmd (सक्षम); }

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

सीरियल मॉनिटर पर एक पूर्णांक मुद्रण

अधिकांश समय, यदि हम डिबगिंग या मॉनिटरिंग के लिए एक धारावाहिक मॉनिटर का उपयोग कर रहे हैं, तो हम धारावाहिक मॉनीटर पर एक प्रकार का चर प्रिंट करना चाहते हैं। यह कार्य ठीक यही करता है

void Serial_print_int (int number) // सीरियल मॉनीटर {int count = 0; चार अंक = ""; जबकि (संख्या! = 0) // इंट को चार सरणी में विभाजित करें {अंक = संख्या% 10; गिनती ++; संख्या = संख्या / 10; } जबकि (गिनती! = 0) // सही दिशा में प्रिंट चार सरणी {UART1_SendData8 (अंक + 0x30); जबकि (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // गिनती भेजने के लिए प्रतीक्षा करें-- }}

यह पूर्णांक मान में लेता है और पहले लूप में वर्ण सरणी में परिवर्तित करता है, फिर दूसरे जबकि लूप में, हम प्रत्येक अक्षर को हमारे प्रिंट चार फ़ंक्शन के समान भेजेंगे।

नई लाइन प्रिंट करना

यह एक नई लाइन प्रिंट करने का एक सरल कार्य है। "0x0a" ऐसा करने के लिए हेक्सवल्यू, हम इसे 8-बिट ट्रांसमिट कमांड का उपयोग करके भेज रहे हैं।

शून्य Serial_newline (शून्य) {UART1_SendData8 (0x0a); जबकि (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // भेजने के लिए प्रतीक्षा करें}

धारावाहिक मॉनिटर के लिए एक स्ट्रिंग मुद्रण

एक अन्य उपयोगी कार्य वास्तव में सीरियल मॉनिटर पर तार प्रिंट करना है।

शून्य Serial_print_string (चार स्ट्रिंग) {। char i = 0; जबकि (स्ट्रिंग! = 0x00) {UART1_SendData8 (स्ट्रिंग); जबकि (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); मैं ++; }}

फिर, यह फ़ंक्शन स्ट्रिंग को चार सरणी में परिवर्तित करता है और प्रत्येक वर्ण को भेजता है। जैसा कि हम जानते हैं कि सभी तार समाप्त हो जाएंगे। इसलिए हमें केवल शून्य 0x00 तक पहुँचने तक ट्रैवर्स को रखना और प्रसारित करना है।

यह देखने के लिए कि क्या सीरियल डेटा पढ़ने के लिए उपलब्ध है

यह फ़ंक्शन यह जांचता है कि क्या बफर में कोई सीरियल डेटा पढ़ने के लिए तैयार है।

bool Serial_available () {if (UART1_GetFlagStatus (UART1_FLAG_RXNE) == TRUE) TRUE लौटाएँ; और वापसी FALSE; }

यह ध्वज UART1_FLAG_RXNE के लिए जाँच करता है, यदि यह सत्य है, तो यह सत्य है और यदि यह नहीं है, तो यह गलत है।