Demo datos simulados

Creación de dispositivos IOT

Para las pruebas de la plataforma IoT, vamos a crear un dispositivo para cada protocolo (HTTP, MQTT y CoAP). Seguidamente debemos agregar al Dashboard, estos dispositivos en forma de entidades.

Figure 1. Lista de dispositivos

Se han creado los dispositivos http_device, mqtt_device y coap_device para obtener data usando los protocolos HTTP, MQTT y CoAP, respectivamente. Agregamos los dispositivos al dashboard, con su respectivo alias.

Figure 2. Agregación de alias

Despliegue de contenedores Docker para el envío de datos

Una vez creado los dispositivos en Thingsboard y haberlos agregado al dashboard. Se despliegan contenedores Docker para el envio de data, con el objetivo que la plataforma pueda reconocerla y presentarla visualmente. Para ello, desde otra máquina virtual se realiza el despliegue de tres Dockers que van a enviar data de forma continua usando los protocolos HTTP, MQTT y COAP.

Se crean tres directorios, donde estarán los archivos necesarios para el despliegue de cada uno de los contenedores Docker.

* coap:

    -entrypoint-coap.sh
    -Dockerfile
    -docker-compose.yml

* http:

    -entrypoint-http.sh
    -Dockerfile
    -docker-compose.yml

* mqtt:

    -entrypoint-mqtt.sh
    -Dockerfile
    -docker-compose.yml

Entrypoint-<protocolo>.sh

Este archivo contiene un script que genera datos de manera continua y aleatoria, para tres parámetros ambientales como Temperatura, Humedad y Presión atmosférica. Una vez generado los valores, estos son enviados usando el protocolo respectivo.

Script MQTT

El script MQTT requiere como parametros de entrada el valor base y la variacion maxima de los 3 parametros ambientales. Si estos valores no son definidos por el usuario en el archivo docker-compose.yml, se fijaran los valores por defecto. El script implementa un bucle infinito, donde en cada iteración genera tres valores aleatorios a ser enviados mediante el protocolo MQTT. La variable de entorno HOSTNAME hace referencia a la direccion IP del servidor donde se ejecuta la plataforma y la variable ACCESS_TOKEN a la clave de autorizacion requerida para el envio de los datos.

Los datos enviados corresponden a las variables Temperatura, Humedad y Presión y se realiza cada 5 segundos.

#!/bin/sh

PORT=${PORT}
TIME=${TIME}
TEMP_BASE=${TEMP_BASE}
TEMP_DELTA=${TEMP_DELTA}
HUM_BASE=${HUM_BASE}
HUM_DELTA=${HUM_DELTA}
PRESS_BASE=${PRESS_BASE}
PRESS_DELTA=${PRESS_DELTA}

if [ ! ${TIME} ]; then
	TIME=5
fi

if [ ! ${PORT} ]; then
	PORT=1883
fi

if [ ! ${TEMP_BASE} ]; then
	TEMP_BASE=22
fi

if [ ! ${TEMP_DELTA} ]; then
	TEMP_DELTA=2
fi

if [ ! ${HUM_BASE} ]; then
	HUM_BASE=70
fi

if [ ! ${HUM_DELTA} ]; then
	HUM_DELTA=4
fi

if [ ! ${PRESS_BASE} ]; then
	PRESS_BASE=995
fi

if [ ! ${PRESS_DELTA} ]; then
	PRESS_DELTA=3
fi

while [ true ]
do
        RANDOM1=$(echo "scale=2; ${TEMP_BASE} + $(($RANDOM % (${TEMP_DELTA}*100)))/100" | bc)
        RANDOM2=$(echo "scale=2; ${HUM_BASE} + $(($RANDOM % (${HUM_DELTA}*100)))/100" | bc)
        RANDOM3=$(echo "scale=2; ${PRESS_BASE} + $(($RANDOM % (${PRESS_DELTA}*100)))/100" | bc)

mosquitto_pub -d -q 1 -h "${HOST_NAME}" -p "${PORT}" -t "v1/devices/me/telemetry" -u "${ACCESS_TOKEN}" -m {"temperature":$RANDOM1}
mosquitto_pub -d -q 1 -h "${HOST_NAME}" -p "${PORT}" -t "v1/devices/me/telemetry" -u "${ACCESS_TOKEN}" -m {"humidity":$RANDOM2}
mosquitto_pub -d -q 1 -h "${HOST_NAME}" -p "${PORT}" -t "v1/devices/me/telemetry" -u "${ACCESS_TOKEN}" -m {"pressure":$RANDOM3}

sleep ${TIME}

done

Script HTTP

El script HTTP requiere como parametros de entrada el valor base y la variacion maxima de los 3 parametros ambientales. Si estos valores no son definidos por el usuario en el archivo docker-compose.yml, se fijarán los valores por defecto. El script implementa un bucle infinito, donde en cada iteración genera tres valores aleatorios a ser enviados mediante el protocolo HTTP. La variable de entorno HOST_NAME hace referencia a la direccion IP del servidor donde se ejecuta la plataforma y la variable ACCESS_TOKEN a la clave de autorizacion requerida para el envio de los datos.

Los datos enviados corresponden a las variables Temperatura, Humedad y Presión y se realiza cada 5 segundos.

#!/bin/sh

PORT=${PORT}
TIME=${TIME}
TEMP_BASE=${TEMP_BASE}
TEMP_DELTA=${TEMP_DELTA}
HUM_BASE=${HUM_BASE}
HUM_DELTA=${HUM_DELTA}
PRESS_BASE=${PRESS_BASE}
PRESS_DELTA=${PRESS_DELTA}

if [ ! ${TIME} ]; then
	TIME=5
fi

if [ ! ${PORT} ]; then
	PORT=8080
fi

if [ ! ${TEMP_BASE} ]; then
	TEMP_BASE=22
fi

if [ ! ${TEMP_DELTA} ]; then
	TEMP_DELTA=2
fi

if [ ! ${HUM_BASE} ]; then
	HUM_BASE=70
fi

if [ ! ${HUM_DELTA} ]; then
	HUM_DELTA=4
fi

if [ ! ${PRESS_BASE} ]; then
	PRESS_BASE=995
fi

if [ ! ${PRESS_DELTA} ]; then
	PRESS_DELTA=3
fi


while [ true ]
do
        RANDOM1=$(echo "scale=2; ${TEMP_BASE} + $(($RANDOM % (${TEMP_DELTA}*100)))/100" | bc)
        RANDOM2=$(echo "scale=2; ${HUM_BASE} + $(($RANDOM % (${HUM_DELTA}*100)))/100" | bc)
        RANDOM3=$(echo "scale=2; ${PRESS_BASE} + $(($RANDOM % (${PRESS_DELTA}*100)))/100" | bc)

	curl -v -X POST -d "{\"temperature\": $RANDOM1, \"humidity\": $RANDOM2, \"pressure\": $RANDOM3}" http://${HOST_NAME}:${PORT}/api/v1/${ACCESS_TOKEN}/telemetry --header "Content-Type:application/json"

sleep ${TIME}

done

Script COAP

El script implementa un bucle infinito, donde en cada iteracion genera tres valores aleatorios a ser enviados mediante el protocolo COAP. La variable de entorno HOSTNAME hace referencia a la direccion IP del servidor donde se ejecuta la plataforma y la variable ACCESS_TOKEN a la clave de autorizacion requerida para el envio de los datos.

Los datos enviados corresponden a las variables Temperatura, Humedad y Presión y se realiza cada 5 segundos.

#!/bin/sh

PORT=${PORT}
TIME=${TIME}
TEMP_BASE=${TEMP_BASE}
TEMP_DELTA=${TEMP_DELTA}
HUM_BASE=${HUM_BASE}
HUM_DELTA=${HUM_DELTA}
PRESS_BASE=${PRESS_BASE}
PRESS_DELTA=${PRESS_DELTA}

if [ ! ${TIME} ]; then
	TIME=5
fi

if [ ! ${PORT} ]; then
	PORT=5683
fi

if [ ! ${TEMP_BASE} ]; then
	TEMP_BASE=22
fi

if [ ! ${TEMP_DELTA} ]; then
	TEMP_DELTA=2
fi

if [ ! ${HUM_BASE} ]; then
	HUM_BASE=70
fi

if [ ! ${HUM_DELTA} ]; then
	HUM_DELTA=4
fi

if [ ! ${PRESS_BASE} ]; then
	PRESS_BASE=995
fi

if [ ! ${PRESS_DELTA} ]; then
	PRESS_DELTA=3
fi

while [ true ]
do
	RANDOM1=$(echo "scale=2; ${TEMP_BASE} + $(($RANDOM % (${TEMP_DELTA}*100)))/100" | bc)
	RANDOM2=$(echo "scale=2; ${HUM_BASE} + $(($RANDOM % (${HUM_DELTA}*100)))/100" | bc)
	RANDOM3=$(echo "scale=2; ${PRESS_BASE} + $(($RANDOM % (${PRESS_DELTA}*100)))/100" | bc)

echo -n "{'temperature': $RANDOM1,'humidity': $RANDOM2, 'pressure': $RANDOM3}" | coap post coap://${HOST_NAME}:${PORT}/api/v1/${ACCESS_TOKEN}/telemetry

sleep ${TIME}

done

Dockerfile

Este archivo contiene las instrucciones que se ejecutan al crear una imagen en Docker. Para nuestro caso, vamos a indicarle cual es el sistema operativo del contenedor, los paquetes necesarios para la ejecución de los scripts mostrados y su ejecución.

Dockerfile MQTT

FROM alpine:latest

COPY entrypoint-mqtt.sh .
RUN apk update && apk add mosquitto-clients
RUN chmod +x /entrypoint-mqtt.sh

ENTRYPOINT [ "/entrypoint-mqtt.sh" ]

Dockerfile HTTP

FROM alpine:latest

COPY entrypoint-http.sh .
RUN apk update && apk add curl
RUN chmod +x /entrypoint-http.sh

ENTRYPOINT [ "/entrypoint-http.sh" ]

Dockerfile COAP

FROM alpine:latest

COPY entrypoint-coap.sh .
RUN apk update && apk add npm && npm install coap-cli -g
RUN chmod +x /entrypoint-coap.sh

ENTRYPOINT [ "/entrypoint-coap.sh" ]

Docker-compose.yml

Docker Compose es una herramienta para definir y ejecutar aplicaciones Docker de varios contenedores. Esta herramienta usa el formato de serialización YAML para configurar los servicios del contenedor. Luego, con un solo comando, crea e inicia todos los servicios desde su configuración. En esta sección, vamos a crear tres docker-compose.yml, uno para cada protocolo. En ellos, se especifica la creación de una imagen usando el Dockerfile y la implementación de un contenedor en base a esa imagen. Este contenedor es el que enviará la data de manera constante al servidor Thingsboard. Adicionalmente en los archivos con extensión (YML) se definen los parametros (Valores Base, valores delta, HOST_NAME , ACCESS_TOKEN, tiempo en segundos , número de puerto) requeridos por los scripts.

Docker-compose MQTT

version: '2.2'

services:
  tb-mqtt:
    restart: always
    build:
      context: .
      dockerfile: Dockerfile
    image: mqtt-device
    environment:
      - HOST_NAME=192.168.27.51
      - ACCESS_TOKEN=qvJ8KUsAxwOEF8xp6mCn
      - PORT=2883
      - TIME=3
      - TEMP_BASE=22
      - TEMP_DELTA=3
      - HUM_BASE=70
      - HUM_DELTA=4
      - PRESS_BASE=1103
      - PRESS_DELTA=4

Docker-compose HTTP

version: '2.2'

services:
  tb-http:
    restart: always
    build:
      context: .
      dockerfile: Dockerfile
    image: http-device
    environment:
      - HOST_NAME=192.168.27.51
      - ACCESS_TOKEN=lalg1SuKEK1lDhBjobLB
      - PORT=9090
      - TIME=10
      - TEMP_BASE=22
      - TEMP_DELTA=3
      - HUM_BASE=70
      - HUM_DELTA=4
      - PRESS_BASE=1103
      - PRESS_DELTA=4

Docker-compose COAP

version: '2.2'

services:
  tb-coap:
    restart: always
    build:
      context: .
      dockerfile: Dockerfile
    image: coap-device
    environment:
      - HOST_NAME=192.168.27.51
      - ACCESS_TOKEN=xV1bBks73vXiMXURkmC6
      - PORT=5683
      - TIME=3
      - TEMP_BASE=22
      - TEMP_DELTA=3
      - HUM_BASE=70
      - HUM_DELTA=4
      - PRESS_BASE=1103
      - PRESS_DELTA=4

Despliegue de dispositivos Producers

Para el despliegue de los dispositivos que enviaran data hacia thingsboard, usaremos la herramienta docker-compose. Docker-compose usando el archivo docker-compose.yml creara una imagen y un respectivo contenedor, esto lo logra usando el archivo Dockerfile, que especifica la imagen a crear. Dentro de Dockerfile también vemos que se hace uso del script entrypoint, que tiene los pasos a seguir para hacer uso de las distintas herramientas que enviaran data usando los protocolos HTTP, MQTT y CoAP.

Entramos a la terminal y ejecutamos docker-compose. Para el correcto funcionamiento, debemos de especificar las variables de entorno HOST_NAME y ACCESS_TOKEN. HOST_NAME, es la dirección del servidor thingsboard, y ACCESS_TOKEN especifica al dispositivo en thingsboard al cual le va a llegar los datos, esta información la podemos obtener desde la misma plataforma thingsboard como vimos en la sección 2.

Figure 3. Despliegue de los dispostivos IOT docker

De la imagen podemos visualizar lo siguiente:

Al usar docker-compose, se crea una red especifica para el despliegue de los contenedores, no se usa la red por defecto de docker, la cual esta anexada al bridge docker0.
Inicia la creación del servicio tb_coap, esto a partir de la información del Dockerfile.
En este paso se visualiza los pasos que está siguiendo la creación de la imagen, desde usar la imagen Alpine, copiar el ejecutable entrypoint, instalar los paquetes necesarios, darle permisos de ejecución a entrypoint, y finalmente ejecutar el script.
Se termina de crear la imagen con su respectivo identificador.
Se genera una etiqueta para la imagen creada. Esta se etiqueta como coap-device:latest.
La alerta WARNING, indica que se creado una imagen para el servicio tb_coap especificado en docker-compose, dado que esta imagen no existía anteriormente. Para futuros despliegues con docker-compose, no se creará esta imagen dado que ya se encuentra creada. Y se finaliza el proceso con la creación del contenedor coap_tb-coap_1.

Este proceso se sigue para los contenedores con HTTP y MQTT.

Visualización de los datos

Una vez que se tienen los producers enviando información a thingsboard, podemos agregar widgets para la visualización respectiva en el dashboard.Entramos al dashboard en thingsboard y seguimos los pasos vistos en la sección 3. En este caso vamos a crear 3 “Timeseries –Flot” por parámetro (Temperatura, Humedad y Presión atmosférica). Cada chart va a recibir información de los 3 protocolos.

Figure 4. Creación de widget "Timseries-Flot"

Lo mismo haremos para los demás parámetros como Humedad y Presión.Agregamos chart y visualizamos funcionamiento

Figure 5. Dashboard con valores simulados

Puede descargar el Dashboard desde el siguiente enlace: Simulación_ThingsBoard_Random.json