En este post veremos cómo conectar una «cosa» al Internet de las Cosas, utilizando Ultralight 2.0 sobre HTTP utilizando FIWARE
Para ello vamos a utilizar una placa Intel Edison, y le añadiremos un sensor de temperatura. Por lo tanto, nuestra «cosa» será un termómetro, y mandaremos la información utilizando el protocolo Ultralight 2.0, desarrollado por Telefónica. Además configuraremos todo esto para que utilice FIWARE.
Por tanto, necesitaremos:

• Placa Intel Edison y sensor de temperatura
• Instancia en cloud, o servidor con acceso por SSH
• Intel XDK o algún IDE similar para programar nuestra «cosa»
• FIWARE Generic Enablers: Orion Context Broker, IoT Agent Ultra Light 2.0

El primer paso será configurar una instancia a la que poder conectarnos, y configurarla apropiadamente. Teniendo acceso a un cloud, podemos lanzar una instancia de Ubuntu 14.04 y acceder por ssh. Seguidamente, tendremos que instalar Docker y Docker-Compose, para a continuación configurar nuestro archivo de docker-compose, el cual tendrá la siguiente forma:
[codeblocks name=’Uno’]
Ahora, para dejar los servicios levantados, tendremos que ejecutar el siguiente comando: [fusion_code]c3VkbyBkb2NrZXIgY29tcG9zZSB1cCAtZA==[/fusion_code]
Y después, comprobaremos que los servicios han sido correctamente inicializados utilizando el comando [fusion_code]c3VkbyBkb2NrZXIgcHM=[/fusion_code]
El siguiente paso será configurar el IoT Agent para que se comunique con Orion Context Broker. Para ello vamos a hacer lo siguiente:

• Extraer el fichero de configuración del IoT Agent (docker) al directorio home de nuestra instancia (maquina host)
• Modificar los parámetros
• Volver a introducir el fichero dentro del docker IoTAgent
• Reiniciar el IoT Agent

Para copiar el fichero de configuración, ejecutaremos el siguiente comando
[fusion_code]c3VkbyBkb2NrZXIgY3AgY3JlYXRpb25fdWwyXzE6L29wdC9pb3RhdWwvY29uZmlnLWJsYW5rLmpzIH4v[/fusion_code]
Vamos a configurar ahora nuestro IoT Agent para que funcione por HTTP, por lo tanto, todo lo relativo a MQTT lo dejaremos para más adelante.
[codeblocks name=’Dos’]
Lo más importante de este archivo, es especificar las cabeceras «service» y «subservice» que vamos a utilizar, el tipo de entidad que vamos a comunicar (en este caso «Thing«) y una URL y puerto donde se puedan comunicar Orion Context Broker y el IoT Agent. En este caso, la IP privada de la máquina y el puerto del IoT Agent es suficiente. Si ponemos localhost tendremos problemas de comunicación, ya que el docker container es una máquina virtual con su propia interfaz de red, y no conseguiremos comunicarnos si utilizamos esta palabra reservada ó 127.0.0.1.
Ahora copiaremos el fichero que hemos modificado y sustituiremos el fichero que estaba en el IoTAgent, para después reiniciar el servicio y que recargue dicha configuración. Para ello ejecutaremos los siguientes comandos:
[fusion_code]c3VkbyBkb2NrZXIgY3Agfi9jb25maWctYmxhbmsuanMgY3JlYXRpb25fdWwyXzE6L29wdC9pb3RhdWwvICZhbXA7JmFtcDsgc3VkbyBkb2NrZXIgcmVzdGFydCBjcmVhdGlvbl91bDJfMQ==[/fusion_code]
Ya tenemos nuestra arquitectura Cloud, así que hecho esto ya podemos pasar a utilizar nuestra Intel Edison. Utilizaremos el IDE que provee Intel, Intel XDK, para elaborar el código en Node.js y subirlo a la placa. Los pasos que ahora haremos serán los siguientes:

• Conectar la placa
• Configurarla para trabajar en la misma red
• Conectar los sensores
• Cargarle el código
• Dejar la placa enviando datos

La Intel Edison trae dos USBs, uno para la transmisión de datos y configuración y otro para alimentación. Conectamos ambos a nuestro equipo, y en el caso de Mac o Linux no hará falta instalar ningún driver. En el caso de Windows habrá que instalar los drivers específicos.
Una vez hecho esto y con la placa conectada a nuestro equipo, abrimos un terminal e introducimos el comando
[fusion_code]c2NyZWVuIC9kZXYvdHR5LnVzYnNlcmlhbC1BOTAzT1I0SyAxMTUyMDAgLUw=[/fusion_code]
Nos pedirá que introduzcamos usuario y contraseña. En el primer uso, será usuario root y sin contraseña. Una vez hayamos entrado en la placa, la configuraremos, y utilizaremos el comando
[fusion_code]Y29uZmlndXJlX2VkaXNvbiAtLXNldHVw[/fusion_code]
De manera que le asignaremos un nombre al dispositivo, una contraseña para el usuario root, y la conectaremos al mismo WiFi donde está conectado nuestro equipo.
A continuación, vamos a utilizar una pantalla LCD y un sensor de temperatura para mostrar la temperatura recogida por el sensor, y enviarla a través de internet a nuestro Orion Context Broker en el cloud. Para ello conectamos el shield de Arduino a nuestra Intel, y sobre el shield conectaremos el sensor de temperatura a una de las entradas analógicas, y la pantalla a una de las entradas I2C. de manera que quedaría conectada como en la siguiente imagen:

Ahora es el momento de introducir el código a la placa. Para ello abriremos el Intel XDK y le cargaremos el código, que iremos explicando.
[codeblocks name=’Tres’]
En este código se comienza llamando a la función useLcd(), que escribirá en la parte superior un mensaje y dará paso a las funciones rotateColors(display), waiting2(display) y uploadData(). La función de rotateColors simplemente irá cambiando el color de la pantalla, mientras que la función waiting2 leerá el sensor de temperatura y escribirá su valor en el display convertido a Celsius cada segundo, y llamará a la función uploadData. Por último, la función uploadData es la que comunicará nuestra «cosa» con la nube mediante el protocolo Ultralight 2.0 utilizando HTTP.
Podemos ver en la consola del IntelXDK cómo se van subiendo los datos si ejecutamos el código:

Además, ahora podemos comprobar que los datos se están recogiendo adecuadamente en Orion Context Broker si realizamos una petición REST a su API.

Por último, podemos crear un dashboard para visualizar los datos de Ultralight 2.0 en tiempo real de una manera muy fácil gracias a freeboard.io

Con una cuenta creada en freeboard.io, añadiremos lo primero la fuente de datos, donde tendremos que ir introduciendo los datos, como Fiware-Service, Fiware-Subservice, Host:Port, etc.

A continuación añadiremos un panel. Posteriormente añadiremos un widget del tipo Gauge, linkando la fuente de datos que acabamos de introducir al valor del gráfico. En este caso quedaría así:

Una vez guardemos, podremos visualizar nuestro gráfico y cómo va cambiando cada segundo

Todo este proceso lo podéis encontrar en nuestro canal de YouTube. Os dejamos aquí el video:
[fusion_youtube id=»https://www.youtube.com/edit?o=U&video_id=Flpnk8zA2vw» width=»» height=»» autoplay=»false» api_params=»» hide_on_mobile=»small-visibility,large-visibility» class=»»][/fusion_youtube]
Hasta aquí el post de cómo conectar una «cosa» al Internet de las Cosas utilizando FIWARE y el protocolo Ultralight2.0 sobre HTTP.
¡No os perdáis el siguiente post, donde hablaremos de como comunicarnos por MQTT en lugar de HTTP!