[嵌入式系统-25]：RT-Thread -12- 内核组件编程接口 - 网络组件 - HTTP编程

文火冰糖的硅基工坊2024-02-18 15:08

目录

一、HTTP编程概述

[1.1 概述](#1.1 概述)

[1.2 HTTP 服务器和 HTTP 客户端](#1.2 HTTP 服务器和 HTTP 客户端)

[二、HTTP Client](#二、HTTP Client)

[2.1 如何配置HTTP Client](#2.1 如何配置HTTP Client)

[2.2 HTTP Client代码实例1：socket发送http报文](#2.2 HTTP Client代码实例1：socket发送http报文)

[2.3 HTTP Client代码实例2：httpc_xx接口收发HTTP报文](#2.3 HTTP Client代码实例2：httpc_xx接口收发HTTP报文)

[2.3.1 接口函数描述](#2.3.1 接口函数描述)

[2.3.2 代码实例：httpc_get](#2.3.2 代码实例：httpc_get)

[2.3.3 代码实例：httpc_post](#2.3.3 代码实例：httpc_post)

[2.3.4 代码实例：httpc_put](#2.3.4 代码实例：httpc_put)

[三、HTTP Server](#三、HTTP Server)

[3.1 如何配置HTTP Server](#3.1 如何配置HTTP Server)

[3.2 HTTP Server代码实例](#3.2 HTTP Server代码实例)

一、HTTP编程概述

1.1 概述

RT-Thread 是一个开源的实时操作系统，支持 HTTP 协议的编程。在 RT-Thread 上进行 HTTP 编程可以实现设备与互联网之间的数据通信和远程控制等功能。一般来说，RT-Thread 上进行 HTTP 编程的步骤包括：

  1. 在 RT-Thread 上配置和初始化网络模块，确保设备可以正常连接到网络。
  2. 使用 RT-Thread 提供的相关 API，如 socket API 或者相关网络库，建立 HTTP 连接。
  3. 构建 HTTP 请求报文，包括请求方法、URL、请求头和请求体等信息。
  4. 发送 HTTP 请求并接收服务器返回的响应，处理响应数据。
  5. 根据需求处理服务器返回的数据，执行相应的逻辑操作。
  6. 断开 HTTP 连接，并释放相关资源。

在 RT-Thread 中进行 HTTP 编程需要了解网络编程和 HTTP 协议的相关知识，同时根据具体需求选择合适的网络库或者协议栈进行开发。通过 HTTP 编程，可以实现设备与云平台、服务器之间的数据交互，实现远程控制、数据采集和设备管理等功能。

1.2 HTTP 服务器和 HTTP 客户端

在 RT-Thread 上，你可以同时实现 HTTP 服务器和 HTTP 客户端的功能。

HTTP 服务器：

要在 RT-Thread 上实现 HTTP 服务器，你可以选择使用 RT-Thread 提供的网络库或协议栈（如 lwIP 或 NuttX），并使用相应的 API 进行开发。

  1. 配置和初始化网络模块，确保设备可以正常连接到网络。
  2. 创建并配置 HTTP 服务器实例，指定监听的端口号。
  3. 注册处理 HTTP 请求的回调函数，该函数会在收到客户端的请求时被调用。
  4. 在回调函数中，解析接收到的 HTTP 请求报文，根据请求的 URL、方法等信息确定执行的操作。
  5. 根据具体逻辑处理请求，并构建并发送 HTTP 响应报文给客户端。

HTTP 客户端：

要在 RT-Thread 上实现 HTTP 客户端，你同样可以选择使用 RT-Thread 提供的网络库或协议栈，并使用相应的 API 进行开发。

  1. 配置和初始化网络模块，确保设备可以正常连接到网络。
  2. 创建并配置 HTTP 客户端实例，指定目标服务器的 IP 地址和端口号。
  3. 构建 HTTP 请求报文，包括请求方法、URL、请求头和请求体等信息。
  4. 发送 HTTP 请求给目标服务器，并等待服务器返回的响应。
  5. 解析接收到的 HTTP 响应报文，提取需要的数据。
  6. 根据具体需求处理服务器返回的数据，执行相应的逻辑操作。

无论是 HTTP 服务器还是客户端，你都需要根据具体需求选择合适的网络库或协议栈，并进行相应的配置和开发工作。同时，你需要了解 HTTP 协议的相关知识，以便正确地构建和解析 HTTP 请求和响应报文。

二、HTTP Client

2.1 如何配置HTTP Client

在 RT-Thread 上配置 HTTP 客户端可以使用 RT-Thread 提供的网络库或协议栈，并通过相应的 API 进行配置和开发。下面是一个简单的配置流程：

  1. 确保你的 RT-Thread 配置了正确的网络模块，以便设备可以正常连接到网络。你可以在 RT-Thread 的配置文件中进行相关设置。

  2. 在 RT-Thread 的包管理器中安装相应的 HTTP 客户端软件包。例如，你可以使用 uAgent 或 SCons 具体库。这些库提供了 HTTP 客户端的功能和 API。

  3. 在 RT-Thread 的应用程序中添加相应的头文件包含和编译选项。根据你选择的 HTTP 客户端库，你需要包含相应的头文件，并在编译选项中添加相应的库依赖。

  4. 配置 HTTP 客户端的初始化参数，如目标服务器的 IP 地址和端口号。具体的配置方法和 API 可以根据选择的 HTTP 客户端库而有所不同。可以参考相应的文档或示例代码来进行配置。

  5. 构建 HTTP 请求报文，包括请求方法、URL、请求头和请求体等信息。根据需要设置请求的参数和数据。

  6. 使用 HTTP 客户端库提供的 API 发送 HTTP 请求给目标服务器。例如，你可以使用相应的函数来发送 GET 或 POST 请求，并等待服务器返回的响应。

  7. 解析接收到的 HTTP 响应报文，提取需要的数据。根据具体需求，你可以使用库提供的函数来解析和处理响应。

请注意，在配置和使用 HTTP 客户端时，你需要了解 HTTP 协议的相关知识，并参考相应的库文档和示例代码。这将帮助你正确地配置和使用 HTTP 客户端，在 RT-Thread 上与远程服务器进行数据通信。

2.2 HTTP Client代码实例1：socket发送http报文

下面是一个在 RT-Thread 上使用 HTTP 客户端组件的代码示例，它演示了如何在 RT-Thread 中进行 HTTP 请求。

#include <rtthread.h>
#include <finsh.h>
#include <lwip/sockets.h>
#include <sys/time.h>

#define HTTP_CLIENT_BUFFER_SIZE 1024
#define SERVER_HOST "api.example.com"
#define SERVER_PORT 80
#define HTTP_REQUEST "GET /data HTTP/1.1\r\nHost: api.example.com\r\nConnection: close\r\n\r\n"

static void http_client_thread_entry(void *parameter)
{
    struct sockaddr_in server_addr;
    int client_sock;
    int ret;

    // 创建套接字
    client_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (client_sock < 0)
    {
        rt_kprintf("Failed to create socket\n");
        goto exit;
    }

    // 设置目标服务器地址
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    server_addr.sin_addr.s_addr = inet_addr(SERVER_HOST);

    // 连接到服务器
    ret = connect(client_sock, (struct sockaddr *)&server_addr, sizeof(server_addr));
    if (ret < 0)
    {
        rt_kprintf("Failed to connect to server\n");
        goto exit;
    }

    // 发送 HTTP 请求
    ret = send(client_sock, HTTP_REQUEST, strlen(HTTP_REQUEST), 0);
    if (ret < 0)
    {
        rt_kprintf("Failed to send HTTP request\n");
        goto exit;
    }

    // 接收并打印服务器响应
    char buffer[HTTP_CLIENT_BUFFER_SIZE];
    memset(buffer, 0, sizeof(buffer));
    while (1)
    {
        ret = recv(client_sock, buffer, sizeof(buffer) - 1, 0);
        if (ret <= 0)
        {
            break;
        }

        rt_kprintf("%s", buffer);
        memset(buffer, 0, sizeof(buffer));
    }

exit:
    // 关闭套接字
    if (client_sock >= 0)
    {
        closesocket(client_sock);
    }

    // 删除线程
    if (parameter != RT_NULL)
    {
        rt_thread_delete(parameter);
    }
}

/* 创建 HTTP 客户端线程 */
int http_client_example(void)
{
    rt_thread_t thread;

    thread = rt_thread_create("http_client", http_client_thread_entry, RT_NULL, 2048, 20, 10);
    if (thread != RT_NULL)
    {
        rt_thread_startup(thread);
    }

    return RT_EOK;
}

此示例使用了 socket 函数和相关网络 API，通过创建一个套接字连接到服务器，并发送 HTTP 请求。在 http_client_thread_entry 函数中，我们首先创建一个套接字，然后设置目标服务器的地址并连接到服务器。接下来，我们发送 HTTP 请求并通过调用 recv 函数接收并打印服务器的响应。最后，我们关闭套接字并删除线程。

请注意，在实际使用中，你可能需要根据实际情况修改服务器地址、端口和 HTTP 请求。此示例仅用作参考，具体的请求格式和数据处理可能需要根据服务器的要求进行调整。

同时，如果你要在 RT-Thread 中使用 HTTP 客户端，你也可以考虑使用已经提供的 HTTP 客户端组件，如 Mongoose-Client，它可以更方便地实现 HTTP 请求和响应处理。

2.3 HTTP Client代码实例2：httpc_xx接口收发HTTP报文

2.3.1 接口函数描述

在 RT-Thread 中，HTTP 客户端（httpc）接口提供了一组函数，用于在嵌入式系统中实现 HTTP 客户端功能。通过这些接口，用户可以方便地发送 HTTP 请求并处理服务器的响应。以下是一些常用的 RT-Thread HTTP 客户端接口函数：

  1. httpc_init：初始化 HTTP 客户端模块，可用于初始化 HTTP 客户端数据结构和相关资源。

    int httpc_init(void);

  2. httpc_deinit：释放 HTTP 客户端模块使用的资源，一般在不需要使用 HTTP 客户端时调用。

    void httpc_deinit(void);

  3. httpc_get：发送 HTTP GET 请求，并获取服务器的响应数据。

    int httpc_get(const char *url, struct http_client_data *client_data);

  4. httpc_post：发送 HTTP POST 请求，并获取服务器的响应数据。

    int httpc_post(const char *url, const char *post_data, size_t post_data_len, struct http_client_data *client_data);

  5. httpc_put：发送 HTTP PUT 请求，并获取服务器的响应数据。

    int httpc_put(const char *url, const char *put_data, size_t put_data_len, struct http_client_data *client_data);

  6. httpc_delete：发送 HTTP DELETE 请求，并获取服务器的响应数据。

    int httpc_delete(const char *url, struct http_client_data *client_data);

  7. httpc_set_timeout：设置 HTTP 请求超时时间，单位为毫秒。可以在发送 HTTP 请求之前调用此函数设置超时时间。

    void httpc_set_timeout(unsigned int ms);

这些函数提供了基本的 HTTP 请求功能，可以帮助嵌入式系统与远程服务器进行通信。用户可以根据需要结合实际情况选择合适的函数，并参考 RT-Thread 的文档和示例代码来进行开发。

httpc_post与httpc_put的区别

在 HTTP 协议中，POST 和 PUT 方法都用于向服务器提交数据，但它们在语义和用法上有一些区别：

  1. POST 方法 ：POST 方法用于向服务器提交数据，通常用于创建新资源、提交表单数据或进行数据更新。在 HTTP 请求中，POST 请求对应的数据会被包含在请求体中，而请求的 URI 可以指向处理请求的资源的 URI 或者处理请求的服务器端程序的 URI。POST 请求通常会产生副作用，例如创建、更新或删除资源。POST 请求的主要作用是向服务器提交数据。

  2. PUT 方法 ：PUT 方法用于向服务器上传指定的资源，通常用于更新或创建资源。在 HTTP 请求中，PUT 请求也会将数据包含在请求体中，但请求的 URI 应该是指向目标资源的 URI。PUT 请求被认为是幂等的，即多次相同的 PUT 请求对资源的状态不会产生变化，也就是说重复执行 PUT 请求不会对资源产生额外的影响。PUT 请求的主要作用是传输数据以更新服务器上的资源。

总结来说，POST 方法主要用于提交数据并触发服务器的特定动作，而 PUT 方法主要用于传输数据以更新或创建资源，并且 PUT 请求应该是幂等的。

在使用 RT-Thread 中的 HTTP 客户端（例如 httpc）时，你可以根据需求选择使用 POST 方法或 PUT 方法来向服务器发送数据。根据 HTTP 协议的语义，合理地选择 POST 或 PUT 方法可以更好地符合实际需求。

下面是 HTTP POST 方法和 HTTP PUT 方法的进一步比较：

  1. 语义差异：POST 方法通常用于向服务器提交数据，涉及创建新资源、提交表单数据或进行数据更新。而 PUT 方法主要用于传输数据以更新或创建资源。

  2. URI 的处理：在 POST 请求中，URI 可以指向处理请求的资源的 URI 或者处理请求的服务器端程序的 URI。而在 PUT 请求中，URI 应该指向目标资源的 URI。

  3. 副作用：POST 请求通常会产生副作用，例如创建、更新或删除资源。而 PUT 请求被认为是幂等的，即多次相同的 PUT 请求对资源的状态不会产生变化。

  4. 请求体的类型 ：POST 和 PUT 请求都可以在请求体中携带数据，但它们的用途略有不同。POST 请求的主要作用是向服务器提交数据，请求体通常包含表单数据、JSON 数据等。PUT 请求的主要作用是传输数据以更新服务器上的资源，请求体通常包含要更新的数据。

  5. 重复提交 ：根据 HTTP 协议的设计，多次提交相同的 POST 请求会产生多个资源实例，而多次提交相同的 PUT 请求不会产生额外的影响，资源的状态保持一致。

在使用 HTTP 客户端库进行开发时（如 RT-Thread 中的 httpc），你需要根据具体需求选择使用 POST 方法还是 PUT 方法。如果需要提交数据并触发服务器的特定动作，可以选择使用 POST 方法。如果需要传输数据以更新或创建资源，并且期望请求是幂等的，可以使用 PUT 方法。

2.3.2 代码实例：httpc_get

下面是一个使用 RT-Thread httpc 接口的简单示例代码，用于发送 HTTP GET 请求并打印服务器响应的状态码和响应体：

#include <rtthread.h>
#include <httpclient.h>

void httpc_get_example(void)
{
    const char *url = "http://httpbin.org/get";
    struct httpclient_data client;
    int ret;

    rt_memset(&client, 0, sizeof(client));

    ret = httpc_get(url, &client);

    if (ret == 0)
    {
        rt_kprintf("HTTP GET Status: %d\n", client.response_code);
        if (client.data_len > 0)
        {
            rt_kprintf("Response Body: %.*s\n", client.data_len, client.data);
        }
    }
    else
    {
        rt_kprintf("HTTP GET request failed\n");
    }
}

int httpc_example(void)
{
    httpc_get_example();
    return 0;
}

MSH_CMD_EXPORT(httpc_example, send http GET request);

在这个示例代码中，我们定义了一个 httpc_get_example 函数，该函数用于发送 HTTP GET 请求并处理服务器的响应。在 httpc_get_example 函数中，我们首先定义了一个目标 URL，然后通过调用 httpc_get 函数发送 HTTP GET 请求，并将响应数据保存在 struct httpclient_data 结构体中。接下来，我们检查返回值，如果请求成功，则打印服务器的状态码和响应体内容。

在 httpc_example 函数中，我们直接调用 httpc_get_example 函数执行示例代码。

使用示例代码时，请根据实际情况修改目标 URL，并按照 RT-Thread 的编译、配置和运行流程进行操作。

2.3.3 代码实例：httpc_post

下面是一个使用 RT-Thread httpc 接口的简单示例代码，用于发送 HTTP POST 请求并打印服务器响应的状态码和响应体：

#include <rtthread.h>
#include <httpclient.h>

void httpc_post_example(void)
{
    const char *url = "http://httpbin.org/post";
    const char *content_type = "application/json";
    const char *body = "{\"key\": \"value\"}";
    struct httpclient_data client;
    int ret;

    rt_memset(&client, 0, sizeof(client));

    ret = httpc_request(url, HTTPCLIENT_POST, content_type, body, rt_strlen(body), &client);

    if (ret == 0)
    {
        rt_kprintf("HTTP POST Status: %d\n", client.response_code);
        if (client.data_len > 0)
        {
            rt_kprintf("Response Body: %.*s\n", client.data_len, client.data);
        }
    }
    else
    {
        rt_kprintf("HTTP POST request failed\n");
    }
}

int httpc_example(void)
{
    httpc_post_example();
    return 0;
}

MSH_CMD_EXPORT(httpc_example, send http POST request);

在这个示例代码中，我们定义了一个 httpc_post_example 函数，该函数用于发送 HTTP POST 请求并处理服务器的响应。在 httpc_post_example 函数中，我们首先定义了目标 URL、Content-Type（内容类型）和请求体（body）。然后通过调用 httpc_request 函数发送 HTTP POST 请求，并将响应数据保存在 struct httpclient_data 结构体中。接下来，我们检查返回值，如果请求成功，则打印服务器的状态码和响应体内容。

在 httpc_example 函数中，我们直接调用 httpc_post_example 函数执行示例代码。

使用示例代码时，请根据实际情况修改目标 URL、Content-Type 和请求体，并按照 RT-Thread 的编译、配置和运行流程进行操作。

2.3.4 代码实例：httpc_put

下面是一个使用 RT-Thread httpc 接口的简单示例代码，用于发送 HTTP PUT 请求并打印服务器响应的状态码和响应体：

#include <rtthread.h>
#include <httpclient.h>

void httpc_put_example(void)
{
    const char *url = "http://httpbin.org/put";
    const char *content_type = "text/plain";
    const char *body = "This is the PUT request body";
    struct httpclient_data client;
    int ret;

    rt_memset(&client, 0, sizeof(client));

    ret = httpc_request(url, HTTPCLIENT_PUT, content_type, body, rt_strlen(body), &client);

    if (ret == 0)
    {
        rt_kprintf("HTTP PUT Status: %d\n", client.response_code);
        if (client.data_len > 0)
        {
            rt_kprintf("Response Body: %.*s\n", client.data_len, client.data);
        }
    }
    else
    {
        rt_kprintf("HTTP PUT request failed\n");
    }
}

int httpc_example(void)
{
    httpc_put_example();
    return 0;
}

MSH_CMD_EXPORT(httpc_example, send http PUT request);

在这个示例代码中，我们定义了一个 httpc_put_example 函数，该函数用于发送 HTTP PUT 请求并处理服务器的响应。与之前的示例类似，我们定义了目标 URL、Content-Type 和请求体，并通过调用 httpc_request 函数发送 HTTP PUT 请求。接着，我们检查返回值，如果请求成功，则打印服务器的状态码和响应体内容。

在 httpc_example 函数中，我们直接调用 httpc_put_example 函数执行示例代码。

请记得根据实际情况修改目标 URL、Content-Type 和请求体，并按照 RT-Thread 的编译、配置和运行流程进行操作。

三、HTTP Server

3.1 如何配置HTTP Server

配置 RT-Thread 的 HTTP 服务器需要进行一些步骤，以下是简要的配置过程：

  1. 首先，在 RT-Thread 的包管理器中选择并添加 HTTP 服务器组件 。你可以在包管理器中搜索相应的组件，例如 Mongoose 或者 LwIP。

  2. 配置网络相关的设置，确保网络正常连接，可以使用 LwIP 或者其他支持的网络协议栈，并根据实际情况进行配置。

  3. 在 RT-Thread 的环境配置文件（rtconfig.h）中启用 HTTP 服务器相关的宏定义，一般情况下会有对应的宏定义用于启用 HTTP 服务器功能。

  4. 根据具体的 HTTP 服务器组件，进行相应的初始化工作。通常需要在应用程序或者系统初始化阶段调用相应的初始化函数完成 HTTP 服务器的启动。

  5. 配置 HTTP 服务器的参数，如监听端口、默认页面、虚拟路径映射等。具体配置方式会根据选择的 HTTP 服务器组件而有所不同。

  6. 编写处理 HTTP 请求的回调函数或者页面处理逻辑，根据业务需求进行相应的处理和响应。

  7. 最后，编译整个 RT-Thread 项目并烧录到目标设备中，启动系统后 HTTP 服务器将会运行并监听指定端口，可以通过浏览器等工具进行访问和测试。

注意：以上步骤仅供参考，具体操作可能会因为使用的 HTTP 服务器组件而有所差异，建议查阅相应的文档和示例代码进行详细配置。

3.2 HTTP Server代码实例

以下是一个简单的示例代码，演示了如何在 RT-Thread 中使用 Mongoose HTTP 服务器组件创建一个简单的 HTTP 服务器：

#include <rtthread.h>
#include <mongoose.h>

static struct mg_mgr mgr;

static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
    if (ev == MG_EV_HTTP_REQUEST) {
        struct http_message *hm = (struct http_message *) ev_data;
        mg_printf(nc, "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nHello from RT-Thread!\r\n");
        nc->flags |= MG_F_SEND_AND_CLOSE;
    }
}

static void http_server_thread_entry(void *parameter) {
    struct mg_connection *nc;

    mg_mgr_init(&mgr, NULL);
    nc = mg_bind(&mgr, "8080", ev_handler);
    mg_set_protocol_http_websocket(nc);

    while (1) {
        mg_mgr_poll(&mgr, 1000);
    }
}

int http_server_init(void) {
    rt_thread_t thread;

    thread = rt_thread_create("http_server",
                               http_server_thread_entry, RT_NULL,
                               2048, 25, 10);
    if (thread != RT_NULL) {
        rt_thread_startup(thread);
        return 0;
    }
    
    return -1;
}

INIT_APP_EXPORT(http_server_init);

在这个示例中，我们使用了 Mongoose 库来创建一个简单的 HTTP 服务器，当接收到 HTTP 请求时，服务器会返回一个包含 "Hello from RT-Thread!" 的简单文本响应。在 http_server_init() 函数中创建了一个线程来运行 HTTP 服务器，并在初始化过程中注册了路由处理函数 ev_handler。

需要注意的是，上述代码仅供参考，实际使用时需要根据具体需求进行适当的修改和调整。另外，确保在 RT-Thread 的环境中正确添加了 Mongoose HTTP 服务器组件，并进行了相应的配置。

相关推荐
feng_xiaoshi33 分钟前
【云原生】云原生架构的反模式
云原生·架构
玄奕子33 分钟前
GPT对话知识库——在STM32的平台下，通过SPI读取和写入Flash的步骤。
stm32·单片机·gpt·嵌入式·嵌入式驱动
读心悦42 分钟前
如何在 Axios 中封装事件中心EventEmitter
javascript·http
小白爱电脑44 分钟前
WIFI网速不够是不是光猫的“路由模式”和“桥接模式”配置错了？
网络·智能路由器·桥接模式
CXDNW2 小时前
【网络篇】计算机网络——应用层详述（笔记）
服务器·笔记·计算机网络·http·web·cdn·dns
卑微求AC2 小时前
(C语言贪吃蛇)16.贪吃蛇食物位置随机(完结撒花)
linux·c语言·开发语言·嵌入式·c语言贪吃蛇
qxqxa2 小时前
cfg80211是怎么配置无线设备的AP的？
网络·驱动开发
架构师吕师傅2 小时前
性能优化实战（三）：缓存为王-面向缓存的设计
后端·微服务·架构
秋夫人3 小时前
http cache-control
网络·网络协议·http
叶北辰CHINA4 小时前
nginx反向代理，负载均衡，HTTP配置简述（说人话）
linux·运维·nginx·http·云原生·https·负载均衡
热门推荐
01组基轨迹建模 GBTM的介绍与实现（Stata 或 R）02【经验分享】Ubuntu22.04安装微信(linux官方版)032024年高教社杯数学建模国赛C题超详细解题思路分析04分享几个惊艳的 Three.js 个人站点05安卓系列机型永久去除data分区加密 详细步骤解析06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07springer 在线投稿编译踩坑08Ubuntu24.04安装中文输入法09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CTF网络安全大赛简单的web抓包题目：HEADache