Archivo de la categoría: demo

Demo IoT

En esta demo se va a ver la potencia de IoT con la combinación de varias tecnologías open source. Se usará Arduino y dispositivos compatibles con Arduino, Raspberry Pi, Node-RED y otras tecnologías como Telegram.

Además, esta demo pretende ser interactiva, es decir, que una vez vista esta demostración, cualquiera con las herramientas y código proporcionado y los elementos hardware descritos, podrán interactuar con la plataforma IoT de la demo.

Descripción de la Demo

Esta demo consiste en conectar múltiples dispositivos basados en Arduino de cualquier persona del mundo e interactuar con la plataforma IoT instalada en una Raspberry Pi, así como usar un grupo de Telegram para recibir avisos y alertas.

Para conectar todos los dispositivos basados en Arduino usaremos un broker MQTT público, en nuestro caso será MyQttHub https://myqtthub.com/, pero también podría usarse CloudMQTT https://www.cloudmqtt.com/.

Es imprescindible tener el usuario y contraseña del broker para interactuar, si no las tienes puedes pedirlas en aprendiendoarduino@gmail.com

Para saber más de MQTT puedes ver: https://aprendiendoarduino.wordpress.com/2018/11/19/mqtt/

Esta es la estructura que vamos a usar:

Cada dispositivo Arduino publicará en el broker MQTT un dato en un topic y en función del topic, la plataforma IoT basada en Node-Red y ejecutándose en una Raspberry Pi, realizará una serie de acciones.

Además usaremos el grupo de telegram https://t.me/aprendiendoarduinocursoarduino para la recepción de alertas e interactuar con un bot en los dispositivos conectados. Únete al grupo de telegram para interactuar.

Cada dispositivo basado en Arduino conectado a Internet (p.e. basado en ESP8266) se conecta al broker MQTT público mandando o recibiendo datos y esos datos son recibidos en la plataforma IoT basada en Node-RED, instalada en una Raspberry Pi en la sede central.

El dispositivo puede publicar datos en unos topics determinados que se leerán desde Node-RED y se ejecutarán una serie de acciones.

También el dispositivo se puede suscribir a unos topics determinados y leer los datos recibidos, así como ejecutar una serie de acciones en función de los datos recibidos.

Funcionalidades de la Demo

Los dispositivos basados en Arduino podrán hacer las siguientes acciones:

  • Mandar mensajes de alerta. Por ejemplo la apertura de un detector magnético. Cuando se reciba, se mandará un mensaje al grupo de Telegram con el estado del sensor y quien lo manda y se visualizará en https://www.aprendiendoarduino.com/servicios/mensajes/index.html
  • También se mandará una foto al grupo de Telegram cuando se reciba el mensaje de alerta.
  • Mandar mensajes de temperatura y/o humedad. Estos datos se almacenarán en una BBDD y se visualizarán en el Dashboard de Node Red y en https://www.aprendiendoarduino.com/servicios/datos/graficas.html
  • También se puede configurar una alerta para enviar a Telegram y al panel de mensajes, en caso que se supere una temperatura o humedad determinada.
  • Recibir mensaje de encendido o apagado del led integrado de Arduino

Para visualizar e interactuar se dispone de:

  • Grupo de Telegram
  • Dashboard de Node-RED, que solo se visualiza en local donde esté instalado
  • Gráficas
  • Alertas

Estructura de topics

Para poder interactuar con la plataforma los mensajes se deben mandar con una estructura de topic concreta:

  • demo/temperatura/Z – envía un dato numérico de temperatura
  • demo/humedad/Z – envía un dato numérico de humedad
  • demo/reset/Z – envía un mensaje de reset al reinicarse
  • demo/alerta/xx – envía un texto de alarma
  • demo/led/xx – envía un dato ON/OFF para el estado del LED

Siendo xx un identificador del nodo que puede ser un nombre o un número y siendo Z un número del 2 al 20 para identificar la gráfica donde visualizar los datos en https://www.aprendiendoarduino.com/servicios/datos/graficas.html.

Elementos de Hardware Usado

Hardware Nodos Remotos

Hardware Nodo Central

Raspberry Pi 3 Model B o superior:  https://www.raspberrypi.org/products/raspberry-pi-3-model-b/. Esta Raspberry Pi tiene instalado Node-RED donde se ejecutará la plataforma y la programación IoT.

Para la fotos una Raspberry Pi conectada a Internet con cámara. Por ejemplo, unas Raspberry Pi Zero W con cámara

