Archivo del Autor: jecrespom

Acerca de jecrespom

Twitter: @jecrespom

Diario del Curso IoT, Smart Cities y Node-RED

El diario del curso es una herramienta para seguir los puntos vistos en cada sesión del curso, que permite conocer el avance sesión a sesión.

También sirve para documentar los puntos y dudas que surgen en el curso fuera del temario, pero que es importante tenerlo por escrito como: enlaces interesantes, ampliar un tema de interés, tecnologías relacionadas, etc…

Sesión 1 (3 de mayo) – «Presentación Curso»

Capítulos vistos:

Sesión 2 (4 de mayo) – «Hardware IoT»

Smart Spots: https://smartcities.hopu.eu/index.html

OPA LWM2M: https://en.wikipedia.org/wiki/OMA_LWM2M

Logroño ciudad Inteligente: https://ciudadinteligente.logrono.es/

Soldar Módulos Wemos D1 Mini:

  • Usar espadines hembra en los ESP8266
  • Usar espadines macho en los shields: relé, oled y led.
  • Usar espadines macho/hembra (los más alargados) en el resto de shields: DHT11, DS18B20, BMP180,

Nodos y Firmware: https://aprendiendoarduino.wordpress.com/2021/12/05/material-curso-node-red/

Capítulos vistos:

Sesión 3 (9 de mayo) – «Comunicaciones IoT»

Plataforma Smart cities: https://elliotcloud.com/smart-cities-2/

Acceso a los metadatos: https://sacseguridad.com/auto-entrenamiento-y-aprendizaje-de-las-camaras-de-video-bosch-o-camera-trainer/

Bosch Metadata Publisher
Es una herramienta gratuita que permite al desarrollador de aplicaciones utilizar el protocolo MQTT y así poder trabajar en ambientes de comunicación M2M (Machine to Machine) o IoT (Internet of Things), posibilitando el desarrollo de aplicaciones que involucren dispositivos de automatización industrial o de edificios con base en la generación de metadatos por parte de la cámara.

Metadata y eventos de analíticas vía ONVIF
Con la interfaz de conformidad ONVIF disponible en las cámaras Bosch con FW 6.10 y superior se es compatible para recibir eventos de análisis basados en el motor de reglas de IVA en el borde y la secuencia de metadatos en el formato ONVIF. Use esta funcionalidad para desarrollar interfaces de integración con sistemas VMS de terceros, o para desarrollar sus propias aplicaciones de software que toman como base el foro ONVIF.

Capítulos vistos:

Sesión 4 (11 de mayo) – «Protocolos IoT»

Actualizada parte de SQLite en Instalación de Servicios en Raspberry Pi OS

Actualizada lista de librerías en Sensorización IoT con ESP8266

Listado completo de firmware de shields: https://github.com/jecrespo/Curso-Node-RED/tree/master/Remote%20Nodes%20Firmware/Wemos%20Shields%20Usage

HW LoRaWAN:

LoRa Network Server: https://www.chirpstack.io/

Broker MQTT:

  • Host: aprendiendonodered.com
  • Port: 8883
  • username: cursomqtt
  • Topic Path: cursomqtt/#

Capítulos vistos:

Sesión 5 (16 de mayo) – «MQTT»

Demo LoRa punto a punto: https://www.aprendiendoarduino.com/2018/03/07/demo-lora-con-moteino/

Datos enviados a Broker MQTT

Mosquitto Clients Count. Se quedan las conexiones al hacer un deploy. Probar con netstat -ntp | grep ESTABLISHED.*mosquitto

Configuración mosquitto: https://mosquitto.org/man/mosquitto-conf-5.html

  • message_size_limit
  • max_queued_messages
  • memory_limit
  • max_connections

Capítulos vistos:

Sesión 6 (18 de mayo) – «Instalación y Configuración Node-RED»

Problema en el cierre de socket en nodos MQTT: https://github.com/node-red/node-red/issues/3593

NodeRed 3.0.0-beta.1: https://discourse.nodered.org/t/node-red-3-0-0-beta-1-released/62124

Instalada beta en https://enriquecrespo.com:18809/

Instalar en Docker Node-RED dev: https://hub.docker.com/r/nodered/node-red-dev/tags

Demo Sigfox: https://www.aprendiendoarduino.com/2018/03/05/demo-mkrfox1200/

HW Sigfox:

Capítulos vistos:

Sesión 7 (23 de mayo) – «Node-RED»

