🕵️ 🚤 ⌨️ Modules Laurent et Smart Home (Partie 2). Arduino et AMS 😍 👩🏿‍🤝‍👩🏼 👨‍👧‍👦

Ceci est le deuxième article d'une série sur l'intégration des modules Laurent de KernelChip dans les systèmes domotiques, et dans cette partie, nous nous concentrerons sur l'intégration de ces modules avec l'écosystème Arduino. Dans la première partie de la série, nous avons parlé de l'intégration avec le système domotique populaire MajorDoMo, et dans la troisième partie, vous apprendrez à gérer ces modules à partir d'esquisses dans le langage de programmation de traitement, directement depuis le bureau de votre ordinateur.

Arduino est notre tout

Où sans Arduino? Je ne vais pas décrire les avantages de cette plate-forme pendant longtemps, sa popularité parle d'elle-même, alors passons immédiatement aux détails techniques de la mise en œuvre de l'interaction des modules Arduino et Laurent. Et en cours de route, nous n'oublierons pas le système Arduino Mega Server , dérivé très intéressant de l'écosystème Arduino.

Le fer

Pour contrôler des modules sur un réseau, par exemple, la carte Arduino Uno commune ou la carte Arduino Mega tout aussi populaire avec une carte d'interface réseau Ethernet Shield assemblée sur la base de la puce W5100 conviennent. Tous les exemples de cet article sont donnés pour une telle combinaison et ont été testés en pratique. Tout fonctionne de manière fiable et sans aucun problème.

Ethernet Shield basé sur la puce W5100

Autrement dit, il vous suffit de prendre le croquis et de le télécharger sur votre carte Uno ou Mega, après l'avoir légèrement modifié pour vos tâches.

Gérer les modules d'esquisse

Dans la première partie de la série, j'ai déjà parlé des principes de gestion des modules Laurent sur le réseau, pour ceux qui n'ont pas lu la première partie, je vais répéter brièvement la théorie ici.

Les informations sont échangées avec les modules sur le réseau et pour commencer à travailler avec eux, vous devez établir une connexion TCP / IP sur le port 2424. Une fois la connexion établie, vous pouvez envoyer des commandes de texte (dites commandes KE) qui contrôlent le module. Le site Web KernelChip contient une documentation détaillée, y compris une description accessible des commandes KE.

Essayons maintenant de traduire ces «termes de référence» théoriques dans le langage simple des croquis Arduino.

Esquisser

Je ne vais pas expliquer ici comment installer et configurer l'environnement de programmation Arduino, on suppose que vous l'avez déjà fait et que vous pouvez écrire des croquis simples. Donc, pour commencer, nous devons connecter les bibliothèques SPI.h et Ethernet.h nécessaires pour contrôler le bus et le module Ethernet lui-même.

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

Ensuite, vous devez définir les paramètres réseau pour le module Ethernet et le module Laurent, que nous gérerons. Notez que les adresses MAC et les adresses IP doivent être uniques et LAURENT_PORT doit être défini sur 2424 et aucun autre.

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;

Nous avons encore besoin d'un tampon pour stocker les commandes réseau, il est sélectionné avec une taille de 200 octets avec une certaine marge.Si vous avez des problèmes avec un manque de RAM, vous pouvez le réduire, par exemple, à 100 octets ou même moins.

char buf[200];

Et la touche finale est le client Ethernet pour le module Laurent. Nous allons maintenant effectuer toutes les opérations avec le module en utilisant l'objet lclient.

EthernetClient lclient;

Voilà, regardons maintenant une fonction qui envoie des commandes au module Laurent.

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

Si une connexion est établie avec le module Laurent sur le port 2424, le contenu du tampon est envoyé au module et dupliqué en série pour une inspection visuelle. Ensuite, 100 millisecondes sont attendues et la réponse du module est reçue. Après cela, une pause à nouveau et la communication avec le module est interrompue. Si, pour une raison quelconque, la connexion au module n'a pas pu être établie, un message d'erreur s'affiche.

Analysons maintenant l'initialisation. L'initialisation Ethernet est une fonction simple

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

Et le module Laurent est initialisé par la fonction laurentInit (), dont nous allons maintenant analyser le fonctionnement en détail. Il est assez volumineux et vous devez bien le comprendre car c'est à partir du code de cette fonction que vous pourrez construire vos propres requêtes vers les modules Laurent.

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

Initialement, un message d'initialisation s'affiche et une tentative de connexion au module Laurent est tentée. En cas d'échec, un message d'erreur s'affiche et si la connexion au module réussit, une commande d'autodiagnostic est envoyée, à laquelle le module sain doit répondre par «#OK».

Ensuite, une commande est envoyée pour entrer le mot de passe (dans ce cas, c'est le mot de passe par défaut). Et 500 millisecondes est attendue.

Ensuite, deux commandes supplémentaires sont introduites - l'une d'entre elles arrête la sortie de données par le module (si elle disparaît), et la seconde désactive le relais n ° 2, que nous utilisons dans nos expériences. En d'autres termes, ces commandes ramènent le module à un état initial.

Voici une impression du processus d'initialisation sur lequel toutes les commandes et toutes les réponses des modules sont visibles:

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

Maintenant, le code de la fonction setup () standard. Tous les sous-systèmes sont initialisés, y compris un port série à un débit standard de 9600 bauds.

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

Nous avons donc initialisé le module et nous pouvons le gérer comme nous le souhaitons: envoyer des commandes, lire des réponses, construire une logique de contrôle en tenant compte des données émises par le module Laurent.

Considérez, par exemple, la tâche la plus simple - allumer et éteindre à intervalles réguliers la lumière d'une lampe connectée au deuxième relais du module Laurent.

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

La fonction loop () est une boucle infinie et la lampe, obéissant à nos commandes, s'allumera en continu et s'éteindra toutes les 3 secondes. Ceci, bien sûr, n'est qu'un exemple, en fait, la logique de travail peut être n'importe laquelle et tout dépend de vos besoins. Et bien sûr, vous pouvez envoyer non seulement des commandes pour activer ou désactiver les charges, mais aussi toutes les autres prises en charge par le module. Vous pouvez trouver une liste complète des commandes et leur description dans la documentation des modules Laurent.

Vous pouvez prendre ce croquis et l'intégrer dans vos propres projets, leur ajoutant ainsi un support pour la gestion des modules Laurent. Ou vice versa, prenez cette esquisse comme base et augmentez progressivement sa fonctionnalité. Il n'y a pas de limite à la perfection. Voici le croquis complet.

Code d'esquisse complet

#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

Arduino Mega Server (AMS) est un système puissant pour Arduino Mega (maintenant aussi pour Arduino DUE et, bientôt, pour d'autres plates-formes 32 bits M0 (Zero) et Genuino 101), qui contient le code "pour toutes les occasions" et plus encore serveur intégré et interface Web conviviale. AMS prend en charge les modules Laurent dès la sortie de la boîte et vous n'avez pas besoin d'ajouter autre chose que la logique utilisateur.

AMS a une structure modulaire et l'activation et la désactivation des modules se fait simplement en commentant une ligne dans un croquis, par exemple,

#define LAURENT_FEATURE

//#define LAURENT_FEATURE

Si la ligne est commentée, alors le module n'est pas compilé et ne participe pas au travail, comme on peut le voir sur les indicateurs des modules dans l'en-tête du site. Ou vice versa, un module compilé et fonctionnel est indiqué en bleu. Dans ce cas, le module de commande LRT LRT ne fonctionne pas.

Indicateurs de fonctionnement du module

Travailler avec les réponses du module Laurent

Ajoutons maintenant la possibilité non seulement d'afficher les réponses des modules, mais aussi de les utiliser, par exemple, de les analyser ou de les afficher sur les pages Web d'Arduino Mega Server. Pour ce faire, nous avons besoin d'une nouvelle variable chaîne et d'une constante qui détermine la longueur de la chaîne que nous attribuons aux réponses des modules Laurent. Dans l'exemple de test, il est égal à 25 caractères, mais vous pouvez l'augmenter si les réponses ne correspondent pas à cette valeur. Vous devez juste vous rappeler que la RAM du microcontrôleur est une ressource précieuse et vous devez la sauvegarder. Ajoutez les lignes suivantes au module laurent.ino standard du package AMS:

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

Nous devons également changer le code de la fonction qui fait les demandes (les changements ajoutés sont mis en évidence par des flèches).

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

Ainsi, nous avons appris comment obtenir des réponses de Laurent dans la variable de demande et maintenant nous pouvons faire ce que nous jugeons approprié. Ensuite, je vais montrer comment afficher les résultats des requêtes directement dans le tableau de bord dans l'en-tête du site AMS.

Une petite note. Cet exemple utilise la fonction Serialprint au lieu du Serial.print standard car il économise plus de RAM. Et il peut facilement être converti en un standard en mettant simplement fin à deux mots.

Sortie de la réponse du module à l'en-tête du site

Et le dernier exemple. Affichez les réponses des modules Laurent dans l'en-tête du site Arduino Mega Server. Pour ce faire, nous devons ajouter la demande à la boucle loop principale () de l'esquisse AMS. Ouvrez le fichier arduino_mega_server.ino et entrez le code suivant avant la fonction cyclosInSecWork ():

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

Ce code interrogera la santé du module Laurent toutes les trente secondes. Naturellement, ce n'est qu'un exemple, à cet endroit, il peut y avoir n'importe quelle demande et n'importe quel code. Ainsi, dans la variable lrequest nous avons une réponse sur l'état du module et pouvons maintenant l'afficher dans l'en-tête du site. Pour ce faire, ouvrez le module server_ajax.ino et à la toute fin, dans le code de fonction responseDash (EthernetClient cl), avant la ligne cl.println (""); ajoutez le code suivant:

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

Ce code, en fait, envoie les réponses du module à la page Web. Il reste à faire deux choses: la première consiste à ajouter du code JavaScript qui "captera" nos données et la seconde est le code HTML sur la page AMS elle-même, où les réponses du module seront affichées.

Donc, ouvrez le fichier scripts.js et dans la fonction getDashData () avant le crochet de fermeture} // if (this.responseXML! = Null) entrez le code qui acceptera nos locaux.

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

Il ne reste plus qu'à corriger légèrement le fichier dash.htm de la livraison AMS standard et à lui ajouter du code qui affichera des informations à l'écran. Immédiatement après la ligne contenant class = "online-device", nous entrons dans notre nouvelle ligne avec le code:

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

C'est tout. Nous avons affiché les réponses du module Laurent dans l'en-tête du site Arduino Mega Server. Et voici le résultat de nos efforts. L'état du module est clairement visible dans le panneau AMS et il est mis à jour toutes les 30 secondes, donc si quelque chose arrive au module, vous en serez informé après un maximum de 30 secondes.

Conclusion

Comme vous pouvez le voir, il n'y a rien de compliqué à gérer les modules Laurent en utilisant Arduino et Arduino Mega Server, et si vous avez déjà de tels modules ou prévoyez de les ajouter à votre système Smart Home, cet article vous aidera à le faire facilement et simplement.

Et dans le prochain article du cycle, vous apprendrez comment gérer Loranes directement à partir de l'écran de votre ordinateur et comment rendre le processus d'enseignement de la programmation des enfants interactif et plus intéressant.

Addition . Une chaîne Youtube est ouverte et voici une vidéo promo du Arduino Mega Server, qui montre comment travailler avec un vrai système.

Modules Laurent et Smart Home (Partie 2). Arduino et AMS