Adicionar camadas de transferência da biblioteca Configure seu AWS credenciais Crie um pool de dispositivos IDT gratuitamente RTOS Configuração de parâmetros de compilação, atualização e teste

Preparação para testar sua placa de microcontrolador pela primeira vez

Você pode usar o IDT for Free RTOS para testar a portabilidade das RTOS interfaces do Free. Depois de portar as RTOS interfaces gratuitas para os drivers de dispositivo da sua placa, você usa AWS IoT Device Tester para executar os testes de qualificação em sua placa de microcontrolador.

Adicionar camadas de transferência da biblioteca

Para portar o Free RTOS para o seu dispositivo, siga as instruções no Guia de RTOS portabilidade gratuita.

Configure seu AWS credenciais

Você precisa configurar seu AWS credenciais para AWS IoT Device Tester para se comunicar com o AWS Nuvem. Para obter mais informações, consulte Configurar AWS Credenciais e região para desenvolvimento. Válido AWS as credenciais devem ser especificadas no arquivo devicetester_extract_location/devicetester_afreertos_[win|mac|linux]/configs/config.json de configuração.

Crie um pool de dispositivos IDT gratuitamente RTOS

Os dispositivos a serem testados são organizados em grupos de dispositivos. Cada grupo de dispositivos consiste em um ou mais dispositivos idênticos. Você pode configurar IDT gratuitamente RTOS para testar um único dispositivo em um pool ou vários dispositivos em um pool. Para acelerar o processo de qualificação, IDT o for Free RTOS pode testar dispositivos com as mesmas especificações em paralelo. Ele usa o método round-robin para executar um grupo de testes diferente em cada dispositivo de um grupo de dispositivos.

Você pode adicionar um ou mais dispositivos a um grupo de dispositivos editando a seção devices do modelo device.json na pasta configs.

nota

Todos os dispositivos no mesmo pool devem ter a mesma especificação técnica SKU e.

Para permitir compilações paralelas do código-fonte para diferentes grupos de teste, o IDT for Free RTOS copia o código-fonte para uma pasta de resultados dentro da pasta RTOS extraída do IDT for Free. O caminho do código-fonte no comando de compilação ou atualização deve ser referenciado por meio da variável testdata.sourcePath ou sdkPath. IDTfor Free RTOS substitui essa variável por um caminho temporário do código-fonte copiado. Para obter mais informações, consulte, IDTpara RTOS variáveis gratuitas.

Veja a seguir um exemplo do arquivo device.json usado para criar um grupo de dispositivos com vários 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"
              }
            ]
          }
        ]
    }
]

Os seguintes recursos são usados no arquivo device.json:

id

Um ID alfanumérico definido pelo usuário que identifica exclusivamente um grupo de dispositivos. Os dispositivos que pertencem a um grupo devem ser do mesmo tipo. Quando um conjunto de testes está em execução, os dispositivos do grupo são usados para paralelizar a carga de trabalho.

sku

Um valor alfanumérico que identifica exclusivamente a placa sendo testada. SKUÉ usado para rastrear placas qualificadas.

nota

Se você quiser listar sua pasta em AWS O Catálogo de dispositivos do parceiro, SKU que você especificar aqui, deve corresponder ao SKU que você usa no processo de listagem.

features

Uma matriz que contém recursos compatíveis com o dispositivo. AWS IoT Device Tester usa essas informações para selecionar os testes de qualificação a serem executados.

Os valores compatíveis são:

TCP/IP

Indica se sua placa suporta uma pilha TCP /IP e se ela é suportada no chip (MCU) ou descarregada em outro módulo. TCP/IP é necessário para a qualificação.

WIFI

Indica se a placa tem recursos de Wi-Fi. Deve ser definido como No, se Cellular estiver definido como Yes.

Cellular

