Archivo de la etiqueta: Formación Node-RED

Versiones Node-RED

Node red pasó a la versión 1.x en septiembre de 2019 con cambios notables, veamos los cambios introducidos en Node-RED a lo largo de sus versiones.

Versiones node-red: https://github.com/node-red/node-red/releases

La última versión a 20 de noviembre de 2020 es la 1.2.5

Novedades Node-Red 0.20: https://programarfacil.com/blog/raspberry-pi/novedades-node-red-0-20/

Salto de la 0.x a la 1.x explica las diferencias:

Version 1.0 (30/09/2019): https://nodered.org/blog/2019/09/30/version-1-0-released

Vídeo versión 1.0: https://www.youtube.com/watch?v=nIVBZQi18fQ&feature=youtu.be 

Versión 1.1 (30/06/2020): https://nodered.org/blog/2020/06/30/version-1-1-released

Version 1.2 (15/10/2020): https://nodered.org/blog/2020/10/15/version-1-2-released

Vídeo versión 1.2: https://www.youtube.com/watch?v=rnM5sfb2qoY 

Planes de releases: https://nodered.org/blog/2020/07/01/release-plans 

Releases: https://nodered.org/about/releases/ 

Planes de futuro: https://nodered.org/blog/2020/10/13/future-plans 

Vídeo de los creadores de Node-RED hablando del estado de Node-RED: https://openjsf.org/blog/2020/05/13/nodered-ama-recap/

Material Prácticas Curso Node-RED Developer

Para el curso on-line “Node-RED Developer Nivel 1”, el material necesario por parte de los alumnos para realizarlo es:

  • 1 PC o Portátil con conexión a internet.
  • Para seguir el curso on-line es recomendable dos pantallas, una para seguir el vídeo y otra para programar en Node-RED.
  • Una cuenta en github o bitbucket.
  • Opcionalmente software de virtualización instalado para ejecutar Node-RED. p.e. VirtualBox, VMWare Fusion o Docker.
  • Opcionalmente una Raspberry Pi conectada a Internet. Estas Raspberry Pi podrían ser proporcionadas por el Think TIC y configurarlas para acceso remoto desde casa del alumno a los dispositivos ubicados en el Think TIC.
  • Opcionalmente los alumnos con dispositivos IoT podrían conectarse e interactuar con ellos.

Todo el software y documentación utilizado en el curso es libre con licencia creative commons o similar.

Toda la documentación generada para la impartición de este curso será liberada con licencia Creative Commons y podrá ser utilizada bajo sus términos. La documentación estará disponible en https://www.aprendiendoarduino.com/ 

Entorno On-Line de Prácticas

Arquitectura

Se dispone de tres servidores:

  • enriquecrespo.com (S.O. CentOS 8)
    • Mosquitto
    • Grafana
    • Docker
    • Otros servicios públicos
  • aprendiendoarduino.com
    • Documentación curso con WordPress
    • BBDD MySQL públicas

Servidor cloud con las siguientes características:

  • 1 vCPU
  • 2 GB RAM
  • 20 GB SSD

Node-RED

Cada alumno debe tener al menos una instancia de Node-RED instalada en el S.O. o virtualización que desee.

Opcionalmente se puede proporcionar una instancia en enriquecrespo.com. El usuario y contraseña se enviará por correo.

Broker MQTT. Mosquitto

Se usará un broker común para comunicar todos los dispositivos en la dirección: mqtt://enriquecrespo.com:1883

Los alumnos recibirán usuario y contraseña para acceder al broker con permisos de lectura y escritura en aprendiendonodered21/#

Opcionalmente hay una dirección de MQTT seguro en: mqtts://enriquecrespo.com:8883 y MQTT sobre websocket en ws://enriquecrespo.com:9001

Servicios

Base de datos MySQL en https://qaej225.aprendiendoarduino.com/ donde los alumnos podrán usar para almacenar datos. Recibirán por correo las credenciales de acceso.

Grupo de telegram para comunicarse y programar bots.

Hardware Usado para Interactuar

Para interactuar en el curso disponemos de diversos HW conectados.

M5stack: https://m5stack.com/collections/m5-core/products/basic-core-iot-development-kit 

M5Stick-C con sensor ENV:

Goodtimera M5STICKC IoT - Placa de Desarrollo (Bluetooth, WiFi, IoT, ESP32  Stem PYTHO): Amazon.es: Hogar

Arduino UNO + GSM Shield con conexión móvil: https://store.arduino.cc/arduino-gsm-shield-2-integrated-antenna 

Raspberry Pi Zero: Instalada en local con cámara y programada con Node-RED, usada como dispositivo remoto.

Raspberry Pi 3B: Instalada en local con Node-RED, Mosquitto y BBDD, usada como servidor.

Wibeee instalado y publicando datos.

Wibeee ONE 2W

Si el alumno tiene algún HW con que quiera interactuar, puede presentarlo y lo integramos en las prácticas.

Configuración de las Instancias de Node-RED Alumnos

Las instancias de Node-RED de los alumnos están desplegadas con Docker y con configuración personalizada y una serie de configuraciones adicionales  ya hechas.

El acceso es a través de https://enriquecrespo.com:188xx/ siendo xx el número de alumno asignado.

Los puertos 88xx y 83xx también estarán disponibles para cada alumno para exponer una API/Websocket y MQTT respectivamente.

También hay una red interna para comunicar son servicios internos no expuestos como BBDD a las instancias de Node-RED

Comando para levantar el contenedor:

docker run –restart always -d -p 188xx:1880 -p 88xx:80 -p 83xx:1883 –network ‘alumnos’ -v /opt/docker_volumes/nodered_dataxx:/data –name noderedxx nodered/node-red

El fichero de configuración settings.js tiene estas modificaciones:

  • password nodered:
 adminAuth: {
         type: "credentials",
         users: [{
             username: "admin",
             password: "password cifrada usando node-red admin hash-pw",
             permissions: "*"
         }]
     }, 
  • password dahsboard y web estática
 httpNodeAuth: {user:"user",pass:"password cifrada usando node-red admin hash-pw"},
 httpStaticAuth: {user:"user",pass:"password cifrada usando node-red admin hash-pw"}, 
  • activar SSL y certificados
 https: {
       key: require("fs").readFileSync('/data/certificates/privkey.pem'),
       cert: require("fs").readFileSync('/data/certificates/cert.pem')
     },
 requireHttps: true, 
  • activar proyectos
 editorTheme: {
         projects: {
             enabled: true
         }
     } 
  • activar grabar datos en local o en memoria (almacenamiento)
 contextStorage: {
         default: "memoryOnly",
         memoryOnly: { module: 'memory' },
         file: { module: 'localfilesystem' }
     }, 

Presentación del Curso «Node-RED Developer»

Título: “Curso Node-RED Developer. Nivel 1”

Motivación

Node-RED se está convirtiendo en un lenguaje de programación muy popular en IoT/Industria 4.0, que cada vez están adoptando más empresas en sus desarrollo.

Node-RED es una herramienta de programación visual (low-code). Node-Red se ha consolidado como framework open-source para la gestión y transformación de datos en tiempo real en entornos de Industry 4.0, IOT, Marketing digital o sistemas de Inteligencia Artificial entre otros. La sencillez de aprendizaje y uso, que no requiere de conocimientos de programación, su robustez y la necesidad de bajos recursos de cómputo ha permitido que hoy en día se encuentre integrado en prácticamente la mayoría de dispositivos IOT e IIOT del mercado, así como equipos Raspberry, sistemas cloud o equipos locales.

Dentro del itinerario de formación para IoT/Industria 4.0, este curso profundiza de forma práctica en la programación dentro del entorno IoT/Industria 4.0/digitalización. Anteriormente se trataron muchos temas y tecnologías de forma práctica sin profundizar en ellas, para entrar ahora en la programación.

Este curso surge de diversas conversaciones con gente de empresas, alumnos de los cursos de Arduino y especialmente personal del Think TIC en los últimos años donde se ha habla de la necesidad de que las pequeñas y medianas empresas puedan acceder a las ventajas de soluciones IoT o Industria 4.0 que solo pueden acceder las grandes corporaciones.

En anteriores cursos se ha introducido qué es IoT con el uso de tecnologías libres en el Think TIC:

