Scarica, crea, esegui il flashing ed esegui la demo OTA di FreerTOS su Renesas RX65N - Gratuito RTOS

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

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

Importante

Questa integrazione di riferimento è ospitata nel repository Amazon-FreeRTOS che è obsoleto. Ti consigliamo di iniziare da qui quando crei un nuovo progetto. Se hai già un progetto FreeRTOS esistente basato sull'ormai obsoleto repository Amazon-FreerTOS, consulta il. Guida alla migrazione del RTOS repository Github gratuito da Amazon

Questo capitolo mostra come scaricare, creare, eseguire il flashing ed eseguire le applicazioni demo FreerTOS OTA su Renesas RX65N.

Configura il tuo ambiente operativo

Le procedure descritte in questa sezione utilizzano i seguenti ambienti:

  • IDE: 2 studio 7.8.0, e 2 studio 2020-07

  • Catene di strumenti: CCRX Compiler v3.0.1

  • Dispositivi di destinazione: RSKRX65N-2MB

  • Debugger: emulatore E 2 , E 2 Lite

  • Software: Renesas Flash Programmatore, Renesas Secure Flash Programmer.exe, Tera Term

Per configurare l'hardware
  1. Connect l'emulatore E 2 Lite e la porta seriale USB alla scheda RX65N e al PC.

  2. Connect la fonte di alimentazione all'RX65N.

Configura le tue risorse AWS

  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. Configurare il tuo AWS account e autorizzazioni

  2. Per configurare gli aggiornamenti OTA, segui i passaggi indicatiOTAaggiornare i prerequisiti. In particolare, segui i passaggi indicati inPrerequisiti per gli aggiornamenti utilizzando OTA 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).

      schermata della console che mostra i file da scaricare
    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 chiavi ECDSA-SHA256 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.

Se non hai Tera Term installato sul tuo PC, puoi scaricarlo da https://ttssh2.osdn.jp/index.html.en e configurarlo come mostrato qui. Assicurati di collegare la porta seriale USB dal dispositivo al PC.

Finestra di configurazione della porta seriale Tera Term

Importa, configura il file di intestazione e crea aws_demos e boot_loader

Per iniziare, selezioni l'ultima versione del pacchetto FreerTOS, che verrà scaricata GitHub e importata automaticamente nel progetto. In questo modo puoi concentrarti sulla configurazione di FreerTOS e sulla scrittura del codice dell'applicazione.

  1. Avvia e 2 studio.

  2. Scegli File, quindi scegli Importa...

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

    finestra di importazione di e-squared studio
  4. Scegli Controlla altre versioni... per mostrare la finestra di dialogo per il download.

    finestra di dialogo per il download di e-squared studio
  5. Seleziona il pacchetto più recente.

    finestra di dialogo per il download del modulo e-squared studio
  6. Scegli Accetto per accettare il contratto di licenza con l'utente finale.

    finestra di dialogo EULA di e-squared studio
  7. Attendi il completamento del download.

    scarica la barra di avanzamento
  8. Seleziona i progetti aws_demos e boot_loader, quindi scegli Fine per importarli.

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

    1. Scegliete la toolchain corrente.

    2. Scegli il generatore Current.

    finestra delle proprietà di e-squared studio
  10. Nel pannello di navigazione scegli Impostazioni. Scegli la scheda Toolchain, quindi scegli la versione della toolchain.

    Impostazioni di integrazione della toolchain per Renesas CCRX versione v3.01.00, con possibilità di modificare la toolchain.

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

    La finestra delle impostazioni di configurazione di C/C++ Build mostra le opzioni del compilatore e del linker come il file esadecimale di output, il tipo di file di output, la directory di output e le opzioni di divisione dei file.
    Albero delle impostazioni dell'interfaccia con opzioni per Stack Analysis, Tool Chain Editor, C/C++ General, MCU, Project References, ecc.
  11. Nel progetto bootloader, projects\renesas\rx65n-rsk\e2studio\boot_loader\src\key\code_signer_public_key.h apri e inserisci la chiave pubblica. Per informazioni su come creare una chiave pubblica, consulta Come implementare FreerTOS OTA utilizzando Amazon Web Services su RX65N 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.

    Editor di codice che mostra un file di intestazione C con definizione di CODE_SIGNER_PUBLIC_KEY e una variabile chiave pubblica code signer con codifica PEM.

    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"
      Frammento di codice che mostra il nome dell' AWS IoT oggetto e le impostazioni di configurazione dell'endpoint del broker.
    5. Apri il file tools/certificate_configuration/CertificateConfigurator.html.

    6. Importa il file PEM del certificato e il file PEM a chiave privata che hai scaricato in precedenza.

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

      Strumento di configurazione dei certificati con campi per fornire i file PEM del certificato client e della chiave privata dalla console e un pulsante per generare e salvare il file aws_clientcredential_keys.h AWS IoT .
    8. Apri il file e specifica questi valori. vendors/renesas/boards/rx65n-rsk/aws_demos/config_files/ota_demo_config.h

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

      Dove your-certificate-key è il valore del file. secp256r1.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 su RX65N 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.

      File di codice sorgente che mostra il codice C che definisce una stringa costante del certificato Code Signer con codifica PEM con dati del certificato redatti.
  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.

      Frammento di codice che mostra le definizioni delle versioni di un'applicazione, incluse le macro per i numeri di versione principali, secondari e di build.
    3. Modificate le seguenti impostazioni nel Section Viewer.

      Finestra del visualizzatore di sezioni che mostra gli indirizzi di memoria, i nomi delle sezioni come SU, SI, i registri e i componenti dell'interfaccia come buffer di rete, eccezioni e pulsanti di azione.
    4. Scegliete Build per creare il file. aws_demos.mot

  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 sull'RX65N-RSK per installare il firmware iniziale.

    1. Scarica https://github.com/renesas/Amazon-FreeRTOS-Tools e apriRenesas 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).

      Finestra Renesas Secure Flash Programmer con MCU, verifica del firmware, numero di sequenza, percorso chiave AES e campi del percorso del file.
    3. Crea una directory denominata init_firmware Genera userprog.mot e salvala nella directory. init_firmware 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 https://www.renesas.com/tw/en/products/software-tools/tools/programmer/renesas-flash-programmer-programming-gui.html.

    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.

      La finestra Renesas Flash Programmer mostra i dettagli del progetto del microcontrollore RX Group, il percorso del file e le opzioni di funzionamento flash come Cancella, Programma e Verifica con i pulsanti Start e OK.
    4. Per eseguire il flash, scegli Sfoglia... userprog.mot e accedi alla init_firmware directory, seleziona il userprog.mot file e scegli Avvia.

      La finestra Renesas Flash Programmer mostra le impostazioni delle operazioni di cancellazione, tra cui il microcontrollore RX Group, l'opzione per sfogliare il file di programma, i pulsanti Erase e Start e i dettagli sullo stato dei blocchi selezionati da cancellare.
  16. La versione 0.9.2 (versione iniziale) del firmware è stata installata sull'RX65N-RSK. La scheda RX65N-RSK è ora in attesa degli aggiornamenti OTA. Se hai aperto Tera Term sul tuo PC, quando viene eseguito il firmware iniziale, viene visualizzato qualcosa di simile al seguente.

    ------------------------------------------------- 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.

      Finestra Renesas Secure Flash Programmer con selezione MCU, tipo di verifica del firmware, numero di sequenza, campo chiave AES MAC e input del percorso del file per la generazione di firmware sicuro.
  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

    Interfaccia di gestione dei bucket Amazon S3 con cartelle, caricamenti, versioni e opzioni di autorizzazione
  20. Crea un processo per aggiornare il firmware sull'RX65N-RSK.

    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. Accedi 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. Seleziona Successivo.

      Impostazioni di firma dell'immagine del firmware e aggiornamento OTA con opzioni per firmare nuovo firmware, selezionare firmware firmato in precedenza, utilizzare firmware firmato personalizzato, specificare il profilo di firma del codice, il file di immagine del firmware, il percorso sul dispositivo e il ruolo IAM per il processo di aggiornamento OTA.
    5. Inserisci un ID, quindi scegli Crea.

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

    Output della riga di comando che mostra l'inizializzazione e la connessione di un thread a un broker.
  22. Sulla AWS IoT console, verifica che lo stato del processo sia Riuscito.

    Panoramica del processo di test AFR OTA-Demo che mostra che 1 risorsa ha avuto successo.