Partage via


Tutoriel : Créer une application en temps réel

Ce tutoriel montre comment créer un exemple d’application pour les cœurs en temps réel sur un appareil Azure Sphere. Consultez Vue d’ensemble des applications Azure Sphere pour obtenir des informations de base sur les applications compatibles en temps réel.

Dans ce tutoriel, vous allez apprendre à :

  • Télécharger un exemple d’application
  • Installer la chaîne d’outils GNU Arm
  • Configurer le matériel pour afficher la sortie
  • Activer le développement et le débogage
  • Démarrer un émulateur de terminal pour afficher la sortie
  • Générer, exécuter et déboguer une application compatible en temps réel

Important

Ces instructions supposent que vous utilisez du matériel qui suit le matériel de conception de carte de référence (RDB) MT3620, tel que le kit de développement MT3620 de Seeed Studios. Si vous utilisez un autre matériel Azure Sphere, consultez la documentation du fabricant pour savoir si l’UART est exposé et comment y accéder. Vous devrez peut-être configurer le matériel pour afficher la sortie différemment et mettre à jour l’exemple de code et le champ Uarts du fichier app_manifest.json pour utiliser un autre UART.

Conditions préalables

Télécharger l’exemple d’application

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

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

Installer la chaîne d’outils GNU Arm Embedded

Vous pouvez télécharger et installer GNU Arm Embedded Toolchain à partir du site web du développeur Arm. Vous pouvez également utiliser des artefacts vcpkg pour installer et configurer automatiquement l’environnement de développement.

  • Visual Studio 2022 : si vous utilisez Visual Studio 2022, installez la chaîne d’outils incorporée GNU Arm (arm-none-eabi) à partir du site web du développeur Arm.
  • Visual Studio 2019 : la chaîne d’outils est automatiquement installée avec l’extension azure-sphere pour Visual Studio sur Visual Studio 2019. Si vous utilisez Visual Studio 2019, passez à Configurer le matériel pour afficher la sortie. Toutefois, si vous avez installé la chaîne d’outils GNU Arm Embedded manuellement, Visual Studio utilise la version que vous avez installée.

Pour installer la chaîne d’outils, sur le site web du développeur Arm, recherchez la chaîne d’outils incorporée GNU Arm (arm-none-eabi) qui inclut le compilateur pour le processeur ARM Cortex-M4. Suivez les instructions qui s’y trouvent pour télécharger et installer le compilateur pour votre plateforme de système d’exploitation.

Par défaut, Visual Studio Code recherche la chaîne d’outils et doit trouver la version que vous avez installée. Si vous rencontrez des problèmes de build liés à la chaîne d’outils, entrez le chemin d’accès comme suit :

  1. SélectionnezPréférences>de fichier>Paramètres>Extensions>Azure Sphere.
  2. Entrez le chemin d’installation de GNU Arm Embedded Toolchain dans le paramètre Azure Sphere : Chemin Arm Gnu .

Pour installer la chaîne d’outils, sur le site web du développeur Arm, recherchez la chaîne d’outils incorporée GNU Arm (arm-none-eabi) qui inclut le compilateur pour le processeur ARM Cortex-M4. Suivez les instructions qui s’y trouvent pour télécharger et installer le compilateur pour votre plateforme de système d’exploitation.

Configurer le matériel pour afficher la sortie

Actuellement, chaque cœur en temps réel prend en charge un UART TX uniquement. Les applications en temps réel peuvent utiliser cet UART pour envoyer une sortie de journal à partir de l’appareil. Pendant le développement et le débogage d’applications, vous avez généralement besoin d’un moyen de lire et d’afficher la sortie. L’exemple HelloWorld_RTApp_MT3620_BareMetal montre comment une application peut écrire dans l’UART.

Utilisez un adaptateur USB-série tel que le FTDI Friend pour connecter l’UART sur le cœur en temps réel à un port USB de votre machine. Vous aurez également besoin d’un émulateur de terminal pour établir une connexion série avec les paramètres de terminal 115200-8-N-1 (115 200 bps, 8 bits, aucun bits de parité, un bit d’arrêt) pour afficher la sortie.

