Skip to main content

Rastreo de Activos sin Interrupciones con Amazon Sidewalk y Redes LoRaWAN

Introducción​

Experimenta una integración de red sin interrupciones con esta demostración de doble dispositivo. 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 solo presionar un botón, cambia entre LoRaWAN y Sidewalk para mantener una conectividad persistente.
  • Conectado a la Nube: Observa la transferencia de datos en tiempo real hacia AWS IoT Core, visualizada a través de una aplicación web de AWS en un monitor o pantalla de laptop.
  • Eficiencia con Batería: Los dispositivos aseguran un funcionamiento constante, sin cables, para una experiencia verdaderamente móvil.

El proceso se divide en los siguientes pasos principales:

Requisitos Previos​

Instalación del SDK de nRF Connect​

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

  • Usando Visual Studio Code y la extensión nRF Connect para VS Code (recomendado)
  • Usando la línea de comandos y nRF Util

Paso 1: Actualiza el sistema operativo

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

Paso 2: Instalar prerrequisitos

Paso 3: Instala el toolchain de nRF Connect SDK

  • Abre la extensión nRF Connect en Visual Studio Code haciendo clic en su ícono en la Barra de Actividades.

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

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

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

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

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

  • Abre la extensión nRF Connect en Visual Studio Code haciendo clic en su ícono en la Barra de Actividades.

  • En la Vista de Bienvenida de la extensión, haz clic en Manage SDKs. Aparecerá una lista de acciones en el selector rápido de Visual Studio Code.

  • Haz clic en Install SDK. Aparecerá la lista de versiones disponibles del SDK en el selector rápido de Visual Studio Code.

  • Selecciona la versión del SDK que deseas instalar; nosotros usamos la versión V2.5.0.

La instalación de SDK comenzará y puede tomar varios minutos.

Configuración del entorno Sidewalk​

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

  • Abre una ventana de terminal. La estructura de tu directorio debería verse así:
.
|___ .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 del 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"

Verifica la presencia de Sidewalk en west:

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

Dependiendo de tu conezión, la actualización tomará algo de tiempo.

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

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

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

  • Descarga el SWDM016

  • Con tu directorio de trabajo en el repositorio clonado de Nordic, en el directorio raíz, es decir, ~/ncs/<versión>/sidewalk:

    patch -p1 < ../nRF52840_LR11xx_driver_v010000.diff

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

  • Copia las bibliotecas del controlador de radio lib*.a dentro del proyecto sidewalk a ~/ncs/<versión>/sidewalk/lib/lora_fsk/
    Se proporcionan dos bibliotecas, 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 el 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 una pila CDK que contiene todos los recursos backend para la aplicación Asset Tracker. Finalmente, instalarás todas las dependencias del frontend y configurarás la aplicación.

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

Paso 2: Configurar los prerrequisitos

  • Abre el IDE de Cloud9.

  • Clona el repositorio de GitHub en el terminal de tu entorno Cloud9 ejecutando 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 backend: 

    # Prepare the AWS account for CDK
    npm run infra:bootstrap
    # Deploy the backend resources
    npm run infra:deploy

  • Crea un archivo de configuración: 

    npm run utils:createConfig

Configuración LoRaWAN​

Agregar Gateway LoRaWAN en AWS​

Consulta este Get Started para agregar el gateway SenseCAP M2 Multi-Platform a AWS IoT Core.

Agregar Dispositivo LoRaWAN en AWS​

Paso 1: Definir las llaves

Define el DevEUI/JoinEUI/APPkey y la REGIÓN en src/lorawan_v4/example_options.h.

tip

JoinEUI también conocido como AppEUI

Paso 2: Crear perfiles

Inicia sesión en la Consola de AWS IoT, navega a Devices y 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 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 Considerar la selección de bandas de frecuencia LoRa para tus gateways y conexión de dispositivos.

  • Perfil de servicio

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

Paso 3: Agregar dispositivo

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

Especificación del dispositivo inalámbrico: OTAAv1.0x

pir

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

pir

Navega a la página de Dispositivos (Devices) y selecciona el dispositivo que agregaste anteriormente.

Configuración de Sidewalk​

Configuración de 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 en Amazon Sidewalk.

Consulta Configuración de un gateway Sidewalk para más detalles.

Configuración de tu dispositivo Sidewalk​

Añade tu dispositivo Sidewalk​

Paso 1: Añade el perfil de dispositivo y el 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, selecciona Provision device y realiza los siguientes pasos.

Paso 2: Obtén el archivo JSON del dispositivo

Para obtener el archivo JSON para provisionar tu dispositivo Sidewalk:

  • Ve al hub de dispositivos Sidewalk.

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

  • Descarga el archivo JSON seleccionando Download device JSON file en la página de detalles del dispositivo agregado.

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

pir

Paso 3: Provisiona tu endpoint Sidewalk

Genera la imagen binaria

  • Instala el archivo de requerimientos

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

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

Ejecuta el script provision.py para generar el archivo de imagen binaria de fabricación que se usará para provisionar la placa de desarrollo que estés utilizando como endpoint Sidewalk.

  • Si estás usando el archivo JSON combinado que obtuviste desde la consola de AWS IoT, utiliza el parámetro certificate_json para especificar este archivo como entrada al ejecutar el script de provisión.

    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 separados que obtuviste como respuestas de las operaciones API GetDeviceProfile y GetWirelessDevice, utiliza los parámetros wireless_device_json y device_profile_json para especificar estos archivos como entrada al ejecutar el script de provisión.

    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ás ver la siguiente salida:

  • Flashea el archivo mfg.hex

    Tu archivo de provisión generalmente estará 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 más información sobre cómo flashear la imagen binaria, consulta la documentación de Nordic Semiconductor.

Paso 4: Compilar y flashear la demo

  • Abre una ventana de terminal.

  • Navega 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 utilizando el siguiente comando west

    west build --board wio_tracker_1110 -- -DRADIO=LR1110_SRC

    o con la librería pre-compilada del driver de radio:

    west build --board wio_tracker_1110 -- -DRADIO=LR1110

  • Flashea la aplicación usando el siguiente comando flash:

    west flash

Registro de Sidewalk​

Después de haber provisionado el endpoint Sidewalk, es necesario registrarlo para que pueda comunicarse a través de la red Sidewalk.

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

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

Para realizar el registro usando Sidewalk FFN:

  • Tu gateway Sidewalk y el endpoint deben estar encendidos.
  • El gateway debe estar inscrito en Sidewalk y cerca del endpoint. Recomendamos mantener los dispositivos a menos de 10 metros de distancia.

Para registro manual de Sidewalk y más detalles, consulta aquí.

Cambio de red​

La red predeterminada es LoRaWAN, presiona el User Button para cambiar de red.

Ver Mensaje​

Agregar Destino​

En la consola de IoT Core, selecciona LPWAN devices en el menú lateral y luego Destinations.

Selecciona Edit y elige Publish to AWS IoT Core message broker. En el cuadro de texto para el topic, ingresa assets como el Tema MQTT.

En Permissions selecciona Create a new service role y deja el campo Role name en blanco.

  • ExpressionType: MqttTopic
  • Expression: EmbeddedWorldTrackerDemo

Agregar Regla de Decodificador​

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

Nombra tu regla y envíala.

Desde la regla de IoT Core, selecciona la función Lambda y luego haz clic en Create a Lambda function.

Crear función desde cero
Function name: Nombra tu función.
Runtime: Node.js 14.x
Architecture: x86_64

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

En la página de configuración de la función que aparece, elimina todo el código y reemplázalo con el siguiente script. Luego, haz 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 a Device Destination, ingresa un nombre para la regla y escribe el nombre de la función que acabas de crear.

Luego, navega a la AWS IoT Core Console, selecciona MQTT Test Client y suscríbete al topic.

Agregar regla para el tracker​

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)
}

Construcción de la Aplicación Web​

Vamos a desplegar los recursos necesarios de Amazon Location Service para mostrar nuestro dispositivo en un mapa.

Crear el Mapa​

Como primer paso, necesitarás crear un nuevo recurso de mapa en Amazon Location Service 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, después haz clic en Create map.

Crear Calculadora de Rutas​

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

Crear Rastreador​

Navega a Trackers -> Create tracker:

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

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

Crear Colección de Geocercas​

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

Mostrar la Aplicación Web​

Desplegar la App en CloudFront​

  • En tu terminal de Cloud9, navega a /home/ec2-user/environment/asset-tracking-workshop:

    cd /home/ec2-user/environment/asset-tracking-workshop

  • Corre el siguiente comando:

    npm run frontend:publish

  • Una vez completado, recibirás el URL del sitio web

  • Navega a esta URL en tu navegador para ver tu aplicación de rastreo.

Recursos​

SWDM016

template_lbm_wio_tracker

Loading Comments...