Condividi tramite

Esercitazione: Creare un'applicazione con funzionalità in tempo reale

  • Articolo

Importante

Questa è la documentazione di Azure Sphere (legacy). Azure Sphere (legacy) viene ritirato il 27 settembre 2027 e gli utenti devono eseguire la migrazione ad Azure Sphere (integrato) entro questo periodo. Usare il selettore di versione posizionato sopra il sommario per visualizzare la documentazione di Azure Sphere (integrata).

Questa esercitazione illustra come creare un'applicazione di esempio per i core in tempo reale in un dispositivo Azure Sphere. Per informazioni di base sulle applicazioni con funzionalità in tempo reale, vedere Panoramica delle applicazioni Azure Sphere.

In questa esercitazione apprenderai a:

  • Scaricare un'applicazione di esempio
  • Installare la toolchain GNU Arm
  • Configurare l'hardware per visualizzare l'output
  • Abilitare lo sviluppo e il debug
  • Avviare un emulatore di terminale per visualizzare l'output
  • Compilare, eseguire ed eseguire il debug di un'applicazione con funzionalità in tempo reale

Importante

Queste istruzioni presuppongono l'uso di hardware conforme alla progettazione della scheda di riferimento (RDB) MT3620, ad esempio MT3620 Dev Kit di Seeed Studios. Se si usa un hardware di Azure Sphere diverso, consultare la documentazione del produttore per scoprire se UART è esposto e come accedervi. Potrebbe essere necessario configurare l'hardware per visualizzare l'output in modo diverso e aggiornare il codice di esempio e il campo "Uarts" del file app_manifest.json per usare un dispositivo UART diverso.

Prerequisiti

Scaricare l'applicazione di esempio

È possibile scaricare l'applicazione HelloWorld come indicato di seguito:

  1. Puntare il browser a Microsoft Samples Browser.
  2. Digitare "Azure Sphere" nella casella Di ricerca.
  3. Selezionare Azure Sphere - Hello World nei risultati della ricerca.
  4. Selezionare Scarica ZIP.
  5. Aprire il file scaricato ed estrarre in una directory locale.

Installare GNU Arm Embedded Toolchain

È possibile scaricare e installare gnu Arm Embedded Toolchain dal sito Web per sviluppatori arm. In alternativa, è possibile usare gli artefatti vcpkg per installare e configurare automaticamente l'ambiente di sviluppo.

  • Visual Studio 2022: se si usa Visual Studio 2022, installare gnu Arm Embedded Toolchain (arm-none-eabi) dal sito Web per sviluppatori Arm.
  • Visual Studio 2019: la toolchain viene installata automaticamente con l'estensione Azure Sphere per Visual Studio in Visual Studio 2019. Se si usa Visual Studio 2019, passare a Configurare l'hardware per visualizzare l'output. Tuttavia, se è stata installata manualmente la toolchain GNU Arm Embedded, Visual Studio userà la versione installata.

Per installare la toolchain, nel sito Web per sviluppatori arm trovare la toolchain GNU Arm Embedded (arm-none-eabi) che include il compilatore per il processore ARM Cortex-M4. Seguire le istruzioni per scaricare e installare il compilatore per la piattaforma del sistema operativo.

Per impostazione predefinita, Visual Studio Code cerca la toolchain e trova la versione installata. Se si verificano problemi di compilazione correlati alla toolchain, immettere il percorso come indicato di seguito:

  1. Selezionare Estensioni>delle impostazioni>delle preferenze>file>di Azure Sphere.
  2. Immettere il percorso di installazione di GNU Arm Embedded Toolchain nell'impostazione Azure Sphere: Arm Gnu Path .

Per installare la toolchain, nel sito Web per sviluppatori arm trovare la toolchain GNU Arm Embedded (arm-none-eabi) che include il compilatore per il processore ARM Cortex-M4. Seguire le istruzioni per scaricare e installare il compilatore per la piattaforma del sistema operativo.

Configurare l'hardware per visualizzare l'output

Tutti i core per operazioni in tempo reale supportano attualmente un dispositivo UART solo TX. Le RTApp usano questo UART per inviare l'output del log dal dispositivo. Durante lo sviluppo e il debug di applicazioni, in genere è necessario un modo per leggere e visualizzare l'output. L'esempio HelloWorld_RTApp_MT3620_BareMetal illustra come un'applicazione può scrivere in UART.

Usare un adattatore USB-seriale, ad esempio FTDI Friend, per connettere il dispositivo UART nel core per operazioni in tempo reale alla porta USB del computer. È necessario anche un emulatore di terminale per stabilire una connessione seriale con le impostazioni del terminale 115200-8-N-1 (115200 bps, 8 bit, senza bit di parità, un bit di arresto) per visualizzare l'output.

Per configurare l'hardware per visualizzare l'output da un'app in tempo reale, seguire questa procedura. Per determinare le posizioni dei pin, è necessario fare riferimento alla documentazione del produttore dell'hardware. Se si usa un hardware che segue l'hardware di progettazione della scheda di riferimento (RDB, Reference Board Design) MT3620, ad esempio il kit di sviluppo MT3620 di Seeed Studios, vedere le intestazioni dell'interfaccia RDB per determinare le posizioni dei pin.

  1. Collegare la messa a terra sull'adattatore da porta USB a seriale alla messa a terra sul kit di sviluppo. Nell'hardware RDB MT3620 la messa a terra corrisponde a intestazione 3, pin 2.
  2. Collegare il ricevitore dell'adattatore da porta USB a seriale al trasmettitore IOM4-0 del kit di sviluppo. Nell'hardware RDB MT3620 il trasmettitore IOM4-0 corrisponde a intestazione 3, pin 6.
  3. Connettere l'adattatore USB a seriale a una porta USB libera nel computer di sviluppo e determinare la porta a cui è connesso il dispositivo seriale. In Windows avviare Gestione dispositivi selezionare Visualizza>dispositivi per contenitore e cercare "USB UART". Ad esempio, FT232R USB UART indica la scheda FTDI Friend.
  4. Avviare un programma emulatore di terminale e aprire un terminale 115200-8-N-1 sulla porta COM usata dall'adattatore. Per informazioni su come specificare la porta e la velocità, vedere la documentazione per l'emulatore del terminale.

Configurare l'hardware per visualizzare l'output

Tutti i core per operazioni in tempo reale supportano attualmente un dispositivo UART solo TX. Le RTApp usano questo UART per inviare l'output del log dal dispositivo. Durante lo sviluppo e il debug di applicazioni, in genere è necessario un modo per leggere e visualizzare l'output. L'esempio HelloWorld_RTApp_MT3620_BareMetal illustra come un'applicazione può scrivere in UART.

Usare un adattatore USB-seriale, ad esempio FTDI Friend, per connettere il dispositivo UART nel core per operazioni in tempo reale alla porta USB del computer. È necessario anche un emulatore di terminale per stabilire una connessione seriale con le impostazioni del terminale 115200-8-N-1 (115200 bps, 8 bit, senza bit di parità, un bit di arresto) per visualizzare l'output.

Per configurare l'hardware per visualizzare l'output da un'app in tempo reale, seguire questa procedura. Per determinare le posizioni dei pin, è necessario fare riferimento alla documentazione del produttore dell'hardware. Se si usa un hardware che segue l'hardware di progettazione della scheda di riferimento (RDB, Reference Board Design) MT3620, ad esempio il kit di sviluppo MT3620 di Seeed Studios, vedere le intestazioni dell'interfaccia RDB per determinare le posizioni dei pin.

  1. Collegare la messa a terra sull'adattatore da porta USB a seriale alla messa a terra sul kit di sviluppo. Nell'hardware RDB MT3620 la messa a terra corrisponde a intestazione 3, pin 2.

  2. Collegare il ricevitore dell'adattatore da porta USB a seriale al trasmettitore IOM4-0 del kit di sviluppo. Nell'hardware RDB MT3620 il trasmettitore IOM4-0 corrisponde a intestazione 3, pin 6.

  3. Connettere l'adattatore USB a seriale a una porta USB libera nel computer di sviluppo e determinare la porta a cui è connesso il dispositivo seriale.

    • In Windows avviare Gestione dispositivi selezionare Visualizza>dispositivi per contenitore e cercare "USB UART". Ad esempio, FT232R USB UART indica la scheda FTDI Friend.

    • In Linux digitare il comando seguente:

      dmesg | grep ttyUSB

      La porta dovrebbe essere denominata ttyUSBn, dove n indica il numero di porta. Se il dmesg comando elenca diverse porte USB, quella connessa all'ultima porta segnalata come collegata. Ad esempio, nell'esempio seguente si userà ttyUSB4:

    ~$ dmesg | grep ttyUSB
[  144.564350] usb 1-1.1.2: FTDI USB Serial Device converter now attached to ttyUSB0
[  144.564768] usb 1-1.1.2: FTDI USB Serial Device converter now attached to ttyUSB1
[  144.565118] usb 1-1.1.2: FTDI USB Serial Device converter now attached to ttyUSB2
[  144.565593] usb 1-1.1.2: FTDI USB Serial Device converter now attached to ttyUSB3
[  144.570429] usb 1-1.1.3: FTDI USB Serial Device converter now attached to ttyUSB4
[  254.171871] ftdi_sio ttyUSB1: FTDI USB Serial Device converter now disconnected from ttyUSB1

  4. Avviare un programma emulatore di terminale e aprire un terminale 115200-8-N-1 sulla porta COM usata dall'adattatore. Per informazioni su come specificare la porta e la velocità, vedere la documentazione per l'emulatore del terminale.

Abilitare lo sviluppo e il debug

Prima di poter compilare un'applicazione di esempio sul dispositivo Azure Sphere o sviluppare nuove applicazioni, è necessario abilitare lo sviluppo e il debug. Per impostazione predefinita, i dispositivi Azure Sphere sono "bloccati", ovvero non consentono il caricamento da un PC di applicazioni in fase di sviluppo, oltre a non permettere il debug delle applicazioni. La preparazione del dispositivo per il debug rimuove questa restrizione e carica il software necessario per il debug e sblocca le funzionalità del dispositivo come descritto in Funzionalità del dispositivo e comunicazione.

Per eseguire il debug nei core in tempo reale, usare il comando azsphere device enable-development. Questo comando configura il dispositivo per accettare applicazioni da un PC per il debug e assegna il dispositivo al gruppo di dispositivi sviluppo, che non consente gli aggiornamenti delle applicazioni cloud. Durante lo sviluppo e il debug delle applicazioni, è consigliabile lasciare il dispositivo in questo gruppo in modo da evitare la sovrascrittura dell'applicazione in fase di sviluppo da parte degli aggiornamenti cloud.

In Windows è necessario aggiungere il --enable-rt-core-debugging parametro , che carica i server di debug e i driver necessari per ogni tipo di core nel dispositivo.

  1. Accedere ad Azure Sphere se non è già stato fatto:

    azsphere login

  2. Aprire un'interfaccia della riga di comando usando PowerShell o il prompt dei comandi di Windows con privilegi di amministratore. Il --enable-rt-core-debugging parametro richiede privilegi di amministratore perché installa i driver USB per il debugger.

  3. Immettere il comando seguente:

    azsphere device enable-development --enable-rt-core-debugging

  4. Chiudere la finestra dopo il completamento del comando perché il privilegio di amministratore non è più necessario. È consigliabile usare sempre il privilegio minimo necessario per eseguire un'attività.

Se il comando azsphere device enable-development non riesce, vedere Risolvere i problemi di Azure Sphere per assistenza.

Compilare ed eseguire l'applicazione HelloWorld RTApp con Visual Studio

  1. Avviare Visual Studio. Selezionare Apri una cartella locale, passare alla cartella in cui è stato estratto il file Azure_Sphere___Hello_World.zip scaricato e quindi selezionare la cartella HelloWorld_RTApp_MT3620_Baremetal.

  2. Se non si usa un RDB MT3620, aggiornare il file di app_manifest.json e il codice di esempio per specificare l'UART corretto, ad esempio ISU1.

  3. Se la generazione di CMake non viene avviata automaticamente, selezionare il file CMakeLists.txt.

  4. Nella finestra Output di Visual Studio l'output di CMake dovrebbe visualizzare i messaggi CMake generation started. eCMake generation finished.

  5. Selezionare Compila>tutto. Se il menu non è presente, aprire Esplora soluzioni, fare clic con il pulsante destro del mouse sul file CMakeLists.txt e scegliere Compila. Il percorso di output dell'applicazione HelloWorld_RTApp_MT3620_Baremetal viene visualizzato nella finestra Output .

  6. Nel menu Seleziona voce di avvio selezionare HelloWorld_RTApp_MT3620_Baremetal (RTCore).

  7. Premere F5 per distribuire l'applicazione.

  8. L'emulatore di terminale connesso visualizzerà l'output del programma HelloWorld_RTApp_MT3620_Baremetal. Il programma invia le parole seguenti a intervalli di un secondo:

    Tick

    Tock

  9. Usare il debugger per impostare i punti di interruzione, esaminare le variabili e provare altre attività di debug.

Compilare ed eseguire l'applicazione HelloWorld RTApp con Visual Studio Code

  1. In Visual Studio Code aprire la cartella HelloWorld_RTApp_MT3620_BareMetal nella cartella in cui è stato estratto il file Azure_Sphere___Hello_World.zip scaricato. Se viene richiesto di selezionare un kit, scegliere di non usare un kit.

  2. Se non si usa l'hardware RDB MT3620, aggiornare il file app_manifest.json e il codice di esempio specificando il dispositivo UART corretto, ad esempio ISU1.

  3. Premere F5 per avviare il debugger. Se il progetto non è già stato compilato oppure se i file sono stati cambiati ed è necessaria una ricompilazione, Visual Studio Code compilerà il progetto prima dell'avvio del debug.

  4. Nella finestra di output di Azure Sphere verrà visualizzato un messaggio che indica che è in corso la distribuzione dell'immagine, con i percorsi dell'SDK e del compilatore.

  5. L'emulatore di terminale connesso visualizzerà l'output del programma HelloWorld_RTApp_MT3620_Baremetal. Il programma invia le parole seguenti a intervalli di un secondo:

    Tick

    Tock

  6. Usare le funzionalità di debug di Visual Studio Code per impostare i punti di interruzione, esaminare le variabili e provare altre attività di debug.

Risoluzione dei problemi

È possibile che l'esecuzione dell'applicazione inizi prima che OpenOCD stabilisca una connessione. Di conseguenza, i punti di interruzione impostati precedentemente nel codice potrebbero essere ignorati. Per risolvere il problema, è possibile ritardare l'avvio dell'app fino a quando OpenOCD non stabilisce la connessione.

  1. Inserire il codice seguente all'inizio del punto di ingresso dell'applicazione RTCoreMain. In questo modo l'applicazione entrerà e rimarrà in un ciclo while finché la variabile f non sarà impostata su true.

     volatile bool f = false;
 while (!f) {
    // empty.
 }

  2. Premere F5 per avviare l'app con il debug (F5) e quindi avviare immediatamente l'esecuzione.

  3. Nel riquadro debug Variabili locali modificare il valore di f da zero a uno.

  4. Eseguire il codice come di consueto.

Compilare l'esempio

  1. Aprire un'interfaccia della riga di comando usando PowerShell, il prompt dei comandi di Windows o la shell dei comandi linux. Passare alla directory di compilazione del progetto.

  2. Dalla directory di compilazione del progetto, al prompt dei comandi eseguire CMake con i parametri seguenti:

    cmake --preset <preset-name> <source-path>

    • --preset <preset-name>

      Nome del set di impostazioni di configurazione della compilazione definito in CMakePresets.json.

    • --build <cmake-path>

      Directory binaria che contiene la cache CMake. Ad esempio, se si esegue CMake in un esempio di Azure Sphere, il comando di compilazione sarà cmake --build out/ARM-Debug.

    • <source-path>

      Percorso della directory contenente i file di origine per l'applicazione di esempio. Nell'esempio il repository di esempi di Azure Sphere è stato scaricato in una directory denominata AzSphere.

      I parametri di CMake sono separati da spazi. Il carattere di continuazione della riga (^ per la riga di comando di Windows, \ per la riga di comando linux o ' per PowerShell) può essere usato per la leggibilità, ma non è obbligatorio.

    Gli esempi seguenti illustrano i comandi CMake per un'applicazione RTApp. Dove indicato, sostituire <file-path> con il percorso di installazione per gnu Arm Embedded Toolchain nel sistema.

    Prompt dei comandi di Windows

    cmake ^
--preset "ARM-Debug" ^
"C:\AzSphere\azure-sphere-samples\Samples\HelloWorld\HelloWorld_RTApp_MT3620_BareMetal"

    Windows PowerShell

    cmake `
--preset "ARM-Debug" `
"C:\AzSphere\azure-sphere-samples\Samples\HelloWorld\HelloWorld_RTApp_MT3620_BareMetal"

  3. Eseguire Ninja per compilare l'applicazione e creare il file del pacchetto immagine:

    ninja -C out/ARM-Debug

    Ninja inserisce l'applicazione risultante e i file imagepackage nella directory specificata.

    È anche possibile richiamare Ninja tramite CMake con il comando seguente:

    cmake --build out/<binary-dir>

    Impostare <binary-dir> sulla directory binaria che contiene la cache CMake. Ad esempio, se si esegue CMake in un esempio di Azure Sphere, il comando di compilazione sarà cmake --build out/ARM-Debug.

Quando si esegue la risoluzione dei problemi, soprattutto dopo aver apportato modifiche ai comandi CMake, eliminare l'intera compilazione e riprovare.

Eseguire l'esempio

  1. Eliminare tutte le applicazioni già distribuite nel dispositivo:

    azsphere device sideload delete

  2. Dalla directory del progetto, al prompt dei comandi, caricare il pacchetto immagine creato da Ninja:

    azsphere device sideload deploy --image-package <path-to-imagepackage>

  3. Identificare l'ID componente per l'immagine:

    azsphere image-package show --image-package <path-to-imagepackage>

    Il comando restituisce tutti i metadati per il pacchetto immagine. L'ID componente per l'applicazione si trova nella sezione Identità per il tipo di immagine dell'applicazione. Ad esempio:

    Image package metadata:
Section: Identity
Image Type:           Application
Component ID:         <component id>
Image ID:             <image id>

    È possibile usare i comandi seguenti per arrestare, avviare e ottenere lo stato dell'applicazione:

    azsphere device app stop --component-id <component id>

    azsphere device app start --component-id <component id>

    azsphere device app show-status --component-id <component id>

Eseguire il debug dell'esempio

  1. Arrestare l'applicazione se è in esecuzione.

    azsphere device app stop --component-id <component id>

  2. Riavviare l'applicazione per il debug.

    azsphere device app start --component-id <component id>

    Questo comando restituisce la core su cui è in esecuzione l'applicazione.

    <component id>
App state   : running
Core        : Real-time 0

  3. Passare alla cartella Openocd per il sysroot in cui è stata creata l'applicazione. I sysroot sono installati nella cartella di installazione di Azure Sphere SDK. Ad esempio, in Windows la cartella viene installata per impostazione predefinita in C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\openocd e in Linux in /opt/azurespheresdk/Sysroots/*sysroot*/tools/sysroots/x86_64-pokysdk-linux.

  4. Eseguire openocd come illustrato nell'esempio seguente. L'esempio presuppone che l'app sia in esecuzione nella core 0. Se l'app è in esecuzione nel core 1, sostituire "targets io0" con "targets io1".

    openocd -f mt3620-rdb-ftdi.cfg -f mt3620-io0.cfg -c "gdb_memory_map disable" -c "gdb_breakpoint_override hard" -c init -c "targets io0" -c halt -c "targets"

  5. Passare alla cartella che contiene il file con estensione out dell'applicazione e avviare arm-none-eabi-gdb, che fa parte di GNU Arm Embedded Toolchain:

    Prompt dei comandi di Windows

    "C:\Program Files (x86)\GNU Arm Embedded Toolchain\9 2020-q2-update\bin\arm-none-eabi-gdb" HelloWorld_RTApp_MT3620_BareMetal.out

    Windows PowerShell

    & "C:\Program Files (x86)\GNU Arm Embedded Toolchain\9 2020-q2-update\bin\arm-none-eabi-gdb" HelloWorld_RTApp_MT3620_BareMetal.out

  6. Il server OpenOCD fornisce un'interfaccia per il server GDB su :4444. Impostare la destinazione per il debug.

    target remote :4444

  7. È ora possibile eseguire comandi gdb.

  8. L'emulatore di terminale connesso visualizzerà l'output dell'applicazione.

Usare le app partner

Quando si carica un'applicazione nel dispositivo Azure Sphere, per impostazione predefinita gli strumenti di distribuzione di Azure Sphere eliminano tutte le applicazioni esistenti. Per evitare che ciò accada quando si sviluppano applicazioni che comunicano tra loro, è necessario contrassegnare le applicazioni come partner. Quando si distribuisce una delle applicazioni, i partner non verranno eliminati. Per informazioni dettagliate, vedere Contrassegnare le applicazioni come partner.

Passaggi successivi