Esercitazione: Creare un'applicazione di alto livello

Un'applicazione di alto livello viene eseguita nel sistema operativo Azure Sphere, usa le librerie di applicazioni Azure Sphere e può comunicare con Internet e con i servizi basati sul cloud. Per informazioni di base sulle applicazioni di alto livello, vedere Panoramica delle applicazioni Azure Sphere .

In questa esercitazione imparerai come:

• Preparare il dispositivo per lo sviluppo e il debug
• Compilare, eseguire ed eseguire il debug di un'applicazione di alto livello

Prerequisiti

• Installa CMake e Ninja per Windows o per Linux.

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

• Installa Visual Studio e l'estensione Azure Sphere.

• Installa l'SDK per Windows o per Linux.
• Scegli un catalogo e richiedi il tuo dispositivo.
• Configurare la rete e aggiornare il sistema operativo del dispositivo.

Preparare il dispositivo per lo sviluppo e il debug

Prima di poter creare un'applicazione di esempio sul dispositivo Azure Sphere o sviluppare nuove applicazioni, è necessario abilitare lo sviluppo e il sideload. Per impostazione predefinita, i dispositivi Azure Sphere sono "bloccati"; ovvero non consentono il caricamento di applicazioni in fase di sviluppo da un computer e non consentono il debug delle applicazioni. La preparazione del dispositivo per il sideload rimuove questa restrizione.

Il comando az sphere device enable-development configura il dispositivo per accettare applicazioni per il debug, carica il server di debug nel dispositivo e assegna il dispositivo a un gruppo di dispositivi 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.

1. Assicurarsi che il dispositivo Azure Sphere sia connesso al computer e che il computer sia connesso a Internet.

2. Aprire un'interfaccia della riga di comando usando PowerShell, il prompt dei comandi di Windows o la shell dei comandi di Linux.

3. Immettere il comando seguente:

   az sphere device enable-development --resource-group <ResourceGroupName> --catalog <CatalogName> --device <DeviceIdValue>
   

   L'output dovrebbe essere simile al seguente:

   Getting device capability configuration for application development.
   Downloading device capability configuration for device ID '<device ID>'.
   Successfully downloaded device capability configuration.
   Successfully wrote device capability configuration file 'C:\Users\user\AppData\Local\Temp\tmpD732.tmp'.
   Setting device group ID 'a6df7013-c7c2-4764-8424-00cbacb431e5' for device with ID '<device ID>'.
   Successfully disabled over-the-air updates.
   Enabling application development capability on attached device.
   Applying device capability configuration to device.
   Successfully applied device capability configuration to device.
   The device is rebooting.
   Installing debugging server to device.
   Deploying 'C:\Program Files (x86)\Microsoft Azure Sphere SDK\DebugTools\gdbserver.imagepackage' to the attached device.
   Image package 'C:\Program Files (x86)\Microsoft Azure Sphere SDK\DebugTools\gdbserver.imagepackage' has been deployed to the attached device.
   Application development capability enabled.
   Successfully set up device '<device ID>' for application development, and disabled over-the-air updates.
   Command completed successfully in 00:00:38.3299276.
   

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 di alto livello con Visual Studio Code

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

1. Avvia Visual Studio Code. Seleziona Visualizza>tavolozza comandi e quindi digita "Azure Sphere: Genera nuovo progetto".

2. Selezionare Lampeggia dal menu Modelli.

1. Visual Studio Code visualizza quindi una finestra Esplora file. Passare alla cartella in cui si vuole posizionare l'applicazione Lampeggia. Visual Studio Code crea la cartella Blink nella posizione selezionata e genera i file di compilazione per l'applicazione Blink. Dovrebbero essere visualizzati i messaggi da CMake.

2. Aprire il file di 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 Seeed Azure Sphere MT3620 Development Kit:

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

   Con il modello vengono fornite diverse definizioni hardware. Ad esempio, se si usa una scheda Mini Dev MT3620 SEEED, specificare HardwareDefinitions/seeed_mt3620_mdb.

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

4. Attendi alcuni secondi che Visual Studio Code crei l'applicazione, crei un pacchetto di immagini, lo distribuisci alla bacheca e lo avvii in modalità debug. Lungo il percorso, nel riquadro Output verranno visualizzati gli aggiornamenti di 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 da CMake/Build.

   Successivamente, il riquadro di output mostra l'output durante la distribuzione del pacchetto di immagini nel dispositivo. Infine, la console di debug riceve lo stato attivo e mostra l'output gdb.

   Mancia

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

5. Dopo un breve ritardo, dovrebbe lampeggiare un LED.

6. Imposta un punto di interruzione in un punto qualsiasi in main.c e scorro nell'applicazione in modo da poter esplorare le funzionalità di debug di Visual Studio Code per Azure Sphere.

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

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

1. Se non sei nuovo di Visual Studio, prendi in considerazione la Guida introduttiva o la Presentazione guidata per informazioni sull'esplorazione e l'uso.

2. Apri Visual Studio e seleziona Crea un nuovo progetto. Nella casella Search digita "sfera azure" per ottenere un elenco dei modelli Azure Sphere. Scegliere Azure Sphere Blink dall'elenco.

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

4. Aprire il file di 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 Seeed Azure Sphere MT3620 Development Kit:

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

   Con il modello vengono fornite diverse definizioni hardware. Ad esempio, se si usa una scheda Mini Dev MT3620 SEEED, specificare HardwareDefinitions/seeed_mt3620_mdb.

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

6. Verifica che il dispositivo sia connesso al PC tramite USB. Nel menu Imposta elemento di avvio , premi F5 o seleziona l'app Azure Sphere (HLCore)* dove l'app Azure Sphere è il nome dell'applicazione di alto livello corrente.

7. Se viene richiesto di creare il progetto, selezionare Sì. Visual Studio compila l'applicazione, crea un pacchetto di immagini, lo sideload sulla bacheca e lo avvia in modalità debug. Il sideload significa che l'applicazione viene fornita direttamente dal PC tramite una connessione cablata, invece che tramite cloud.

   Mancia

   Prendere nota della posizione del pacchetto di immagini, come sarà necessario durante la creazione di una distribuzione. Dovrebbe essere visualizzato un messaggio come "Il file di output è in:< 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 con "out/ARM-Debug".

8. Per impostazione predefinita, il riquadro Output mostra l'output da Output dispositivo. Per visualizzare i messaggi del debugger, selezionare Debug dal menu a discesa Mostra output da : . Puoi anche esaminare lo smontaggio del programma, i registri o la memoria tramite il menu Debug>Di Windows .

9. Quando esegui il programma, dovresti vedere un LED lampeggiare.

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.

Creare l'esempio

Per creare i file build e imagepackage per l'applicazione di esempio HelloWorld_HighLevelApp, seguire questa procedura.

1. Aggiorna l'esempio per l'hardware di destinazione, se necessario. Per impostazione predefinita, i campioni dell'hardware di destinazione che segue la progettazione della scheda di riferimento MT3620 (RDB), ad esempio MT3620 Development Kit di Seeed Studios. Ulteriori definizioni hardware di destinazione per le applicazioni di esempio sono disponibili nella directory HardwareDefinitions del repository Azure Sphere Samples. 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 dell'hardware. Per 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 di Linux. Passare alla directory della build 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 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 l Hello World'app di alto livello:

   Finestre

   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"
   

   Linux

   cmake \
    --preset "ARM-Debug" \
    ./AzSphere/azure-sphere-samples/Samples/HelloWorld/HelloWorld_HighLevelApp
   

4. 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. Se il dispositivo esegue già un'applicazione, eliminarla:

   az sphere device sideload delete
   

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

3. Caricare il pacchetto di immagini nel dispositivo eseguendo il comando di distribuzione sideload del dispositivo az sphere e specificando il pacchetto di immagini. Per esempio:

   az sphere device sideload deploy --image-package HelloWorld_HighLevelApp.imagepackage
   

   Questo comando carica il pacchetto di immagini e avvia l'applicazione. Dovresti vedere un LED lampeggiare.

   Mancia

   Prendere nota del percorso del pacchetto di immagini. Userai il pacchetto di immagini in un secondo momento nella Guida introduttiva alla distribuzione.

Eseguire il debug dell'esempio

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

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

   az sphere image-package show --image-package HelloWorld_HighLevelApp.imagepackage
   

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

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

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

   Dovresti vedere:

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

4. Utilizzare un client terminale per stabilire una connessione TCP Telnet o raw per leggere il flusso di output dal processo. Specificare 192.168.35.2 come indirizzo IP e 2342 come porta.

5. Apri un'interfaccia della riga di comando usando PowerShell o un prompt dei comandi standard in Windows o una shell dei comandi su Linux e passa il file binario dell'app .out dalla build come parametro. In questo modo verrà abilitato il debug del codice sorgente completo.

   Finestre

   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
   

   Linux

    /opt/azurespheresdk/Sysroots/*sysroot*/tools/sysroots/x86_64-pokysdk-linux/usr/bin/arm-poky-linux-musleabi/arm-poky-linux-musleabi-gdb HelloWorld_HighLevelApp.out
   

---

Nota

Azure Sphere SDK viene fornito con più sysroot in modo che le applicazioni possano essere destinate a set DI API diversi, come descritto nella versione di Runtime dell'applicazione, sysroots e API Beta. I sysroot vengono installati nella cartella di installazione di Azure Sphere SDK in Sysroots.

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

   target remote 192.168.35.2:2345

2. Esegui tutti gli altri comandi gdb che scegli. Ad esempio, i comandi seguenti impostano un punto di interruzione all'immissione su main() e quindi continuano l'esecuzione dopo il punto di interruzione, rispettivamente.

   break main
   

   c
   

   Per ulteriori informazioni sul debug con gdb, vedere GDB: The KERNEL PROJECT Debugger o una delle altre numerose fonti sull'argomento.

Passaggi successivi

Hai creato un'applicazione di alto livello da eseguire nel tuo dispositivo Azure Sphere. È consigliabile modificarlo ora. Le definizioni hardware descrivono come modificare un file JSON delle definizioni hardware e generare nuovamente il file di intestazione associato.

Scopri quindi come distribuire l'applicazione di alto livello dal cloud.

Esercitazione: Creare una distribuzione cloud

Vedere anche

Visita la Raccolta sfere di Azure, una raccolta di script, utilità e funzioni di Azure Sphere, di ispirazione, non mantenuti e riutilizzabili.