Exemplo - IoT Platform: Central de Documentação do Alibaba Cloud

Informações básicas

Para obter mais informações sobre conexões HTTPS, consulte Visão geral.

Etapa 1: Inicializar um cliente

Adicione a dependência subjacente e configure o recurso de saída de log. Em seguida, utilize a operação aiot_http_init para criar uma instância de cliente e inicializar os parâmetros padrão.

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

Etapa 2: Configurar recursos necessários

Chame a operação aiot_http_setopt para configurar os seguintes itens:

Para mais detalhes sobre os parâmetros da operação, consulte aiot_http_option_t.

Defina os parâmetros de conexão.

Código de amostra

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

Parâmetros:

Parâmetro	Exemplo	Descrição
http_host	iot-06z00ax1o.http.iothub.aliyuncs.com	O endpoint. Se você utilizar uma instância Enterprise Edition ou uma instância pública ativada em 30 de julho de 2021 ou posteriormente, visualize o endpoint na página Instance Details. Clique em View Development Configurations no canto superior direito. O endpoint será exibido no painel Development Configurations. Caso utilize uma instância pública ativada antes de 30 de julho de 2021, o endpoint será `https://iot-as-http.${YourRegionId}.aliyuncs.com`.
product_key	a18wP	As informações de autenticação do dispositivo. Para mais informações, consulte Obter informações de verificação do dispositivo. Neste exemplo, utiliza-se o método de autenticação de certificado único por dispositivo.
device_name	LightSwitch
device_secret	uwMTmVAMnGGHaAkqmeDY6cHxxB

Configure o monitoramento de status.

Especifique os callbacks para monitorar o status.

Código de amostra

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

}

Parâmetros:

Parâmetro	Exemplo	Descrição
AIOT_HTTPOPT_RECV_HANDLER	demo_http_recv_handler	Quando o dispositivo recebe uma mensagem de resposta, este callback é acionado para executar as operações necessárias.
AIOT_HTTPOPT_EVENT_HANDLER	demo_http_event_handler	Caso o token seja alterado, este callback é invocado para garantir a validade do token.

Defina o callback para monitorar o status.

Se houver alteração no token, o sistema chama este callback para executar as operações requeridas.

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

Ao ler uma mensagem de rede, o callback executa as operações necessárias. Neste exemplo, a mensagem é impressa. Ao definir a lógica de processamento, observe os seguintes pontos:

Para obter mais informações sobre os parâmetros de uma mensagem de resposta, consulte Conectar e comunicar via HTTPS.
Uma mensagem recebida contém as seguintes seções: AIOT_HTTPRECV_STATUS_CODE, AIOT_HTTPRECV_HEADER e AIOT_HTTPRECV_BODY. Essas seções indicam, respectivamente, o código de status, o tipo de mensagem e o corpo da mensagem.
Processe os códigos de status conforme suas necessidades de negócio. Para mais detalhes sobre códigos de status, consulte Lista de códigos de status 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;

    }
}

Etapa 3: Estabelecer uma conexão

Utilize a operação aiot_http_auth para enviar uma solicitação de autenticação ao IoT Platform e obter um token. Para saber como especificar os parâmetros, consulte Definir parâmetros de conexão.

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

Etapa 4: Enviar uma mensagem

Invoque a operação aiot_http_send dentro da função demo_http_post_lightswitch para enviar uma mensagem a um tópico específico.

Nota

Neste exemplo, as mensagens enviadas são impressas. Personalize a função demo_http_post_lightswitch de acordo com as necessidades do seu negócio.
É necessário remover os símbolos de comentário de ambos os lados do código de amostra para enviar mensagens ao IoT Platform.

Código de amostra

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

Parâmetros:

Parâmetro

Exemplo

Descrição

data[]

{\"id\":\"1\",\"version\":\"1.0\",\"params\":{\"LightSwitch\":0}}

A mensagem enviada ao IoT Platform.

Como este exemplo utiliza um tópico personalizado, você pode definir livremente o formato da mensagem.

Para mais informações sobre formatos de mensagem, consulte Formatos de dados.

topic

/a1wAf/LightSwitch/user/update

O tópico que possui permissão de publicação (Publish).

a18wP representa o ProductKey do dispositivo.
LightSwitch corresponde ao DeviceName do dispositivo.

Por meio deste tópico, o dispositivo consegue enviar mensagens ao IoT Platform.

Para mais detalhes sobre tópicos, consulte O que é um tópico.

Etapa 5: Receber uma resposta

Após o envio da mensagem, o IoT Platform retorna uma resposta. O dispositivo deve chamar a operação aiot_http_recv para receber os dados de resposta HTTPS e processá-los por meio do callback de evento.

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

Etapa 6: Sair do programa

Execute a operação aiot_http_deinit para destruir a instância do cliente HTTPS e liberar os recursos.

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

    return 0;

Próximos passos

Após configurar o arquivo de código de amostra, compile-o para gerar um arquivo executável. Neste exemplo, gera-se o arquivo executável ./output/http-basic-demo.

Para mais informações, consulte Compilação e execução.
Para obter detalhes sobre os resultados da execução, consulte Logs de operação.