Los dispositivos Particle son kits de desarrollo de hardware compactos y fáciles de programar que proporcionan todo lo que necesitas para construir proyectos conectados a la nube. Particle combina un microcontrolador ARM, un chip de comunicación (WiFi, GPRS o 3G) y un IDE web con toneladas de ejemplos y bibliotecas de la comunidad para hacer que tu desarrollo con Ubidots sea lo más simple y eficiente posible.
Este tutorial explica cómo interactuar con la API REST de Ubidots utilizando Particle.
Requisitos
Cable Micro USB.
Cuenta Ubidots activa
Biblioteca Particle de Ubidots
Tabla de Contenidos
Configuración del Software del Dispositivo
Biblioteca Ubidots: protocolos HTTP, TCP y UDP
Enviar Valores a Ubidots
Enviar Valores con Contexto
Enviar Valores con Marca de Tiempo
Enviar Valores con coordenadas GPS
Recuperar Valores de Ubidots
7.1. Recuperar múltiples últimos Valores de variables a través de TCP
1. Configuración del Software del Dispositivo
Paso 1: Configura y reclama tu Dispositivo Particle:
– Particle Electron: Sigue estos pasos para configurar el plan de datos de Particle. Pasos de Particle Electron.
– Particle Photon: Puedes configurar tu Particle Photon ya sea Usando tu smartphone o Conectándolo a tu computadora a través de USB.
Paso 2: Crear Nueva Aplicación
En el IDE Web de Particle Build, crea una nueva aplicación. Para detalles adicionales sobre cómo "Crear Nueva Aplicación," simplemente haz clic aquí y sigue el sencillo proceso de 3 pasos.
NOTA: Titulamos el proyecto de esta guía "Myapp". Cualquier nombre que selecciones, necesitarás referirte al mismo nombre a lo largo de tu proyecto. Siempre que veas "Myapp," sabe que esto es una referencia a tu aplicación en el IDE de Particle.
Paso 3: Agregar la biblioteca Ubidots al proyecto "Myapp":
Ve a la opción de Bibliotecas en el panel lateral derecho
Busca "Ubidots"
Selecciona la Biblioteca Ubidots
NOTA: Ten cuidado de no elegir la Biblioteca UbidotsMQTTHaz clic en "INCLUIR EN EL PROYECTO".
Selecciona el proyecto para incluir la biblioteca. En este caso "Myapp".
Haz clic en "CONFIRMAR".
2. Biblioteca Ubidots: Protocolos HTTP, TCP y UDP.
La biblioteca de Ubidots para dispositivos Particle es un firmware ligero que utiliza en el código Declaración de Instancia y Selección de Protocolo con invocación de método estándar para enviar/recuperar datos a/de Ubidots.
Por Ejemplo:
– Declaración de Instancia y Selección de Protocolo:
HTTP:
Ubidots ubidots(UBI_TOKEN, UBI_HTTP);TCP:
Ubidots ubidots(UBI_TOKEN, UBI_TCP);UDP:
Ubidots ubidots(UBI_TOKEN, UBI_UDP);
Usando una de las instancias y protocolos anteriores, tu dispositivo se autentica con la nube de Ubidots utilizando el UBI_TOKEN (TOKENS) y selecciona el método para comunicarse utilizando una de las banderas UBI_HTTP, UBI_TCP o UBI_UDP.
Para información adicional sobre la biblioteca de Ubidots para dispositivos Particle, consulta nuestro repositorio de GitHub.
3. Enviar Valores a Ubidots
En los ejemplos a continuación encontrarás códigos de muestra para integrar a Ubidots desde Dispositivos Particle a través de los protocolos mencionados anteriormente.
Siguiendo los pasos a continuación, podrás enviar datos a Ubidots a través de cualquiera de los protocolos soportados por la biblioteca: HTTP, TCP o UDP.
Paso 1: Copia y pega el siguiente código en tu proyecto "Myapp".
Paso 2: Ingresa un TOKEN válido de tu cuenta de Ubidots.
Paso 3: Elige Protocolo comentando/descomentando la instancia apropiada.
Paso 4: Descomenta la línea 36 si deseas ver mensajes de depuración en el monitor serial.
Paso 5: Cambia las etiquetas de variable en las líneas 43, 44, 45 según sea necesario.
Paso 6: Verifica el código.
Paso 7: Flashea el código a tus dispositivos Particle.
Paso 8: Revisa tu cuenta de Ubidots.
// Este ejemplo envía datos a múltiples variables a // la API de Ubidots a través de HTTP, TCP o UDP./**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Instancias y Constantes ****************************************/#ifndef TOKEN#define TOKEN "Your_Token" // Pon aquí tu TOKEN de Ubidots#endifUbidots ubidots(TOKEN, UBI_TCP); // Comenta esta línea para usar otro protocolo.//Ubidots ubidots(TOKEN, UBI_HTTP); // Descomenta esta línea para usar el protocolo HTTP.//Ubidots ubidots(TOKEN, UBI_UDP); // Descomenta esta línea para usar el protocolo UDP/**************************************** * Funciones Auxiliares ****************************************///Pon 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); bool bufferSent = false; bufferSent = ubidots.send(); // Enviará datos a una etiqueta de dispositivo que coincida con el Id del dispositivo if(bufferSent){ // Haz algo si los valores se enviaron correctamente Serial.println("Valores enviados por el dispositivo"); } delay(5000);}4. Enviar Valores con Contexto
Siguiendo los pasos a continuación, podrás enviar datos con contexto a Ubidots utilizando cualquiera de los protocolos soportados por la biblioteca: HTTP, TCP o UDP.
Paso 1: Copia y pega el siguiente código en el proyecto "Myapp".
Paso 2: Ingresa un TOKEN válido de tu cuenta de Ubidots.
Paso 3: Elige Protocolo comentando/descomentando la instancia apropiada.
Paso 4: Descomenta la línea 36 si deseas ver mensajes de depuración en el monitor serial.
Paso 5: Cambia las etiquetas de variable en la línea 52 según sea necesario.
Paso 6: Verifica el código.
Paso 7: Flashea el código a tus dispositivos Particle.
Paso 8: Revisa tu cuenta de Ubidots.
// Este ejemplo envía datos y contexto a una variable a // la API de Ubidots a través de HTTP, TCP o UDP./**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Instancias y Constantes ****************************************/#ifndef TOKEN#define TOKEN "Your_Token" // Pon aquí tu TOKEN de Ubidots#endifUbidots ubidots(TOKEN, UBI_TCP); // Comenta esta línea para usar otro protocolo.//Ubidots ubidots(TOKEN, UBI_HTTP); // Descomenta esta línea para usar el protocolo HTTP.//Ubidots ubidots(TOKEN, UBI_UDP); // Descomenta esta línea para usar el protocolo UDP./**************************************** * Funciones Auxiliares ****************************************///Pon 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 value = analogRead(A0); /* Agrega pares clave-valor de contexto */ ubidots.addContext("weather-status", "sunny"); ubidots.addContext("time", "11:40:56 pm"); /* Reserva memoria para almacenar el array de contexto */ char* context = (char *) malloc(sizeof(char) * 60); /* Construye el contexto con los pares clave-valor para enviar a Ubidots */ ubidots.getContext(context); ubidots.add("temperature", value, context); // Cambia por el nombre de tu variable bool bufferSent = false; bufferSent = ubidots.send(); // Enviará datos a una etiqueta de dispositivo que coincida con el Id del dispositivo if(bufferSent){ // Haz algo si los valores se enviaron correctamente Serial.println("Valores enviados por el dispositivo"); } free(context); delay(5000);}5. Enviar Valores con Marca de Tiempo
Siguiendo los pasos a continuación, podrás enviar datos con marca de tiempo a Ubidots a través de cualquiera de los protocolos soportados por la biblioteca: HTTP, TCP o UDP.
Paso 1: Copia y pega el siguiente código en el proyecto "Myapp".
Paso 2: Ingresa un TOKEN válido de tu cuenta de Ubidots.
Paso 3: Elige Protocolo comentando/descomentando la instancia apropiada.
Paso 4: Descomenta la línea 36 si deseas ver mensajes de depuración en el monitor serial.
Paso 5: Cambia las etiquetas de variable en las líneas 43 según sea necesario.
Paso 6: Verifica el código.
Paso 7: Flashea el código a tus dispositivos Particle.
Paso 8: Revisa tu cuenta de Ubidots.
// Este ejemplo envía datos junto con la marca de tiempo en el estándar POSIX ms// a una variable a la API de Ubidots a través de HTTP, TCP o UDP./**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Instancias y Constantes ****************************************/#ifndef TOKEN#define TOKEN "Your_Token" // Pon aquí tu TOKEN de Ubidots#endifUbidots ubidots(TOKEN, UBI_TCP); // Comenta esta línea para usar otro protocolo.//Ubidots ubidots(TOKEN, UBI_HTTP); // Descomenta esta línea para usar el protocolo HTTP.//Ubidots ubidots(TOKEN, UBI_UDP); // Descomenta esta línea para usar el protocolo UDP./**************************************** * Funciones Auxiliares ****************************************///Pon 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 value = analogRead(A0); unsigned long timestamp_seconds = Time.now(); ubidots.add("temperature", value, NULL, timestamp_seconds); // Cambia por el nombre de tu variable bool bufferSent = false; bufferSent = ubidots.send(); // Enviará datos a una etiqueta de dispositivo que coincida con el Id del dispositivo if(bufferSent){ // Haz algo si los valores se enviaron correctamente Serial.println("Valores enviados por el dispositivo"); } delay(5000);}6. Enviar Valores con Coordenadas GPS
Siguiendo los pasos a continuación, podrás enviar datos con Coordenadas GPS como contexto a Ubidots a través de cualquiera de los protocolos soportados por la biblioteca: HTTP, TCP o UDP.
Paso 1: Copia y pega el siguiente código en el proyecto "Myapp".
Paso 2: Ingresa un TOKEN válido de tu cuenta de Ubidots.
Paso 3: Elige Protocolo comentando/descomentando la instancia apropiada.
Paso 4: Descomenta la línea 36 si deseas ver mensajes de depuración en el monitor serial.
Paso 5: Cambia las etiquetas de variable en las líneas 65 según sea necesario.
Paso 6: Verifica el código.
Paso 7: Flashea el código a tus dispositivos Particle.
Paso 8: Revisa tu cuenta de Ubidots.
// Este ejemplo envía datos con coordenadas GPS codificadas // a una variable a la API de Ubidots a través de HTTP, TCP o UDP./**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Constantes ****************************************/#ifndef TOKEN#define TOKEN "Your_Token" // Pon aquí tu TOKEN de Ubidots#endifUbidots ubidots(TOKEN, UBI_TCP); // Comenta esta línea para usar otro protocolo.//Ubidots ubidots(TOKEN, UBI_HTTP); // Descomenta esta línea para usar el protocolo HTTP.//Ubidots ubidots(TOKEN, UBI_UDP); // Descomenta esta línea para usar el protocolo UDP./**************************************** * Funciones Auxiliares ****************************************///Pon 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 value = analogRead(A0); /* Coordenadas codificadas */ float latitude = 37.773; float longitude = -6.2345; /* Reserva memoria para almacenar las claves de contexto, agrega tantas como necesites */ char* str_lat = (char *) malloc(sizeof(char) * 10); char* str_lng = (char *) malloc(sizeof(char) * 10); /* Guarda como char las coordenadas */ sprintf(str_lat, "%f", latitude); sprintf(str_lng, "%f", longitude); /* Reserva memoria para almacenar el array de contexto */ char* context = (char *) malloc(sizeof(char) * 30); /* Agrega pares clave-valor de contexto */ ubidots.addContext("lat", str_lat); ubidots.addContext("lng", str_lng); /* Construye el contexto con las coordenadas GPS para enviar a Ubidots */ ubidots.getContext(context); /* Envía la posición */ ubidots.add("position", value, context); // Cambia por el nombre de tu variable bool bufferSent = false; bufferSent = ubidots.send(); // Enviará datos a una etiqueta de dispositivo que coincida con el Id del dispositivo if(bufferSent){ // Haz algo si los valores se enviaron correctamente Serial.println("Valores enviados por el dispositivo"); } /* libera memoria */ free(str_lat); free(str_lng); free(context); delay(5000);}7. Recuperar Valores de Ubidots
Siguiendo los pasos a continuación, podrás recuperar datos de Ubidots utilizando HTTP o TCP.
NOTA IMPORTANTE: El protocolo UDP no soporta la recuperación de datos ya que este protocolo está destinado únicamente a reenviar mensajes del cliente al servidor.
Paso 1: Copia y pega el siguiente código en el proyecto "Myapp".
Paso 2: Ingresa un TOKEN válido de tu cuenta de Ubidots.
Paso 3: Elige Protocolo comentando/descomentando la instancia apropiada.
Paso 4: Descomenta la línea 33 si deseas ver mensajes de depuración en el monitor serial.
Paso 5: Ingresa Etiqueta de Dispositivo y Variable en la línea 38 para recuperar el último valor.
Paso 6: Verifica el código.
Paso 7: Flashea el código a tus dispositivos Particle.
Paso 8: Revisa tu cuenta de Ubidots.
// Este ejemplo recupera el último valor de una variable de la API de Ubidots./**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Instancias y Constantes ****************************************/#ifndef TOKEN#define TOKEN "Your_Token" // Pon aquí tu TOKEN de Ubidots#endifUbidots ubidots(TOKEN, UBI_TCP); // Comenta esta línea para usar otro protocolo.//Ubidots ubidots(TOKEN, UBI_HTTP); // Descomenta esta línea para usar el protocolo HTTP./**************************************** * Funciones Auxiliares ****************************************///Pon 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() { /* Obtiene el último valor usando. */ float value = ubidots.get("weather-station", "temperature"); // Evalúa los resultados obtenidos if(value!=ERROR_VALUE){ Serial.print("valor:"); Serial.println(value); } delay(5000);}7.1. Recuperar múltiples últimos valores de variables a través de TCP
Siguiendo los pasos a continuación, podrás recuperar múltiples últimos valores de variables de Ubidots a través de TCP.
Paso 1: Copia y pega el siguiente código en el proyecto "Myapp".
Paso 2: Ingresa un TOKEN válido de tu cuenta de Ubidots.
Paso 3: Descomenta la línea 33 si deseas ver mensajes de depuración en el monitor serial.
Paso 4: Ingresa Etiquetas de Dispositivo y Variable en las líneas 38 y 39 respectivamente para recuperar los últimos valores. Ten en cuenta que las etiquetas de variable deben estar en formato de lista separada por comas
Paso 5: Verifica el código.
Paso 6: Flashea el código a tus dispositivos Particle.
Paso 7: Revisa tu cuenta de Ubidots.
Nota importante: Para evitar problemas de desbordamiento de memoria, recomendamos agregar hasta 20 etiquetas de variable.
// Este ejemplo recupera el último valor de una variable de la API de Ubidots// usando el protocolo TCP./**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Constantes ****************************************/#ifndef UBIDOTS_TOKEN#define UBIDOTS_TOKEN "" // Pon aquí tu TOKEN de Ubidots#endifUbidots ubidots(UBIDOTS_TOKEN, UBI_TCP);/**************************************** * Funciones Auxiliares ****************************************/// Pon aquí tus funciones auxiliares/**************************************** * Funciones Principales ****************************************/void setup() { Serial.begin(115200);// Descomenta esta línea para imprimir mensajes de depuración ubidots.setDebug(true);}void loop() { /* Obtiene múltiples últimos valores de una lista de variables separadas por comas */ const char* deviceLabel = "machine1"; const char* variablesList = "var1,var2,var3"; tcpMap myMap = ubidots.getMultipleValues(deviceLabel, variablesList); /* Accede a los valores recuperados según la lista ordenada devuelta */ float var1_value = myMap[0]; float var2_value = myMap[1]; float var3_value = myMap[2]; // Evalúa los resultados obtenidos if (var1_value != ERROR_VALUE) { Serial.printf("Valor para la variable var_1: %f", var1_value); } if (var2_value != ERROR_VALUE) { Serial.printf("Valor para la variable var_2: %f", var2_value); } if (var3_value != ERROR_VALUE) { Serial.printf("Valor para la variable var_2: %f", var3_value); } delay(5000);}Otros usuarios también encontraron útil: