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:

1.1 – Presentación del Curso
1.2 – Material del Curso
2.1 – ¿Qué es IoT?
2.2 – Ecosistema IoT
2.3 – Tecnologías IoT
2.4 – Arquitecturas IoT
Práctica 1: Instalación y configuración Raspberry Pi OS

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:

2.5 – Edge Computing
3.4 – Raspberry Pi OS
3.5 – Instalación Software Raspberry Pi
3.6 – Acceso Remoto Raspberry Pi
6.1 – Qué es Node-RED
Práctica 1: Instalación y configuración Raspberry Pi OS (continuar)
Práctica 1b: Instalación de Servicios en Raspberry Pi OS

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:

2.6 – Industria 4.0 (IIoT)
3.1 – Dispositivos HW IoT
3.2 – Raspberry Pi
3.3 – Raspberry Pi en la Industria
3.7 – Arduino en IoT
Práctica 1b: Instalación de Servicios en Raspberry Pi OS (continuar)
Práctica 2: Sensorización IoT con ESP8266

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:

Conversor Modbus LoRa: https://www.dragino.com/products/lora-lorawan-end-node/item/154-rs485-ln.html
Sensores ambientales LoRA: https://www.milesight-iot.com/lorawan/sensor/em500-series/
Gateway LoRa: https://mikrotik.com/product/wap_lr8_kit
Gateway interior: https://alfaiot.com/tienda/gateway-lorawan-indoor/
Conexión Lora punto a punto: https://mikrotik.com/product/wireless_wire_cube_pro
Gateway Monocanal DIY con ESP32: https://github.com/things4u/ESP-1ch-Gateway
Gateway Multicanal con Raspberry Pi y Balena: https://www.balena.io/blog/deploy-a-basics-station-lora-gateway-with-ttn-and-balena/
Sensor LoRa: https://www.dragino.com/products/lora/item/128-lsn50.html
Sensor LoRa Ultrasonidos: https://www.elsys.se/en/elt-ultrasonic/

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

Broker MQTT:

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

Capítulos vistos:

5.1 – Protocolos IoT Capa Aplicación
5.3 – Protocolo MQTT

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:

4.1 – Conectividad IoT
5.3 – Protocolo MQTT (continuar)
Práctica 3: Wifi + MQTT con ESP8266

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:

Sensor Sigfox: https://partners.sigfox.com/products/allsense-smart-environment-and-agriculture

Capítulos vistos:

5.4 – Instalación y Configuración de Mosquitto
MQTT broker simple con: https://flows.nodered.org/node/node-red-contrib-aedes
6.4 – Versiones de Node-RED
6.3 – Instalación Node-RED
6.5 – Configuración y Securización de Node-RED
Práctica 4: Instalar, Configurar y Securizar Node-RED
6.2 – Node-RED en la Industria

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

Web: https://www.thethingsnetwork.org/
Versión profesional: https://www.thethingsindustries.com/
Mapa: https://www.thethingsnetwork.org/map
Hardware: https://www.thethingsnetwork.org/device-repository/
TTN mapper: https://ttnmapper.org/heatmap/
Gateway monocanal: https://github.com/things4u/ESP-1ch-Gateway
Añadir gateway: https://www.thethingsindustries.com/docs/gateways/adding-gateways/

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:

4.2 – Gateway IoT
4.3 – Wifi
5.2 – API REST

Material Curso Smart Cities

1 respuesta

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

Otros nodos remotos utilizados:
- M5Stick-C con sensor ENV:
  - https://m5stack.com/collections/m5-core/products/stick-c
  - https://m5stack.com/collections/m5-hat/products/m5stickc-env-hat-sht30-bmp280-bmm150
- Raspberry Pi Zero: Instalada en local con cámara y programada con Node-RED, usada como dispositivo remoto.
- Wibeee
- Otros dispositivos para interactuar.

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

1 respuesta

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:

La documentación del curso se publicará en formato web y se usará para realizar el seguimiento del curso: https://www.aprendiendoarduino.com/cursos/fundamentos-iot-y-desarrollo-node-red-para-smart-cities/
Todo el código de las prácticas utilizado en el curso está disponible en el repositorio: https://github.com/jecrespo y https://github.com/aprendiendonodered
Diario del curso: https://aprendiendoarduino.wordpress.com/2022/05/02/diario-del-curso-iot-smart-cities-y-node-red/

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

Fecha	Temario	Horas 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)	2h	1h – 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 30m	1h 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 30m	1h 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 30m	1h 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)	2h	1h – Práctica 5: Desarrollo Node-RED: MQTT y Dashboard (1/2)
Día 10 1 de junio 17:00-20:00	Dashboard con Node-RED	2h	1h – 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	2h	2h – Práctica 6: Desarrollo Node-RED: BBDD y Tratamiento Datos 2h – Práctica 7: Integración de Datos en Plataforma IoT
TOTAL		21h 30m	14h 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

2 respuestas

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:
Temperatura Alta:
Temperatura Baja:

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

2 respuestas

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.

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.

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.

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.

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.

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.

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.

wemos D1 mini: https://www.wemos.cc/en/latest/d1/d1_mini.html
shield para wemos D1 mini relé: https://www.wemos.cc/en/latest/d1_mini_shield/relay.html
shield para wemos D1 mini neopixel: https://www.wemos.cc/en/latest/d1_mini_shield/rgb_led.html
shield para wemos D1 mini oled: https://www.wemos.cc/en/latest/d1_mini_shield/oled_0_66.html
shield para wemos D1 mini DHT: https://www.wemos.cc/en/latest/d1_mini_shield/dht.html
shield para wemos D1 mini DS18B20: http://www.esp8266learning.com/wemos-mini-compatible-ds18b20-shield.php
shield para wemos D1 mini BMP180: http://www.esp8266learning.com/wemos-mini-bmp180-shield.php
shield para wemos D1 mini Matrix LED: https://www.wemos.cc/en/latest/d1_mini_shield/matrix_led.html
shield para wemos D1 micro SD: https://www.wemos.cc/en/latest/d1_mini_shield/micro_sd.html

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

M5Atom Matrix: https://m5stack.com/collections/m5-atom/products/atom-matrix-esp32-development-kit
M5Stack Basic: https://m5stack.com/collections/m5-core/products/basic-core-iot-development-kit
M5StickC: https://m5stack.com/collections/m5-core/products/stick-c
M5StickC-Plus: https://m5stack.com/collections/m5-core/products/m5stickc-plus-esp32-pico-mini-iot-development-kit
M5Stack código VS Code: https://github.com/jecrespo/M5stack

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)