El objetivo de este taller es poner en práctica lo visto en la charla http://www.aprendiendoarduino.com/iot-conectando-dispositivos-con-arduino/ y demostrar lo sencillo que es hacer una prueba de concepto de un proyecto IoT para conectar a Internet cosas.
En las tres horas que dura el taller vamos a hacer pequeñas pruebas de conexión de Arduino con diversas plataformas de una forma guiada, pero dejando a cada uno de los participantes que puedan hacer pruebas por su cuenta y puedan “jugar” un poco con los elementos conectados.
Un proyecto IoT sencillo llevaría más tiempo y de dejaremos para futuros cursos.
El código usado en el taller está disponible en https://github.com/jecrespo/aprendiendoarduino-iot
Y se puede descargar desde: https://github.com/jecrespo/aprendiendoarduino-iot/archive/master.zip
SW Taller IoT
Última versión del IDE de Arduino instalada https://www.arduino.cc/en/Main/Software
Para los que trabajen con el ESP8266, instalar el soporte Arduino para ESP8266 https://github.com/esp8266/Arduino
Para los que usen XBEE instalar XCTU: https://www.digi.com/products/xbee-rf-solutions/xctu-software/xctu
Código del taller: https://github.com/jecrespo/aprendiendoarduino-iot y descarga
HW Taller IoT
Cada participante usará su portátil con el software instalado.
Disponemos de 17 puestos numerados del 1 al 17.
Tipo A (números 1 al 17)
- Arduino UNO
- Protoboard
- Cables conexión
- Cable USB
- Ethernet Shield
- LEDs y Resistencias 220 ohms
- Botón/pulsador
- Servo
- Sonda Temperatura (TMP36)
- Potenciómetro
Tipo B (opcional)
- Arduino UNO (Usado como programador ESP8266)
- ESP8266 (usado como microcontrolador)
- Protoboard
- Cables conexión
- Cable USB
- LEDs y Resistencias 220 ohms
- Botón/pulsador
- Potenciómetro
Tipo C (opcional)
- Arduino Leonardo
- Protoboard
- Cables conexión
- Cable USB
- XBee Shield
- Módulo XBee
- XBee Explorer (Para programar el módulo XBEE)
- LEDs y Resistencias 220 ohms
- Botón/pulsador
- Potenciómetro
Puesto Gateway (opcional)
- Arduino UNO
- Ethernet Shield
- XBee Shield
- Protoboard
- LEDs y Resistencias 220 ohms
- Botón/pulsador
- Potenciómetro
Conexiones:
- Botón – Entrada digital pullup — pin 6
- Led Rojo – Salida digital — pin 7
- Led Verde – Salida digital — pin 8
- Sonda de temperatura – Entrada analógica — pin A0
- Potenciómetro – Entrada analógica — pin A1
- Servo – PWM — pin 9
Esquema:
Comunicaciones Taller IoT
Disponemos de tres tipos de conexiones:
- Ethernet – Ethernet Shield
- Wifi – ESP8266
- XBee – XBee shield y un módulo
Conexión Ethernet
El Arduino ethernet shield nos da la capacidad de conectar un Arduino a una red ethernet. Es la parte física que implementa la pila de protocolos TCP/IP.
Está basada en el chip ethernet Wiznet W5100. El Wiznet W5100 provee de una pila de red IP capaz de soportar TCP y UDP. Soporta hasta cuatro conexiones de sockets simultáneas. Usa la librería Ethernet para leer y escribir los flujos de datos que pasan por el puerto ethernet. Me permitirá escribir sketches que se conecten a internet usando la shield.
Librería ethernet: http://arduino.cc/en/Reference/Ethernet
El shield provee un conector ethernet estándar RJ45. La ethernet shield dispone de unos conectores que permiten conectar a su vez otras placas encima y apilarlas sobre la placa Arduino.
Arduino usa los pines digitales 10, 11, 12, y 13 (SPI) para comunicarse con el W5100 en la ethernet shield. Estos pines no pueden ser usados para e/s genéricas.
Conexión ESP8266
El ESP8266 es un chip Wi-Fi de bajo coste con pila TCP/IP completa y capacidad de MCU (Micro Controller Unit) producida por el fabricante chino Espressif Systems, con sede en Shanghai.
Características:
- 32-bit RISC CPU: Tensilica Xtensa LX106 running at 80 MHz*
- 64 KiB of instruction RAM, 96 KiB of data RAM
- External QSPI flash – 512 KiB to 4 MiB* (up to 16 MiB is supported)
- IEEE 802.11 b/g/n Wi-Fi
- Integrated TR switch, balun, LNA, power amplifier and matching network
- WEP or WPA/WPA2 authentication, or open networks
- 16 GPIO pins
- SPI, I²C,
- I²S interfaces with DMA (sharing pins with GPIO)
- UART on dedicated pins, plus a transmit-only UART can be enabled on GPIO2
- 1 port 10-bit ADC
Los módulos ESP8266 los podemos encontrar en diferentes encapsulados y placas:
En nuestro caso vamos a usar el ESP-01:
Pines:
- TX (goes to the 3.3V Rx of the UART USB adapter to the PC)
- CH_PD (enable/power down, must be pulled to 3.3v directly or via resistor)
- RESET
- VCC (3.3v power supply)
- GND (connect to power ground)
- GPIO 2
- GPIO 0 (leave open or pull up for normal, pull down to upload new firmware)
- RX (goes to the 3.3V Tx of the UART USB adapter to the PC)
Para usar el ESP8266 con Arduino vamos a conectarnos por el puerto serie. Arduino UNO es usado solo como programador. Este es el esquema.
OJO: ¡¡va alimentado a 3.3V!!
El Arduino Core ESP8266 está disponible a través de GitHub: https://github.com/esp8266/Arduino
Reference de Arduino core a ESP8266: https://github.com/esp8266/Arduino/blob/master/doc/reference.md
Debemos instalar el soporte a terceros en nuestro IDE simplemente añadiendo el texto “http://arduino.esp8266.com/stable/package_esp8266com_index.json” en propiedades:
Y luego desde el gestor de tarjetas dar a instalar al soporte para ESP8266.
Conexión XBee
XBee es el nombre comercial del Digi de una familia de módulos de comunicación por radio y están basados en el estándar zigbee, pero digi tiene muchos Xbee y algunos son zigbee estándar y otros son propietarios o modificaciones del estándar. Existen muchos módulos Xbee basados en el estándar IEEE 802.15.4
Para programar el módulo XBee necesitaremos el XBee explorer.
XBee Series 1 (también llamados XBee 802.15.4) – Son la serie más fácil para trabajar, no necesitan ser configurados, pero incluso así se pueden obtener beneficios de estos módulos. Debido a que son fáciles para trabajar, son los más recomendables especialmente si se está empezando.
Para configurar y usar los módulos XBee es necesario descargar e instalar XBee Configuration and Test Utility (XCTU) que es un software multiplataforma que permite interactuar con los módulos mediante un interfaz gráfico. Esta aplicación incluye herramientas que hacen muy sencillo configurar y probar los módulos XBee.
XCTU nos sirve para configurar, inicializar, actualizar firmware y testear los módulos XBee, comunicándose por puerto serie a los módulos. Una ventaja de este software es que puedes ver rápidamente un resumen de todos los parámetros del módulo y una descripción de ellos.
Más información y descarga de XCTU: http://www.digi.com/products/xbee-rf-solutions/xctu-software/xctu
Los dispositivos XBee se comunican entre ellos a través del aire enviando y recibiendo mensajes. Estos dispositivos no pueden gestionar los datos enviados o recibidos, sin embargo pueden comunicarse con otros dispositivos a través del interfaz serie.
Por lo tanto tenemos dos tipos de comunicación en los dispositivos XBee:
- Comunicación inalámbrica: es la comunicación entre los módulos XBee, estos módulos deben ser parte de la misma red y usar la misma frecuencia de radio.
- Comunicación serie: es la comunicación entre el módulo XBee y el microcontrolador o el PC a través de un puerto serie.
En la comunicación inalámbrica los módulos transmiten y reciben información a través de la modulación de las ondas electromagnéticas. Para que se realice la transmisión ambos módulos deben estar en la misma frecuencia y en la misma red. Esto se determina por dos parámetros:
- Channel (CH) es la frecuencia usada para comunicar, es decir, el canal dentro de la red.
- Personal Area Network Identifier (ID) es un identificador único que establece que los módulos están en la misma red.
Un módulo XBee solo recibirá y transmitirá datos a otros XBee dentro de las misma red (mismo ID) y usando el mismo canal (mismo CH).
Vamos a trabajar en modo transparente el módulo XBee funciona de forma que todo lo recibido por el puerto serie es enviado inmediatamente al aire y todo lo recibido por la radio es se manda tal cual al puerto serie.
En modo transparente para comunicar dos módulos, es necesario configurar la dirección del destino en el módulo que envía datos. Esta dirección se programa en los parámetros: Destination Address High (DH) y Destination Address Low (DL).
Configuración de los módulos:
Param | NODO (END DEVICE) | COORDINATOR | Effect |
CH | C | C | Define la frecuencia a usar. Debe ser la misma en ambos módulos. |
ID | 2015 | 2015 | Define la red a la que se conecta la radio. Debe ser la misma en ambos módulos. |
DH | 0013A200 | 0013A200 | DH y DL forma la dirección de destino. Es donde las notificaciones son mandadas cuando cambia el valor del pin. Se configura como dirección corta de 16 bits. |
DL | SL of Coordinator | — | |
MY | 123X | 5678 | Define la dirección corta de 16 bits.
X es el número del kit. |
CE | 0 | 1 | Coordinator mode |
A1 | 0111b | — | End Device Association |
A2 | — | 100b | association settings |
Haremos un esquema de comunicación punto a punto. En este modelo un módulo puede comunicarse con un módulo o múltiples módulos que estén en la misma red. Esta comunicación implica un nodo central coordinador con varios nodos remotos (end devices) conectándose al nodo central.
En el protocolo 802.15.4 los módulos XBee tienen dos roles:
- Coordinator, es el nodo central de la red. Inicia la red y permite a otros dispositivos conectarse, puede seleccionar la frecuencia del canal y hace la sincronización de la red. Para configurar un nodo como coordinador hay que cambiar el parámetro CE (Coordinator Enable) a 1.
- End device, es un nodo remoto de la red. Puede comunicarse con el coordinador y con otros end devices de la red. Se puede poner en modo sleep.
En el coordinador, cambiado el parámetro A2 es posible asociar end devices sin que conozcan el canal (CH) y el ID de red (ID) siendo inicializados por el coordinador.
El nodo usado como coordinador está configurado como un gateway y todo lo que recibe los manda por ethernet.
Plataformas Taller IoT
Una vez todo instalado vamos a conectarnos a diversas plataformas haciendo algunas prácticas con ellas, mandando datos, visualizandolos, enviando mensajes que se mostrarán por pantalla, analizar los datos, etc…
Plataforma Propia (opcional)
Disponemos de una plataforma muy sencilla de IoT en: http://www.aprendiendoarduino.com/servicios/
Esta plataforma es un desarrollo simple que está alojado en un hosting compartido, pero podría estar en una Raspberry Pi.
Desde ella podemos:
- Mandar datos desde Arduino o ESP8266 y verlos en tiempo real: http://www.aprendiendoarduino.com/servicios/datos/index.html
- Visualizar en tiempo real los datos enviados: http://www.aprendiendoarduino.com/servicios/datos/graficas.html
- Envío de mensajes y visualización: http://www.aprendiendoarduino.com/servicios/mensajes/index.html
- Envío de SMSs y visualización de los enviados y estado del envío: http://www.aprendiendoarduino.com/servicios/SMS/index.html
Todo el código de la plataforma y Arduino en:
- Grabar datos y visualizar datos y gráficas: https://github.com/jecrespo/aprendiendoarduino-servicios/tree/master/datos
- Grabar mensajes y visaualizarlos: https://github.com/jecrespo/aprendiendoarduino-servicios/tree/master/mensajes
- Mandar SMS y visualizarlos: https://github.com/jecrespo/aprendiendoarduino-servicios/tree/master/SMS
Conexión para enviar datos de temperatura:
Datasheet sonda temperatura: https://www.arduino.cc/en/uploads/Main/TemperatureSensor.pdf
Ejercicios propuestos:
- Enviar datos de la sonda de temperatura o del potenciómetro y visualizarlos en tiempo real en http://www.aprendiendoarduino.com/servicios/datos/graficas.html
- Mandar un mensaje y visualizarlo en tiempo real solicitando por el puerto serie el nombre y el mensaje.
- Mandar un SMS y visualizarlo en tiempo real solicitando por el puerto serie el nº de teléfono y el mensaje.
- Modificar el programa de envío de mensaje y SMS para que mande un mensaje fijo al pulsar un botón.
- Conectar con la web de aemet y guardar los datos de humedad exterior y sacarlos en una gráfica.
El código de Arduino para usar cada uno de ellos es: https://github.com/jecrespo/aprendiendoarduino-iot/tree/master/00%20-%20Plataforma%20Propia
Opendata AEMET: https://opendata.aemet.es/centrodedescargas/inicio
Documentación API: https://opendata.aemet.es/dist/index.html
Ejemplos: https://opendata.aemet.es/centrodedescargas/ejemProgramas
Solicitar API KEY: https://opendata.aemet.es/centrodedescargas/altaUsuario
Manejar JSON en Arduino:
- Librería ArduinoJson: https://bblanchon.github.io/ArduinoJson/
- Librería json-streaming-parser: https://github.com/squix78/json-streaming-parser
- aJson: https://github.com/interactive-matter/aJson/
- Uso aJson: http://hardwarefun.com/tutorials/parsing-json-in-arduino
- Uso aJson: http://interactive-matter.eu/blog/2010/08/14/ajson-handle-json-with-arduino/
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 u otro HW.
Canal público: https://thingspeak.com/channels/242341
Ejemplo práctico
Pasos previos:
- Darse de alta en la plataforma Thingspeak.
- Instalar la librería de Arduino para Thingspeak.
- Cargar en Arduino el sketch: https://github.com/jecrespo/aprendiendoarduino-iot/blob/master/01-Thingspeak/datalogger_DHCP/datalogger_DHCP.ino
Documentación: https://thingspeak.com/docs
Crear un nuevo canal: Nodo X, siendo X el número de kit usado.
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.
Crear tres campos, donde registramos los datos del potenciómetro, la temperatura y cuando pulso el botón:
- temperatura
- potenciómetro
- botón
API de tablas y canales: API: https://es.mathworks.com/help/thingspeak/channels-and-charts.html
Aplicaciones de thingspeak (Thingspeak apps): https://thingspeak.com/apps
Ejercicio propuesto:
- Mandar los datos de las dos entradas analógicas y una digital a un canal de thingspeak.
- Crear una visualización de datos con MATLAB
- Crear una app con ThingHTTP, que llame a la API de de mensajes de aprendiendoarduino.com: http://www.aprendiendoarduino.com/servicios/mensajes/grabaMensajes.php y cada vez que se pulse el botón se mandará un mensaje que podrá visualizarse en tiempo real en: http://www.aprendiendoarduino.com/servicios/mensajes/index.html
http://www.aprendiendoarduino.com/servicios/mensajes/grabaMensajes.php?nombre=NOMBRE&mensaje=MENSAJE
- Crear un nuevo react que cuando se pulse el botón llame a la regla definida en ThingHTTP para que mande el mensaje.
- Ver el resto de apps que ofrece thingspeak
Repositorio: https://github.com/jecrespo/aprendiendoarduino-iot/tree/master/01-Thingspeak
Información:
- React app: https://es.mathworks.com/help/thingspeak/react-app.html
- Manual Thinghttp APP: https://es.mathworks.com/help/thingspeak/thinghttp-app.html
Carriots (opcional)
Carriots es una Plataforma como Servicio (PaaS en sus siglas en inglés) diseñada para proyectos del Internet de las Cosas (IoT) y de Máquina a Máquina (M2M)
Más información: https://www.carriots.com/que-es-carriots
Carriots es una plataforma IoT creada en España.
- Cree potentes productos y servicios IoT.
- Conecte fácilmente “sus cosas” al Internet de las Cosas.
- Construya sus apps inteligentes con Carriots en 5 pasos.
Pasos:
- Conectar Dispositivos
- Recopilar Datos
- Gestionar Dispositivos y Datos
- Construir APPs
Casos de uso: https://www.carriots.com/casos-de-uso
Pasos previos:
- Darse de alta en la plataforma Carriots.
- Crear un nuevo dispositivo llamado ArduinoX, siendo X el número de Arduino.
En este caso recibo datos en formato JSON en lugar de crear fields.
Información:
- Documentación desarrolladores: https://www.carriots.com/que-es-carriots
- Mandar datos a Carriots: https://www.carriots.com/tutorials/arduino_carriots/arduino_library
- Ejemplo de uso: https://www.carriots.com/tutorials/arduino_carriots/alert_system
- API carriots: https://www.carriots.com/documentation/api
- Wizard Listener: https://cpanel.carriots.com/wizards/createlistener
- Wizard gráficas: https://cpanel.carriots.com/graphs/
Ejercicio Propuesto:
- Mandar datos del potenciómetro cada 10 segundos a la plataforma mediante MQTT
- Mandar el aviso de puerta abierta o cerrada cada vez que cambia mediante API REST.
- Visualizar el flujo de datos
- Exportar los datos a fichero.
- Configurar un listener para que mande un correo al pulsar un botón o al pasar de 700 en el valor leído del potenciómetro. Usar el wizard de listener.
- Usar el wizard de gráficas para hacer una gráfica.
Repositorio: https://github.com/jecrespo/aprendiendoarduino-iot/tree/master/02-Carriots
Tutorial de Alerta con Arduino https://www.carriots.com/tutorials/arduino_carriots/alert_system
MQTT y Adafruit IO
MQTT son las siglas de Message Queue Telemetry Transport y tras ellas se encuentra un protocolo ideado por IBM y liberado para que cualquiera podamos usarlo enfocado a la conectividad Machine-to-Machine (M2M).
Está enfocado al envío de datos en aplicaciones donde se requiere muy poco ancho de banda. Además, sus características le permiten presumir de tener un consumo realmente bajo así como precisar de muy pocos recursos para su funcionamiento.
Estas características han hecho que rápidamente se convierta en un protocolo muy empleado en la comunicación de sensores y, consecuentemente, dentro del Internet de las Cosas.
Es precisamente el broker el elemento encargado de gestionar la red y transmitir los mensajes.
Para este taller vamos a usar el broker público de Adafruit https://io.adafruit.com, pero pueden usarse otros como https://www.cloudmqtt.com/
Dentro de la arquitectura de MQTT, es muy importante el concepto “topic” o “tema” en español ya que a través de estos “topics” se articula la comunicación puesto que emisores y receptores deben estar subscritos a un “topic” común para poder entablar la comunicación. Este concepto es prácticamente el mismo que se emplea en colas, donde existen un publicadores (que publican o emiten información) y unos subscritores (que reciben dicha información) siempre que ambas partes estén subscritas a la misma cola.
Este tipo de arquitecturas, lleva asociada otra interesante característica: la comunicación puede ser de uno a uno o de uno a muchos.
Un “topic” se representa mediante una cadena y tiene una estructura jerárquica. Cada jerarquía se separa con ‘/’. Por ejemplo, “edificio1/planta5/sala1/raspberry2/temperatura” o “/edificio3/planta0/sala3/arduino4/ruido“. De esta forma se pueden crear jerarquías de clientes que publican y reciben datos, como podemos ver en la imagen:
De esta forma un nodo puede subscribirse a un “topic” concreto (“edificio1/planta2/sala0/arduino0/temperatura”) o a varios (“edificio1/planta2/#”).
MQTT me permite gran escalabilidad. Añadir un nuevo Arduino o un suscriptor es muy sencillo dentro de la jerarquía vista
Un cliente MQTT sencillo (y con limitaciones) para instalar en nuestro PC es MQTT Lens. Uso de MQTT lens: http://www.hivemq.com/blog/mqtt-toolbox-mqtt-lens
Como habrás imaginado, para conseguir una comunicación MQTT, emplearemos una librería. Existen muchas disponibles gracias a la gran (tanto en tamaño como en calidad) comunidad que existe alrededor de Arduino.
Una de las librerías más conocidas y la más estable y flexible es Arduino Client for MQTT http://pubsubclient.knolleary.net/ que nos provee de un sencillo cliente que nos permite tanto subscribirnos como publicar contenido usando MQTT. Internamente, usa la API de Arduino Ethernet Client lo que lo hace compatible con un gran número de shields y placas
Otras Librerías MQTT para Arduino:
- https://github.com/i-n-g-o/esp-mqtt-arduino
- http://pubsubclient.knolleary.net/
- https://github.com/adafruit/Adafruit_MQTT_Library
Ejemplo práctico
Pasos previos:
- Darse de alta en la plataforma Adafruit IO: https://io.adafruit.com una cuenta por grupo de 3 o 4 puestos, de forma que cada grupo usa un mismo broker y puedan interactuar entre ellos.
- No es necesario crear feeds puesto que se crean automáticamente al generarlos desde el programa de Arduino al suscribirse
- Instalar la librería Adafruit MQTT Library: https://github.com/adafruit/Adafruit_MQTT_Library
- Carga en Arduino el sketch: https://github.com/jecrespo/aprendiendoarduino-iot/blob/master/03-MQTT/Adafruit_MQTT_DHCP/Adafruit_MQTT_DHCP.ino
Para usar MQTT en arduino podemos usar varias librerías:
- Adafruit MQTT Library: https://github.com/adafruit/Adafruit_MQTT_Library
- Arduino client for MQTT: http://pubsubclient.knolleary.net/ , github https://github.com/knolleary/pubsubclient. Note that the library only works with networking libraries that support the Arduino Client interface.
Ejercicio propuesto:
- Para ver un ejemplo de MQTT podemos usar el broker gratuito de https://io.adafruit.com/
- Conectar un potenciómetro y un LED en el Arduino.
- Crear un feed con en nombre nodeX-pot y nodeX-led, siendo X el número del kit (no es necesario crearlo, al suscribirse se crea automáticamente)
- Crear un dashboard con el nombre nodeX, siendo X el número del kit. Configurarlo con un toggle asociado al feed de LED, un gauge asociado al feed del potenciómetro y un line chart asociado al feed del potenciómetro.
- Comprobar en el dashboard el dato del potenciómetro y encender y apagar el led con el toggle.
- Crear un trigger de forma que cuando el valor del potenciómetro sea mayor que 700 encienda el led de uno de los compañeros del mismo broker o mande un email.
- Comprobar que al pulsar el botón se enciende y apaga el led de un nodo remoto. Para ello al pulsar el botón se debe publicar en el topic nodeY-led siendo Y el número del kit dentro del mismo usuario de adafruit IO.
Información:
- MQTT y Adafruit IO: https://learn.adafruit.com/mqtt-adafruit-io-and-you
- Tutorial: https://learn.adafruit.com/adafruit-io
Repositorio: https://github.com/jecrespo/aprendiendoarduino-iot/tree/master/03-MQTT