Condividi tramite

Eseguire il debug di un'applicazione di alto livello

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

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

    Pulsante Debugger GDB remoto

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

    Si noti l'ID immagine del pacchetto immagine nell'output Visualizza>output>da: Output di compilazione. L'ID immagine verrà usato più avanti in Esercitazione: Creare una distribuzione cloud.

  3. Per impostazione predefinita, nella finestra Output viene visualizzato 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.

È quindi possibile usare il debugger di Visual Studio per impostare punti di interruzione, sospendere, eseguire il passaggio, eseguire l'istruzione, riavviare o arrestare l'applicazione.

Durante l'arresto in corrispondenza di un punto di interruzione nel codice sorgente C, è possibile aprire una finestra Disassembly che mostra l'indirizzo corrente, l'assembler mnemonic per il comando corrente e informazioni quali i registri coinvolti o il comando del codice sorgente in esecuzione.

Per aprire la finestra Disassembly :

  1. Assicurarsi che il file sorgente del codice C contenente il punto di interruzione sia aperto in Visual Studio.
  2. Selezionare Debug>disassembly>oppure premere ALT+8.

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

  2. 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 alla finestra di output, che visualizza l'output da CMake/Build.

    Il riquadro Output mostra quindi il risultato quando il pacchetto immagine viene distribuito nel dispositivo. Infine, la console di debug riceve lo stato attivo e mostra l'output del debugger.

Usare il debugger di Visual Studio Code per impostare punti di interruzione, sospendere, eseguire il passaggio, eseguire l'istruzione, riavviare o arrestare l'applicazione.

Durante l'arresto in corrispondenza di un punto di interruzione nel codice sorgente C, è possibile aprire una visualizzazione Disassembly che mostra l'indirizzo corrente, i dati esadecimali non elaborati, l'assembler mnemonic per il comando corrente e informazioni quali i registri coinvolti o il comando del codice sorgente in esecuzione.

Per aprire la visualizzazione Disassembly:

  1. Verificare che il file sorgente del codice C contenente il punto di interruzione sia aperto in un editor di Visual Studio Code.
  2. Fare clic con il pulsante destro del mouse nella finestra dell'editor e scegliere Apri visualizzazione disassembly oppure selezionare Visualizza>>comandi Apri visualizzazione disassembly.

Per eseguire il debug dell'applicazione, arrestarla e quindi riavviarla con il debug:

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
Command completed successfully in 00:00:00.9121174.

  1. Aprire un prompt dei comandi e usare qualsiasi client terminale Windows 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, il prompt dei comandi di Windows o la shell dei comandi linux. Avviare il debugger della riga di comando gdb :

    Prompt dei comandi di Windows

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

    Windows PowerShell

    & "C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\gcc\arm-poky-linux-musleabi-gdb.exe" IntercoreComms_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 tutti i comandi gdb scelti. Ad esempio:

    break main

    c

    I comandi break e c impostano, nell'ordine, un punto di interruzione all'inserimento di main() per poi continuare l'esecuzione dopo il punto di interruzione. Sono disponibili diversi documenti relativi a gdb.