Titan – NA48: Servidor LoRa

Detalles del escenario

MTX-StarLora se presenta como gateway LoRa-4G utilizando un servidor LoRa externo. Consulte nuestra nota de aplicación 39.

MTX-StarLora también se presenta con LoRa server integrado en su interior. Eso significa que MTX-StarLora no depende de servidores LoRa externos, como TTN y entre otros, todo el control sobre otras puertas de enlace y dispositivos LoRa externos se realiza internamente. Esto es perfecto para ser independiente de terceros.

MTX-StarLora está integrado con ChirpStack https://www.chirpstack.io/.

Características:

• Dispositivos finales clase A, B y C
• Tasa de datos adaptativa
• Registro de cuadros en vivo
• (Re)configuración de canal
• Multiinquilino
• API e integración
• Compatible con LoRaWAN 1.0 y 1.1

Descripción del ejemplo

Esta nota de aplicación muestra paso a paso cómo crear una red LoRa, con sensores LoRa remotos conectados y administrados por un servidor LoRa interno.

MTX-StarLora utilizará LTE 4G como interfaz WAN, recopilará toda la información de los sensores LoRa y se enviará a la plataforma de integración en la nube de la parte final de esta nota.

El servidor interno de Chirpstack LoRa enviará datos de carga útil del sensor LoRa mediante la integración HTTPS a la plataforma Cervello.

La plataforma en la nube Cervello es perfecta para esta aplicación porque las funciones de programación de VPI pueden recibir y administrar todas las cargas útiles, filtrar y decodificar esta carga útil de tramas en valores de telemetrías. Las telemetrías se almacenarán y se podrán visualizar en tablas visuales, gráficos…

Cervello también se utilizará como administrador de dispositivos: podemos recopilar información de DNS (dirección IP, hora, IMEI, intensidad de la señal…) y se puede utilizar para agrupar y controlar mediante comandos AT.

Sensores LoRa: podemos recomendar/probar los siguientes nodos:

• Adeunis
• RAK
• URSALINK

El MTX-StarLora con capacidades de LoRa también tiene todas las características de MTX-StarLora-Titan, por lo que puede usar RS232/485/USB en serie: pasarelas Eth-4G, Modbus, Datalogger, VPN, etc., lo que lo hace uno de los routers industriales IoT-M2M más completos en el mercado.

Consulte la nota de aplicación 49 si desea extender la red LoRa con un gateway esclavo y tener un aspecto técnico más profundo sobre la implementación del servidor LoRa.

Configuración MTX-StarLora

Primero acceda a Titan usando un cable Ethernet con la dirección IP predeterminada 192.168.1.2.

Usuario: admin

Contraseña: admin

Después, es necesario configurar MTX-StarLora con la información APN de la red de la tarjeta SIM.

WAN > Configuración básica

Tenga cuidado con el PIN de SIM (si la tarjeta SIM tiene PIN habilitado) y los más importantes, “APN”, “Nombre de usuario” y “Contraseña”.

Por favor, mantenga el campo del Call center como se muestra, * 99 *** 1 #.

Después haga clic en el botón Guardar config y reinicie el router usando el menú.

Otro > Reiniciar para permitir que el router se reinicie con una nueva configuración y se conecte a Internet.

Compruebe WAN IP y mantenga este valor.

En este ejemplo, la interfaz LAN se usa ya que está conectada directamente a otro router con conexión a Internet, usará 4G WAN como respaldo/falla.

Menú: WAN > Configuración básica > Utilidades

Haga clic en el botón Configuración de conmutación por error y complete en su caso la IP del gateway. Si esto falla, la WAN se cambiará para usar la red celular 4G.

Para configurar LAN, MTX-StarLora tiene dos puertos Ethernet, usando el número uno:

Para configurar el DynDNS, complete los siguientes campos:

Servidor

Dominio

Acceso

Contraseña

Entonces, puede siempre, incluso si se ha cambiado la IP, para acceder a Titan.

Puede utilizar otras funciones de MTX-StarLora como Serial Gateways, Modbus, Logger, MQTT, VPN, SMS…

Configuración LoRa

Habilite el servidor LoRa.

Dispositivos externos: LoRa gateway no es necesario para usar el servidor LoRa interno.

Por favor, rellene Otro > MQTT Broker para habilitar el puerto de escucha 1883.

Ahora es el momento de abrir LoRa server.

Se abrirá una nueva ventana con el puerto 8080.

Dirección del router (normalmente 192.168.1.2:8080).

Mi caso http://starLoRa.ddns.net:8080.

Se abrirá ChirpStack Server.

• Usuario predeterminado: admin
• Contraseña predeterminada: admin

Puede encontrar información, guías, ayuda y foros comunitarios en

https://www.chirpstack.io/

y

https://www.chirpstack.io/project/guides/connect-gateway/.

Pasos de configuración de ChirpStack

Es obligatorio seguir todos estos pasos para crear una red LoRa.

• Paso 1: añadir un servidor
• Paso 2: añadir/crear un perfil de gateway – conectado a 1) servidor
• Paso 3: añadir/crear un perfil de servicio – debe estar conectado a 1) servidor
• Paso 4: añadir/crear un perfil de dispositivo – debe estar conectado a 1) servidor
• Paso 5: añadir/crear un gateway – conectado a 1) servidor y 2) perfil de gateway
• Paso 6: añadir/crear una aplicación: debe estar conectado a 3) perfil de servicio
• Paso 7: añadir dispositivos – debe estar conectado a 4) perfil de dispositivo

1. Repita el paso 7 para agregar otros dispositivos externos

Paso 1: añadir un servidor

Haga clic en Network-servers > Add

Complete con una cadena en Network-server-name, ejemplo MTX-StarLora-JS-LoRa. Complete con una cadena en el servidor de red 127.0.0.1:8000.

Rellene Gateway Discovery de la siguiente manera:

Compruebe si se ha creado el servidor de red:

Paso 2: añadir/crear un perfil de gateway

Haga clic en Gateway-profiles:

Haga clic en crear:

Complete un nombre de cadena para el perfil de gateway y use su servidor de red creado en el paso 1.

Compruebe si el perfil de gateway está vinculado al servidor de red.

Paso 3: añadir/crear un perfil de servicio

Haga clic en Service-profiles:

Complete con los nombres de su servidor de red del paso 1 y del perfil de servicio del paso 2. Para otros campos, lea la documentación de Chirpstack.

Como ejemplo:

Paso 4: añadir/crear un perfil de dispositivo

Haga clic en Device-profiles:

Rellene un nombre para Device-profile-name (obligatorio).

Verifique su versión MAC de LoRaWan y otros parámetros como su escenario LoRa.

Si desea agregar dispositivos externos mediante OTAA, marque los campos UNIR. Si va a utilizar claves ABP, deje este cuadro sin marcar.

En este ejemplo, usaremos las claves predeterminadas Deveui y LoRa almacenadas en los nodos (alguna explicación en el Paso 7).

Llene los campos Class-B y Class-C con su escenario LoRa especificado o ajústelo a sus mejores características de rendimiento. Estos son algunos ejemplos:

Codec es una buena característica de ChirpStack. Esto tiene como objetivo obtener un objeto con información extraída de la carga útil y no toda la carga útil del nodo.

Si va a usar solo un tipo de sensores LoRaWan del mismo extremo, puede preguntarle al fabricante de su nodo y completar/codificar. Lea la documentación/ayuda. No usaremos esta función en esta nota de aplicación.

Al final de esta nota de aplicación se puede ver cómo tenemos el código Codec integrado en la plataforma IoT en la nube Cervello.

Paso 5: añadir/crear un gateway

Esta sección puede que no parezca importante, pero lo es. Tenemos que agregar y crear el MTX-StarLora como Gateway. Haga clic en Gateways:

Después haga clic en Crear.

Escriba un nombre del gateway y una cadena de descripción.

También complete el ID del gateway (identificación), como en el ejemplo 010203040a0b0c0d.

En este ejemplo, el nombre del gateway es JS-GATEWAY. También debe utilizar el perfil del gateway configurado en el paso 2.

Si lo hace correctamente, obtendrá la información en vivo:

Paso 6: añadir/crear una aplicación

El siguiente punto es crear una nueva aplicación. En esta sección también añadiremos los dispositivos de los nodos LoRaWan finales y veremos la carga útil.

Cree una aplicación.

Haga clic en Aplicación > Crear

Complete el nombre de la aplicación y la descripción de la aplicación con algunas cadenas de texto y utilice el perfil de servicio configurado en el paso 3.

Como ejemplo, esta es una aplicación creada.

Paso 7: añadir dispositivos

Importante: ahora crearemos y agregaremos nuevos dispositivos LoRaWan de nodos finales.

Tome ahora la información de su nodo del dispositivo LoRaWan.

Necesitará esta información obligatoria:

• Dispositivo EUI (Dev EUI)
• Clave de aplicación (Application key)

Puede obtener esta información del proveedor de su dispositivo y, a veces, conectar el dispositivo remoto final a su ordenador portátil.

CÓMO USAR EL DISPOSITIVO ADEUNIS END

COMFORT ARF8275AAC

Aquí puede extraer Dev EUI.

18B260000007AB

Introduzca estos datos en la descripción del dispositivo. Rellene con 00 al principio por si acaso.

Ir a Devices > My device:

Copie la clave de la aplicación LoRa.

Mantenga la clave de la aplicación Gen en blanco.

Después haga clic en Set device keys.

Espere hasta que se reciban los marcos.

Haga clic en Device data y espere.

Encontrará algunos mensajes para unirse y subir. Haga clic arriba y extraiga.

adr:true

dr:0

fCnt:323

fPort:1

data:TIAA5Sc=

objectJSON:

Lea el manual y extraiga la información de esta cadena.

Los datos son Base64 tienen que decodificar a HEX. Utilice

https://cryptii.com/pipes/base64-to-hex

4c 80 00 e5 27 > 4c8000e527.

Puede usar el manual de Adeunis pero use https://codec-adeunis.com/decoder.

{
  type: 0x4c Comfort data,
  status: {
    frameCounter: 4,
    hardwareError: false,
    lowBattery: false,
    configurationDone: false,
    configurationInconsistency: false
  },
  decodingInfo: values: [t=0, t-1, t-2, ...],
  temperature: {
    unit: °C,
    values: [
      22.9
    ]
  },
  humidity: {
    unit: %,
    values: [
      39
    ]
  }
}

En este software puede encontrar Device EUI. Recuerde que este número es como IMEI, MAC… almacenado en el dispositivo y normalmente, no se puede cambiar. En este caso, usaremos la clave de aplicación generada aleatoriamente por ChirpStark y la copiaremos a Ursalink.

En este software puede encontrar Device EUI. Recuerde que este número es como IMEI, MAC… almacenado en el dispositivo y normalmente, no se puede cambiar. En este caso, usaremos la clave de aplicación generada aleatoriamente por ChirpStark y la copiaremos a Ursalink.

Una comprobación importante en el dispositivo es ver si está activado.

Compruebe ahora de nuevo los mensajes de tráfico de dispositivos:

Haga clic en el mensaje y, de nuevo, una estructura de información similar, información sobre la red, LoRa y los datos.

data:A2fUAARoSQZlIgAbAAYABWoAAA== ???

UC11: data:AWfZAAJoPw==

Home io remoto data:CQEA

Este sensor puede leer temperatura, humedad y tiene presencia PIR. Agregar más nodos será así:

Tenga en cuenta que las tramas LoRa, las cargas útiles no salen del servidor ChirpStack y/o están en Titan. Esas son aplicaciones separadas y no podemos usar ninguna forma de información de Titan (MQTT, HTTP, etc.). La única forma de extraer y enviar esa información es, en Aplicaciones, utilizar Integraciones. Vaya a Aplicaciones > Integraciones. Encontrará alguna integración con servicios en la nube:

HTTP

AWS SNS

AZURE

GCP

INFLUXDB

myDevices

SEMTECH

ThingBoards.io

Usaremos HTTP como quizás la forma más fácil de publicar todos los marcos de LoRa en un servidor.

Haga clic en Edit.

Rellene la información.

En el siguiente ejemplo, utilizaremos la plataforma en la nube de Cervello para recopilar todas las cargas útiles de LoRa, decodificar y crear valores de telemetrías simples.

Cervello recopila información en una carga útil JSON (entre otros). Simplemente ajuste 2 encabezados y el campo más importante es la URL.

En nuestro caso, debemos completar en la URL el ID y contraseña para conectarnos correctamente a Cervello. También puedes ver que hemos creado en Cervello un tema para recibir estos marcos.

Integración HTTP usando Cervello Stem

Cree un nuevo dispositivo (se necesita una Organización ya creada, si no, cree una nueva).

Complete el campo de nombre con algún nombre, en nuestro ejemplo, MTX-StarLora-STAR-LoRa-TEST. Complete Descripción con alguna descripción, en nuestro ejemplo, TEST LoRa HTTP.

Tipo de dispositivo: GATEWAY

Protocolo de comunicación: DEFAULT

Medios de conectividad: otros

Después, se crean las credenciales del dispositivo.

Por favor, preste atención. Haga clic en Device credentials. Después aparece un cuadro con

• CLIENT ID
• ACCESS KEY
• ACCESS TOKEN

Cópielos en algún documento ya que Access Token ya no aparecerá. En nuestro caso:

Tenemos:

• ID de cliente: jtbqr5gtypev9u
• Clave de acceso: apm87w1pcysqaw
• Token de acceso: du79dfe4qk8ptj

La URL en ChripStack es entonces:

https://broker.release.cervello.io?c=jtbqr5gtypev9u&u=apm87w1pcysqaw&p=du79dfe4qk8ptj&t=/lora/debug

En Cervello usaremos la interfaz de programación VPI con los siguientes pasos:

• Cree una aplicación (nuestro ejemplo AppStarLoRa)
• Vincular dispositivo a aplicación

Cree un VPI, en nuestro caso el nombre VPI-StarLoRa.

Añada el siguiente bloque:

Dispositivo de escucha de datos y escriba un nombre en el tema, en nuestro ejemplo, LoRa/debug.

En la depuración puede ver algún paquete LoRa en vivo, este caso es un nodo final de Adeunis.

{
  organizationId: 1973cbd9-75a2-4599-aa90-6bae7f37a204,
  originatorId: b89dd4ed-9297-424b-8e18-020df9662c5d,
  deviceId: b89dd4ed-9297-424b-8e18-020df9662c5d,
  deviceName: MTX-StarLora-STAR-LORA-TEST,
  referenceName: null,
  applications: [
    82e3c562-48eb-4223-9056-21449b44f684
  ],
  assets: [],
  tags: [],
  customFields: null,
  isPublic: false,
  clientId: jtbqr5gtypev9u,
  topic: /lora/debug,
  payload: {
    applicationID: 1,
    applicationName: JS-APP,
    deviceName: COMFORT,
    devEUI: ABiyYAAAB6s=,
    rxInfo: [
      {
        gatewayID: AQIDBAoLDA0=,
        time: null,
        timeSinceGPSEpoch: null,
        rssi: -47,
        loRaSNR: 10.5,
        channel: 4,
        rfChain: 0,
        board: 0,
        antenna: 0,
        location: {
          latitude: 40.39924,
          longitude: -3.71709,
          altitude: 609,
          source: UNKNOWN,
          accuracy: 0
        },
        fineTimestampType: NONE,
        context: dUmrDA==,
        uplinkID: lhkyE2YbTg2sHkKG7C0krw==,
        crcStatus: CRC_OK
      }
    ],
    txInfo: {
      frequency: 867300000,
      modulation: LORA,
      loRaModulationInfo: {
        bandwidth: 125,
        spreadingFactor: 12,
        codeRate: 4/5,
        polarizationInversion: false
      }
    },
   adr: true,
    dr: 0,
    fCnt: 416,
    fPort: 1,
    data: TCAA5Cg=,
    objectJSON: ,
    tags: {},
    confirmedUplink: true,
    devAddr: BaQxnw==
  },
  time: 1612525208425,
  action: message_publish

Este otro es el URSALINK AM100.

{
  organizationId: 1973cbd9-75a2-4599-aa90-6bae7f37a204,
  originatorId: b89dd4ed-9297-424b-8e18-020df9662c5d,
  deviceId: b89dd4ed-9297-424b-8e18-020df9662c5d,
  deviceName: MTX-StarLora-STAR-LORA-TEST,
  referenceName: null,
  applications: [
    82e3c562-48eb-4223-9056-21449b44f684
  ],
  assets: [],
  tags: [],
  customFields: null,
  isPublic: false,
  clientId: jtbqr5gtypev9u,
  topic: /lora/debug,
  payload: {
    applicationID: 1,
    applicationName: JS-APP,
    deviceName: AM100,
    devEUI: JOEkEnohcgA=,
    rxInfo: [
      {
        gatewayID: AQIDBAoLDA0=,
        time: null,
        timeSinceGPSEpoch: null,
        rssi: -40,
        loRaSNR: 12.8,
        channel: 4,
        rfChain: 0,
        board: 0,
        antenna: 0,
        location: {
          latitude: 40.39924,
          longitude: -3.71709,
          altitude: 609,
          source: UNKNOWN,
          accuracy: 0
        },
        fineTimestampType: NONE,
        context: fhjurA==,
        uplinkID: q9xQmrwcQSadGQo+iSI2Tw==,
        crcStatus: CRC_OK
}
    ],
    txInfo: {
      frequency: 867300000,
      modulation: LORA,
      loRaModulationInfo: {
        bandwidth: 125,
        spreadingFactor: 10,
        codeRate: 4/5,
        polarizationInversion: false
      }
    },
    adr: true,
    dr: 2,
    fCnt: 3,
    fPort: 85,
    data: AXVkA2f1AARoUQZlFAAaAAkABWoAAANn9QAEaE8GZRQAGgAJAAVqAAA=,
    objectJSON: ,
    tags: {},
    confirmedUplink: true,
    devAddr: BfRdnw==
  },
  time: 1612525356533,
  action: message_publish
}

Nuestra tarea ahora es filtrar los marcos usando ID, en nuestro bloque Switch.

El bloque de funciones es decodificar la información de la trama. Pídale a su dispositivo final LoRaWan que obtenga información y un código de ejemplo. Por lo general, se denomina Codec.

/**
 * Ursalink AM100 / AM102 Payload Decoder
 *
 * definition [channel-id] [channel-type] [channel-data]
 *
 * 01: battery      -> 0x01 0x75 [1byte]  Unit: %
 * 03: temperature  -> 0x03 0x67 [2bytes] Unit: °C
 * 04: humidity     -> 0x04 0x68 [1byte]  Unit: %
 * 05: PIR          -> 0x05 0x6A [2bytes] 
 * 06: illumination -> 0x06 0x65 [6bytes] Unit: lux
 * ------------------------------------------ AM100
 * 07: CO2          -> 0x07 0x7D [2bytes] Unit: ppm
 * 08: TVOC         -> 0x08 0x7D [2bytes] Unit: ppb
 * 09: Pressure     -> 0x09 0x73 [2bytes] Unit: hPa
 * ------------------------------------------ AM102
 */
function Decoder(bytes) {
    var decoded = {};

    for (var i = 0; i < bytes.length;) {
        var channel_id = bytes[i++];
        var channel_type = bytes[i++];
        // BATTERY
        if (channel_id === 0x01 && channel_type === 0x75) {
            decoded.battery = bytes[i];
            i += 1;
        }
        // TEMPERATURE
        else if (channel_id === 0x03 && channel_type === 0x67) {
            decoded.temperature = readInt16LE(bytes.slice(i, i + 2)) / 10;
            i += 2;
        }
        // HUMIDITY
        else if (channel_id === 0x04 && channel_type === 0x68) {
            decoded.humidity = bytes[i] / 2;
            i += 1;
        }
        // PIR
        else if (channel_id === 0x05 && channel_type === 0x6A) {
            decoded.activity = readInt16LE(bytes.slice(i, i + 2));
            i += 2;
        }
        // LIGHT
        else if (channel_id === 0x06 && channel_type === 0x65) {
            decoded.illumination = readInt16LE(bytes.slice(i, i+2));
           // decoded.infrared_and_visible = readInt16LE(bytes.slice(i + 2, i + 4));
           // decoded.infrared = readInt16LE(bytes.slice(i + 4, i + 6));
            i += 6;
        }
        // CO2
        else if (channel_id === 0x07 && channel_type === 0x7D) {
            decoded.co2 = readInt16LE(bytes.slice(i, i + 2));
            i += 2;
        }
        // TVOC
        else if (channel_id === 0x08 && channel_type === 0x7D) {
            decoded.tvoc = readInt16LE(bytes.slice(i, i + 2));
            i += 2;
        }
        // PRESSURE
        else if (channel_id === 0x09 && channel_type === 0x73) {
            decoded.pressure = readInt16LE(bytes.slice(i, i + 2))/10;
            i += 2;
        } else {
            break;
        }
    }
    return decoded;
}

/* ******************************************
 * bytes to number
 ********************************************/
function readUInt16LE(bytes) {
    var value = (bytes[1] << 8) + bytes[0]; return value & 0xffff; } function readInt16LE(bytes) { var ref = readUInt16LE(bytes); return ref > 0x7fff ? ref - 0x10000 : ref;
}

/* ******************************************
 * payload processing
 ********************************************/

var hexBase64Payload = data.payload.data;

var hexPayload = Buffer.from(hexBase64Payload,\'base64\');
var decodedPayload = Decoder(Buffer.from(hexPayload,\'hex\'));


var msg = {
    device_name: data.payload.deviceName,
    deviceId: data.deviceId,
    data: {}
}

msg[data][data.payload.deviceName] = {
           data: decodedPayload }
    

send(0, msg);

Casi terminado. En VPI, el bloque de telemetría crea una Telemetría; en nuestro ejemplo, tomará solo TEMP como valor de telemetría.

En este ejemplo, hemos creado un dispositivo periférico que permitirá telemetrías e información separadas de otros nodos. De esta manera también será fácil crear grupos, etiquetas, para una mejor experiencia del usuario final.

Haga clic en el dispositivo periférico AM100 en el Administrador de dispositivos y obtenga toda la información.