Creare un'applicazione con funzionalità in tempo reale

Articolo
03/01/2025

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

È possibile usare Visual Studio, Visual Studio Code o l'interfaccia della riga di comando per sviluppare e sottoporre a debug le applicazioni con funzionalità in tempo reale (RTApp) in modo molto simile alle applicazioni di alto livello.

Prerequisiti

Connettere il dispositivo Azure Sphere al computer
Installare Azure Sphere
Installare la toolchain GNU Arm Embedded
Configurare l'hardware per visualizzare l'output da UART dedicato, se non è già stato fatto

Abilitare lo sviluppo e il debug

Prima di poter compilare un'applicazione di esempio sul 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 da un PC di applicazioni in fase di sviluppo, oltre a non permettere 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à del dispositivo e comunicazione.

Per eseguire il debug nei core in tempo reale, usare il comando azsphere device enable-development. Questo comando configura il dispositivo per accettare applicazioni da un PC per il debug e assegna il dispositivo al gruppo di dispositivi 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 da evitare la sovrascrittura dell'applicazione in fase di sviluppo da parte degli aggiornamenti cloud.

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.

Windows
Linux

Accedere ad Azure Sphere se non è già stato fatto:
```
azsphere login
```
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 i driver USB per il debugger.

Immettere il comando seguente:

azsphere device enable-development --enable-rt-core-debugging

Chiudere la finestra dopo il completamento del comando perché il privilegio di amministratore non è più necessario. È consigliabile usare sempre il privilegio minimo necessario per eseguire un'attività.

Se il comando azsphere device enable-development non riesce, vedere Risolvere i problemi di Azure Sphere per assistenza.

Abilitare lo sviluppo e il debug

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.

Accedere ad Azure Sphere se non è già stato fatto:
```
azsphere login
```
Aprire un'interfaccia della riga di comando usando 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 i driver USB per il debugger.

Immettere il comando seguente:

azsphere device enable-development --enable-rt-core-debugging

Chiudere la finestra dopo il completamento del comando perché il privilegio di amministratore non è più necessario. È consigliabile usare sempre il privilegio minimo necessario per eseguire un'attività.

Se il comando azsphere device enable-development non riesce con il messaggio di errore seguente, vedere 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 'azsphere device show-deployment-status'.

Compilare l'applicazione RTApp con Visual Studio Code

Per compilare un'applicazione RTApp:

In Visual Studio Code aprire la cartella HelloWorld_RTApp_MT3620_BareMetal nel clone del repository di esempi di Azure Sphere. Se viene richiesto di selezionare un kit, scegliere di non usare un kit.
Premere F5 per avviare il debugger. Se il progetto non è già stato compilato oppure se i file sono stati cambiati ed è necessaria una ricompilazione, Visual Studio Code compilerà il progetto prima dell'avvio del debug.
L'emulatore di terminale connesso visualizzerà l'output dell'applicazione. Il programma invia le parole seguenti a intervalli di un secondo:

Tick

Tock

Nota

Visual Studio Code include IntelliSense, ma non verrà aggiornato automaticamente quando si modifica il file CMakeLists.txt. È necessario eseguire il comando CMake: Eliminare cache e riconfigurare per aggiornare IntelliSense. La visualizzazione delle destinazioni CMake si trova nella visualizzazione dell'estensione CMake sulla barra sinistra.

Compilare l'applicazione RTApp con Visual Studio

Per compilare un'applicazione RTApp:

In Visual Studio selezionare File>CMake e passare alla cartella che contiene l'esempio.
Se la generazione di CMake non viene avviata automaticamente, selezionare il file CMakeLists.txt.
In Visual Studio visualizzare >l'output>Mostra output da: L'output di CMake dovrebbe visualizzare i messaggi e CMake generation started.CMake generation finished.
Nel menu CMake (se presente) selezionare Compila tutto. Se il menu non è presente, aprire Esplora soluzioni, fare clic con il pulsante destro del mouse sul file CMakeLists.txt e scegliere Compila. Il percorso di output dell'applicazione Azure Sphere viene visualizzato nella finestra Output .
Premere F5 per distribuire l'applicazione.
L'emulatore di terminale connesso visualizzerà l'output dell'applicazione. Il programma invia le parole seguenti a intervalli di un secondo:

Tick

Tock
Nota
- Visual Studio offre la funzionalità IntelliSense per le applicazioni RTApp di Azure Sphere raccogliendo i dati dalla cache di CMake. Visual Studio aggiorna la cache ogni volta che viene modificato il file CMakeLists.txt o CMakeSettings.json nell'applicazione RTApp.
- Per impostazione predefinita, in Visual Studio viene usata la visualizzazione cartelle. Se si preferisce una visualizzazione logica del progetto CMake, è possibile passare alla visualizzazione destinazioni CMake. In Esplora soluzioni selezionare l'icona di attivazione/disattivazione delle cartelle:
  
  Dal menu a discesa selezionare Visualizzazione destinazioni CMake.
- È possibile che l'esecuzione dell'applicazione inizi prima che OpenOCD stabilisca una connessione. Di conseguenza, i punti di interruzione impostati precedentemente nel codice potrebbero essere ignorati. Per risolvere il problema, è possibile ritardare l'avvio dell'app fino a quando OpenOCD non stabilisce la connessione.
  1. Inserire il codice seguente all'inizio del punto di ingresso dell'applicazione RTCoreMain. In questo modo l'applicazione entrerà e rimarrà in un ciclo while finché la variabile f non sarà impostata su true.
```
  volatile bool f = false;
  while (!f) {
    // empty.
  }
```
  2. Premere F5 per avviare l'app con il debug e quindi interrompere l'esecuzione.
  3. Nel riquadro debug Variabili locali modificare il valore di f da zero a uno.
  4. Procedere normalmente con l'esecuzione del codice.

Compilare un'applicazione RTApp con l'interfaccia della riga di comando

Le istruzioni seguenti presuppongono che si usi CMake. Se si preferisce eseguire la compilazione nella riga di comando senza usare CMake, è possibile determinare le opzioni del compilatore e del linker appropriate esaminando i file AzureSphereToolchainBase.cmake e AzureSphereRTCoreToolchain.cmake, che vengono installati con Azure Sphere SDK.

Aprire un'interfaccia della riga di comando usando PowerShell, il prompt dei comandi di Windows o la shell dei comandi linux. Passare alla directory di compilazione del progetto.
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 del set di impostazioni di configurazione della compilazione definito in CMakePresets.json.
- --build <cmake-path>
  
  Directory binaria che contiene la cache CMake. Ad esempio, se si esegue CMake in un esempio di Azure Sphere, il comando di compilazione sarà cmake --build out/ARM-Debug.
- <source-path>
  
  Percorso della directory contenente i file di origine per l'applicazione di esempio. Nell'esempio il repository di esempi di Azure Sphere è stato scaricato in una directory denominata AzSphere.
  
  I parametri di CMake sono separati da spazi. Il carattere di continuazione della riga (^ per la riga di comando di Windows, \ per la riga di comando linux o ' per PowerShell) può essere usato per la leggibilità, ma non è obbligatorio.
Gli esempi seguenti illustrano i comandi CMake per HelloWorld RTApp:
- Windows
- Linux
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"
```
```
cmake \
--preset "ARM-Debug" \
./AzSphere/azure-sphere-samples/Samples/HelloWorld/HelloWorld_RTApp_MT3620_BareMetal
```
Eseguire Ninja per compilare l'applicazione e creare il file del pacchetto immagine:
```
ninja -C out/ARM-Debug
```
Ninja inserisce l'applicazione risultante e i file imagepackage nella directory specificata.

È anche possibile 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 in un esempio di Azure Sphere, il comando di compilazione sarà cmake --build out/ARM-Debug.
Eliminare tutte le applicazioni già distribuite nel dispositivo:
```
azsphere device sideload delete
```

Distribuire il pacchetto immagine creato da Ninja:

azsphere device sideload deploy --image-package <package-name>

Identificare l'ID componente per l'immagine:
```
azsphere image-package show --image-package <path-to-imagepackage>
```
Il comando restituisce tutti i metadati per il pacchetto immagine. L'ID componente per l'applicazione si trova nella sezione Identità per il tipo di immagine dell'applicazione. Ad esempio:
```
Image package metadata:
Section: Identity
Image Type:           Application
Component ID:         <component id>
Image ID:             <image id>
```
Determinare il core in cui è in esecuzione l'app.

Per impostazione predefinita, l'applicazione RTApp viene distribuita nel primo core in tempo reale disponibile nel dispositivo; attualmente non è possibile specificare un determinato core. Per identificare il core in cui viene eseguita l'applicazione, usare il comando azsphere device app per arrestare e riavviare l'applicazione. Specificare l'ID componente per l'applicazione nei comandi. Ad esempio:
```
azsphere device app stop --component-id <component id>
<component id>: App state: stopped
```
```
azsphere device app start --component-id <component id>
<component id>
App state: running
Core     : Real-time 0
```
L'emulatore di terminale connesso visualizzerà l'output dell'applicazione. Il programma invia le parole seguenti a intervalli di un secondo:

Tick

Tock

Output del log da un'applicazione RTApp

Ogni core per operazioni in tempo reale in MT3620 ha un dispositivo UART dedicato per la registrazione dell'output. I core in tempo reale possono accedere anche agli UART ISU. Il database RDB MT3620 espone solo il pin TX, che è possibile usare per visualizzare l'output del log dall'applicazione. Altri componenti hardware potrebbero esporre questa funzionalità in modo diverso o non esporla affatto. Per visualizzare l'output del log, configurare l'hardware per visualizzare l'output come descritto nell'avvio rapido. L'UART dedicato non richiede l'uso del manifesto dell'applicazione Uart. Non deve tuttavia essere usato per scopi diversi dalla registrazione dell'output per un'applicazione RTApp.

Sviluppare con le app partner

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

Risoluzione dei problemi

Se si verificano problemi, vedere Risoluzione dei problemi delle applicazioni con funzionalità in tempo reale.

Risorse aggiuntive

Altri driver ed esempi per le app RTApp destinate ai core M4 in tempo reale nel chip MT3620 sono disponibili in GitHub dai partner Azure Sphere:

MediaTek HAL (livello di astrazione hardware)
Driver codethink.
Esempi di codethink.

Condividi tramite

Creare un'applicazione con funzionalità in tempo reale

Prerequisiti

Abilitare lo sviluppo e il debug

Abilitare lo sviluppo e il debug

Compilare l'applicazione RTApp con Visual Studio Code

Compilare l'applicazione RTApp con Visual Studio

Compilare un'applicazione RTApp con l'interfaccia della riga di comando

Output del log da un'applicazione RTApp

Sviluppare con le app partner

Risoluzione dei problemi

Risorse aggiuntive

Commenti e suggerimenti

Risorse aggiuntive