Creare un'applicazione di alto livelloBuild a high-level application

In questa sezione viene descritto come compilare, creare un pacchetto e distribuire un Azure Sphere applicazione di alto livello.This section describes how to build, package, and deploy an Azure Sphere high-level application.

Queste istruzioni usano come esempio l'applicazione di esempio HelloWorld_HighLevelApp .These instructions use the HelloWorld_HighLevelApp sample application as an example.

PrerequisitiPrerequisites

Preparare il dispositivo allo sviluppo e al debugPrepare your device for development and debugging

Prima di poter compilare un'applicazione di esempio sul dispositivo Azure Sphere o sviluppare nuove applicazioni, è necessario abilitare lo sviluppo e il sideload.Before you can build a sample application on your Azure Sphere device or develop new applications for it, you must enable development and sideloading. Per impostazione predefinita, i dispositivi Azure Sphere sono "bloccati", ovvero non consentono il caricamento da un computer di applicazioni in fase di sviluppo, oltre a non permettere il debug delle applicazioni.By default, Azure Sphere devices are "locked"; that is, they do not allow applications under development to be loaded from a computer, and they do not allow debugging of applications. Preparando il dispositivo per il sideload, questa restrizione viene rimossa.Preparing the device for sideloading removes this restriction.

Il comando Abilita-sviluppo del dispositivo azsphere configura il dispositivo in modo che accetti le applicazioni per il debug, carica il server di debug nel dispositivo e assegna il dispositivo a un gruppo di dispositivi che non consente gli aggiornamenti dell'applicazione cloud.The azsphere device enable-development command configures the device to accept applications for debugging, loads the debugging server onto the device, and assigns the device to a device group that does not allow cloud application updates. 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.During application development and debugging, you should leave the device in this group so that cloud application updates do not overwrite the application under development.

  1. Verificare che il dispositivo Azure Sphere sia connesso al computer e che il computer sia connesso a Internet.Make sure that your Azure Sphere device is connected to your computer, and your computer is connected to the internet.

  2. Aprire un Azure Sphere Prompt dei comandi per gli sviluppatori (Windows) o una finestra del terminale (Linux).Open an Azure Sphere Developer Command Prompt (Windows) or a terminal window (Linux).

  3. Immettere il comando seguente:Enter the following command:

    azsphere device enable-development

    L'output dovrebbe essere simile al seguente:You should see output similar to the following:

    Getting device capability configuration for application development.
    Downloading device capability configuration for device ID '<device ID>'.
    Successfully downloaded device capability configuration.
    Successfully wrote device capability configuration file 'C:\Users\user\AppData\Local\Temp\tmpD732.tmp'.
    Setting device group ID 'a6df7013-c7c2-4764-8424-00cbacb431e5' for device with ID '<device ID>'.
    Successfully disabled over-the-air updates.
    Enabling application development capability on attached device.
    Applying device capability configuration to device.
    Successfully applied device capability configuration to device.
    The device is rebooting.
    Installing debugging server to device.
    Deploying 'C:\Program Files (x86)\Microsoft Azure Sphere SDK\DebugTools\gdbserver.imagepackage' to the attached device.
    Image package 'C:\Program Files (x86)\Microsoft Azure Sphere SDK\DebugTools\gdbserver.imagepackage' has been deployed to the attached device.
    Application development capability enabled.
    Successfully set up device '<device ID>' for application development, and disabled over-the-air updates.
    Command completed successfully in 00:00:38.3299276.
    

Se il comando Abilita-sviluppo del dispositivo azsphere non riesce, vedere risoluzione dei problemi Azure Sphere per la guida.If the azsphere device enable-development command fails, see Troubleshoot Azure Sphere issues for help.

Compilare e distribuire l'applicazione in Visual StudioBuild and deploy the application in Visual Studio

  1. Assicurarsi che il dispositivo sia connesso al PC tramite USB.Ensure that your device is connected to your PC by USB. Nel menu Imposta elemento di avvio selezionare GDB Debugger (HLCore) o premere F5.In the Set startup item menu, select GDB Debugger (HLCore) or press F5.

    Pulsante Debugger GDB remoto

  2. Se viene richiesto di compilare il progetto, selezionare .If you are prompted to build the project, select Yes. Visual Studio compila l'applicazione, crea un pacchetto immagine, la trasferisce localmente nella scheda e la avvia in modalità di debug.Visual Studio compiles the application, creates an image package, sideloads it onto the board, and starts it in debug mode. Trasferimento locale significa che l'applicazione viene distribuita direttamente dal computer tramite una connessione cablata, invece che tramite il cloud.Sideloading means that the application is delivered directly from the PC over a wired connection, rather than delivered through the cloud.

    Prendere nota del percorso nell'output della build, che indica la posizione del pacchetto immagine di output nel PC.Note the path in the Build output, which indicates the location of the output image package on your PC. Il pacchetto di immagini verrà usato più avanti in esercitazione: creare una distribuzione cloud.You'll use the image package later in Tutorial: Create a cloud deployment.

  3. Per impostazione predefinita, la finestra di Output mostra l'output di Output del dispositivo.By default, the Output window shows output from Device Output. Per visualizzare i messaggi del debugger, selezionare Debug dal menu a discesa Mostra output di: .To see messages from the debugger, select Debug from the Show output from: dropdown menu. È anche possibile esaminare il disassembly, i registri o la memoria del programma tramite il menu Debug > Windows.You can also inspect the program disassembly, registers, or memory through the Debug > Windows menu.

Compilare e distribuire l'applicazione in Visual Studio CodeBuild and deploy the application in Visual Studio Code

  1. Premere F5 per compilare ed eseguire il debug del progetto.Press F5 to build and debug the project. Se il progetto non è stato compilato in precedenza o se i file sono stati modificati e la ricompilazione è obbligatoria, Visual Studio Code compilerà il progetto prima dell'avvio del debug.If the project has not previously been built, or if files have changed and rebuilding is required, Visual Studio Code will build the project before debugging starts.

  2. Attendere alcuni secondi per Visual Studio Code compilare l'applicazione, creare un pacchetto immagine, distribuirlo nella lavagna e avviarlo in modalità di debug.Wait several seconds for Visual Studio Code to build the application, create an image package, deploy it to the board, and start it in debug mode. Gli aggiornamenti di stato verranno visualizzati nel riquadro di output lungo il percorso.You'll see status updates in the Output pane along the way.

    In primo luogo, CMake determina se l'applicazione deve essere compilata.First, CMake determines whether the application needs to be built. In tal caso, lo stato attivo passa alla finestra di output, che Visualizza l'output da CMake/Build.If so, focus shifts to the output window, which displays the output from CMake/Build.

    Successivamente, la finestra di output mostra l'output di azsphere mentre distribuisce il pacchetto immagine nel dispositivo.Next, the output window shows the output from azsphere as it deploys the image package to the device. Infine, la console di debug riceve lo stato attivo e mostra l'output di gdb.Finally, the Debug Console receives focus and shows gdb output.

Compilare l'applicazioneBuild the application

Per compilare l'applicazione sarà necessario individuare nel computer gli strumenti di compilazione, le intestazioni e le librerie corretti, collettivamente noti come sysroot.To build your application you will need to find the correct compilation tools, headers, and libraries—collectively called the sysroot—on your computer. Il Azure Sphere SDK viene fornito con più sysroot, in modo che le applicazioni possano essere destinate a diversi set di API, come descritto nelle API versione del runtime dell'applicazione, sysroot e beta.The Azure Sphere SDK ships with multiple sysroots so applications can target different API sets, as described in Application runtime version, sysroots, and Beta APIs. I sysroot sono installati nella cartella di installazione di Azure Sphere SDK in Sysroots.The sysroots are installed in the Azure Sphere SDK installation folder under Sysroots.

  1. Creare o passare alla directory che conterrà i file da generare durante il processo di compilazione.Create or navigate to the directory that will contain the files to be generated during the build process.

  2. Se l'applicazione dipende da un'altra applicazione, contrassegnare le applicazioni come partner nei rispettivi file app_manifest.md.If your application depends on another application, mark the applications as partners in their app_manifest.md files.

  3. Aggiungere o aggiornare il file CMakeLists.txt per l'applicazione per chiamare le funzioni CMake di Azure Sphere se necessario.Add or update the CMakeLists.txt file for your application to call the Azure Sphere CMake functions as necessary.

  4. Dalla directory di compilazione del progetto, al prompt dei comandi, eseguire CMake con i parametri seguenti:From your project build directory, at the command prompt, run CMake with the following parameters:

    • -G Impostare questo parametro su "Ninja" per indicare che CMake deve usare il generatore Ninja per creare i file di compilazione, in quanto Ninja verrà usato per completare la compilazione.-G Set this parameter to "Ninja" to indicate that CMake should use the Ninja generator to create the build files, as Ninja will be used to complete the build.

    • -DCMAKE_TOOLCHAIN_FILE-DCMAKE_TOOLCHAIN_FILE

      Impostare questo parametro sul percorso del file della catena di strumenti del compilatore nel computer.Set this parameter to the path to the compiler tool chain file on your machine. Per Windows, il CMAKE_TOOLCHAIN_FILE deve puntare a C:\Programmi (x86) \Microsoft Azure Sphere SDK\CMakeFiles\AzureSphereRTCoreToolchain.cmake.For Windows, the CMAKE_TOOLCHAIN_FILE should point to C:\Program Files (x86)\Microsoft Azure Sphere SDK\CMakeFiles\AzureSphereRTCoreToolchain.cmake. Per Linux, specificare/opt/azurespheresdk/CMakeFiles/AzureSphereRTCoreToolchain.cmake.For Linux, specify /opt/azurespheresdk/CMakeFiles/AzureSphereRTCoreToolchain.cmake.

    • -DAZURE_SPHERE_TARGET_API_SET-DAZURE_SPHERE_TARGET_API_SET

      Impostare questo parametro sul set di API Azure Sphere desiderato da usare.Set this parameter to the desired Azure Sphere API set to use. Nell'esempio è impostato su "Latest-LTS", che seleziona il set più recente di API designato per il supporto a lungo termine.In the example it is set to "latest-lts", which selects the latest set of APIs designated for long-term support.

    • -DCMAKE_BUILD_TYPE-DCMAKE_BUILD_TYPE

      Impostare questo parametro sul tipo di compilazione.Set this parameter to the build type. I valori possibili sono Debug e Release.Possible values are Debug and Release.

    • Il parametro finale è il percorso della directory nel computer che contiene i file di origine per l'applicazione di esempio.The final parameter is the path to the directory on your machine that contains the source files for the sample application. Nell'esempio il repository degli esempi di Azure Sphere è stato scaricato in una directory denominata AzSphere.In the example the Azure Sphere samples repository was downloaded to a directory called AzSphere.

      I parametri di CMake sono separati da spazi.CMake parameters are separated by spaces. Il carattere di continuazione di riga (^ per la riga di comando di Windows, \ per la riga di comando di Linux o ' per PowerShell) può essere usato per migliorare la leggibilità, ma non è obbligatorio.The line continuation character (^ for Windows command line, \ for Linux command line, or ` for PowerShell) can be used for readability but is not required.

    Gli esempi seguenti illustrano i comandi CMake per l'app di alto livello Hello World.The following examples show the CMake commands for the Hello World high-level app.

    cmake ^
     -G "Ninja" ^
     -DCMAKE_TOOLCHAIN_FILE="C:\Program Files (x86)\Microsoft Azure Sphere SDK\CMakeFiles\AzureSphereToolchain.cmake" ^
     -DAZURE_SPHERE_TARGET_API_SET="latest-lts" ^
     -DCMAKE_BUILD_TYPE="Debug" ^
     "C:\AzSphere\azure-sphere-samples\Samples\HelloWorld\HelloWorld_HighLevelApp"
    
  5. Compilare l'applicazione e creare il file con estensione imagepackage eseguendo Ninja dalla riga di comando:Build the application and create the .imagepackage file by running ninja from the command line:

    ninja

    Ninja inserisce i file dell'applicazione e i file con estensione imagepackage risultanti nella directory corrente.Ninja places the resulting application and .imagepackage files in the current directory.

Distribuire l'applicazioneDeploy the application

Assicurarsi che il dispositivo disponga della funzionalità appDevelopment in modo da poter effettuare il trasferimento locale dell'applicazione e verificare che sia presente il server di debug.Make sure your device has the appDevelopment capability so you can sideload the application and ensure that the debugging server is present. Se necessario, usare il comando azsphere device enable-development.Use the azsphere device enable-development command if necessary.

  1. Se il dispositivo ha già in esecuzione una o più applicazioni, eliminarle.If your device is already running one or more applications, delete them.

    azsphere device sideload delete

    Si noti che questo comando elimina tutte le applicazioni nel dispositivo.Note that this command deletes all the applications on the device. Se è già stata distribuita un'applicazione RTApp che rappresenta un partner per l'app di alto livello, usare il parametro --componentid per specificare quale applicazione eliminare.If you've already deployed an RTApp that is a partner to the high-level app, use the --componentid parameter to specify which application to delete. È possibile trovare l'ID del componente dell'applicazione nella app_manifest.jssu file.You can find the component ID of the application in its app_manifest.json file.

  2. Caricare il pacchetto immagine nel dispositivo eseguendo il comando azsphere Device sideload deploy e specificando il pacchetto immagine.Load the image package onto your device by running the azsphere device sideload deploy command and specifying the image package. Ad esempio:For example:

    azsphere device sideload deploy --imagepackage HelloWorld_HighLevelApp.imagepackage

    L'applicazione dovrebbe essere ora eseguita.Your application should start running.

È possibile arrestare e riavviare l'applicazione in un secondo momento usando i comandi azsphere device app stop -i <component ID> e azsphere device app start -i <component ID>.You can later stop and restart the application by using the azsphere device app stop -i <component ID> and azsphere device app start -i <component ID> commands.