devbox
Li_阴宅
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

ESP32 的esp_http_client详解

作者：Li_阴宅 | 2024-07-24 17:24:25

赞

踩

ESP32 的esp_http_client详解

说明：我使用的是esp-idf-V3.1.3 ，官方给我们封装好了 HTTP，使用起来还是很方便

一、wifi连接

在main函数里面主要是做了wifi连接的初始化和HTTP任务的创建，如下是main的全部内容
 

  1. void app_main()
  2. {
  3.     esp_err_t ret = nvs_flash_init();
  4.     if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
  5.       ESP_ERROR_CHECK(nvs_flash_erase());
  6.       ret = nvs_flash_init();
  7.     }
  8.     ESP_ERROR_CHECK(ret);
  9.     app_wifi_initialise();   //wifi连接部分
  10.  
  11.     xTaskCreate(&http_test_task, "http_test_task", 8192*2, NULL, 5, NULL);//创建HTTP任务
  12. }

进入wifi初始化函数app_wifi_initialise(void)，里面主要是设置连接的wifi，及启动wifi连接。

  1. void app_wifi_initialise(void)
  2. {
  3.     tcpip_adapter_init();//tcp协议初始化
  4.     wifi_event_group = xEventGroupCreate();//创建一个事件组
  5.     ESP_ERROR_CHECK(esp_event_loop_init(event_handler, NULL));//wifi 事件
  6.     wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
  7.     ESP_ERROR_CHECK(esp_wifi_init(&cfg));
  8.     ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
  9.     wifi_config_t wifi_config = {
  10.         .sta = {
  11.             .ssid = "TPLINK",
  12.             .password = "12345678",//设置要连接的wifi
  13.         },
  14.     };
  15.     ESP_LOGI(TAG, "Setting WiFi configuration SSID %s...", wifi_config.sta.ssid);
  16.     ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));//设置模式
  17.     ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));//设置连接wifi的参数
  18.     ESP_ERROR_CHECK(esp_wifi_start());//启动wifi
  19.  
  20. }

启动wifi之后就会产生一个SYSTEM_EVENT_STA_START事件，在里面开始连接wifi，连接成功之后就会产生一个事件给创建的HTTP, http是一直在等待wifi连接成功才往下执行，具体可以看下代码

  1. static esp_err_t event_handler(void *ctx, system_event_t *event)
  2. {
  3.     switch (event->event_id) {
  4.         case SYSTEM_EVENT_STA_START:
  5.             esp_wifi_connect();
  6.             break;
  7.         case SYSTEM_EVENT_STA_GOT_IP:
  8.             xEventGroupSetBits(wifi_event_group, CONNECTED_BIT);
  9.             break;
  10.         case SYSTEM_EVENT_STA_DISCONNECTED:
  11.             /* This is a workaround as ESP32 WiFi libs don't currently
  12.                auto-reassociate. */
  13.             esp_wifi_connect();
  14.             xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);
  15.             break;
  16.         default:
  17.             break;
  18.     }
  19.     return ESP_OK;
  20. }

二、HTTP 任务解析

1、http任务里面我就保留了一个http_rest();，为了自己看调试数据方便

  1. static void http_test_task(void *pvParameters)
  2. {
  3.     app_wifi_wait_connected();
  4.     ESP_LOGI(TAG, "Connected to AP, begin http example");
  5.     http_rest();
  6.     /* http_auth_basic();
  7.     http_auth_basic_redirect();
  8.     http_auth_digest();
  9.     http_relative_redirect();
  10.     http_absolute_redirect();
  11.     https();
  12.     http_redirect_to_https();
  13.     http_download_chunk();
  14.     http_perform_as_stream_reader();
  15.     ESP_LOGI(TAG, "Finish http example");*/
  16.     vTaskDelete(NULL);
  17. }

2、http_rest函数，里面我只保留了POST ,而且做了修改连接到自己的服务器，代码如下

  1. static void http_rest()
  2. {
  3.    esp_http_client_config_t config = {
  4.         .url = "http://wjabc.wjabc.top",
  5.  
  6.         .event_handler = _http_event_handler,
  7.     };
  8.     esp_http_client_handle_t client = esp_http_client_init(&config);
  9.  
  10.     char post_data1[1024] = {0};
  11.  
  12.     Get_CurrentData(post_data1);//得到JSON数据 用如 post_data
  13.  
  14.     esp_http_client_set_url(client, "http://wjabc.wjabc.top/m/userAction!connect");
  15. //  esp_http_client_set_url(client, "http://wjabc.wjabc.top/m/userAction!deviceSave");
  16.     esp_http_client_set_method(client, HTTP_METHOD_POST);
  17.     esp_http_client_set_post_field(client, post_data1, strlen(post_data1));
  18.     esp_err_t err  = esp_http_client_perform(client);
  19.     if (err == ESP_OK) {
  20.         ESP_LOGI(TAG, "HTTP POST Status = %d, content_length = %d",
  21.                 esp_http_client_get_status_code(client),
  22.                 esp_http_client_get_content_length(client));
  23.         int len =  esp_http_client_get_content_length(client);
  24.         int read_len = 0;
  25.         char buf[1024] = {0};
  26.         read_len = esp_http_client_read(client, buf, len);
  27.         printf("\nrecv data len:%d %d %s\n",read_len,len,buf);
  28.     } else {
  29.         ESP_LOGE(TAG, "HTTP POST request failed: %s", esp_err_to_name(err));
  30.     }
  31. }

这里是esp32 HTTP client 主要部分，下面详细讲解这里，因为我也是小白，写的不好或者不对的地方，还希望大家指出来

1、 esp_http_client_config_t 结构，这里主要是初始化了 URL 和http的一个事件

 esp_http_client_config_t config = {
        .url = "http://wjabc.wjabc.top",

        .event_handler = _http_event_handler,
    };

2、esp_http_client_handle_t client = esp_http_client_init(&config)函数，

作用：分配空间，初始化等

进入函数里面看看函数的全部

  1. esp_http_client_handle_t esp_http_client_init(const esp_http_client_config_t *config)
  2. {
  3.  
  4.     esp_http_client_handle_t client;
  5.     transport_handle_t tcp;
  6.     bool _success;
  7.     //第一部分分配空间
  8.     _success = (
  9.                    (client                         = calloc(1, sizeof(esp_http_client_t)))           &&
  10.                    (client->parser                 = calloc(1, sizeof(struct http_parser)))          &&
  11.                    (client->parser_settings        = calloc(1, sizeof(struct http_parser_settings))) &&
  12.                    (client->auth_data              = calloc(1, sizeof(esp_http_auth_data_t)))        &&
  13.                    (client->request                = calloc(1, sizeof(esp_http_data_t)))             &&
  14.                    (client->request->headers       = http_header_init())                             &&
  15.                    (client->request->buffer        = calloc(1, sizeof(esp_http_buffer_t)))           &&
  16.                    (client->response               = calloc(1, sizeof(esp_http_data_t)))             &&
  17.                    (client->response->headers      = http_header_init())                             &&
  18.                    (client->response->buffer       = calloc(1, sizeof(esp_http_buffer_t)))
  19.                );
  20.  
  21.     if (!_success) {
  22.         ESP_LOGE(TAG, "Error allocate memory");
  23.         esp_http_client_cleanup(client);
  24.         return NULL;
  25.     }
  26.      //第二部分
  27.     _success = (
  28.                    (client->transport_list = transport_list_init()) && //分配空间
  29.                    (tcp = transport_tcp_init()) && //分配TCP空间及初始化TCP 函数
  30.                    (transport_set_default_port(tcp, DEFAULT_HTTP_PORT) == ESP_OK) &&//设置默认端口为80
  31.                    (transport_list_add(client->transport_list, tcp, "http") == ESP_OK)//设置默认协议为http
  32.                );
  33.     if (!_success) {
  34.         ESP_LOGE(TAG, "Error initialize transport");
  35.         esp_http_client_cleanup(client);
  36.         return NULL;
  37.     }
  38.  
  39.  
  40.     if (_set_config(client, config) != ESP_OK) {
  41.         ESP_LOGE(TAG, "Error set configurations");
  42.         esp_http_client_cleanup(client);
  43.         return NULL;
  44.     }
  45.     //第三部分 给请求和应答数据分配空间
  46.     _success = (
  47.                    (client->request->buffer->data  = malloc(client->buffer_size))  &&
  48.                    (client->response->buffer->data = malloc(client->buffer_size))
  49.                );
  50.  
  51.     if (!_success) {
  52.         ESP_LOGE(TAG, "Allocation failed");
  53.         esp_http_client_cleanup(client);
  54.         return NULL;
  55.     }
  56.     //第四部分 设置url和用户代理 host
  57.     _success = (
  58.                    (esp_http_client_set_url(client, config->url) == ESP_OK) &&
  59.                    (esp_http_client_set_header(client, "User-Agent", DEFAULT_HTTP_USER_AGENT) == ESP_OK) &&
  60.                    (esp_http_client_set_header(client, "Host", client->connection_info.host) == ESP_OK)
  61.                );
  62.  
  63.     if (!_success) {
  64.         ESP_LOGE(TAG, "Error set default configurations");
  65.         esp_http_client_cleanup(client);
  66.         return NULL;
  67.     }
  68.     //第五部分设置各种函数指针的值
  69.     client->parser_settings->on_message_begin = http_on_message_begin;
  70.     client->parser_settings->on_url = http_on_url;
  71.     client->parser_settings->on_status = http_on_status;
  72.     client->parser_settings->on_header_field = http_on_header_field;
  73.     client->parser_settings->on_header_value = http_on_header_value;
  74.     client->parser_settings->on_headers_complete = http_on_headers_complete;
  75.     client->parser_settings->on_body = http_on_body;
  76.     client->parser_settings->on_message_complete = http_on_message_complete;
  77.     client->parser_settings->on_chunk_complete = http_on_chunk_complete;
  78.     client->parser->data = client;
  79.     client->event.client = client;
  80.  
  81.     client->state = HTTP_STATE_INIT;
  82.     return client;
  83. }

