Condividi tramite

Creare un'applicazione in tempo reale

  • Articolo

È possibile usare Visual Studio, Visual Studio Code o la riga di comando (CLI) per sviluppare ed eseguire il debug di applicazioni in tempo reale (RTApp) allo stesso modo delle applicazioni di alto livello.

Prerequisiti

Abilitare lo sviluppo e il debug

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

Per eseguire il debug sui core in tempo reale, utilizza il comando di abilitazione-sviluppo del dispositivo az sphere . Questo comando configura il dispositivo in modo da accettare le applicazioni da un PC per il debug e assegna il dispositivo al gruppo di dispositivi di sviluppo, 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.

In Windows, è necessario aggiungere il --enable-rt-core-debugging parametro, che carica i server di debug e i driver necessari per ogni tipo di core nel dispositivo.

  1. Se non l'hai già fatto, accedi ad Azure Sphere:

    az login

  2. Aprire un'interfaccia della riga di comando usando PowerShell o il prompt dei comandi di Windows con privilegi di amministratore. Il --enable-rt-core-debugging parametro richiede privilegi di amministratore perché installa driver USB per il debugger.

  3. Immettere il comando seguente:

    az sphere device enable-development --enable-rt-core-debugging  --catalog <CatalogName>  --resource-group <ResourceGroupName>

  4. Chiudere la finestra al termine del comando perché il privilegio di amministratore non è più necessario. Come procedura consigliata, è consigliabile usare sempre il privilegio più basso che può eseguire un'attività.

Se il comando di abilitazione-sviluppo del dispositivo az sphere non riesce, vedi Risolvere i problemi di Azure Sphere per assistenza.

Abilitare lo sviluppo e il debug

Prima di poter creare un'applicazione di esempio nel dispositivo Azure Sphere o sviluppare nuove applicazioni, è necessario abilitare lo sviluppo e il debug. Per impostazione predefinita, i dispositivi Azure Sphere sono "bloccati"; ovvero, non consentono il caricamento di applicazioni in fase di sviluppo da un PC e non consentono il debug delle applicazioni. La preparazione del dispositivo per il debug rimuove questa restrizione e carica il software necessario per il debug e sblocca le funzionalità del dispositivo come descritto in Funzionalità e comunicazione del dispositivo.

Per eseguire il debug sui core in tempo reale, utilizza il comando di abilitazione-sviluppo del dispositivo az sphere . Questo comando configura il dispositivo in modo da accettare le applicazioni da un PC per il debug e assegna il dispositivo al gruppo di dispositivi di sviluppo, 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.

In Windows, è necessario aggiungere il --enable-rt-core-debugging parametro, che carica i server di debug e i driver necessari per ogni tipo di core nel dispositivo.

  1. Accedere ad Azure se non è già stato fatto:

    az login

  2. Apri un'interfaccia della riga di comando utilizzando PowerShell, il prompt dei comandi di Windows o la shell dei comandi Linux con privilegi di amministratore. Il --enable-rt-core-debugging parametro richiede privilegi di amministratore perché installa driver USB per il debugger.

  3. Immettere il comando seguente:

    az sphere device enable-development --enable-rt-core-debugging

  4. Chiudere la finestra al termine del comando perché il privilegio di amministratore non è più necessario. Come procedura consigliata, è consigliabile usare sempre il privilegio più basso che può eseguire un'attività.

Se il comando di abilitazione-sviluppo del dispositivo az sphere non riesce con il seguente messaggio di errore, vedi Risolvere i problemi di Azure Sphere per assistenza.

error: The device did not accept the device capability configuration. Please check the Azure Sphere OS on your device is up-to-date using 'az sphere device show-deployment-status'.

Creare l'RTApp usando Visual Studio Code

Per creare un'RTApp:

  1. In Visual Studio Code apri la cartella HelloWorld_RTApp_MT3620_BareMetal nel tuo clone del repository degli esempi di Azure Sphere. Se ti viene richiesto di selezionare un kit, scegli "Non usare un kit".

  2. Premere F5 per avviare il debugger. Se il progetto non è stato creato in precedenza o se i file sono stati modificati e la ricostruzione è obbligatoria, Visual Studio Code crea il progetto prima dell'inizio del debug.

  3. L'emulatore del terminale connesso deve visualizzare l'output dall'applicazione. Il programma invia le parole seguenti a intervalli di un secondo:

    Tick

    Tock

    Nota

    Visual Studio Code fornisce Intellisense, ma non si aggiorna automaticamente quando si modifica CMakeLists.txt. È necessario eseguire il comando CMake: Delete Cache and Reconfigure per aggiornare Intellisense. La visualizzazione dei bersagli CMake è disponibile nella visualizzazione dell'estensione CMake sulla barra sinistra.

Creare l'RTApp con Visual Studio

Per creare un'RTApp:

  1. In Visual Studio selezionare File>CMake e passare alla cartella contenente l'esempio.

  2. Se la generazione CMake non viene avviata automaticamente, selezionare il file CMakeLists.txt.

  3. In Visual Studio, visualizza>output show>da: CMake output dovrebbe mostrare i messaggi CMake generation started. e CMake generation finished.

  4. Nel menu CMake (se presente) selezionare Genera tutto. Se il menu non è presente, aprire Esplora soluzioni, fare clic con il pulsante destro del mouse sul file CMakeLists.txt e scegliere Genera. La posizione di output dell'applicazione Azure Sphere viene visualizzata nella finestra Output .

  5. Premere F5 per distribuire l'applicazione.

  6. L'emulatore del terminale connesso deve visualizzare l'output dall'applicazione. Il programma invia le parole seguenti a intervalli di un secondo:

    Tick

    Tock

    Nota

    • Visual Studio fornisce Intellisense per Azure Sphere RTApps raccogliendo dati dalla cache di CMake. Visual Studio aggiorna la cache ogni volta che il CMakeLists.txt o CMakeSettings.json file nell'RTApp viene modificato.

    • Per impostazione predefinita, Visual Studio usa la visualizzazione Cartelle. Se si preferisce una visualizzazione logica del progetto CMake, è possibile passare alla visualizzazione CMake Targets. In Esplora soluzioni selezionare l'icona di attivazione/disattivazione della cartella:

      Passare tra le visualizzazioni Soluzione e Cartella

      Nel menu a discesa selezionare CMake Targets View.

    • L'applicazione potrebbe iniziare l'esecuzione prima di OpenOCD effettua una connessione. Di conseguenza, i punti di interruzione impostati all'inizio del codice potrebbero non essere presenti. Una soluzione alternativa consiste nel posticipare l'avvio dell'app finché OpenOCD non si connette.

      1. Inserire il codice seguente all'inizio del punto di ingresso dell'applicazione RTCoreMain. In questo modo l'applicazione verrà immessa e rimarrà in un while ciclo fino a quando la variabile f non viene impostata su true.

          volatile bool f = false;
  while (!f) {
    // empty.
  }

      2. Premi F5 per avviare l'app con il debug e quindi interrompo l'esecuzione.

      3. Nel riquadro di debug Locals modificare il valore da f zero a uno.

      4. Scorrere il codice normalmente.

Crea RTApp usando la CLI

Le istruzioni seguenti presuppongono l'uso di CMake. Se si preferisce creare sulla riga di comando senza usare CMake, è possibile determinare le opzioni appropriate del compilatore e del linker esaminando i file Azure SphereToolchainBase.cmake e Azure SphereRTCoreToolchain.cmake, installati con Azure Sphere SDK.

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

  2. 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 HelloWorld RTApp:

    Prompt dei comandi di Windows

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

    Windows PowerShell

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

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

  4. Eliminare le applicazioni già distribuite nel dispositivo:

    az sphere device sideload delete

  5. Distribuisci il pacchetto di immagini creato da Ninja:

    az sphere device sideload deploy --image-package <package-name>

  6. Ottenere l'ID componente per l'immagine:

    az sphere image-package show --image-package <path-to-imagepackage>

    Il comando restituisce tutti i metadati per il pacchetto di immagini. L'ID componente per l'applicazione viene visualizzato nella sezione Identity relativa al tipo di immagine dell'applicazione. Per esempio:

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

  7. Determinare il core su cui è in esecuzione l'app.

    Per impostazione predefinita, la RTApp viene distribuita al primo core in tempo reale disponibile nel dispositivo; al momento non è possibile specificare un determinato nucleo. Per scoprire quale core l'applicazione è in esecuzione su, utilizzare il comando dell'app dispositivo az sphere per arrestare e quindi riavviare l'applicazione. Specificare l'ID componente per l'applicazione nei comandi. Per esempio:

    az sphere device app stop --component-id <component id>
<component id>: App state: stopped

    az sphere device app start --component-id <component id>
<component id>
App state: running
Core     : Real-time 0

  8. L'emulatore del terminale connesso deve visualizzare l'output dall'applicazione. Il programma invia le parole seguenti a intervalli di un secondo:

    Tick

    Tock

Registrare l'output da un'RTApp

Ogni core in tempo reale sull'MT3620 dispone di un oggetto UART dedicato destinato all'output di registrazione. I core in tempo reale possono anche accedere agli UARTs ISU. Mt3620 RDB espone solo il pin TX, che è possibile utilizzare per visualizzare l'output del log dall'applicazione. Altri componenti hardware potrebbero esporre il problema in modo diverso o non visualizzarlo affatto. Per visualizzare l'output del log, configurare l'hardware per visualizzare questo output come descritto nella guida introduttiva. L'oggetto UART dedicato non richiede il requisito del manifesto dell'applicazione Uart , ma non deve essere usato per scopi diversi dalla registrazione dell'output per un'RTApp.

Sviluppare con le app partner

Quando si carica un'applicazione nel dispositivo Azure Sphere, gli strumenti di distribuzione di Azure Sphere eliminano per impostazione predefinita tutte le applicazioni esistenti. Per evitare che ciò si verifichi quando si sviluppano applicazioni che comunicano tra loro, è necessario contrassegnare le applicazioni come partner. Quando si distribuisce una delle applicazioni, i relativi partner non verranno eliminati. Per informazioni dettagliate, vedere Contrassegnare le applicazioni come partner .

Risoluzione dei problemi relativi

Se si verificano problemi, vedi Risoluzione dei problemi relativi alle applicazioni in tempo reale.

Risorse aggiuntive

Ulteriori driver e campioni per RTApp che puntano ai core in tempo reale M4 nel chip MT3620 sono disponibili su GitHub dai partner Azure Sphere: