Skip to main content

Seguimiento Continuo de Activos con Redes Amazon Sidewalk y LoRaWAN

Introducción​

Experimenta la integración perfecta de redes con esta demostración de dispositivo dual. La configuración incluye la versátil Placa de Desarrollo Seeed Studio Wio Tracker y el robusto dispositivo Rastreador Seeed Studio SenseCAP T1000-S, ambos mostrando transiciones fluidas entre redes LoRaWAN y Sidewalk para una cobertura óptima.

  • Soporte de Red Dual: Con una sola pulsación de botón, cambia entre LoRaWAN y Sidewalk para mantener conectividad persistente.
  • Conectado a la Nube: Observa la transferencia de datos en tiempo real a AWS IoT Core, visualizada a través de una aplicación web AWS en una pantalla/monitor de laptop.
  • Eficiencia Alimentada por Batería: Los dispositivos aseguran operación consistente, sin cables para una experiencia verdaderamente móvil.

El proceso se divide en estos pasos principales:

Prerrequisitos​

Instalación del nRF Connect SDK​

Hay diferentes formas de instalar el nRF Connect SDK, dependiendo de tu entorno de desarrollo preferido y la herramienta de gestión de toolchain:

  • Usando Visual Studio Code y la extensión nRF Connect para VS Code (recomendado)

  • Usando línea de comandos y nRF Util

Paso 1: Actualizar sistema operativo

Antes de comenzar a configurar el toolchain, instala las actualizaciones disponibles para tu sistema operativo. Consulta Requisitos para información sobre los sistemas operativos soportados.

Paso 2: Instalar prerrequisitos

Paso 3: Instalar el toolchain del nRF Connect SDK

  • Abre la extensión nRF Connect en Visual Studio Code haciendo clic en su icono en la Barra de Actividad.

  • En la Vista de Bienvenida de la extensión, haz clic en Install Toolchain.

  • Selecciona la versión del toolchain a instalar. La versión del toolchain debe coincidir con la versión del nRF Connect SDK con la que vas a trabajar. Usamos la V2.5.0(recomendada).

Después de instalar el toolchain, puedes acceder a la opción Install Toolchain haciendo clic en Manage toolchains.

Paso 4: Obtener el código del nRF Connect SDK

Para clonar el código del nRF Connect SDK, completa los siguientes pasos:

  • Abre la extensión nRF Connect en Visual Studio Code haciendo clic en su icono en la Barra de Actividad.

  • En la Vista de Bienvenida de la extensión, haz clic en Manage SDKs. La lista de acciones aparece en la selección rápida de Visual Studio Code.

  • Haz clic en Install SDK. La lista de versiones de SDK disponibles aparece en la selección rápida de Visual Studio Code.

  • Selecciona la versión del SDK a instalar, usamos V2.5.0.

La instalación del SDK comienza y puede tomar varios minutos.

Configuración del entorno Sidewalk​

Sigue estos pasos para descargar la aplicación Sidewalk para el nRF Connect SDK:

  • Abre una ventana de terminal. Tu estructura de directorios debería verse de la siguiente manera:
.
|___ .west
|___ bootloader
|___ modules
|___ nrf
|___ nrfxlib
|___ zephyr
|___ ...
  • Asegúrate de que la ruta del manifiesto apunte a west.yml dentro del directorio nrf:
west manifest --path
/path-to-ncs-folder/nrf/west.yml

En caso de que la ruta de tu manifiesto apunte a un archivo diferente, usa el siguiente comando:

west config manifest.path nrf
  • Habilita el filtro de grupo Sidewalk para west.
west config manifest.group-filter "+sidewalk"

Verificar la presencia de acera en el oeste:

west list sidewalk
sidewalk     sidewalk                     <sidewalk_revision> https://github.com/nrfconnect/sdk-sidewalk
  • Actualizar todos los repositorios:
west update

