Archivo de la etiqueta: nodos 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

Nodos de Configuración en Node-RED

Un nodo de configuración (config) es un tipo especial de nodo que contiene una configuración reutilizable que puede ser compartida por nodos regulares en un flujo.

Los nodos de configuración se agregan a través del cuadro de diálogo de edición de un nodo que requiere el nodo de configuración. Tendrá un campo para seleccionar entre los nodos de configuración disponibles del tipo requerido o para agregar una nueva instancia.

Al hacer clic en el botón junto al cuadro de selección, se abrirá el cuadro de diálogo de edición para el nodo seleccionado o se agregará una nueva instancia del nodo de configuración.

El cuadro de diálogo de edición del nodo de configuración solo tiene las propiedades del nodo y las pestañas de descripción, ya que un nodo de configuración no tiene icono ni puertos para establecer etiquetas.

En el pie de página del diálogo hay una indicación de cuántos nodos usan este nodo de configuración. También proporciona un cuadro de selección para establecer el alcance del nodo de configuración. El alcance determina en qué flujos está disponible el nodo de configuración. De forma predeterminada, está disponible en todos los flujos, pero el cuadro de selección se puede utilizar para que sea local para un solo flujo.

Al igual que con los nodos normales, también se puede habilitar o deshabilitar usando el botón de alternar en el pie de página.

Algunos nodos necesitan compartir la configuración. Por ejemplo, los nodos MQTT In y MQTT Out comparten la configuración del intermediario MQTT, lo que les permite agrupar la conexión. Los nodos de configuración tienen un alcance global de forma predeterminada, esto significa que el estado se compartirá entre los flujos.

Un uso común de los nodos de configuración es representar una conexión compartida a un sistema remoto. En ese caso, el nodo de configuración también puede ser responsable de crear la conexión y ponerla a disposición de los nodos que usan el nodo de configuración. En tales casos, el nodo de configuración también debe manejar el evento de cierre para desconectarse cuando el nodo se detiene.

Dependiendo de como esté diseñado un nodo usará un nodo de configuración concreto. Cuando instalamos de la librería un conjunto de nodos vemos los nodos de configuración que también se instalan, p.e. https://flows.nodered.org/node/node-red-dashboard instala 3 nodos de configuración.

La barra lateral de los nodos de configuración proporciona una lista de todos los nodos de configuración, organizados por su alcance. Cada nodo muestra su tipo y etiqueta, junto con un recuento de cuántos nodos de flujo regular utilizan actualmente ese nodo de configuración.

Si el nodo de configuración no se utiliza, se muestra con un contorno de puntos. La vista también se puede filtrar para mostrar solo los nodos no utilizados seleccionando el filtro “no utilizado” en el encabezado.

El cuadro de diálogo de edición de un nodo de configuración se puede abrir haciendo doble clic en el nodo.

Más información: https://nodered.org/docs/creating-nodes/config-nodes 

La información confidencial de los nodos de configuración se guardan en el fichero cifrado flows_cred.json y no se comparte al exportar. El resto de datos de los nodos de configuración usados en el flow exportado, junto con su información, sí se exportan.

Uso del Editor de Node-RED

Manual: https://nodered.org/docs/user-guide/editor/

Workspace

Workspace: https://nodered.org/docs/user-guide/editor/workspace/

  • Herramientas
  • Personalizar vista

Flujos (Pestañas): https://nodered.org/docs/user-guide/editor/workspace/flows

  • Añadir un flujo
  • Editar propiedades de un flujo
  • Habilitar/deshabilitar un flujo
  • Borrar un flujo
  • Cambiar entre flujos

Nodos: https://nodered.org/docs/user-guide/editor/workspace/nodes

  • Añadir nodos de forma rápida
  • Editar las propiedades de un nodo
  • Habilitar/deshabilitar un nodo
  • Nodos de configuración

Entender los nodos de Node-RED: https://medium.com/node-red/understanding-node-red-flows-64e37f2777fb

Si un nodo tiene cambios no desplegados, muestra un círculo azul sobre él. Si hay errores con su configuración, muestra un triángulo rojo.

Pulsando ctrl + click del ratón puedo añadir nodos de una forma rápida:

La configuración de un nodo se puede editar haciendo doble clic en el nodo o presionando enter cuando el espacio de trabajo tenga el foco. Si se seleccionan varios nodos, se editará el primer nodo de la selecció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.

Por ejemplo, los nodos MQTT In y Out utilizan un nodo de configuración MQTT Broker para representar una conexión compartida a un agente MQTT.

Los nodos de configuración se agregan a través del diálogo de edición de un nodo que requiere el nodo de configuración. Tendrá un campo para seleccionar entre los nodos de configuración disponibles del tipo requerido o para agregar una nueva instancia.

El cuadro de diálogo de edición contiene tres pestañas:

  • Propiedades: el formulario de edición específico del tipo de nodo que se está editando.
  • 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.

Wires: https://nodered.org/docs/user-guide/editor/workspace/wires

  • Dividir wires
  • Mover wires
  • Borrar wires

Grupos: https://nodered.org/docs/user-guide/editor/workspace/groups 

  • Crear un grupo
  • Editar propiedades de grupo
  • Añadir nodos al grupo
  • Unir grupos
  • Desagrupar
  • Quitar un nodo de un grupo

Subflows: https://nodered.org/docs/user-guide/editor/workspace/subflows

  • Crear un subflow
  • Editar un subflow
  • Entradas y Salidas
  • Estado del subflow
  • Editar propiedades del subflow
  • Propiedades
  • Apariencia
  • Borrar un 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 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.

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.

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.

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.

Selección: https://nodered.org/docs/user-guide/editor/workspace/selection

  • Herramienta de lazo
  • Seleccionar todos los nodos
  • Seleccionar flujos

Si se mantiene presionada la tecla Ctrl al hacer clic en el nodo, el nodo se agregará a la selección actual (o se eliminará si ya estaba seleccionado).

Si se mantiene presionada la tecla Shift al hacer clic en el nodo, seleccionará ese nodo y todos los demás nodos a los que está conectado.

Se selecciona un cable cuando se hace clic en él. A diferencia de los nodos, solo es posible seleccionar un cable a la vez.

El editor admite las acciones estándar de copiar/cortar/pegar. Tenga en cuenta que utilizan un portapapeles interno en lugar del portapapeles del sistema.

Importar y Exportar Flujos: https://nodered.org/docs/user-guide/editor/workspace/import-export

  • Importar flujos
  • Exportar flujos

Los flujos se pueden importar y exportar desde el editor usando su formato JSON, lo que facilita compartir flujos con otros.

Más información: 

Búsqueda de flujos: https://nodered.org/docs/user-guide/editor/workspace/search

  • Sintaxis de búsqueda

El cuadro de diálogo Buscar se puede utilizar para buscar nodos dentro del espacio de trabajo, incluidos los nodos de configuración.

Indexa todas las propiedades de los nodos, por lo que se puede utilizar para buscar un nodo por su id, tipo, nombre o cualquier otra propiedad.

Paleta de Nodos

Paleta: https://nodered.org/docs/user-guide/editor/palette/

La paleta contiene todos los nodos que están instalados y disponibles para su uso.

Están organizados en varias categorías, con entradas, salidas y funciones en la parte superior. Si hay subflujos, aparecen en una categoría en la parte superior de la paleta.

Gestor de paleta: https://nodered.org/docs/user-guide/editor/palette/manager

  • Gestionar nodos
  • Instalar nodos

El Administrador de paletas se puede usar para instalar nuevos nodos en la paleta. Se puede acceder en la pestaña palette del cuadro de diálogo Configuración de usuario.

El Administrador de paleta tiene dos pestañas:

  • Nodes: enumeran los módulos que están instalados actualmente en el tiempo de ejecución
  • Install: enumera los módulos disponibles que se pueden instalar

Añadir nodos a la paleta: https://nodered.org/docs/user-guide/runtime/adding-nodes

Además de instalar nodos mediante el administrador de paletas (Palette Manager) podemos instalar mediante:

  • npm: Para instalar un módulo de nodo desde la línea de comandos, puede usar el siguiente comando desde su directorio de datos de usuario (por defecto, $HOME/.node-red) – npm install <npm-package-name>
  • Subir el módulo: tgz file.
  • Manual: Durante el desarrollo también es posible instalar nodos copiando sus archivos .js y .html en un directorio de nodos dentro de su directorio de datos de usuario. Si estos nodos tienen dependencias npm, también deben instalarse dentro del directorio de datos del usuario. Esto solo se recomienda realmente para fines de desarrollo.

Actualizar nodos:

  • La forma más fácil de buscar actualizaciones de nodos es abrir el administrador de paletas en el editor. Luego puede aplicar esas actualizaciones según sea necesario.
  • 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
    Para instalar la última versión de cualquier módulo, ejecute el comando: npm install <nombre-de-módulo>

Independientemente de la opción que tome, deberá reiniciar Node-RED para cargar las actualizaciones.

Barra Lateral

Manual: https://nodered.org/docs/user-guide/editor/sidebar/

La barra lateral contiene una serie de herramientas útiles del editor:

  • Information – view information about nodes and their help
  • Help – provides access to the help content for all nodes in the editor – not just the current selection
  • Debug – view messages passed to Debug nodes
  • Configuration Nodes – manage configuration nodes
  • Context data – view the contents of context

El orden de las pestañas puede cambiarse, simplemente moviendo las pestañas.

Algunos nodos contribuyen con sus propios paneles de barra lateral, como node-red-dashboard: https://flows.nodered.org/node/node-red-dashboard o la activación de proyectos.

Ejercicios

Instalar el nodo de dashboard e intentar hacer un botón que encienda el led de la Raspberry Pi https://flows.nodered.org/node/node-red-dashboard

Hacer un dashboard y mostrar los datos publicado de temperatura, humedad y presión en el topic aprendiendonodered/casa/m5stick/#

Crear un flujo que al pulsar un botón de tu raspberry pi, encienda el led de la raspberry pi del compañero.

Modifica el anterior para que encienda todas las de la fila, de forma consecutiva durante 1 segundo haciendo el efecto del coche fantástico Usa el node de delay.

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

Biblioteca Node-RED

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

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

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

Core Nodes

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

Nodos Adicionales

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

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

Más información:

HTTP Request

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

HTTP requests

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

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 MongoDB

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

Nodo Timer 

Timer Switch: https://flows.nodered.org/node/node-red-contrib-timerswitch

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

Nodo Modbus TCP

Nodos de modbusTCP:

Nodo Open PLC

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

Nodo OPC UA

Nodos: