Ejemplo de uso - IoT Platform - Centro de documentación de Alibaba Cloud

Este tema utiliza el archivo ./demos/data_model_basic_demo.c del Link SDK for C para demostrar cómo implementar Thing Specification Language (TSL) en un dispositivo mediante la API de Link SDK.

Contexto

Para obtener más información sobre el modelo TSL, consulte Usage instructions.
El modelo TSL usa conexiones MQTT. Para ver ejemplos de código relacionados, consulte MQTT connection.

Paso 1: Inicializar

Incluya el archivo de encabezado.
```
……
……
#include "aiot_dm_api.h"
```

Configure las dependencias subyacentes y la salida de registros.

    aiot_sysdep_set_portfile(&g_aiot_sysdep_portfile);
    aiot_state_set_logcb(demo_state_logcb);

Llame a aiot_dm_init para crear e inicializar una instancia de cliente data-model.

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

Paso 2: Configurar funciones

Llame a aiot_dm_setopt para configurar a continuación las siguientes funciones.

Associate an MQTT connection handle
Implement a callback function to process TSL messages
Configure whether IoT Platform sends response messages

Asocie un controlador de conexión MQTT.
Importante
Antes de configurar los parámetros de la función TSL, asegúrese de haber configurado los parámetros obligatorios, como la información de autenticación del dispositivo. Para obtener más información, consulte Configure MQTT connection parameters.
- Código de ejemplo:
```
    aiot_dm_setopt(dm_handle, AIOT_DMOPT_MQTT_HANDLE, mqtt_handle);
```
- Parámetros relacionados:
  
  Parámetro
  
  Valor de ejemplo
  
  Descripción
  
  AIOT_DMOPT_MQTT_HANDLE
  
  mqtt_handle
  
  Asocia el controlador de conexión MQTT. Las solicitudes TSL usan esta conexión.

Implemente una función de callback para procesar mensajes TSL.

Defina la función de callback para los mensajes 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;
    }
}

Registre la función de callback para los mensajes TSL.
- Código de ejemplo:
```
    aiot_dm_setopt(dm_handle, AIOT_DMOPT_RECV_HANDLER, (void *)demo_dm_recv_handler);                   
```
- Parámetros relacionados:
  
  Parámetro
  
  Valor de ejemplo
  
  Descripción
  
  AIOT_DMOPT_RECV_HANDLER
  
  demo_dm_recv_handler
  
  El SDK invoca esta función de callback cuando recibe un mensaje TSL.

Configure si IoT Platform envía mensajes de respuesta.
Esta configuración indica si IoT Platform envía un mensaje de respuesta después de recibir un mensaje del dispositivo.
- Código de ejemplo:
```
    uint8_t post_reply = 1;
    ……
    ……
   aiot_dm_setopt(dm_handle, AIOT_DMOPT_POST_REPLY, (void *)&post_reply);
```
- Parámetros relacionados:
  Parámetro
  
  Ejemplo
  
  Descripción
  
  AIOT_DMOPT_POST_REPLY
  
  1
  
  Valores válidos:
  
  1: enviar un mensaje de respuesta.
  
  0: no enviar un mensaje de respuesta.
- Si establece el parámetro AIOT_DMOPT_POST_REPLY en 1, debe implementar la lógica para manejar los mensajes de respuesta.
  
  Puede implementar la lógica según sus requisitos de negocio. El código de ejemplo solo imprime registros.
  - ICA Standard Data Format (Alink JSON): al crear un producto, establezca el parámetro Data Format en ICA Standard Data Format (Alink JSON).
    
    El mensaje de respuesta se devuelve en la estructura recv->data.generic_reply y usa el formato de datos Alink. Para obtener más información, consulte Device properties, events, and services.
    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: en la página de configuración del producto dentro de la consola de IoT Platform, establezca el parámetro Data Format en Passthrough/Custom.
    
    El mensaje de respuesta se devuelve en la estructura recv->data.raw_data. Antes de enviar o recibir mensajes, debe cargar un script de análisis en IoT Platform. Para obtener más información, consulte Message parsing.
    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); }

Paso 3: Reportar propiedades

Una vez que el dispositivo establece una conexión MQTT, llame a aiot_dm_send para enviar mensajes de propiedad a IoT Platform. Almacene el mensaje de propiedad en la estructura aiot_dm_msg_t y páselo a aiot_dm_send.

Escriba el código para reportar mensajes de propiedad con base en uno de los siguientes formatos de datos del dispositivo.

ICA standard data format (Alink JSON)
Custom data format

ICA standard data format (Alink JSON)

Agregue un modelo TSL.

Antes de reportar propiedades, inicie sesión en la consola de IoT Platform. En la página Product Details, vaya a la pestaña Feature Definition y agregue propiedades al modelo TSL del módulo predeterminado o de un módulo personalizado, como demo_extra_block. Para obtener más información, consulte Add a TSL model manually.

A continuación se muestran las propiedades del modelo TSL que corresponden al código de ejemplo.

Nombre del módulo TSL	Nombre de la función	Identificador	Tipo	Definición de datos	Tipo de lectura/escritura
Módulo predeterminado	Night light switch 1	LightSwitch	bool	0: encendido 1: apagado	Read/Write
	Power	Power	text	Longitud de datos: 10,240	Read/Write
	Operating current	WF	int32	Rango de valores: 0–10 Tamaño de paso: 1 Unidad: A	Read/Write
demo_extra_block	Night light switch 2	NightLightSwitch	bool	0: encendido 1: apagado	Read/Write

También puede importar el archivo TSL de este ejemplo. Para consultar las instrucciones, vea Add TSL models in batches.

Establezca el contenido del mensaje de propiedad.

Código de ejemplo:

Módulo predeterminado:

/* 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}]}}");

Módulo personalizado:

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

Descripción del mensaje de ejemplo:

Los mensajes del modelo TSL reportados están en formato JSON. A continuación se muestran mensajes de ejemplo y sus formatos de datos Alink correspondientes. Para obtener más información, consulte Report device properties.

Nota

Solo necesita proporcionar los datos del dispositivo, que corresponden al valor del parámetro params en el formato de datos Alink. Link SDK se encarga de encapsular los mensajes reportados.

Tipo de mensaje

Mensaje de ejemplo

Formato Alink

Propiedad individual

{\"LightSwitch\": 0}

{
  "id": "123",
  "version": "1.0",
  "sys":{
      "ack":0
  },
  "params": {
         "LightSwitch": 0
    },
  "method": "thing.event.property.post"
}

Propiedades por lotes

{\"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
                },
          ]
      }, 
}

Después de reportar las propiedades por lotes, IoT Platform envía un mensaje de respuesta. Para comprobar que IoT Platform recibió el mensaje, suscríbase al tema /sys/a18wP******/LightSwitch/thing/event/property/batch/post_reply.

Código de ejemplo:
```
    aiot_mqtt_sub(mqtt_handle, "/sys/a18wP******/LightSwitch/thing/event/property/batch/post_reply", NULL, 1,
                  NULL);
```
Donde:
- a18wP****** es el ProductKey del dispositivo.
- LightSwitch es el DeviceName del dispositivo.

Defina las funciones para reportar propiedades.

/* 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

Cargue un script de análisis de datos del modelo TSL en IoT Platform.

Para obtener más información, consulte Messages in a custom data format.

Escriba el código del dispositivo para reportar mensajes binarios.

Código de ejemplo:

    {
        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);
    }

Nota

Cuando use modelos TSL para la comunicación, asegúrese de que el tráfico de datos no supere el umbral.

Para conocer los límites de comunicación, consulte Connection and communication.
Si el volumen de comunicación supera el umbral, inicie sesión en la consola de IoT Platform para consultar los mensajes acumulados. Para obtener más información, consulte View and monitor consumer groups.

Paso 4: Establecer propiedades

Llame a la API en la nube de IoT Platform SetDeviceProperty o SetDevicesProperty para enviar un comando de configuración de propiedades a un dispositivo. El dispositivo llama a aiot_mqtt_recv para recibir el comando y lo procesa con la función de callback demo_dm_recv_handler.

Use la siguiente información para escribir la lógica de procesamiento de la función de callback:

Notas:

El mensaje recibido se pasa como un parámetro de entrada de tipo aiot_dm_recv_handler_t y se almacena en la ubicación que usted especifique mediante la estructura aiot_dm_recv_t.

El campo del mensaje recibido que contiene el contenido del comando de configuración de propiedades depende del formato de datos del dispositivo, como se muestra a continuación.

Formato de datos del dispositivo	Campo del mensaje	Descripción
ICA standard data format (Alink JSON)	`recv->data.property_set.params`	Coincide con el valor del campo params en el formato de datos Alink. Para obtener más información, consulte Property messages.
passthrough/custom format	`recv->data.raw_data`	El dispositivo debe analizar sintácticamente los datos. Para obtener más información, consulte Messages in passthrough/custom format.

Lógica de procesamiento recomendada:
1. Actualice las propiedades del dispositivo.
2. Reporte las propiedades actualizadas.

Lógica de procesamiento en el código de ejemplo:

El código de ejemplo solo imprime el mensaje recibido. Para ver una demostración de cómo reportar las propiedades establecidas, descomente el bloque de código bajo el comentario TODO; para ello, elimine los símbolos /* y */.

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);
    }
    */
}

Paso 5: Reportar eventos

Una vez que el dispositivo establece una conexión MQTT, llame a aiot_dm_send para enviar mensajes de evento a IoT Platform. El mensaje se almacena en una estructura aiot_dm_msg_t y se pasa como parámetro a aiot_dm_send.

Escriba el código para reportar eventos con base en uno de los siguientes formatos de datos del dispositivo.

Si su dispositivo usa el custom format, la interfaz para reportar eventos es la misma que para las propiedades. Para obtener más información, consulte the procedure for reporting messages in the custom format in Step 3.
Si su dispositivo usa el ICA standard data format (Alink JSON), siga el procedimiento descrito a continuación para escribir el código del lado del dispositivo.

Agregue un modelo TSL.

Antes de reportar un evento, inicie sesión en la consola de IoT Platform. En la página Product details, vaya a la pestaña Feature definition y agregue un evento para el producto. Para obtener más información, consulte Add a TSL model manually.

A continuación se describe el evento del modelo TSL que se usa en el código de ejemplo.

Nombre de la función	Identificador	Tipo	Parámetro de salida
Error	Error	Fault	Nombre del parámetro: Error code Identificador del parámetro: ErrorCode Tipo de datos: enum Elementos de enumeración: 0: falla de hardware del dispositivo 1: falla de software del dispositivo 2: error desconocido

También puede importar el archivo TSL de este ejemplo. Para consultar las instrucciones, vea Add TSL models in batches.

Establezca el contenido del mensaje de evento.
- Código de ejemplo:
```
        demo_send_event_post(dm_handle, "Error", "{\"ErrorCode\": 0}");
```
- Descripción del mensaje de ejemplo:
  
  Los dispositivos reportan los mensajes del modelo TSL en formato JSON. A continuación se muestra un mensaje de ejemplo y su formato de datos Alink correspondiente. Para obtener más información, consulte Report device events.
  
  Nota
  Solo necesita proporcionar los datos del dispositivo, que corresponden al valor del parámetro params en el formato de datos Alink. Link SDK se encarga de encapsular los mensajes reportados.
  Carga útil de ejemplo
  
  Formato Alink
  
  {\"ErrorCode\": 0}
  
  { "id": "123", "version": "1.0", "params": { "ErrorCode": 0 }, "method": "thing.event.alarm.post" }

Defina una función para reportar mensajes de evento.


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);
}

Paso 6: Invocación del servicio

Puede llamar a las API en la nube de IoT Platform, InvokeThingService o InvokeThingsService, para enviar un comando de invocación de servicio a un dispositivo. El dispositivo llama a aiot_mqtt_recv para recibir el comando y ejecuta la acción correspondiente según la configuración de la función de devolución de llamada demo_dm_recv_handler.

Utilice la siguiente información para escribir la lógica de procesamiento de la función de devolución de llamada:

Notas de uso:

El mensaje recibido se pasa como parámetro de entrada de tipo aiot_dm_recv_handler_t y se almacena en una ubicación que usted especifique mediante la estructura aiot_dm_recv_t.

El contenido del comando de invocación del servicio varía según el formato de datos del dispositivo. En la tabla a continuación se muestran los campos donde se almacena dicho contenido.

Formato de datos del dispositivo	Campo síncrono	Campo asíncrono	Descripción
ICA standard data format (Alink JSON)	`recv->data.sync_service_invoke`	`recv->data.async_service_invoke`	Los datos de este campo tienen el mismo formato que el valor del parámetro params en los datos Alink. Para obtener más información, consulte Service messages.
passthrough/custom format	`recv->data.raw_data`	`recv->data.raw_service_invoke`	Debe cargar un script de análisis sintáctico para procesar el contenido del comando. Para obtener más información, consulte Messages in passthrough/custom format.

Si utiliza una función independiente para gestionar la respuesta en lugar de enviarla desde la función de devolución de llamada, asegúrese de que los valores de los siguientes parámetros del mensaje de respuesta coincidan con los de la solicitud de IoT Platform.
- Llamada síncrona: rrpc_id y msg_id
- Llamada asíncrona: msg_id
Al enviar una respuesta de servicio a IoT Platform, tenga en cuenta el tiempo de espera:
- Llamada síncrona: Después de recibir un mensaje de servicio síncrono, debe enviar una respuesta en un plazo de 8 segundos. De lo contrario, IoT Platform considera que la invocación finalizó con errores, incluso si el dispositivo recibió el mensaje.
- Llamada asíncrona: puede definir una lógica de tiempo de espera personalizada para las llamadas asíncronas según sus requisitos de negocio. IoT Platform no impone ningún límite.

Lógica de procesamiento recomendada:
1. Ejecute el comando del servicio.
2. Devuelva una respuesta de servicio a IoT Platform.

Lógica de procesamiento en el código de ejemplo:

El código de ejemplo solo imprime el mensaje recibido. Para ver una demostración sobre cómo notificar las propiedades establecidas, elimine los símbolos /* y */ para descomentar el bloque de código ubicado bajo el comentario TODO.

ICA standard data format (Alink JSON)

Llamada síncrona:

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");
        }
    }
}

Llamada asíncrona:

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 lógica de procesamiento para la invocación asíncrona de servicios binarios es la misma que para la configuración de propiedades binarias. Para obtener más información, consulte Custom topic message parsing.

En el siguiente código de ejemplo se muestra la lógica de procesamiento para la invocación síncrona de servicios binarios:

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);
    }
    */
}

Paso 7: Desconexión

Nota

MQTT suele utilizarse en dispositivos que requieren una conexión persistente. Por lo tanto, el programa normalmente no llega a este punto.

En el programa de ejemplo, el hilo principal se encarga de configurar los parámetros y establecer la conexión. Una vez establecida la conexión, el hilo principal puede entrar en estado de hibernación.

Puede llamar a aiot_mqtt_disconnect para enviar un mensaje de desconexión a IoT Platform y desconectarse de la red.

    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;
    }

Paso 8: Salir del programa

Llame a aiot_dm_deinit para destruir la instancia del cliente del modelo de datos y liberar sus recursos.

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

Pasos siguientes

Compile el código para generar el archivo ejecutable ./output/data-model-basic-demo.

Para obtener más información, consulte Compile and run.
Consulte Runtime logs para conocer los detalles del resultado de la ejecución.

Parámetro	Valor de ejemplo	Descripción
AIOT_DMOPT_MQTT_HANDLE	mqtt_handle	Asocia el controlador de conexión MQTT. Las solicitudes TSL usan esta conexión.

Carga útil de ejemplo	Formato Alink
`{\"ErrorCode\": 0}`	`{ "id": "123", "version": "1.0", "params": { "ErrorCode": 0 }, "method": "thing.event.alarm.post" }`