Archivo de la etiqueta: Dashboard

Dashboard Node-RED

Dashboard UI

Uno de los nodos más populares de Node-RED es el de dashboard, que permite hacer un dashboard muy sencillo desde Node-RED.

Node dashboard: https://flows.nodered.org/node/node-red-dashboard

Github: https://github.com/node-red/node-red-dashboard

Cómo usarlo:

El diseño del dashboard debe considerarse como una cuadrícula. Cada elemento del grupo tiene un ancho: de forma predeterminada, 6 ‘unidades’ (una unidad tiene 48 píxeles de ancho de forma predeterminada con un espacio de 6 píxeles).

Cada widget del grupo también tiene un ancho: de forma predeterminada, ‘auto’, lo que significa que ocupará el ancho del grupo en el que se encuentra, pero puede establecerlo en un número fijo de unidades.

El algoritmo de diseño del dashboard siempre trata de colocar elementos tan altos y a la izquierda como sea posible dentro de su contenedor; esto se aplica a cómo se posicionan los grupos en la página, así como a cómo se colocan los widgets en un grupo.

Dado un grupo con un ancho de 6, si agrega seis widgets, cada uno con un ancho de 2, se colocarán en dos filas, tres widgets en cada uno.

Si agrega dos grupos de ancho 6, siempre que la ventana de su navegador sea lo suficientemente ancha, se sentarán uno al lado del otro. Si encoge el navegador, en algún momento el segundo grupo cambiará para estar debajo del primero, en una columna.

Es posible utilizar múltiples grupos si es posible, en lugar de un gran grupo, para que la página pueda cambiar de tamaño dinámicamente en pantallas más pequeñas.

Una descripción completa de los controles: https://flows.nodered.org/node/node-red-dashboard

Y se accede al dashboard con http://IP_NodeRED:1880/ui

Multiusuario en Dashboard: Este panel NO admite varios usuarios individuales. Es una vista del estado del flujo Node-RED subyacente, que a su vez es de un solo usuario. Si el estado del flujo cambia, todos los clientes serán notificados de ese cambio.

Los mensajes que provienen del tablero tienen un msg.socketid, y las actualizaciones como el cambio de pestaña, notificaciones y alertas de audio se dirigirán solo a esa sesión. Elimine msg.sessionid para enviar a todas las sesiones.

Más información:

https://randomnerdtutorials.com/getting-started-with-node-red-dashboard/
http://noderedguide.com/tag/dashboard/
http://developers.sensetecnic.com/article/a-node-red-dashboard-using-node-red-dashboard/
Vídeo: https://www.youtube.com/watch?v=N6DCcHne9hg
Advanced dashboards charts: https://es.coursera.org/lecture/developer-nodered/advanced-dashboard-nodes-charts-QrAmd
Visualización de datos con Node-RED: https://www.hackair.eu/data-visualisation-with-node-red-dashboard/

Tutoriales node red dashboard

Características

Barra lateral: El diseño del widget es administrado por una pestaña del tablero en la barra lateral del editor Node-RED.

Layout:

Tabs: desde aquí puede reordenar las pestañas, los grupos y los widgets, y agregar y editar sus propiedades.
Links: también se pueden agregar al menú otras páginas web. Opcionalmente, se pueden abrir en un iframe, si la página de destino lo permite.

Site:

Título: se puede establecer el título de la página de la interfaz de usuario.
Opciones: oculta opcionalmente la barra de título y permite deslizar el dedo hacia los lados entre pestañas en una pantalla táctil. También puede establecer si la plantilla usa el tema seleccionado o usa el tema de Material angular subyacente. También puede optar por utilizar el tema Material angular en todas partes.
Formato de fecha: establece el formato de fecha predeterminado para el gráfico y otras etiquetas.
Tamaños: establece la geometría básica del diseño de la cuadrícula en píxeles. Se puede configurar el ancho y alto de los widgets, al igual que el ancho de los grupos. Estas son las definiciones básicas de las «unidades» que se utilizan en otras partes del dashboard.

Theme: el tema y la fuente de la interfaz de usuario se configuran en la barra lateral del dashboard. Puede seleccionar un tema claro, oscuro o personalizado predeterminado. No puede tener diferentes temas para cada pestaña.

Nodos de Dashboard. Widgets.

Repositorio: https://github.com/node-red/node-red-dashboard

La mayoría de los widgets pueden tener una etiqueta y un valor, ambos pueden especificarse mediante las propiedades del mensaje entrante si es necesario y modificarse mediante filtros de angular. Por ejemplo, la etiqueta se puede establecer en {{msg.topic}}, o el valor se puede establecer en {{value|number:1}}% para redondear el valor a un lugar decimal y agregar un signo de %.

Cada nodo puede analizar msg.payload para que sea adecuado para su visualización.

Cualquier widget puede desactivarse pasando una propiedad msg.enabled establecida en false. Nota: esto no impide que el widget reciba mensajes, pero impide que las entradas estén activas y cambia el estilo del widget.

La mayoría de los widgets de interfaz de usuario también se pueden configurar mediante un mensaje msg.ui_control. Más información en https://github.com/node-red/node-red-dashboard/blob/master/config-fields.md

Widgets disponibles:

Audio out – Un widget que le permitirá reproducir audio (wav o mp3) o enviar texto a voz (TTS) al cliente.
Button – Pulsador para interactuar. El icono se puede configurar usando Material o fa-icons; el color y el color de fondo también se pueden configurar. Si el widget tiene un tamaño de 1 de ancho, el icono tiene prioridad.
Chart – Gráfica de datos. Tiene modos de gráfico de líneas, barras y tarta. Además, las etiquetas del eje X se pueden personalizar utilizando una cadena de formato de fecha. Para obtener más información sobre los formatos de datos de gráficos aceptados ver https://github.com/node-red/node-red-dashboard/blob/master/Charts.md
Colour Picker – Selector de color
Date Picker – Selector de fechas. El formato de fecha mostrado se puede especificar en la pestaña Site usando el formato moment.js.
Dropdown – Selección desplegable. Se pueden especificar varios pares de etiquetas y valores. Las opciones también se pueden configurar a través de msg.options que contienen una matriz de objetos. Si es solo texto, el valor será el mismo que el de la etiqueta; de lo contrario, puede especificar ambos mediante el uso de un objeto de pares «etiqueta»: «valor»: [«Opción 1», «Opción 2», {«Opción 3»: 3}]. msg.payload pre seleccionará el valor en el menú desplegable.
Form – Formulario. Un widget que puede estar compuesto por varios sub-widgets. Cuando se envían, todos los valores se envían como un solo mensaje.
Gauge – Indicador, tiene 4 modos: estándar (indicador simple), rosquilla (360 ° completo), brújula y onda. También puede especificar la gama de colores de los indicadores estándar y de rosca.
Notification – Erea alertas para el usuario; puede ser un mensaje emergente o un cuadro de alerta descartable. La alerta puede estar dirigida a un solo usuario.
Numeric – Entrada numérica con botones arriba / abajo.
Slider – Control deslizante horizontal simple, con tamaño de paso variable.
Switch – Conmutador/interruptor. También puede configurar dos iconos y / o colores según el estado.
Template – El nodo de plantilla permite al usuario especificar y crear sus propios widgets dentro del marco usando HTML, Javascript. Este es un widget de Angular.js. También puede usar esto para anular los estilos CSS integrados.
Text – Texto de solo lectura. La etiqueta y el valor pueden ser configurados. El widget de texto aceptará html, por lo que puede usarlo junto con los íconos fa.
Text input – El cuadro de entrada de texto, con etiqueta opcional, también admite modos de contraseña, correo electrónico y color.
UI-Control – Permite cierto control dinámico del Dashboard. El envío de un msg.payload del número de pestaña o tab_name cambiará a esa pestaña. Las pestañas se pueden habilitar/deshabilitar/ocultar/mostrar a través de msg. Los grupos se pueden ocultar y hacer visibles mediante un mensaje también.

Charts

El widget charts, traza los valores de entrada en un gráfico. Puede ser un gráfico de líneas basado en el tiempo, un gráfico de barras (vertical u horizontal) o un gráfico circular.

Características:

