Tutoriel : Connecter une application d’appareil multicomposant IoT Plug-and-Play s’exécutant sur Linux ou Windows à IoT Hub

Article
02/06/2024

Ce tutoriel vous montre comment créer un exemple d'application d'appareil IoT Plug-and-Play avec des composants, comment le connecter à votre hub IoT, et comment utiliser l'outil Explorateur Azure IoT pour voir les informations qu'il envoie au hub. L’exemple d’application est écrit en C et est inclus dans le Azure IoT device SDK pour C. Un générateur de solutions peut utiliser l’outil Explorateur Azure IoT pour comprendre les fonctionnalités d’un appareil IoT Plug-and-Play sans avoir à afficher de code d’appareil.

Dans ce tutoriel, vous allez :

Téléchargez l’exemple de code.
Générez l’exemple de code.
Exécutez l’exemple d’application d’appareil et vérifiez qu’il se connecte à votre hub IoT.
Vérifiez le code source.

Prérequis

Avant de continuer, assurez-vous d’avoir configuré votre environnement, y compris votre hub IoT.

Vous pouvez suivre ce tutoriel sur Linux ou Windows. Dans ce tutoriel, les commandes de l’interpréteur de commandes suivent la convention Linux des séparateurs de chemin « / ». Si vous suivez ce guide sur Windows, veillez à remplacer les séparateurs par « \ ».

Les prérequis diffèrent selon le système d’exploitation :

Linux

Ce tutoriel suppose que vous utilisez Ubuntu Linux. Les étapes de ce didacticiel ont été testées à l’aide d’Ubuntu 18.04.

Pour suivre ce tutoriel sur Linux, installez les logiciels suivants dans votre environnement Linux local :

Installez GCC, Git, cmake et toutes les dépendances nécessaires à l’aide de la commande apt-get :

sudo apt-get update
sudo apt-get install -y git cmake build-essential curl libcurl4-openssl-dev libssl-dev uuid-dev

Vérifiez que la version de cmake est supérieure à 2.8.12 et que la version de GCC est supérieure à 4.4.7.

cmake --version
gcc --version

Windows

Pour effectuer ce tutoriel sur Windows, vous devez installer les logiciels suivants sur votre environnement Windows local :

Visual Studio (Community, Professional ou Enterprise) : veillez à inclure la charge de travail Développement Desktop en C++ quand vous installez Visual Studio.
Git.
CMake.

Téléchargement du code

Si vous avez suivi le Tutoriel : Connecter un exemple d’application pour appareil IoT Plug-and-Play s’exécutant sur Linux ou Windows à IoT Hub (C), vous avez déjà téléchargé le code.

Dans ce tutoriel, vous préparez un environnement de développement qui vous permet de cloner et générer le kit SDK Azure IoT Hub Device C.

Ouvrez une invite de commandes dans un dossier de votre choix. Exécutez la commande suivante pour cloner le dépôt GitHub Azure IoT C SDKs and Libraries à cet emplacement :

git clone https://github.com/Azure/azure-iot-sdk-c.git
cd azure-iot-sdk-c
git submodule update --init

Attendez-vous à ce que cette opération prenne plusieurs minutes.

Générer et exécuter le code

Vous pouvez générer et exécuter le code à l’aide de Visual Studio ou de cmake sur la ligne de commande.

Utiliser Visual Studio

Ouvrez le dossier racine du dépôt cloné. Après quelques secondes, la prise en charge de CMake dans Visual Studio crée tout ce dont vous avez besoin pour exécuter et déboguer le projet.
Une fois que Visual Studio est prêt, dans l’Explorateur de solutions, accédez à l’exemple iothub_client/samples/pnp/pnp_temperature_controller/ .
Cliquez avec le bouton droit sur le fichier pnp_temperature_controller.c, puis sélectionnez Ajouter une configuration Debug. Sélectionnez Par défaut.

Visual Studio ouvre le fichier launch.vs.json. Modifiez ce fichier comme indiqué dans l’extrait suivant pour définir les variables d’environnement nécessaires. Vous avez noté l’ID d’étendue et la clé primaire d’inscription lorsque vous avez terminé Configurer votre environnement pour les guides de démarrages rapides et tutoriels IoT Plug-and-Play :

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "default",
      "project": "iothub_client\\samples\\pnp\\pnp_temperature_controller\\pnp_temperature_controller.c",
      "projectTarget": "",
      "name": "pnp_temperature_controller.c",
      "env": {
        "IOTHUB_DEVICE_SECURITY_TYPE": "DPS",
        "IOTHUB_DEVICE_DPS_ID_SCOPE": "<Your ID scope>",
        "IOTHUB_DEVICE_DPS_DEVICE_ID": "my-pnp-device",
        "IOTHUB_DEVICE_DPS_DEVICE_KEY": "<Your enrollment primary key>"
      }
    }
  ]
}

Cliquez avec le bouton droit sur le fichier pnp_temperature_controller.c, puis sélectionnez Définir comme élément de démarrage.
Pour tracer l’exécution du code dans Visual Studio, ajoutez un point d’arrêt à la fonction main dans le fichier main.
Vous pouvez à présent exécuter et déboguer l’exemple à partir du menu Déboguer.

L’appareil, désormais prêt à recevoir des commandes et des mises à jour de propriétés, a commencé à envoyer des données de télémétrie au hub. Laissez l’exemple s’exécuter pendant que vous effectuez les étapes suivantes.

Utiliser `cmake` sur la ligne de commande

Pour créer l'exemple :

Créez un sous-dossier cmake dans le dossier racine du kit SDK de l’appareil cloné, puis accédez à ce dossier :
```
cd azure-iot-sdk-c
mkdir cmake
cd cmake
```
Exécutez les commandes suivantes pour produire et générer les fichiers projet du kit SDK et des exemples :
```
cmake ..
cmake --build .
```

Dans Configurer votre environnement, vous avez créé quatre variables d’environnement pour configurer l’exemple afin d’utiliser le service Device Provisioning Service (DPS) pour vous connecter à votre hub IoT :

IOTHUB_DEVICE_SECURITY_TYPE avec la valeur DPS
IOTHUB_DEVICE_DPS_ID_SCOPE avec l’étendue ID DPS.
IOTHUB_DEVICE_DPS_DEVICE_ID avec la valeur my-pnp-device.
IOTHUB_DEVICE_DPS_DEVICE_KEY avec la clé primaire d’inscription.
IOTHUB_DEVICE_DPS_ENDPOINT avec la valeur global.azure-devices-provisioning.net.

Pour en savoir plus sur l’exemple de configuration, consultez l’exemple de fichier Lisez-moi.

Pour exécuter l’exemple :

Dans le dossier cmake, accédez au dossier qui contient le fichier exécutable et exécutez-le :

# Bash
cd iothub_client/samples/pnp/pnp_temperature_controller
./pnp_temperature_controller

REM Windows
cd iothub_client\samples\pnp\pnp_temperature_controller\Debug
pnp_temperature_controller.exe

Utiliser l’Explorateur Azure IoT pour valider le code

Une fois l’exemple de client d’appareil démarré, utilisez l’outil Explorateur Azure IoT pour vérifier qu’il fonctionne.

Ouvrez l’explorateur Azure IoT.
Dans la page Hubs IoT, si vous n’avez pas encore ajouté de connexion à votre hub IoT, sélectionnez + Ajouter une connexion. Entrez la chaîne de connexion pour le hub IoT que vous avez créé précédemment et sélectionnez Enregistrer.
Dans la page Paramètres IoT Plug-and-Play, sélectionnez + Ajouter > Dossier local et sélectionnez le dossier models local dans lequel vous avez enregistré vos fichiers de modèle.
Dans la page Hubs IoT, cliquez sur le nom du hub que vous souhaitez utiliser. Vous voyez la liste des appareils enregistrés sur le hub IoT.
Cliquez sur l’ID d’appareil de l’appareil que vous avez créé précédemment.
Le menu de gauche affiche les différents types d’informations disponibles pour l’appareil.
Sélectionnez Composants IoT Plug-and-Play pour afficher les informations de modèle de votre appareil.
Vous pouvez afficher les différents composants de l’appareil, Le composant par défaut et tous les composants supplémentaires. Sélectionnez un composant à utiliser.
Sélectionnez la page Télémétrie, puis sélectionnez Démarrer pour afficher les données de télémétrie envoyées par l’appareil pour ce composant.
Sélectionnez la page Propriétés (lecture seule) pour afficher les propriétés en lecture seule signalées pour ce composant.
Sélectionnez la page Propriétés (accessibles en écriture) pour afficher les propriétés accessibles en écriture que vous pouvez mettre à jour pour ce composant.
Sélectionnez une propriété par son nom, entrez une nouvelle valeur, puis sélectionnez Mettre à jour la valeur souhaitée.
Pour afficher la nouvelle valeur, sélectionnez le bouton Actualiser.
Sélectionnez la page Commandes pour afficher toutes les commandes pour ce composant.
Sélectionnez la commande que vous souhaitez tester, le cas échéant. Sélectionnez Envoyer la commande pour appeler la commande sur l’appareil. Vous pouvez voir que votre appareil répond à la commande dans la fenêtre d’invite de commandes où l’exemple de code est en cours d’exécution.

Vérifier le code

Cet exemple implémente un appareil contrôleur de température IoT Plug-and-Play. Cet exemple implémente un modèle avec plusieurs composants. Le fichier de modèle DTDL (Digital Twins Definition Language) V2 pour l’appareil de contrôle de température définit la télémétrie, les propriétés et les commandes implémentées par l’appareil.

Fonctions d’assistance IoT Plug-and-Play

Pour cet exemple, le code utilise des fonctions d’assistance du dossier /common :

pnp_device_client_ll contient la méthode de connexion pour IoT Plug-and-Play avec model-id inclus en tant que paramètre : PnP_CreateDeviceClientLLHandle.

pnp_protocol : contient les fonctions d’assistance IoT Plug-and-Play :

PnP_CreateReportedProperty
PnP_CreateReportedPropertyWithStatus
PnP_ParseCommandName
PnP_CreateTelemetryMessageHandle
PnP_ProcessTwinData
PnP_CopyPayloadToString
PnP_CreateDeviceClientLLHandle_ViaDps

Ces fonctions d’assistance sont suffisamment génériques pour être utilisées dans votre propre projet. Cet exemple les utilise dans les trois fichiers qui correspondent à chaque composant du modèle :

pnp_deviceinfo_component
pnp_temperature_controller
pnp_thermostat_component

Par exemple, dans le fichier pnp_deviceinfo_component, la fonction SendReportedPropertyForDeviceInformation utilise deux des fonctions d’assistance :

if ((jsonToSend = PnP_CreateReportedProperty(componentName, propertyName, propertyValue)) == NULL)
{
    LogError("Unable to build reported property response for propertyName=%s, propertyValue=%s", propertyName, propertyValue);
}
else
{
    const char* jsonToSendStr = STRING_c_str(jsonToSend);
    size_t jsonToSendStrLen = strlen(jsonToSendStr);

    if ((iothubClientResult = IoTHubDeviceClient_LL_SendReportedState(deviceClientLL, (const unsigned char*)jsonToSendStr, jsonToSendStrLen, NULL, NULL)) != IOTHUB_CLIENT_OK)
    {
        LogError("Unable to send reported state for property=%s, error=%d", propertyName, iothubClientResult);
    }
    else
    {
        LogInfo("Sending device information property to IoTHub.  propertyName=%s, propertyValue=%s", propertyName, propertyValue);
    }
}

Chaque composant de l’exemple suit ce modèle.

Flux de code

La fonction main initialise la connexion et envoie l’ID du modèle :

deviceClient = CreateDeviceClientAndAllocateComponents();

Le code utilise PnP_CreateDeviceClientLLHandle pour se connecter au hub IoT, définir modelId en tant qu’option et configurer la méthode d’appareil ainsi que les gestionnaires de rappels de jumeaux d’appareil pour les méthodes directes et les mises à jour des jumeaux d’appareil :

g_pnpDeviceConfiguration.deviceMethodCallback = PnP_TempControlComponent_DeviceMethodCallback;
g_pnpDeviceConfiguration.deviceTwinCallback = PnP_TempControlComponent_DeviceTwinCallback;
g_pnpDeviceConfiguration.modelId = g_temperatureControllerModelId;
...

deviceClient = PnP_CreateDeviceClientLLHandle(&g_pnpDeviceConfiguration);

&g_pnpDeviceConfiguration contient également les informations de connexion. La variable d’environnement IOTHUB_DEVICE_SECURITY_TYPE détermine si l’exemple utilise une chaîne de connexion ou le service de provisionnement des appareils pour se connecter au hub IoT.

Quand l’appareil envoie un ID de modèle, il devient un appareil IoT Plug-and-Play.

Une fois les gestionnaires de rappels en place, l’appareil réagit aux mises à jour des jumeaux et aux appels de méthodes directes :

Pour le rappel des jumeaux d’appareil, PnP_TempControlComponent_DeviceTwinCallback appelle la fonction PnP_ProcessTwinData pour traiter les données. PnP_ProcessTwinData utilise le PnP_ProcessTwinData pour analyser le contenu JSON et consulter chaque propriété, en appelant PnP_TempControlComponent_ApplicationPropertyCallback sur chaque élément.

Pour le rappel des commandes, la fonction PnP_TempControlComponent_DeviceMethodCallback utilise la fonction d’assistance afin d’analyser les noms de commandes et de composants :

PnP_ParseCommandName(methodName, &componentName, &componentNameSize, &pnpCommandName);

La fonction PnP_TempControlComponent_DeviceMethodCallback appelle ensuite la commande sur le composant :

LogInfo("Received PnP command for component=%.*s, command=%s", (int)componentNameSize, componentName, pnpCommandName);
if (strncmp((const char*)componentName, g_thermostatComponent1Name, g_thermostatComponent1Size) == 0)
{
    result = PnP_ThermostatComponent_ProcessCommand(g_thermostatHandle1, pnpCommandName, rootValue, response, responseSize);
}
else if (strncmp((const char*)componentName, g_thermostatComponent2Name, g_thermostatComponent2Size) == 0)
{
    result = PnP_ThermostatComponent_ProcessCommand(g_thermostatHandle2, pnpCommandName, rootValue, response, responseSize);
}
else
{
    LogError("PnP component=%.*s is not supported by TemperatureController", (int)componentNameSize, componentName);
    result = PNP_STATUS_NOT_FOUND;
}

La fonction main initialise les propriétés en lecture seule envoyées au hub IoT :

PnP_TempControlComponent_ReportSerialNumber_Property(deviceClient);
PnP_DeviceInfoComponent_Report_All_Properties(g_deviceInfoComponentName, deviceClient);
PnP_TempControlComponent_Report_MaxTempSinceLastReboot_Property(g_thermostatHandle1, deviceClient);
PnP_TempControlComponent_Report_MaxTempSinceLastReboot_Property(g_thermostatHandle2, deviceClient);

La fonction main entre dans une boucle pour mettre à jour les données d’événement et de télémétrie pour chaque composant :

while (true)
{
    PnP_TempControlComponent_SendWorkingSet(deviceClient);
    PnP_ThermostatComponent_SendTelemetry(g_thermostatHandle1, deviceClient);
    PnP_ThermostatComponent_SendTelemetry(g_thermostatHandle2, deviceClient);
}

La fonction PnP_ThermostatComponent_SendTelemetry vous montre comment utiliser le struct PNP_THERMOSTAT_COMPONENT. L’exemple utilise ce struct pour stocker des informations sur les deux thermostats dans le contrôleur de température. Le code utilise la fonction PnP_CreateTelemetryMessageHandle pour préparer le message et l’envoyer :

messageHandle = PnP_CreateTelemetryMessageHandle(pnpThermostatComponent->componentName, temperatureStringBuffer);
...
iothubResult = IoTHubDeviceClient_LL_SendEventAsync(deviceClientLL, messageHandle, NULL, NULL);

Pour finir, la fonction main détruit les différents composants et ferme la connexion au hub.

Ce tutoriel vous montre comment créer un exemple d'application d'appareil IoT Plug-and-Play avec des composants, comment le connecter à votre hub IoT, et comment utiliser l'outil Explorateur Azure IoT pour voir les informations qu'il envoie au hub. L’exemple d’application est écrit en C# et est inclus dans le SDK Azure IoT Device pour C#. Un créateur de solutions peut utiliser l’outil Explorateur Azure IoT pour comprendre les fonctionnalités d’un appareil IoT Plug-and-Play sans avoir besoin d’examiner le code d’appareil.

Dans ce tutoriel, vous allez :

Téléchargez l’exemple de code.
Générez l’exemple de code.
Exécutez l’exemple d’application d’appareil et vérifiez qu’il se connecte à votre hub IoT.
Vérifiez le code source.

Prérequis

Avant de continuer, assurez-vous d’avoir configuré votre environnement, y compris votre hub IoT.

Vous pouvez exécuter ce tutoriel sur Linux ou Windows. Dans ce tutoriel, les commandes de l’interpréteur de commandes suivent la convention Linux des séparateurs de chemin « / ». Si vous suivez ce guide sur Windows, veillez à remplacer les séparateurs par « \ ».

Le dernier Kit de développement logiciel (SDK) .NET 5.0 pour votre plateforme.
Git.

Clonez le référentiel SDK avec l’exemple de code

Si vous avez terminé Démarrage rapide : Connecter un exemple d’application pour appareil IoT Plug-and-Play s’exécutant sur Windows à IoT Hub (C#), vous avez déjà cloné le dépôt.

Clonez les échantillons à partir du dépôt GitHub des échantillons Azure IoT pour C#. Ouvrez une invite de commandes dans un dossier de votre choix. Exécutez la commande suivante pour cloner le dépôt GitHub Microsoft Azure IoT SDK pour .NET :

git clone https://github.com/Azure/azure-iot-sdk-csharp.git

Générer le code

Vous pouvez maintenant construire l’échantillon et l'exécuter. Exécutez les commandes suivantes pour générer l’échantillon :

cd azure-iot-sdk-csharp/iothub/device/samples/solutions/PnpDeviceSamples/TemperatureController
dotnet build

Exécuter l’exemple d’appareil

Pour exécuter l’exemple, exécutez la commande suivante :

dotnet run

Utiliser l’Explorateur Azure IoT pour valider le code

Une fois l’exemple de client d’appareil démarré, utilisez l’outil Explorateur Azure IoT pour vérifier qu’il fonctionne.

Ouvrez l’explorateur Azure IoT.
Dans la page Hubs IoT, si vous n’avez pas encore ajouté de connexion à votre hub IoT, sélectionnez + Ajouter une connexion. Entrez la chaîne de connexion pour le hub IoT que vous avez créé précédemment et sélectionnez Enregistrer.
Dans la page Paramètres IoT Plug-and-Play, sélectionnez + Ajouter > Dossier local et sélectionnez le dossier models local dans lequel vous avez enregistré vos fichiers de modèle.
Dans la page Hubs IoT, cliquez sur le nom du hub que vous souhaitez utiliser. Vous voyez la liste des appareils enregistrés sur le hub IoT.
Cliquez sur l’ID d’appareil de l’appareil que vous avez créé précédemment.
Le menu de gauche affiche les différents types d’informations disponibles pour l’appareil.
Sélectionnez Composants IoT Plug-and-Play pour afficher les informations de modèle de votre appareil.
Vous pouvez afficher les différents composants de l’appareil, Le composant par défaut et tous les composants supplémentaires. Sélectionnez un composant à utiliser.
Sélectionnez la page Télémétrie, puis sélectionnez Démarrer pour afficher les données de télémétrie envoyées par l’appareil pour ce composant.
Sélectionnez la page Propriétés (lecture seule) pour afficher les propriétés en lecture seule signalées pour ce composant.
Sélectionnez la page Propriétés (accessibles en écriture) pour afficher les propriétés accessibles en écriture que vous pouvez mettre à jour pour ce composant.
Sélectionnez une propriété par son nom, entrez une nouvelle valeur, puis sélectionnez Mettre à jour la valeur souhaitée.
Pour afficher la nouvelle valeur, sélectionnez le bouton Actualiser.
Sélectionnez la page Commandes pour afficher toutes les commandes pour ce composant.
Sélectionnez la commande que vous souhaitez tester, le cas échéant. Sélectionnez Envoyer la commande pour appeler la commande sur l’appareil. Vous pouvez voir que votre appareil répond à la commande dans la fenêtre d’invite de commandes où l’exemple de code est en cours d’exécution.

Vérifier le code

Cet exemple implémente un appareil contrôleur de température IoT Plug-and-Play. Le modèle implémenté par cet exemple utilise plusieurs composants. Le fichier de modèle DTDL (Digital Twins Definition Language) V2 pour l’appareil de contrôle de température définit la télémétrie, les propriétés et les commandes implémentées par l’appareil.

Le code de l’appareil se connecte à votre hub IoT en utilisant la méthode CreateFromConnectionString standard. L’appareil envoie l’ID de modèle du modèle DTDL qu’il implémente dans la demande de connexion. Un appareil qui envoie un ID de modèle est un appareil IoT Plug-and-Play :

private static DeviceClient InitializeDeviceClient(string hostname, IAuthenticationMethod authenticationMethod)
{
    var options = new ClientOptions
    {
        ModelId = ModelId,
    };

    var deviceClient = DeviceClient.Create(hostname, authenticationMethod, TransportType.Mqtt, options);
    deviceClient.SetConnectionStatusChangesHandler((status, reason) =>
    {
        s_logger.LogDebug($"Connection status change registered - status={status}, reason={reason}.");
    });

    return deviceClient;
}

L’ID de modèle est stocké dans le code, comme indiqué dans l’extrait de code suivant :

private const string ModelId = "dtmi:com:example:TemperatureController;1";

Une fois que l’appareil se connecte à votre hub IoT, le code inscrit les gestionnaires de commandes. La commande reboot est définie dans le composant par défaut. La commande getMaxMinReport est définie dans chacun des deux composants de thermostat :

await _deviceClient.SetMethodHandlerAsync("reboot", HandleRebootCommandAsync, _deviceClient, cancellationToken);
await _deviceClient.SetMethodHandlerAsync("thermostat1*getMaxMinReport", HandleMaxMinReportCommandAsync, Thermostat1, cancellationToken);
await _deviceClient.SetMethodHandlerAsync("thermostat2*getMaxMinReport", HandleMaxMinReportCommandAsync, Thermostat2, cancellationToken);

Il existe des gestionnaires distincts pour les mises à jour des propriétés souhaitées sur les deux composants de thermostat :

_desiredPropertyUpdateCallbacks.Add(Thermostat1, TargetTemperatureUpdateCallbackAsync);
_desiredPropertyUpdateCallbacks.Add(Thermostat2, TargetTemperatureUpdateCallbackAsync);

L’exemple de code envoie des données de télémétrie depuis chaque composant de thermostat :

await SendTemperatureAsync(Thermostat1, cancellationToken);
await SendTemperatureAsync(Thermostat2, cancellationToken);

La méthode SendTemperatureTelemetryAsync utilise la classe PnpHhelper pour créer des messages pour chaque composant :

using Message msg = PnpHelper.CreateIothubMessageUtf8(telemetryName, JsonConvert.SerializeObject(currentTemperature), componentName);

La classe PnpHelper contient d’autres exemples de méthodes que vous pouvez utiliser avec un modèle à plusieurs composants.

Utilisez l’outil Explorateur Azure IoT pour visualiser les données de télémétrie et les propriétés des deux composants de thermostat :

Appareil à plusieurs composants dans l’Explorateur Azure IoT

Vous pouvez également utiliser l'outil Explorateur Azure IoT pour appeler des commandes dans l'un ou l'autre des deux composants de thermostat, ou dans le composant par défaut.

Ce tutoriel vous montre comment créer un exemple d'application d'appareil IoT Plug-and-Play avec des composants, comment le connecter à votre hub IoT, et comment utiliser l'outil Explorateur Azure IoT pour voir les informations qu'il envoie au hub. L’exemple d’application est écrit en Java et est inclus dans l’Azure IoT device SDK pour Java. Un créateur de solutions peut utiliser l’outil Explorateur Azure IoT pour comprendre les fonctionnalités d’un appareil IoT Plug-and-Play sans avoir besoin d’examiner du code d’appareil.

Dans ce tutoriel, vous allez :

Téléchargez l’exemple de code.
Générez l’exemple de code.
Exécutez l’exemple d’application d’appareil et vérifiez qu’il se connecte à votre hub IoT.
Vérifiez le code source.

Prérequis

Avant de continuer, assurez-vous d’avoir configuré votre environnement, y compris votre hub IoT.

Pour suivre ce tutoriel, installez le logiciel suivant dans votre environnement local :

Téléchargement du code

Si vous avez terminé Tutoriel : Connecter un exemple d’application pour appareil IoT Plug-and-Play à IoT Hub (Java), vous avez déjà cloné le référentiel.

Ouvrez une invite de commandes dans le répertoire de votre choix. Exécutez la commande suivante pour cloner le dépôt GitHub de kits de développement logiciel (SDK) et de bibliothèques Java Azure IoT dans cet emplacement :

git clone https://github.com/Azure/azure-iot-sdk-java.git

Attendez-vous à ce que cette opération prenne plusieurs minutes.

Générer le code

Accédez au dossier racine de l’exemple de contrôleur de température dans le référentiel du SDK Java cloné et générez-le :

cd azure-iot-sdk-java/device/iot-device-samples/pnp-device-sample/temperature-controller-device-sample
mvn clean package

Exécuter l’exemple d’appareil

IOTHUB_DEVICE_SECURITY_TYPE avec la valeur DPS
IOTHUB_DEVICE_DPS_ID_SCOPE avec l’étendue ID DPS.
IOTHUB_DEVICE_DPS_DEVICE_ID avec la valeur my-pnp-device.
IOTHUB_DEVICE_DPS_DEVICE_KEY avec la clé primaire d’inscription.
IOTHUB_DEVICE_DPS_ENDPOINT avec la valeur global.azure-devices-provisioning.net.

Pour exécuter l'exemple d'application, accédez au dossier /device/iot-device-samples/pnp-device-sample/temperature-controller-device-sample et exécutez la commande suivante :

mvn exec:java -Dexec.mainClass="samples.com.microsoft.azure.sdk.iot.device.TemperatureController"

Utiliser l’Explorateur Azure IoT pour valider le code

Une fois l’exemple de client d’appareil démarré, utilisez l’outil Explorateur Azure IoT pour vérifier qu’il fonctionne.

Ouvrez l’explorateur Azure IoT.
Dans la page Hubs IoT, si vous n’avez pas encore ajouté de connexion à votre hub IoT, sélectionnez + Ajouter une connexion. Entrez la chaîne de connexion pour le hub IoT que vous avez créé précédemment et sélectionnez Enregistrer.
Dans la page Paramètres IoT Plug-and-Play, sélectionnez + Ajouter > Dossier local et sélectionnez le dossier models local dans lequel vous avez enregistré vos fichiers de modèle.
Dans la page Hubs IoT, cliquez sur le nom du hub que vous souhaitez utiliser. Vous voyez la liste des appareils enregistrés sur le hub IoT.
Cliquez sur l’ID d’appareil de l’appareil que vous avez créé précédemment.
Le menu de gauche affiche les différents types d’informations disponibles pour l’appareil.
Sélectionnez Composants IoT Plug-and-Play pour afficher les informations de modèle de votre appareil.
Vous pouvez afficher les différents composants de l’appareil, Le composant par défaut et tous les composants supplémentaires. Sélectionnez un composant à utiliser.
Sélectionnez la page Télémétrie, puis sélectionnez Démarrer pour afficher les données de télémétrie envoyées par l’appareil pour ce composant.
Sélectionnez la page Propriétés (lecture seule) pour afficher les propriétés en lecture seule signalées pour ce composant.
Sélectionnez la page Propriétés (accessibles en écriture) pour afficher les propriétés accessibles en écriture que vous pouvez mettre à jour pour ce composant.
Sélectionnez une propriété par son nom, entrez une nouvelle valeur, puis sélectionnez Mettre à jour la valeur souhaitée.
Pour afficher la nouvelle valeur, sélectionnez le bouton Actualiser.
Sélectionnez la page Commandes pour afficher toutes les commandes pour ce composant.
Sélectionnez la commande que vous souhaitez tester, le cas échéant. Sélectionnez Envoyer la commande pour appeler la commande sur l’appareil. Vous pouvez voir que votre appareil répond à la commande dans la fenêtre d’invite de commandes où l’exemple de code est en cours d’exécution.

Vérifier le code

Le code d’appareil utilise la classe DeviceClient standard pour se connecter à votre hub IoT. L’appareil envoie l’ID de modèle du modèle DTDL qu’il implémente dans la demande de connexion. Un appareil qui envoie un ID de modèle est un appareil IoT Plug-and-Play :

private static void initializeDeviceClient() throws URISyntaxException, IOException {
    ClientOptions options = new ClientOptions();
    options.setModelId(MODEL_ID);
    deviceClient = new DeviceClient(deviceConnectionString, protocol, options);

    deviceClient.registerConnectionStatusChangeCallback((status, statusChangeReason, throwable, callbackContext) -> {
        log.debug("Connection status change registered: status={}, reason={}", status, statusChangeReason);

        if (throwable != null) {
            log.debug("The connection status change was caused by the following Throwable: {}", throwable.getMessage());
            throwable.printStackTrace();
        }
    }, deviceClient);

    deviceClient.open();
}

L’ID de modèle est stocké dans le code, comme indiqué dans l’extrait de code suivant :

private static final String MODEL_ID = "dtmi:com:example:Thermostat;1";

Une fois que l’appareil se connecte à votre hub IoT, le code inscrit les gestionnaires de commandes.

deviceClient.subscribeToDeviceMethod(new MethodCallback(), null, new MethodIotHubEventCallback(), null);

Il existe des gestionnaires distincts pour les mises à jour des propriétés souhaitées sur les deux composants de thermostat :

deviceClient.startDeviceTwin(new TwinIotHubEventCallback(), null, new GenericPropertyUpdateCallback(), null);
Map<Property, Pair<TwinPropertyCallBack, Object>> desiredPropertyUpdateCallback = Stream.of(
        new AbstractMap.SimpleEntry<Property, Pair<TwinPropertyCallBack, Object>>(
                new Property(THERMOSTAT_1, null),
                new Pair<>(new TargetTemperatureUpdateCallback(), THERMOSTAT_1)),
        new AbstractMap.SimpleEntry<Property, Pair<TwinPropertyCallBack, Object>>(
                new Property(THERMOSTAT_2, null),
                new Pair<>(new TargetTemperatureUpdateCallback(), THERMOSTAT_2))
).collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));

deviceClient.subscribeToTwinDesiredProperties(desiredPropertyUpdateCallback);

L’exemple de code envoie des données de télémétrie depuis chaque composant de thermostat :

sendTemperatureReading(THERMOSTAT_1);
sendTemperatureReading(THERMOSTAT_2);

La méthode sendTemperatureReading utilise la classe PnpHhelper pour créer des messages pour chaque composant :

Message message = PnpHelper.createIotHubMessageUtf8(telemetryName, currentTemperature, componentName);

La classe PnpHelper contient d’autres exemples de méthodes que vous pouvez utiliser avec un modèle à plusieurs composants.

Utilisez l’outil Explorateur Azure IoT pour visualiser les données de télémétrie et les propriétés des deux composants de thermostat :

Appareil à plusieurs composants dans l’Explorateur Azure IoT

Vous pouvez également utiliser l'outil Explorateur Azure IoT pour appeler des commandes dans l'un ou l'autre des deux composants de thermostat, ou dans le composant par défaut.

Ce tutoriel vous montre comment créer un exemple d'application d'appareil IoT Plug-and-Play avec des composants, comment le connecter à votre hub IoT, et comment utiliser l'outil Explorateur Azure IoT pour voir les informations qu'il envoie au hub. L’exemple d’application est écrit pour Node.js et est inclus dans le kit Azure IoT Hub Device SDK pour Node.js. Un créateur de solutions peut utiliser l’outil Explorateur Azure IoT pour comprendre les fonctionnalités d’un appareil IoT Plug-and-Play sans avoir besoin d’examiner le code d’appareil.

Dans ce tutoriel, vous allez :

Téléchargez l’exemple de code.
Exécutez l’exemple d’application d’appareil et vérifiez qu’il se connecte à votre hub IoT.
Vérifiez le code source.

Prérequis

Avant de continuer, assurez-vous d’avoir configuré votre environnement, y compris votre hub IoT.

Pour suivre ce tutoriel, vous avez besoin de Node.js sur votre machine de développement. Vous pouvez télécharger la dernière version recommandée pour plusieurs plateformes à partir de nodejs.org.

Vous pouvez vérifier la version actuelle de Node.js sur votre machine de développement à l’aide de la commande suivante :

node --version

Téléchargement du code

Si vous avez terminé Tutoriel : Connecter un exemple d’application pour appareil IoT Plug-and-Play s’exécutant sur Windows à IoT Hub (Node), vous avez déjà cloné le référentiel.

Ouvrez une invite de commandes dans le répertoire de votre choix. Exécutez la commande suivante pour cloner le dépôt GitHub SDK Microsoft Azure IoT pour for Node.js à cet emplacement :

git clone https://github.com/Azure/azure-iot-sdk-node

Installer les bibliothèques nécessaires

Vous utilisez le kit de développement logiciel (SDK) de l’appareil pour créer l’exemple de code inclus. L’application que vous créez simule un appareil Plug-and-Play avec plusieurs composants qui se connecte à un hub IoT. L’application envoie les données de télémétrie et les propriétés et reçoit des commandes.

Dans une fenêtre de terminal locale, accédez au dossier de votre dépôt cloné, puis au dossier /azure-iot-sdk-node/device/samples/javascript. Exécutez ensuite la commande suivante pour installer les bibliothèques requises :

npm install

Cette commande installe les fichiers npm appropriés nécessaires pour exécuter les exemples dans le dossier.

Vérifier le code

Accédez au dossier azure-iot-sdk-node/device/samples/javascript.

Le dossier azure-iot-sdk-node/device/samples/javascript contient l’exemple de code pour l’appareil contrôleur de température IoT Plug-and-Play.

Le code figurant dans le fichier pnp_temperature_controller.js implémente un appareil contrôleur de température IoT Plug-and-Play. Le modèle implémenté par cet exemple utilise plusieurs composants. Le fichier de modèle DTDL (Digital Twins Definition Language) V2 pour l’appareil de contrôle de température définit la télémétrie, les propriétés et les commandes implémentées par l’appareil.

Ouvrez le fichier pnp_temperature_controller.js dans un éditeur de code de votre choix. L’exemple de code montre comment :

Définissez le modelId DTMI pour l’appareil que vous implémentez. Ce DTMI est défini par l’utilisateur et doit correspondre au DTMI du modèle DTDL du contrôleur de température.
Implémenter les composants définis dans le modèle DTDL du contrôleur de température. Les composants d’un contrôleur de température réel doivent implémenter ces deux interfaces. Ces deux interfaces sont déjà publiées dans un dépôt central. Dans cet exemple, les deux interfaces sont :
- Thermostat
- Informations sur l’appareil développées par Azure
Définit les noms des composants. Cet exemple a deux thermostats et un composant d’informations sur l’appareil.
Définissez les noms des commandes pour les commandes auxquelles l’appareil répond.
Définit la constante serialNumber. serialNumber est fixe pour un appareil donné.
Définit les gestionnaires de commandes.
Définit les fonctions pour envoyer des réponses aux commandes.
Définit des fonctions helper pour journaliser les demandes de commandes.
Définit une fonction helper pour créer les propriétés.
Définit un écouteur pour les mises à jour des propriétés.
Définit une fonction pour envoyer de la télémétrie depuis cet appareil. Les thermostats et le composant par défaut envoient de la télémétrie. Cette fonction reçoit le nom du composant comme paramètre.
Définissez une fonction main qui :
- Utilise le SDK d’appareil pour créer un client d’appareil et se connecter à votre hub IoT. L’appareil fournit le modelId pour que IoT Hub puisse identifier l’appareil en tant qu’appareil IoT Plug-and-Play.
- Commence à écouter les demandes de commande en utilisant la fonction onDeviceMethod. La fonction configure un écouteur pour les demandes de commande provenant du service :
  - Le DTDL de l’appareil définit les commandes reboot et getMaxMinReport.
  - La fonction commandHandler définit la façon dont l’appareil répond à une commande.
- Commence à envoyer de la télémétrie en utilisant setInterval et sendTelemetry.
- Utilise la fonction helperCreateReportedPropertiesPatch pour créer les propriétés et les updateComponentReportedProperties pour mettre à jour les propriétés.
- Utilise desiredPropertyPatchListener pour être à l’écoute des mises à jour de propriétés.
- Désactive tous les écouteurs et toutes les tâches, puis quitte la boucle quand vous appuyez sur Q ou q.

IOTHUB_DEVICE_SECURITY_TYPE avec la valeur DPS
IOTHUB_DEVICE_DPS_ID_SCOPE avec l’étendue ID DPS.
IOTHUB_DEVICE_DPS_DEVICE_ID avec la valeur my-pnp-device.
IOTHUB_DEVICE_DPS_DEVICE_KEY avec la clé primaire d’inscription.
IOTHUB_DEVICE_DPS_ENDPOINT avec la valeur global.azure-devices-provisioning.net.

Pour en savoir plus sur l’exemple de configuration, consultez l’exemple de fichier Lisez-moi.

Maintenant que vous avez vu le code, utilisez la commande suivante pour exécuter l’exemple :

node pnp_temperature_controller.js

Vous voyez la sortie suivante, qui indique que l’appareil a commencé à envoyer des données de télémétrie au hub et est maintenant prêt à recevoir des commandes et des mises à jour de propriétés.

Messages de confirmation de l’appareil

Laissez l’exemple s’exécuter pendant que vous effectuez les étapes suivantes.

Utiliser l’Explorateur Azure IoT pour valider le code

Une fois l’exemple de client d’appareil démarré, utilisez l’outil Explorateur Azure IoT pour vérifier qu’il fonctionne.

Ouvrez l’explorateur Azure IoT.
Dans la page Hubs IoT, si vous n’avez pas encore ajouté de connexion à votre hub IoT, sélectionnez + Ajouter une connexion. Entrez la chaîne de connexion pour le hub IoT que vous avez créé précédemment et sélectionnez Enregistrer.
Dans la page Paramètres IoT Plug-and-Play, sélectionnez + Ajouter > Dossier local et sélectionnez le dossier models local dans lequel vous avez enregistré vos fichiers de modèle.
Dans la page Hubs IoT, cliquez sur le nom du hub que vous souhaitez utiliser. Vous voyez la liste des appareils enregistrés sur le hub IoT.
Cliquez sur l’ID d’appareil de l’appareil que vous avez créé précédemment.
Le menu de gauche affiche les différents types d’informations disponibles pour l’appareil.
Sélectionnez Composants IoT Plug-and-Play pour afficher les informations de modèle de votre appareil.
Vous pouvez afficher les différents composants de l’appareil, Le composant par défaut et tous les composants supplémentaires. Sélectionnez un composant à utiliser.
Sélectionnez la page Télémétrie, puis sélectionnez Démarrer pour afficher les données de télémétrie envoyées par l’appareil pour ce composant.
Sélectionnez la page Propriétés (lecture seule) pour afficher les propriétés en lecture seule signalées pour ce composant.
Sélectionnez la page Propriétés (accessibles en écriture) pour afficher les propriétés accessibles en écriture que vous pouvez mettre à jour pour ce composant.
Sélectionnez une propriété par son nom, entrez une nouvelle valeur, puis sélectionnez Mettre à jour la valeur souhaitée.
Pour afficher la nouvelle valeur, sélectionnez le bouton Actualiser.
Sélectionnez la page Commandes pour afficher toutes les commandes pour ce composant.
Sélectionnez la commande que vous souhaitez tester, le cas échéant. Sélectionnez Envoyer la commande pour appeler la commande sur l’appareil. Vous pouvez voir que votre appareil répond à la commande dans la fenêtre d’invite de commandes où l’exemple de code est en cours d’exécution.

Ce tutoriel vous montre comment créer un exemple d’application d’appareil IoT Plug-and-Play avec des composants, comment le connecter à votre hub IoT, et comment utiliser l’outil Explorateur Azure IoT pour voir les informations qu’il envoie au hub. L’exemple d’application est écrit en Python et inclus dans le SDK Azure IoT Device pour Python. Un créateur de solutions peut utiliser l’outil Explorateur Azure IoT pour comprendre les fonctionnalités d’un appareil IoT Plug-and-Play sans avoir besoin d’examiner le code d’appareil.

Dans ce tutoriel, vous allez :

Téléchargez l’exemple de code.
Exécutez l’exemple d’application d’appareil et vérifiez qu’il se connecte à votre hub IoT.
Vérifiez le code source.

Prérequis

Avant de continuer, assurez-vous d’avoir configuré votre environnement, y compris votre hub IoT.

Pour suivre ce tutoriel, vous avez besoin de Python installé sur votre machine de développement. Consultez le Kit de développement logiciel (SDK) Python Azure IoT pour connaître les exigences actuelles en matière de version de Python. Vous pouvez vérifier votre version de Python à l’aide de la commande suivante :

python --version

Vous pouvez télécharger la dernière version recommandée pour plusieurs plateformes à partir de python.org.

Téléchargement du code

Le package azure-iot-device est publié en tant que PIP.

Dans votre environnement Python local, installez le package comme suit :

pip install azure-iot-device

Si vous avez terminé Tutoriel : Connecter un exemple d’application pour appareil IoT Plug-and-Play s’exécutant sur Windows à IoT Hub (Python), vous avez déjà cloné le référentiel.

Clonez le référentiel IoT du Kit de développement logiciel (SDK) Python :

git clone --branch v2 https://github.com/Azure/azure-iot-sdk-python

Vérifier le code

Le dossier azure-iot-sdk-python/samples/pnp contient l’exemple de code pour l’appareil IoT Plug-and-Play. Les fichiers de l’exemple de contrôleur de température sont les suivants :

temp_controller_with_thermostats.py
pnp_helper.py

Le contrôleur de température a plusieurs composants et un composant par défaut, en fonction du modèle DTDL du contrôleur de température.

Ouvrez le fichier temp_controller_with_thermostats.py dans l’éditeur de votre choix. Le code dans ce fichier effectue les opérations suivantes :

Importe pnp_helper.py pour accéder aux méthodes d’assistance.
Définit deux identificateurs de modèle de jumeau numérique (DTMI) qui représentent de manière unique deux interfaces différentes, définies dans le modèle DTDL. Les composants d’un contrôleur de température réel doivent implémenter ces deux interfaces. Ces deux interfaces sont déjà publiées dans un dépôt central. Les DTMI doivent être connus de l’utilisateur et varient en fonction du scénario d’implémentation de l’appareil. Pour l’exemple actuel, ces deux interfaces représentent :
- un thermostat ;
- des informations sur l’appareil développées par Azure.
Définit le DTMI model_id pour l’appareil en cours d’implémentation. Le DTMI est défini par l’utilisateur et doit correspondre au DTMI spécifié dans le fichier du modèle DTDL.
Définit les noms donnés aux composants dans le fichier DTDL. Il existe deux thermostats dans le DTDL et un composant d’informations sur l’appareil. Une constante nommée serial_number est également définie dans le composant par défaut. Un serial_number ne peut pas changer pour un appareil.
Définit des implémentations de gestionnaire de commandes. Ces gestionnaires définissent ce que fait le dispositif lorsqu’il reçoit des demandes de commande.
Définit des fonctions pour créer une réponse de commande. Ces fonctions définissent la façon dont l’appareil répond avec des demandes de commande. Vous pouvez créer des fonctions de réponse de commande si une commande doit renvoyer une réponse personnalisée au hub IoT. Si une fonction de réponse pour une commande n’est pas fournie, une réponse générique est envoyée. Dans cet exemple, seule la commande getMaxMinReport a une réponse personnalisée.
Définit une fonction pour envoyer la télémétrie de cet appareil. Les thermostats et le composant par défaut envoient de la télémétrie. Cette fonction a un paramètre de nom de composant facultatif lui permettant d’identifier le composant qui a envoyé la télémétrie.
Définit un écouteur pour les demandes de commande.
Définit un écouteur pour les mises à jour de propriétés souhaitées.
A une fonction main qui effectue les opérations suivantes :
- Utilise le Kit de développement logiciel (SDK) d’appareil pour créer un client d’appareil et se connecter à votre hub IoT. L’appareil envoie le model_id pour permettre au hub IoT d’identifier l’appareil en tant qu’appareil IoT Plug-and-Play.
- Utilise la fonction create_reported_properties dans le fichier d’assistance pour créer les propriétés. Transmettez à cette fonction le nom du composant et les propriétés en tant que paires clé-valeur.
- Met à jour les propriétés lisibles de ses composants en appelant patch_twin_reported_properties.
- Commence à écouter les demandes de commande à l’aide de la fonction execute_command_listener. La fonction configure un écouteur pour les demandes de commande provenant du service. Quand vous configurez l’écouteur, vous fournissez un method_name, un user_command_handler et un create_user_response_handler facultatif en tant que paramètres.
  - Le method_name définit la demande de commande. Dans cet exemple, le modèle définit les commandes reboot, et getMaxMinReport.
  - La fonction user_command_handler définit ce que l’appareil doit faire quand il reçoit une commande.
  - La fonction create_user_response_handler crée une réponse à envoyer à votre hub IoT quand une commande s’exécute correctement. Vous pouvez afficher cette réponse dans le portail. Si cette fonction n’est pas fournie, une réponse générique est envoyée au service.
- Utilise execute_property_listener pour écouter les mises à jour de propriétés.
- Commence à envoyer la télémétrie à l’aide de send_telemetry. L’exemple de code utilise une boucle pour appeler trois fonctions d’envoi de télémétrie. Chacune d’elles est appelée toutes les huit secondes.
- Désactive l’ensemble des écouteurs et des tâches, puis quitte la boucle quand vous appuyez sur Q ou q.

IOTHUB_DEVICE_SECURITY_TYPE avec la valeur DPS
IOTHUB_DEVICE_DPS_ID_SCOPE avec l’étendue ID DPS.
IOTHUB_DEVICE_DPS_DEVICE_ID avec la valeur my-pnp-device.
IOTHUB_DEVICE_DPS_DEVICE_KEY avec la clé primaire d’inscription.
IOTHUB_DEVICE_DPS_ENDPOINT avec la valeur global.azure-devices-provisioning.net.

Pour en savoir plus sur l’exemple de configuration, consultez l’exemple de fichier Lisez-moi.

Utilisez la commande suivante pour exécuter cet exemple :

python temp_controller_with_thermostats.py

L’exemple d’appareil envoie à votre IoT Hub des messages de télémétrie à intervalles de quelques secondes.

Vous voyez la sortie suivante indiquant que l’appareil a commencé à envoyer des données de télémétrie au hub et est prêt à recevoir des commandes et des mises à jour de propriétés.

Messages de confirmation de l’appareil

Laissez l’exemple s’exécuter pendant que vous effectuez les étapes suivantes.

Utiliser l’Explorateur Azure IoT pour valider le code

Une fois l’exemple de client d’appareil démarré, utilisez l’outil Explorateur Azure IoT pour vérifier qu’il fonctionne.

Ouvrez l’explorateur Azure IoT.
Dans la page Hubs IoT, si vous n’avez pas encore ajouté de connexion à votre hub IoT, sélectionnez + Ajouter une connexion. Entrez la chaîne de connexion pour le hub IoT que vous avez créé précédemment et sélectionnez Enregistrer.
Dans la page Paramètres IoT Plug-and-Play, sélectionnez + Ajouter > Dossier local et sélectionnez le dossier models local dans lequel vous avez enregistré vos fichiers de modèle.
Dans la page Hubs IoT, cliquez sur le nom du hub que vous souhaitez utiliser. Vous voyez la liste des appareils enregistrés sur le hub IoT.
Cliquez sur l’ID d’appareil de l’appareil que vous avez créé précédemment.
Le menu de gauche affiche les différents types d’informations disponibles pour l’appareil.
Sélectionnez Composants IoT Plug-and-Play pour afficher les informations de modèle de votre appareil.
Vous pouvez afficher les différents composants de l’appareil, Le composant par défaut et tous les composants supplémentaires. Sélectionnez un composant à utiliser.
Sélectionnez la page Télémétrie, puis sélectionnez Démarrer pour afficher les données de télémétrie envoyées par l’appareil pour ce composant.
Sélectionnez la page Propriétés (lecture seule) pour afficher les propriétés en lecture seule signalées pour ce composant.
Sélectionnez la page Propriétés (accessibles en écriture) pour afficher les propriétés accessibles en écriture que vous pouvez mettre à jour pour ce composant.
Sélectionnez une propriété par son nom, entrez une nouvelle valeur, puis sélectionnez Mettre à jour la valeur souhaitée.
Pour afficher la nouvelle valeur, sélectionnez le bouton Actualiser.
Sélectionnez la page Commandes pour afficher toutes les commandes pour ce composant.
Sélectionnez la commande que vous souhaitez tester, le cas échéant. Sélectionnez Envoyer la commande pour appeler la commande sur l’appareil. Vous pouvez voir que votre appareil répond à la commande dans la fenêtre d’invite de commandes où l’exemple de code est en cours d’exécution.

Nettoyer les ressources

Si vous prévoyez de continuer avec d’autres articles développeurs d’appareils, vous pouvez conserver et réutiliser les ressources que vous avez utilisées dans cet article. Sinon, vous pouvez supprimer les ressources que vous avez créées dans cet article afin d’éviter des frais supplémentaires.

Vous pouvez supprimer simultanément le hub et l’appareil inscrit en supprimant la totalité du groupe de ressources avec la commande Azure CLI suivante. N’utilisez pas cette commande si ces ressources partagent un groupe de ressources avec d’autres ressources que vous souhaitez conserver.

az group delete --name <YourResourceGroupName>

Pour supprimer seulement le hub IoT, exécutez la commande suivante en utilisant Azure CLI :

az iot hub delete --name <YourIoTHubName>

Pour supprimer seulement l’appareil que vous avez inscrit auprès de votre hub IoT, exécutez la commande suivante en utilisant Azure CLI :

az iot hub device-identity delete --hub-name <YourIoTHubName> --device-id <YourDeviceID>

Vous pouvez aussi supprimer les exemples de fichiers clonés de votre ordinateur de développement.

Étapes suivantes

Dans ce tutoriel, vous avez découvert comment connecter un appareil IoT Plug-and-Play avec des composants à un hub IoT. Pour découvrir plus d’informations sur les modèles d’appareils IoT Plug-and-Play, consultez :

Guide du développeur pour la modélisation d'IoT Plug-and-Play

Tutoriel : Connecter une application d’appareil multicomposant IoT Plug-and-Play s’exécutant sur Linux ou Windows à IoT Hub

Prérequis

Linux

Windows

Téléchargement du code

Générer et exécuter le code

Utiliser Visual Studio

Utiliser cmake sur la ligne de commande

Utiliser l’Explorateur Azure IoT pour valider le code

Vérifier le code

Fonctions d’assistance IoT Plug-and-Play

Flux de code

Prérequis

Clonez le référentiel SDK avec l’exemple de code

Générer le code

Exécuter l’exemple d’appareil

Utiliser l’Explorateur Azure IoT pour valider le code

Vérifier le code

Prérequis

Téléchargement du code

Générer le code

Exécuter l’exemple d’appareil

Utiliser l’Explorateur Azure IoT pour valider le code

Vérifier le code

Prérequis

Téléchargement du code

Installer les bibliothèques nécessaires

Vérifier le code

Utiliser l’Explorateur Azure IoT pour valider le code

Prérequis

Téléchargement du code

Vérifier le code

Utiliser l’Explorateur Azure IoT pour valider le code

Nettoyer les ressources

Étapes suivantes

Ressources supplémentaires

Utiliser `cmake` sur la ligne de commande