Introducción a Node-RED y Raspberry Pi con un sistema de alarma con Arduino Deja un comentario
Node-RED es una herramienta creada por el grupo de Servicios de Tecnologías Emergentes de IBM. Al contrario de lo que pueda parecer, se trata de un software bastante sencillo de utilizar sobre todo con Raspberry Pi.
En este artículo te voy a mostrar cómo puedes dar los primeros pasos con Node-RED a través de un tutorial. Al finalizar tendrás un sistema de alarma con Arduino o ESP8266 que envía notificaciones PUSH a tu móvil a través de Pushover.
Es importante entender la función que desempeña Node-RED dentro de aplicaciones y sistemas que utilizan el IoT. Sólo así sabremos la potencia que tiene esta herramienta.
Va a ser un tutorial bastante largo donde veremos un poco de historia sobre Node-RED, cómo encaja dentro de los objetos conectados y por último, un tutorial completo para comunicar vía MQTT con Arduino y ESP8266.
Ponte cómodo, prepara una buena taza de café y comencemos con el tutorial de introducción a Node-RED con Raspberry Pi y el sistema de alarma con Arduino y ESP8266.
Antes de empezar con Node-RED
Este tutorial va a ser bastante práctico. La idea es instalar Node-RED en una Raspberry Pi para hacer un proyecto del IoT. Por lo tanto, antes de empezar tienes que tener instalado el último sistema operativo Raspbian en tu Raspberry Pi.
Puedes seguir el tutorial de la fundación Raspberry Pi donde te lo explican paso a paso.
Una vez lo tengas instalado, también vas a necesitar instalar el broker MQTT Mosquitto. Esto nos permitirá comunicarnos con Node-RED de una forma muy sencilla.
Además de la Raspberry Pi vas a necesitar el siguiente hardware
- Arduino MKR1000, NodeMCU o cualquier otra placa compatible
- Un interruptor magnético
El objetivo es crear un sistema de alarma con Arduino y ESP8266 que nos avise en el móvil cuando se abre una puerta o ventana.
Todo irá integrado con Node-RED y la comunicación se hará con el protocolo MQTT.
¿Qué es Node-RED?
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.
¿Y qué conseguimos con Node-RED? ponernos en acción lo antes posible. Podemos hacer un proyecto complejo como enviar una notificación push a un móvil en apenas 5 minutos. ¿No te lo crees? Pues prepárate porque en breve lo vas a ver en acción.
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, principios básicos
Node-RED está creado a partir de NodeJS y la librería de JavaScript D3.js.
NodeJS proporciona la potencia suficiente para que Node-RED sea fiable y escalable. NodeJS es un software muy potente que permite la programación en JavaScript del lado del servidor.
Sus ventaja más importante es que está optimizado para poder tratar múltiples conexiones concurrentes de una manera óptima. Es el mayor ecosistema de código abierto que existe en el mundo y está siendo utilizado por empresas punteras como PayPal y Netflix.
Por otro lado, D3.js es el encargado de la interfaz web. Node-RED es accesible a través de un navegador es decir, sólo necesitamos acceder a una página web para poder crear nuestros propios sistemas. No hace falta instalar ningún entorno de desarrollo o IDE.
En esta aplicación web podremos arrastrar y conectar nodos con diferentes funcionalidades para crear flujos de datos que hagan una determinada cosa.
Por ejemplo, podemos suscribirnos a un topic de MQTT, recibir un dato de temperatura, almacenarlo en una base de datos y mostrarlo en un panel de control a través de una página web.
Vuelvo a repetir que todo esto sin tener que programar una línea de código. Esto no quiere decir que no debamos conocer la programación, al contrario.
Se requiere unos altos conocimientos de lógica computacional para desarrollar proyectos con Node-RED.
Pero no sólo podemos hacer esto, también podemos conectar con servicios de terceros como IFTTT, ThingSpeak, Google Home, ThingerIO, etc…
Si realmente quieres ver las capacidades de Node-RED, no te pierdas el repositorio de nodos y flujos que tienes a tu disposición para descargar y utilizar 🙂
¿Por qué elegir Node-RED para proyectos del IoT y domótica?
Node-RED es de código abierto y está mantenido por IBM.
Se puede instalar en cualquier sistema operativo incluyendo Raspbian para Raspberry Pi.
Evita tener que profundizar en tecnologías complejas difíciles de implementar y programar.
Esto te permite crear prototipos muy rápidamente y centrarte en hacer cosas divertidas en lugar de pasar horas y horas programando en un lenguaje de alto nivel.
Sólo piensa por un momento los procesos que se ven involucrados cuando enviamos un dato o información a una plataforma en la nube. ¿Te ves capacitado para programar un sistema de este tipo tu solo?
¿Quieres montar tu primer proyecto con Arduino?
Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso a paso y en sólo una semana.
Imagino que la respuesta será NO. Pues gracias a Node-RED serás capaz y lo más importante, no perderás mucho tiempo.
A mi me encanta programar, es mi pasión. Sin embargo, no me gusta perder el tiempo una y otra vez en cada proyecto haciendo tareas repetitivas. Prefiero centrarme en otros problemas a resolver y dejar esto de la mano de Node-RED 🙂
Por si fuera poco, en este tutorial te voy a enseñar cómo puedes hacer un sistema domótico muy rápidamente sin tener conocimientos de protocolos, lenguajes o servicios.
Vamos a ponernos en acción ya mismo y comenzamos instalando Node-RED en una Raspberry Pi.
Instalar Node-RED en Raspberry Pi
Instalar Node-RED es tu Raspberry Pi es extremadamente sencillo. Esto es debido a que por defecto, ya viene preinstalado en el sistema operativo Raspbian.
Sólo tenemos que hacer una cosa, abrir un terminal e introducir el siguiente comando.
|
bash <(curl –sL https://raw.githubusercontent.com/node–red/raspbian–deb–package/master/resources/update–nodejs–and–nodered) |
Básicamente lo que hace este comando es actualizar NodeJS y Node-RED. Es importante siempre trabajar con las últimas versiones.
Nada más ejecutar el comando te hará una pregunta ¿Estás seguro de hacer esto? [y/n]
Debes poner y o Y y dar a la tecla Enter. Esto hará que comience la actualización que puede tardar más o menos tiempo dependiendo de tu conexión. Te recomiendo que si tienes la posibilidad, conectes la Raspberry Pi por cable Ethernet.
Ahora sólo tienes que tener paciencia ya que esto puede tardar unos cuantos minutos. Cuando finalice verás algo parecido a esto.
Con esto ya tenemos instalado Node-RED listo para empezar a trabajar. Pero antes, tenemos que arrancarlo. Lo interesante es que lo haga de forma automática cuando arrancamos Raspbian.
Inicio automático de Node-RED con Raspberry Pi
Por defecto Node-RED está apagado. Podemos ejecutarlo de dos formas diferentes: manual o automático.
Para ejecutarlo manual puedes ir al menú de la Raspberry Pi a la ruta Menu>Programming>Node-RED.
O escribir en una terminal el siguiente comando
Las dos opciones tienen el mismo efecto, arrancan Node-RED.
Pero también podemos hacer que lo haga de forma automática escribiendo el siguiente comando en una terminal.
|
sudo systemctl enable nodered.service |
Esto hará que cada vez que se reinicie la Raspberry Pi, arranque Node-RED de forma automática.
Ya sea de una forma o de otra, lo primero que debemos hacer es probar que todo ha ido bien.
Es recomendable que asignes una IP fija a tu Raspberry Pi. Esto lo puedes hacer a nivel de sistema operativo o asignando una IP fija desde el router a través de la MAC de la Raspberry Pi.
Node-RED primera prueba
Como ya te he dicho, para acceder a Node-RED no necesitamos instalar ningún entorno de desarrollo o IDE. Sólo tenemos que acceder a través de una página web.
Lo primero es saber qué IP tiene tu Raspberry Pi. Eso lo puedes ver fácilmente ejecutando el siguiente comando en una terminal.
En mi caso es la 192.168.0.164.
Sabiendo la IP ya podemos acceder a Node-RED. Sólo tienes que poner esto en un navegador. Eso sí, sustituye la IP 192.168.0.164 por la IP donde hayas instalado Node-RED.
|
http://192.168.0.164:1880 |
Aparecerá una página web como esta.
Y ya está, con esto ya podemos empezar a programar con Node-RED.
Entorno de desarrollo de Node-RED
Vamos a echar un vistazo rápido por Node-RED y ver cómo se organiza para poder programar nuestras aplicaciones del IoT con Arduino o ESP8266.
Nada más abrir la aplicación aparecen las siguientes secciones principales.
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.
Podemos ver más información sobre lo que hace un nodo en el panel de información si hacemos click sobre cualquiera de ellos.
Por último, el panel de debug sirve para mostrar mensajes de lo que está ocurriendo dentro de cada flujo o tratamiento de datos. Es como el monitor serie del IDE de Arduino.
Para que entiendas cómo funcionan, vamos a ver un ejemplo muy sencillo.
Primer flujo con 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.
Para saber si están conectados, puedes mover uno de los nodos.
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 🙂
Por último tienes que hacer click en Done.
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.
Ahora ya podemos probar la aplicación.
Probando el primer flujo con 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.
Este ejemplo es muy básico y no hace nada útil. El objetivo es que te familiarices con Node-RED y que veas las capacidades y sencillez de esta herramienta.
Ahora vamos a pasar a hacer algo más serio, un sistema de alarma con Arduino o ESP8266 y Node-RED que te avise de si han abierto la puerta de tu casa.
Sistema de alarma con Arduino y Node-RED
Un sistema de alarma con Arduino y Node-RED puede ser muy útil para protegerte de robos o simplemente, para saber si han abierto la puerta o una ventana de casa.
El esquema básico de la aplicación sería el siguiente.
El sistema es bastante sencillo. Tenemos que conectar un interruptor magnético que lo podemos comprar por menos de 2€.
En el hardware puedes utilizar tanto un ESP8266, ya sea NodeMCU o Wemos, o un Arduino MKR1000. La programación es prácticamente la misma salvo las funciones específicas de la red WiFi de cada placa.
Aunque creo que lo tienes claro, no está demás recordar que es necesario que la placa se pueda conectar a Internet o a la red local ya sea por WiFi o Ethernet.
Raspberry Pi se encargará de gestionar los mensajes MQTT a través del broker Mosquitto y de poner en contacto el hardware (Arduino o ESP8266) con el servicio Pushover a través de Node-RED.
Antes de continuar tengo que decir que para este caso, no sería necesario utilizar una Raspberry Pi con Node-RED y MQTT Mosquitto. Directamente la aplicación Pushover tiene una API a la que podemos acceder desde Arduino o ESP8266.
Sin embargo, si en futuro queremos añadir alguna otra funcionalidad, por ejemplo que detecte que eres tu el que entra en casa, no podremos hacerlo de forma sencilla si no utilizamos Node-RED.
Este tutorial te muestra cómo crear un prototipo rápido y económico. El resto de funcionalidades y mejoras dependen de ti 🙂
Interruptor magnético con Arduino
Un interruptor magnético tiene dos partes. Una parte es un interruptor que está abierto en estado de reposo. A esto se le conoce como normalmente abierto.
También hay otro tipo de interruptores que en estado de reposo están cerrados. Se conocen como normalmente cerrado.
La otra parte es un imán. Al acercar el imán al interruptor, el campo magnético hace que se cierre y por lo tanto, permite circular la corriente.
Es un sistema muy sencillo y parecido a cómo funciona un pulsador con Arduino.
Del interruptor saldrán dos cables. La idea es hacer circular una corriente por esos cables y detectar cuando está abierto o cerrado el circuito. El esquema eléctrico para conectarlo con Arduino o ESP8266 sería el siguiente.
He utilizado el pin 8 con Arduino MKR1000 y el pin D4 en NodeMCU. En los dos casos, controlaré si se ha cerrado el circuito a través de una interrupción.
Como ves es muy sencillo. Sólo nos faltaría poner una resistencia pull-up pero eso lo implementaremos a través del software como verás en la siguiente sección.
Sistema de alarma con Arduino y ESP8266
No voy a entrar muy en detalle de cómo tenemos que programar Arduino o el ESP8266. Sólo te voy a explicar, en términos generales, cómo programar un sistema de alarma con Arduino o ESP8266.
El esquema general del código con Arduino y ESP8266 sería el siguiente.
La lógica es muy sencilla aparte de las características que debe tener con respecto al protocolo MQTT del cual, ya he hablado extensamente en un podcast y en un artículo.
Básicamente, el programa detecta si se ha producido una interrupción al separar las dos partes del interruptor magnético. De ser así, el código lo detecta y publica un mensaje MQTT en el topic /casa/puerta/alarma.
A continuación te dejo el código para Arduino y ESP8266 para que lo pruebes e investigues por ti mismo.
Código sistema de alarma con Arduino
Este código es sólo válido para Arduino MKR1000. No te olvides de cambiar el SSID de tu red WiFi en la línea 15, la contraseña en la línea 16 y poner la IP del broker MQTT en la línea 22.
El resto es igual para todos, esa es una de las ventajas de la plataforma Arduino 😉
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 |
// Decomentar para mostrar debug monitor serie #define DEBUG_ALARMA //Librerías #include #include // Pines const byte intPuerta = 8; // Variables interrupción de interruptor volatile boolean isrAlarmaCentinela = false; // Detectar interrupción // Configuración WiFi char ssid[] = “SSID-WIFI”; // SSID de la WiFi char pass[] = “PASS-WIFI”; // Constraseña de la WiFi int status = WL_IDLE_STATUS; WiFiClient clienteWifi; // Configuración MQTT PubSubClient clientMqtt(clienteWifi); const char* servidorMqtt = “IP-BROKER-MQTT”; const char* topicAlarma = “/casa/puerta/alarma”; void setup() { #ifdef DEBUG_ALARMA Serial.begin(9600); 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 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 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á o travez tras 5 segundos”); #endif // Esperamos 5 segundos delay(5000); } } } |
Código sistema de alarma con ESP8266
El código que te muestro a continuación es válido para cualquier placa que lleve un microcontrolador ESP8266.
Es muy parecido al código de Arduino MKR1000, Lo único que cambia es el nombre de variables y objetos de la conexión WiFi con el ESP8266. También hay algún cambio en la lógica para conectar con la red WiFi.
No te olvides de cambiar el SSID y la contraseña de la red WiFi y la IP del broker MQTT.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 |
// Decomentar para mostrar debug monitor serie #define DEBUG_ALARMA //Librerías #include #include // Pines const byte intPuerta = 2; // Variables interrupción de interruptor volatile boolean isrAlarmaCentinela = false; // Detectar interrupción // Configuración WiFi char* ssid = “SSID-WIFI”; // SSID de la WiFi char* pass = “PASS-WIFI”; // Constraseña de la WiFi WiFiClient clienteWifi; // Configuración MQTT PubSubClient clientMqtt(clienteWifi); const char* servidorMqtt = “IP-BROKER-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 ESP8266”); // 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; WiFi.begin(ssid, pass); #ifdef DEBUG_ALARMA Serial.print(“[WIFI]Intentando conectar a: “); Serial.println(ssid); #endif while (WiFi.status() != WL_CONNECTED || intentosWiFi > 30) { #ifdef DEBUG_ALARMA Serial.print(“.”); #endif // Esperamos delay(500); intentosWiFi++; } #ifdef DEBUG_ALARMA Serial.println(“.”); #endif // Si no ha conetado mostramos error if (WiFi.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 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á o travez tras 5 segundos”); #endif // Esperamos 5 segundos delay(5000); } } } |
Si conectas Arduino MKR1000 o NodeMCU podrás comprobar a través del monitor serie que envía un mensaje. Sólo falta que en el otro extremo alguien lo esté escuchando. Esto lo haremos con Node-RED.
Pero antes, vamos a configurar la plataforma Pushover para que nos envíe notificaciones PUSH al móvil ya sea Android o iOS.
En los dos códigos he definido una constante arriba del código que se llama DEBUG_ALARMA. Si la comentas no mostrará mensajes por el monitor serie.
Aplicación Pushover con Arduino y Node-RED
Pushover es una plataforma que nos permite enviar notificaciones PUSH a un teléfono con iOS o Android. Dispone de una versión de evaluación durante 7 días.
Si quieres acceder a la versión de pago, tendrás que comprar la APP por unos 5€ ya sea para Android o para iOS a través de la tienda de aplicaciones para cada sistema operativo.
Te recomiendo que la pruebes durante 7 días y luego si te interesa, la compres. Yo la compré y la verdad es que estoy encantado.
Para configurar Pushover sigue los siguientes pasos:
#1 Alta en la plataforma Pushover
Entra en la web de Pushover y crea una cuenta haciendo click en Login o Signup. Rellena los campos de email y password.
Una vez validas tu cuenta vía email, ya puedes empezar a utilizar Pushover. Cuando haces esto, se abre el panel de control.
Aquí podemos hacer muchas cosas pero lo que nos interesa para nuestro sistema de alarma con Arduino o ESP8266 y Node-RED es añadir un dispositivo que puede ser un móvil, tablet u ordenador y añadir una aplicación para enviar notificaciones.
Vamos a empezar configurando la APP del dispositivo móvil.
#2 Instalar APP Pushover en el móvil
Ahora toca instalar la APP Pushover en tu móvil. Hay versiones para iOS y Android.
Lo primero es autentificarte en la plataforma. Ojo, puedes crear una cuenta o ingresar en la plataforma. Selecciona ingresar.
Rellena con el email y la contraseña que has utilizado para darte de alta en la plataforma Pushover.
Por último, tienes que dar un nombre al dispositivo para identificarlo en el panel de control. Yo, como soy muy original, lo he llamado Luis 🙂
No te olvides de hacer click en el botón Add Device.
#3 Probando las notificaciones con Pushover
Antes de continuar, vamos a probar las notificaciones. Si entras en el panel de control de la plataforma Pushover, podrás comprobar que se ha añadido un nuevo dispositivo.
Además, se ha habilitado un formulario para enviar un mensaje. Puedes enviar un mensaje a un dispositivo concreto o a todos los dispositivos. Elige un sonido para la notificación, pon un título y un texto.
Cuando lo tengas haz click en el botón Send Notification. Si tienes cerca el móvil verás como te ha llegado una notificación que ha reproducido un sonido.
Además, puedes entrar dentro de la APP Pushover y ver el mensaje completo.
Perfecto, todo funciona correctamente. Vamos a continuar.
#4 Añadir una aplicación a Pushover
Lo que hemos hecho antes es añadir un dispositivo, pero ahora vamos a añadir una aplicación. Una aplicación es un dispositivo que enviará notificaciones PUSH a nuestro móvil. ¿Te imaginas quién va a ser nuestra aplicación?
Efectivamente, Node-RED. La idea es que cada vez que lea un mensaje MQTT enviado desde Arduino o ESP8266 indicando que se activado el interruptor magnético, nos envíe una notificación al móvil para avisarnos.
Esta es la base del sistema de alarma con Arduino y ESP8266.
En el panel de control de Pushover ves a la sección Your Applications. Aquí puedes añadir todas las aplicaciones que quieras. Pulsa en el enlace Create an Application/API Token.
El nombre puedes poner el que quieras por ejemplo, Alarma Casa. Pon una descripción e incluso puedes poner una foto. La foto de una sirena puede ser interesante 🙂
Por último tienes que hacer check en la caja para decir que estás de acuerdo con los términos del servicio y hacer click en el botón Create Application.
Una vez que creas la aplicación, se abre una nueva pantalla donde te muestra el API Token/Key. Este identificador nos hará falta en Node-RED. Lo puedes guardar o puedes consultarlo más tarde haciendo click en el dispositivo que has creado.
Eso sí, no lo compartas con nadie 🙂
También nos muestra información útil como estadísticas de mensajes. El límite de notificaciones es de 7.500 cada mes. Yo creo que es más que suficiente.
Ahora ya tenemos todo preparado para empezar a conectar Arduino o ESP8266 a Node-RED. Eso lo veremos a continuación.
Integrar Arduino, ESP8266 y Node-RED
Ya estamos llegando casi al final del tutorial de introducción a Node-RED con un sistema de alarma con Arduino o ESP8266. Seguramente estés pensando que ahora toca lo más complicado, programar la parte del backend en el servidor.
Y no te digo que no, eso sería lo normal. Pero los Makers siempre tenemos un as bajo la manga y en este caso se llama Node-RED. Vas a alucinar lo sencillo que resulta hacer esto con esta herramienta.
Vamos a ir por partes. Lo primero es configurar un nodo de entrada para suscribirnos al topic MQTT /casa/puerta/alarma donde se están enviando los mensajes de alarma desde Arduino o ESP8266.
Configurar nodo MQTT en Node-RED
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.
En Node-RED se está recibiendo un mensaje a través del topic /casa/puerta/alarma con el payload o carga útil de 1.
Si miras el código que has cargado a Arduino o ESP8266 verás que es eso es precisamente lo que estamos enviando cuando se detecta que las dos partes del interruptor magnético, se separan.
Perfecto, ya tenemos la alarma casi implementada y con sólo dos nodos, increíble ¿verdad?
Pero claro, así es de poca utilidad. Ahora vamos a añadir la integración con Pushover para que envíe notificaciones al móvil.
Integración de Pushover con Node-RED
Una de las ventajas de Node-RED es que tiene un repositorio con más de 1.400 nodos de código abierto listos para usar. Puedes encontrar prácticamente de todo.
Ahora mismo el que nos interesa es Pushover. Para instalarlo entra en el menú principal en la opción Manage palette.
El nuevo panel que se abre nos permite gestionar los nodos de Node-RED. Entra en la pestaña Install y en campo search modules escribe pushover.
Aparecerán dos resultados de búsqueda. Vamos a elegir el segundo resultado aunque los dos funcionan de la misma forma.
Para instalarlo sólo tienes que hacer click en el botón install. La duración de la instalación dependerá de tu conexión a Internet ya que esta acción lo que hace es bajarse el código de este nodo a tu máquina.
Para cerrar este panel haz click en el botón Close.
Ahora tenemos un nuevo nodo. Si miras en la parte de nodos, verás que se ha creado una nueva categoría, mobile, y dentro hay un nodo que se llama pushover.
Vamos a arrastrar el nodo al flujo y conectarlo con el nodo mqtt.
Otra de las características de Node-RED es que un nodo puede conectarse a varios nodos como vemos en el ejemplo.
Lo último que nos queda es configurar el nodo pushover. Haz doble click sobre él para abrir el panel de configuración.
Lo primero es rellenar el campo Title. Este será el título que aparecerá en la notificación PUSH que envíe Pushover.
En el campo Device tienes que poner el nombre del dispositivo que has dado al configurar la APP en tu móvil. En mi caso la he llamado Luis.
En el campo Sound selecciona un sonido. Será el que se reproduzca en tu móvil cuando recibas la notificación. Puedes elegir entre unos cuantos
Las claves de API son las que tienes en el panel de control de Pushover.
User key es la clave de usuario y la encuentras nada más entrar al panel de control de Pushover.
Y API token la encuentras dentro del dispositivo que hemos creado.
Por último, pon un nombre rellenando el campo Name y haz click en el botón Done.
Y con un único nodo hemos conseguido conectar un Arduino o ESP8266 a nuestro móvil. Realmente increíble.
Sólo nos queda un paso, dar al botón Deploy y ya tenemos todo listo para probar la aplicación.
Probando sistema de alarma con Arduino ESP8266 y Node-RED
Ha llegado el momento, vamos a probar si el sistema es capaz de enviarnos una notificación al móvil. Sólo tienes que conectar la placa y simular que se abre una puerta ¿te ha funcionado? a mi sí 🙂
He recibido el siguiente mensaje 🙂
Perfecto, objetivo conseguido. Adoro las tecnologías abiertas y el Open Source 🙂
Ahora, con este sistema de alarma con Arduino y Node-RED, estaremos a salvo de los cacos 😉
¿Quieres montar tu primer proyecto con Arduino?
Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso a paso y en sólo una semana.
Conclusiones del tutorial de introducción a Node-RED y Raspberry Pi: sistema de alarma con Arduino
En este artículo has podido comprobar lo sencillo que es comunicar Arduino o ESP8266 con diferentes servicios gracias a Node-RED.
Esa es la esencia de esta herramienta. Nos permite ponernos en acción muy rápidamente, sin tener que investigar durante días o semanas una tecnología.
Eso no quita que si queremos profundizar lo hagamos, pero evitando el síndrome de parálisis por análisis.
En esta introducción a Node-RED sólo hemos visto una pequeña parte de sus capacidades. Node-RED es una herramienta muy amplia que nos permite hacer muchísimas cosas.
Ahora depende de ti el seguir avanzando pero eso sí, no olvides compartir con todos nosotros tus avances.
¿Te ha parecido difícil la introducción a Node-RED?
¿Crees que es útil un sistema de alarma con Arduino y ESP8266 con Node-RED?
Pues todos los comentarios aquí abajo 🙂
Gracias a Shutterstock por la cesión de la imagen.
