Partager via

Créer une application en temps réel

  • Article

Vous pouvez utiliser Visual Studio, Visual Studio Code ou la ligne de commande (CLI) pour développer et déboguer des applications en temps réel (RTApps) de la même façon que les applications de haut niveau.

Conditions préalables

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.

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, comme décrit dans Fonctionnalités et communication 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 si vous ne l’avez pas déjà fait :

    az login

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

  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 avec le message d’erreur suivant, consultez Résoudre les problèmes d’Azure Sphere pour obtenir de l’aide.

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

Générer l’application en temps réel à l’aide de Visual Studio Code

Pour générer une application en temps réel :

  1. Dans Visual Studio Code, ouvrez le dossier HelloWorld_RTApp_MT3620_BareMetal dans votre clone du référentiel d’exemples Azure Sphere. Si vous êtes invité à sélectionner un kit, choisissez « Ne pas utiliser de kit ».

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

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

    Tick

    Tock

    Note

    Visual Studio Code fournit IntelliSense, mais il ne se met pas automatiquement à jour lorsque vous modifiez CMakeLists.txt. Vous devez exécuter la commande CMake : Supprimer le cache et reconfigurer pour actualiser IntelliSense. La vue des cibles CMake se trouve dans la vue d’extension CMake sur la barre de gauche.

Générer l’application en temps réel à l’aide de Visual Studio

Pour générer une application en temps réel :

  1. Dans Visual Studio, sélectionnez Fichier>CMake et accédez au dossier qui contient l’exemple.

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

  3. Dans Visual Studio, afficher>la sortie>Afficher la sortie de : La sortie CMake doit afficher les messages CMake generation started. et CMake generation finished.

  4. Dans le menu CMake (le cas échéant), sélectionnez Tout générer. Si le menu n’est pas présent, ouvrez Explorateur de solutions, cliquez avec le bouton droit sur le fichier CMakeLists.txt, puis sélectionnez Générer. L’emplacement de sortie de l’application Azure Sphere s’affiche dans la fenêtre Sortie .

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

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

    Tick

    Tock

    Note

    • Visual Studio fournit IntelliSense pour les rtapps Azure Sphere en collectant des données à partir de son cache CMake. Visual Studio met à jour le cache chaque fois que le fichier CMakeLists.txt ou CMakeSettings.json dans l’application en temps réel change.

    • Par défaut, Visual Studio utilise l’affichage Dossier. Si vous préférez une vue logique du projet CMake, vous pouvez passer à l’affichage Cibles CMake. Dans Explorateur de solutions, sélectionnez l’icône bascule de dossier :

      Basculer entre les affichages Solution et Dossier

      Dans le menu déroulant, sélectionnez Vue des cibles CMake.

    • 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, puis passez à l’exécution.

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

      4. Parcourir le code comme d’habitude.

Générer une application en temps réel à l’aide de l’interface CLI

Les instructions suivantes supposent que vous utilisez CMake. Si vous préférez générer sur la ligne de commande sans utiliser CMake, vous pouvez déterminer les options appropriées du compilateur et de l’éditeur de liens en examinant les fichiers AzureSphereToolchainBase.cmake et AzureSphereRTCoreToolchain.cmake, qui sont installés avec le Kit de développement logiciel (SDK) Azure Sphere.

  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 helloWorld RTApp :

    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.

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

    az sphere device sideload delete

  5. Déployez le package d’image créé par Ninja :

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

  6. 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"
  },
...

  7. Déterminez le cœur sur lequel votre application s’exécute.

    Par défaut, l’application en temps réel est déployée sur le premier cœur en temps réel disponible sur l’appareil ; actuellement, vous ne pouvez pas spécifier un cœur particulier. Pour savoir sur quel cœur l’application s’exécute, utilisez la commande az sphere device app pour arrêter, puis redémarrer l’application. Fournissez l’ID de composant pour l’application dans les commandes. Par exemple :

    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’émulateur de terminal connecté doit afficher la sortie de l’application. Le programme envoie les mots suivants à intervalles d’une seconde :

    Tick

    Tock

Sortie du journal d’une application en temps réel

Chaque cœur en temps réel sur le MT3620 dispose d’un UART dédié destiné à la journalisation de la sortie. Les cœurs en temps réel peuvent également accéder aux UART de l’ISU. La base de données RDB MT3620 expose uniquement la broche TX, que vous pouvez utiliser pour afficher la sortie du journal à partir de l’application. D’autres matériels peuvent exposer cela différemment, ou pas du tout. Pour afficher la sortie du journal, configurez votre matériel pour afficher cette sortie, comme décrit dans le guide de démarrage rapide. L’UART dédié ne nécessite pas l’exigence du manifeste de l’application Uart . Toutefois, elle ne doit pas être utilisée à des fins autres que la journalisation de la sortie d’une application en temps réel.

Développer avec 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 .

Dépannage

Si vous rencontrez des problèmes, consultez Résolution des problèmes liés aux applications en temps réel.

Ressources supplémentaires

Des pilotes et des exemples supplémentaires pour les rtApps qui ciblent les cœurs en temps réel M4 sur la puce MT3620 sont disponibles sur GitHub auprès des partenaires Azure Sphere :