Archivo de la etiqueta: flujos Node-RED

Biblioteca Node-RED

Node-RED dispone de una biblioteca de nodos, flujos y colecciones que la comunidad alimenta, donde obtener muchos recursos para la programación de Node-RED.

Los nodos de Node-RED se empaquetan como módulos y se publican en el repositorio público de npm https://www.npmjs.com/. Una vez publicados en npm, se pueden agregar a la biblioteca de flujo mediante un formulario.

Node-RED Library: https://flows.nodered.org/

Para añadir un nodo a Node-RED: https://nodered.org/docs/getting-started/adding-nodes

  • Usando el editor en gestor de paleta: https://nodered.org/docs/user-guide/editor/palette/manager 
  • Instalar desde npm con el comando npm install <nombre-paquete>
  • Con el fichero package.json que se genera en los proyectos. npm agregará automáticamente módulos adicionales instalados a la sección de dependencias del archivo package.json en su directorio de usuario.

Para actualizar los nodos:

  • La forma más fácil de buscar actualizaciones de nodos es abrir el Administrador de paleta en el editor.
  • También puede buscar actualizaciones desde la línea de comandos usando npm. En su directorio de usuario, ~/.node-red ejecute el comando: npm outdated y luego para los paquetes actualizables usar npm install <name-of-module>@latest

Cualquiera que sea la opción que adopte, deberá reiniciar Node-RED para cargar las actualizaciones.

Más información sobre package.json: https://nodejs.org/en/knowledge/getting-started/npm/what-is-the-file-package-json/ 

Si quieres crear tu propio nodo: https://nodered.org/docs/creating-nodes/first-node 

Core Nodes

La paleta Node-RED incluye un conjunto predeterminado de nodos que son los bloques de construcción básicos para crear flujos.

Todos los nodos incluyen documentación que puede ver en la pestaña de la barra lateral Información cuando selecciona un nodo.

Core nodes: https://nodered.org/docs/user-guide/nodes

Cuando instala Node-RED, se inicia con un conjunto predeterminado de nodos. Hay 8 categorías principales de nodos en la instalación predeterminada: entradas, salidas, funciones, social, almacenamiento, análisis, avanzado y Raspberry Pi (si se instala en una Raspberry Pi). 

Más información: http://noderedguide.com/node-red-lecture-4-a-tour-of-the-core-nodes/ 

Nodos Más Usados

A 2/12/2020 hay 29247 nodos.Los nodos más descargados: https://flows.nodered.org/search?type=node&sort=downloads 

A 2/12/2020 hay 1731 flows. Los más descargados: https://flows.nodered.org/search?type=flow&sort=downloads 

A 2/12/2020 hay 297 colecciones. Los más descargados: https://flows.nodered.org/search?type=collection&sort=downloads 

Usuarios Node-RED

Usuarios interesantes a los que seguir en https://flows.nodered.org/ 

Colecciones en Librería Node-RED

En la librería de Node-RED disponemos de colecciones, que son agrupaciones de nodos y flujos para agrupar y tener guardados.

Ejemplo de colección: https://flows.nodered.org/collection/cQjGjy9o32Rj

Colecciones interesantes:

Flujos en Librería Node-RED

En la librería de Node-RED disponemos de Flows creados por los usuarios y que comparten en https://flows.nodered.org/search?type=flow

Algunos Flujos destacados:

Monitorizar Raspberry Pi

Este flujo muestra en un dashboard la CPU, Memoria, uso del disco y temperatura del CPU de la Raspberry Pi donde está Node-RED. También hay dos botones para reiniciar y apagar el sistema. Es necesario instalar el nodo de Dashboard.

Flujo: https://flows.nodered.org/flow/fa6e4749ff7f9067fd6b5330bc54f9e3

Timer in Dashboard

Buen ejemplo de un timer en Dashboard: https://flows.nodered.org/flow/f24cb20846f57eec19ed617b25cb61ae

Este temporizador en NodeRED se puede implementar como un único subflujo configurable a través de variables de entorno. Para configurar el subflujo, debe proporcionar la iteración del temporizador (cada temporizador debe tener su propio número como: 1 | 2 |… n) y valores para la payload en el inicio y la parada (cadena).

Más información:

Nodos necesarios:

Schneider POWERLOGIC PM5150 via MODBUS TCP

Flow: https://flows.nodered.org/flow/7c058a46b095af5b8bd469c7c5328454

Subflow para leer variables del power meter PM5150 de Schneider.

Usa el nodo https://flows.nodered.org/node/node-red-contrib-modbus contra Schneider Power Logic PM5000 series: https://www.se.com/ww/en/product-range/61281-powerlogic-pm5000-series/

Se hace una función para leer y sacar un objeto json con los datos que devuelve el nodo de Modbus.

Nodos Adicionales

Hay más de 3000 nodos, algunos de los más interesantes son:

Extra Nodes: https://github.com/node-red/node-red-nodes 

Más información sobre nodos interesantes:

Nodos en Node-RED por Categorías

Básicos

Nodo Generador de Datos

Un nodo Node-RED para crear una cadena de valores de datos ficticios a partir de una plantilla. Útil para casos de prueba.

Nodo: https://flows.nodered.org/node/node-red-node-data-generator 

Node RBE

Un nodo Node-RED que proporciona informes por excepción (RBE) y capacidad de banda muerta. RBE = Report by Exception

El nodo se bloquea a menos que el valor entrante cambie – modo RBE, o cambie en más de una cierta cantidad (valor absoluto o porcentaje) – modos de banda prohibida.

Básicamente este nodo hace de filtro, de detector de flanco y puede servir para implementar histéresis.

Nodo: https://flows.nodered.org/node/node-red-node-rbe

Explicar: https://cookbook.nodered.org/basic/report-by-exception 

Nodo Exec

El nodo exec le permite tomar cualquier comando del sistema existente, programa de Python o script que haya escrito y ejecutarlo desde node-red e incorporar los resultados en su flujo. Ejecuta un comando de sistema y devuelve su salida. 

El nodo puede ser configurado para esperar hasta que el comando se complete, o para enviar su salida a medida que el comando la genera.

Para más información leer la información del nodo en Node-RED

El comando que se ejecuta puede ser configurado en el nodo o proporcionado por el mensaje recibido.

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

Una mejora: https://flows.nodered.org/node/node-red-node-daemon. Similar al nodo exec pero este llama al comando en el momento de inicio y luego conduce cualquier entrada al nodo al STDIN del comando en ejecución, y alimenta cualquier STDOUT a la primera salida. Útil para monitorear procesos basados en la línea de comandos.

Otra alternativa: https://flows.nodered.org/node/node-red-contrib-bigexec

Ejecutar un Script de Python

Ejecutar un script de Python usando el nodo exec.

Leer: https://www.rodened.com/posts/how-to-use-python-in-node-red-1/

También se le pueden pasar argumentos y el script de python debe estar preparado para recogerlos en el formato.

Existe un nodo que ayuda a hacerlo: https://flows.nodered.org/node/node-red-contrib-pythonshell

Instalar python y crear entornos virtuales desde Node-RED: https://flows.nodered.org/flow/778859ca2503db35ff0e12341508efef/in/vL27qorhYRSn

Flujo para ejecutar python con nodo exec y template: https://flows.nodered.org/flow/0a6e073bcd6bda364fafd32699837cc7

También se pueden escribir funciones en python usando estos nodos:

Ejemplo:

[{"id":"8a505abb.d39b08","type":"tab","label":"pythontest","disabled":false,"info":""},{"id":"f4c14ccb.34202","type":"inject","z":"8a505abb.d39b08","name":"","topic":"","payload":"","payloadType":"date","repeat":"","crontab":"","once":false,"onceDelay":0.1,"x":140,"y":240,"wires":[["e7344e2.b6687b"]]},{"id":"e7344e2.b6687b","type":"template","z":"8a505abb.d39b08","name":"","field":"payload","fieldType":"msg","format":"python","syntax":"plain","template":"import time\n\nwhile True:\n    print(time.ctime())\n    time.sleep(10)\n","output":"str","x":320,"y":240,"wires":[["ab959ca2.a43e"]]},{"id":"ab959ca2.a43e","type":"file","z":"8a505abb.d39b08","name":"","filename":"pythontest.py","appendNewline":false,"createDir":false,"overwriteFile":"true","encoding":"none","x":510,"y":240,"wires":[["7cbbdbb3.3de674"]]},{"id":"7cbbdbb3.3de674","type":"exec","z":"8a505abb.d39b08","command":"python3 pythontest.py","addpay":false,"append":"","useSpawn":"true","timer":"","oldrc":false,"name":"","x":740,"y":240,"wires":[["44900928.37bb68"],[],[]]},{"id":"44900928.37bb68","type":"debug","z":"8a505abb.d39b08","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"false","x":970,"y":240,"wires":[]}]

HTTP Request

Hacer peticiones de HTTP desde Node-RED. Estos nodos están instalados por defecto.

HTTP requests

Nodo JSON

JSON, es una forma estándar de representar un objeto JavaScript como una cadena. Las API web suelen utilizarlo para devolver datos.

Si una propiedad de mensaje contiene una cadena JSON, primero se debe analizar en su objeto JavaScript equivalente antes de poder acceder a las propiedades que contiene. Node-RED proporciona un nodo JSON para realizar esta conversión.

Conversión desde/hacia JSON: https://cookbook.nodered.org/basic/convert-json 

Más información: http://www.steves-internet-guide.com/working-with-json-data-node-red/ 

Nodo File

Nodo file, lee y escribe ficheros locales en el host donde está instalada la instancia de Node-RED.

El nombre del archivo debe ser una ruta absoluta, de lo contrario será relativo al directorio de trabajo del proceso Node-RED, que normalmente es .node-red

Uso de nodo file storage en docker.

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

Nodo Lógica Booleana

Un conjunto de nodos lógica booleana mejorado para Node-RED: flow interruption node, blinker node, invert node, filter node, etc… con valores persistentes después del reinicio y más.

Nodos: https://flows.nodered.org/node/node-red-contrib-boolean-logic-ultimate 

Nodo Moment

Nodo interesante para manejo de fechas:

Con este nodo solucionas el problema de la fecha, que coge la fecha del contenedor o servidor si no está bien configurada.

Nodo Buffer Parser

Nodos de Node-RED para convertir valores hacia y desde búfer/matriz. Admite Big/Little Endian, BCD, intercambio de bytes y mucho más

Muy interesante para tratamiento de datos

Nodo: https://flows.nodered.org/node/node-red-contrib-buffer-parser 

Timers y Loops

Timer Switch 

Un temporizador de Node-RED fácil, intuitivo y preciso que le permite encender/apagar algo varias veces al día y admite horarios de tan solo 1 segundo.

Timer switch https://flows.nodered.org/node/node-red-contrib-timerswitch muy interesante para temporizaciones.

Uso con dashboard: https://www.instructables.com/id/Day-Timer-Using-Node-Red-With-Persistant-Memory/ 

Loop

Nodos Node-RED para ayudar al flujo de bucles.

Este módulo tiene 3 nodos:

Counter loop: https://flows.nodered.org/node/node-red-contrib-loop-processing 

Nodo Interval Length

Un nodo Node Red para medir la longitud del intervalo entre mensajes sucesivos

Nodo: https://flows.nodered.org/node/node-red-contrib-interval-length

Nodo BigTimer

BigTimer es un nodo de temporización Node-Red que ofrece una gama de funciones de temporización. Los BigTimers se pueden utilizar individualmente o en grupos. Soporte completo para crepúsculo/atardecer y variaciones también control día/semana/mes (y días especiales). El nodo ofrece salidas adecuadas para MQTT, voz y bases de datos. 

Nodo: https://flows.nodered.org/node/node-red-contrib-bigtimer

Más información: https://tech.scargill.net/big-timer/

Nodo Cron/Temporizar eventos

Un nodo programador flexible (cron, eventos solares, fechas simples) para Node-RED con control dinámico total y soporte de zona horaria

Nodo: https://flows.nodered.org/node/node-red-contrib-cron-plus

Más Básico: https://flows.nodered.org/node/node-red-contrib-cron

Flujo de cron programable desde Dashboard: https://flows.nodered.org/flow/79a66966a6cc655a827872a4af794b94

Nodo Chronos

Programación, manejo de colas, enrutamiento, filtrado y manipulación de nodos basados en el tiempo Node-RED.

Nodo: https://flows.nodered.org/node/node-red-contrib-chronos 

Nodo iCalc

Este módulo Node RED obtiene los eventos de una URL ical o de un servidor caldav.

Nodo: https://flows.nodered.org/node/node-red-contrib-ical-events 

Nodo ActionFlows

Crea patrones de diseño extensibles, en bucle y reutilizables para flujos. 

ActionFlows trae bucles fáciles de usar y características OOP (programación orientada a objetos) al paradigma de programación de flujo de Node-RED. Tres nodos le permiten crear flujos extensibles, con alcance, en bucle y priorizados. Las utilidades incluyen evaluaciones comparativas de rendimiento con precisión de nanosegundos. 

Para comprender ActionFlows, revise cada sección comenzando con Conceptos básicos a continuación y los ejemplos de cada sección.

Nodo: https://flows.nodered.org/node/node-red-contrib-actionflows 

Stop Timer

Envía el mensaje a través de la primera salida después de la duración del temporizador. Un nuevo mensaje recibido antes de que expire el temporizador reemplazará el mensaje existente y el temporizador se reiniciará, a menos que el nuevo mensaje tenga un payload de ‘stop’ o ‘STOP’, que detendrá el temporizador.

Nodo: https://flows.nodered.org/node/node-red-contrib-stoptimer-varidelay

Utilidades

Nodo Toggle

Toggle switch node para Node-red. Nodopara cualquier conmutador (físico o virtual), almacenando su estado y proporcionando operación de alternancia sin necesidad de utilizar nodos de función o variables de flujo / globales.

Nodo: https://flows.nodered.org/node/node-red-contrib-toggle

Nodo Enrutado de Mensajes

Un nodo Node Red para enrutar mensajes entre nodos.

Nodo: https://flows.nodered.org/node/node-red-contrib-msg-router 

Nodo Summariser

Nodo para hacer cálculos de arrays como suma, contar, etc…

Nodo: https://flows.nodered.org/node/node-red-contrib-summariser

Nodo Máquina de Estados

Nodo: https://flows.nodered.org/node/node-red-contrib-xstate-machine

Nodo para Manipular Nodos

Nodos Node-Red para manipular flujos usando la API nodejs

Nodo: https://flows.nodered.org/node/node-red-contrib-flowman  

Nodo VNC

Nodo para conectar a un servidor y mandar eventos de teclado, ratón, etc…

Nodo: https://flows.nodered.org/node/node-red-contrib-vnc

Comunicaciones

Nodo socketio

Socket.IO es una biblioteca de JavaScript para aplicaciones web en tiempo real. Permite la comunicación bidireccional en tiempo real entre servidores y clientes web. Tiene dos partes: una biblioteca del lado del cliente que se ejecuta en el navegador y una biblioteca del lado del servidor para Node.js. Ambos componentes tienen una API casi idéntica. Como Node.js, está impulsado por eventos.

Nodo: https://flows.nodered.org/node/node-red-contrib-socketio 

Otros:

Nodo Utilidades Browser

Nodos Node-RED para la funcionalidad del navegador, como carga de archivos, cámara y micrófono. Muy interesante para subir datos, tomar datos de la cámara y del micrófono.

Nodo: https://flows.nodered.org/node/node-red-contrib-browser-utils 

Cliente Telnet

Un nodo Node-red para gestionar un diálogo con un servidor telnet sobre IP. Está destinado a simplificar el envío de consultas a un servidor y tratar las respuestas de forma asincrónica

Nodo: https://flows.nodered.org/node/node-red-contrib-telnet-client 

RedLink

Redlink es una forma de conectar muchas instancias de Node-Red juntas usando conexiones de «servicio» soft para crear esencialmente un cluster de «servicio» usando hardware dispar para crear una gran red de Node-Red.

Redlink no utiliza un sistema de mensajería tradicional, en realidad crea una malla jerárquica de servicios web interconectados utilizando HTTPS-POST como transporte y un concepto de enrutamiento similar a OSPF.

Nodo: https://flows.nodered.org/node/node-red-contrib-redlink

LDAP Login

Nodo Node-RED para Microsoft Active Directory (LDAP).

Nodo: https://flows.nodered.org/node/node-red-contrib-ldap-login

Comunicaciones Industriales

Nodo Modbus TCP

Nodos de modbusTCP:

Recomendado https://flows.nodered.org/node/node-red-contrib-modbus

Con el nodo https://flows.nodered.org/node/node-red-contrib-modbus no solo puedo leer modbus sino que puedo montar un servidor modbus.

Como usar este nodo:

Para leer datos lo mejor es usar modbus-flex-getter donde la entrada es un objeto json con estos datos:

  • unitid (0..255 tcp | 0..247 serial) – overrides default Unit-ID
  • fc (1..4)
  • start address (0:65535)
  • quantity (1:65535) of coils/inputs/registers to be read from the start address

Modbus-getter y Modbus-read indicas en el nodo los registros a leer. Importante: If you have more than 10 nodes on one communication configuration, use the Modbus-Flex-Getter or think about multiple connections to your Modbus device, please! You can do polling with the Modbus-Getter and Modbus-Flex-Getter, too by using an injecting node with an interval.

Vídeo manejar Modbus: https://www.youtube.com/watch?v=uillyhwBoEU 

Nodo Open PLC

Este paquete permite configurar e interactuar con una instancia de OpenPLC desde Node-RED.

Open-PLC: https://flows.nodered.org/node/node-red-contrib-openplc

Nodo OPC DA

Un nodo Node-RED para hablar con dispositivos de automatización utilizando el protocolo OPC-DA

Nodo: https://flows.nodered.org/node/node-red-contrib-opc-da

Nodo OPC UA

Nodos: 

KNX

Controle su instalación KNX a través de Node-Red. KNX IN/OUT de nodo único con importador de direcciones de grupo ETS opcional. Fácil de usar y altamente configurable.

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

BBDD

Nodo MySQL

Un nodo Node-RED para leer y escribir en una base de datos MySQL

Nodo de mysql: https://flows.nodered.org/node/node-red-node-mysql

Código del nodo de mysql: https://github.com/node-red/node-red-nodes/tree/master/storage/mysql 

Ejemplo: https://flows.nodered.org/flow/13c55d1aa11e864609e24fa534a1fa26

Ejemplo de uso: https://tech.scargill.net/tag/mqtt-and-mysql-on-node-red/ 

Insertar en BBDD. Función, que inserta el texto, usuario y localización de payload:

 texto = msg.payload.text;
 localizacion = msg.payload.location;
 usuario = msg.payload.user
 msg.topic = "INSERT INTO `tabla` (`Texto`, `Localizacion`, `Usuario`) VALUES ('" + texto + "', '" + localizacion + "', '" + usuario + "')";
 return msg; 

Nodo MongoDB

Un nodo Node-RED para guardar datos en una base de datos MongoDB.

Nodo MongoDB: https://flows.nodered.org/node/node-red-node-mongodb

SQL-Lite

Un nodo Node-Red para leer y escribir una base de datos sqlite local.

Flujo: https://flows.nodered.org/node/node-red-node-sqlite

SQL-lite https://randomnerdtutorials.com/sqlite-with-node-red-and-raspberry-pi/

Tutorial: http://developers.sensetecnic.com/article/using-sqlite-with-fred/

Nodo BBDD Connection Manager

Administrador de conexiones generalizado de Node-Red para permitir la agrupación de conexiones. 

Actualmente maneja los siguientes tipos de conexión:

  • postgreSQL
  • Casandra
  • DataStax
  • monetdb
  • neo4j
  • db2

Nodo: https://flows.nodered.org/node/node-red-contrib-connectionmanager

Nodo JSON DB

Nodo-RED Nodo para almacenar/recuperar fácilmente información almacenada en un archivo .json. Se implementa un almacenamiento en caché diferido para cargar la colección solo cuando sea necesario. Además, es posible configurar la colección para que solo escriba en el archivo json cuando Node-RED se detiene o se vuelve a implementar un flujo.

Nodo: https://flows.nodered.org/node/node-red-contrib-json-db

Ejemplo: https://flows.nodered.org/flow/fcd5e92e53d30abf73dcc9a21534e3d8 

Redes Sociales

Twitter

Nodo Twitter: https://flows.nodered.org/node/node-red-node-twitter

Nodo Twitter Stream: https://flows.nodered.org/node/node-red-contrib-twitter-stream 

Facebook

Nodo Facebook: https://flows.nodered.org/node/node-red-contrib-facebook

Nodo Facebook Messenger Writer: https://flows.nodered.org/node/node-red-contrib-facebook-messenger-writer 

Instagram

Nodo: https://flows.nodered.org/node/node-red-node-instagram 

IoT

Web Nodes

Una colección de nodos Node-RED para servicios web populares.

Paquete: https://flows.nodered.org/node/node-red-node-web-nodes 

Nodo no Oficial de Google Cloud

Nodo: https://flows.nodered.org/node/node-red-contrib-google-cloud 

Nodo TTN

Los nodos TTN para Node-RED reciben eventos y mensajes de dispositivos, así como también envían mensajes a los dispositivos.

TTN: https://www.thethingsnetwork.org/ 

Nodo: https://flows.nodered.org/node/node-red-contrib-ttn 

Decrypt Payload: https://flows.nodered.org/flow/845bb5b8cf788939dd261f472c289f77

Estructura de los Flujos en Node-RED

Cuando comience a usar Node-RED, probablemente comience a agregar todos sus nodos a la misma pestaña en el editor. Con el tiempo, eso puede provocar un desorden de nodos y cables que dificultan encontrar partes particulares del flujo.

Pensar un poco en cómo estructurar sus flujos al comienzo de cualquier proyecto de desarrollo puede ayudar a mantenerlos organizados y facilitar su mantenimiento. El método principal para organizar los flujos en Node-RED es separarlos en varias pestañas dentro del editor. Hay algunas estrategias diferentes que se pueden utilizar para hacer eso.

Si puede identificar componentes lógicos separados de su aplicación, considere colocarlos en pestañas separadas.

Para una aplicación de automatización del hogar, puede poner la lógica de flujo para cada habitación en una pestaña separada para reflejar el espacio físico. O es posible que desee separar los flujos según la función, por lo que todos los flujos relacionados con la iluminación van en una pestaña y la calefacción en otra.

Si está creando un backend de API HTTP, cada pestaña podría representar un tipo de recurso independiente al que accede la API.

El objetivo debe ser facilitar la «lectura» de un flujo individual de principio a fin. Mantenerlo en una sola pestaña puede ayudar a lograrlo.

Otra consideración es si está trabajando junto con otros desarrolladores en la misma aplicación Node-RED. Es mucho más fácil administrar la combinación de cambios si están en pestañas separadas. Si tiene desarrolladores con diferentes roles o especializaciones, considere cómo eso puede afectar la forma en que se organizan sus flujos.

Hacer Flujos Reutilizables

A medida que crea sus flujos, es posible que encuentre algunas partes comunes que desee reutilizar en varios lugares. Debe evitar tener varias copias de esas partes comunes distribuidas en sus flujos, ya que se vuelven más difíciles de mantener; termina con varios lugares para aplicar correcciones y podría pasar por alto uno fácilmente.

Node-RED proporciona dos formas diferentes de crear flujos reutilizables: nodos de enlaces y subflujos

Los nodos de enlace (link nodes) le permiten crear un flujo que puede saltar entre pestañas en el editor; agregan un cable virtual desde el final de un flujo hasta el inicio de otro.

Los subflows le permiten crear un nuevo nodo en la paleta cuya implementación interna se describe como un flujo. Luego, puede agregar nuevas instancias del subflujo en cualquier lugar donde lo haría con un nodo normal.

Existen algunas diferencias importantes entre los dos enfoques. Los nodos de enlace no se pueden usar en medio de un flujo, donde los mensajes se pasan por el enlace y luego regresan cuando el otro flujo se completa. Solo se pueden utilizar para iniciar o finalizar un flujo. También se pueden conectar a más de un nodo de enlace. Esto le permite pasar mensajes a varios flujos o hacer que varios flujos pasen mensajes a un solo flujo. Se pueden usar dentro de una sola pestaña para ayudar a que haya flujos en el espacio de trabajo sin que haya muchos cables que se crucen de derecha a izquierda.

Los link nodes no se pueden crear entrando o saliendo de un subflujo.

Más información sobre los nodos link: https://techexplorations.com/guides/esp32/nore-red-esp32-project/node-red-link/ 

Los subflujos aparecen como nodos regulares, por lo que se pueden utilizar en cualquier punto de un flujo. Sin embargo, cada instancia del subflujo es independiente de las demás. Cualquier contexto de flujo dentro del subflujo se limitará a las instancias individuales. Si el subflujo crea una conexión a un sistema remoto (p.e mandar un email), cada instancia creará su propia conexión.

Subflows en Node-RED

Un subflujo es una colección de nodos que se contraen en un solo nodo en el espacio de trabajo. Se pueden usar para reducir la complejidad visual de un flujo o para agrupar un grupo de nodos como un flujo reutilizable que se usa en varios lugares.

Una vez creado, el subflujo se agrega a la paleta de nodos disponibles. Las instancias individuales del subflujo se pueden agregar al espacio de trabajo como cualquier otro nodo.

Crear Subflows

Se puede crear un subflujo seleccionando la opción “Subflow -> Create Subflow” en el menú. Esto creará un subflujo en blanco y lo abrirá en el espacio de trabajo.

También es posible convertir la selección actual de nodos a un subflujo seleccionando la opción “Subflow -> Selection to Subflow” en el menú. Los nodos se moverán a un nuevo subflujo y se reemplazarán por un nodo de instancia de subflujo dentro del flujo.

Esto solo es posible si los cables que entran en la selección están conectados a un nodo, ya que el nodo de subflujo resultante solo puede tener como máximo una entrada.

Un subflujo no puede contener una instancia de sí mismo, ni directa ni indirectamente.

Editar un Subflow

Hay dos formas de abrir un subflujo para editar su contenido. Haga doble clic en su nodo en la paleta o haga clic en el botón “Editar plantilla de flujo” en el cuadro de diálogo de edición de un nodo de instancia de subflujo.

El subflujo se abre en el espacio de trabajo como una nueva pestaña. A diferencia de las pestañas de flujo normal, las pestañas de subflujo se pueden cerrar para ocultarlas.

Las entradas y salidas del subflujo están representadas por los nodos cuadrados grises que se pueden conectar al flujo de forma normal.

La barra de herramientas ofrece opciones para agregar y eliminar estos nodos. Al igual que con los nodos de flujos normales, puede haber como máximo una entrada y tantas salidas como sea necesario. 

La barra de herramientas ofrece una opción para agregar una salida de “estado” a un subflujo. Esto se puede utilizar para actualizar el estado de los nodos de instancia de subflujo. Lo que haya en payload y se mande al node ‘status’, se mostrará en el esatdo del subflow. También se puede usar el nodo ‘status’ y mandar al estado del subflow para mostrarlo.

El botón «editar propiedades» abre el cuadro de diálogo de propiedades del subflujo. Al igual que con el cuadro de diálogo Propiedades del flujo, se puede establecer el nombre y la descripción del subflujo.

  •  Propiedades: propiedades por instancia que se exponen como variables de entorno dentro del subflujo.
  •  Descripción: documentación por nodo formateada con Markdown. Esto se muestra en la barra lateral de Información cuando se selecciona el nodo.
  •  Apariencia: opciones para personalizar la apariencia del nodo.

La pestaña Apariencia ofrece opciones para:

  • cambiar la categoría de paleta en la que aparece el nodo
  • seleccione si se muestra la etiqueta del nodo
  • cambiar el color del nodo
  • cambiar el icono del nodo
  • proporcionar etiquetas de puerto personalizadas.

Personalizar Subflows

Al crear subflujos, es posible que desee poder personalizar su comportamiento de alguna manera. Por ejemplo, cambiar el tema de MQTT en el que publica. Un patrón para hacer eso es establecer msg.topic en cada mensaje que se pasa al subflujo. Pero eso requiere agregar un nodo Cambiar delante de cada instancia de subflujo para establecer el valor deseado.

Una forma más sencilla de hacerlo es mediante las propiedades de subflujo. Estas son propiedades que se pueden establecer en la instancia de subflujo y aparecen como variables de entorno dentro del subflujo.

La pestaña “Propiedades” del cuadro de diálogo de edición se puede utilizar para definir un conjunto de propiedades que luego se pueden personalizar para cada instancia del subflujo. Luego, las propiedades se exponen como variables de entorno dentro del subflujo.

Cada entrada en la tabla de propiedades se puede expandir para personalizar cómo se muestra cuando se edita una instancia del subflujo. La pestaña “Vista previa de la interfaz de usuario” proporciona una vista previa de cómo aparecerán.

En la propia instancia de subflow puedes añadir variables de entorno para solo esa instancia.

El valor que se pone es el valor por defecto y en la personalización puedo añadir el icono, label y el input type que puede ser de tipo:

  • input
  • credential
  • select
  • checkbox
  • spinner

Por ejemplo, para que dentro de un subflow publique en un topic que se defina como una variable de entorno y que se indica al crear el nodo, se pone como:

Entonces añadir MY_TOPIC como una propiedad del subflow.

Cuando un usuario edita una instancia individual, puede proporcionar un valor personalizado para MY_TOPIC para esa instancia del subflow.

Este patrón se puede aplicar a cualquier campo de configuración de nodo que le permita ingresar el valor directamente. Actualmente, no funciona para campos que se exponen como checkboxes u otros elementos personalizados de la IU.

Contexto en Subflow

Para los nodos en un subflujo, el contexto del flujo lo comparten esos nodos y no el flujo en el que se encuentra el subflujo. Los nodos dentro de un subflujo pueden acceder al contexto del flujo principal anteponiendo $parent. a la clave de contexto: var colour = flow.get(«$parent.colour»);

Las variables de flow creadas dentro de un subflow, no se ven en el “context data”.

Captura de errores en un Subflow

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.

En el caso del estado de del subflow, se puede detectar dentro del subflow con el nodo “status” o desde el flujo que contiene el subflow, también con el nodo “status”.

Borrar un Subflow

El botón «delete subflow» de la barra de herramientas del subflujo se puede utilizar para eliminar el subflujo y todas las instancias del mismo.

Más información de Subflows:

Exportable Subflows

En próximas versiones de Node-RED va a estar disponible los Subflows exportables. Se quiere facilitar a los usuarios la creación de sus propios nodos y compartirlos con la comunidad. El objetivo es permitir que los subflujos se publiquen como módulos de nodo adecuados que luego se puedan instalar como cualquier otro nodo de la biblioteca.

El trabajo ya está en marcha en esto: hay un borrador de PR (Pull Request) que agrega soporte básico para cargar subflujos en el tiempo de ejecución desde un módulo.

Ejemplo de Subflow

Ejemplo de subflow simple con un if then else. Consiste en crear unas variables de entorno MAX y MIN y en función de ellas enrutar. Estas variables tienen un valor por defecto de 100 en el MAX y de 0 en el MIN.

[{"id":"88bbe218.63673","type":"subflow","name":"Subflow 1","info":"","category":"","in":[{"x":50,"y":30,"wires":[{"id":"ab7f195c.aa0308"}]}],"out":[{"x":340,"y":200,"wires":[{"id":"ab7f195c.aa0308","port":"2"}]},{"x":340,"y":80,"wires":[{"id":"ab7f195c.aa0308","port":"0"}]},{"x":340,"y":140,"wires":[{"id":"ab7f195c.aa0308","port":"1"}]}],"env":[{"name":"MAX","type":"num","value":"100","ui":{"icon":"font-awesome/fa-thermometer-full","type":"spinner"}},{"name":"MIN","type":"num","value":"0","ui":{"icon":"font-awesome/fa-thermometer-empty","type":"spinner"}}],"color":"#DDAA99"},{"id":"ab7f195c.aa0308","type":"switch","z":"88bbe218.63673","name":"If else","property":"payload","propertyType":"msg","rules":[{"t":"lt","v":"MIN","vt":"env"},{"t":"gt","v":"MAX","vt":"env"},{"t":"else"}],"checkall":"true","repair":false,"outputs":3,"x":160,"y":140,"wires":[[],[],[]]},{"id":"95c32f11.1ede8","type":"tab","label":"Ejemplo Subflow","disabled":false,"info":""},{"id":"cf06a908.bb4758","type":"subflow:88bbe218.63673","z":"95c32f11.1ede8","name":"","env":[],"x":380,"y":80,"wires":[["98bc246e.47db78"],["11198781.6b7008"],["e488842f.92dd48"]]},{"id":"614a918a.f2d9","type":"inject","z":"95c32f11.1ede8","name":"","props":[{"p":"payload"},{"p":"topic","vt":"str"}],"repeat":"","crontab":"","once":false,"onceDelay":0.1,"topic":"","payload":"-1","payloadType":"str","x":130,"y":80,"wires":[["cf06a908.bb4758"]]},{"id":"98bc246e.47db78","type":"debug","z":"95c32f11.1ede8","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"false","x":670,"y":60,"wires":[]},{"id":"11198781.6b7008","type":"debug","z":"95c32f11.1ede8","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"false","x":670,"y":100,"wires":[]},{"id":"e488842f.92dd48","type":"debug","z":"95c32f11.1ede8","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"false","x":670,"y":140,"wires":[]}]

Programación Básica 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!…

Más información: https://about.sofia2.com/2016/11/16/que-es-nodered/

Historia de Node-RED: https://nodered.org/about/#history

Node-RED consiste en un tiempo de ejecución (runtime) basado en Node.js al que apunta un navegador web para acceder al editor de flujo. Dentro del navegador, crea la aplicación arrastrando los nodos de su paleta a un espacio de trabajo y comienza a conectarlos. Con un solo clic, la aplicación (deploy) se vuelve a implementar en el tiempo de ejecución donde se ejecuta.

La paleta de nodos se puede ampliar fácilmente instalando nuevos nodos creados por la comunidad y los flujos que cree se pueden compartir fácilmente como archivos JSON.

Node.js es un tiempo de ejecución (runtime) de un solo hilo: solo hay un bucle de eventos que debe compartirse entre todos los flujos en el tiempo de ejecución.

Si un usuario crea un flujo que utiliza muchos recursos, podría tener un impacto negativo en el rendimiento de los otros flujos. Cualquier error en ese flujo que bloquee el ciclo de eventos detendría la ejecución de todo lo demás. Del mismo modo, no tenemos ningún mecanismo para aislar el contexto global de cada flujo.

Pueden colocarse diferentes flujos cada uno en su propia instancia de tiempo de ejecución. Esta sería una buena práctica en caso de tener una gran cantidad de flujos para diferentes tipos de tareas.

Conceptos básicos de nodered: https://nodered.org/docs/user-guide/concepts

  • Nodo: Un nodo es el bloque de construcción básico de un flujo. Los nodos se activan al recibir un mensaje del nodo anterior en un flujo o al esperar algún evento externo, como una solicitud HTTP entrante, un temporizador o un cambio de hardware GPIO. Procesan ese mensaje o evento y luego pueden enviar un mensaje a los siguientes nodos del flujo.
  • Nodo de Configuración: Un nodo de configuración (config) es un tipo especial de nodo que contiene una configuración reutilizable que los nodos regulares pueden compartir en un flujo.
  • Flow (Flujo) Un flujo se representa como una pestaña dentro del espacio de trabajo del editor y es la forma principal de organizar los nodos. El término «flujo» también se utiliza para describir informalmente un conjunto único de nodos conectados. Por lo tanto, un flujo (pestaña) puede contener múltiples flujos (conjuntos de nodos conectados).
  • Contexto: El contexto es una forma de almacenar información que se puede compartir entre nodos sin usar los mensajes que pasan a través de un flujo. Hay tres tipos de contexto:
    • Nodo: solo visible para el nodo que establece el valor
    • Flujo: visible para todos los nodos en el mismo flujo (o pestaña en el editor)
    • Global: visible para todos los nodos
  • Mensaje: Los mensajes son los que pasan entre los nodos en un flujo. Son objetos simples de JavaScript que pueden tener cualquier conjunto de propiedades. A menudo se les conoce como msg dentro del editor. Por convención, tienen una propiedad llamada “payload” que contiene la información más útil.
  • Subflow: Un subflujo es una colección de nodos que se contraen en un solo nodo en el espacio de trabajo. Se pueden usar para reducir la complejidad visual de un flujo o para agrupar un grupo de nodos como un componente reutilizable que se usa en varios lugares.
  • Wire: Los cables conectan los nodos y representan cómo pasan los mensajes a través del flujo.
  • Palette (Paleta): La paleta está a la izquierda del editor y enumera los nodos que están disponibles para usar en los flujos. Se pueden instalar nodos adicionales en la paleta utilizando la línea de comandos o el Administrador de paletas.
  • Workspace: El área de trabajo es el área principal donde se desarrollan los flujos arrastrando nodos de la paleta y conectandolos. El espacio de trabajo tiene una fila de pestañas en la parte superior; uno para cada flujo y cualquier subflujo que se haya abierto.
  • Barra Lateral: La barra lateral contiene paneles que proporcionan una serie de herramientas útiles dentro del editor. Estos incluyen paneles para ver más información y ayuda sobre un nodo, para ver el mensaje de depuración y para ver los nodos de configuración del flujo.

Con respecto a Node-RED, se pueden hacer muchas cosas. Desde encender un LED en remoto, crear una API Rest en 5 minutos o conectar con una base de datos InfluxDB para graficar con Grafana. Aunque es visual, se requieren unos conocimientos técnicos en programación y tecnología medios y/o avanzados.

También permite programar en JavaScript funciones que pueden hacer de todo. Node-RED da mucho juego para muchas cosas.

El editor de flujos de Node-RED consiste en una sencilla interfaz en HTML, accesible desde cualquier navegador, en la que arrastrando y conectando nodos entre sí, es posible definir un flujo que ofrezca un servicio.

Como vemos, el editor se estructura como un entorno gráfico sencillo con:

  • Paleta de Nodos: Muestra todos los nodos que tenemos disponibles en nuestra instalación. Como veremos más adelante, existe un repositorio de nodos desarrollados por otros usuarios e incluso podemos crear e instalar nuestros propios nodos.
  • Editor: Nos permite arrastrar nodos desde la paleta y conectarlos. De este modo iremos creado el flujo de operación. El lienzo de node-red no tiene límites y se puede hacer zoom.

Help Sidebar: https://nodered.org/docs/user-guide/editor/sidebar/help 

Info Sidebar: https://nodered.org/docs/user-guide/editor/sidebar/info 

Agrupación de nodos. Para ayudar a organizar los flujos, ahora puede agrupar los nodos en el editor. El grupo puede tener un borde y un color de fondo personalizados y una etiqueta opcional.

Documentación: https://nodered.org/docs/user-guide/editor/workspace/groups 

Asimismo, seleccionando cada nodo, se muestra a la izquierda su formulario de configuración, donde es posible establecer las propiedades concretas de dicho nodo:

Usar el editor: https://nodered.org/docs/user-guide/editor/

En node-Red los nodos se comunican entre sí mediante msg, que es un objeto con propiedades y que podemos añadir propiedades. La propiedad principal es payload, pero puedo añadir las que quiera. Puedo añadir otras propiedades como temperatura.

Los objetos están en formato JSON: https://www.json.org/json-en.html

JSON (JavaScript Object Notation) es un formato ligero de intercambio de datos. Es fácil de leer y escribir para los humanos. Es fácil para las máquinas de analizar y generar.

JSON está construido sobre dos estructuras:

  • Una colección de pares nombre/valor. En varios lenguajes, esto se realiza como un objeto, registro, estructura, diccionario, tabla hash, lista de claves o conjunto asociativo.
  • Una lista ordenada de valores. En la mayoría de los lenguajes, esto se realiza como una matriz, vector, lista o secuencia.

Se trata de estructuras de datos universales. Prácticamente todos los lenguajes de programación modernos las soportan de una forma u otra. Tiene sentido que un formato de datos que es intercambiable con los lenguajes de programación también se base en estas estructuras.

Más información y herramienta de chequeo: On Line JSON checker

En JSON, toman estas formas:

  • Un objeto es un conjunto desordenado de pares de nombre/valor.
  • Un objeto comienza con {corchete izquierdo y termina con } corchete derecho.
  • Cada nombre va seguido de dos puntos y los pares nombre/valor están separados por una coma.

Si una propiedad de un mensaje contiene una cadena JSON, primero debe ser analizada en su objeto JavaScript equivalente antes de que se pueda acceder a las propiedades que contiene. Para determinar si una propiedad contiene una cadena o un objeto, se puede usar el nodo Debug. Node-RED proporciona un nodo JSON para hacer esta conversión.

En los nodos con entrada y salida, lo que entra sale y se mantiene la información salvo la que modifiques en el nodo. 

Hay tres propiedades principales y que siempre existen:

  • número de mensaje
  • topic
  • payload

Ejemplo:

{"_msgid":"f5daa4f0.f34888","topic":"timestamp","payload":"2020-03-08T11:53:50.646Z"}

El valor de una propiedad puede ser cualquier tipo de JavaScript válido como:

  • Boolean – true, false
  • Number – eg 0, 123.4
  • String – «hello»
  • Array – [1,2,3,4]
  • Object – { «a»: 1, «b»: 2}
  • Null

Más información sobre los tipos en javascript: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures

Disponemos de un debug que nos muestra el objeto y la podemos sacar por pantalla.

Los nodos son la unidad mínima que podemos encontrar en Node-RED. En la parte izquierda de la interfaz podemos ver la lista de nodos que vienen instalados por defecto y organizados en categorías según su funcionalidad. Esta es la paleta de nodos.

Hay nodos de entrada, salida, funciones, social, para almacenar datos, etc… Esto muestra la capacidad de Node-RED de comunicarse con otros servicios.

Se pueden clasificar en tres tipos de nodos:

  • Nodos que sólo admiten entradas: sólo admiten datos de entrada para ser enviados a algún sitio como pueda ser una base de datos o un panel de control.
  • Nodos que sólo admiten salidas: son los nodos que sólo ofrecen datos tras recibirlos a través de diferentes métodos como por ejemplo un mensaje MQTT.
  • Nodos que admiten entradas y salidas: estos nodos nos permiten la entrada de datos y luego ofrecen una o varias salidas. Por ejemplo, podemos leer una temperatura, transformarla en grados Celsius y enviarla a otro nodo.

Los nodos los arrastramos al flujo o flow, en inglés. Aquí es donde tendremos la lógica para cada dato a base de ir arrastrando nodos.

Categorías principales de la paleta de nodos:

  • common – the basic building block nodes: Inject, Debug, Catch, Status, Links, Comment.
  • function – the main function nodes: Function, Switch, Change, Template, Exec, Delay, Trigger, Range
  • network – nodes that do things over the network. This means the HTTP In and HTTP Response node are now sat next to each other and not split across different categories – likewise the MQTT, TCP and UDP nodes.
  • sequence – the nodes for working with message sequences: Split, Join, Sort and Batch.
  • parser – the nodes for working with particular data formats: CSV, HTML, JSON, XML and YAML.
  • storage – the file nodes.

Algunos de los nodos disponibles en Node-RED, los nodes de core son: https://nodered.org/docs/user-guide/nodes 

  • Inject: para disparar un flujo manualmente. Inyecta una payload a un topic.
  • Debug: sirve para mostrar mensajes en la zona de debug de Node-RED. Puede habilitarse o deshabilitarse.
  • Function: permite programar un nodo mediante JavaScript, pero es mejor buscar nodos hechos que hagan la función deseada, por ejemplo un temporizador.
  • Change: se usa para modificar las propiedades de un mensaje sin usar funciones
  • Switch: permite que los mensajes sean enrutados a diferentes ramas de un flujo mediante un conjunto de reglas contra el mensaje.
  • Template: se usa para generar texto usando las propiedades de un mensaje.

Trabajar con mensajes en Node-RED: https://nodered.org/docs/user-guide/messages 

Escribir funciones en Node-RED: https://nodered.org/docs/writing-functions 

Existen además muchos tipos de nodos que podemos ver en https://flows.nodered.org/ que son contribuciones de terceros.

Los nodos se organizan en flujos, para organizar los nodos como queramos. Es recomendable agrupar en flujos tareas que tengan relación entre ellos, pero solo a modo organizativo.

En node-red se puede trabajar con variables:

  • Contexto – solo aplica a un nodo
  • Flujo – aplica solo al flujo
  • globales – aplica a todo.

Cookbook de nodered: https://cookbook.nodered.org/ 

Node-RED programming guide: http://noderedguide.com/ 

Administración de node red mediante comando: https://nodered.org/docs/node-red-admin

Running node-red: https://nodered.org/docs/getting-started/running 

Más información: https://programarfacil.com/blog/raspberry-pi/introduccion-node-red-raspberry-pi/ 

Por ejemplo, podemos suscribirnos a un topic de MQTT, recibir un dato de temperatura y mostrarlo en la pantalla de debug:

primer flujo node-red

Pero no sólo podemos hacer esto, también podemos conectar con servicios de terceros como IFTTT, ThingSpeak, Google Home, ThingerIO, etc…

Primeros Flujos

Primer Flujo en Node-RED

Vamos a probar un flujo muy simple. Lo que hará es mostrar un texto por el panel de debug. Arrastra un nodo inject de la categoría input y un nodo debug de la categoría output al flujo. Los tienes que conectar entre ellos arrastrando el punto de la parte derecha del nodo inject sobre el punto de la parte izquierda del nodo debug.

primer flujo node-red

A continuación vamos a editar el nodo inject. Si haces doble click sobre el nodo se abrirá un panel donde nos muestra diferentes parámetros. En este panel tienes que seleccionar del menú desplegable donde pone Payload, la opción que pone String.

En el campo de texto pon cualquier cosa como por ejemplo Hola mundo 🙂

Para guardar la aplicación sólo tienes que dar a Deploy que si te has dado cuenta, ha pasado de estar en un color gris oscuro a rojo.

Para saber que se ha hecho un deploy, se puede hacer que mande un correo cada vez que se reinicia Node-RED. Flujo:

[{«id»:»67252650.d05f28″,»type»:»e-mail»,»z»:»45a71fc.1bebde»,»server»:»smtp.gmail.com»,»port»:»465″,»secure»:true,»tls»:true,»name»:»micuenta@gmail.com»,»dname»:»manda email alerta»,»x»:410,»y»:580,»wires»:[]},{«id»:»fc4c30da.caea3″,»type»:»inject»,»z»:»45a71fc.1bebde»,»name»:»»,»props»:[{«p»:»payload»},{«p»:»topic»,»vt»:»str»}],»repeat»:»»,»crontab»:»»,»once»:true,»onceDelay»:0.1,»topic»:»Mi instancia Node-RED deployed»,»payload»:»Mi instancia de Node-RED ha hecho un redeploy o se ha reiniciado.»,»payloadType»:»str»,»x»:210,»y»:580,»wires»:[[«67252650.d05f28»]]}]

deploy node-red

Una vez que lo hayas pulsado, volverá de nuevo al color gris oscuro. Esto quiere decir que ya tenemos guardados todos los cambios del flujo de Node-RED.

Para probar este primer flujo con Node-RED tenemos que abrir el panel de debug que está situado en la parte derecha. Luego, tienes que hacer click sobre la parte izquierda del nodo inject.

Esto hará que en el panel debug aparezca lo que hemos escrito en la configuración del nodo inject.

Como puedes ver, el mensaje se muestra en el panel debug.

Más información: https://programarfacil.com/blog/raspberry-pi/introduccion-node-red-raspberry-pi/ 

Ejercicios

Hacer un programa que se suscriba al topic aprendiendonodered/casa/m5stack/A (Botones A, B o C del m5stack) y saque por pantalla de debug el dato que manda.

Luego en función de si se hace click o doble click, publicar “ON” u “OFF” en el topic  aprendiendonodered/alumnoxx/ledA (A,B,C)

Hacer un programa que publicando en el topic /raspberrypi/led el texto “on” se encienda y publicando off se apague. 

Hacer un flujo que cada vez que se pulse el botón publique en el topic /raspberrypi/boton el valor recibido

Hacer otro flujo para que al pulsar el botón se encienda al detectar un flanco ascendente y al volver a pulsar se apague.

Solución: https://github.com/jecrespo/Curso-Node-RED