🏛️ 🐢 🚴🏻 लॉरेंट मॉड्यूल और स्मार्ट होम (भाग 2)। Arduino और AMS 👸🏻 ♦️ 🗞️

यह होम ऑटोमेशन सिस्टम में कर्नेलशिप के लॉरेंट मॉड्यूल को एकीकृत करने पर एक श्रृंखला का दूसरा लेख है , और इस भाग में हम इन मॉड्यूल को Arduino पारिस्थितिकी तंत्र के साथ एकीकृत करने पर ध्यान केंद्रित करेंगे। श्रृंखला के पहले भाग में , हमने एक लोकप्रिय होम ऑटोमेशन सिस्टम MajorDoMo के साथ एकीकरण के बारे में बात की, और तीसरे भाग में आप सीखेंगे कि अपने कंप्यूटर के डेस्कटॉप से सही, प्रसंस्करण प्रोग्रामिंग भाषा में स्केच से इन मॉड्यूल को कैसे प्रबंधित करें।

Arduino हमारा सब कुछ है

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

लोहा

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

W5100 चिप पर आधारित इथरनेट शील्ड

, यानी आपको अपने कार्यों के लिए इसे थोड़ा बदलने के बाद, बस स्केच लेना होगा और इसे अपने ऊनो या मेगा बोर्ड पर अपलोड करना होगा।

स्केच मॉड्यूल का प्रबंधन करें

श्रृंखला के पहले भाग में, मैंने पहले ही नेटवर्क पर लॉरेंट मॉड्यूल के प्रबंधन के सिद्धांतों के बारे में बात की थी, उन लोगों के लिए जिन्होंने पहले भाग को नहीं पढ़ा है, मैं यहां सिद्धांत को संक्षेप में दोहराऊंगा।

नेटवर्क पर मॉड्यूल के साथ सूचना का आदान-प्रदान किया जाता है और उनके साथ काम करना शुरू करने के लिए आपको पोर्ट 2424 पर एक टीसीपी / आईपी कनेक्शन स्थापित करना होगा। एक बार कनेक्शन स्थापित हो जाने के बाद, आप टेक्स्ट कमांड (तथाकथित KE कमांड) भेज सकते हैं जो मॉड्यूल को नियंत्रित करते हैं। KernelChip वेबसाइट प्रलेखन विस्तृत है, KE आदेशों की एक सुलभ विवरण सहित।

अब आइए इस सैद्धांतिक "संदर्भ की शर्तों" को अर्डुइनो स्केच की सरल भाषा में अनुवाद करने का प्रयास करें।

स्केच

मैं यहां यह नहीं बताऊंगा कि Arduino प्रोग्रामिंग पर्यावरण को कैसे स्थापित और कॉन्फ़िगर किया जाए, यह माना जाता है कि आप पहले से ही ऐसा कर चुके हैं और सरल रेखाचित्र लिखने में सक्षम हैं। इसलिए, शुरुआत के लिए, हमें बस और ईथरनेट मॉड्यूल को नियंत्रित करने के लिए आवश्यक पुस्तकालयों SPI.h और Ethernet.h को जोड़ना होगा।

#include <SPI.h>
#include <Ethernet.h>

फिर आपको ईथरनेट मॉड्यूल और लॉरेंट मॉड्यूल के लिए नेटवर्क सेटिंग्स सेट करने की आवश्यकता है, जिसे हम प्रबंधित करेंगे। ध्यान दें कि मैक पते और आईपी पते अद्वितीय होने चाहिए, और LAURENT_PORT 2424 पर सेट होना चाहिए और कोई अन्य नहीं।

byte SELF_MAC[] = {0x00, 0x2A, 0xF5, 0x12, 0x67, 0xEE};
byte SELF_IP[] = {192, 168, 2, 20};

byte LAURENT_IP[] = {192, 168, 2, 19};
int LAURENT_PORT = 2424;

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

char buf[200];

और अंतिम स्पर्श लॉरेंट मॉड्यूल के लिए ईथरनेट क्लाइंट है। अब हम lclient ऑब्जेक्ट का उपयोग करके मॉड्यूल के साथ सभी ऑपरेशन करेंगे।

EthernetClient lclient;

यही है, अब एक फ़ंक्शन को देखें जो लॉरेंट मॉड्यूल को कमांड भेजता है।

void sendLaurentRequest() {
  if (lclient.connect(LAURENT_IP, LAURENT_PORT)) { 
    Serial.print("Command: ");
    Serial.println(buf);
    lclient.println(buf);
    delay(100);
  
    Serial.print("Answer:  ");
    while(lclient.available() != 0) {
      char c = lclient.read();
      Serial.print(c);
    }
    delay(500);
    lclient.stop();
  } else {
      Serial.println("Error sending command");
    }
}

यदि पोर्ट 2424 पर लॉरेंट मॉड्यूल के साथ एक कनेक्शन स्थापित किया गया है, तो बफर की सामग्री को मॉड्यूल में भेजा जाता है और दृश्य निरीक्षण के लिए सीरियल में डुप्लिकेट किया जाता है। फिर 100 मिलीसेकंड की उम्मीद की जाती है और मॉड्यूल प्रतिक्रिया प्राप्त होती है। उसके बाद, मॉड्यूल के साथ फिर से एक विराम और संचार टूट गया है। यदि किसी कारण से मॉड्यूल से कनेक्शन स्थापित नहीं किया जा सका, तो एक त्रुटि संदेश प्रदर्शित होता है।

अब आइए इनिशियलाइज़ेशन का विश्लेषण करें। ईथरनेट इनिशियलाइज़ेशन एक साधारण कार्य है

void ethernetInit() {
  Ethernet.begin(SELF_MAC, SELF_IP);
}

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

void laurentInit() {
  Serial.println("Start modul Laurent Init...");
  Serial.print("Connect to Laurent... ");
  if (lclient.connect(LAURENT_IP, LAURENT_PORT)) {
    Serial.println("OK");
    lclient.stop();
    
    // Send test command
    Serial.println("Selftest...");
    sprintf(buf, "$KE");
    sendLaurentRequest();

    // Send password (default: "Laurent")
    Serial.println("Set password...");
    sprintf(buf, "$KE,PSW,SET,Laurent");   
    sendLaurentRequest();
  } else {
      Serial.println("failed");
    }
  delay(500);
    
  //   DATA
  sprintf(buf, "$KE,DAT,OFF");
  sendLaurentRequest();
  delay(100);
  
  //  
  sprintf(buf, "$KE,REL,2,0");
  sendLaurentRequest();
  
  Serial.println("Modul Laurent Init done");
}

प्रारंभ में, एक आरंभिक संदेश प्रदर्शित होता है और लॉरेंट मॉड्यूल से जुड़ने का प्रयास किया जाता है। यदि यह विफल रहता है, तो एक त्रुटि संदेश प्रदर्शित होता है, और यदि मॉड्यूल से कनेक्शन सफल होता है, तो एक स्व-निदान कमांड भेजा जाता है, जिसके लिए स्वस्थ मॉड्यूल को "# ओके" के साथ जवाब देना चाहिए।

अगला, पासवर्ड दर्ज करने के लिए एक कमांड भेजा जाता है (इस मामले में, यह डिफ़ॉल्ट पासवर्ड है)। और 500 मिलीसेकंड होने की उम्मीद है।

अगला, दो अतिरिक्त कमांड पेश किए जाते हैं - उनमें से एक मॉड्यूल द्वारा डेटा आउटपुट को रोकता है (यदि यह जाता है), और दूसरा रिले नंबर 2 को बंद कर देता है, जिसे हम अपने प्रयोगों में उपयोग करते हैं। दूसरे शब्दों में, ये कमांड मॉड्यूल को कुछ प्रारंभिक अवस्था में लाते हैं।

यहां आरंभिक प्रक्रिया का एक प्रिंटआउट है जिस पर सभी कमांड और सभी मॉड्यूल प्रतिक्रियाएं दिखाई देती हैं:

Start modul Laurent Init...
Connect to Laurent... OK
Selftest...
Command: $KE
Answer:  #OK
Set password...
Command: $KE,PSW,SET,Laurent
Answer:  #PSW,SET,OK
Command: $KE,DAT,OFF
Answer:  #DAT,OK
Command: $KE,REL,2,0
Answer:  #REL,OK
Modul Laurent Init done

अब मानक सेटअप () फ़ंक्शन के लिए कोड। सभी उपप्रणालियों को आरम्भ किया जाता है, जिसमें मानक 9600 बॉड दर पर एक सीरियल पोर्ट भी शामिल है।

void setup() {  
  Serial.begin(9600);  
  ethernetInit();
  laurentInit();
}

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

उदाहरण के लिए, सबसे सरल कार्य पर विचार करें - नियमित अंतराल पर चालू और बंद करने के लिए लॉरेंट मॉड्यूल के दूसरे रिले से जुड़े दीपक का प्रकाश।

void loop() {
  //  
  sprintf(buf, "$KE,REL,2,1");
  sendLaurentRequest();
  delay(3000);
  //  
  sprintf(buf, "$KE,REL,2,0");
  sendLaurentRequest();
  delay(3000);
}

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

आप इस स्केच को ले सकते हैं और इसे अपनी परियोजनाओं में एकीकृत कर सकते हैं, इस प्रकार लॉरेंट मॉड्यूल को प्रबंधित करने के लिए समर्थन जोड़ सकते हैं। या इसके विपरीत, इस स्केच को एक आधार के रूप में लें और धीरे-धीरे इसकी कार्यक्षमता बढ़ाएं। पूर्णता की कोई सीमा नहीं है। यहाँ पूरा स्केच है।

पूर्ण स्केच कोड

#include <SPI.h>
#include <Ethernet.h>

byte SELF_MAC[] = {0x00, 0x2A, 0xF5, 0x12, 0x67, 0xEE};
byte SELF_IP[] = {192, 168, 2, 20};

byte LAURENT_IP[] = {192, 168, 2, 19};
int LAURENT_PORT = 2424;

char buf[200];

EthernetClient lclient;

void ethernetInit() {
Ethernet.begin(SELF_MAC, SELF_IP);
}

void laurentInit() {
Serial.println(«Start modul Laurent Init...»);
Serial.print(«Connect to Laurent… „);
if (lclient.connect(LAURENT_IP, LAURENT_PORT)) {
Serial.println(“OK»);
lclient.stop();

// Send test command
Serial.println(«Selftest...»);
sprintf(buf, "$KE");
sendLaurentRequest();

// Send password (default: «Laurent»)
Serial.println(«Set password...»);
sprintf(buf, "$KE,PSW,SET,Laurent");
sendLaurentRequest();
} else {
Serial.println(«failed»);
}
delay(500);

// DATA
sprintf(buf, "$KE,DAT,OFF");
sendLaurentRequest();
delay(100);

//
sprintf(buf, "$KE,REL,2,0");
sendLaurentRequest();

Serial.println(«Modul Laurent Init done»);
} // laurentInit

void sendLaurentRequest() {
if (lclient.connect(LAURENT_IP, LAURENT_PORT)) {
Serial.print(«Command: „);
Serial.println(buf);
lclient.println(buf);
delay(100);

Serial.print(“Answer: „);
while(lclient.available() != 0) {
char c = lclient.read();
Serial.print©;
}
delay(500);
lclient.stop();
} else {
Serial.println(“Error sending command»);
}
} // sendLaurentRequest

void setup() {
Serial.begin(9600);
ethernetInit();
laurentInit();
}

void loop() {
//
sprintf(buf, "$KE,REL,2,1");
sendLaurentRequest();
delay(3000);

//
sprintf(buf, "$KE,REL,2,0");
sendLaurentRequest();
delay(3000);
}

Arduino मेगा सर्वर

Arduino Mega Server (AMS) Arduino Mega (अब Arduino DUE के लिए और जल्द ही, अन्य 32-बिट प्लेटफार्मों M0 (Zero) और Genuino 101) के लिए एक शक्तिशाली प्रणाली है, जिसमें "सभी अवसरों के लिए" कोड शामिल है और साथ ही अधिक अंतर्निहित सर्वर और उपयोगकर्ता के अनुकूल वेब इंटरफ़ेस। AMS बॉक्स के ठीक बाहर लॉरेंट मॉड्यूल का समर्थन करता है और आपको उपयोगकर्ता तर्क के अलावा कुछ भी जोड़ने की आवश्यकता नहीं है।

AMS में एक मॉड्यूलर संरचना होती है और स्विचिंग मॉड्यूल ऑन-ऑफ किया जाता है, बस एक रेखाचित्र में एक पंक्ति में टिप्पणी की जाती है, उदाहरण के लिए,

#define LAURENT_FEATURE

या

//#define LAURENT_FEATURE

यदि लाइन पर टिप्पणी की जाती है, तो मॉड्यूल संकलित नहीं किया जाता है और काम में भाग नहीं लेता है, जैसा कि साइट के हेडर में मॉड्यूल के संकेतक पर देखा जा सकता है। या इसके विपरीत, एक संकलित और काम करने वाले मॉड्यूल को नीले रंग में इंगित किया गया है। इस स्थिति में, LRT नियंत्रण मॉड्यूल LRT काम नहीं करता है।

मॉड्यूल ऑपरेशन संकेतक

लॉरेंट मॉड्यूल प्रतिक्रियाओं के साथ काम करना

अब चलो न केवल मॉड्यूल प्रतिक्रियाओं को दिखाने की क्षमता जोड़ते हैं, बल्कि उनके साथ काम भी करते हैं, उदाहरण के लिए, उनका विश्लेषण करें या Arduino मेगा वेब वेब पृष्ठों पर प्रदर्शित करें। ऐसा करने के लिए, हमें एक नया स्ट्रिंग चर और एक स्थिरांक चाहिए जो उस स्ट्रिंग की लंबाई निर्धारित करता है जिसे हम लॉरेंट मॉड्यूल के उत्तरों को निर्दिष्ट करते हैं। परीक्षण उदाहरण में, यह 25 वर्णों के बराबर है, लेकिन आप इसे बढ़ा सकते हैं यदि उत्तर इस मूल्य में फिट नहीं होते हैं। आपको बस याद रखने की ज़रूरत है कि माइक्रोकंट्रोलर की रैम एक मूल्यवान संसाधन है और आपको इसे बचाने की आवश्यकता है। निम्नलिखित लाइनों को AMS पैकेज से मानक laurent.ino मॉड्यूल में जोड़ें:

byte MAX_LEN_LREQUEST = 25;
String lrequest = String(MAX_LEN_LREQUEST);

हमें फ़ंक्शन के कोड को भी बदलने की आवश्यकता है जो अनुरोध करता है (जोड़ा गया परिवर्तन तीर द्वारा हाइलाइट किया गया है)।

void sendLaurentRequest() {
  if (lclient.connect(LAURENT_IP, LAURENT_PORT)) { 
    Serialprint("Command: ");
    Serial.println(buf);
    lclient.println(buf);
    delay(100);
  
    Serialprint("Answer:  ");
    // -------------------->
    lrequest = "";
    // -------------------->
    while(lclient.available() != 0) {
      char c = lclient.read();
      Serial.print(c);
      // -------------------->
      if (lrequest.length() < MAX_LEN_LREQUEST) {
        lrequest += (c);
      }
      // -------------------->
    }
    delay(500);
    lclient.stop();
  } else {
      Serialprint("Error sending command\n");
    }
}

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

एक छोटा नोट। यह उदाहरण मानक Serial.print के बजाय Serialprint फ़ंक्शन का उपयोग करता है क्योंकि यह अधिक RAM बचाता है। और इसे आसानी से एक मानक में परिवर्तित किया जा सकता है, बस दो शब्दों का अंत करके।

साइट हेडर के लिए मॉड्यूल प्रतिक्रिया आउटपुट

और अंतिम उदाहरण। चलो Arduino मेगा सर्वर साइट के हेडर में लॉरेंट मॉड्यूल के उत्तर प्रदर्शित करते हैं। ऐसा करने के लिए, हमें AMS स्केच के मुख्य लूप () लूप में अनुरोध जोड़ना होगा। Arduino_mega_server.ino फ़ाइल खोलें और cyclosInSecWork () से पहले निम्न कोड दर्ज करें:

    #ifdef LAURENT_FEATURE
      if (cycle30s) {
        sprintf(buf, "$KE");   
        sendLaurentRequest();
      }
    #endif

यह कोड लॉरेंट मॉड्यूल के स्वास्थ्य को हर तीस सेकंड में क्वेरी करेगा। स्वाभाविक रूप से, यह सिर्फ एक उदाहरण है, इस जगह पर कोई भी अनुरोध और कोई भी कोड हो सकता है। इस प्रकार, परिवर्तनीय lrequest में हमारे पास मॉड्यूल की स्थिति के बारे में एक उत्तर है और अब इसे साइट के हेडर में प्रदर्शित कर सकते हैं। ऐसा करने के लिए, server_ajax.ino मॉड्यूल खोलें और बहुत अंत में, responseDash फ़ंक्शन कोड (EthernetClient cl) में, लाइन cl.println ("") से पहले; निम्नलिखित कोड जोड़ें:

    #ifdef LAURENT_FEATURE
      sendTagString("laurent", "", lrequest, cl);
    #endif

यह कोड, वास्तव में, मॉड्यूल प्रतिक्रियाओं को वेब पेज पर भेजता है। यह दो काम करता है: पहला जावास्क्रिप्ट कोड जोड़ना है जो हमारे डेटा को "कैच" करेगा और दूसरा स्वयं AMS पेज पर HTML कोड है, जहां मॉड्यूल उत्तर प्रदर्शित किए जाएंगे।

तो, लिपियों को खोलें। Js फ़ाइल और getDashData () क्लोजिंग ब्रैकेट से पहले फ़ंक्शन} // if (this.responseXML! = Null) उस कोड को दर्ज करें जो हमारे परिसर को स्वीकार करेगा।

          // Laurent
          try {
            var laurent = this.responseXML.getElementsByTagName('laurent')[0].childNodes[0].nodeValue;
          } catch (err) {
              laurent = "-";
            }
          document.getElementById("laurent").innerHTML = laurent;

यह मानक AMS डिलीवरी से डैश.htm फ़ाइल को थोड़ा ठीक करने के लिए ही रहता है और इसमें कोड जोड़ देता है जो स्क्रीन पर जानकारी प्रदर्शित करेगा। वर्ग = "ऑनलाइन-डिवाइस" वाली लाइन के तुरंत बाद हम कोड के साथ अपनी नई लाइन दर्ज करते हैं:

<p>Laurent: <span class="value" id="laurent">...</span></p>

बस इतना ही। हमने Arduino Mega Server साइट के हेडर में लॉरेंट मॉड्यूल प्रतिक्रियाओं को प्रदर्शित किया है। और यहाँ हमारे प्रयासों का परिणाम है। एएमएस पैनल में मॉड्यूल की स्थिति स्पष्ट रूप से दिखाई देती है और इसे हर 30 सेकंड में अपडेट किया जाता है, इसलिए यदि मॉड्यूल में कुछ होता है, तो आप अधिकतम 30 सेकंड के बाद इसके बारे में जान पाएंगे।

निष्कर्ष

जैसा कि आप देख सकते हैं, Arduino और Arduino Mega Server का उपयोग करके लॉरेंट मॉड्यूल को प्रबंधित करने में कुछ भी जटिल नहीं है, और यदि आपके पास पहले से ही ऐसे मॉड्यूल हैं या उन्हें अपने स्मार्ट होम सिस्टम में जोड़ने की योजना है, तो यह लेख आपको आसानी से और सरलता से ऐसा करने में मदद करेगा।

और चक्र से अगले लेख में, आप सीखेंगे कि अपने कंप्यूटर की स्क्रीन से सीधे लोरेंस का प्रबंधन कैसे करें और बच्चों को प्रोग्रामिंग की प्रक्रिया को इंटरैक्टिव और अधिक रोचक कैसे बनाएं।

जोड़ । एक Youtube चैनल खुला है और यहाँ Arduino Mega Server का प्रोमो वीडियो है , जो दर्शाता है कि वास्तविक प्रणाली के साथ कैसे काम किया जाए।

लॉरेंट मॉड्यूल और स्मार्ट होम (भाग 2)। Arduino और AMS