रास्पबेरी पाई फॉर्म फैक्टर में एसटीएम 32 एफ 4 डिबग बोर्ड

शुभ दोपहर, प्रिय खाबरोवित्स! मैं अपनी परियोजना को जनता के सामने लाना चाहता हूं - STM32 पर आधारित एक छोटा सा डिबग बोर्ड, लेकिन रास्पबेरी पाई फॉर्म फैक्टर में। यह अन्य डिबग बोर्डों से भिन्न है कि इसमें रास्पबेरी पाई मामलों के साथ संगत एक ज्यामिति और एक वायरलेस मॉडेम के रूप में एक ईएसपी 8266 मॉड्यूल है। और माइक्रो-एसडी कार्ड और एक स्टीरियो एम्पलीफायर के लिए कनेक्टर के रूप में भी अच्छा जोड़। इस सभी धन का लाभ उठाने के लिए, मैंने एक उच्च-स्तरीय पुस्तकालय और एक डेमो प्रोग्राम (C ++ 11 में) विकसित किया। लेख में मैं इस परियोजना के हार्डवेयर और सॉफ्टवेयर दोनों हिस्सों के बारे में विस्तार से वर्णन करना चाहता हूं।

इस परियोजना से कौन लाभान्वित हो सकता है? शायद, केवल उन लोगों को जो इस बोर्ड को खुद को मिलाप करना चाहते हैं, क्योंकि मैं छोटे पैमाने पर उत्पादन के लिए भी कोई विकल्प नहीं मानता हूं। यह एक शुद्ध शौक है। मेरी राय में, बोर्ड कार्यों की एक विस्तृत श्रृंखला को शामिल करता है जो वाईफाई और ध्वनि का उपयोग करके छोटे घर के शिल्प के ढांचे में उत्पन्न हो सकता है।

शुरू करने के लिए, मैं इस सवाल का जवाब देने की कोशिश करूंगा कि यह सब क्यों है। इस परियोजना के मुख्य प्रेरक इस प्रकार हैं:

• STM32 प्लेटफ़ॉर्म का विकल्प विशुद्ध रूप से सौंदर्य संबंधी विचारों के कारण है - मुझे मूल्य / प्रदर्शन अनुपात, प्लस बाह्य उपकरणों की एक विस्तृत श्रृंखला, प्लस नियंत्रक निर्माता (sw4stm, cubeMX, HAL पुस्तकालय) से एक बड़ा और सुविधाजनक विकास पारिस्थितिकी तंत्र पसंद है।
• बेशक, नियंत्रक निर्माता स्वयं (डिस्कवरी, न्यूक्लियो) से कई डिबग बोर्ड हैं, साथ ही तीसरे पक्ष के निर्माताओं (उदाहरण के लिए, ओलीमेक्स) से। लेकिन अपने फॉर्म फैक्टर में घर पर उनमें से कई को दोहराने के लिए कम से कम मेरे लिए समस्याग्रस्त है। मेरे संस्करण में, हमारे पास एक सरल दो-परत टोपोलॉजी और घटक हैं जो मैनुअल सोल्डरिंग के लिए सुविधाजनक हैं।
• उनके उपकरणों के लिए, मैं अंदर इलेक्ट्रॉनिक्स की निम्न गुणवत्ता के मुखौटे के लिए सभ्य मामलों को रखना चाहता हूं। कम से कम दो लोकप्रिय मंच हैं जिनके लिए सबसे विविध मामलों की एक बड़ी संख्या है: अरुडिनो और रास्पबेरी पाई। कनेक्टर्स के लिए कटआउट के स्थान के संदर्भ में उनमें से दूसरा मुझे अधिक सुविधाजनक लग रहा था। इसलिए, बोर्ड की ज्यामिति के लिए एक दाता के रूप में, मैंने इसे चुना।
• बोर्ड पर चयनित नियंत्रक में USB, SDIO, I2S, नेटवर्क है। दूसरी ओर, ये वही इंटरफेस घर के शौक के लिए भी उपयोगी हैं। यही कारण है, एक मानक बंधन के साथ नियंत्रक के अलावा, मैंने एक यूएसबी कनेक्टर, एक एसडी कार्ड, एक ऑडियो पथ (डिजिटल-से-एनालॉग कनवर्टर और एम्पलीफायर), साथ ही साथ ईएसपी 8266 पर आधारित एक वायरलेस मॉड्यूल भी जोड़ा।

सर्किट और घटक

ऐसा लगता है कि निम्नलिखित विशेषताओं और घटकों के साथ एक बहुत अच्छा बोर्ड निकला है:

• STM32F405RG नियंत्रक: एआरएम 32-बिट कॉर्टेक्स-एम 4 एक गणितीय कोप्रोसेसर के साथ, 168 मेगाहर्ट्ज तक आवृत्ति, 1 एमबी फ्लैश मेमोरी, 196 जीबी रैम।
  
  
• नियंत्रक (6 पिन) प्रोग्रामिंग के लिए SWD कनेक्टर।
• रिबूट करने के लिए बटन रीसेट करें।
• तीन रंग की एलईडी। एक तरफ, तीन नियंत्रक पिन खो जाते हैं। दूसरी ओर, वे अभी भी GPIO कनेक्टर्स पर सीमित संपर्कों के कारण खो जाएंगे, और इस तरह के एलईडी को डीबग करने के लिए, बात बहुत उपयोगी है।
• उच्च-आवृत्ति एचएसई (कोर घड़ी के लिए 16 मेगाहर्ट्ज) और कम-आवृत्ति एलएसई (वास्तविक समय की घड़ी के लिए 32.7680 kHz) क्वार्ट्ज।
• 2.54 मिमी की पिच वाली GPIO पिन ब्रेडबोर्ड मॉडल के साथ संगत है।
• रास्पबेरी पाई के 3.5 मिमी ऑडियो जैक के स्थान पर, मैंने 5-वोल्ट पावर कनेक्टर को तैनात किया। पहली नज़र में, यह निर्णय विवादास्पद है। लेकिन वहाँ पेशेवरों रहे हैं। यूएसबी कनेक्टर से पावर वैकल्पिक रूप से मौजूद है (नीचे विवरण), लेकिन यह सर्किट डिबगिंग के लिए एक बुरा विकल्प है, क्योंकि इस मामले में कंप्यूटर के यूएसबी पोर्ट को जलाने से पहले का समय काफी कम हो सकता है।

• मिनी-यूएसबी पोर्ट एक ओर, यह नियंत्रक के यूएसबी-ओटीजी पोर्ट के संरक्षण चिप STF203-22.TCT के माध्यम से जुड़ा हुआ है। दूसरी ओर, VBUS पावर पिन GPIO कनेक्टर से जुड़ा है। यदि आप इसे + 5V पिन से जोड़ते हैं, तो बोर्ड यूएसबी पोर्ट से संचालित होगा।

• कठोरता के साथ माइक्रो-एसडी मेमोरी कार्ड के लिए कनेक्टर: 47 k-पुल-अप रेसिस्टर्स , पावर मैनेजमेंट ट्रांजिस्टर ( P-चैनल MOSFET BSH205 ) और पावर लाइन पर एक छोटा ग्रीन एलईडी।

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

• UDA1334 पर आधारित डिजिटल-से-एनालॉग कनवर्टर। इस चिप को बाहरी घड़ी संकेत की आवश्यकता नहीं है, जो इसके उपयोग की सुविधा देता है। डेटा I2S बस के ऊपर प्रेषित होता है। दूसरी ओर, डेटशीट 47 μF पर 5 ध्रुवीय कैपेसिटर के रूप में उपयोग करने की सिफारिश करती है। इस मामले में आकार महत्वपूर्ण है। सबसे छोटे जो खरीदे गए थे वे 1411 के आकार के साथ टैंटलम हैं, जो सस्ते भी नहीं हैं। हालांकि, मैं कीमत के बारे में और अधिक विस्तार से लिखूंगा। एनालॉग पावर के लिए, अपने स्वयं के रैखिक स्टेबलाइजर का उपयोग किया जाता है, डिजिटल हिस्से की शक्ति को डबल ट्रांजिस्टर द्वारा चालू / बंद किया जाता है।

• दो चैनल एम्पलीफायर दो 31AP2005 चिप्स पर आधारित है। उनका मुख्य लाभ स्ट्रेपिंग घटकों (केवल पावर फिल्टर और एक इनपुट फिल्टर) की एक छोटी संख्या है। ऑडियो आउटपुट - 2.54 मिमी की पिच के साथ 4 प्लेटफ़ॉर्म। खुद के लिए, मैंने अभी तक यह तय नहीं किया है कि सबसे अच्छा क्या है - इस तरह के एक मेकशिफ्ट विकल्प या, जैसे कि रास्पबेरी, एक 3.5 मिमी प्लग। एक नियम के रूप में, 3.5 मिमी हेडफ़ोन के साथ जुड़ा हुआ है, हमारे मामले में हम वक्ताओं को जोड़ने के बारे में बात कर रहे हैं।

• अंतिम मॉड्यूल एक ईएसपी 11 शाल है जिसमें एक वाईफाई मॉडेम के रूप में स्ट्रैपिंग (पावर, प्रोग्रामिंग सॉकेट) है। UART बोर्ड के निष्कर्ष नियंत्रक से जुड़े होते हैं और साथ ही साथ एक बाहरी कनेक्टर (टर्मिनल और प्रोग्रामिंग से सीधे बोर्ड के साथ काम करने के लिए) के लिए आउटपुट होते हैं। एक पावर स्विच (एक माइक्रोकंट्रोलर से स्थायी बाहरी या नियंत्रण) है। बोर्ड को प्रोग्रामिंग मोड में डालने के लिए पावर और "फ्लैश" कनेक्टर को इंगित करने के लिए एक अतिरिक्त एलईडी है।

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

कुछ तस्वीरें:

ESP11 मॉड्यूल तैयार करना

ESP8266 एक प्रसिद्ध चीज है। मुझे यकीन है कि कई लोग पहले से ही इसके बारे में परिचित हैं, इसलिए एक विस्तृत मार्गदर्शिका यहां बहुत ही शानदार होगी। ईएसपी 11 मॉड्यूल को बोर्ड से जोड़ने की योजनाबद्ध विशेषताओं के कारण, मैं केवल उन लोगों के लिए एक संक्षिप्त मार्गदर्शिका दूंगा जो इसे बदलना चाहते हैं:

• मैं ईएसपी के साथ काम करने के लिए एस्पटूल उपयोगिता का उपयोग करूंगा । निर्माता से मानक उपयोगिता के विपरीत, एक्टपुल प्लेटफॉर्म स्वतंत्र है।
• शुरू करने के लिए, ईएसपी-पीडब्लूआर जम्पर (हम निकट संपर्क 1 और 2) के साथ बाहरी पावर मोड चालू करें, और किसी भी यूएसएआरटी-यूएसबी एडाप्टर के माध्यम से कंप्यूटर से मॉड्यूल को कनेक्ट करें। एडाप्टर जीआरडी / आरएक्स / टीडी पिन से जुड़ता है। हम बोर्ड को बिजली की आपूर्ति करते हैं:
  
• हम सुनिश्चित करते हैं कि एडाप्टर ऑपरेटिंग सिस्टम द्वारा मान्यता प्राप्त है। मेरे उदाहरण में, मैं FT232 के आधार पर एक एडाप्टर का उपयोग करता हूं, इसलिए उपकरणों की सूची के साथ इसे FT232 सीरियल (UART) आईसी के रूप में दिखाई देना चाहिए:
  

  > lsusb ... Bus 001 Device 010: ID 0483:3748 STMicroelectronics ST-LINK/V2 Bus 001 Device 009: ID 0403:6001 Future Technology Devices International, Ltd FT232 Serial (UART) IC ... 

• ESP8266 स्वयं फ्लैश मेमोरी की मात्रा में भिन्न होता है। व्यवहार में, एक ही ESP11 मॉड्यूल में, मुझे 512 KB (4 Mbit) और 1 MB (8 Mbit) दोनों का सामना करना पड़ा। तो पहली बात यह जांचना है कि मॉड्यूल के उपयोग किए गए उदाहरण में मेमोरी कितनी है। बोर्ड से बिजली बंद करें, और मॉड्यूल को प्रोग्रामिंग मोड में डालें, जम्पर "फ्लैश" को बंद करें।

• बिजली चालू करें, निम्नलिखित मापदंडों के साथ एस्प्टूल चलाएं

 > esptool.py --port /dev/ttyUSB0 flash_id Connecting.... Detecting chip type... ESP8266 Chip is ESP8266EX Uploading stub... Running stub... Stub running... Manufacturer: e0 Device: 4014 Detected flash size: 1MB Hard resetting... 

• esptool की रिपोर्ट है कि, इस मामले में, हम 1 एमबी मेमोरी वाले मॉड्यूल के साथ काम कर रहे हैं।
• 1 एमबी वाले संस्करण के लिए, आप नवीनतम फर्मवेयर का उपयोग कर सकते हैं, उदाहरण के लिए, ईएसपी 8266 एटी बिन वी 1.6.1 । लेकिन यह 4 Mbit वाले संस्करण के लिए उपयुक्त नहीं है, जिसके लिए आपको कुछ पुराने का उपयोग करने की आवश्यकता है, उदाहरण के लिए यह एक । फर्मवेयर में कई फाइलें होती हैं, प्रत्येक फ़ाइल के शुरुआती पते आधिकारिक दस्तावेज ESP8266 AT निर्देश सेट में इंगित किए जाते हैं । इन प्रारंभ पतों का उपयोग एस्प्टूल उपयोगिता के मापदंडों के रूप में किया जाता है। उदाहरण के लिए, 1 एमबी के साथ एक मॉड्यूल के लिए, एस्कापुल के पैरामीटर इस तरह दिखाई देंगे (सभी आवश्यक फ़ाइलों को पहले फर्मवेयर संग्रह से निकाला जाना चाहिए और कार्य निर्देशिका में एकत्र किया जाना चाहिए)
  

   > esptool.py --port /dev/ttyUSB0 write_flash 0x00000 boot.bin 0x01000 user1.1024.new.2.bin 0x7E000 blank.bin 0xFB000 blank.bin 0xFC000 esp_init_data_default.bin 0xFE000 blank.bin 

• हम बोर्ड को बिजली की आपूर्ति करते हैं, निर्दिष्ट मापदंडों के साथ एस्प्टूल चलाते हैं।
• स्क्रिप्ट को पूरा करने के बाद, बोर्ड से बिजली बंद करें, "फ्लैश" जम्पर खोलें, माइक्रोकंट्रोलर से पावर कंट्रोल चालू करें। मॉड्यूल काम के लिए तैयार है।

सॉफ्टवेयर

जीथब पर एक परीक्षण कार्यक्रम है। वह निम्नलिखित करती है:

• अधिकतम आवृत्ति (168 मेगाहर्ट्ज) पर नियंत्रक प्रदर्शित करता है
• वास्तविक समय घड़ी को सक्रिय करता है
• एसडी कार्ड को सक्रिय करता है और इससे नेटवर्क कॉन्फ़िगरेशन पढ़ता है। फ़ाइल सिस्टम के साथ काम करने के लिए FatFS लाइब्रेरी का उपयोग किया जाता है।
• निर्दिष्ट WLAN के लिए एक कनेक्शन स्थापित करता है
• निर्दिष्ट NTP सर्वर से जुड़ता है और उससे वर्तमान समय का अनुरोध करता है। घड़ी छोड़ देता है।
• कई निर्दिष्ट बंदरगाहों की स्थिति की निगरानी करता है। यदि उनकी स्थिति बदल गई है, तो निर्दिष्ट टीसीपी सर्वर पर एक पाठ संदेश भेजता है।
• जब आप बाहरी बटन पर क्लिक करते हैं, तो यह एसडी कार्ड से निर्दिष्ट * .wav फ़ाइल को पढ़ता है और इसे एसिंक्रोनस मोड (डीएमए नियंत्रक का उपयोग करके I2S) में खेलता है।
• ESP11 के साथ काम को अतुल्यकालिक मोड में भी लागू किया जाता है (अब तक DMA के बिना, केवल व्यवधान पर)
• USART1 (पिन PB6 / PB7) के माध्यम से लॉग इन करें
• और, बेशक, एलईडी झपकी।

Habré पर कई लेख थे जो STM32 को एक निम्न स्तर पर (केवल रजिस्टर प्रबंधन या CMSIS द्वारा) प्रोग्रामिंग के लिए समर्पित थे। उदाहरण के लिए, अपेक्षाकृत अंतिम से: एक , दो , तीन । लेख, निश्चित रूप से, बहुत उच्च गुणवत्ता वाले हैं, लेकिन मेरी व्यक्तिपरक राय यह है कि किसी उत्पाद के एक बार के विकास के लिए, यह दृष्टिकोण, शायद, खुद को सही ठहराता है। लेकिन एक लंबी अवधि के शौक परियोजना के लिए, जब आप चाहते हैं कि सब कुछ सुंदर और एक्स्टेंसिबल हो, तो यह दृष्टिकोण बहुत कम है। Arduino की लोकप्रियता के कारणों में से एक सॉफ्टवेयर प्लेटफ़ॉर्म के रूप में, मेरी राय में, यह है कि Arduino के लेखकों ने ऑब्जेक्ट-ओरिएंटेड आर्किटेक्चर के लिए इतना निम्न स्तर छोड़ा है। इसलिए, मैंने उसी दिशा में जाने का निर्णय लिया और एचएएल लाइब्रेरी के ऊपर एक उच्च स्तरीय वस्तु-उन्मुख परत को जोड़ा।

इस प्रकार, कार्यक्रम के तीन स्तर प्राप्त होते हैं:

• निर्माता लाइब्रेरी (HAL, FatFS, भविष्य के USB-OTG में) आधार बनाते हैं
• मेरी StmPlusPlus लाइब्रेरी इसी आधार पर आधारित है। इसमें बेस कक्षाओं (जैसे सिस्टम, IOPort, IOPin, टाइमर, RealTimeClock, Usart, Spi, I2S) का एक सेट शामिल है, बाहरी उपकरणों के ड्राइवर वर्गों का एक सेट (जैसे SdCard, Esp11, DcfReceiver, Dac_MCP49x1, AudioDac_UDA1334 और जैसे अन्य) एक WAV अतुल्यकालिक खिलाड़ी के रूप में सेवा वर्ग।
• StmPlusPlus लाइब्रेरी के आधार पर, एप्लिकेशन स्वयं बनाया जा रहा है।

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

StmPlusPlus लाइब्रेरी

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

पहला उदाहरण समय-समय पर एक पिन राज्य (उदाहरण के लिए, एक बटन) को मतदान करने और इस राज्य के बदलने पर एक हैंडलर को कॉल करने के लिए एक वर्ग है:

 class Button : IOPin { public: class EventHandler { public: virtual void onButtonPressed (const Button *, uint32_t numOccured) =0; }; Button (PortName name, uint32_t pin, uint32_t pull, const RealTimeClock & _rtc, duration_ms _pressDelay = 50, duration_ms _pressDuration = 300); inline void setHandler (EventHandler * _handler) { handler = _handler; } void periodic (); private: const RealTimeClock & rtc; duration_ms pressDelay, pressDuration; time_ms pressTime; bool currentState; uint32_t numOccured; EventHandler * handler; }; 

निर्माता सभी बटन मापदंडों को परिभाषित करता है:

 Button::Button (PortName name, uint32_t pin, uint32_t pull, const RealTimeClock & _rtc, duration_ms _pressDelay, duration_ms _pressDuration): IOPin{name, pin, GPIO_MODE_INPUT, pull, GPIO_SPEED_LOW}, rtc{_rtc}, pressDelay{_pressDelay}, pressDuration{_pressDuration}, pressTime{INFINITY_TIME}, currentState{false}, numOccured{0}, handler{NULL} { // empty } 

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

 void Button::periodic () { if (handler == NULL) { return; } bool newState = (gpioParameters.Pull == GPIO_PULLUP)? !getBit() : getBit(); if (currentState == newState) { // state is not changed: check for periodical press event if (currentState && pressTime != INFINITY_TIME) { duration_ms d = rtc.getUpTimeMillisec() - pressTime; if (d >= pressDuration) { handler->onButtonPressed(this, numOccured); pressTime = rtc.getUpTimeMillisec(); ++numOccured; } } } else if (!currentState && newState) { pressTime = rtc.getUpTimeMillisec(); numOccured = 0; } else { duration_ms d = rtc.getUpTimeMillisec() - pressTime; if (d < pressDelay) { // nothing to do } else if (numOccured == 0) { handler->onButtonPressed(this, numOccured); } pressTime = INFINITY_TIME; } currentState = newState; } 

इस दृष्टिकोण का मुख्य लाभ अपने प्रसंस्करण से किसी घटना का पता लगाने के लिए तर्क और कोड की विविधता है। यह HAL_GetTick नहीं है जिसका उपयोग गिनती के समय के लिए किया जाता है, जो कि इसके प्रकार (uint32_t) के कारण, प्रत्येक 2 ^ 32 मिलीसेकंड (प्रत्येक 49 दिन) पर अतिप्रवाह द्वारा रीसेट किया जाता है। मैंने अपना स्वयं का वर्ग RealTimeClock लागू किया, जो प्रोग्राम की शुरुआत से मिलीसेकंड की गणना करता है, या uint64_t जैसे नियंत्रक को चालू करता है, जो लगभग 5 ^ 8 वर्ष देता है।

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

 class Spi { public: const uint32_t TIMEOUT = 5000; enum class DeviceName { SPI_1 = 0, SPI_2 = 1, SPI_3 = 2, }; Spi (DeviceName _device, IOPort::PortName sckPort, uint32_t sckPin, IOPort::PortName misoPort, uint32_t misoPin, IOPort::PortName mosiPort, uint32_t mosiPin, uint32_t pull = GPIO_NOPULL); HAL_StatusTypeDef start (uint32_t direction, uint32_t prescaler, uint32_t dataSize = SPI_DATASIZE_8BIT, uint32_t CLKPhase = SPI_PHASE_1EDGE); HAL_StatusTypeDef stop (); inline HAL_StatusTypeDef writeBuffer (uint8_t *pData, uint16_t pSize) { return HAL_SPI_Transmit(hspi, pData, pSize, TIMEOUT); } private: DeviceName device; IOPin sck, miso, mosi; SPI_HandleTypeDef *hspi; SPI_HandleTypeDef spiParams; void enableClock(); void disableClock(); }; 

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

 Spi::Spi (DeviceName _device, IOPort::PortName sckPort, uint32_t sckPin, IOPort::PortName misoPort, uint32_t misoPin, IOPort::PortName mosiPort, uint32_t mosiPin, uint32_t pull): device(_device), sck(sckPort, sckPin, GPIO_MODE_AF_PP, pull, GPIO_SPEED_HIGH, false), miso(misoPort, misoPin, GPIO_MODE_AF_PP, pull, GPIO_SPEED_HIGH, false), mosi(mosiPort, mosiPin, GPIO_MODE_AF_PP, pull, GPIO_SPEED_HIGH, false), hspi(NULL) { switch (device) { case DeviceName::SPI_1: #ifdef SPI1 sck.setAlternate(GPIO_AF5_SPI1); miso.setAlternate(GPIO_AF5_SPI1); mosi.setAlternate(GPIO_AF5_SPI1); spiParams.Instance = SPI1; #endif break; ... case DeviceName::SPI_3: #ifdef SPI3 sck.setAlternate(GPIO_AF6_SPI3); miso.setAlternate(GPIO_AF6_SPI3); mosi.setAlternate(GPIO_AF6_SPI3); spiParams.Instance = SPI3; #endif break; } spiParams.Init.Mode = SPI_MODE_MASTER; spiParams.Init.DataSize = SPI_DATASIZE_8BIT; spiParams.Init.CLKPolarity = SPI_POLARITY_HIGH; spiParams.Init.CLKPhase = SPI_PHASE_1EDGE; spiParams.Init.FirstBit = SPI_FIRSTBIT_MSB; spiParams.Init.TIMode = SPI_TIMODE_DISABLE; spiParams.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE; spiParams.Init.CRCPolynomial = 7; spiParams.Init.NSS = SPI_NSS_SOFT; } 

समान योजना सक्षमकॉल और डिसकॉलक प्रक्रियाओं को लागू करती है, जो अन्य नियंत्रकों के लिए खराब एक्स्टेंसिबल और खराब पोर्टेबल हैं। इस मामले में, उन टेम्प्लेट का उपयोग करना बेहतर होता है जहाँ टेम्पलेट पैरामीटर HAL इंटरफ़ेस नाम (SPI1, SPI2, SPI3), पिन पैरामीटर (GPIO_AF5_SPI1) और कुछ ऐसा होता है जो क्लॉकिंग के चालू / बंद को नियंत्रित करता है। इस विषय पर एक दिलचस्प लेख है, हालांकि यह एवीआर नियंत्रकों की समीक्षा करता है, जो हालांकि, एक मौलिक अंतर नहीं करता है।

स्थानांतरण का प्रारंभ और अंत दो स्टार्ट / स्टॉप विधियों द्वारा नियंत्रित किया जाता है:

 HAL_StatusTypeDef Spi::start (uint32_t direction, uint32_t prescaler, uint32_t dataSize, uint32_t CLKPhase) { hspi = &spiParams; enableClock(); spiParams.Init.Direction = direction; spiParams.Init.BaudRatePrescaler = prescaler; spiParams.Init.DataSize = dataSize; spiParams.Init.CLKPhase = CLKPhase; HAL_StatusTypeDef status = HAL_SPI_Init(hspi); if (status != HAL_OK) { USART_DEBUG("Can not initialize SPI " << (size_t)device << ": " << status); return status; } /* Configure communication direction : 1Line */ if (spiParams.Init.Direction == SPI_DIRECTION_1LINE) { SPI_1LINE_TX(hspi); } /* Check if the SPI is already enabled */ if ((spiParams.Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE) { /* Enable SPI peripheral */ __HAL_SPI_ENABLE(hspi); } USART_DEBUG("Started SPI " << (size_t)device << ": BaudRatePrescaler = " << spiParams.Init.BaudRatePrescaler << ", DataSize = " << spiParams.Init.DataSize << ", CLKPhase = " << spiParams.Init.CLKPhase << ", Status = " << status); return status; } HAL_StatusTypeDef Spi::stop () { USART_DEBUG("Stopping SPI " << (size_t)device); HAL_StatusTypeDef retValue = HAL_SPI_DeInit(&spiParams); disableClock(); hspi = NULL; return retValue; } 

इंटरप्ट का उपयोग करके हार्डवेयर इंटरफ़ेस के साथ काम करें । वर्ग डीएमए नियंत्रक का उपयोग करके एक I2S इंटरफ़ेस लागू करता है। I2S (इंटर-आईसी साउंड) एसपीआई के लिए एक हार्डवेयर-सॉफ़्टवेयर ऐड-ऑन है, जो स्वयं, उदाहरण के लिए, ऑडियो प्रोटोकॉल और बिट दर के आधार पर घड़ी चयन और चैनल नियंत्रण करता है।

इस स्थिति में, I2S वर्ग "पोर्ट" वर्ग से विरासत में मिला है, अर्थात, I2S विशेष गुणों वाला एक बंदरगाह है। कुछ डेटा एचएएल संरचनाओं में संग्रहीत किया जाता है (प्लस सुविधा के लिए, डेटा की मात्रा के लिए शून्य)। कुछ डेटा लिंक द्वारा मुख्य कोड से स्थानांतरित किए जाते हैं (उदाहरण के लिए, irqPrio संरचना)।

 class I2S : public IOPort { public: const IRQn_Type I2S_IRQ = SPI2_IRQn; const IRQn_Type DMA_TX_IRQ = DMA1_Stream4_IRQn; I2S (PortName name, uint32_t pin, const InterruptPriority & prio); HAL_StatusTypeDef start (uint32_t standard, uint32_t audioFreq, uint32_t dataFormat); void stop (); inline HAL_StatusTypeDef transmit (uint16_t * pData, uint16_t size) { return HAL_I2S_Transmit_DMA(&i2s, pData, size); } inline void processI2SInterrupt () { HAL_I2S_IRQHandler(&i2s); } inline void processDmaTxInterrupt () { HAL_DMA_IRQHandler(&i2sDmaTx); } private: I2S_HandleTypeDef i2s; DMA_HandleTypeDef i2sDmaTx; const InterruptPriority & irqPrio; }; 

इसका निर्माता सभी स्थिर पैरामीटर सेट करता है:

 I2S::I2S (PortName name, uint32_t pin, const InterruptPriority & prio): IOPort{name, GPIO_MODE_INPUT, GPIO_NOPULL, GPIO_SPEED_FREQ_LOW, pin, false}, irqPrio{prio} { i2s.Instance = SPI2; i2s.Init.Mode = I2S_MODE_MASTER_TX; i2s.Init.Standard = I2S_STANDARD_PHILIPS; // will be re-defined at communication start i2s.Init.DataFormat = I2S_DATAFORMAT_16B; // will be re-defined at communication start i2s.Init.MCLKOutput = I2S_MCLKOUTPUT_DISABLE; i2s.Init.AudioFreq = I2S_AUDIOFREQ_44K; // will be re-defined at communication start i2s.Init.CPOL = I2S_CPOL_LOW; i2s.Init.ClockSource = I2S_CLOCK_PLL; i2s.Init.FullDuplexMode = I2S_FULLDUPLEXMODE_DISABLE; i2sDmaTx.Instance = DMA1_Stream4; i2sDmaTx.Init.Channel = DMA_CHANNEL_0; i2sDmaTx.Init.Direction = DMA_MEMORY_TO_PERIPH; i2sDmaTx.Init.PeriphInc = DMA_PINC_DISABLE; i2sDmaTx.Init.MemInc = DMA_MINC_ENABLE; i2sDmaTx.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; i2sDmaTx.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; i2sDmaTx.Init.Mode = DMA_NORMAL; i2sDmaTx.Init.Priority = DMA_PRIORITY_LOW; i2sDmaTx.Init.FIFOMode = DMA_FIFOMODE_ENABLE; i2sDmaTx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; i2sDmaTx.Init.MemBurst = DMA_PBURST_SINGLE; i2sDmaTx.Init.PeriphBurst = DMA_PBURST_SINGLE; } 

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

 HAL_StatusTypeDef I2S::start (uint32_t standard, uint32_t audioFreq, uint32_t dataFormat) { i2s.Init.Standard = standard; i2s.Init.AudioFreq = audioFreq; i2s.Init.DataFormat = dataFormat; setMode(GPIO_MODE_AF_PP); setAlternate(GPIO_AF5_SPI2); __HAL_RCC_SPI2_CLK_ENABLE(); HAL_StatusTypeDef status = HAL_I2S_Init(&i2s); if (status != HAL_OK) { USART_DEBUG("Can not start I2S: " << status); return HAL_ERROR; } __HAL_RCC_DMA1_CLK_ENABLE(); __HAL_LINKDMA(&i2s, hdmatx, i2sDmaTx); status = HAL_DMA_Init(&i2sDmaTx); if (status != HAL_OK) { USART_DEBUG("Can not initialize I2S DMA/TX channel: " << status); return HAL_ERROR; } HAL_NVIC_SetPriority(I2S_IRQ, irqPrio.first, irqPrio.second); HAL_NVIC_EnableIRQ(I2S_IRQ); HAL_NVIC_SetPriority(DMA_TX_IRQ, irqPrio.first + 1, irqPrio.second); HAL_NVIC_EnableIRQ(DMA_TX_IRQ); return HAL_OK; } 

स्टॉप प्रक्रिया इसके विपरीत करती है:

 void I2S::stop () { HAL_NVIC_DisableIRQ(I2S_IRQ); HAL_NVIC_DisableIRQ(DMA_TX_IRQ); HAL_DMA_DeInit(&i2sDmaTx); __HAL_RCC_DMA1_CLK_DISABLE(); HAL_I2S_DeInit(&i2s); __HAL_RCC_SPI2_CLK_DISABLE(); setMode(GPIO_MODE_INPUT); } 

यहाँ कई दिलचस्प विशेषताएं हैं:

• इस मामले में प्रयुक्त व्यवधानों को स्थैतिक स्थिरांक के रूप में परिभाषित किया गया है। यह अन्य नियंत्रकों के लिए सुवाह्यता के लिए एक ऋण है।
• कोड का ऐसा संगठन यह सुनिश्चित करता है कि पोर्ट पिन हमेशा GPIO_MODE_INPUT स्थिति में हो जब कोई ट्रांसमिशन न हो। यह एक प्लस है।
• इंटरप्ट की प्राथमिकता को बाहर से स्थानांतरित किया जाता है, अर्थात, मुख्य कोड के एक स्थान पर एक बाधा प्राथमिकता मानचित्र सेट करने का एक अच्छा अवसर है। यह भी एक प्लस है।
• रोक प्रक्रिया DMA1 क्लॉकिंग को अक्षम करती है। इस मामले में, इस सरलीकरण के बहुत नकारात्मक परिणाम हो सकते हैं यदि कोई और व्यक्ति डीएमए 1 का उपयोग करना जारी रखता है। इस तरह के उपकरणों के उपभोक्ताओं का एक केंद्रीकृत रजिस्टर बनाकर समस्या का समाधान किया जाता है, जो कि क्लॉकिंग के लिए जिम्मेदार होगा।
• एक और सरलीकरण - प्रारंभ प्रक्रिया एक त्रुटि के मामले में इंटरफ़ेस को अपनी मूल स्थिति में नहीं लाती है (यह एक ऋण है, लेकिन आसानी से फिक्सिंग है)। उसी समय, त्रुटियों को अधिक विस्तार से लॉग किया जाता है, जो एक प्लस है।
• इस वर्ग का उपयोग करते समय, मुख्य कोड को SPI2_IRQn और DMA1_Stream4_IRQn को बीच में रोकना चाहिए और यह सुनिश्चित करना चाहिए कि संबंधित processI2SInterrupt और processDmaTxInterrupt हैंडलर कहलाते हैं।

मुख्य कार्यक्रम

मुख्य कार्यक्रम को काफी सरलता से वर्णित पुस्तकालय का उपयोग करके लिखा गया है:

 int main (void) { HAL_Init(); IOPort defaultPortA(IOPort::PortName::A, GPIO_MODE_INPUT, GPIO_PULLDOWN); IOPort defaultPortB(IOPort::PortName::B, GPIO_MODE_INPUT, GPIO_PULLDOWN); IOPort defaultPortC(IOPort::PortName::C, GPIO_MODE_INPUT, GPIO_PULLDOWN); // System frequency 168MHz System::ClockDiv clkDiv; clkDiv.PLLM = 16; clkDiv.PLLN = 336; clkDiv.PLLP = 2; clkDiv.PLLQ = 7; clkDiv.AHBCLKDivider = RCC_SYSCLK_DIV1; clkDiv.APB1CLKDivider = RCC_HCLK_DIV8; clkDiv.APB2CLKDivider = RCC_HCLK_DIV8; clkDiv.PLLI2SN = 192; clkDiv.PLLI2SR = 2; do { System::setClock(clkDiv, FLASH_LATENCY_3, System::RtcType::RTC_EXT); } while (System::getMcuFreq() != 168000000L); MyApplication app; appPtr = &app; app.run(); } 

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

एक अलग अनुभाग में, हमें उपयोग किए जाने वाले सभी व्यवधानों को परिभाषित करना चाहिए। चूँकि हम C ++ में लिखते हैं, और व्यवधान C की दुनिया की चीजें हैं, हमें उनके अनुसार मास्क लगाना होगा:

 extern "C" { void SysTick_Handler (void) { HAL_IncTick(); if (appPtr != NULL) { appPtr->getRtc().onMilliSecondInterrupt(); } } void DMA2_Stream3_IRQHandler (void) { Devices::SdCard::getInstance()->processDmaRxInterrupt(); } void DMA2_Stream6_IRQHandler (void) { Devices::SdCard::getInstance()->processDmaTxInterrupt(); } void SDIO_IRQHandler (void) { Devices::SdCard::getInstance()->processSdIOInterrupt(); } void SPI2_IRQHandler(void) { appPtr->getI2S().processI2SInterrupt(); } void DMA1_Stream4_IRQHandler(void) { appPtr->getI2S().processDmaTxInterrupt(); } void HAL_I2S_TxCpltCallback(I2S_HandleTypeDef *channel) { appPtr->processDmaTxCpltCallback(channel); } ... } 

MyApplication वर्ग इन सभी उपकरणों के लिए सभी उपयोग किए गए उपकरणों, कॉल कंस्ट्रक्टरों की घोषणा करता है, और आवश्यक ईवेंट हैंडलर भी लागू करता है:

 class MyApplication : public RealTimeClock::EventHandler, class MyApplication : public RealTimeClock::EventHandler, WavStreamer::EventHandler, Devices::Button::EventHandler { public: static const size_t INPUT_PINS = 8; // Number of monitored input pins private: UsartLogger log; RealTimeClock rtc; IOPin ledGreen, ledBlue, ledRed; PeriodicalEvent heartbeatEvent; IOPin mco; // Interrupt priorities InterruptPriority irqPrioI2S; InterruptPriority irqPrioEsp; InterruptPriority irqPrioSd; InterruptPriority irqPrioRtc; // SD card IOPin pinSdPower, pinSdDetect; IOPort portSd1, portSd2; SdCard sdCard; bool sdCardInserted; // Configuration Config config; // ESP Esp11 esp; EspSender espSender; // Input pins std::array<IOPin, INPUT_PINS> pins; std::array<bool, INPUT_PINS> pinsState; // I2S2 Audio I2S i2s; AudioDac_UDA1334 audioDac; WavStreamer streamer; Devices::Button playButton; ... 

यही है, वास्तव में, सभी उपयोग किए गए उपकरणों को सांख्यिकीय रूप से घोषित किया जाता है, जो संभावित रूप से प्रयुक्त मेमोरी में वृद्धि की ओर जाता है, लेकिन डेटा तक पहुंच को बहुत सरल करता है। MyApplication वर्ग के निर्माता में, सभी उपकरणों के डिजाइनरों को कॉल करना आवश्यक है, जिसके बाद, जब तक रन प्रक्रिया शुरू हो जाती है, तब तक सभी उपयोग किए गए माइक्रोकंट्रोलर उपकरणों को प्रारंभिक किया जाएगा:

  MyApplication::MyApplication () : // logging log(Usart::USART_1, IOPort::B, GPIO_PIN_6, GPIO_PIN_7, 115200), // RTC rtc(), ledGreen(IOPort::C, GPIO_PIN_1, GPIO_MODE_OUTPUT_PP), ledBlue(IOPort::C, GPIO_PIN_2, GPIO_MODE_OUTPUT_PP), ledRed(IOPort::C, GPIO_PIN_3, GPIO_MODE_OUTPUT_PP), heartbeatEvent(rtc, 10, 2), mco(IOPort::A, GPIO_PIN_8, GPIO_MODE_AF_PP), // Interrupt priorities irqPrioI2S(6, 0), // I2S DMA interrupt priority: 7 will be also used irqPrioEsp(5, 0), irqPrioSd(3, 0), // SD DMA interrupt priority: 4 will be also used irqPrioRtc(2, 0), // SD card pinSdPower(IOPort::A, GPIO_PIN_15, GPIO_MODE_OUTPUT_PP, GPIO_PULLDOWN, GPIO_SPEED_HIGH, true, false), pinSdDetect(IOPort::B, GPIO_PIN_3, GPIO_MODE_INPUT, GPIO_PULLUP), portSd1(IOPort::C, /* mode = */GPIO_MODE_OUTPUT_PP, /* pull = */GPIO_PULLUP, /* speed = */GPIO_SPEED_FREQ_VERY_HIGH, /* pin = */GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12, /* callInit = */false), portSd2(IOPort::D, /* mode = */GPIO_MODE_OUTPUT_PP, /* pull = */GPIO_PULLUP, /* speed = */GPIO_SPEED_FREQ_VERY_HIGH, /* pin = */GPIO_PIN_2, /* callInit = */false), sdCard(pinSdDetect, portSd1, portSd2), sdCardInserted(false), // Configuration config(pinSdPower, sdCard, "conf.txt"), //ESP esp(rtc, Usart::USART_2, IOPort::A, GPIO_PIN_2, GPIO_PIN_3, irqPrioEsp, IOPort::A, GPIO_PIN_1), espSender(rtc, esp, ledRed), // Input pins pins { { IOPin(IOPort::A, GPIO_PIN_4, GPIO_MODE_INPUT, GPIO_PULLUP), IOPin(IOPort::A, GPIO_PIN_5, GPIO_MODE_INPUT, GPIO_PULLUP), IOPin(IOPort::A, GPIO_PIN_6, GPIO_MODE_INPUT, GPIO_PULLUP), IOPin(IOPort::A, GPIO_PIN_7, GPIO_MODE_INPUT, GPIO_PULLUP), IOPin(IOPort::C, GPIO_PIN_4, GPIO_MODE_INPUT, GPIO_PULLUP), IOPin(IOPort::C, GPIO_PIN_5, GPIO_MODE_INPUT, GPIO_PULLUP), IOPin(IOPort::B, GPIO_PIN_0, GPIO_MODE_INPUT, GPIO_PULLUP), IOPin(IOPort::B, GPIO_PIN_1, GPIO_MODE_INPUT, GPIO_PULLUP) } }, // I2S2 Audio Configuration // PB10 --> I2S2_CK // PB12 --> I2S2_WS // PB15 --> I2S2_SD i2s(IOPort::B, GPIO_PIN_10 | GPIO_PIN_12 | GPIO_PIN_15, irqPrioI2S), audioDac(i2s, /* power = */ IOPort::B, GPIO_PIN_11, /* mute = */ IOPort::B, GPIO_PIN_13, /* smplFreq = */ IOPort::B, GPIO_PIN_14), streamer(sdCard, audioDac), playButton(IOPort::B, GPIO_PIN_2, GPIO_PULLUP, rtc) { mco.activateClockOutput(RCC_MCO1SOURCE_PLLCLK, RCC_MCODIV_5); } 

एक उदाहरण के रूप में, एक बटन पर क्लिक करने के लिए ईवेंट हैंडलर जो WAV फ़ाइल खेलना शुरू / बंद करता है:

  virtual void MyApplication::onButtonPressed (const Devices::Button * b, uint32_t numOccured) { if (b == &playButton) { USART_DEBUG("play button pressed: " << numOccured); if (streamer.isActive()) { USART_DEBUG(" Stopping WAV"); streamer.stop(); } else { USART_DEBUG(" Starting WAV"); streamer.start(AudioDac_UDA1334::SourceType:: STREAM, config.getWavFile()); } } } 

और अंत में, मुख्य रन विधि उपकरणों के कॉन्फ़िगरेशन को पूरा करती है (उदाहरण के लिए, एक घटना हैंडलर के रूप में MyApplication सेट करता है), और एक अंतहीन लूप शुरू करता है, जहां यह समय-समय पर उन उपकरणों को संदर्भित करता है जिन्हें समय-समय पर ध्यान देने की आवश्यकता होती है:

 void MyApplication::run () { log.initInstance(); USART_DEBUG("Oscillator frequency: " << System::getExternalOscillatorFreq() << ", MCU frequency: " << System::getMcuFreq()); HAL_StatusTypeDef status = HAL_TIMEOUT; do { status = rtc.start(8 * 2047 + 7, RTC_WAKEUPCLOCK_RTCCLK_DIV2, irqPrioRtc, this); USART_DEBUG("RTC start status: " << status); } while (status != HAL_OK); sdCard.setIrqPrio(irqPrioSd); sdCard.initInstance(); if (sdCard.isCardInserted()) { updateSdCardState(); } USART_DEBUG("Input pins: " << pins.size()); pinsState.fill(true); USART_DEBUG("Pin state: " << fillMessage()); esp.assignSendLed(&ledGreen); streamer.stop(); streamer.setHandler(this); streamer.setVolume(1.0); playButton.setHandler(this); bool reportState = false; while (true) { updateSdCardState(); playButton.periodic(); streamer.periodic(); if (isInputPinsChanged()) { USART_DEBUG("Input pins change detected"); ledBlue.putBit(true); reportState = true; } espSender.periodic(); if (espSender.isOutputMessageSent()) { if (reportState) { espSender.sendMessage(config, "TCP", config.getServerIp(), config.getServerPort(), fillMessage()); reportState = false; } if (!reportState) { ledBlue.putBit(false); } } if (heartbeatEvent.isOccured()) { ledGreen.putBit(heartbeatEvent.occurance() == 1); } } } 

थोड़ा सा प्रयोग

— . — 168 MHz. , , 172 MHz 180 MHz, , , MCO. , USART I2S, , , HAL.

. github . - , Mouser ( ). 37 . . , STM Olimex, .

. , :

• ( ). , , . : 4 8 . PLL, .
• , . 47 μF . , .
• SWD . - , . .
• . SMD , . 3 .

प्रलेखन

github GPL v3:

आपका ध्यान के लिए धन्यवाद!