Conectar el Blues Notecard LoRa a Ubidots

El Notecard es una bomba de datos de dispositivo a nube que simplifica la adición de dispositivos IoT a una red a través de LoRa, con una API fácil de usar. Se monta en el Notecarrier, una placa de desarrollo que permite una rápida creación de prototipos y es esencial para la interfaz del Notecard con los sensores. En esta aplicación simple, el Notecard + Notecarrier ofrecen una forma rápida de crear prototipos y desarrollar un producto completo, que, cuando se combina con Ubidots, proporciona una aplicación de monitoreo completa.

Requisitos

Una cuenta activa de Blues Notehub.
Una cuenta activa de The Things Network.
Un gateway Blues indoor LoRaWAN u otro gateway.
Un Blues Notecard LoRa.
Un Notecarrier F o un Notecarrier B.

1. Configurar un Gateway en The Things Stack

Necesitarás un gateway conectado a The Things Stack para que esta integración funcione. Puede ser un gateway LoRa de Blues u otra marca/modelo. Puedes seguir la guía de Blues para este propósito.

2. Configuración del hardware y verificación de la conexión USB

Asegúrate de conectar la antena al Notecard LoRa y luego conéctalo a tu Notecarrier. Finalmente, usa un cable USB para conectar el Notecarrier a tu PC.

A continuación, ve a Notecard LoRa Quickstart de Blues. Allí, podrás usar la terminal en el navegador de Blues para comunicarte con la placa de Blues:

Haz clic en el botón ubicado en la esquina superior derecha de la pantalla, luego haz clic en el botón USB Notecard y luego selecciona tu dispositivo:

Consejo profesional: Si estás usando Linux y tienes problemas de conexión, intenta instalar libusb-1.0.0-dev. Si estás en Windows y no puedes conectarte, es posible que necesites instalar los controladores CP210x de SILabs.

Una vez conectado, ejecuta el siguiente comando para verificar si la conexión serial con el dispositivo está funcionando correctamente:

{"req" : "card.version" }

Si obtienes un JSON que contiene los datos del dispositivo, eso significa que la configuración se realizó correctamente y puedes proceder a la siguiente sección; de lo contrario, asegúrate de que tu cable USB no sea solo de alimentación, que las conexiones entre las placas sean correctas y que las dependencias enumeradas en el "consejo profesional" anterior estén instaladas.

3. Configurar el Notecard

Necesitarás definir el objeto o la estructura de los datos de tu interés para que el Notecard sepa cómo interpretar los datos. Supongamos, por ejemplo, que estás interesado en medir la temperatura y la humedad. En ese caso, podrías tener los datos en un objeto como el siguiente:

{
   "temp":34.1,
   "humid":50
}

Copia y pega el siguiente comando en la terminal del navegador para configurar dicha estructura de datos:

{
   "req":"note.template",
   "file":"data.qo",
   "port":1,
   "format":"compact",
   "body":{
      "temp":14.1,
      "humid":14.1
   }
}

Después de hacerlo, obtendrás una salida como la siguiente en la terminal de Blues:

Si planeas usar un esquema JSON diferente a este, simplemente reemplázalo bajo la clave body del comando proporcionado anteriormente.

4. Crear un proyecto en Notehub y asociar el Notecard a él

Inicia sesión en Notehub y crea un nuevo proyecto. Después de hacer esto, se mostrará el ProductUID para este proyecto; cópialo:

Regresa a la terminal serial en el navegador y ejecuta el siguiente comando, solo asegúrate de pegar tu ProductUID en él (en lugar de "<productUID>"):

{"req":"hub.set", "product": <productUID> }

El comando anterior es para vincular el hardware al proyecto creado en Notehub.

El siguiente paso es realizar una sincronización entre el Notecard y Notehub. Ejecuta el siguiente comando:

{"req":"hub.sync"}

Después de hacer eso, deberías poder ver tu dispositivo agregado al proyecto:

Ahora que el dispositivo está asociado al proyecto, vamos a simular una transmisión de datos. Para hacer esto, ejecuta el siguiente comando:

{"req":"note.add","file":"data.qo","body":{"temp":35.5,"humid":56.23}}

Ahora dirígete a la sección Eventos dentro de Notehub. Allí, podrás ver los datos enviados desde el Notecard a Notehub:

5. Enrutar los datos a Ubidots

El siguiente paso es enrutar los datos desde Notehub a Ubidots. Ve a tu cuenta de Ubidots, haz clic en Dispositivos → Funciones y crea una nueva UbiFunction con los siguientes parámetros:

Nombre: Ingresa un nombre para la UbiFunction.
Método: POST.
Runtime: Para este ejemplo, se eligió Python 3.11, sin embargo, puedes seleccionar el que prefieras.
Token: Selecciona el token de Ubidots que deseas usar para esta aplicación en particular.

Después de crear la UbiFunction, copia su URL del endpoint HTTPS. No te preocupes por el código de la UbiFunction por el momento.

Ahora, regresa a tu proyecto en Notehub y haz clic en la pestaña Routes:

Desde allí, crea una nueva ruta de Solicitudes/respuestas HTTP/HTTPS generales.

Configura los campos requeridos de la ruta de Solicitudes/respuestas HTTP/HTTPS generales de la siguiente manera:

Nombre de la ruta: Elige cualquier nombre.
URL: Pega aquí la URL del endpoint HTTPS de la UbiFunction.
Menú desplegable de HTTP Headers: Selecciona la opción "headers adicionales".
Header: Escribe X-Auth-Token aquí.
Valor del header: El token de Ubidots que usaste anteriormente en la configuración de la UbiFunction.

Después de eso, haz clic en el botón Create Route para guardar estos ajustes.

Ahora, regresa a la UbiFunction y, allí, reemplaza todo el código con el siguiente:

import requests
import time

BASE_URL = "https://industrial.api.ubidots.com"
REQUESTS_FUNCTIONS = {"get": requests.get, "post": requests.post}

def main(args):
  
    # Print Args for debugging.
    print(args)
    
    # Get the device label -> Use the devId as device label
    device_label: str = args.get('device', 'dev:').split(':')[-1] or None
    # Get the payload
    payload: dict = args.get('body', None)
    # Get the selected Ubidots token for making the request
    token: str = args.get('token', None)
    
    if device_label == '' or device_label is None:
        print('No device label')
        return {"[ERROR]" : "No device label received"}
    
    if payload is None:
        print('No payload received.')
        return {"[ERROR]" : "No payload received."}
        
    if token is None:
        print('No Ubidots Token received.')
        return {"[ERROR]" : "No Ubidots Token received."}
        
    
    # Send the data to a device
    req = update_device(device_label, payload, token)

    print("[INFO] Request result:")
    print(req.text)
    return {"status": "Ok", "result": req.json()}
    

def update_device(device, payload, token):
    """
    updates a variable with a single dot
    """

    url = "{}/api/v1.6/devices/{}".format(BASE_URL, device)
    headers = {"X-Auth-Token": token, "Content-Type": "application/json"}

    req = create_request(url, headers, payload, attempts=5, request_type="post")
    
    return req

def create_request(url, headers, data, attempts, request_type):
    """
    Function to create a request to the server
    """

    request_func = REQUESTS_FUNCTIONS.get(request_type)

    kwargs = {"url": url, "headers": headers}

    if request_type == "post":
        kwargs["json"] = data

    try:
        req = request_func(**kwargs)
        print("[INFO] Request result: {}".format(req.text))
        status_code = req.status_code
        time.sleep(1)

        while status_code >= 400 and attempts < 5:
            req = request_func(**kwargs)
            print("[INFO] Request result: {}".format(req.text))
            status_code = req.status_code
            attempts += 1
            time.sleep(1)

        return req
    except Exception as e:
        print("[ERROR] There was an error with the request, details:")
        print(e)
        return None

Con esta configuración, cada vez que el Notecard entregue datos a Notehub, se redirigirán automáticamente a un dispositivo en Ubidots.

El dispositivo aparecerá en Ubidots con la etiqueta devUID del dispositivo: