Archivo de la categoría: Wemos D1 mini

MQTT y ESP8266

Para trabajar con MQTT es interesante instalar primero en el ordenador un cliente como MQTT.fx para hacer debug: https://mqttfx.jensd.de/ o MQTT explorer http://mqtt-explorer.com/ 

Para conseguir una comunicación MQTT con ESP8266 o Arduino, emplearemos una librería. Existen muchas disponibles gracias a la comunidad que existe alrededor de Arduino. Concretamente, nosotros emplearemos una de las más conocidas y la más estable y flexible, lo que facilita su uso en proyectos que queramos realizar donde intervengan Arduino y MQTT.

Dicha librería es pubsubclient Arduino Client for MQTT y nos provee de un sencillo cliente que nos permite tanto subscribirnos como publicar contenido usando MQTT. Internamente, usa la API de Arduino Ethernet Client lo que lo hace compatible con un gran número de ‘shields’ y placas como:

  • Arduino Ethernet
  • Arduino YUN
  • Arduino WiFi Shield
  • Intel Galileo/Edison
  • ESP8266
  • ESP32

Web: https://pubsubclient.knolleary.net/ 

Instalar la librería mediante el gestor de librerías:

PubSubClient es una librería compatible con Arduino y ESP8266. Básicamente hace que nuestra placa se comporte como un cliente MQTT, es decir, que podamos publicar mensajes y suscribirnos a un topic o varios para recibir mensajes. Da lo mismo si utilizas un Arduino o un ESP8266, el código es prácticamente el mismo. La diferencia reside en cómo nos conectamos a la red WiFi o Ethernet, cada placa utiliza su propia librería.

Github PubSubClient: https://github.com/knolleary/pubsubclient 

API Documentación: https://pubsubclient.knolleary.net/api.html 

Enviando un mensaje a través del protocolo MQTT con Wemos D1 Mini

Vamos a partir de uno de los ejemplos que vienen dentro de la librería. Lo encontrarás en Archivo>Ejemplos>PubSubClient>mqtt_esp8266. Esta opción te abre el siguiente código: https://github.com/knolleary/pubsubclient/blob/master/examples/mqtt_esp8266/mqtt_esp8266.ino 

Configurar el SSID y el password de la red. En mqtt_server poner la IP de la Raspberry Pi donde se ha instalado el broker Mosquitto.

NOTA: tener en cuenta que si usamos usuario y contraseña debemos usar connect (clientID, username, password) en lugar de connect (clientID) https://pubsubclient.knolleary.net/api.html#connect3   

Código: https://github.com/jecrespo/Curso-IoT-Open-Source/blob/master/mqtt_esp8266/mqtt_esp8266.ino 

Este sketch publica un mensaje «hello world #x” consecutivo cada 2 segundos en el topic “outTopic” y se suscribe al topic “inTopic”. Además  cuando se recibe un mensaje se dispara la función callback que si es un 1 enciendo el led integrado y en caso contrario se desactiva.

Firmware para Wemos D1 Mini + Shields

El firmware para los nodos remotos:

Probar cada firmware y hacer un programa sencillo para interactuar con ellos.

Firmware de otros nodos remotos: https://github.com/jecrespo/Curso-Node-RED/tree/master/Remote%20Nodes%20Firmware/Firmware%20M5Stack%20Varios 

Topic Map

El topic map del firmware de los dispositivos es:

  • curso/wemos/{nombre}/dato10s – publica mensaje numerado cada 10s
  • curso/wemos/{nombre}/dato60s – publica mensaje numerado cada 60s
  • curso/wemos/{nombre}/reset – publica mensaje cada reset o inicio
  • curso/wemos/{nombre}/led – suscrito (1 led ON, otro valor  led OFF)
  • curso/wemos/{nombre}/text – suscrito (muestra el mensaje por pantalla)
  • curso/wemos/{nombre}/rele – suscrito (1 relé ON, otro valor  relé OFF). Firmware relé
  • curso/wemos/{nombre}/oled – suscrito (muestra el mensaje por pantalla oled). Firmware oled
  • curso/wemos/{nombre}/temperatura – publica dato temperatura cada 10 segundos. Firmware DS18B20
  • curso/wemos/{nombre}/matrix – suscrito (0 efecto y apaga, de 1 a 8 ilumina de 1 a 8 líneas de matriz ). Firmware matrix.
  • curso/raspberrypi/{nombre}/CPU – publica Node-RED el datos de CPU 
  • curso/raspberrypi/{nombre}/Temperatura – publica Node-RED el datos de temperatura procesador
  • curso/raspberrypi/{nombre}/Memoria – publica Node-RED el datos de memoria libre
  • curso/wibeee/# – datos eléctricos de Wibeee
  • curso/m5atom/enrique/aviso – suscrito (“alarma” – leds rojos, “aviso” – leds amarillos, “ok” – leds verdes, otro mensaje apaga)
  • curso/m5atom/enrique/boton – al pulsar publica “press” o “longpress”
  • curso/m5stack/enrique/A – al pulsar botón A publica “press”
  • curso/m5stack/enrique/B – al pulsar botón B publica “press” 
  • curso/m5stack/enrique/C – al pulsar botón C publica “press”
  • curso/m5stack/enrique/led – suscrito (1 dibuja en pantalla círculo rojo, otro valor  dibuja en pantalla círculo verde)
  • curso/m5stack/enrique/text – suscrito, muestra por pantalla el texto
  • curso/m5stick/enrique/temperatura – publica dato temperatura cada 1 segundo
  • curso/m5stick/enrique/humedad – publica dato humedad cada 1 segundo
  • curso/m5stick/enrique/presion – publica dato presión cada 1 segundo
  • curso/m5stickplus/enrique/distancia – publica dato distancia cuando se activa
  • curso/m5stickplus/enrique/button – al pulsar botón publica “press”
  • curso/m5stickplus/enrique/led – suscrito (1 led ON, otro valor  led OFF)
  • curso/m5stickplus/enrique/label  – suscrito (“red” – circulo rojo, “yellow” – circulo amarillo, “green” – circulo verde, “black” – circulo negro)

Práctica 3: Wifi con ESP8266

Configurar la wifi del Wemos D1 mini para mandar datos de los sensores.

Esquema:

Resultado de imagen de thingspeak esp8266

Tareas a realizar:

Solución

Escaner wifi: https://github.com/jecrespo/aprendiendoarduino-curso-esp8266-youtube/blob/master/WiFiScanMejorado/WiFiScanMejorado.ino 

Escaner wifi + oled: https://github.com/jecrespo/Curso-Node-RED/blob/master/Remote%20Nodes%20Firmware/wifi_scanner%2Boled/wifi_scanner%2Boled.ino 

Conectar por HTTP a aprendiendoarduino.com: https://github.com/jecrespo/aprendiendoarduino-curso-esp8266-youtube/blob/master/WiFiClientBasicMejorado/WiFiClientBasicMejorado.ino 

Instalar librería MQTT para arduino, “PubSubClient”, mediante el gestor de librerías:

Web: https://pubsubclient.knolleary.net/

Ejemplo mqtt_esp8266: https://github.com/knolleary/pubsubclient/blob/master/examples/mqtt_esp8266/mqtt_esp8266.ino 

Comprobar que manda y recibe mensajes y que se enciende y apaga el led.

Thingspeak

Instalar la librería “thingspeak” del gestor de librerías de Arduino

Darse de alta en Thingspeak. Web: https://thingspeak.com/users/sign_up

Crear cuenta:

Crear un Nuevo Canal llamado: “Curso IoT”

Crear 4 Fields en el canal:

  • Temperatura – Guarda los datos de temperatura
  • Humedad – Guarda los datos de humedad
  • Presión – Guarda las aperturas de puerta
  • Iluminación – Guarda las aperturas de puerta

Guarda la API Key y el número de canal

Abrir el ejemplo Thingspeak — ESP8266 — program board directly — WriteMultipleFiledsSecure de la librería thingspeak

Completar los datos del fichero secrets.h (segunda pestaña):

  • SSID – SSID de la Wifi que usemos
  • SECRET_PASS — Password de la Wifi
  • SECRET_CH_ID — ID del canal creado
  • SECRET_WRITE_APIKEY — API key de Thingspeak

Ejecutar el ejemplo y comprobar en el monitor serie que manda datos. Comprobar que se conecta y sale el mensaje “Channel update successful.” cada 2’ segundos

Crear una vista privada y visualizar los datos de los 4 campos creados.

Conectar el shield DS18B20 y oled al Wemos D1 mini.

Cargar el  programa modificado para que mande los datos de temperatura del sensor DS18B20 al field 1 y lo muestre por la pantalla OLED: https://github.com/jecrespo/Curso-Node-RED/blob/master/Remote%20Nodes%20Firmware/Thingspeak_WriteMultipleFieldsSecure/Thingspeak_WriteMultipleFieldsSecure.ino

Práctica 2: Sensorización IoT con ESP8266

Programar los sensores, actuadores y periféricos que conectaremos a Internet como nodos remotos (motes). Programar la toma de datos de sensores, accionar los actuadores y usar los periféricos.

Pasos a realizar:

Módulos:

Solución

Instalar librerías:

Firmware de uso de cada shield:

Demo IoT

En esta demo se va a ver la potencia de IoT con la combinación de varias tecnologías open source. Se usará Arduino y dispositivos compatibles con Arduino, Raspberry Pi, Node-RED y otras tecnologías como Telegram.

Además, esta demo pretende ser interactiva, es decir, que una vez vista esta demostración, cualquiera con las herramientas y código proporcionado y los elementos hardware descritos, podrán interactuar con la plataforma IoT de la demo.

Descripción de la Demo

Esta demo consiste en conectar múltiples dispositivos basados en Arduino de cualquier persona del mundo e interactuar con la plataforma IoT instalada en una Raspberry Pi, así como usar un grupo de Telegram para recibir avisos y alertas.

Para conectar todos los dispositivos basados en Arduino usaremos un broker MQTT público, en nuestro caso será MyQttHub https://myqtthub.com/, pero también podría usarse CloudMQTT https://www.cloudmqtt.com/.

Es imprescindible tener el usuario y contraseña del broker para interactuar, si no las tienes puedes pedirlas en aprendiendoarduino@gmail.com

Para saber más de MQTT puedes ver: https://aprendiendoarduino.wordpress.com/2018/11/19/mqtt/

Esta es la estructura que vamos a usar:

Cada dispositivo Arduino publicará en el broker MQTT un dato en un topic y en función del topic, la plataforma IoT basada en Node-Red y ejecutándose en una Raspberry Pi, realizará una serie de acciones.

Además usaremos el grupo de telegram https://t.me/aprendiendoarduinocursoarduino para la recepción de alertas e interactuar con un bot en los dispositivos conectados. Únete al grupo de telegram para interactuar.

Cada dispositivo basado en Arduino conectado a Internet (p.e. basado en ESP8266) se conecta al broker MQTT público mandando o recibiendo datos y esos datos son recibidos en la plataforma IoT basada en Node-RED, instalada en una Raspberry Pi en la sede central.

El dispositivo puede publicar datos en unos topics determinados que se leerán desde Node-RED y se ejecutarán una serie de acciones.

También el dispositivo se puede suscribir a unos topics determinados y leer los datos recibidos, así como ejecutar una serie de acciones en función de los datos recibidos.

Funcionalidades de la Demo

Los dispositivos basados en Arduino podrán hacer las siguientes acciones:

  • Mandar mensajes de alerta. Por ejemplo la apertura de un detector magnético. Cuando se reciba, se mandará un mensaje al grupo de Telegram con el estado del sensor y quien lo manda y se visualizará en https://www.aprendiendoarduino.com/servicios/mensajes/index.html
  • También se mandará una foto al grupo de Telegram cuando se reciba el mensaje de alerta.
  • Mandar mensajes de temperatura y/o humedad. Estos datos se almacenarán en una BBDD y se visualizarán en el Dashboard de Node Red y en https://www.aprendiendoarduino.com/servicios/datos/graficas.html
  • También se puede configurar una alerta para enviar a Telegram y al panel de mensajes, en caso que se supere una temperatura o humedad determinada.
  • Recibir mensaje de encendido o apagado del led integrado de Arduino

Para visualizar e interactuar se dispone de:

  • Grupo de Telegram
  • Dashboard de Node-RED, que solo se visualiza en local donde esté instalado
  • Gráficas
  • Alertas

Estructura de topics

Para poder interactuar con la plataforma los mensajes se deben mandar con una estructura de topic concreta:

  • demo/temperatura/Z – envía un dato numérico de temperatura
  • demo/humedad/Z – envía un dato numérico de humedad
  • demo/reset/Z – envía un mensaje de reset al reinicarse
  • demo/alerta/xx – envía un texto de alarma
  • demo/led/xx – envía un dato ON/OFF para el estado del LED

Siendo xx un identificador del nodo que puede ser un nombre o un número y siendo Z un número del 2 al 20 para identificar la gráfica donde visualizar los datos en https://www.aprendiendoarduino.com/servicios/datos/graficas.html.

Elementos de Hardware Usado

Hardware Nodos Remotos

Hardware Nodo Central

Raspberry Pi 3 Model B o superior:  https://www.raspberrypi.org/products/raspberry-pi-3-model-b/. Esta Raspberry Pi tiene instalado Node-RED donde se ejecutará la plataforma y la programación IoT.

Para la fotos una Raspberry Pi conectada a Internet con cámara. Por ejemplo, unas Raspberry Pi Zero W con cámara

Adicionalmente un M5stack para visualizar datos en la pantalla y controlar dispositivos con los botones.

Código Usado

Todo el código usado en la demo está disponible en el repositorio: https://github.com/jecrespo/demo-iot

Interactúa con la Plataforma

Como ejercicio, puedes interactuar con la plataforma y ser parte de la demos

Para la interacción con la demo necesitarás:

Para poder interactuar con la plataforma los mensajes se deben mandar con una estructura de topic concreta:

  • demo/temperatura/Z – envía un dato numérico de temperatura
  • demo/humedad/Z – envía un dato numérico de humedad
  • demo/reset/Z – envía un mensaje de reset al reinicarse
  • demo/alerta/xx – envía un texto de alarma
  • demo/led/xx – envía un dato ON/OFF para el estado del LED

Siendo xx un identificador del nodo que puede ser un nombre o un número y siendo Z un número del 2 al 20.

Los mensajes de alarma se publicarán en el grupo de Telegram https://t.me/aprendiendoarduinocursoarduino

Ejercicios Finales

Veamos unos ejercicios completos con todo lo aprendido durante el curso.

Este ejercicio consiste en el montaje de 15 nodos remotos basados en Wemos D1 mini que gestionaremos con Node-RED y 15 Raspberry Pi con un led y un pulsador cada una y que además ejecutarán Node-RED localmente.

Montaje

Esquema de conexión nodo Remoto Wemos D1 Mini basado en:

Esquema de conexión RAspberry Pi:

  • Pin LED: 12 (GPIO 18) 
  • Pin Pulsador: 16 (GPIO 23) (Usando la resistencia interna de Pulldown)

Preparación

La programación de los nodos remotos basados en ESP8266 se hará mediante Node-RED ejecutado en cada Raspberry Pi, para ello se instalará un firmware que puede obtenerse de: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/firmware-Ejercicio_Final/firmware-Ejercicio_Final.ino.

NOTA: este firmware es para el nodo 14, pero en caso de que el nodo sea otro nº de nodo sustituir estas líneas, siendo X = 1, 2, 3, 4 ,5, 6, ….:

  • const char* publish_10sec = «nodoX/dato10s»;
  • const char* publish_60sec = «nodoX/dato60s»;
  • const char* publish_reset = «nodoX/reset»;
  • const char* subs_led = «nodoX/led»;
  • const char* subs_rele = «nodoX/rele»;
  • if (client.connect(«wemosd1mini187222X»,»usuario_mosquitto»,»password_mosquitto»))

Este firmware publica en un topic cada 10 segundos y en otro cada 60 segundos. Los topics son:

  • nodoX/dato10s
  • nodoX/dato60s

En caso de que el nodo se resete publica en el topic: nodoX/reset

Los nodos estás suscrito a dos topic:

  • nodoX/led – enciende y apaga el led integrado de ESP8266
  • nodoX/rele – enciende y apaga el relé

Para el control del LED y botón de Raspberry Pi, se hará mediante la programación en cada uno de los Node-RED de cada Raspberry Pi.

  • RPiX/led – topic al que se suscribe para indicar si se enciende o apaga
  • RPiX/pulsador – topic al que publica el estado: pulsado (1) o liberado (0)

Testeo del Sistema

Una vez configurado todo el sistema comprobar que cada nodo y Raspberry Pi está publicando los datos y funciona el control al modificar los valores de los topics a los que están suscritos.

Para ello usar un cliente MQTT como MQTT.fx:

  • suscrito a los topics:
    • nodoX/dato10s
    • nodoX/dato60s
    • nodoX/reset
    • RPiX/pulsador
  • publicando a los topics:
    • nodoX/led
    • nodoX/rele
    • RPiX/led

Una vez comprobado que leo los valores que publican los nodos y que puedo modificar el estado de los leds y relé publicando en los topics, pasamos a programar el sistema completo usando Node-RED.

Todo el código de los ejercicios: https://github.com/jecrespo/Curso-Node-RED/tree/master/04-Ejercicio%20Final

Ejercicio 1 – Dashboard

Configura Node-RED para que se vea un dashboard “Home” con tres grupos:

  • Suscripciones: las 3 suscripciones y botón que resete los valores
  • Pulsadores: dos botones para encender led y relé de nodo remoto
  • RPi: un pulsador que maneje el LED de la RPi y un gauge con el estado del pulsador.

Además al pulsar el pulsador encender el led detectando flaco, una pulsación enciende y otra pulsación apaga.

La configuración en Node-RED es:

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_1/Ejercicio_1-1.json

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_1/Ejercicio_1-2.json

Ejercicio 2 – Interacción por Grupos

Crear un nuevo grupo del dashboard Home llamado “Control Relés” con 3 botones que encienda:

  • Botón 1: controla relés 1, 2, 3, 4, 5
  • Botón 2: controla relés 6, 7, 8, 9, 10
  • Botón 3: controla relés 11, 12, 13, 14, 15

Dashboard

Nodos

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_2/Ejercicio_2.json

Ejercicio 3 – Seguridad

Poner un pin para encender los Reles, de forma que si no hay pin no se puede encender desde el dashboard. Simular una cerradura de forma que al poner el pin correcto se abre y luego a los 5 segundos se cierra.

Mostar en el dashboard el estado de la cerradura.

Crear un tab nuevo en el dashboard llamado pin de seguridad

Basarse en el flujo: https://flows.nodered.org/flow/7bcb0b049df4fa3c962294137ebaec19

Hacer el flujo como un subflow.

Dashboard

Flujo

Subflow

Código:

Ejercicio 4 – Email y SMS

Hacer un formulario en el dashboard para mandar un correo electrónico y otro para mandar un SMS usando el servicio de Twilio: https://www.twilio.com/

Dashboard

Flujo

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_4/Ejercicio_4.json

Luego usar esta configuración para enviar un correo y un SMS cuando se pulse el botón de la Raspberry Pi y el relé del nodo remoto 14 esté encendido, viéndolo en un dashboard.

Ejercicio 5 – Imágenes

Coger mediante Node-RED la imagen publicada en http://www.aprendiendoarduino.com/servicios/imagen.jpg y que se actualiza cada 30 segundos en el servidor.

Mostrar la imagen en el dashboard y su información.

Publicar en el topic raspberrypi/image la imagen por MQTT para poder reutilizarla.

Mandar la imagen por email al pulsar un botón.

Dashboard

Flujo

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_5/Ejercicio_5.json

Probar con otros servicios online a coger vídeo o imagen y tratarlo en Node-RED

Ejercicio 6 – Twitter

Hacer un flujo que tuitee algo. Para ello es necesario darse de alta en: https://developer.twitter.com/en/apps

Hacer un flujo que monitorice un hashtag (p.e. #Rioja), lo publique en cloudMQTT y lo guarde en una BBDD MySQL.

Flujo

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_6/Ejercicio_6.json

Ejercicio 7 – Open Weather Map

Usando el node de OpenWeatherMap, hacer un dashboard con la temperatura, humedad y presión donde se actualice el dato en un gauge y se haga una gráfica que muestre los últimos 7 días.

Mandar el dato de la temperatura a los nodos remotos, para ello publicar en el topic “nodoX/temperatura” el dato de temperatura y comprobar que llegan, para ello modificar el firmware para que los nodos remotos estén suscritos y lo muestren por el puerto serie.

Hacer un botón para que mande la predicción de los próximos 5 días al correo electrónico.

Dashboard

Flujo

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_7/Ejercicio_7.json

Ejercicio 8 – Telegram

Hacer un bot de Telegram con Node-RED que mande mensajes a grupos o canales y que responda a determinados comandos.

Para crear un bot de telegram: https://core.telegram.org/bots

Para añadir comandos al bot:

  • /setcommands
  • @aprendiendoarduino_bot

Pasar los comandos:

help – Ayuda
start – Inicio
enciende – Enciende Led
apaga – Apaga led
lee – Muestra datos broker

Y ya tengo los comandos configurados:

  • /help
  • /start
  • /enciende
  • /apaga
  • /lee

Para configurar el bot en Telegram solo hace falta poner el nombre del bot y el token.

Crear un canal o un grupo y hacer un flujo sencillo que al pulsar mande un un mensaje por Telegram a tu usuario y a al grupo o canal.

Ahora queda que desde Node-RED lea los comandos y responda. Al mandar el comando /enciende el LED de la Raspberry Pi al mandar el comando /apaga el LED de la Raspberry Pi. El comando /lee me devuelve el estado del LED.

Una forma de hacer esto es publicando el el topic /raspberrypi/led el valor ON u OFF y ya tengo otro flujo hecho en el ejercicio 1.

Para saber el estado, se puede guardar en una variable de flujo que se actualiza con el topic /raspberrypi/led de forma que no solo cuando modifico desde el bot sino desde otros lugares.

Flujo

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_8/Ejercicio_8.json