Eseguire il debug di applicazioni partner

  • Articolo

  1. Verifica che il dispositivo sia connesso al PC tramite USB. Nel menu imposta elemento di avvio , seleziona App Azure Sphere (All Cores), dove App Azure Sphere è il nome del tuo progetto di primo livello o premi F5.

    Pulsante Debugger GDB remoto

  2. Se viene richiesto di creare il progetto, selezionare Sì. Visual Studio compila le applicazioni partner, crea pacchetti di immagini, li sideload sulla bacheca e li avvia in modalità debug. Il sideload significa che le applicazioni vengono fornite direttamente dal PC tramite una connessione cablata, invece che tramite cloud.

    Nota i percorsinell'output Mostraoutput>di visualizzazione> da: Output build, che indica la posizione dei pacchetti di immagini di output nel PC. Quando si è pronti per creare una distribuzione, è necessario conoscere i percorsi dei pacchetti di immagini.

  3. Per impostazione predefinita, la finestra 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 .

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

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

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

Per aprire la finestra Disassembly :

  1. Assicurarsi che il file di origine codice C contenente il punto di interruzione sia aperto in Visual Studio.
  2. Seleziona Debug>Windows>Disassembly o premi 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. Seleziona Apri area di lavoro per aprire contemporaneamente l'applicazione in tempo reale e l'applicazione di alto livello.

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

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

  4. Nel menu a discesa visualizzato nella parte superiore della finestra sul lato sinistro dello schermo, seleziona Avvia app Azure Sphere (gdb)(area di lavoro).On the pulldown menu that appears at the top of the window on the left side of the screen, select Launch Azure Sphere Apps (gdb)(workspace).

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

  6. Attendi alcuni secondi che Visual Studio Code crei le applicazioni, crei i pacchetti di immagini, li distribui alla lavagna e li avvii in modalità debug. Lungo il percorso, nel riquadro Output verranno visualizzati gli aggiornamenti di 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.

    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.

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

Mentre ti fermi a un punto di interruzione nel codice sorgente C, puoi aprire una visualizzazione Disassembly che mostra l'indirizzo corrente, i dati esadecimali non elaborati, il mnemonic assembler per il comando corrente e informazioni come i registri coinvolti o il comando codice sorgente in esecuzione.

Per aprire la visualizzazione Disassembly:

  1. Assicurarsi che il file sorgente 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 o Visualizza>tavolozza dei comandi>Apri visualizzazione disassembly.

  1. Arresta l'applicazione che supporta in tempo reale se è in esecuzione.

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

  2. Riavviare l'applicazione che supporta il debug in tempo reale.

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

  6. Passare alla cartella che contiene il file .out dell'applicazione in tempo reale che supporta e avviare arm-none-eabi-gdb, che fa parte del toolchain CPU Arm Embedded:

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

    target remote :4444

  8. È ora possibile eseguire i comandi gdb. Aggiungere un punto di interruzione in corrispondenza della funzione HandleSendTimerDeferred:

    break HandleSendTimerDeferred

  9. L'emulatore del terminale connesso deve visualizzare l'output dall'applicazione che supporta il tempo reale.

  10. Apri un nuovo prompt dei comandi di Azure Sphere (Windows) o una finestra terminale (Linux).

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

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

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

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

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

  14. Avvia gdb con il comando seguente:

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

  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. Digita c per continuare, osserva l'output nel terminale Telnet/TCP, quindi passa al prompt dei comandi o alla finestra terminale contenente la sessione di debug dell'applicazione in tempo reale.

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

È possibile spostarsi tra le sessioni di debug, passando tra l'applicazione che supporta il tempo reale e l'applicazione di alto livello. Nelle due finestre di output dovrebbe essere visualizzato un output simile al seguente:

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, digita q al prompt di gdb.