TTN: The Things Network (TTN) es una iniciativa basada en la comunidad para establecer una red global de IoT. La iniciativa fue lanzada por Wienke Giezeman en 2015 y actualmente cubre más de 20.000 pasarelas LoRaWAN instaladas en más de 150 países. Los voluntarios se encargan de la construcción, el cuidado y el pago de los portales

Plantilla settings.js para Node-RED: https://github.com/jecrespo/configuracion-node-red

Múltiples instancias Node-RED con inicio mediante systemd:

  • https://nodered.org/docs/faq/customising-systemd-on-pi
  • Copiar el directorio completo .node-red: cp -R .node-red/ .node-red_1
  • Modificar en settings.js: uiPort: process.env.PORT || 1881 y userDir: ‘/home/pi/.node-red_1/’
  • sudo find / -name nodered.service (buscar donde está el servicio generalmente bajo /usr/lib/systemd/system/nodered.service)
  • sudo cp nodered.service nodered2.service
  • Añadir la línea: Environment=”NODE_RED_OPTIONS=-s /home/pi/.node-red2/settings.js”
  • sudo systemctl enable nodered2.service
  • sudo systemctl start nodered2.service

Capítulos vistos:

Sesión 8 (25 de mayo)

Sesión 9 (30 de mayo)

Sesión 10 (1 de junio)

Sesión 11 (9 de junio – presencial)

Otros

Otros puntos:

Material Curso Smart Cities

Para el curso on-line “Fundamentos IoT y Desarrollo con Node-RED para Smart Cities”, el material necesario por parte de los Asistentes 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.

El PC de cada asistente deberá tener un sistema operativo instalado, ya sea un sistema Windows, MacOS o Linux. Las licencias del Sistema Operativo y el software que tenga correrán a cargo del cliente/alumno.

  • Nodo Edge/Gateway. Instalación Node-RED. Recomendable usar Raspberry Pi + tarjeta SD 16Gb + alimentador conectada a Internet por alumno, pero podría usarse una máquina virtual o en un servidor cloud. Opcionalmente puede usarse instancias en la nube de Node-RED desde el servidor de https://www.aprendiendoarduino.com/ 

Las Raspberry Pis se usarán como instancias de Node-RED y nodos edge a los que se conectan los nodos remotos, por lo que no conectaremos sensores/actuadores/periféricos a las Raspberry Pi.

  • Nodos remotos por asistente compuesto por el siguiente material:
    • 2x Wemos D1 min o NodeMCU o equivalente
    • 1x shields para wemos D1 mini relé o equivalente
    • 1x shields para wemos D1 mini neopixel o equivalente
    • 1x shields para wemos D1 mini oled o equivalente
    • 1x shields para wemos D1 mini temperatura (puede ser DHT o
    • de temperatura) o equivalente
    • 1 x Cable USB para programar Wemos

Si el alumno tiene algún HW con que quiera interactuar, puede presentarlo y lo integramos en las prácticas. El HW puede estar tanto en el aula como remotamente en su casa, oficina, etc…

Servicios Cloud para el Curso

Se usará un broker común para comunicar todos los dispositivos: mqtts://aprendiendonodered.com:8883

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

Base de datos MySQL en https://enriquecrespo.com/phpmyadmin/ donde los alumnos podrán usar para almacenar datos. Los alumnos recibirán las credenciales de acceso.

Base de datos InfluxDB en https://enriquecrespo.com:8086/ donde los alumnos podrán usar para almacenar datos. Los alumnos recibirán las credenciales de acceso.

Grafana en https://enriquecrespo.com:3000/ para representar gráficamente los datos. Recibirán por correo las credenciales de acceso.

Otros servicios programados con Node-RED en aprendiendonodered.com: API, Open Data, servidor FTP, gateway servicios de terceros, simulación de datos, etc… y servicios self hosted (gotify, thingsboard, thinger.io, etc…)

Interacción con servicios cloud de terceros como: APIs, Open Data, Cámaras/Imágenes, Plataformas IoT, Redes Sociales, Servicios de Mensajería, Servicios de alertas, email, etc…

Topología de Prácticas

Presentación Curso Smart Cities

Título: “Fundamentos IoT y Desarrollo con Node-RED para Smart Cities”

El curso semipresencial “Fundamentos IoT y Desarrollo con Node-RED para Smart Cities” ha sido diseñado para conocer los fundamentos de IoT en aplicaciones de Smart Cities para capacitar en nuevas tecnologías. Este curso está enfocado en dar a conocer las nuevas tecnologías utilizadas en Smart Cities, con el fin de operar e integrar las plataformas IoT.

Motivación

Gracias a las 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.

En la industria conectada e IoT, cada vez se está haciendo más popular el uso de Node-RED debido a su estabilidad, continuo desarrollo y aportaciones externas que hacen de ella una herramienta de programación utilizada para conectar dispositivos de hardware, APIs y servicios de internet.

Node-RED es una herramienta de programación (Low Code Programming) que se utiliza para conectar dispositivos de hardware, APIs y servicios de internet. Adecuado para los equipos dedicados al Internet de las cosas ( IoT) 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á al equipo IoT explorar y ampliar las soluciones que ofrece.

Objetivos

El objetivo de este curso es conocer las tecnologías necesarias para el desarrollar soluciones IoT/Smart Cities y valiéndonos para ello de herramientas, tecnologías, protocolos y software libre/open source que hay a nuestra disposición, en especial el uso de Node-RED, desarrollo e integración con sistemas externos y plataformas enfocadas IoT/Smart Cities

Con los conocimientos adquiridos, los asistentes aprenderán las tecnologías necesarias para hacer aplicaciones IoT/Smart Cities sencillas o integrar desarrollos propios en sistemas ya implantados.  Se adquirirán conocimientos en cuanto manejo, montaje y parametrización de redes de comunicación IoT, protocolos IoT y hardware IoT.

Se aprenderá a usar Node-RED, un framework enfocado a IoT para programar, automatizar e integrar plataformas IoT.

Metodología Curso On-Line

El curso se realizará entre el 3 de mayo y el 9 de junio de 2022.

El curso semipresencial consiste en 36 horas de formación, repartidas de la siguiente forma:

  • 10 sesiones on-line en directo de 3 horas cada una los lunes y miércoles de 17:00 a 20:00 entre el 3 de mayo y el 1 de junio de 2022. Se realizará un descanso de 10-15 minutos a la mitad de las sesión.
  • Una sesión presencial de 6 horas el 9 de junio de 2022 en las instalaciones del cliente, que se organizará a lo largo del curso.

La plataforma en vídeo usada será https://meet.jit.si/aprendiendoarduino y se grabarán todas las sesiones. En casos de problemas con esta plataforma se podrá usar Google Meet.

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

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 – Compartir Igual (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.

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, etc…

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

Programación del Curso

FechaTemarioHoras On-line (live)Prácticas
Día 1
3 de mayo
17:00-20:00
Presentación
Fundamentos IoT
Verticales IoT/Smart Cities
1h
1h 30m
30m
0
Día 2
4 de mayo
17:00-20:00
Hardware IoT (1/2)
Comunicaciones IoT (1/2)
1h
1h 
1h – Práctica 1: Instalación y Configuración Raspbian
Día 3
9 de mayo
17:00-20:00
Hardware IoT (2/2)
Comunicaciones IoT (2/2) 
1h
1h
1h – Práctica 2: Sensorización y Comunicación con ESP8266 (1/2)
Día 4
11 de mayo
17:00-20:00
Protocolos IoT (1/2)
2h1h – Práctica 2: Sensorización y Comunicación con ESP8266 (2/2)
Día 5
16 de mayo
17:00-20:00
Protocolos IoT – MQTT (2/2)1h 30m1h 30m – Práctica 3: Wifi + MQTT con ESP8266
Día 6
18 de mayo
17:00-20:00
Administración Node-RED (1/2)1h 30m1h 30m – Práctica 4: Instalar y configurar Node-RED (1/2)
Día 7
23 de mayo
17:00-20:00
Administración Node-RED (2/2)1h 30m1h 30m – Práctica 4: Instalar y configurar Node-RED (2/2)
Día 8
25 de mayo
17:00-20:00
Programación con Node-RED (1/3)2h 1h – Práctica 5: Desarrollo Node-RED: MQTT y Dashboard
Día 9
30 de mayo
17:00-20:00
Desarrollo con Node-RED (2/3)2h1h – Práctica 5: Desarrollo Node-RED: MQTT y Dashboard (1/2)
Día 10
1 de junio
17:00-20:00
Dashboard con Node-RED2h1h – Práctica 5: Desarrollo Node-RED: MQTT y Dashboard (2/2)
Día 11
9 de junio
8:00-14:00
Sesión presencial en las instalaciones del cliente.
Plataformas IoT
2h2h – Práctica 6: Desarrollo Node-RED: BBDD y Tratamiento Datos
2h – Práctica 7: Integración de Datos en Plataforma IoT
TOTAL21h 30m14h 30m

Contenido del Curso

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

Contenido:

  • Fundamentos IoT
  • Hardware IoT
  • Comunicaciones IoT
  • Protocolos IoT
  • Administración Node-RED
  • Desarrollo con Node-RED

Presentaciones

  • ¿Nombre?
  • Breve presentación con el rol/puesto y aplicación de los puntos del curso al trabajo.

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/

Ejercicios Node-RED

Ejercicio 01

Mostrar en el dashboard en un mismo grupo 3 widgets text donde cada segundo actualice el timestamp (epoch time), la fecha usando el nodo node-red-contrib-date y el día y hora en formato, usando el nodo moment para transformarlo.

Código: https://github.com/aprendiendonodered/ejercicio01 

Vídeo: https://youtu.be/wS0E1j1q7sM  

Ejercicio 02

Leer el dato de la temperatura publicado en MQTT y hacer que cuando la temperatura esté fuera de un rango entre 18 y 22 grados, ponga el estado de confort en un elemento del dashboard y mande un email.

Código: https://github.com/aprendiendonodered/ejercicio02 

Vídeos:

Imágenes:

Ejercicio 03

Hacer un dashboard para ver la temperatura de todas las Raspberry Pi publicada en MQTT y sus gráficas. Usar MQTT Explorer para explorar qué datos están publicados.

Opcionalmente hacer varias tabs/pestañas para mostrar: temperaturas, CPU y memoria agrupadas en cada pestaña.

Código: https://github.com/aprendiendonodered/ejercicio04

Vídeos:

Flujo:

Dashboard Final:

Ejercicio 04

Sobre el Ejercicio02, añadir de forma dinámica los umbrales máximos y mínimos de alerta mediante dos sliders en el dashboard.

También hacer que los valores de los colores del gauge cambien en función del valor de MAX y MIN introducido por los sliders

Opcionalmente mostrar los mensajes de alerta y los iconos:

  • Todo Correcto: <i class=”fa fa-lightbulb-o fa-2x nr-dashboard-ok”></i>
  • Temperatura Alta: <i class=”fa fa-warning fa-2x nr-dashboard-warning”></i>
  • Temperatura Baja: <i class=”fa fa-exclamation-circle fa-2x nr-dashboard-error”></i>

Para cambiar la configuración de los widgets de dashboard se usa mediante msg.ui_control como se indica aquí: https://github.com/node-red/node-red-dashboard/blob/master/config-fields.md 

En este caso uso un nodo change donde borro payload y pongo las propiedades msg.ui_control.seg1 y msg.ui_control.seg2 a los valores almacenados en las variables de contexto.

Por último no dejar que el valor MIN sea mayor que MAX, ni que MAX sea menor que min en el dashboard, para ello controlar el valor de MIN y MAX al cambiar con un nodo switch y tomar la decisión a hacer.

Código: https://github.com/aprendiendonodered/ejercicio06.git 

Vídeos:

Ejercicio 05

Hacer un dashboard para controlar los wemos D1 Mini con el firmware instalado en el curso: https://aprendiendoarduino.wordpress.com/2021/02/20/mqtt-y-esp8266/

El Dashboard tendrá:

  • Un gauge y una gráfica indicando la temperatura de la sonda DS18B20
  • Un pulsador para encender y apagar el led del Wemos D1 Mini
  • Un pulsador para encender y apagar el relé
  • Un Input text o un formulario para mandar mensajes a la pantalla oled
  • Un slider para encender los 8 niveles de la matriz led.

Código: https://github.com/aprendiendonodered/ejercicio11 

Vídeo Youtube:

Flujo:

Dashboard:

Ejercicio 6 – 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.

Mostrar en el dashboard el estado de la cerradura.

Crear un flujo nuevo en el dashboard llamado pin de seguridad

Basarse en el flujo:

Hacer el flujo como un subflow.

Dashboard

Flujo

Subflow

Código:

Ejercicio 7 – 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

Ejercicio 8 – Mapa de Terremotos

Basándose en este flow: https://nodered.org/docs/tutorials/second-flow, hacer un mapa del mundo mostrando los terremotos actuales.

Usar el nodo worldmap: https://flows.nodered.org/node/node-red-contrib-web-worldmap 

Repositorio: https://github.com/aprendiendonodered/EJERCICIO27_Mapa_Terremotos.git

Ejercicio 9 – OwnTracks

Instalar la aplicación owntracks en un móvil: https://owntracks.org/

Configurar un broker MQTT público y que comience a transmitir datos:

  • Host: aprendiendonodered.com
  • Port: 8883
  • username: owntracks
  • Topic: owntracks/#

Programar un dashboard de worldmap y mostrar la posición y el track de los datos que mandamos por MQTT desde la app owntracks.

Adicionalmente guardar los datos en una BBDD InfluxDB. Hay un bucket en enriquecrespo.com llamado owntracks para guardar estos datos.

Repositorio: https://github.com/aprendiendonodered/EJERCICIO30_OWN_TRACKS

Ejercicio 10 – Open Weather Map

Usando el nodo 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 por MQTT al topic “cursomqtt/raspberrypixx/temperatura”.

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

MQTT y Node-RED

Node-RED y MQTT con Wemos D1 Mini

Capturar los datos mandados por los nodos remotos por MQTT.

Sólo tienes que arrastrar el nodo mqtt que está en la categoría input al flujo.

sistema alarma node-red

Ahora hay que configurarlo. Aquí es donde vemos la potencia de Node-RED. En el caso de MQTT lo único que tenemos que hacer es configurar el broker y el topic.

Al tratarse de un nodo de entrada, lo que hace es recibir los mensajes publicados en un topic es decir, se suscribe al topic. Haz doble click sobre el nodo para que abra el panel de configuración.

En el panel de configuración MQTT vamos a configurar primero el broker MQTT. Haz click en el lápiz que aparece en Server.

sistema alarma node-red

Esto abre un nuevo panel de configuración. Pon un nombre al broker MQTT por ejemplo RASPBERRY PI MOSQUITTO. En Server tienes que poner la IP donde está instalado el broker MQTT y el puerto que utiliza, normalmente es el 1883.

Esta sería la configuración mínima. No te olvides de hacer click en el botón Add.

sistema alarma node-red

Después de esta acción volverás al panel de configuración del nodo mqtt y automáticamente, habrá seleccionado el broker MQTT que acabamos de crear.

Por último, vamos a rellenar el campo de Topic. Debe ser el mismo que hemos puesto en Arduino o el ESP8266, /casa/puerta/alarma. Una vez lo tengas, haz click en Done.

sistema alarma node-red

Ahora sólo nos queda probarlo. Para ello vamos a utilizar el mismo nodo debug de la categoría output que hemos utilizado antes.

Arrástralo al flujo, conecta los dos nodos y haz click en el botón Deploy.

sistema alarma node-red

Para probar el sistema lo podemos hacer de dos formas. Desde una terminal de Raspberry Pi podemos publicar un mensaje en el topic o directamente conectando la placa y simulando que abren la puerta.

El resultado sería el siguiente.

sistema alarma node-red

Otro ejemplo mucho más completo con Lego: http://www.internetoflego.com/lego-train-automation-wifi-controlled-nodemcu-esp8266/ 

Cargar Datos de Raspberry Pi a MQTT

Mandar cada 10 segundos los datos de CPU, Memoria y temperatura de la Raspberry Pi por MQTT al topic: cursomqtt/raspberrypixx/{CPU/Memoria/Temperatura}

Código para obtener los datos de Raspberry Pi, usando en nodo exec: 

[{"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"]]}]

Flujo:

Ejemplo con Nodos Remotos

Vamos a usar los Wemos D1 mini, para integrarlos como nodos remotos y programarlos desde Node-RED.

Esquema:

Firmware de uso de cada shield:

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 

Completos tutoriales:

Topic Map

El topic map del firmware de los dispositivos es:

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

Publicar en MQTT desde Node-RED

Publicar desde Node-RED en diversos topics para encender 

Cada firmware ya está configurado para solo configurar el topic donde va a publicar y el topic al que se suscribe:

  • RELE: Paso ON y OFF
  • OLED: Paso el string que va a mostrar por pantalla
  • LEDS: 7 topics donde paso el color en formato RGB y el brillo

Probar diferentes publicaciones en diferentes topics para encender/apagar los relés, encender/apagar leds y mandar mensajes a las pantallas.

Ejemplos a programar con Node-RED

  • Al leer una pulsación un botón de los M5stick, se enciende un relé.
  • Al superar una temperatura mandar un mensaje de alerta
  • Mandar a las pantallas oled los datos de CPU u otras mediciones
  • En función de la distancia encender más o menos leds de wemos
  • Cuando un nodo se desconecte mandar un mensaje a una pantalla

Consola MQTT en Dashboard

Instalar Dashboard de Node-RED: https://flows.nodered.org/node/node-red-dashboard

Crear un dashboard y un grupo.

Usar los siguientes nodos de Dashboard y añadir a los grupos:

  • gauge: para mostrar mediciones como la temperatura o la CPU
  • chart: para mostrar gráfica de mediciones
  • switch: para encender y apagar leds y reles
  • slider: para encender leds y aumentar la intensidad de los leds
  • text input: para mandar mensajes a las pantallas
  • text: para mostrar datos de topics