Contenido


Construya un sensor de temperatura listo para la nube con Arduino Uno y la Fundación IBM IoT, Parte 2

Escriba el sketch y conéctese a la Fundación IBM IoT Quickstart

Comments

Contenido de la serie:

Este contenido es la parte # de # de la serie: Construya un sensor de temperatura listo para la nube con Arduino Uno y la Fundación IBM IoT, Parte 2

Manténgase en contacto por contenidos adicionales de esta serie.

Este contenido es parte de la serie:Construya un sensor de temperatura listo para la nube con Arduino Uno y la Fundación IBM IoT, Parte 2

Manténgase en contacto por contenidos adicionales de esta serie.

En la Parte 1 de esta serie de tutoriales de cuatro partes analicé el diseño de un proyecto para monitorear las temperaturas en mi clóset de cableado, construido utilizando Arduino Uno y el sensor de temperatura Virtuabotix DHT11. Mostré la construcción del circuito para el proyecto y le mostré los pasos sobre cómo realizar la instalación del IDE Arduino y la forma de probar cada uno de los componentes individuales del proyecto con diferentes sketches muestra de Arduino. Ahora ya está listo para ver el diseño del sketch que vincula el proyecto IoT a la nube y los pasos para permitir el monitoreo de la temperatura en tiempo real y los datos de la humedad a control remoto. Sin embargo, primero necesito analizar el protocolo que usará para comunicarse con la Fundación IBM IoT: MQTT.

¿Qué es MQTT?

MQTT (anteriormente Message Queueing Telemetry Transport) es un protocolo de comunicaciones ligero y rápido diseñado para Internet of Things. Tiene sus orígenes en IBM (donde se desarrolló originalmente por Andy Stanford-Clark) y desde entonces se envió a Organization for the Advancement of Structured Information Standards (OASIS) para la estandarización donde la versión actual de la norma del protocolo es la versión 3.1. La especificación MQTT V3.1 Protocol Specification establece que su propósito es ser un protocolo de mensajes de publicación/subscripción basado en un broker ligero, diseñado para ser abierto, simple, ligero y fácil de implementar”. En el tiempo desde su introducción, la parte "fácil de implementar” ciertamente ha comprobado ser cierta, dado que se han desarrollado varias bibliotecas diferentes implementando clientes MQTT. Usted puede encontrar vínculos a casi todos ellos en la página del proyecto Eclipse Paho.

MQTT es perfecto para su uso en los dispositivos integrados porque:

  • Es asíncrono con diferentes niveles múltiples de calidad del servicio, lo que resulta ser importante en los casos donde las conexiones de Internet son poco confiables.
  • Envía mensajes cortos y estrechos que se vuelven adecuados para las situaciones de un bajo ancho de banda.
  • No se requiere de mucho software para implementar a un cliente, lo cual lo vuelve fantástico para los dispositivos como Arduino con una memoria limitada.

MQTT es el protocolo en el que la Fundación IBM IoT QuickStart está diseñado para tomar su información.

Descargando e instalando las bibliotecas Arduino MQTT

En este tutorial, usará las características integradas de la Fundación IBM Internet of Things Quickstart para graficar los datos tiempo real del sensor Arduino.

Es tan sencillo instalar las bibliotecas del cliente de MQTT para Arduino como lo es encontrar e instalar las bibliotecas que ya ha visto en la Parte 1 para los dispositivos de hardware específicos. La biblioteca particular que se usará para sus proyectos puede encontrarse en el sitio de web Arduino Client para MQTT, que describe la biblioteca, se vincula a la documentación y provee otro vínculo a GitHub donde puede descargarlo.

En mi ejemplo usé el cliente V1.9.1 del vínculo GitHub. Descargue el archivo ZIP o TAR y después extraiga el directorio PubSubClient del archivo al subdirectorio de las bibliotecas de su directorio Arduino IDE. Después reinicie el IDE de Arduino. Las opciones de menú PubSubClient>mqtt_auth, PubSubClient>mqtt_basic y PubSubClient>mqtt_publish_in_callback deberán estar disponibles ahora, como se muestra en la Figura 1.

Figura 1. Menú PubSubClient
Screenshot of the PubSubClient menu options
Screenshot of the PubSubClient menu options

Probando MQTT localmente

El proceso que ha venido siguiendo hasta ahora en esta serie de tutoriales es el de introducir un nuevo componente o tecnología en la solución y después probarlo independientemente para asegurar que está funcionando correctamente. Ahora que ha descargado e instalado el software del cliente MQTT, hará lo mismo para el mismo. Sin embargo, seguirá necesitando una pieza adicional de software para probar a su cliente.

MQTT es un protocolo basado en el broker: Los clientes se conectan a un broker que media la comunicación entre ellos. De hecho, es un simple proceso. Un conjunto de clientes registran su interés sobre el tópico con el broker. Cuando otro cliente publica un mensaje sobre ese tópico, el broker le envía el mensaje a los clientes que se suscriben.

El broker que usará para la prueba local es otra contribución de código abierto denominado Mosquitto. Puede instalarlo en la PC local que está usando para programar Arduino y después probar que Arduino puede comunicarse con el broker.

Mosquitto

Puede descargar Mosquitto del sitio de web Mosquitto. Está disponible para Windows®, Mac y la mayoría de los variantes de Linux®. La instalación es simple: Para Linux, simplemente se trata de instalar un nuevo paquete; para Windows, puede instalar el sistema ya sea como un servicio Windows o un ejecutable independiente. Si está usando Windows, asegúrese de poner una marca en el cuadro para instalarlo como un servicio. Es más fácil correrlo desde la línea de comando porque puede ver más fácilmente la información de depuración tal y como está registrada.

Después de instalar Mosquitto, inícielo desde la línea de comando (en cualquier plataforma) operando el comando:

 mosquitto -v

El indicador -v es para el registro tipo "verbose", lo cual significa que puede ver la información sobre las conexiones que se están haciendo y los mensajes que se reciben o envían. Verá ese resultado en un minuto al momento de empezar a enviar mensajes al corredor local.

Descargando el sketch muestra

El siguiente paso es descargar el sketch de la muestra que une todas las piezas (consulte Download). Usted publicará un mensaje a través de MQTT a un broker MQTT (primero a su broker local y después al broker que forma parte de IoT Foundation QuickStart). Para que IoT Foundation QuickStart eventualmente analice y despliegue los datos del sensor deberá publicarlos a un tópico designado iot-2/evt/status/fmt/json. De la misma forma, deberá formatear los datos en una forma específica también. Si mira a la documentación de la receta de la Fundación IoT QuickStart para "Connect my device to QuickStart", verá que los datos deberán estar en el siguiente formato de JavaScript Object Notation (JSON):

 { "d": { "name1": "stringvalue", "name2": intvalue, ... } }

El sketch muestra es un programa simple. Desde las otras muestras de Arduino que les indiqué en la Parte 1, puede ver que todos los programas Arduino tienen la misma estructura. Incluyen un conjunto estándar de funciones denominadas setup() y loop(), junto con algunas declaraciones variables opcionales y las declaraciones de cualesquiera funciones de utilitarios que puede usar en cualesquiera de sus funciones setup() o loop(). Primero, verá el inicio del código para hacer unos cuantos cambios a algunas de aquellas declaraciones variables para que pueda probar el programa localmente.

Cambios al sketch muestra

Al igual que con cualesquiera otros sketches de Arduino , el programa principal contiene referencias a las bibliotecas que se ven en el sketch:

 #include <SPI.h> #include <Ethernet.h> #include <PubSubClient.h> #include <dht11.h>

Como podrá verlo, el sketch usa las bibliotecas Ethernet para impulsar el shield Ethernet y las bibliotecas DHT11 para el acceso a las lecturas de DHT11 — al igual que los ejemplos que vio en la Parte 1. Sin embargo, también estará usando las bibliotecas PubSubClient por primera vez. Para poder aprovechar las ventajas de esto, se requiere hacer un par de cambios al código para probarlos contra el servidor local:

 // Update this to either the MAC address found on the sticker on your Ethernet shield (newer shields) // or a different random hexadecimal value (change at least the last four bytes) byte mac[] = {0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED }; char macstr[] = "deedbafefeed"; // Note this next value is only used if you intend to test against a local MQTT server byte localserver[] = {192, 168, 1, 98 }; // Update this value to an appropriate open IP on your local network byte ip[] = {192, 168, 1, 20 };

Como lo dice el primer comentario, el primer cambio que necesita hacer es actualizar las variables mac y macstr para igualar la dirección MAC de su shield Ethernet. Los shields más novedosos de Ethernet lo tienen impreso en una calcomanía en la tarjeta. Si está usando una tarjeta más antigua, sólo cambie los últimos cuatro caracteres hexadecimales al azar a otros valores hexadecimales válidos y estará bien. Después, cambie la variable ip para que sea una dirección abierta de IP en su red local. Las bibliotecas Ethernet son capaces de usar DHCP, y pueden buscar la forma de hacerlo si está interesado, pero es más simple usar direcciones fijas de IP cuando sea posible. Posteriormente, actualice la variable localserver a la dirección de IP de la computadora en la que está usando el servidor Mosquitto. Finalmente, actualizará el sketch para conectarlo a su servidor MQTT local en lugar del servidor de la Fundación IBM IoT QuickStart.

Ubique esta sección del código:

 // Uncomment this next line and comment out the line after it to test against a local MQTT server //PubSubClient client(localserver, 1883, 0, ethClient); PubSubClient client(servername, 1883, callback, ethClient);

No comente la línea que contiene el constructor que empieza con client(localserver y comente la línea que está abajo del mismo que inicia con client(servername. Después guarde el sketch.

Ahora que ya hizo los cambios necesarios, echará un vistazo rápido al resto de este programa simple. En medio de los dos snippets ya ha visto que viene con un conjunto de declaraciones variables:

 char servername[]="messaging.quickstart.internetofthings.ibmcloud.com"; String clientName = String("d:quickstart:arduino:") + macstr; String topicName = String("iot-2/evt/status/fmt/json"); dht11 DHT11; float tempF = 0.0; float tempC = 0.0; float humidity = 0.0; EthernetClient ethClient;

Como podrá ver, hay variables para la temperatura en Fahrenheit y centígrados y para la humedad. También hay una variable que contendrá la instancia del cliente Ethernet que usará el cliente PubSub.

Después viene la definición de la función setup():

 void setup() { // Start the Ethernet client, open up serial port for debugging, and attach the DHT11 sensor Ethernet.begin(mac, ip); Serial.begin(9600); DHT11.attach(3); }

Esta función es bastante simple; empieza con el cliente Ethernet con la dirección MAC suministrada y la dirección estática de IP en la que correrá el cliente. Después arranca el puerto serial (para la comunicación al Monitor Serial para propósitos de depuración) y finalmente abre la comunicación con DHT11 en el pin 3.

La siguiente función por examinar es loop(), que se llama continuamente siempre y cuando Arduino esté en operación:

 void loop() { char clientStr[34]; clientName.toCharArray(clientStr,34); char topicStr[26]; topicName.toCharArray(topicStr,26); getData(); if (!client.connected()) { Serial.print("Trying to connect to: "); Serial.println(clientStr); client.connect(clientStr); } if (client.connected() ) { String json = buildJson(); char jsonStr[200]; json.toCharArray(jsonStr,200); boolean pubresult = client.publish(topicStr,jsonStr); Serial.print("attempt to send "); Serial.println(jsonStr); Serial.print("to "); Serial.println(topicStr); if (pubresult) Serial.println("successfully sent"); else Serial.println("unsuccessfully sent"); } delay(5000); }

Como podrá verlo, gran parte de esta función está dedicada a producir un resultado de depuración. Sin embargo, hay unos cuantos elementos centrales por notar. Cerca de la parte superior de la llamada a la función getData() (que examinará después) que obtiene los datos del sensor del DHT11. La función loop() entonces verifica si el cliente PubSubClient está conectado. Si no está conectado, la función loop() se trata de conectar al broker MQTT. Si está conectado, entonces la función loop() formatea una cadena JSON usando buildJson() y después publica eso al broker MQTT usando el método publish() de PubSubClient. Finalmente, loop() espera 5,000 ms en la parte inferior de la función antes de que el tiempo de ejecución de Arduino vuelve a girar en torno a esto y vuelve a llamar la función.

Posteriormente, vea la función getData():

 void getData() { int chk = DHT11.read(); switch (chk) { case 0: Serial.println("Read OK"); humidity = (float)DHT11.humidity; tempF = DHT11.fahrenheit(); tempC = DHT11.temperature; break; case -1: Serial.println("Checksum error"); break; case -2: Serial.println("Time out error"); break; default: Serial.println("Unknown error"); break; } }

Esta función simplemente verifica el estatus de los datos de la biblioteca DHT11, entonces lee los valores de datos de los sensores si está listo; de otra forma imprime un mensaje de información en la consola.

Finalmente, vea la función que formatea el resultado JSON:

 String buildJson() { String data = "{"; data+="\n"; data+= "\"d\": {"; data+="\n"; data+="\"myName\": \"Arduino DHT11\","; data+="\n"; data+="\"temperature (F)\": "; data+=(int)tempF; data+= ","; data+="\n"; data+="\"temperature (C)\": "; data+=(int)tempC; data+= ","; data+="\n"; data+="\"humidity\": "; data+=(int)humidity; data+="\n"; data+="}"; data+="\n"; data+="}"; return data; }

Una de las debilidades de Processing tal y como se implementan en Arduino es la falta de buenas instalaciones para el procesamiento de la cadena. Pudo haber notado algunas de las extrañas conversiones que se tuvieron que hacer entre las instancias de la clase String y el tipo de cadena para llamar las funciones esperando una o la otra. De la misma forma, el formatear incluso una cadena JSON simple como ésta puede ser desafiante en virtud de la falta de una buena biblioteca de formateo de cadena — aunque existen dichas funciones para formatear los resultados a la consola.

Probando contra un broker local de Mosquitto

Bien, ya casi estamos allí con la primera parte. Ahora, suba la información del sketch modificado a Arduino siguiendo los procedimientos para subir la información que se analizan en la Parte 1. Tan pronto como se ve el estatus "Done uploading" en la línea de estatus del IDE Arduino, abra el Monitor Serial oprimiendo Ctrl-Shift-M.

Validando sus resultados

Ahora, asumiendo que todo ha salido bien, deberá ver el siguiente tipo de resultados en la ventana de la terminal donde se inició Mosquitto:

 1405807697: mosquitto version 1.2.3 (build date 22/12/2013 13:36:32.54) starting 1405807697: Using default config. 1405807697: Opening ipv6 listen socket on port 1883. 1405807697: Opening ipv4 listen socket on port 1883. 1405807718: New connection from 192.168.1.20 on port 1883. 1405807718: New client connected from 192.168.1.20 as d:quickstart:arduino:deedb afefeed (c2, k15). 1405807718: Sending CONNACK to d:quickstart:arduino:deedbafefeed (0) 1405807718: Received PUBLISH from d:quickstart:arduino:deedbafefeed (d0, q0, r0, m0, 'iot-2/evt/status/fmt/json', ... (100 bytes)) 1405807723: Socket error on client d:quickstart:arduino:deedbafefeed, disconnect ing. 1405807723: New connection from 192.168.1.20 on port 1883. 1405807723: New client connected from 192.168.1.20 as d:quickstart:arduino:deedb afefeed (c2, k15). 1405807723: Sending CONNACK to d:quickstart:arduino:deedbafefeed (0) 1405807723: Received PUBLISH from d:quickstart:arduino:deedbafefeed (d0, q0, r0, m0, 'iot-2/evt/status/fmt/json', ... (100 bytes)) 1405807729: Received PUBLISH from d:quickstart:arduino:deedbafefeed (d0, q0, r0, m0, 'iot-2/evt/status/fmt/json', ... (100 bytes)) 1405807734: Received PUBLISH from d:quickstart:arduino:deedbafefeed (d0, q0, r0, m0, 'iot-2/evt/status/fmt/json', ... (100 bytes))

La clave para saber que se están haciendo las cosas bien es que verá las últimas cuantas líneas para saber sobre Received PUBLISH from.... Eso significa que el sketch Arduino se está conectando exitosamente al broker Mosquitto. Ahora, eche un vistazo al Monitor Serial; deberá contener mensajes como los siguientes:

 Read OK Trying to connect to d:quickstart:arduino:deedbafefeed attempt to send { "d": { "myName": "Arduino DHT11", "temperature (F)": 71, "temperature (C)": 22, "humidity": 43 } } to iot-2/evt/status/fmt/json successfully sent

Conectándose a la Fundación IoT Quickstart de Arduino

Bien, ahora que las cosas están funcionando localmente, está listo para probar esto contra la Fundación IoT QuickStart. En su navegador, visite el sitio de web de la Fundación IBM Internet of Things, que se muestra en la Figura 2.

Figura 2. Página principal de la Fundación IBM IoT

Haga clic en el botón que dice Pruébelo con nuestro Quickstart. Verá la página que se muestra en la Figura 3.

Figura 3. Página de bienvenida de la Fundación IBM IoT Quickstart

En este tutorial, usará las funciones integradas de la Fundación IoT Quickstart para graficar los datos en tiempo real del sensor Arduino. En la Parte 3 y Parte 4, escribirá una aplicación para hacer algo más interesante con los datos que reciba.

La Fundación IoT tiene varias recetas básicas para otros dispositivos. Si tiene un dispositivo más sofisticado tal como Intel Galileo o Raspberry Pi, querrá probar estas recetas. Por ahora, simplemente escriba la dirección MAC de su Arduino. Pero antes de hacer clic en Go, hay que hacer un cambio más al sketch.

Cambiando el sketch

¿Recuerda hace apenas unas cuantas instrucciones cuando cambió el sketch para apuntar al servidor MQTT local en lugar del servidor MQTT en la Fundación IoT? Ahora que ya está listo para volverlo a cambiar. Comente y no comente las líneas que regresó al código original:

 // Uncomment this next line and comment out the line after it to test against a local MQTT server //PubSubClient client(localserver, 1883, 0, ethClient); PubSubClient client(servername, 1883, callback, ethClient);

Después de hacer este cambio, guarde el sketch y súbalo a Arduino. Si quiere reiniciar el Monitor Serial, puede hacerlo, pero la verdadera prueba será lo que ve en la Fundación IoT. Regrese a su navegador, haga clic en el botón Go en la página de la dirección de Mac y espere unos cuantos minutos.

Graficando los datos

Si las cosas han funcionado, deberá ver una página que despliegue una gráfica de sus lecturas de temperatura, como la que se muestra en la Figura 4.

Figura 4. Datos graficados

¡Lo ha logrado! Ahora tiene un dispositivo que construyó que forma parte del IOT global. Para mi caso particular simple, esto es todo lo que yo necesitaba: una gráfica que podía ver durante unas cuantas horas para revisar la temperatura dentro de mi clóset de cableado. Las malas noticias es que incluso a medio día en un día caluroso, la temperatura nunca subió a más de 73°F (22.7° C), así que estoy de nuevo en mi tablero de dibujo descifrando mi problema. Pero su trabajo sobre cómo aprovechar el IoT apenas está iniciando.

¿Qué sigue?

En los dos tutoriales siguientes en esta serie (Parte 3 y Parte 4), escribirá su propia aplicación — que corre IBM®Cloud™— que pueda contener los datos enviados desde su Arduino y permitir el despliegue y la comparación de los datos actuales contra los datos históricos.


Recursos para Descargar


Temas relacionados


Comentarios

Inicie Sesión o Regístrese para agregar comentarios.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=90
Zone=Internet of Things
ArticleID=1002294
ArticleTitle=Construya un sensor de temperatura listo para la nube con Arduino Uno y la Fundación IBM IoT, Parte 2: Escriba el sketch y conéctese a la Fundación IBM IoT Quickstart
publish-date=09162014