Cada valor de carga de mensaje de entrada se convertirá en un número. Si la conversión falla, el mensaje se ignora.
Los valores mínimos y máximos del eje Y son opcionales. El gráfico se escalará automáticamente a cualquier valor recibido.
Se pueden mostrar varias series en el mismo gráfico utilizando un valor de topic de mensaje diferente en cada mensaje de entrada. Se pueden mostrar varias barras de la misma serie mediante la propiedad msg.label.
El eje X define una ventana de tiempo o un número máximo de puntos para mostrar. Los datos más antiguos se eliminarán automáticamente del gráfico. Las etiquetas de los ejes se pueden formatear utilizando una cadena con formato de tiempo moment.js.
Ingresando un msg.payload que contenga una matriz en blanco [] borrará el gráfico.
La etiqueta también se puede establecer mediante una propiedad de mensaje estableciendo el campo con el nombre de la propiedad, por ejemplo {{msg.topic}}.
La salida del nodo contiene una matriz del estado del gráfico que se puede conservar si es necesario. Esto se puede pasar al nodo del gráfico para volver a mostrar los datos persistentes.

Más información de: https://github.com/node-red/node-red-dashboard/blob/master/Charts.md

Text Widget

Muestra un campo de texto no editable en la interfaz de usuario. Cada msg.payload recibido actualizará el texto basado en el formato de valor proporcionado.

El campo Formato de Valor puede utilizarse para cambiar el formato mostrado y puede contener filtros válidos de HTML y Angular. Por ejemplo: {{value | uppercase}} ° pondrá en mayúsculas el texto de payload y añadirá el símbolo de grado.

La etiqueta también puede ser establecida por una propiedad de mensaje estableciendo el campo al nombre de la propiedad, por ejemplo {{msg.topic}}.

También están disponibles las siguientes fuentes de iconos: Icono de Material Design (e.g. ‘check’, ‘close’) o un icono de Font Awesome (por ejemplo, ‘fa-fire’), o un icono de Weather.

Puedes utilizar el conjunto completo de iconos de google material si añades «mi-» al nombre del icono, por ejemplo, «mi-videogame_asset».

El widget también tiene una clase de nr-dashboard-widget-{the_widget_label_with_underscores} que se puede usar para un estilo adicional si es necesario.

NOTA: el nr-dashboard-xx es una clase de Node-RED que define el color. Son variables CSS. Ver las variables en https://github.com/node-red/node-red-dashboard/blob/master/src/theme.less

Para el nodo ui_text de Dashboard, el campo «Value Format» puede utilizarse para cambiar el formato de visualización y puede contener HTML y filtros de Angular https://scotch.io/tutorials/all-about-the-built-in-angularjs-filters que permiten modificar el texto.

Insertar en payload en lugar de un texto un icono usando fa (font awesome icons):

Bombilla:
Warning:
Error:
Con un if cambio color: World

Iconos que se pueden usar:

Ejemplo de uso de iconos fa: https://fontawesome.com/v4.7.0/examples/

Insertar iconos en HTML: https://www.w3schools.com/icons/

Algunos ejemplos de indicadores simples que pueden utilizarse para mostrar el estado utilizando el widget de texto, ya sea pasando en html incluyendo fa-iconos o utilizando las clases de color incorporadas. Ver este flow: https://flows.nodered.org/flow/90341d0d81f59762fe1cf8d753723636

Ejercicios Finales

1 respuesta

Veamos unos ejercicios completos con todo lo aprendido durante el curso.

Este ejercicio consiste en el montaje de 15 nodos remotos basados en Wemos D1 mini que gestionaremos con Node-RED y 15 Raspberry Pi con un led y un pulsador cada una y que además ejecutarán Node-RED localmente.

Montaje

Esquema de conexión nodo Remoto Wemos D1 Mini basado en:

Node-RED con Wemos D1 Mini: https://wiki.wemos.cc/products:d1:d1_mini
Shield Relay: https://wiki.wemos.cc/products:d1_mini_shields:relay_shield

Esquema de conexión RAspberry Pi:

Pin LED: 12 (GPIO 18)
Pin Pulsador: 16 (GPIO 23) (Usando la resistencia interna de Pulldown)

Preparación

La programación de los nodos remotos basados en ESP8266 se hará mediante Node-RED ejecutado en cada Raspberry Pi, para ello se instalará un firmware que puede obtenerse de: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/firmware-Ejercicio_Final/firmware-Ejercicio_Final.ino.

NOTA: este firmware es para el nodo 14, pero en caso de que el nodo sea otro nº de nodo sustituir estas líneas, siendo X = 1, 2, 3, 4 ,5, 6, ….:

const char* publish_10sec = «nodoX/dato10s»;
const char* publish_60sec = «nodoX/dato60s»;
const char* publish_reset = «nodoX/reset»;
const char* subs_led = «nodoX/led»;
const char* subs_rele = «nodoX/rele»;
if (client.connect(«wemosd1mini187222X»,»usuario_mosquitto»,»password_mosquitto»))

Este firmware publica en un topic cada 10 segundos y en otro cada 60 segundos. Los topics son:

nodoX/dato10s
nodoX/dato60s

En caso de que el nodo se resete publica en el topic: nodoX/reset

Los nodos estás suscrito a dos topic:

nodoX/led – enciende y apaga el led integrado de ESP8266
nodoX/rele – enciende y apaga el relé

Para el control del LED y botón de Raspberry Pi, se hará mediante la programación en cada uno de los Node-RED de cada Raspberry Pi.

RPiX/led – topic al que se suscribe para indicar si se enciende o apaga
RPiX/pulsador – topic al que publica el estado: pulsado (1) o liberado (0)

Testeo del Sistema

Una vez configurado todo el sistema comprobar que cada nodo y Raspberry Pi está publicando los datos y funciona el control al modificar los valores de los topics a los que están suscritos.

Para ello usar un cliente MQTT como MQTT.fx:

suscrito a los topics:
- nodoX/dato10s
- nodoX/dato60s
- nodoX/reset
- RPiX/pulsador
publicando a los topics:
- nodoX/led
- nodoX/rele
- RPiX/led

Una vez comprobado que leo los valores que publican los nodos y que puedo modificar el estado de los leds y relé publicando en los topics, pasamos a programar el sistema completo usando Node-RED.

Todo el código de los ejercicios: https://github.com/jecrespo/Curso-Node-RED/tree/master/04-Ejercicio%20Final

Ejercicio 1 – Dashboard

Configura Node-RED para que se vea un dashboard “Home” con tres grupos:

Suscripciones: las 3 suscripciones y botón que resete los valores
Pulsadores: dos botones para encender led y relé de nodo remoto
RPi: un pulsador que maneje el LED de la RPi y un gauge con el estado del pulsador.

Además al pulsar el pulsador encender el led detectando flaco, una pulsación enciende y otra pulsación apaga.

La configuración en Node-RED es:

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_1/Ejercicio_1-1.json

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_1/Ejercicio_1-2.json

Ejercicio 2 – Interacción por Grupos

Crear un nuevo grupo del dashboard Home llamado “Control Relés” con 3 botones que encienda:

Botón 1: controla relés 1, 2, 3, 4, 5
Botón 2: controla relés 6, 7, 8, 9, 10
Botón 3: controla relés 11, 12, 13, 14, 15

Dashboard

Nodos

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_2/Ejercicio_2.json

Ejercicio 3 – Seguridad

Poner un pin para encender los Reles, de forma que si no hay pin no se puede encender desde el dashboard. Simular una cerradura de forma que al poner el pin correcto se abre y luego a los 5 segundos se cierra.

Mostar en el dashboard el estado de la cerradura.

Crear un tab nuevo en el dashboard llamado pin de seguridad

Basarse en el flujo: https://flows.nodered.org/flow/7bcb0b049df4fa3c962294137ebaec19

Hacer el flujo como un subflow.

Dashboard

Flujo

Subflow

Código:

Ejercicio 4 – Email y SMS

Hacer un formulario en el dashboard para mandar un correo electrónico y otro para mandar un SMS usando el servicio de Twilio: https://www.twilio.com/

Dashboard

Flujo

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_4/Ejercicio_4.json

Luego usar esta configuración para enviar un correo y un SMS cuando se pulse el botón de la Raspberry Pi y el relé del nodo remoto 14 esté encendido, viéndolo en un dashboard.

Ejercicio 5 – Imágenes

Coger mediante Node-RED la imagen publicada en http://www.aprendiendoarduino.com/servicios/imagen.jpg y que se actualiza cada 30 segundos en el servidor.

Mostrar la imagen en el dashboard y su información.

Publicar en el topic raspberrypi/image la imagen por MQTT para poder reutilizarla.

Mandar la imagen por email al pulsar un botón.

Dashboard

Flujo

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_5/Ejercicio_5.json

Probar con otros servicios online a coger vídeo o imagen y tratarlo en Node-RED

Ejercicio 6 – Twitter

Hacer un flujo que tuitee algo. Para ello es necesario darse de alta en: https://developer.twitter.com/en/apps

Hacer un flujo que monitorice un hashtag (p.e. #Rioja), lo publique en cloudMQTT y lo guarde en una BBDD MySQL.

Flujo

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_6/Ejercicio_6.json

Ejercicio 7 – Open Weather Map

Usando el node de OpenWeatherMap, hacer un dashboard con la temperatura, humedad y presión donde se actualice el dato en un gauge y se haga una gráfica que muestre los últimos 7 días.

Mandar el dato de la temperatura a los nodos remotos, para ello publicar en el topic “nodoX/temperatura” el dato de temperatura y comprobar que llegan, para ello modificar el firmware para que los nodos remotos estén suscritos y lo muestren por el puerto serie.

Hacer un botón para que mande la predicción de los próximos 5 días al correo electrónico.

Dashboard

Flujo

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_7/Ejercicio_7.json

Ejercicio 8 – Telegram

Hacer un bot de Telegram con Node-RED que mande mensajes a grupos o canales y que responda a determinados comandos.

Para crear un bot de telegram: https://core.telegram.org/bots

Para añadir comandos al bot:

/setcommands
@aprendiendoarduino_bot

Pasar los comandos:

help – Ayuda
start – Inicio
enciende – Enciende Led
apaga – Apaga led
lee – Muestra datos broker

Y ya tengo los comandos configurados:

/help
/start
/enciende
/apaga
/lee

Para configurar el bot en Telegram solo hace falta poner el nombre del bot y el token.

Crear un canal o un grupo y hacer un flujo sencillo que al pulsar mande un un mensaje por Telegram a tu usuario y a al grupo o canal.

Ahora queda que desde Node-RED lea los comandos y responda. Al mandar el comando /enciende el LED de la Raspberry Pi al mandar el comando /apaga el LED de la Raspberry Pi. El comando /lee me devuelve el estado del LED.

Una forma de hacer esto es publicando el el topic /raspberrypi/led el valor ON u OFF y ya tengo otro flujo hecho en el ejercicio 1.

Para saber el estado, se puede guardar en una variable de flujo que se actualiza con el topic /raspberrypi/led de forma que no solo cuando modifico desde el bot sino desde otros lugares.

Flujo

Código: https://github.com/jecrespo/Curso-Node-RED/blob/master/04-Ejercicio%20Final/Ejercicio_8/Ejercicio_8.json

Dashboard en Node-RED

3 respuestas

Uno de los nodos más populares de Node-RED es el de dashboard, que permite hacer un dashboard muy sencillo desde Node-RED.

Node dashboard: https://flows.nodered.org/node/node-red-dashboard

Github: https://github.com/node-red/node-red-dashboard

Cómo usarlo:

El algoritmo de diseño del tablero siempre trata de colocar elementos tan altos y a la izquierda como sea posible dentro de su contenedor; esto se aplica a cómo se posicionan los grupos en la página, así como a cómo se colocan los widgets en un grupo.

Dado un grupo con un ancho de 6, si agrega seis widgets, cada uno con un ancho de 2, se colocarán en dos filas, tres widgets en cada uno.

Es posible utilizar múltiples grupos si es posible, en lugar de un gran grupo, para que la página pueda cambiar de tamaño dinámicamente en pantallas más pequeñas.

Una descripción completa de los controles: https://flows.nodered.org/node/node-red-dashboard
Y se accede al dashboard con http://IP_NodeRED:1880/ui

Más información:

https://randomnerdtutorials.com/getting-started-with-node-red-dashboard/
http://noderedguide.com/tag/dashboard/
http://developers.sensetecnic.com/article/a-node-red-dashboard-using-node-red-dashboard/
Vídeo: https://www.youtube.com/watch?v=N6DCcHne9hg
Advanced dashboards charts: https://es.coursera.org/lecture/developer-nodered/advanced-dashboard-nodes-charts-QrAmd
Visualización de datos con Node-RED: https://www.hackair.eu/data-visualisation-with-node-red-dashboard/

Tutoriales node red dashboard

Otro dashboard es el freeboard:

Web Estática

Web estatica: el modo httpstatic de settings.js me da la ruta de una web estáticas para mostrar por ejemplo una foto.

Se debe cambiar el valor de httpStatic para que sea la ruta completa a la carpeta que contiene sus imágenes o web estática.

Después de reiniciar el Node-RED, accederá al editor en http://localhost:1880/admin y podrá cargar la web estática con http://localhost:1880

Servir una web statica: https://cookbook.nodered.org/http/serve-a-local-file

Más información: ttps://discourse.nodered.org/t/how-to-enable-ability-to-input-local-image-files-in-to-node-red-dashboard/3085

Securizar el Dashboard

Documentación: https://flows.nodered.org/node/node-red-dashboard

Puede usar la propiedad httpNodeAuth en su archivo Node-RED settings.js para securizar el panel de control, ya que se crea de la misma manera que otros nodos HTTP. Los detalles se pueden encontrar al final de esta página en los documentos http://nodered.org/docs/security

Este Dashboard no es compatible con múltiples usuarios individuales. Es una vista del estado del flujo Node-RED subyacente, que en sí mismo es un solo usuario. Si el estado del flujo cambia, todos los clientes serán notificados de ese cambio.

Los mensajes provenientes del tablero tienen un msg.socketid, y las actualizaciones como cambio de pestaña, notificaciones y alertas de audio se dirigirán solo a esa sesión. Elimine el msg.sessionid para enviarlo a todas las sesiones.

La ruta de acceso al Dashboard de Node-RED se puede cambiar desde el campo httpNodeRoot se puede cambiar en la configuración.

Poner login con usuario y password en un dashboard para acceder con programación en Node-RED https://github.com/phyunsj/node-red-dashboard-login

Flow para poner un pin en Dashboard y confirmar una acción: https://flows.nodered.org/flow/7bcb0b049df4fa3c962294137ebaec19

Ejemplo Arduino + MQTT + NodeRed + Dashboard

Hacer un Dashboard como este usando dos sondas o dos potenciómetros que manden datos a varios topic y se muestre en el dashboard, así como un led que pueda encenderse al pulsar un botón del dashboard y dos leds que se enciendan cuando se supere el umbral de temperatura.

Además hacer una pestaña con las gráficas y hacer un flujo de debug para ver los datos.

Todos los datos serán guardarlos en la BBDD MariaDB instalada en las Raspberry Pi

Ejemplo hecho con 4 flujos:

Código node-red: https://github.com/jecrespo/Curso-IoT-Open-Source/blob/master/node-red/node-red.json

Código Arduino: https://github.com/jecrespo/Curso-IoT-Open-Source/blob/master/node-red/arduino-node-red/arduino-node-red.ino

Node-RED

2 respuestas

Node-RED es una herramienta muy potente que sirve para comunicar hardware y servicios de una forma muy rápida y sencilla. Simplifica enormemente la tarea de programar del lado del servidor gracias a la programación visual.

Fue creada por Nick O’Leary y Dave Conway-Jones del grupo de Servicios de Tecnologías Emergentes de IBM en el año 2013. Su objetivo es dar solución a la complejidad que surge cuando queremos integrar nuestro hardware con otros servicios.

Su punto fuerte es la sencillez. Nos permite utilizar tecnologías complejas sin tener que profundizar hasta el más mínimo detalle en todas ellas. Nos quedamos en una capa inicial donde nos centramos en lo importante y dejamos de lado aquello que no es práctico.

Wikipedia: https://en.wikipedia.org/wiki/Node-RED

La estructura mínima son los nodos. Estos se arrastran a través de la interfaz gráfica y nos permiten hacer una tarea concreta. Recibir una llamada HTTP, un mensaje MQTT o la activación de un pulsador.

Todos estos nodos se organizan en flujos o flows que agrupan nodos que se conectan entre ellos. Todo de una forma visual, sin apenas tener que programar.

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… ademas de ofrecer integración con apis de terceros, tales como Twitter, Facebook, Yahoo!…

Se trata de una herramienta visual muy ligera, programada en NodeJS y que puede ejecutarse desde en dispositivos tan limitados como una Raspberry, hasta en plataformas complejas como IBM Bluemix, Azure IoT o Sofia2 Platform.

Web: https://nodered.org/

Node-RED es una herramienta de código abierto, estando este disponible en github.

Repositorio: https://github.com/node-red/node-red

Una de las características más notables de Node-RED es la sencillez con la que se pueden crear nuevos nodos e instalarlos, en el siguiente enlace disponemos de toda la documentación necesaria: http://nodered.org/docs/creating-nodes/, en él, podemos ver que desarrollar un nuevo nodo es tan sencillo como crear un fichero HTML con el formulario de configuración mostrado en la imagen anterior para el nodo en concreto, y un fichero JS, con la lógica del nodo escrita en NodeJS.

De este modo, cualquier persona u organización puede crearse sus propios nodos, adaptando el motor de flujo a las necesidades de su negocio.

Los flujos programados en Node-RED se almacenan internamente en formato JSON y son portables entre distintas instalaciones de Node-RED, siempre que el Node-RED de destino tenga instalados los nodos utilizados en el flujo.

De este modo un flujo Node-RED consiste en un fichero con este aspecto:

La facilidad de desarrollo de nuevos nodos, así como la portabilidad de los flujos, confieren a Node-RED un marcado enfoque social. Gran parte de su éxito se fundamenta en que los nodos y flujos desarrollados por una persona u organización, pueden ser aprovechados por otras. En este sentido, en el sitio oficial de Node-RED encontramos una sección de contribuciones de terceros, con más de 1000 nodos y flujos subidos por la comunidad y listos para utilizar.

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

Getting Started Node-RED: https://nodered.org/#get-started

Comunidad Node-RED: https://nodered.org/#community

Documentación Node-RED: https://nodered.org/docs/

En cuanto a cómo instalar Node-RED, existen dos alternativas:

Modo Standalone: Donde se ejecuta como un proceso NodeJS independiente del resto de procesos.
Modo Embebido: Donde forma parte de una aplicación mayor, de forma que es responsabilidad de esta controlar el ciclo de vida del propio Node-RED

Ambas instalaciones son securizables tanto a nivel control de acceso con usuario y contraseña, como con certificado SSL para acceder al editor por protocolo seguro HTTPS.

Asimismo dispone de un API Rest de administración y operación (http://nodered.org/docs/api/) de manera que puede interactuar y ser controlado por un sistema externo.

Estas características son las que hacen que Node-RED sea adecuado para ejecutarse casi en cualquier plataforma, ya que le dan la versatilidad de ser instalado tal cual, por ejemplo en una Raspberry. O poder ser administrado por un sistema mayor, como por ejemplo IBM Bluemix.

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

Localmente
En un dispositivo
En la nube

Es posible instalar Node-RED en un portátil y controlar el broker desde el mismo.

Configuración node red: https://nodered.org/docs/configuration

Node-RED con Arduino: https://nodered.org/docs/hardware/arduino

API nodered: https://nodered.org/docs/api/

Más información:

https://about.sofia2.com/2016/11/16/que-es-nodered/
https://programarfacil.com/blog/raspberry-pi/introduccion-node-red-raspberry-pi/
https://www.toptal.com/nodejs/programacion-visual-con-node-red-conectando-el-internet-de-las-cosas-con-facilidad/es
Ver este articulo que tiene cosas interesante como las limitaciones de node red: https://ricveal.com/blog/node-red-construye-el-internet-de-las-cosas/

Vídeo Introducción IoT: https://www.youtube.com/watch?time_continue=85&v=vYreeoCoQPI

Curso IoT simatic (Siemens con Node red); http://www.infoplc.net/descargas/109-siemens/comunicaciones/2847-manual-simatic-iot2040-node-red

Instalar Node-RED en Raspberry Pi

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

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

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

Para iniciar Node-RED en el arranque de Raspberry Pi de forma automática usar:

sudo systemctl enable nodered.service

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

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

pantalla node-red

Para encontrar más nodos y ejemplos de flows ver https://flows.nodered.org/

Para añadir nodos adicionales primero debe instalar la herramienta npm, ya que no está incluida en la instalación predeterminada de Raspbian. Esto no es necesario si ha actualizado a Node.js 8.x.

Los siguientes comandos instalan npm y luego lo actualizan a la última versión.

sudo apt-get install npm
sudo npm install -g npm

Para poder ver la paleta e instalar nodos, reiniciar el servicio:

sudo systemctl restart nodered.service

Y luego para instalar un nodo:

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

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

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

Alternativamente se puede instalar mediante un script con el comando:

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

Configurar y Securizar Node-RED

Para configurar Node-RED seguir: https://nodered.org/docs/configuration

El fichero de configuración se encuentra normalmente en $HOME/.node-red/settings.js

Para securizar Node-RED seguir: https://nodered.org/docs/security para añadir usuario y password, así como otras configuraciones de seguridad

Para calcular la contraseña uso https://www.dailycred.com/article/bcrypt-calculator

Command line administration: https://nodered.org/docs/node-red-admin

Para usar https con Node-RED seguir estos tutoriales:

Programación Node-RED

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.

secciones principales node-red

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

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 nodos se unen en flujos que se ejecutan en paralelo.

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 datos o propiedades que no se pueden modificar.:

número de mensaje
topic
payload

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.

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.

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/?num_pages=1 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/

connect to a MQTT broker: https://cookbook.nodered.org/mqtt/connect-to-broker
suscribirse a un topic: https://cookbook.nodered.org/mqtt/subscribe-to-topic
publicar en un topic: https://cookbook.nodered.org/mqtt/publish-retained-message

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/

Node Red en Cloud

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

FRED: Front End For Node-RED

documentación de FRED: http://docs.sensetecnic.com/fred/
Fred Desktop documentation: http://docs.sensetecnic.com/desktop/
STS MQTT: http://docs.sensetecnic.com/mqtt/
STS InfluxDB: http://docs.sensetecnic.com/influxdb/
FAQ FRED: http://docs.sensetecnic.com/fred/faq/

Web principal de FRED

Sensetecnic: http://sensetecnic.com/
Docs Sensetecnic: http://docs.sensetecnic.com/
Developers Sensetecnic: http://developers.sensetecnic.com/

Google cloud: https://medium.com/google-cloud/deploy-your-node-red-environment-onto-kubernetes-clusters-using-google-cloud-platform-2e4775c2e79f

Más información:

http://noderedguide.com/tag/fred/

Ejemplos Node-RED

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.

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.

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/

Node-RED y MQTT

Sólo tienes que arrastrar el nodo mqtt que está en la categoría input al flujo.

Ahora hay que configurarlo. Aquí es donde vemos la potencia de Node-RED. Cuando utilizamos una tecnología, nos centramos en lo superficial. En el caso de MQTT lo único que tenemos que hacer es configurar el broker y el topic.

Al tratarse de un nodo de entrada, lo que hace es recibir los mensajes publicados en un topic es decir, se suscribe al topic. Haz doble click sobre el nodo para que abra el panel de configuración.

En el panel de configuración MQTT vamos a configurar primero el broker MQTT. Haz click en el lápiz que aparece en Server.

Esto abre un nuevo panel de configuración. Pon un nombre al broker MQTT por ejemplo ALARMA PUERTA. En Server tienes que poner la IP donde está instalado el broker MQTT y el puerto que utiliza, normalmente es el 1883.

Esta sería la configuración mínima. No te olvides de hacer click en el botón Add.

Después de esta acción volverás al panel de configuración del nodo mqtt y automáticamente, habrá seleccionado el broker MQTT que acabamos de crear.

Por último, vamos a rellenar el campo de Topic. Debe ser el mismo que hemos puesto en Arduino o el ESP8266, /casa/puerta/alarma. Una vez lo tengas, haz click en Done.

Ahora sólo nos queda probarlo. Para ello vamos a utilizar el mismo nodo debug de la categoría output que hemos utilizado antes.

Arrástralo al flujo, conecta los dos nodos y haz click en el botón Deploy.

Para probar el sistema lo podemos hacer de dos formas. Desde una terminal de Raspberry Pi podemos publicar un mensaje en el topic o directamente conectando la placa y simulando que abren la puerta.

El resultado sería el siguiente.