Esercitazione: Creare un'applicazione in tempo reale

  • Articolo

In questa esercitazione viene illustrato come creare un'applicazione di esempio per i core in tempo reale in un dispositivo Azure Sphere. Per informazioni di base sulle applicazioni in tempo reale, vedere Panoramica delle applicazioni Azure Sphere .

In questa esercitazione imparerai come:

  • Scaricare un'applicazione di esempio
  • Installare il porta toolchain ARM DIVA
  • Configurare l'hardware per la visualizzazione dell'output
  • Abilitare lo sviluppo e il debug
  • Avviare un emulatore di terminale per visualizzare l'output
  • Creare, eseguire ed eseguire il debug di un'applicazione in tempo reale

Importante

Queste istruzioni presuppongono l'uso di hardware che segue l'hardware per la progettazione della scheda di riferimento (RDB, Reference Board Design) MT3620, ad esempio MT3620 Dev Kit di Seeed Studios. Se usi hardware Azure Sphere diverso, consulta la documentazione del produttore per scoprire se l'oggetto 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 oggetto UART diverso.

Prerequisiti

Scaricare l'applicazione di esempio

Puoi scaricare l'applicazione HelloWorld come segue:

  1. Punta il browser al browser Microsoft Samples.
  2. Digita "Azure Sphere" nella casella Search.
  3. Seleziona Azure Sphere - Hello World dai risultati della ricerca.
  4. Seleziona Scarica ZIP.
  5. Aprire il file scaricato ed estrarre il file in una directory locale.

Installare il toolchain ARM Embedded di HUX

È possibile scaricare e installare il toolchain PSTL Arm Embedded dal sito Web per sviluppatori Arm. In alternativa, è possibile usare gli elementi vcpkg per installare e configurare automaticamente l'ambiente di sviluppo.

  • Visual Studio 2022: se si usa Visual Studio 2022, installare IL TOOLCHAIN (arm-none-eabi) DIED (ARM Embedded Toolchain) 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 usi Visual Studio 2019, vai a Configurare l'hardware per la visualizzazione dell'output. Tuttavia, se è stato installato manualmente il toolchainCELL ARM Embedded, Visual Studio userà la versione installata.

Per installare il toolchain, sul sito Web per sviluppatori Arm, individuare il TOOLCHAIN (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 il toolchain e dovrebbe trovare la versione installata. Se si verificano problemi di compilazione relativi al toolchain, immettere il percorso nel modo seguente:

  1. Seleziona Impostazioni impostazioni impostazioni>> file >Estensioni>Azure Sphere.
  2. Immettere il percorso di installazione del toolchain ARM Embedded in AZURE Sphere: Arm Directory .

Per installare il toolchain, sul sito Web per sviluppatori Arm, individuare il TOOLCHAIN (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 la visualizzazione dell'output

Attualmente, ogni core in tempo reale supporta un oggetto UART solo TX. RTApps può usare questo oggetto UART per inviare l'output del log dal dispositivo. Durante lo sviluppo e il debug delle applicazioni, in genere è necessario un modo per leggere e visualizzare l'output. L'esempio HelloWorld_RTApp_MT3620_BareMetal mostra come un'applicazione può scrivere nell'oggetto UART.

Usa un adattatore da USB a seriale, ad esempio FTDI Friend, per collegare l'UART nel core in tempo reale a una porta USB del computer. È inoltre necessario un emulatore di terminale per stabilire una connessione seriale con 115200-8-N-1 impostazioni del terminale (115200 bps, 8 bit, nessun bit di parità, un bit di interruzione) per visualizzare l'output.

Per configurare l'hardware per la visualizzazione dell'output da un'RTApp, seguire questa procedura. Dovrai fare riferimento alla documentazione del produttore dell'hardware per determinare le posizioni dei pin. Se usi hardware che segue l'hardware per la progettazione della scheda di riferimento (RDB) MT3620, come MT3620 Dev Kit di Seeed Studios, l'analisi delle intestazioni dell'interfaccia RDB può aiutarti a determinare le posizioni dei pin.

  1. Collega GND sull'adattatore da USB a seriale a GND nel tuo dev kit. Sull'hardware MT3620 RDB, GND è Header 3, pin 2.
  2. Collega RX sull'adattatore da USB a seriale a IOM4-0 TX nel kit di sviluppo. Sull'hardware MT3620 RDB, IOM4-0 TX è Header 3, pin 6.
  3. Collega l'adattatore da USB a seriale a una porta USB gratuita del computer di sviluppo e determina a quale porta è collegato il dispositivo seriale. In Windows, avvia Gestione dispositivi, seleziona Visualizza>dispositivi per contenitore e cerca "USB UART". Ad esempio, FT232R USB UART indica l'adattatore FTDI Friend.
  4. Avvia un programma di emulatore terminale e apri un terminale 115200-8-N-1 sulla porta COM utilizzata dall'adattatore. Consulta la documentazione dell'emulatore del terminale per scoprire come specificare la porta e la velocità.

Configurare l'hardware per la visualizzazione dell'output

Attualmente, ogni core in tempo reale supporta un oggetto UART solo TX. RTApps può usare questo oggetto UART per inviare l'output del log dal dispositivo. Durante lo sviluppo e il debug delle applicazioni, in genere è necessario un modo per leggere e visualizzare l'output. L'esempio HelloWorld_RTApp_MT3620_BareMetal mostra come un'applicazione può scrivere nell'oggetto UART.

Usa un adattatore da USB a seriale, ad esempio FTDI Friend, per collegare l'UART nel core in tempo reale a una porta USB del computer. È inoltre necessario un emulatore di terminale per stabilire una connessione seriale con 115200-8-N-1 impostazioni del terminale (115200 bps, 8 bit, nessun bit di parità, un bit di interruzione) per visualizzare l'output.

Per configurare l'hardware per la visualizzazione dell'output da un'RTApp, seguire questa procedura. Dovrai fare riferimento alla documentazione del produttore dell'hardware per determinare le posizioni dei pin. Se usi hardware che segue l'hardware per la progettazione della scheda di riferimento (RDB) MT3620, come MT3620 Dev Kit di Seeed Studios, l'analisi delle intestazioni dell'interfaccia RDB può aiutarti a determinare le posizioni dei pin.

  1. Collega GND sull'adattatore da USB a seriale a GND nel tuo dev kit. Sull'hardware MT3620 RDB, GND è Header 3, pin 2.

  2. Collega RX sull'adattatore da USB a seriale a IOM4-0 TX nel kit di sviluppo. Sull'hardware MT3620 RDB, IOM4-0 TX è Header 3, pin 6.

  3. Collega l'adattatore da USB a seriale a una porta USB gratuita del computer di sviluppo e determina a quale porta è collegato il dispositivo seriale.

    • In Windows, avvia Gestione dispositivi, seleziona Visualizza>dispositivi per contenitore e cerca "USB UART". Ad esempio, FT232R USB UART indica l'adattatore FTDI Friend.

    • Su Linux digita il comando seguente:

      dmesg | grep ttyUSB

      La porta deve essere denominata ttyUSBn, dove n indica il numero di porta. Se il dmesg comando elenca più porte USB, quella collegata all'ultima di solito segnalata come collegata. Ad esempio, nei seguenti casi 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. Avvia un programma di emulatore terminale e apri un terminale 115200-8-N-1 sulla porta COM utilizzata dall'adattatore. Consulta la documentazione dell'emulatore del terminale per scoprire come specificare la porta e la velocità.

Abilitare lo sviluppo e il debug

Prima di poter creare un'applicazione di esempio nel 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 di applicazioni in fase di sviluppo da un PC e non consentono 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.

Per eseguire il debug sui core in tempo reale, utilizza il comando di abilitazione-sviluppo del dispositivo az sphere . Questo comando configura il dispositivo in modo da accettare le applicazioni da un PC per il debug e assegna il dispositivo al gruppo di dispositivi di 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 che gli aggiornamenti delle applicazioni cloud non sovrascriva l'applicazione in fase di sviluppo.

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. Se non l'hai già fatto, accedi ad Azure Sphere:

    az 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 driver USB per il debugger.

  3. Immettere il comando seguente:

    az sphere device enable-development --enable-rt-core-debugging  --catalog <CatalogName>  --resource-group <ResourceGroupName>

  4. Chiudere la finestra al termine del comando perché il privilegio di amministratore non è più necessario. Come procedura consigliata, è consigliabile usare sempre il privilegio più basso che può eseguire un'attività.

Se il comando di abilitazione-sviluppo del dispositivo az sphere non riesce, vedi Risolvere i problemi di Azure Sphere per assistenza.

Creare ed eseguire l'applicazione HelloWorld RTApp con Visual Studio

  1. Avviare Visual Studio. Seleziona Apri una cartella locale, passa alla cartella in cui è stato estratto il file di Azure_Sphere___Hello_World.zip scaricato e quindi seleziona la cartella HelloWorld_RTApp_MT3620_Baremetal.

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

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

  4. Nella finestra Output di Visual Studio , l'output CMake deve mostrare i messaggi CMake generation started. e CMake generation finished..

  5. Seleziona Compila compila>tutto. Se il menu non è presente, aprire Esplora soluzioni, fare clic con il pulsante destro del mouse sul file CMakeLists.txt e scegliere Genera. La posizione di output dell'applicazione HelloWorld_RTApp_MT3620_Baremetal viene visualizzata nella finestra Output .

  6. Nel menu Seleziona elemento di avvio seleziona HelloWorld_RTApp_MT3620_Baremetal (RTCore).On the Select Startup Item menu, select HelloWorld_RTApp_MT3620_Baremetal (RTCore).

  7. Premere F5 per distribuire l'applicazione.

  8. L'emulatore del terminale connesso deve visualizzare 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.

Creare 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 di Azure_Sphere___Hello_World.zip scaricato. Se ti viene richiesto di selezionare un kit, scegli Non usare un kit.

  2. Se non usi l'hardware MT3620 RDB, aggiorna il file app_manifest.json e il codice di esempio per specificare l'oggetto UART corretto, ad esempio ISU1.

  3. Premere F5 per avviare il debugger. Se il progetto non è stato creato in precedenza o se i file sono stati modificati e la ricostruzione è obbligatoria, Visual Studio Code crea il progetto prima dell'inizio del debug.

  4. La finestra di output di Azure Sphere dovrebbe mostrare "Immagine di distribuzione..." seguito dai percorsi dell'SDK e del compilatore.

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

    Tick

    Tock

  6. Usa 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 relativi

L'applicazione potrebbe iniziare l'esecuzione prima di OpenOCD effettua una connessione. Di conseguenza, i punti di interruzione impostati all'inizio del codice potrebbero non essere presenti. Una soluzione alternativa consiste nel posticipare l'avvio dell'app finché OpenOCD non si connette.

  1. Inserire il codice seguente all'inizio del punto di ingresso dell'applicazione RTCoreMain. In questo modo l'applicazione verrà immessa e rimarrà in un while ciclo fino a quando la variabile f non viene impostata su true.

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

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

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

  4. Scorrere il codice come al solito.

Creare l'esempio

  1. Aprire un'interfaccia della riga di comando usando PowerShell, il prompt dei comandi di Windows o la shell dei comandi di Linux. Passare alla directory della build 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 preimpostato per la configurazione della build, come definito in CMakePresets.json.

    • --build <cmake-path>

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

    • <source-path>

      Percorso della directory che contiene i file di origine per l'applicazione di esempio. Nell'esempio, il repository di campioni Azure Sphere è stato scaricato in una directory denominata AzSfera.

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

    Gli esempi seguenti mostrano i comandi CMake per un'RTApp. Se indicato, sostituire <file-path> con il percorso di installazione per il toolchain ARM Embedded DI CUI 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. Esegui Ninja per creare l'applicazione e creare il file del pacchetto di immagini:

    ninja -C out/ARM-Debug

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

    Puoi anche 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 su un esempio di Azure Sphere, il comando di compilazione sarà cmake --build out/ARM-Debug.

Durante la risoluzione dei problemi, soprattutto dopo aver apportato modifiche ai comandi di CMake, eliminare l'intera build e riprovare.

Eseguire l'esempio

  1. Eliminare le applicazioni già distribuite nel dispositivo:

    az sphere device sideload delete

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

    az sphere device sideload deploy --image-package <path-to-imagepackage>

    L'applicazione inizierà a essere eseguita subito dopo il caricamento. Nell'emulatore del terminale connesso verranno visualizzati i seguenti elementi:

    Tick

Tock

Tick
.
.
.

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

    az sphere image-package show --image-package <path-to-imagepackage>

    Il comando restituisce tutti i metadati per il pacchetto di immagini. L'ID componente per l'applicazione viene visualizzato nella sezione Identity relativa al tipo di immagine dell'applicazione. Per esempio:

    ...
  "Identity": {
    "ComponentId": "<component-id>",
    "ImageId": "<image-id>",
    "ImageType": "Application"
  },
...

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

    az sphere device app stop --component-id <component id>

    az sphere device app start --component-id <component id>

    az sphere device app show-status --component-id <component id>

Eseguire il debug dell'esempio

  1. Interrompere l'applicazione se è in esecuzione.

    az sphere device app stop --component-id <component id>

  2. Riavviare l'applicazione per il debug.

    az sphere device app start --debug-mode true  --component-id <component id>

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

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

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

  4. Esegui openocd come illustrato nell'esempio seguente. L'esempio presuppone che l'app sia in esecuzione sul core 0. Se l'app è in esecuzione sul core 1, sostituisci "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 .out dell'applicazione e avviare arm-none-eabi-gdb, che fa parte del toolchain EMBEDDED DINNETTE:

    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 server GDB su :4444. Impostare la destinazione per il debug.

    target remote :4444

  7. È ora possibile eseguire i comandi gdb.

  8. L'emulatore del terminale connesso deve visualizzare l'output dall'applicazione.

Usare le app dei partner

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

Passaggi successivi