Indica se a placa tem recursos de celular. Deve ser definido como No, se WIFI estiver definido como Yes. Quando esse recurso estiver definido comoYes, o FullSecureSockets teste será executado usando AWS EC2instâncias t2.micro e isso pode incorrer em custos adicionais em sua conta. Para obter mais informações, consulte os EC2preços da Amazon.

TLS

Indica se sua placa suportaTLS. TLSé necessário para a qualificação.

PKCS11

Indica o algoritmo de criptografia de chave pública compatível com a placa. PKCS11é necessário para a qualificação. Os valores compatíveis são ECC, RSA, Both e No. Both indica que a placa é compatível com os algoritmos ECC e RSA.

KeyProvisioning

Indica o método de gravação de um certificado de cliente X.509 confiável em sua placa. Os valores válidos são Import, Onboard e No. O provisionamento de chaves é necessário para a qualificação.

Use Import se a sua placa permitir a importação de chaves privadas. IDTcriará uma chave privada e a integrará no RTOS código-fonte gratuito.
Use Onboard se a placa for compatível com a geração de chaves privadas integradas (por exemplo, se o dispositivo tiver um elemento seguro ou se você preferir gerar o seu próprio par de chaves de dispositivo e certificado). Adicione um elemento secureElementConfig em cada uma das seções do dispositivo e coloque o caminho absoluto para o arquivo de chave pública no campo publicKeyAsciiHexFilePath.
Se a placa não for compatível com o provisionamento de chaves, use No.

OTA

Indica se sua placa suporta over-the-air (OTA) a funcionalidade de atualização. O OtaDataPlaneProtocol atributo indica qual protocolo de OTA plano de dados o dispositivo suporta. O atributo será ignorado se o OTA recurso não for suportado pelo dispositivo. Quando "Both" selecionado, o tempo de execução do OTA teste é prolongado devido à execução de testes mistos e ambosMQTT. HTTP

nota

A partir da IDT v4.1.0, OtaDataPlaneProtocol aceita somente HTTP e MQTT como valores suportados.

BLE

Indica se sua placa suporta Bluetooth Low Energy (BLE).

devices.id

Um identificador exclusivo, definido pelo usuário, para o dispositivo que está sendo testado.

devices.connectivity.protocol

O protocolo de comunicação usado para se comunicar com esse dispositivo. Valor compatível: uart.

devices.connectivity.serialPort

A porta serial do computador host usada para se conectar aos dispositivos que estão sendo testados.

devices.secureElementConfig.PublicKeyAsciiHexFilePath

O caminho absoluto para o arquivo que contém a chave pública de bytes hexadecimal extraída da chave privada integrada.

Formato de exemplo:


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

Se sua chave pública estiver no formato .der, você pode codificar a chave pública em hexadecimal diretamente para gerar o arquivo hexadecimal.

Exemplo de comando para a chave pública .der para gerar o arquivo hexadecimal:


xxd -p pubkey.der > outFile

Se sua chave pública estiver no formato .pem, é possível extrair a parte codificada em base64, decodificá-la em formato binário e, em seguida, codificá-la em hexadecimal para gerar o arquivo hexadecimal.

Por exemplo, use esses comandos para gerar um arquivo hexadecimal para a chave pública .pem:

Retire a parte codificada em base64 da chave (retire o cabeçalho e o rodapé) e armazene-a em um arquivo, por exemplo, nomeie-a como base64key, execute este comando para convertê-la para o formato .der:
```
base64 —decode base64key > pubkey.der
```
Execute o comando xxd para convertê-la para o formato hexadecimal.
```
xxd -p pubkey.der > outFile
```

devices.secureElementConfig.SecureElementSerialNumber

(Opcional) O número de série do elemento seguro. Forneça esse campo quando o número de série for impresso junto com a chave pública do dispositivo ao executar o projeto de RTOS demonstração/teste gratuito.

devices.secureElementConfig.preProvisioned

(Opcional) Defina como "Sim" se o dispositivo tiver um elemento seguro pré-provisionado com credenciais bloqueadas, que não possa importar, criar ou destruir objetos. Essa configuração entra em vigor somente quando features KeyProvisioning definida como “Integrado”, junto com PKCS11 definida como "ECC”.

