El RedBear Duo es un pequeño kit de desarrollo de hardware Wi-Fi y BLE que viene con el firmware de Particle por defecto. Esto nos permite utilizar el entorno de desarrollo de Particle y disfrutar de su facilidad de uso, ejemplos de la comunidad y bibliotecas preconfiguradas.
Siguiendo esta guía, podrás POST y GET datos a/de Ubidots utilizando el módulo RedBear Duo en solo un par de minutos!
Requisitos
Paso a Paso
Configuración del Dispositivo
Reclama tu RedBear Duo en Particle IDE
Crea una nueva APP e incluye la Biblioteca de Ubidots
Envía (POST) Valores a Ubidots
Envía (POST) Valores a Ubidots con Contexto
Envía (POST) Valores con Timestamp
Recibe (GET) Valores de Ubidots
Recibe (GET) Valores de Ubidots con Contexto
Funcionalidad especial
- Obtener timestamp
- Cambiar Etiqueta del Dispositivo
- Cambiar Nombre del Dispositivo
- Usar método TCP para Enviar (POST) ValoresResumen
1. Configuración del Dispositivo
1. Conecta el RedBear Duo a un ordenador a través del puerto USB utilizando un cable USB.
2. Por defecto, el RedBear Duo trae "Setup Firmware" que te permite verificar la versión de la placa RedBear, el ID del Dispositivo de la placa. Además, podrás configurar las credenciales de WiFi.
Según tu sistema operativo, consulta los siguientes pasos:
Usuarios de Windows
1. Descarga e instala el controlador Silicon Labs CP2102 para Windows.
2. Ve a Administración de Equipos y busca Silicon Labs CP210x USB to UART Bridge bajo Puertos (COM & LPT), y toma nota del número COM entre paréntesis, este se usará más tarde en nuestra configuración.
3. Abre PuTTY, selecciona Serial para la conexión, ingresa el puerto COM de Silicon y coloca 115200 para la velocidad; luego haz clic en el botón Abrir para completar este paso.
NOTA: Si no te gusta Putty, siéntete libre de elegir otras herramientas de comunicación soportadas por Windows, como HyperTerminal o TeraTerm.
Usuarios de MacOSX
1. Instala "screen" siguiendo las instrucciones proporcionadas en esta guía.
2. Con "screen" correctamente instalado, ejecuta el siguiente comando en la terminal del ordenador para acceder a la terminal de RedBear.
NOTA: El xxx ubicado al final del comando se refiere al Puerto Serial asignado a la placa RedBear. Basado en esto, debes reemplazar el xxx con el puerto asignado a la placa.
screen /dev/ttyxxx
Usuarios de Linux
1. Instala "screen" siguiendo las instrucciones proporcionadas en esta guía.
2. Con "screen" correctamente instalado, ejecuta el siguiente comando en la terminal del ordenador para acceder a la terminal de RedBear.
NOTA: El xxx ubicado al final del comando se refiere al Puerto Serial asignado a la RedBear. Basado en esto, puedes reemplazar el xxx con el puerto asignado a la placa.
screen /dev/ttyxxx
3. Ahora, escribe los siguientes comandos en la terminal de RedBear para configurar la placa correctamente:
[OPCIONAL] Escribe
vpara verificar la versión de RedBear.Escribe
ipara imprimir el ID del Dispositivo; el ID del Dispositivo es el que se necesita para reclamar el dispositivo en el Particle IDE, así que por favor mantenlo a mano para más tarde.Escribe
wpara establecer las credenciales de WiFi. En este punto, la placa pedirá el SSID (nombre de la red), tipo de seguridad y contraseña, así que por favor asigna las credenciales de la red a la que te conectarás.
NOTA: Para poder configurar las credenciales de WiFi en la placa, esto debe realizarse en "Modo de Escucha". Para poner la placa en modo de escucha, mantén presionado el botón "SETUP" durante al menos 3 segundos.
Si la configuración de tu red WiFi se ingresa correctamente, el RedBear Duo saldrá del Modo de Escucha e intentará conectarse al punto de acceso a Internet. El LED RGB debería parpadear en verde si la conexión se establece correctamente con Internet. Si el Duo se conecta al punto de acceso con éxito, realizará un reinicio suave y se reiniciará. De lo contrario, el Duo volverá a entrar en Modo de Escucha y esperará que vuelvas a ingresar las credenciales de Wi-Fi.
Si estás usando PuTTY u otro terminal serial, cuando el Duo realice un reinicio, se desconectará del terminal, posiblemente desconectándose del puerto serial correcto. Si esto sucede, necesitas cerrar el puerto serial, luego presionar el botón RESET de la placa, y luego volver a abrir el puerto serial para restaurar la comunicación con el Duo.
2. Reclama tu RedBear Duo en Particle IDE
1. Ve a Particle's IDE.
2. Haz clic en Dispositivos –> AÑADIR NUEVO DISPOSITIVO.
3. Asigna el ID del Dispositivo que guardaste en el paso anterior (Configuración del Dispositivo). Luego haz clic en RECLAMAR UN DISPOSITIVO.
Ahora, el RedBear Duo está agregado al Particle IDE.
3. Crea una nueva APP e incluye la Biblioteca de Ubidots
1. Después de reclamar tu RedBear Duo en el Particle IDE y configurar tu cuenta de Ubidots, vamos a la Web IDE de Particle y "Crear Nueva App."
Para detalles adicionales sobre cómo "Crear Nueva App," simplemente haz clic aquí y sigue el sencillo proceso de 3 pasos.
2. Con la nueva app creada, necesitas agregar la Biblioteca de Ubidots a la app previamente creada para poder trabajar con tu hardware RedBear y Ubidots.
Para incluir la biblioteca, ve a la pestaña de bibliotecas (notada en la imagen a continuación) y busca el conjunto de bibliotecas de Ubidots, específicamente la biblioteca UBIDOTSMQTT. Asegúrate de agregar la última versión de la biblioteca.
Ten en cuenta que también hay una versión MQTT de la comunicación de Ubidots con RedBear. Para este tutorial, utilizaremos la biblioteca "Ubidots" TCP/UDP. Si prefieres utilizar protocolos MQTT, consulta esta guía para instrucciones sobre cómo hacerlo.
Haz clic en INCLUIR EN APP. Y regresa a la app previamente creada. Con la biblioteca añadida a la App, ahora podemos comenzar a codificar en el Particle IDE.
4. Envía (POST) Valores a Ubidots
Puedes enviar valores a Ubidots utilizando la etiqueta de variable, también puedes enviar valores con timestamp y contexto.
Enviando valores usando la etiqueta de variable
Usando el siguiente código de ejemplo, Ubidots creará automáticamente una nueva variable con la etiqueta de variable asignada en el código.
NOTA IMPORTANTE: La biblioteca de Ubidots te permite enviar un máximo de 5 valores. Si necesitas POSTear más valores, simplemente agrega la línea ubidots.add("variable_name", value); a tu código con los parámetros necesarios.
Además, puedes encontrar el código de ejemplo a continuación en el Particle IDE. Ve a Bibliotecas Incluidas, busca y haz clic en UBIDOTS y selecciona UbidotsSendValues.cpp, luego cópialo y pégalo en el Particle IDE.
No olvides agregar tu TOKEN de Ubidots donde se indica.
// Este ejemplo es para obtener el último valor de la variable de la API de Ubidots// Este ejemplo es para guardar múltiples variables en la API de Ubidots con el método TCP/**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Constantes ****************************************/#define TOKEN "Your_Token" // Coloca aquí tu TOKEN de UbidotsUbidots ubidots(TOKEN);/**************************************** * Funciones Auxiliares ****************************************///Coloca aquí tus funciones auxiliares/**************************************** * Funciones Principales ****************************************/void setup() { Serial.begin(115200); //ubidots.setDebug(true); //Descomenta esta línea para imprimir mensajes de depuración}void loop() { float value1 = analogRead(A0); float value2 = analogRead(A1); float value3 = analogRead(A2); ubidots.add("Variable_Name_One", value1); // Cambia por el nombre de tu variable ubidots.add("Variable_Name_Two", value2); ubidots.add("Variable_Name_Three", value3); ubidots.sendAll(); delay(5000);}5. Envía (POST) Valores a Ubidots con Contexto
El siguiente ejemplo es para enviar un valor con contexto a Ubidots, creará la variable automáticamente con la etiqueta asignada por ti en el código.
Además, puedes encontrar el código de ejemplo a continuación en el Particle IDE. Ve a Bibliotecas Incluidas para buscar y hacer clic en UBIDOTS. Luego selecciona UbidotsSendValuesWithContext.cpp, copia y pega el código de ejemplo en el Particle IDE de tu nueva App.
No olvides agregar tu TOKEN de Ubidots donde se indica.
// Este ejemplo es para guardar múltiples variables con contexto en la API de Ubidots con el método TCP/**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Constantes ****************************************/#define TOKEN "Your_Token" // Coloca aquí tu TOKEN de UbidotsUbidots ubidots(TOKEN);/**************************************** * Funciones Auxiliares ****************************************///Coloca aquí tus funciones auxiliares/**************************************** * Funciones Principales ****************************************/void setup() { Serial.begin(115200); //ubidots.setDebug(true); //Descomenta esta línea para imprimir mensajes de depuración}void loop() { float value1 = analogRead(A0); char context[25]; sprintf(context, "lat=1.2343$lng=132.1233"); //Envía latitud y longitud para ver la posición en un mapa ubidots.add("Variable_Name_One", value1, context); // Cambia por el nombre de tu variable ubidots.sendAll(); delay(5000);}6. Envía (POST) Valores con Timestamp
El siguiente ejemplo es para enviar un valor con timestamp a Ubidots, creará la variable automáticamente con la etiqueta asignada por ti en el código.
Además, puedes encontrar el código de ejemplo a continuación en el Particle IDE. Ve a Bibliotecas Incluidas, luego busca y haz clic en UBIDOTS. Luego selecciona UbidotsSendValuesWithTimeStamp.cpp, copia y pega en el Particle IDE de tu nueva app.
No olvides agregar tu TOKEN de Ubidots donde se indica.
/**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Constantes ****************************************/#define TOKEN "Your Ubidots TOKEN" // Coloca aquí tu TOKEN de UbidotsUbidots ubidots(TOKEN);/**************************************** * Funciones Auxiliares ****************************************////**************************************** * Funciones Principales ****************************************/void setup() { Serial.begin(115200); //ubidots.setDebug(true); //Descomenta esta línea para imprimir mensajes de depuración}void loop() { float value1 = analogRead(A0); unsigned long t = ubidots.ntpUnixTime(); // calcula tu timestamp actual en SEGUNDOS ubidots.add("test-1", value1); // Cambia el primer argumento por la etiqueta de tu variable ubidots.add("test-2", value1, NULL, t-20000); // Envía un valor con un timestamp personalizado ubidots.add("test-3", value1); // Envía las variables 'test-1' y 'test-2' con tu timestamp actual, // la variable 'test-2' se enviará con su timestamp personalizado ubidots.sendAll(t); delay(5000);}7. Recibe (GET) Valores de Ubidots
Esta biblioteca te permite GET el último valor de una variable de Ubidots usando la etiqueta de variable o ID de variable, también puedes obtener el valor de contexto si es necesario.
Para GET el último valor usando el ID de variable deberías usar la siguiente línea:
getValue(VAR_ID)
Para obtener el último valor usando la etiqueta de variable deberías usar la siguiente línea:
getValueWithDatasource(DEVICE_LABEL, VAR_LABEL)
El siguiente ejemplo muestra cómo GET el último valor de una variable en tu cuenta de Ubidots.
No olvides agregar tu TOKEN, el dispositivo y la etiqueta de variable o ID de variable donde se indica en el código de ejemplo.
// Este ejemplo es para GET el último valor de la variable de la API de Ubidots/**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Constantes ****************************************/#define TOKEN "...." // Coloca aquí tu TOKEN de Ubidots#define VAR_ID "58d9153e762542576b721820" // Coloca aquí el nombre de tu fuente de datos#define VAR_LABEL "...." // Coloca aquí la etiqueta de tu variable api#define DEVICE_LABEL "...." // Coloca aquí la etiqueta de tu dispositivo api/**************************************** * Funciones Auxiliares ****************************************///Coloca aquí tus funciones auxiliares/**************************************** * Funciones Principales ****************************************/Ubidots ubidots(TOKEN);void setup() { Serial.begin(115200); //ubidots.setDebug(true); //Descomenta esta línea para imprimir mensajes de depuración}void loop() { float value1; value1 = ubidots.getValue(VAR_ID); float value2; value2 = ubidots.getValueWithDatasource(DEVICE_LABEL, VAR_LABEL); if(value1!=NULL){ Serial.println(value1); } if(value2!=NULL){ Serial.println(value2); } delay(5000);}8. Recibe (GET) Valores de Ubidots con Contexto
getVarContext(VARIABLE_ID)
El siguiente ejemplo es para GET el contexto de una variable de Ubidots.
Para obtener el contexto de una variable almacenada en Ubidots, ve a Bibliotecas Incluidas y haz clic en UBIDOTS y selecciona UbidotsGetContext.cpp y copia y pega en el Particle IDE de tu nueva app.
No olvides agregar tu TOKEN de Ubidots y ID de variable donde se indica en el código de ejemplo.
// Este ejemplo es para obtener el último valor de la variable de la API de Ubidots/**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Constantes ****************************************/#define TOKEN "...." // Coloca aquí tu TOKEN de Ubidots#define VAR_ID "58d9153e762542576b721820" // Coloca aquí el nombre de tu fuente de datos/**************************************** * Funciones Auxiliares ****************************************///Coloca aquí tus funciones auxiliares/**************************************** * Funciones Principales ****************************************/Ubidots ubidots(TOKEN);void setup() { Serial.begin(115200); //ubidots.setDebug(true); //Descomenta esta línea para imprimir mensajes de depuración}void loop() { char* context; ubidots.getVarContext(VAR_ID); Serial.println(context); delay(5000);}9. Funcionalidad especial
Obtener timestamp
Si necesitas obtener el timestamp, puedes usar el servidor NTP creado por Francesco Potorti portado a esta biblioteca, simplemente agrega a tu código la siguiente rutina:
Obtener timestamp
unsigned long timestamp = ubidots.ntpUnixTime(); // calcula tu timestamp actual en SEGUNDOSubidots.add("test-1", 1);ubidots.sendAll(timestamp);Cambiar Etiqueta del Dispositivo
Función para Establecer Etiqueta del Dispositivo
ubidots.setDeviceLabel(DeviceLabel);
Ejemplo usando la Función setDeviceLabel
// Este ejemplo es para guardar valores con un nombre de fuente de datos establecido#include "Ubidots/Ubidots.h"#define TOKEN "Your_Token_Here" // Coloca aquí tu TOKEN de Ubidots#define DEVICE_LABEL "Your_DEVICE_LABEL"Ubidots ubidots(TOKEN);void setup() { Serial.begin(115200); ubidots.setDeviceLabel(DEVICE_LABEL);}void loop() { float value1 = analogRead(A0); float value2 = analogRead(A1); float value3 = analogRead(A2); ubidots.add("Variable_Name_One", value1); // Cambia por el nombre de tu variable ubidots.add("Variable_Name_Two", value2); ubidots.add("Variable_Name_Three", value3); ubidots.sendAll(); delay(5000);}Cambiar Nombre del Dispositivo
Función para Establecer Nombre del Dispositivo
ubidots.setDeviceName(DEVICE_NAME);
Ejemplo usando la Función setDeviceName
// Este ejemplo es para guardar valores con un nombre de fuente de datos establecido#include "Ubidots/Ubidots.h"#define TOKEN "Your_Token_Here" // Coloca aquí tu TOKEN de Ubidots#define DEVICE_NAME "Your_DEVICE_NAME"Ubidots ubidots(TOKEN);void setup() { Serial.begin(115200); ubidots.setDeviceName(DEVICE_NAME);}void loop() { float value1 = analogRead(A0); float value2 = analogRead(A1); float value3 = analogRead(A2); ubidots.add("Variable_Name_One", value1); // Cambia por el nombre de tu variable ubidots.add("Variable_Name_Two", value2); ubidots.add("Variable_Name_Three", value3); ubidots.sendAll(); delay(5000);}La biblioteca de Ubidots para Particle tiene una función especial para establecer un nombre de Dispositivo. Este nombre de Dispositivo es el gemelo digital o el dispositivo digital en Ubidots que coincide con el hardware físico en el mundo real.
Con tu dispositivo Particle no puedes cambiar el nombre del dispositivo digital creado. Para cambiar el nombre de tu dispositivo, simplemente modifícalo directamente en el front-end de Ubidots.
Usar método TCP para Enviar (POST) Valores
Función para establecer transmisión
ubidots.setMethod(TYPE_UDP);
Ejemplo usando la Función setMethod
// Este ejemplo permite enviar datos usando el protocolo UDP#include "Ubidots/Ubidots.h"#define TOKEN "Your_Token_Here" // Coloca aquí tu TOKEN de UbidotsUbidots ubidots(TOKEN);void setup() { Serial.begin(115200); /* TYPE_TCP se usa para enviar datos usando el método TCP si no llamas a esta función, la biblioteca se establece automáticamente como UDP */ ubidots.setMethod(TYPE_TCP); }void loop() { float value1 = analogRead(A0); float value2 = analogRead(A1); float value3 = analogRead(A2); ubidots.add("Variable_Name_One", value1); // Cambia por el nombre de tu variable ubidots.add("Variable_Name_Two", value2); ubidots.add("Variable_Name_Three", value3); ubidots.sendAll(); delay(5000);}Las bibliotecas de Ubidots disponibles en la plataforma Particle también tienen la función para establecer el método de transmisión de datos. Con esta función puedes cambiar del método UDP al método TCP.
10. Resumen
Con este sencillo tutorial, puedes POST y GET datos a/de Ubidots con la facilidad del Particle IDE y la placa RedBear Duo.
¡Ahora es el momento de crear Dashboards de Ubidots para visualizar tus datos y desplegar tu solución IoT! ¡Feliz desarrollo! :)
Otros lectores también han encontrado útil...