Gracias a la herramientas libres/Open Source es posible democratizar el IoT y la industria 4.0. Antes se necesitaba muchísimo dinero no solo en HW y licencias de SW, sino en consultores que hacen un diseño a medida y realizan la integración de los sistemas, ahora no solo el SW libre y el HW libre y barato, sino que la comunidad da soporte a las dudas, hace documentación y tutoriales, así como librerías para facilitar el trabajo.

Muchas empresas no dan el salto de digitalización porque la inversión inicial puede ser muy alta al necesitar contratar a una empresa externa o herramientas profesionales, pero quién mejor que el personal de la propia empresa que es quien mejor conoce los procesos internos, gracias a la tecnología abiertas, es posible con una pequeña inversión económica y una formación centrada en la digitalización de los procesos.

Objetivo

Node-Red es una herramienta open source de desarrollo/programación basada en flujos. Es una programación visual desarrollada originalmente por IBM para conectar dispositivos de hardware, API y servicios en línea como parte del Internet de las cosas (IoT).

El objetivo de este curso es que el alumno aprenda el uso de Node-RED y la programación visual mediante flujos para su uso en entornos de domótica, IIoT e IoT. El alumno será capaz de instalar, configurar y realizar proyectos de dificultad intermedia usando Node-RED.

Node red es adecuado para profesionales dedicados al Internet de las cosas Industrial (IIoT) y personal dedicado al diseño y prueba de soluciones para la comunicación de equipos de planta con aplicaciones de IT. Dado que la mayoría de dispositivos IoT para industria 4.0 posibilitan realizar un programa de control con la herramienta de Node-Red, el dominio de dicha herramienta permitiría al equipo IIoT explorar y ampliar las soluciones que ofrece a la empresa que lo use.

Al finalizar el curso el alumno será capaz de:

  • Instalar Node-RED en diversas plataformas
  • Conocer el protocolo MQTT
  • Configurar y usar de forma segura Node-RED
  • Usar la programación de flujos de forma eficiente
  • Hacer módulos de funciones en Node-RED
  • Hacer debug de los programas Node-RED
  • Instalar y utilizar nodos
  • Configurar un dashboard
  • Integrar Node-RED con servicios de terceros

Requisitos

Para la realización de este curso es necesario tener conocimientos básicos o experiencia en algunas de estas áreas: programación, redes TCP/IP, redes inalámbricas, protocolos de comunicación, bases de datos, uso de sistemas linux, microcontroladores, autómatas, electrónica, uso de sensores, actuadores, motores, etc… 

También es recomendable nociones básicas de programación, especialmente javascript o Node.js, protocolos IoT (REST y MQTT) y servicios IoT on-line

Es recomendable un conocimiento medio de Inglés puesto que gran parte de la documentación está en Inglés.

Metodología

El curso on-line consiste en 20 horas de formación en directo, repartidas en 10 sesiones de 2 horas en horario de 18:00 a 20:00 entre el 23 de noviembre y el 4 de diciembre.

Al finalizar cada sesión de 2 horas, se propondrá un reto o ejercicio para realizar a lo largo de la duración del curso. Cada día se hará una sesión de tutoría de 1 hora de duración para ayuda, en grupos reducidos, sobre las dudas relativas a los retos o ejercicios propuestos.

La plataforma en vídeo usada será https://meet.jit.si/ y se grabarán todas las sesiones, tanto las de formación como las de tutorías para las prácticas.

Los recursos utilizados para la realización de este curso son:

Además están disponibles otros recursos para ampliar información:

Es posible interactuar en el curso mediante:

Toda la documentación será on-line con el objetivo de mantenerla actualizada y no con un documento físico que se queda obsoleto rápidamente. Después de finalizar el curso toda la documentación on-line seguirá estando disponible de forma pública.

Toda la documentación está liberada con licencia Creative Commons.

Reconocimiento – NoComercial – CompartirIgual (by-nc-sa): No se permite un uso comercial de la obra original ni de las posibles obras derivadas, la distribución de las cuales se debe hacer con una licencia igual a la que regula la obra original.

Aprendiendo Arduino by Enrique Crespo is licensed under a Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.

Contenido del Curso

Toda la documentación del curso y el código usado es libre y accesible desde https://www.aprendiendoarduino.com/cursos/node-red-developer-para-iot-nivel-i/ 

Contenido del Curso

Toda la documentación del curso y el código usado es libre y accesible desde https://www.aprendiendoarduino.com/

  • Presentación del Curso
  • Entorno On-Line de Prácticas
  • Instalación de Node-RED
  • Protocolo MQTT
  • Edge Computing
  • Configurar y securizar Node-RED
  • Node-Red en la Nube
  • Programación Node-RED
  • Nodos Node-RED
  • Dashboard Node-Red
  • Debug Node-RED
  • Funciones en Node-RED
  • Integración con Servicios de Terceros
  • Proyectos con Node-RED

Presentaciones

  • Nombre
  • ¿Has usado Node-RED?
  • ¿Aplicaciones de Node-RED?
  • ¿Hardware con el que interactuar?

Contacto

Para cualquier consulta durante el curso y en cualquier otro momento mediante email: aprendiendoarduino@gmail.com

Twitter @jecrespo: https://twitter.com/jecrespom

Y más información sobre el curso y el autor: http://www.aprendiendoarduino.com/acerca-de/

Saber Más Node-RED Developer

Curso On-Line “Node-RED Developer para IoT (Nivel I)”: https://www.aprendiendoarduino.com/cursos/node-red-developer-para-iot-nivel-i/

Día 1 – «Presentación del Curso»

Reto/Ejercicio: Instalar una instancia privada de Node-RED en Raspberry Pi o en un PC/Portátil.

Instrucciones instalación Node-RED: https://nodered.org/#get-started

Instalar Rapsbian:

Puntos vistos:

Día 2 – «Programación Básica»

Reto/Ejercicio: Hacer los primeros flujos sencillos. Hacer que cuando la temperatura esté fuera de un rango entre 18 y 22 grados, ponga en rojo un elemento del dashboard y mande un email.

¿Qué tal la instalación de Raspbian y Node-RED?

Instalar MQTT Explorer: http://mqtt-explorer.com/

Proceso de instalación certificados letsencrypt: https://letsencrypt.org/

  • Certbot simplifica todo el proceso: https://certbot.eff.org/ 
  • sudo yum install epel-release
  • yum install certbot
  • Solo certificado: certbot certonly –standalone
  • Para renovar hacer: certbot renew
 Congratulations! Your certificate and chain have been saved at:
 /etc/letsencrypt/live/xxxxx/fullchain.pem
    Your key file has been saved at:
 /etc/letsencrypt/live/xxxxx/privkey.pem
    Your cert will expire on xxxx. To obtain a new or tweaked
    version of this certificate in the future, simply run certbot
    again. To non-interactively renew *all* of your certificates, run
    "certbot renew" 

Una vez tenemos los certificados TLS en la ruta indicada, dependiendo del software que los necesite configurarlo, indicando la ruta donde están los certificados.

Puntos vistos:

Día 3 – «Mensajes y Dashboard»

Reto/Ejercicio: Hacer un flujo para publicar datos de CPU, Memoria y temperatura de las Raspberry Pi de casa en MQTT topic aprendiendonodered/alumnoxx/raspberrypi/[CPU,Memoria,Temperatura] y que la instancia de Node-RED del curso las recoja y muestre en el dashboard. Para ello usar el broker MQTT. Opcionalmente usar el broker integrado en Node-RED aedes o HTTP endpoint.

Usar estos nodos:

[{"id":"af22b399.12614","type":"exec","z":"8a81314e.a0f79","command":"vcgencmd measure_temp","addpay":false,"append":"","useSpawn":"","timer":"","name":"RPi Temp.","x":325.2221908569336,"y":46.33333683013916,"wires":[["14f0a295.59181d"],[],[]]},{"id":"408435c9.447fec","type":"exec","z":"8a81314e.a0f79","command":"top -d 0.5 -b -n2 | grep \"Cpu(s)\"|tail -n 1 | awk '{print $2 + $4}'","addpay":false,"append":"","useSpawn":"","timer":"","name":"CPU Load","x":325.2221908569336,"y":126.33333683013916,"wires":[["2c7475c7.6cc01a"],[],[]]},{"id":"8fbcbdf9.549b7","type":"exec","z":"8a81314e.a0f79","command":"free | grep Mem | awk '{print 100*($4+$6+$7)/$2}'","addpay":false,"append":"","useSpawn":"","timer":"","name":"Free Memory","x":325.2222099304199,"y":190.55557250976562,"wires":[["daf6433c.bad81"],[],[]]},{"id":"14f0a295.59181d","type":"function","z":"8a81314e.a0f79","name":"","func":"str = msg.payload\nmsg.payload = str.substring(5,9);\nreturn msg;","outputs":1,"noerr":0,"x":471.888858795166,"y":33.00000190734863,"wires":[["46daa272.4333ac","334a9ddd.345602"]]},{"id":"daf6433c.bad81","type":"function","z":"8a81314e.a0f79","name":"","func":"str = msg.payload\nmsg.payload = parseInt(str.substring(0,str.length - 1));\nreturn msg;","outputs":1,"noerr":0,"x":530,"y":180,"wires":[["1ba39571.ba75ab"]]}]

Vídeos explicando como hacer determinadas cosas en Node-RED. Solicitar aquellos temas que no tengáis claro como hacer.

Datos publicados en Broker MQTT y disponibles para todos. Ver con MQTT Explorer.

Uso de nodo file storage en docker.

  • ruta de fichero en docker es /data
  • ruta por defecto /usr/src/node-red/

Puntos vistos:

Día 4 – «Dashboard y Mensajes»

Reto/Ejercicio: Hacer un dashboard para ver la temperatura de todas las Raspberry Pi publicada en MQTT y sus gráficas. Usar MQTT Explorer para ver que datos

Ejemplo sencillo de dashboard:

Ejercicio día 2:

Como se están publicando los datos en MQTT, verlos con MQTT Explorer. Y datos almacenados.

Puntos vistos:

Día 5 – «Industria y MQTT»

Reto/Ejercicio: Hacer un IFTTT con Node-RED. ¿Ideas?. P.e. si recibo un correo con el subject «twitter», twittear el contenido del correo. P.e. si recibo una llamada por la el HTTP endpoint mandar un email.

IFTTT Propio. Como IFTTT es ahora de pago, hacer tu propio IFTTT con Node-RED. Planes IFTTT: https://ifttt.com/plans

Puntos vistos:

Día 6 – «MQTT y Estructura Flujos»

Reto/Ejercicio: Sobre el ejercicio del día 2, añadir de forma dinámica los umbrales máximos y mínimos de alerta mediante dos sliders en el dashboard.

Puntos del curso ordenados.

Más de 2.2M de datos generados.

Preparad para el próximo día la cuenta de github o bitbucket

Plataforma IoT Low Code: https://elliotcloud.com/. Cinco verticales:

Vídeo del ejercicio día 3:

Código ejercicio 3: https://github.com/aprendiendonodered/ejercicio03

Vídeo del ejercicio día 4:

Código del ejercicio 4: https://github.com/aprendiendonodered/ejercicio04

Puntos vistos:

Día 7 – «Proyectos»

Reto/Ejercicio: Hacer un subflujo con 3 salidas, que pasándole una variable de entorno del topic donde se suscriba y el número de datos a analizar, devuelva la media, máxima y mínima de esos datos por cada salida.

Posible error en web https://www.aprendiendoarduino.com/

Monitorizar el nivel de CO2 en las aulas: https://anaire.org/

Vídeo ejemplo de configuración del color del fondo usando otros botones: https://www.loom.com/share/01e0780081dc4489bf0542e1d8f3b8ec

[{"id":"bce47629.9fe348","type":"tab","label":"Flow 3","disabled":false,"info":""},{"id":"4af7152f.f760fc","type":"ui_button","z":"bce47629.9fe348","name":"Verde","group":"bffdcbc1.a72298","order":3,"width":0,"height":0,"passthru":false,"label":"Verde","tooltip":"","color":"","bgcolor":"green","icon":"","payload":"green","payloadType":"str","topic":"","x":160,"y":80,"wires":[["23266e50.ff3442"]]},{"id":"c80cb0ae.e9bf1","type":"ui_button","z":"bce47629.9fe348","name":"Rojo","group":"bffdcbc1.a72298","order":1,"width":0,"height":0,"passthru":false,"label":"Rojo","tooltip":"","color":"","bgcolor":"red","icon":"","payload":"red","payloadType":"str","topic":"","x":160,"y":160,"wires":[["23266e50.ff3442"]]},{"id":"d9f808b6.2de0e8","type":"ui_button","z":"bce47629.9fe348","name":"Negro","group":"bffdcbc1.a72298","order":2,"width":0,"height":0,"passthru":false,"label":"Negro","tooltip":"","color":"","bgcolor":"black","icon":"","payload":"black","payloadType":"str","topic":"","x":160,"y":260,"wires":[["23266e50.ff3442"]]},{"id":"ac22cd7c.00d88","type":"ui_button","z":"bce47629.9fe348","name":"","group":"bffdcbc1.a72298","order":4,"width":0,"height":0,"passthru":false,"label":"button","tooltip":"","color":"","bgcolor":"{{background}}","icon":"","payload":"","payloadType":"str","topic":"","x":630,"y":160,"wires":[[]]},{"id":"23266e50.ff3442","type":"change","z":"bce47629.9fe348","name":"","rules":[{"t":"set","p":"background","pt":"msg","to":"payload","tot":"msg"}],"action":"","property":"","from":"","to":"","reg":false,"x":380,"y":160,"wires":[["ac22cd7c.00d88"]]},{"id":"bffdcbc1.a72298","type":"ui_group","name":"Default","tab":"601bd98f.ac6fc8","order":1,"disp":true,"width":"6","collapse":false},{"id":"601bd98f.ac6fc8","type":"ui_tab","name":"Home","icon":"dashboard","disabled":false,"hidden":false}]

Vídeos del ejercicio día 5

Código ejercicio día 5: https://github.com/aprendiendonodered/ejercicio05

Integración de Node-RED con email, twitter y HTTP endpoint:

Puntos vistos:

Día 8 – «Funciones»

Reto/Ejercicio: Clonar el proyecto https://github.com/aprendiendonodered/ejercicio04 y añadir toda la información de todas las Raspberry Pi que publican datos en mqtt://enriquecrespo.com:1883 y añadir las chart a cada datos, mostrando los datos de forma visual y personalizando el dashboard.

Corregido los códigos a importar del botón de cambia de color y subflow con variables de entorno MAX y MIN.

KNX en Node-RED: https://flows.nodered.org/node/node-red-contrib-knx-ultimate

Vídeo del ejercicio día 5 publicado.

Puntos vistos:

Día 9 – «Biblioteca Node-RED»

Reto/Ejercicio: Hacer una función que guarde los últimos 20 valores en una variable de contexto y una vez tenga los 20, mande la media, máximo y mínimos por tres salidas y en una cuarta mande los 20 mensajes que ha retenido de forma consecutiva.

Hacer también este mismo ejercicio buscando nodos en https://flows.nodered.org/ que hagan esas funciones.

Puntos vistos:

Día 10 – «Debug Node-RED»

Reto/Ejercicio: Hacer una aplicación con Node-RED y publicar. Recoger datos de una Raspberry Pi, ordenarlos y guardar en formato csv. Luego, obtener los datos pulsando un botón del dashboard y mostrarlos en un chart del dashboard.

Disponibilidad de los servicios tras el curso

  • nodered.enriquecrespo.com se apagará, pero si queréis usarlo durante un tiempo, lo puedo mantener un tiempo
  • mosquitto en enriquecrespo.com permanecerá activo. Si alguien desea un usuario con acceso exclusivo a un grupo de topics, puedo suministrarlo.
  • si alguien quiere una instancia de Node-RED basada en docker en enriquecrespo.com puedo suministrarla.

Nodos AI:

Puntos vistos:

Temas que mandaré la próxima semana:

  • Ejercicios resueltos del curso y vídeos: Ejercicios Resueltos del Curso
  • Tutorial Plataforma IoT segura en VPS o Servidor Público: Node-RED + Mosquitto + Servicios (p.e. InfluxDB y Grafana)

Otros puntos (no los vamos a ver pero hemos hablado de ello):

Otros puntos para futuros cursos:

  • Documentar Flujos
  • Control de Flujos
  • Trabajar con Datos Formateados
  • Ejemplos Node-RED y MQTT
  • Personalización Dashboard Node-RED
  • Ejemplos Dashboard Node-RED
  • Creación de Nodos

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