Adicionalmente un M5stack para visualizar datos en la pantalla y controlar dispositivos con los botones.

Código Usado

Todo el código usado en la demo está disponible en el repositorio: https://github.com/jecrespo/demo-iot

Interactúa con la Plataforma

Como ejercicio, puedes interactuar con la plataforma y ser parte de la demos

Para la interacción con la demo necesitarás:

Para poder interactuar con la plataforma los mensajes se deben mandar con una estructura de topic concreta:

  • demo/temperatura/Z – envía un dato numérico de temperatura
  • demo/humedad/Z – envía un dato numérico de humedad
  • demo/reset/Z – envía un mensaje de reset al reinicarse
  • demo/alerta/xx – envía un texto de alarma
  • demo/led/xx – envía un dato ON/OFF para el estado del LED

Siendo xx un identificador del nodo que puede ser un nombre o un número y siendo Z un número del 2 al 20.

Los mensajes de alarma se publicarán en el grupo de Telegram https://t.me/aprendiendoarduinocursoarduino

Demo LoRa con Moteino

Medición de temperatura remota de forma inalámbrica usando LoRa con un MoteinUSB with flash https://lowpowerlab.com/guide/moteino/. Integración de los datos en un servidor propio https://www.aprendiendoarduino.com/ y en thingspeak https://thingspeak.com/. Se usa un gateway sencillo de reenvio de mensajes usando un Arduino Yun conectado por WiFi a Internet y un shield LoRa http://www.dragino.com/products/lora/item/102-lora-shield.html

Hardware Utilizado en el módulo LoRa

Hardware utilizado en el gateway:

Esta demo consiste en un cliente basado en un moteino alimentado por batería que manda datos de temperatura de una sonda DHT22 a un nodo central que hace de gateway basado en un Arduino Yun con un shield Lora de Draguino.

Cliente

Para empezar con Moteino, lo primero es instalar el soporte para estas tarjetas e instalar las librerías: https://lowpowerlab.com/guide/moteino/programming-libraries/

Luego la guía de programación con el IDE de Arduino: https://lowpowerlab.com/guide/moteino-programming/arduinoide/

Para LoRa usamos el módulo RFM95: https://lowpowerlab.com/guide/moteino/transceivers/ y necesitaremos la librería recomendada que soporta LoRa: https://lowpowerlab.com/guide/moteino/lora-support/. Para estos módulos la librería recomendada es: http://www.airspayce.com/mikem/arduino/RadioHead/index.html, la descargamos e instalamos.

Tomando como base el ejemplo rf95_client de la librería Radiohead modificado para mandar la temperatura de una sonda DHT22 que es un dato de tipo float, en lugar de “Hello World”.

El código del cliente está disponible en: https://github.com/jecrespo/aprendiendoarduino-lora/blob/master/Demo_LoRa/rf95_client/rf95_client.ino

Servidor/Gateway

Se usa un Arduino Yun https://store.arduino.cc/arduino-yun que dispone de conexión ethernet y wifi y para la red LoRa uso un LoRa shield de draguino http://www.dragino.com/products/module/item/102-lora-shield.html

Más información sobre el shield ver este documento: http://wiki.dragino.com/index.php?title=Lora_Shield

Para este shield uso la misma librería: http://www.airspayce.com/mikem/arduino/RadioHead/index.html,

Tomando como base el ejemplo rf95_server de la librería Radiohead modificado para recibir un float y sacarlo por el puerto de consola.

IMPORTANTE: en el ejemplo de rf95_server no usar el pin 9 para el led (int led = 9;) porque el pin 9 se usa como reset en el shield de draguino.

Una vez comprobado que el servidor recibe datos, debe hacer su función de gateway y mandar los datos a una base de datos alojada en https://www.aprendiendoarduino.com/ y poder ver la gráfica en https://www.aprendiendoarduino.com/servicios/datos/graficas.html

Para grabar datos se debe llamar a una API desde el arduino Yun. Uso el HTTP client para mandar datos https://www.arduino.cc/en/Tutorial/HttpClient. De esta forma hace el Arduino Yun + Shield LoRa de Gateway reenviando los datos recibidos por LoRa a un servidor público.

El código del servidor está en https://github.com/jecrespo/aprendiendoarduino-lora/blob/master/Demo_LoRa/rf95_server/rf95_server.ino

Dispositivos Sigfox y Lora recogiendo datos en campo:

Para mandar los datos a thingspeak uso la API y mando los datos llamando a https://api.thingspeak.com/update?api_key=writeapikey&field1=22.8

Está disponible una vista publica de los datos: https://thingspeak.com/channels/440179

Demo MKRFOX1200

Medición de temperatura y humedad con un Arduino MKRFOX1200 y sistema simple de alarma basado en un umbral superior. Integración en un servidor propio https://www.aprendiendoarduino.com/ y en thingspeak https://thingspeak.com/

Hardware utilizado:

En esta demo demuestra la potencia de la red Sigfox para IoT, usando un sistema simple se va a medir la temperatura y humedad ambiente de forma inalámbrica y con total movilidad. Se usa un sensor de temperatura y humedad DHT22 conectado al MKRFOX1200 que manda mensajes con los datos cada 30 segundos para esta demostración. Para no llegar al límite diario de mensajes de Sigfox habría que hacerlo cada 10 minutos.

En el mensaje se mandan 3 datos:

  • Temperatura (5 bytes en ASCII). De -9.00 a 99.99
  • Humedad (5 bytes en ASCII). De 00.00 a 99.99
  • Evento de alarma (1 byte ASCII). 0 = normal (no event), 1 = alarm triggered, 2 = restore alarm.

Lo mando todo como texto para simplificar todo, pero si puede mandar los float y ahorrar un byte. Un buen ejemplo de base para mandar un float y convertir diferentes tipos de datos para mandar por sigfox: https://github.com/nicolsc/sigfox-weather-station

El propio Arduino detecta la alarma de alta temperatura y manda en el byte de alarma el evento, cuando la alarma se recupera manda un nuevo evento de recuperación.

Puesto que desde el backend de Sigfox no es capaz de distinguir cuando es una alarma o no, ya que solo puede reenviar los datos del mensaje mandado por el dispositivo sigfox, estos datos se reenvían mediante dos callbacks a:

En ambas plataformas la misión es almacenar los datos, representarlos gráficamente y analizar el mensaje y mandar el evento de alarma cuando corresponda. Incluso desde cualquiera de las dos plataformas, se podría hacer la comprobación de alarma al superar el umbral en lugar de mandarlo por mensaje Sigfox. Estas son las tareas que el backend de Sigfox no puede hacer.

La ventaja de usar un servidor/plataforma propia es que los datos los guardamos en nuestra infraestructura y son accesibles para siempre. Para el caso de la plataforma propia aprovechamos para guardar datos adicionales y aprender más de Sigfox:

Y desde la BBDD podríamos ver los valores máximos y mínimos de RSSI y SNR.

El código a cargar en Arduino es https://github.com/jecrespo/AprendiendoArduino-Sigfox

Dispositivos Sigfox y Lora recogiendo datos en campo:

Una vez cargado el código en Arduino y el dispositivo registrado en el backend de Sigfox ya podemos ver los los mensajes en el backend, dentro de device apartado messages.

Los datos del mensaje en el backend se ven en HEX, para comprobar que lo enviado es correcto se puede usar este conversor a ASCII: https://www.rapidtables.com/convert/number/hex-to-ascii.html

Desde el backend las funciones que se pueden hacer con los datos son muy limitadas, así que con el uso de las callbacks podemos reenviar estos datos a plataformas externas.

Estas callbacks transfieren los datos recibidos de los dispositivos asociados al device type a su infraestructura. Para obtener más información, consulte la documentación de callback: https://backend.sigfox.com/apidocs/callback

Las callbacks están asociadas a los device type, he creado dos callbacks una para mandar los datos a la plataforma propia https://www.aprendiendoarduino.com/ y otra para reenviar los datos a thingspeak https://thingspeak.com/

Para  https://www.aprendiendoarduino.com/ el callback es:

Y el código que guarda los datos en la BBDD y manda los mensajes de alarma está hecho en PHP y el código está en: https://github.com/jecrespo/aprendiendoarduino-servicios/tree/master/sigfox y además de guardar los datos en una BBDD, las temperaturas los guarda en otra BBDD para representar gráficamente y se encarga también del envío de alarmas.

Y veo los datos en tiempo real:

Para la plataforma thingspeak: https://thingspeak.com/, hago una llamada a la API de sigfox para actualizar: https://api.thingspeak.com/update.json?api_key=writeapikey&field2={customData#humidity}&field1={customData#temperature}

El callback es:

Este es un esquema de lo que estamos haciendo:

Lo que hago es desde el backend de sigfox es reenviar los datos a la plataforma IoT:

Desde thingspeak hay que configurar un canal con los campos temperatura y humedad y podemos dar una vista pública que puede verse en https://thingspeak.com/channels/440162

Imágenes y más información en: