A continuación se mostrará como realizar los Callbacks hacia diferentes plataformas, es decir, mandar la información hacia una plataforma específica para presentar la información enviada por el Devkit de manera mas intuitiva y facil de entender. Para entender mas sobre los callbacks ir al siguiente link: Callback
El mas facil de los Callbacks es hacia un correo o conjunto de correos. Cada vez que llegue al backend un mensaje de nuestro dispositivo, se enviara un mensaje a los correos configurados. Para realizar el callback, damos click en el device type de nuestro dispositivo
en la columna del lado izquierdo damos click en "Callbacks"
enseguida, en la parte superior derecha, daremos click en "NEW" y de las diferentes opciones de callbacks, seleccionaremos "Custom Callback"
Configuramos el callback de la siguiente manera
Damos click en OK. Con eso nuestro Callback esta hecho. La proxima vez que mandemos un mensaje de nuestro devkit, nos llegara un correo con el "Subject" que nosotros elegimos asi como la informacion que recibimos.
Para esta parte utilizaremos el ejemplo del sensor de temperatura anterior.
Ahora que el backend está recibiendo los mensajes del Devkit, procederemos a visualizar los datos en Losant, plataforma dedicada al internet de las cosas en donde se pueden visualizar y analizar datos provenientes de dispositivos IoT, además es facil de usar ya que se configura por medio de diagramas de flujo.
Comenzaremos por crear una cuenta gratuita. Ésta nos permite registrar hasta 100 dispositivos y enviar hasta 1M de payloads. Una vez hecha la cuenta crearemos una nueva aplicación.
EL nombre de la aplicación puede ser cualquiera, pero de manera que sea facil de reconocer. Enseguida daremos click en 'Create Application'
Dentro de nuestra aplicacíon configuraremos 3 cosas:
1: Webhook - Url en donde se enviarán todos los datos desde el backend a la plataforma.
2: Device - Dispositivo en donde Losant guardará la informacion proveniente del Devkit para posteriormente mostrarla en un dashboard.
3: Workflow - Diagrama de flujo que se activará cada vez que haya un request por parte del backend de Sigfox.
Dentro de nuestra aplicación nos dirigimos a la pestaña 'Webhooks' y damos click.
Damos click en 'Add Webhook' y aparecerá la siguiente ventana en donde configuraremos lo siguiente:
- El nombre de nuevo puede ser cualquiera y lo demás lo dejamos con la misma configuración
Mas abajo marcamos la opción 'Wait for reply from workflow' y seguido damos click en 'Create Webhook"
Notaremos que al momento de crearlo nos genera una URL:
Esta URL la copiaremos y guardaremos para usarla posteriormente para configurar el callback de Sigfox.
Ahora, configuraremos el device en donde Losant guardará los datos provenientes de Sigfox. En nuestra pantalla principal de la aplicacion, daremos click en 'Devices', seguido daremos click en 'Create new device'
Damos click en 'Create blank device'
En el Device Name podemos poner el nombre que queramos pero de preferencia que indentifique a nuestro dispositivo Marcamos la casilla 'Standalone' en el Device Type
En la parte de atributos colocamos:
Debemos de tener en cuenta la información que estamos leyendo y enviando desde el dispositivo. En este caso estamos enviando unicamente la temperatura del sensor por lo que el tipo de dato que recibira Losant será un número y el nombre de la variable puede ser cualquiera, pero una que identifique nuestra información.
Ahora es turno de configurar el diagrama de flujo para que una vez que Losant reciba la información sepa que hacer con ella.
En nuestro menú principal de la aplicación damos click en 'Workflows', seguido damos click en 'Create Workflow'
Le damos el nombre que nosotros queramos y opcionalmente podemos asignarle una descripción. Seguido damos click en 'Create Workflow'
Notaremos que nos abrirá un espacio de trabajo donde podremos crear nuestro diagrama de flujo.
Del lado izquierdo nos muestra todos los nodos disponibles. Tales como 'Triggers', 'User Experience', 'Data', etc.
Debido a que nuestra información esta llegando por medio de un Webhook, el diagrama de flujo se activará cada que llegue información a ese Webhook que creamos.
Por lo tanto, en el lado izquierdo en la sección de 'Triggers' buscamos por el nodo 'Webhook'
Lo arrastramos y pegamos a nuestro espacio de trabajo.
Ahora, buscaremos el nodo 'Debug'. Este nodo nos sirve para observar que esta sucediendo en determinada parte del diagrama de flujo. Lo conectaremos debajo de nuestro 'Webhook' para poder observar que información llega.
Ahora presionaremos en 'Deploy Workflow' para guardar nuestro diagrama de flujo y quede listo para recibir información. Dejaremos esta parte pendiente para continuar configurando el backend en Sigfox.
Para esta parte es necesario haber registrado el dispositivo en el backend de Sigfox. Daremos click en 'Device Type' y buscamos por nuestro dispositivo registrado
Dentro de nuestro Device Type, del lado izquierdo en el menú buscamos la opción 'Callbacks' y damos click
Los callbacks nos sirven para poder jalar nuestra información del backend Sigfox a nuestra webApp, plataforma, etc. Para nuestro ejemplo haremos un callback a Losant
Dentro de la sección 'Callbacks' damos click en 'New', seguido daremos click en 'Custom Callback'
En la ventana que nos aparece, configuraremos nuestro callback de la siguiente manera:
- Type : Data & Uplink
- Channel: URL //
- Custom Payload Config : Variables personalizadas, decodificación del mensaje hexadecimal
- URL Pattern : URL a la que le enviaremos la información del dispositivo
- Use HTTP method : POST
- Content type : Application/json
Así nuestro callback quedará listo para poder recibir la información en Losant.
Ahora conectado nuestro sensor de temperatura y el Devkit con el código cargado, procederemos a apretar el botón para enviar la información de temperatura a Losant. Al hacer esto iremos al diagrama de flujo previamente creado y del lado derecho presionaremos en 'Debug'
Ahí aparecera toda la información relacionada con el nodo 'Debug'.
Cada vez que presionamos el botón del Devkit, nos aparecera nueva información relacionada a Losant y al Devkit, en particular hay un Path dentro de ese formato Json que nos interesa el cual es : 'data.query.temp'
En la cual Losant esta recibiendo la informacion proveniente del Devkit y de Sigfox.
Tal cual esta llegando la información no se esta guardando en ningun lado por lo tanto tenemos que guardar de alguna manera esa información y para ello haremos uso de nuestro 'device virtual' previamente creado.
En nuestro diagrama de flujo buscaremos por el nodo 'Device state' y lo agregaremos a nuestro diagrama de flujo de la siguiente manera.
Justo entonces nos aparecera la configuración del nodo, el cual configuraremos de la siguiente manera:
-
Device : Marcamos la opción 'Select a specific device' y en la lista buscamos por nuestro device creado anteriormente
-
State :
- Data Metod: Individual Fields
Dentro de esta parte veremos que ya esta preconfigurado nuestro campo Temperatura al cual le hace falta el valor asignado. Dentro de 'Value' colocaremos el Json path en donde llegaba la información de Sigfox de la siguiente manera: Value : {data.query.temp}
Finalmete damos click en 'Deploy Workflow'
De esta manera nuestra información proveniente de Sigfox quedará almacenada en nuestro Device para posteriormente mostrarla en el Dashboard de Losant.
Con la información ya almacenada en nuestro device en Losant. Podemos visualizarla en un Dashboard sencillo.
Para ello iremos a la parte superior y daremos click en 'Dashboards', seguido de 'Create Dashboard'.
Le daremos el nombre que queramos y damos click en 'Create Dashboard'.
Nos mostrará distintos wodgets que podemos elegir para mostrar la informacion en la forma que queramos. Para este ejemplo seleccionaremos 'Gauge' y damos click en 'Customize'
Siguiendo la siguiente configuración, le damos el nombre que queramos y buscamos por nuestra aplicación anteriormente creada.
En la parte de 'Block data', en Device buscaremos por el nuestro creado anteriormente En Attribute seleccionamos Temperatura En Label podemos colocar las unidades de la informacion que estemos mostrando o simplemente a que se refiere ese Widget.
En esta sección realizaremos un Callback hacia Microsoft Azure utilizando el ejemplo del sensor de temperatura, para mandar la información y desplegarla en un dashboard donde podamos observar una gráfica de la temperatura con respecto al tiempo. Lo que necesitamos es:
-Una cuenta en Microsoft Azure
-Un correo no personal (academico o de trabajo) para crear una cuenta en Power BI
Entramos en nuestra cuenta de Microsoft Azure y veremos el "Panel", donde se muestran los recursos que hagamos. En este caso está vacio porque no hemos creado ninguno.
Ahora, crearemos un nuevo recurso con el que jalaremos los datos del backend hacia Azure. Damos click en Nuevo -> Internet de las cosas -> IoT Hub
Asignamos un nombre a nuestro recurso y en "Grupo de recursos" seleccionamos "Crear Nuevo" y le damos un nombre. Todo lo demas se queda como aparece por default. Damos click en "Crear"
Despues de unos minutos, en las notificaciones nos mostrará un mensaje de que la implementación fue creada con éxito. Damos click en "Ir al recurso"
Enseguida nos mostrará la informacion de nuestro recurso creado.
Para poder realizar el Callback, necesitaremos la clave de acceso hacia nuestro recurso. Nos vamos a
Directivas de Acceso Compartido -> iothubowner -> Cadena de conexión (clave principal). Esta clave nos servira un poco mas adelante en la configuracion de nuestro callback en el backend
Regresamos al backend de sigfox para crear el Callback. Nos vamos a nuestro dispositivo y damos click en el "Device Type"
En el panel de la izquierda damos click en Callbacks -> New
De los posibles Callbacks, seleccionamos "Microsoft Azure Iot hub"
Ahora tendremos que configurar el Callback.
- En "Custom Payload Config" escribimos "temp::float:32:little-endian"
- En "Connection string" pegamos la clave que copiamos de Azure.
- En "JSON body" pegamos el siguiente codigo
{
"device" : "{device}",
"data" : "{data}",
"temperatura" : "{customData#temp}",
"time" : "{time}",
"snr" : "{snr}",
"station" : "{station}",
"avgSignal" : "{avgSnr}",
"seqNumber" : "{seqNumber}"
}
quedando como se muestra en la siguiente imagen
Damos Click en "Ok" y con eso queda creado nuestro Callback. Ahora verificaremos que no exista ningun error. Damos click en "Associated devices"
hacemos click en el ID de nuestro Devkit
y en el panel izquierdo nos vamos a "Messages" para visualizar el estatus del Callback. Presionamos el boton de nuestro Devkit para mandar un mensaje. Si todo fue correctamente configurado la flecha en Callbacks ahora permanecerá en verde como se muestra en la imagen
Con esto queda finalizada la parte en el backend.
Regresamos a Microsoft Azure y nos vamos a
Nuevo -> Internet de las Cosas -> Stream Analytics Job
le asignamos un nombre y en "Grupo de recursos" seleccionamos "Usar existente" y nos aparecerá por default el recurso que creamos anteriormente y damos click en crear.
Despues de un momento, en las notificaciones nos aparecerá que la implementacion fue correcta. Damos click en ir al recurso
Ahora ya tenemos implementado nuestro recurso de Stream Analytics.
Damos click en "Entradas" y configuramos el método por le cual entrarán los datos provenientes del backend hacia Azure.
-Asignamos un alias a nuestra nueva entrada
-En "Tipo de origen" seleccionamos "Flujo de datos"
-En "Origen" seleccionamos "Centro de IoT"
-En "Opción de importación" seleccionamos "Usar centro de IoT de la suscripción actual"
-En "Centro de IoT" seleccionamos nuestro recurso creado anteriormente, en este caso se llama "devkit-test"
Los demas campos los dejamos como aparecen por defecto, quedando como se muestra en las siguientes imagenes
Damos click en crear. Despues de unos momentos, en las notificaciones nos indicará que la prueba de conexión fue correcta.
Regresamos a nuestro recurso de Stream Analytics. Ahora configuraremos la parte de salida de los datos. Damos click en "Salidas"
Asignamos un "Alias" y en "Receptor" seleccionamos "Power BI". Para esta parte necesitaremos nuestra cuenta en Power BI. Damos click en "Autorizar" y nos pedira iniciar sesión en Power BI con nuestro correo institucional o de trabajo.
Una vez que iniciemos sesión, nos habilitará opciones para configurar y abajo aparecerá la cuenta con la que hemos iniciado sesión en Power BI. Seleccionamos "Mi area de trabajo" y asignamos nombres al "Conjunto de datos" y a la "Tabla" que nos creará.
Damos click en "Crear" y como en los anteriores recursos, en las notificaciones nos mostrará un mensaje de que fué creado con éxito. Ahora configuraremos las variables que mandaremos de nuestra "Entrada de datos" hacia la "Salida de datos". Nos dirigimos hacia "Consulta"
Copiamos y pegamos el siguiente código.
SELECT
CAST(temperatura as float) as temp,
System.Timestamp AS Timestamp
INTO
[El nombre de su salida]
FROM
[El nombre de su entrada]
Con esto definimos que queremos enviar la variable temperatura como una nuava variable llamada temp y el tiempo hacia nuestra salida(Power BI) desde nuestro recurso de entrada. Y damos click en guardar.
ya que tenemos configurado la entrada y salida de datos, ya podemos empezar a enviar los datos de nuestro Devkit hacia Power BI y verlos en un dashboard. Damos click en "Iniciar"
Nuevamente damos click en "Iniciar" y despues de unos segundos nos indicará en "Ejecución".
Presionamos el botón de nuestro Devkit para mandar mensajes.
Ahora abrimos nuestra cuenta en Power BI. Nos vamos a
Mi area de trabajo -> Conjunto de Datos
y veremos nuestra variable Temp que definimos cuando configuramos la salida hacia Power BI. Damos click en "Crear informe"
Seleccionamos "Gráfico de lineas" y del lado derecho marcamos nuestras variables que queremos graficar, en este caso son temp y timestamp. Enseguida se graficarán los datos que enviamos desde que "Iniciamos" el recurso de Stream Analytics. Damos click en Guardar.
Con eso ya tenemos nuestro dashboard donde se mostrá la grafica de la temperatura con respecto al tiempo. Tenemos que dar click en "Actualizar" para que la grafica muestre los datos mas recientes.
Por último, para detener el envio de datos, regresamos a Azure y seleccionamos "Detener"
Ahora es el turno de hacer la integración con la plataforma de Amazon Web Services (AWS). Se utilizará el ejemplo del sensor de temperatura, sin embargo puede utilizarse el ejemplo del sensor ultrasónico.
Creamos una cuenta en la plataforma de Amazon
Una vez creada la cuenta la dejamos abierta y accedemos al backend para visualizar nuestro dispositivo. Damos click en el "Device type"
en la columna del lado izquierdo damos click en "Callbacks"
enseguida, en la parte superior derecha, daremos click en "NEW" y de las diferentes opciones de callbacks, seleccionaremos "AWS IoT"
ahora tendremos que configurar el callback hacia AWS. Tener en cuenta el "External ID", ya que lo necesitaremos mas adelante para configurar la parte de AWS. Hacemos click en "Launch Stack"
a continuación nos abrirá una pagina donde configuraremos el STACK creado en AWS. En la esquina superior derecha seleccionaremos la region, en este caso se seleccionó "US East (N. Virginia)". En la parte de "Select template" dejamos todo como está y damos click en "Next"
ahora tenemos que configurar "Specify Details", donde necesitaremos nuestro "Account number", el cual podemos obtener en la esquina superior derecha, en Support-> Support Center
Seleccionamos un nombre para nuestro Stack. Copiamos nuestro "Account number" y lo pegamos en "AWSAccountId" en la pagina de AWS. Ahora necesitaremos el External ID que nos proporciona sigfox en el backend. Regresamos al backend, lo copiamos y lo pegamos en "ExternalId". Dejamos la region como "us-east-1" y escribimos un "Topic name". Damos click en next
En la parte de "Options", no modificamos nada y damos click en "Next". Finalmente en el "Review", seleccionamos "I acknowledge that AWS CloudFormation might create IAM resources" y seleccionamos "Create"
Despues de unos minutos estara creado nuestro Stack. Con esto ya queda configurada la parte de AWS del Callback.
Ahora falta terminar el Callback en el backend de Sigfox. Una vez que aparezca la leyenda "Create_complete", seleccionamos nuestro Stack y nos vamos a la pestaña "Outputs" y Copiamos el "ARNRole".
Pegamos el "ARNRole" que obtuvimos de AWS. En "topic", escribimos el mismo que pusimos en nuestro Stack, escogemos la misma region (US East (N. Virginia)) y escribimos el siguiente json
{
"device" : "{device}",
"data" : "{data}",
"time" : "{time}",
"snr" : "{snr}",
"station" : "{station}",
"avgSnr" : "{avgSnr}",
"lat" : "{lat}",
"lng" : "{lng}",
"rssi" : "{rssi}",
"seqNumber" : "{seqNumber}"
}
y damos click en OK. Con esto ya tenemos creado nuestro Callback en el backend. Para verificar que no hay ningun problema con la configuración, mandamos un mensaje hacia sigfox y observamos el indicador del callback,que debe quedar de color verde, lo que indica que se realizó de manera exitosa
Ahora que tenemos nuestro Stack creado, vamos a crear una tabla por medio de DynamoDB con los datos que mandamos por medio de nuestro dispositivo. Vamos a Services-> DynamoDB
damos click en "Crear tabla"
Ahora tenemos que configurar nuestra tabla. Le asignamos un nombre, escribimos "deviceid" en Partition Key, seleccionamos "Añadir clave de ordenación" y escribimos "timestamp" y damos click a "Crear"
despues de unos minutos, se habrá creado nuestra tabla
ahora debemos crear una regla que nos permita enviar enviar los datos recividos hacia nuestra tabla recien creada. Nos vamos a Services-> IoT Core
y seleccionamos "ACTUAR"
damos click en "Crear"
le asignamos el mismo nombre que nuestro Stack, y agregamos una pequeña descripcion (opcional)
en el campo "Instruccion de consulta de regla" escribimos SELECT * FROM 'sigfox' donde 'sigfox' es el mismo nombre del topic que pusimos en el callback. Despues tenemos que agregar la accion que queremos que se ejecute. Damos click en "Añadir acción"
y escogemos "DynamoDB"
posteriormente, tenemos que configurar la acción de insertar los datos en DynamoDB. Seleccionamos nuestra tabla creada anteriormente y escribimos ${device} en "Hash key value", $ {timestamp()} en "Range key value" y "payload" en "Write message data to this column"
Creamos un nuevo role dando click en "Create a new role"
y le asignamos el nombre "dynamodbsigfox" y damos click en "Add action"
finalmente damos click en "Crear una regla"
una vez creada, nos aparecera en nuestras reglas
si le damos click nos mostrará las caracteristicas de la regla que hemos creado
Finalmente, si nos regresamos a DynamoDB->Tables->sigfox->Items, podremos ver los mensajes que enviemos por medio de nuestro Devkit
Ahora toca la integración con la plataforma Ubidots. Al igual que en los ejemplos pasados, en este también se utilizará la práctica del sensor de temperatura. Lo primero que se debe hacer es crear una cuenta en el siguiente link ubidots.
Una vez creada la cuenta, nos aparecerá lo siguiente
Nos vamos a la esquina superior derecha y damos click en nuestro usuario para desplegar un menú, donde seleccionaremos “API CREDENTIALS”, para obtener un Token que nos permitirá crear el callback.
Ahora, copiamos y guardamos el token ya que sera necesario posteriormente
Enseguida creamos el callback. Vamos al backend a nuestro dispositivo y damos click en el DEVICE TYPE.
nos desplegara la información sobre el DEVICE TYPE. Selecionaremos CALLBACKS en el panel izquierdo
y seleccionamos CUSTOM CALLBACK
configuramos el callback de acuerdo a la imagen de abajo y en “URL Pattern” escribimos las siguiente dirección
http://things.ubidots.com/api/v1.6/devices/{device}/?token=YOUR_TOKEN
seguida del Token que copiamos enseguida de crear nuestra cuenta.
y damos click en OK para terminar el callback. Con esto queda creado el callback hacia Ubidots.
Ahora que nuestro Callback esta creado, ya podemos mandar la información de la temperatura de nuestro Devkit hacia la plataforma. Presionamos el botón para mandar la información de la temperatura y en el backend podremos observar el estatus del callback, el cual debe quedar en color verde
si regresamos a Ubidots, veremos que aparece el ID de nuestro dispositivo
si damos click en el nos aparecerá la variable que enviamos, en este caso es la variable “temp”
finalmente, si damos click, podremos ver los datos en forma de gráfica, así como un historial de la información enviada.
Para crear el dashboard, en la parte superior, damos click en “DASHBOARD”
en la esquina superior derecha seleccionamos “Create Widget”
y tendremos que seleccionar de que tipo lo queremos. En este caso seleccionaremos una gráfica sencilla
seleccionamos nuestro dispositivo así como la variable de nuestro interés, que en este caso es “temp”. Finalmente damos click en “ADD VARIABLE”
y ahora nuestro dashboard tendrá la gráfica de la temperatura.
Para agregar más Widgets a nuestro dashboard se sigue el mismo procedimiento.
Thinger.io es una plataforma con librerías de código abierto que permite gestionar multitud de dispositivos a través de Internet. Es gratuita para makers con las siguientes limitaciones:
- Permite conectar un máximo de 3 dispositivos.
- No existe limitación en cuanto a los recursos de cada dispositivo, es decir el número de parámetros a medir por los sensores que tenga conectados (más allá de su propia capacidad) o el número de parámetros a enviar a los dispositivos desde la plataforma.
- Los valores de los parámetros recibidos en la plataforma se pueden almacenar hasta en un máximo de 10 campos (Data Buckets) diferentes. Cada Data Bucket puede almacenar datos de múltiples sensores, con una frecuencia máxima de un minuto (un almacenamiento cada minuto).
- Los valores de los sensores se pueden visualizar hasta un máximo de 10 pantallas gráficas de visualización de datos (Dashboards).
Creamos una cuenta en Thinger.io. Una vez creada la cuenta, veremos la pantalla principal.
Seleccionamos Device buckets->Add bucket
configuramos nuestro bucket. Escribimos un ID para identificarlo, un nombre y una descripción. Lo habilitamos y en Data Source seleccionamos "From Write Call". Click en Add bucket
Ahora necesitamos crer el token necesario para poder conectarnos con el backend. Seleccionamos "Access Tokens"
Escribimos un ID y un nombre para identificarlos y en la parte de "Tokens Permissions" damos click en +Add
realizamos la siguiente configuración
- Select Permission Type -> Bucket
- Access -> Specific resource -> nuestro bucket creado (Devkit_NXTIoT)
- Actions -> Select specific action -> WriteBucket
click en Add
ahora ya tenemos creado nuestro "Access token". Este Token lo necesitaremos para la configuracion en el backend
Enseguida creamos el callback. Vamos al backend a nuestro dispositivo y damos click en el DEVICE TYPE.
nos desplegara la información sobre el DEVICE TYPE. Selecionaremos CALLBACKS en el panel izquierdo
y seleccionamos CUSTOM CALLBACK
realizamos la siguiente configuracion
- Type: DATA, UPLINK Channel: URL
- Custom payload config: lat::float:32:little-endian lng::float:32:little-endian temp::int:8 bat::int:8
- URL pattern: la url debe tener el siguiente formato https://api.thinger.io/v1/users/{user_id}/buckets/{bucket_id}/data
- {user_id} y {bucket_id} se deben cambiar de acuerdo a nuestra cuenta y a el Id de nuestro bucket. Para este ejemplo la URL quedo como https://api.thinger.io/v1/users/gpg117/buckets/Devkit_NXTIoT/data
- Use HTTP Method: POST
- Headers: En esta parte es donde necesitaremos pegar el Access token que creamos
- Authorization: Bearer "Your Token"
- Content type: Application/json
- Body:
{
"device" : "{device}",
"longitud" : "{customData#lng}",
"latitud" : "{customData#lat}",
"temp" : "{customData#temp}",
"bateria" : "{customData#bat}"
}
Damos click en "OK"
Una vez realizado el callback, presionamos el boton para enviar un mensaje. Si nos vamos a nuestro bucket creado, veremos los mensajes enviados con nuestro Devkit
Damos click en "Dashboards" en el panel izquierdo. Escribimos la informacion que nos pida y damos click en "Add dashboard"
habilitamos el switch de la derecha y seleccionamos "Add widget"
realizamos la configuracion y lo guardamos
y en nuestro dashboard veremos la grafica de la temperatura
podemos agregar mas widgets para visualizar mas informacion
