Geekly articles weekly

Laurent Module und Smart Home (Teil 2). Arduino und AMS

Dies ist der zweite Artikel in einer Reihe zur Integration der Laurent- Module von KernelChip in Hausautomationssysteme. In diesem Teil konzentrieren wir uns auf die Integration dieser Module in das Arduino-Ökosystem. Im ersten Teil der Serie haben wir über die Integration in das beliebte MajorDoMo-Hausautomationssystem gesprochen. Im dritten Teil erfahren Sie, wie Sie diese Module anhand von Skizzen in der Programmiersprache Processing direkt vom Desktop Ihres Computers aus verwalten.

Bild

Arduino ist unser Alles


Wo ohne Arduino? Ich werde die Vorteile dieser Plattform noch lange nicht beschreiben, ihre Beliebtheit spricht für sich. Kommen wir also sofort zu den technischen Details der Interaktion zwischen Arduino- und Laurent-Modulen. Dabei werden wir das Arduino Mega Server-System als sehr interessantes Derivat des Arduino-Ökosystems nicht vergessen .

Eisen


Zur Steuerung von Modulen über das Netzwerk eignen sich beispielsweise die gemeinsame Arduino Uno-Karte oder die ebenso beliebte Arduino Mega-Karte mit einer Ethernet Shield-Netzwerkschnittstellenkarte, die auf Basis des W5100-Chips zusammengesetzt ist. Alle Beispiele in diesem Artikel sind für eine solche Kombination angegeben und wurden in der Praxis getestet. Alles funktioniert zuverlässig und ohne Probleme.

Bild
Ethernet Shield basierend auf dem W5100-Chip

Das heißt, Sie müssen nur die Skizze nehmen und auf Ihr Uno- oder Mega-Board hochladen, nachdem Sie sie für Ihre Aufgaben ein wenig geändert haben.

Skizzenmodule verwalten


Im ersten Teil der Reihe habe ich bereits über die Prinzipien der Verwaltung von Laurent-Modulen über das Netzwerk gesprochen. Für diejenigen, die den ersten Teil nicht gelesen haben, werde ich die Theorie hier kurz wiederholen.

Informationen werden über das Netzwerk mit den Modulen ausgetauscht. Um mit ihnen arbeiten zu können, müssen Sie eine TCP / IP-Verbindung an Port 2424 herstellen. Sobald die Verbindung hergestellt ist, können Sie Textbefehle (sogenannte KE-Befehle) senden, die das Modul steuern. Die KernelChip-Website enthält eine detaillierte Dokumentation, einschließlich einer zugänglichen Beschreibung der KE-Befehle.

Versuchen wir nun, diese theoretischen „Aufgabenbereiche“ in die einfache Sprache der Arduino-Skizzen zu übersetzen.

Skizzieren


Ich werde hier nicht erklären, wie die Arduino-Programmierumgebung installiert und konfiguriert wird. Es wird davon ausgegangen, dass Sie dies bereits getan haben und einfache Skizzen schreiben können. Für den Anfang müssen wir also die erforderlichen Bibliotheken SPI.h und Ethernet.h verbinden, um den Bus und das Ethernet-Modul selbst zu steuern.

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

Anschließend müssen Sie die Netzwerkeinstellungen für das Ethernet-Modul und das Laurent-Modul festlegen, die wir verwalten werden. Beachten Sie, dass MAC-Adressen und IP-Adressen eindeutig sein müssen und LAURENT_PORT auf 2424 und keine andere festgelegt sein muss.

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;

Wir benötigen noch einen Puffer zum Speichern von Netzwerkbefehlen. Er wird mit einer Größe von 200 Byte und einem gewissen Spielraum ausgewählt. Wenn Sie Probleme mit fehlendem RAM haben, können Sie ihn beispielsweise auf 100 Byte oder sogar weniger reduzieren.

char buf[200];

Der letzte Schliff ist der Ethernet-Client für das Laurent-Modul. Jetzt werden wir alle Operationen mit dem Modul unter Verwendung des lclient-Objekts ausführen.

EthernetClient lclient;

Schauen wir uns nun eine Funktion an, die Befehle an das Laurent-Modul sendet.

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");
    }
}

Wenn eine Verbindung mit dem Laurent-Modul an Port 2424 hergestellt wird, wird der Inhalt des Puffers an das Modul gesendet und zur visuellen Überprüfung in Serial dupliziert. Dann werden 100 Millisekunden erwartet und die Modulantwort wird empfangen. Danach wird erneut eine Pause eingelegt und die Kommunikation mit dem Modul unterbrochen. Wenn die Verbindung zum Modul aus irgendeinem Grund nicht hergestellt werden konnte, wird eine Fehlermeldung angezeigt.

Lassen Sie uns nun die Initialisierung analysieren. Die Ethernet-Initialisierung ist eine einfache Funktion

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

Das Laurent-Modul wird durch die Funktion laurentInit () initialisiert, deren Funktionsweise wir nun im Detail analysieren werden. Es ist ziemlich groß und Sie müssen es gut verstehen, da Sie auf der Grundlage des Codes für diese Funktion Ihre eigenen Anforderungen an Laurent-Module erstellen können.

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");
}

Zunächst wird eine Initialisierungsnachricht angezeigt und versucht, eine Verbindung zum Laurent-Modul herzustellen. Wenn dies fehlschlägt, wird eine Fehlermeldung angezeigt, und wenn die Verbindung zum Modul erfolgreich ist, wird ein Eigendiagnosebefehl gesendet, auf den das fehlerfreie Modul mit "#OK" antworten soll.

Als nächstes wird ein Befehl zur Eingabe des Kennworts gesendet (in diesem Fall ist dies das Standardkennwort). Und 500 Millisekunden werden erwartet.

Als nächstes werden zwei zusätzliche Befehle eingeführt - einer von ihnen stoppt die vom Modul ausgegebene Daten (falls dies der Fall ist) und der zweite schaltet das Relais Nr. 2 aus, das wir in unseren Experimenten verwenden. Mit anderen Worten, diese Befehle bringen das Modul in einen Anfangszustand.

Hier ist ein Ausdruck des Initialisierungsprozesses, bei dem alle Befehle und alle Modulantworten sichtbar sind:

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

Nun der Code für die Standardfunktion setup (). Alle Subsysteme werden initialisiert, einschließlich einer seriellen Schnittstelle mit einer Standard-Baudrate von 9600.

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

Also haben wir das Modul initialisiert und können es so verwalten, wie wir es brauchen: Befehle senden, Antworten lesen, Steuerlogik unter Berücksichtigung der vom Laurent-Modul ausgegebenen Daten erstellen.

Stellen Sie sich zum Beispiel die einfachste Aufgabe vor - das Licht einer Lampe, die an das zweite Relais des Laurent-Moduls angeschlossen ist, in regelmäßigen Abständen ein- und auszuschalten.

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

Die loop () -Funktion ist eine Endlosschleife, und die Lampe, die unseren Befehlen folgt, leuchtet kontinuierlich auf und erlischt alle 3 Sekunden. Dies ist natürlich nur ein Beispiel, in der Tat kann die Logik der Arbeit beliebig sein und alles hängt von Ihren Bedürfnissen ab. Natürlich können Sie nicht nur Befehle zum Aktivieren oder Deaktivieren von Lasten senden, sondern auch alle anderen, die vom Modul unterstützt werden. Eine vollständige Liste der Befehle und ihrer Beschreibung finden Sie in der Dokumentation zu Laurent-Modulen.

Sie können diese Skizze in Ihre eigenen Projekte integrieren und so die Verwaltung von Laurent-Modulen unterstützen. Oder umgekehrt, nehmen Sie diese Skizze als Grundlage und erweitern Sie schrittweise ihre Funktionalität. Der Perfektion sind keine Grenzen gesetzt. Hier ist die vollständige Skizze.

Vollständiger Skizzencode
#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 Mega Server


Bild

Arduino Mega Server (AMS) ist ein leistungsstarkes System für Arduino Mega (jetzt auch für Arduino DUE und bald auch für andere 32-Bit-Plattformen M0 (Zero) und Genuino 101), das den Code "für alle Gelegenheiten" und mehr enthält eingebauter Server und benutzerfreundliche Weboberfläche. AMS unterstützt Laurent-Module sofort und Sie müssen nichts anderes als Benutzerlogik hinzufügen.

AMS ist modular aufgebaut und das Ein- und Ausschalten von Modulen erfolgt durch einfaches Auskommentieren einer Linie in einer Skizze, z.

#define LAURENT_FEATURE

oder

//#define LAURENT_FEATURE

Wenn die Zeile auskommentiert ist, wird das Modul nicht kompiliert und nimmt nicht an der Arbeit teil, wie aus den Indikatoren der Module in der Kopfzeile der Site hervorgeht. Oder umgekehrt wird ein kompiliertes und funktionierendes Modul blau angezeigt. In diesem Fall funktioniert das LRT-Steuermodul LRT nicht.

Bild
Modulbetriebsanzeigen

Arbeiten mit Antworten des Laurent-Moduls


Fügen wir nun die Möglichkeit hinzu, Modulantworten nicht nur anzuzeigen, sondern auch mit ihnen zu arbeiten, z. B. zu analysieren oder auf Arduino Mega Server-Webseiten anzuzeigen. Dazu benötigen wir eine neue Zeichenfolgenvariable und eine Konstante, die die Länge der Zeichenfolge bestimmt, die wir den Antworten der Laurent-Module zuweisen. Im Testbeispiel entspricht dies 25 Zeichen. Sie können es jedoch erhöhen, wenn die Antworten nicht in diesen Wert passen. Sie müssen sich nur daran erinnern, dass der RAM des Mikrocontrollers eine wertvolle Ressource ist, und Sie müssen ihn speichern. Fügen Sie dem Standardmodul laurent.ino aus dem AMS-Paket die folgenden Zeilen hinzu:

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

Wir müssen auch den Code der Funktion ändern, die die Anforderungen stellt (hinzugefügte Änderungen werden durch Pfeile hervorgehoben).

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");
    }
}

So haben wir gelernt, wie man Laurent-Antworten in der Variablen lrequest erhält, und jetzt können wir alles tun, was wir für richtig halten. Als Nächstes werde ich zeigen, wie die Ergebnisse von Abfragen direkt im Dashboard in der Kopfzeile der AMS-Site angezeigt werden.

Eine kleine Notiz. In diesem Beispiel wird die Serialprint-Funktion anstelle der Standardfunktion Serial.print verwendet, da dadurch mehr RAM gespart wird. Und es kann leicht in einen Standard umgewandelt werden, indem einfach zwei Wörter beendet werden.

Ausgabe der Modulantwort an den Site-Header


Und das letzte Beispiel. Lassen Sie uns die Antworten der Laurent-Module im Header der Arduino Mega Server-Site anzeigen. Dazu müssen wir die Anforderung zur Hauptschleife () der AMS-Skizze hinzufügen. Öffnen Sie die Datei arduino_mega_server.ino und geben Sie den folgenden Code vor der Funktion cyclosInSecWork () ein:

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

Dieser Code fragt alle dreißig Sekunden den Zustand des Laurent-Moduls ab. Dies ist natürlich nur ein Beispiel, an dieser Stelle kann es jede Anfrage und jeden Code geben. Daher haben wir in der Variablen lrequest eine Antwort auf den Status des Moduls und können diese nun im Header der Site anzeigen. Öffnen Sie dazu das Modul server_ajax.ino und ganz am Ende den Funktionscode responseDash (EthernetClient cl) vor der Zeile cl.println (""). Fügen Sie den folgenden Code hinzu:

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

Dieser Code sendet tatsächlich die Modulantworten an die Webseite. Es bleiben zwei Dinge zu tun: Der erste besteht darin, JavaScript-Code hinzuzufügen, der unsere Daten "abfängt", und der zweite ist der HTML-Code auf der AMS-Seite selbst, auf der die Modulantworten angezeigt werden.

Öffnen Sie also die Datei scripts.js und geben Sie in der Funktion getDashData () vor der schließenden Klammer} // if (this.responseXML! = Null) den Code ein, der unsere Prämissen akzeptiert.

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

Es bleibt nur, die Datei dash.htm aus der Standard-AMS-Lieferung geringfügig zu korrigieren und Code hinzuzufügen, der Informationen auf dem Bildschirm anzeigt. Unmittelbar nach der Zeile mit class = "online-device" geben wir unsere neue Zeile mit dem Code ein:

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

Das ist alles. Wir haben die Antworten des Laurent-Moduls im Header der Arduino Mega Server-Site angezeigt. Und hier ist das Ergebnis unserer Bemühungen. Der Status des Moduls ist im AMS-Bereich deutlich sichtbar und wird alle 30 Sekunden aktualisiert. Wenn also etwas mit dem Modul passiert, werden Sie nach maximal 30 Sekunden darüber informiert.

Bild

Fazit


Wie Sie sehen, ist die Verwaltung von Laurent-Modulen mit Arduino und Arduino Mega Server nicht kompliziert. Wenn Sie bereits über solche Module verfügen oder diese Ihrem Smart Home-System hinzufügen möchten, hilft Ihnen dieser Artikel dabei, dies einfach und unkompliziert zu tun.

Im nächsten Artikel aus dem Zyklus erfahren Sie, wie Sie Loranes direkt vom Bildschirm Ihres Computers aus verwalten und wie Sie den Prozess des Unterrichtens von Kindern im Programmieren interaktiv und interessanter gestalten.

Ergänzung . Ein Youtube-Kanal ist geöffnet und hier ist ein Promo-Video des Arduino Mega Servers, das zeigt, wie man mit einem realen System arbeitet.

Source: https://habr.com/ru/post/de387205/

More articles:


All Articles