Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # IDT con el conjunto de calificación FreeRTOS 2.0 (FRQ 2.0) El conjunto de calificación FreeRTOS 2.0 es una versión actualizada del conjunto de calificación FreeRTOS. Recomendamos a los desarrolladores que utilicen FRQ 2.0 porque está formado por casos de prueba relevantes para calificar los dispositivos que ejecutan las bibliotecas de soporte a largo plazo (LTS) de FreeRTOS. IDT for FreeRTOS verifica el puerto de FreeRTOS del microcontrolador y si se comunica eficazmente con él. AWS IoT En concreto, verifica las interfaces de la capa de portabilidad de las bibliotecas de FreeRTOS y si los repositorios de pruebas de FreeRTOS se implementan correctamente. También realiza pruebas con. end-to-end AWS IoT Core[Las pruebas ejecutadas por IDT para FreeRTOS se definen en el repositorio FreeRTOS. GitHub](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests) IDT para FreeRTOS ejecuta las pruebas como aplicaciones integradas que se instalan en el dispositivo microcontrolador que se está probando. Las imágenes binarias de la aplicación incluyen FreeRTOS, las interfaces de FreeRTOS transferidas y los controladores de dispositivos de la placa. El objetivo de las pruebas es verificar el correcto funcionamiento de las interfaces de FreeRTOS transferidas sobre los controladores de dispositivos. IDT for FreeRTOS genera informes de pruebas que puede enviar AWS IoT para que su hardware aparezca en AWS el catálogo de dispositivos asociados. Para obtener más información, consulte el [Programa de Calificación de Dispositivos de AWS](https://aws.amazon.com/partners/dqp/). IDT para FreeRTOS se ejecuta en un equipo host (Windows, macOS o Linux) que esté conectado al dispositivo que se está probando. IDT configura y orquesta los casos de prueba y agrega los resultados. También proporciona una interfaz de línea de comandos para administrar la ejecución de las pruebas. Para probar su dispositivo, IDT for FreeRTOS crea recursos AWS IoT como cosas, grupos de FreeRTOS o funciones Lambda. Para crear estos recursos, IDT for FreeRTOS utiliza las credenciales configuradas en AWS el para realizar llamadas a `config.json` la API en su nombre. Estos recursos se aprovisionarán en distintos momentos durante una prueba. Cuando se ejecuta IDT para FreeRTOS en su equipo host, realiza los siguientes pasos: 1. Carga y valida su dispositivo y la configuración de credenciales. 1. Realiza pruebas seleccionadas con los recursos locales y de la nube necesarios. 1. Depura los recursos locales y de la nube. 1. Genera informes de pruebas que indican si la placa supera las pruebas necesarias para la cualificación. # Configurar los requisitos previos de calificación LTS En esta sección se describen los requisitos previos para probar microcontroladores con. AWS IoT Device Tester ## Preparación para la calificación de FreeRTOS **nota** AWS IoT Device Tester for FreeRTOS recomienda encarecidamente utilizar el último parche de la versión más reciente de FreerTOS-LTS. IDT para FRQ 2.0 es una calificación para FreeRTOS. Antes de ejecutar IDT FRQ 2.0 para la calificación, debe completar el proceso de [Calificación de su placa](https://docs.aws.amazon.com/freertos/latest/qualificationguide/freertos-qualification.html) que se indica en la *Guía de calificación de FreeRTOS*. Para realizar la portabilidad de bibliotecas, probarlas y configurar `manifest.yml`, consulte [Portabilidad de las bibliotecas de FreeRTOS](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting.html) en la *Guía de portabilidad de FreeRTOS*. FRQ 2.0 contiene un proceso diferente para la calificación. Consulte [Últimos cambios en la calificación](https://docs.aws.amazon.com/freertos/latest/qualificationguide/latest-changes.html) en la *Guía de calificación de FreeRTOS* para obtener más información. El repositorio [FreeRTOS-Libraries-Integration-Tests](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests) debe estar presente para que IDT se ejecute. Consulta el [archivo README.md](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests/blob/main/README.md) para saber cómo clonar y portar este repositorio a tu proyecto fuente. FreeRTOS-Libraries-Integration-Testsdebe incluir el que `manifest.yml` se encuentra en la raíz de su proyecto para que IDT se ejecute. **nota** IDT depende de la implementación de `UNITY_OUTPUT_CHAR` del repositorio de pruebas. Los registros de salida de la prueba y los registros del dispositivo no deben intercalarse entre sí. Consulte [ Implementación de macros de registro de bibliotecas](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-library-logging-macros.html) en la *Guía de portabilidad de FreeRTOS* para obtener más detalles. ## Descarga de IDT para FreeRTOS Cada versión de FreeRTOS tiene una versión correspondiente de IDT para FreeRTOS para realizar pruebas de calificación. Descargue la versión adecuada de IDT para FreeRTOS [desde las versiones AWS IoT Device Tester compatibles de](https://docs.aws.amazon.com/freertos/latest/userguide/dev-test-versions-afr.html) FreeRTOS. Extraiga IDT para FreeRTOS en una ubicación del sistema de archivos en la que tenga permisos de lectura y escritura. Dado que Microsoft Windows tiene un límite de caracteres para la longitud de la ruta de acceso, extraiga IDT para FreeRTOS en un directorio raíz, como `C:\` o `D:\`. **nota** Varios usuarios no pueden ejecutar IDT desde una ubicación compartida, como un directorio NFS o una carpeta compartida de red de Windows. Esto dará lugar a bloqueos o daños en los datos. Le recomendamos que extraiga el paquete IDT a una unidad local. ## Descarga de Git IDT debe tener Git instalado como requisito previo para garantizar la integridad del código fuente. Sigue las instrucciones de la [GitHub](https://github.com/git-guides/install-git)guía para instalar Git. Para verificar la versión actual de Git instalada, introduzca el comando `git --version` en el terminal. **aviso** IDT usa Git para alinearse con el estado de un directorio, limpio o sucio. Si Git no está instalado, los grupos de pruebas de `FreeRTOSIntegrity` fallarán o no se ejecutarán como se espera. Si IDT devuelve un error, como `git executable not found` o `git command not found`, instale o vuelva a instalar Git e inténtelo de nuevo. **Topics** + [Preparación para la calificación de FreeRTOS](#idt-preparing-qualification) + [Descarga de IDT para FreeRTOS](#idt-download-dev-tester-afr) + [Descarga de Git](#idt-download-git) + [Crea una AWS cuenta](#lts-config-aws-account) + [AWS IoT Device Tester política gestionada](#managed-policy) + [(Opcional) Instale el AWS Command Line Interface](#install-cli) ## Crea una AWS cuenta **nota** El conjunto completo de calificaciones de IDT solo es compatible con los siguientes Regiones de AWS Este de EE. UU. (Norte de Virginia) Oeste de EE. UU. (Oregón) Asia-Pacífico (Tokio) Europa (Irlanda) Para probar su dispositivo, IDT for FreeRTOS crea recursos AWS IoT como cosas, grupos de FreeRTOS y funciones Lambda. Para crear esos recursos, IDT para FreeRTOS requiere que cree y configure AWS una cuenta y una política de IAM que conceda permiso a IDT for FreeRTOS para acceder a los recursos en su nombre mientras se ejecutan las pruebas. Los siguientes pasos son para crear y configurar su cuenta. AWS 1. Si ya tienes una AWS cuenta, pasa al paso siguiente. O bien, cree una [cuenta de AWS](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/). 1. Siga los pasos que se indican en [ Creación de roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html). No añada permisos ni políticas en este momento. 1. Para ejecutar pruebas de calificación OTA, vaya al paso 4. De lo contrario, vaya al paso 5. 1. Asocie la política en línea de permisos de IAM de OTA a su rol de IAM. 1. **importante** La siguiente plantilla de política concede permiso a IDT para crear roles, crear políticas y asociar políticas a roles. IDT para FreeRTOS utiliza estos permisos para las pruebas que crean roles. Si bien la plantilla de política no proporciona privilegios de administrador al usuario, los permisos se pueden usar para obtener acceso de administrador a su AWS cuenta. 1. Siga estos pasos para asociar los permisos necesarios a su rol de IAM: 1. En la pestaña **Permisos**, seleccione **Añadir permisos**. 1. Elija **Crear política insertada**. 1. Elija la pestaña **JSON** y copie los siguientes permisos en el cuadro de texto **JSON**. Utilice la plantilla que aparece en **La mayoría de las regiones** si no se encuentra en la región de China. Si se encuentra en la región de China, utilice la plantilla que aparece en **Regiones de Pekín y 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 ] La siguiente plantilla de política se puede utilizar en las regiones de Pekín y Ningxia. ------ 1. Cuando haya terminado, elija **Review policy (Revisar política)**. 1. **IDTFreeRTOSIAMPermissions**Introdúzcalo como nombre de la política. 1. Elija **Crear política**. 1. Adjunte **AWSIoTDeviceTesterForFreeRTOSFullAccess** a su función de IAM. 1. Para asociar los permisos necesarios a su rol de IAM: 1. En la pestaña **Permisos**, seleccione **Añadir permisos**. 1. Seleccione **Asociar políticas**. 1. Busque la política de **AWSIoTDeviceTesterForFreeRTOSFullacceso**. Marque la casilla. 1. Elija **Añadir permisos**. 1. Exporte las credenciales para IDT. Consulte [Obtención de credenciales de rol de IAM para el acceso a la CLI](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html) para obtener más información. ## AWS IoT Device Tester política gestionada La política `AWSIoTDeviceTesterForFreeRTOSFullAccess` administrada contiene los siguientes AWS IoT Device Tester permisos para la verificación de versiones, las funciones de actualización automática y la recopilación de métricas. + `iot-device-tester:SupportedVersion` Otorga AWS IoT Device Tester permiso para obtener la lista de productos, conjuntos de pruebas y versiones de IDT compatibles. + `iot-device-tester:LatestIdt` Otorga AWS IoT Device Tester permiso para obtener la última versión de IDT disponible para su descarga. + `iot-device-tester:CheckVersion` Otorga AWS IoT Device Tester permiso para comprobar la compatibilidad de las versiones de IDT, los conjuntos de pruebas y los productos. + `iot-device-tester:DownloadTestSuite` Otorga AWS IoT Device Tester permiso para descargar las actualizaciones del conjunto de pruebas. + `iot-device-tester:SendMetrics` Otorga AWS permiso para recopilar métricas sobre el uso AWS IoT Device Tester interno. ## (Opcional) Instale el AWS Command Line Interface Es posible que prefiera utilizar el AWS CLI para realizar algunas operaciones. Si no tiene la AWS CLI instalada, siga las instrucciones que se indican en [Instalación de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html). Configure AWS CLI la AWS región que desee utilizar ejecutándola **aws configure** desde una línea de comandos. Para obtener información sobre las AWS regiones que admiten IDT para FreeRTOS, [AWS consulte Regiones](https://docs.aws.amazon.com/general/latest/gr/rande.html#amazon-freertos-ota-control) y puntos finales. Para obtener más información sobre **aws configure**, consulte [ Configuración rápida con **aws configure**](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config). # Primera prueba de su placa de microcontrolador Puede usar IDT para FreeRTOS para probar la implementación de las bibliotecas FreeRTOS. Una vez que haya portado las bibliotecas de FreeRTOS a los controladores de dispositivo de su placa, utilícelas AWS IoT Device Tester para ejecutar las pruebas de calificación en la placa del microcontrolador. ## Añadir capas de portabilidad de bibliotecas Para realizar la portabilidad de FreeRTOS para su dispositivo, consulte la [Guía de portabilidad de FreeRTOS](https://docs.aws.amazon.com/freertos/latest/portingguide/porting-guide.html). Al implementar el repositorio de pruebas de FreeRTOS y realizar la portabilidad de las capas de FreeRTOS, debe proporcionar un `manifest.yml` con las rutas a cada biblioteca, incluido el repositorio de pruebas. Este archivo se ubicará en el directorio raíz de su código fuente. Consulte las [instrucciones del archivo de manifiesto](https://docs.aws.amazon.com/freertos/latest/qualificationguide/afq-checklist-manifest-instr.html) para obtener más información. ## Configura tus AWS credenciales para AWS IoT Device Tester comunicarte con la nube AWS Debe configurar sus AWS credenciales para AWS IoT Device Tester poder comunicarse con la AWS nube. Para obtener más información, consulte [Configuración de credenciales y regiones de AWS para desarrollo](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html). Las AWS credenciales válidas se especifican en el archivo `devicetester_extract_location/devicetester_freertos_[win|mac|linux]/configs/config.json` de configuración. ``` "auth": { "method": "environment" } "auth": { "method": "file", "credentials": { "profile": "" } } ``` El `auth` atributo del `config.json` archivo tiene un campo de método que controla la AWS autenticación y se puede declarar como archivo o entorno. Al configurar el campo como entorno, se extraen AWS las credenciales de las variables de entorno de la máquina host. Al configurar el campo en un archivo, se importa un perfil específico del archivo de configuración `.aws/credentials`. **Topics** + [Añadir capas de portabilidad de bibliotecas](#lts-add-port-layer) + [Configura tus AWS credenciales para AWS IoT Device Tester comunicarte con la nube AWS](#lts-cfg-aws-afr) + [Creación de un grupo de dispositivos en IDT para FreeRTOS](lts-cfg-dt-dp.md) + [Configurar ajustes de Build, Flash y Test](lts-cfg-dt-ud.md) # Creación de un grupo de dispositivos en IDT para FreeRTOS Los dispositivos que se vayan a probar se organizan en grupos de dispositivos. Cada grupo de dispositivos se compone de uno o varios dispositivos idénticos. Puede configurar IDT para FreeRTOS para probar un solo dispositivo o varios dispositivos de un grupo. Para acelerar el proceso de calificación, IDT para FreeRTOS puede probar en paralelo dispositivos con la misma especificación. Utiliza un método de turnos rotativos para ejecutar un grupo de pruebas diferentes en todos los dispositivos de un grupo de dispositivos. El archivo `device.json` tiene una matriz en su nivel superior. Cada atributo de la matriz es un nuevo grupo de dispositivos. Cada grupo de dispositivos tiene un atributo de matriz de dispositivos, que tiene varios dispositivos declarados. En la plantilla, hay un grupo de dispositivos y solo un dispositivo en ese grupo de dispositivos. Puede añadir uno o varios dispositivos a un grupo de dispositivos editando la sección `devices` de la plantilla `device.json` en la carpeta `configs`. **nota** Todos los dispositivos del mismo grupo deben tener la misma especificación técnica y SKU. Para habilitar las compilaciones en paralelo del código fuente para diferentes grupos de prueba, IDT para FreeRTOS copia el código fuente en una carpeta de resultados dentro de la carpeta extraída de IDT para FreeRTOS. Debe hacer referencia a la ruta del código fuente en el comando build o flash con la variable `testdata.sourcePath`. IDT para FreeRTOS reemplaza esta variable con una ruta temporal del código fuente copiado. Para obtener más información, consulte [Variables de IDT para FreeRTOS](lts-dt-vars.md). A continuación se muestra un ejemplo de un archivo `device.json` utilizado para crear un grupo de dispositivos con varios dispositivos. ``` [ { "id": "pool-id", "sku": "sku", "features": [ { "name": "Wifi", "value": "Yes | No" }, { "name": "Cellular", "value": "Yes | No" }, { "name": "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" } ] } ] } ] ``` En el archivo `device.json` se utilizan los siguientes atributos: ** `id` ** Un ID alfanumérico definido por el usuario que identifica de manera exclusiva a un grupo de dispositivos. Los dispositivos que pertenecen a un grupo deben ser del mismo tipo. Cuando se ejecuta un conjunto de pruebas, los dispositivos del grupo se utilizan para paralelizar la carga de trabajo. ** `sku` ** Un valor alfanumérico que identifica de forma única la placa que está probando. El SKU se utiliza para realizar un seguimiento de placas cualificadas. Si quieres incluir tu placa en el catálogo de dispositivos AWS asociados, la SKU que especifiques aquí debe coincidir con la que utilizaste en el proceso de publicación. ** `features` ** Una matriz que contiene las funciones compatibles del dispositivo. AWS IoT Device Tester utiliza esta información para seleccionar las pruebas de calificación que se van a ejecutar. Los valores admitidos son: ** `Wifi` ** Indica si la placa tiene capacidades Wi-Fi. ** `Cellular` ** Indica si la placa tiene capacidad móvil. ** `PKCS11` ** Indica el algoritmo de criptografía de clave pública que admite la placa. PKCS11 es obligatorio para obtener la calificación. Los valores admitidos son `ECC`, `RSA` y `Both`. `Both` indica que la placa admite `ECC` y `RSA`. ** `KeyProvisioning` ** Indica el método para escribir un certificado de cliente X.509 de confianza en la placa. Los valores válidos son `Import`, `Onboard`, `Both` y `No`. Se requiere el aprovisionamiento de las claves `Onboard`, `Both` o `No` para la calificación. La opción `Import` por sí sola no es válida para la calificación. + Utilice `Import` solo si su placa permite la importación de claves privadas. `Import`La selección no es una configuración válida para la calificación y solo debe usarse con fines de prueba, específicamente en casos de PKCS11 prueba. `Onboard`, `Both` o `No` se requiere para obtener la calificación. + Utilice `Onboard` si la placa admite claves privadas integradas (por ejemplo, si su dispositivo tiene un elemento seguro o si prefiere generar su propio par de claves de dispositivo y certificado). Procure añadir un elemento `secureElementConfig` en cada una de las secciones del dispositivo e introduzca la ruta absoluta del archivo de claves públicas en el campo `publicKeyAsciiHexFilePath`. + Utilice `Both` si la placa admite tanto la importación de claves privadas como la generación de claves integradas para el aprovisionamiento de claves. + Utilice `No` si la placa no admite el aprovisionamiento de claves. `No` solo es una opción válida cuando el dispositivo también está aprovisionado previamente. ** `OTA` ** Indica si su placa admite la funcionalidad de actualización over-the-air (OTA). El atributo `OtaDataPlaneProtocol` indica qué protocolo de plano de datos de OTA admite el dispositivo. Para la calificación, se necesita OTA con el protocolo de plano de datos HTTP o MQTT. Para omitir la ejecución de pruebas OTA durante las pruebas, defina la característica OTA en `No` y el atributo `OtaDataPlaneProtocol` en `None`. No se tratará de una ejecución de calificación. ** `BLE` ** Indica si la placa admite Bluetooth de bajo consumo (BLE). ** `devices.id` ** Un identificador único y definido por el usuario para el dispositivo que se está probando. ** `devices.connectivity.serialPort` ** El puerto de serie del equipo host utilizado para conectarse a los dispositivos que se van a probar. ** `devices.secureElementConfig.PublicKeyAsciiHexFilePath` ** Es obligatorio si la placa no está `pre-provisioned` o si no se proporciona `PublicDeviceCertificateArn`. Dado que `Onboard` es un tipo de aprovisionamiento de claves obligatorio, este campo es actualmente obligatorio para el grupo de pruebas de FullTransportInterface TLS. Si su dispositivo está `pre-provisioned`, `PublicKeyAsciiHexFilePath` es opcional y no es necesario incluirlo. El bloque siguiente es una ruta absoluta al archivo que contiene la clave pública de bytes hexadecimales extraída de la clave 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 ``` Si la clave pública tiene el formato .der, puede codificar directamente la clave pública en formato hexadecimal para generar el archivo hexadecimal. Para generar el archivo hexadecimal a partir de una clave pública .der, introduzca el siguiente comando **xxd**: ``` xxd -p pubkey.der > outFile ``` Si su clave pública tiene el formato .pem, puede extraer los encabezados y pies de página codificados en base64 y decodificarlos en formato binario. A continuación, realice la codificación hexadecimal de la cadena binaria para generar el archivo hexadecimal. Para generar un archivo hexadecimal para una clave pública .pem, realice lo siguiente: 1. Ejecute el siguiente comando **base64** para eliminar el encabezado y el pie de página en base64 de la clave pública. A continuación, la clave decodificada, denominada `base64key`, se envía al archivo `pubkey.der`: ``` base64 —decode base64key > pubkey.der ``` 1. Ejecute el siguiente comando **xxd** para convertir `pubkey.der` a formato hexadecimal. La clave resultante se guarda como `outFile`. ``` xxd -p pubkey.der > outFile ``` ** `devices.secureElementConfig.PublicDeviceCertificateArn` ** El ARN del certificado del elemento seguro en el que se ha cargado. AWS IoT Core*Para obtener información sobre cómo cargar el certificado a AWS IoT Core, consulte los [certificados de cliente X.509](https://docs.aws.amazon.com/iot/latest/developerguide/x509-client-certs.html) en la AWS IoT Guía para desarrolladores.* ** `devices.secureElementConfig.SecureElementSerialNumber` ** (Opcional) Número de serie del elemento seguro. El número de serie se puede usar para crear certificados de dispositivo para el aprovisionamiento de claves JITR. ** `devices.secureElementConfig.preProvisioned` ** (Opcional) Indique el valor “Sí” si el dispositivo tiene un elemento seguro aprovisionado previamente con credenciales bloqueadas, que no puede importar, crear ni destruir objetos. Si este atributo está establecido en **Sí**, debe proporcionar las etiquetas pkcs11 correspondientes. ** `devices.secureElementConfig.pkcs11JITPCodeVerifyRootCertSupport` ** (Opcional) Configúrelo en **Sí** si la PKCS11 implementación principal del dispositivo admite el almacenamiento para JITP. Esto habilitará la prueba `codeverify` de JITP al probar el PKCS 11 principal y requerirá que se proporcionen la clave de la verificación del código, el certificado JITP y las etiquetas PKCS 11 del certificado raíz. ** `identifiers` ** (Opcional) Una matriz de pares de nombre-valor arbitrarios. Puede utilizar estos valores en los comandos Build y Flash descritos en la siguiente sección. # Configurar ajustes de Build, Flash y Test IDT para FreeRTOS crea e instala las pruebas en su placa automáticamente. Para habilitarlo, debe configurar IDT para que ejecute los comandos build y flash para el hardware. Los ajustes de compilación e instalación se configuran en el archivo de plantilla `config` que se encuentra en la carpeta `userdata.json`. # Configurar ajustes para probar dispositivos Los ajustes de compilación, instalación y prueba se realizan en el archivo `configs/userdata.json`. El siguiente ejemplo de JSON muestra cómo puede configurar IDT para FreeRTOS para probar varios 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": "" } } ``` A continuación se indican los atributos usados en `userdata.json`: ** `sourcePath` ** La ruta a la raíz del código fuente de FreeRTOS trasladado. ** `retainModifiedSourceDirectories` ** (Opcional) Compruebe si se deben conservar los directorios fuente modificados utilizados durante la creación e instalación con fines de depuración. Si se establece en`true`, el nombre de los directorios fuente modificados cambia a retainedSrc y se encuentran en las carpetas de registros de resultados de cada grupo de pruebas ejecutado. Si no se incluye, el campo se establece de forma predeterminada en `false`. ** `freeRTOSTestParamConfigPath` ** La ruta al `test_param_config.h` archivo para la FreeRTOS-Libraries-Integration-Tests integración. Este archivo debe usar la variable de `{{testData.sourcePath}}` marcador de posición para que sea relativo a la raíz del código fuente. AWS IoT Device Tester usa los parámetros de este archivo para configurar las pruebas. ** `freeRTOSTestExecutionConfigPath` ** La ruta al `test_execution_config.h` archivo para FreeRTOS-Libraries-Integration-Tests la integración. Este archivo debe usar la variable de `{{testData.sourcePath}}` marcador de posición para que sea relativo a la raíz del repositorio. AWS IoT Device Tester usa este archivo para controlar qué pruebas deben ejecutarse. ** `freeRTOSVersion` ** La versión de FreeRTOS, incluida la versión del parche utilizada en su implementación. Consulte [Versiones compatibles de FreeRTOS AWS IoT Device Tester para ver las versiones](https://docs.aws.amazon.com/freertos/latest/userguide/dev-test-versions-afr.html) de FreeRTOS compatibles con FreeRTOS. AWS IoT Device Tester ** `buildTool` ** El comando para crear el código fuente. Todas las referencias a la ruta del código fuente en el comando de compilación deben sustituirse por la variable. AWS IoT Device Tester `{{testData.sourcePath}}` Usa el `{{config.idtRootPath}}` marcador de posición para hacer referencia a un script de compilación relativo a la ruta AWS IoT Device Tester raíz. ** `flashTool` ** El comando para instalar una imagen en el dispositivo. Todas las referencias a la ruta del código fuente en el comando flash deben sustituirse por la AWS IoT Device Tester variable. `{{testData.sourcePath}}` Utilice el `{{config.idtRootPath}}` marcador de posición para hacer referencia a un script flash relativo a la ruta AWS IoT Device Tester raíz. La nueva estructura de pruebas de integración con FRQ 2.0 no requiere variables de ruta como `{{enableTests}}` y `{{buildImageName}}`. Las pruebas OTA de extremo a extremo se ejecutan con las plantillas de configuración que se proporcionan en el [ FreeRTOS-Libraries-Integration-Tests](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests/blob/main/config_template/) GitHub repositorio. Si los archivos del GitHub repositorio están presentes en tu proyecto fuente principal, el código fuente no se cambia entre las pruebas. Si necesita una imagen de creación diferente para las pruebas integrales OTA, debe crear esta imagen en el script de creación y especificarla en el archivo `userdata.json` especificado en `otaConfiguration`. ** `testStartDelayms` ** Especifica cuántos milisegundos esperará el ejecutor de pruebas de FreeRTOS antes de empezar a ejecutar las pruebas. Esto puede resultar útil si el dispositivo que se está probando comienza a generar información de prueba importante antes de que IDT tenga la oportunidad de conectarse y empezar a registrar datos debido a problemas de latencia de red o de otro tipo. Este valor se aplica únicamente a los grupos de pruebas de FreeRTOS y no a otros grupos de pruebas que no utilizan el ejecutor de pruebas de FreeRTOS, como las pruebas OTA. Si recibe un error de tipo **expected 10 but received 5**, este campo debe establecerse en 5000. ** `echoServerConfiguration` ** Los ajustes para configurar el servidor echo para la prueba de TLS. Este campo es obligatorio. ** `keyGenerationMethod` ** El servidor echo se configura con esta opción. Las opciones son EC o RSA. ** `serverPort` ** El número de puerto en el que se ejecuta el servidor echo. ** `otaConfiguration` ** La configuración para las pruebas PAL y E2E OTA. Este campo es obligatorio. **`otaE2EFirmwarePath`** Ruta a la imagen binaria OTA que IDT utiliza para las pruebas integrales OTA. ** `otaPALCertificatePath` ** La ruta al certificado para la prueba PAL OTA en el dispositivo. Se utiliza para verificar la firma. Por ejemplo, **ecdsa-sha256-signer.crt.pem**. ** `deviceFirmwarePath` ** La ruta al nombre con codificación rígida para el arranque de la imagen del firmware. Si el dispositivo no utiliza el sistema de archivos para el arranque del firmware, especifique este campo como `'NA'`. Si el dispositivo utiliza el sistema de archivos para el arranque del firmware, especifique la ruta o el nombre de la imagen de arranque del firmware. ** `codeSigningConfiguration` ** ** `signingMethod` ** El método de firma de código. Los valores posibles son AWS o Personalizado. Para las regiones de Beijing y Ningxia, utilice Personalizado. AWS en esa región no se admite la firma de código. ** `signerHashingAlgorithm` ** El algoritmo hash admitido en el dispositivo. Los valores posibles son `SHA1` o `SHA256`. ** `signerSigningAlgorithm` ** El algoritmo de firma admitido en el dispositivo. Los valores posibles son `RSA` o `ECDSA`. ** `signerCertificate` ** Certificado de confianza utilizado para OTA. Para el método de firma de AWS código, utilice el Amazon Resource Name (ARN) para el certificado de confianza cargado en el AWS Certificate Manager. Para el método de firma de código personalizado, utilice la ruta absoluta al archivo de certificado del firmante. Para obtener información sobre cómo crear un certificado de confianza, consulte [ Creación de un certificado de firma de código](https://docs.aws.amazon.com/freertos/latest/userguide/ota-code-sign-cert.html). ** `untrustedSignerCertificate` ** El ARN o ruta de archivo de un segundo certificado utilizado en algunas pruebas OTA como certificado que no es de confianza. Para obtener información sobre cómo crear un certificado, consulte [ Creación de un certificado de firma de código](https://docs.aws.amazon.com//freertos/latest/userguide/ota-code-sign-cert.html). ** `signerCertificateFileName` ** El nombre de la ruta del certificado de firma de código en el dispositivo. Este valor debe coincidir con el nombre de archivo que proporcionó al ejecutar el comando `aws acm import-certificate`. ** `compileSignerCertificate` ** Valor booleano que determina el estado del certificado de verificación de firma. Los valores válidos son `true` y `false`. Establezca este valor en **verdadero** si el certificado de verificación de firma del firmante del código no está aprovisionado o instalado. Debe estar compilado en el proyecto. AWS IoT Device Tester busca el certificado de confianza y lo compila en él. `aws_codesigner_certificate.h` ** `signerPlatform` ** El algoritmo de firma y cifrado que AWS Code Signer utiliza al crear el trabajo de actualización de la OTA. En la actualidad, los valores posibles para este campo son `AmazonFreeRTOS-TI-CC3220SF` y `AmazonFreeRTOS-Default`. + Elija `AmazonFreeRTOS-TI-CC3220SF` si es `SHA1` y `RSA`. + Elija `AmazonFreeRTOS-Default` si es `SHA256` y `ECDSA`. + Si necesita `SHA256` \$1 `RSA` o `SHA1` \$1 `ECDSA` para su configuración, contacte con nosotros para obtener ayuda adicional. + Configure `signCommand` si eligió `Custom` para `signingMethod`. ** `signCommand` ** Se necesitan dos marcadores de posición `{{inputImageFilePath}}` y `{{outputSignatureFilePath}}` en el comando. `{{inputImageFilePath}}` es la ruta del archivo de la imagen creada por IDT que se va a firmar. `{{outputSignatureFilePath}} ` es la ruta del archivo de la firma que generará el script. ** `pkcs11LabelConfiguration` ** PKCS11 la configuración de etiquetas requiere al menos un conjunto de etiquetas de etiqueta de certificado de dispositivo, etiqueta de clave pública y etiqueta de clave privada para ejecutar los grupos de PKCS11 prueba. PKCS11 Las etiquetas obligatorias se basan en la configuración del dispositivo en el `device.json` archivo. Si el aprovisionamiento previo está establecido en **Sí**`device.json`, las etiquetas obligatorias deben ser una de las siguientes, en función de lo que se elija para la PKCS11 función. + `PreProvisionedEC` + `PreProvisionedRSA` Si el aprovisionamiento previo está establecido en **No** en `device.json`, las etiquetas necesarias son: + `pkcs11LabelDevicePrivateKeyForTLS` + `pkcs11LabelDevicePublicKeyForTLS` + `pkcs11LabelDeviceCertificateForTLS` Las tres etiquetas siguientes son necesarias solo si selecciona **Sí** para `pkcs11JITPCodeVerifyRootCertSupport` en el archivo`device.json`. + `pkcs11LabelCodeVerifyKey` + `pkcs11LabelRootCertificate` + `pkcs11LabelJITPCertificate` Los valores de estos campos deben coincidir con los valores definidos en la [Guía de portabilidad de FreeRTOS](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting-pkcs.html). ** `pkcs11LabelDevicePrivateKeyForTLS` ** (Opcional) Esta etiqueta se usa para la etiqueta PKCS 11 de la clave privada. En el caso de los dispositivos con soporte integrado y de importación para el aprovisionamiento de claves, esta etiqueta se utiliza para realizar pruebas. Esta etiqueta puede ser diferente de la definida para el caso de aprovisionamiento previo. Si el aprovisionamiento de claves está establecido en **No** y el aprovisionamiento previo en **Sí**, en `device.json`, no estará definido. ** `pkcs11LabelDevicePublicKeyForTLS` ** (Opcional) Esta etiqueta se usa para la etiqueta PKCS 11 de la clave pública. En el caso de los dispositivos con soporte integrado y de importación para el aprovisionamiento de claves, esta etiqueta se utiliza para realizar pruebas. Esta etiqueta puede ser diferente de la definida para el caso de aprovisionamiento previo. Si el aprovisionamiento de claves está establecido en **No** y el aprovisionamiento previo en **Sí**, en `device.json`, no estará definido. ** `pkcs11LabelDeviceCertificateForTLS` ** (Opcional) Esta etiqueta se usa para la etiqueta PKCS 11 del certificado del dispositivo. En el caso de los dispositivos con soporte integrado y de importación para el aprovisionamiento de claves, esta etiqueta se utilizará para realizar pruebas. Esta etiqueta puede ser diferente de la definida para el caso de aprovisionamiento previo. Si el aprovisionamiento de claves está establecido en **No** y el aprovisionamiento previo en **Sí**, en `device.json`, no estará definido. ** `pkcs11LabelPreProvisionedECDevicePrivateKeyForTLS` ** (Opcional) Esta etiqueta se usa para la etiqueta PKCS 11 de la clave privada. En el caso de los dispositivos con elementos de seguridad o limitaciones de hardware, se utilizará una etiqueta diferente para conservar AWS IoT las credenciales. Si su dispositivo admite el aprovisionamiento previo con una clave EC, proporcione esta etiqueta. Si el aprovisionamiento previo está establecido en **Sí** en `device.json`, se debe indicar esta etiqueta, `pkcs11LabelPreProvisionedRSADevicePrivateKeyForTLS` o ambas. Esta etiqueta puede ser diferente de la definida para los casos de integración e importación. ** `pkcs11LabelPreProvisionedECDevicePublicKeyForTLS` ** (Opcional) Esta etiqueta se usa para la etiqueta PKCS 11 de la clave pública. En el caso de los dispositivos con elementos seguros o limitaciones de hardware, tendrá una etiqueta diferente para conservar AWS IoT las credenciales. Si su dispositivo admite el aprovisionamiento previo con una clave EC, proporcione esta etiqueta. Si el aprovisionamiento previo está establecido en **Sí** en `device.json`, se debe indicar esta etiqueta, `pkcs11LabelPreProvisionedRSADevicePublicKeyForTLS` o ambas. Esta etiqueta puede ser diferente de la definida para los casos de integración e importación. ** `pkcs11LabelPreProvisionedECDeviceCertificateForTLS` ** (Opcional) Esta etiqueta se usa para la etiqueta PKCS 11 del certificado del dispositivo. En el caso de los dispositivos con elementos seguros o limitaciones de hardware, tendrá una etiqueta diferente para conservar AWS IoT las credenciales. Si su dispositivo admite el aprovisionamiento previo con una clave EC, proporcione esta etiqueta. Si el aprovisionamiento previo está establecido en **Sí** en `device.json`, se debe indicar esta etiqueta, `pkcs11LabelPreProvisionedRSADeviceCertificateForTLS` o ambas. Esta etiqueta puede ser diferente de la definida para los casos de integración e importación. ** `pkcs11LabelPreProvisionedRSADevicePrivateKeyForTLS` ** (Opcional) Esta etiqueta se usa para la etiqueta PKCS 11 de la clave privada. En el caso de los dispositivos con elementos seguros o limitaciones de hardware, tendrá una etiqueta diferente para conservar AWS IoT las credenciales. Si su dispositivo admite el aprovisionamiento previo con una clave RSA, proporcione esta etiqueta. Si el aprovisionamiento previo está establecido en **Sí** en `device.json`, se debe indicar esta etiqueta, `pkcs11LabelPreProvisionedECDevicePrivateKeyForTLS` o ambas. ** `pkcs11LabelPreProvisionedRSADevicePublicKeyForTLS` ** (Opcional) Esta etiqueta se usa para la etiqueta PKCS 11 de la clave pública. En el caso de los dispositivos con elementos seguros o limitaciones de hardware, tendrá una etiqueta diferente para conservar AWS IoT las credenciales. Si su dispositivo admite el aprovisionamiento previo con una clave RSA, proporcione esta etiqueta. Si el aprovisionamiento previo está establecido en **Sí** en `device.json`, se debe indicar esta etiqueta, `pkcs11LabelPreProvisionedECDevicePublicKeyForTLS` o ambas. ** `pkcs11LabelPreProvisionedRSADeviceCertificateForTLS` ** (Opcional) Esta etiqueta se usa para la etiqueta PKCS 11 del certificado del dispositivo. En el caso de los dispositivos con elementos seguros o limitaciones de hardware, tendrá una etiqueta diferente para conservar AWS IoT las credenciales. Si su dispositivo admite el aprovisionamiento previo con una clave RSA, proporcione esta etiqueta. Si el aprovisionamiento previo está establecido en **Sí** en `device.json`, se debe indicar esta etiqueta, `pkcs11LabelPreProvisionedECDeviceCertificateForTLS` o ambas. ** `pkcs11LabelCodeVerifyKey` ** (Opcional) Esta etiqueta se utiliza como etiqueta PKCS 11 de la clave de verificación del código. Si su dispositivo admite el almacenamiento PKCS 11 del certificado JITP, la clave de verificación de código y el certificado raíz, proporcione esta etiqueta. Si `pkcs11JITPCodeVerifyRootCertSupport` en `device.json` está establecido en **Sí**, se debe indicar esta etiqueta. ** `pkcs11LabelJITPCertificate` ** (Opcional) Esta etiqueta se usa para la etiqueta PKCS 11 del certificado JITP. Si su dispositivo admite el almacenamiento PKCS 11 del certificado JITP, la clave de verificación de código y el certificado raíz, proporcione esta etiqueta. Si `pkcs11JITPCodeVerifyRootCertSupport` en `device.json` está establecido en **Sí**, se debe indicar esta etiqueta. # Variables de IDT para FreeRTOS Los comandos para compilar el código y actualizar el dispositivo pueden requerir conectividad u otra información sobre los dispositivos para funcionar correctamente. AWS IoT Device Tester permite hacer referencia a la información del dispositivo en flash y compilar comandos utilizando [JsonPath](https://goessner.net/articles/JsonPath/). Mediante el uso de JsonPath expresiones sencillas, puede obtener la información requerida especificada en el `device.json` archivo. ## Variables de ruta IDT para FreeRTOS define las siguientes variables de ruta que se pueden utilizar en líneas de comandos y archivos de configuración: ** `{{testData.sourcePath}}` ** Amplía la ruta del código fuente. Si utiliza esta variable, se debe utilizar tanto en los comandos flash como en los comandos build. ** `{{device.connectivity.serialPort}}` ** Amplía al puerto serie. ** `{{device.identifiers[?(@.name == 'serialNo')].value[0]}}` ** Se amplía hasta el número de serie de su dispositivo. ** `{{config.idtRootPath}}` ** Se expande hasta la ruta AWS IoT Device Tester raíz. # UI para IDT para el conjunto de calificación FreeRTOS 2.0 (FRQ 2.0) AWS IoT Device Tester for FreeRTOS (IDT for FreeRTOS) incluye una interfaz de usuario (UI) basada en la web en la que puede interactuar con la aplicación de línea de comandos de IDT y los archivos de configuración relacionados. Utilice la IU de IDT para FreeRTOS para crear una nueva configuración o modificar una existente para el dispositivo. También puede usar la IU para llamar a la aplicación de IDT y ejecutar las pruebas de FreeRTOS en su dispositivo. Para obtener información sobre cómo utilizar la línea de comandos para ejecutar pruebas de calificación, consulte [Primera prueba de su placa de microcontrolador](lts-qual-steps.md). En esta sección se describen los requisitos previos de la IU de IDT para FreeRTOS y cómo ejecutar las pruebas de calificación desde la IU. **Topics** + [Configurar los requisitos previos de IDT](#lts-dev-tester-ui-prereqs) + [Configure las credenciales para usar la interfaz de usuario de IDT AWS](lts-configure-aws-credentials.md) + [Apertura de la IU de IDT para FreeRTOS](lts-open-idt-ui.md) + [Creación de una nueva configuración](lts-create-new-configuration.md) + [Modificación de una configuración existente](lts-modify-existing-configuration.md) + [Ejecución de pruebas de calificación](lts-run-tests-from-ui.md) ## Configurar los requisitos previos de IDT Para realizar pruebas a través de la interfaz de usuario AWS IoT Device Tester (IDT) para FreeRTOS, debe cumplir los requisitos previos de la página de IDT FreeRTOS [Configurar los requisitos previos de calificación LTS](lts-idt-dev-tester-prereqs.md) Qualification (FRQ) 2.x. # Configure las credenciales para usar la interfaz de usuario de IDT AWS Debe configurar las credenciales de usuario de IAM para el AWS usuario en [Crea una AWS cuenta](lts-idt-dev-tester-prereqs.md#lts-config-aws-account) el que creó. Puede especificar sus credenciales de una de las dos formas siguientes: + En un archivo de credenciales + Como variables de entorno. ## Configure AWS las credenciales con un archivo de credenciales IDT utiliza el mismo archivo de credenciales que la AWS CLI. Para obtener más información, consulte [Configuración y archivos de credenciales](https://docs.aws.amazon.com/cli/latest/userguide/cli-config-files.html). La ubicación del archivo de credenciales varía en función del sistema operativo que utilice: + **macOS y Linux**: `~/.aws/credentials` + **Windows**: `C:\Users\UserName\.aws\credentials` Añada sus AWS credenciales al `credentials` archivo en el siguiente formato: ``` [default] aws_access_key_id = your_access_key_id aws_secret_access_key = your_secret_access_key ``` **nota** Si no usa el `default` AWS perfil, debe especificar el nombre del perfil en la interfaz de usuario de IDT para FreeRTOS. Para obtener más información sobre los perfiles, consulte [Opciones de los archivos de configuración y credenciales](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html). ## Configure AWS las credenciales con variables de entorno Las variables de entorno son las variables que mantiene el sistema operativo y utilizan los comandos del sistema. No se guardan si cierra la sesión de SSH. La interfaz de usuario de IDT para Freertos usa `AWS_ACCESS_KEY_ID` las variables de entorno `AWS_SECRET_ACCESS_KEY` y para almacenar AWS sus credenciales. Para establecer estas variables en Linux, MacOS, o Unix, utilice **export**: ``` export AWS_ACCESS_KEY_ID=your_access_key_id export AWS_SECRET_ACCESS_KEY=your_secret_access_key ``` Para establecer estas variables en Windows, utilice **set**: ``` set AWS_ACCESS_KEY_ID=your_access_key_id set AWS_SECRET_ACCESS_KEY=your_secret_access_key ``` # Apertura de la IU de IDT para FreeRTOS En este tema se explica cómo abrir la IU de IDT para FreeRTOS para usar el conjunto de calificación de FreeRTOS. **Para abrir la IU de IDT para FreeRTOS** 1. Descargue una versión compatible de IDT para FreeRTOS. A continuación, extraiga el archivo descargado a un directorio para el que tenga permisos de lectura y escritura. 1. Vaya al directorio de instalación de IDT para FreeRTOS: ``` cd devicetester-extract-location/bin ``` 1. Ejecute el siguiente comando para abrir la IU de IDT para FreeRTOS: ------ #### [ Linux ] ``` .devicetester_ui_linux_x86-64 ``` ------ #### [ Windows ] ``` ./devicetester_ui_win_x64-64 ``` ------ #### [ macOS ] ``` ./devicetester_ui_mac_x86-64 ``` **nota** En macOS, para permitir que su sistema ejecute la IU, vaya a **Preferencias del sistema -> Seguridad y privacidad**. Cuando ejecute las pruebas, es posible que tenga que hacerlo tres veces más. ------ La IU de IDT para FreeRTOS se abre en el navegador predeterminado. Las tres últimas versiones principales de los siguientes navegadores son compatibles con la IU: + Google Chrome + Mozilla Firefox + Microsoft Edge + Apple Safari para macOS **nota** Para una mejor experiencia, recomendamos Google Chrome o Mozilla Firefox para acceder a la IU de IDT para FreeRTOS. La IU no admite Microsoft Internet Explorer. **importante** Debe configurar sus AWS credenciales antes de abrir la interfaz de usuario. Si no ha configurado sus credenciales, cierre la ventana del navegador de la IU de IDT para FreeRTOS, siga los pasos que se indican en [Configure las credenciales para usar la interfaz de usuario de IDT AWS](lts-configure-aws-credentials.md) y, a continuación, vuelva a abrir la IU de IDT para FreeRTOS. # Creación de una nueva configuración Si es la primera vez que lo usa, debe crear una nueva configuración para configurar los archivos de configuración JSON que IDT para FreeRTOS necesita para ejecutar las pruebas. A continuación, puede ejecutar pruebas o modificar la configuración creada. Para ver ejemplos de los archivos `config.json`, `device.json` y `userdata.json`, consulte [Primera prueba de su placa de microcontrolador](lts-qual-steps.md). **Para crear una nueva configuración** 1. En la IU de IDT para FreeRTOS, abra el menú de navegación y elija **Crear nueva configuración**. ![\[Interfaz Device Tester for FreeRTOS con el botón “Crear nueva configuración” e información sobre la autocomprobación automática de los microcontroladores.\]](http://docs.aws.amazon.com/es_es/freertos/latest/userguide/images/gsg-create-configuration.png) 1. Siga las instrucciones del asistente de configuración para introducir los ajustes de configuración de IDT que se utilizan para ejecutar las pruebas de calificación. El asistente configura los siguientes ajustes en los archivos de configuración JSON ubicados en el directorio `devicetester-extract-location/config`. + **Configuración de dispositivos**: la configuración del grupo de dispositivos para los dispositivos que se van a probar. Estos ajustes se configuran en los campos `id` y `sku`, y el bloque de **dispositivos** para el grupo de dispositivos en el archivo `config.json`. ![\[Pantalla de configuración de Device Tester for FreeRTOS con campos de identificador y SKU para configurar un grupo de dispositivos, opciones de configuración de dispositivos como el método de conectividad, el aprovisionamiento de claves, la configuración de PKCS #11, los campos de entrada de detalles del dispositivo y controles para añadir dispositivos o identificadores.\]](http://docs.aws.amazon.com/es_es/freertos/latest/userguide/images/gsg-device-settings.png) + **AWS configuración de la cuenta**: la Cuenta de AWS información que IDT for FreeRTOS utiliza para AWS crear recursos durante las pruebas. Estos ajustes se configuran en el archivo `config.json`. ![\[Cuenta de AWS página de configuración con campos para la región de la cuenta, las credenciales, la ubicación como archivo o entorno y el nombre del perfil\]](http://docs.aws.amazon.com/es_es/freertos/latest/userguide/images/gsg-account-settings.png) + **Implementación de FreeRTOS**: la ruta absoluta al repositorio y al código portado de FreeRTOS, y a la versión de FreeRTOS en la que desea ejecutar IDT FRQ. Las rutas a los archivos de cabecera de ejecución y configuración de parámetros del `FreeRTOS-Libraries-Integration-Tests` GitHub repositorio. Los comandos build y flash de su hardware que permiten a IDT crear e instalar las pruebas en su placa automáticamente. Estos ajustes se configuran en el archivo `userdata.json`. ![\[Sección de configuración de implementación de FreeRTOS con rutas de repositorio, rutas de ejecución de pruebas, versión de FreeRTOS, detalles de la herramienta de compilación y configuración de la herramienta flash.\]](http://docs.aws.amazon.com/es_es/freertos/latest/userguide/images/gsg-implementation-settings.png) + **Etiquetas PKCS 11 y servidor Echo**: las etiquetas [PKCS 11](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting-pkcs.html) que corresponden a las claves aprovisionadas en su hardware según la funcionalidad de las clave y el método de aprovisionamiento de claves. Los ajustes de configuración del servidor echo para las pruebas de la interfaz de transporte. Estos ajustes se configuran en los archivos `userdata.json` y `device.json`. ![\[Etiquetas PKCS #11 y configuraciones de servidores de Eco con campos de entrada para las etiquetas clave, el método de generación de claves y el número de puerto del servidor\]](http://docs.aws.amazon.com/es_es/freertos/latest/userguide/images/gsg-pkcs11-settings.png) + **Over-the-air Actualizaciones (OTA)**: la configuración que controla las pruebas de funcionalidad de las OTA. Estos ajustes se configuran en el bloque de `features` de los archivos `device.json` y `userdata.json`. ![\[Opciones de configuración de actualización de OTA: omitir pruebas, protocolos de datos, rutas de firmware, ruta de certificación PAL, firma de código, hash/sign algoritmos, certificados de trusted/untrusted firmante, archivo de certificado de firmante, compilación de certificados de firmante, plataforma de firmante.\]](http://docs.aws.amazon.com/es_es/freertos/latest/userguide/images/gsg-ota-settings.png) 1. En la página **Revisar**, compruebe la información de configuración. ![\[La configuración creó un cuadro de diálogo para Device Tester for FreeRTOS, que muestra detalles sobre la creación de una nueva configuración de prueba con opciones para editar o ejecutar pruebas.\]](http://docs.aws.amazon.com/es_es/freertos/latest/userguide/images/gsg-configuration-created.png) Cuando termine de revisar la configuración, para ejecutar las pruebas de calificación, elija **Ejecutar pruebas**. # Modificación de una configuración existente Si ya ha configurado los archivos de configuración de IDT para FreeRTOS, puede utilizar la IU de IDT para FreeRTOS para modificar la configuración existente. Los archivos de configuración existentes deben estar ubicados en el directorio `devicetester-extract-location/config`. **Para modificar una configuración** 1. En la IU de IDT para FreeRTOS, abra el menú de navegación y elija **Editar configuración existente**. El panel de configuración muestra información sobre los ajustes de configuración existentes. Si una configuración es incorrecta o no está disponible, el estado de esa configuración es `Error validating configuration`. ![\[Pantalla de configuración con el dispositivo Cuenta de AWS, la implementación de Freertos, las etiquetas PKCS y el servidor echo, las over-the-air actualizaciones y las secciones de configuración de ejecución de pruebas que muestran el estado válido.\]](http://docs.aws.amazon.com/es_es/freertos/latest/userguide/images/modify-existing-configuration.png) 1. Complete los siguientes pasos para modificar un ajuste de configuración existente: 1. Seleccione el nombre de un ajuste de configuración para abrir su página de ajustes. 1. Modifique los ajustes y, a continuación, seleccione **Guardar** para volver a generar el archivo de configuración correspondiente. 1. Para modificar la configuración de ejecución de pruebas de IDT para FreeRTOS, elija **Configuración de ejecución de pruebas de IDT** en la vista de edición: ![\[Cuadro de diálogo de configuración de la prueba de IDT con opciones para seleccionar la prueba, omitir grupos de pruebas, multiplicar el tiempo de espera y detener la prueba en caso de que se produzca el primer error.\]](http://docs.aws.amazon.com/es_es/freertos/latest/userguide/images/idt-testrun-settings.png) Cuando termine de modificar la configuración, compruebe que todas las opciones de configuración pasen la validación. Si el estado de cada parámetro de configuración es `Valid`, puede ejecutar las pruebas de calificación con esta configuración. # Ejecución de pruebas de calificación Después de crear una configuración para la IU de IDT para FreeRTOS, puede ejecutar las pruebas de calificación. **Para ejecutar pruebas de calificación** 1. En el menú de navegación, elija **Ejecutar pruebas**. 1. Seleccione **Iniciar pruebas** para iniciar la ejecución de la prueba. De forma predeterminada, todas las pruebas aplicables se ejecutan para la configuración del dispositivo. IDT para FreeRTOS genera un informe de calificación cuando finalizan todas las pruebas. ![\[La interfaz de Device Tester for FreeRTOS muestra que aún no se ha realizado ninguna prueba, con opciones para crear una nueva configuración, editar la configuración existente y ejecutar pruebas.\]](http://docs.aws.amazon.com/es_es/freertos/latest/userguide/images/idt-run-tests.png) IDT para FreeRTOS ejecuta las pruebas de calificación. A continuación, muestra el resumen de la ejecución de la prueba y cualquier error en la consola de **Ejecutor de prueba**. Una vez finalizada la ejecución de la prueba, puede ver los resultados y los registros de la prueba desde las siguientes ubicaciones: + Los resultados de las pruebas se encuentran en el directorio `devicetester-extract-location/results/execution-id`. + Los registros de las pruebas se encuentran en el directorio `devicetester-extract-location/results/execution-id/logs`. Para obtener más información sobre los resultados y registros de las pruebas, consulte [Vea el IDT de forma gratuita RTOSresults](view-results-lts.md) y [Vea el IDT de forma gratuita RTOSlogs](view-logs-lts.md). ![\[Registro de ejecución de Device Tester para FreeRTOS que muestra las pruebas superadas, los grupos de pruebas y las rutas de archivos de los registros e informes.\]](http://docs.aws.amazon.com/es_es/freertos/latest/userguide/images/idt-results.png) # Ejecución del conjunto de calificación de FreeRTOS 2.0 Utilice el ejecutable AWS IoT Device Tester for FreeRTOS para interactuar con IDT for FreeRTOS. Los ejemplos de línea de comandos siguientes le muestran como ejecutar las pruebas de cualificación para un grupo de dispositivos (un 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 ``` Ejecuta un conjunto de pruebas en un grupo de dispositivos. El archivo `userdata.json` debe estar ubicado en el directorio `devicetester_extract_location/devicetester_freertos_[win|mac|linux]/configs/`. **nota** Si ejecuta IDT para FreeRTOS en Windows, utilice barras diagonales (/) para especificar la ruta al archivo `userdata.json`. Utilice el siguiente comando para ejecutar un grupo de prueba 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 ``` Los parámetros `suite-id` y `pool-id` son opcionales si está ejecutando un único conjunto de pruebas en un único grupo de dispositivos (es decir, tiene un único grupo de dispositivos definido en el archivo `device.json`). Utilice el siguiente comando para ejecutar un caso de prueba específico: ``` devicetester_[linux | mac | win_x86-64] run-suite \ --group-id group-id \ --test-id test-id ``` Puede utilizar el comando `list-test-cases` para ver los casos de prueba en un grupo de pruebas. **Opciones de la línea de comandos de IDT para FreeRTOS** **group-id** (Opcional) Los grupos de prueba que se van a ejecutar, como una lista separada por comas. Si no se especifica, IDT ejecuta todos los grupos de prueba del conjunto de pruebas. **pool-id** (Opcional) El grupo de dispositivos que se va a probar. Es necesario si define varios grupos de dispositivos en `device.json`. Si solo tiene un grupo de dispositivos, puede omitir esta opción. **suite-id** (Opcional) La versión del conjunto de pruebas que se va a ejecutar. Si no se especifica, IDT utiliza la versión más reciente del directorio de pruebas del sistema. **test-id** (Opcional) Las pruebas que se van a ejecutar, como una lista separada por comas. Si se especifica, `group-id` debe especificar un solo grupo. **Example** ``` devicetester_[linux | mac | win_x86-64] run-suite --group-id FreeRTOSVersion --test-id FreeRTOSVersion ``` **h** Utilice la opción de ayuda para obtener más información sobre las opciones de `run-suite`. **Example** **Ejemplo** ``` devicetester_[linux | mac | win_x86-64] run-suite -h ``` ------ ## Comandos de IDT para FreeRTOS El comando de IDT para FreeRTOS admite las siguientes operaciones: ------ #### [ IDT v4.5.2 and later ] ** `help` ** Enumera información acerca del comando especificado. ** `list-groups` ** Muestra los grupos de un conjunto determinado. ** `list-suites` ** Muestra los conjuntos disponibles. ** `list-supported-products` ** Muestra los productos compatibles y las versiones del conjunto de pruebas. ** `list-supported-versions` ** Muestra las versiones de FreeRTOS y del conjunto de pruebas compatibles con la versión actual de IDT. ** `list-test-cases` ** Muestra los casos de prueba de un grupo especificado. ** `run-suite` ** Ejecuta un conjunto de pruebas en un grupo de dispositivos. Utilice la opción `--suite-id` para especificar una versión del conjunto de pruebas u omítala para utilizar la versión más reciente en el sistema. Utilice el `--test-id` para ejecutar un caso de prueba individual. **Example** ``` devicetester_[linux | mac | win_x86-64] run-suite --group-id FreeRTOSVersion --test-id FreeRTOSVersion ``` A partir de IDT v3.0.0, IDT comprueba en línea los conjuntos de pruebas más recientes. Para obtener más información, consulte [Versiones del conjunto de pruebas](idt-test-suite-versions.md). ------ # Vea el IDT de forma gratuita RTOSresults Mientras ejecuta, IDT escribe errores en la consola, en archivos de registro y en informes de prueba. Una vez que IDT completa el conjunto de pruebas de cualificación, escribe un resumen de ejecución de la prueba en la consola y genera dos informes de prueba. Estos informes se pueden encontrar en `devicetester-extract-location/results/execution-id/`. Ambos informes capturan los resultados de la ejecución del conjunto de pruebas de cualificación. Este `awsiotdevicetester_report.xml` es el informe de la prueba de calificación que debe enviar AWS para incluir su dispositivo en el catálogo de dispositivos AWS asociados. El informe contiene los componentes siguientes: + La versión IDT para FreeRTOS. + La versión de FreeRTOS que se ha probado. + Las características de FreeRTOS que admite el dispositivo en función de las pruebas superadas. + El SKU y el nombre de dispositivo especificado en el archivo `device.json`. + Las características del dispositivo especificado en el archivo `device.json`. + El resumen de agregación de los resultados de casos de prueba. + Un desglose de los resultados de los casos de prueba por bibliotecas que se probaron en función de las características de los dispositivos. Se `FRQ_Report.xml` trata de un informe en [formato JUnit XML](https://llg.cubic.org/docs/junit/) estándar. Puede integrarlo en CI/CD plataformas como [Jenkins](https://jenkins.io/), [Bamboo](https://www.atlassian.com/software/bamboo), etc. El informe contiene los componentes siguientes: + Un resumen de agregación de los resultados de casos de prueba. + Un desglose de los resultados de los casos de prueba por bibliotecas que se probaron en función de las características de los dispositivos. # Interpretar los resultados de IDT para FreeRTOS La sección del informe en `awsiotdevicetester_report.xml` o `FRQ_Report.xml` muestra los resultados de las pruebas que se ejecutan. La primera etiqueta XML `` contiene el resumen general de la ejecución de las pruebas. Por ejemplo: `` **Atributos que se utilizan en la etiqueta ``** ** `name` ** El nombre del grupo de prueba. ** `time` ** El tiempo, en segundos, que se ha tardado en ejecutar el conjunto de cualificación. ** `tests` ** El número de casos de prueba ejecutados. ** `failures` ** El número de casos de prueba que se ejecutaron, pero que no se superaron. ** `errors` ** El número de casos de prueba que IDT para FreeRTOS no ha podido ejecutar. ** `disabled` ** Este atributo no se utiliza y se puede omitir. Si no hay fallos o errores en los casos de prueba, el dispositivo cumple con los requisitos técnicos para ejecutar FreeRTOS y puede interoperar con los servicios. AWS IoT Si decide incluir su dispositivo en el catálogo de dispositivos AWS asociados, puede utilizar este informe como prueba de aptitud. Si se producen errores en el caso de prueba, puede identificar el caso de prueba fallido revisando las etiquetas XML ``. Las etiquetas XML `` dentro de la etiqueta `` muestran el resumen del resultado de caso de prueba de un grupo de prueba. `` El formato es similar a la etiqueta ``, pero con un atributo denominado `skipped` que no se utiliza y que se puede pasar por alto. Dentro de cada etiqueta XML ``, hay etiquetas `` para cada uno de los casos de prueba ejecutados para un grupo de prueba. Por ejemplo: `` **Atributos que se utilizan en la etiqueta ``** ** `name` ** El nombre del producto que se está probando. ** `version` ** La versión del producto que se está probando. ** `features` ** Las características validadas. Las características marcadas como `required` son necesarias para solicitar la cualificación de la placa. En el siguiente fragmento se muestra cómo aparece esta información en el archivo `awsiotdevicetester_report.xml`. ``` ``` Las características marcadas como `optional` no son necesarias para la cualificación. Los siguientes fragmentos muestran características opcionales: ``` ``` Si no hay errores de pruebas para las características requeridas, el dispositivo cumple los requisitos técnicos para ejecutar FreeRTOS y puede interoperar con servicios de AWS IoT . Si quiere mostrar su dispositivo en el [Catálogo de dispositivos de socios de AWS](https://partners.amazonaws.com/qualified-devices), puede utilizar este informe como prueba de calificación. Si se producen errores en pruebas, puede identificar la prueba fallido revisando las etiquetas XML ``. Las etiquetas XML `` dentro de la etiqueta `` muestran el resumen del resultado de la prueba de un grupo de prueba. Por ejemplo: ``` ``` El formato es similar a la etiqueta ``, pero con un atributo `skipped` que no se utiliza y que se puede pasar por alto. Dentro de cada etiqueta XML ``, hay etiquetas `` para cada prueba ejecutada para un grupo de prueba. Por ejemplo: ``` ``` **Atributos que se utilizan en la etiqueta ``** ** `name` ** El nombre del caso de prueba. ** `attempts` ** Las veces que IDT para FreeRTOS ha ejecutado la prueba. Cuando una prueba genera un error o si se produce un error, las etiquetas `` o `` se agregan a la etiqueta `` con información para la resolución de problemas. Por ejemplo: ``` Reason for the test case failure Reason for the test case execution error ``` Para obtener más información, consulte [Errores de solución de problemas de la ](dt-afr-troubleshooting.md). # Vea el IDT de forma gratuita RTOSlogs Encontrará los registros que IDT para FreeRTOS genera a partir de la ejecución de la prueba en `devicetester-extract-location/results/execution-id/logs`. Se generan dos conjuntos de registros: + `test_manager.log` Contiene los registros generados a partir de IDT para FreeRTOS (por ejemplo, configuración relacionada con los registros y generación de informes). + `test_group_id/test_case_id/test_case_id.log` El archivo de registro de un caso de prueba, incluida la salida del dispositivo que se está probando. El nombre que se asigna al archivo de registro depende del grupo de prueba y del caso de prueba ejecutado.