Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # IDT con suite di qualificazione FreerTOS 2.0 (FRQ 2.0) La suite di qualificazione FreerTOS 2.0 è una versione aggiornata della suite di qualificazione FreerTOS. Consigliamo agli sviluppatori di utilizzare FRQ 2.0 perché consiste in casi di test pertinenti per qualificare i dispositivi che eseguono le librerie FreerTOS Long Term Support (LTS). IDT for FreerTOS verifica la porta di FreerTOS sul microcontrollore e se comunica efficacemente con. AWS IoT In particolare, verifica le interfacce del livello di porting con le librerie FreeRTOS e se i repository di test FreerTOS sono implementati correttamente. end-to-end AWS IoT Core Esegue anche test con. [I test eseguiti da IDT per FreerTOS sono definiti nel repository FreerTOS. GitHub](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests) IDT per FreerTOS esegue i test come applicazioni integrate che lampeggiano sul dispositivo microcontrollore sottoposto a test. Le immagini binarie dell'applicazione includono FreeRTOS, le interfacce FreeRTOS con porting e i driver dei dispositivi di scheda. Lo scopo dei test è verificare che le interfacce FreeRTOS con porting funzionino correttamente sui driver del dispositivo. IDT for FreerTOS genera report di test che puoi inviare AWS IoT per inserire il tuo hardware nel Partner Device Catalog. AWS Per ulteriori informazioni, consulta [AWS Device Qualification Program](https://aws.amazon.com/partners/dqp/). IDT per FreerTOS viene eseguito su un computer host (Windows, macOS o Linux) collegato al dispositivo in fase di test. IDT configura e orchestra i casi di test e aggrega i risultati. Fornisce inoltre un'interfaccia a riga di comando per gestire l'esecuzione dei test. Per testare il tuo dispositivo, IDT for FreeRTOS crea risorse come AWS IoT oggetti, gruppi FreerTOS, funzioni Lambda. Per creare queste risorse, IDT for FreerTOS utilizza AWS le credenziali configurate in per effettuare chiamate API per `config.json` tuo conto. Il provisioning di queste risorse viene effettuato varie volte nel corso di un test. Quando esegui IDT for FreerTOS sul tuo computer host, esegue i seguenti passaggi: 1. Carica e convalida la configurazione del dispositivo e delle credenziali. 1. Esegue i test selezionati con le risorse locali e cloud richieste. 1. Esegue la pulizia di risorse locali e cloud. 1. Genera i report di test che indicano se la scheda ha superato i test richiesti per la qualifica. # Imposta i prerequisiti di qualificazione LTS Questa sezione descrive i prerequisiti per testare i microcontrollori con. AWS IoT Device Tester ## Preparati per la qualificazione FreerTOS **Nota** AWS IoT Device Tester for FreerTOS consiglia vivamente di utilizzare l'ultima patch release della versione più recente di FreeRTOS-LTS. IDT for FRQ 2.0 è una qualifica per FreerTOS. *Prima di avviare IDT FRQ 2.0 per la qualificazione, devi completare [Qualifying your board nella FreerTOS Qualification](https://docs.aws.amazon.com/freertos/latest/qualificationguide/freertos-qualification.html) Guide.* *Per effettuare il porting delle librerie, i test e la configurazione di`manifest.yml`, consulta [Porting the FreerTOS librerie nella FreeRTOS](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting.html) Porting Guide.* FRQ 2.0 contiene un processo di qualificazione diverso. Vedi [le ultime modifiche alle qualifiche nella guida alla qualificazione](https://docs.aws.amazon.com/freertos/latest/qualificationguide/latest-changes.html) di *FreerTOS* per i dettagli. Il repository [FreeRTOS-Libraries-Integration-Tests](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests) deve essere presente affinché IDT possa funzionare. Vedi [README.md](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests/blob/main/README.md) su come clonare e trasferire questo repository sul tuo progetto sorgente. FreeRTOS-Libraries-Integration-Testsè necessario includere il file che `manifest.yml` si trova nella radice del progetto, affinché IDT possa funzionare. **Nota** IDT dipende dall'implementazione di. `UNITY_OUTPUT_CHAR` I log dei risultati dei test e i log del dispositivo non devono interlacciarsi tra loro. Vedi [la sezione Implementazione delle macro di registrazione della libreria nella FreerTOS Porting](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-library-logging-macros.html) *Guide per ulteriori dettagli*. ## Scarica IDT per FreerTOS Ogni versione di FreerTOS ha una versione corrispondente di IDT per FreerTOS per eseguire test di qualificazione. Scarica la versione appropriata di IDT per FreerTOS [dalle versioni](https://docs.aws.amazon.com/freertos/latest/userguide/dev-test-versions-afr.html) supportate di per FreerTOS. AWS IoT Device Tester Estrai IDT for FreerTOS in una posizione del file system in cui disponi dei permessi di lettura e scrittura. Poiché Microsoft Windows ha un limite di caratteri per la lunghezza del percorso, estrai IDT per FreerTOS in una directory principale come o. `C:\` `D:\` **Nota** Più utenti non devono eseguire IDT da una posizione condivisa, come una directory NFS o una cartella condivisa di rete Windows. Ciò provocherà arresti anomali o danneggiamento dei dati. Si consiglia di estrarre il pacchetto IDT in un'unità locale. ## Scarica Git IDT deve avere Git installato come prerequisito per garantire l'integrità del codice sorgente. Segui le istruzioni nella [GitHub](https://github.com/git-guides/install-git)guida per installare Git. Per verificare la versione attualmente installata di Git, inserisci il comando `git --version` nel terminale. **avvertimento** IDT usa Git per allinearsi allo stato pulito o sporco di una directory. Se Git non è installato, i gruppi di `FreeRTOSIntegrity` test falliranno o non verranno eseguiti come previsto. Se IDT restituisce un errore come `git executable not found` o`git command not found`, installa o reinstalla Git e riprova. **Topics** + [Preparati per la qualificazione FreerTOS](#idt-preparing-qualification) + [Scarica IDT per FreerTOS](#idt-download-dev-tester-afr) + [Scarica Git](#idt-download-git) + [Crea un account AWS](#lts-config-aws-account) + [AWS IoT Device Tester politica gestita](#managed-policy) + [(Facoltativo) Installa il AWS Command Line Interface](#install-cli) ## Crea un account AWS **Nota** La suite di qualificazione IDT completa è supportata solo nei seguenti paesi Regioni AWS Stati Uniti orientali (Virginia settentrionale) Stati Uniti occidentali (Oregon) Asia Pacifico (Tokyo) Europa (Irlanda) Per testare il tuo dispositivo, IDT for FreeRTOS crea risorse come AWS IoT oggetti, gruppi FreeRTOS e funzioni Lambda. Per creare tali risorse, IDT for FreerTOS richiede la creazione e la configurazione di AWS un account e una policy IAM che conceda a IDT for FreerTOS l'autorizzazione ad accedere alle risorse per tuo conto durante l'esecuzione dei test. I seguenti passaggi servono a creare e configurare il tuo account. AWS 1. Se hai già un AWS account, vai al passaggio successivo. Altrimenti crea un [AWS account](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/). 1. Segui i passaggi descritti in [Creazione di ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html). Al momento non aggiungere autorizzazioni o politiche. 1. Per eseguire i test di qualificazione OTA, vai al passaggio 4. Altrimenti vai al passaggio 5. 1. Allega la policy in linea per le autorizzazioni OTA IAM al tuo ruolo IAM. 1. **Importante** Il modello di policy seguente concede l'autorizzazione IDT per creare ruoli, policy e collegare policy ai ruoli. IDT for FreerTOS utilizza queste autorizzazioni per i test che creano ruoli. Sebbene il modello di policy non fornisca privilegi di amministratore all'utente, le autorizzazioni possono essere utilizzate per ottenere l'accesso come amministratore al proprio account. AWS 1. Segui i passaggi seguenti per assegnare le autorizzazioni necessarie al tuo ruolo IAM: 1. Nella pagina **Autorizzazioni, scegli **Aggiungi** autorizzazioni**. 1. Scegli **Create inline policy** (Crea policy in linea). 1. Scegliere la scheda **JSON** e copiare le seguenti autorizzazioni nella casella di testo **JSON** . Usa il modello sotto **La maggior parte delle regioni** se non ti trovi nella regione Cina. Se ti trovi nella regione della Cina, usa il modello in Regioni di **Pechino 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 ] Il seguente modello di politica può essere utilizzato nelle regioni di Pechino e Ningxia. ------ 1. Al termine, seleziona **Review policy (Rivedi policy)**. 1. Inserisci **IDTFreeRTOSIAMPermissions**come nome della politica. 1. Scegli **Crea policy**. 1. Allega **AWSIoTDeviceTesterForFreeRTOSFullAccess** al tuo ruolo IAM. 1. Per assegnare le autorizzazioni necessarie al tuo ruolo IAM: 1. Nella pagina **Autorizzazioni, scegli **Aggiungi** autorizzazioni**. 1. Scegli **Collega policy**. 1. Cerca la politica di **AWSIoTDeviceTesterForFreeRTOSFullaccesso**. Seleziona la casella. 1. Scegli **Add Permissions (Aggiungi autorizzazioni)**. 1. Esporta le credenziali per IDT. Per ulteriori dettagli, consulta [Ottenere le credenziali del ruolo IAM per l'accesso alla CLI](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html). ## AWS IoT Device Tester politica gestita La policy `AWSIoTDeviceTesterForFreeRTOSFullAccess` gestita contiene le seguenti AWS IoT Device Tester autorizzazioni per il controllo della versione, le funzionalità di aggiornamento automatico e la raccolta di metriche. + `iot-device-tester:SupportedVersion` Concede AWS IoT Device Tester l'autorizzazione a recuperare l'elenco dei prodotti supportati, delle suite di test e delle versioni IDT. + `iot-device-tester:LatestIdt` Concede AWS IoT Device Tester l'autorizzazione a recuperare l'ultima versione IDT disponibile per il download. + `iot-device-tester:CheckVersion` Concede AWS IoT Device Tester l'autorizzazione a verificare la compatibilità delle versioni per IDT, suite di test e prodotti. + `iot-device-tester:DownloadTestSuite` Concede AWS IoT Device Tester l'autorizzazione a scaricare gli aggiornamenti della suite di test. + `iot-device-tester:SendMetrics` Concede AWS l'autorizzazione a raccogliere metriche sull' AWS IoT Device Tester utilizzo interno. ## (Facoltativo) Installa il AWS Command Line Interface Potresti preferire utilizzare il AWS CLI per eseguire alcune operazioni. Se non lo hai AWS CLI installato, segui le istruzioni in [Installare il AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html). Configuralo AWS CLI per la AWS regione che desideri utilizzare eseguendolo **aws configure** da una riga di comando. [Per informazioni sulle AWS regioni che supportano IDT for FreerTOS,AWS consulta Regioni ed endpoint.](https://docs.aws.amazon.com/general/latest/gr/rande.html#amazon-freertos-ota-control) [Per ulteriori informazioni, **aws configure** vedere Configurazione rapida con. **aws configure**](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) # Primo test della scheda del microcontrollore Puoi usare IDT for FreerTOS per testare la tua implementazione delle librerie FreerTOS. Dopo aver effettuato il porting delle librerie FreerTOS per i driver di dispositivo della tua scheda, AWS IoT Device Tester usale per eseguire i test di qualificazione sulla tua scheda microcontrollore. ## Aggiunta di livelli di porting delle librerie [Per portare FreerTOS sul tuo dispositivo, consulta la FreerTOS Porting Guide.](https://docs.aws.amazon.com/freertos/latest/portingguide/porting-guide.html) Quando si implementa il repository dei test FreerTOS e si esegue il porting dei layer FreerTOS, è necessario fornire `manifest.yml` un percorso a ciascuna libreria, incluso l'archivio dei test. Questo file si troverà nella directory principale del codice sorgente. Consultate [le istruzioni del file manifest](https://docs.aws.amazon.com/freertos/latest/qualificationguide/afq-checklist-manifest-instr.html) per i dettagli. ## Configura AWS le tue credenziali AWS IoT Device Tester per comunicare con il Cloud AWS È necessario configurare le AWS credenziali AWS IoT Device Tester per comunicare con il AWS Cloud. Per ulteriori informazioni, consulta [Configurare AWS le credenziali e la regione per](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html) lo sviluppo. AWS Le credenziali valide sono specificate nel `devicetester_extract_location/devicetester_freertos_[win|mac|linux]/configs/config.json` file di configurazione. ``` "auth": { "method": "environment" } "auth": { "method": "file", "credentials": { "profile": "" } } ``` L'`auth`attributo del `config.json` file ha un campo di metodo che controlla AWS l'autenticazione e può essere dichiarato come file o come ambiente. L'impostazione del campo su environment estrae le AWS credenziali dalle variabili di ambiente della macchina host. L'impostazione del campo su file importa un profilo specificato dal file di `.aws/credentials` configurazione. **Topics** + [Aggiunta di livelli di porting delle librerie](#lts-add-port-layer) + [Configura AWS le tue credenziali AWS IoT Device Tester per comunicare con il Cloud AWS](#lts-cfg-aws-afr) + [Crea un pool di dispositivi in IDT per FreerTOS](lts-cfg-dt-dp.md) + [Configurazione delle impostazioni di compilazione, flashing e test](lts-cfg-dt-ud.md) # Crea un pool di dispositivi in IDT per FreerTOS I dispositivi da testare sono organizzati in pool di dispositivi. Ogni pool di dispositivi è composto da uno o più dispositivi identici. Puoi configurare IDT per FreerTOS per testare un singolo dispositivo o più dispositivi in un pool. Per accelerare il processo di qualificazione, IDT for FreerTOS può testare dispositivi con le stesse specifiche in parallelo. Lo strumento utilizza un metodo Round Robin per eseguire un gruppo di test differente su ciascun dispositivo di un pool. Il `device.json` file ha un array nel suo livello superiore. Ogni attributo dell'array è un nuovo pool di dispositivi. Ogni pool di dispositivi ha un attributo di array di dispositivi, che ha più dispositivi dichiarati. Nel modello è presente un pool di dispositivi e solo un dispositivo in quel pool di dispositivi. È possibile aggiungere uno o più dispositivi a un pool di dispositivi modificando la sezione `devices` del modello `device.json` nella cartella `configs`. **Nota** Tutti i dispositivi dello stesso pool devono avere le stesse specifiche tecniche e lo stesso SKU. Per abilitare le build parallele del codice sorgente per diversi gruppi di test, IDT for FreerTOS copia il codice sorgente in una cartella dei risultati all'interno della cartella estratta IDT for FreerTOS. È necessario fare riferimento al percorso del codice sorgente nel comando build o flash utilizzando la variabile. `testdata.sourcePath` IDT for FreerTOS sostituisce questa variabile con un percorso temporaneo del codice sorgente copiato. Per ulteriori informazioni, consulta [IDT per variabili FreerTOS](lts-dt-vars.md). Di seguito è riportato un `device.json` file di esempio utilizzato per creare un pool di dispositivi con più dispositivi. ``` [ { "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" } ] } ] } ] ``` I seguenti attributi vengono utilizzati nel file `device.json`: ** `id` ** Un ID alfanumerico definito dall'utente che identifica in modo univoco un pool di dispositivi. I dispositivi appartenenti a un pool devono essere dello stesso tipo. Durante l'esecuzione di una suite di test, i dispositivi del pool vengono utilizzati per parallelizzare il carico di lavoro. ** `sku` ** Un valore alfanumerico che identifica in modo univoco la scheda da testare. Il codice SKU viene utilizzato per tenere traccia delle schede qualificate. Se desideri inserire la tua scheda nel AWS Partner Device Catalog, lo SKU che specifichi qui deve corrispondere allo SKU che utilizzi nel processo di pubblicazione delle offerte. ** `features` ** Un array che contiene le funzionalità supportate dal dispositivo. AWS IoT Device Tester utilizza queste informazioni per selezionare i test di qualificazione da eseguire. I valori supportati sono: ** `Wifi` ** Indica se la scheda dispone di funzionalità Wi-Fi. ** `Cellular` ** Indica se la scheda dispone di funzionalità di rete cellulare. ** `PKCS11` ** Indica l'algoritmo di crittografia a chiave pubblica supportato dalla scheda. PKCS11 è necessario per la qualificazione. I valori supportati sono `ECC``RSA`, e`Both`. `Both`indica che la scheda supporta entrambi `ECC` e`RSA`. ** `KeyProvisioning` ** Indica il metodo di scrittura di un certificato client X.509 attendibile sulla scheda. I valori validi sono `Import``Onboard`, `Both` e`No`. `Onboard``Both`, oppure per la qualificazione è richiesta la fornitura delle `No` chiavi. `Import`da sola non è un'opzione valida per la qualificazione. + `Import`Utilizzalo solo se la tua scheda consente l'importazione di chiavi private. `Import`La selezione non è una configurazione valida per la qualificazione e deve essere utilizzata solo a scopo di test, in particolare per i casi di PKCS11 test. `Onboard`, `Both` o `No` è necessario per la qualificazione. + Utilizzalo `Onboard` se la tua scheda supporta le chiavi private integrate (ad esempio, se il tuo dispositivo ha un elemento sicuro o se preferisci generare la tua coppia di chiavi e il tuo certificato del dispositivo). Assicurarsi di aggiungere un elemento `secureElementConfig` in ciascuna delle sezioni del dispositivo e inserire il percorso assoluto del file della chiave pubblica nel campo `publicKeyAsciiHexFilePath`. + Utilizzalo `Both` se la tua scheda supporta sia l'importazione di chiavi private che la generazione di chiavi integrate per il provisioning delle chiavi. + Utilizzalo `No` se la tua scheda non supporta il provisioning delle chiavi. `No`è un'opzione valida solo quando anche il dispositivo è preconfigurato. ** `OTA` ** Indica se la scheda supporta la funzionalità di aggiornamento over-the-air (OTA). L'attributo `OtaDataPlaneProtocol` indica quale protocollo di piano dei dati OTA supporta il dispositivo. Per la qualificazione è richiesta una OTA con protocollo dataplane HTTP o MQTT. Per ignorare l'esecuzione dei test OTA durante il test, imposta la funzionalità OTA su e l'attributo su`No`. `OtaDataPlaneProtocol` `None` Questa non sarà una corsa di qualificazione. ** `BLE` ** Indica se la scheda supporta Bluetooth Low Energy (BLE). ** `devices.id` ** Un identificativo univoco definito dall'utente del dispositivo sottoposto a test. ** `devices.connectivity.serialPort` ** La porta seriale del computer host utilizzato per connettersi ai dispositivi da testare. ** `devices.secureElementConfig.PublicKeyAsciiHexFilePath` ** Obbligatoria se la tavola NON è `pre-provisioned` o non `PublicDeviceCertificateArn` viene fornita. Poiché `Onboard` è un tipo obbligatorio di Key Provisioning, questo campo è attualmente obbligatorio per il gruppo di test FullTransportInterface TLS. Se il dispositivo lo è`pre-provisioned`, `PublicKeyAsciiHexFilePath` è facoltativo e non deve essere incluso. Il blocco seguente è un percorso assoluto del file che contiene la chiave pubblica in byte esadecimali estratta dalla chiave `Onboard` privata. ``` 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 la chiave pubblica è in formato.der, puoi codificare direttamente in esadecimale la chiave pubblica per generare il file esadecimale. Per generare il file esadecimale da una chiave pubblica.der, inserisci il seguente comando: **xxd** ``` xxd -p pubkey.der > outFile ``` Se la tua chiave pubblica è in formato.pem, puoi estrarre le intestazioni e i piè di pagina codificati in base64 e decodificarla in formato binario. Quindi, codificate in modo esadecimale la stringa binaria per generare il file esadecimale. Per generare un file esadecimale per una chiave pubblica.pem, procedi come segue: 1. Esegui il **base64** comando seguente per rimuovere l'intestazione e il piè di pagina base64 dalla chiave pubblica. La chiave decodificata, denominata`base64key`, viene quindi emessa nel file: `pubkey.der` ``` base64 —decode base64key > pubkey.der ``` 1. Esegui il seguente **xxd** comando per `pubkey.der` convertire in formato esadecimale. La chiave risultante viene salvata come `outFile` ``` xxd -p pubkey.der > outFile ``` ** `devices.secureElementConfig.PublicDeviceCertificateArn` ** L'ARN del certificato del tuo elemento sicuro su cui viene caricato. AWS IoT Core*Per informazioni sul caricamento del certificato su AWS IoT Core, consulta i [certificati client X.509](https://docs.aws.amazon.com/iot/latest/developerguide/x509-client-certs.html) nella Developer Guide.AWS IoT * ** `devices.secureElementConfig.SecureElementSerialNumber` ** (Facoltativo) Il numero di serie dell'elemento sicuro. Il numero di serie viene utilizzato opzionalmente per creare certificati di dispositivo per la fornitura di chiavi JITR. ** `devices.secureElementConfig.preProvisioned` ** (Facoltativo) Imposta su «Sì» se il dispositivo dispone di un elemento sicuro preconfigurato con credenziali bloccate, che non può importare, creare o distruggere oggetti. Se questo attributo è impostato su **Sì, è necessario fornire le etichette** pkcs11 corrispondenti. ** `devices.secureElementConfig.pkcs11JITPCodeVerifyRootCertSupport` ** (Facoltativo) Imposta su **Sì** se l'PKCS11 implementazione principale del dispositivo supporta l'archiviazione per JITP. Ciò abiliterà il test JITP durante il `codeverify` test di base di PKCS 11 e richiede la fornitura della chiave di verifica del codice, del certificato JITP e delle etichette PKCS 11 del certificato radice. ** `identifiers` ** (Facoltativo) Un array di coppie nome/valore arbitrarie. Puoi utilizzare questi valori nei comandi di compilazione e flashing descritti nella sezione successiva. # Configurazione delle impostazioni di compilazione, flashing e test IDT for FreerTOS crea e invia automaticamente i test sulla scheda. Per abilitare ciò, è necessario configurare IDT per eseguire i comandi build e flash per il proprio hardware. Le impostazioni dei comandi di compilazione e flashing sono configurate nel file di modello `userdata.json` che si trova nella cartella `config`. # Configurazione delle impostazioni per il testing dei dispositivi Le impostazioni di compilazione, flashing e test vengono eseguite nel file `configs/userdata.json`. Il seguente esempio JSON mostra come configurare IDT per FreerTOS per testare più dispositivi: ``` { "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": "" } } ``` Il seguente elenca gli attributi utilizzati in `userdata.json`: ** `sourcePath` ** Il percorso alla radice del codice sorgente di FreerTOS portato. ** `retainModifiedSourceDirectories` ** (Facoltativo) Verifica se conservare le directory sorgente modificate utilizzate durante la compilazione e il flashing per scopi di debug. Se impostata su`true`, le directory di origine modificate vengono denominate RetainedSrc e si trovano nelle cartelle di registro dei risultati di ogni esecuzione del gruppo di test. Se non è incluso, il valore predefinito del campo è. `false` ** `freeRTOSTestParamConfigPath` ** Il percorso del `test_param_config.h` file per FreeRTOS-Libraries-Integration-Tests l'integrazione. Questo file deve utilizzare la variabile `{{testData.sourcePath}}` placeholder per renderlo relativo alla radice del codice sorgente. AWS IoT Device Tester utilizza i parametri di questo file per configurare i test. ** `freeRTOSTestExecutionConfigPath` ** Il percorso del `test_execution_config.h` file per FreeRTOS-Libraries-Integration-Tests l'integrazione. Questo file deve utilizzare la variabile `{{testData.sourcePath}}` placeholder per renderlo relativo alla radice del repository. AWS IoT Device Tester utilizza questo file per controllare quali test devono essere eseguiti. ** `freeRTOSVersion` ** La versione di FreerTOS inclusa la versione patch utilizzata nell'implementazione. Vedi [Versioni supportate di AWS IoT Device Tester for FreeRTOS](https://docs.aws.amazon.com/freertos/latest/userguide/dev-test-versions-afr.html) per le versioni FreeRTOS compatibili con for FreerTOS. AWS IoT Device Tester ** `buildTool` ** Il comando per creare il codice sorgente. Tutti i riferimenti al percorso del codice sorgente nel comando build devono essere sostituiti dalla AWS IoT Device Tester variabile`{{testData.sourcePath}}`. Utilizzate il `{{config.idtRootPath}}` segnaposto per fare riferimento a uno script di compilazione relativo al percorso AWS IoT Device Tester principale. ** `flashTool` ** Il comando per far lampeggiare un'immagine sul dispositivo. Tutti i riferimenti al percorso del codice sorgente nel comando flash devono essere sostituiti dalla AWS IoT Device Tester variabile`{{testData.sourcePath}}`. Utilizzate il `{{config.idtRootPath}}` segnaposto per fare riferimento a uno script flash relativo al AWS IoT Device Tester percorso principale. La nuova struttura dei test di integrazione con FRQ 2.0 non richiede variabili di percorso come e. `{{enableTests}}` `{{buildImageName}}` I test OTA End to End vengono eseguiti con i modelli di configurazione forniti nel [ FreeRTOS-Libraries-Integration-Tests](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests/blob/main/config_template/) GitHub repository. Se i file del GitHub repository sono presenti nel progetto sorgente principale, il codice sorgente non viene modificato tra un test e l'altro. Se è necessaria un'immagine di build diversa per OTA End to End, è necessario creare questa immagine nello script di compilazione e specificarla nel `userdata.json` file specificato sotto`otaConfiguration`. ** `testStartDelayms` ** Speciifica quanti millisecondi aspetterà il test runner FreerTOS prima di iniziare a eseguire i test. Ciò può essere utile se il dispositivo sottoposto a test inizia a emettere importanti informazioni di test prima che IDT abbia la possibilità di connettersi e avviare la registrazione a causa di problemi di rete o di altro tipo. Questo valore è applicabile solo ai gruppi di test FreerTOS e non ad altri gruppi di test che non utilizzano il test runner FreerTOS, come i test OTA. Se ricevi un errore relativo a **10 previsto ma ne ricevi 5**, questo campo deve essere impostato su 5000. ** `echoServerConfiguration` ** La configurazione per configurare il server echo per il test TLS. Questo campo è obbligatorio. ** `keyGenerationMethod` ** Il server echo è configurato con questa opzione. Le opzioni sono EC o RSA. ** `serverPort` ** Il numero di porta su cui viene eseguito il server echo. ** `otaConfiguration` ** La configurazione per i test OTA PAL e OTA E2E. Questo campo è obbligatorio. **`otaE2EFirmwarePath`** Percorso dell'immagine del contenitore OTA utilizzata da IDT per i test OTA End to End. ** `otaPALCertificatePath` ** Il percorso del certificato per il test OTA PAL sul dispositivo. Viene utilizzato per verificare la firma. Ad esempio, **ecdsa-sha256-signer.crt.pem**. ** `deviceFirmwarePath` ** Il percorso del nome codificato per l'avvio dell'immagine del firmware. Se il dispositivo NON utilizza il file system per l'avvio del firmware, specifica questo campo come`'NA'`. Se il dispositivo utilizza il file system per l'avvio del firmware, specifica il percorso o il nome dell'immagine di avvio del firmware. ** `codeSigningConfiguration` ** ** `signingMethod` ** Il metodo di firma del codice. I valori possibili sono AWS o Personalizzato. Per le regioni di Pechino e Ningxia, usa Custom. AWS la firma del codice non è supportata in quella regione. ** `signerHashingAlgorithm` ** L'algoritmo hash supportato sul dispositivo. I valori possibili sono `SHA1` o `SHA256`. ** `signerSigningAlgorithm` ** L'algoritmo di firma supportato sul dispositivo. I valori possibili sono `RSA` o `ECDSA`. ** `signerCertificate` ** Il certificato attendibile utilizzato per OTA. Per il metodo di firma del AWS codice, usa Amazon Resource Name (ARN) per il certificato affidabile caricato su Certificate Manager AWS . Per il metodo di firma del codice personalizzato, utilizza il percorso assoluto del file del certificato del firmatario. Per informazioni sulla creazione di un certificato affidabile, consulta [Creare un certificato di firma del codice](https://docs.aws.amazon.com/freertos/latest/userguide/ota-code-sign-cert.html). ** `untrustedSignerCertificate` ** L'ARN o il percorso del file per un secondo certificato utilizzato in alcuni test OTA come certificato non attendibile. Per informazioni sulla creazione di un certificato, consulta [Creare un](https://docs.aws.amazon.com//freertos/latest/userguide/ota-code-sign-cert.html) certificato di firma del codice. ** `signerCertificateFileName` ** Il nome del file del certificato di firma del codice sul dispositivo. Questo valore deve corrispondere al nome di file fornito durante l'esecuzione del `aws acm import-certificate` comando. ** `compileSignerCertificate` ** Valore booleano che determina lo stato del certificato di verifica della firma. I valori validi sono `true` e `false`. Imposta questo valore su **true** se il certificato di verifica della firma del firmatario del codice non è fornito o visualizzato. Deve essere compilato nel progetto. AWS IoT Device Tester recupera il certificato affidabile e lo compila in. `aws_codesigner_certificate.h` ** `signerPlatform` ** L'algoritmo di firma e hashing utilizzato da AWS Code Signer durante la creazione del processo di aggiornamento OTA. Al momento, i valori possibili per questo campo sono `AmazonFreeRTOS-TI-CC3220SF` e `AmazonFreeRTOS-Default`. + Scegli `AmazonFreeRTOS-TI-CC3220SF` se `SHA1` e `RSA`. + Scegli `AmazonFreeRTOS-Default` se `SHA256` e `ECDSA`. + Se ti occorre `SHA256` \$1 `RSA` o `SHA1` \$1 `ECDSA` per la configurazione, contattaci per ulteriore supporto. + Configura `signCommand` se hai scelto `Custom` per `signingMethod`. ** `signCommand` ** Sono necessari due segnaposto `{{inputImageFilePath}}` e `{{outputSignatureFilePath}}` nel comando. `{{inputImageFilePath}}` è il percorso del file dell'immagine creata da IDT da firmare. `{{outputSignatureFilePath}} ` è il percorso del file della firma che verrà generato dallo script. ** `pkcs11LabelConfiguration` ** PKCS11 la configurazione dell'etichetta richiede almeno un set di etichette di etichetta di certificato del dispositivo, etichetta a chiave pubblica e etichetta a chiave privata per eseguire i gruppi di PKCS11 test. Le PKCS11 etichette richieste si basano sulla configurazione del dispositivo nel `device.json` file. Se pre-provisioned è impostato su **Sì** in`device.json`, le etichette richieste devono essere una delle seguenti, a seconda del tipo scelto per la PKCS11 funzionalità. + `PreProvisionedEC` + `PreProvisionedRSA` Se pre-provisioned è impostato su **No** in`device.json`, le etichette richieste sono: + `pkcs11LabelDevicePrivateKeyForTLS` + `pkcs11LabelDevicePublicKeyForTLS` + `pkcs11LabelDeviceCertificateForTLS` Le tre etichette seguenti sono obbligatorie solo se si seleziona **Sì** per `pkcs11JITPCodeVerifyRootCertSupport` nel file`device.json`. + `pkcs11LabelCodeVerifyKey` + `pkcs11LabelRootCertificate` + `pkcs11LabelJITPCertificate` I valori di questi campi devono corrispondere ai valori definiti nella [FreerTOS Porting Guide](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting-pkcs.html). ** `pkcs11LabelDevicePrivateKeyForTLS` ** (Facoltativo) Questa etichetta viene utilizzata per l'etichetta PKCS \$111 della chiave privata. Per i dispositivi con supporto integrato e di importazione per la fornitura di chiavi, questa etichetta viene utilizzata a scopo di test. Questa etichetta può essere diversa da quella definita per il caso predisposto. Se il provisioning delle chiavi è impostato su **No** e il pre-provisioning è impostato su **Sì**, nel`device.json`, questo non sarà definito. ** `pkcs11LabelDevicePublicKeyForTLS` ** (Facoltativo) Questa etichetta viene utilizzata per l'etichetta PKCS \$111 della chiave pubblica. Per i dispositivi con supporto integrato e di importazione per la fornitura di chiavi, questa etichetta viene utilizzata a scopo di test. Questa etichetta può essere diversa da quella definita per il caso preconfezionato. Se il provisioning delle chiavi è impostato su **No** e il pre-provisioning è impostato su **Sì**, nel`device.json`, questo non sarà definito. ** `pkcs11LabelDeviceCertificateForTLS` ** (Facoltativo) Questa etichetta viene utilizzata per l'etichetta PKCS \$111 del certificato del dispositivo. Per i dispositivi con supporto integrato e di importazione per la fornitura di chiavi, questa etichetta verrà utilizzata per i test. Questa etichetta può essere diversa da quella definita per il caso preconfezionato. Se il provisioning delle chiavi è impostato su **No** e il pre-provisioning è impostato su **Sì**, nel`device.json`, questo non sarà definito. ** `pkcs11LabelPreProvisionedECDevicePrivateKeyForTLS` ** (Facoltativo) Questa etichetta viene utilizzata per l'etichetta PKCS \$111 della chiave privata. Per i dispositivi con elementi sicuri o limitazioni hardware, questa avrà un'etichetta diversa per conservare AWS IoT le credenziali. Se il tuo dispositivo supporta il pre-provisioning con una chiave EC, fornisci questa etichetta. Quando PreProvisioned è impostato su **Yes** in`device.json`, è necessario fornire questa etichetta o entrambe. `pkcs11LabelPreProvisionedRSADevicePrivateKeyForTLS` Questa etichetta può essere diversa da quella definita per i casi di bordo e di importazione. ** `pkcs11LabelPreProvisionedECDevicePublicKeyForTLS` ** (Facoltativo) Questa etichetta viene utilizzata per l'etichetta PKCS \$111 della chiave pubblica. Per i dispositivi con elementi sicuri o limitazioni hardware, questa avrà un'etichetta diversa per conservare AWS IoT le credenziali. Se il tuo dispositivo supporta il pre-provisioning con una chiave EC, fornisci questa etichetta. Quando PreProvisioned è impostato su **Yes** in`device.json`, è necessario fornire questa etichetta o entrambe. `pkcs11LabelPreProvisionedRSADevicePublicKeyForTLS` Questa etichetta può essere diversa da quella definita per i casi di bordo e di importazione. ** `pkcs11LabelPreProvisionedECDeviceCertificateForTLS` ** (Facoltativo) Questa etichetta viene utilizzata per l'etichetta PKCS \$111 del certificato del dispositivo. Per i dispositivi con elementi sicuri o limitazioni hardware, questa avrà un'etichetta diversa per conservare AWS IoT le credenziali. Se il tuo dispositivo supporta il pre-provisioning con una chiave EC, fornisci questa etichetta. Quando PreProvisioned è impostato su **Yes** in`device.json`, è necessario fornire questa etichetta o entrambe. `pkcs11LabelPreProvisionedRSADeviceCertificateForTLS` Questa etichetta può essere diversa da quella definita per i casi di bordo e di importazione. ** `pkcs11LabelPreProvisionedRSADevicePrivateKeyForTLS` ** (Facoltativo) Questa etichetta viene utilizzata per l'etichetta PKCS \$111 della chiave privata. Per i dispositivi con elementi sicuri o limitazioni hardware, questa avrà un'etichetta diversa per conservare AWS IoT le credenziali. Se il tuo dispositivo supporta il pre-provisioning con una chiave RSA, fornisci questa etichetta. Quando PreProvisioned è impostato su **Yes** in`device.json`, è necessario fornire questa etichetta o `pkcs11LabelPreProvisionedECDevicePrivateKeyForTLS` entrambe. ** `pkcs11LabelPreProvisionedRSADevicePublicKeyForTLS` ** (Facoltativo) Questa etichetta viene utilizzata per l'etichetta PKCS \$111 della chiave pubblica. Per i dispositivi con elementi sicuri o limitazioni hardware, questa avrà un'etichetta diversa per conservare AWS IoT le credenziali. Se il tuo dispositivo supporta il pre-provisioning con una chiave RSA, fornisci questa etichetta. Quando PreProvisioned è impostato su **Yes** in`device.json`, è necessario fornire questa etichetta o `pkcs11LabelPreProvisionedECDevicePublicKeyForTLS` entrambe. ** `pkcs11LabelPreProvisionedRSADeviceCertificateForTLS` ** (Facoltativo) Questa etichetta viene utilizzata per l'etichetta PKCS \$111 del certificato del dispositivo. Per i dispositivi con elementi sicuri o limitazioni hardware, questa avrà un'etichetta diversa per conservare AWS IoT le credenziali. Se il tuo dispositivo supporta il pre-provisioning con una chiave RSA, fornisci questa etichetta. Quando PreProvisioned è impostato su **Yes** in`device.json`, è necessario fornire questa etichetta o `pkcs11LabelPreProvisionedECDeviceCertificateForTLS` entrambe. ** `pkcs11LabelCodeVerifyKey` ** (Facoltativo) Questa etichetta viene utilizzata per l'etichetta PKCS \$111 della chiave di verifica del codice. Se il dispositivo dispone del supporto per l'archiviazione PKCS \$111 del certificato JITP, della chiave di verifica del codice e del certificato root, fornisci questa etichetta. Se `pkcs11JITPCodeVerifyRootCertSupport` in `device.json` è impostato su **Sì**, questa etichetta deve essere fornita. ** `pkcs11LabelJITPCertificate` ** (Facoltativo) Questa etichetta viene utilizzata per l'etichetta PKCS \$111 del certificato JITP. Se il dispositivo dispone del supporto per l'archiviazione PKCS \$111 del certificato JITP, della chiave di verifica del codice e del certificato root, fornisci questa etichetta. Se `pkcs11JITPCodeVerifyRootCertSupport` in `device.json` è impostato su **Sì**, questa etichetta deve essere fornita. # IDT per variabili FreerTOS I comandi per creare il codice e eseguire il flashing del dispositivo potrebbero richiedere connettività o altre informazioni sui dispositivi per funzionare correttamente. AWS IoT Device Tester consente di fare riferimento alle informazioni sul dispositivo in flash e di creare comandi utilizzando [JsonPath](https://goessner.net/articles/JsonPath/). Utilizzando JsonPath espressioni semplici, è possibile recuperare le informazioni richieste specificate nel `device.json` file. ## Variabili di percorso IDT per FreerTOS definisce le seguenti variabili di percorso che possono essere utilizzate nelle righe di comando e nei file di configurazione: ** `{{testData.sourcePath}}` ** Si estende al percorso del codice sorgente. Se utilizzi questa variabile, deve essere utilizzata sia nei comandi flash che di compilazione. ** `{{device.connectivity.serialPort}}` ** Si estende alla porta seriale. ** `{{device.identifiers[?(@.name == 'serialNo')].value[0]}}` ** Estende al numero seriale del dispositivo. ** `{{config.idtRootPath}}` ** Si espande fino al percorso principale. AWS IoT Device Tester # Interfaccia utente per IDT per la suite di qualificazione FreerTOS 2.0 (FRQ 2.0) AWS IoT Device Tester for FreerTOS (IDT for FreerTOS) include un'interfaccia utente (UI) basata sul Web in cui è possibile interagire con l'applicazione a riga di comando IDT e i relativi file di configurazione. Utilizzi l'interfaccia utente IDT for FreerTOS per creare una nuova configurazione o modificarne una esistente per il tuo dispositivo. Puoi anche usare l'interfaccia utente per chiamare l'applicazione IDT ed eseguire i test FreerTOS sul tuo dispositivo. Per informazioni su come utilizzare la riga di comando per eseguire i test di qualificazione, consulta. [Primo test della scheda del microcontrollore](lts-qual-steps.md) Questa sezione descrive i prerequisiti per l'interfaccia utente IDT for FreerTOS e come eseguire i test di qualificazione dall'interfaccia utente. **Topics** + [Imposta i prerequisiti IDT](#lts-dev-tester-ui-prereqs) + [Configura le AWS credenziali per utilizzare l'interfaccia utente IDT](lts-configure-aws-credentials.md) + [Apri l'interfaccia utente di IDT per FreerTOS](lts-open-idt-ui.md) + [Crea una nuova configurazione](lts-create-new-configuration.md) + [Modifica una configurazione esistente](lts-modify-existing-configuration.md) + [Esegui test di qualificazione](lts-run-tests-from-ui.md) ## Imposta i prerequisiti IDT Per eseguire i test tramite l'interfaccia utente AWS IoT Device Tester (IDT) for FreerTOS, è necessario completare i prerequisiti nella [Imposta i prerequisiti di qualificazione LTS](lts-idt-dev-tester-prereqs.md) pagina per IDT FreerTOS Qualification (FRQ) 2.x. # Configura le AWS credenziali per utilizzare l'interfaccia utente IDT Devi configurare le credenziali utente IAM per l' AWS utente in [Crea un account AWS](lts-idt-dev-tester-prereqs.md#lts-config-aws-account) cui hai creato. Puoi specificare le credenziali in uno dei due modi seguenti: + In un file di credenziali + Come variabili di ambiente ## Configura AWS le credenziali con un file di credenziali IDT usa lo stesso file delle credenziali di AWS CLI. Per ulteriori informazioni, consulta l'argomento relativo ai [file di configurazione e delle credenziali](https://docs.aws.amazon.com/cli/latest/userguide/cli-config-files.html). La posizione del file delle credenziali varia in base al sistema operativo utilizzato: + **macOS e Linux** — `~/.aws/credentials` + **Windows** – `C:\Users\UserName\.aws\credentials` Aggiungi AWS le tue credenziali al `credentials` file nel seguente formato: ``` [default] aws_access_key_id = your_access_key_id aws_secret_access_key = your_secret_access_key ``` **Nota** Se non utilizzi il `default` AWS profilo, devi specificare il nome del profilo nell'interfaccia utente di IDT per FreerTOS. Per ulteriori informazioni sui profili, consulta [Configurazione e impostazioni dei file di credenziali](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html). ## Configura AWS le credenziali con variabili di ambiente Le variabili di ambiente sono variabili gestite dal sistema operativo e utilizzate dai comandi di sistema. Non vengono salvati se si chiude la sessione SSH. L'interfaccia utente di IDT per FreerTOS utilizza le variabili di ambiente `AWS_SECRET_ACCESS_KEY` e per `AWS_ACCESS_KEY_ID` memorizzare le credenziali. AWS Per impostare queste variabili su Linux, macOS o Unix, utilizza **export**: ``` export AWS_ACCESS_KEY_ID=your_access_key_id export AWS_SECRET_ACCESS_KEY=your_secret_access_key ``` Per impostare queste variabili su Windows, utilizza **set**: ``` set AWS_ACCESS_KEY_ID=your_access_key_id set AWS_SECRET_ACCESS_KEY=your_secret_access_key ``` # Apri l'interfaccia utente di IDT per FreerTOS Questo argomento spiega come aprire l'interfaccia utente IDT for FreerTOS per utilizzare la suite di qualificazione FreeRTOS. **Per aprire l'interfaccia utente di IDT per FreerTOS** 1. Scarica una versione IDT per FreerTOS supportata. Quindi estrai l'archivio scaricato in una directory per la quale disponi delle autorizzazioni di lettura e scrittura. 1. Vai alla directory di installazione di IDT for FreerTOS: ``` cd devicetester-extract-location/bin ``` 1. Esegui il seguente comando per aprire l'interfaccia utente IDT per FreerTOS: ------ #### [ Linux ] ``` .devicetester_ui_linux_x86-64 ``` ------ #### [ Windows ] ``` ./devicetester_ui_win_x64-64 ``` ------ #### [ macOS ] ``` ./devicetester_ui_mac_x86-64 ``` **Nota** In macOS, per consentire al sistema di eseguire l'interfaccia utente, vai a **Preferenze di sistema -> Sicurezza e privacy**. Quando esegui i test, potrebbe essere necessario farlo altre tre volte. questo ------ L'interfaccia utente di IDT per FreerTOS si apre nel browser predefinito. Le ultime tre versioni principali dei seguenti browser supportano l'interfaccia utente: + Google Chrome + Mozilla Firefox + Microsoft Edge + Apple Safari per macOS **Nota** Per un'esperienza migliore, consigliamo Google Chrome o Mozilla Firefox per accedere all'interfaccia utente IDT per FreerTOS. Microsoft Internet Explorer non è supportato dall'interfaccia utente. **Importante** È necessario configurare le AWS credenziali prima di aprire l'interfaccia utente. Se non hai configurato le tue credenziali, chiudi la finestra del browser dell'interfaccia utente di IDT per FreerTOS, segui i passaggi indicati e poi riapri l'interfaccia utente di IDT per FreerTOS. [Configura le AWS credenziali per utilizzare l'interfaccia utente IDT](lts-configure-aws-credentials.md) # Crea una nuova configurazione Se sei un utente alle prime armi, devi creare una nuova configurazione per configurare i file di configurazione JSON richiesti da IDT for FreerTOS per eseguire i test. È quindi possibile eseguire test o modificare la configurazione creata. Per esempi dei `userdata.json` file, e`config.json`,`device.json`,,,,,,, vedi[Primo test della scheda del microcontrollore](lts-qual-steps.md). **Per creare una nuova configurazione** 1. **Nell'interfaccia utente di IDT per FreerTOS, apri il menu di navigazione e scegli Crea nuova configurazione.** ![\[Interfaccia Device Tester per FreerTOS con pulsante «Crea nuova configurazione» e informazioni sull'autotest automatico dei microcontrollori.\]](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/gsg-create-configuration.png) 1. Segui la procedura guidata di configurazione per accedere alle impostazioni di configurazione IDT utilizzate per eseguire i test di qualificazione. La procedura guidata configura le seguenti impostazioni nei file di configurazione JSON che si trovano nella directory. `devicetester-extract-location/config` + **Impostazioni del dispositivo: le impostazioni** del pool di dispositivi per i dispositivi da testare. Queste impostazioni sono configurate nei `sku` campi `id` and e il blocco dei **dispositivi** per il pool di dispositivi contenuto nel `config.json` file. ![\[Schermata di configurazione di Device Tester for FreerTOS con campi Identifier e SKU per la configurazione di un pool di dispositivi, opzioni di impostazione del dispositivo come metodo di connettività, key provisioning, impostazioni PKCS #11, campi di immissione dei dettagli del dispositivo e controlli per aggiungere dispositivi o identificatori.\]](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/gsg-device-settings.png) + **AWS impostazioni dell'account** — Le Account AWS informazioni che IDT for FreerTOS utilizza per AWS creare risorse durante le esecuzioni dei test. Queste impostazioni sono configurate nel file. `config.json` ![\[Account AWS pagina delle impostazioni con campi per la regione dell'account, la posizione delle credenziali come file o ambiente e il nome del profilo\]](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/gsg-account-settings.png) + Implementazione **FreerTOS**: il percorso assoluto verso il repository FreerTOS e il codice portato e la versione di FreeRTOS su cui vuoi eseguire IDT FRQ. I percorsi dei file di intestazione di esecuzione e configurazione dei parametri dal repository. `FreeRTOS-Libraries-Integration-Tests` GitHub I comandi build e flash per l'hardware che consentono a IDT di creare ed eseguire test sulla scheda in modo automatico. Queste impostazioni sono configurate nel `userdata.json` file. ![\[Sezione di configurazione dell'implementazione di FreerTOS con percorsi di repository, percorsi di esecuzione dei test, versione di FreeRTOS, dettagli dello strumento di compilazione e impostazioni dello strumento flash.\]](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/gsg-implementation-settings.png) + Etichette **PKCS \$111 e server Echo: le etichette** [PKCS \$111](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting-pkcs.html) che corrispondono alle chiavi fornite nell'hardware in base alla funzionalità delle chiavi e al metodo di fornitura delle chiavi. Le impostazioni di configurazione del server echo per i test dell'interfaccia di trasporto. Queste impostazioni sono configurate nei `device.json` file `userdata.json` and. ![\[Etichette PKCS #11 e configurazioni del server Echo con campi di input per le etichette delle chiavi, il metodo di generazione delle chiavi e il numero di porta del server\]](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/gsg-pkcs11-settings.png) + **Over-the-air Aggiornamenti (OTA)**: le impostazioni che controllano i test di funzionalità OTA. Queste impostazioni sono configurate nel `features` blocco dei `userdata.json` file `device.json` and. ![\[Opzioni di configurazione dell'aggiornamento OTA: skip test, protocolli dati, percorsi firmware, percorso certificato PAL, firma del codice, hash/sign algoritmi, certificati firmatari, file di certificato trusted/untrusted firmatario, compilazione del certificato firmatario, piattaforma firmatario.\]](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/gsg-ota-settings.png) 1. Nella pagina di revisione, verifica le informazioni di **configurazione**. ![\[Finestra di dialogo di configurazione creata per Device Tester for FreerTOS, che mostra i dettagli sulla creazione di una nuova configurazione di test con opzioni per modificare o eseguire test.\]](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/gsg-configuration-created.png) **Dopo aver terminato la revisione della configurazione, per eseguire i test di qualificazione, scegli Esegui test.** # Modifica una configurazione esistente Se hai già configurato i file di configurazione per IDT per FreerTOS, puoi usare l'interfaccia utente IDT for FreerTOS per modificare la configurazione esistente. I file di configurazione esistenti devono trovarsi nella directory. `devicetester-extract-location/config` **Per modificare una configurazione** 1. **Nell'interfaccia utente di IDT per FreerTOS, apri il menu di navigazione e scegli Modifica configurazione esistente.** La dashboard di configurazione mostra informazioni sulle impostazioni di configurazione esistenti. Se una configurazione è errata o non disponibile, lo stato di tale configurazione è`Error validating configuration`. ![\[Schermata di configurazione con le sezioni relative al dispositivo Account AWS, all'implementazione di FreerTOS, alle etichette PKCS e al server echo over-the-air, agli aggiornamenti e alle impostazioni di esecuzione del test che mostrano lo stato valido.\]](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/modify-existing-configuration.png) 1. Per modificare un'impostazione di configurazione esistente, completa i seguenti passaggi: 1. Scegli il nome di un'impostazione di configurazione per aprire la relativa pagina delle impostazioni. 1. Modifica le impostazioni, quindi scegli **Salva** per rigenerare il file di configurazione corrispondente. 1. Per modificare le impostazioni di esecuzione del test IDT per FreerTOS, **scegli le impostazioni di esecuzione del test IDT nella vista di** modifica: ![\[Finestra di dialogo delle impostazioni di esecuzione del test IDT con opzioni per la selezione del test, il salto dei gruppi di test, il moltiplicatore di timeout e l'interruzione al primo errore.\]](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/idt-testrun-settings.png) Dopo aver modificato la configurazione, verifica che tutte le impostazioni di configurazione superino la convalida. Se lo stato di ogni impostazione di configurazione è`Valid`, puoi eseguire i test di qualificazione con questa configurazione. # Esegui test di qualificazione Dopo aver creato una configurazione per l'interfaccia utente IDT per FreerTOS, puoi eseguire i test di qualificazione. **Per eseguire test di qualificazione** 1. Nel menu di navigazione, scegli **Esegui test**. 1. Scegli **Avvia test** per iniziare l'esecuzione del test. Per impostazione predefinita, vengono eseguiti tutti i test applicabili per la configurazione del dispositivo. IDT for FreerTOS genera un rapporto di qualificazione al termine di tutti i test. ![\[L'interfaccia Device Tester per FreerTOS non mostra ancora alcun test eseguito, con opzioni per creare una nuova configurazione, modificare la configurazione esistente ed eseguire test.\]](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/idt-run-tests.png) IDT for FreerTOS esegue i test di qualificazione. **Visualizza quindi il riepilogo dei test eseguiti e gli eventuali errori nella console Test runner.** Al termine dell'esecuzione del test, è possibile visualizzare i risultati e i registri del test dalle seguenti posizioni: + I risultati dei test si trovano nella `devicetester-extract-location/results/execution-id` directory. + I registri dei test si trovano nella `devicetester-extract-location/results/execution-id/logs` directory. Per ulteriori informazioni sui risultati e sui registri dei test, vedere [Visualizza l'IDT gratuitamente RTOSresults](view-results-lts.md) e. [Visualizza l'IDT gratuitamente RTOSlogs](view-logs-lts.md) ![\[Registro di esecuzione di Device Tester for FreerTOS che mostra i test superati, i gruppi di test e i percorsi dei file per log e report.\]](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/idt-results.png) # Esegui la suite di qualificazione FreerTOS 2.0 Usa l'eseguibile AWS IoT Device Tester for FreerTOS per interagire con IDT for FreerTOS. Gli esempi della riga di comando seguenti illustrano come eseguire i test di qualifica per un pool di dispositivi (serie di dispositivi identici). ------ #### [ 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 ``` Esegue una suite di test in un determinato pool di dispositivi. Il file `userdata.json` si deve trovare nella directory `devicetester_extract_location/devicetester_freertos_[win|mac|linux]/configs/`. **Nota** Se stai usando IDT for FreerTOS su Windows, usa le barre (/) per specificare il percorso del file. `userdata.json` Utilizza il comando seguente per eseguire un gruppo di test specifico: ``` devicetester_[linux | mac | win] run-suite \ --suite-id FRQ_1.99.0 \ --group-id group-id \ --pool-id pool-id \ --userdata userdata.json ``` I parametri `suite-id` e `pool-id` sono facoltativi se esegui una singola suite di test su un singolo pool di dispositivi (ovvero nel tuo file `device.json` c'è un solo pool di dispositivi definito). Utilizza il comando seguente per eseguire un caso di test specifico in un gruppo di test: ``` devicetester_[linux | mac | win_x86-64] run-suite \ --group-id group-id \ --test-id test-id ``` Puoi utilizzare il comando `list-test-cases` per elencare i casi di test in un gruppo di test. **IDT per le opzioni della riga di comando di FreerTOS** **group-id** (Facoltativo) I gruppi di test da eseguire, come elenco con valori separati da virgole. Se non specificato, IDT esegue tutti i gruppi di test nella suite di test. **pool-id** (Facoltativo) Il pool di dispositivi da testare. Questo è necessario se si definiscono più pool di dispositivi in `device.json`. Se hai un solo pool di dispositivi, questa opzione può essere omessa. **suite-id** (Facoltativo) Versione della suite di test da eseguire. Se non specificato, IDT utilizza la versione più recente nella directory dei test del sistema. **test-id** (Facoltativo) I test da eseguire, come elenco con valori separati da virgole. Se specificato, `group-id` deve includere un singolo gruppo. **Example** ``` devicetester_[linux | mac | win_x86-64] run-suite --group-id FreeRTOSVersion --test-id FreeRTOSVersion ``` **h** Utilizza l'opzione di aiuto per ulteriori informazioni sulle opzioni `run-suite`. **Example** **Esempio** ``` devicetester_[linux | mac | win_x86-64] run-suite -h ``` ------ ## Comandi IDT per FreerTOS Il comando IDT for FreerTOS supporta le seguenti operazioni: ------ #### [ IDT v4.5.2 and later ] ** `help` ** Elenca le informazioni sul comando specificato. ** `list-groups` ** Elenca i gruppi in una determinata suite. ** `list-suites` ** Elenca le suite disponibili. ** `list-supported-products` ** Elenca i prodotti e le versioni della suite di test supportati. ** `list-supported-versions` ** Elenca le versioni di FreerTOS e della suite di test supportate dalla versione IDT corrente. ** `list-test-cases` ** Elenca i casi di test in un gruppo specificato. ** `run-suite` ** Esegue una suite di test in un determinato pool di dispositivi. Utilizza l'opzione `--suite-id` per specificare una versione della suite di test oppure omettila per utilizzare la versione più recente nel sistema. Utilizza `--test-id` per eseguire un singolo caso di test. **Example** ``` devicetester_[linux | mac | win_x86-64] run-suite --group-id FreeRTOSVersion --test-id FreeRTOSVersion ``` A partire da IDT v3.0.0, IDT controlla online le suite di test più recenti. Per ulteriori informazioni, consulta [Versioni della suite di test](idt-test-suite-versions.md). ------ # Visualizza l'IDT gratuitamente RTOSresults Durante l'esecuzione, IDT scrive gli errori nella console, i file di log e i report di test. Al termine della suite di test di qualifica, IDT scrive un riepilogo dell'esecuzione dei test nella console e genera due report di test. Questi report sono disponibili in `devicetester-extract-location/results/execution-id/`. Entrambi i report acquisiscono i risultati dall'esecuzione della suite di test di qualifica. `awsiotdevicetester_report.xml`È il rapporto del test di qualificazione che invii AWS per inserire il tuo dispositivo nel AWS Partner Device Catalog. Il report contiene i seguenti elementi: + La versione IDT per FreerTOS. + La versione di FreerTOS che è stata testata. + Le funzionalità di FreerTOS supportate dal dispositivo in base ai test superati. + Il codice SKU e il nome del dispositivo specificato nel file `device.json`. + Le caratteristiche del dispositivo specificato nel file `device.json`. + Il riepilogo aggregato dei risultati dei casi di test. + Un'analisi dei risultati dei casi di test suddivisi per le librerie sottoposte a test in base alle caratteristiche del dispositivo. `FRQ_Report.xml`Si tratta di un report in [JUnit formato XML](https://llg.cubic.org/docs/junit/) standard. Puoi integrarlo in CI/CD piattaforme come [Jenkins](https://jenkins.io/), [Bamboo](https://www.atlassian.com/software/bamboo) e così via. Il report contiene i seguenti elementi: + Un riepilogo aggregato dei risultati dei casi di test. + Un'analisi dei risultati dei casi di test suddivisi per le librerie sottoposte a test in base alle caratteristiche del dispositivo. # Interpreta i risultati di IDT for FreerTOS La sezione dei report in `awsiotdevicetester_report.xml` o `FRQ_Report.xml` elenca i risultati dei test eseguiti. Il primo tag XML `` contiene il riepilogo complessivo dell'esecuzione dei test. Esempio: `` **Attributi utilizzati nel `` tag** ** `name` ** Il nome della suite di test. ** `time` ** Il tempo, espresso in secondi, impiegato per eseguire la suite di qualifica. ** `tests` ** Il numero dei casi di test eseguiti. ** `failures` ** Il numero dei casi di test eseguiti ma non superati. ** `errors` ** Il numero di casi di test che IDT for FreerTOS non è riuscito a eseguire. ** `disabled` ** Questo attributo non è utilizzato e si può ignorare. Se non ci sono guasti o errori nel test case, il tuo dispositivo soddisfa i requisiti tecnici per eseguire FreerTOS e può interagire con i servizi. AWS IoT Se scegli di inserire il tuo dispositivo nel AWS Partner Device Catalog, puoi utilizzare questo rapporto come prova di idoneità. In caso di esiti negativi o errori nei casi di test, puoi identificare il caso di test non riuscito esaminando i tag XML ``. I tag XML `` all'interno del tag `` mostrano il riepilogo dei risultati dei casi di test per un gruppo di test. `` Il formato è simile al tag ``, ma con un attributo denominato `skipped` che non viene utilizzato e si può ignorare. All'interno di ogni tag XML `` ci sono tag `` per ciascuno dei casi di test eseguiti per un gruppo di test. Esempio: `` **Attributi utilizzati nel tag ``** ** `name` ** Il nome del prodotto sottoposto a test. ** `version` ** La versione del prodotto sottoposto a test. ** `features` ** Le caratteristiche convalidate. Le caratteristiche contrassegnate come `required` sono necessarie per inviare la scheda per la qualifica. Il seguente frammento mostra come appare nel `awsiotdevicetester_report.xml` file. ``` ``` Caratteristiche contrassegnate come `optional` non sono necessarie per la qualifica. I seguenti snippet mostrano caratteristiche facoltative. ``` ``` Se non si verificano errori o errori nei test per le funzionalità richieste, il dispositivo soddisfa i requisiti tecnici per eseguire FreerTOS e può interagire con i servizi. AWS IoT Se desideri inserire il tuo dispositivo nel [AWS Partner Device Catalog](https://partners.amazonaws.com/qualified-devices), puoi utilizzare questo rapporto come prova di idoneità. In caso di esiti negativi o errori nei test, puoi identificare il test non riuscito esaminando i tag XML ``. I tag XML `` all'interno del tag `` mostrano il riepilogo dei risultati dei test per un gruppo di test. Esempio: ``` ``` Il formato è simile al `` tag, ma ha un `skipped` attributo che non viene utilizzato e può essere ignorato. All'interno di ogni tag XML `` ci sono tag `` per ciascuno dei test eseguiti per un gruppo di test. Esempio: ``` ``` **Attributi utilizzati nel tag ``** ** `name` ** Il nome del caso di test. ** `attempts` ** Il numero di volte in cui IDT per FreerTOS ha eseguito il test case. Quando un test non riesce o si verifica un errore, i tag `` o `` vengono aggiunti al tag `` con informazioni per la risoluzione dei problemi. Esempio: ``` Reason for the test case failure Reason for the test case execution error ``` Per ulteriori informazioni, consulta [Risoluzione degli errori](dt-afr-troubleshooting.md). # Visualizza l'IDT gratuitamente RTOSlogs Puoi trovare i log che IDT for FreerTOS genera dall'esecuzione del test in. `devicetester-extract-location/results/execution-id/logs` Vengono generate due serie di log: + `test_manager.log` Contiene i log generati da IDT per FreerTOS (ad esempio, la configurazione relativa ai log e la generazione di report). + `test_group_id/test_case_id/test_case_id.log` Il file di log per un caso di test, incluso l'output dal dispositivo sottoposto a test. Il file di log viene denominato in base al gruppo di test e al caso di test che è stato eseguito.