Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Vorbereitung auf den ersten Test Ihres Mikrocontroller-Boards

Sie können IDT for FreeRTOS verwenden, um Ihre Implementierung der FreeRTOS-Bibliotheken zu testen. Nachdem Sie die FreeRTOS-Bibliotheken für die Gerätetreiber Ihres Mainboards portiert haben, verwenden Sie diese, AWS IoT Device Tester um die Qualifizierungstests auf Ihrem Mikrocontroller-Board durchzuführen.

Fügen Sie Bibliotheksportierungsebenen hinzu und implementieren Sie ein FreeRTOS-Testrepository

Informationen zum Portieren von FreeRTOS für Ihr Gerät finden Sie im FreeRTOS Porting Guide. Bei der Implementierung des FreeRTOS-Test-Repositorys und der Portierung der FreeRTOS-Ebenen müssen Sie einen manifest.yml Pfad zu jeder Bibliothek angeben, einschließlich des Test-Repositorys. Diese Datei befindet sich im Stammverzeichnis Ihres Quellcodes. Einzelheiten finden Sie in den Anweisungen zur Manifestdatei.

Konfigurieren Ihrer AWS-Anmeldeinformationen

Sie müssen Ihre AWS Anmeldeinformationen für AWS IoT Device Tester die Kommunikation mit der AWS Cloud konfigurieren. Weitere Informationen finden Sie unter AWSAnmeldeinformationen einrichten und Region für Entwicklung. Gültige AWS Anmeldeinformationen sind in der devicetester_extract_location/devicetester_freertos_[win|mac|linux]/configs/config.json Konfigurationsdatei angegeben.

"auth": {
   "method": "environment"
}

"auth": {
    "method": "file",
    "credentials": {
        "profile": "<your-aws-profile>"
    }
}

Das auth Attribut der config.json Datei hat ein Methodenfeld, das die AWS Authentifizierung steuert, und kann entweder als Datei oder als Umgebung deklariert werden. Wenn Sie das Feld auf Umgebung setzen, werden Ihre AWS Anmeldeinformationen aus den Umgebungsvariablen Ihres Host-Computers abgerufen. Wenn Sie das Feld auf Datei setzen, wird ein bestimmtes Profil aus der .aws/credentials Konfigurationsdatei importiert.

Erstellen Sie einen Gerätepool in IDT für FreeRTOS

Zu testende Geräte werden in Gerätepools organisiert. Jeder Gerätepool besteht aus einem oder mehreren identischen Geräten. Sie können IDT für FreeRTOS konfigurieren, um ein einzelnes Gerät oder mehrere Geräte in einem Pool zu testen. Um den Qualifizierungsprozess zu beschleunigen, kann IDT for FreeRTOS Geräte mit denselben Spezifikationen parallel testen. Er verwendet eine Round Robin-Methode, um auf jedem Gerät in einem Gerätepool eine andere Testgruppe auszuführen.

Die device.json Datei hat ein Array in ihrer obersten Ebene. Jedes Array-Attribut ist ein neuer Gerätepool. Jeder Gerätepool hat ein Geräte-Array-Attribut, für das mehrere Geräte deklariert sind. In der Vorlage gibt es einen Gerätepool und nur ein Gerät in diesem Gerätepool. Sie können ein oder mehrere Geräte zu einem Gerätepool hinzufügen, indem Sie den Abschnitt devices der Vorlage device.json im Ordner configs bearbeiten.

Im Folgenden finden Sie eine device.json Beispieldatei, die verwendet wurde, um einen Gerätepool mit mehreren Geräten zu erstellen.

[
    {
        "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"
              }
            ]
          }
        ]
    }
]

Die folgenden Attribute werden in der Datei device.json verwendet:

Konfiguration von Build-, Flash- und Testeinstellungen

IDT for FreeRTOS erstellt und flasht Tests automatisch auf Ihrem Board. Um dies zu aktivieren, müssen Sie IDT so konfigurieren, dass es die Build- und Flash-Befehle für Ihre Hardware ausführt. Die Einstellungen für den Build- und den Flash-Befehl werden in der userdata.json-Vorlagendatei im Ordner config konfiguriert.

Konfigurieren von Einstellungen für das Testen von Geräten

Build-, Flash- und Testeinstellungen werden in der configs/userdata.json-Datei vorgenommen. Das folgende JSON-Beispiel zeigt, wie Sie IDT für FreeRTOS konfigurieren können, um mehrere Geräte zu testen:

{
    "sourcePath": "</path/to/freertos>",
    "retainModifiedSourceDirectories": true | false,
    "freeRTOSVersion": "<freertos-version>",
    "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": [
            "<build command> -any-additional-flags {{testData.sourcePath}}"
        ]
    },
    "flashTool": {
        "name": "your-flash-tool-name",
        "version": "your-flash-tool-version",
        "command": [
            "<flash 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": "<device-private-key-label>",
        "pkcs11LabelDevicePublicKeyForTLS": "<device-public-key-label>",
        "pkcs11LabelDeviceCertificateForTLS": "<device-certificate-label>",
        "pkcs11LabelPreProvisionedECDevicePrivateKeyForTLS": "<preprovisioned-ec-device-private-key-label>",
        "pkcs11LabelPreProvisionedECDevicePublicKeyForTLS": "<preprovisioned-ec-device-public-key-label>",
        "pkcs11LabelPreProvisionedECDeviceCertificateForTLS": "<preprovisioned-ec-device-certificate-label>",
        "pkcs11LabelPreProvisionedRSADevicePrivateKeyForTLS": "<preprovisioned-rsa-device-private-key-label>",
        "pkcs11LabelPreProvisionedRSADevicePublicKeyForTLS": "<preprovisioned-rsa-device-public-key-label>",
        "pkcs11LabelPreProvisionedRSADeviceCertificateForTLS": "<preprovisioned-rsa-device-certificate-label>",
        "pkcs11LabelCodeVerifyKey": "<code-verification-key-label>",
        "pkcs11LabelJITPCertificate": "<JITP-certificate-label>",
        "pkcs11LabelRootCertificate": "<root-certificate-label>"
     }   
  }

Im Folgenden werden die in der userdata.json-Datei verwendeten Attribute aufgelistet:

IDT für FreeRTOS-Variablen

Die Befehle zum Erstellen Ihres Codes und zum Flashen des Geräts erfordern möglicherweise Konnektivität oder andere Informationen über Ihre Geräte, um erfolgreich ausgeführt zu werden. AWS IoT Device Testerermöglicht es Ihnen, Geräteinformationen in Flash zu referenzieren und Befehle mithilfe von zu erstellen JsonPath. Mithilfe einfacher JsonPath Ausdrücke können Sie die in Ihrer device.json Datei angegebenen erforderlichen Informationen abrufen.

Pfadvariablen

IDT for FreeRTOS definiert die folgenden Pfadvariablen, die in Befehlszeilen und Konfigurationsdateien verwendet werden können: