Geekly articles weekly

Módulos Laurent y Smart Home (Parte 2). Arduino y AMS

Este es el segundo artículo de una serie sobre la integración de los módulos Laurent de KernelChip en los sistemas de automatización del hogar, y en esta parte nos centraremos en la integración de estos módulos con el ecosistema Arduino. En la primera parte de la serie, hablamos sobre la integración con MajorDoMo, un popular sistema de automatización del hogar, y en la tercera parte aprenderá cómo administrar estos módulos a partir de bocetos en el lenguaje de programación de procesamiento, directamente desde el escritorio de su computadora.

imagen

Arduino es nuestro todo


¿Dónde sin Arduino? No voy a describir las ventajas de esta plataforma durante mucho tiempo, su popularidad habla por sí misma, así que veamos de inmediato los detalles técnicos de la interacción entre los módulos Arduino y Laurent. Y en el camino, no olvidaremos el sistema Arduino Mega Server , como un derivado muy interesante del ecosistema Arduino.

Hierro


Para controlar módulos a través de la red, por ejemplo, la placa Arduino Uno común o la placa Arduino Mega igualmente popular completa con una tarjeta de interfaz de red Ethernet Shield ensamblada en base al chip W5100 son adecuadas. Todos los ejemplos en este artículo se dan para tal combinación y se han probado en la práctica. Todo funciona de manera confiable y sin ningún problema.

imagen
Ethernet Shield basado en el chip W5100

Es decir, solo tiene que tomar el boceto y subirlo a su tarjeta Uno o Mega, después de cambiarlo un poco para sus tareas.

Administrar módulos de croquis


En la primera parte de la serie, ya hablé sobre los principios de administrar los módulos de Laurent a través de la red, para aquellos que no han leído la primera parte, repetiré brevemente la teoría aquí.

La información se intercambia con los módulos a través de la red y para comenzar a trabajar con ellos, debe establecer una conexión TCP / IP en el puerto 2424. Una vez establecida la conexión, puede enviar comandos de texto (los llamados comandos KE) que controlan el módulo. El sitio web KernelChip tiene documentación detallada, que incluye una descripción accesible de los comandos KE.

Ahora intentemos traducir estos “términos de referencia” teóricos al lenguaje simple de los bocetos de Arduino.

Bosquejo


No explicaré aquí cómo instalar y configurar el entorno de programación Arduino, se supone que ya lo ha hecho y que puede escribir bocetos simples. Entonces, para empezar, necesitamos conectar las bibliotecas necesarias SPI.h y Ethernet.h para controlar el bus y el módulo Ethernet en sí.

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

Luego, debe establecer la configuración de red para el módulo Ethernet y el módulo Laurent, que administraremos. Tenga en cuenta que las direcciones MAC y las direcciones IP deben ser únicas, y LAURENT_PORT debe establecerse en 2424 y en ninguna otra.

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;

Todavía necesitamos un búfer para almacenar comandos de red, se selecciona con un tamaño de 200 bytes con cierto margen, si tiene problemas con la falta de RAM, puede reducirlo, por ejemplo, a 100 bytes o incluso menos.

char buf[200];

Y el toque final es el cliente Ethernet para el módulo Laurent. Ahora realizaremos todas las operaciones con el módulo utilizando el objeto lclient.

EthernetClient lclient;

Eso es todo, ahora veamos una función que envía comandos al módulo 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 se establece una conexión con el módulo Laurent en el puerto 2424, el contenido del búfer se envía al módulo y se duplica en Serial para inspección visual. Luego se esperan 100 milisegundos y se recibe la respuesta del módulo. Después de eso, una pausa nuevamente y la comunicación con el módulo se interrumpe. Si por alguna razón no se pudo establecer la conexión con el módulo, se muestra un mensaje de error.

Ahora analicemos la inicialización. La inicialización de Ethernet es una función simple.

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

Y el módulo Laurent se inicializa con la función laurentInit (), cuya operación ahora analizaremos en detalle. Es bastante grande y necesita comprenderlo bien porque es sobre la base del código para esta función que puede construir sus propias solicitudes a los módulos 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");
}

Inicialmente, se muestra un mensaje de inicialización y se intenta conectarse al módulo Laurent. Si esto falla, se muestra un mensaje de error, y si la conexión al módulo es exitosa, se envía un comando de autodiagnóstico, al cual el módulo en buen estado debe responder con "#OK".

A continuación, se envía un comando para ingresar la contraseña (en este caso, esta es la contraseña predeterminada). Y se esperan 500 milisegundos.

A continuación, se introducen dos comandos adicionales: uno de ellos detiene la salida de datos por el módulo (si funciona), y el segundo apaga el relé n. ° 2, que usamos en nuestros experimentos. En otras palabras, estos comandos llevan el módulo a un estado inicial.

Aquí hay una impresión del proceso de inicialización en el que todos los comandos y todas las respuestas del módulo son 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

Ahora el código para la función de configuración estándar (). Todos los subsistemas se inicializan, incluido un puerto serie a una velocidad estándar de 9600 baudios.

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

Entonces, inicializamos el módulo y podemos administrarlo de la manera que necesitamos: enviar comandos, leer respuestas, construir lógica de control teniendo en cuenta los datos emitidos por el módulo Laurent.

Considere, por ejemplo, la tarea más simple: encender y apagar a intervalos regulares la luz de una lámpara conectada al segundo relé del módulo Laurent.

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

La función loop () es un bucle infinito y la lámpara, obedeciendo nuestros comandos, se encenderá continuamente y se apagará cada 3 segundos. Esto, por supuesto, es solo un ejemplo, de hecho, la lógica del trabajo puede ser cualquiera y todo depende de sus necesidades. Y, por supuesto, puede enviar no solo comandos para habilitar o deshabilitar cargas, sino también cualquier otro compatible con el módulo. Puede encontrar una lista completa de comandos y su descripción en la documentación de los módulos Laurent.

Puede tomar este boceto e integrarlo en sus propios proyectos, agregando así soporte para administrar los módulos de Laurent. O viceversa, tome este boceto como base y aumente gradualmente su funcionalidad. No hay límite para la perfección. Aquí está el boceto completo.

Código de boceto completo
#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);
}


Mega Servidor Arduino


imagen

Arduino Mega Server (AMS) es un poderoso sistema para Arduino Mega (ahora también para Arduino DUE y, pronto, para otras plataformas de 32 bits M0 (Zero) y Genuino 101), que contiene el código "para todas las ocasiones" y más Servidor incorporado e interfaz web fácil de usar. AMS admite módulos Laurent desde el primer momento y no necesita agregar nada más que lógica de usuario.

AMS tiene una estructura modular y los módulos de encendido y apagado se realizan simplemente comentando una línea en un boceto, por ejemplo,

#define LAURENT_FEATURE

o

//#define LAURENT_FEATURE

Si la línea está comentada, el módulo no se compila y no participa en el trabajo, como se puede ver en los indicadores de los módulos en el encabezado del sitio. O viceversa, un módulo compilado y de trabajo se indica en azul. En este caso, el módulo de control LRT LRT no funciona.

imagen
Indicadores de operación del módulo

Trabajando con las respuestas del módulo Laurent


Ahora agreguemos la capacidad de no solo mostrar las respuestas del módulo, sino también trabajar con ellas, por ejemplo, analizarlas o mostrarlas en las páginas web de Arduino Mega Server. Para hacer esto, necesitamos una nueva variable de cadena y una constante que determine la longitud de la cadena que asignamos a las respuestas de los módulos de Laurent. En el ejemplo de prueba, es igual a 25 caracteres, pero puede aumentarlo si las respuestas no se ajustan a este valor. Solo necesita recordar que la RAM del microcontrolador es un recurso valioso y debe guardarla. Agregue las siguientes líneas al módulo laurent.ino estándar del paquete AMS:

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

También necesitamos cambiar el código de la función que realiza las solicitudes (los cambios agregados se resaltan con flechas).

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

Por lo tanto, aprendimos cómo obtener respuestas de Laurent en la variable lrequest y ahora podemos hacer lo que creamos conveniente. A continuación, mostraré cómo mostrar los resultados de las consultas directamente en el panel del tablero en el encabezado del sitio de AMS.

Una pequeña nota Este ejemplo usa la función Serialprint en lugar del Serial.print estándar porque ahorra más RAM. Y se puede convertir fácilmente en uno estándar simplemente poniendo fin a dos palabras.

Salida de la respuesta del módulo al encabezado del sitio


Y el último ejemplo. Muestremos las respuestas de los módulos Laurent en el encabezado del sitio Arduino Mega Server. Para hacer esto, necesitamos agregar la solicitud al bucle principal () del boceto AMS. Abra el archivo arduino_mega_server.ino e ingrese el siguiente código antes de la función cyclosInSecWork ():

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

Este código consultará el estado del módulo Laurent cada treinta segundos. Naturalmente, esto es solo un ejemplo, en este lugar puede haber cualquier solicitud y cualquier código. Por lo tanto, en la variable lrequest tenemos una respuesta sobre el estado del módulo y ahora podemos mostrarla en el encabezado del sitio. Para hacer esto, abra el módulo server_ajax.ino y al final, en el código de función responseDash (EthernetClient cl), antes de la línea cl.println (""); agregue el siguiente código:

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

Este código, de hecho, envía las respuestas del módulo a la página web. Queda por hacer dos cosas: la primera es agregar código JavaScript que "capturará" nuestros datos y la segunda es el código HTML en la página AMS, donde se mostrarán las respuestas del módulo.

Entonces, abra el archivo scripts.js y en la función getDashData () antes del corchete de cierre} // if (this.responseXML! = Null) ingrese el código que aceptará nuestras premisas.

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

Solo queda corregir ligeramente el archivo dash.htm de la entrega AMS estándar y agregarle un código que muestre información en la pantalla. Inmediatamente después de la línea que contiene class = "online-device", ingresamos nuestra nueva línea con el código:

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

Eso es todo. Hemos mostrado las respuestas del módulo Laurent en el encabezado del sitio Arduino Mega Server. Y aquí está el resultado de nuestros esfuerzos. El estado del módulo es claramente visible en el panel AMS y se actualiza cada 30 segundos, por lo que si algo le sucede al módulo, lo sabrá después de un máximo de 30 segundos.

imagen

Conclusión


Como puede ver, no hay nada complicado en la administración de módulos Laurent con Arduino y Arduino Mega Server, y si ya tiene dichos módulos o planea agregarlos a su sistema Smart Home, este artículo lo ayudará a hacerlo de manera fácil y sencilla.

Y en el próximo artículo del ciclo, aprenderá cómo administrar Loranes directamente desde la pantalla de su computadora y cómo hacer que el proceso de enseñar a los niños a programar sea interactivo y más interesante.

Además . Un canal de Youtube está abierto y aquí hay un video promocional del Arduino Mega Server, que muestra cómo trabajar con un sistema real.

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

More articles:


All Articles