Eseguire il debug di applicazioni partner

1. Assicurarsi che il dispositivo sia connesso al PC tramite USB. Nel menu Imposta voce di avvio selezionare App Azure Sphere (Tutti i core) in cui App Azure Sphere è il nome del progetto di primo livello o premere F5.

   

2. Se viene richiesto di compilare il progetto, selezionare Sì. Visual Studio compila le applicazioni partner, crea pacchetti di immagini, li trasferisce localmente nella scheda e li avvia in modalità di debug. Il trasferimento locale significa che le applicazioni vengono distribuite direttamente dal PC tramite una connessione cablata, anziché recapitate tramite il cloud.

   Si notino i percorsi nell'output Visualizza>output>da: Output di compilazione, che indica il percorso dei pacchetti di immagine di output nel PC. Quando si è pronti per creare una distribuzione, è necessario conoscere i percorsi dei pacchetti immagine.

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.

Se si dispone di due app RTApp, assicurarsi che entrambe siano elencate come app partner nel file di launch.vs.json di primo livello.

Usare il debugger di Visual Studio per impostare punti di interruzione, sospendere, eseguire il passaggio, eseguire l'istruzione, 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 di Windows>oppure premere ALT+8.

1. Aprire la cartella contenente le applicazioni partner. Visual Studio Code rileva il file dell'area di lavoro e chiede se si vuole aprire l'area di lavoro. Selezionare Apri area di lavoro per aprire sia l'applicazione in tempo reale che l'applicazione di alto livello contemporaneamente.

2. Fare clic con il pulsante destro del mouse su uno dei due file CMakeLists.txt e scegliere Compila tutti i progetti.

3. Fare clic sull'icona Esegui nella barra delle attività di Visual Studio Code.

4. Nel menu a discesa visualizzato nella parte superiore della finestra sul lato sinistro della schermata selezionare Avvia app Azure Sphere (gdb)(area di lavoro).

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 le applicazioni, creare i pacchetti immagine, distribuirli nella scheda e avviarli in modalità di debug. Nel riquadro Output verranno visualizzati gli aggiornamenti dello stato.

   Prima di tutto, CMake determina se le applicazioni devono essere compilate. In tal caso, lo stato attivo passa alla finestra di output, che visualizza l'output da CMake/Build.

   Il riquadro di output mostra quindi l'output di azsphere mentre distribuisce il pacchetto immagine nel dispositivo. Infine, la console di debug riceve lo stato attivo e mostra l'output di gdb.

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>riquadro>comandi Apri visualizzazione disassembly.

1. Arrestare l'applicazione con funzionalità in tempo reale se è in esecuzione.

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

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

2. Riavviare l'applicazione con funzionalità in tempo reale con il debug.

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

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

   • Windows
   • Linux

   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. Aprire un'interfaccia della riga di comando usando PowerShell, il prompt dei comandi di Windows o la shell dei comandi linux.

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

   • Windows
   • Linux

   Prompt dei comandi di Windows

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

   Windows PowerShell

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

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

   target remote :4444

8. È ora possibile eseguire comandi gdb. Aggiungere un punto di interruzione alla funzione HandleSendTimerDeferred:

   break HandleSendTimerDeferred

9. L'emulatore del terminale connesso deve visualizzare l'output dell'applicazione con supporto in tempo reale.

10. Aprire una nuova finestra del prompt dei comandi di Azure Sphere (Windows) o terminale (Linux).

11. Passare alla cartella che contiene il file imagepackage dell'applicazione di alto livello.

12. Se l'applicazione è in esecuzione, arrestarla e quindi riavviarla con il debug:

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

13. Aprire un emulatore di terminale e stabilire una connessione Telnet o TCP alla porta 192.168.35.2 sulla porta 2342 per visualizzare l'output dell'app di alto livello.

14. Avviare gdb con il comando seguente:

    • Windows
    • Linux

    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.

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

    target remote 192.168.35.2:2345
    

16. Aggiungere un punto di interruzione alla funzione SendMessageToRTApp:

    break SendMessageToRTApp
    

17. Digitare c per continuare, osservare l'output nel terminale Telnet/TCP, quindi passare al prompt dei comandi o alla finestra del terminale contenente la sessione di debug dell'applicazione in tempo reale.

18. Digitare c per continuare e osservare l'output nella sessione seriale connessa.

È possibile lavorare avanti e indietro tra sessioni di debug, passando dall'applicazione con supporto in tempo reale all'applicazione di alto livello. L'output dovrebbe essere simile al seguente nelle due finestre di output:

Starting debugger....
                     Process /mnt/apps/25025d2c-66da-4448-bae1-ac26fcdd3627/bin/app created; pid = 40
                     Listening on port 2345
                                           Remote debugging from host 192.168.35.1, port 56522
              High-level intercore comms application
                                                    Sends data to, and receives data from a real-time capable application.
                                          Sending: hl-app-to-rt-app-00
                                                                      Sending: hl-app-to-rt-app-01

IntercoreComms_RTApp_MT3620_BareMetal
App built on: Nov 17 2020, 09:25:19
Sender: 25025d2c-66da-4448-bae1-ac26fcdd3627
Message size: 19 bytes:
Hex: 68:6c:2d:61:70:70:2d:74:6f:2d:72:74:2d:61:70:70:2d:30:30
Text: hl-app-to-rt-app-00

Per terminare ogni sessione di debug, digitare q al prompt di gdb.