Pour configurer le matériel pour afficher la sortie d’une application en temps réel, procédez comme suit. Vous devez vous reporter à la documentation du fabricant de votre matériel pour déterminer les emplacements des broches. Si vous utilisez du matériel qui suit le matériel de conception de carte de référence (RDB) MT3620, comme le kit de développement MT3620 de Seeed Studios, l’examen des en-têtes d’interface RDB peut vous aider à déterminer les emplacements des broches.

  1. Connectez GND sur l’adaptateur USB-série à GND sur votre kit de développement. Sur le matériel RDB MT3620, GND est En-tête 3, broche 2.
  2. Connectez RX sur l’adaptateur USB-série à IOM4-0 TX sur votre kit de développement. Sur le matériel RDB MT3620, IOM4-0 TX est En-tête 3, broche 6.
  3. Connectez l’adaptateur USB-série à un port USB gratuit sur votre ordinateur de développement et déterminez le port auquel le périphérique série est connecté. Sur Windows, démarrez Gestionnaire de périphériques, sélectionnez Afficher>les appareils par conteneur, puis recherchez « USB UART ». Par exemple, L’UART USB FT232R indique l’adaptateur FTDI Friend.
  4. Démarrez un programme d’émulateur de terminal et ouvrez un terminal 115200-8-N-1 sur le port COM utilisé par l’adaptateur. Consultez la documentation de l’émulateur de terminal pour savoir comment spécifier le port et la vitesse.

Configurer le matériel pour afficher la sortie

Actuellement, chaque cœur en temps réel prend en charge un UART TX uniquement. Les applications en temps réel peuvent utiliser cet UART pour envoyer une sortie de journal à partir de l’appareil. Pendant le développement et le débogage d’applications, vous avez généralement besoin d’un moyen de lire et d’afficher la sortie. L’exemple HelloWorld_RTApp_MT3620_BareMetal montre comment une application peut écrire dans l’UART.

Utilisez un adaptateur USB-série tel que le FTDI Friend pour connecter l’UART sur le cœur en temps réel à un port USB de votre machine. Vous aurez également besoin d’un émulateur de terminal pour établir une connexion série avec les paramètres de terminal 115200-8-N-1 (115 200 bps, 8 bits, aucun bits de parité, un bit d’arrêt) pour afficher la sortie.

Pour configurer le matériel pour afficher la sortie d’une application en temps réel, procédez comme suit. Vous devez vous reporter à la documentation du fabricant de votre matériel pour déterminer les emplacements des broches. Si vous utilisez du matériel qui suit le matériel de conception de carte de référence (RDB) MT3620, comme le kit de développement MT3620 de Seeed Studios, l’examen des en-têtes d’interface RDB peut vous aider à déterminer les emplacements des broches.

  1. Connectez GND sur l’adaptateur USB-série à GND sur votre kit de développement. Sur le matériel RDB MT3620, GND est En-tête 3, broche 2.

  2. Connectez RX sur l’adaptateur USB-série à IOM4-0 TX sur votre kit de développement. Sur le matériel RDB MT3620, IOM4-0 TX est En-tête 3, broche 6.

  3. Connectez l’adaptateur USB-série à un port USB gratuit sur votre ordinateur de développement et déterminez le port auquel le périphérique série est connecté.

    • Sur Windows, démarrez Gestionnaire de périphériques, sélectionnez Afficher>les appareils par conteneur, puis recherchez « USB UART ». Par exemple, L’UART USB FT232R indique l’adaptateur FTDI Friend.

    • Sur Linux, tapez la commande suivante :

      dmesg | grep ttyUSB
      

      Le port doit être nommé ttyUSBn, où n indique le numéro de port. Si la dmesg commande répertorie plusieurs ports USB, celui qui est connecté au généralement le dernier comme étant attaché. Par exemple, dans ce qui suit, vous utilisez ttyUSB4 :

    ~$ dmesg | grep ttyUSB
    [  144.564350] usb 1-1.1.2: FTDI USB Serial Device converter now attached to ttyUSB0
    [  144.564768] usb 1-1.1.2: FTDI USB Serial Device converter now attached to ttyUSB1
    [  144.565118] usb 1-1.1.2: FTDI USB Serial Device converter now attached to ttyUSB2
    [  144.565593] usb 1-1.1.2: FTDI USB Serial Device converter now attached to ttyUSB3
    [  144.570429] usb 1-1.1.3: FTDI USB Serial Device converter now attached to ttyUSB4
    [  254.171871] ftdi_sio ttyUSB1: FTDI USB Serial Device converter now disconnected from ttyUSB1
    
  4. Démarrez un programme d’émulateur de terminal et ouvrez un terminal 115200-8-N-1 sur le port COM utilisé par l’adaptateur. Consultez la documentation de l’émulateur de terminal pour savoir comment spécifier le port et la vitesse.

Activer 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 débogage. 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 PC, et ils n’autorisent pas le débogage des applications. La préparation de l’appareil pour le débogage supprime cette restriction et charge les logiciels requis pour le débogage et déverrouille les fonctionnalités de l’appareil .

Pour déboguer sur les cœurs en temps réel, utilisez la commande az sphere device enable-development . Cette commande configure l’appareil pour qu’il accepte les applications d’un PC à des fins de débogage et affecte l’appareil au groupe d’appareils de développement, 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.

Sur Windows, vous devez ajouter le --enable-rt-core-debugging paramètre , qui charge les serveurs de débogage et les pilotes requis pour chaque type de cœur sur l’appareil.

  1. Connectez-vous à Azure Sphere si vous ne l’avez pas déjà fait :

    az login
    
  2. Ouvrez une interface de ligne de commande à l’aide de PowerShell ou de l’invite de commandes Windows avec des privilèges d’administrateur. Le --enable-rt-core-debugging paramètre nécessite un privilège d’administrateur, car il installe des pilotes USB pour le débogueur.

  3. Entrez la commande suivante :

    az sphere device enable-development --enable-rt-core-debugging  --catalog <CatalogName>  --resource-group <ResourceGroupName>
    
  4. Fermez la fenêtre une fois la commande terminée, car le privilège administrateur n’est plus nécessaire. Comme meilleure pratique, vous devez toujours utiliser le privilège le plus bas qui peut accomplir une tâche.

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 RTApp HelloWorld avec Visual Studio

  1. Démarrez Visual Studio. Sélectionnez Ouvrir un dossier local, accédez au dossier dans lequel vous avez extrait le fichier Azure_Sphere___Hello_World.zip téléchargé, puis sélectionnez le dossier HelloWorld_RTApp_MT3620_Baremetal.

  2. Si vous n’utilisez pas de RDB MT3620, mettez à jour le fichier app_manifest.json et l’exemple de code pour spécifier l’UART correct, par exemple ISU1.

  3. Si la génération de CMake ne démarre pas automatiquement, sélectionnez le fichier CMakeLists.txt.

  4. Dans la fenêtre Sortie de Visual Studio , la sortie CMake doit afficher les messages CMake generation started. et CMake generation finished..

  5. Sélectionnez Générer>tout. Si le menu n’est pas présent, ouvrez Explorateur de solutions, cliquez avec le bouton droit sur le fichier CMakeLists.txt et sélectionnez Générer. L’emplacement de sortie de l’application HelloWorld_RTApp_MT3620_Baremetal s’affiche dans la fenêtre Sortie .

  6. Dans le menu Sélectionner un élément de démarrage, sélectionnez HelloWorld_RTApp_MT3620_Baremetal (RTCore).

  7. Appuyez sur F5 pour déployer l’application.

  8. L’émulateur de terminal connecté doit afficher la sortie du programme HelloWorld_RTApp_MT3620_Baremetal. Le programme envoie les mots suivants à intervalles d’une seconde :

    Tick

    Tock

  9. Utilisez le débogueur pour définir des points d’arrêt, inspecter les variables et essayer d’autres tâches de débogage.

Générer et exécuter l’application RTApp HelloWorld avec Visual Studio Code

  1. Dans Visual Studio Code, ouvrez le dossier HelloWorld_RTApp_MT3620_BareMetal dans le dossier dans lequel vous avez extrait le fichier Azure_Sphere___Hello_World.zip téléchargé. Si vous êtes invité à sélectionner un kit, choisissez Ne pas utiliser de kit.

  2. Si vous n’utilisez pas de matériel RDB MT3620, mettez à jour le fichier app_manifest.json et l’exemple de code pour spécifier l’UART approprié, par exemple ISU1.

  3. Appuyez sur F5 pour démarrer le débogueur. Si le projet n’a pas été généré précédemment, ou si les fichiers ont été modifiés et que la reconstruction est requise, Visual Studio Code génère le projet avant le démarrage du débogage.

  4. La fenêtre de sortie Azure Sphere doit afficher « Déploiement de l’image... » suivis des chemins d’accès au SDK et au compilateur.

  5. L’émulateur de terminal connecté doit afficher la sortie du programme HelloWorld_RTApp_MT3620_Baremetal. Le programme envoie les mots suivants à intervalles d’une seconde :

    Tick

    Tock

  6. Utilisez les fonctionnalités de débogage de Visual Studio Code pour définir des points d’arrêt, inspecter des variables et essayer d’autres tâches de débogage.

Dépannage

L’application peut commencer à s’exécuter avant qu’OpenOCD n’établit une connexion. Par conséquent, les points d’arrêt définis au début du code peuvent être manqués. Une solution de contournement simple consiste à retarder le démarrage de l’application jusqu’à ce qu’OpenOCD se connecte.

  1. Insérez le code suivant au début du point d’entrée de l’application RTCoreMain. Cela entraîne l’entrée et le maintien de l’application dans une while boucle jusqu’à ce que la variable f soit définie sur true.

     volatile bool f = false;
     while (!f) {
        // empty.
     }
    
  2. Appuyez sur F5 pour démarrer l’application avec le débogage (F5), puis passez à l’exécution.

  3. Dans le volet Débogage local , remplacez la valeur de f zéro par un.

  4. Parcourez le code comme d’habitude.

Générer l’exemple

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

  2. À 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 une application en temps réel. Lorsque cela est indiqué, remplacez <file-path> par le chemin d’installation de gnu Arm Embedded Toolchain sur votre système.

    Invite de commandes 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. 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

  1. Supprimez toutes les applications déjà déployées sur l’appareil :

    az sphere device sideload delete
    
  2. À partir du répertoire de votre projet, à l’invite de commandes, chargez le package d’image créé par ninja :

    az sphere device sideload deploy --image-package <path-to-imagepackage>
    

    L’application commence à s’exécuter peu après son chargement. Les éléments suivants s’affichent sur l’émulateur de terminal connecté :

    Tick
    
    Tock
    
    Tick
    .
    .
    .
    
  3. Obtenez l’ID de composant pour l’image :

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

    La commande retourne toutes les métadonnées du package d’image. L’ID de composant de l’application apparaît dans la section Identité pour le type d’image d’application. Par exemple :

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

    Vous pouvez utiliser les commandes suivantes pour arrêter, démarrer et obtenir les status de l’application :

    az sphere device app stop --component-id <component id>
    
    az sphere device app start --component-id <component id>
    
    az sphere device app show-status --component-id <component id>
    

Déboguer l’exemple

  1. Arrêtez l’application si elle est en cours d’exécution.

    az sphere device app stop --component-id <component id>
    
  2. Relancez l’application pour le débogage.

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

    Cette commande retourne le noyau sur lequel l’application s’exécute.

    <component id>
    App state   : running
    Core        : Real-time 0
    
  3. Accédez au dossier Openocd pour le sysroot avec lequel l’application a été générée. Les sysroots sont installés dans le dossier d’installation du Kit de développement logiciel (SDK) Azure Sphere. Par exemple, sur Windows, le dossier est installé par défaut sur C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\openocd et sur Linux, à l’adresse /opt/azurespheresdk/Sysroots/*sysroot*/tools/sysroots/x86_64-pokysdk-linux.

  4. Exécutez openocd comme le montre l’exemple suivant. L’exemple suppose que l’application s’exécute sur le noyau 0. Si l’application s’exécute sur core 1, remplacez « targets io0 » par « 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. Accédez au dossier qui contient le fichier .out de l’application et démarrez arm-none-eabi-gdb, qui fait partie de la chaîne d’outils GNU Arm Embedded :

    Invite de commandes Windows

    "C:\Program Files (x86)\GNU Arm Embedded Toolchain\9 2020-q2-update\bin\arm-none-eabi-gdb" HelloWorld_RTApp_MT3620_BareMetal.out
    

    Windows PowerShell

    & "C:\Program Files (x86)\GNU Arm Embedded Toolchain\9 2020-q2-update\bin\arm-none-eabi-gdb" HelloWorld_RTApp_MT3620_BareMetal.out
    
  6. Le serveur OpenOCD fournit une interface de serveur GDB sur :4444. Définissez la cible pour le débogage.

    target remote :4444

  7. Vous pouvez maintenant exécuter des commandes gdb.

  8. L’émulateur de terminal connecté doit afficher la sortie de l’application.

Utiliser des applications partenaires

Lorsque vous chargez une application sur l’appareil Azure Sphere, les outils de déploiement Azure Sphere suppriment par défaut toutes les applications existantes. Pour éviter que cela ne se produise lorsque vous développez des applications qui communiquent entre elles, vous devez marquer les applications comme des partenaires. Lorsque vous déployez l’une des applications, ses partenaires ne sont pas supprimés. Pour plus d’informations, consultez Marquer des applications en tant que partenaires .

Étapes suivantes