Añadir capas de portabilidad de bibliotecas Configure sus credenciales AWS Creación de un grupo de dispositivos en IDT para FreeRTOS Configurar ajustes de Build, Flash y Test

Preparación para probar su placa de microcontrolador por primera vez

Puede utilizar IDT para FreeRTOS para realizar pruebas a medida que traslada las interfaces de FreeRTOS. Después de AWS IoT Device Tester portar las interfaces FreeRTOS a los controladores de los dispositivos de la placa, se suelen realizar las pruebas de calificación en la placa del microcontrolador.

Añadir capas de portabilidad de bibliotecas

Para realizar la portabilidad de FreeRTOS para su dispositivo, siga las instrucciones de la Guía de portabilidad de FreeRTOS.

Configure sus credenciales AWS

Debe configurar sus AWS credenciales para AWS IoT Device Tester poder comunicarse con la AWS nube. Para obtener más información, consulte Configuración de credenciales y regiones de AWS para desarrollo. AWS Las credenciales válidas deben especificarse en el archivo devicetester_extract_location/devicetester_afreertos_[win|mac|linux]/configs/config.json de configuración.

Creación de un grupo de dispositivos en IDT para FreeRTOS

Los dispositivos que se vayan a probar se organizan en grupos de dispositivos. Cada grupo de dispositivos se compone de uno o varios dispositivos idénticos. Puede configurar IDT para FreeRTOS para probar un solo dispositivo de un grupo o varios dispositivos de un grupo. Para acelerar el proceso de calificación, IDT para FreeRTOS puede probar en paralelo dispositivos con la misma especificación. Utiliza un método de turnos rotativos para ejecutar un grupo de pruebas diferentes en todos los dispositivos de un grupo de dispositivos.

Puede añadir uno o varios dispositivos a un grupo de dispositivos editando la sección devices de la plantilla device.json en la carpeta configs.

nota

Todos los dispositivos del mismo grupo debe tener la misma especificación técnica y SKU.

Para habilitar las compilaciones en paralelo del código fuente para diferentes grupos de prueba, IDT para FreeRTOS copia el código fuente en una carpeta de resultados dentro de la carpeta extraída de IDT para FreeRTOS. Se debe hacer referencia a la ruta del código fuente en el comando build o flash con la variable testdata.sourcePath o sdkPath. IDT para FreeRTOS reemplaza esta variable con una ruta temporal del código fuente copiado. Para obtener más información, consulte Variables de IDT para FreeRTOS.

A continuación se muestra un ejemplo de un archivo device.json utilizado para crear un grupo de dispositivos con varios dispositivos.


[
    {
        "id": "pool-id",
        "sku": "sku",
        "features": [
            {
                "name": "WIFI",
                "value": "Yes | No"
            },
            {
                "name": "Cellular",
                "value": "Yes | No"
            },
            {
                "name": "OTA",
                "value": "Yes | No",
                "configs": [
                    {
                        "name": "OTADataPlaneProtocol",
                        "value": "HTTP | MQTT"
                    }
                ]
            },
            {
                "name": "BLE",
                "value": "Yes | No"
            },
            {
                "name": "TCP/IP",
                "value": "On-chip | Offloaded | No"
            },
            {
                "name": "TLS",
                "value": "Yes | No"
            },
            {
                "name": "PKCS11",
                "value": "RSA | ECC | Both | No"
            },
            {
                "name": "KeyProvisioning",
                "value": "Import | Onboard | No"
            }
        ],

        "devices": [
          {
            "id": "device-id",
            "connectivity": {
              "protocol": "uart",
              "serialPort": "/dev/tty*"
            },
            ***********Remove the section below if the device does not support onboard key generation***************
            "secureElementConfig" : {
              "publicKeyAsciiHexFilePath": "absolute-path-to/public-key-txt-file: contains-the-hex-bytes-public-key-extracted-from-onboard-private-key",
              "secureElementSerialNumber": "secure-element-serialNo-value",
              "preProvisioned"           : "Yes | No"
            },
            **********************************************************************************************************
            "identifiers": [
              {
                "name": "serialNo",
                "value": "serialNo-value"
              }
            ]
          }
        ]
    }
]

En el archivo device.json se utilizan los siguientes atributos:

id

Un ID alfanumérico definido por el usuario que identifica de manera exclusiva a un grupo de dispositivos. Los dispositivos que pertenecen a un grupo deben ser del mismo tipo. Cuando se ejecuta un conjunto de pruebas, los dispositivos del grupo se utilizan para paralelizar la carga de trabajo.

sku

Un valor alfanumérico que identifica de forma única la placa que está probando. El SKU se utiliza para realizar un seguimiento de placas cualificadas.

nota

Si quieres incluir tu placa en el catálogo de dispositivos AWS asociados, la SKU que especifiques aquí debe coincidir con la que utilizaste en el proceso de publicación.

features

Una matriz que contiene las funciones compatibles del dispositivo. AWS IoT Device Tester utiliza esta información para seleccionar las pruebas de calificación que se van a ejecutar.

Los valores admitidos son:

TCP/IP

Indica si la placa admite una pila TCP/IP y si es compatible en chip (MCU) o se descarga en otro módulo. TCP/IP es necesario para la cualificación.

WIFI

Indica si la placa tiene capacidades Wi-Fi. Se debe establecer en No si Cellular se establece en Yes.

Cellular

Indica si la placa tiene capacidad móvil. Se debe establecer en No si WIFI se establece en Yes. Si esta función está configuradaYes, la FullSecureSockets prueba se ejecutará con instancias EC2 de AWS t2.micro, lo que puede suponer costes adicionales para su cuenta. Para obtener más información, consulte Precios de Amazon EC2.

TLS

Indica si la placa admite TLS. TLS es necesario para la cualificación.

PKCS11

Indica el algoritmo de criptografía de clave pública que admite la placa. PKCS11 es necesario para la cualificación. Los valores admitidos son ECC, RSA, Both y No. Both indica que la placa admite los algoritmos ECC y RSA.

KeyProvisioning

Indica el método para escribir un certificado de cliente X.509 de confianza en la placa. Los valores admitidos son Import, Onboard y No. El aprovisionamiento de claves es necesario para la cualificación.

Utilice Import si su placa permite la importación de claves privadas. IDT creará una clave privada y la compilará en el código fuente de FreeRTOS.
Utilice Onboard si la placa admite la generación de claves privadas integrada (por ejemplo, si su dispositivo tiene un elemento seguro o si prefiere generar su propio par de claves de dispositivo y certificado). Procure añadir un elemento secureElementConfig en cada una de las secciones del dispositivo e introduzca la ruta absoluta del archivo de claves públicas en el campo publicKeyAsciiHexFilePath.
Si la placa no admite el aprovisionamiento de claves, utilice No.

OTA

Indica si su placa admite la funcionalidad de actualización over-the-air (OTA). El atributo OtaDataPlaneProtocol indica qué protocolo de plano de datos de OTA admite el dispositivo. El atributo se omite si el dispositivo no admite la característica OTA. Cuando "Both" se selecciona, el tiempo de ejecución de las pruebas OTA se prolonga debido a la ejecución de MQTT, HTTP y pruebas mixtas.

nota

A partir de la versión 4.1.0 de IDT, OtaDataPlaneProtocol solo acepta HTTP y MQTT como valores admitidos.

BLE

Indica si la placa admite Bluetooth de bajo consumo (BLE).

devices.id

Un identificador único y definido por el usuario para el dispositivo que se está probando.

devices.connectivity.protocol

El protocolo de comunicación que se usará para la comunicación con este dispositivo. Valor compatible: uart.

devices.connectivity.serialPort

El puerto de serie del equipo host utilizado para conectarse a los dispositivos que se van a probar.

devices.secureElementConfig.PublicKeyAsciiHexFilePath

La ruta absoluta del archivo que contiene la clave pública de bytes hexadecimales extraída de la clave privada integrada.

Formato de ejemplo:


3059 3013 0607 2a86 48ce 3d02 0106 082a
8648 ce3d 0301 0703 4200 04cd 6569 ceb8
1bb9 1e72 339f e8cf 60ef 0f9f b473 33ac
6f19 1813 6999 3fa0 c293 5fae 08f1 1ad0
41b7 345c e746 1046 228e 5a5f d787 d571
dcb2 4e8d 75b3 2586 e2cc 0c

Si la clave pública tiene el formato .der, puede codificar directamente la clave pública en formato hexadecimal para generar el archivo hexadecimal.

Ejemplo de comando para que la clave pública .der genere un archivo hexadecimal:


xxd -p pubkey.der > outFile

Si la clave pública tiene el formato .pem, puede extraer la parte codificada en base64, decodificarla en formato binario y, a continuación, codificarla en formato hexadecimal para generar el archivo hexadecimal.

Por ejemplo, utilice estos comandos para generar un archivo hexadecimal para una clave pública .pem:

Saque la parte de la clave codificada en base64 (elimine el encabezado y el pie de página) y guárdela en un archivo, por ejemplo, con el nombre base64key, y ejecute este comando para convertirla al formato .der:
```
base64 —decode base64key > pubkey.der
```
Ejecute el comando xxd para convertirla a formato hexadecimal.
```
xxd -p pubkey.der > outFile
```

devices.secureElementConfig.SecureElementSerialNumber

(Opcional) Número de serie del elemento seguro. Indique este campo cuando se imprima el número de serie junto con la clave pública del dispositivo al ejecutar el proyecto de demostración/prueba de FreeRTOS.

devices.secureElementConfig.preProvisioned

(Opcional) Indique el valor “Sí” si el dispositivo tiene un elemento seguro aprovisionado previamente con credenciales bloqueadas, que no puede importar, crear ni destruir objetos. Esta configuración solo se aplica cuando features tiene KeyProvisioning establecido en “Incorporación” y PKCS11 está establecido en “ECC”.

identifiers

(Opcional) Una matriz de pares de nombre-valor arbitrarios. Puede utilizar estos valores en los comandos Build y Flash descritos en la siguiente sección.

Configurar ajustes de Build, Flash y Test

Para que IDT para FreeRTOS pueda compilar e instalar pruebas en su placa de forma automática, debe configurar IDT para que ejecute los comandos de compilación e instalación para su hardware. Los ajustes de compilación e instalación se configuran en el archivo de plantilla config que se encuentra en la carpeta userdata.json.

Configurar ajustes para probar dispositivos

Los ajustes de compilación, instalación y prueba se realizan en el archivo configs/userdata.json. Se admite la configuración del servidor Echo cargando los certificados y las claves del cliente y del servidor en customPath. Para obtener más información, consulte Configuración de un servidor echo en la Guía de portabilidad de FreeRTOS. El siguiente ejemplo de JSON muestra cómo puede configurar IDT para FreeRTOS para probar varios dispositivos:


{
    "sourcePath": "/absolute-path-to/freertos",
    "vendorPath": "{{testData.sourcePath}}/vendors/vendor-name/boards/board-name",
    // ***********The sdkConfiguration block below is needed if you are not using the default, unmodified FreeRTOS repo. 
    // In other words, if you are using the default, unmodified FreeRTOS repo then remove this block***************
    "sdkConfiguration": {
        "name": "sdk-name",
        "version": "sdk-version",
        "path": "/absolute-path-to/sdk"
    },
    "buildTool": {
        "name": "your-build-tool-name",
        "version": "your-build-tool-version",
        "command": [
            "{{config.idtRootPath}}/relative-path-to/build-parallel.sh {{testData.sourcePath}} {{enableTests}}"
        ]
    },
    "flashTool": {
        "name": "your-flash-tool-name",
        "version": "your-flash-tool-version",
        "command": [
            "/{{config.idtRootPath}}/relative-path-to/flash-parallel.sh {{testData.sourcePath}} {{device.connectivity.serialPort}} {{buildImageName}}"
        ],
        "buildImageInfo" : {
            "testsImageName": "tests-image-name",
            "demosImageName": "demos-image-name"
        }
    },
    "testStartDelayms": 0,
    "clientWifiConfig": {
        "wifiSSID": "ssid",
        "wifiPassword": "password",
        "wifiSecurityType": "eWiFiSecurityOpen | eWiFiSecurityWEP | eWiFiSecurityWPA | eWiFiSecurityWPA2 | eWiFiSecurityWPA3"
    },
    "testWifiConfig": {
        "wifiSSID": "ssid",
        "wifiPassword": "password",
        "wifiSecurityType": "eWiFiSecurityOpen | eWiFiSecurityWEP | eWiFiSecurityWPA | eWiFiSecurityWPA2 | eWiFiSecurityWPA3"
    },
    //**********
    //This section is used to start echo server based on server certificate generation method,
    //When certificateGenerationMethod is set as Automatic specify the eccCurveFormat to generate certifcate and key based on curve format,
    //When certificateGenerationMethod is set as Custom specify the certificatePath and PrivateKeyPath to be used to start echo server
    //**********
    "echoServerCertificateConfiguration": {
      "certificateGenerationMethod": "Automatic | Custom",
      "customPath": {
          "clientCertificatePath":"/path/to/clientCertificate",
          "clientPrivateKeyPath": "/path/to/clientPrivateKey",
          "serverCertificatePath":"/path/to/serverCertificate",
          "serverPrivateKeyPath": "/path/to/serverPrivateKey"
      },
    "eccCurveFormat": "P224 | P256 | P384 | P521"
    },
    "echoServerConfiguration": {
        "securePortForSecureSocket": 33333, // Secure tcp port used by SecureSocket test. Default value is 33333. Ensure that the port configured isn't blocked by the firewall or your corporate network
        "insecurePortForSecureSocket": 33334, // Insecure tcp port used by SecureSocket test. Default value is 33334. Ensure that the port configured isn't blocked by the firewall or your corporate network
        "insecurePortForWiFi": 33335 // Insecure tcp port used by Wi-Fi test. Default value is 33335. Ensure that the port configured isn't blocked by the firewall or your corporate network
    },
    "otaConfiguration": {
        "otaFirmwareFilePath": "{{testData.sourcePath}}/relative-path-to/ota-image-generated-in-build-process",
        "deviceFirmwareFileName": "ota-image-name-on-device",
        "otaDemoConfigFilePath": "{{testData.sourcePath}}/relative-path-to/ota-demo-config-header-file",
        "codeSigningConfiguration": {
            "signingMethod": "AWS | Custom",
            "signerHashingAlgorithm": "SHA1 | SHA256",
            "signerSigningAlgorithm": "RSA | ECDSA",
            "signerCertificate": "arn:partition:service:region:account-id:resource:qualifier | /absolute-path-to/signer-certificate-file",
            "signerCertificateFileName": "signerCertificate-file-name",
            "compileSignerCertificate": boolean,
            // ***********Use signerPlatform if you choose aws for signingMethod***************
            "signerPlatform": "AmazonFreeRTOS-Default | AmazonFreeRTOS-TI-CC3220SF",
            "untrustedSignerCertificate": "arn:partition:service:region:account-id:resourcetype:resource:qualifier",
            // ***********Use signCommand if you choose custom for signingMethod***************
            "signCommand": [
                "/absolute-path-to/sign.sh {{inputImageFilePath}} {{outputSignatureFilePath}}"
            ]
        }
    },
    // ***********Remove the section below if you're not configuring CMake***************
    "cmakeConfiguration": {
        "boardName": "board-name",
        "vendorName": "vendor-name",
        "compilerName": "compiler-name",
        "frToolchainPath": "/path/to/freertos/toolchain",
        "cmakeToolchainPath": "/path/to/cmake/toolchain"
    },
    "freertosFileConfiguration": {
        "required": [
            {
                "configName": "pkcs11Config",
                "filePath": "{{testData.sourcePath}}/vendors/vendor-name/boards/board-name/aws_tests/config_files/core_pkcs11_config.h"
            },
            {
                "configName": "pkcs11TestConfig",
                "filePath": "{{testData.sourcePath}}/vendors/vendor-name/boards/board-name/aws_tests/config_files/iot_test_pkcs11_config.h"
            }
        ],
        "optional": [
            {
                "configName": "otaAgentTestsConfig",
                "filePath": "{{testData.sourcePath}}/vendors/vendor-name/boards/board-name/aws_tests/config_files/ota_config.h"
            },
            {
                "configName": "otaAgentDemosConfig",
                "filePath": "{{testData.sourcePath}}/vendors/vendor-name/boards/board-name/aws_demos/config_files/ota_config.h"
            },
            {
                "configName": "otaDemosConfig",
                "filePath": "{{testData.sourcePath}}/vendors/vendor-name/boards/board-name/aws_demos/config_files/ota_demo_config.h"
            }
        ]
    }
}

A continuación se indican los atributos usados en userdata.json:

sourcePath

La ruta a la raíz del código fuente de FreeRTOS trasladado. Para las pruebas en paralelo con un SDK, sourcePath se puede establecer mediante el marcador de posición {{userData.sdkConfiguration.path}}. Por ejemplo:


{ "sourcePath":"{{userData.sdkConfiguration.path}}/freertos" }

vendorPath

La ruta al código de FreeRTOS específico del proveedor. Para las pruebas en serie, vendorPath se puede establecer como una ruta absoluta. Por ejemplo:


{ "vendorPath":"C:/path-to-freertos/vendors/espressif/boards/esp32" }

Para las pruebas en paralelo, vendorPath se puede establecer mediante el marcador {{testData.sourcePath}}. Por ejemplo:


{ "vendorPath":"{{testData.sourcePath}}/vendors/espressif/boards/esp32" }

La variable vendorPath solo es necesaria cuando se ejecuta sin un SDK; de lo contrario, se puede eliminar.

nota

Al ejecutar pruebas en paralelo sin un SDK, el marcador de posición {{testData.sourcePath}} se debe utilizar en los campos vendorPath, buildTool y flashTool. Al ejecutar la prueba con un solo dispositivo, las rutas absolutas se deben utilizar en los campos vendorPath, buildTool y flashTool. Cuando se ejecuta con un SDK, el marcador de posición {{sdkPath}} debe usarse en los comandos sourcePath, buildTool y flashTool.

sdkConfiguration

Si va a calificar FreeRTOS con alguna modificación en la estructura de archivos y carpetas que vaya más allá de lo necesario para la portabilidad, tendrá que configurar la información del SDK en este bloque. Si no va a calificar un FreeRTOS con un FreeRTOS trasladado dentro de un SDK, puede omitir este bloque por completo.

sdkConfiguration.name: El nombre del SDK que está utilizando con FreeRTOS. Si no utiliza un SDK, puede omitir todo el bloque de sdkConfiguration.
sdkConfiguration.version: La versión del SDK que está utilizando con FreeRTOS. Si no utiliza un SDK, puede omitir todo el bloque de sdkConfiguration.
sdkConfiguration.path: La ruta absoluta al directorio del SDK que contiene el código de FreeRTOS. Si no utiliza un SDK, puede omitir todo el bloque de sdkConfiguration.

buildTool

La ruta completa a su script de compilación (.bat o .sh) que contiene los comandos para compilar el código fuente. Todas las referencias a la ruta del código fuente en el comando de compilación deben reemplazarse por la AWS IoT Device Tester variable {{testdata.sourcePath}} y las referencias a la ruta del SDK deben reemplazarse por{{sdkPath}}. Utilice el marcador de posición {{config.idtRootPath}} para hacer referencia a la ruta de IDT absoluta o relativa.

testStartDelayms

Especifica cuántos milisegundos esperará el ejecutor de pruebas de FreeRTOS antes de empezar a ejecutar las pruebas. Esto puede resultar útil si el dispositivo que se está probando comienza a generar información de prueba importante antes de que IDT tenga la oportunidad de conectarse y empezar a registrar datos debido a una latencia de red o de otro tipo. El valor máximo permitido es de 30 000 ms (30 segundos). Este valor se aplica únicamente a los grupos de pruebas de FreeRTOS y no a otros grupos de pruebas que no utilizan el ejecutor de pruebas de FreeRTOS, como las pruebas OTA.

flashTool

Ruta completa a su script de flash (.sh o .bat) que contiene los comandos flash para su dispositivo. Todas las referencias a la ruta del código fuente en el comando de instalación deben reemplazarse por la variable {{testdata.sourcePath}} de IDT para FreeRTOS y todas las referencias a la ruta del SDK deben reemplazarse por la variable {{sdkPath}} de IDT para FreeRTOS. Utilice el marcador de posición {{config.idtRootPath}} para hacer referencia a la ruta de IDT absoluta o relativa.

buildImageInfo

testsImageName: El nombre del archivo creado por el comando de compilación al compilar pruebas desde la carpeta freertos-source/tests.
demosImageName: El nombre del archivo creado por el comando de compilación al compilar pruebas desde la carpeta freertos-source/demos.

clientWifiConfig

La configuración de wifi del cliente. Las pruebas de biblioteca Wi-Fi requieren una placa MCU para conectarse a dos puntos de acceso. (Los dos puntos de acceso pueden ser los mismos). Este atributo configura los ajustes de Wi-Fi para el primer punto de acceso. Algunos de los casos de prueba Wi-Fi esperan que el punto de acceso tenga cierto nivel de seguridad y que no estén abiertos. Asegúrese de que ambos puntos de acceso estén en la misma subred que el equipo host que ejecuta IDT.

wifi_ssid

El SSID de wifi.

wifi_password

La contraseña de wifi.

wifiSecurityType

El tipo de seguridad wifi utilizada. Uno de los valores:

eWiFiSecurityOpen
eWiFiSecurityWEP
eWiFiSecurityWPA
eWiFiSecurityWPA2
eWiFiSecurityWPA3

nota

Si la placa no es compatible con wifi, debe volver a incluir la sección clientWifiConfig en el archivo device.json, pero puede omitir los valores de estos atributos.

testWifiConfig

La configuración de wifi de prueba. Las pruebas de biblioteca Wi-Fi requieren una placa MCU para conectarse a dos puntos de acceso. (Los dos puntos de acceso pueden ser los mismos). Este atributo configura los ajustes de wifi para el segundo punto de acceso. Algunos de los casos de prueba Wi-Fi esperan que el punto de acceso tenga cierto nivel de seguridad y que no estén abiertos. Asegúrese de que ambos puntos de acceso estén en la misma subred que el equipo host que ejecuta IDT.

wifiSSID

El SSID de wifi.

wifiPassword

La contraseña de wifi.

wifiSecurityType

El tipo de seguridad wifi utilizada. Uno de los valores:

eWiFiSecurityOpen
eWiFiSecurityWEP
eWiFiSecurityWPA
eWiFiSecurityWPA2
eWiFiSecurityWPA3

nota

Si la placa no es compatible con wifi, debe volver a incluir la sección testWifiConfig en el archivo device.json, pero puede omitir los valores de estos atributos.

echoServerCertificateConfiguration

El marcador de posición configurable para la generación de certificados del servidor echo para realizar pruebas de conexiones seguras. Este campo es obligatorio.

certificateGenerationMethod

Especifica si el certificado del servidor se genera automáticamente o se proporciona manualmente.

customPath

Si certificateGenerationMethod es “Personalizado”, certificatePath y privateKeyPath son obligatorios.

certificatePath: Especifica la ruta de archivo del certificado del servidor.
privateKeyPath: Especifica la ruta del archivo de la clave privada.

eccCurveFormat

Especifica el formato de curva que admite la placa. Es necesario si PKCS11 se ha establecido en “ecc” en device.json. Los valores válidos son “P224”, “P256”, “P384” o “P521”.

echoServerConfiguration

Los puertos configurables del servidor echo para las pruebas de sockets seguros WiFi y las conexiones. Este campo es opcional.

securePortForSecureSocket: El puerto que se utiliza para configurar un servidor de eco con TLS para la prueba de sockets seguros. El valor predeterminado es 33333. Asegúrese de que el puerto configurado no esté bloqueado por un firewall o por la red de la empresa.
insecurePortForSecureSocket: El puerto que se utiliza para configurar un servidor de eco sin TLS para la prueba de sockets seguros. El valor predeterminado que se ha utilizado en la prueba es 33334. Asegúrese de que el puerto configurado no esté bloqueado por un firewall o por la red de la empresa.
insecurePortForWiFi: El puerto que se utiliza para configurar el servidor echo sin TLS para la WiFi prueba. El valor predeterminado que se ha utilizado en la prueba es 33335. Asegúrese de que el puerto configurado no esté bloqueado por un firewall o por la red de la empresa.

otaConfiguration

La configuración de OTA. [Opcional]

otaFirmwareFilePath

La ruta completa a la imagen de OTA creada después de la compilación. Por ejemplo, {{testData.sourcePath}}/relative-path/to/ota/image/from/source/root.

deviceFirmwareFileName

La ruta de archivo completa en el dispositivo de MCU donde se descargará el firmware de OTA. Algunos dispositivos no utilizan este campo, pero en cualquier caso deberá proporcionar un valor.

otaDemoConfigFilePath

La ruta completa a aws_demo_config.h, que se encuentra en afr-source/vendors/vendor/boards/board/aws_demos/config_files/. Estos archivos se incluyen en la plantilla de código de portabilidad proporcionada por FreeRTOS.

codeSigningConfiguration

La configuración de firma de código.

signingMethod

El método de firma de código. Los valores posibles son AWS o Custom.

nota

Para las regiones de Pekín y Ningxia, utilice Custom. La firma de código de AWS no se admite en estas regiones.

signerHashingAlgorithm

El algoritmo hash admitido en el dispositivo. Los valores posibles son SHA1 o SHA256.

signerSigningAlgorithm

El algoritmo de firma admitido en el dispositivo. Los valores posibles son RSA o ECDSA.

signerCertificate

Certificado de confianza utilizado para OTA.

Para el método de firma de AWS código, utilice el nombre de recurso de Amazon (ARN) para el certificado de confianza cargado en. AWS Certificate Manager

Para el método de firma de código personalizado, utilice la ruta absoluta al archivo de certificado del firmante.

Para obtener más información acerca de cómo crear un certificado de confianza, consulte Crear un certificado de firma de código.

signerCertificateFileName

El nombre de la ruta del certificado de firma de código en el dispositivo. Este valor debe coincidir con el nombre de archivo que proporcionó al ejecutar el comando aws acm import-certificate.

Para obtener más información, consulte Crear un certificado de firma de código.

compileSignerCertificate

trueEstablézcalo en si el certificado de verificación de firma del firmante del código no está aprovisionado ni mostrado, por lo que debe compilarse en el proyecto. AWS IoT Device Tester busca el certificado de confianza y lo compila en él. aws_codesigner_certifiate.h

untrustedSignerCertificate

El ARN o ruta de archivo de un segundo certificado utilizado en algunas pruebas OTA como certificado que no es de confianza. Para obtener más información sobre cómo crear un certificado, consulte Creación de un certificado de firma de código.

signerPlatform

El algoritmo de firma y cifrado que AWS Code Signer utiliza al crear el trabajo de actualización de la OTA. En la actualidad, los valores posibles para este campo son AmazonFreeRTOS-TI-CC3220SF y AmazonFreeRTOS-Default.

Elija AmazonFreeRTOS-TI-CC3220SF si es SHA1 y RSA.
Elija AmazonFreeRTOS-Default si es SHA256 y ECDSA.

Si necesita SHA256 | RSA o SHA1 | ECDSA para su configuración, contacte con nosotros para obtener ayuda adicional.

Configure signCommand si eligió Custom para signingMethod.

signCommand

El comando utilizado para realizar la firma de código personalizado. Puede encontrar la plantilla en el directorio /configs/script_templates.

Se necesitan dos marcadores de posición {{inputImageFilePath}} y {{outputSignatureFilePath}} en el comando. {{inputImageFilePath}} es la ruta del archivo de la imagen creada por IDT que se va a firmar. {{outputSignatureFilePath}} es la ruta del archivo de la firma que generará el script.

cmakeConfiguration

Configuración de CMake [opcional]

nota

Para ejecutar casos de prueba de CMake, debe proporcionar el nombre de la placa, el nombre del proveedor y la frToolchainPath o el compilerName. También puede proporcionar la cmakeToolchainPath si tiene una ruta personalizada a la cadena de herramientas de CMake.

boardName: El nombre de la placa que se prueba. El nombre de la placa debe ser el mismo que el nombre de la carpeta en path/to/afr/source/code/vendors/vendor/boards/board.
vendorName: El nombre del proveedor de la placa que se prueba. El nombre del proveedor debe ser el mismo que el nombre de la carpeta path/to/afr/source/code/vendors/vendor.
compilerName: El nombre del compilador.
frToolchainPath: La ruta completa de la cadena de herramientas del compilador.
cmakeToolchainPath: La ruta completa de la cadena de herramientas de CMake. Este campo es opcional

freertosFileConfiguration

La configuración de los archivos FreeRTOS que IDT modifica antes de ejecutar las pruebas.

required

En esta sección se especifican las pruebas obligatorias cuyos archivos de configuración ha movido, por ejemplo, PKCS11, TLS, etc.

configName: El nombre de la prueba que se está configurando.
filePath: La ruta absoluta a los archivos de configuración en el repositorio freertos. Utilice la variable {{testData.sourcePath}} para definir la ruta.

optional

En esta sección se especifican las pruebas opcionales cuyos archivos de configuración ha movido, por ejemplo WiFi, OTA, etc.

configName: El nombre de la prueba que se está configurando.
filePath: La ruta absoluta a los archivos de configuración en el repositorio freertos. Utilice la variable {{testData.sourcePath}} para definir la ruta.

nota

Para ejecutar casos de prueba de CMake, debe proporcionar el nombre de la placa, el nombre del proveedor y la afrToolchainPath o el compilerName. También puede proporcionar la cmakeToolchainPath si tiene una ruta personalizada a la cadena de herramientas de CMake.

Variables de IDT para FreeRTOS

Los comandos para compilar el código y flashear el dispositivo pueden requerir conectividad u otra información sobre los dispositivos para funcionar correctamente. AWS IoT Device Tester permite hacer referencia a la información del dispositivo en flash y crear comandos utilizando JsonPath. Mediante el uso de JsonPath expresiones sencillas, puede obtener la información requerida especificada en el device.json archivo.

Variables de ruta

IDT para FreeRTOS define las siguientes variables de ruta que se pueden utilizar en líneas de comandos y archivos de configuración:

{{testData.sourcePath}}: Amplía la ruta del código fuente. Si utiliza esta variable, se debe utilizar tanto en los comandos flash como en los comandos build.
{{sdkPath}}: Se expande al valor que tiene en su userData.sdkConfiguration.path cuando se utiliza en los comandos build y flash.
{{device.connectivity.serialPort}}: Amplía al puerto serie.
{{device.identifiers[?(@.name == 'serialNo')].value[0]}}: Se amplía hasta el número de serie de su dispositivo.
{{enableTests}}: Valor entero que indica si la compilación es para pruebas (valor 1) o demostraciones (valor 0).
{{buildImageName}}: El nombre de archivo de la imagen compilada por el comando de compilación.
{{otaCodeSignerPemFile}}: Archivo PEM para el firmante del código OTA.
{{config.idtRootPath}}: Se expande hasta la ruta AWS IoT Device Tester raíz. Esta variable reemplaza la ruta absoluta de IDT cuando la utilizan los comandos build y flash.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Requisitos previos

Uso de la IU de IDT para ejecutar el conjunto de calificación de FreeRTOS