这个里面主要重点介绍下第二部分的transport_tcp_init()函数

 

  1. transport_handle_t transport_tcp_init()
  2. {
  3.     transport_handle_t t = transport_init();
  4.     transport_tcp_t *tcp = calloc(1, sizeof(transport_tcp_t));
  5.     HTTP_MEM_CHECK(TAG, tcp, return NULL);
  6.     tcp->sock = -1;
  7.     transport_set_func(t, tcp_connect, tcp_read, tcp_write, tcp_close, tcp_poll_read, tcp_poll_write, tcp_destroy);
  8.     transport_set_context_data(t, tcp);
  9.  
  10.     return t;
  11. }

这个函数里面可以分成两部分

a、给TCP分配空间

b、设置TCP的回调函数

 tcp_connect, tcp_read, tcp_write, tcp_close, tcp_poll_read, tcp_poll_write, tcp_destroy

 tcp_connect函数,这个函数可以分成4部分

a、resolve_dns(host, &remote_ip)                                     域名解析到IP

b、tcp->sock = socket(PF_INET, SOCK_STREAM, 0);   创建socket套接字

c、setsockopt(tcp->sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); 设置接收数据超时时间

d、connect(tcp->sock, (struct sockaddr *)(&remote_ip), sizeof(struct sockaddr)) != 0 连接TCP到服务器

  1.  
  2. static int tcp_connect(transport_handle_t t, const char *host, int port, int timeout_ms)
  3. {
  4.     struct sockaddr_in remote_ip;
  5.     struct timeval tv;
  6.     transport_tcp_t *tcp = transport_get_context_data(t);
  7.  
  8.     bzero(&remote_ip, sizeof(struct sockaddr_in));
  9.  
  10.     //if stream_host is not ip address, resolve it AF_INET,servername,&serveraddr.sin_addr
  11.     if (inet_pton(AF_INET, host, &remote_ip.sin_addr) != 1) {
  12.         if (resolve_dns(host, &remote_ip) < 0) {//域名解析
  13.             return -1;
  14.         }
  15.     }
  16.  
  17.     tcp->sock = socket(PF_INET, SOCK_STREAM, 0);//创建socket 
  18.  
  19.     if (tcp->sock < 0) {
  20.         ESP_LOGE(TAG, "Error create socket");
  21.         return -1;
  22.     }
  23.  
  24.     remote_ip.sin_family = AF_INET;
  25.     remote_ip.sin_port = htons(port);
  26.  
  27.     http_utils_ms_to_timeval(timeout_ms, &tv);
  28.  
  29.     setsockopt(tcp->sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));//设置接收超时
  30.  
  31.     ESP_LOGD(TAG, "[sock=%d],connecting to server IP:%s,Port:%d...",
  32.              tcp->sock, ipaddr_ntoa((const ip_addr_t*)&remote_ip.sin_addr.s_addr), port);
  33.     //连接TCP
  34.     if (connect(tcp->sock, (struct sockaddr *)(&remote_ip), sizeof(struct sockaddr)) != 0) {
  35.         close(tcp->sock);
  36.         tcp->sock = -1;
  37.         return -1;
  38.     }
  39.     return tcp->sock;
  40. }

