Node-RED es una herramienta de programación visual que permite integrar numerosísimas fuentes de información, hardware y software, y manipular los datos obtenidos para hacer con ellos casi cualquier cosa. Sé que esta definición puede sonar un tanto imprecisa, pero Node-RED es de esas herramientas cuyo límite es la imaginación de sus usuarios.

Cuenta además con las ventajas de que es una proyecto open source y está basado en tecnologías web, lo que permite instalarlo en múltiples plataformas y con cualquier sistema operativo. Esto permite por ejemplo convertir una Raspberry Pi en un servidor Node-RED a la que conectar todos nuestros dispositivos IoT.

No obstante, y como buen fan de Windows que soy, haré este primer experimento en mi ordenador principal, con Windows 10.

Node-RED para Windows

El primer paso para instalar Node-RED en un ordenador Windows es descargar e instalar Node.js. Lo podemos encontrar en su página web oficial:

https://nodejs.org/en/

Y después abrir un CMD (cuando vayáis a hacer instalaciones os recomiendo que lo abráis con «Ejecutar como administrador») y escribir el siguiente comando:

npm install -g –unsafe-perm node-red

Ahora podemos iniciar Node-RED escribiendo en CMD el comando:

node-red

Y podemos acceder a Node-RED desde un navegador de internet. Bastará con acceder al puerto 1880 de la máquina donde hemos instalado Node-RED. Si lo hacemos desde la máquina local escribiremos, por tanto, http://localhost:1880/.

Prueba de funcionamiento

Vamos a hacer la prueba más sencilla posible para entender cómo funcionan los flujos de información en Node-RED.

Usaremos para ello los dos primeros bloques que aparecen en el menú por defecto: inject y debug.

Para configurar las propiedades de cada bloque tenemos que hacer doble clic en el mismo y aparece un menú contextual bastante intuitivo. Así por ejemplo, vemos que inject permite insertar un dato de los tipos habituales (string, number, boolean…). Para el ejemplo seleccionaremos un string con el valor «Hola mundo».

De manera análoga debemos configurar el bloque debug para elegir qué propiedad del bloque inject queremos recibir y dónde queremos mostrarla. En este caso, lo haremos por la ventana de depuración (debug window).

Cuando ya tenemos los bloques configurados, pulsamos sobre el botón Deploy en la esquina superior derecha y ya tendremos funcionando el flujo de información,

Ahora, para verificarlo pulsamos sobre el cuadrado del bloque inject e «inyectaremos» el string «Hola mundo» y lo visualizaremos en la debug window.

Ya hemos creado nuestro primer flow (flujo) en Node-RED.

MQTT

Ahora bien, lo divertido de Node-RED es la conexión con el mundo real. ¿Y cómo conseguimos eso?

Pues bien, una de las formas más sencillas y populares es mediante el uso del protocolo MQTT y un broker MQTT, esto es, un servicio que se encarga de recibir y distribuir los mensajes entre todos los dispositivos que a él se conectan a demanda de estos.

Podéis encontrar información más detallada en otras fuentes, pero aquí nos quedaremos con lo esencial para hacer funcionar nuestros montajes, y esto es que en nuestro ecosistema IoT habrá publicadores (envían mensajes al broker) y suscriptores (reciben mensajes desde el broker). Bastará con configurar correctamente estas funciones de publicación y suscripción para que unos y otros «se hablen» entre sí.

¿Cuál es el primer paso entonces? Pues hacernos con un broker MQTT. No nos quebraremos mucho la cabeza y recurriremos al híperfamoso Mosquitto. Igual que Node-RED, Mosquitto es un proyecto open source y podemos hacernos con él desde su sitio web:

https://mosquitto.org/download/

Para completar la instalación, escribimos el comando

mosquitto install

y ya tendremos Mosquitto funcionando como un servicio de Windows.