identifiers

(Opcional) Uma matriz de pares de nome-valor arbitrários. Você pode usar esses valores nos comandos de compilação e atualização descritos na próxima seção.

Configuração de parâmetros de compilação, atualização e teste

IDTRTOSPara criar e testar automaticamente em sua placa gratuitamente, você deve configurar IDT para executar os comandos de compilação e flash em seu hardware. As configurações de comando de compilação e atualização são definidas no modelo de arquivo userdata.json localizado na pasta config.

Configuração de parâmetros para testar dispositivos

As configurações de compilação, atualização e teste são feitas no arquivo configs/userdata.json. Oferecemos suporte à configuração do servidor echo carregando os certificados e chaves do cliente e do servidor no customPath. Para obter mais informações, consulte Configurando um servidor de eco no Guia de RTOS portabilidade gratuita. O JSON exemplo a seguir mostra como você pode configurar IDT o Free RTOS para testar vários 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"
            }
        ]
    }
}

Veja a seguir uma lista dos recursos usados no userdata.json:

sourcePath

O caminho para a raiz do RTOS código-fonte livre portado. Para testes paralelos com umSDK, eles sourcePath podem ser configurados usando o {{userData.sdkConfiguration.path}} espaço reservado. Por exemplo:


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

vendorPath

O caminho para o RTOS código gratuito específico do fornecedor. Para testes em série, o vendorPath pode ser definido como um caminho absoluto. Por exemplo:


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

Para testes paralelos, o vendorPath pode ser definido usando o espaço reservado {{testData.sourcePath}}. Por exemplo:


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

A vendorPath variável só é necessária quando executada sem umSDK, caso contrário, ela pode ser removida.

nota

Ao executar testes em paralelo sem umSDK, o {{testData.sourcePath}} espaço reservado deve ser usado nos flashTool camposvendorPath,buildTool,. o executar o teste com um único dispositivo, caminhos absolutos devem ser usados nos campos vendorPath, buildTool e flashTool. Ao executar com umSDK, o {{sdkPath}} espaço reservado deve ser usado nos flashTool comandos sourcePathbuildTool, e.

sdkConfiguration

Se você estiver qualificado como Gratuito RTOS com quaisquer modificações nos arquivos e na estrutura de pastas além do necessário para a portabilidade, você precisará configurar suas SDK informações neste bloco. Se você não está qualificado com um Free portado RTOS dentro de umSDK, você deve omitir totalmente esse bloco.

sdkConfiguration.name: O nome do SDK que você está usando com o FreeRTOS. Se você não estiver usando umSDK, o sdkConfiguration bloco inteiro deverá ser omitido.
sdkConfiguration.version: A versão do SDK que você está usando com o FreeRTOS. Se você não estiver usando umSDK, o sdkConfiguration bloco inteiro deverá ser omitido.
sdkConfiguration.path: O caminho absoluto para seu SDK diretório que contém seu RTOS código livre. Se você não estiver usando umSDK, o sdkConfiguration bloco inteiro deverá ser omitido.

buildTool

O caminho completo para o script de compilação (.bat ou .sh) que contém os comandos para compilar seu código-fonte. Todas as referências ao caminho do código-fonte no comando build devem ser substituídas pelo AWS IoT Device Tester a variável {{testdata.sourcePath}} e as referências ao SDK caminho devem ser substituídas por{{sdkPath}}. Use o {{config.idtRootPath}} espaço reservado para referenciar o IDT caminho absoluto ou relativo.

testStartDelayms

Especifica quantos milissegundos o executor de RTOS teste gratuito esperará antes de começar a executar os testes. Isso pode ser útil se o dispositivo em teste começar a emitir informações de teste importantes antes IDT de ter a chance de se conectar e iniciar o registro devido à rede ou outra latência. O valor máximo permitido é 30.000 ms (30 segundos). Esse valor é aplicável somente aos grupos de RTOS teste gratuitos e não aplicável a outros grupos de teste que não utilizam o executor de RTOS teste gratuito, como os OTA testes.

flashTool

O caminho completo para o script de atualização (.sh ou .bat) que contém os comandos de atualização para o dispositivo. Todas as referências ao caminho do código-fonte no comando f.ash devem ser substituídas pela RTOS variável IDT for Free {{testdata.sourcePath}} e todas as referências ao seu SDK caminho devem ser substituídas pela RTOS variável IDT for Free{{sdkPath}}. Use o {{config.idtRootPath}} espaço reservado para referenciar o caminho absoluto ou relativo. IDT

buildImageInfo

testsImageName: O nome do arquivo produzido pelo comando de compilação ao compilar testes da pasta freertos-source/tests.
demosImageName: O nome do arquivo produzido pelo comando de compilação ao compilar testes da pasta freertos-source/demos.

clientWifiConfig

Configuração do Wi-Fi do cliente. Os testes da biblioteca Wi-Fi exigem que uma MCU placa se conecte a dois pontos de acesso. (Os dois pontos de acesso podem ser os mesmos.) Este atributo define as configurações de Wi-Fi para o primeiro ponto de acesso. Alguns dos casos de teste de Wi-Fi esperam que o ponto de acesso tenha algum recurso de segurança e que não esteja aberto. Verifique se os dois pontos de acesso estão na mesma sub-rede do computador host em execuçãoIDT.

wifi_ssid

O Wi-FiSSID.

wifi_password

A senha do Wi-Fi.

wifiSecurityType

O tipo de segurança do Wi-Fi utilizada. Um dos valores:

eWiFiSecurityOpen
eWiFiSecurityWEP
eWiFiSecurityWPA
eWiFiSecurityWPA2
eWiFiSecurityWPA3

nota

Se a placa não for compatível com Wi-Fi, você ainda deverá incluir a seção clientWifiConfig no arquivo device.json, mas poderá omitir os valores desses recursos.

testWifiConfig

Configuração de teste do Wi-Fi. Os testes da biblioteca Wi-Fi exigem que uma MCU placa se conecte a dois pontos de acesso. (Os dois pontos de acesso podem ser os mesmos.) Esse atributo define a configuração do Wi-Fi para o segundo ponto de acesso. Alguns dos casos de teste de Wi-Fi esperam que o ponto de acesso tenha algum recurso de segurança e que não esteja aberto. Verifique se os dois pontos de acesso estão na mesma sub-rede do computador host em execuçãoIDT.

wifiSSID

O Wi-FiSSID.

wifiPassword

A senha do Wi-Fi.

wifiSecurityType

O tipo de segurança do Wi-Fi utilizada. Um dos valores:

eWiFiSecurityOpen
eWiFiSecurityWEP
eWiFiSecurityWPA
eWiFiSecurityWPA2
eWiFiSecurityWPA3

nota

Se a placa não for compatível com Wi-Fi, você ainda deverá incluir a seção testWifiConfig no arquivo device.json, mas poderá omitir os valores desses recursos.

echoServerCertificateConfiguration

O espaço reservado configurável de geração de certificados do servidor echo para testes de SSL. Este campo é obrigatório.

certificateGenerationMethod

Especifica se o certificado do servidor é gerado automaticamente ou fornecido manualmente.

customPath

Se o certificateGenerationMethod for "personalizado", certificatePath e privateKeyPath são obrigatórios.

certificatePath: Especifica o caminho do arquivo do certificado do servidor.
privateKeyPath: Especifica o caminho do arquivo da chave privada.

eccCurveFormat

Especifica o formato de curva compatível com a placa. Obrigatório quando PKCS11 estiver definido como "ecc" em device.json. Os valores válidos são "P224", "P256", "P384" ou "P521".

echoServerConfiguration

As portas configuráveis do servidor de eco para WiFi testes de soquetes seguros. Esse campo é opcional.

securePortForSecureSocket: A porta usada para configurar um servidor de eco TLS para o teste de soquetes seguros. O valor padrão é 33333. Verifique se a porta configurada não está bloqueada por um firewall ou pela rede corporativa.
insecurePortForSecureSocket: A porta que é usada para configurar o servidor de eco sem o teste TLS de soquetes seguros. O valor padrão usado no teste é 33334. Verifique se a porta configurada não está bloqueada por um firewall ou pela rede corporativa.
insecurePortForWiFi: A porta que é usada para configurar o servidor de eco sem TLS WiFi teste. O valor padrão usado no teste é 33335. Verifique se a porta configurada não está bloqueada por um firewall ou pela rede corporativa.

otaConfiguration

A OTA configuração. [Opcional]

otaFirmwareFilePath

O caminho completo para a OTA imagem criada após a construção. Por exemplo, {{testData.sourcePath}}/relative-path/to/ota/image/from/source/root.

deviceFirmwareFileName

O caminho completo do arquivo no MCU dispositivo em que o OTA firmware está localizado. Alguns dispositivos não usam esse campo, mas você ainda deve fornecer um valor.

otaDemoConfigFilePath

O caminho completo para aws_demo_config.h, encontrado em afr-source/vendors/vendor/boards/board/aws_demos/config_files/. Esses arquivos estão incluídos no modelo de código de portabilidade fornecido pelo FreeRTOS.

codeSigningConfiguration

A configuração de assinatura de código.

signingMethod

O método de assinatura de código. Os valores possíveis são AWS ou Custom.

nota

Nas regiões de Pequim e Ningxia, use Custom. Não há compatibilidade para a assinatura de código da AWS nessas regiões.

signerHashingAlgorithm

O algoritmo de hash ao qual o dispositivo oferece suporte. Os valores possíveis são SHA1 ou SHA256.

signerSigningAlgorithm

O algoritmo de assinatura ao qual o dispositivo oferece suporte. Os valores possíveis são RSA ou ECDSA.

signerCertificate

O certificado confiável usado paraOTA.

Para AWS método de assinatura de código, use o Amazon Resource Name (ARN) para o certificado confiável carregado no AWS Certificate Manager.

Para o método de assinatura de código personalizado, use o caminho absoluto para o arquivo de certificado do assinante.

Para obter mais informações sobre como criar um certificado confiável, consulte Criação de um certificado de assinatura de código.

signerCertificateFileName

O nome do arquivo do certificado de assinatura de código no dispositivo. Esse valor deve corresponder ao nome do arquivo que você forneceu ao executar o comando aws acm import-certificate.

Para obter mais informações, consulte Criação de um certificado de assinatura de código.

compileSignerCertificate

Defina como true se o certificado de verificação de assinatura do signatário do código não for provisionado ou atualizado, então ele deve ser compilado no projeto. AWS IoT Device Tester busca o certificado confiável e o compila em. aws_codesigner_certifiate.h

untrustedSignerCertificate

O caminho de arquivo ARN ou para um segundo certificado usado em alguns OTA testes como um certificado não confiável. Para obter mais informações sobre como criar um certificado, consulte Criar um certificado de assinatura de código.

signerPlatform

O algoritmo de assinatura e hashing que AWS O Code Signer usa ao criar o trabalho de OTA atualização. Atualmente, os valores possíveis para este campo são AmazonFreeRTOS-TI-CC3220SF e AmazonFreeRTOS-Default.

Escolha AmazonFreeRTOS-TI-CC3220SF se SHA1 e RSA.
Escolha AmazonFreeRTOS-Default se SHA256 e ECDSA.

Se você precisar de SHA256 | RSA ou SHA1 | ECDSA para sua configuração, entre em contato conosco para obter mais suporte.

Configure signCommand se você escolheu Custom para signingMethod.

signCommand

O comando usado para executar a assinatura de código personalizado. É possível encontrar o modelo no diretório /configs/script_templates.

Dois espaços reservados {{inputImageFilePath}} e {{outputSignatureFilePath}} são obrigatórios no comando. {{inputImageFilePath}}é o caminho do arquivo da imagem criada por IDT to be signed. {{outputSignatureFilePath}}é o caminho do arquivo da assinatura que será gerado pelo script.

cmakeConfiguration

CMakeconfiguração [Opcional]

nota

Para executar casos de CMake teste, você deve fornecer o nome da placa, o nome do fornecedor e o frToolchainPath oucompilerName. Você também pode fornecer o cmakeToolchainPath se tiver um caminho personalizado para o CMake conjunto de ferramentas.

boardName: O nome da placa em teste. O nome do painel deve ser o mesmo que o nome da pasta em path/to/afr/source/code/vendors/vendor/boards/board.
vendorName: O nome do fornecedor para a placa em teste. O fornecedor deve ser o mesmo que o nome da pasta em path/to/afr/source/code/vendors/vendor.
compilerName: O nome do compilador.
frToolchainPath: O caminho totalmente qualificado para o conjunto de ferramentas do compilador
cmakeToolchainPath: O caminho totalmente qualificado para a cadeia de ferramentas. CMake Este campo é opcional

freertosFileConfiguration

A configuração dos RTOS arquivos gratuitos que são IDT modificados antes da execução dos testes.

required

Esta seção especifica os testes necessários cujos arquivos de configuração você moveu, por exemplo,, PKCS11TLS, e assim por diante.

configName: O nome do teste que é configurado.
filePath: O caminho absoluto para os arquivos de configuração no repositório freertos. Use a variável {{testData.sourcePath}} para definir o caminho.

optional

Esta seção especifica testes opcionais cujos arquivos de configuração você moveu, por exemplo OTA WiFi, e assim por diante.

configName: O nome do teste que é configurado.
filePath: O caminho absoluto para os arquivos de configuração no repositório freertos. Use a variável {{testData.sourcePath}} para definir o caminho.

nota

Para executar casos de CMake teste, você deve fornecer o nome da placa, o nome do fornecedor e o afrToolchainPath oucompilerName. Você também pode fornecer cmakeToolchainPath se você tem um caminho personalizado para o CMake conjunto de ferramentas.

IDTpara RTOS variáveis gratuitas

Os comandos para compilar o código e atualizar o dispositivo podem exigir conectividade ou outras informações sobre seus dispositivos para que possam ser executados. AWS IoT Device Tester permite que você faça referência às informações do dispositivo em flash e crie comandos usando JsonPatho. Usando JsonPath expressões simples, você pode buscar as informações necessárias especificadas em seu device.json arquivo.

Variáveis de caminho

IDTfor Free RTOS define as seguintes variáveis de caminho que podem ser usadas em linhas de comando e arquivos de configuração:

{{testData.sourcePath}}: Expande o caminho do código-fonte. Se você usar essa variável, ela deverá ser usada nos comandos de compilação e atualização.
{{sdkPath}}: Expande-se para o valor em seu userData.sdkConfiguration.path quando usado nos comandos compilar e atualizar.
{{device.connectivity.serialPort}}: Expande à porta serial.
{{device.identifiers[?(@.name == 'serialNo')].value[0]}}: Expande o número de série do dispositivo.
{{enableTests}}: Valor inteiro que indica se a compilação é para testes (valor 1) ou demonstrações (valor 0).
{{buildImageName}}: O nome do arquivo da imagem criada pelo comando de compilação.
{{otaCodeSignerPemFile}}: PEMarquivo para o signatário OTA do código.
{{config.idtRootPath}}: Expande-se para o AWS IoT Device Tester caminho raiz. Essa variável substitui o caminho absoluto de IDT quando usada pelos comandos build e flash.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Pré-requisitos

Use a IDT interface do usuário para executar o pacote de RTOS qualificação gratuito