Monitorizar la caseta de jardín con microcontroladores y sensores - Parte 3

Estos valores se muestran en el navegador del PC o del smartphone cuando se introduce la dirección IP del servidor web (en mi caso: http://192.168.178.100) en la línea de dirección.

El servidor web está programado de tal manera que emite la palabra "Alarm" cuando se supera una temperatura de 50°C o una concentración de gas de 100. Pero hay que mirar activamente en la página correspondiente para que se muestre todo. Eso no era suficiente para mí, también quería ser notificado con una señal acústica y visual. Así que tuve que evaluar la página web con un microcontrolador o un microordenador, filtrar los valores medidos y, si era necesario, activar la alarma con un zumbador y LED.  En la segunda parte presenté una solución con una Raspberry Pi con WLAN y una pantalla OLED I2C de 128 x 64 píxeles de 1,3 pulgadas.

Ahora quiero presentar la configuración con una placa D1 y un Shield de Teclado LCD:

Hardware requerido para la primera parte:

Hardware requerido para la tercera parte:

El punto de partida para muchos proyectos es la colección de sketches de ejemplo, que se amplía con cada instalación de nuevos microcontroladores o una biblioteca de programas. Rápidamente encontré los sketches WiFiClient y WiFiClientBasic en Examples/ESP8266WIFI, que básicamente sirven para conectarse a páginas web desde Internet.

Dos desafíos (Io aprendí en la OTAN: "No hay problemas, sólo retos"):

En primer lugar, no quiero conectarme a Internet, sino consultar una dirección IP en la red WLAN doméstica. Y en segundo lugar, quiero guardar el texto HTML transmitido en una variable de cadena para su posterior procesamiento.

Así que el Sketch WiFiClientBasic se tiene que ampliar y modificar. Necesitamos las siguientes bibliotecas de programas para registrar la placa D1 con el router en casa y luego leer la página HTML del servidor web en el cobertizo del jardín como cliente web.

 # include 
 # include 
 # include 
 ESP8266Wifimulti Wifimulti;

Por otra parte, se declara el SSID y la contraseña para el acceso WLAN y se introduce la dirección IP del servidor web (en mi caso http://192.168.178.100) y el puerto para HTML (80). Aquí usted tiene que hacer sus propias entradas.

A continuación, se definen las variables globales de los valores medidos para que estén disponibles en todas las funciones.

En el void setup () se establecen las conexiones con el monitor serie del Arduino IDE y con la WLAN doméstica.

La consulta regular del servidor Web se realiza con http.GET() y http.GetString () en el bucle void (), la página web completa se almacena en la variable payload.

Después de muchas líneas de formato y del código para la actualización automática de la página web en el navegador, al final encontramos los valores medidos deseados para la temperatura, la humedad relativa del DHT22 y para la concentración de gas del MQ-2. Al principio, lo único que ayuda es "Tabula rasa" = Borrar los primeros 721 caracteres con el método de cadena StringName.substring (from,to). En mi caso from=722, to es opcional y se puede omitir.

Con un bucle for busco entonces los índices de las letras T (para la temperatura), H (para la humedad) y G (para la concentración de gas) como valores de referencia para la reutilización del método StringName.substring (from,to). He tenido que trastear un poco con los valores respectivos de los parámetros from y to, porque la temperatura puede tener uno o dos dígitos y posiblemente un signo menos, y el valor de la concentración de gas puede tener dos o tres dígitos. Afortunadamente, el método String.toFloat () es muy tolerante e ignora los espacios en la temperatura y el carácter < al final de un valor de dos dígitos para la concentración de gas.

Voilá, esto muestra los valores de temperatura, humedad y concentración de gas en el Monitor serie. Aquí está el boceto (parcial) para descargar.

Pero eso es solo la mitad de la historia. Queremos utilizar la placa D1 sin conectarla al PC y, si es necesario, activar una alarma cuando se superen los valores límite. Así que necesitamos una pequeña pantalla, por supuesto, nuestro zumbador de nuevo y, si es necesario, un LED rojo para la alarma cuando se superen los valores límite.

Por su practicidad, utilizo el LCD Keypad Shield. Los detalles sobre cómo utilizar el teclado (es decir, los botones) se pueden encontrar en la publicación "El nuevo D1 con ESP8266mod-12F en formato Uno". Pero no necesitamos las llaves aquí. Sólo utilizamos la pantalla LCD, que se conecta a los pines GPIO aquí. Así que instale e incluya la biblioteca correspondiente (no I2C) y defina los pines de acuerdo con el diagrama de pines de la placa D1:

 // La pantalla LCD no tiene un adaptador I2C, los datos se transfieren a través de los pines D4 a D7
 #include 
 // Pin LCD a Arduino
 const En t pin_bl = 15; 
 const En t pin_en = 2; 
 const En t pin_rs = 0; 
 const En t pin_d4 = 4; 
 const En t pin_d5 = 14; 
 const En t pin_d6 = 12; 
 const En t pin_d7 = 13;  

Utilizamos el Pin libre D2 = GPIO16 para el zumbador y el LED.

Aquí está el sketch extendido: (descargar)

 /*
     Este boceto lee el texto HTML de un servidor TCP en su red local.
     Por Gerald Lechner y Bernd Albrecht para AZ-Entrega * /
  
 #include 
 #include 
  
 #include // *** Cliente HTTP
  
 #IFNDEF STASSID
 #define stassid "su ssid"
 #define stapsk "tu contraseña"
 #endif
  
 const char * ssid     = Sassid;
 const char * contraseña = Staptk;
  
 const char * url = "Http://192.168.178.100";
 const uint16_t Puerto = 80;
  
 // La pantalla LCD no tiene un adaptador I2C, los datos se transfieren a través de los pines D4 a D7
 #include 
 // Pin LCD a Arduino
 const En t pin_bl = 15; 
 const En t pin_en = 2; 
 const En t pin_rs = 0; 
 const En t pin_d4 = 4; 
 const En t pin_d5 = 14; 
 const En t pin_d6 = 12; 
 const En t pin_d7 = 13;  
  
 Cristal liquido LCD( pin_rs,  pin_en,  pin_d4,  pin_d5,  pin_d6,  pin_d7);
  
 flotador t = 0.0;
 flotador H = 0.0;
 flotador GRAMO = 0.0;
 En t Indext;
 En t índice;
 En t Índice;
 En t zumbador=16;
  
 Esp8266wifimulti Wifimulti;
  
 vacío configurar() {
   De serie.empezar(115200);
   // Inicializar el PIN DIGITAL D2 = GPIO16 en cuanto a la salida.
   mono(zumbador, PRODUCCIÓN);  
   LCD.empezar(16, 2);       // LCD1602 con 16 caracteres y 2 líneas
   // Comenzamos conectándonos a una red WiFi
   Wifi.Moda(Wifi_sta);
   Wifimulti.addap(ssid, contraseña);
  
   De serie.imprimir();
   De serie.imprimir();
   De serie.impresión("Espera a WiFi ...");
  
   tiempo (Wifimulti.correr() != Wl_connected) {
     De serie.impresión(".");
     demora(500);
   }
  
   De serie.imprimir("");
   De serie.imprimir("WiFi conectado");
   De serie.imprimir("Dirección IP: ");
   De serie.imprimir(Wifi.localizar());
  
   demora(500);
 }
  
  
 vacío círculo() {
   De serie.impresión("conectado a ");
 // serial.print (host);
   De serie.impresión(url);    // neu
   De serie.impresión(':');
   De serie.imprimir(Puerto);
  
  
   // **** neue hauptschleife
   si ((Wifimulti.correr() == Wl_connected)) {
  
     Wificliente cliente;
  
     Httpclient http;
  
     De serie.impresión("[HTTP] comienza ... \ N");
     si (http.empezar(cliente, url)) {  // http "url" "" entffernt
  
  
       De serie.impresión("[Http] consigue ... \ n");
       // Iniciar conexión y enviar encabezado HTTP
       En t código httpcode = http.OBTENER();
  
       // httpcode será negativo en error
       si (código httpcode > 0) {
         // Se ha enviado encabezado HTTP y se ha manejado el encabezado de respuesta del servidor
         De serie.printf("[Http] Get ... Código:% d \ n", código httpcode);
  
         // archivo encontrado en el servidor
         si (código httpcode == Http_code_ok || código httpcode == Http_code_moved_permanely) {
           Cuerda carga útil = http.getstring();
           Cuerda Payload1 = carga útil.subcadena(722);
 // serial.println (carga útil);
 // serial.println ();
           De serie.imprimir(Payload1);
           por (En t I=0;I<=Payload1.largo();I++)  
             {
               si (Payload1.charat(I) == 'T') indext = I;
 // serial.println (Index);
               si (Payload1.charat(I) == 'H') índice = I;           
 // serial.println (indexh); 
               si (Payload1.charat(I) == 'GRAMO') índice = I;           
 // serial.println (indexg);
               } 
             Cuerda Tstring = Payload1.subcadena(indext+12,índice-10);
             Cuerda Hermana = Payload1.subcadena(índice+10,índice+12);
             Cuerda Gstring = Payload1.subcadena(índice+18,índice+22);
 // serial.println (Payload1);
             De serie.imprimir(Tstring);
             De serie.imprimir(Hermana);
             De serie.imprimir(Gstring);
             t = Tstring.flotar();
             h = En t(Hermana.flotar());
             gramo = En t(Gstring.flotar());
             De serie.imprimir(t,1);
             De serie.imprimir(En t(h));
             De serie.imprimir(En t(gramo)); 
             LCD.claro(); 
             LCD.setcursor(0,0);     // Zählung Beginnt Bei Null, Ert Zeichen, Dann Zeile
             LCD.impresión("T =");
             LCD.impresión(Cuerda(t));
             LCD.impresión("H =");
             LCD.impresión(Cuerda(En t(h)));            
             LCD.setcursor(0,1);     // 0 = erstes zeichen, 1 = zweite zeile
             LCD.impresión("G =");
             LCD.impresión(Cuerda(En t(gramo))); 
             si (t>50.0 || gramo>100) {
               LCD.impresión("¡Alarma!");
               escritura digital(zumbador, ELEVADO);   // girar el timbre y liderado en
               demora(200);                       // Espere
               escritura digital(zumbador, BAJO);    // girar el zumbador y liderado
               demora(100);                        // Espere
               escritura digital(zumbador, ELEVADO);   // girar el timbre y liderado en 
               demora(200);                       // Espere
               escritura digital(zumbador, BAJO);    // girar el zumbador y liderado 
               demora(100);                       // Espere
               }        
           }
         }
       demás {
         De serie.printf("[HTTP] Get ... Falló, error:% s \ n", http.errorestra(código httpcode).c_str());
       }
  
       http.fin();
     } demás {
       De serie.printf("[Http} no se puede conectar \ n");
     }
   }
  
   demora(5000);
 }

En el blog de tres partes presenté cómo enviar los datos de los sensores a través de la WLAN doméstica y mostrar los valores en el PC, smartphone, con Raspberry o ESP8266 (incluso todos al mismo tiempo) y activar una alarma cuando se superan los valores de umbral. Como se mencionó al principio, también podrá añadir detectores de movimiento y otros sensores como dispositivo antirrobo. Diviértase construyendo.

Descargar en formato pdf