Para verificar su correcto funcionamiento podemos replicar la prueba realizada por Luis Llamas en su blog (https://www.luisllamas.es/como-instalar-mosquitto-el-broker-mqtt/).

En la carpeta en la que hemos instalado Mosquitto encontramos dos ejecutables llamados mosquitto_pub y mosquitto_sub.

Si abrimos dos ventanas de comandos diferentes (en modo Administrador, como recomiendo siempre) y vamos a la ruta de Mosquitto (podríamos tocar el PATH en variables de entorno para poder ejecutarlo desde cualquier punto, pero es una prueba puntual y no lo considero necesario), escribiremos en una:

mosquitto_sub -d -h localhost -p 1883 -t "mimqtt/test"

y en la otra:

mosquitto_pub -d -h localhost -p 1883 -t "mimqtt/test" -m "Hola Mundo"

Creando un flujo MQTT en Node-RED

Ahora crearemos un flujo en Node-RED que recibe información vía MQTT.

Iniciamos Node-RED con el mismo comando que usamos anteriormente y disponemos sobre el diagrama de flujo el bloque mqtt in.

En el panel de propiedades definimos el servidor en el que está localizado el broker MQTT y el nombre del topic al que nos vamos a suscribir. Si, por ejemplo, usamos el mismo topic que antes, mimqtt/test, será este el que haya que configurar.

Y con el mismo comando mosquitto_pub:

El mundo real: Conectando con un NodeMCU

¿Recordáis la placa de desarrollo NodeMCU de la que os hablé en este post? Pues llega e momento de utilizarlo.

En esta prueba hay dos tareas clave: por un lado, NodeMCU se tiene que conectar a nuestra red WiFi local para poder comunicarse con el servidor Node-RED y con el broker MQTT, y, al mismo tiempo, debe ser capaz de publicar mensajes en un topic MQTT que sea leído por el broker MQTT.

Para realizar este tipo de tareas «especiales» es habitual que tengamos que hacer uso de librerías adicionales a las posibilidades básicas de la placa de desarrollo que usemos. En este caso, tenemos que emplear las librerías ESP8266WiFi y PubSubClient para conseguir respectivamente los objetivos citados.

Para instalarlas, debéis acudir a Programa > Incluir librería en el IDE de arduino.cc. Encontraréis ESP8266WiFi buscando en el menú de Gestionar librerías. Por su parte, para instalar PubSubClient tendréis que conseguir el ZIP de, por ejemplo;

https://github.com/Imroy/pubsubclient

y añadirla manualmente con Añadir librería .ZIP…

Y en este punto os remito a este estupendo artículo de programarfacil.com

https://programarfacil.com/blog/raspberry-pi/introduccion-node-red-raspberry-pi/

Y al código que nos propone en su ejemplo bajo el apartado «Código sistema de alarma con Arduino». Recordad parametrizar correctamente las variables ssid, pass y servidorMQTT a las de vuestra red y usar la librería WiFi correspondiente a vuestro microcontrolador (ya hablé de ello en https://jjosemayorga.com/como-programar-nodemcu/).

// Decomentar para mostrar debug monitor serie
#define DEBUG_ALARMA

//Librerías
#include <ESP8266WiFi.h>
#include <PubSubClient.h>

// Pines
const byte intPuerta = 5;

// Variables interrupción de interruptor
volatile boolean isrAlarmaCentinela = false; // Detectar interrupción

// Configuración WiFi
const char* ssid = "el_ssid_de_tu_red";
const char* pass = "el_password_de_tu_red";
int status = WL_IDLE_STATUS;
WiFiClient  clienteWifi;

// Configuración MQTT
PubSubClient clientMqtt(clienteWifi);
const char* servidorMqtt = "la_ip_de_tu_servidor_mqtt";
const char* topicAlarma = "/casa/puerta/alarma";

void setup() {

#ifdef DEBUG_ALARMA
  Serial.begin(115200);
  delay(500);
  Serial.println("[INI]Comienzo del programa sistema alarma con Arduino MKR1000");

  // Señal arrancando
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
  digitalWrite(LED_BUILTIN, HIGH);
#endif

  // Conexión con la red WiFi
  int intentosWiFi = 0;
  while (status != WL_CONNECTED || intentosWiFi > 5) {
#ifdef DEBUG_ALARMA
    Serial.print("[WIFI]Intentando conectar a: ");
    Serial.println(ssid);
#endif

    // Conectando a la red WiFi WPA/WPA2
    WiFi.mode(WIFI_STA);//added here
    status = WiFi.begin(ssid, pass);

    // Esperamos 10 segundos para conectarnos
    delay(10000);

    intentosWiFi++;
  }

  // Si no ha conetado mostramos error
  if (status != WL_CONNECTED)
  {
    while (1) {
      digitalWrite(LED_BUILTIN, HIGH);
      delay(500);
      digitalWrite(LED_BUILTIN, LOW);
      delay(500);
    }
  }

#ifdef DEBUG_ALARMA
  Serial.println("[WIFI]Conectado a la WiFi");
#endif

  // Configuración MQTT
  clientMqtt.setServer(servidorMqtt, 1883);
#ifdef DEBUG_ALARMA
  Serial.println("[MQTT]Conectado al servidor MQTT");
#endif

  // Configuración de interrupciones
  pinMode(intPuerta, INPUT_PULLUP); // Interrupción interruptor magnético
  attachInterrupt(intPuerta, isrAlarma, FALLING); //Interrupción interruptor magnético

  // Apagado de LED
  digitalWrite(LED_BUILTIN, LOW);
}

void loop()
{
  // Comprobamos conexión con broker MQTT
  if (!clientMqtt.connected()) {
    reconnectMqtt();
  }
  clientMqtt.loop();

  // Si detecta interrupción alarma
  if (isrAlarmaCentinela) {

    // Marcamos para que no vuelva a pasar
    isrAlarmaCentinela = false;

    // Enviamos mensaje
    clientMqtt.publish(topicAlarma, "1");

#ifdef DEBUG_ALARMA
    Serial.println("[MQTT]Publicando mensaje alarma: Puerta abierta");
    digitalWrite(LED_BUILTIN, HIGH);
    delay(500);
    digitalWrite(LED_BUILTIN, LOW);
#endif
  }
}

void isrAlarma() {
  // Marca ha ejecutado interrupción
  isrAlarmaCentinela = true;
}

void reconnectMqtt() {
  // Repetimos hasta conectar
  while (!clientMqtt.connected()) {
#ifdef DEBUG_ALARMA
    Serial.println("[MQTT]Esperando conexión con MQTT...");
#endif
    // Intentamos conectar
    WiFi.mode(WIFI_STA);//added here
    if (clientMqtt.connect("ALARMA-PUERTA-MKR1000")) {
#ifdef DEBUG_ALARMA
      Serial.println("[MQTT]Conectado");
#endif
    } else {
#ifdef DEBUG_ALARMA
      Serial.print("[MQTT]Fallo, rc=");
      Serial.print(clientMqtt.state());
      Serial.println(" se intentará otra vez tras 5 segundos");
#endif
      // Esperamos 5 segundos
      delay(5000);
    }
  }
}

Únicamente me gustaría añadir un par de tips que a mí me habrían ahorrado mucho tiempo…

1) Hay que permitir las conexiones anónimas al broker Mosquitto. Para ello hay que acudir al directorio donde hemos instalado Mosquitto (típicamente C:\Program Files\Mosquitto), abrir el archivo mosquitto.conf con el bloc de notas o algún editor de código como Notepad++ y añadir las líneas

allow_anonymous true
listener 1883 0.0.0.0

y convertir en comentario (poniendo un# delante) la línea

#allow_anonymous false

2) Si vas a utilizar NodeMCU o cualquier placa de desarrollo basada en ESP8266 es necesario añadir la línea

WiFi.mode(WIFI_STA);

antes de realizar la conexión. Sólo en ESP8266. Si usas Arduino MKR1000 no hace falta. De hecho, la librería WiFi101.h ni siquiera tiene ese atributo. De no hacerlo así, aparecerá el mensaje rc=-2 al hacer la conexión.

La prueba de fuego

Ya tenemos un servidor Node-RED corriendo en el puerto 1880 de nuestro PC, un broker MQTT en el puerto 1883 y el código cargado en NodeMCU. Es el momento de verificar si funciona correctamente…

¡Primera prueba con Node-RED completada con éxito!

No es difícil imaginarse que si en lugar de usar esos dos cables que he utilizado en la prueba conectamos los extremos del detector magnético que os mostré en ¿Cómo funciona un detector magnético? tendremos una aplicación capaz de avisar de cuándo se abre una puerta.

Lista de materiales

Recuerda que puedes hacerte con algunos NodeMCU aquí.