Dependiendo de tu conexión, la actualización podría tomar algo de tiempo.

  • Instala los requisitos de Python para Sidewalk.
pip install -r sidewalk/requirements.txt

Agregar LR11xx a la Extensión Sidewalk del nRF Connect SDK​

Este repositorio contiene el controlador de software que permite a la familia LR11xx de silicio soportar el protocolo Sidewalk cuando se empareja con el MCU Nordic nRF52840 y el nRF Connect SDK. El controlador se ofrece en forma binaria, como una biblioteca estática que implementa las interfaces de "Capa de Abstracción de Plataforma" necesarias para soportar conectividad LoRa o FSK. La biblioteca estática contiene dentro de sí una implementación completa del SWDR001 de Semtech (Controlador LR11xx), que puede ser usado para acceder a otras características del silicio LR11xx, como escaneo WIFI y GNSS y medición de distancias.

  • Descarga el SWDM016

  • Con tu directorio de trabajo en el repositorio nordic clonado, en el directorio de nivel superior, es decir, ~/ncs/<version>/sidewalk:

patch -p1 < ../nRF52840_LR11xx_driver_v010000.diff

la ruta del directorio padre .. asume que pusiste el archivo diff ahí, de lo contrario puedes especificar la ruta completa a su ubicación.

  • Copia las librerías del controlador de radio lib*.a al proyecto sidewalk en ~/ncs/<version>/sidewalk/lib/lora_fsk/
    Se proporcionan dos librerías, una con LOG_RUNTIME_FILTERING habilitado y otra sin él.

  • Copia la carpeta ~/template_lbm_wio_tracker/boards/arm/wio_tracker_1110 a ~/ncs/v2.5.0/zephyr/boards/arm.

·
├─── .west/
├─── modules/
├─── nrf/
├─── ...
└─── zephyr/
     └─── Boards/
          └─── arm/
               └─── wio_tracker_1110/

Crear Recursos​

Paso 1: Desplegar Entorno Cloud9

En esta sección crearás todos los recursos que necesitamos antes de comenzar. Como primer paso crearás un Espacio de Trabajo Cloud9 que usarás para construir y desplegar otros recursos. Luego desplegarás un Stack CDK que contiene todos los recursos backend para la aplicación Asset Tracker. Finalmente, instalarás todas las dependencias frontend y configurarás la aplicación.

  • Deja todas las demás configuraciones como predeterminadas excepto el Tipo de instancia. Selecciona m5.large.

Paso 2: Configurar Prerrequisitos

  • Abre el IDE de Cloud9.
  • Clona el repositorio de github en tu terminal del entorno Cloud9 ingresando el siguiente comando:
git clone --recurse-submodules https://github.com/aws-samples/aws-iot-asset-tracker-demo.git /home/ec2-user/environment/asset-tracking-workshop
  • Navega al directorio de la aplicación de ejemplo:
cd ~/environment/asset-tracking-workshop
  • Redimensiona el volumen EBS de la instancia EC2 subyacente.
npm run utils:resizeC9EBS
  • Instala las dependencias del proyecto:
npm ci
  • Despliega la infraestructura del backend:
# Prepare the AWS account for CDK
npm run infra:bootstrap
# Deploy the backend resources
npm run infra:deploy
  • Crear un archivo de configuración:
npm run utils:createConfig

Configuración LoRaWAN​

Agregar Gateway LoRaWAN en AWS​

Consulta esta Guía de Inicio para agregar el gateway SenseCAP M2 Multi-Platform a AWS IoT Core.

Agregar Dispositivo LoRaWAN en AWS​

Paso 1: Definir las claves

Define el DevEUI/JoinEUI/APPkey y la REGION en src/lorawan_v4/example_options.h.

tip

JoinEUI también conocido como AppEUI

Paso 2: Crear perfiles

Inicia sesión en AWS IoT Console, navega a Devices, haz clic en Profiles.

  • Perfil de dispositivo

Los perfiles de dispositivo definen las capacidades del dispositivo y los parámetros de arranque que el servidor de red utiliza para configurar el servicio de acceso de radio LoRaWAN. Incluye la selección de parámetros como la banda de frecuencia LoRa, la versión de parámetros regionales LoRa y la versión MAC del dispositivo.

Para conocer las diferentes bandas de frecuencia, consulta Considera la selección de bandas de frecuencia LoRa para tus gateways y conexión de dispositivos.

  • Perfil de servicio

Recomendamos que dejes habilitada la configuración AddGWMetaData para que recibas metadatos adicionales del gateway para cada carga útil, como RSSI y SNR para la transmisión de datos.

Paso 3: Agregar dispositivo

Navega a LPWAN devices > Devices, haz clic en Add wireless device.

Wireless device specification: OTAAv1.0x

pir

Selecciona el perfil de dispositivo y destino que creaste en el paso anterior.

pir

Navega a la página de Dispositivos y elige el dispositivo que agregaste anteriormente.

Configuración Sidewalk​

Configurar un gateway Sidewalk (Opcional)​

Puedes configurar un gateway Sidewalk, configurarlo y asociar tu gateway con tu cuenta de Amazon. Tu endpoint Sidewalk se conectará y comunicará con el gateway Sidewalk después de que esté registrado con Amazon Sidewalk.

Consulta Configurar un gateway Sidewalk para más detalles.

Configurar tu dispositivo Sidewalk​

Agregar tu dispositivo Sidewalk​

Paso 1: Agregar tu perfil de dispositivo y dispositivo final Sidewalk

Antes de crear un dispositivo inalámbrico, primero crea un perfil de dispositivo.

Navega a la pestaña Sidewalk del hub de Dispositivos, elige Provision device, y luego realiza los siguientes pasos.

Paso 2: Obtener archivo JSON del dispositivo

Para obtener el archivo JSON para aprovisionar tu dispositivo Sidewalk:

  • Ve al hub de dispositivos Sidewalk.

  • Elige el dispositivo que agregaste a AWS IoT Core para Amazon Sidewalk para ver sus detalles.

  • Obtén el archivo JSON eligiendo Download device JSON file en la página de detalles del dispositivo que agregaste.

Se descargará un archivo certificate.json que contiene la información requerida para aprovisionar tu dispositivo final.

pir

Paso 3: Aprovisionar tu endpoint Sidewalk

Generar imagen binaria

  • Instalar el archivo de requisitos

Ve a la carpeta del SDK de Sidewalk $[Amazon Sidewalk repository]/tools/scripts/public/provision/, y luego ejecuta el siguiente comando para instalar el archivo de requirements.

pip3 install -r requirements.txt
  • Generar la imagen binaria de fabricación

Ejecuta el script provision.py para generar el archivo de imagen binaria de fabricación que se utilizará para aprovisionar la placa de desarrollo que estás usando como punto final de Sidewalk.

  • Si estás usando el archivo JSON de dispositivo combinado que obtuviste de la consola de AWS IoT, usa el parámetro certificate_json para especificar este archivo como entrada al ejecutar el script de aprovisionamiento.
python3 provision.py aws --output_bin mfg.bin --certificate_json certificate.json \ 
   --config config/[device_vendor]/[device]_dk/config.yaml

Si estás usando los archivos JSON de dispositivo separados que obtuviste como respuestas de las operaciones de API GetDeviceProfile y GetWirelessDevice, usa los parámetros wireless_device_json y device_profile_json para especificar estos archivos como entrada al ejecutar el script de aprovisionamiento.

python3 provision.py aws --output_bin mfg.bin \  
   --wireless_device_json wireless_device.json \
   --device_profile_json device_profile.json \ 
   --config config/[device_vendor]/[device]_dk/config.yaml

Deberías ver la siguiente salida:

  • Flashea el archivo mfg.hex

Tu archivo de aprovisionamiento estará típicamente ubicado en el directorio EdgeDeviceProvisioning.

Para flashear la imagen binaria, usa la dirección 0xFD000 para cargar la imagen binaria en el Nordic Semiconductor HDK. Para información sobre cómo flashear la imagen binaria, consulta la documentación de Nordic Semiconductor.

Paso 4: Construir y flashear la demo

  • Abre una ventana de terminal.

  • Ve al directorio template_lbm_wio_tracker.

Por ejemplo:

cd /opt/nordic/ncs/v2.5.0/sidewalk/samples/template_lbm_wio_tracker
  • Construye la aplicación usando el siguiente comando west:
west build --board wio_tracker_1110 -- -DRADIO=LR1110_SRC

o con biblioteca de controlador de radio precompilada:

west build --board wio_tracker_1110 -- -DRADIO=LR1110
  • Flashea la aplicación usando el siguiente comando west:
west flash

Registro de Sidewalk​

Después de haber aprovisionado el endpoint de Sidewalk, el endpoint debe registrarse para que pueda comunicarse a través de la red Sidewalk.

Para registrar su endpoint de Sidewalk, use el registro automático sin contacto con Sidewalk Frustration Free Networking (FFN), o registre manualmente su dispositivo usando una máquina Mac o Ubuntu nativa que ejecute el script de registro.

Criterios Registro automático(usando Sidewalk FFN)Registro manual
Asociación de usuario y endpointEste método de registro no requiere ninguna asociación entre el endpoint de Sidewalk y un usuario. El endpoint puede unirse a la red Sidewalk sin estar asociado con ningún usuario.Este método de registro requiere una asociación entre el endpoint de Sidewalk y la cuenta de Amazon de un usuario.
LWA (Login with Amazon)LWA no es requerido.LWA es requerido para vincular la cuenta de Amazon del usuario y la cuenta de AWS que es usada por el desarrollador del endpoint de Sidewalk.

Para realizar el registro usando Sidewalk FFN:

  • Su gateway y endpoint de Sidewalk deben estar encendidos.
  • Su gateway debe estar habilitado para Sidewalk, y en rango cercano a su endpoint. Recomendamos que mantenga los dispositivos dentro de 10 metros uno del otro.

Para Registro manual de Sidewalk y otros detalles por favor consulte aquí.

Cambio de Red​

El predeterminado es la red LoRaWAN, haga clic en el Botón de Usuario para cambiar de red.

Ver Mensaje​

Agregar Destino​

En la consola de IoT Core, seleccione LPWAN devices del menú izquierdo y luego Destinations.

Seleccione Edit y seleccione Publish to AWS IoT Core message broker. En el cuadro de texto del tema, ingrese assets como el Tema MQTT.

Bajo Permissions seleccione Create a new service role y deje el Role name en blanco.

  • ExpressionType: MqttTopic
  • Expression: EmbeddedWorldTrackerDemo

Agregar Regla de Decodificador​

Navegue a la pestaña Message routing → Rules, y haga clic en el botón Create Rule.

Nombre su regla y envíela.

Desde la Regla de IoT Core, seleccione la Función Lambda. luego haga clic en Create a Lambda function.

Author from scratch
Function name: Nombre su función.
Runtime: Node.js 14.x
Architexture: x86_64

Haga clic en el botón Create function para crear una nueva función

En la siguiente página de configuración de función, elimine todo el código y reemplácelo con el siguiente script, luego haga clic en el botón Deploy.

Código Lambda
const {IoTDataPlaneClient, PublishCommand} = require("@aws-sdk/client-iot-data-plane");
const {IoTWirelessClient, GetWirelessDeviceCommand} = require("@aws-sdk/client-iot-wireless");
const client = new IoTDataPlaneClient({
    "region": "us-east-1"
});
const wireless_client = new IoTWirelessClient({
    "region": "us-east-1"
});

function decodeUplink(input) {
    const originMessage = input.toLocaleUpperCase()
    const decoded = {
        valid: true,
        err: 0,
        payload: input,
        messages: []
    }
    let measurement = messageAnalyzed(originMessage)
    if (measurement.length === 0) {
        decoded.valid = false
        return {data: decoded}
    }

    for (let message of measurement) {
        if (message.length === 0) {
            continue
        }
        let elements = []
        for (let element of message) {
            if (element.errorCode) {
                decoded.err = element.errorCode
                decoded.errMessage = element.error
            } else {
                elements.push(element)
            }
        }
        if (elements.length > 0) {
            decoded.messages.push(elements)
        }
    }
    return {data: decoded}
}

function messageAnalyzed(messageValue) {
    try {
        let frames = unpack(messageValue)
        let measurementResultArray = []
        for (let i = 0; i < frames.length; i++) {
            let item = frames[i]
            let dataId = item.dataId
            let dataValue = item.dataValue
            let measurementArray = deserialize(dataId, dataValue)
            measurementResultArray.push(measurementArray)
        }
        return measurementResultArray
    } catch (e) {
        return e.toString()
    }
}

function unpack(messageValue) {
    return [{dataId: 0, dataValue: messageValue}]
}

function deserialize(dataId, dataValue) {
    let measurementArray = null
    measurementArray = [
        {
            measurementId: '4198',
            type: 'Latitude',
            measurementValue: parseFloat(getSensorValue(dataValue.substring(0, 8), 1000000))
        },
        {
            measurementId: '4197',
            type: 'Longitude',
            measurementValue: parseFloat(getSensorValue(dataValue.substring(8, 16), 1000000))
        },
        {
            measurementId: '4097',
            type: 'Air Temperature',
            measurementValue: getSensorValue(dataValue.substring(16, 20), 10)
        },
        {
            measurementId: '4098',
            type: 'Air Humidity',
            measurementValue: getSensorValue(dataValue.substring(20, 22))
        }
    ]
    return measurementArray
}

function getSensorValue(str, dig) {
    if (str === '8000') {
        return null
    } else {
        return loraWANV2DataFormat(str, dig)
    }
}

function bytes2HexString(arrBytes) {
    var str = ''
    for (var i = 0; i < arrBytes.length; i++) {
        var tmp
        var num = arrBytes[i]
        if (num < 0) {
            tmp = (255 + num + 1).toString(16)
        } else {
            tmp = num.toString(16)
        }
        if (tmp.length === 1) {
            tmp = '0' + tmp
        }
        str += tmp
    }
    return str
}

function loraWANV2DataFormat(str, divisor = 1) {
    let strReverse = bigEndianTransform(str)
    let str2 = toBinary(strReverse)
    if (str2.substring(0, 1) === '1') {
        let arr = str2.split('')
        let reverseArr = arr.map((item) => {
            if (parseInt(item) === 1) {
                return 0
            } else {
                return 1
            }
        })
        str2 = parseInt(reverseArr.join(''), 2) + 1
        return '-' + str2 / divisor
    }
    return parseInt(str2, 2) / divisor
}

function bigEndianTransform(data) {
    let dataArray = []
    for (let i = 0; i < data.length; i += 2) {
        dataArray.push(data.substring(i, i + 2))
    }
    return dataArray
}

function toBinary(arr) {
    let binaryData = arr.map((item) => {
        let data = parseInt(item, 16)
            .toString(2)
        let dataLength = data.length
        if (data.length !== 8) {
            for (let i = 0; i < 8 - dataLength; i++) {
                data = `0` + data
            }
        }
        return data
    })
    return binaryData.toString().replace(/,/g, '')
}

exports.handler = async (event) => {
    try {
        let device_id = event['WirelessDeviceId'];
        let lorawan_info = null;
        let sidewalk_info = null;
        let payload = null
        let timestamp = null

        let queryDeviceRequest = {
            Identifier: device_id,
            IdentifierType: "WirelessDeviceId"
        }
        let deviceInfo = await wireless_client.send(new GetWirelessDeviceCommand(queryDeviceRequest))
        console.log("device_info：" + JSON.stringify(deviceInfo))
        if (!deviceInfo || deviceInfo.name) {
            return {
                statusCode: 500,
                body: 'can not find this wirelessDeviceId: ' + device_id
            };
        }
        let device_name = deviceInfo.Name

        if (event["WirelessMetadata"]["LoRaWAN"]) {
            lorawan_info = event["WirelessMetadata"]["LoRaWAN"]
            timestamp = lorawan_info["Timestamp"]
            let bytes = Buffer.from(event["PayloadData"], 'base64');
            payload = bytes2HexString(bytes)
        } else if (event["WirelessMetadata"]["Sidewalk"]) {
            timestamp = new Date().getTime()
            let origin = new Buffer(event["PayloadData"], 'base64')
            payload = origin.toString('utf8')
        }

        console.log(`event.PayloadData: ${payload}`)
        const resolved_data = decodeUplink(payload);
        
        // publish all measurement data
        const input = { // PublishRequest
            topic: `tracker/EmbeddedWorldTrackerDemo/sensor/${device_id}`,
            qos: 0,
            retain: false,
            payload: JSON.stringify({
                DeviceName: "assettracker",
                timestamp: timestamp,
                data: resolved_data.data,
                WirelessDeviceId: device_id,
                PayloadData: event['PayloadData'],
                WirelessMetadata: event["WirelessMetadata"]
            })
        };

        const command = new PublishCommand(input);
        const response = await client.send(command);
        console.log("response: " + JSON.stringify(response));
        return {
            statusCode: 200,
            body: 'Message published successfully' + JSON.stringify(event)
        };
    } catch (error) {
        console.error('Error publishing message:', error);

        return {
            statusCode: 500,
            body: 'Error publishing message'
        };
    }
};

Ahora regresa al Device Destination, selecciona Enter a rule name e ingresa el nombre que acabamos de crear.

Navega a la AWS IoT Core Console y selecciona MQTT Test Client y suscríbete al tema.

Agregar Regla de Rastreador​

Repite los pasos anteriores para crear una nueva regla, y copia el siguiente código Lambda:

Código Lambda
const {IoTDataPlaneClient, PublishCommand} = require("@aws-sdk/client-iot-data-plane");

const {LocationClient, BatchUpdateDevicePositionCommand} = require("@aws-sdk/client-location")

const {IoTWirelessClient, UpdateResourcePositionCommand } = require("@aws-sdk/client-iot-wireless");
const client = new IoTDataPlaneClient({
    "region": "us-east-1"
});
const wireless_client = new IoTWirelessClient({
    "region": "us-east-1"
});

exports.handler = async (event) => {
    console.log(`message received: ${JSON.stringify(event)}`)
    let device_id = event['WirelessDeviceId']
    let device_name = event['DeviceName']
    let measurements = event['data']['messages']
    let resolver_time = event['timestamp']
    let network = 1; // 1: lorawan 2: sidewalk
    if (event["WirelessMetadata"] && event["WirelessMetadata"]["Sidewalk"]) {
        network = 2
    }

    let longitude;
    let latitude;
    let gps_data = null
    let sensor_map = {}
    if (measurements && measurements.length > 0) {
        for (let i = 0; i < measurements.length; i++) {
            for (let j = 0; j < measurements[i].length; j++) {
                if (measurements[i][j].measurementId === "4097") {
                    sensor_map["Temperature"] = measurements[i][j].measurementValue;
                }
                if (measurements[i][j].measurementId === "4098") {
                    sensor_map["Humidity"] = measurements[i][j].measurementValue;
                }
                if (measurements[i][j].measurementId === "4197") {
                    longitude = measurements[i][j]["measurementValue"];
                }
                if (measurements[i][j].measurementId === "4198") {
                    latitude = measurements[i][j]["measurementValue"];
                }

                if (latitude && longitude) {
                    try {
                        gps_data = {
                            "type": "Point",
                            "coordinates": [longitude, latitude]
                            // "coordinates": [33.3318, -22.2155, 13.123]
                        }
                    } catch (e) {
                        console.log(`===>error`, e)
                    }
                }
            }
        }
    }

    if (gps_data) {
        console.log(`update device location : ${JSON.stringify(gps_data)}`)
        await updateDevicePosition(gps_data, device_id);
        const input = { // PublishRequest
            topic: `tracker/EmbeddedWorldTrackerDemo/location/${device_id}`,
            qos: 0,
            retain: false,
            payload: JSON.stringify({
                timestamp: resolver_time,
                deviceId: device_id,
                deviceName: device_name,
                latitude: gps_data.coordinates[1],
                longitude: gps_data.coordinates[0],
                positionProperties: {'batteryLevel': 90, "sensor:": 60}
            })
        };
        const command = new PublishCommand(input);
        const response = await client.send(command);
        console.log("mqtt push response: " + JSON.stringify(response));

        let locationClient = new LocationClient()
        let location_info = {
            TrackerName: 'AssetTracker',
            Updates: [
                {
                    DeviceId: 'assettracker',
                    SampleTime: new Date(resolver_time),
                    Position: [
                        gps_data.coordinates[0], gps_data.coordinates[1]
                    ],
                    Accuracy: {
                        Horizontal: 1,
                    },
                    PositionProperties: {
                        "context": JSON.stringify({net: network}),
                        "sensor": JSON.stringify(sensor_map)
                    }
                }
            ]
        }
        let loc_response = await locationClient.send(new BatchUpdateDevicePositionCommand(location_info))
        console.log("loc update response: " + JSON.stringify(loc_response));

    }
}

async function updateDevicePosition(gps_data, device_id) {
    const input = { // UpdateResourcePositionRequest
        ResourceIdentifier: device_id, // required
        ResourceType: "WirelessDevice", // required
        GeoJsonPayload: JSON.stringify(gps_data),
    };
    const command = new UpdateResourcePositionCommand(input);
    const wireless_response = await wireless_client.send(command);
    console.log(wireless_response)
}

Construyendo la Aplicación Web​

Desplegaremos los recursos necesarios de Amazon Location Service requeridos para mostrar nuestro dispositivo en un mapa.

Creando el Mapa​

Como primer paso necesitarás crear un nuevo recurso de Mapa de Amazon Location Service. Lo harás usando la Consola de AWS.

  • Abre la Consola de Amazon Location Service.

  • Luego expande la barra de navegación en el lado izquierdo de la pantalla, y selecciona Maps.

  • En esta pantalla, crea un nuevo mapa:

  • Ingresa el nombre del mapa y selecciona el estilo de mapa HERE Explore, luego haz clic en Create map.

Creando el Calculador de Rutas​

Continúa seleccionando HERE como Proveedor de Datos, haz clic en el botón Create route calculator.

Creando el Rastreador​

Navega a Trackers -> Create tracker:

Ingresa el nombre del rastreador y selecciona Time-based filtering bajo filtrado de posición.

Luego desplázate hacia abajo y marca la configuración Enable EventBridge events bajo la configuración de EventBridge, luego haz clic en Create tracker.

Creando la Colección de Geocercas​

Navega a Geofence collections, y haz clic en create geofence collection.

Mostrar la Aplicación Web​

Desplegar la Aplicación a Cloudfront​

  • En tu Terminal de Cloud9, navega a /home/ec2-user/environment/asset-tracking-workshop:
cd /home/ec2-user/environment/asset-tracking-workshop
  • Ejecuta el siguiente comando:
npm run frontend:publish
  • Una vez completado, recibirás la URL del sitio web.
  • Navega a esta URL en tu navegador para ver tu aplicación de seguimiento.

Recursos​

SWDM016

template_lbm_wio_tracker

Loading Comments...