🙄 🔫 🧛🏽 ESP8266 भाग एक के माध्यम से वाईफ़ाई के माध्यम से ARDUINO के साथ प्रोग्रामिंग और डेटा विनिमय 💇🏾 😯 👩🏿‍🤝‍👨🏾

कई अन्य होममेड उत्पादों की तरह, मैं नियमित रूप से सभी प्रकार के शौकिया शिल्प के लिए AVR माइक्रोकंट्रोलर का उपयोग करता हूं। और Arduino अवधारणा के लिए धन्यवाद, ये हस्तशिल्प अब एक सुरुचिपूर्ण रूप भी लेते हैं। वास्तव में, कुछ 300-400 रूबल के लिए, हमें एक मुखौटा, सिल्क्सस्क्रीन के साथ एक लघु बहु-परत बोर्ड मिलता है और माइक्रोकंट्रोलर के लिए बाह्य उपकरणों के साथ पूरी तरह से उस पर तलाक दिया जाता है (इसके अलावा, एसएमडी संस्करण में!)। मैं एक ही "Arduino" श्रृंखला के सभी प्रकार के प्लग-इन के बारे में बात नहीं कर रहा हूं: सेंसर, नियंत्रक, डिस्प्ले और पूरे सेट, अतिरिक्त बाह्य उपकरणों की हमें बहुत आवश्यकता है। और फिर, सब कुछ सस्ता और उत्कृष्ट प्रदर्शन में भी है। वस्तुतः अब "घुटने" पर कुछ और मिलाप करने की आवश्यकता नहीं है।

लेकिन इन सभी विभिन्न शौकिया शिल्पों को स्वाभाविक रूप से प्रारंभिक प्रोग्रामिंग की आवश्यकता होती है। और बाद में, विभिन्न सुधारों के साथ, मुझे लगातार इन शिल्पों को फिर से भरना है। यह स्पष्ट है कि नियमित रूप से प्रोग्रामर के पास उन्हें खींचने की तुलना में इस रिमोट को करना अधिक सुविधाजनक है। सामान्य तौर पर, एक ही Arduino प्लेटफॉर्म के लिए धन्यवाद, यहां कई विकल्प हैं: ब्लूटूथ, ZigBee, आपके व्यक्तिगत प्रोटोकॉल, IR और यहां तक कि वाई-फाई के साथ एक रेडियो चैनल। वे सभी आपको अपने माइक्रोकंट्रोलर के साथ वायरलेस संपर्क स्थापित करने की अनुमति देते हैं। लेकिन हम आखिरी विकल्प पर रुकेंगे। इसके चार मुख्य कारण हैं:

1: आधुनिक, चीजों का इंटरनेट!

2: हर अपार्टमेंट में एक वायरलेस राउटर है, अपने डिवाइस को होम नेटवर्क और वॉइला में रजिस्टर करें!

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

4: ESP8266 चिप्स की एक अद्भुत श्रृंखला है, जिस पर यह सब लागू करना ~~बहुत~~ आसान ~~नहीं है~~ ।

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

यह माना जाता है कि पाठक पहले से ही Arduino मॉड्यूल (शील्ड) और ESP2626 के कनेक्शन और फर्मवेयर दोनों से परिचित है। वास्तव में, इन उपकरणों के साथ काम करने की मूल बातें बताते हुए वेब पर भारी मात्रा में सामग्री पोस्ट की गई है और मैं यहां दोहराना नहीं चाहूंगा। शुरुआती लोगों के लिए, लेख के अंत में इन मुद्दों पर उपयोगी लिंक की एक सूची है, जहां आप बहुत सारी जानकारी पा सकते हैं ~~, यह आपके लिए काम क्यों नहीं करता है~~ । एक पूर्व इलेक्ट्रॉनिक्स इंजीनियर के रूप में अपने अनुभव से, मैं जिम्मेदारी से घोषणा कर सकता हूं कि 99% समस्याएं इस प्रकार हैं:

1. खराब संपर्क। चूंकि "Arduino" ढाल एक दूसरे के साथ "पिता-माता" प्रकार के तारों के माध्यम से स्विचिंग करता है, और टांका लगाने के माध्यम से नहीं, बहुत बार कुछ, कहीं, कहीं दूर चला जाता है। इसे देखें। और वास्तव में, जैसा कि वे कहते हैं, इलेक्ट्रॉनिक्स संपर्कों का विज्ञान है।

2. बिजली की समस्या। 5 वोल्ट बिजली की आपूर्ति न करें जहां 3.3 की आवश्यकता होती है। कभी-कभी ईएसपी 8266 से धुआं निकलता है। हालांकि, दूसरी ओर, यह समस्याओं के बिना पाँच-वोल्ट डिवाइस से तार्किक संकेतों को पचाता है।

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

4. निष्कर्ष के साथ भ्रम। हमेशा जांचें कि कौन से सिग्नल कहां जाते हैं। RXD रिसीवर को TXD ट्रांसमीटर के साथ-साथ TXD से RXD से कनेक्ट करना होगा, लेकिन MOSI को MOSI, और MISO से MISO, और इसी तरह कनेक्ट करना होगा।

5. ESP8266 में इन-सर्किट पुल-अप प्रतिरोधों पर भरोसा न करें, हमेशा 5-10 किलो-ओम बाहरी प्रतिरोधों के माध्यम से शून्य या बिजली की ओर जाता है, और न केवल एक जम्पर। अन्यथा, आप कर सकते हैं, सबसे अच्छा, एक अभूतपूर्व वर्तमान खपत प्राप्त करें, और फिर जलाए गए प्लास्टिक की अप्रिय गंध को गंध करें।