剩下的几个大家自己看下源码，就不介绍了

3、Get_CurrentData(post_data1); 这个是我自己写的，里面就是打包json数据，esp32自带cJSON,直接使用就可以，详细代码

void Get_CurrentData(char *dat){
    cJSON *root;

    root = cJSON_CreateObject();
    cJSON_AddStringToObject(root,"HardwareVersion","V1.0");
    cJSON_AddStringToObject(root,"SoftwareVersion","V1.0");
    cJSON_AddStringToObject(root,"OnlyID","112233445566");
    cJSON_AddStringToObject(root,"Status","true");
    char *out = cJSON_Print(root);
    memcpy(dat,out,strlen(out));
    cJSON_Delete(root);
    free(out);
}

4、esp_http_client_set_url(client, "http://wjabc.wjabc.top/m/userAction!connect"); 函数，这个函数主要是解析url ,然后得到各个字段，下面是这里详细介绍了URL的组成

URL详解

　　URL(Uniform Resource Locator) 地址用于描述一个网络上的资源， 基本格式如下

schema://host[:port#]/path/.../[;url-params][?query-string][#anchor]

　　scheme 指定低层使用的协议(例如：http, https, ftp)

　　host HTTP服务器的IP地址或者域名

　　port# HTTP服务器的默认端口是80，这种情况下端口号可以省略。如果使用了别的端口，必须指明，例如 http://www.cnblogs.com:8080/

　　path 访问资源的路径

　　url-params

　　query-string 发送给http服务器的数据

　　anchor- 锚

　　URL 的一个例子

http://www.mywebsite.com/sj/test;id=8079?name=sviergn&x=true#stuff

Schema: http

host: www.mywebsite.com

path: /sj/test

URL params: id=8079

Query String: name=sviergn&x=true

Anchor: stuff

  1. esp_err_t esp_http_client_set_url(esp_http_client_handle_t client, const char *url)
  2. {
  3.     char *old_host = NULL;
  4.     struct http_parser_url purl;
  5.     int old_port;
  6.  
  7.     if (client == NULL || url == NULL) {
  8.         ESP_LOGE(TAG, "client or url must not NULL");
  9.         return ESP_ERR_INVALID_ARG;
  10.     }
  11.  
  12.     http_parser_url_init(&purl);
  13.     printf("----------------------http_client_set_url--------------------------\n");
  14.     int parser_status = http_parser_parse_url(url, strlen(url), 0, &purl);
  15.  
  16.     if (parser_status != 0) {
  17.         ESP_LOGE(TAG, "Error parse url %s", url);
  18.         return ESP_ERR_INVALID_ARG;
  19.     }
  20.     old_host = client->connection_info.host;
  21.     old_port = client->connection_info.port;
  22.     if(old_host != old_host){
  23.     	printf("old_host:%s\n",old_host);
  24.     }else{
  25.     	printf("old_host:%s\n","NULL");
  26.     }
  27.  
  28.     printf("old_port:%d\n",old_port);
  29.     if (purl.field_data[UF_HOST].len) {
  30.         http_utils_assign_string(&client->connection_info.host, url + purl.field_data[UF_HOST].off, purl.field_data[UF_HOST].len);
  31.         HTTP_MEM_CHECK(TAG, client->connection_info.host, return ESP_ERR_NO_MEM);
  32.     }
  33.     printf("host:%s\n",client->connection_info.host);
  34.     // Close the connection if host was changed
  35.     if (old_host && client->connection_info.host
  36.             && strcasecmp(old_host, (const void *)client->connection_info.host) != 0) {
  37.         ESP_LOGD(TAG, "New host assign = %s", client->connection_info.host);
  38.         if (esp_http_client_set_header(client, "Host", client->connection_info.host) != ESP_OK) {
  39.             return ESP_ERR_NO_MEM;
  40.         }
  41.         esp_http_client_close(client);
  42.     }
  43.     printf("host:%s\n",client->connection_info.host);
  44.     if (purl.field_data[UF_SCHEMA].len) {
  45.         http_utils_assign_string(&client->connection_info.scheme, url + purl.field_data[UF_SCHEMA].off, purl.field_data[UF_SCHEMA].len);
  46.         HTTP_MEM_CHECK(TAG, client->connection_info.scheme, return ESP_ERR_NO_MEM);
  47.  
  48.         if (strcasecmp(client->connection_info.scheme, "http") == 0) {
  49.             client->connection_info.port = DEFAULT_HTTP_PORT;
  50.         } else if (strcasecmp(client->connection_info.scheme, "https") == 0) {
  51.             client->connection_info.port = DEFAULT_HTTPS_PORT;
  52.         }
  53.     }
  54.     printf("scheme:%s\n",client->connection_info.scheme);
  55.     printf("port:%d\n",client->connection_info.port);
  56.     if (purl.field_data[UF_PORT].len) {
  57.         client->connection_info.port = strtol((const char*)(url + purl.field_data[UF_PORT].off), NULL, 10);
  58.     }
  59.  
  60.     if (old_port != client->connection_info.port) {
  61.         esp_http_client_close(client);
  62.     }
  63.  
  64.     if (purl.field_data[UF_USERINFO].len) {
  65.         char *user_info = NULL;
  66.         http_utils_assign_string(&user_info, url + purl.field_data[UF_USERINFO].off, purl.field_data[UF_USERINFO].len);
  67.         if (user_info) {
  68.             char *username = user_info;
  69.             char *password = strchr(user_info, ':');
  70.             if (password) {
  71.                 *password = 0;
  72.                 password ++;
  73.                 http_utils_assign_string(&client->connection_info.password, password, 0);
  74.                 HTTP_MEM_CHECK(TAG, client->connection_info.password, return ESP_ERR_NO_MEM);
  75.             }
  76.             http_utils_assign_string(&client->connection_info.username, username, 0);
  77.             HTTP_MEM_CHECK(TAG, client->connection_info.username, return ESP_ERR_NO_MEM);
  78.             free(user_info);
  79.         } else {
  80.             return ESP_ERR_NO_MEM;
  81.         }
  82.     } else {
  83.         free(client->connection_info.username);
  84.         free(client->connection_info.password);
  85.         client->connection_info.username = NULL;
  86.         client->connection_info.password = NULL;
  87.     }
  88.     if(client->connection_info.username != NULL){
  89.     	printf("username:%s\n",client->connection_info.username);
  90.     }else{
  91.     	printf("username:%s\n","NULL");
  92.     }
  93.     if(client->connection_info.password != NULL){
  94.     	printf("password:%s\n",client->connection_info.password);
  95.     }else{
  96.     	printf("password:%s\n","NULL");
  97.     }
  98.  
  99.     //Reset path and query if there are no information
  100.     if (purl.field_data[UF_PATH].len) {
  101.         http_utils_assign_string(&client->connection_info.path, url + purl.field_data[UF_PATH].off, purl.field_data[UF_PATH].len);
  102.     } else {
  103.         http_utils_assign_string(&client->connection_info.path, "/", 0);
  104.     }
  105.     printf("path:%s\n",client->connection_info.path);
  106.     HTTP_MEM_CHECK(TAG, client->connection_info.path, return ESP_ERR_NO_MEM);
  107.  
  108.     if (purl.field_data[UF_QUERY].len) {
  109.         http_utils_assign_string(&client->connection_info.query, url + purl.field_data[UF_QUERY].off, purl.field_data[UF_QUERY].len);
  110.         HTTP_MEM_CHECK(TAG, client->connection_info.query, return ESP_ERR_NO_MEM);
  111.     } else if (client->connection_info.query) {
  112.         free(client->connection_info.query);
  113.         client->connection_info.query = NULL;
  114.     }
  115.     if(client->connection_info.query != NULL){
  116.     	printf("query:%s\n",client->connection_info.query);
  117.     }else{
  118.     	printf("query:%s\n","NULL");
  119.     }
  120.  
  121.     return ESP_OK;
  122. }

esp_http_client_set_url 源码比较多，大家自己仔细看看，我用url = http://wjabc.wjabc.top/m/userAction!connect 作为参数

解析得到的数据：

old_host:NULL
old_port:80
host:wjabc.wjabc.top
host:wjabc.wjabc.top
scheme:http
port:80
username:NULL
password:NULL
path:/m/userAction!connect
query:NULL

这些数据都是赋值给了connection_info_t结构体的成员

typedef struct {
    char                         *url;
    char                         *scheme;
    char                         *host;
    int                          port;
    char                         *username;
    char                         *password;
    char                         *path;
    char                         *query;
    char                         *cert_pem;
    esp_http_client_method_t     method;
    esp_http_client_auth_type_t  auth_type;
    esp_http_client_transport_t  transport_type;
    int                          max_store_header_size;
} connection_info_t;

5、esp_http_client_set_method(client, HTTP_METHOD_POST);函数，这个函数就比较简单了

作用：设置请求方式为POST

esp_err_t esp_http_client_set_method(esp_http_client_handle_t client, esp_http_client_method_t method)
{
    client->connection_info.method = method;
    return ESP_OK;
}

可以看到 也是给上面的结构体复制，

6、esp_http_client_set_post_field(client, post_data1, strlen(post_data1));函数，

作用：设置url,解析参数

  1. esp_err_t esp_http_client_set_post_field(esp_http_client_handle_t client, const char *data, int len)
  2. {
  3.     esp_err_t err = ESP_OK;
  4.     client->post_data = (char *)data;
  5.     client->post_len = len;
  6.     ESP_LOGD(TAG, "set post file length = %d", len);
  7.     if (client->post_data) {
  8.     	err = esp_http_client_set_header(client, "Content-Type", "application/json");
  9.        // err = esp_http_client_set_header(client, "Content-Type", "application/x-www-form-urlencoded");
  10.     } else {
  11.         client->post_len = 0;
  12.         err = esp_http_client_set_header(client, "Content-Type", NULL);
  13.     }
  14.     return err;
  15. }

这个函数首先设置了HTTP请求的数据body，这个数据是第二步得到的JSON数据，然后下面设置了Content-Type内容编码，我们这里是cJSON，所以设置为application/json，注释掉原来的了。

7、esp_http_client_perform(client); 这个函数是重点，完成TCP发送和接收，主要说下三个部分

  1. esp_err_t esp_http_client_perform(esp_http_client_handle_t client)
  2. {
  3.     esp_err_t err;
  4.     do {  //第一部分
  5.         if ((err = esp_http_client_open(client, client->post_len)) != ESP_OK) {
  6.             return err;
  7.         }
  8.         if (client->post_data && client->post_len) {
  9.         	printf("\r\nclient_open post_data len:%d %s\r\n\n",client->post_len,client->post_data);
  10. //第二部分
  11.             if (esp_http_client_write(client, client->post_data, client->post_len) <= 0) {
  12.                 ESP_LOGE(TAG, "Error upload data");
  13.                 return ESP_ERR_HTTP_WRITE_DATA;
  14.             }
  15.         }
  16. 第三大部分
  17.         int lenth = esp_http_client_fetch_headers(client);
  18.         if (lenth < 0) {
  19.             return ESP_ERR_HTTP_FETCH_HEADER;
  20.         }
  21.         printf("\n 12recv Data len:%d %s\n\n",client->response->buffer->len,client->response->buffer->data);
  22.  
  23.         if ((err = esp_http_check_response(client)) != ESP_OK) {
  24.             ESP_LOGE(TAG, "Error response");
  25.             return err;
  26.         }
  27.         while (client->response->is_chunked && !client->is_chunk_complete) {
  28.             if (esp_http_client_get_data(client) <= 0) {
  29.                 ESP_LOGD(TAG, "Read finish or server requests close");
  30.                 break;
  31.             }
  32.         }
  33.         while (client->response->data_process < client->response->content_length) {
  34.             if (esp_http_client_get_data(client) <= 0) {
  35.                 ESP_LOGD(TAG, "Read finish or server requests close");
  36.                 break;
  37.             }
  38.         }
  39.  
  40.         http_dispatch_event(client, HTTP_EVENT_ON_FINISH, NULL, 0);
  41.  
  42.         if (!http_should_keep_alive(client->parser)) {
  43.             ESP_LOGD(TAG, "Close connection");
  44.             esp_http_client_close(client);
  45.         } else {
  46.             if (client->state > HTTP_STATE_CONNECTED) {
  47.                 client->state = HTTP_STATE_CONNECTED;
  48.             }
  49.         }
  50.     } while (client->process_again);
  51.     return ESP_OK;
  52. }

a、esp_http_client_open(client, client->post_len)) 函数

作用：连接TCP,并发送HTTP头

  1. esp_err_t esp_http_client_open(esp_http_client_handle_t client, int write_len)
  2. {
  3.     esp_err_t err;
  4.     if (client->state == HTTP_STATE_UNINIT) {
  5.         ESP_LOGE(TAG, "Client has not been initialized");
  6.         return ESP_ERR_INVALID_STATE;
  7.     }
  8.  
  9.     if ((err = esp_http_client_prepare(client)) != ESP_OK) {
  10.         ESP_LOGE(TAG, "Failed to initialize request data");
  11.         esp_http_client_close(client);
  12.         return err;
  13.     }
  14.  
  15.     if (client->state < HTTP_STATE_CONNECTED) {
  16.         ESP_LOGD(TAG, "Begin connect to: %s://%s:%d", client->connection_info.scheme, client->connection_info.host, client->connection_info.port);
  17.         client->transport = transport_list_get_transport(client->transport_list, client->connection_info.scheme);
  18.         if (client->transport == NULL) {
  19.             ESP_LOGE(TAG, "No transport found");
  20.             return ESP_ERR_HTTP_INVALID_TRANSPORT;
  21.         }
  22. //第一部分连接TCP
  23.         if (transport_connect(client->transport, client->connection_info.host, client->connection_info.port, client->timeout_ms) < 0) {
  24.             ESP_LOGE(TAG, "Connection failed, sock < 0");
  25.             return ESP_ERR_HTTP_CONNECT;
  26.         }
  27.         http_dispatch_event(client, HTTP_EVENT_ON_CONNECTED, NULL, 0);//产生一个连接成功事件
  28.         client->state = HTTP_STATE_CONNECTED;
  29.     }
  30.  
  31.     if (write_len >= 0) {
  32.         http_header_set_format(client->request->headers, "Content-Length", "%d", write_len);
  33.     } else if (write_len < 0) {
  34.         esp_http_client_set_header(client, "Transfer-Encoding", "chunked");
  35.         esp_http_client_set_method(client, HTTP_METHOD_POST);
  36.     }
  37.  
  38.     int header_index = 0;
  39.     int wlen = client->buffer_size;
  40.  
  41.     const char *method = HTTP_METHOD_MAPPING[client->connection_info.method];
  42.  
  43.     int first_line = snprintf(client->request->buffer->data,
  44.                               client->buffer_size, "%s %s",
  45.                               method,
  46.                               client->connection_info.path);
  47.     if (first_line > client->buffer_size) {
  48.         ESP_LOGE(TAG, "Out of buffer");
  49.         return ESP_ERR_HTTP_CONNECT;
  50.     }
  51.     printf("\n---->:%s\n",client->request->buffer->data);
  52.     if (client->connection_info.query) {
  53.         first_line += snprintf(client->request->buffer->data + first_line,
  54.                                client->buffer_size - first_line, "?%s", client->connection_info.query);
  55.         if (first_line > client->buffer_size) {
  56.             ESP_LOGE(TAG, "Out of buffer");
  57.             return ESP_ERR_HTTP_CONNECT;
  58.         }
  59.     }
  60.     printf("\n---->:%s\n",client->request->buffer->data);
  61.     first_line += snprintf(client->request->buffer->data + first_line,
  62.                            client->buffer_size - first_line, " %s\r\n", DEFAULT_HTTP_PROTOCOL);
  63.     if (first_line > client->buffer_size) {
  64.         ESP_LOGE(TAG, "Out of buffer");
  65.         return ESP_ERR_HTTP_CONNECT;
  66.     }
  67.     wlen -= first_line;
  68.  
  69.     while ((header_index = http_header_generate_string(client->request->headers, header_index, client->request->buffer->data + first_line, &wlen))) {
  70.         if (wlen <= 0) {
  71.             break;
  72.         }
  73.         if (first_line) {
  74.             wlen += first_line;
  75.             first_line = 0;
  76.         }
  77.         client->request->buffer->data[wlen] = 0;
  78.         ESP_LOGD(TAG, "Write header[%d]: %s", header_index, client->request->buffer->data);
  79.         printf("\r\nclient_open Write Data len:%d %s\r\n\n",wlen,client->request->buffer->data);
  80. //第二部分 发送http头
  81.         if (transport_write(client->transport, client->request->buffer->data, wlen, client->timeout_ms) <= 0) {
  82.             ESP_LOGE(TAG, "Error write request");
  83.             esp_http_client_close(client);
  84.             return ESP_ERR_HTTP_WRITE_DATA;
  85.         }
  86.         wlen = client->buffer_size;
  87.     }
  88.     client->state = HTTP_STATE_REQ_COMPLETE_HEADER;
  89.     return ESP_OK;
  90. }

函数源码比较长，这个里面主要可以分成两部分,其它基本是组包，组成HTTP头

1、transport_connect(client->transport, client->connection_info.host, client->connection_info.port, client->timeout_ms)

到这里才调用TCP 连接服务器，连接成功之后通过http_dispatch_event(client, HTTP_EVENT_ON_CONNECTED, NULL, 0)发送一个事件给HTTP的事件函数

2、transport_write(client->transport, client->request->buffer->data, wlen, client->timeout_ms)

到这是连接成功之后发送http头数据，esp32是 http头和body分开发送的

b、esp_http_client_write(client, client->post_data, client->post_len)

这个函数是发送body的函数，详细见下图，上面部分是esp_http_client_open函数里面发送的，下面的是esp_http_client_write发送的。

c、int esp_http_client_fetch_headers(esp_http_client_handle_t client)

http发送之后，调用esp_http_client_fetch_headers等待接收数据，

  1. int esp_http_client_fetch_headers(esp_http_client_handle_t client)
  2. {
  3.     if (client->state < HTTP_STATE_REQ_COMPLETE_HEADER) {
  4.         return ESP_FAIL;
  5.     }
  6.  
  7.     client->state = HTTP_STATE_REQ_COMPLETE_DATA;
  8.     esp_http_buffer_t *buffer = client->response->buffer;
  9.     client->response->status_code = -1;
  10.  
  11.     while (client->state < HTTP_STATE_RES_COMPLETE_HEADER) {
  12.         buffer->len = transport_read(client->transport, buffer->data, client->buffer_size, client->timeout_ms);
  13.         if (buffer->len <= 0) {
  14.             return ESP_FAIL;
  15.         }
  16.         http_parser_execute(client->parser, client->parser_settings, buffer->data, buffer->len);
  17.     }
  18.     buffer->data[buffer->len] = 0;
  19.     ESP_LOGD(TAG, "content_length = %d", client->response->content_length);
  20.     if (client->response->content_length <= 0) {
  21.         client->response->is_chunked = true;
  22.         return 0;
  23.     }
  24.     return client->response->content_length;
  25. }

这个函数比较简单，就是在里面一直等待http返回应答数据，里面设置了接收超时，接收到数据就退出，下面图就是接收到的http应答

8、 esp_http_client_get_status_code(client)

作用：判断http应答状态 正常是200

9、esp_http_client_get_content_length(client))

作用：得到body的数据长度

10、esp_http_client_read(client, buf, len);

作用：获取HTTP 返回的body数据

下面就是得到的数据

11、 esp_http_client_cleanup(client);

作用：用的最后一个函数。它将关闭连接(如果有的话)并释放分配给HTTP客户端的所有内存

 

到这里基本结束了，写了2个多小时，深夜2.17

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/875983
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号