Video. Conectar ESP8266 a Internet. WifiClient

Publicado el Deja un comentarioPublicada en Arduino, ESP8266, HTTP, Práctica, Video, Wifi, Youtube

TODO: poner enlace al vídeo

Una vez escaneadas las redes, vamos a conectarnos a una de ellas y acceder a internet llegando a un servidor y ver su contenido.

El ejemplo WiFiClientBasic que podemos encontrar en Archivos – Ejemplos – ESP8266WiFi – WiFiClientBasic.

Este ejemplo se conecta a una red WiFi y manda un mensaje a un servidor TCP, en este caso a la IP 192.168.1.1 y al puerto 80.

La clase ESP8266WiFiMulti es igual que la clase ESP8266WiFi pero que permite configurar múltiples conexiones a puntos de acceso que en caso de perder la conexión se conecte al siguiente: http://arduino-esp8266.readthedocs.io/en/latest/esp8266wifi/station-examples.html?highlight=ESP8266WiFiMulti

Con WiFi.mode(WIFI_STA); pongo el ESP8266 en modo estación, es decir, para conectar a una red WiFi de un punto de acceso.

Para más información:

Una vez conectado entramos en el loop y me conecto a un servidor como cliente. La clase cliente permite acceder a servicios de los servidor pudiendo enviar y recibir datos:

NOTA: en caso que el router wifi de una IP en otro rango que no sea el 192.168.1.x, cambiar la IP de la variable host por la IP del router wifi al que nos conectamos.

Ejercicio propuesto: conectar a https://www.aprendiendoarduino.com/servicios/aprendiendoarduino/ y leer el mensaje que devuelve.

Solución: https://github.com/jecrespo/aprendiendoarduino-curso-esp8266-youtube/blob/master/WiFiClientBasicMejorado/WiFiClientBasicMejorado.ino

En este caso debemos usar un lenguaje de comunicación común para hablar entre el servidor y el ESP8266, es el mismo lenguaje que usa cualquier navegador que se conecta a una página web y es el HTTP.

Una vez conectados al puerto 80 debe mandar un GET con la ruta del servidor y acabar con una línea nueva, tal y como funciona este protocol. Para ello mando:

client.println("GET /servicios/aprendiendoarduino/ HTTP/1.0");
client.println("Host: www.aprendiendoarduino.com");
client.println();

Si todo funciona bien recibiré la respuesta “HTTP1.1 200 OK” seguido de las cabeceras y luego una línea nueva, tras la cual aparecerá la respuesta del servidor. Para leer todas las líneas y no solo la primera es necesario hacer un bucle while mientras haya datos recibidos con la instrucción client.available(): https://www.arduino.cc/en/Reference/WiFiClientAvailable

NOTA: es necesario añadir la cabecera HTTP “Host: www.aprendiendoarduino.com” para que el hosting de la web resuelva el nombre del dominio.

La respuesta obtenida es:

Mensaje oculto: “Bienvenido al servidor de www.aprendiendoarduino.com

Más información sobre el protocolo HTTP: https://aprendiendoarduino.wordpress.com/2017/06/26/protocolo-http-2/

Demo LoRa con Moteino

Publicado el Deja un comentarioPublicada en Arduino, demo, LoRa, LoRaWAN, LPWAN, Práctica

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

Publicado el Deja un comentarioPublicada en Arduino, demo, IoT, MKRFOX1200, Plataformas, Práctica, Sigfox

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