Archivo de la etiqueta: Node-RED

Instalación Node-RED

Node-RED es un motor de flujos con enfoque IoT, que permite definir gráficamente flujos de servicios, a través de protocolos estándares como REST, MQTT, Websocket, AMQP… además de ofrecer integración con APIs de terceros, tales como Twitter, Facebook, Yahoo!…

Node-RED puede instalarse en multitud de Sistemas Operativos y Hardware, el principal requisito es que pueda instalarse Node.js: https://nodejs.org/es/

Versiones soportadas de node.js: https://nodered.org/docs/faq/node-versions 

Instalación de Node-RED: https://nodered.org/docs/getting-started/

Instalar Node-RED en Raspberry Pi

Node-Red no viene instalado en Raspberry Pi pero se puede hacer desde add/remove software.

La forma es desde Menú – Preferencias – Software Recomendado. También  se instala de esta manera, se puede actualizar usando sudo apt-get upgrade.

También puede hacerse desde usando: sudo apt install nodered

IMPORTANTE: Este método de instalación NO es recomendable porque instala una versión antigua de Node-RED.

En el caso de Raspberry Pi OS Buster, ejecutando apt show nodered

Package: nodered
Version: 1.2.9-1
Priority: optional
Section: editors
Maintainer: Dave Conway-Jones <dceejay@gmail.com>
Installed-Size: 50,2 MB
Depends: nodejs (>= 10), npm (>= 5.8), python (>= 2.7)
Homepage: http://nodered.org
Download-Size: 4.714 kB
APT-Sources: http://archive.raspberrypi.org/debian buster/main armhf Packages
Description: Node-RED - low-code programming for event-driven applications
 A graphical flow editor for event driven applications.
 Runs on Node.js - using a browser for the user interface.
 See http://nodered.org for more information, documentation and examples.
 .
 Copyright 2017,2021 JS Foundation and other contributors, https://js.foundation/
 Copyright 2015,2017 IBM Corp.
 Licensed under the Apache License, Version 2.0
 http://www.apache.org/licenses/LICENSE-2.0

Luego se puede ejecutar manualmente con el comando “node-red-star”:

Para iniciar Node-RED en el arranque de Raspberry Pi de forma automática usar: sudo systemctl enable nodered.service

Más información https://nodered.org/docs/hardware/raspberrypi

Para comprobar que funciona abrir en un navegador http://ip-raspberry:1880

Para encontrar más nodos y ejemplos de flows ver https://flows.nodered.org/ estos nodos se pueden instalar desde el palette.

Instalación Recomendada de Node-Red en Raspberry Pi

La instalación recomendada para tener la última version de Node-RED en Raspberry Pi: https://nodered.org/docs/getting-started/raspberrypi

Comprobar la versión de node.js y npm instalada:

  • node –version
  • npm –version

Ejecutar el script, ojo cuesta un tiempo instalar: 

script antiguo para Raspberry Pi: bash <(curl -sL https://raw.githubusercontent.com/node-red/raspbian-deb-package/master/resources/update-nodejs-and-nodered)

Si se hace en RPi apt-get upgrade se actualizan las versiones de node.js y npm

Para versiones de OS basada en rpm usar (CentOS, Fedora, etc…) Usar el script: bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/rpm/update-nodejs-and-nodered)

Para más detalles ver https://github.com/node-red/linux-installers 

Este script sirve para instalar Node.js, npm y Node-RED en una Raspberry Pi. El script también se puede utilizar para actualizar una instalación existente cuando hay una nueva versión disponible.

El script que se descarga y ejecuta puede verse en: https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered

Este script eliminará las versiones de Node.js anteriores a la versión 7.x, y Node-RED y

si es necesario, reemplaza con con Node.js 10.x LTS (dubnium) y el último Node-RED de Npm.

También mueve cualquier nodo Node-RED que esté instalado globalmente en su usuario ~/.node-red/node_modules, y los agrega a su package.json, para que puede administrarlos con el administrador de paletas.

También intenta ejecutar ‘npm rebuild’ para actualizar los nodos adicionales que haya instalado que puede tener un componente binario nativo. Si bien esto normalmente funciona bien, necesitas comprobar que tiene éxito para su combinación de nodos instalados.

Estos son los pasos que realiza:

  • Stop Node-RED                   
  • Remove old version of Node-RED      
  • Remove old version of Node.js       
  • Install Node.js                     
  • Clean npm cache                     
  • Install Node-RED core               
  • Move global nodes to local          
  • Install extra Pi nodes              
  • Npm rebuild existing nodes          
  • Add shortcut commands               
  • Update systemd script               

Los errores de instalación se pueden ver en: /var/log/nodered-install.log

Para ejecutar Node-RED como servicio y que se inicie en el boot de Raspberry PI ejecutar: sudo systemctl enable nodered.service

Iniciar el servicio de Node-RED con: sudo systemctl start nodered.service 

Para comprobar que funciona abrir un navegador y enterar en: http://{your_pi_ip-address}:1880 

Más información:

Instalar Node-RED en CentOS

La instalación en local se hace siguiendo este enlace: https://nodered.org/docs/getting-started/local

Es recomendable crear un usuario nodered y hacer la instalación con ese usuario.

Para versiones de Linux basadas en RPM como Red HAT, fedora o CentOS usar esta instalación: https://github.com/node-red/linux-installers. Funciona perfectamente.

Usar este script: bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/rpm/update-nodejs-and-nodered)

Y luego activar el inicio automático en el arranque: sudo systemctl enable nodered.service

Para actualizar usar el mismo script que el de instalación.

Instalación Manual en CentOS

Para instalar Node-RED es necesario una versión soportada de Node.js: https://nodered.org/docs/faq/node-versions

Sigue leyendo solo si eres usuario avanzado, sino te recomiendo que instales Node-RED con el script.

Primero instalar node.js en CentOS:

Para poder instalar add-ons: sudo yum install gcc-c++ make

Para actualizar paquetes npm: npm install -g npm

Y luego instalar node-RED (use the node package manager, npm, that comes with Node.js): npm install -g –unsafe-perm node-red

Running Node-RED: https://nodered.org/docs/getting-started/running 

  • poner node-red
  • abrir firewall  sudo firewall-cmd –permanent –add-port=1880/tcp
  • firewall-cmd –reload

Arrancar node-red en el arranque: https://nodered.org/docs/hardware/raspberrypi#adding-autostart-capability-using-systemd

Más información para la instalación: https://ketandesai.co.uk/os/install-node-red-on-centos-7/

Para actualizar node-red instalado en local https://nodered.org/docs/getting-started/local usar el comando: npm install -g –unsafe-perm node-red

NOTA: no olvidar actualizar a la última versión de nodejs.

Para configurar:

Para securizar:

Comandos básicos de npm: https://vortexbird.com/comandos-basicos-de-npm/

Actualizar Node-Red en CentOS

Si se ha usado el script usar:

Si se ha instalado con npm:

  • cp flows_cred.json backup/flows_cred.json
  • cp flows.json backup/flows.json (Backup de nodos y credenciales)
  • yum update (actualizar node.js y npm)
  • npm install -g npm (actualizar paquetes npm)
  • sudo npm install -g –unsafe-perm node-red (actualizar node-red)
  • systemctl restart nodered.service (reiniciar servicio)
  • systemctl status nodered.service (comprobar servicio)
  • Actualizar nodos desde Manage Palette

Instalar Node-RED en Docker

Node-RED en docker: https://nodered.org/docs/getting-started/docker

Docker hub oficial de Node-RED desde la version 1.x: https://hub.docker.com/r/nodered/node-red/

Imagen de Node-RED: https://github.com/node-red/node-red-docker/blob/master/README.md

Para versiones antiguas: https://hub.docker.com/r/nodered/node-red-docker

La forma más sencilla de ejecutar Node-RED en docker:

  • docker run -it -p 1880:1880 –name mynodered nodered/node-red

Las imágenes Node-RED se basan en imágenes oficiales de Node JS Alpine Linux para mantenerlas lo más pequeñas posible. El uso de Alpine Linux reduce el tamaño de la imagen construida, pero elimina las dependencias estándar que se requieren para la compilación del módulo nativo.

Una vez que está Node-RED ejecutándose con Docker, debemos asegurarnos de que los nodos o flujos agregados no se pierdan si se destruye el contenedor. Estos datos de usuario pueden conservarse montando un directorio de datos en un volumen fuera del contenedor. Esto puede hacerse usando un montaje de enlace o un volumen de datos con nombre.

Node-RED utiliza el directorio /data dentro del contenedor para almacenar los datos de configuración del usuario.

Para guardar el directorio de usuario Node-RED dentro del contenedor en un directorio host fuera del contenedor, puede usar el siguiente comando. Para permitir el acceso a este directorio de host, el usuario de node-red (uid predeterminado = 1000) dentro del contenedor debe tener el mismo uid que el propietario del directorio de host. Esto puede ser forzado con el comando sudo chown -R 1000:1000 path/to/your/node-red/data. Más información https://github.com/node-red/node-red-docker/wiki/Permissions-and-Persistence

docker run -it -p 1880:1880 -v /home/pi/.node-red:/data –name mynodered nodered/node-red

Montar un volumen de datos dentro del contenedor en esta ruta de directorio significa que la configuración de usuario pueden guardarse fuera del contenedor e incluso compartirse entre instancias de contenedor.

En este ejemplo, el directorio host /home/pi/.node-red está vinculado al directorio contenedor /data

El contenedor utiliza el directorio /data como el directorio de configuración del usuario. Para agregar nodos adicionales, puede abrir el shell en el contenedor y ejecutar los comandos de instalación npm adecuados:

  • docker exec -it mynodered /bin/bash (Abre un shell en el contenedor)
  • cd /data
  • npm install node-red-node-smooth (una vez en el contenedor npm instala el nodo)
  • exit
  • docker stop mynodered
  • docker start mynodered (reiniciar contenedor)

Para montar /data en un path externo:

  • docker run –restart always -d -p 1880:1880 -v /opt/docker_volumes/nodered_data:/data –name nodered nodered/node-red
  • Y si lo añado en una red: docker run –restart always -d -p 1880:1880 –network ‘Entorno Desarrollo’ -v /opt/docker_volumes/nodered_data:/data –name nodered nodered/node-red

Para que funcione hay que dar permisos de escritura al uid 1000 al directorio /opt/docker_volumes/nodered_data

Actualizar un Contenedor 

Para actualizar el contendor: https://nodered.org/docs/getting-started/docker#updating

Actualizar el contenedor con una copia del antiguo:

  • docker pull nodered/node-red
  • docker stop nodered
  • docker rename nodered nodered.bak (lo renombro para tener de backup y luego lo elimino)
  • docker run –restart always -d -p 1880:1880 –network ‘Entorno Desarrollo’ -v /opt/docker_volumes/nodered_data:/data –name nodered nodered/node-red
  • docker rm nodered.bak (borro el anterior si funciona)
  • (borro la imagen antigua)

Para cambiar la time zone del contenedor:

  • docker run -it -p 1880:1880 –name mynodered -e TZ=Europe/London nodered/node-red

Docker de node-red en raspberry pi: https://domology.es/docker-de-node-red-en-raspberry-pi/

Más información: https://nodered.org/docs/getting-started/docker

Instalación Manual de Node-RED. Instalación en Local

Esto sirve para cualquier sistema operativo ya sea Windows, Linux, MacOS, etc…. Documentación: https://nodered.org/docs/getting-started/local 

Instalación en Windows:

Node-RED puede instalarse en multitud de Sistemas Operativos y Hardware, el principal requisito es que pueda instalarse Node.js: https://nodejs.org/es/

Node-RED se pueden instalar mediante npm, Además para añadir nodos adicionales primero debe instalar la herramienta npm

Primero se debe instalar node.js, para ello seguir las guias proporcionadas para su instalación: https://nodejs.org/en/download/package-manager/ 

Versiones node.js soportadas por Node-RED: https://nodered.org/docs/faq/node-versions 

npm es el sistema de gestión de paquetes por defecto para Node.js

npm ya viene instalado con la instalación de node.js desde la versión 8.x. Ver: https://www.npmjs.com/get-npm 

El comando para instalar y actualizar Node-RED una vez instalado Node.js: sudo npm install -g –unsafe-perm node-red

Y luego para instalar un nodo/librería, se puede hacer mediante npm en lugar de la paleta de nodos con:

  • cd ~/.node-red
  • npm install node-red-{example node name}

Node-RED Desktop

Por el momento, para instalar Node-RED, un usuario tiene que instalar node.js y npm, luego ejecutar algunos comandos con los que puede que no estén familiarizados y ven una pantalla llena de resultados de npm, la mayoría de los cuales significarán muy poco para ellos.

Existen algunos proyectos de instalador de node-RED como: https://sakazuki.github.io/node-red-desktop/ 

Instalador Node-RED usando Electron: https://jejo.es/posts/electron/electronarduinonodered/v104/ 

Node-RED Portable:

Ejecutar Node-RED

Una vez instalado Node-RED ejecutar el comando para iniciar: node-red

La salida del registro le proporciona varias piezas de información:

  • Las versiones de Node-RED y Node.js
  • Cualquier error cuando intentó cargar los nodos de la paleta
  • La ubicación de su archivo de configuración y directorio de usuarios
  • El nombre del archivo de flujos que está utilizando.

Para tener un log de lo que está pasando usar node-red-log

Otros comandos:

  • node-red-stop to stop Node-RED
  • node-red-start to start Node-RED again
  • node-red-log to view the recent log output
  • sudo systemctl enable nodered.service to autostart Node-RED at every boot
  • sudo systemctl disable nodered.service to disable autostart on boot
  • sudo systemctl status nodered.service to check service status
  • sudo systemctl restart nodered.service to restart service

Nodo-RED utiliza el fichero flows_<hostname>.json como el archivo de flujos predeterminado. Puede cambiar esto proporcionando el nombre del archivo de flujos como argumento para el comando node-red

Iniciar Node-RED en el inicio o como servicio: https://nodered.org/docs/faq/starting-node-red-on-boot

Uso de la línea de comandos de node-red: https://nodered.org/docs/getting-started/local#command-line-usage

Override individual settings: https://nodered.org/docs/getting-started/local#override-individual-settings 

node-red-admin es la herramienta de línea de comandos le permite administrar de forma remota una instancia de Node-RED: https://nodered.org/docs/user-guide/node-red-admin

Para instalar node-red-admin: sudo npm install -g node-red-admin

Para ver todos los nodos instalados: node-red-admin list

Desde la versión 1.1 se ha integrado en Node-RED y se ejecuta como: node-red admin y no es necesario instalar de forma separada

Más comandos: https://nodered.org/docs/user-guide/node-red-admin

Personalizar Node-RED

Se pueden poner Themes en Node-RED: https://github.com/node-red-contrib-themes

Colección de temas: https://github.com/node-red-contrib-themes/theme-collection

Instalación: npm install @node-red-contrib-themes/theme-collection

Para configurar editar en settings.js:

// Customising the editor
    editorTheme: {
        projects: {
            // To enable the Projects feature, set this value to true
            enabled: true
        },
        theme: "<theme-name>"
    }

Luego reiniciar Node-RED con: systemctl restart nodered

Temas disponibles:

  • dark
  • midnight-red
  • oled
  • solarized-dark
  • solarized-light

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

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/ 

Beta version 1.3 Node-RED: https://discourse.nodered.org/t/node-red-1-3-0-beta-1-released/41960

  • change log: https://github.com/node-red/node-red/blob/15715a296862bf9603facd45bf1a7ef17623890b/CHANGELOG.md
  • Uso de de módulos npm en funciones. Al establecer functionExternalModules en verdadero en el archivo de configuración, podrá configurar sus nodos de función con una lista de módulos adicionales.
  • Ahora es posible anidar referencias a las propiedades del mensaje en los nodos change y switch. Ejemplo: set flow.rooms[msg.topic] to the value of msg.payload
  • Node-RED Plugins framework
  • Ahora es posible empaquetar un subflujo como un módulo y publicarlo en npm para instalarlo en la paleta como cualquier otro nodo.
  • El cuadro de diálogo Exportar ahora muestra una lista estructurada de lo que está exportando. El JSON sin formato aún se puede ver en una segunda pestaña del cuadro de diálogo.
  • Con esta versión, si pulsa Mayús y hace clic en el lado izquierdo del nodo, seleccionaremos todos los nodos ascendentes. Si pulsa Mayús y hace clic en el lado derecho, seleccionaremos todos los nodos de corriente abajo. Shift-clic en el centro del nodo seleccionará todo el flujo como antes.
  • Los nodos MQTT ahora son compatibles con MQTTv5 y la gran mayoría de las nuevas funciones que presenta la versión 5.

Versión 1.3 (08/04/2021): https://nodered.org/blog/2021/04/08/version-1-3-released

  • Mejorada la selección de nodos. Más información: https://github.com/node-red/node-red/pull/2877 
  • Hay un nuevo ajuste disponible que gobierna lo que puede ser instalado en Node-RED – externalModules. Esto cubre dos cosas separadas: qué nuevos nodos pueden ser instalados a través del gestor de paletas, y qué módulos pueden ser cargados por el nodo Function. Más información: https://github.com/node-red/node-red/pull/2797 
  • Los nodos MQTT ahora soportan MQTTv5 y la gran mayoría de las nuevas características que introduce v5.

Planning Node-RED 2.0: https://discourse.nodered.org/t/planning-for-node-red-2-0/41918

Presentación Curso Node-RED Developer. 2021

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.

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.

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 19 y 30 de abril de 2021.

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:

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-2021-nivel-i/

  • 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/

Práctica 6: Integración de Datos en Plataforma IoT

Ejercicio 01

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 

Flujo:

Dashboard:

Vídeos solución:

Ejercicio 02

Almacenar en la Base de datos MySQL instalada en la Raspberry Pi en la práctica 1 https://aprendiendoarduino.wordpress.com/2021/02/13/practica-1-instalacion-y-configuracion-raspberry-pi-os/ los datos de temperatura del sensor DS18B20 con el firmware de la práctica 2: https://aprendiendoarduino.wordpress.com/2021/02/15/practica-2-sensorizacion-iot-con-esp8266/

Hacer la lógica para controlar el relé de forma cuando la temperatura sea inferior a 21 grados encienda el relé y lo pare cuando alcance los 23 grados. Cuando el relé se encienda o apague, mandar un correo.

Hacer un dashboard que muestra la temperatura del sensor DS18B20 con un gauge y el estado del relé con un texto.

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

Flujo:

Dashboard:

Vídeos solución:

Ejercicio 03

Capturar foto de Raspberry Pi Zero mediante un botón del dashboard y mostrar la foto en el dashboard.

Tomar foto:

  • publicar un valor cualquiera en el topic cursocefire/tomafotomqtt. La foto se publica en el topic cursocefire/foto en baja resolución.
  • publicar un valor cualquiera en el topic cursocefire/tomafotoweb. La foto se actualiza en https://www.aprendiendoarduino.com/servicios/imagen.jpg en alta resolución.

Hacer dos grupos en el dashboard para los dos métodos de captura de datos.

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

Flujo:

Dashboard: 

Vídeos solución:

Ejercicio 04

Configurar un cliente FTP y un servidor FTP con Node-RED e interactuar entre ellos:

Capturar datos de MQTT publicados en enriquecrespo.com:8883 y guarda los datos en un fichero local usando el nodo file en formato csv usando el nodo csv https://cookbook.nodered.org/basic/generate-csv. Poner un botón en el dashboard y al pulsarlo, mandar los datos del fichero csv con el cliente ftp al servidor y borrar los datos del fichero (inicializarlo).

Para mandar los datos se puede usar el servidor público ftp en enriquecrespo.com: 7021 o un servidor propio con node red o de otro tipo.

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

Flujo:

Dashboard:

Vídeos solución:

Práctica 5: Programar Node-RED, MQTT y Dashboard

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 solución:

Ejercicio 02

Leer un 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.

Usar el nodo email y ver la información para usarlo: https://flows.nodered.org/node/node-red-node-email 

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

Vídeos solución:

Imágenes:

Ejercicio 03

Hacer un flujo para publicar datos de CPU, Memoria y temperatura de las Raspberry Pi de casa en MQTT en los topics:

  • cursocefire/alumnoxx/raspberrypi/CPU
  • cursocefire/alumnoxx/raspberrypi/Memoria
  • cursocefire/alumnoxx/raspberrypi/Temperatura

Luego hacer que la instancia de Node-RED que las recoja y muestre en el dashboard.

Para publicar los datos de casa, usar el broker MQTT del curso enriquecrespo.com:1883. Opcionalmente usar el broker instalado en la práctica 4: https://aprendiendoarduino.wordpress.com/2021/02/28/practica-4-instalar-configurar-y-securizar-mosquitto-y-node-red-en-raspberry-pi/.

Código Raspberry Pi:

Vídeo 1 con código Raspberry Pi:

Código Node-RED Dashboard:

Vídeo segunda parte:

Dashboard:

Código Total: https://github.com/aprendiendonodered/ejercicio03 

Anexo: Obtener Datos de Raspberry Pi

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

Código para obtener los datos Raspberry Pi y mandar a MQTT: https://github.com/jecrespo/Curso-Node-RED/blob/master/Monitor%20Raspberry%20Pi/monitor_raspberrypi.json 

Ejercicio 04

Hacer un dashboard para ver la temperatura de todas las Raspberry Pi o de otros elementos publicado 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: