Archivo de la categoría: Formación 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

Ejercicios Curso Node-RED Developer

Ejercicios del curso “Node-RED Developer Nivel 1”: https://www.aprendiendoarduino.com/cursos/node-red-developer-para-iot-nivel-i/ 

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:

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 flujo para publicar datos de CPU, Memoria y temperatura de las Raspberry Pi de casa en MQTT en los topics:

  • aprendiendonodered/alumnoxx/raspberrypi/CPU
  • aprendiendonodered/alumnoxx/raspberrypi/Memoria
  • aprendiendonodered/alumnoxx/raspberrypi/Temperatura

Luego hacer que la instancia de Node-RED del curso 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 integrado en Node-RED aedes o un HTTP endpoint.

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

Ejercicio 04

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:

  • Vídeo 1:
  • Vídeo 2:
  • Vídeo 3:

Flujo:

Dashboard Final:

Ejercicio 05

Hacer IFTTT con Node-RED. Ejemplos:

  • Si recibo un correo con el asunto “twitter”, entonces twittear el contenido del correo.
  • Si recibo una llamada por el HTTP endpoint “mail”, entonces mandar un email al destinatario, asunto y contenido indicados

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

La llamada http en un GET y debe tener el formato: https://enriquecrespo.com:188xx/mail?destinatario=pepe@gmail.com&asunto=mandacorreo&contenido=hola_que_tal

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

Vídeos:

  • Primera parte:
  • Segunda parte: 

Petición usada: https://enriquecrespo.com:18802/mail?destinatario=aprendiendoraspberrypi@gmail.com&asunto=correo_desde_http_para_twitter&contenido=hola_node_red 

Además en este caso si hago una petición HTTP GET o POST manda el email y luego la segunda condición cuando lee el email, manda el tweet, lo que hace que se desencadenen los dos eventos.

Ejercicio 06

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.

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 paylaod 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:

  • Primera Parte
  • Segunda Parte

Ejercicio 07

Hacer un subflujo con 5 salidas, que pasándole una variable de entorno con el número de datos a analizar, devuelva la media, máxima y mínima de esos datos por cada salida, una vez retenidos y analizados. En la cuarta salida me devuelva un array de los datos analizados y en la quinta el contador interno.

Personalizar el flujo, añadiendo documentación de lo que hace el subflow y lo que devuelve cada salida.

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

Vídeos:

  • Primera Parte
  • Segunda Parte
  • Tercera Parte
  • Cuarta Parte

Ejercicio 08

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.

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

Vídeos:

  • Primera Parte:
  • Segunda Parte:
  • Tercera Parte:

Ejercicio 09

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ínimo por tres salidas y en una cuarta mande los 20 mensajes que ha retenido de forma consecutiva. En la quinta salida mandar el dato del contador interno.

Una vez hecho, añadir una funcionalidad para que si recibe un mensaje en la propiedad msg.acumulado, tome ese dato como el número de datos a acumular para hacer el cálculo. Una vez llegue este dato, actualiza el acumulado del contador y en función de lo que lleve acumulado, espera hasta llegar al nuevo dato o si lo ha superado, manda lo que ya tiene.

Por último, encapsular esta función en un subflow para poder reutilizarlo.

Añadir dato a un array: https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/push 

Función reduce: https://www.w3schools.com/jsref/jsref_reduce.asp 

Función Max: https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Math/max 

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

Vídeos:

  • Primera parte:
  • Segunda parte:
  • Tercera parte:

Ejercicio 10 (Ejercicio Final)

Hacer un CSV con los datos de temperatura, memoria y CPU que manda vuestra Raspberry PI y guardar en un fichero llamado raspberrypi.csv. Añadir también el campo timestamp al fichero csv.

Para ello tomar los datos publicados en MQTT, ordenarlos y prepararlos para que los pase a un nodo join y los ponga en este orden: timestamp,CPU,Memory,Temperature 

Para que los ordene de forma automática el nodo join debemos hacer uso de la propiedad parts como hace el nodo split usando:

  • parts.index – para el orden de los elementos del grupo a unir
  • parts.id – para indicar que es el mismo grupo
  • parts.count – para indicar el nº de mensajes del grupo

También crear un flujo con un nodo inject que cree el fichero con la cabecera: “timestamp,CPU,Memory,Temperature” y que además al hacerlo vacíe el fichero existente.

Crear otro flujo con un nodo inject que lee con “file in” el contenido del fichero y lo mande a la pantalla de debug.

Luego con un botón del dashboard hacer la parte de inicializar el fichero (que aparezca una notificación del dashboard para confirmar que se desea inicializar) y con otro botón del dashboard un flujo que lea el fichero y lo mande al nodo chart del dashboard y hacer las gráficas.

Opcionalmente, hacer un tercer botón que mande por email el fichero csv, como fichero adjunto.

Opcionalmente, hacer un flujo que lea los datos del fichero llamado raspberrypi.csv y obtener los datos de media, máxima y mínima de la temperatura, memoria y CPU y mostrar en el dashboard en un nodo texto.

Opcionalmente, hacer un flujo que agrupe los datos en grupos de 100 y sacar los datos de media, máxima y mínima cada 100 valores y guardar en otro fichero llamado raspberrypi_agrupados.csv con los campos: timestamp,CPU_AVG,CPU_MAX,CPU_MIN,Memory_AVG,Memory_MAX,Memory_MIN,Temperature_AVG,Temperature_MAX,Temperature_MIN

Mandar datos al nodo chart: https://github.com/node-red/node-red-dashboard/blob/master/Charts.md 

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

Vídeos:

  • Primera parte:
  • Segunda parte:
  • Tercera parte:
  • Cuarta parte:
  • Quinta parte:
  • Sexta parte:

Node-RED en la Nube

Es posible tener instancias de Node-RED en cloud. Existen varias alternativas.

FRED

FRED: Front End For Node-RED. Node-RED as a Service

Hosting de node-red gratuito FRED (hasta 50 nodos): https://fred.sensetecnic.com/

Como funciona FRED: http://sensetecnic.com/how-fred-cloud-node-red-works/ 

Docs FRED: http://docs.sensetecnic.com/fred/ 

FAQ: http://docs.sensetecnic.com/fred/faq/

Más información sobre FRED:

Developers:

Hosting Node-RED: https://fred.sensetecnic.com/ la forma más sencilla.

Mi cuenta de FRED: aprendiendoarduino

FRED en la Industria:

FRED Desktop (Recoger datos locales fácilmente):

STS MQTT y InfluxDB: 

Otros Cloud

En stackhero: https://www.stackhero.io/en/services/Node-RED

Node-RED en cloud: https://github.com/langanjp/PI-NodeRed/wiki/Node-RED-in-the-Cloud

IBM Cloud:

Microsoft Azure: https://nodered.org/docs/getting-started/azure

Google cloud:

Node-RED y Datacake:

AWS – https://nodered.org/docs/getting-started/aws 

Node-RED en VPS: https://jejo.es/posts/node-red/instalar_node-red_en_vps_debian8/ 

Node-RED un proveedor de hosting:

Manejo de errores en Node-RED

Node-RED proporciona los nodos Catch y Status como formas de generar flujos que pueden responder a errores. Como no existe una asociación visual directa entre un nodo Catch y los nodos a los que apunta, debe considerar cómo colocarlos para mantener los flujos legibles.

Colocarlos cerca de las partes del flujo a las que corresponden puede ayudar, pero debe tener cuidado de no sobrecargar los flujos.

Otro enfoque es agrupar todos los flujos de manejo de errores debajo del flujo principal, haciendo que la ruta “buena” sea claramente distinta de las rutas de error.

Dar a sus nodos Catch un nombre claro también es muy importante para ayudar a identificar fácilmente los escenarios que deben manejar. Cualquiera que sea el enfoque que elija, intente ser coherente en los diferentes flujos.

Manejar errores con Node-RED: https://nodered.org/docs/user-guide/handling-errors

Manejo de errores:

Si bien es fácil crear flujos que hacen lo correcto cuando todo funciona, también es importante pensar en lo que podría salir mal.

Por ejemplo, si el flujo interactúa con una base de datos externa o API, ¿qué sucede si deja de responder a las solicitudes? ¿O qué pasa si los nodos MQTT pierden su conexión con un corredor?

El manejo de errores en cualquier aplicación es esencial para garantizar que este tipo de eventos se manejen correctamente. Lo que signifique manejar el error dependerá de los requisitos de la aplicación. Es posible que desee probar una acción que falló o activar una alerta por separado, o tal vez el error sea un evento completamente esperado que es solo otra parte de la lógica de la aplicación.

Node-RED proporciona dos formas para que un nodo informe un error. Puede simplemente escribir un mensaje en el registro o puede notificar al tiempo de ejecución del error y hacer que se active un flujo.

El nodo de catch, es similar a la instrucción “try/except” en python, es decir, sirve para el manejo de excepciones.

Si el error solo se escribe en el registro, verá el mensaje en la barra lateral de depuración y la salida del registro, pero no podrá crear un flujo para manejarlo.

Si notifica al tiempo de ejecución correctamente, entonces es un error detectable que puede usarse para desencadenar un flujo de manejo de errores.

Hay un tercer tipo de error que puede hacer que el tiempo de ejecución de Node-RED se apague. Estos errores uncaughtException no se pueden manejar en el flujo y son causados por errores en los nodos.

Más información: https://techexplorations.com/guides/esp32/nore-red-esp32-project/node-red-catch/ 

Logging Errors

Cuando se produzca un error, este aparecerá en la barra de debug.

Esto muestra el mensaje de error, la fecha/hora del error y el nodo que registró el error. Al igual que con otros mensajes de depuración, al colocar el cursor sobre él, se resaltará el nodo en el espacio de trabajo. Si no está en la vista actual, al hacer clic en el nombre del nodo en la esquina superior se mostrará en el espacio de trabajo.

Nodo Catch

Si un nodo notifica al tiempo de ejecución de un error, entonces el nodo Catch puede usarse para crear un flujo para manejarlo. Si un nodo Catch detecta un error, no se registrará en la barra lateral Debug.

El mensaje enviado por Catch será el mensaje proporcionado por el nodo que informa del error. Este mensaje tendrá un conjunto de propiedades de error que proporciona información sobre el error:

 {
     "topic": ...,
     "payload": ...,
     "error": {
         "message": "An error",
         "source": {
             "id": "2e25823d.fa3f7e",
             "type": "function",
             "name": "My Function",
             "count": 1
         }
     }
 } 

Count indica cuántas veces un nodo ha lanzado este mensaje. Esta propiedad es utilizada por el tiempo de ejecución para detectar mensajes atascados en un bucle, donde se devuelven al nodo de origen, que luego registra el error nuevamente, y así sucesivamente. El tiempo de ejecución permitirá que un mensaje se repita 9 veces antes de registrar otro error, que no se puede detectar que rompa el bucle. Eliminar esta propiedad deshabilitará la verificación.

Si el mensaje ya tenía una propiedad msg.error cuando el nodo informó el error, esa propiedad se moverá a msg._error.

De forma predeterminada, el nodo Catch está configurado para ser activado por todos los nodos en la misma pestaña en el editor, pero también se puede configurar para apuntar a nodos específicos en la pestaña.

Si un nodo Catch está configurado para que lo activen todos los nodos, también se puede configurar para que solo se active en errores que aún no hayan sido detectados por otro nodo Catch. Esto le permite crear flujos de manejo de errores que se dirigen a nodos específicos y también tener un controlador de errores que capturará “todo lo demás”.

Si se registra un error desde el interior de un subflow, el tiempo de ejecución primero comprobará si hay nodos Catch dentro del subflujo. Si no hay ninguno allí, el error se propagará hasta el flujo que contiene la instancia del subflujo.

Más información: https://nodered.org/docs/user-guide/handling-errors#catchable-errors 

Errores no Registrados

Estos son los errores que un nodo escribe en el registro sin notificar al tiempo de ejecución correctamente. No se pueden manejar mediante el nodo Catch.

El nodo puede proporcionar formas alternativas de manejar el error. Por ejemplo, actualizando su propiedad de estado (que se puede monitorear con el nodo Status). Puede enviar un mensaje normalmente, pero con alguna propiedad adicional establecida para indicar el error.

Errores “uncaughtException”

Estos son un tipo particular de error de node.js que puede ocurrir cuando un nodo no puede manejar correctamente un error interno. Hacen que todo el tiempo de ejecución de Node-RED se apague, ya que eso es lo único seguro que se puede hacer.

Más información: https://nodejs.org/api/process.html#process_warning_using_uncaughtexception_correctly 

La causa típica será que un nodo haya iniciado una tarea asincrónica y esa tarea haya producido un error. Un nodo bien escrito habrá registrado un controlador de errores para esa tarea, pero si no hay uno, el error no se detectará.

Si encuentra este tipo de error, debe intentar identificar qué nodo causó el error y elevar un caso contra el autor del nodo. Esto no siempre es fácil debido a la naturaleza asincrónica del error.

Nodo Status

No todas las condiciones de error aparecerán como eventos de error que pueden detectarse en un nodo Catch. Por ejemplo, los nodos MQTT que pierden su conexión no generarán un error, pero sí un cambio de estado.

Así como el nodo Catch se puede usar para manejar eventos de error, el nodo Status se puede usar para manejar cambios en el estado de un nodo.

El mensaje enviado por el nodo Estado incluye la propiedad de estado que proporciona información sobre el estado y el nodo que desencadenó el evento.

 {
     "status": {
         "fill": "red",
         "shape": "ring",
         "text": "node-red:common.status.disconnected",
         "source": {
             "id": "27bbb5b1.d3eb3a",
             "type": "mqtt out"
         }
     }
 } 

El la visualización del estado de los nodos está habilitado de forma predeterminada, pero se puede deshabilitar en el menú > configuración

Aunque es útil como indicador visual, es aún más útil tener esta información de estado disponible en el flujo y poder tomar medidas en función del estado del nodo. Para ello disponemos del nodo “Status”.

Al añadir este nodo debe indicarse que nodos vamos a monitorizar su estado. El nodo de estado envía un mensaje cada vez que cambia el estado de los nodos supervisados. Este mensaje consta de dos objetos.

  • objeto de estado: se utiliza para obtener información de estado
  • objeto de origen: identifica el origen del mensaje mediante el ID de nodo. Cada nodo tiene una identificación de nodo única.

Debido a que la información de estado solo se envía cuando el estado cambia, generalmente es necesario colocar la información en una variable global o de flujo. Para hacer esto, pase el mensaje de estado a un nodo de función que tenga el siguiente código.

 var mqtt_status=msg.status;
 global.set('mqtt_status',mqtt_status);
 return;

Al crear funciones puedo poner un estado que sea leible desde el nod status: https://nodered.org/docs/creating-nodes/status 

Más información: http://www.steves-internet-guide.com/using-the-node-red-status-node/ 

Nodo Complete

Activa un flujo cuando otro nodo completa el tratamiento de un mensaje. Si un nodo le dice al runtime cuando ha terminado de manejar un mensaje, este nodo puede usarse para desencadenar un segundo flujo.

Por ejemplo, esto se puede utilizar junto con un nodo sin puerto de salida, como el nodo de envío de correo electrónico, para continuar el flujo.

Este nodo debe estar configurado para manejar el evento para los nodos seleccionados en el flujo. A diferencia del nodo Catch, no proporciona un modo ‘manejar todo’ que se aplica automáticamente a todos los nodos del flujo.

No todos los nodos activarán este evento; dependerá de si se han implementado para admitir esta función como se introdujo en Node-RED 1.0.

Más información: https://nodered.org/blog/2019/09/20/node-done

Debug Node-RED

El nodo debug puede ver las propiedades del mensaje enviando el mensaje al nodo de depuración.

La barra lateral de depuración muestra los mensajes que se pasan a los nodos de depuración dentro del flujo, así como ciertos mensajes de registro del tiempo de ejecución.

Junto a cada mensaje, la barra lateral de depuración incluye información sobre la hora a la que se recibió el mensaje y qué nodo de depuración lo envió. Al hacer clic en la identificación del nodo de origen, se revelará ese nodo dentro del espacio de trabajo.

El botón en el nodo se puede utilizar para habilitar o deshabilitar su salida. Se recomienda deshabilitar o eliminar los nodos de depuración que no se estén utilizando.

El nodo también se puede configurar para enviar todos los mensajes al registro de tiempo de ejecución o para enviar mensajes cortos (32 caracteres) al texto de estado en el nodo de depuración.

El nodo de depuración puede establecer su estado independientemente de lo que pase a la barra lateral de depuración. Útil si desea depurar un resumen más corto del estado, mientras muestra información más completa en la barra lateral donde hay más espacio. Para ello debe activarse en la configuración del nodo mostrar su estado.

Los mensaje de debug de la barra lateral se pueden borrar y filtrar por:

  • Todos los nodos
  • Flujo/pestaña actual
  • Nodos seleccionados.

De forma predeterminada, la barra lateral debug muestra todos los mensajes que se le pasan. Esto se puede filtrar haciendo clic en el botón para abrir el panel de opciones de filtro.

La barra lateral de depuración solo puede mostrar los 100 mensajes más recientes. Si la barra lateral muestra actualmente una lista filtrada de mensajes, los mensajes ocultos aún cuentan para el límite de 100. Si un flujo tiene nodos de depuración ruidosos, en lugar de filtrarlos desde la barra lateral, puede ser mejor desactivarlos haciendo clic en su botón en el espacio de trabajo.

El botón en el pie de página de la barra lateral se puede utilizar para abrir una ventana separada del navegador que contiene la barra lateral Depurar.

Existen una serie de acciones en bloque sobre los nodos de debug. Pueden verse en Action List (Ctrl/Cmd-Shift-P or View -> Action List) y asignar atajos de teclado a ellos:

  • core:activate-selected-debug-nodes
  • core:activate-all-debug-nodes
  • core:activate-all-flow-debug-nodes
  • core:deactivate-selected-debug-nodes
  • core:deactivate-all-debug-nodes
  • core:deactivate-all-flow-debug-nodes

Nodo para ver el payload que pasa: https://flows.nodered.org/node/node-red-show-value 

Más información:

Logging en Node-RED

Para ver los logs de node red:

  • node-red-log command (se se ha instalado con el script)
  • sudo journalctl -f -u nodered -o cat

Logging en Node-RED: https://nodered.org/docs/user-guide/runtime/logging

Node-RED usa un logger que escribe su salida en la consola. También admite el uso de módulos de registro personalizados para permitir que la salida se envíe a otra parte.

El logger de la consola se puede configurar en la propiedad de logging en su archivo de configuración settings.js:

 // Configure the logging output
 logging: {
     // Console logging
     console: {
         level: "info",
         metrics: false,
         audit: false
     }
 } 

Hay 3 propiedades que se utilizan para configurar el comportamiento del logger:

  • level: Nivel de logging a registrar
  • metrics: Cuando se establece en true, el tiempo de ejecución de Node-RED genera información sobre la ejecución del flujo y el uso de la memoria.
  • audit: Cuando se establece en verdadero, se registran los eventos de acceso a la API HTTP de administrador. El evento incluye información adicional como el punto final al que se accede, la dirección IP y la marca de tiempo.

También se puede utilizar un módulo de logging personalizado. Por ejemplo, la salida de métricas puede enviarse a un sistema separado para monitorear el desempeño del sistema. Esto luego se puede mandar a un sistema de análisis de log externo como Kibana o Logstash

Más información: https://nodered.org/docs/user-guide/runtime/logging 

El log está completamente administrado por journald fuera de node-red. Si está ejecutando en un sistema Linux utilizando el archivo de servicio systemd para ejecutar node-red, la salida se envía a /var/log/syslog.

El log se puede ver con el comando: sudo journalctl -f -u nodered -o cat

Salida de log al inicializar Node-RED:

 Start Node-RED
 Once Node-RED has started, point a browser at http://127.0.0.1:1880
 On Pi Node-RED works better with the Firefox or Chrome browser
 Use   sudo systemctl enable nodered.service  to autostart Node-RED at every boot
 Use   sudo systemctl disable nodered.service to disable autostart on boot
 To find more nodes and example flows - go to http://flows.nodered.org
 21 Nov 11:04:58 - [info] 
 Welcome to Node-RED
 ===================
 21 Nov 11:04:58 - [info] Node-RED version: v1.2.5
 21 Nov 11:04:58 - [info] Node.js  version: v12.19.1
 21 Nov 11:04:58 - [info] Linux 4.18.0-193.28.1.el8_2.x86_64 x64 LE
 21 Nov 11:04:59 - [info] Loading palette nodes
 node-telegram-bot-api deprecated Automatic enabling of cancellation of promises is deprecated.
 In the future, you will have to enable it yourself.
 See https://github.com/yagop/node-telegram-bot-api/issues/319. internal/modules/cjs/loader.js:1015:30
 21 Nov 11:05:03 - [info] RedBot version: 0.19.7 (node-red-contrib-chatbot)
 21 Nov 11:05:09 - [info] Dashboard version 2.23.4 started at /ui
 21 Nov 11:05:09 - [info] Settings file  : /root/.node-red/settings.js
 21 Nov 11:05:09 - [info] Context store  : 'memoryOnly' [module=memory]
 21 Nov 11:05:09 - [info] Context store  : 'file' [module=localfilesystem]
 21 Nov 11:05:09 - [info] User directory : /user/.node-red
 21 Nov 11:05:09 - [info] Server now running at https://127.0.0.1:1880/
 21 Nov 11:05:09 - [info] Active project : Demo_Proyecto
 21 Nov 11:05:09 - [info] Flows file     : /user/.node-red/projects/Demo_Proyecto/flow.json
 21 Nov 11:05:09 - [info] Starting flows
 21 Nov 11:05:09 - [info] Started flows
 21 Nov 11:05:09 - [info] [mqtt-broker:2ac34a26.7bd096] Connected to broker: mqtt://localhost:1883 

Flow Debugger

Una de las características que se mejorará en las siguientes versiones de Node-RED es un depurador de flujo adecuado.

Node-RED proporciona el nodo de depuración para ayudar al desarrollador a comprender lo que sucede en su flujo. Son herramientas útiles, pero tienen sus límites. Solo puede depurar en los puntos en los que ha agregado un nodo al flujo. Cuando tiene un flujo que involucra múltiples ramas y eventos de tiempo, puede ser difícil ver cómo fluyen los mensajes en cada rama al mismo tiempo.

Flow Debugger permitirá al desarrollador establecer puntos de interrupción a lo largo de su flujo. Cuando un mensaje llega a un punto de interrupción, el tiempo de ejecución se pausará y los mensajes dejarán de fluir. Luego, el desarrollador puede inspeccionar el flujo en diferentes puntos para inspeccionar los mensajes que esperan ser entregados.

Cuando se ejecuta con el depurador habilitado, el usuario podrá visualizar el rendimiento de sus flujos, para ver dónde se está gastando el tiempo o si existen cuellos de botella que podrían optimizarse.