IoT Platform:Exemple d'utilisation

Contexte

• Pour plus d'informations sur le modèle TSL, consultez Instructions d'utilisation.

• Le modèle TSL repose sur des connexions MQTT. Pour des exemples de code associés, reportez-vous à Connexion MQTT.

Étape 1 : Initialisation

1. Incluez le fichier d'en-tête.

   ……
   ……
   #include "aiot_dm_api.h"

2. Configurez les dépendances sous-jacentes et la sortie des journaux.

       aiot_sysdep_set_portfile(&g_aiot_sysdep_portfile);
       aiot_state_set_logcb(demo_state_logcb);

3. Appelez aiot_dm_init pour créer et initialiser une instance client data-model.

       dm_handle = aiot_dm_init();
       if (dm_handle == NULL) {
           printf("aiot_dm_init failed");
           return -1;}

Étape 2 : Configuration des fonctionnalités

Appelez aiot_dm_setopt pour configurer les fonctionnalités suivantes.

• Associer un handle de connexion MQTT

• Implémenter une fonction de rappel pour traiter les messages TSL

• Configurer l'envoi de messages de réponse par IoT Platform

1. Associez un handle de connexion MQTT.

   Important

   Avant de configurer les paramètres des fonctionnalités TSL, assurez-vous d'avoir configuré les paramètres requis, tels que les informations d'authentification de l'appareil. Pour plus d'informations, consultez Configurer les paramètres de connexion MQTT.

   • Exemple de code :

         aiot_dm_setopt(dm_handle, AIOT_DMOPT_MQTT_HANDLE, mqtt_handle);

   • Paramètres associés :

     Paramètre	Valeur d'exemple	Description
     AIOT_DMOPT_MQTT_HANDLE	mqtt_handle	Associe le handle de connexion MQTT. Les requêtes TSL utilisent cette connexion.

2. Implémentez une fonction de rappel pour traiter les messages TSL.

   1. Définissez la fonction de rappel pour les messages TSL.

      static void demo_dm_recv_handler(void *dm_handle, const aiot_dm_recv_t *recv, void *userdata)
      {
          printf("demo_dm_recv_handler, type = %d\r\n", recv->type);
          switch (recv->type) {
              /* Response to commands for property reporting, event reporting, getting desired property values, or deleting desired property values */
              case AIOT_DMRECV_GENERIC_REPLY: {
                  demo_dm_recv_generic_reply(dm_handle, recv, userdata);
              }
              break;
              /* Set properties */
              case AIOT_DMRECV_PROPERTY_SET: {
                  demo_dm_recv_property_set(dm_handle, recv, userdata);
              }
              break;
              /* Asynchronously invoke a service */
              case AIOT_DMRECV_ASYNC_SERVICE_INVOKE: {
                  demo_dm_recv_async_service_invoke(dm_handle, recv, userdata);
              }
              break;
              /* Synchronously invoke a service */
              case AIOT_DMRECV_SYNC_SERVICE_INVOKE: {
                  demo_dm_recv_sync_service_invoke(dm_handle, recv, userdata);
              }
              break;
              /* Downstream binary data */
              case AIOT_DMRECV_RAW_DATA: {
                  demo_dm_recv_raw_data(dm_handle, recv, userdata);
              }
              break;
              /* Synchronously invoke a service in binary format. This message contains an rrpc_id in addition to the binary data. */
              case AIOT_DMRECV_RAW_SYNC_SERVICE_INVOKE: {
                  demo_dm_recv_raw_sync_service_invoke(dm_handle, recv, userdata);
              }
              break;
              /* Response from IoT Platform to upstream binary data */
              case AIOT_DMRECV_RAW_DATA_REPLY: {
                  demo_dm_recv_raw_data_reply(dm_handle, recv, userdata);
              }
              break;
              default:
                  break;
          }
      }

   2. Enregistrez la fonction de rappel pour les messages TSL.

      • Exemple de code :

            aiot_dm_setopt(dm_handle, AIOT_DMOPT_RECV_HANDLER, (void *)demo_dm_recv_handler);                   

      • Paramètres associés :

        Paramètre	Valeur d'exemple	Description
        AIOT_DMOPT_RECV_HANDLER	demo_dm_recv_handler	Le SDK appelle cette fonction de rappel lors de la réception d'un message TSL.

3. Configurez l'envoi de messages de réponse par IoT Platform.

   Ce paramètre détermine si IoT Platform envoie un message de réponse après réception d'un message de l'appareil.

   • Exemple de code :

         uint8_t post_reply = 1;
         ……
         ……
        aiot_dm_setopt(dm_handle, AIOT_DMOPT_POST_REPLY, (void *)&post_reply);

   • Paramètres associés :

     Paramètre	Exemple	Description
     AIOT_DMOPT_POST_REPLY	1	Valeurs valides : 1 : Envoyer un message de réponse. 0 : Ne pas envoyer de message de réponse.

   • Si vous définissez le paramètre AIOT_DMOPT_POST_REPLY sur 1, vous devez implémenter la logique de traitement des messages de réponse.

     Adaptez cette logique à vos besoins métier. L'exemple de code se contente d'afficher les journaux.

     • ICA Standard Data Format (Alink JSON) : Lors de la création d'un produit, réglez le paramètre Data Format sur ICA Standard Data Format (Alink JSON).

       Le message de réponse est renvoyé dans la structure recv->data.generic_reply et utilise le format de données Alink. Pour plus d'informations, consultez Propriétés, événements et services des appareils.

       static void demo_dm_recv_generic_reply(void *dm_handle, const aiot_dm_recv_t *recv, void *userdata){
           printf("demo_dm_recv_generic_reply msg_id = %d, code = %d, data = %.*s, message = %.*s\r\n",
               recv->data.generic_reply.msg_id,
               recv->data.generic_reply.code,
               recv->data.generic_reply.data_len,
               recv->data.generic_reply.data,
               recv->data.generic_reply.message_len,
               recv->data.generic_reply.message);
       }

     • Passthrough/Custom format : Dans la page des paramètres du produit de la console IoT Platform, réglez le paramètre Data Format sur Passthrough/Custom.

       Le message de réponse est renvoyé dans la structure recv->data.raw_data. Avant d'envoyer ou de recevoir des messages, vous devez charger un script d'analyse dans IoT Platform. Pour plus d'informations, consultez Analyse des messages.

       static void demo_dm_recv_raw_data_reply(void *dm_handle, const aiot_dm_recv_t *recv, void *userdata)
       {
           printf("demo_dm_recv_async_service_invoke receive reply for up_raw msg, data len = %d\r\n", recv->data.raw_data.data_len);
       }

Étape 3 : Signalement des propriétés

Une fois la connexion MQTT établie par l'appareil, appelez aiot_dm_send pour envoyer des messages de propriété à IoT Platform. Stockez le message de propriété dans la structure aiot_dm_msg_t et transmettez-le à aiot_dm_send.

ICA standard data format (Alink JSON)

1. Ajoutez un modèle TSL.

   • Avant de signaler des propriétés, connectez-vous à la console IoT Platform. Dans la page Product Details, accédez à l'onglet Feature Definition et ajoutez des propriétés au modèle TSL pour le module par défaut ou un module personnalisé, tel que demo_extra_block. Pour plus d'informations, consultez Ajouter manuellement un modèle TSL.

     Le tableau suivant liste les propriétés du modèle TSL correspondant à l'exemple de code.

     Nom du module TSL	Nom de la fonctionnalité	Identifiant	Type	Définition des données	Type de lecture/écriture
     module par défaut	Interrupteur veilleuse 1	LightSwitch	bool	0 : activé 1 : désactivé	Lecture/Écriture
     	Puissance	Power	text	Longueur des données : 10 240	Lecture/Écriture
     	Courant de fonctionnement	WF	int32	Plage de valeurs : 0–10 Pas : 1 Unité : A	Lecture/Écriture
     demo_extra_block	Interrupteur veilleuse 2	NightLightSwitch	bool	0 : activé 1 : désactivé	Lecture/Écriture

   • Vous pouvez également importer le fichier TSL pour cet exemple. Pour obtenir des instructions, consultez Ajouter des modèles TSL par lots.

2. Définissez le contenu du message de propriété.

   • Exemple de code :

     • Module par défaut :

       /* Content for reporting a single property */
               demo_send_property_post(dm_handle, "{\"LightSwitch\": 0}");
       /* Content for reporting properties in a batch */
               demo_send_property_batch_post(dm_handle, "{\"properties\":{\"Power\": [ {\"value\":\"on\",\"time\":1612684518000}],\"WF\": [{\"value\": 3,\"time\":1612684518000}]}}");

     • Module personnalisé :

               demo_send_property_post(dm_handle, "{\"demo_extra_block:NightLightSwitch\": 1}");

   • Description de l'exemple de message :

     • Les messages de modèle TSL signalés sont au format JSON. Le tableau suivant présente des exemples de messages et leurs formats de données Alink correspondants. Pour plus d'informations, consultez Signaler les propriétés de l'appareil.

       Remarque

       Il vous suffit de fournir les données de l'appareil, qui correspondent à la valeur du paramètre params dans le format de données Alink. Le Link SDK gère l'encapsulation des messages signalés.

       Type de message	Exemple de message	Format Alink
       Propriété unique	{\"LightSwitch\": 0}	{ "id": "123", "version": "1.0", "sys":{ "ack":0 }, "params": { "LightSwitch": 0 }, "method": "thing.event.property.post" }
       Propriétés par lots	{\"properties\":{\"Power\": [ {\"value\":\"on\",\"time\":1612684518000}],\"WF\": [{\"value\": 3,\"time\":1612684518000}]}}	{ "id": 123, "version": "1.0", "sys":{ "ack":0 }, "method": "thing.event.property.batch.post", "params": { "properties": { "Power": [{ "value": "on", "time": 1612684518000 }, ], "WF": [{ "value": 3, "time": 1612684518000 }, ] }, }

     • Après le signalement des propriétés par lots, IoT Platform envoie un message de réponse. Pour vérifier la bonne réception du message par IoT Platform, abonnez-vous au topic /sys/a18wP******/LightSwitch/thing/event/property/batch/post_reply.

       Exemple de code :

           aiot_mqtt_sub(mqtt_handle, "/sys/a18wP******/LightSwitch/thing/event/property/batch/post_reply", NULL, 1,
                         NULL);

       Où :

       • a18wP****** correspond au ProductKey de l'appareil.

       • LightSwitch correspond au DeviceName de l'appareil.

3. Définissez les fonctions de signalement des propriétés.

   /* Report a single property */
   int32_t demo_send_property_post(void *dm_handle, char *params)
   {
       aiot_dm_msg_t msg;
       memset(&msg, 0, sizeof(aiot_dm_msg_t));
       msg.type = AIOT_DMMSG_PROPERTY_POST;
       msg.data.property_post.params = params;
       return aiot_dm_send(dm_handle, &msg);
   }
   /* Report properties in a batch */
   int32_t demo_send_property_batch_post(void *dm_handle, char *params)
   {
       aiot_dm_msg_t msg;
       memset(&msg, 0, sizeof(aiot_dm_msg_t));
       msg.type = AIOT_DMMSG_PROPERTY_BATCH_POST;
       msg.data.property_post.params = params;
       return aiot_dm_send(dm_handle, &msg);
   }

Custom data format

1. Chargez un script d'analyse des données du modèle TSL dans IoT Platform.

   Pour plus d'informations, consultez Messages dans un format de données personnalisé.

2. Rédigez le code de l'appareil pour signaler des messages binaires.

   Exemple de code :

       {
           aiot_dm_msg_t msg;
           uint8_t raw_data[] = {0x01, 0x02};
           memset(&msg, 0, sizeof(aiot_dm_msg_t));
           msg.type = AIOT_DMMSG_RAW_DATA;
           msg.data.raw_data.data = raw_data;
           msg.data.raw_data.data_len = sizeof(raw_data);
           aiot_dm_send(dm_handle, &msg);
       }

Étape 4 : Définition des propriétés

Appelez l'API cloud d'IoT Platform SetDeviceProperty ou SetDevicesProperty pour envoyer une commande de définition de propriété à un appareil. L'appareil appelle aiot_mqtt_recv pour recevoir la commande et la traite via la fonction de rappel demo_dm_recv_handler.

Utilisez les informations suivantes pour rédiger la logique de traitement de la fonction de rappel :

• Remarques :

  • Le message reçu est transmis en tant que paramètre d'entrée de type aiot_dm_recv_handler_t et stocké à l'emplacement spécifié à l'aide de la structure aiot_dm_recv_t.

  • Le champ du message reçu contenant le contenu de la commande de définition de propriété dépend du format de données de l'appareil, comme indiqué dans le tableau suivant.

    Format de données de l'appareil	Champ du message	Description
    ICA standard data format (Alink JSON)	recv->data.property_set.params	Correspond à la valeur du champ params dans le format de données Alink. Pour plus d'informations, consultez Messages de propriété.
    passthrough/custom format	recv->data.raw_data	L'appareil doit analyser les données. Pour plus d'informations, consultez Messages au format passthrough/personnalisé.

• Logique de traitement recommandée :

  1. Mettez à jour les propriétés de l'appareil.

  2. Signalez les propriétés mises à jour.

• Logique de traitement dans l'exemple de code :

  L'exemple de code se contente d'afficher le message reçu. Pour voir une démonstration du signalement des propriétés définies, décommentez le bloc de code sous le commentaire TODO en supprimant les symboles /* et */.

  • ICA standard data format (Alink JSON)

    static void demo_dm_recv_property_set(void *dm_handle, const aiot_dm_recv_t *recv, void *userdata)
    {
        printf("demo_dm_recv_property_set msg_id = %ld, params = %.*s\r\n",
                (unsigned long)recv->data.property_set.msg_id,
                recv->data.property_set.params_len,
                recv->data.property_set.params);
        /* TODO: The following code demonstrates how to respond to a property-setting command from IoT Platform. Uncomment it to see how it works. */
        /*
        {
            aiot_dm_msg_t msg;
            memset(&msg, 0, sizeof(aiot_dm_msg_t));
            msg.type = AIOT_DMMSG_PROPERTY_SET_REPLY;
            msg.data.property_set_reply.msg_id = recv->data.property_set.msg_id;
            msg.data.property_set_reply.code = 200;
            msg.data.property_set_reply.data = "{}";
            int32_t res = aiot_dm_send(dm_handle, &msg);
            if (res < 0) {
                printf("aiot_dm_send failed\r\n");
            }
        }
        */
    }

  • passthrough/custom format

    static void demo_dm_recv_raw_data(void *dm_handle, const aiot_dm_recv_t *recv, void *userdata)
    {
        printf("demo_dm_recv_raw_data raw data len = %d\r\n", recv->data.raw_data.data_len);
        /* TODO: The following code demonstrates how to send data in binary format. To use this feature, you must deploy the corresponding passthrough script in IoT Platform. */
        /*
        {
            aiot_dm_msg_t msg;
            uint8_t raw_data[] = {0x01, 0x02};
            memset(&msg, 0, sizeof(aiot_dm_msg_t));
            msg.type = AIOT_DMMSG_RAW_DATA;
            msg.data.raw_data.data = raw_data;
            msg.data.raw_data.data_len = sizeof(raw_data);
            aiot_dm_send(dm_handle, &msg);
        }
        */
    }

Étape 5 : Signalement des événements

Une fois la connexion MQTT établie par l'appareil, appelez aiot_dm_send pour envoyer des messages d'événement à IoT Platform. Le message est stocké dans une structure aiot_dm_msg_t et transmis en paramètre à aiot_dm_send.

Rédigez le code de signalement des événements selon l'un des formats de données d'appareil suivants.

• Si votre appareil utilise le custom format, l'interface de signalement des événements est identique à celle des propriétés. Pour plus d'informations, consultez la procédure de signalement des messages au format personnalisé à l'étape 3.

• Si votre appareil utilise le ICA standard data format (Alink JSON), suivez la procédure ci-dessous pour rédiger le code côté appareil.

1. Ajoutez un modèle TSL.

   • Avant de signaler un événement, connectez-vous à la console IoT Platform. Dans la page Product details, accédez à l'onglet Feature definition et ajoutez un événement pour le produit. Pour plus d'informations, consultez Ajouter manuellement un modèle TSL.

     Le tableau suivant décrit l'événement du modèle TSL utilisé dans l'exemple de code.

     Nom de la fonctionnalité	Identifiant	Type	Paramètre de sortie
     Erreur	Error	Panne	Nom du paramètre : Code d'erreur Identifiant du paramètre : ErrorCode Type de données : enum Éléments d'énumération : 0 : Panne matérielle de l'appareil 1 : Panne logicielle de l'appareil 2 : Erreur inconnue

   • Vous pouvez également importer le fichier TSL pour cet exemple. Pour obtenir des instructions, consultez Ajouter des modèles TSL par lots.

2. Définissez le contenu du message d'événement.

   • Exemple de code :

             demo_send_event_post(dm_handle, "Error", "{\"ErrorCode\": 0}");

   • Description de l'exemple de message :

     Les appareils signalent les messages de modèle TSL au format JSON. Le tableau suivant présente un exemple de message et son format de données Alink correspondant. Pour plus d'informations, consultez Signaler les événements de l'appareil.

     Remarque

     Il vous suffit de fournir les données de l'appareil, qui correspondent à la valeur du paramètre params dans le format de données Alink. Le Link SDK gère l'encapsulation des messages signalés.

     Exemple de charge utile	Format Alink
     {\"ErrorCode\": 0}	{ "id": "123", "version": "1.0", "params": { "ErrorCode": 0 }, "method": "thing.event.alarm.post" }

3. Définissez une fonction pour signaler les messages d'événement.

   
   int32_t demo_send_event_post(void *dm_handle, char *event_id, char *params)
   {
       aiot_dm_msg_t msg;
       memset(&msg, 0, sizeof(aiot_dm_msg_t));
       msg.type = AIOT_DMMSG_EVENT_POST;
       msg.data.event_post.event_id = event_id;
       msg.data.event_post.params = params;
       return aiot_dm_send(dm_handle, &msg);
   }

Étape 6 : Invocation de service

Vous pouvez appeler les API cloud d'IoT Platform, InvokeThingService ou InvokeThingsService, pour envoyer une commande d'invocation de service à un appareil. L'appareil appelle aiot_mqtt_recv pour recevoir la commande et exécute l'action correspondante selon les paramètres de la fonction de rappel demo_dm_recv_handler.

Utilisez les informations suivantes pour rédiger la logique de traitement de la fonction de rappel :

• Remarques d'utilisation :

  • Le message reçu est transmis en tant que paramètre d'entrée de type aiot_dm_recv_handler_t et stocké à l'emplacement spécifié à l'aide de la structure aiot_dm_recv_t.

  • Le contenu de la commande d'invocation de service varie selon le format de données de l'appareil. Le tableau suivant liste les champs où le contenu de la commande est stocké.

    Format de données de l'appareil	Champ synchrone	Champ asynchrone	Description
    ICA standard data format (Alink JSON)	recv->data.sync_service_invoke	recv->data.async_service_invoke	Les données de ce champ ont le même format que la valeur du paramètre params dans les données Alink. Pour plus d'informations, consultez Messages de service.
    passthrough/custom format	recv->data.raw_data	recv->data.raw_service_invoke	Vous devez charger un script d'analyse pour interpréter le contenu de la commande. Pour plus d'informations, consultez Messages au format passthrough/personnalisé.

  • Si vous utilisez une fonction distincte pour gérer la réponse au lieu de l'envoyer depuis la fonction de rappel, assurez-vous que les valeurs des paramètres suivants dans le message de réponse correspondent à celles de la requête d'IoT Platform.

    • Appel synchrone : rrpc_id et msg_id

    • Appel asynchrone : msg_id

  • Lors de l'envoi d'une réponse de service à IoT Platform, tenez compte du délai d'expiration :

    • Appel synchrone : Après la réception d'un message de service synchrone, vous devez envoyer une réponse dans les 8 secondes. Sinon, IoT Platform considère l'invocation comme ayant échoué, même si l'appareil a bien reçu le message.

    • Appel asynchrone : Vous pouvez définir une logique de délai d'expiration personnalisée pour les appels asynchrones selon vos besoins métier. IoT Platform n'impose aucune limite.

• Logique de traitement recommandée :

  1. Exécutez la commande de service.

  2. Renvoyez une réponse de service à IoT Platform.

• Logique de traitement dans l'exemple de code :

  L'exemple de code se contente d'afficher le message reçu. Pour voir une démonstration du signalement des propriétés définies, décommentez le bloc de code sous le commentaire TODO en supprimant les symboles /* et */.

  • ICA standard data format (Alink JSON)

    • Appel synchrone :

      static void demo_dm_recv_sync_service_invoke(void *dm_handle, const aiot_dm_recv_t *recv, void *userdata)
      {
          printf("demo_dm_recv_sync_service_invoke msg_id = %ld, rrpc_id = %s, service_id = %s, params = %.*s\r\n",
                  (unsigned long)recv->data.sync_service_invoke.msg_id,
                  recv->data.sync_service_invoke.rrpc_id,
                  recv->data.sync_service_invoke.service_id,
                  recv->data.sync_service_invoke.params_len,
                  recv->data.sync_service_invoke.params);
          /* TODO: The following code shows how to respond to a synchronous service invocation from IoT Platform.
              */
          {
              aiot_dm_msg_t msg;
              memset(&msg, 0, sizeof(aiot_dm_msg_t));
              msg.type = AIOT_DMMSG_SYNC_SERVICE_REPLY;
              msg.data.sync_service_reply.rrpc_id = recv->data.sync_service_invoke.rrpc_id;
              msg.data.sync_service_reply.msg_id = recv->data.sync_service_invoke.msg_id;
              msg.data.sync_service_reply.code = 200;
              msg.data.sync_service_reply.service_id = "SetLightSwitchTimer";
              msg.data.sync_service_reply.data = "{}";
              int32_t res = aiot_dm_send(dm_handle, &msg);
              if (res < 0) {
                  printf("aiot_dm_send failed\r\n");
              }
          }
      }

    • Appel asynchrone :

      static void demo_dm_recv_async_service_invoke(void *dm_handle, const aiot_dm_recv_t *recv, void *userdata)
      {
          printf("demo_dm_recv_async_service_invoke msg_id = %ld, service_id = %s, params = %.*s\r\n",
                  (unsigned long)recv->data.async_service_invoke.msg_id,
                  recv->data.async_service_invoke.service_id,
                  recv->data.async_service_invoke.params_len,
                  recv->data.async_service_invoke.params);
          /* TODO: The following code shows how to respond to an asynchronous service invocation from IoT Platform. You can uncomment it to see the effect.
              */
          /*
          {
              aiot_dm_msg_t msg;
              memset(&msg, 0, sizeof(aiot_dm_msg_t));
              msg.type = AIOT_DMMSG_ASYNC_SERVICE_REPLY;
              msg.data.async_service_reply.msg_id = recv->data.async_service_invoke.msg_id;
              msg.data.async_service_reply.code = 200;
              msg.data.async_service_reply.service_id = "ToggleLightSwitch";
              msg.data.async_service_reply.data = "{\"dataA\": 20}";
              int32_t res = aiot_dm_send(dm_handle, &msg);
              if (res < 0) {
                  printf("aiot_dm_send failed\r\n");
              }
          }
          */
      }

  • passthrough/custom format

    • La logique de traitement pour l'invocation de service binaire asynchrone est identique à celle de la définition de propriété binaire. Pour plus d'informations, consultez Analyse des messages de topic personnalisé.

    • L'exemple de code suivant illustre la logique de traitement pour l'invocation de service binaire synchrone :

      static void demo_dm_recv_raw_sync_service_invoke(void *dm_handle, const aiot_dm_recv_t *recv, void *userdata)
      {
          printf("demo_dm_recv_raw_sync_service_invoke raw sync service rrpc_id = %s, data_len = %d\r\n",
                  recv->data.raw_service_invoke.rrpc_id,
                  recv->data.raw_service_invoke.data_len);
          /* TODO: The following code shows how to respond to a synchronous service invocation from IoT Platform. You can uncomment it to see the effect. */
          /*
          {
              aiot_dm_msg_t msg;
              uint8_t raw_data[] = {0x01, 0x02};
              memset(&msg, 0, sizeof(aiot_dm_msg_t));
              msg.type = AIOT_DMMSG_RAW_SERVICE_REPLY;
              msg.data.raw_service_reply.rrpc_id = recv->data.raw_service_invoke.rrpc_id;
              msg.data.raw_data.data = raw_data;
              msg.data.raw_data.data_len = sizeof(raw_data);
              aiot_dm_send(dm_handle, &msg);
          }
          */
      }

Étape 7 : Déconnexion

Appelez aiot_mqtt_disconnect pour envoyer un message de déconnexion à IoT Platform et vous déconnecter du réseau.

    res = aiot_mqtt_disconnect(mqtt_handle);
    if (res < STATE_SUCCESS) {
        aiot_mqtt_deinit(&mqtt_handle);
        printf("aiot_mqtt_disconnect failed: -0x%04X\n", -res);
        return -1;
    }

Étape 8 : Quitter le programme

Appelez aiot_dm_deinit pour détruire l'instance client data-model et libérer ses ressources.

    res = aiot_dm_deinit(&dm_handle);
    if (res < STATE_SUCCESS) {
        printf("aiot_dm_deinit failed: -0x%04X\n", -res);
        return -1;
    }

Étapes suivantes

• Compilez le code pour générer le fichier exécutable ./output/data-model-basic-demo.

  Pour plus d'informations, consultez Compiler et exécuter.

• Consultez les Journaux d'exécution pour obtenir des détails sur le résultat de l'exécution.