Todos os produtos
Search

Este produto

    IoT Platform:Exemplo de uso

    Central de documentação

    IoT Platform:Exemplo de uso

    Última atualização: Jul 04, 2026

    Este tópico utiliza o arquivo ./demos/data_model_basic_demo.c do Link SDK for C para demonstrar como implementar a Thing Specification Language (TSL) em um dispositivo por meio da API do Link SDK.

    Contexto

    • Para obter mais informações sobre o modelo TSL, consulte Instruções de uso.

    • O modelo TSL utiliza conexões MQTT. Para exemplos de código relacionados, consulte Conexão MQTT.

    Etapa 1: Inicializar

    1. Insira o arquivo de cabeçalho.

      ……
……
#include "aiot_dm_api.h"

    2. Configure as dependências subjacentes e a saída de log.

          aiot_sysdep_set_portfile(&g_aiot_sysdep_portfile);
    aiot_state_set_logcb(demo_state_logcb);

    3. Chame aiot_dm_init para crie e inicializar uma instância de cliente data-model.

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

    Etapa 2: Configurar recursos

    Chame aiot_dm_setopt para configurar os seguintes recursos.

    1. Associe um identificador de conexão MQTT.

      Importante

      Antes de configurar os parâmetros de recursos TSL, certifique-se de ter configurado os parâmetros necessários, como as informações de autenticação do dispositivo. Para obter mais informações, consulte Configurar parâmetros de conexão MQTT.

      • Código de exemplo:

            aiot_dm_setopt(dm_handle, AIOT_DMOPT_MQTT_HANDLE, mqtt_handle);

      • Parâmetros relacionados:

        Parâmetro

        Valor de exemplo

        Descrição

        AIOT_DMOPT_MQTT_HANDLE

        mqtt_handle

        Associa o identificador de conexão MQTT. As solicitações TSL utilizam esta conexão.

    2. Implemente uma função de callback para processar mensagens TSL.

      1. Defina a função de callback para mensagens 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. Registre a função de callback para mensagens TSL.

        • Código de exemplo:

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

        • Parâmetros relacionados:

          Parâmetro

          Valor de exemplo

          Descrição

          AIOT_DMOPT_RECV_HANDLER

          demo_dm_recv_handler

          O SDK invoca esta função de callback ao receber uma mensagem TSL.

    3. Configure o envio de mensagens de resposta pelo IoT Platform.

      Esta configuração define se o IoT Platform envia uma mensagem de resposta após receber uma mensagem do dispositivo.

      • Código de exemplo:

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

      • Parâmetros relacionados:

        Parâmetro

        Exemplo

        Descrição

        AIOT_DMOPT_POST_REPLY

        1

        Valores válidos:

        • 1: Enviar uma mensagem de resposta.

        • 0: Não enviar uma mensagem de resposta.

      • Se você definir o parâmetro AIOT_DMOPT_POST_REPLY como 1, será necessário implementar a lógica para tratar as mensagens de resposta.

        Essa lógica pode ser implementada conforme seus requisitos de negócio. O código de exemplo apenas imprime logs.

        • ICA Standard Data Format (Alink JSON): Ao crie um produto, defina o parâmetro Data Format como ICA Standard Data Format (Alink JSON).

          A mensagem de resposta é retornada na struct recv->data.generic_reply e utiliza o formato de dados Alink. Para obter mais informações, consulte Propriedades, eventos e serviços do dispositivo.

          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: Na página de configurações do produto no console do IoT Platform, defina o parâmetro Data Format como Passthrough/Custom.

          A mensagem de resposta é retornada na struct recv->data.raw_data. Antes de enviar ou receber mensagens, faça upload de um script de análise no IoT Platform. Para obter mais informações, consulte Análise de mensagens.

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

    Etapa 3: Relatar propriedades

    Após o dispositivo estabelecer uma conexão MQTT, chame aiot_dm_send para enviar mensagens de propriedade ao IoT Platform. Armazene a mensagem de propriedade na struct aiot_dm_msg_t e passe-a para aiot_dm_send.

    Escreva o código para relatar mensagens de propriedade com base em um dos seguintes formatos de dados do dispositivo.

    ICA standard data format (Alink JSON)

    1. Adicione um modelo TSL.

      • Antes de relatar propriedades, faça login no console do IoT Platform. Na página Product Details, acesse a aba Feature Definition e adicione propriedades ao modelo TSL do módulo padrão ou de um módulo personalizado, como demo_extra_block. Para obter mais informações, consulte Adicionar um modelo TSL manualmente.

        A tabela a seguir lista as propriedades do modelo TSL correspondentes ao código de exemplo.

        Nome do módulo TSL

        Nome do recurso

        Identificador

        Tipo

        Definição de dados

        Tipo de leitura/gravação

        módulo padrão

        Interruptor de luz noturna 1

        LightSwitch

        bool

        • 0: ligado

        • 1: desligado

        Leitura/Gravação

        Potência

        Power

        text

        Comprimento dos dados: 10.240

        Leitura/Gravação

        Corrente operacional

        WF

        int32

        • Faixa de valores: 0–10

        • Incremento: 1

        • Unidade: A

        Leitura/Gravação

        demo_extra_block

        Interruptor de luz noturna 2

        NightLightSwitch

        bool

        • 0: ligado

        • 1: desligado

        Leitura/Gravação

      • Alternativamente, importe o arquivo TSL deste exemplo. Para instruções, consulte Adicionar modelos TSL em lote.

    2. Defina o conteúdo da mensagem de propriedade.

      • Código de exemplo:

        • Módulo padrão:

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

      • Descrição da mensagem de exemplo:

        • As mensagens de modelo TSL relatadas estão no formato JSON. A tabela a seguir mostra mensagens de exemplo e seus formatos de dados Alink correspondentes. Para obter mais informações, consulte Relatar propriedades do dispositivo.

          Nota

          Você precisa fornecer apenas os dados do dispositivo, que correspondem ao valor do parâmetro params no formato de dados Alink. O Link SDK cuida do encapsulamento das mensagens relatadas.

          Tipo de mensagem

          Mensagem de exemplo

          Formato Alink

          Propriedade única

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

          Propriedades em lote

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

        • Após relatar propriedades em lote, o IoT Platform envia uma mensagem de resposta. Para verifique se o IoT Platform recebeu a mensagem, inscreva-se no tópico /sys/a18wP******/LightSwitch/thing/event/property/batch/post_reply.

          Código de exemplo:

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

          Onde:

          • a18wP****** é a ProductKey do dispositivo.

          • LightSwitch é o DeviceName do dispositivo.

    3. Defina as funções para relatar propriedades.

      /* 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. Faça upload de um script de análise de dados do modelo TSL no IoT Platform.

      Para obter mais informações, consulte Mensagens em formato de dados personalizado.

    2. Escreva o código do dispositivo para relatar mensagens binárias.

      Código de exemplo:

          {
        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

    Ao utilizar modelos TSL para comunicação, certifique-se de que o tráfego de dados não exceda o limiar.

    Etapa 4: Definir propriedades

    Chame a API de nuvem do IoT Platform SetDeviceProperty ou SetDevicesProperty para enviar um comando de definição de propriedade ao dispositivo. O dispositivo chama aiot_mqtt_recv para receber o comando e o processa com a função de callback demo_dm_recv_handler.

    Utilize as informações a seguir para escrever a lógica de processamento da função de callback:

    • Observações:

      • A mensagem recebida é passada como um parâmetro de entrada do tipo aiot_dm_recv_handler_t e armazenada em um local especificado pela estrutura aiot_dm_recv_t.

      • O campo da mensagem recebida que contém o conteúdo do comando de definição de propriedade depende do formato de dados do dispositivo, conforme mostrado na tabela a seguir.

        Formato de dados do dispositivo

        Campo da mensagem

        Descrição

        ICA standard data format (Alink JSON)

        recv->data.property_set.params

        Corresponde ao valor do campo params no formato de dados Alink. Para obter mais informações, consulte Mensagens de propriedade.

        passthrough/custom format

        recv->data.raw_data

        O dispositivo deve analisar os dados. Para obter mais informações, consulte Mensagens em formato passthrough/personalizado.

    • Lógica de processamento recomendada:

      1. Atualize as propriedades do dispositivo.

      2. Relate as propriedades atualizadas.

    • Lógica de processamento no código de exemplo:

      O código de exemplo apenas imprime a mensagem recebida. Para ver uma demonstração de como relatar as propriedades definidas, descomente o bloco de código abaixo do comentário TODO removendo os símbolos /* e */.

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

    Etapa 5: Relatar eventos

    Após o dispositivo estabelecer uma conexão MQTT, chame aiot_dm_send para enviar mensagens de evento ao IoT Platform. A mensagem é armazenada em uma struct aiot_dm_msg_t e passada como parâmetro para aiot_dm_send.

    Escreva o código para relatar eventos com base em um dos seguintes formatos de dados do dispositivo.

    • Se o seu dispositivo utilizar o custom format, a interface para relatar eventos é a mesma usada para propriedades. Para obter mais informações, consulte o procedimento para relatar mensagens no formato personalizado na Etapa 3.

    • Se o seu dispositivo utilizar o ICA standard data format (Alink JSON), siga o procedimento abaixo para escrever o código do lado do dispositivo.

    1. Adicione um modelo TSL.

      • Antes de relatar um evento, faça login no console do IoT Platform. Na página Product details, acesse a aba Feature definition e adicione um evento para o produto. Para obter mais informações, consulte Adicionar um modelo TSL manualmente.

        A tabela a seguir descreve o evento do modelo TSL utilizado no código de exemplo.

        Nome do recurso

        Identificador

        Tipo

        Parâmetro de saída

        Erro

        Error

        Falha

        • Nome do parâmetro: Código de erro

        • Identificador do parâmetro: ErrorCode

        • Tipo de dados: enum

        • Itens de enumeração:

          • 0: Falha de hardware do dispositivo

          • 1: Falha de software do dispositivo

          • 2: Erro desconhecido

      • Alternativamente, importe o arquivo TSL deste exemplo. Para instruções, consulte Adicionar modelos TSL em lote.

    2. Defina o conteúdo da mensagem de evento.

      • Código de exemplo:

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

      • Descrição da mensagem de exemplo:

        Os dispositivos relatam mensagens de modelo TSL no formato JSON. A tabela a seguir mostra uma mensagem de exemplo e seu formato de dados Alink correspondente. Para obter mais informações, consulte Relatar eventos do dispositivo.

        Nota

        Você precisa fornecer apenas os dados do dispositivo, que correspondem ao valor do parâmetro params no formato de dados Alink. O Link SDK cuida do encapsulamento das mensagens relatadas.

        Payload de exemplo

        Formato Alink

        		 
        {\"ErrorCode\": 0}
        		 
        {
  "id": "123",
  "version": "1.0",
  "params": {
        "ErrorCode": 0
  },
  "method": "thing.event.alarm.post"
}

    3. Defina uma função para relatar mensagens 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);
}

    Etapa 6: Invocação de serviço

    Você pode chamar as APIs de nuvem do IoT Platform, InvokeThingService ou InvokeThingsService, para enviar um comando de invocação de serviço ao dispositivo. O dispositivo chama aiot_mqtt_recv para receber o comando e executa a ação correspondente com base nas configurações da função de callback demo_dm_recv_handler.

    Utilize as informações a seguir para escrever a lógica de processamento da função de callback:

    • Notas de uso:

      • A mensagem recebida é passada como um parâmetro de entrada do tipo aiot_dm_recv_handler_t e armazenada em um local especificado pela estrutura aiot_dm_recv_t.

      • O conteúdo do comando de invocação de serviço varia conforme o formato de dados do dispositivo. A tabela a seguir lista os campos onde o conteúdo do comando é armazenado.

        Formato de dados do dispositivo

        Campo síncrono

        Campo assíncrono

        Descrição

        ICA standard data format (Alink JSON)

        recv->data.sync_service_invoke

        recv->data.async_service_invoke

        Os dados neste campo têm o mesmo formato que o valor do parâmetro params nos dados Alink. Para obter mais informações, consulte Mensagens de serviço.

        passthrough/custom format

        recv->data.raw_data

        recv->data.raw_service_invoke

        É necessário fazer upload de um script de análise para interpretar o conteúdo do comando. Para obter mais informações, consulte Mensagens em formato passthrough/personalizado.

      • Caso utilize uma função separada para tratar a resposta em vez de enviá-la diretamente da função de callback, garanta que os valores dos seguintes parâmetros na mensagem de resposta correspondam aos da solicitação do IoT Platform.

        • Chamada síncrona: rrpc_id e msg_id

        • Chamada assíncrona: msg_id

      • Ao enviar uma resposta de serviço ao IoT Platform, atente-se ao período de tempo limite:

        • Chamada síncrona: Após receber uma mensagem de serviço síncrona, envie uma resposta dentro de 8 segundos. Caso contrário, o IoT Platform considerará a invocação como falha, mesmo que o dispositivo tenha recebido a mensagem.

        • Chamada assíncrona: Defina uma lógica de tempo limite personalizada para chamadas assíncronas conforme seus requisitos de negócio. O IoT Platform não impõe limites nesse caso.

    • Lógica de processamento recomendada:

      1. Execute o comando de serviço.

      2. Retorne uma resposta de serviço ao IoT Platform.

    • Lógica de processamento no código de exemplo:

      O código de exemplo apenas imprime a mensagem recebida. Para ver uma demonstração de como relatar as propriedades definidas, descomente o bloco de código abaixo do comentário TODO removendo os símbolos /* e */.

      • ICA standard data format (Alink JSON)

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

        • Chamada assí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

        • A lógica de processamento para invocação de serviço binário assíncrona é a mesma usada para definição de propriedade binária. Para obter mais informações, consulte Análise de mensagens de tópico personalizado.

        • O código de exemplo a seguir mostra a lógica de processamento para invocação de serviço binário síncrono:

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

    Etapa 7: Desconectar

    Nota

    O protocolo MQTT é normalmente utilizado em dispositivos que exigem conexão persistente. Por isso, o programa geralmente não chega a este ponto.

    No programa de exemplo, a thread principal é responsável por configurar parâmetros e estabelecer a conexão. Após estabelecer a conexão, a thread principal pode entrar em hibernação.

    Chame aiot_mqtt_disconnect para enviar uma mensagem de desconexão ao IoT Platform e encerrar a conexão de rede.

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

    Etapa 8: Sair do programa

    Chame aiot_dm_deinit para destruir a instância do cliente data-model e liberar seus recursos.

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

    Próximas etapas

    • Compile o código para gerar o arquivo executável ./output/data-model-basic-demo.

      Para obter mais informações, consulte Compilar e execute.

    • Consulte os Logs de execução para obter detalhes sobre o resultado da execução.