📕 🧑🏽‍🤝‍🧑🏻 🚶🏾 Arduino वायरलेस नेटवर्क 🙌 💆🏽 🍳

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

बजट रेडियो मॉड्यूल

हमारा नेटवर्क 433.90MHz की आवृत्ति पर संचालित बजट रेडियो मॉड्यूल पर आधारित होगा। इस तरह के एक मॉड्यूल की लागत लगभग $ 2.5 है, इसलिए बाहरी दुनिया के साथ संचार को व्यवस्थित करने के लिए लागत कम है। बेशक, आप संचार के लिए तैयार किए गए ईथरनेट मॉड्यूल का उपयोग कर सकते हैं और यहां तक कि वैकल्पिक फर्मवेयर के आधार पर वायरलेस राउटर के साथ सहजीवन बना सकते हैं, लेकिन कई मामलों में ऐसे रेडियो मॉड्यूल पर सब कुछ करना आसान और सस्ता है।

ट्रांसमीटर:

रिसीवर:

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

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

प्रत्येक मॉड्यूल कंट्रोलर से प्राथमिक रूप से जुड़ा होता है - Vcc / Gnd के माध्यम से बिजली की आपूर्ति की जाती है और डेटा आउटपुट माइक्रो-कंट्रोलर पर एक मुफ्त डिजिटल इनपुट से जुड़ा होता है। रिसेप्शन / ट्रांसमिशन की गुणवत्ता में सुधार करने के लिए, 10-15 सेमी मापने वाले तार के रूप में एंटीना को अतिरिक्त रूप से कनेक्ट करने की सिफारिश की जाती है। वैसे, संचार सीमा मॉड्यूल को आपूर्ति की जाने वाली शक्ति पर भी निर्भर करती है - यदि वे 12 वी से संचालित होती हैं, तो संचार रेंज और विश्वसनीयता में काफी वृद्धि होती है।

रिसीवर और ट्रांसमीटर Arduino UNO R3 माइक्रो-नियंत्रक से जुड़े:

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

वर्चुअलवायर लाइब्रेरी

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

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

वर्चुअलवायर (लाइब्रेरी उपयोग उदाहरणों से) का उपयोग कर ट्रांसमीटर कोड:

कोड देखें

// transmitter.pde // // Simple example of how to use VirtualWire to transmit messages // Implements a simplex (one-way) transmitter with an TX-C1 module #include <VirtualWire.h> void setup() { Serial.begin(9600); // Debugging only Serial.println("setup"); // Initialise the IO and ISR vw_set_ptt_inverted(true); // Required for DR3100 vw_setup(2000); // Bits per sec } void loop() { const char *msg = "hello"; digitalWrite(13, true); // Flash a light to show transmitting vw_send((uint8_t *)msg, strlen(msg)); vw_wait_tx(); // Wait until the whole message is gone digitalWrite(13, false); delay(200); }

रिसीवर कोड:

कोड देखें

 // receiver.pde // // Simple example of how to use VirtualWire to receive messages // Implements a simplex (one-way) receiver with an Rx-B1 module #include <VirtualWire.h> void setup() { Serial.begin(9600); // Debugging only Serial.println("setup"); // Initialise the IO and ISR vw_set_ptt_inverted(true); // Required for DR3100 vw_setup(2000); // Bits per sec vw_rx_start(); // Start the receiver PLL running } void loop() { uint8_t buf[VW_MAX_MESSAGE_LEN]; uint8_t buflen = VW_MAX_MESSAGE_LEN; if (vw_get_message(buf, &buflen)) // Non-blocking { int i; digitalWrite(13, true); // Flash a light to show received good message // Message with a good checksum received, dump it. Serial.print("Got: "); for (i = 0; i < buflen; i++) { Serial.print(buf[i], HEX); Serial.print(" "); } Serial.println(""); digitalWrite(13, false); } }

संचार प्रोटोकॉल

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

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

device_id - पैकेट भेजने वाले उपकरण का पहचानकर्ता। डेटा प्रकार: अहस्ताक्षरित int (लंबाई 2 बाइट्स, 0 से 65535 तक मानों की श्रेणी) - जैसा कि मुझे लगता है, यह एक होम नेटवर्क के लिए काफी पर्याप्त है।

डेस्टिने_ड - डिवाइस का पहचानकर्ता जिसे पैकेट का इरादा है। डेटा प्रकार डिवाइस_ड के समान है। यह ध्यान रखना महत्वपूर्ण है कि पैकेट अभी भी सभी प्राप्तकर्ताओं द्वारा प्राप्त किए जाएंगे, लेकिन पहले से ही रिसीवर पर कार्यक्रम के साथ आप उन पैकेटों को "काट" सकते हैं जो डिवाइस के लिए अभिप्रेत नहीं हैं। आप एक नियम के रूप में भी ले सकते हैं कि इस क्षेत्र में "0" का अर्थ एक प्रसारण पैकेट है।

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

कमांड - कमांड का प्रकार। बाइट डेटा प्रकार (लंबाई 1 बाइट, मान 0 से 255 तक होता है)। यह तथाकथित "टीम क्लास" है, लेकिन वास्तव में जानकारी है कि हम किस तरह का डेटा भेज रहे हैं। उदाहरण के लिए, हम ओपनिंग / क्लोजिंग कंट्रोल कमांड के लिए नंबर 10 और तापमान डेटा ट्रांसमिशन कमांड के लिए नंबर 15 असाइन करके अपनी खुद की टेबल बना सकते हैं। मुख्य बात यह है कि हमारे पास यह टेबल निरंतर है। और आप इसे और भी अधिक चालाकी से कर सकते हैं - एक ही ZWave प्रोटोकॉल में संभव कमांड पर झांकने और अपने घर में उनकी तालिका का उपयोग करने के लिए ताकि सब कुछ "वयस्कों की तरह" हो, और इस मूल्यवान जानकारी की सुरक्षा का ध्यान रखने की कोई आवश्यकता नहीं है।

डेटा - वास्तविक डेटा। डेटा प्रकार इंट (लंबाई 2 बाइट्स) है, मानों की सीमा -32.768 से 32.767 तक है। इस क्षेत्र में हम सीधे डेटा को एक ही संख्या के रूप में प्रसारित करते हैं। पर्याप्त नहीं है; ठीक है, यह मुझे पर्याप्त लगता है। तापमान पारित किया जा सकता है (उदाहरण के लिए, यह मानकर कि यह 100 से गुणा किया जाता है), स्थिति। मोशन सेंसर आसान है, रिले के साथ एक रिसीवर के लिए एक कमांड पाठ डेटा भेजने के रूप में सरल है, निश्चित रूप से, इसे बाहरी डिस्प्ले पर नहीं भेजा जा सकता है, लेकिन यह लक्ष्य निर्धारित नहीं किया गया है, और मेरे वर्तमान और भविष्य के उपकरणों के लिए यह मेरी आंखों के लिए पर्याप्त है और कुछ दर्जन की संख्या में सब कुछ वर्णन करने के लिए। संभव टीमें।

नतीजतन, हमारे पास 9 बाइट्स का एक पैकेट लंबाई है। एक छोटा पैकेज, वास्तव में, बहुत अच्छा है - सबसे पहले, यह कम संभावना है कि यह रास्ते में "ब्रेक" करेगा; दूसरे, स्थानांतरण के लिए कम समय, जो कई उपकरणों के बीच हवा को साझा करने की संभावना को कम करता है। वैसे, बाद की परिस्थिति को "विरल" की आवश्यकता होगी, अर्थात् अक्सर जानकारी नहीं भेजते। इसी समय, यह वांछनीय है कि जब गवाही समय-समय पर भेजी जाती है, तो सत्रों के बीच का अंतराल कुछ हद तक भिन्न होता है। लेकिन यह सब पहले से ही एक विशिष्ट डिवाइस को एकीकृत करते समय प्रदान किया जाना चाहिए। जैसा कि हो सकता है, मैं प्रेषित डेटा के पैकेट के न्यूनतम आकार की गिरावट के लिए संरचना की सार्वभौमिकता पर बहुत अधिक झुकाव की सलाह नहीं दूंगा।

इसलिए, हमने पैकेज की संरचना पर फैसला किया है, अब हमें एक्सचेंज को लागू करने की आवश्यकता है। यहाँ EasyTransfer नामक एक अन्य उपयोगी पुस्तकालय हमारी सहायता के लिए आता है । वास्तव में, यह वर्चुअलवायर के "शीर्ष पर" काम करता है, जिससे आप रिसीवर / ट्रांसमीटर पर डेटा संरचना का वर्णन कर सकते हैं और बाईटकोड के सेट से नहीं, बल्कि पूरे ढांचे द्वारा एक्सचेंज कर सकते हैं।

हमारे मामले में, डेटा संरचना में निम्नलिखित रूप होंगे:

 struct SEND_DATA_STRUCTURE{ unsigned int device_id; unsigned int destination_id; unsigned int packet_id; byte command; int data; };

यह जरूरी है कि रिसीवर और ट्रांसमीटर पर संरचना एक-एक है, अन्यथा हम गलत जानकारी प्राप्त करेंगे। दरअसल, इसलिए, पैकेज की संरचना को पहले से निर्धारित करना महत्वपूर्ण है।

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

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

ट्रांसमीटर कोड:

कोड देखें

 #include <VirtualWire.h> #include <EasyTransferVirtualWire.h> #include <EEPROM.h> //       -  const int led_pin = 13; const int transmit_pin = 2; unsigned int unique_device_id = 0; unsigned int count = 1; //create object EasyTransferVirtualWire ET; struct SEND_DATA_STRUCTURE{ //  .          // ,      26  ( VirtualWire) unsigned int device_id; unsigned int destination_id; unsigned int packet_id; byte command; int data; }; //     SEND_DATA_STRUCTURE mydata; //       unsigned int  EEPROM void EEPROMWriteInt(int p_address, unsigned int p_value) { byte lowByte = ((p_value >> 0) & 0xFF); byte highByte = ((p_value >> 8) & 0xFF); EEPROM.write(p_address, lowByte); EEPROM.write(p_address + 1, highByte); } unsigned int EEPROMReadInt(int p_address) { byte lowByte = EEPROM.read(p_address); byte highByte = EEPROM.read(p_address + 1); return ((lowByte << 0) & 0xFF) + ((highByte << 8) & 0xFF00); } void setup() { //   pinMode(led_pin, OUTPUT); ET.begin(details(mydata)); vw_set_tx_pin(transmit_pin); // ,    data-  vw_setup(2000); //  Serial.begin(9600); randomSeed(analogRead(0)); // / Device ID Serial.print("Getting Device ID... "); unique_device_id=EEPROMReadInt(0); if (unique_device_id<10000 || unique_device_id>60000) { Serial.print("N/A, updating... "); unique_device_id=random(10000, 60000); EEPROMWriteInt(0, unique_device_id); } Serial.println(unique_device_id); } void loop() { mydata.device_id = unique_device_id; mydata.destination_id = 0; mydata.packet_id = random(65535); mydata.command = 0; mydata.data = count; digitalWrite(led_pin, HIGH); //       Serial.print("Transmitting packet "); Serial.print(mydata.packet_id); Serial.print(" device id "); Serial.print(mydata.device_id); Serial.print(" data: "); Serial.print(mydata.data); Serial.print(" ... "); ET.sendData(); //   digitalWrite(led_pin, LOW); Serial.println("DONE"); delay(1000); count = count + 1; }

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

रिसीवर कोड:

कोड देखें

 #include <VirtualWire.h> #include <EasyTransferVirtualWire.h> #include <EEPROM.h> const int led_pin = 13; const int receive_pin = 2; unsigned int unique_device_id = 0; //create object EasyTransferVirtualWire ET; char buf[120]; struct SEND_DATA_STRUCTURE{ //  .          // ,      26  ( VirtualWire) unsigned int device_id; unsigned int destination_id; unsigned int packet_id; byte command; int data; }; //     SEND_DATA_STRUCTURE mydata; //       unsigned int  EEPROM void EEPROMWriteInt(int p_address, unsigned int p_value) { byte lowByte = ((p_value >> 0) & 0xFF); byte highByte = ((p_value >> 8) & 0xFF); EEPROM.write(p_address, lowByte); EEPROM.write(p_address + 1, highByte); } unsigned int EEPROMReadInt(int p_address) { byte lowByte = EEPROM.read(p_address); byte highByte = EEPROM.read(p_address + 1); return ((lowByte << 0) & 0xFF) + ((highByte << 8) & 0xFF00); } void setup() { pinMode(led_pin, OUTPUT); Serial.begin(9600); // Debugging only ET.begin(details(mydata)); // Initialise the IO and ISR vw_set_rx_pin(receive_pin); vw_setup(2000); //   vw_rx_start(); //    // Device ID Serial.print("Getting Device ID... "); unique_device_id=EEPROMReadInt(0); if (unique_device_id<10000 || unique_device_id>60000) { Serial.print("N/A, updating... "); unique_device_id=random(10000, 60000); EEPROMWriteInt(0, unique_device_id); } Serial.println(unique_device_id); } void loop() { if(ET.receiveData()) //   ,  { digitalWrite(led_pin, HIGH); Serial.print("Got: "); Serial.print("Device ID: "); Serial.print(mydata.device_id); Serial.print(" Destination ID: "); Serial.print(mydata.destination_id); Serial.print(" Packet ID: "); Serial.print(mydata.packet_id); Serial.print(" Command: "); Serial.print(mydata.command); Serial.print(" Data: "); Serial.print(mydata.data); Serial.println(); digitalWrite(led_pin, LOW); } }

हुर्रे! हमारा स्काईनेट हवा पर है! आप पहले से ही बहुत उपयोगी चीजें कर सकते हैं, लेकिन पूर्णता की कोई सीमा नहीं है ... हम आगे बढ़ते हैं।

मेजरडोमो में एकीकरण

अगला चरण स्मार्ट होम के लिए अधिक जटिल प्रबंधन वातावरण में हमारी संपूर्ण "अर्थव्यवस्था" का एकीकरण है। इस मामले में, मेजरडोमो प्लेटफॉर्म का उपयोग किया जाता है , लेकिन किसी अन्य प्रणाली के साथ एकीकरण समान रूप से आयोजित किया जा सकता है।

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

स्क्रिप्ट कंट्रोल पैनल में, एक संदेश प्राप्त करें, जिसमें स्क्रिप्ट प्राप्त करना आसान हो ।
स्क्रिप्ट कोड:

 $device_id=$params['did']; $destination_id=$params['dest']; $packet_id=$params['pid']; $command_id=$params['c']; $data=$params['d']; say("  $device_id   $packet_id   $command_id   $data");

इस कोड को जोड़ने के बाद, आप तुरंत इसे http लिंक के माध्यम से कॉल कर सकते हैं:

192.168.0.17/objects/?script=easyRF

(192.168.0.17 के बजाय आपका सर्वर पता)

अगला कदम Arduino से MajorDoMo को प्राप्त डेटा को स्ट्रीम करना है। विकल्प हैं - आप Arduino रिसीवर में एक ईथरनेट मॉड्यूल जोड़ सकते हैं और तुरंत नेटवर्क पर http अनुरोध भेज सकते हैं, या आप USB के माध्यम से माइक्रो-नियंत्रक को कनेक्ट कर सकते हैं और ArduinoGW प्रोग्राम का उपयोग कर सकते हैं, जो COM पोर्ट पर "सुनता है" और अगर http भेजने के लिए एक महत्वपूर्ण अनुक्रम है। - एक अनुरोध, यह खुद को नेटवर्क पर पुनर्निर्देशित करता है

हम दूसरी विधि का उपयोग करेंगे, क्योंकि इसके लिए अतिरिक्त उपकरणों की आवश्यकता नहीं होती है। इस स्थिति में, रिसीवर कोड इस तरह दिखेगा:

कोड देखें

 #include <VirtualWire.h> #include <EasyTransferVirtualWire.h> #include <EEPROM.h> const int led_pin = 13; const int receive_pin = 2; unsigned int unique_device_id = 0; //create object EasyTransferVirtualWire ET; char buf[120]; struct SEND_DATA_STRUCTURE{ //  .          // ,      26  ( VirtualWire) unsigned int device_id; unsigned int destination_id; unsigned int packet_id; byte command; int data; }; //     SEND_DATA_STRUCTURE mydata; //       unsigned int  EEPROM void EEPROMWriteInt(int p_address, unsigned int p_value) { byte lowByte = ((p_value >> 0) & 0xFF); byte highByte = ((p_value >> 8) & 0xFF); EEPROM.write(p_address, lowByte); EEPROM.write(p_address + 1, highByte); } unsigned int EEPROMReadInt(int p_address) { byte lowByte = EEPROM.read(p_address); byte highByte = EEPROM.read(p_address + 1); return ((lowByte << 0) & 0xFF) + ((highByte << 8) & 0xFF00); } void setup() { pinMode(led_pin, OUTPUT); Serial.begin(9600); // Debugging only ET.begin(details(mydata)); // Initialise the IO and ISR vw_set_rx_pin(receive_pin); vw_setup(2000); // Bits per sec vw_rx_start(); // Start the receiver PLL running // Device ID Serial.print("Getting Device ID... "); unique_device_id=EEPROMReadInt(0); if (unique_device_id<10000 || unique_device_id>60000) { Serial.print("N/A, updating... "); unique_device_id=random(10000, 60000); EEPROMWriteInt(0, unique_device_id); } Serial.println(unique_device_id); } void loop() { if(ET.receiveData()) //   ,  { digitalWrite(led_pin, HIGH); Serial.print("Got: "); Serial.print("Device ID: "); Serial.print(mydata.device_id); Serial.print(" Destination ID: "); Serial.print(mydata.destination_id); Serial.print(" Packet ID: "); Serial.print(mydata.packet_id); Serial.print(" Command: "); Serial.print(mydata.command); Serial.print(" Data: "); Serial.print(mydata.data); Serial.println(); digitalWrite(led_pin, LOW); sprintf(buf, "GET /objects/?script=easyRF&did=%u&dest=%u&pid=%u&c=%u&d=%i HTTP/1.0", (int)mydata.device_id, (int)mydata.destination_id, (int)mydata.packet_id, (int)mydata.command, (int)mydata.data); Serial.println(buf); //      HTTP- (     ethernet-shield- Serial.println(); } }

वह सब है! हम डिवाइस बनाते हैं, रेडियो मॉड्यूल जोड़ते हैं और हर चीज और हर चीज की बातचीत को कॉन्फ़िगर करते हैं।

आगे का विकास

जैसा कि मैंने ऊपर लिखा है, इस लेख को एक विचार की अवधारणा के रूप में माना जा सकता है, जिसे कई दिशाओं में विकसित किया जा सकता है, यहां तक कि पैकेज की मूल संरचना को बदलने के बिना भी।

मन में आए कुछ विचार मुझे दें:

* "विश्वसनीय" एक्सचेंज के नोड्स का निर्माण (हम एक ही डिवाइस पर रिसीवर और ट्रांसमीटर दोनों का उपयोग करते हैं और वितरण नियंत्रण के साथ पैकेटों के आदान-प्रदान को व्यवस्थित करते हैं, हम वितरण नियंत्रण के लिए अलग-अलग कमांड का चयन करते हैं)
* हम अधिक महंगे और विश्वसनीय रेडियो मॉड्यूल का उपयोग करते हैं
* हम कोड को बदलने की आवश्यकता के बिना "बाइंडिंग" एक डिवाइस को दूसरे को लागू करने की प्रक्रिया को लागू करते हैं (दो उपकरणों के "बाइंडिंग" मोड में स्थानांतरण और एक युग्मित डिवाइस के EEPROM को लेखन)

वह सब है। आपका ध्यान के लिए धन्यवाद!

Arduino वायरलेस नेटवर्क

बजट रेडियो मॉड्यूल

वर्चुअलवायर लाइब्रेरी

संचार प्रोटोकॉल

मेजरडोमो में एकीकरण

आगे का विकास

More articles: