Tutoriel : Créer une application de haut niveau

Article
08/09/2023

Une application de haut niveau s’exécute sur le système d’exploitation Azure Sphere, utilise les bibliothèques d’applications Azure Sphere et peut communiquer avec Internet et avec les services cloud. Pour plus d’informations sur les applications de haut niveau, consultez Vue d’ensemble des applications Azure Sphere .

Dans ce tutoriel, vous allez apprendre à :

Préparer votre appareil pour le développement et le débogage

Générer, exécuter et déboguer une application de haut niveau

Conditions préalables

Installez CMake et Ninja pour Windows ou pour Linux.

Installez Visual Studio Code pour Windows ou pour Linux.
Installez CMake et Ninja pour Windows ou pour Linux.

Installez Visual Studio et l’extension Azure Sphere.

Installez le Kit de développement logiciel (SDK) pour Windows ou pour Linux.
Choisissez un catalogue et revendez votre appareil.
Configurez la mise en réseau et mettez à jour le système d’exploitation de l’appareil.

Préparer votre appareil pour le développement et le débogage

Avant de pouvoir créer un exemple d’application sur votre appareil Azure Sphere ou développer de nouvelles applications pour celui-ci, vous devez activer le développement et le chargement indépendant. Par défaut, les appareils Azure Sphere sont « verrouillés » ; autrement dit, ils n’autorisent pas le chargement des applications en cours de développement à partir d’un ordinateur, et ils n’autorisent pas le débogage des applications. La préparation de l’appareil pour le chargement indépendant supprime cette restriction.

La commande az sphere device enable-development configure l’appareil pour accepter les applications à des fins de débogage, charge le serveur de débogage sur l’appareil et affecte l’appareil à un groupe d’appareils qui n’autorise pas les mises à jour des applications cloud. Pendant le développement et le débogage de l’application, vous devez laisser l’appareil dans ce groupe afin que les mises à jour des applications cloud ne remplacent pas l’application en cours de développement.

Assurez-vous que votre appareil Azure Sphere est connecté à votre ordinateur et que votre ordinateur est connecté à Internet.
Ouvrez une interface de ligne de commande à l’aide de PowerShell, de l’invite de commandes Windows ou de l’interpréteur de commandes Linux.

Entrez la commande suivante :

az sphere device enable-development --resource-group <ResourceGroupName> --catalog <CatalogName> --device <DeviceIdValue>

Vous devez voir une sortie similaire à ce qui suit :

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.

Si la commande az sphere device enable-development échoue, consultez Résoudre les problèmes Azure Sphere pour obtenir de l’aide.

Générer et exécuter l’application de haut niveau avec Visual Studio Code

Ce tutoriel utilise le modèle Blink Azure Sphere, qui fait partie de l’extension Azure Sphere pour Visual Studio Code. Le modèle Blink fait clignoter une LED pour vous permettre de vérifier que l’appareil et les outils Azure Sphere sont installés et configurés correctement.

Démarrez Visual Studio Code. Sélectionnez Afficher>la palette de commandes, puis tapez « Azure Sphere : Générer un nouveau projet ».
Sélectionnez Clignoter dans le menu Modèles.

Visual Studio Code affiche ensuite une fenêtre Explorateur de fichiers. Accédez au dossier dans lequel vous souhaitez placer l’application Blink. Visual Studio Code crée le dossier Blink à l’emplacement sélectionné et génère les fichiers de build pour l’application Blink. Les messages de CMake doivent s’afficher.
Ouvrez le fichier CMakeLists.txt et modifiez le paramètre TARGET_DIRECTORY pour spécifier le dossier qui contient les définitions du matériel que vous utilisez. Par défaut, le TARGET_DIRECTORY spécifie HardwareDefinitions/mt3620_rbd, qui correspond au Kit de développement Mt3620 Azure Sphere seeed :
```
azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "HardwareDefinitions/mt3620_rdb" TARGET_DEFINITION "template_appliance.json")
```
Plusieurs définitions matérielles sont fournies avec le modèle. Par exemple, si vous utilisez une mini-carte de développement MT3620 SEEED, spécifiez Plutôt HardwareDefinitions/seeed_mt3620_mdb.
Appuyez sur F5 pour générer et déboguer le projet. Si le projet n’a pas été généré précédemment, ou si les fichiers ont changé et qu’une reconstruction est nécessaire, Visual Studio Code génère le projet avant le démarrage du débogage.
Attendez plusieurs secondes que Visual Studio Code génère l’application, crée un package d’image, le déploie sur la carte et le démarre en mode débogage. Vous verrez status mises à jour dans le volet Sortie en cours de route.

Tout d’abord, CMake détermine si l’application doit être générée. Si c’est le cas, le focus est déplacé vers le volet de sortie, qui affiche la sortie de CMake/Build.

Ensuite, le volet de sortie affiche la sortie lors du déploiement du package d’images sur l’appareil. Enfin, la console de débogage reçoit le focus et affiche la sortie gdb.

Pointe

Notez l’emplacement de votre package d’images, car vous en aurez besoin lorsque vous créerez un déploiement. Vous devez voir un message tel que « Fichiers de build écrits <dans le chemin d’accès> » dans la fenêtre Sortie , où <chemin d’accès> est le chemin complet du dossier de build de votre application Blink, se terminant généralement par « out\ARM-Debug » ou « out/ARM-Debug ».
Après un court délai, vous devriez voir un voyant clignoter.
Définissez un point d’arrêt quelque part dans main.c et parcourez l’application afin de pouvoir explorer les fonctionnalités de débogage de Visual Studio Code pour Azure Sphere.

Générer et exécuter l’application de haut niveau avec Visual Studio

Ce tutoriel utilise le modèle Blink Azure Sphere, qui fait partie de l’extension Azure Sphere pour Visual Studio. Le modèle Blink fait clignoter une LED pour vous permettre de vérifier que l’appareil et les outils Azure Sphere sont installés et configurés correctement.

Si vous débutez avec Visual Studio, envisagez le guide de démarrage rapide ou la visite guidée pour en savoir plus sur la navigation et l’utilisation de celui-ci.
Ouvrez Visual Studio et sélectionnez Créer un projet. Dans la zone Recherche, tapez « azure sphere » pour obtenir la liste des modèles Azure Sphere. Choisissez Azure Sphere Blink dans la liste.
Entrez un nom et un emplacement pour le projet, puis sélectionnez Créer.
Ouvrez le fichier CMakeLists.txt et modifiez le paramètre TARGET_DIRECTORY pour spécifier le dossier qui contient les définitions du matériel que vous utilisez. Par défaut, le TARGET_DIRECTORY spécifie HardwareDefinitions/mt3620_rbd, qui correspond au Kit de développement Mt3620 Azure Sphere seeed :
```
azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "HardwareDefinitions/mt3620_rdb" TARGET_DEFINITION "template_appliance.json")
```
Plusieurs définitions matérielles sont fournies avec le modèle. Par exemple, si vous utilisez une mini-carte de développement MT3620 SEEED, spécifiez Plutôt HardwareDefinitions/seeed_mt3620_mdb.
Dans Visual Studio, sélectionnez Afficher la>sortie pour afficher le volet Sortie .
Vérifiez que votre appareil est connecté à votre PC par USB. Dans le menu Définir l’élément de démarrage , appuyez sur F5 ou sélectionnez Application Azure Sphere (HLCore)* où Application Azure Sphere est le nom de votre application de haut niveau actuelle.
Si vous êtes invité à générer le projet, sélectionnez Oui. Visual Studio compile l’application, crée un package d’image, le charge sur la carte et le démarre en mode débogage. Le chargement indépendant signifie que l’application est fournie directement à partir du PC via une connexion câblée, plutôt que par le biais du cloud.

Pointe

Notez l’emplacement de votre package d’image, car vous en aurez besoin lors de la création d’un déploiement. Vous devez voir un message tel que « Le fichier de sortieest à : <chemin d’accès> » dans la sortie Afficher>> lasortie Afficher la sortie de : Build, où <chemin d’accès> est le chemin complet du dossier de build de votre application Blink, se terminant généralement par « out/ARM-Debug ».
Par défaut, le volet Sortie affiche la sortie de sortie de l’appareil. Pour afficher les messages du débogueur, sélectionnez Déboguer dans le menu déroulant Afficher la sortie de : . Vous pouvez également inspecter le désassemblement du programme, les registres ou la mémoire via le menu Déboguer>Windows .
Lorsque vous exécutez le programme, vous devez voir un voyant clignoter.

Télécharger l’exemple d’application

Vous pouvez télécharger l’application HelloWorld comme suit :

Pointez votre navigateur vers Microsoft Samples Browser.
Tapez « Azure Sphere » dans la zone Recherche.
Sélectionnez Azure Sphere - Hello World dans les résultats de la recherche.
Sélectionnez Télécharger le fichier ZIP.
Ouvrez le fichier téléchargé et extrayez-le dans un répertoire local.

Générer l’exemple

Pour créer les fichiers build et .imagepackage pour l’exemple d’application HelloWorld_HighLevelApp, procédez comme suit.

Mettez à jour l’exemple pour cibler votre matériel, si nécessaire. Par défaut, les exemples ciblent le matériel qui suit la conception de la carte de référence (RDB) MT3620, comme le kit de développement MT3620 de Seeed Studios. Des définitions de matériel cible supplémentaires pour les exemples d’applications sont disponibles dans le répertoire HardwareDefinitions du référentiel Exemples Azure Sphere. Par exemple, les fichiers de définition de matériel pour le Starter Kit Avnet MT3620 se trouvent dans le sous-répertoire HardwareDefinitions/avnet_mt3620_sk.
- Ouvrez CMakeLists.txt et mettez à jour le paramètre TARGET_DIRECTORY dans la fonction azure_target_hardware_definition pour qu’il pointe vers le sous-répertoire de votre matériel. Par exemple :
```
azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "../../../HardwareDefinitions/avnet_mt3620_sk" TARGET_DEFINITION "sample_appliance.json")
```
Ouvrez une interface de ligne de commande à l’aide de PowerShell, de l’invite de commandes Windows ou de l’interpréteur de commandes Linux. Accédez au répertoire de build de votre projet.
À partir du répertoire de build de votre projet, à l’invite de commandes, exécutez CMake avec les paramètres suivants :
```
cmake --preset <preset-name> <source-path>
```
- --preset <preset-name>
  
  Nom prédéfini de configuration de build tel que défini dans CMakePresets.json.
- --build <cmake-path>
  
  Répertoire binaire qui contient le cache CMake. Par exemple, si vous exécutez CMake sur un exemple Azure Sphere, la commande build est cmake --build out/ARM-Debug.
- <source-path>
  
  Chemin d’accès du répertoire qui contient les fichiers sources de l’exemple d’application. Dans l’exemple, le référentiel d’exemples Azure Sphere a été téléchargé dans un répertoire appelé AzSphere.
  
  Les paramètres CMake sont séparés par des espaces. Le caractère de continuation de ligne (^ pour la ligne de commande Windows, \ pour la ligne de commande Linux ou ' pour PowerShell) peut être utilisé pour la lisibilité, mais n’est pas obligatoire.
Les exemples suivants illustrent les commandes CMake pour la Hello World application de haut niveau :
- Windows
- Linux
Invite de commandes Windows
```
 cmake ^
 --preset "ARM-Debug" ^
 "C:\AzSphere\azure-sphere-samples\Samples\HelloWorld\HelloWorld_HighLevelApp"
```
Windows PowerShell
```
 cmake `
 --preset "ARM-Debug" `
 "C:\AzSphere\azure-sphere-samples\Samples\HelloWorld\HelloWorld_HighLevelApp"
```
```
cmake \
 --preset "ARM-Debug" \
 ./AzSphere/azure-sphere-samples/Samples/HelloWorld/HelloWorld_HighLevelApp
```
Exécutez Ninja pour générer l’application et créer le fichier de package d’image :
```
ninja -C out/ARM-Debug
```
Ninja place l’application et les fichiers .imagepackage obtenus dans le répertoire spécifié.

Vous pouvez également appeler Ninja via CMake avec la commande suivante :
```
cmake --build out/<binary-dir>
```
Définissez <binary-dir> sur le répertoire binaire qui contient le cache CMake. Par exemple, si vous exécutez CMake sur un exemple Azure Sphere, la commande build est cmake --build out/ARM-Debug.

Lors de la résolution des problèmes, en particulier après avoir apporté des modifications à vos commandes CMake, supprimez l’intégralité de votre build et réessayez.

Exécuter l’exemple

Si votre appareil exécute déjà une application, supprimez l’application :
```
az sphere device sideload delete
```
Accédez au répertoire qui contient les fichiers build et .imagepackage créés précédemment.
Chargez le package d’images sur votre appareil en exécutant la commande az sphere device sideload deploy et en spécifiant le package d’image. Par exemple :
```
az sphere device sideload deploy --image-package HelloWorld_HighLevelApp.imagepackage
```
Cette commande charge le package d’image et démarre l’application. Vous devriez voir un voyant clignoter.

Pointe

Notez le chemin du package d’image. Vous utiliserez le package d’image plus loin dans le guide de démarrage rapide sur le déploiement.

Déboguer l’exemple

Accédez au répertoire qui contient les fichiers build et .imagepackage créés précédemment.

Obtenez l’ID du composant si vous ne l’avez pas déjà :

az sphere image-package show --image-package HelloWorld_HighLevelApp.imagepackage

Si l’application est en cours d’exécution, arrêtez-la, puis redémarrez-la avec l’option --debug-mode :

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

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

Vous devriez voir :

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

Utilisez un client terminal pour établir une connexion Telnet ou TCP brute pour lire le flux de sortie du processus. Spécifiez 192.168.35.2 comme adresse IP et 2342 comme port.

Ouvrez une interface de ligne de commande à l’aide de PowerShell ou d’une invite de commandes standard sur Windows, ou interpréteur de commandes sur Linux, puis transmettez le fichier binaire de l’application .out à partir de votre build en tant que paramètre. Cela permet d’activer le débogage complet du code source.

Windows
Linux

Invite de commandes Windows

"C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\gcc\arm-poky-linux-musleabi-gdb" HelloWorld_HighLevelApp.out

Windows PowerShell

& "C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\gcc\arm-poky-linux-musleabi-gdb" HelloWorld_HighLevelApp.out

 /opt/azurespheresdk/Sysroots/*sysroot*/tools/sysroots/x86_64-pokysdk-linux/usr/bin/arm-poky-linux-musleabi/arm-poky-linux-musleabi-gdb HelloWorld_HighLevelApp.out

Note

Le Kit de développement logiciel (SDK) Azure Sphere est fourni avec plusieurs sysroots afin que les applications puissent cibler différents ensembles d’API, comme décrit dans Version du runtime d’application, sysroots et API bêta. Les sysroots sont installés dans le dossier d’installation du Kit de développement logiciel (SDK) Azure Sphere sous Sysroots.

Définissez la cible de débogage distant sur l’adresse IP 192.168.35.2 sur le port 2345 :

target remote 192.168.35.2:2345
Exécutez les autres commandes gdb que vous choisissez. Par exemple, les commandes suivantes définissent un point d’arrêt lors de l’entrée sur main(), puis continuent l’exécution après le point d’arrêt, respectivement.
```
break main
```
```
c
```
Pour plus d’informations sur le débogage avec gdb, consultez GDB : Le débogueur de projet GNU ou l’une des nombreuses autres sources sur le sujet.

Étapes suivantes

Vous avez créé une application de haut niveau à exécuter sur votre appareil Azure Sphere. Vous souhaiterez peut-être le modifier maintenant. Définitions matérielles décrit comment modifier un fichier JSON de définition matérielle et regéner le fichier d’en-tête associé.

Ensuite, découvrez comment déployer votre application de haut niveau à partir du cloud.

Tutoriel : Créer un déploiement cloud

Voir aussi

Visitez la galerie Azure Sphere, une collection de scripts, utilitaires et fonctions Azure Sphere inspirants, non entretenus et réutilisables.

Partager via