Scarica, crea, esegui il flashing ed esegui la demo OTA di FreerTOS su Renesas N RX65

Per configurare l'hardware

1. Connect l'emulatore E ² Lite e la porta seriale USB alla scheda RX65 N e al PC.

2. Connect la fonte di alimentazione al RX65 N.

1. Per eseguire le demo di FreerTOS, è necessario disporre di AWS un account con un utente IAM autorizzato ad accedere ai servizi. AWS IoT Se non l'hai già fatto, segui i passaggi indicati. Configurazione dell'account e delle autorizzazioni AWS

2. Per configurare gli aggiornamenti OTA, segui la procedura riportata di seguitoPrerequisiti per l'aggiornamento OTA. In particolare, segui i passaggi indicati inPrerequisiti per gli aggiornamenti OTA mediante MQTT.

3. Apri la AWS IoT console.

4. Nel riquadro di navigazione a sinistra, scegli Gestisci, quindi scegli Cose per creare un oggetto.

   Una cosa è una rappresentazione di un dispositivo o di un'entità logica in AWS IoT. Può trattarsi di un dispositivo fisico o un sensore, ad esempio una lampadina o un interruttore su un muro. Può anche essere un'entità logica come un'istanza di un'applicazione o un'entità fisica a cui non si connette AWS IoT, ma è correlata a dispositivi che lo fanno (ad esempio, un'auto dotata di sensori del motore o un pannello di controllo). AWS IoT fornisce un registro degli oggetti che ti aiuta a gestire le tue cose.

   1. Scegli Crea, quindi scegli Crea una singola cosa.

   2. Inserisci un nome per il tuo oggetto, quindi scegli Avanti.

   3. Scegli Crea certificato.

   4. Scarica i tre file creati, quindi scegli Attiva.

   5. Scegliere Attach a policy (Collega policy).

      

   6. Seleziona la politica in cui hai creatoPolicy dei dispositivi.

      Ogni dispositivo che riceve un aggiornamento OTA tramite MQTT deve essere registrato come oggetto in AWS IoT e deve avere una politica allegata come quella elencata. Ulteriori informazioni sugli elementi degli oggetti "Action" e "Resource" sono disponibili in Operazioni di policy AWS IoT Core e Risorse per operazioni AWS IoT Core.

      Note

      • Le iot:Connect autorizzazioni consentono al dispositivo di connettersi tramite MQTT AWS IoT .

      • Le autorizzazioni iot:Publish e iot:Subscribe sugli argomenti dei processi AWS IoT (.../jobs/*) consentono al dispositivo connesso di ricevere notifiche e documenti relativi ai processi e di pubblicare lo stato di completamento dell'esecuzione di un processo.

      • Le iot:Publish autorizzazioni iot:Subscribe e sugli argomenti degli stream AWS IoT OTA (.../streams/*) consentono al dispositivo connesso di recuperare i dati di aggiornamento OTA da. AWS IoT Queste autorizzazioni sono necessarie per eseguire gli aggiornamenti del firmware tramite MQTT.

      • Le iot:Receive autorizzazioni consentono di AWS IoT Core pubblicare messaggi su tali argomenti sul dispositivo connesso. Questa autorizzazione viene controllata ad ogni recapito di un messaggio MQTT. È possibile utilizzare questa autorizzazione per revocare l'accesso ai client attualmente sottoscritti a un argomento.

5. Per creare un profilo di firma del codice e registrare un certificato di firma del codice su. AWS

   1. Per creare le chiavi e la certificazione, vedere la sezione 7.3 «Generazione di coppie di SHA256 chiavi ECDSA con OpenSSL» nella politica di progettazione degli aggiornamenti del firmware MCU di Renesas.

   2. Apri la AWS IoT console. Nel riquadro di navigazione a sinistra, seleziona Gestisci, quindi Jobs. Seleziona Crea un lavoro, quindi Crea processo di aggiornamento OTA.

   3. In Seleziona i dispositivi da aggiornare scegli Seleziona, quindi scegli l'elemento che hai creato in precedenza. Seleziona Avanti.

   4. Nella pagina Crea un processo di aggiornamento OTA FreerTOS, procedi come segue:

      1. Per Seleziona il protocollo per il trasferimento delle immagini del firmware, scegli MQTT.

      2. Per Seleziona e firma l'immagine del firmware, scegli Firma una nuova immagine del firmware per me.

      3. Per il profilo Code Signing, scegli Crea.

      4. Nella finestra Crea un profilo di firma del codice, inserisci un nome di profilo. Per la piattaforma hardware del dispositivo, seleziona Windows Simulator. Per il certificato di firma del codice, scegli Importa.

      5. Sfoglia per selezionare il certificato (secp256r1.crt), la chiave privata del certificato (secp256r1.key) e la catena di certificati (ca.crt).

      6. Inserisci un nome di percorso del certificato di firma del codice sul dispositivo. Quindi, scegli Crea.

6. Per concedere l'accesso alla firma del codice per AWS IoT, segui i passaggi indicati inConcedi l'accesso alla firma del codice per AWS IoT.

1. ^{Avvia e 2 studio.}

2. Scegli File, quindi scegli Importa...

3. Seleziona il progetto Renesas GitHub FreerTOS (con librerie IoT).

   

4. Scegli Controlla altre versioni... per mostrare la finestra di dialogo per il download.

   

5. Seleziona il pacchetto più recente.

   

6. Scegli Accetto per accettare il contratto di licenza con l'utente finale.

   

7. Attendi il completamento del download.

   

8. Seleziona i progetti aws_demos e boot_loader, quindi scegli Fine per importarli.

   

9. Per entrambi i progetti, apri le proprietà del progetto. Nel riquadro di navigazione, scegliete Tool Chain Editor.

   1. Scegliete la toolchain corrente.

   2. Scegli il generatore Current.

   

10. Nel pannello di navigazione scegli Impostazioni. Scegli la scheda Toolchain, quindi scegli la versione della toolchain.

    

    Scegliete la scheda Impostazioni dello strumento, espandete Convertitore e scegliete Output. Nella finestra principale, assicurati che il file esadecimale di output sia selezionato, quindi scegli il tipo di file di output.

    
    

11. Nel progetto bootloader, apri projects\renesas\rx65n-rsk\e2studio\boot_loader\src\key\code_signer_public_key.h e inserisci la chiave pubblica. Per informazioni su come creare una chiave pubblica, consulta Come implementare FreerTOS OTA utilizzando Amazon Web Services RX65 su N e la sezione 7.3 «Generazione di coppie di chiavi ECDSA con OpenSSL» nella politica di progettazione dell'SHA256 aggiornamento del firmware MCU di Renesas.

    

    Quindi boot_loader.mot crea il progetto da creare.

12. Apri il aws_demos progetto.

    1. Apri la AWS IoT console.

    2. Nel riquadro di navigazione a sinistra scegliere Impostazioni. Prendi nota del tuo endpoint personalizzato nella casella di testo Device data endpoint.

    3. Scegli Gestisci, quindi scegli Cose. Prendi nota del nome dell' AWS IoT oggetto della tua bacheca.

    4. Nel aws_demos progetto, aprite demos/include/aws_clientcredential.h e specificate i seguenti valori.

       #define clientcredentialMQTT_BROKER_ENDPOINT[] = "Your AWS IoT endpoint";
       #define clientcredentialIOT_THING_NAME "The AWS IoT thing name of your board"

       

    5. Apri il file tools/certificate_configuration/CertificateConfigurator.html.

    6. Importate il file PEM del certificato e il file PEM a chiave privata che avete scaricato in precedenza.

    7. Scegli Genera e salva aws_clientcredential_keys.h e sostituisci questo file nella directory. demos/include/

       

    8. vendors/renesas/boards/rx65n-rsk/aws_demos/config_files/ota_demo_config.hApri il file e specifica questi valori.

       #define otapalconfigCODE_SIGNING_CERTIFICATE [] = "your-certificate-key";

       your-certificate-keyDov'è il valore del filesecp256r1.crt. Ricordati di aggiungere «\» dopo ogni riga della certificazione. Per ulteriori informazioni sulla creazione del secp256r1.crt file, consulta Come implementare FreerTOS OTA utilizzando Amazon Web Services RX65 su N e la sezione 7.3 «Generazione di coppie di chiavi ECDSA SHA256 con OpenSSL» nella politica di progettazione dell'aggiornamento del firmware MCU di Renesas.

       

13. Attività A: installare la versione iniziale del firmware

    1. Apri il vendors/renesas/boards/board/aws_demos/config_files/aws_demo_config.h file, commenta e definisci CONFIG_OTA_MQTT_UPDATE_DEMO_ENABLED oCONFIG_OTA_HTTP_UPDATE_DEMO_ENABLED. #define CONFIG_CORE_MQTT_MUTUAL_AUTH_DEMO_ENABLED

    2. Aprire il demos/include/ aws_application_version.h file e impostare la versione iniziale del firmware su0.9.2.

       

    3. Modificate le seguenti impostazioni nel Section Viewer.

       

    4. Scegliete Build per creare il aws_demos.mot file.

14. Crea il file userprog.mot con Renesas Secure Flash Programmer. userprog.motè una combinazione di e. aws_demos.mot boot_loader.mot È possibile eseguire il flashing di questo file su RX65 N-RSK per installare il firmware iniziale.

    1. Scarica https://github.com/renesas/Amazon-FreeRTOS-Tools e apri. Renesas Secure Flash Programmer.exe

    2. Scegli la scheda Initial Firm e imposta i seguenti parametri:

       • Private Key Path: la posizione disecp256r1.privatekey.

       • Percorso del file del loader di avvio: la posizione di boot_loader.mot (projects\renesas\rx65n-rsk\e2studio\boot_loader\HardwareDebug).

       • Percorso del file: la posizione di aws_demos.mot (projects\renesas\rx65n-rsk\e2studio\aws_demos\HardwareDebug).

       

    3. Create una directory init_firmware denominata userprog.mot Generate e salvatela init_firmware nella directory. Verificate che la generazione sia riuscita.

15. Esegui il flashing del firmware iniziale sull' RX65N-RSK.

    1. Scarica l'ultima versione di Renesas Flash Programmer (Programming GUI) da - .html. https://www.renesas.com/tw/ en/products/software-tools/tools/programmer/renesas flash-programmer-programming-gui

    2. Apri il vendors\renesas\rx_mcu_boards\boards\rx65n-rsk\aws_demos\flash_project\erase_from_bank\ erase.rpj file per cancellare i dati sulla banca.

    3. Scegli Inizia per cancellare la banca.

       

    4. Per lampeggiareuserprog.mot, scegli Sfoglia... e accedi alla init_firmware directory, seleziona il userprog.mot file e scegli Avvia.

       

16. La versione 0.9.2 (versione iniziale) del firmware è stata installata sul tuo RX65 N-RSK. La scheda RX65 N-RSK è ora in attesa degli aggiornamenti OTA. Se hai aperto Tera Term sul tuo PC, all'esecuzione del firmware iniziale viene visualizzato qualcosa di simile a quanto segue.

    -------------------------------------------------
    RX65N secure boot program
    -------------------------------------------------
    Checking flash ROM status.
    bank 0 status = 0xff [LIFECYCLE_STATE_BLANK]
    bank 1 status = 0xfc [LIFECYCLE_STATE_INSTALLING]
    bank info = 1. (start bank = 0)
    start installing user program.
    copy secure boot (part1) from bank0 to bank1...OK
    copy secure boot (part2) from bank0 to bank1...OK
    update LIFECYCLE_STATE from [LIFECYCLE_STATE_INSTALLING] to [LIFECYCLE_STATE_VALID]
    bank1(temporary area) block0 erase (to update LIFECYCLE_STATE)...OK
    bank1(temporary area) block0 write (to update LIFECYCLE_STATE)...OK
    swap bank...
    -------------------------------------------------
    RX65N secure boot program
    -------------------------------------------------
    Checking flash ROM status.
    bank 0 status = 0xf8 [LIFECYCLE_STATE_VALID]
    bank 1 status = 0xff [LIFECYCLE_STATE_BLANK]
    bank info = 0. (start bank = 1)
    integrity check scheme = sig-sha256-ecdsa
    bank0(execute area) on code flash integrity check...OK
    jump to user program
    0 1 [ETHER_RECEI] Deferred Interrupt Handler Task started
    1 1 [ETHER_RECEI] Network buffers: 3 lowest 3
    2 1 [ETHER_RECEI] Heap: current 234192 lowest 234192
    3 1 [ETHER_RECEI] Queue space: lowest 8
    4 1 [IP-task] InitializeNetwork returns OK
    5 1 [IP-task] xNetworkInterfaceInitialise returns 0
    6 101 [ETHER_RECEI] Heap: current 234592 lowest 233392
    7 2102 [ETHER_RECEI] prvEMACHandlerTask: PHY LS now 1
    8 3001 [IP-task] xNetworkInterfaceInitialise returns 1
    9 3092 [ETHER_RECEI] Network buffers: 2 lowest 2
    10 3092 [ETHER_RECEI] Queue space: lowest 7
    11 3092 [ETHER_RECEI] Heap: current 233320 lowest 233320
    12 3193 [ETHER_RECEI] Heap: current 233816 lowest 233120
    13 3593 [IP-task] vDHCPProcess: offer c0a80a09ip
    14 3597 [ETHER_RECEI] Heap: current 233200 lowest 233000
    15 3597 [IP-task] vDHCPProcess: offer c0a80a09ip
    16 3597 [IP-task] IP Address: 192.168.10.9
    17 3597 [IP-task] Subnet Mask: 255.255.255.0
    18 3597 [IP-task] Gateway Address: 192.168.10.1
    19 3597 [IP-task] DNS Server Address: 192.168.10.1
    20 3600 [Tmr Svc] The network is up and running
    21 3622 [Tmr Svc] Write certificate...
    22 3697 [ETHER_RECEI] Heap: current 232320 lowest 230904
    23 4497 [ETHER_RECEI] Heap: current 226344 lowest 225944
    24 5317 [iot_thread] [INFO ][DEMO][5317] ---------STARTING DEMO---------
    
    25 5317 [iot_thread] [INFO ][INIT][5317] SDK successfully initialized.
    26 5317 [iot_thread] [INFO ][DEMO][5317] Successfully initialized the demo. Network type for the demo: 4
    27 5317 [iot_thread] [INFO ][MQTT][5317] MQTT library successfully initialized.
    28 5317 [iot_thread] [INFO ][DEMO][5317] OTA demo version 0.9.2
    
    29 5317 [iot_thread] [INFO ][DEMO][5317] Connecting to broker...
    
    30 5317 [iot_thread] [INFO ][DEMO][5317] MQTT demo client identifier is rx65n-gr-rose (length 13).
    31 5325 [ETHER_RECEI] Heap: current 206944 lowest 206504
    32 5325 [ETHER_RECEI] Heap: current 206440 lowest 206440
    33 5325 [ETHER_RECEI] Heap: current 206240 lowest 206240
    38 5334 [ETHER_RECEI] Heap: current 190288 lowest 190288
    39 5334 [ETHER_RECEI] Heap: current 190088 lowest 190088
    40 5361 [ETHER_RECEI] Heap: current 158512 lowest 158168
    41 5363 [ETHER_RECEI] Heap: current 158032 lowest 158032
    42 5364 [ETHER_RECEI] Network buffers: 1 lowest 1
    43 5364 [ETHER_RECEI] Heap: current 156856 lowest 156856
    44 5364 [ETHER_RECEI] Heap: current 156656 lowest 156656
    46 5374 [ETHER_RECEI] Heap: current 153016 lowest 152040
    47 5492 [ETHER_RECEI] Heap: current 141464 lowest 139016
    48 5751 [ETHER_RECEI] Heap: current 140160 lowest 138680
    49 5917 [ETHER_RECEI] Heap: current 138280 lowest 138168
    59 7361 [iot_thread] [INFO ][MQTT][7361] Establishing new MQTT connection.
    62 7428 [iot_thread] [INFO ][MQTT][7428] (MQTT connection 81cfc8, CONNECT operation 81d0e8) Wait complete with result SUCCESS.
    63 7428 [iot_thread] [INFO ][MQTT][7428] New MQTT connection 4e8c established.
    64 7430 [iot_thread] [OTA_AgentInit_internal] OTA Task is Ready.
    65 7430 [OTA Agent T] [prvOTAAgentTask] Called handler. Current State [Ready] Event [Start] New state [RequestingJob]
    66 7431 [OTA Agent T] [INFO ][MQTT][7431] (MQTT connection 81cfc8) SUBSCRIBE operation scheduled.
    67 7431 [OTA Agent T] [INFO ][MQTT][7431] (MQTT connection 81cfc8, SUBSCRIBE operation 818c48) Waiting for operation completion.
    68 7436 [ETHER_RECEI] Heap: current 128248 lowest 127992
    69 7480 [OTA Agent T] [INFO ][MQTT][7480] (MQTT connection 81cfc8, SUBSCRIBE operation 818c48) Wait complete with result SUCCESS.
    70 7480 [OTA Agent T] [prvSubscribeToJobNotificationTopics] OK: $aws/things/rx65n-gr-rose/jobs/$next/get/accepted
    71 7481 [OTA Agent T] [INFO ][MQTT][7481] (MQTT connection 81cfc8) SUBSCRIBE operation scheduled.
    72 7481 [OTA Agent T] [INFO ][MQTT][7481] (MQTT connection 81cfc8, SUBSCRIBE operation 818c48) Waiting for operation completion.
    73 7530 [OTA Agent T] [INFO ][MQTT][7530] (MQTT connection 81cfc8, SUBSCRIBE operation 818c48) Wait complete with result SUCCESS.
    74 7530 [OTA Agent T] [prvSubscribeToJobNotificationTopics] OK: $aws/things/rx65n-gr-rose/jobs/notify-next
    75 7530 [OTA Agent T] [prvRequestJob_Mqtt] Request #0
    76 7532 [OTA Agent T] [INFO ][MQTT][7532] (MQTT connection 81cfc8) MQTT PUBLISH operation queued.
    77 7532 [OTA Agent T] [INFO ][MQTT][7532] (MQTT connection 81cfc8, PUBLISH operation 818b80) Waiting for operation completion.
    78 7552 [OTA Agent T] [INFO ][MQTT][7552] (MQTT connection 81cfc8, PUBLISH operation 818b80) Wait complete with result SUCCESS.
    79 7552 [OTA Agent T] [prvOTAAgentTask] Called handler. Current State [RequestingJob] Event [RequestJobDocument] New state [WaitingForJob]
    80 7552 [OTA Agent T] [prvParseJSONbyModel] Extracted parameter [ clientToken: 0:rx65n-gr-rose ]
    81 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: execution
    82 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: jobId
    83 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: jobDocument
    84 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: afr_ota
    85 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: protocols
    86 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: files
    87 7552 [OTA Agent T] [prvParseJSONbyModel] parameter not present: filepath
    99 7651 [ETHER_RECEI] Heap: current 129720 lowest 127304
    100 8430 [iot_thread] [INFO ][DEMO][8430] State: Ready  Received: 1   Queued: 0   Processed: 0   Dropped: 0
    101 9430 [iot_thread] [INFO ][DEMO][9430] State: WaitingForJob  Received: 1   Queued: 0   Processed: 0   Dropped: 0
    102 10430 [iot_thread] [INFO ][DEMO][10430] State: WaitingForJob  Received: 1   Queued: 0   Processed: 0   Dropped: 0
    103 11430 [iot_thread] [INFO ][DEMO][11430] State: WaitingForJob  Received: 1   Queued: 0   Processed: 0   Dropped: 0
    104 12430 [iot_thread] [INFO ][DEMO][12430] State: WaitingForJob  Received: 1   Queued: 0   Processed: 0   Dropped: 0
    105 13430 [iot_thread] [INFO ][DEMO][13430] State: WaitingForJob  Received: 1   Queued: 0   Processed: 0   Dropped: 0
    106 14430 [iot_thread] [INFO ][DEMO][14430] State: WaitingForJob  Received: 1   Queued: 0   Processed: 0   Dropped: 0
    107 15430 [iot_thread] [INFO ][DEMO][15430] State: WaitingForJob  Received: 1   Queued: 0   Processed: 0   Dropped: 0 

17. Attività B: aggiorna la versione del firmware

    1. Aprire il demos/include/aws_application_version.h file e incrementare il valore del APP_VERSION_BUILD token a0.9.3.

    2. Ricreare il progetto.

18. Crea il userprog.rsu file con Renesas Secure Flash Programmer per aggiornare la versione del firmware.

    1. Apri il file Amazon-FreeRTOS-Tools\Renesas Secure Flash Programmer.exe.

    2. Scegli la scheda Update Firm e imposta i seguenti parametri:

       • Percorso del file: la posizione del aws_demos.mot file (projects\renesas\rx65n-rsk\e2studio\aws_demos\HardwareDebug).

    3. Crea una directory denominata update _firmware. Genera userprog.rsu e salvalo nella update_firmware directory. Verifica che la generazione sia riuscita.

       

19. Carica l'aggiornamento del firmware in un bucket Amazon S3 come descritto in. userproj.rsu Crea un bucket Amazon S3 per archiviare l'aggiornamento

    

20. Crea un processo per aggiornare il firmware sull'N-RSK. RX65

    AWS IoT Jobs è un servizio che notifica a uno o più dispositivi connessi un Job in sospeso. Un job può essere utilizzato per gestire una flotta di dispositivi, aggiornare il firmware e i certificati di sicurezza sui dispositivi o eseguire attività amministrative come il riavvio dei dispositivi e l'esecuzione di diagnosi.

    1. Accedere alla console AWS IoT. Nel riquadro di navigazione, scegli Gestisci e scegli Lavori.

    2. Scegli Crea un lavoro, quindi scegli Crea lavoro OTA Update. Seleziona una cosa, quindi scegli Avanti.

    3. Crea un processo di aggiornamento OTA FreerTOS come segue:

       • Scegli MQTT.

       • Seleziona il profilo di firma del codice che hai creato nella sezione precedente.

       • Seleziona l'immagine del firmware che hai caricato in un bucket Amazon S3.

       • Per il nome del percorso dell'immagine del firmware sul dispositivo, inserisci. test

       • Scegli il ruolo IAM che hai creato nella sezione precedente.

    4. Scegli Next (Successivo).

       

    5. Inserisci un ID e poi scegli Crea.

21. Riapri Tera Term per verificare che il firmware sia stato aggiornato correttamente alla versione demo OTA 0.9.3.

    

22. Sulla AWS IoT console, verifica che lo stato del processo sia Riuscito.