Esercitazione: Creare un'applicazione di alto livello

• Installare CMake e Ninja per Windows o per Linux.

• Installare Visual Studio Code per Windows o per Linux.
• Installare CMake e Ninja per Windows o per Linux.

• Installare l'estensione Azure Sphere per Visual Studio.

Compilare ed eseguire l'applicazione di alto livello con Visual Studio Code

Questa esercitazione usa il modello Blink di Azure Sphere, che fa parte dell'estensione Azure Sphere per Visual Studio Code. Il modello Blink lampeggia un LED in modo da poter verificare che il dispositivo e gli strumenti di Azure Sphere siano installati e configurati correttamente.

1. Avviare Visual Studio Code. Selezionare Visualizza>riquadro comandi e quindi digitare Azure Sphere: Genera nuovo progetto.

   

2. Scegliere Blink dal menu Modelli.

   

3. Visual Studio Code visualizza quindi una finestra di Esplora file. Passare alla cartella in cui si vuole inserire l'applicazione Blink. Visual Studio Code crea la cartella Blink nel percorso selezionato e genera i file di compilazione per l'applicazione Blink. Verranno visualizzati messaggi da CMake.

4. Aprire il file CMakeLists.txt e modificare l'impostazione TARGET_DIRECTORY per specificare la cartella contenente le definizioni per l'hardware in uso. Per impostazione predefinita, il TARGET_DIRECTORY specifica HardwareDefinitions/mt3620_rbd, che corrisponde al Kit di sviluppo MT3620 Seeed Azure Sphere:

   azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "HardwareDefinitions/mt3620_rdb" TARGET_DEFINITION "template_appliance.json")
   

   Vengono fornite diverse definizioni hardware con il modello. Ad esempio, se si usa una scheda di sviluppo MINI SEEED MT3620, specificare invece HardwareDefinitions/seeed_mt3620_mdb.

5. Premere F5 per compilare ed eseguire il debug del progetto. Se il progetto non è stato compilato in precedenza o se i file sono stati modificati e la ricompilazione è necessario, Visual Studio Code compilerà il progetto prima dell'avvio del debug.

6. Attendere alcuni secondi per consentire a Visual Studio Code di compilare l'applicazione, creare un pacchetto immagine, distribuirlo nella scheda e avviarlo in modalità di debug. Nel riquadro Output verranno visualizzati gli aggiornamenti dello stato.

   Prima di tutto, CMake determina se l'applicazione deve essere compilata. In tal caso, lo stato attivo passa al riquadro di output, che visualizza l'output di CMake/Build.

   Il riquadro di output mostra quindi l'output di Azure Sphere durante la distribuzione del pacchetto immagine nel dispositivo. Infine, la console di debug riceve lo stato attivo e mostra l'output di gdb.

   Suggerimento

   Prendere nota del percorso del pacchetto immagine, perché sarà necessario quando si crea una distribuzione. Verrà visualizzato un messaggio come "Compila file scritti <nel percorso>" nella finestra Output , dove <percorso> è il percorso completo della cartella di compilazione dell'applicazione Blink, che termina in genere in "out\ARM-Debug" o "out/ARM-Debug".

7. Dopo un breve ritardo, dovrebbe essere visualizzato un LED lampeggiante.

8. Impostare un punto di interruzione in main.c ed eseguire l'applicazione, in modo da esplorare le funzionalità di debug di Visual Studio Code per Azure Sphere.

Compilare ed eseguire l'applicazione di alto livello con Visual Studio

Questa esercitazione usa il modello Blink di Azure Sphere, che fa parte dell'estensione Azure Sphere per Visual Studio. Il modello Blink lampeggia un LED in modo da poter verificare che il dispositivo e gli strumenti di Azure Sphere siano installati e configurati correttamente.

1. Se si è poco esperti di Visual Studio, è consigliabile consultare l'Avvio rapido o la Presentazione guidata per informazioni su come esplorarlo e usarlo.

2. Aprire Visual Studio e selezionare Crea un nuovo progetto. Nella casella Di ricerca digitare "azure sphere" per ottenere un elenco di modelli di Azure Sphere. Scegliere Azure Sphere Blink dall'elenco.

3. Immettere un nome e un percorso per il progetto e quindi selezionare Crea.

4. Aprire il file CMakeLists.txt e modificare l'impostazione TARGET_DIRECTORY per specificare la cartella contenente le definizioni per l'hardware in uso. Per impostazione predefinita, il TARGET_DIRECTORY specifica HardwareDefinitions/mt3620_rbd, che corrisponde al Kit di sviluppo MT3620 Seeed Azure Sphere:

   azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "HardwareDefinitions/mt3620_rdb" TARGET_DEFINITION "template_appliance.json")
   

   Vengono fornite diverse definizioni hardware con il modello. Ad esempio, se si usa una scheda di sviluppo MINI SEEED MT3620, specificare invece HardwareDefinitions/seeed_mt3620_mdb.

5. In Visual Studio selezionare Visualizza>output per visualizzare il riquadro Output.

6. Assicurarsi che il dispositivo sia connesso al PC tramite USB. Nel menu Imposta voce di avvio selezionare App Azure Sphere (HLCore) in cui l'app Azure Sphere è il nome dell'applicazione di alto livello corrente o premere F5.

   

7. Se viene richiesto di compilare il progetto, selezionare Sì. Visual Studio compila l'applicazione, crea un pacchetto immagine, la trasferisce localmente nella scheda e la avvia in modalità di debug. Trasferimento locale significa che l'applicazione viene distribuita direttamente dal computer tramite una connessione cablata, invece che tramite il cloud.

   Suggerimento

   Prendere nota del percorso del pacchetto immagine, perché sarà necessario durante la creazione di una distribuzione. Verrà visualizzato un messaggio come "Il file di output si trova in corrispondenza del <percorso>" nell'output in Visualizza>output Mostra output>da: Build, dove <percorso> è il percorso completo della cartella di compilazione dell'applicazione Blink, che termina in genere in "out/ARM-Debug".

8. Per impostazione predefinita, il riquadro Output mostra l'output dell'output del dispositivo. Per visualizzare i messaggi del debugger, selezionare Debug dal menu a discesa Mostra output di:. È anche possibile esaminare il disassembly, i registri o la memoria del programma tramite il menu Debug>Windows.

9. Quando si esegue il programma, si dovrebbe vedere un LED lampeggiante.

Scaricare l'applicazione di esempio

È possibile scaricare l'applicazione HelloWorld come segue:

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.

Compilare l'esempio

Per creare i file della compilazione e i file con estensione imagepackage per l'applicazione di esempio HelloWorld_HighLevelApp, seguire questi passaggi.

1. Aggiornare l'esempio in modo che sia destinato all'hardware in uso, se necessario. Per impostazione predefinita, l'hardware di destinazione degli esempi che segue la progettazione della scheda di riferimento MT3620 (RDB), ad esempio il Kit di sviluppo MT3620 di Seeed Studios. Le definizioni hardware di destinazione aggiuntive per le applicazioni di esempio sono disponibili nella directory HardwareDefinitions del repository di esempi di Azure Sphere. Ad esempio, i file di definizione hardware per avnet MT3620 Starter Kit si trovano nella sottodirectory HardwareDefinitions/avnet_mt3620_sk.

   • Aprire CMakeLists.txt e aggiornare il parametro TARGET_DIRECTORY nella funzione azure_target_hardware_definition in modo che punti alla sottodirectory per l'hardware. Ad esempio:

     azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "../../../HardwareDefinitions/avnet_mt3620_sk" TARGET_DEFINITION "sample_appliance.json")
     

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

3. 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 l'app di alto livello Hello World:

   • Windows
   • Linux

   Prompt dei comandi di Windows

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

   Windows PowerShell

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

4. 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 eventuali applicazioni già in esecuzione nel dispositivo:

   azsphere device sideload delete
   

2. Passare alla directory contenente i file build e .imagepackage creati in precedenza.

3. Caricare il pacchetto immagine nel dispositivo eseguendo il comando azsphere device sideload deploy e specificando il pacchetto immagine. Ad esempio:

   • Interfaccia della riga di comando di Azure Sphere
   • Interfaccia della riga di comando classica di Azure Sphere

   azsphere device sideload deploy --image-package HelloWorld_HighLevelApp.imagepackage
   

   Questo comando carica il pacchetto immagine e avvia l'applicazione. Verrà visualizzato un LED lampeggiante.

   Suggerimento

   Prendere nota del percorso del pacchetto immagine. Il pacchetto immagine sarà utile in un secondo momento nella Guida introduttiva alla distribuzione.

Eseguire il debug dell'esempio

1. Passare alla directory contenente i file build e .imagepackage creati in precedenza.

2. Ottenere l'ID componente se non è già disponibile:

   • Interfaccia della riga di comando di Azure Sphere
   • Interfaccia della riga di comando classica di Azure Sphere

   azsphere image-package show --image-package HelloWorld_HighLevelApp.imagepackage
   

1. Se l'applicazione è in esecuzione, arrestarla e quindi riavviarla con l'opzione --debug-mode :

   • Interfaccia della riga di comando di Azure Sphere
   • Interfaccia della riga di comando classica di Azure Sphere

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

   azsphere device app start --debug-mode --component-id <ComponentId>
   

Dovrebbe essere visualizzato quanto segue:

 <ComponentId>
 App state   : debugging
 GDB port    : 2345
 Output port : 2342
 Core        : High-level

1. Usare un client terminale per stabilire una connessione TCP non elaborata o Telnet per leggere il flusso di output dal processo. Specificare 192.168.35.2 come indirizzo IP e 2342 come porta.

2. Aprire un'interfaccia della riga di comando usando PowerShell o un prompt dei comandi standard in Windows o la shell dei comandi in Linux e passare il file binario dell'app con estensione out dalla compilazione come parametro. In questo modo verrà abilitato il debug completo del codice sorgente.

   • Windows
   • Linux

   Prompt dei comandi di Windows

   "C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\gcc\arm-poky-linux-musleabi-gdb" HelloWorld_HighLevelApp.out
   

   Windows PowerShell

   & "C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\gcc\arm-poky-linux-musleabi-gdb" HelloWorld_HighLevelApp.out
   

   Nota

   Azure Sphere SDK viene fornito con più sysroot in modo che le applicazioni possano avere come destinazione set di API diversi, come descritto in Versione del runtime dell'applicazione, sysroot e API Beta. I sysroot sono installati nella cartella di installazione di Azure Sphere SDK in Sysroots.

3. Impostare la destinazione di debug remoto sull'indirizzo IP 192.168.35.2 sulla porta 2345:

   target remote 192.168.35.2:2345

4. Eseguire qualsiasi altro comando gdb scelto. Ad esempio, i comandi seguenti impostano un punto di interruzione alla voce su main() e quindi continuano l'esecuzione dopo il punto di interruzione, rispettivamente.

   break main
   

   c
   

   Per altre informazioni sul debug con gdb, vedere GDB: The GNU Project Debugger o una delle altre numerose origini sull'argomento.