सॉफ्टवेयर के 6. Shoals। चूंकि अलग-अलग उपयोगकर्ताओं के लिए सॉफ़्टवेयर समान उत्साही लोगों द्वारा लिखे गए हैं, फर्मवेयर से स्वयं ग्लिट्स और बग्स समय-समय पर उसी फर्मवेयर के संस्करणों को अपडेट करते समय पॉप आउट होते हैं। इसका उपचार प्रासंगिक मंचों पर किया जाता है, कभी-कभी अंग्रेजी में भी। कुछ साथियों ने यह भी दावा किया कि ईएसपी चिप खुद सेंट पीटर्सबर्ग में मौसम की तरह नम था, लेकिन दूसरी ओर यह भी राय है कि 2014 (जिस साल यह पहली बार जारी किया गया था) के बाद से, इस स्थिति में नाटकीय रूप से सुधार हुआ है (मौसम के विपरीत)।

7. रहस्यमय glitches। यह एक दुर्लभ, लेकिन तंत्रिका-खपत घटना है। उदाहरण के लिए, मेरे पास एक दूरस्थ "Arduino" उपकरण नहीं है। बल्कि, ऐसा हुआ लेकिन त्रुटियों के साथ। लेकिन यह त्रुटियों के बिना चला गया अगर प्रोग्रामर की एक केबल उस पर लटका दी गई (लेकिन प्रोग्रामर के बिना ही)। "अहा," मैंने खुद को बताया, और डेटा ट्रांसफर पिन और सिंक पिन के बीच 15 पीएफ संधारित्र मिलाया। सब कुछ काम कर गया। लेकिन दिन को मार डाला।

तो, चलो सबसे सरल से शुरू करते हैं। हमारे पास चीन में बना एक यांत्रिक अंग है MechArm (लेकिन ऐसा नहीं है कि हावर्ड वॉलोविट इकट्ठे हों) और विंडोज के साथ एक व्यक्तिगत कंप्यूटर। कार्य प्रोग्राम को दूरस्थ रूप से फ्लैश करना और इसे कंप्यूटर से प्रबंधित करना है।

नियंत्रण नियंत्रक के लिए, हम ATmega328P पत्थर के साथ एक प्यारा लघु Arduino नैनो दुपट्टा लेते हैं। यह बोर्ड पूरी तरह से मैकेनिकल आर्म में धकेल दिया जाता है।

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

सबसे आसान विकल्प बिल्ट-इन बूट लोडर (बूटलोडर) है। यह FLASH में एक मेमोरी प्रीसेट है, एक प्रोग्राम जो एक निश्चित प्रोटोकॉल के अनुसार एक कोड प्राप्त करता है (उदाहरण के लिए, सबसे सरल UART का उपयोग करके) और इसे विशेष कमांड के साथ लोड किए गए प्रोग्राम के स्थान पर लिखता है। यह काम करता है, उदाहरण के लिए, बूटलोडर ARDUINO IDE। रीसेट या प्रारंभ के बाद, बूटलोडर डेटा प्राप्त करने के लिए कुछ समय इंतजार करता है और अगर यह इंतजार नहीं करता है, तो यह शून्य पते से प्रोग्राम का निष्पादन शुरू करता है। यदि डेटा आता है, तो वह इसे प्रोग्राम सेक्शन में लिखता है। अगले रीसेट के बाद, डाउनलोड किया गया प्रोग्राम चलना शुरू हो जाता है। विस्तार से, शायद मैंने गलत तरीके से वर्णन किया है, लेकिन सार बस यही है। परिणामस्वरूप, हमें प्रोग्रामिंग के लिए केवल तीन आउटपुट चाहिए: आरटीडी रिसीवर, रीसेट रीसेट और जीएनडी ग्राउंड। सामान्य तौर पर, टीआरडी ट्रांसमीटर का उपयोग रिकॉर्ड किए गए कार्यक्रम को सत्यापित करने के लिए भी किया जाता है, लेकिन सरल प्रदर्शन अनुप्रयोगों (परमाणु ऊर्जा संयंत्र के लिए नहीं) के लिए, सत्यापन को छोड़ा जा सकता है।

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

दूसरा विकल्प सीरियल SPI इंटरफ़ेस के माध्यम से प्रोग्रामिंग है। यहां कोई आंतरिक बूटलोडर नहीं है, लेकिन हम उपरोक्त इंटरफ़ेस के माध्यम से विशेष कमांड और फिर डेटा भेजकर प्रोग्राम करते हैं। यहां हमारे पास एक बाहरी बूटलोडर है, लेकिन आपको अभी भी इसे लिखना होगा। RESET और GND के अलावा, चार अतिरिक्त MOSI आउटपुट ट्रांसमिशन, MISO - डेटा, SLK सिंक्रोनाइज़ेशन, CS - चिप चयन के लिए उपयोग किए जाते हैं। लेकिन सामान्य तौर पर, आप MISO और CS को भी हटा सकते हैं। डेटा केवल स्वीकार किया जाएगा (तब कार्यक्रम का कोई सत्यापन नहीं होगा), और हमारे पास केवल एक क्रिस्टल है।

प्रत्येक दृष्टिकोण के अपने पेशेवरों और विपक्ष हैं (और मैंने JTAG पर बिल्कुल भी विचार नहीं किया, क्योंकि मानव जीवन छोटा है)। लेकिन अंत में, मैं एसपीआई की ओर झुक गया क्योंकि मैं असेंबलर में लिखने के लिए बहुत आलसी था, लेकिन मुझे खुले तैयार बूटलोडर्स नहीं मिले (मैं इसे अच्छी तरह से नहीं देखता था)।

एक वायरलेस चैनल बनाने के लिए, जैसा कि मैंने पहले ही कहा था, मैंने वर्तमान में व्यापक रूप से ज्ञात चिप ESP8266 - एक माइक्रोकंट्रोलर, या बल्कि वाई-फाई इंटरफ़ेस के साथ चीनी निर्माता एस्प्रेसिफ के पूरे SoC (सिस्टम-ऑन-चिप) को चुना। वाई-फाई के अलावा, यह बाहरी फ्लैश मेमोरी से कार्यक्रमों को निष्पादित करने की क्षमता से प्रतिष्ठित है। और विशेष रूप से मेरी परियोजना के लिए, मैंने बोर्ड पर 512 KB मेमोरी के साथ ESP8266-07 लिया।

सामान्य तौर पर, कोई भी ईएसपी 8266 उपयुक्त है जहां एसपीआई को लागू करने के लिए अतिरिक्त पैर हैं। इसलिए, सबसे सरल ESP8266-01 हमें सूट नहीं करता है, क्योंकि इसमें इनपुट / आउटपुट पोर्ट के लिए बहुत कम पैर हैं। लेकिन दूसरी ओर, कीमत में अंतर एक सौ रूबल से कम है, और वे समान रूप से उपलब्ध हैं। खैर, ईएसपी के साथ बड़े डिबग बोर्ड, जहां बाह्य उपकरणों का एक गुच्छा सुविधा के लिए है, हमारे लिए भी उपयुक्त नहीं हैं, क्योंकि वे उस जगह पर नहीं आते हैं जहां हम उन्हें अपने यांत्रिक हाथ में धकेलना चाहते हैं।

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

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

हम किस सॉफ्टवेयर का उपयोग करेंगे:

पीसी के लिए, मैंने JAVA, IntelliJ IDEA में सब कुछ लिखा। लेकिन मूल रूप से, आप कुछ भी कर सकते हैं, हमारे लिए मुख्य बात एक ग्राहक लिखना है जो एवीआर को चमकाने के लिए कार्यक्रम को ESP8266 पर भेजेगा।

मैं स्वयं एवीआर के लिए ATMEL स्टूडियो , सी भाषा में, शायद ही कभी असेंबलर में कार्यक्रम लिखता हूं। मैं सिद्धांत रूप में Arduino स्केच का उपयोग नहीं करता हूं, लगभग किसी भी आवश्यक पुस्तकालय को उसके काम की पूरी समझ के साथ एक या दो घंटे में लिखा जाता है। मैंने रेखाचित्रों की कोशिश की, लेकिन जब तक आपके पास AVR पर एक ऑपरेटिंग सिस्टम नहीं है, रेखाचित्र एक दोस्त से बाह्य उपकरणों को दूर कर देगा और नियमित रूप से विफल रहेगा। हां, ATMEL STUDIO की तुलना में खुद Arduino IDE, एक बहुत ही आदिम चीज है। लेकिन यहां सवाल यह है कि निश्चित रूप से, मानविकी और स्कूली बच्चों के लिए विवादास्पद, यह अधिक मजेदार और आसान होगा, शायद, स्केच के साथ।

ESP8266 प्रोग्रामिंग के लिए, मैंने NodeMCU फर्मवेयर का उपयोग किया, और मैंने लुआ में कार्यक्रम लिखा। नहीं, मुझे जावा और सी में लिखना अच्छा लगेगा, लेकिन ईएसपी में कोई नहीं हैं। हमारे काम पर लागू होने वाली लू भाषा कठिन नहीं है, एक-दो तुच्छताओं में महारत हासिल करना। और वास्तव में, प्रोग्राम डाउनलोड करने और उन्हें ईएसपी पर डीबग करने के लिए, मैंने आईडीई ईएसप्लोरर लिया। एक नि: शुल्क घरेलू उत्पाद (लेकिन आप इसे लेखक को दान कर सकते हैं), जो कि उपर्युक्त मीडिया के साथ तुलना नहीं किया जा सकता है, लेकिन जैसा कि उपहार घोड़ा कहता है ... लेकिन ईएसप्लोरर का उपयोग करने और एलयूए पर लिखने के लिए, हमें सबसे पहले ईएसपी 8266 चिप में बेस फर्मवेयर (निर्माता से आपूर्ति की गई) को बदलने की आवश्यकता है। नया वाला। NODE MCU PyFlasher कार्यक्रम इस उपक्रम में हमारी मदद करेगा। मेरा मतलब है, इसे फिर से भरने में मदद मिलेगी। और हम स्वयं फर्मवेयर बनाएंगे और इसे रचनाकारों की वेबसाइट के हाथों में प्राप्त करेंगे: NodeMCU । और आप इस प्रक्रिया के बारे में अधिक पढ़ सकते हैं :

सब कुछ बहुत सुलभ और समझ में आता है। हम आधार पुस्तकालयों में एसपीआई समर्थन और बिट संचालन जोड़ते हैं (एलयूए में, हमारे मामले में, बिट संचालन अतिभारित हैं और उनसे बेकार हैं)। आपको फ़र्मवेयर में बहुत सारे पुस्तकालयों को बंद नहीं करना चाहिए, क्योंकि ESP8266 पर किसी भी विभिन्न सॉफ़्टवेयर की उपस्थिति के कारण बहुत कम मेमोरी बची है, किसी प्रकार का दयनीय 20 kB।

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

कौन फर्मवेयर बनाने के लिए बहुत आलसी है, आप बादल से मेरा डाउनलोड कर सकते हैं।

अब हमारे पास फर्मवेयर है और हमें बेस एक के बजाय इसे ESP8266 में लोड करना होगा। ऐसा करने के लिए, हमें एक सरल यूएसबी एडाप्टर - UART की आवश्यकता है।

हम TXD पैरों को RXD से जोड़ते हैं, और RXD को TXD से जोड़ते हैं, हम आम जमीन बनाते हैं, लेकिन उपयोग नहीं करते हैं, जैसा कि लग रहा था, एडेप्टर पर एक सुविधाजनक 3.3 V पावर आउटपुट। ज्यादातर मामलों में, ESP8266 इसे पूरी तरह से सूखा देगा। इसलिए, हम इसे अलग से खिलाते हैं। फिर हमने ईएसपी को प्रोग्रामिंग मोड (जमीन पर GP0, अगर कोई भी भूल गया) में डाल दिया और NODE MCU PyFlasher चलाएं ।

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

आवश्यक फर्मवेयर प्राप्त करने के बाद, हम अब NODE MCU से बहुत सुविधाजनक API का उपयोग करते हुए LUA प्रोग्राम लिख सकते हैं और (इसमें माइक्रोप्रियन भी है, लेकिन मैंने इसका उपयोग नहीं किया है)। हम पहले से ही उल्लेख किए गए ईएसप्लोरर को लॉन्च करते हैं।

