IoT Platform:Exemple

Contexte

Pour plus d’informations sur les connexions HTTPS, consultez la rubrique Vue d’ensemble.

Étape 1 : Initialiser un client

Ajoutez la dépendance sous-jacente et configurez la journalisation. Utilisez l’opération aiot_http_init pour créer une instance de client et initialiser les paramètres par défaut.

 /* Add the underlying dependencies to the SDK. */
    aiot_sysdep_set_portfile(&g_aiot_sysdep_portfile);
    /* Configure the log output feature for the SDK. */
    aiot_state_set_logcb(demo_state_logcb);
    ...
    ...

    /* Create an HTTPS client instance and set the default parameters. */
    http_handle = aiot_http_init();

Étape 2 : Configurer les fonctionnalités requises

Appelez l’opération aiot_http_setopt pour configurer les éléments suivants :

1. Définir les paramètres de connexion.

2. Configurer les rappels d’événement.

Pour plus d’informations sur les paramètres de l’opération, consultez la documentation relative à aiot_http_option_t.

1. Définissez les paramètres de connexion.

   • Exemple de code

         char       *http_host = "iot-as-http.cn-shanghai.aliyuncs.com";
         ...
         aiot_sysdep_network_cred_t cred;
         char *product_key       = "a18wP******";
         char *device_name       = "LightSwitch";
         char *device_secret     = "uwMTmVAMnGGHaAkqmeDY6cHxxB******";
         ...
         ...
     
         /* Set the domain name of the HTTPS server.  */
         aiot_http_setopt(http_handle, AIOT_HTTPOPT_HOST, (void *)host);
         /* Set the server port.  */
         aiot_http_setopt(http_handle, AIOT_HTTPOPT_PORT, (void *)&port);
         /* Set the security credential of the device.  */
         aiot_http_setopt(http_handle, AIOT_HTTPOPT_NETWORK_CRED, &cred);
         /* Set the ProductKey of the device.  */
         aiot_http_setopt(http_handle, AIOT_HTTPOPT_PRODUCT_KEY, product_key);
         /* Set the DeviceName of the device.  */
         aiot_http_setopt(http_handle, AIOT_HTTPOPT_DEVICE_NAME, device_name);
         /* Set the DeviceSecret of the device.  */
         aiot_http_setopt(http_handle, AIOT_HTTPOPT_DEVICE_SECRET, device_secret);
                                     

   • Paramètres :

     Paramètre	Exemple	Description
     http_host	iot-06z00ax1o******.http.iothub.aliyuncs.com	Le endpoint. Si vous utilisez une instance Enterprise Edition ou une instance publique activée le 30 juillet 2021 ou ultérieurement, consultez le endpoint sur la page Instance Details. Cliquez sur View Development Configurations dans le coin supérieur droit. Le endpoint s’affiche dans le panneau Development Configurations. Si vous utilisez une instance publique activée avant le 30 juillet 2021, le endpoint est https://iot-as-http.${YourRegionId}.aliyuncs.com.
     product_key	a18wP******	Les informations d’authentification de l’appareil. Pour plus d’informations, consultez la rubrique Obtenir les informations de vérification de l’appareil. Dans cet exemple, la méthode d’authentification unique-certificate-per-device est utilisée.
     device_name	LightSwitch
     device_secret	uwMTmVAMnGGHaAkqmeDY6cHxxB******

2. Configurez la surveillance de l’état.

   1. Spécifiez les rappels pour surveiller l’état.

      • Exemple de code

            int main(int argc, char *argv[])
        {
            ...
            ...
        
            /* Specify the callback that is called when data arrives. */
            aiot_http_setopt(http_handle, AIOT_HTTPOPT_RECV_HANDLER, demo_http_recv_handler);
            /* Specify the callback that is called when the internal status changes. */
            aiot_http_setopt(http_handle, AIOT_HTTPOPT_EVENT_HANDLER, demo_http_event_handler);
        
        }

      • Paramètres :

        Paramètre	Exemple	Description
        AIOT_HTTPOPT_RECV_HANDLER	demo_http_recv_handler	Lorsque l’appareil reçoit un message de réponse, le rappel est appelé pour effectuer les opérations requises.
        AIOT_HTTPOPT_EVENT_HANDLER	demo_http_event_handler	Lorsque le jeton change, le rappel est appelé pour garantir la validité du jeton.

   2. Définissez le rappel pour surveiller l’état.

      • Lorsque le jeton change, le rappel est appelé pour effectuer les opérations requises.

        void demo_http_event_handler(void *handle, const aiot_http_event_t *event, void *user_data)
        {
            int32_t res;
        
            /* Handle expired tokens. */
            if (event->type == AIOT_HTTPEVT_TOKEN_INVALID) {
                printf("token invalid, invoke iot_http_auth to get new token\n");
                res = aiot_http_auth(handle);
                printf("aiot_http_auth in callback, res = -0x%04x\r\n", -res);
            }
        }

      • Lorsqu’un message réseau est lu, le rappel est appelé pour effectuer les opérations requises. Dans cet exemple, le message est affiché. Lorsque vous spécifiez la logique de traitement, tenez compte des points suivants.

        • Pour plus d’informations sur les paramètres d’un message de réponse, consultez la rubrique Se connecter et communiquer via HTTPS.

        • Un message reçu contient les sections suivantes : AIOT_HTTPRECV_STATUS_CODE, AIOT_HTTPRECV_HEADER, et AIOT_HTTPRECV_BODY. Ces sections indiquent respectivement le code d’état, le type de message et le corps du message.

        • Traitez les codes d’état en fonction de vos besoins métier. Pour plus d’informations sur les codes d’état, consultez la liste des Codes d’état HTTP.

        void demo_http_recv_handler(void *handle, const aiot_http_recv_t *packet, void *userdata)
        {
            switch (packet->type) {
                case AIOT_HTTPRECV_STATUS_CODE: {
                    /* TODO: If the following code is not annotated, the SDK receives a message and prints the HTTPS status code by using this callback, such as 404, 200, and 302.  */
                    /* printf("status code: %d\n", packet->data.status_code.code); */
                }
                break;
        
                case AIOT_HTTPRECV_HEADER: {
                    /* TODO: If the following code is not annotated, the SDK receives a message and prints the HTTPS header by using this callback, such as Content-Length.  */
                    /* printf("key: %s, value: %s\n", packet->data.header.key, packet->data.header.value); */
                }
                break;
        
                /* TODO: If you need to process HTTPS response messages from IoT Platform, specify the logic. In this example, response messages are printed.  */
                case AIOT_HTTPRECV_BODY: {
                    printf("%.*s\r\n", packet->data.body.len, packet->data.body.buffer);
                }
                break;
        
                default: {
                }
                break;
        
            }
        }

Étape 3 : Établir une connexion

Appelez l’opération aiot_http_auth pour envoyer une demande d’authentification à IoT Platform et obtenir un jeton. Pour savoir comment spécifier les paramètres, consultez la section Définir les paramètres de connexion.

/* Initiate an authentication request and obtain a token. */
    res = aiot_http_auth(http_handle);
    if (res == 0) {
        printf("aiot_http_auth succeed\r\n");
    } else {
        /* If the authentication fails, release resources of the instance and exit the program. */
        printf("aiot_http_auth failed, res = -0x%04x\r\n", -res);
        aiot_http_deinit(&http_handle);
        return -1;
    }

Étape 4 : Envoyer un message

Appelez l’opération aiot_http_send dans la fonction demo_http_post_lightswitch pour envoyer un message à un topic spécifié.

• Exemple de code

  int32_t demo_http_post_lightswitch(void *handle)
  {
      char data[] = "{\"id\":\"1\",\"version\":\"1.0\",\"params\":{\"LightSwitch\":0}}";
      int32_t res;
  
      res = aiot_http_send(handle,
                           "/a1wAf******/LightSwitch/user/update",
                           (uint8_t *)data,
                           strlen(data));
      if (res < 0) {
          printf("aiot_http_send res = -0x%04X\r\n", -res);
          return res;
      }
      ...
      ...
  }

• Paramètres :

  Paramètre	Exemple	Description
  data[]	{\"id\":\"1\",\"version\":\"1.0\",\"params\":{\"LightSwitch\":0}}	Le message envoyé à IoT Platform. Dans cet exemple, un topic personnalisé est utilisé. Par conséquent, vous pouvez personnaliser le format du message. Pour plus d’informations sur les formats de message, consultez la rubrique Formats de données.
  topic	/a1wAf******/LightSwitch/user/update	Le topic disposant de l’autorisation Publish. a18wP****** indique le ProductKey de l’appareil. LightSwitch indique le DeviceName de l’appareil. L’appareil peut envoyer des messages à IoT Platform via ce topic. Pour plus d’informations sur les topics, consultez la rubrique Qu’est-ce qu’un topic.

Étape 5 : Recevoir une réponse

Après l’envoi du message, IoT Platform renvoie un message de réponse. L’appareil appelle l’opération aiot_http_recv pour recevoir les données de réponse HTTPS et les traiter à l’aide du rappel d’événement.

    res = aiot_http_recv(handle);
    if (res >= 0) {
        /* If a response from the server is received and the response code is 0, device data is submitted. */
        return 0;
    } else {
        printf("aiot_http_recv res = -0x%04X\r\n", -res);
        return -1;
    }

Étape 6 : Quitter le programme

Appelez l’opération aiot_http_deinit pour détruire l’instance de client HTTPS et libérer les ressources.

    aiot_http_deinit(&http_handle);
    printf("program exit as normal return\r\n");
    printf("\r\n");

    return 0;

Étapes suivantes

• Après avoir configuré le fichier de code exemple, compilez-le pour générer un fichier exécutable. Dans cet exemple, le fichier exécutable ./output/http-basic-demo est généré.

  Pour plus d’informations, consultez la section Compilation et exécution.

• Pour plus d’informations sur les résultats d’exécution, consultez la rubrique Journaux d’opération.