"En el pasado, construir más allá de una conexión de un solo punto requería soluciones de hardware de alto costo e implementaciones de software para conectar los espacios intermedios necesarios para la comunicación de dispositivo a dispositivo. A medida que las plataformas de IoT han madurado, han comenzado a adoptar una alternativa de bajo consumo y bajo costo que puede cerrar las brechas entre estos dispositivos: redes de malla inalámbrica.

Particle Mesh es una tecnología de red de malla inalámbrica construida sobre el protocolo de red Thread, y diseñada para conectar los espacios entre las implementaciones de Wi-Fi y celulares existentes con redes locales que son de bajo costo, seguras y ultra confiables.

Los dispositivos IoT tradicionales que utilizan conectividad Wi-Fi y celular dependen de la nube para retransmitir mensajes entre dispositivos. Esto funciona muy bien cuando estás creando un producto independiente, pero a veces necesitas más que eso. Los kits de desarrollo de Particle Mesh no solo están conectados a Internet, son puertas de enlace a Internet y crean una malla inalámbrica local a la que otros dispositivos pueden unirse. Estos dispositivos trabajan juntos para asegurar que los mensajes lleguen a donde deben, y alimentan productos que no son posibles o económicamente viables con conectividad Wi-Fi y celular. Particle Mesh le da a cada dispositivo IoT una red local para entender y conectarse con el mundo que lo rodea, asegurando que los productos tengan la información que necesitan para sonar la alarma cuando más importa"
– Cita de el blog de Particle

En seguimiento, este artículo te guiará a través del proceso de integración de dispositivos Particle Mesh para enviar datos desde un Endpoint o Gateway de Particle, conocidos como Xenon y Argon/Boron, respectivamente, a Ubidots utilizando uno de los protocolos de nube IoT soportados en la biblioteca de Ubidots para Particle, a saber, HTTP, TCP/UDP o Webhooks de Particle.

Requisitos

Dispositivos Particle Mesh: 1 Argon/Boron y 1 Xenon
Cable Micro USB
Cuenta Ubidots activa
Biblioteca de Particle de Ubidots

1. Configuración del Dispositivo

Paso 1: Configura y reclama tus Dispositivos Particle Mesh:

– Particle Argon/Boron/Xenon: reclama y configura tus dispositivos Mesh.
– Guía rápida para dispositivos Mesh: sigue las guías rápidas de Particle aquí.

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 de Ubidots al proyecto "Myapp":

Ve a la opción de Bibliotecas en el panel lateral derecho
Busca "Ubidots"
Selecciona la Biblioteca de Ubidots
NOTA: Ten cuidado de no elegir la Biblioteca UbidotsMQTT
Haz clic en "INCLUIR EN EL PROYECTO".
Selecciona el proyecto para incluir la biblioteca. En este caso "Myapp".
Haz clic en "CONFIRMAR".

2. Biblioteca de Ubidots: Selección de Instancia de Malla y Protocolo de Nube.

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 de Nube con invocación de método estándar para envolver el protocolo de Malla de Particle y enviar datos a Ubidots utilizando cualquiera de los protocolos de nube soportados.

Por Ejemplo:

– Declaración de Instancia: Este tipo de instancia solo se aplica a dispositivos capaces de Malla de Particle.

Malla: Ubidots ubidots(UBI_TOKEN, UBI_MESH);

Usando la instancia anterior, tu dispositivo está autenticado con la nube de Ubidots usando el UBI_TOKEN (TOKENS) e indica a la biblioteca que tu dispositivo es capaz de Malla mediante la bandera UBI_MESH.

– Selección de Protocolo de Nube: una vez que la instancia de Ubidots se declara para indicar que el dispositivo va a manejar mensajes de red de Malla, la biblioteca también requiere un comando adicional para indicar qué protocolo de nube entre los disponibles, HTTP, TCP o UDP, se utilizará para enviar datos a Ubidots.

HTTP: ubidots.setCloudProtocol(UBI_HTTP);
TCP: ubidots.setCloudProtocol(UBI_TCP);
UDP: ubidots.setCloudProtocol(UBI_UDP);

Cualquiera de estas líneas debe ser invocada en la función setup() de tu firmware de la siguiente manera:

void setup() {    ubidots.setCloudProtocol(UBI_HTTP);}

NOTA: Ten cuidado de no usar el método setCloudProtocol(iotProtocol) en dispositivos Xenon ya que estos no tienen capacidades de conexión a Internet, solo los Argon/Boron pueden llamarlo.

Para información adicional sobre la biblioteca de Ubidots para dispositivos Particle, consulta nuestro repositorio de GitHub.

3. Enviar datos a Ubidots a través de Malla y HTTP, TCP o UDP.

En los ejemplos a continuación encontrarás códigos de muestra para integrar a Ubidots desde Dispositivos Particle Mesh a través de los protocolos mencionados anteriormente.

Esta sección se dividirá en 2. La primera parte hace referencia al código necesario en el gateway de Particle Mesh, es decir, los dispositivos Argon/Boron, para manejar la red de Malla y enviar todos los mensajes provenientes de los Endpoints Xenon a Ubidots utilizando el protocolo de nube seleccionado. En segundo lugar, tenemos el código necesario en el Endpoint Xenon para leer un puerto analógico y enviarlo a través de la red de Malla al gateway.

NOTA: Necesitarás crear dos aplicaciones separadas en el IDE de Particle siguiendo los pasos 2 y 3 en la sección "1. Configuración del Dispositivo"

A. Pasos para Gateways de Particle Mesh: Argon/Boron

Paso 1: Copia y pega el siguiente código en tu proyecto "MyAppMeshGateways".
Paso 2: Ingresa un TOKEN válido de tu cuenta de Ubidots.
Paso 3: Elige Protocolo comentando/descomentando el método apropiado en la función setup().
Paso 4: Descomenta la línea 38 si deseas ver mensajes de depuración en el monitor serial.
Paso 5: Verifica el código.
Paso 6: Flashea el código a tu dispositivo gateway de Particle.

/**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Instancias y Constantes ****************************************/#ifndef UBIDOTS_TOKEN#define UBIDOTS_TOKEN "....." //Pon aquí tu TOKEN de Ubidots#endifUbidots ubidots(UBIDOTS_TOKEN, UBI_INDUSTRIAL, UBI_MESH);/**************************************** * Funciones Auxiliares ****************************************/// Pon aquí tus funciones auxiliares/**************************************** * Funciones Principales ****************************************/void setup() {  Serial.begin(115200);  /*    Descomenta UNA de las siguientes líneas para elegir un Protocolo de nube diferente para enviar datos    [DEFAULT] = UBI_TCP  */  // ubidots.setCloudProtocol(UBI_HTTP);  // ubidots.setCloudProtocol(UBI_TCP);  // ubidots.setCloudProtocol(UBI_UDP);  // Descomenta esta línea para imprimir mensajes de depuración  // ubidots.setDebug(true);}void loop() {     ubidots.meshLoop(); }

B. Pasos para Endpoints de Particle Mesh: Xenon

Paso 1: Copia y pega el siguiente código en tu proyecto "MyAppMeshEndpoints".
Paso 2: Ingresa un TOKEN válido de tu cuenta de Ubidots, y una VARIABLE_LABEL.
Paso 3: Descomenta la línea 30 si deseas ver mensajes de depuración en el monitor serial.
Paso 4: Verifica el código.
Paso 5: Flashea el código a tu dispositivo endpoint de Particle.
Paso 6: Verifica tu cuenta de Ubidots.

/**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Instancias y Constantes ****************************************/#ifndef UBIDOTS_TOKEN#define UBIDOTS_TOKEN "...."  // Pon aquí tu TOKEN de Ubidots#define VARIABLE_LABEL "...." // Pon aquí tu ETIQUETA DE VARIABLE de Ubidots#endifUbidots ubidots(UBIDOTS_TOKEN, UBI_INDUSTRIAL, UBI_MESH);/**************************************** * 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);  Serial.println("Agregando valor");  ubidots.add(VARIABLE_LABEL, value);  ubidots.meshPublishToUbidots();  Serial.println("terminado");  delay(5000);}

4. Enviar datos a Ubidots a través de Malla y Webhooks de Particle.

Usar Webhooks de Particle para enviar datos desde tus endpoints Xenon a Ubidots, primero pasando por un gateway de Malla como el Argon o Boron, requiere crear un webhook en tu consola de particle. Sigue los pasos a continuación para hacerlo:

Paso 1: Ve a tu cuenta de Particle, inicia sesión y crea una "Nueva Integración"
Paso 2: Ve a tu consola de particle y elige Integraciones.
Paso 3: Selecciona "Nueva Integración"
Paso 4: Selecciona "Webhook"
Paso 5: Nombra el nuevo Webhook
Paso 6: Agrega la URL de muestra a continuación
URL del Webhook:

https://industrial.api.ubidots.com/api/v1.6/devices/##{#{{PARTICLE_DEVICE_ID}}}

NOTA IMPORTANTE: Vamos a llamar y asignar automáticamente el ID del Dispositivo de Particle para asegurar que la etiqueta del dispositivo en Ubidots permanezca única. Para hacer esto, vamos a usar la clave predefinida disponible de Particle:##{#{{PARTICLE_DEVICE_ID}}} Esta llamada asignará automáticamente a la URL el ID del dispositivo que activó el webhook.

Paso 7: Selecciona el método "POST"
Paso 8: Selecciona "Cuerpo Personalizado" Formato de Solicitud
Paso 9: Haz que el Webhook esté disponible para TODOS los dispositivos de tu cuenta eligiendo "Cualquiera"

Paso 10: Selecciona CONFIGURACIÓN AVANZADA

Completa el editor de texto como se ve a continuación:

##{#{{PARTICLE_EVENT_VALUE}}}

En las opciones de Encabezados HTTP de la configuración, completa como se ve a continuación:

X-Auth-Token | TU_TOKEN_UBIDOTS_AQUÍ

Content-Type | application/json

Para encontrar tu TOKEN de Ubidots, consulta aquí.

Paso 11: CREA WEBHOOK y verifica que los datos se estén transmitiendo a Ubidots.

Después de crear Webhooks de Particle en tu consola, aquí está la parte de codificación de esta sección. Sigue los dos conjuntos de pasos de código a continuación: uno para los gateways y el segundo para el endpoint:

A. Pasos para Gateways de Particle Mesh: Argon/Boron

/**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Instancias y Constantes ****************************************/#ifndef UBIDOTS_TOKEN#define UBIDOTS_TOKEN "....." //Pon aquí tu TOKEN de Ubidots#endifUbidots ubidots(UBIDOTS_TOKEN, UBI_INDUSTRIAL, UBI_MESH);/**************************************** * Funciones Auxiliares ****************************************/// Pon aquí tus funciones auxiliares/**************************************** * Funciones Principales ****************************************/void setup() {  Serial.begin(115200);  ubidots.setCloudProtocol(UBI_PARTICLE);  // Descomenta esta línea para imprimir mensajes de depuración  // ubidots.setDebug(true);}void loop() {     ubidots.meshLoop(); }

B. Pasos para Endpoints de Particle Mesh: Xenon

Paso 1: Copia y pega el siguiente código en tu proyecto "MyAppMeshEndpoints".
Paso 2: Ingresa un TOKEN válido de tu cuenta de Ubidots.
Paso 3: Descomenta la línea 30 si deseas ver mensajes de depuración en el monitor serial.
Paso 4: Asegúrate de que la línea ubidots.meshPublishToUbidots("Ubidots"); ingrese el nombre de tu Webhook. En nuestro caso es "Ubidots"
Paso 5: Verifica el código.
Paso 6: Flashea el código a tu dispositivo endpoint de Particle.
Paso 7: Verifica tu cuenta de Ubidots.

/**************************************** * Incluir Bibliotecas ****************************************/#include "Ubidots.h"/**************************************** * Definir Instancias y Constantes ****************************************/#ifndef UBIDOTS_TOKEN#define UBIDOTS_TOKEN "...."  // Pon aquí tu TOKEN de Ubidots#define VARIABLE_LABEL "...." // Pon aquí tu ETIQUETA DE VARIABLE de Ubidots#endifUbidots ubidots(UBIDOTS_TOKEN, UBI_INDUSTRIAL, UBI_MESH);/**************************************** * 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);  Serial.println("Agregando valor");  ubidots.add(VARIABLE_LABEL, value);  ubidots.meshPublishToUbidots("Ubidots");  Serial.println("terminado");  delay(5000);}

Otros usuarios también encontraron útil: