Interactúa con la API de Ubidots vía HTTP y MQTT usando las librerías nativas de Node-RED.
¿Qué es Node-RED?
Node-RED es un editor visual que permite a programadores de distintos niveles interconectar rápidamente hardware, sistemas en la nube, bases de datos y API para construir aplicaciones o servicios IoT.
Desde sus sencillos comienzos como una herramienta para prototipar, y que fue desarrollada como un proyecto secundario por un equipo de IBM, Node-RED ha logrado posicionarse como una herramienta de alto impacto para el mundo IoT, siendo adoptada oficialmente como habilitadora de reconocidas marcas de dispositivos industriales, como Multitech, Wago o Broadsens, entre otros.
Desde entonces, Node-RED se ha convertido en una herramienta visual para crear flujos de trabajo en entornos de IoT. Permite encadenar o cablear dispositivos y servicios de IoT como lo hace IFTTT, principalmente para aplicaciones web, API y servicios.
Según esta encuesta realizada por Node-RED con su comunidad, el 31% de usuarios usa esta herramienta en entornos de producción de manufactura, y su uso sigue creciendo, combinando su facilidad modular con la habilidad de entrar al mundo de protocolos industriales y de los PLC.
Por su parte, Ubidots es una plataforma para crear soluciones y negocios IoT de forma rápida e intuitiva. Esto se logra con múltiples herramientas para visualizar, transformar y analizar datos, así como para generar alertas y reportes, entre otras.
¡Con esta guía aprenderás a conectar Node-RED con Ubidots para acelerar aún más el desarrollo de tus soluciones!
Usaremos tanto los nodos MQTT de Ubidots, así como como las librerías HTTP y MQTT nativas de Node-RED (“nodos”) para leer/enviar datos desde y hacia Ubidots.
Índice de contenidos
1. Instalar los nodos MQTT de Ubidots en Node-RED
2. Usar los nodos MQTT de Ubidots
3. Usar los nodos HTTP y MQTT nativos de Node-RED
1. Instalar los nodos MQTT de Ubidots en Node-RED
Una vez Node-RED esté ejecutándose en tu computador, ve al menú de la parte superior derecha y haz clic en la opción ‘Manage pallets’. Una ventana, como se ve en la imagen de abajo, aparecerá. Ve a la pestaña de ‘Install’, busca ‘ubidots’ e instala los nodos llamados ‘ubidots-nodered’.
Finalmente, cierra y vuelve a iniciar Node-RED. Ahora deberías ver los nodos MQTT de Ubidots en la sección de ‘input’ y ‘output’ encontradas, respectivamente, en el panel ‘Node’ que está a la izquierda.
NOTA: Por defecto, los nodos MQTT de Ubidots usan QoS 1.
2.Usar los nodos MQTT de Ubidots
Nodo ‘publish’ MQTT de Ubidots
Como su nombre sugiere, este nodo publica datos en Ubidots. La siguiente es una configuración típica para el nodo:
Donde:
- Account type: define el bróker hacia el cual se enviarán los datos: Ubidots.
- Name: se refiere al nombre del nodo (opcional).
- Token: de tu cuenta de Ubidots. Puede ser un Account Token o un Organizational Token (requerido)
- Device Label: la etiqueta del dispositivo en el que se van a publicar los datos. Puede enviarse dinámicamente en el objeto JSON como mensaje de entrada con la llave: «ubidotsDeviceLabel«. Si no se envía una Device Label, tomará el valor por defecto del campo Device Label. Ten presente que se requiere el Device Label.
- TLS: Por defecto, todos los datos enviados se encriptan vía TLS. Desmarca la casilla si los datos deben enviarse sin encriptar.
El nodo acepta los siguientes parámetros como entradas:
- msg.payload: contiene el cuerpo del mensaje. En este caso, son los valores que se publicarán, en formato JSON, en el dispositivo dado. Cada llave es la etiqueta de la variable.
- msg.payload.ubidotsDeviceLabel: la etiqueta del dispositivo en el que se publicará el paquete. Si no se envía una Device Label, se tomará la del campo Device Label de la configuración del nodo.
Ejemplo de publicación: la sencilla estructura de nodo que se muestra a continuación publica valores de temperatura, humedad y presión a un dispositivo en Ubidots llamado “Machine_1”:
El ejemplo usa nodos tipo ‘inject’ para enviar valores fijos y un nodo tipo ‘function’ para construir el objeto de datos JSON aceptado por la plataforma. A la derecha, debajo del nodo ‘out’ de Ubidots, hay un nodo ‘debug’ que ayuda a inspeccionar el objeto de datos de salida como se muestra a continuación:
Esta es la versión portapapeles del ejemplo de publicación para que la puedas importar fácilmente a tu proyecto Node-RED.
[{«id»:»c365b578.54a618″,»type»:»inject»,»z»:»99b17f5d.db16″,»name»:»Temperature»,»topic»:»temperature»,»payload»:»58″,»payloadType»:»json»,»repeat»:»»,»crontab»:»»,»once»:false,»onceDelay»:0.1,»x»:270,»y»:140,»wires»:[[«2403cd9b.1b5802»]]},{«id»:»daf81333.2a9aa»,»type»:»inject»,»z»:»99b17f5d.db16″,»name»:»Humidity»,»topic»:»Humidity»,»payload»:»47″,»payloadType»:»num»,»repeat»:»»,»crontab»:»»,»once»:false,»onceDelay»:0.1,»x»:260,»y»:180,»wires»:[[«2403cd9b.1b5802»]]},{«id»:»452f88ba.1f1488″,»type»:»inject»,»z»:»99b17f5d.db16″,»name»:»Pressure»,»topic»:»pressure»,»payload»:»60″,»payloadType»:»num»,»repeat»:»»,»crontab»:»»,»once»:false,»onceDelay»:0.1,»x»:260,»y»:220,»wires»:[[«2403cd9b.1b5802»]]},{«id»:»2403cd9b.1b5802″,»type»:»function»,»z»:»99b17f5d.db16″,»name»:»function»,»func»:»var label = msg.topic;\nvar value = msg.payload;\n\nmsg.payload = {\n [label]: value\n};\n\nmsg.payload.ubidotsDeviceLabel = \»Machine_1\»;\n\nreturn msg;»,»outputs»:1,»noerr»:0,»x»:520,»y»:180,»wires»:[[«391d78a3.4a1418″,»a52cd0b9.af8af»]]},{«id»:»391d78a3.4a1418″,»type»:»debug»,»z»:»99b17f5d.db16″,»name»:»»,»active»:true,»tosidebar»:true,»console»:false,»tostatus»:false,»complete»:»false»,»x»:690,»y»:240,»wires»:[]},{«id»:»a52cd0b9.af8af»,»type»:»ubidots_out»,»z»:»99b17f5d.db16″,»name»:»»,»token»:»YOUR-UBIDOTS-TOKEN»,»label_device»:»»,»device_label»:»Machine_x»,»tier»:»business»,»tls_checkbox»:true,»x»:690,»y»:180,»wires»:[]}]
Nodo ‘subscribe’ MQTT de Ubidots
Como su nombre indica, este nodo subscribe variables o ‘topics’ (10 como máximo). La siguiente es una configuración típica para el nodo:
Donde:
- Account type: define el bróker hacia el cual se enviarán los datos: Ubidots.
- Name: se refiere al nombre del nodo (opcional).
- Token: de tu cuenta de Ubidots. Puede ser un Account Token o un Organizational Token (requerido)
- Device Label: la etiqueta del dispositivo en el que se van a publicar los datos. Ten presente que este campo será ignorado en caso de que se marque la casilla ‘Use custom topics’.
- TLS: Por defecto, todos los datos enviados se encriptan vía TLS. Desmarca la casilla si los datos deben enviarse sin encriptar.
- Use custom topics: habilitar la suscripción a ‘custom topics’. Esto inhabilita la suscripción a variables.
- Variable Labels/Custom topics: si la opción ‘Use custom topics’ está deshabilitada, debes ingresar la etiqueta de la variable a la cual el nodo se va a suscribir. De lo contrario, debes ingresar el ‘topic’ en el siguiente formato:
Device_Label/Variable_Label. Opcionalmente, se puede agregar /lv para suscribir al último valor únicamente. Los ‘topics’ soportan caracteres comodín: “+” para niveles únicos y “#” para múltiples niveles.
- Last Value: de la variable. Solo disponible cuando la opción ‘Use custom topic’ está deshabilitada.
- Add Variable/Add Topic: agrega una variable o ‘topic’ adicional (hasta 10).
La salida es un objeto JSON con la etiqueta de la variable como “key” y el último objeto valor/punto como “value”, por ejemplo:
{«variable_label»: {«value»: 100, «timestamp»: 1583523586668, «context»: { «key1»: «value1», «key2»: «value2»}, «created_at»: 1583523586732}
Ejemplo de suscripción a una variable: la siguiente estructura de nodo suscribe el último valor a las variables de ‘Temperature’, ‘Humidity’ y ‘Pressure’, todas ellas de un dispositivo en Ubidots llamado “Machine_1”:
El ejemplo usa un nodo tipo ‘function’ para dividir 3 variables en salidas individuales. De esta forma, las puedes manejar de forma separada. La siguiente imagen muestra la respuesta del objeto JSON cuando las variables se actualizan.
Esta es la versión portapapeles para que la puedas importar fácilmente a tu proyecto:
[{«id»:»a7bea0eb.9b358″,»type»:»function»,»z»:»99b17f5d.db16″,»name»:»function»,»func»:»const varLabels = [\n \»temperature\»,\n \»humidity\»,\n \»pressure\»\n ];\n \nvar payload = msg.payload;\nvar label = Object.keys(payload)[0];\nvar output = [];\nvarLabels.forEach(function (varLabel){\n if (label == varLabel) {\n msg.payload = payload[label].value;\n output.push(msg);\n } else {\n output.push(null);\n }\n});\n\nreturn output;»,»outputs»:3,»noerr»:0,»x»:460,»y»:480,»wires»:[[«1a30a1cc.46933e»],[«563aac2d.eb64b4»],[«2a5f0a3a.a77b46»]]},{«id»:»1a30a1cc.46933e»,»type»:»debug»,»z»:»99b17f5d.db16″,»name»:»Temperature»,»active»:true,»tosidebar»:true,»console»:false,»tostatus»:false,»complete»:»payload»,»targetType»:»msg»,»x»:650,»y»:440,»wires»:[]},{«id»:»563aac2d.eb64b4″,»type»:»debug»,»z»:»99b17f5d.db16″,»name»:»Humidity»,»active»:true,»tosidebar»:true,»console»:false,»tostatus»:false,»complete»:»payload»,»targetType»:»msg»,»x»:640,»y»:480,»wires»:[]},{«id»:»2a5f0a3a.a77b46″,»type»:»debug»,»z»:»99b17f5d.db16″,»name»:»Pressure»,»active»:true,»tosidebar»:true,»console»:false,»tostatus»:false,»complete»:»payload»,»targetType»:»msg»,»x»:640,»y»:520,»wires»:[]},{«id»:»3173299f.902716″,»type»:»ubidots_in»,»z»:»99b17f5d.db16″,»tier»:»business»,»name»:»Ubidots in»,»token»:»YOUR-UBIDOTS-TOKEN»,»device_label»:»machine_1″,»tls_checkbox_in»:true,»custom_topic_checkbox»:false,»label_variable_1″:»temperature»,»label_variable_2″:»humidity»,»label_variable_3″:»pressure»,»label_variable_4″:»»,»label_variable_5″:»»,»label_variable_6″:»»,»label_variable_7″:»»,»label_variable_8″:»»,»label_variable_9″:»»,»label_variable_10″:»»,»checkbox_variable_1_last_value»:true,»checkbox_variable_2_last_value»:false,»checkbox_variable_3_last_value»:false,»checkbox_variable_4_last_value»:true,»checkbox_variable_5_last_value»:true,»checkbox_variable_6_last_value»:true,»checkbox_variable_7_last_value»:true,»checkbox_variable_8_last_value»:true,»checkbox_variable_9_last_value»:true,»checkbox_variable_10_last_value»:true,»x»:260,»y»:480,»wires»:[[«a7bea0eb.9b358»]]}]
Ejemplo de suscripción a ‘topic’: la siguiente estructura de nodo suscribe a los ‘topic’ “+/status/lv” y “machine_2/#”. Por lo tanto, retornará cada actualización en variables con la etiqueta ‘status’ independiente del dispositivo y cada actualización de variable del dispositivo “Machine 2”:
El ejemplo usa un nodo tipo ‘function’ para separar las salidas de ambos ‘topics’, resultando en salidas individuales para que las puedas manejar por separado. La siguiente imagen muestra la respuesta del objeto JSON:
Esta es la versión portapapeles para que la puedas importar fácilmente a tu proyecto:
[{«id»:»77f94f4b.91c54″,»type»:»ubidots_in»,»z»:»99b17f5d.db16″,»tier»:»business»,»name»:»Ubidots in»,»token»:»YOUR-UBIDOTS-TOKEN»,»device_label»:»machine_1″,»tls_checkbox_in»:true,»custom_topic_checkbox»:true,»label_variable_1″:»+/status/lv»,»label_variable_2″:»machine_2/#»,»label_variable_3″:»»,»label_variable_4″:»»,»label_variable_5″:»»,»label_variable_6″:»»,»label_variable_7″:»»,»label_variable_8″:»»,»label_variable_9″:»»,»label_variable_10″:»»,»checkbox_variable_1_last_value»:true,»checkbox_variable_2_last_value»:false,»checkbox_variable_3_last_value»:true,»checkbox_variable_4_last_value»:true,»checkbox_variable_5_last_value»:true,»checkbox_variable_6_last_value»:true,»checkbox_variable_7_last_value»:true,»checkbox_variable_8_last_value»:true,»checkbox_variable_9_last_value»:true,»checkbox_variable_10_last_value»:true,»x»:260,»y»:700,»wires»:[[«cc9719d3.ba4a78»]]},{«id»:»cc9719d3.ba4a78″,»type»:»function»,»z»:»99b17f5d.db16″,»name»:»function»,»func»:»var payload = msg.payload;\nvar key = Object.keys(payload)[0]\nvar output;\n\nswitch(key.includes(\»status\»)){\n case true:\n output = [msg, null];\n break;\n \n case false:\n output = [null, msg];\n break;\n}\nreturn output;»,»outputs»:2,»noerr»:0,»x»:460,»y»:700,»wires»:[[«fe1b808a.ecfba»],[«92898340.777d4»]]},{«id»:»fe1b808a.ecfba»,»type»:»debug»,»z»:»99b17f5d.db16″,»name»:»status»,»active»:true,»tosidebar»:true,»console»:false,»tostatus»:false,»complete»:»payload»,»targetType»:»msg»,»x»:630,»y»:681,»wires»:[]},{«id»:»92898340.777d4″,»type»:»debug»,»z»:»99b17f5d.db16″,»name»:»Machine 2 Variables»,»active»:true,»tosidebar»:true,»console»:false,»tostatus»:false,»complete»:»payload»,»targetType»:»msg»,»x»:680,»y»:721,»wires»:[]}]
3. Usar los nodos HTTP y MQTT nativos de Node-RED
¿Por qué usar librerías nativas en lugar de la librería de Ubidots?
Gracias a nuestra experiencia e interacción con miles de desarrolladores, los servicios de Node-RED y Ubidots se complementan bien cuando:
- Entender los conceptos que hay tras los protocolos IoT: trabajar con librerías HTTP y MQTT nativas te ayudará a entender los conceptos que hay tras estos protocolos, enriqueciendo así tu pericia IoT. Usar una librería que cubra estos protocolos puede ahorrarte líneas de Código, pero ocultará conceptos importantes que pueden ser útiles para solucionar problemas y escalar tu proyecto.
- Conectarse desde cualquier dispositivo/servidor Node-RED: algunos ambientes Node-RED dificultan la instalación de librerías de terceros. Por ejemplo, si estás ejecutando Node-RED desde un servidor del cual no eres el administrador y no puedes instalar librerías. Usar librerías nativas puede ahorrarte tiempo, dolores de cabeza y costos de desarrollo.
En los siguientes ejemplos usaremos un nodo tipo “inject” para simular datos, pero, claro está, en aplicaciones verdaderas solo tienes que reemplazar este nodo con su fuente de datos real.
Node-RED + Ubidots usando HTTP
Esta es una estructura de nodos simple que envía un valor aleatorio de corriente, de entre 0 y 5, y un valor de voltaje fijo a un dispositivo de Ubidots llamado «node-red»:
La magia ocurre en el nodo tipo ‘function’, llamado “Setup Request”, el cual prepara la solicitud de acuerdo con los parámetros HTTP permitidos por la API de Ubidots:
Esta es la versión portapapeles para que puedas importarla a tu proyecto. Solo cópiala y pégala, de ser necesario.
[{«id»:»c53b887d.a27888″,»type»:»inject»,»z»:»98e9cf79.a372f8″,»name»:»»,»topic»:»»,»payload»:»»,»payloadType»:»none»,»repeat»:»5″,»crontab»:»»,»once»:true,»x»:110,»y»:100,»wires»:[[«90633f9e.bc1a58»]]},{«id»:»90633f9e.bc1a58″,»type»:»function»,»z»:»98e9cf79.a372f8″,»name»:»Setup Request»,»func»:»var msg;\ndevice_label = \»Node-RED\»;\nubidots_token = \»BBFF-xxxxxxxxxxxxxx\»;\nmsg.method = \»POST\»;\nmsg.url = \»http://industrial.api.ubidots.com/api/v1.6/devices/\» + device_label + \»/?token=\» + ubidots_token;\nmsg.payload = {\»current\»:5*Math.round(Math.random() * 100) / 100,\»voltage\»:\»110\»};\nreturn msg;»,»outputs»:1,»noerr»:0,»x»:275,»y»:100,»wires»:[[«4b95b329.d784c4»]]},{«id»:»8cf48dc0.84df7″,»type»:»debug»,»z»:»98e9cf79.a372f8″,»name»:»»,»active»:true,»console»:»false»,»complete»:»payload»,»x»:629,»y»:100,»wires»:[]},{«id»:»4b95b329.d784c4″,»type»:»http request»,»z»:»98e9cf79.a372f8″,»name»:»»,»method»:»use»,»ret»:»txt»,»url»:»»,»x»:453,»y»:100,»wires»:[[«8cf48dc0.84df7»]]}]
Node-RED + Ubidots usando MQTT
Este es un ejemplo que publica datos de temperatura en el bróker MQTT de Ubidots y suscribe a la variable actualizada:
Este ejemplo usa un nodo tipo ‘inject’ para publicar el dato {«temperature»:123} en un nodo MQTT ‘publish’ configurado según se especifica en la documentación MQTT de Ubidots, es decir:
Bróker de Ubidots:
industrial.api.ubidots.com
Port: 1883
Username: tu token de Ubidots
Password: déjalo en blanco
‘Topic’ de publicación:
/v1.6/devices/{LABEL_DEVICE}
‘Topic’ de suscripción:
/v1.6/devices/{LABEL_DEVICE}/{VARIABLE_LABEL}/lv
- Ten en cuenta que «lv» es la sigla de ‘last value’ (último valor). Esto significa que el ‘topic’ solo devuelve el último valor numérico de la variable, en vez de un objeto JSON, facilitando así su adecuación, en caso de ser necesario.
Ingresar todo esto en Node-RED se vería así:
En el nodo ‘publish’ MQTT:
Al hacer clic en el botón ‘edit’ del bróker:
En el nodo ‘subscribe’ MQTT:
Finalmente, esta es la versión portapapeles para que puedas importar fácilmente esta muestra a tu proyecto:
[{«id»:»8765d540.6b6bc8″,»type»:»inject»,»z»:»eb630143.270018″,»name»:»»,»topic»:»»,»payload»:»{\»temperature\»:123}»,»payloadType»:»str»,»repeat»:»»,»crontab»:»»,»once»:false,»onceDelay»:»»,»x»:190,»y»:200,»wires»:[[«f3c857d3.8d10c»]]},{«id»:»f3c857d3.8d10c»,»type»:»mqtt out»,»z»:»eb630143.270018″,»name»:»»,»topic»:»/v1.6/devices/node-red»,»qos»:»»,»retain»:»»,»broker»:»694beaca.29a254″,»x»:577,»y»:201,»wires»:[]},{«id»:»cc230b36.52f4e8″,»type»:»mqtt in»,»z»:»eb630143.270018″,»name»:»»,»topic»:»/v1.6/devices/node-red/temperature/lv»,»qos»:»2″,»datatype»:»auto»,»broker»:»694beaca.29a254″,»x»:220,»y»:331,»wires»:[[«3e83a146.589e16»]]},{«id»:»3e83a146.589e16″,»type»:»debug»,»z»:»eb630143.270018″,»name»:»»,»active»:true,»tosidebar»:true,»console»:false,»tostatus»:false,»complete»:»payload»,»targetType»:»msg»,»x»:594,»y»:330,»wires»:[]},{«id»:»694beaca.29a254″,»type»:»mqtt-broker»,»z»:»»,»name»:»»,»broker»:»industrial.api.ubidots.com»,»port»:»1883″,»clientid»:»»,»usetls»:false,»compatmode»:true,»keepalive»:»60″,»cleansession»:true,»birthTopic»:»»,»birthQos»:»0″,»birthPayload»:»»,»closeTopic»:»»,»closeQos»:»0″,»closePayload»:»»,»willTopic»:»»,»willQos»:»0″,»willPayload»:»»}]
NOTA: deberás configurar el bróker MQTT incluso después de pegar la versión portapapeles de arriba.
De esta forma puedes vincular dos herramientas, Node-RED y Ubidots, que tienen como objetivo la aceleración del desarrollo de tus proyectos IoT gracias a la simplificación de los procesos y el ahorro tanto de tiempo como de dinero.
Obtén un mes de prueba gratis en Ubidots y despliega tu solución IoT
Controlling devices with Node-Red and Ubidots
