As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # IDT com o pacote de qualificação do FreeRTOS 2.0 (FRQ 2.0) O pacote de qualificação do FreeRTOS 2.0 é uma versão atualizada do pacote de qualificação do FreeRTOS. É recomendado que os desenvolvedores usem o FRQ 2.0 porque ele consiste em casos de teste relevantes para qualificar dispositivos que executam as bibliotecas do FreeRTOS Long Term Support (LTS). O IDT para FreeRTOS verifica a porta do FreeRTOS em seu microcontrolador e se ele se comunica de forma eficaz com. AWS IoT Especificamente, ele verifica as interfaces da camada de portabilidade com as bibliotecas do FreeRTOS e se os repositórios de teste do FreeRTOS estão implementados corretamente. Ele também realiza end-to-end testes com AWS IoT Core. [Os testes executados pelo IDT para FreeRTOS são definidos no repositório do FreeRTOS. GitHub](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests) O IDT para FreeRTOS executa testes como aplicações incorporadas que são exibidas no dispositivo microcontrolador em teste. As imagens binárias da aplicação incluem o FreeRTOS, as interfaces do FreeRTOS obtidas por portabilidade e os drivers de dispositivos da placa. A finalidade dos testes é verificar se as interfaces do FreeRTOS obtidas por portabilidade funcionam corretamente em cima dos drivers do seu dispositivo. O IDT for FreeRTOS gera relatórios de teste que você pode enviar AWS IoT para que seu hardware seja listado no AWS Partner Device Catalog. Para obter mais informações, consulte [Programa de Qualificação de Dispositivos da AWS](https://aws.amazon.com/partners/dqp/). O IDT para FreeRTOS é executado em um computador host (Windows, macOS ou Linux) que está conectado à placa em teste. O IDT configura e orquestra casos de teste e reúne resultados. Ele também fornece uma interface de linha de comando para gerenciar a execução dos testes. Para testar seu dispositivo, o IDT for FreeRTOS cria recursos como AWS IoT coisas, grupos do FreeRTOS e funções Lambda. Para criar esses recursos, o IDT para FreeRTOS usa AWS as credenciais configuradas no para fazer chamadas de API em `config.json` seu nome. Esses recursos são provisionados em vários momentos durante o teste. Ao executar o IDT para FreeRTOS em seu computador host, ele executa as seguintes etapas: 1. Carrega e valida o dispositivo e configuração de credenciais. 1. Executa testes selecionados com os recursos locais e de nuvem necessários. 1. Remove recursos locais e de nuvem. 1. Gera relatórios de testes que indicam se a placa passou nos testes necessários para a qualificação. # Configurar os pré-requisitos de qualificação LTS Esta seção descreve os pré-requisitos para testar microcontroladores com. AWS IoT Device Tester ## Preparar-se para a qualificação do FreeRTOS **nota** AWS IoT Device Tester for FreeRTOS recomenda fortemente o uso da última versão de patch da versão mais recente do FreeRTOS-LTS. O IDT para FRQ 2.0 é uma qualificação para FreeRTOS. Antes de executar o IDT FRQ 2.0 para qualificação, é preciso concluir a [Qualificação de sua placa](https://docs.aws.amazon.com/freertos/latest/qualificationguide/freertos-qualification.html) no *Guia de qualificação do FreeRTOS*. Para portar bibliotecas, testar e configurar o `manifest.yml`, consulte [Como portar as bibliotecas do FreeRTOS](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting.html) no *Guia de portabilidade do FreeRTOS*. O FRQ 2.0 contém um processo diferente de qualificação. Consulte [Alterações mais recentes na qualificação](https://docs.aws.amazon.com/freertos/latest/qualificationguide/latest-changes.html) no *Guia de qualificação do FreeRTOS* para obter detalhes. O repositório [IDT-FreeRTOS-Libraries-Integration-Tests](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests) deve estar presente para que o IDT seja executado. Consulte o [README.md](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests/blob/main/README.md) sobre como clonar e portar esse repositório para seu projeto de origem. FreeRTOS-Libraries-Integration-Testsdeve incluir o `manifest.yml` localizado na raiz do seu projeto, para que o IDT seja executado. **nota** O IDT depende da implementação do repositório de testes do `UNITY_OUTPUT_CHAR`. Os logs de saída de teste e os logs do dispositivo não devem ser intercalados entre si. Consulte [Como implementar a seção de macros de registro em log da biblioteca](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-library-logging-macros.html) no *Guia de portabilidade do FreeRTOS* para obter mais detalhes. ## Baixe o IDT para FreeRTOS Cada versão do FreeRTOS tem uma versão correspondente do IDT para o FreeRTOS para realizar testes de qualificação. Baixe a versão apropriada do IDT para FreeRTOS a [partir das versões](https://docs.aws.amazon.com/freertos/latest/userguide/dev-test-versions-afr.html) suportadas do para FreeRTOS. AWS IoT Device Tester Extraia o IDT para FreeRTOS em um local no sistema de arquivos onde existam permissões de leitura e gravação. Como o Microsoft Windows tem um limite de caracteres para o comprimento do caminho, extraia o IDT para FreeRTOS em um diretório raiz, como `C:\` ou `D:\`. **nota** Vários usuários não devem executar o IDT de um local compartilhado, como um diretório NFS ou uma pasta compartilhada de rede do Windows. Isto pode resultar em falhas ou corrupção de dados. Recomendamos extrair o pacote IDT para uma unidade local. ## Baixe o Git O IDT deve ter o Git instalado como um pré-requisito para garantir a integridade do código-fonte. Siga as instruções no [GitHub](https://github.com/git-guides/install-git)guia para instalar o Git. Para verificar a versão atual instalada do Git, digite o comando `git --version` no terminal. **Atenção** O IDT usa o Git para se alinhar ao status de limpo ou sujo de um diretório. Se o Git não estiver instalado, os grupos de teste `FreeRTOSIntegrity` falharão ou não serão executados conforme o esperado. Se o IDT retornar um erro como `git executable not found` ou`git command not found`, instale ou reinstale o Git e tente novamente. **Topics** + [Preparar-se para a qualificação do FreeRTOS](#idt-preparing-qualification) + [Baixe o IDT para FreeRTOS](#idt-download-dev-tester-afr) + [Baixe o Git](#idt-download-git) + [Crie uma AWS conta](#lts-config-aws-account) + [AWS IoT Device Tester política gerenciada](#managed-policy) + [(Opcional) Instale o AWS Command Line Interface](#install-cli) ## Crie uma AWS conta **nota** O pacote completo de qualificação da IDT é suportado somente no seguinte Regiões da AWS Leste dos EUA (N. da Virgínia) Oeste dos EUA (Oregon) Ásia-Pacífico (Tóquio) Europa (Irlanda) Para testar seu dispositivo, o IDT for FreeRTOS cria recursos como AWS IoT coisas, grupos do FreeRTOS e funções Lambda. Para criar esses recursos, o IDT for FreeRTOS exige que você crie e configure AWS uma conta e uma política do IAM que conceda ao IDT for FreeRTOS permissão para acessar recursos em seu nome durante a execução de testes. As etapas a seguir são para criar e configurar sua AWS conta. 1. Se você já tiver uma AWS conta, vá para a próxima etapa. Para criar uma [conta da AWS](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/). 1. Siga as etapas em [Como criar perfis do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html). Não adicione permissões ou políticas no momento. 1. Para executar testes de qualificação OTA, vá para a etapa 4. Caso contrário, vá para a etapa 5. 1. Anexe a política embutida de permissões do OTA IAM ao seu perfil do IAM. 1. **Importante** O modelo de política a seguir concede ao IDT permissão para criar funções e políticas, e associar políticas às funções. O IDT para FreeRTOS usa essas permissões para testes que criam perfis. Embora o modelo de política não forneça privilégios de administrador ao usuário, as permissões podem ser usadas para obter acesso de administrador à sua AWS conta. 1. Siga as etapas abaixo para anexar as permissões necessárias ao perfil do IAM: 1. Na guia **Permissões**, escolha **Adicionar permissões**. 1. Escolha **Criar política em linha**. 1. Escolha a guia **JSON** e copie as permissões a seguir na caixa de texto **JSON**. Use o modelo na **Maioria das regiões** se não estiver na região da China. Se estiver na região da China, use o modelo nas **regiões de Pequim e Ningxia**. ------ #### [ Most Regions ] ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "iotdeviceadvisor:*", "Resource": [ "arn:aws:iotdeviceadvisor:*:*:suiterun/*/*", "arn:aws:iotdeviceadvisor:*:*:suitedefinition/*" ] }, { "Effect": "Allow", "Action": "iam:PassRole", "Resource": "arn:aws:iam::*:role/idt*", "Condition": { "StringEquals": { "iam:PassedToService": "iotdeviceadvisor.amazonaws.com" } } }, { "Effect": "Allow", "Action": [ "execute-api:Invoke*", "iam:ListRoles", "iot:Connect", "iot:CreateJob", "iot:DeleteJob", "iot:DescribeCertificate", "iot:DescribeEndpoint", "iot:DescribeJobExecution", "iot:DescribeJob", "iot:DescribeThing", "iot:GetPolicy", "iot:ListAttachedPolicies", "iot:ListCertificates", "iot:ListPrincipalPolicies", "iot:ListThingPrincipals", "iot:ListThings", "iot:Publish", "iot:UpdateThingShadow", "logs:CreateLogGroup", "logs:CreateLogStream", "logs:DescribeLogGroups", "logs:DescribeLogStreams", "logs:PutLogEvents", "logs:PutRetentionPolicy" ], "Resource": "*" }, { "Effect": "Allow", "Action": "iotdeviceadvisor:*", "Resource": "*" }, { "Effect": "Allow", "Action": "logs:DeleteLogGroup", "Resource": "arn:aws:logs:*:*:log-group:/aws/iot/deviceadvisor/*" }, { "Effect": "Allow", "Action": "logs:GetLogEvents", "Resource": "arn:aws:logs:*:*:log-group:/aws/iot/deviceadvisor/*:log-stream:*" }, { "Effect": "Allow", "Action": [ "iam:CreatePolicy", "iam:DetachRolePolicy", "iam:DeleteRolePolicy", "iam:DeletePolicy", "iam:CreateRole", "iam:DeleteRole", "iam:AttachRolePolicy" ], "Resource": [ "arn:aws:iam::*:policy/idt*", "arn:aws:iam::*:role/idt*" ] }, { "Effect": "Allow", "Action": [ "ssm:GetParameters" ], "Resource": [ "arn:aws:ssm:*::parameter/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2" ] }, { "Effect": "Allow", "Action": [ "ec2:DescribeInstances", "ec2:RunInstances", "ec2:CreateSecurityGroup", "ec2:CreateTags", "ec2:DeleteTags" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "ec2:CreateKeyPair", "ec2:DeleteKeyPair" ], "Resource": [ "arn:aws:ec2:*:*:key-pair/idt-ec2-ssh-key-*" ] }, { "Effect": "Allow", "Condition": { "StringEqualsIgnoreCase": { "aws:ResourceTag/Owner": "IoTDeviceTester" } }, "Action": [ "ec2:TerminateInstances", "ec2:DeleteSecurityGroup", "ec2:AuthorizeSecurityGroupIngress", "ec2:RevokeSecurityGroupIngress" ], "Resource": [ "*" ] } ] } ``` ------ ------ #### [ Beijing and Ningxia Regions ] O modelo de política a seguir pode ser usado nas regiões de Pequim e Ningxia. ------ 1. Ao concluir, selecione **Review policy (Revisar política)**. 1. Insira **IDTFreeRTOSIAMPermissions**como nome da política. 1. Selecione **Criar política**. 1. Anexe **AWSIoTDeviceTesterForFreeRTOSFullo Access** à sua função do IAM. 1. Para associar as permissões necessárias ao seu perfil do IAM: 1. Na guia **Permissões**, escolha **Adicionar permissões**. 1. Escolha **Anexar políticas**. 1. Pesquise a política de **AWSIoTDeviceTesterForFreeRTOSFullacesso**. Marque a caixa. 1. Escolha **Adicionar permissões**. 1. Exporte credenciais para o IDT. Consulte [Obter credenciais de perfil do IAM para acesso à CLI](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html) para obter detalhes. ## AWS IoT Device Tester política gerenciada A política `AWSIoTDeviceTesterForFreeRTOSFullAccess` gerenciada contém as seguintes AWS IoT Device Tester permissões para verificação de versão, recursos de atualização automática e coleção de métricas. + `iot-device-tester:SupportedVersion` Concede AWS IoT Device Tester permissão para buscar a lista de produtos compatíveis, suítes de teste e versões do IDT. + `iot-device-tester:LatestIdt` Concede AWS IoT Device Tester permissão para obter a versão mais recente do IDT disponível para download. + `iot-device-tester:CheckVersion` Concede AWS IoT Device Tester permissão para verificar a compatibilidade de versões do IDT, suítes de teste e produtos. + `iot-device-tester:DownloadTestSuite` Concede AWS IoT Device Tester permissão para baixar atualizações da suíte de testes. + `iot-device-tester:SendMetrics` Concede AWS permissão para coletar métricas sobre o uso AWS IoT Device Tester interno. ## (Opcional) Instale o AWS Command Line Interface Talvez você prefira usar o AWS CLI para realizar algumas operações. Se não tiver a AWS CLI instalada, siga as instruções em [Instalar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html). Configure o AWS CLI para a AWS região que você deseja usar executando a **aws configure** partir de uma linha de comando. [Para obter informações sobre as AWS regiões que oferecem suporte ao IDT para FreeRTOS,AWS consulte Regiões e endpoints.](https://docs.aws.amazon.com/general/latest/gr/rande.html#amazon-freertos-ota-control) Para obter mais informações sobre **aws configure**, consulte [Configuração rápida com o **aws configure**](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config). # Primeiro teste da sua placa de microcontrolador É possível usar o IDT for FreeRTOS para testar sua implementação das bibliotecas do FreeRTOS. Depois de portar as bibliotecas do FreeRTOS para os drivers de dispositivo da sua placa, AWS IoT Device Tester use para executar os testes de qualificação na sua placa microcontroladora. ## Adicionar camadas de transferência da biblioteca Para fazer a portabilidade do FreeRTOS para seu dispositivo, consulte o [Guia de portabilidade do FreeRTOS](https://docs.aws.amazon.com/freertos/latest/portingguide/porting-guide.html). Ao implementar o repositório de testes do FreeRTOS e portar as camadas do FreeRTOS, é preciso fornecer um `manifest.yml` com caminhos para cada biblioteca, incluindo o repositório de testes. Este arquivo estará no diretório-raiz do código-fonte. Consulte as [instruções do arquivo de manifesto](https://docs.aws.amazon.com/freertos/latest/qualificationguide/afq-checklist-manifest-instr.html) para obter detalhes. ## Configure suas AWS credenciais AWS IoT Device Tester para se comunicar com a nuvem AWS Você precisa configurar suas AWS credenciais para se AWS IoT Device Tester comunicar com a AWS nuvem. Para obter mais informações, consulte [Configurar as credenciais e a região da AWS para desenvolvimento](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html). AWS As credenciais válidas são especificadas no arquivo `devicetester_extract_location/devicetester_freertos_[win|mac|linux]/configs/config.json` de configuração. ``` "auth": { "method": "environment" } "auth": { "method": "file", "credentials": { "profile": "" } } ``` O `auth` atributo do `config.json` arquivo tem um campo de método que controla a AWS autenticação e pode ser declarado como arquivo ou ambiente. Definir o campo como ambiente extrai suas AWS credenciais das variáveis de ambiente da sua máquina host. Definir o campo como arquivo importa um perfil especificado do arquivo de configuração `.aws/credentials`. **Topics** + [Adicionar camadas de transferência da biblioteca](#lts-add-port-layer) + [Configure suas AWS credenciais AWS IoT Device Tester para se comunicar com a nuvem AWS](#lts-cfg-aws-afr) + [Crie um grupo de dispositivos no IDT para FreeRTOS](lts-cfg-dt-dp.md) + [Configuração de parâmetros de compilação, atualização e teste](lts-cfg-dt-ud.md) # Crie um grupo de dispositivos no IDT para FreeRTOS Os dispositivos a serem testados são organizados em grupos de dispositivos. Cada grupo de dispositivos consiste em um ou mais dispositivos idênticos. Também é possível configurar o IDT para FreeRTOS para testar um único dispositivo ou vários dispositivos em um grupo. Para acelerar o processo de qualificação, o IDT para FreeRTOS 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. O arquivo `device.json` tem uma matriz em seu nível superior. Cada recurso da matriz é um novo grupo de dispositivos. Cada grupo de dispositivos tem um recurso de matriz de dispositivos, que tem vários dispositivos declarados. No modelo, há um grupo de dispositivos e somente um dispositivo neste 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 grupo devem ser da mesma especificação técnica e SKU. Para habilitar as compilações paralelas do código-fonte para diferentes grupos de teste, o IDT para FreeRTOS copia o código-fonte para uma pasta de resultados dentro da pasta onde o IDT para FreeRTOS foi extraído. É preciso referenciar o caminho do código-fonte no comando de compilação ou atualização por meio da variável `testdata.sourcePath`. O IDT para FreeRTOS substitui esta variável por um caminho temporário do código-fonte copiado. Para obter mais informações, consulte [Variáveis do IDT para FreeRTOS](lts-dt-vars.md). Veja a seguir um exemplo do arquivo `device.json` que foi 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": "BLE", "value": "Yes | No" }, { "name": "PKCS11", "value": "RSA | ECC | Both" }, { "name": "OTA", "value": "Yes | No", "configs": [ { "name": "OTADataPlaneProtocol", "value": "MQTT | HTTP | None" } ] }, { "name": "KeyProvisioning", "value": "Onboard | Import | Both | No" } ], "devices": [ { "id": "device-id", "connectivity": { "protocol": "uart", "serialPort": "/dev/tty*" }, "secureElementConfig" : { "publicKeyAsciiHexFilePath": "absolute-path-to/public-key-txt-file: contains-the-hex-bytes-public-key-extracted-from-onboard-private-key", "publiDeviceCertificateArn": "arn:partition:iot:region:account-id:resourcetype:resource:qualifier", "secureElementSerialNumber": "secure-element-serialNo-value", "preProvisioned" : "Yes | No", "pkcs11JITPCodeVerifyRootCertSupport": "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. A SKU é usada para rastrear as placas qualificadas. Se você quiser listar sua placa no AWS Partner Device Catalog, o SKU especificado aqui deve corresponder ao SKU que você usa no processo de listagem. ** `features` ** Uma matriz que contém os recursos suportados pelo 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: ** `Wifi` ** Indica se a placa tem recursos de Wi-Fi. ** `Cellular` ** Indica se a placa tem recursos de celular. ** `PKCS11` ** Indica o algoritmo de criptografia de chave pública que a placa suporta. PKCS11 é necessário para a qualificação. Os valores compatíveis são `ECC`, `RSA`, e `Both`. `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`, `Both` e `No`. O provisionamento das chaves `Onboard`, `Both` ou `No` é necessário para a qualificação. `Import`, por si só, não é uma opção válida para qualificação. + Use `Import` somente se a sua placa permitir a importação de chaves privadas. `Import`A seleção não é uma configuração válida para qualificação e deve ser usada somente para fins de teste, especificamente com casos PKCS11 de teste. `Onboard`, `Both` ou `No` é necessário para a qualificação. + Use `Onboard` se a placa for compatível com 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`. + Use `Both` se sua placa suportar a importação de chaves privadas e a geração de chaves integradas para provisionamento de chaves. + Use `No` se sua placa não suportar o provisionamento de chaves. `No` só é uma opção válida quando seu dispositivo também está pré-provisionado. ** `OTA` ** Indica se sua placa suporta a funcionalidade de atualização over-the-air (OTA). O recurso `OtaDataPlaneProtocol` indica a qual protocolo de plano de dados OTA o dispositivo oferece suporte. Um OTA com o protocolo de plano de dados HTTP ou MQTT é necessário para a qualificação. Para pular a execução de testes OTA durante o teste, defina o recurso OTA como `No` e o recurso `OtaDataPlaneProtocol` como `None`. Esta não será uma corrida de qualificação. ** `BLE` ** Indica se a placa é compatível com Bluetooth Low Energy (BLE). ** `devices.id` ** Um identificador exclusivo, definido pelo usuário, para o dispositivo que está sendo testado. ** `devices.connectivity.serialPort` ** A porta serial do computador host usada para se conectar aos dispositivos que estão sendo testados. ** `devices.secureElementConfig.PublicKeyAsciiHexFilePath` ** Obrigatório se sua placa NÃO for `pre-provisioned` ou `PublicDeviceCertificateArn` não for fornecido. Como `Onboard` é um tipo obrigatório de provisionamento de chaves, esse campo atualmente é obrigatório para o grupo de FullTransportInterface teste TLS. Se o seu dispositivo for `pre-provisioned`, `PublicKeyAsciiHexFilePath` é opcional e não precisa ser incluído. O bloco a seguir é um caminho absoluto para o arquivo que contém a chave pública de bytes hexadecimal extraída da chave privada `Onboard`. ``` 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, é possível codificar a chave pública em hexadecimal diretamente para gerar o arquivo hexadecimal. Para gerar o arquivo hexadecimal a partir de uma chave pública .der, digite o seguinte comando **xxd**: ``` xxd -p pubkey.der > outFile ``` Se sua chave pública estiver no formato .pem, é possível extrair os cabeçalhos e rodapés codificados em base64 e decodificá-los em formato binário. Em seguida, string binária é codificada em hexadecimal para gerar o arquivo hexadecimal. Para gerar um arquivo hexadecimal para uma chave pública. pem, faça o seguinte: 1. Execute o comando **base64** a seguir para remover o cabeçalho e o rodapé base64 da chave pública. A chave decodificada, chamada `base64key`, é enviada para o arquivo `pubkey.der`: ``` base64 —decode base64key > pubkey.der ``` 1. Execute o comando **xxd** a seguir para converter `pubkey.der` para o formato hexadecimal. A chave resultante é salva como `outFile`. ``` xxd -p pubkey.der > outFile ``` ** `devices.secureElementConfig.PublicDeviceCertificateArn` ** O ARN do certificado do seu elemento seguro que é carregado para. AWS IoT Core*Para obter informações sobre como carregar seu certificado para AWS IoT Core, consulte [certificados de cliente X.509 no Guia](https://docs.aws.amazon.com/iot/latest/developerguide/x509-client-certs.html) do AWS IoT desenvolvedor.* ** `devices.secureElementConfig.SecureElementSerialNumber` ** (Opcional) O número de série do elemento seguro. O número de série é usado como opção para criar certificados de dispositivo para o provisionamento de chaves JITR. ** `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. Se este recurso for definido como **Sim**, os rótulos pkcs11 correspondentes deverão ser fornecidos. ** `devices.secureElementConfig.pkcs11JITPCodeVerifyRootCertSupport` ** (Opcional) Defina como **Sim** se a PKCS11 implementação principal do dispositivo suportar armazenamento para JITP. Isto habilitará o teste `codeverify` JITP ao testar o PKCS 11 principal e exigirá que sejam fornecidos rótulos de chave de verificação de código, certificado JITP e certificado raiz PKCS 11. ** `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 O IDT para FreeRTOS compila e atualiza os testes automaticamente em sua placa. Para habilitar isso, é preciso configurar o IDT para executar os comandos compilar e atualizar do 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`. O seguinte exemplo de JSON mostra como é possível configurar o IDT para FreeRTOS para testar vários dispositivos: ``` { "sourcePath": "", "retainModifiedSourceDirectories": true | false, "freeRTOSVersion": "", "freeRTOSTestParamConfigPath": "{{testData.sourcePath}}/path/from/source/path/to/test_param_config.h", "freeRTOSTestExecutionConfigPath": "{{testData.sourcePath}}/path/from/source/path/to/test_execution_config.h", "buildTool": { "name": "your-build-tool-name", "version": "your-build-tool-version", "command": [ " -any-additional-flags {{testData.sourcePath}}" ] }, "flashTool": { "name": "your-flash-tool-name", "version": "your-flash-tool-version", "command": [ " -any-additional-flags {{testData.sourcePath}} -any-additional-flags" ] }, "testStartDelayms": 0, "echoServerConfiguration": { "keyGenerationMethod": "EC | RSA", "serverPort": 9000 }, "otaConfiguration": { "otaE2EFirmwarePath": "{{testData.sourcePath}}/relative-path-to/ota-image-generated-in-build-process", "otaPALCertificatePath": "/path/to/ota/pal/certificate/on/device", "deviceFirmwarePath" : "/path/to/firmware/image/name/on/device", "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", "untrustedSignerCertificate": "arn:partition:service:region:account-id:resourcetype:resource:qualifier", "signerCertificateFileName": "signerCertificate-file-name", "compileSignerCertificate": true | false, // ***********Use signerPlatform if you choose AWS for signingMethod*************** "signerPlatform": "AmazonFreeRTOS-Default | AmazonFreeRTOS-TI-CC3220SF" ] } }, ********** This section is used for PKCS #11 labels of private key, public key, device certificate, code verification key, JITP certificate, and root certificate. When configuring PKCS11, you set up labels and you must provide the labels of the device certificate, public key, and private key for the key generation type (EC or RSA) it was created with. If your device supports PKCS11 storage of JITP certificate, code verification key, and root certificate, set 'pkcs11JITPCodeVerifyRootCertSupport' to 'Yes' in device.json and provide the corresponding labels. ********** "pkcs11LabelConfiguration":{ "pkcs11LabelDevicePrivateKeyForTLS": "", "pkcs11LabelDevicePublicKeyForTLS": "", "pkcs11LabelDeviceCertificateForTLS": "", "pkcs11LabelPreProvisionedECDevicePrivateKeyForTLS": "", "pkcs11LabelPreProvisionedECDevicePublicKeyForTLS": "", "pkcs11LabelPreProvisionedECDeviceCertificateForTLS": "", "pkcs11LabelPreProvisionedRSADevicePrivateKeyForTLS": "", "pkcs11LabelPreProvisionedRSADevicePublicKeyForTLS": "", "pkcs11LabelPreProvisionedRSADeviceCertificateForTLS": "", "pkcs11LabelCodeVerifyKey": "", "pkcs11LabelJITPCertificate": "", "pkcs11LabelRootCertificate": "" } } ``` Veja a seguir uma lista dos recursos usados no `userdata.json`: ** `sourcePath` ** O caminho para a raiz do código-fonte transferido do FreeRTOS. ** `retainModifiedSourceDirectories` ** (Opcional) Verifica se deve reter os diretórios de origem modificados usados durante a compilação e a atualização para fins de depuração. Se definido como `true`, os diretórios de origem modificados são denominados RetainedSrc e são encontrados nas pastas de log de resultados em cada execução do grupo de teste. Se não for incluído, o campo assume `false` como padrão. ** `freeRTOSTestParamConfigPath` ** O caminho para o `test_param_config.h` arquivo para FreeRTOS-Libraries-Integration-Tests integração. Esse arquivo deve usar a variável de `{{testData.sourcePath}}` espaço reservado para torná-lo relativo à raiz do código-fonte. AWS IoT Device Tester usa os parâmetros desse arquivo para configurar os testes. ** `freeRTOSTestExecutionConfigPath` ** O caminho para o `test_execution_config.h` arquivo para FreeRTOS-Libraries-Integration-Tests integração. Esse arquivo deve usar a variável de `{{testData.sourcePath}}` espaço reservado para torná-lo relativo à raiz do repositório. AWS IoT Device Tester usa esse arquivo para controlar quais testes devem ser executados. ** `freeRTOSVersion` ** A versão dos FreeRTOS, incluindo a versão do patch usada em sua implementação. Consulte [Versões suportadas do FreeRTOS AWS IoT Device Tester para as versões do](https://docs.aws.amazon.com/freertos/latest/userguide/dev-test-versions-afr.html) FreeRTOS compatíveis com o FreeRTOS. AWS IoT Device Tester ** `buildTool` ** O comando para compilar o código-fonte. Todas as referências ao caminho do código-fonte no comando build devem ser substituídas pela AWS IoT Device Tester variável`{{testData.sourcePath}}`. Use o `{{config.idtRootPath}}` espaço reservado para referenciar um script de construção em relação ao caminho AWS IoT Device Tester raiz. ** `flashTool` ** O comando para exibir uma imagem em seu dispositivo. Todas as referências ao caminho do código-fonte no comando f.ash devem ser substituídas pela AWS IoT Device Tester variável`{{testData.sourcePath}}`. Use o `{{config.idtRootPath}}` espaço reservado para referenciar um script flash em relação ao caminho AWS IoT Device Tester raiz. A nova estrutura de testes de integração com o FRQ 2.0 não requer variáveis de caminho como `{{enableTests}}` e `{{buildImageName}}`. Os testes OTA End to End são executados com os modelos de configuração fornecidos no [ FreeRTOS-Libraries-Integration-Tests](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests/blob/main/config_template/) GitHub repositório. Se os arquivos no GitHub repositório estiverem presentes no seu projeto fonte principal, o código-fonte não será alterado entre os testes. Se for necessária uma imagem de compilação diferente para o OTA End to End, esta imagem deverá ser criada no script de compilação e especificada no arquivo `userdata.json` especificado abaixo `otaConfiguration`. ** `testStartDelayms` ** Especifica quantos milissegundos o executor de testes do FreeRTOS aguardará antes de começar a executar os testes. Isto pode ser útil se o dispositivo em teste começar a gerar informações de teste importantes antes que o IDT tenha a chance de se conectar e iniciar o registro em log devido à rede ou outros problemas de latência. Este valor é aplicável somente aos grupos de teste do FreeRTOS, e não a outros grupos de teste que não utilizam o executor de testes do FreeRTOS, como os testes OTA. Se receber um erro relacionado a **10 esperados, mas cinco recebidos**, este campo deverá ser definido como 5.000. ** `echoServerConfiguration` ** A configuração para configurar o servidor de eco para o teste TLS. Este campo é obrigatório. ** `keyGenerationMethod` ** O servidor echo está configurado com esta opção. As opções são EC ou RSA. ** `serverPort` ** O número da porta na qual o servidor echo é executado. ** `otaConfiguration` ** A configuração para testes OTA PAL e OTA E2E. Este campo é obrigatório. **`otaE2EFirmwarePath`** O caminho para a imagem do compartimento OTA que o IDT usa para os testes do OTA End to End. ** `otaPALCertificatePath` ** O caminho para o certificado para o teste OTA PAL no dispositivo. Isto é usado para verificar a assinatura. Por exemplo, **ecdsa-sha256-signer.crt.pem**. ** `deviceFirmwarePath` ** O caminho para o nome com codificação rígida da imagem do firmware a ser inicializada. Se o seu dispositivo NÃO usar o sistema de arquivos para inicialização do firmware, especifique este campo como `'NA'`. Se o seu dispositivo usa o sistema de arquivos para inicialização do firmware, especifique o caminho ou o nome da imagem de inicialização do firmware. ** `codeSigningConfiguration` ** ** `signingMethod` ** O método de assinatura de código. Os valores possíveis são AWS ou Custom. Para as regiões de Pequim e Ningxia, use Personalizado. AWS a assinatura de código não é suportada nessa região. ** `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 de confiança usado para OTA. Para o método de assinatura de AWS 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 [Criar um certificado de assinatura de código](https://docs.aws.amazon.com/freertos/latest/userguide/ota-code-sign-cert.html). ** `untrustedSignerCertificate` ** O ARN ou caminho de arquivo de um segundo certificado usado em alguns testes OTA como um certificado não confiável. Para obter informações sobre como criar um certificado, consulte [Criar um certificado de assinatura de código](https://docs.aws.amazon.com//freertos/latest/userguide/ota-code-sign-cert.html). ** `signerCertificateFileName` ** O nome do arquivo do certificado de assinatura de código no dispositivo. Este valor deve corresponder ao nome do arquivo fornecido ao executar o comando `aws acm import-certificate`. ** `compileSignerCertificate` ** Valor booleano que determina o status do certificado de verificação de assinatura. Os valores válidos são `true` e `false`. Defina este valor como **verdadeiro** se o certificado de verificação da assinatura do signatário do código não for provisionado ou exibido. Ele deve ser compilado no projeto. AWS IoT Device Tester busca o certificado confiável e o compila em. `aws_codesigner_certificate.h` ** `signerPlatform` ** O algoritmo de assinatura e hashing que o AWS Code Signer usa ao criar o trabalho de atualização do OTA. 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` \$1 `RSA` ou `SHA1` \$1 `ECDSA` para sua configuração, entre em contato conosco para obter mais suporte. + Configure `signCommand` se você escolheu `Custom` para `signingMethod`. ** `signCommand` ** Dois espaços reservados `{{inputImageFilePath}}` e `{{outputSignatureFilePath}}` são necessários no comando. `{{inputImageFilePath}}` é o caminho do arquivo da imagem criada pelo IDT a ser assinado. `{{outputSignatureFilePath}} ` é o caminho do arquivo da assinatura que será gerado pelo script. ** `pkcs11LabelConfiguration` ** PKCS11 a configuração do rótulo requer pelo menos um conjunto de rótulos de rótulo de certificado de dispositivo, rótulo de chave pública e rótulo de chave privada para executar os grupos de PKCS11 teste. As PKCS11 etiquetas necessárias são baseadas na configuração do dispositivo no `device.json` arquivo. Se pré-provisionado estiver definido como **Sim** em`device.json`, os rótulos necessários deverão ser um dos abaixo, dependendo do que for escolhido para o recurso. PKCS11 + `PreProvisionedEC` + `PreProvisionedRSA` Se pré-provisionado estiver definido como **Não** em `device.json`, os rótulos necessários serão: + `pkcs11LabelDevicePrivateKeyForTLS` + `pkcs11LabelDevicePublicKeyForTLS` + `pkcs11LabelDeviceCertificateForTLS` Os três rótulos a seguir são necessários somente se você selecionar **Sim** para `pkcs11JITPCodeVerifyRootCertSupport` em seu arquivo `device.json`. + `pkcs11LabelCodeVerifyKey` + `pkcs11LabelRootCertificate` + `pkcs11LabelJITPCertificate` Os valores desses campos devem corresponder aos valores definidos no [Guia de portabilidade do FreeRTOS](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting-pkcs.html). ** `pkcs11LabelDevicePrivateKeyForTLS` ** (Opcional) Este rótulo é usado para o rótulo PKCS n.º 11 da chave privada. Para dispositivos com suporte integrado e de importação de provisionamento de chaves, este rótulo é usado para testes. Este rótulo pode ser diferente daquele definido para o caso pré-provisionado. Se tiver o provisionamento de chaves definido como **Não** e o pré-provisionado definido como **Sim**, em `device.json`, isso será indefinido. ** `pkcs11LabelDevicePublicKeyForTLS` ** (Opcional) Este rótulo é usado para o rótulo PKCS n.º 11 da chave pública. Para dispositivos com suporte integrado e de importação de provisionamento de chaves, este rótulo é usado para testes. Este rótulo pode ser diferente do definido para o caso pré-provisionado. Se tiver o provisionamento de chaves definido como **Não** e o pré-provisionado definido como **Sim**, em `device.json`, isso será indefinido. ** `pkcs11LabelDeviceCertificateForTLS` ** (Opcional) Este rótulo é usado para o rótulo PKCS n.º 11 do certificado do dispositivo. Para dispositivos com suporte integrado e de importação de provisionamento de chaves, este rótulo será usado para testes. Este rótulo pode ser diferente do definido para o caso pré-provisionado. Se tiver o provisionamento de chaves definido como **Não** e o pré-provisionado definido como **Sim**, em `device.json`, isso será indefinido. ** `pkcs11LabelPreProvisionedECDevicePrivateKeyForTLS` ** (Opcional) Este rótulo é usado para o rótulo PKCS n.º 11 da chave privada. Para dispositivos com elementos seguros ou limitações de hardware, isso terá uma etiqueta diferente para preservar AWS IoT as credenciais. Se o seu dispositivo for compatível com o pré-provisionamento com uma chave EC, forneça este rótulo. Quando PreProvisioned é definido como **Sim** em `device.json`, este rótulo, `pkcs11LabelPreProvisionedRSADevicePrivateKeyForTLS`, ou ambos devem ser fornecidos. Este rótulo pode ser diferente do definido para caixas integradas e de importação. ** `pkcs11LabelPreProvisionedECDevicePublicKeyForTLS` ** (Opcional) Este rótulo é usado para o rótulo PKCS n.º 11 da chave pública. Para dispositivos com elementos seguros ou limitações de hardware, isso terá uma etiqueta diferente para preservar AWS IoT as credenciais. Se o seu dispositivo for compatível com o pré-provisionamento com uma chave EC, forneça este rótulo. Quando PreProvisioned é definido como **Sim** em `device.json`, este rótulo, `pkcs11LabelPreProvisionedRSADevicePublicKeyForTLS`, ou ambos devem ser fornecidos. Este rótulo pode ser diferente do definido para caixas integradas e de importação. ** `pkcs11LabelPreProvisionedECDeviceCertificateForTLS` ** (Opcional) Este rótulo é usado para o rótulo PKCS n.º 11 do certificado do dispositivo. Para dispositivos com elementos seguros ou limitações de hardware, isso terá uma etiqueta diferente para preservar AWS IoT as credenciais. Se o seu dispositivo for compatível com o pré-provisionamento com uma chave EC, forneça este rótulo. Quando PreProvisioned é definido como **Sim** em `device.json`, este rótulo, `pkcs11LabelPreProvisionedRSADeviceCertificateForTLS`, ou ambos devem ser fornecidos. Este rótulo pode ser diferente do definido para caixas integradas e de importação. ** `pkcs11LabelPreProvisionedRSADevicePrivateKeyForTLS` ** (Opcional) Este rótulo é usado para o rótulo PKCS n.º 11 da chave privada. Para dispositivos com elementos seguros ou limitações de hardware, isso terá uma etiqueta diferente para preservar AWS IoT as credenciais. Se o seu dispositivo for compatível com o pré-provisionamento com uma chave RSA, forneça este rótulo. Quando PreProvisioned é definido como **Sim** em `device.json`, este rótulo, `pkcs11LabelPreProvisionedECDevicePrivateKeyForTLS`, ou ambos devem ser fornecidos. ** `pkcs11LabelPreProvisionedRSADevicePublicKeyForTLS` ** (Opcional) Este rótulo é usado para o rótulo PKCS n.º 11 da chave pública. Para dispositivos com elementos seguros ou limitações de hardware, isso terá uma etiqueta diferente para preservar AWS IoT as credenciais. Se o seu dispositivo for compatível com o pré-provisionamento com uma chave RSA, forneça este rótulo. Quando PreProvisioned é definido como **Sim** em `device.json`, este rótulo, `pkcs11LabelPreProvisionedECDevicePublicKeyForTLS`, ou ambos devem ser fornecidos. ** `pkcs11LabelPreProvisionedRSADeviceCertificateForTLS` ** (Opcional) Este rótulo é usado para o rótulo PKCS n.º 11 do certificado do dispositivo. Para dispositivos com elementos seguros ou limitações de hardware, isso terá uma etiqueta diferente para preservar AWS IoT as credenciais. Se o seu dispositivo for compatível com o pré-provisionamento com uma chave RSA, forneça este rótulo. Quando PreProvisioned é definido como **Sim** em `device.json`, este rótulo, `pkcs11LabelPreProvisionedECDeviceCertificateForTLS`, ou ambos devem ser fornecidos. ** `pkcs11LabelCodeVerifyKey` ** (Opcional) Este rótulo é usado para o rótulo PKCS n.º 11 da chave de verificação de código. Se o seu dispositivo tiver suporte de armazenamento PKCS n.º 11 para o certificado JITP, a chave de verificação de código e o certificado-raiz, forneça este rótulo. Quando `pkcs11JITPCodeVerifyRootCertSupport` em `device.json` estiver definido como **Sim**, este rótulo deverá ser fornecido. ** `pkcs11LabelJITPCertificate` ** (Opcional) Este rótulo é usado para o rótulo PKCS n.º 11 do certificado JITP. Se o seu dispositivo tiver suporte de armazenamento PKCS n.º 11 para o certificado JITP, a chave de verificação de código e o certificado-raiz, forneça este rótulo. Quando `pkcs11JITPCodeVerifyRootCertSupport` em `device.json` estiver definido como **Sim**, este rótulo deverá ser fornecido. # Variáveis do IDT para FreeRTOS Os comandos para criar seu código e atualizar o dispositivo podem exigir conectividade ou outras informações sobre seus dispositivos para serem executados com êxito. AWS IoT Device Tester permite referenciar informações do dispositivo em flash e criar comandos usando [JsonPath](https://goessner.net/articles/JsonPath/)o. Usando JsonPath expressões simples, você pode buscar as informações necessárias especificadas em seu `device.json` arquivo. ## Variáveis de caminho O IDT para FreeRTOS 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. ** `{{device.connectivity.serialPort}}` ** Expande à porta serial. ** `{{device.identifiers[?(@.name == 'serialNo')].value[0]}}` ** Expande o número de série do dispositivo. ** `{{config.idtRootPath}}` ** Expande-se até o caminho AWS IoT Device Tester raiz. # Interface do usuário para o IDT para o pacote de qualificação FreeRTOS 2.0 (FRQ 2.0) AWS IoT Device Tester para FreeRTOS (IDT for FreeRTOS) inclui uma interface de usuário (UI) baseada na web na qual você pode interagir com o aplicativo de linha de comando do IDT e os arquivos de configuração relacionados. Você usa a interface do IDT para FreeRTOS para criar uma nova configuração ou modificar uma existente para seu dispositivo. Você também pode usar a interface do usuário para chamar a aplicação IDT e executar os testes do FreeRTOS em seu dispositivo. Para obter informações sobre o uso da linha de comando para executar os testes de qualificação, consulte [Primeiro teste da sua placa de microcontrolador](lts-qual-steps.md). Esta seção descreve os pré-requisitos da interface do usuário do IDT para FreeRTOS e como executar testes de qualificação a partir da interface do usuário. **Topics** + [Configurar os pré-requisitos do IDT](#lts-dev-tester-ui-prereqs) + [Configurar AWS credenciais para usar a interface de usuário do IDT](lts-configure-aws-credentials.md) + [Abrir a interface de usuário do IDT para FreeRTOS](lts-open-idt-ui.md) + [Criar uma configuração](lts-create-new-configuration.md) + [Modificar uma configuração existente](lts-modify-existing-configuration.md) + [Execute testes de qualificação](lts-run-tests-from-ui.md) ## Configurar os pré-requisitos do IDT Para executar testes por meio da interface do usuário AWS IoT Device Tester (IDT) for FreeRTOS, você deve preencher os pré-requisitos na página do IDT FreeRTOS Qualification ([Configurar os pré-requisitos de qualificação LTS](lts-idt-dev-tester-prereqs.md)FRQ) 2.x. # Configurar AWS credenciais para usar a interface de usuário do IDT Você deve configurar suas credenciais de usuário do IAM para o AWS usuário que você criou. [Crie uma AWS conta](lts-idt-dev-tester-prereqs.md#lts-config-aws-account) Você pode especificar suas credenciais de uma das seguintes formas: + Em um arquivo de credenciais + Como variáveis de ambiente ## Configurar AWS credenciais com um arquivo de credenciais O IDT usa o mesmo arquivo de credenciais que a AWS CLI. Para obter mais informações, consulte [Arquivos de configuração e credenciais](https://docs.aws.amazon.com/cli/latest/userguide/cli-config-files.html). O local do arquivo de credenciais varia de acordo com o sistema operacional que você usa: + **macOS e Linux** – `~/.aws/credentials` + **Windows**: `C:\Users\UserName\.aws\credentials` Adicione suas AWS credenciais ao `credentials` arquivo no seguinte formato: ``` [default] aws_access_key_id = your_access_key_id aws_secret_access_key = your_secret_access_key ``` **nota** Se você não usar o `default` AWS perfil, deverá especificar o nome do perfil na interface de usuário do IDT para Freertos. Para obter mais informações sobre perfis, consulte [Configurações de arquivos de configuração e credenciais](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html). ## Configurar AWS credenciais com variáveis de ambiente As variáveis de ambiente são variáveis mantidas pelo sistema operacional e usadas pelos comandos do sistema. Elas não são salvas se você fechar a sessão SSH. A interface de usuário do IDT para FreeRTOS usa as variáveis de ambiente `AWS_SECRET_ACCESS_KEY` e `AWS_ACCESS_KEY_ID` para armazenar suas credenciais. AWS Para definir essas variáveis no Linux, macOS ou Unix, use :**export** ``` export AWS_ACCESS_KEY_ID=your_access_key_id export AWS_SECRET_ACCESS_KEY=your_secret_access_key ``` Para definir essas variáveis no Windows, use :**set** ``` set AWS_ACCESS_KEY_ID=your_access_key_id set AWS_SECRET_ACCESS_KEY=your_secret_access_key ``` # Abrir a interface de usuário do IDT para FreeRTOS Este tópico explica como abrir a interface de usuário do IDT para FreeRTOS para usar o pacote de qualificações do FreeRTOS. **Como abrir a interface de usuário do IDT para FreeRTOS** 1. Baixe um IDT compatível para a versão do FreeRTOS. Em seguida, extraia o arquivo baixado em um diretório para o qual você tenha permissões de leitura e gravação. 1. Navegue até o diretório da instalação do IDT para FreeRTOS: ``` cd devicetester-extract-location/bin ``` 1. Execute o comando a seguir para abrir a interface de usuário do IDT para FreeRTOS: ------ #### [ Linux ] ``` .devicetester_ui_linux_x86-64 ``` ------ #### [ Windows ] ``` ./devicetester_ui_win_x64-64 ``` ------ #### [ macOS ] ``` ./devicetester_ui_mac_x86-64 ``` **nota** No macOS, para permitir que seu sistema execute a interface do usuário, acesse **Preferências do sistema -> Segurança e privacidade**. Ao executar os testes, é aconselhável repeti-lo três vezes. ------ A interface de usuário do IDT para FreeRTOS é aberta em seu navegador padrão. As três versões principais mais recentes dos seguintes navegadores são compatíveis com a interface do usuário: + Google Chrome + Mozilla Firefox + Microsoft Edge + Apple Safari para macOS **nota** Para obter uma melhor experiência, recomendamos o Google Chrome ou o Mozilla Firefox para acessar a interface de usuário do IDT para FreeRTOS. O Microsoft Internet Explorer não é compatível com a interface do usuário. **Importante** Você deve configurar suas AWS credenciais antes de abrir a interface do usuário. Se você não configurou suas credenciais, feche a janela do navegador da interface de usuário do IDT para FreeRTOS, siga as etapas em [Configurar AWS credenciais para usar a interface de usuário do IDT](lts-configure-aws-credentials.md) e reabra a interface de usuário do IDT para FreeRTOS. # Criar uma configuração Se você for um usuário iniciante, deverá criar uma nova configuração para definir os arquivos de configuração JSON que o IDT para FreeRTOS exige para executar testes. Em seguida, você pode executar testes ou modificar a configuração criada. Para obter exemplos dos arquivos `config.json`, `device.json` e `userdata.json`, consulte [Primeiro teste da sua placa de microcontrolador](lts-qual-steps.md). **Como criar uma configuração** 1. Na interface de usuário do IDT para FreeRTOS, abra o menu de navegação e escolha **Criar nova configuração**. ![\[Device Tester para interface do FreeRTOS com botão "Criar configuração" e informações sobre autoteste automatizado de microcontroladores.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/gsg-create-configuration.png) 1. Siga o assistente de configuração para inserir as configurações do IDT usadas para executar os testes de qualificação. O assistente define as seguintes configurações nos arquivos de configuração JSON localizados no diretório `devicetester-extract-location/config`. + **Configurações de dispositivos**: as configurações do grupo de dispositivos para os dispositivos a serem testados. Essas configurações são definidas nos campos `id` e `sku` no bloco do grupo de **dispositivos** no arquivo `config.json`. ![\[Tela de configuração do Device Tester para o FreeRTOS com campos de identificador e SKU para configurar um pool de dispositivos, opções de configurações do dispositivo como método de conectividade, provisionamento de chave, configurações PKCS #11, campos de entrada de detalhes do dispositivo e controles para adicionar dispositivos ou identificadores.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/gsg-device-settings.png) + **AWS configurações da conta** — As Conta da AWS informações que o IDT para FreeRTOS usa para AWS criar recursos durante as execuções de teste. Essas configurações são definidas no arquivo `config.json`. ![\[Conta da AWS página de configurações com campos para região da conta, localização das credenciais como arquivo ou ambiente e nome do perfil\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/gsg-account-settings.png) + **Implementação do FreeRTOS**: o caminho absoluto para o repositório e o código transferido do FreeRTOS e a versão do FreeRTOS na qual você deseja executar o FRQ do IDT. Os caminhos para os arquivos de cabeçalho de configuração de execução e parâmetros do `FreeRTOS-Libraries-Integration-Tests` GitHub repositório. Compilar e instalar: os comandos para seu hardware que permitem que o IDT compile e instale testes em sua placa automaticamente. Essas configurações são definidas no arquivo `userdata.json`. ![\[Seção de configuração da implementação do FreeRTOS com caminhos de repositório, caminhos de execução de testes, versão do FreeRTOS, detalhes da ferramenta de compilação e configurações da ferramenta de gravação em flash.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/gsg-implementation-settings.png) + **Rótulos PKCS \$111 e servidor echo**: os rótulos [PKCS \$111](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting-pkcs.html) que correspondem às chaves provisionadas em seu hardware com base na funcionalidade e no método de provisionamento de chaves. As configurações do servidor echo para os testes da Interface de transporte. Essas configurações são definidas nos arquivos `userdata.json` e `device.json`. ![\[Rótulos PKCS #11 e configurações do servidor Echo com campos de entrada para rótulos de chave, método de geração de chave e número da porta do servidor\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/gsg-pkcs11-settings.png) + **Over-the-air Atualizações (OTA) — As** configurações que controlam os testes de funcionalidade OTA. Essas configurações são definidas no bloco `features` dos arquivos `device.json` e `userdata.json`. ![\[Opções de configuração de atualização do OTA: ignorar testes, protocolos de dados, caminhos de firmware, caminho do certificado PAL, assinatura de código, hash/sign algoritmos, certificados do assinante, arquivo do certificado do trusted/untrusted assinante, compilar certificado do assinante, plataforma do assinante.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/gsg-ota-settings.png) 1. Na página **Revisar**, verifique suas informações de configuração. ![\[Caixa de diálogo de configuração criada para o Device Tester para o FreeRTOS, mostrando detalhes sobre a criação de uma configuração de teste com opções para editar ou executar testes.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/gsg-configuration-created.png) Depois de concluir a revisão da configuração, para executar os testes de qualificação, escolha **Executar testes**. # Modificar uma configuração existente Se você já configurou arquivos de configuração do IDT para FreeRTOS, você pode usar a interface de usuário do IDT para FreeRTOS para modificar sua configuração existente. Os arquivos de configuração existentes devem estar localizados no diretório `devicetester-extract-location/config`. **Como criar uma configuração** 1. Na interface de usuário do IDT para FreeRTOS, abra o menu de navegação e escolha **Editar configuração existente**. O painel de configuração exibe informações sobre suas configurações existentes. Se uma configuração estiver incorreta ou indisponível, o status dessa configuração será `Error validating configuration`. ![\[Tela de configuração com seções de dispositivo Conta da AWS, implementação de FreeRTOS, rótulos PKCS e servidor de eco over-the-air, atualizações e configurações de execução de teste mostrando status válido.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/modify-existing-configuration.png) 1. Para modificar uma configuração existente, conclua estas etapas: 1. Escolha o nome de uma configuração para abrir sua página de ajustes. 1. Modifique as configurações e escolha **Salvar** para regenerar o arquivo de configuração correspondente. 1. Para modificar as configurações de execução de teste do IDT para FreeRTOS, escolha as **configurações de execução de teste do IDT** na visualização de edição: ![\[Caixa de diálogo de configurações de execução de testes do IDT com opções para seleção de testes, ignorar grupos de testes, multiplicador de tempo limite e interrupção na primeira falha.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/idt-testrun-settings.png) Depois de concluir a modificação da configuração, verifique se todas as configurações passaram pela validação. Se o status de cada configuração for `Valid`, será possível executar seus testes de qualificação com essa configuração. # Execute testes de qualificação Após criar uma configuração para a interface de usuário do IDT para FreeRTOS, é possível executar os testes de qualificação. **Como executar testes de qualificação** 1. No menu de navegação, escolha **Executar testes**. 1. Escolha **Iniciar testes** para iniciar a execução do teste. Por padrão, todos os testes aplicáveis são executados para a configuração do seu dispositivo. O IDT para FreeRTOS gera um relatório de qualificação quando todos os testes terminam. ![\[A interface do Device Tester para FreeRTOS mostra que nenhum teste foi executado ainda, com opções para criar uma configuração, editar uma configuração existente e executar testes.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/idt-run-tests.png) O IDT para FreeRTOS executa os testes de qualificação. Em seguida, ele exibe o resumo da execução do teste e todos os erros no console do **Executor de teste**. Depois que a execução do teste for concluída, você poderá visualizar os resultados e os logs do teste nos seguintes locais: + Os resultados dos testes estão localizados no diretório `devicetester-extract-location/results/execution-id`. + Os logs de teste estão localizados no diretório `devicetester-extract-location/results/execution-id/logs`. Para obter mais informações sobre os resultados de teste e logs, consulte [Veja o IDT gratuitamente RTOSresults](view-results-lts.md) e [Veja o IDT gratuitamente RTOSlogs](view-logs-lts.md). ![\[Log de execução do Device Tester para FreeRTOS exibindo testes aprovados, grupos de testes e caminhos dos arquivos de log e relatórios.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/idt-results.png) # Executar o pacote de qualificação do FreeRTOS 2.0 Use o executável AWS IoT Device Tester for FreeRTOS para interagir com o IDT for FreeRTOS. Os exemplos de linha de comando a seguir mostram como executar os testes de qualificação para um grupo de dispositivos (um conjunto de dispositivos idênticos). ------ #### [ IDT v4.5.2 and later ] ``` devicetester_[linux | mac | win] run-suite \ --suite-id suite-id \ --group-id group-id \ --pool-id your-device-pool \ --test-id test-id \ --userdata userdata.json ``` Executa um conjunto de testes em um grupo de dispositivos. O arquivo `userdata.json` deve estar localizado no diretório `devicetester_extract_location/devicetester_freertos_[win|mac|linux]/configs/`. **nota** Se estiver executando o IDT para FreeRTOS no Windows, use barras (/) para especificar o caminho até o arquivo `userdata.json`. Use o seguinte comando para executar um grupo de testes específico: ``` devicetester_[linux | mac | win] run-suite \ --suite-id FRQ_1.99.0 \ --group-id group-id \ --pool-id pool-id \ --userdata userdata.json ``` Os parâmetros `suite-id` e `pool-id` são opcionais se você estiver executando um único conjunto de testes em um único grupo de dispositivos (ou seja, você tem apenas um grupo de dispositivos definido no arquivo `device.json`). Use o seguinte comando para executar um caso de teste em um grupo de testes: ``` devicetester_[linux | mac | win_x86-64] run-suite \ --group-id group-id \ --test-id test-id ``` Você pode usar o comando `list-test-cases` para listar os casos de teste em um grupo de testes. **Opções de linhas de comando do IDT para FreeRTOS** **group-id** (Opcional) Os grupos de testes a serem executados, como uma lista separada por vírgulas. Se não for especificado, o IDT executará todos os grupos de testes no conjunto de testes. **pool-id** (Opcional) O grupo de dispositivos a ser testado. Isso será necessário se você definir vários grupos de dispositivos no `device.json`. Se você tiver apenas um grupo de dispositivos, poderá omitir essa opção. **suite-id** (Opcional) A versão do conjunto de testes a ser executada. Se não for especificada, o IDT usará a versão mais recente no diretório de testes em seu sistema. **test-id** (Opcional) Os testes a serem executados, como uma lista separada por vírgulas. Se especificado, `group-id` deve especificar um único grupo. **Example** ``` devicetester_[linux | mac | win_x86-64] run-suite --group-id FreeRTOSVersion --test-id FreeRTOSVersion ``` **h** Use a opção de ajuda para saber mais sobre as opções de `run-suite`. **Example** **Exemplo** ``` devicetester_[linux | mac | win_x86-64] run-suite -h ``` ------ ## Comandos do IDT para FreeRTOS O comando do IDT para FreeRTOS é compatível com as seguintes operações: ------ #### [ IDT v4.5.2 and later ] ** `help` ** Lista as informações sobre o comando especificado. ** `list-groups` ** Lista os grupos em um determinado conjunto. ** `list-suites` ** Lista os conjuntos disponíveis. ** `list-supported-products` ** Lista os produtos compatíveis e as versões do conjunto de testes. ** `list-supported-versions` ** Lista as versões do FreeRTOS e do pacote de teste compatíveis com a versão atual do IDT. ** `list-test-cases` ** Lista os casos de teste em um grupo especificado. ** `run-suite` ** Executa um conjunto de testes em um grupo de dispositivos. Use a opção `--suite-id` para especificar uma versão do conjunto de testes, ou omiti-la para usar a versão mais recente em seu sistema. Use o `--test-id` para executar um caso de teste individual. **Example** ``` devicetester_[linux | mac | win_x86-64] run-suite --group-id FreeRTOSVersion --test-id FreeRTOSVersion ``` Começando com o IDT v3.0.0, o IDT verifica se há conjuntos de testes mais recentes online. Para obter mais informações, consulte [Versões do pacote de testes](idt-test-suite-versions.md). ------ # Veja o IDT gratuitamente RTOSresults Enquanto em execução, o IDT grava erros no console, arquivos de log e relatórios de teste. Depois de concluir o pacote de teste de qualificação, O IDT gravará um resumo da execução de teste no console e gerará dois relatórios de teste. Esses relatórios podem ser encontrados em `devicetester-extract-location/results/execution-id/`. Ambos os relatórios capturam os resultados da execução do pacote de teste de qualificação. Esse `awsiotdevicetester_report.xml` é o relatório do teste de qualificação que você envia AWS para listar seu dispositivo no Catálogo de dispositivos do AWS parceiro. O relatório contém os seguintes elementos: + A versão do IDT para FreeRTOS. + A versão do FreeRTOS que foi testada. + Os recursos do FreeRTOS que são compatíveis com o dispositivo com base nos testes aprovados. + A SKU e o nome do dispositivo especificados no arquivo `device.json`. + Os recursos do dispositivo especificados no arquivo `device.json`. + O resumo agregado dos resultados de casos de teste. + Um detalhamento dos resultados de casos de teste por bibliotecas que foram testadas com base nos recursos do dispositivo. `FRQ_Report.xml`É um relatório em [formato JUnit XML](https://llg.cubic.org/docs/junit/) padrão. Você pode integrá-lo em CI/CD plataformas como [Jenkins](https://jenkins.io/), [Bamboo](https://www.atlassian.com/software/bamboo) e assim por diante. O relatório contém os seguintes elementos: + Um resumo agregado dos resultados de casos de teste. + Um detalhamento dos resultados de casos de teste por bibliotecas que foram testadas com base nos recursos do dispositivo. # Interpretar os resultados do IDT para FreeRTOS A seção de relatório em `awsiotdevicetester_report.xml` ou em `FRQ_Report.xml` lista os resultados dos testes que são executados. A primeira tag XML `` contém o resumo geral da execução do teste. Por exemplo: `` **Atributos usados na tag ``** ** `name` ** O nome do conjunto de testes. ** `time` ** O tempo, em segundos, necessário para executar o conjunto de qualificação. ** `tests` ** O número de casos de teste executados. ** `failures` ** O número de casos de teste que foram executados, mas não foram aprovados. ** `errors` ** O número de casos de teste que o IDT para FreeRTOS não pôde executar. ** `disabled` ** Esse recurso não é usado e pode ser ignorado. Se não houver falhas ou erros no caso de teste, seu dispositivo atende aos requisitos técnicos para executar Freertos e pode interoperar com os serviços. AWS IoT Se você optar por listar seu dispositivo no Catálogo de dispositivos do AWS parceiro, poderá usar esse relatório como evidência de qualificação. Se houver falhas de caso de teste ou erros, você poderá identificar o caso de teste com falha analisando as tags XML ``. As tags XML `` dentro da tag `` mostram o resumo do resultado do caso de teste para um grupo de testes. `` O formato é semelhante à tag ``, mas com um recurso chamado `skipped` que não é usado e pode ser ignorado. Dentro de cada tag XML ``, há tags `` para cada um dos casos de teste que foram executados para um grupo de testes. Por exemplo: `` **Atributos usados na tag ``** ** `name` ** O nome do produto testado. ** `version` ** A versão do produto testado. ** `features` ** Os atributos validados. recursos marcados como `required` são necessários para enviar sua placa para qualificação. O snippet a seguir mostra como essas informações aparecem no arquivo `awsiotdevicetester_report.xml`. ``` ``` Os recursos marcados como `optional` não são necessários para qualificação. Os seguintes trechos mostram recursos opcionais. ``` ``` Se não há falhas de teste ou erros nos recursos exigidos, seu dispositivo atende aos requisitos técnicos para executar o FreeRTOS e pode interoperar com serviços do AWS IoT . Se quiser listar o dispositivo no [AWS Partner Device Catalog](https://partners.amazonaws.com/qualified-devices), poderá usar este relatório como evidência de qualificação. Se houver falhas de teste ou erros, você poderá identificar o teste com falha analisando as tags XML ``. As tags XML `` dentro da tag `` mostram o resumo do resultado do teste para um grupo de testes. Por exemplo: ``` ``` O formato é semelhante à tag ``, mas tem um recurso `skipped` que não é usado e pode ser ignorado. Dentro de cada tag XML ``, há tags `` para cada teste executado para um grupo de testes. Por exemplo: ``` ``` **Atributos usados na tag ``** ** `name` ** O nome do caso de teste. ** `attempts` ** O número de vezes que o IDT para FreeRTOS executou o caso de teste. Quando um teste falha ou ocorre um erro, as tags `` ou `` são adicionadas à tag `` com informações para a solução de problemas. Por exemplo: ``` Reason for the test case failure Reason for the test case execution error ``` Para obter mais informações, consulte [Solucionar erros](dt-afr-troubleshooting.md). # Veja o IDT gratuitamente RTOSlogs É possível encontrar os logs que o IDT para FreeRTOS gera ao executar testes em `devicetester-extract-location/results/execution-id/logs`. Dois conjuntos de logs são gerados: + `test_manager.log` Contém logs gerados de IDT para FreeRTOS (por exemplo, logs relacionados à configuração e geração de relatórios). + `test_group_id/test_case_id/test_case_id.log` O arquivo de log para um caso de teste, incluindo a saída do dispositivo em teste. O arquivo de log é nomeado de acordo com o grupo de teste e com o caso de teste que foi executado.