NodeRED
- 1. ¿Que es NodeRED?
- 2. Crear una instancia de NodeRED en la plataforma de MakersUPV
- 3. Crea tu primer flow: 'Hola mundo' con NodeRED
- 4. Interfaz gráfica
- 5. Recibe los datos del ESP en NodeRED con MQTT
- 6. Ejercicios extra para los más valientes [OPCIONAL]
1. ¿Que es NodeRED?
Node-RED es como un juego de construcción que te permite conectar diferentes partes de tu hogar, tu negocio o tu proyecto de Internet of Thigns (como sensores, dispositivos y servicios en línea) de manera fácil y rápida, sin necesidad de ser un experto en programación. Es como jugar con bloques de LEGO, donde puedes unir diferentes bloques para hacer algo más grande y útil, como una casa o un robot.
Con Node-RED, puedes arrastrar y soltar diferentes "bloques" (llamados nodos) en una interfaz gráfica, conectarlos y configurarlos para que hagan cosas como leer datos de sensores o enviar alertas. Así, puedes automatizar procesos y hacer que todo funcione de manera más eficiente y sin necesidad de mucho conocimiento técnico.
Lo mejor de Node-RED es que tiene muchos bloques predefinidos que te permiten conectar con una gran variedad de dispositivos y servicios en línea, lo que lo hace muy versátil y adaptable a diferentes situaciones. Además, puedes integrarlo con otras herramientas y plataformas en el IoT para crear soluciones personalizadas y adaptadas a tus necesidades.
Te dejo con un video por si te has quedado con ganas de más:
2. Crear una instancia de NodeRED en la plataforma de MakersUPV
Para el taller de NodeRED hemos creado una plataforma donde cada uno de vosotros podrá tener su propia instancia de NodeRED de tal manera de que cada uno tenga su propia instalación y no os chaféis entre unos y otros.
Esta plataforma es accesible desde: taller-nodered.makersupv.com y ha sido creada utilizando el proyecto FlowForge. Si tienes curiosidad pregúntanos.
Registrarse en la plataforma de NodeRED
Deberéis crearos una cuenta por parejas en la plataforma que hemos alojado en nuestros servidores para que podáis hacer uso de NodeRED. Entra en click en taller-nodered.makersupv.com y haz click en Sign up:
Rellenar con el nombre de usuario, nombre completo, email y contraseña, como en cualquier otro sitio.
Os llegará un email con un enlace para confirmar la creación de la cuenta. Haz click en el enlace y confirma la cuenta.
El email llega desde donotreply@flowforge.com o talleres-nodered@makersupv.com. Si no te ha llegado a la bandeja de entrada, mira en la carpeta de Spam o en Promociones.
Una vez validado el email ya podrás loguearte en la plataforma con la cuenta que acabas de crear:
Crear una instancia de NodeRED
A continuación deberás crear una instancia de NodeRED. Esta instancia será unica y exclusiva para tu usuario, por lo que ningún compañero te podrá chafar tus progresos.
Para crear la instancia haz click en "Create Appication":
Te recomendamos utilizar el número del equipo que te han asignado, por ejemplo si eres el equipo 01, llama a la instancia "equipo01".
Ya nos hemos encargado de preparar el tipo de instancia y el stack que necesitaís para el taller por lo que el resto de opciones déjalas por defecto y haz click en "Create Application".
La instancia que acabas de crear aparecerá en la lista con estado starting. Deberás esperar a que el estado cambie a Running para poder empezar a hacer uso de la instancia de NodeRED.
Una vez haya pasado al estado running, le daremos a Open Editor para que nos habrá la instancia de NodeRED. También podremos acceder desde la URL [NOMBRE-INSTANCIA].taller-nodered.makersupv.com.
Observarás que hay que estar logueado en la plataforma para poder entrar, esto se ha hecho así para dar seguridad y que nadie pueda entrar a vuestros Flows.
Listo! ¿Facil verdad?... A decir verdad, hemos simplificado enormemente la tarea de creación de una instancia de NodeRED, gracias a usar FlowForge y a que lo hemos preparado de manera muy simplificada para este taller intruductorio. Pero NodeRED es compatible con casi cualquier hardware, por lo que lo puedes instalar en local en tu ordenador, en la nube con una VM con Docker, AWS, en una Raspberry Pi, en un NAS, en un ordenador viejo que tengas por ahí tirado por casa, etc.
Si te llama la atención, desde MakersUPV te animamos a que nos preguntes y a que te instales NodeRED en tus equipos para aprender. Para empezar, échale un vistazo a https://nodered.org/docs/getting-started/
También puedes hacer uso de la plataforma de Makers para tus proyectos (preguntanos) o usar la versión hosteada de FlowForge, aunque la versión gratis tiene bastantes limitaciones, pero te servirá para aprender, hacer pruebas o incluso proyectos personales sencillitos.
Ahora sigue con el siguiente tutorial para crear tu primer Flow en NodeRED.
3. Crea tu primer flow: 'Hola mundo' con NodeRED
A continuación vamos a crear el primer flow en NodeRED. Y como no podía ser de otra manera, vamos a realizar un 'Hola mundo', es decir, el flow más sencillito que se puede realizar en NodeRED.
Espera, espera... ¿Que narices es un flow?
Según ChatGPT:
En Node-RED, un "flow" es el término utilizado para describir el flujo de trabajo o la secuencia de nodos interconectados que se utilizan para automatizar un proceso o crear una aplicación. En otras palabras, un flujo en Node-RED es una representación visual de un programa que consta de una serie de nodos que realizan tareas específicas y que se conectan entre sí para formar un conjunto de acciones coordinadas.
Cada nodo en un flujo de Node-RED representa una funcionalidad específica, como leer un archivo, procesar datos, enviar un correo electrónico o publicar en Twitter. Los nodos se conectan entre sí mediante cables para indicar el orden en que se deben
ejecutar y cómo los datos deben fluir a través del flujo.
Los flujos de Node-RED son muy flexibles y se pueden personalizar para satisfacer una amplia gama de necesidades de automatización. Pueden ser utilizados para crear aplicaciones web, controlar dispositivos de IoT, analizar datos, integrar sistemas y mucho más.
Guía de uso, documentación oficial de NodeRED (recomendable tenerla a mano al principio): https://nodered.org/docs/user-guide/
1. El editor de NodeRED
El editor de Node-RED se compone de varias partes que se utilizan para crear y gestionar flujos. A continuación, se describen las partes principales del editor de Node-RED:
-
Barra de menú (header): la barra de menú se encuentra en la parte superior del editor y contiene opciones para crear, abrir, guardar y exportar flujos, así como para configurar la herramienta y ver la documentación.
-
Área de trabajo (workspace): el área de trabajo es el espacio central del editor donde se construyen los flujos. Es aquí donde se arrastran y sueltan los nodos, se conectan y se configuran.
-
Paleta de nodo (palette)s: la paleta de nodos se encuentra en el lado izquierdo del editor y contiene todos los nodos disponibles en Node-RED. Los nodos se organizan por categorías, como entrada, salida, procesamiento, etc.
-
Pestañas de flujo: las pestañas de flujo se encuentran en la parte superior del área de trabajo y se utilizan para alternar entre diferentes flujos que se han creado.
-
Barra de propiedades (sidebar): la barra de propiedades se encuentra en la parte inferior del editor y muestra las opciones de configuración del nodo seleccionado. Esta barra cambia según el nodo que se seleccione en el área de trabajo.
Estas son las partes principales del editor de Node-RED. Con estas herramientas, los usuarios pueden construir flujos de manera intuitiva y eficiente.
1. Hola Mundo
Vamos a realizar el Hola mundo de NodeRED. Este sería el flow más sencillito que podemos hacer con NodeRED y nos servirá para empezar a aprender como funciona NodeRED.
En primer lugar, vamos a cambiar el nombre al Flow. Si partimos de una instalación limpia, tendremos el workspace vacío con una sola pestaña, llamada Flow 1. Este es el primer flow, que se crea por defecto. Haremos doble click en la pestaña y se nos desplegará un editor. En este editor podremos cambiar las propiedades del flow como el nombre y la descripción.
Le pondremos "Hola mundo" como nombre y le daremos a Done:
A continuación vamos a insertar nuestro primer nodo dentro del flow "Hola mundo". El primer nodo va a ser un nodo de inyección o inject node. Este nodo nos permite inyectar un mensaje de forma manual o automatizada (luego lo veremos). El nodo de inyección es muy util para depurar un flow cuando estamos probando cosas (más adelante lo aprenderemos a usar también para este fin).
Insertar el nodo es tan sencillo como cogerlo de la paleta de nodos (está el primero, no tiene perdida, y si no lo podemos buscar en el buscador), y arrastrarlo al area de trabajo (da iguial donde, tu tiralo ahí en medio).
Posteriormente debemos configurar el nodo para que mande lo que nos interesa. Por defecto viene configurado para mandar un timestamp, es decir, un número con el tiempo. No obstante, lo vamos a cambiar para que mande el típico mensaje de "Hola mundo". Para ello hacemos doble click en el y se nos abrirá la ventana de propiedades. Cambiaremos el campo msg.payload para que mande un string, en vez de un timestamp.
Introduciremos "Hola mundo" para que mande este mensaje cuando le pulsemos:
El siguiente nodo que introduciremos a nuestro primer flow es el nodo debug. Se trata de un nodo de salida que nos permite visualizar los mensajes que mandemos en la consola de depuración debug (en la barra de la derecha). Este nodo, como su nombre indica, nos será tremendamente util para depurar nuestros flujos de trabajo.
Lo mismo que antes: lo arrastramos al area de trabajo y a continuación uniremos el nodo de inyección del mensaje Hola mundo, con el de depuración mediante un cable:
Como ya te habrás podido imaginar, esto lo que hará será mostrar el mensaje de Hola mundo en la consola de depuración cuando hagamos click en el botón de lanzar el mensaje.
Para probarlo, haremos click en el botón de Deploy, lo cual hará que se guarden nuestros cambios y se despliegue nuestro flujo, es decir, que se comience a ejecutar.
Haremos click en el botón de inyectar y veremos como se muestra el mensaje en la consola de depuración:
Enhorabuena, ya has realizado tu primer flow en NodeRED!!
2. Hola mundo "avanzado"
Ahora vamos a modificar un poco el flow para que muestre un mensaje cada segundo en la consola de debug con la fecha formateada (vamos un pasito más allá).
Para ello vamos a introducir el nodo de function, el cual es muy utilizado, ya que nos permite ejectuar código de Javascript para actuar sobre los mensajes. No te preocupes si no sabes Javascript, lo haremos muy sencillito.
Además, vamos a introducir otros conceptos como el de exportar/importar flows para poder compartirlos con la comunidad o aprovecharnos de flujos hechos por otra gente.
Para descargar nodos compartidos por la comunidad puedes echar un ojo a esto:
Para ello vamos a exportar el flow para importarlo en otro. Haremos click en las opciones y luego en Export (o Ctrl+E, para los que os molen los atajos). Nos aseguraremos de que esté seleccionada la opción de Current flow, puesto que queremos exportar solo el flow de Hola mundo. Haremos click en Copy to clipboard y si somos curiosos podemos pegarlo en un Notepad para ver el contenido, aunque no hace falta, os lo dejo más abajo.
El contenido será algo parecido a esto:
hola-mundo-nodered.json
[
{
"id": "3df5086d4148c6a8",
"type": "tab",
"label": "Hola mundo",
"disabled": false,
"info": "",
"env": []
},
{
"id": "4e9e565e59b044c2",
"type": "inject",
"z": "3df5086d4148c6a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "Hola mundo",
"payloadType": "str",
"x": 270,
"y": 340,
"wires": [
[
"5d6fe20a8f7613af"
]
]
},
{
"id": "5d6fe20a8f7613af",
"type": "debug",
"z": "3df5086d4148c6a8",
"name": "debug 1",
"active": true,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "false",
"statusVal": "",
"statusType": "auto",
"x": 840,
"y": 340,
"wires": []
}
]Se trata de un archivo de texto en formato JSON que describe el flow. Tanto los nodos, como las conexiones entre ellos y sus configuraciones.
Ahora nos vamos otra vez a opciones, hacemos click en Import (Ctrl + I), pegamos el JSON, asegurandonos que esté marcada la opción de New Flow para que nos cree un nuevo flujo de trabajo, y hacemos click en el botón rojo de Import.
Podemos aprovechar también para echarle un vistazo a los ejemplos que vienen instalados en NodeRED, que nos pueden servir para aprender
Observaremos que nos salé un mensaje de que el flow y los nodos ya existen. Esto es porque cada nodo tiene asignado un identificador único y al haber importado un flujo cuyos identificadores ya existen nos dice que algo no cuadra.
Nos da la opción de revisar los nodos para ver donde está fallando. En este caso le daremos directamente a que lo importe como una copia:
Veremos que se nos ha creado un nuevo flujo de trabajo con el mismo nombre y los mismos nodos, es decir, una copia identica.
Le cambiaremos el nombre del flujo a "Hola mundo avanzado".
Ahora vamos a cambiar las propiedades del nodo inject para que esté como estaba al principio. Es decir, para que inyecte un timestamp. Además, le vamos a decir que inyecte el mensaje cada segundo:
A continuación, lle vamos a añadir un nodo de función entre el nodo de inject y el de debug:
Nota: Tan solo tienes que arrastrar el nuevo nodo en medio del cable y soltar. Verás que se marca el cable en lineas discontinuas. Eso significa que se va a cortar el cable y añadir el nodo de función en medio.
A continuación introducimos este código en el bloque de función:
// Crear un objeto "Date" desde el payload
var date = new Date(msg.payload);
// Cambiar el payload para que sea un string formateado
msg.payload = date.toLocaleTimeString('es-ES', { timeZone: 'Europe/Madrid'});
// Devuelve el mensaje formateado
return msg;Este código lo que hace es coger el timestamp, formatearlo para obtener la hora y devolverlo.
Despliega el flujo y observa la salida de debug.
Ya estás preparado para seguir con el siguiente ejercicio!
4. Interfaz gráfica
A continuación vamos a aprender a crear interfaces gráficas con NodeRED de una manera SUUUUPER sencilla. Para ello vamos a hacer uso de una de las grandes maravillas de NodeRED: los plugins (o módulos).
Los plugins o módulos nos permiten obtener nodos adicionalmente a los que vienen incluidos por defecto en NodeRED, y nos permitirán extender las funcionalidades y simplificarnos según que cosas. Vamos a aprender a instalar y utilizar el módulo de node-red-dashboard y como su propio nombre indica, nos permitirá añadir dashboards con componentes gráficos donde mostrar datos, incluir botones, etiquetas, etc.
Puedes ver más información sobre el plugin en el siguiente enlace: https://flows.nodered.org/node/node-red-dashboard
1. Instalar node-red-dashboard
El proceso de instalación (para este y cualquier otro plugin "oficial" de NodeRED no puede ser más sencillo:
Veremos que nos sale un menu con dos pestañas, la primera son los nodos (o plugins) que tenemos instalados. La segunda, es donde encontraremos los plugins que podemos descargar, nos vamos a esta última y buscamos "dashboard" en el buscador:
Vemos que nos sale en tercera posición el que queremos instalar. Hacemos click en Install y listo. Facil, ¿no?
2. Primer ejercicio de prueba con interfaz gráfica
A continuación vamos a realizar una pequeña prueba para verificar que el módulo se ha instalado correctamente, y para conocer brevemente el funcionamiento de los nodos que proporciona este plugin.
Para ello, te pedimos que crees un flujo muy simple donde pintes el valor de timestamp e
Una vez desplegado, para acceder al dashboard deberás acceder a la raiz de la URL de tu instancia terminada en /url, por ejemplo:
https://equipo00.taller-nodered.makersupv.com/ui/
Y verás algo así:
Activa que se inyecte el timestamp cada 1 segundo y observa como crece en el dashboard
5. Recibe los datos del ESP en NodeRED con MQTT
Hasta ahora todo bastante facil, ¿verdad? Vamos a complicarlo un poco más!
Ahora vamos a graficar mediante los nodos de dashboard los datos de los sensores que recibimos mediante MQTT. Para ello deberás usar los nodos mqtt-in y mqtt-out para subscribirte a los topic de MQTT correspondientes.
Vamos a paso a paso para que no te pierdas:
1. Conexión al broker MQTT
En primer lugar nos vamos a conectar al broker servidor MQTT de donde vamos a enviar/recibir datos, al igual que lo hemos hecho con el ESP8266 en Arduino. Recuerda que tanto el dispositivo Arduino como el NodeRED deben estar conectados al mismo servidor MQTT, si no no podrán intercambiar información.
Para ello empieza introduciendo en el workspace un nodo mqtt in y presiona doble click para entrar en la configuración:
Te saldrá totalmente vació y listo para añadiur un nuevo mqtt-broker. Haz click en el botón de editar:
E introduce los datos de conexión para el broker MQTT de MakersUPV:
| Server MQTT | mqtt.makersupv.com |
| Port | 1883 |
| Client ID | (blank) |
| Username | makersupv |
| Password | makersupv |
Asegurate de poner bien el usuario y contraseña, si no no te funcionará!
Te debería quedar de la siguiente manera:
Haz click en el botón de Añadir para guardar el broker MQTT. Tan solo tendrás que realizar este procedimiento la primera vez (con el primer nodo que añadas)
2. Subscripción y publicación al tópico MQTT
Una vez guardado el servidor MQTT, posteriormente rellena el topic de subscripción para el sensor de temperatura:
Estos son los temas (topics) que debes usar:
|
Tipo |
Descripción | Unidades | Topic MQTT |
| Sensor | Lectura sensor temperatura DHT11 | ºC | taller/tXX/sens/DHT11/temp |
| Sensor | Lectura sensor humedad relativa DHT11 | %rh | taller/tXX/sens/DHT11/hum |
| Sensor | Lectura sensor luminosidad LDR | Volts | taller/tXX/sens/LDR |
| Actuador LED | Indicador LED Verde | taller/tXX/leds/verde | |
| Actuador LED | Indicador LED Rojo | taller/tXX/leds/rojo |
Recuerda cambiar t00 por el número de tu equipo
Haz click en Done. Se recomienda que en este punto añadas un nodo de debug y hagas un deploy para comprobar que se están recibiendo los datos del ESP8266 correctamente antes de pasar a los demás.
Una vez te hayas asegurado de que se reciben correctamente los datos, repite el proceso para los demás sensores (humedad y LDR),
Recuerda que puedes usar Copiar y Pegar (Ctrl+C, Ctrl+V) para los nodos
Ah! y para los LEDs... Deberás usar ¿que nodo?
Solución: ¿Que nodo uso para los LEDs?
Para los LEDs deberás usar el nodo mqtt-out, ya que lo que queremos es que el mensaje se mande dirección salida hacia el Arduino. Es decir, queremos usarlo para publicar un mensaje al topic correspondiente.
3. Gauges
Las gauges, o indicadores en español, nos permiten mostrar un dato de manera visual mediante un indicador tipo aguja, similar a por ejemplo el velocimentro de un coche o un manómetro de los analógicos.
Ya los hemos usado anteriormente en el ejemplo con el Timestamp, pero no los hemos configurado. Comenzamos por añadir uno y conectarlo al nodo mqtt-in de la temperatura:
Ahora vamos a configurarlo según los requisitos específicos de nuestra aplicación. Para ello haz click en el nodo correspondiente y cambia los valores de la etiqueta, unidades, rango mínimo y máximo, colores del gradiente, etc. También podrás cambiar entre los distintos tipos de indicador (tipo aguja, donut, compás...)
Te recomiendo usar los nodos de Debug para cerciorarte que los datos llegan y en el formato que esperas
Experimenta las opciones que te da el nodo de Gauge hasta que encuentres la opción que más te guste para representar la temperatura! Recuerda que deberás de pinchar en el botón de Deploy para desplegar los cambios cada vez que edites algo.
Comprueba que los datos se grafican como toca y que el gráfico se va actualizando en tiempo real según van variando las condiciones climáticas
Utiliza tu mano para calentar el sensor de temperatura DHT11 y tirale vaho con la boca para ver como aumenta la humedad relativa
Una vez tengas el de temperatura funcionando deberás hacer lo mismo para el sensor de humedad y para el de lumninosidad.
Cuando hayas acabado, el resultado final debería ser algo parecido a la imagen de arriba, con un Gauge mostrando cada uno de los valores de los sensores.
4. Interruptores/botones
Ahora nos faltaría introducir una manera de encender y apagar los LEDs o actuadores de nuestro circuito. En este ejemplo sencillo que estamos haciendo para el taller son simples LEDs, pero podrían ser perfectamente bombillas, una lámpara, un enchufe inteligente, un relé conectado al motor de la depuradora de casa, la calefacción o cualquier otra cosa, ya pillas la idea...
Para encender y apagar los LED vamos a utilizar el nodo Switch, el cual no es más que un simple interruptor de dos posiciones: ON y OFF.
Será tan facil como añadir un interruptor para cada uno de los LEDs y conectarlo al nodo MQTT de salida correspondiente:
A continuación deberás configurar los nodos interruptor para que manden un 1 cuando el estado sea ON y un 0 cuando sea OFF. De la siguiente manera:
Ejecutalo y prueba el resultado.
5. Gráfico temporal
Las gauges están muy bien para ver los datos en tiempo real, pero quizá te interese ver la evolución de la temperatura a lo largo de unas horas, ¿no? (o de unos minutos, para que nos dé tiempo a verlo en la clase)
Vamos a usar los gráficos (graph) para poder representar datos en un eje temporal:
Prueba a añadir un nodo Chart
Cambia las opciones para que aparezca donde te interese y despliega los cambios. Esperate a que lleguen datos de los sensores y verás como se va rellenando el gráfico en tiempo real.
Cabe destacar que estos gráficos son muy sencillos ya que no guardan los datos en ninguna base de datos y por tanto están bastante limitados. Pero para cosas sencillas nos valen
5. Resultado final
Una vez tengas todo, el resultado final debería ser algo así:
Te animo a que experimentes... Seguro que no te cuesta nada conseguir un resultado MUUUUUUCHO mejor que el mio!
¿Y si quisieramos guardar las métricas en una base de datos?
Pues eso daría para otra sesión de un par de horitas seguramente, pero NodeRED dispone de plugins creados para almacenar datos en una base de datos temporal tipo InfluxDB por ejemplo, o incluso también permite hacer enlaces con bases de datos SQL y NoSQL como MongoDB, etc.
Otra manera de guardar los datos podría ser en un archivo CSV separados por coma mediante el nodo de guardar en fichero, de esa manera los podríamos tener guardados en un archivo en el disco, aunque lo suyo para cosas serias es usar una base de datos como dios manda
Solución [No abrir, no seas tramposo]
[
{
"id": "5778ea97cd1ed074",
"type": "tab",
"label": "ESP8266",
"disabled": false,
"info": "Solución ejercicio visualización sensores y actuadores ESP8266",
"env": []
},
{
"id": "02973140566ef55c",
"type": "mqtt in",
"z": "5778ea97cd1ed074",
"name": "DHT11 Temperatura",
"topic": "taller/t00/sens/DHT11/temp",
"qos": "2",
"datatype": "auto-detect",
"broker": "b5bdeb4155381a5d",
"nl": false,
"rap": true,
"rh": 0,
"inputs": 0,
"x": 450,
"y": 160,
"wires": [
[
"7aa944fea3c07822"
]
]
},
{
"id": "609bc96d69db82e8",
"type": "mqtt in",
"z": "5778ea97cd1ed074",
"name": "DHT11 Humedad",
"topic": "taller/t00/sens/DHT11/hum",
"qos": "2",
"datatype": "auto-detect",
"broker": "b5bdeb4155381a5d",
"nl": false,
"rap": true,
"rh": 0,
"inputs": 0,
"x": 440,
"y": 220,
"wires": [
[
"9e44099297dcc3a5"
]
]
},
{
"id": "e0f0357e049277d2",
"type": "mqtt in",
"z": "5778ea97cd1ed074",
"name": "LDR Luminosidad",
"topic": "taller/t00/sens/LDR",
"qos": "2",
"datatype": "auto-detect",
"broker": "b5bdeb4155381a5d",
"nl": false,
"rap": true,
"rh": 0,
"inputs": 0,
"x": 450,
"y": 280,
"wires": [
[
"280c63846cb13519"
]
]
},
{
"id": "d34f1d5a1ba21375",
"type": "mqtt out",
"z": "5778ea97cd1ed074",
"name": "LED Verde",
"topic": "taller/t00/leds/verde",
"qos": "",
"retain": "",
"respTopic": "",
"contentType": "",
"userProps": "",
"correl": "",
"expiry": "",
"broker": "b5bdeb4155381a5d",
"x": 830,
"y": 400,
"wires": []
},
{
"id": "971b18f52f42468f",
"type": "mqtt out",
"z": "5778ea97cd1ed074",
"name": "LED Rojo",
"topic": "taller/t00/leds/rojo",
"qos": "",
"retain": "",
"respTopic": "",
"contentType": "",
"userProps": "",
"correl": "",
"expiry": "",
"broker": "b5bdeb4155381a5d",
"x": 820,
"y": 460,
"wires": []
},
{
"id": "7aa944fea3c07822",
"type": "ui_gauge",
"z": "5778ea97cd1ed074",
"name": "Temperatura",
"group": "3de4d1022cadb73f",
"order": 0,
"width": "6",
"height": "3",
"gtype": "gage",
"title": "Temperatura",
"label": "ºC",
"format": "{{value}}",
"min": "-10",
"max": "40",
"colors": [
"#00b3b0",
"#e6e600",
"#ca3838"
],
"seg1": "",
"seg2": "",
"diff": false,
"className": "",
"x": 930,
"y": 160,
"wires": []
},
{
"id": "9e44099297dcc3a5",
"type": "ui_gauge",
"z": "5778ea97cd1ed074",
"name": "Humedad",
"group": "3de4d1022cadb73f",
"order": 1,
"width": "6",
"height": "3",
"gtype": "gage",
"title": "Humedad",
"label": "%RH",
"format": "{{value}}",
"min": 0,
"max": "100",
"colors": [
"#1500b3",
"#cbe600",
"#ca3838"
],
"seg1": "",
"seg2": "",
"diff": false,
"className": "",
"x": 920,
"y": 220,
"wires": []
},
{
"id": "280c63846cb13519",
"type": "ui_gauge",
"z": "5778ea97cd1ed074",
"name": "Luminosidad",
"group": "3de4d1022cadb73f",
"order": 2,
"width": "6",
"height": "3",
"gtype": "gage",
"title": "Luminosidad",
"label": "units",
"format": "{{value}}",
"min": 0,
"max": "1000",
"colors": [
"#000000",
"#e6e600",
"#ffffff"
],
"seg1": "",
"seg2": "",
"diff": false,
"className": "",
"x": 930,
"y": 280,
"wires": []
},
{
"id": "34e6bf482f2f4e81",
"type": "ui_switch",
"z": "5778ea97cd1ed074",
"name": "LED Verde",
"label": "LED Verde",
"tooltip": "",
"group": "71d9266564131fe1",
"order": 0,
"width": "4",
"height": "2",
"passthru": false,
"decouple": "false",
"topic": "topic",
"topicType": "msg",
"style": "",
"onvalue": "1",
"onvalueType": "num",
"onicon": "",
"oncolor": "",
"offvalue": "0",
"offvalueType": "num",
"officon": "",
"offcolor": "",
"animate": true,
"className": "",
"x": 510,
"y": 400,
"wires": [
[
"d34f1d5a1ba21375"
]
]
},
{
"id": "6a9f570b1bcbf20c",
"type": "ui_switch",
"z": "5778ea97cd1ed074",
"name": "LED Rojo",
"label": "LED Rojo",
"tooltip": "",
"group": "71d9266564131fe1",
"order": 1,
"width": "4",
"height": "2",
"passthru": true,
"decouple": "false",
"topic": "topic",
"topicType": "msg",
"style": "",
"onvalue": "1",
"onvalueType": "num",
"onicon": "",
"oncolor": "",
"offvalue": "0",
"offvalueType": "num",
"officon": "",
"offcolor": "",
"animate": false,
"className": "",
"x": 500,
"y": 460,
"wires": [
[
"971b18f52f42468f"
]
]
},
{
"id": "b5bdeb4155381a5d",
"type": "mqtt-broker",
"name": "Broker MakersUPV",
"broker": "mqtt.makersupv.com",
"port": "1883",
"clientid": "",
"autoConnect": true,
"usetls": false,
"protocolVersion": "4",
"keepalive": "60",
"cleansession": true,
"birthTopic": "",
"birthQos": "0",
"birthPayload": "",
"birthMsg": {},
"closeTopic": "",
"closeQos": "0",
"closePayload": "",
"closeMsg": {},
"willTopic": "",
"willQos": "0",
"willPayload": "",
"willMsg": {},
"userProps": "",
"sessionExpiry": ""
},
{
"id": "3de4d1022cadb73f",
"type": "ui_group",
"name": "Sensores",
"tab": "be3445ce783f56f1",
"order": 1,
"disp": true,
"width": "12",
"collapse": false,
"className": ""
},
{
"id": "71d9266564131fe1",
"type": "ui_group",
"name": "Actuadores",
"tab": "be3445ce783f56f1",
"order": 2,
"disp": true,
"width": "12",
"collapse": false,
"className": ""
},
{
"id": "be3445ce783f56f1",
"type": "ui_tab",
"name": "ESP8266",
"icon": "fa-thermometer-half",
"disabled": false,
"hidden": false
}
]6. Ejercicios extra para los más valientes [OPCIONAL]
6.1. ¿Y si quisieras encender el LED rojo cuando la temperatura de la sala supere los 30 grados una tarde de agosto cualquiera en Valencia?
PISTA: Utiliza el nodo Switch y el nodo Change
Solución [No abrir, no seas tramposo]
6.2. NIVEL CRACK: ¿Te através a cambiar la luminosidad de los leds mediante el nodo Slider de la UI?
Esta vez sin pistas... y sin solución!!