हम इसे ESP8266 के साथ काम करने के लिए कॉन्फ़िगर करते हैं, सीरियल कनेक्शन के मापदंडों को सेट करते हैं। इंटरनेट पर सब कुछ काफी सरल और बार-बार कहा गया है।

अब हम LUA पर प्रोग्राम लिखते हैं, जिसे हम फिर ESP8266 पर अपलोड करते हैं:

AVR के लिए Lua बूटलोडर ESP8266 को लिखा गया

<b>function InstrProgrammingEnable () -- instruction for MC "enable programming"</b> p=0 while p<31 do p=p+1 pin=8 gpio.write(pin, gpio.LOW) spi.send(1, 0xAC,0x53) read = spi.recv( 1, 8) spi.send(1,0,0) gpio.write(pin, gpio.HIGH) if (string.byte(read)== 83) then print("connection established") p=33 if(p==31) then print("no connection") end end end end <b>function ProgrammingDisable ()</b> pin=2--END OF ESET FOR MK gpio.mode(pin, gpio.INPUT) pin=8 gpio.mode(pin, gpio.INPUT) pin=5--CLK MASTER for SPI gpio.mode(pin, gpio.INPUT) pin=6--MISO MASTER for SPI gpio.mode(pin, gpio.INPUT) pin=7--MOSI MASTER for SPI gpio.mode(pin, gpio.INPUT) end <b>function ProgrammingEnable ()</b> pin=2-- RESET FOR MK gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.LOW) pin=2--POZITIV FOR 4MSEC RESET FOR MK gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.HIGH) tmr.delay(4) gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.LOW) tmr.delay(25000) end <b>function InstrFlashErase() </b> pin=8 gpio.write(pin, gpio.LOW) spi.send(1,0xAC,0x80,0,0) gpio.write(pin, gpio.HIGH) tmr.delay(15000) pin=2--RESET FOR MK gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.HIGH) tmr.delay(20000) gpio.write(pin, gpio.LOW) print( "FLASH is erased") InstrProgrammingEnable () end <b>function InstrStorePAGE(H, address, data)</b> pin=8 gpio.write(pin, gpio.LOW) spi.send(1,H,0,address,data) gpio.write(pin, gpio.HIGH) tmr.delay(500) end <b>function InstrWriteFLASH(page_address_low,page_address_high)</b> pin=8 gpio.write(pin, gpio.LOW) spi.send(1,0x4C,page_address_high,page_address_low,0) gpio.write(pin, gpio.HIGH) tmr.delay(5000)--        end <b>function Programming (payload)</b> pin=8--CS MASTER for SPI gpio.mode(pin, gpio.OUTPUT, gpio.PULLUP) pin=4--LED LIGHTS ON LOW gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.LOW) print(string.len(payload)) page_count = 7 --  1  for k =0 ,page_count ,1 do--quantity of pages for i=0 , 127, 2 do-- -1 address = i/2 data=payload:byte(i+1+128*k) if data == nil then data = 0xff end InstrStorePAGE(0x40,address,data) -- tmr.delay(100)-- otherwise not in time write data =payload:byte(i+1+1+128*k) if data == nil then data = 0xff end InstrStorePAGE(0x48,address,data) -- tmr.delay(100) end page_address_low=bit.band(k ,3)*64 -- 3   11 page_address_high=k/4+frame1024*2 tmr.delay(1000) InstrWriteFLASH(page_address_low,page_address_high) tmr.wdclr() end pin=4--LED gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.HIGH) end <b>--MAIN BLOCK</b> wifi.setmode(wifi.STATION) --wifi.sta.config(" ","") -- set SSID and password of your access point station_cfg={} tmr.delay(30000) station_cfg.ssid=" " tmr.delay(30000) station_cfg.pwd="" tmr.delay(30000) wifi.sta.config(station_cfg) tmr.delay(30000) wifi.sta.connect() tmr.delay(1000000) print(wifi.sta.status()) print(wifi.sta.getip()) while ( wifi.sta.status()~=1 ) do if( wifi.sta.status()==5) then break end end sv=net.createServer(net.TCP,30) tmr.delay(100) print("SERVER READY") sv:listen(4000,function(c) c:on("receive", function(c, payload) print(payload) if (payload =="program\r\n") then c:send("ready\r\n") print("ready for program\r\n") spi.setup(1, spi.MASTER, spi.CPOL_LOW, spi.CPHA_LOW, spi.DATABITS_8,320,spi.FULLDUPLEX) ProgrammingEnable () tmr.delay(100) InstrProgrammingEnable () tmr.delay(100) InstrFlashErase() tmr.delay(100) frame1024=0--    st=net.createServer(net.TCP,30) st:listen(4001,function(c) c:on("receive", function(c, payload) tmr.wdclr() Programming (payload) frame1024=frame1024+1 end) end) end if (payload =="data\r\n") then c:send("ready\r\n") print("ready for data\r\n") srv=net.createServer(net.UDP) tmr.delay(1000) pin=10 gpio.write(pin, gpio.HIGH) uart.setup(0,9600,8,0,1,0) srv:listen(5000) srv:on("receive", function(srv, pl) pl=pl*1 --print(pl) uart.write(0,pl) tmr.wdclr() end) end if (payload =="stop\r\n") then if(st~=nil) then st:close() frame1024=0 ProgrammingDisable () print("stop program") end if(srv~=nil) then srv:close() print("stop data") end end end) end) end)

जहां संबंधित कार्य निम्नलिखित क्रियाएं करते हैं:

फ़ंक्शन InstrProgrammingEnable () - SPI के माध्यम से भेजे गए विशेष कमांड के साथ प्रोग्रामिंग मोड में माइक्रोकंट्रोलर डालता है।

समारोह प्रोग्रामिंग () - प्रोग्रामिंग शुरू करने से पहले सिर्फ 25 एमएस के लिए AVR रीसेट करें

function ProgrammingDisable () - प्रोग्रामिंग की समाप्ति के बाद, हम ESP8266 में SPI आउटपुट को निष्क्रिय अवस्था में ट्रांसलेट करते हैं ताकि वे माइक्रोकंट्रोलर पर कोड निष्पादित करते समय हमारे साथ हस्तक्षेप न करें (अचानक वे वहां उपयोग किए जाते हैं)

फ़ंक्शन InstrFlashErase () - हम प्रोग्रामिंग से पहले माइक्रोकंट्रोलर पर फ्लैश मेमोरी मिटाते हैं । यह क्यों समझाया जाना आवश्यक नहीं है।

फ़ंक्शन InstrStorePAGE (H, पता, डेटा) - यह कमांड प्रोग्राम के बाइट को माइक्रोकंट्रोलर के आंतरिक बफर में लिखता है। लेकिन यह फ्लैश रिकॉर्ड खुद नहीं है, क्योंकि फ्लैश यहां पेज द्वारा पेज पर 128 बाइट्स में लिखा गया है।

फ़ंक्शन InstrWriteFLASH (page_address_low, page_address_high) - लेकिन यह एक फ्लैश रिकॉर्ड है और इसमें समय लगता है, 5,000 μs के समय की देरी पर ध्यान दें।

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

जैसे कि कुछ भी जटिल नहीं है, लेकिन कुछ नुकसानों को दूर करना पड़ा।

अगला मुख्य ब्लॉक है। इसमें हम:

हम एक वायरलेस नेटवर्क में पंजीकृत हैं।

पहले हम एक टीसीपी सर्वर बनाते हैं जो तीन कमांडों को सुनता है:

1. "कार्यक्रम" (हम कार्यक्रम करेंगे)

2. "डेटा" (हम डेटा बदल देंगे),

3. "बंद करो" (हम सब कुछ रोक देते हैं)।

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

यदि हम प्रोग्राम को नहीं, बल्कि डेटा का आदान-प्रदान करना चाहते हैं, तो उन्हें हमारे मामले में माइक्रोकंट्रोलर को भेजते हैं, फिर हम पहले टीसीपी के माध्यम से स्ट्रिंग "डेटा" भेजते हैं। इसके जवाब में, एक यूडीपी सर्वर बनाया जाएगा (मैं आपको याद दिलाता हूं कि हम गतिशील रूप से यांत्रिक हाथ से प्रबंधन नहीं करते हैं और हमें टीसीपी पैकेट के गठन में देरी की आवश्यकता नहीं है, और वास्तव में काउंटर पर पूरे टीसीपी फ्रेम के रूप में एक बाइट भेजें)। और यूडीपी डेटाग्राम छोटे होंगे और जल्दी से बनेंगे।

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

खैर, "स्टॉप" कमांड के साथ, उपर्युक्त सर्वर (पहले को छोड़कर) कनेक्शन बंद करते हैं और मुख्य सर्वर फिर से "प्रोग्राम" और "डेटा" कमांड की प्रतीक्षा स्थिति में चला जाता है।

चूंकि SPI इंटरफ़ेस प्रोग्राम ESP8266, I / O पोर्ट के लिए संकेत CS, CLK, MISO, MOSI, RESET (AVR के लिए) में उत्सर्जित होता है, आप किसी भी उपलब्ध का उपयोग कर सकते हैं, न कि मेरे बूटलोडर में इंगित किए गए। इसके अलावा, यह निकला कि सीएस और एमआईएसओ, सिद्धांत रूप में, इस मामले में भी बाधित हो सकते हैं, यह उनके बिना काम करेगा। खैर, ईएसपी 8266 बोर्ड में निर्मित एलईडी पर एक पिन का उपयोग किया जाता है ताकि यह कभी-कभी झपके और इंगित करता है कि कार्यक्रम अभी भी जीवित है।

रिकॉर्डिंग त्रुटियों की जांच नहीं की जाती है (AVR के पहले अनुरोध के अपवाद के साथ, लेकिन यह जानकारी केवल कंसोल पर प्रदर्शित होती है), EEPROM को प्रोग्राम नहीं किया गया है, 32 केबी से अधिक सिलना नहीं है - संक्षेप में, अभी भी काम करना बाकी है। SPI विनिमय गति लगभग 115 Kbit है, कुछ सेकंड में सब कुछ फ्लैश किया जाता है, लगभग, ISP500 की तरह एक नियमित सीरियल प्रोग्रामर के साथ)।

कोड लें, अपने नेटवर्क और पासवर्ड दर्ज करें, ESplorer पर संकलित करें, इसे "init" कहें (ताकि यह फिर से शुरू हो जाए) और इसे ESP8266 पर भेजें। यह काम करना चाहिए। वायरलेस प्रोग्रामर के रूप में काम करने के अर्थ में, कम से कम।

अब हम प्रबंध दल - एक व्यक्तिगत कंप्यूटर से निपटेंगे।

वास्तव में, हमें HEX फाइल को लेने की आवश्यकता है जिसमें आपके प्रोग्राम ATMEL स्टूडियो पर्यावरण में लिखे गए हैं और इसे WI-FI द्वारा सॉकेट पोर्ट के माध्यम से भेजते हैं जिसे हम जानते हैं (इस मामले में 4000)। छोटी पकड़ यह है कि हमें हस्तांतरण के लिए एक द्विआधारी बिन फ़ाइल की आवश्यकता है, और ATMEL स्टूडियो हमें केवल एक हेक्स के साथ प्रसन्न करता है। दो रास्ते हैं; या इसे WinHex जैसे विशेष प्रोग्राम कनवर्टर के साथ BIN प्रारूप में परिवर्तित करें, या इसे अपने प्रोग्राम में स्वयं करें। मैंने इसे अभी तक नहीं किया है, लेकिन ऐसा लगता है कि यह मुश्किल नहीं है, वहां आपको खिताब को काटने और कुछ और करने की जरूरत है।

परिणामस्वरूप, मैंने JAVA में बूटलोडर कार्यक्रम लिखा (मुख्यतः क्योंकि मुझे नहीं पता कि कुछ और कैसे करना है), बस सुंदर और मुफ्त इंटेलीज आईडीईए वातावरण में काम करना। यह एक TCP क्लाइंट बनाता है जो ESP8266 पर चलने वाले सर्वर की खोज करता है। यदि यह पता चलता है, तो यह उससे संपर्क करता है और उसे ऐसे पते पर स्थित एक फाइल भेजता है। कोड नीचे है।

PC- आधारित जावा फ़ाइल डाउनलोडर

 import java.io.*; import java.net.*; import java.util.ArrayList; import java.util.List; public class Net { <b> public static void main(String args[]) { new Http_client(4000); }</b> } class Http_client extends Thread { int port; String s; String Greetings_from_S; Http_client(int port){ this.port = port; start(); } public void run() { //192.168.1.113 -  ESP8266   .  ,      //    ,    try (Socket socket = new Socket("192.168.1.113", port)) { PrintWriter pw = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true); pw.println("program");// Greetings with SERVER System.out.println("program"); BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); Greetings_from_S = br.readLine(); System.out.println(Greetings_from_S); if(Greetings_from_S.equals("ready")) { try { File file = new File("d:BlinkOUT.bin");//    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file)); byte [] data = new byte[bis.available()]; bis.read(data); byte [] data_buffer = new byte[1024]; int frames = data.length/1024; System.out.println(frames); int residy = data.length%1024; for (int i = 0; i < frames;i++) { for (int k = 0; k< (1024); k++) { data_buffer[k] = data[k+1024*(i)]; } sendingChunk(data_buffer); } byte [] data_buffer2= new byte[residy]; for (int i = 0; i < residy;i++) { data_buffer2[i] = data[i+1024*(frames)]; } sendingChunk(data_buffer2); pw.println("stop");// System.out.println("stop program"); } catch (Exception e) { System.out.println(e); } } } catch (Exception e) { System.out.println(e); } } public void sendingChunk (byte [] data_buffer){ try (Socket socket = new Socket("192.168.1.113", 4001)){ BufferedOutputStream bos = new BufferedOutputStream((socket.getOutputStream())); bos.write(data_buffer); bos.flush(); System.out.println(data_buffer.length); } catch (Exception e) { System.out.println(e); } } }

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

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

शुरू करने के लिए केवल एक चीज कंप्यूटर पर JAVA रनटाइम स्थापित करना है। लेकिन मैं आमतौर पर इंटेलीज आईडीईए से दूर शुरू करता हूं क्योंकि वहां आप हमेशा देख सकते हैं कि कंसोल में क्या हो रहा है (लेकिन यहां आपको एक जावा वातावरण की आवश्यकता है)। हालांकि, ज़ाहिर है, एक स्मार्ट तरीके से आपको GUI बनाने की आवश्यकता है। यही है, खिड़की जहां फ़ाइल का पथ गिरता है, खिड़की में पोर्ट संख्या को बदलने की क्षमता और, अच्छी तरह से, अन्य आवश्यक चीजें। और यह सब एक निष्पादन योग्य फ़ाइल के रूप में इकट्ठा करने के लिए।

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

इस मामले में, हमें चार सर्वोस को नियंत्रित करने की आवश्यकता है। यहाँ वे हैं।

इस तरह की ड्राइव को 2 से 4 प्रतिशत के कर्तव्य कारक के साथ 20 एमएस (50 हर्ट्ज) की अवधि के आयताकार दालों द्वारा नियंत्रित किया जाता है। यानी 2% एक दिशा में पूर्ण मोड़ है, दूसरे में 4% है। कार्य AVR में एकीकृत PWM के लिए है।

एक सर्वो ड्राइव का उपयोग बाएं और दाएं स्थानांतरित करने के लिए किया जाता है; अपने आप से दूसरा - खुद से; तीसरा ऊपर और नीचे; चौथा ही पंजा है, जिसे संकुचित और विस्तारित किया जाना चाहिए। सब कुछ C में लिखा है और ATMEL STUDIO में एक HEX फाइल के लिए संकलित है। एक अजीब तरह का कार्यक्रम इस तथ्य के कारण है कि शुरू में हाथ को माइक्रोकंट्रोलर को तारों से बंधे कीबोर्ड से नियंत्रित किया गया था। लेकिन कल के तारों को हमें और विकसित करना चाहिए।

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

यहां वह कोड है जो हम ESP8266-07 का उपयोग करके Arduino नैनो को लिखते हैं।

माइक्रोकंट्रोलर AVRmega328P के लिए MechArm को नियंत्रित करने का कार्यक्रम

 #define F_CPU 16000000 #include <avr/io.h> #include <stdint.h>//    #include <avr/interrupt.h> #include <math.h> //  #include <stdio.h> // - #include <avr/eeprom.h> #include <setjmp.h> #include <stdlib.h> //  #define UART_BAUD_RATE 115200 //  1    20 #define COUNTER1_OFF TCCR1B=0b00000000 // CS02 CS01 CS00 - 000 - ; 001  ; 010 c  8; 011 -64; 100 -256; 101 -1024 #define COUNTER1_ON TCCR1B=0b00000011 //  0       0  1 #define COUNTER0_OFF TCCR0B=0b00000000 // CS02 CS01 CS00 - 000 - ; 001  ; 010 c  8; 011 -64; 100 -256; 101 -1024 #define COUNTER0_ON TCCR0B=0b00000100 //  2       B2(PD6)  3(PD7) #define COUNTER2_OFF TCCR2B=0b00000000 // CS02 CS01 CS00 - 000 - ; 001  ; 010 c  8; 011 -64; 100 -256; 101 -1024 #define COUNTER2_ON TCCR2B=0b00000110 volatile uint16_t period_20ms; volatile uint8_t State_of_keyboard; volatile uint8_t start_position [6]; volatile int8_t number_servo; ISR(USART_RX_vect)//   UART { State_of_keyboard=UDR0; return; } ISR(TIMER0_COMPA_vect)//  0    { PORTB &=~(1<<0); TIMSK0&=~(1<<OCIE0A); TIFR0 |=(1<<OCF0A); return; } ISR(TIMER0_COMPB_vect) //  1    { PORTB &=~(1<<1); TIFR0 |=(1<<OCF0B); TIMSK0 &=~(1<<OCIE0B); return; } ISR(TIMER2_COMPA_vect)//  2(PD6)    { PORTD &=~(1<<6); TIFR2 |=(1<<OCF2A); TIMSK2 &=~(1<<OCIE2A); return; } ISR(TIMER2_COMPB_vect)//  3(PD7)    { PORTD &=~(1<<7); TIFR2 |=(1<<OCF2B); TIMSK2 &=~(1<<OCIE2B); return; } ISR(TIMER1_OVF_vect){//   20      COUNTER1_OFF; COUNTER0_OFF; COUNTER2_OFF; TIFR0 |=(1<<OCF0A); TIFR0 |=(1<<OCF0B); TIFR2 |=(1<<OCF2A); TIFR2 |=(1<<OCF2B); TIFR1 |=(1<<TOV1); PORTB |=(1<<0)|(1<<1); PORTD |=(1<<6)|(1<<7); TCNT1 = period_20ms; //  20  TCNT0 = 0; TCNT2 = 0; TIMSK0|=(1<<OCIE0A)|(1<<OCIE0B); TIMSK2|=(1<<OCIE2A)|(1<<OCIE2B); OCR0A=start_position[1];//  0  0 OCR0B=start_position[2];//  0  1 OCR2A=start_position[3];//  0  2 OCR2B=start_position[4];//  0  3 COUNTER1_ON; COUNTER2_ON; COUNTER0_ON; return; } void time_delay(long i) { cli();sei(); long k; i*=2000; for(k=0;k<i;k++){;;}; } void timer_counter0_1_2_INIT()//   0,1,2 { // 1 TCCR1A &=~(1<<COM1A0)|~(1<<COM1A1)|~(1<<COM1B0)|~(1<<COM1B1);//   TCCR1A &=~(1<<WGM10)|~(1<<WGM11); TCCR1B &=~(1<<WGM12)|~(1<<WGM13);//    period_20ms=60575; TCNT1 = period_20ms; TIMSK1|=(1<<TOIE1);//|    //TIFR0   TOV0 // 0 TCCR0A &=~(1<<COM0A0)|~(1<<COM0A1)|~(1<<COM0B0)|~(1<<COM0B1);//   TCCR0A &=~(1<<WGM00)|~(1<<WGM01); TCCR0B &=~(1<<WGM02);//    // 2 TCCR2A &=~(1<<COM2A0)|~(1<<COM2A1)|~(1<<COM2B0)|~(1<<COM2B1);//   TCCR2A &=~(1<<WGM20)|~(1<<WGM21); TCCR2B &=~(1<<WGM22);//    COUNTER1_ON; } void servo_reset() { start_position[1]=97;//  0  0 start_position[2]=70;//  0  1 start_position[3]=92;//  0  2 start_position[4]=124; // 0  3 COUNTER1_ON; time_delay(100); } void servo_go( int8_t moven, uint8_t servo_position_max, uint8_t servo_position_min)// { switch (moven){ case 1: start_position[number_servo]++; if(start_position[number_servo]==servo_position_max){start_position[number_servo]--;};//  +90  break; case 2: start_position[number_servo]--; if(start_position[number_servo]==servo_position_min){start_position[number_servo]++;};//6  -90  break; }; time_delay(20); return; } //PORTB-0,1, PORTD - 6,7 -  , 8-  COUNTER 0 int main(void) { uint8_t servo_positionmin=0, servo_positionmax=0; int8_t const servo_position1max = 122, servo_position1min=58; //  int8_t const servo_position2max = 120, servo_position2min=36;// int8_t const servo_position3max = 125, servo_position3min=68;// int8_t const servo_position4max = 129, servo_position4min=108;// 128 108 sei(); DDRD = 0B11000010; //   D2-D5  , D0  RX, D1  TX, D6 D7   3  4 PORTD = 0B00111110; //     DDRB |=(1<<0)|(1<<1);//         PORTB &=(~1<<0)|(~1<<1); UCSR0A=0;// UART UCSR0B=0b10010000; UCSR0C=0b00000110; UBRR0L=103;//  115200 UBRR0H=0; timer_counter0_1_2_INIT(); servo_reset(); PORTB |=(1<<5); while (1) { switch (State_of_keyboard) { case 1://   1 PD0(PB0) number_servo=1; servo_positionmin=servo_position1min; servo_positionmax=servo_position1max; break; case 2: //   1 PD0(PB0) number_servo=1; servo_positionmin=servo_position1min; servo_positionmax=servo_position1max; break; case 5: number_servo=2; //   2 PD1(PB1) servo_positionmin=servo_position2min; servo_positionmax=servo_position2max; break; case 6: number_servo=2; //   2 PD1(PB1) servo_positionmin=servo_position2min; servo_positionmax=servo_position2max; break; case 7: number_servo=3;//   3 PD6 servo_positionmin=servo_position3min; servo_positionmax=servo_position3max; break; case 8: number_servo=3;//   3 PD6 servo_positionmin=servo_position3min; servo_positionmax=servo_position3max; break; case 3: number_servo=4; //   4 PD7 servo_positionmin=servo_position4min; servo_positionmax=servo_position4max; break;//  case 4: number_servo=4; //   4 PD7 servo_positionmin=servo_position4min; servo_positionmax=servo_position4max; break;//  // c    - ,       4-  //        ,         } if(State_of_keyboard==1||State_of_keyboard==3||State_of_keyboard==5||State_of_keyboard==7) { servo_go(1,servo_positionmax,servo_positionmin);// } if(State_of_keyboard==2||State_of_keyboard==4||State_of_keyboard==6||State_of_keyboard==8) //     { servo_go(2,servo_positionmax,servo_positionmin);// } time_delay(20); } }

कार्यक्रम का सार पाठ और टिप्पणियों से स्पष्ट है। हम 20 ms और T0 की एक अनुकरणीय अवधि के लिए T1 काउंटर का उपयोग करते हैं, I / O पोर्ट की चार लाइनों को PWM सिग्नल जारी करने के लिए T2 काउंटर, क्योंकि इन दो काउंटरों में से प्रत्येक दो उपकरणों पर काम कर सकता है।
कार्यक्रम गिनती रजिस्टर OCR0A, OCR0B, OCR2A, OCR2B लोड करने के माध्यम से सर्वो की प्रारंभिक स्थिति निर्धारित करता है। बाधा स्थिरांक भी पेश किए जाते हैं, क्योंकि हमें हमेशा 180 डिग्री की अवधि की आवश्यकता नहीं होती है। अच्छी तरह से और आगे, UART से रुकावट द्वारा, प्रोग्राम ESP8266 (1 से 8 तक) द्वारा भेजे गए नंबर को पकड़ता है और इसे संबंधित सर्वो के लिए एक कमांड में अनुवाद करता है। चार ड्राइव हैं, प्रत्येक दो दिशाओं में काम कर रहे हैं, इसलिए एक से आठ तक पूर्णांक पर्याप्त हैं। एक बार नंबर चुने जाने के बाद, उपरोक्त काउंटर रजिस्टरों की सामग्री या तो बढ़ जाती है या क्रमशः बढ़ जाती है, क्रमशः नियंत्रण पल्स के कर्तव्य चक्र और चयनित सर्वो ड्राइव के रोटेशन के कोण को बदलते हैं। उन ड्राइवों का चयन करें जिन्हें हमने रोटेशन कोण के पुराने मान को बनाए नहीं रखा था (चूंकि संबंधित रजिस्टरों की सामग्री, हालांकि उन्हें अपडेट किया गया था, नहीं बदला था) और उसी स्थिति में यांत्रिक हाथ को पकड़ना जारी रखें।

अब हमें बस नियंत्रण कार्यक्रम लिखना है, टॉटोग्लॉगी के लिए खेद है, वाई-फाई के माध्यम से कंप्यूटर से सीधे यांत्रिक हाथ को नियंत्रित करने के लिए।
कोड भी JAVA में लिखा गया है, लेकिन थोड़ा घेर लिया गया है। एक GUI और ESP8266 के पोर्ट नंबर और नेटवर्क पते को संपादित करने की क्षमता थी।

वहाँ क्या होता है यह खिड़की से स्पष्ट है। मैं इस कार्यक्रम का पाठ यहाँ उपलब्ध नहीं कराता (यह गिथब पर उपलब्ध है), निम्नलिखित कारणों से: इसकी मात्रा का लगभग 95% हिस्सा कीबोर्ड से विंडो निर्माण और सिग्नल प्रोसेसिंग है। लेकिन सार जेएवीए पर पिछले कार्यक्रम के समान है। एक क्लाइंट बनाया जाता है, केवल यूडीपी, जो कि दबाए गए कुंजी के आधार पर, निर्दिष्ट पोर्ट पर निर्दिष्ट पते पर 1 से 8 तक एक संख्या भेजता है।
या आप तुरंत यहां से निष्पादन योग्य प्राप्त कर सकते हैं । विंडोज के साथ 64 बिट मशीनों के लिए। यहां तक कि एक स्थापित जावा पर्यावरण भी आवश्यक नहीं है। सब कुछ पहले से ही 178 एमबी में छाया हुआ है।

इसलिए, मैकेनिकल पेन को इकट्ठा किया गया, डीबग किया गया और अपने भाई को उसकी सालगिरह के लिए प्रस्तुत किया गया। दूसरे शहर से स्काइप पर वोदका के साथ प्लास्टिक बवासीर उठा सकते हैं। हालांकि "द बिग बैंग थ्योरी" श्रृंखला से हॉवर्ड वोलोवित्सा के यांत्रिक हाथ के लिए, वह अभी भी दूर है।

लेकिन फिर निम्नलिखित लेखों में (यदि कोई भी रुचि रखता है), हम इसे मोबाइल फोन से प्रबंधित कर पाएंगे, चार पहिया रोबोट गाड़ी के साथ भी ऐसा ही करेंगे और इंटरनेट पर घड़ी सर्वर से इलेक्ट्रॉनिक घड़ियों में समय को अपडेट कर सकते हैं। फिर हम पुराने स्मार्टफोन को गाड़ी में डालते हैं और वीडियो को न्यूरल नेटवर्क से पैटर्न रिकग्निशन के साथ ड्राइव करते हैं, और वापस मोटर्स को कंट्रोल सिग्नल देते हैं, ~~ओह कुछ पहले से ही मुझे कैरी करता है ...~~

और यह सब सुंदर ईएसपी 8266 के साथ।
मुझे खुशी होगी अगर किसी को लेख दिलचस्प लगा।

[१] पिनआउट और ईएसपी ] २६६ के विनिर्देशों
[२] ईएसपी 6२६६ को जोड़ना। जल्दी शुरू करो।
[३] क्लाउड के माध्यम से NodeMCU फर्मवेयर अपडेट
[४] NODE MCU PyFlasher
[५] ईएसप्लोरर - ईएसपी .२६६ के लिए आईडीई
[६] एवीआर के लिए सी प्रोग्रामिंग
[[] लेखों की समीक्षा - "C भाषा में प्रोग्रामिंग माइक्रोकंट्रोलर"
[ of ] NodeMCU API का वर्णन
[९] लुआ संदर्भ
[१०] लुआ स्क्रिप्ट और मॉड्यूल
[११] इंटेलीज आईडिया
[१२] अब अपने डेस्कटॉप कंप्यूटर में जावा डाउनलोड करें!
[१३] एटलम स्टूडियो

ESP8266 भाग एक के माध्यम से वाईफ़ाई के माध्यम से ARDUINO के साथ प्रोग्रामिंग और डेटा विनिमय

More articles: