El ONE V3 es una de las placas de hardware ofrecidas por SODAQ, una empresa de hardware con la visión de habilitar a las personas y negocios conectando sus dispositivos a internet de manera eficiente y fuera de la red.
Esta increíble y fácil de usar placa nos permite crear varios tipos de aplicaciones IoT como Agricultura Inteligente, Seguimiento de Flotas, Ciudades Inteligentes, y más. Esta placa se destaca gracias a su uso eficiente de la duración de la batería, logrado a través de una lógica de interrupciones bien gestionada.
Algunas características de hardware incluyen:
Compatible con Arduino
Modo de Sueño Profundo: 23uA
Archivos de placa altamente integrados
Microcontrolador ARM Cortex M0+ de 32 bits Atmel SAMD21
Módulo LoRa Microchip RN2903A
GPS uBlox EVA-8M
Magnetómetro 3D y acelerómetro 3D LSM303AGR de ultra bajo consumo
Controlador de carga y batería recargable de celda de moneda a bordo
Recomendamos encarecidamente consultar la documentación oficial de SODAQ para aprender más sobre el ONE V3, como códigos de muestra que puedes usar más tarde, especificaciones de hardware para este modelo y también para otras placas de la familia SODAQ.
¡Ahora es el momento de empezar a hackear! Esta guía te proporcionará todos los conceptos básicos para comenzar a gestionar mensajes de uplink y downlink con el ONE V3, Ubidots y TTN.
NOTA IMPORTANTE: Los códigos de muestra proporcionados en esta guía no están diseñados para gestionar la batería de la manera más eficiente posible. Su propósito principal es mostrar la gestión de mensajes de uplink y downlink utilizando la biblioteca de The Things Network.
Requisitos
Paso a Paso
Configuración del Arduino IDE
Registro del dispositivo TTN
Gestión de mensajes de uplink
Envío de mensajes a TTN
Configuración de carga útil personalizada
Configuración de integración de Ubidots
Verificación de datos
Gestión de mensajes de downlink
Creación de variable
Creación de evento de downlink en Ubidots
Verificación de datos
Demo
Resumen
1. Configuración del Arduino IDE
Para poder trabajar con el SODAQ ONE V3 en el Arduino IDE, necesitas instalar la Plataforma SODAQ utilizando el Gestor de Placas de Arduino preconfigurado asignando la siguiente URL en el menú de Preferencias:
http://downloads.sodaq.net/package_sodaq_samd_index.json
2. Con la plataforma SODAQ instalada, selecciona el dispositivo SODAQ con el que estás trabajando. En este caso, estamos trabajando con un “SODAQ ONE”. Para seleccionar la placa desde tu Arduino IDE, selecciona Herramientas > Placa > SODAQ ONE
3. Instala la biblioteca “The Things Network”.
NOTA: Si no estás familiarizado con agregar nuevas placas o instalar bibliotecas dentro del Arduino IDE, consulta este artículo para obtener orientación adicional.
2. Registro del dispositivo TTN
Para comenzar a gestionar los datos del dispositivo con el servidor de red TTN LoRaWAN, debes registrar el SODAQ ONE V3 dentro de una aplicación. Pero, necesitarás el EUI de hardware que es el identificador único de tu placa. Los pasos a continuación muestran cómo obtener las credenciales requeridas, además del proceso de registro del dispositivo.
1. Carga el siguiente código en la placa para obtener el EUI de hardware para registrar tu dispositivo. Una vez que el código esté cargado, abre el monitor serial y escribe el comando sys get hweui para obtener el EUI del dispositivo.
NOTA: La configuración del monitor serial debe ser “Ambos NL & CR”
/* * Compatible con: * SODAQ MBILI * SODAQ Autonomo * SODAQ ONE * SODAQ ONE BETA * SODAQ EXPLORER */#include "Arduino.h"#if defined(ARDUINO_AVR_SODAQ_MBILI)#define debugSerial Serial #define loraSerial Serial1#elif defined(ARDUINO_SODAQ_AUTONOMO) || defined(ARDUINO_SODAQ_ONE) || defined(ARDUINO_SODAQ_ONE_BETA)#define debugSerial SerialUSB #define loraSerial Serial1#elif defined(ARDUINO_SODAQ_EXPLORER)#define debugSerial SerialUSB#define loraSerial Serial2#else// por favor selecciona una placa sodaq#endifvoid setup() { // Habilitar módulo LoRa #if defined(ARDUINO_SODAQ_AUTONOMO) pinMode(BEE_VCC, OUTPUT); digitalWrite(BEE_VCC, HIGH); //establecer alimentación de entrada BEE alta #elif defined(ARDUINO_AVR_SODAQ_MBILI) pinMode(20, OUTPUT); digitalWrite(20, HIGH); //establecer alimentación de entrada BEE alta #endif // Reinicio duro del módulo RN #if defined(LORA_RESET) pinMode(LORA_RESET, OUTPUT); digitalWrite(LORA_RESET, LOW); delay(100); digitalWrite(LORA_RESET, HIGH); delay(100); #endif while ((!debugSerial) && (millis() < 10000)){ // esperar 10 segundos para el monitor serial } debugSerial.begin(57600); loraSerial.begin(57600); debugSerial.println("Por favor envía el comando");}void loop() { //enviar y recibir datos con serial if (debugSerial.available()){ //debugSerial.print("ENVIAR: "); while (debugSerial.available()) { uint8_t inChar = debugSerial.read(); //debugSerial.write(inChar); loraSerial.write(inChar); } } if (loraSerial.available()){ //debugSerial.print("RECIBIR: "); while (loraSerial.available()) { uint8_t inChar = loraSerial.read(); debugSerial.write(inChar); } }}(código fuente: https://support.sodaq.com/sodaq-one/loraone-lora-basic-sketch/)
Una vez que el código esté cargado en la placa, deberías recibir el siguiente resultado después de solicitar el EUI de hardware:
Ahora con el EUI de hardware obtenido, es hora de registrar un dispositivo dentro de una aplicación en TTN.
2. Primero, ve a la consola de TTN e ingresa a la sección de aplicaciones para agregar una nueva aplicación. Para crear la aplicación, simplemente presiona “agregar aplicación”:
Luego, en la siguiente página asigna los parámetros a continuación:
ID de Aplicación: El identificador único de tu aplicación en la red.
Descripción (opcional): una descripción legible por humanos.
Registro de manejador: manejador donde deseas registrar la aplicación.
Una vez que la aplicación esté creada, serás redirigido a la vista general de la aplicación.
3. Para registrar un dispositivo, ve a la pestaña de dispositivos. Luego presiona “Registrar Dispositivo”
Luego, en la siguiente página asigna los parámetros a continuación:
ID de Dispositivo: el identificador único para el dispositivo en la aplicación. El ID del dispositivo será inmutable.
EUI de Dispositivo: el identificador único para el dispositivo en la red.
El resto de los parámetros (App Key y App EUI) son asignados automáticamente por TTN.
Una vez que el registro del dispositivo esté completo, serás redirigido a la vista general del dispositivo. En este punto, el estado del dispositivo es “nunca visto” porque aún no estamos enviando ningún mensaje.
3. Gestión de mensajes de uplink
Para comenzar a enviar datos (mensajes de uplink) a Ubidots, necesitas establecer algunas configuraciones en el lado de TTN. Por favor, sigue los pasos a continuación cuidadosamente para establecer la comunicación adecuada entre tu dispositivo, TTN y Ubidots.
Envío de mensajes a TTN
Copia el siguiente código y colócalo en el Arduino IDE. Una vez que el código esté pegado, necesitas asignar los parámetros App EUI, App Key, y freqPlan.
El App EUI y App Key se pueden encontrar en la vista general del dispositivo. El freqPlan es la zona donde tu dispositivo va a ser desplegado.
CONSEJO PROFESIONAL: En la parte inferior de la vista general del dispositivo se puede encontrar un “código de ejemplo” listo para reemplazarlo en el código.
#include <TheThingsNetwork.h>// Definir pines de entradas/salidas#define relay 10#define potentiometer A11// Establecer tu AppEUI y AppKeyconst char *appEui = "0000000000000000";const char *appKey = "00000000000000000000000000000000";#define loraSerial Serial1#define debugSerial SerialUSB// Reemplaza REPLACE_ME con TTN_FP_EU868 o TTN_FP_US915#define freqPlan REPLACE_ME // asigna tu zona de frecuenciaTheThingsNetwork ttn(loraSerial, debugSerial, freqPlan);void setup(){ loraSerial.begin(57600); debugSerial.begin(9600); // Esperar un máximo de 10s para el Monitor Serial while (!debugSerial && millis() < 10000) ; // estado y solicitudes de unión debugSerial.println("-- ESTADO"); ttn.showStatus(); debugSerial.println("-- UNIR"); ttn.join(appEui, appKey); // Manejar datos de downlink ttn.onMessage(message); pinMode(relay, OUTPUT); pinMode(potentiometer, INPUT);}void loop(){ debugSerial.println("-- BUCLE"); uint32_t potentiometer_value = analogRead(potentiometer); debugSerial.println(potentiometer_value); // Preparar carga útil de 2 bytes para informar valores del potenciómetro byte payload[2]; payload[0] = highByte(potentiometer_value); payload[1] = lowByte(potentiometer_value); // Enviar valor del potenciómetro ttn.sendBytes(payload, sizeof(payload)); delay(10000);}/* * Declaración para el mensaje de downlink recibido */void message(const uint8_t *payload, size_t size, port_t port){ debugSerial.println("-- MENSAJE"); debugSerial.print("Recibido " + String(size) + " bytes en el puerto " + String(port) + ":"); if (payload[0] == 1) { digitalWrite(relay, HIGH); } else { digitalWrite(relay, LOW); } debugSerial.println();}2. Una vez que los parámetros hayan sido asignados correctamente, carga el código en la placa presionando el botón de carga ubicado en la parte superior izquierda de la interfaz del Arduino IDE.
3. Abre el Monitor Serial para depurar el código; verifica una vez que la solicitud de unión sea aceptada, y cada vez que un nuevo valor se esté enviando a TTN. Ahora, verás el estado del dispositivo activado.
4. Verifica si los datos que se han enviado están siendo recibidos correctamente en TTN. Para hacer esto, consulta la pestaña “Datos”:
Configuración de carga útil personalizada
1. Ve a la vista general de la Aplicación, y consulta la pestaña “Formatos de Carga Útil”. Luego, asigna el siguiente código en la sección del decodificador para formatear la carga útil en un formato permitido por Ubidots, que es un objeto JSON.
function Decoder(bytes, port) { // Decodificar un mensaje de uplink desde un buffer var potentiometer = (bytes[0] << 8) | bytes[1]; return { potentiometer: potentiometer };}2. [OPCIONAL] Una vez que hayas definido el código del decodificador en TTN, puedes probar la carga útil que se está enviando desde el dispositivo para verificar si el valor decodificado es el correcto.
Como puedes ver, el valor enviado desde mi dispositivo es igual a: 03 FF
Luego, asigna la misma carga útil enviada y el resultado debería ser el entero inicial impreso en el monitor serial:
3. Para finalizar, presiona el botón “Guardar funciones de carga útil”. En este punto, si consultas la sección de datos notarás cómo los datos se están decodificando automáticamente después de guardar la función de decodificador.
Configuración de integración de Ubidots
1. Ve a la pestaña “Integración” para agregar una nueva integración. Para crear una nueva integración, simplemente presiona “agregar integración”
Luego, selecciona Ubidots como integración:
En la siguiente ventana, asigna los siguientes parámetros:
ID de Proceso: El identificador único deseado para el proceso de integración
Clave de Acceso: La clave de acceso de la aplicación
Token: Tu Token de cuenta de Ubidots. (consulta esta guía para saber dónde encontrarlo.)
Con todos los parámetros asignados, tu integración debería verse como la de abajo:
Para finalizar, presiona “Agregar integración”. Serás redirigido a la vista general de la integración:
En este punto, una vez que se reciba un nuevo valor en TTN desde el dispositivo, se creará automáticamente un nuevo dispositivo en tu cuenta de Ubidots.
Verificación de datos
1. Ve a la sección de dispositivos de tu cuenta de Ubidots (Dispositivos > Dispositivos) para verificar el nuevo dispositivo creado identificado con el EUI del dispositivo.
Selecciona el dispositivo creado para verificar la variable encargada de recibir las entradas analógicas de la placa, que en este caso es la variable llamada “Potenciómetro”:
2. [ OPCIONAL - CONSEJO PROFESIONAL]: Si estás utilizando múltiples dispositivos para transmitir datos, te recomendamos editar el nombre del dispositivo, asignando un nombre amigable y legible para una identificación más fácil:
4. Gestión de mensajes de downlink
Para gestionar mensajes de downlink con Ubidots y TTN, necesitas crear un nuevo Evento de Ubidots condicionando una variable específica para activar el evento de Downlink de TTN. Para una explicación detallada sobre la integración, consulta esta guía.
Creación de variable
1. Crea una nueva variable en bruto llamada “relay” en el dispositivo creado automáticamente después de la configuración de la integración. Teniendo como resultado una variable vacía, como la que se muestra a continuación:
Creación de Evento de downlink en Ubidots
Ve a la sección de Eventos (Datos > Eventos) de tu cuenta de Ubidots, presiona el ícono naranja de más ubicado en la esquina superior derecha para crear un nuevo evento.
2. Para la lógica de activación selecciona la variable previamente creada “Relay” con la siguiente condición: Si el valor de la variable (relay activado) es igual a 1, entonces activa la acción.
Referencia a la imagen de abajo para una mejor comprensión.
NOTA: Para aprender más sobre la Lógica de Eventos de Ubidots, consulta esta guía.
Para continuar, presiona el ícono de flecha derecha ubicado en la parte inferior izquierda de la página.
3. Selecciona “TTN Downlink” como acción.
4. Asigna todos los parámetros requeridos según tu aplicación. Para aprender más sobre dónde encontrar los parámetros necesarios en TTN, consulta su documentación oficial.
NOTA IMPORTANTE: El evento de downlink requiere una nueva integración HTTP genérica en TTN, diferente de la de uplink creada previamente utilizando la integración de Ubidots para permitir los mensajes entrantes de Ubidots.
5. Tomando como referencia el caso de uso de un relé, el comportamiento esperado es programar un mensaje de downlink cada vez que el relé cambie su estado. Luego, una vez que se reciba un nuevo mensaje de uplink, el mensaje programado se envía al dispositivo para cambiar el estado del relé.
Para hacer esto, en la sección de “Activar disparador”, asigna el valor en bruto deseado que se enviará una vez que el valor de la variable relay esté activado (igual a 1). Es importante destacar que el valor en bruto necesita ser codificado en base64
Disparador de activación - Carga Útil en Bruto: 1 - “AQ==”
De manera similar, en la sección de “Volver a la normalidad”, asigna el valor en bruto deseado que se enviará una vez que el valor de la variable relay esté desactivado (igual a 0).
Volver a la normalidad - Carga Útil en Bruto: 0 - “AA==”
Para finalizar, presiona el ícono de verificación verde para guardar los cambios. Luego, presiona la flecha derecha para finalizar la creación del evento.
Verificación de datos
Ahora con la integración de downlink finalizada, crea un widget de interruptor relacionado con la variable relay para cambiar su estado, y verifica cómo el mensaje está siendo recibido en la sección de datos de TTN. Además, notarás cómo el mensaje también está siendo recibido en el dispositivo.
5. Demo
Comportamiento final utilizando TTN y Ubidots para gestionar mensajes de uplink/downlink:
6. Resumen
Las aplicaciones LPWAN están teniendo un gran impacto en el ecosistema IoT, y mucho más si las integraciones requeridas son rápidas de configurar, simplemente con unos pocos clics. Todo esto facilita la gestión de “cosas” para la comunidad IoT, empoderando a más ingenieros de IoT para hacer crecer sus implementaciones de manera rápida y confiable.