Archivo de la etiqueta: Raspberry Pi

Presentación Taller Wifi Arduino

Dentro del Arduino Day 2019 La Rioja https://www.aprendiendoarduino.com/talleres-arduino/arduino-day-logrono-2019/ celebrado en Logroño celebrado el 16 de marzo de 2019 se realiza el taller “Wifi Arduino”, donde vemos cómo conectar por wifi nuestros Arduinos o dispositivos compatibles.

El objetivo de este taller el conocer las posibilidades de Arduino con Wifi y conectarlo a Internet para comunicar entre dispositivos o con plataformas locales o en la nube. También es muy útil para domotizar la casa.

Veremos las diferentes opciones de conectar Arduino a Wifi o crear una red Wifi así como el uso de las librerías Wifi. Nos centraremos en el uso de los dispositivos basados en el chip ESP8266 de https://www.espressif.com/.

Además este taller sirve como introducción a otros talleres que se realizarán el 30 de marzo dentro del “Arduino Day Extension 2019 La Rioja”:

  • Taller “Ok Google… enciende la luz! Creando electrónica para el Asistente de Google” – @kikeelectronico
  • Taller “Ok Google… enciende la luz! Creando electrónica para el Asistente de Google” – @kikeelectronico

Material Utilizado

El material para el taller es:

Además como servidor local usaremos:

Acerca de Enrique Crespo

El autor del taller es Enrique Crespo. Llevo trabajando con Arduino desde el año 2011 y en el año 2014 empecé mi andadura como profesor de Arduino y otros temas relacionados. Desde entonces he impartido muchos cursos presenciales de Arduino, talleres y conferencias en diversos lugares.

Todos los cursos, talleres y conferencias que he impartido puedes verlos en https://www.aprendiendoarduino.com/, donde publico toda la documentación y código.

Twitter @jecrespo: https://twitter.com/jecrespom

Linkedin: https://www.linkedin.com/in/enriquecrespo/

Para cualquier consulta durante el curso y en cualquier otro momento mediante email: aprendiendoarduino@gmail.com

Anuncios

Thingspeak

ThingSpeak es un plataforma de Internet of Things (IoT) que permite recoger y almacenar datos de sensores en la nube y desarrollar aplicaciones IoT. Thinkspeak también ofrece aplicaciones que permiten analizar y visualizar tus datos en MATLAB y actuar sobre los datos. Los datos de los sensores pueden ser enviados desde Arduino, Raspberry Pi, BeagleBone Black y otro HW.

Web: https://thingspeak.com/

Thingspeak es parte de Mathworks https://en.wikipedia.org/wiki/MathWorks que es la empresa de entre otros Matlab y Simulink.

Uso comercial: https://thingspeak.com/pages/commercial_learn_more

Precios: https://thingspeak.com/prices

Features Thingspeak:

También puede acceder a los recursos de MATLAB y Simulink con una cuenta gratuita de MathWorks.

Apps de Thingspeak, son los servicios de la plataforma IoT: https://thingspeak.com/apps

Librería Thingspeak para Arduino, ESP8266 y ESP32: https://github.com/mathworks/thingspeak-arduino

La estructura de Thingspeak es:

  • Canales (Channels): los datos que recogemos en los dispositivos se guardan en canales.
  • En cada canal se disponen de una serie de campos para guardar datos, así como otra información adicional
  • Los canales pueden ser públicos o privados.
  • Dentro de cada canal podemos añadir visualizaciones o Widgets
  • Los datos del canal se pueden importar o exportar
  • En la pestaña de API keys está la información con las contraseñas (API Keys) para usar con las APIs.

Tutoriales Thingspeak: https://community.thingspeak.com/tutorials/

Tutoriales Arduino:

Tutoriales ESP8266:

Tutoriales Raspberry Pi.

Documentación: https://www.mathworks.com/help/thingspeak/

Getting started con Thingspeak: https://www.mathworks.com/help/thingspeak/getting-started-with-thingspeak.html

Ejemplos: https://www.mathworks.com/help/thingspeak/examples.html

Restful y MQTT APIs: https://www.mathworks.com/help/thingspeak/channels-and-charts-api.html

Alertas: https://www.mathworks.com/help/thingspeak/monitor-channel-inactivity-using-multiple-thingSpeak-apps.html

Más información:

Cliente MQTT Thingspeak

ThingSpeak ahora es compatible con la publicación MQTT, que le permite enviar datos a ThingSpeak desde cualquier dispositivo o servicio compatible con el estándar MQTT.

Puede seguir enviando hasta 3 millones de mensajes al año de forma gratuita. Para determinar cuántos mensajes utiliza, puede iniciar sesión y ver el uso de su cuenta.

Tutoriales para usar MQTT con Arduino:

Ejemplo con Thingspeak

Instalar con el gestor de librerías la librería thinkspeak o manualmente desde https://github.com/mathworks/thingspeak-arduino

Crear un nuevo canal: temperatura casa

Los canales guardan todos los datos que una aplicación Thingspeak recoge. Cada canal incluye 8 campos que pueden almacenar cualquier tipo de dato, además de tres campos para localización del dispositivo y uno para el estado de los datos. Una vez los datos son recogidos en un canal, es posible usarlos con las apps de Thingspeak para analizarlos y visualizarlos.

API: https://es.mathworks.com/help/thingspeak/channels-and-charts.html

Thingspeak apps: https://thingspeak.com/apps

Tutorial: https://es.mathworks.com/help/thingspeak/getting-started-with-thingspeak.html

Analizar datos: https://es.mathworks.com/help/thingspeak/analyze-your-data.html

Actuar con tus datos: https://es.mathworks.com/help/thingspeak/act-on-your-data.html

Código con IP fija y sin librería: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio65-Thingspeak

Código con IP fija y librerías: https://github.com/jecrespo/aprendiendoarduino-iot/tree/master/01-Thingspeak/Temp-y-Hum

Canal público: https://thingspeak.com/channels/242341

Usar MQTT con Thingspeak: http://blogs.mathworks.com/iot/2017/01/20/use-mqtt-to-send-iot-data-to-thingspeak/

Repositorio: https://github.com/jecrespo/aprendiendoarduino-iot/tree/master/01-Thingspeak

Analizar

Ejemplos: https://es.mathworks.com/help/thingspeak/examples.html

Tutorial: https://es.mathworks.com/help/thingspeak/analyze-your-data.html  

Actuar

Con webhooks http, thinghttp: https://thingspeak.com/apps/thinghttp

React: https://thingspeak.com/apps/reacts

React app: https://es.mathworks.com/help/thingspeak/react-app.html

Manual Thinghttp APP: https://es.mathworks.com/help/thingspeak/thinghttp-app.html

Tutorial: http://community.thingspeak.com/tutorials/arduino/cheerlights-with-arduino-and-the-fastled-library/

Restduino: https://github.com/sirleech/RestduinoThingspeak

Time control:

Canal público: https://thingspeak.com/channels/242341

WiFi

El wifi es un mecanismo de conexión de dispositivos electrónicos de forma inalámbrica. Los dispositivos habilitados con wifi como Arduino, pueden conectarse a internet a través de un punto de acceso de red inalámbrica.

Wi-Fi es una marca de la Alianza Wi-Fi, la organización comercial que adopta, prueba y certifica que los equipos cumplen con los estándares 802.11 relacionados a redes inalámbricas de área local.

  • Los estándares IEEE 802.11b, IEEE 802.11g e IEEE 802.11n disfrutan de una aceptación internacional debido a que la banda de 2,4 GHz está disponible casi universalmente, con una velocidad de hasta 11 Mbit/s, 54 Mbit/s y 300 Mbit/s, respectivamente.
  • En la actualidad ya se maneja también el estándar IEEE 802.11ac, conocido como WIFI 5, que opera en la banda de 5 GHz y que disfruta de una operatividad con canales relativamente limpios. La banda de 5 GHz ha sido recientemente habilitada y, además, no existen otras tecnologías (Bluetooth, microondas, ZigBee) que la estén utilizando, por lo tanto existen muy pocas interferencias. Su alcance es algo menor que el de los estándares que trabajan a 2,4 GHz (aproximadamente un 10 %), debido a que la frecuencia es mayor (a mayor frecuencia, menor alcance).

Existen otras tecnologías inalámbricas como Bluetooth que también funcionan a una frecuencia de 2,4 GHz, por lo que puede presentar interferencias con la tecnología wifi. Debido a esto, en la versión 1.2 del estándar Bluetooth actualizó su especificación para que no existieran interferencias con la utilización simultánea de ambas tecnologías, además se necesita tener 40 000 kbit/s.

Existen varias alternativas para garantizar la seguridad de estas redes. Las más comunes son la utilización de protocolos de cifrado de datos para los estándares wifi como el WEP, el WPA, o el WPA2 que se encargan de codificar la información transmitida para proteger su confidencialidad, proporcionados por los propios dispositivos inalámbricos. La mayoría de las formas son las siguientes:

  • WEP, cifra los datos en su red de forma que sólo el destinatario deseado pueda acceder a ellos. Los cifrados de 64 y 128 bits son dos niveles de seguridad WEP. WEP codifica los datos mediante una “clave” de cifrado antes de enviarlo al aire. Este tipo de cifrado no está recomendado debido a las grandes vulnerabilidades que presenta ya que cualquier cracker puede conseguir sacar la clave, incluso aunque esté bien configurado y la clave utilizada sea compleja.
  • WPA: presenta mejoras como generación dinámica de la clave de acceso. Las claves se insertan como dígitos alfanuméricos.
  • WPA2 (estándar 802.11i): que es una mejora relativa a WPA. En principio es el protocolo de seguridad más seguro para Wi-Fi en este momento. Sin embargo requieren hardware y software compatibles, ya que los antiguos no lo son. Utiliza el algoritmo de cifrado AES (Advanced Encryption Standard).
  • IPSEC (túneles IP) en el caso de las VPN y el conjunto de estándares IEEE 802.1X, que permite la autenticación y autorización de usuarios.
  • Filtrado de MAC, de manera que solo se permite acceso a la red a aquellos dispositivos autorizados. Es lo más recomendable si solo se va a usar con los mismos equipos, y si son pocos.
  • Ocultación del punto de acceso: se puede ocultar el punto de acceso (router) de manera que sea invisible a otros usuarios.

Dispositivos de distribución o de red en wifi son:

  • Los puntos de acceso son dispositivos que generan un set de servicio, que podría definirse como una red wifi a la que se pueden conectar otros dispositivos. Los puntos de acceso permiten, en resumen, conectar dispositivos de forma inalámbrica a una red existente. Pueden agregarse más puntos de acceso a una red para generar redes de cobertura más amplia, o conectar antenas más grandes que amplifiquen la señal.
  • Los repetidores inalámbricos son equipos que se utilizan para extender la cobertura de una red inalámbrica, éstos se conectan a una red existente que tiene señal más débil y crean una señal limpia a la que se pueden conectar los equipos dentro de su alcance. Algunos de ellos funcionan también como punto de acceso.
  • Los enrutadores inalámbricos son dispositivos compuestos, especialmente diseñados para redes pequeñas (hogar o pequeña oficina). Estos dispositivos incluyen, un enrutador (encargado de interconectar redes, por ejemplo, nuestra red del hogar con Internet), un punto de acceso (explicado más arriba) y generalmente un conmutador que permite conectar algunos equipos vía cable (Ethernet y USB). Su tarea es tomar la conexión a Internet, y brindar a través de ella acceso a todos los equipos que conectemos, sea por cable o en forma inalámbrica.

Los estándares 802.11b y 802.11g utilizan la banda de 2,4 GHz. En esta banda se definieron 11 canales utilizables por equipos wifi, que pueden configurarse de acuerdo a necesidades particulares. Sin embargo, los 11 canales no son completamente independientes (un canal se superpone y produce interferencias hasta un canal a 4 canales de distancia). El ancho de banda de la señal (22 MHz) es superior a la separación entre canales consecutivos (5 MHz), por eso se hace necesaria una separación de al menos 5 canales con el fin de evitar interferencias entre celdas adyacentes, ya que al utilizar canales con una separación de 5 canales entre ellos (y a la vez cada uno de estos con una separación de 5 MHz de su canal vecino) entonces se logra una separación final de 25 MHz, lo cual es mayor al ancho de banda que utiliza cada canal del estándar 802.11, el cual es de 22 MHz. Tradicionalmente se utilizan los canales 1, 6 y 11, aunque se ha documentado que el uso de los canales 1, 5, 9 y 13 (en dominios europeos) no es perjudicial para el rendimiento de la red.

Esta asignación de canales usualmente se hace sólo en el Punto de acceso, pues los “clientes” automáticamente detectan el canal, salvo en los casos en que se forma una red “Ad-Hoc” o punto a punto cuando no existe punto de acceso.

Canales en 802.11 (wifi) frente a 802.15.4 (zigbee):

Wifi 5G

La tecnología Wi-Fi utiliza dos bandas de frecuencias según el estándar al que nos refiramos:

  • 2,4 GHz: 802.11b, 802.11g y 802.11n
  • 5 GHz: 802.11a, 802.11n y 802.11ac

Banda 2.4 GHz: En España se pueden utilizar los canales 1-13; el canal 14 es el único prohibido, solamente se puede utilizar en Japón. La potencia máxima es siempre 20 dBm.

Banda 5 GHz: En España se permite el uso de los canales 36-64 y 100-140, al igual que en el resto de Europa. La potencia máxima depende del escenario, pero generalmente sería 23 dBm y 30 dBm respectivamente para equipos nuevos con marcado CE a partir de 2015 (ETSI EN 301 893 V1.8.1).

802.11ac:

Wifi en Arduino

Wifi: Hay múltiples formas de conectar Arduino a internet mediante wifi:

Wifi en Raspberry Pi

Raspberry Pi dispone de Wifi integrada en los siguientes modelos:

  • Model 3: 802.11b/g/n single band 2.4 GHz wireless, Bluetooth 4.1 BLE
  • Model 3+: 802.11b/g/n/ac dual band 2.4/5 GHz wireless, Bluetooth 4.2 LS BLE

Configuración WiFi desde Desktop: https://www.raspberrypi.org/documentation/configuration/wireless/desktop.md

Configuración WiFi desde CLI: https://www.raspberrypi.org/documentation/configuration/wireless/wireless-cli.md

En Raspbian, el fichero de configuración de WiFi es: /etc/wpa_supplicant/wpa_supplicant.conf

Configuración headless: https://www.raspberrypi.org/documentation/configuration/wireless/headless.md

Configurar Raspberry Pi como un Access Point: https://www.raspberrypi.org/documentation/configuration/wireless/access-point.md

Configuración WiFi en Raspberry Pi: https://www.luisllamas.es/raspberry-pi-wifi/

Más de configuración wifi en Raspberry Pi:

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.

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

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

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

Node-RED es un motor de flujos con enfoque IoT, que permite definir gráficamente flujos de servicios, a través de protocolos estándares como REST, MQTT, Websocket, AMQP… ademas de ofrecer integración con apis de terceros, tales como Twitter, Facebook, Yahoo!…

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

Web: https://nodered.org/

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  • Localmente
  • En un dispositivo
  • En la nube

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

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

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

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

Más información:

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

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

Instalar Node-RED en Raspberry Pi

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

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

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

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

  • sudo systemctl enable nodered.service

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

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

pantalla node-red

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

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

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

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

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

  • sudo systemctl restart nodered.service

Y luego para instalar un nodo:

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

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

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

Alternativamente se puede instalar mediante un script con el comando:

Configurar y Securizar Node-RED

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

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

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

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

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

Para usar https con Node-RED seguir estos tutoriales:

Programación Node-RED

Con respecto a Node-RED, se pueden hacer muchas cosas. Desde encender un LED en remoto, crear una API Rest en 5 minutos o conectar con una base de datos InfluxDB para graficar con Grafana. Aunque es visual, se requieren unos conocimientos técnicos en programación y tecnología medios y/o avanzados.

También permite programar en JavaScript funciones que pueden hacer de todo. Node-RED da mucho juego para muchas cosas.

El editor de flujos de Node-RED consiste en una sencilla interfaz en HTML, accesible desde cualquier navegador, en la que arrastrando y conectando nodos entre sí, es posible definir un flujo que ofrezca un servicio.

Como vemos, el editor se estructura como un entorno gráfico sencillo con:

  • Paleta de Nodos: Muestra todos los nodos que tenemos disponibles en nuestra instalación. Como veremos más adelante, existe un repositorio de nodos desarrollados por otros usuarios e incluso podemos crear e instalar nuestros propios nodos.
  • Editor: Nos permite arrastrar nodos desde la paleta y conectarlos. De este modo iremos creado el flujo de operación. El lienzo de node-red no tiene límites y se puede hacer zoom.

secciones principales node-red

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

En node-Red los nodos se comunican entre sí mediante msg, que es un objeto con propiedades y que podemos añadir propiedades. La propiedad principal es payload, pero puedo añadir las que quiera. Puedo añadir otras propiedades como temperatura. Los nodos se unen en flujos que se ejecutan en paralelo.

En los nodos con entrada y salida, lo que entra sale y se mantiene la información salvo la que modifiques en el nodo.

Hay tres datos o propiedades que no se pueden modificar.:

  • número de mensaje
  • topic
  • payload

Disponemos de un debug que nos muestra el objeto y la podemos sacar por pantalla.

Los nodos son la unidad mínima que podemos encontrar en Node-RED. En la parte izquierda de la interfaz podemos ver la lista de nodos que vienen instalados por defecto y organizados en categorías según su funcionalidad.

Hay nodos de entrada, salida, funciones, social, para almacenar datos, etc… Esto muestra la capacidad de Node-RED de comunicarse con otros servicios.

Se pueden clasificar en tres tipos de nodos:

  • Nodos que sólo admiten entradas: sólo admiten datos de entrada para ser enviados a algún sitio como pueda ser una base de datos o un panel de control.
  • Nodos que sólo admiten salidas: son los nodos que sólo ofrecen datos tras recibirlos a través de diferentes métodos como por ejemplo un mensaje MQTT.
  • Nodos que admiten entradas y salidas: estos nodos nos permiten la entrada de datos y luego ofrecen una o varias salidas. Por ejemplo, podemos leer una temperatura, transformarla en grados Celsius y enviarla a otro nodo.

Los nodos los arrastramos al flujo o flow, en inglés. Aquí es donde tendremos la lógica para cada dato a base de ir arrastrando nodos.

Algunos de los nodos disponibles en Node-RED, los nodes de core son: https://nodered.org/docs/user-guide/nodes

  • Inject: para disparar un flujo manualmente. Inyecta una payload a un topic.
  • Debug: sirve para mostrar mensajes en la zona de debug de Node-RED. Puede habilitarse o deshabilitarse.
  • Function: permite programar un nodo mediante JavaScript, pero es mejor buscar nodos hechos que hagan la función deseada, por ejemplo un temporizador.
  • Change: se usa para modificar las propiedades de un mensaje sin usar funciones
  • Switch: permite que los mensajes sean enrutados a diferentes ramas de un flujo mediante un conjunto de reglas contra el mensaje.
  • Template: se usa para generar texto usando las propiedades de un mensaje.

Trabajar con mensajes en Node-RED: https://nodered.org/docs/user-guide/messages

Escribir funciones en Node-RED: https://nodered.org/docs/writing-functions

Existen además muchos tipos de nodos que podemos ver en https://flows.nodered.org/?num_pages=1 que son contribuciones de terceros.

Los nodos se organizan en flujos, para organizar los nodos como queramos. Es recomendable agrupar en flujos tareas que tengan relación entre ellos, pero solo a modo organizativo.

En node-red se puede trabajar con variables:

  • Contexto – solo aplica a un nodo
  • Flujo – aplica solo al flujo
  • globales – aplica a todo.

Cookbook de nodered: https://cookbook.nodered.org/

Node-RED programming guide: http://noderedguide.com/

Administración de node red mediante comando: https://nodered.org/docs/node-red-admin

Running node-red: https://nodered.org/docs/getting-started/running

Más información: https://programarfacil.com/blog/raspberry-pi/introduccion-node-red-raspberry-pi/

Node Red en Cloud

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

FRED: Front End For Node-RED

Web principal de FRED

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

Más información:

Ejemplos Node-RED

Primer Flujo en Node-RED

Vamos a probar un flujo muy simple. Lo que hará es mostrar un texto por el panel de debug. Arrastra un nodo inject de la categoría input y un nodo debug de la categoría output al flujo. Los tienes que conectar entre ellos arrastrando el punto de la parte derecha del nodo inject sobre el punto de la parte izquierda del nodo debug.

A continuación vamos a editar el nodo inject. Si haces doble click sobre el nodo se abrirá un panel donde nos muestra diferentes parámetros. En este panel tienes que seleccionar del menú desplegable donde pone Payload, la opción que pone String.

En el campo de texto pon cualquier cosa como por ejemplo Hola mundo 🙂

Para guardar la aplicación sólo tienes que dar a Deploy que si te has dado cuenta, ha pasado de estar en un color gris oscuro a rojo.

Una vez que lo hayas pulsado, volverá de nuevo al color gris oscuro. Esto quiere decir que ya tenemos guardados todos los cambios del flujo de Node-RED.

Para probar este primer flujo con Node-RED tenemos que abrir el panel de debug que está situado en la parte derecha. Luego, tienes que hacer click sobre la parte izquierda del nodo inject.

Esto hará que en el panel debug aparezca lo que hemos escrito en la configuración del nodo inject.

Como puedes ver, el mensaje se muestra en el panel debug.

Más información: https://programarfacil.com/blog/raspberry-pi/introduccion-node-red-raspberry-pi/

Node-RED y MQTT

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

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

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

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

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

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

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

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

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

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

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

El resultado sería el siguiente.

Nodos Node-RED

Existe una amplia librería de nodos para node-RED que puede consultarse en https://flows.nodered.org/?num_pages=1

Para añadir un nodo: https://nodered.org/docs/getting-started/adding-nodes

Si quieres crear tu propio nodo: https://nodered.org/docs/creating-nodes/first-node

Por defecto vienen unos nodos instalados, pero pueden añadirse otros fácilmente.

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

Hay más de 1500 nodos, algunos de los más interesantes son:

Más información:

Nodo MySQL

Node de mysql: https://flows.nodered.org/node/node-red-node-mysql

Código del nodo de mysql: https://github.com/node-red/node-red-nodes/tree/master/storage/mysql

Ejemplo: https://flows.nodered.org/flow/13c55d1aa11e864609e24fa534a1fa26

Ejemplo de uso: https://tech.scargill.net/tag/mqtt-and-mysql-on-node-red/

Y nodo interesante para manejo de fechas:

Nodo MongoDB

Nodo MongoDB: https://flows.nodered.org/node/node-red-node-mongodb

Dashboard en Node-RED

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

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

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

Cómo usarlo: https://randomnerdtutorials.com/getting-started-with-node-red-dashboard/

Más información:

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

Tutoriales node red dashboard

Otro dashboard es el freeboard:

Ejemplo Arduino + MQTT + NodeRed + Dashboard

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

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

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

Ejemplo hecho con 4 flujos:

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

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

Mosquitto

Eclipse Mosquitto™ es un servidor de mensajes de código abierto (con licencia EPL/EDL) que implementa las versiones 3.1 y 3.1.1 del protocolo MQTT. MQTT proporciona un método ligero para llevar a cabo la mensajería utilizando un modelo de publicación/suscripción. Esto lo hace adecuado para la “Internet de los objetos” de mensajería como con sensores de baja potencia o dispositivos móviles como teléfonos, ordenadores embebidos o microcontroladores como el Arduino.

Mosquitto es un broker MQTT OpenSource ampliamente utilizado debido a su ligereza lo que nos permite, fácilmente, emplearlo en gran número de ambientes, incluso si éstos son de pocos recursos.

Web: https://mosquitto.org/

Testear Mosquitto: https://test.mosquitto.org/

Repositorio: https://github.com/eclipse/mosquitto

A través de esta página puedes descargar y seguir los pasos de instalación según cual sea tu sistema operativo.

Una vez que tenemos instalado Mosquito, podemos proceder a crear nuestro primer emisor y subscriptor siguiendo para ello una jerarquía que podría asemejarse a la empleada en una aplicación real como el de un edificio.

Proyectos Eclipse Open Source for IoT

Más información:

Otro MQTT broker: http://www.hivemq.com/

Para descargar e instalar mosquitto seguir las instrucciones de: https://mosquitto.org/download/

Buen tutorial de Luis del Valle: https://programarfacil.com/esp8266/mqtt-esp8266-raspberry-pi/

Instalar Mosquitto en Raspberry Pi

Mosquitto está disponible en el repositorio principal de Raspberry Pi. También hay repositorios Debian proporcionados por el proyecto mosquitto, tal y como se describe en  https://mosquitto.org/blog/2013/01/mosquitto-debian-repository/

Lo primero es descargar la signing key o clave de firma utilizando el comando wget. Este comando descarga el fichero indicado como parámetro en el directorio en el que te encuentras.

Añadimos la clave para a una lista para autenticar el paquete que vamos a descargar más tarde.

  • sudo apt-key add mosquitto-repo.gpg.key

Después descargamos la lista de repositorios de Mosquitto con wget en la carpeta adecuada.

Actualizamos la lista de paquetes disponibles y sus versiones

  • sudo apt-get update

Y finalmente instalamos Mosquitto y los clientes

  • sudo apt-get install mosquitto
  • sudo apt-get install mosquitto-clients

Si va a utilizar MQTT en un proyecto de Python, tendrá que instalar paho-mqtt, que reemplaza al antiguo módulo de Mosquitto Python. Si python-pip no está instalado tendrá que instalarlo primero:

  • sudo apt-get install python-pip
  • sudo pip install paho-mqtt

Más información:

Configurar mosquito

La configuración de mosquitto está el fichero /etc/mosquitto/mosquitto.conf. Recordar hacer copia del fichero antes de hacer alguna modificación

Para añadir todos los mensajes de log en el fichero de log añadir las líneas:

# Save all log in file
log_dest file /var/log/mosquitto/mosquitto.log
log_type all
log_timestamp true

Para más información sobre las opciones del fichero mosquitto.conf ver /usr/share/doc/mosquitto/examples/mosquitto.conf

Para reiniciar el servicio de mosquito usar:

  • sudo systemctl restart mosquitto

En Linux puede recargar los archivos de configuración sin reiniciar el broker enviando la señal HUP de la siguiente manera:

  • kill -HUP PID # where PID is the process ID

Más información:

Comprobar Funcionamiento de Mosquitto

El último paso es probar nuestra instalación. Vamos a usar dos terminales. Uno se suscribirá al tema “test-mosquitto”, y el otro publicará un mensaje sobre este tema. La prueba tendrá éxito si el mensaje enviado por el editor se registra en el terminal de abonado.

Abrir un terminal en el ordenador con PuTTY y para suscribirse al topic “test-mosquitto” poner el comando:

  • mosquitto_sub -d -t ‘test-mosquitto’ (d = debug mode, t = topic)

Las opciones del comando mosquitto_sub son: https://mosquitto.org/man/mosquitto_sub-1.html

Si quisiéramos conectarnos a otro mosquitto y no el de nuestra raspberry usar:

  • mosquitto_sub -d -h IP_BROKER -t ‘test-mosquitto’ (d = debug mode, t = topic, h = host)

Abrir otro terminal y para publicar en el topic “test-mosquitto” poner el comando:

  • mosquitto_pub -d -t ‘test-mosquitto’ -m ‘This is a test message’

Y recibiremos el mensaje en la consola donde nos hemos suscrito:

Probar a suscribirse o publicar a otros mosquitto. También puedes hacerlo instalando el cliente MQTT.fx de: https://mqttfx.jensd.de/

Más información:

Securizar Mosquitto – Autenticación y Autorización

Tenemos un servidor Mosquitto instalado y funcionando, pero cualquiera que pueda acceder al puerto 1883 de nuestra Raspberry Pi o servidor podrá publicar y suscribirse a topics y además los mensajes no están cifrados.

El objetivo es configurar un broker MQTT con autentificación para securizar un poco el acceso al mismo de forma que podamos exponerlo en un servidor público y aún así tengamos zonas privadas.

Vamos a configurar Mosquitto para que use contraseñas. Mosquitto incluye una utilidad para generar un archivo de contraseña especial llamado mosquitto_passwd. Este comando le pedirá que introduzca una contraseña para el nombre de usuario especificado y coloque los resultados en /etc/mosquitto/passwd. Ejecutar este comando y poner la contraseña.

  • sudo mosquitto_passwd -c /etc/mosquitto/passwd curso_iot

Ahora abriremos un nuevo archivo de configuración para Mosquitto y le diremos que use este archivo de contraseñas para requerir inicios de sesión para todas las conexiones:

  • sudo nano /etc/mosquitto/conf.d/default.conf

Y escribir en el fichero:

password_file /etc/mosquitto/passwd
allow_anonymous false

allow_anonymous false deshabilitará todas las conexiones no autenticadas, y la línea del archivo password_file le indica a Mosquitto dónde buscar información de usuario y contraseña.

Una vez modificado el fichero reiniciar mosquitto:

  • sudo systemctl restart mosquitto

En el directorio /etc/mosquitto/conf.d se guardan los ficheros de configuración adicionales.

Para publicar y suscribirse con usuario y contraseña usar:

  • mosquitto_pub -d -t “test” -m “hola_mundo” -u “curso_iot” -P “password”
  • mosquitto_sub -d -t “test” -u “curso_iot” -P “password”

Securizar Mosquitto – Cifrado SSL

Desafortunadamente, estamos enviando contraseñas sin encriptar a través de Internet. Lo arreglaremos añadiendo cifrado SSL a Mosquitto.

MQTT and TLS

MQTT se basa en el protocolo de transporte TCP. De forma predeterminada, las conexiones TCP no utilizan una comunicación cifrada. Para encriptar toda la comunicación MQTT, muchos Brokers MQTT (como Mosquitto) permiten el uso de TLS en lugar de TCP simple. Si utiliza los campos de nombre de usuario y contraseña del paquete MQTT CONNECT para los mecanismos de autenticación y autorización, debería considerar seriamente el uso de TLS.

El puerto 8883 está estandarizado para una conexión MQTT segura. El nombre estandarizado en IANA es “secure-mqtt”. El puerto 8883 está reservado exclusivamente para MQTT a través de TLS.

TLS Overhead

El uso de MQTT sobre TLS tiene sus inconvenientes: la seguridad tiene un costo en términos de uso de la CPU y gastos generales de comunicación. Mientras que el uso adicional de la CPU es típicamente insignificante en el broker, puede ser un problema para los dispositivos muy restringidos que no están diseñados para tareas de computación intensiva. Técnicas como la reanudación de sesión pueden mejorar drásticamente el rendimiento de TLS.

La sobrecarga de comunicaciones del Handshake de TLS puede ser significativa si se espera que las conexiones de los clientes MQTT sean de corta duración. Aunque la cantidad de ancho de banda que necesita el handshake TLS depende de muchos factores, algunas mediciones muestran que establecer una nueva conexión TLS puede requerir hasta unos pocos kilobytes de ancho de banda. Dado que cada paquete está encriptado en TLS, los paquetes en el cable tienen una sobrecarga adicional en comparación con los paquetes no encriptados.

Si utiliza conexiones TCP de larga duración con MQTT (¡lo que debería hacer!), la sobrecarga de TLS, especialmente la sobrecarga de handshake de TLS, puede ser insignificante. Si trata con muchas reconexiones y no puede utilizar la reanudación de sesión, entonces la sobrecarga puede ser significativa, especialmente si está publicando mensajes MQTTT muy pequeños. Si cada byte del cable cuenta para su caso de uso, TLS puede no ser la mejor opción para usted debido a la sobrecarga. Asegúrese de medir cuánta sobrecarga de TLS crea para su caso de uso.

TLS en dispositivos limitados

A veces, TLS no es factible para dispositivos limitados debido a la insuficiencia de recursos. Dependiendo de las cifras utilizadas, TLS puede ser muy intensivo en el cálculo y puede requerir muchos kilobytes de memoria.

Para hacerlo seguir estos tutoriales:

Más información

Ejemplo con Mosquitto y Arduino

Conectar un Arduino al broker MQTT y suscribirse al topic “inTopic” y sacar por el monitor serie lo que lee.

Usar el código: https://github.com/jecrespo/Curso-IoT-Open-Source/blob/master/mqtt_auth_curso/mqtt_auth_curso.ino