ESP-IDF:TCP多线程并发服务器

核心代码：

核心思想就是主线程只处理socket监听功能，把数据处理部分分配到不同的线程中去处理。来了一个客户端连接，就分配新的线程去处理该客户端的数据请求。

代码：

/多线程并发服务器/
#include <stdio.h>
#include “sdkconfig.h”
#include “freertos/semphr.h”
#include “esp_system.h”
#include “esp_spi_flash.h”
#include <string.h>
#include “freertos/FreeRTOS.h”
#include “freertos/task.h”
#include “freertos/event_groups.h”
#include “esp_system.h”
#include “esp_wifi.h”
#include “esp_event.h”
#include “esp_event_loop.h”
#include “esp_log.h”
#include “nvs_flash.h”
#include “sdkconfig.h”

#include “lwip/err.h”
#include “lwip/sys.h”

#include “mdns.h”

#include <sys/param.h>
#include “esp_event.h”

#include “esp_netif.h”
//#include “protocol_examples_common.h”

#include “lwip/sockets.h”
#include <lwip/netdb.h>

/* The examples use WiFi configuration that you can set via ‘make menuconfig’.

If you’d rather not, just change the below entries to strings with
the config you want - ie #define EXAMPLE_WIFI_SSID “mywifissid”
*/
#define EXAMPLE_ESP_WIFI_SSID CONFIG_ESP_WIFI_SSID
#define EXAMPLE_ESP_WIFI_PASS CONFIG_ESP_WIFI_PASSWORD
#define EXAMPLE_ESP_MAXIMUM_RETRY CONFIG_ESP_MAXIMUM_RETRY
#define EXAMPLE_ESP_WIFI_AP_SSID CONFIG_ESP_WIFI_AP_SSID
#define EXAMPLE_ESP_WIFI_AP_PASS CONFIG_ESP_WIFI_AP_PASSWORD
#define EXAMPLE_MAX_STA_CONN CONFIG_MAX_STA_CONN
#define EXAMPLE_IP_ADDR CONFIG_SERVER_IP
#define EXAMPLE_ESP_WIFI_AP_CHANNEL CONFIG_ESP_WIFI_AP_CHANNEL

static const char *TAG = “camera wifi”;
static const char *TAG1 = “michael add:”;

static int s_retry_num = 0;

static esp_err_t event_handler(void *ctx, system_event_t *event)
{
switch(event->event_id) {
case SYSTEM_EVENT_AP_STACONNECTED:
ESP_LOGI(TAG, “station:” MACSTR " join, AID=%d",
MAC2STR(event->event_info.sta_connected.mac),
event->event_info.sta_connected.aid);
break;
case SYSTEM_EVENT_AP_STADISCONNECTED:
ESP_LOGI(TAG, “station:” MACSTR “leave, AID=%d”,
MAC2STR(event->event_info.sta_disconnected.mac),
event->event_info.sta_disconnected.aid);
break;
case SYSTEM_EVENT_STA_START:
esp_wifi_connect();
break;
case SYSTEM_EVENT_STA_GOT_IP:
ESP_LOGI(TAG, “got ip:%s”,
ip4addr_ntoa(&event->event_info.got_ip.ip_info.ip));
s_retry_num = 0;
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
{
if (s_retry_num < EXAMPLE_ESP_MAXIMUM_RETRY) {
esp_wifi_connect();
s_retry_num++;
ESP_LOGI(TAG,“retry to connect to the AP”);
}
ESP_LOGI(TAG,“connect to the AP fail”);
break;
}
default:
break;
}
ESP_LOGI(TAG1,“before mdns_handle_system_event”);
mdns_handle_system_event(ctx, event);
ESP_LOGI(TAG1,“after mdns_handle_system_event”);
return ESP_OK;
}

void wifi_init_softap()
{
if (strcmp(EXAMPLE_IP_ADDR, “192.168.4.1”))
{
int a, b, c, d;
sscanf(EXAMPLE_IP_ADDR, “%d.%d.%d.%d”, &a, &b, &c, &d);
tcpip_adapter_ip_info_t ip_info;
IP4_ADDR(&ip_info.ip, a, b, c, d);
IP4_ADDR(&ip_info.gw, a, b, c, d);
IP4_ADDR(&ip_info.netmask, 255, 255, 255, 0);
ESP_ERROR_CHECK(tcpip_adapter_dhcps_stop(WIFI_IF_AP));
ESP_ERROR_CHECK(tcpip_adapter_set_ip_info(WIFI_IF_AP, &ip_info));
ESP_ERROR_CHECK(tcpip_adapter_dhcps_start(WIFI_IF_AP));
}
wifi_config_t wifi_config;
memset(&wifi_config, 0, sizeof(wifi_config_t));
snprintf((char*)wifi_config.ap.ssid, 32, “%s”, EXAMPLE_ESP_WIFI_AP_SSID);
wifi_config.ap.ssid_len = strlen((char*)wifi_config.ap.ssid);
snprintf((char*)wifi_config.ap.password, 64, “%s”, EXAMPLE_ESP_WIFI_AP_PASS);
wifi_config.ap.max_connection = EXAMPLE_MAX_STA_CONN;
wifi_config.ap.authmode = WIFI_AUTH_WPA_WPA2_PSK;
if (strlen(EXAMPLE_ESP_WIFI_AP_PASS) == 0) {
wifi_config.ap.authmode = WIFI_AUTH_OPEN;
}
if (strlen(EXAMPLE_ESP_WIFI_AP_CHANNEL)) {
int channel;
sscanf(EXAMPLE_ESP_WIFI_AP_CHANNEL, “%d”, &channel);
wifi_config.ap.channel = channel;
}

ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_AP, &wifi_config));ESP_LOGI(TAG, "wifi_init_softap finished.SSID:%s password:%s",EXAMPLE_ESP_WIFI_AP_SSID, EXAMPLE_ESP_WIFI_AP_PASS);

}

void wifi_init_sta()
{
wifi_config_t wifi_config;
memset(&wifi_config, 0, sizeof(wifi_config_t));
snprintf((char*)wifi_config.sta.ssid, 32, “%s”, EXAMPLE_ESP_WIFI_SSID);
snprintf((char*)wifi_config.sta.password, 64, “%s”, EXAMPLE_ESP_WIFI_PASS);

ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config) );ESP_LOGI(TAG, "wifi_init_sta finished.");
ESP_LOGI(TAG, "connect to ap SSID:%s password:%s",EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS);

}

void app_wifi_main()
{
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
wifi_mode_t mode = WIFI_MODE_AP;

if (strlen(EXAMPLE_ESP_WIFI_AP_SSID) && strlen(EXAMPLE_ESP_WIFI_SSID)) {mode = WIFI_MODE_APSTA;
} else if (strlen(EXAMPLE_ESP_WIFI_AP_SSID)) {mode = WIFI_MODE_AP;
} else if (strlen(EXAMPLE_ESP_WIFI_SSID)) {mode = WIFI_MODE_STA;
}esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {ESP_ERROR_CHECK(nvs_flash_erase());ret = nvs_flash_init();
}
ESP_ERROR_CHECK(ret);if (mode == WIFI_MODE_NULL) {ESP_LOGW(TAG,"Neither AP or STA have been configured. WiFi will be off.");return;
}tcpip_adapter_init();
ESP_ERROR_CHECK(esp_event_loop_init(event_handler, NULL));
ESP_ERROR_CHECK(esp_wifi_init(&cfg));
ESP_ERROR_CHECK(esp_wifi_set_mode(mode));if (mode & WIFI_MODE_AP) {wifi_init_softap();
}if (mode & WIFI_MODE_STA) {wifi_init_sta();
}
ESP_ERROR_CHECK(esp_wifi_start());
ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE));

}

/* BSD Socket API Example

This example code is in the Public Domain (or CC0 licensed, at your option.)

Unless required by applicable law or agreed to in writing, this
software is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied.
*/

#define PORT CONFIG_EXAMPLE_PORT
#define KEEPALIVE_IDLE CONFIG_EXAMPLE_KEEPALIVE_IDLE
#define KEEPALIVE_INTERVAL CONFIG_EXAMPLE_KEEPALIVE_INTERVAL
#define KEEPALIVE_COUNT CONFIG_EXAMPLE_KEEPALIVE_COUNT

//static const char *TAG = “example”;

//static void do_retransmit(const int sock)
static void do_retransmit0(const int sock) //michael change for multitasks server
{
int len;
char rx_buffer[128];

do {len = recv(sock, rx_buffer, sizeof(rx_buffer) - 1, 0);if (len < 0) {ESP_LOGE(TAG, "Error occurred during receiving: errno %d", errno);} else if (len == 0) {ESP_LOGW(TAG, "Connection closed");} else {rx_buffer[len] = 0; // Null-terminate whatever is received and treat it like a stringESP_LOGI(TAG, "Received %d bytes: %s", len, rx_buffer);// send() can return less bytes than supplied length.// Walk-around for robust implementation.int to_write = len;char data[]="task0 reply";//michael add for multitasks serverwhile (to_write > 0) {int written = send(sock, rx_buffer + (len - to_write), to_write, 0);written += send(sock, data, sizeof(data), 0);//michael add for multitasks serverif (written < 0) {ESP_LOGE(TAG, "Error occurred during sending: errno %d", errno);}to_write -= written;}}
} while (len > 0);
shutdown(sock, 0); //michael add for multitasks server
close(sock);//michael add for multitasks server

}

static void do_retransmit1(const int sock) //michael change for multitasks server
{
int len;
char rx_buffer[128];

do {len = recv(sock, rx_buffer, sizeof(rx_buffer) - 1, 0);if (len < 0) {ESP_LOGE(TAG, "Error occurred during receiving: errno %d", errno);} else if (len == 0) {ESP_LOGW(TAG, "Connection closed");} else {rx_buffer[len] = 0; // Null-terminate whatever is received and treat it like a stringESP_LOGI(TAG, "Received %d bytes: %s", len, rx_buffer);// send() can return less bytes than supplied length.// Walk-around for robust implementation.int to_write = len;char data[]="task1 reply"; //michael add for multitasks serverwhile (to_write > 0) {int written = send(sock, rx_buffer + (len - to_write), to_write, 0);written += send(sock, data, sizeof(data), 0);//michael add for multitasks serverif (written < 0) {ESP_LOGE(TAG, "Error occurred during sending: errno %d", errno);}to_write -= written;}}
} while (len > 0);
shutdown(sock, 0); //michael add for multitasks server
close(sock);//michael add for multitasks server

}

static void tcp_server_task(void *pvParameters)
{
char addr_str[128];
int addr_family = (int)pvParameters;
int ip_protocol = 0;
int keepAlive = 1;
int keepIdle = KEEPALIVE_IDLE;
int keepInterval = KEEPALIVE_INTERVAL;
int keepCount = KEEPALIVE_COUNT;
struct sockaddr_storage dest_addr;

if (addr_family == AF_INET) {struct sockaddr_in *dest_addr_ip4 = (struct sockaddr_in *)&dest_addr;dest_addr_ip4->sin_addr.s_addr = htonl(INADDR_ANY);dest_addr_ip4->sin_family = AF_INET;dest_addr_ip4->sin_port = htons(PORT);ip_protocol = IPPROTO_IP;
}

#ifdef CONFIG_EXAMPLE_IPV6
else if (addr_family == AF_INET6) {
struct sockaddr_in6 *dest_addr_ip6 = (struct sockaddr_in6 *)&dest_addr;
bzero(&dest_addr_ip6->sin6_addr.un, sizeof(dest_addr_ip6->sin6_addr.un));
dest_addr_ip6->sin6_family = AF_INET6;
dest_addr_ip6->sin6_port = htons(PORT);
ip_protocol = IPPROTO_IPV6;
}
#endif

int listen_sock = socket(addr_family, SOCK_STREAM, ip_protocol);
if (listen_sock < 0) {ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);vTaskDelete(NULL);return;
}
int opt = 1;
setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

#if defined(CONFIG_EXAMPLE_IPV4) && defined(CONFIG_EXAMPLE_IPV6)
// Note that by default IPV6 binds to both protocols, it is must be disabled
// if both protocols used at the same time (used in CI)
setsockopt(listen_sock, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof(opt));
#endif

ESP_LOGI(TAG, "Socket created");int err = bind(listen_sock, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
if (err != 0) {ESP_LOGE(TAG, "Socket unable to bind: errno %d", errno);ESP_LOGE(TAG, "IPPROTO: %d", addr_family);goto CLEAN_UP;
}
ESP_LOGI(TAG, "Socket bound, port %d", PORT);err = listen(listen_sock, 1);
if (err != 0) {ESP_LOGE(TAG, "Error occurred during listen: errno %d", errno);goto CLEAN_UP;
}int sockid[3];//保存主线程收到的sock， michael add for 多线程
int i=0;//保存主线程收到的sock， michael add for 多线程while (1) {ESP_LOGI(TAG, "Socket listening");struct sockaddr_storage source_addr; // Large enough for both IPv4 or IPv6socklen_t addr_len = sizeof(source_addr);ESP_LOGI(TAG, "michael add before accept");int sock = accept(listen_sock, (struct sockaddr *)&source_addr, &addr_len);if (sock < 0) {ESP_LOGE(TAG, "Unable to accept connection: errno %d", errno);break;}ESP_LOGI(TAG, "michael add after accept");// Set tcp keepalive optionsetsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &keepAlive, sizeof(int));setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE, &keepIdle, sizeof(int));setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, &keepInterval, sizeof(int));setsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT, &keepCount, sizeof(int));// Convert ip address to stringif (source_addr.ss_family == PF_INET) {inet_ntoa_r(((struct sockaddr_in *)&source_addr)->sin_addr, addr_str, sizeof(addr_str) - 1);}

#ifdef CONFIG_EXAMPLE_IPV6
else if (source_addr.ss_family == PF_INET6) {
inet6_ntoa_r(((struct sockaddr_in6 )&source_addr)->sin6_addr, addr_str, sizeof(addr_str) - 1);
}
#endif
ESP_LOGI(TAG, “Socket accepted ip address: %s”, addr_str);
//把下面三个操作放到子线程中去处理，实现并行
sockid[i] = sock;
switch (i)
{
case 0:
xTaskCreate(do_retransmit0, “transmit_task0”, 4096, sockid[0], 15, NULL);
break;
case 1:
xTaskCreate(do_retransmit1, “transmit_task1”, 4096, sockid[1], 15, NULL);
break;
default:
ESP_LOGI(TAG1, “only can accept 2 connector”);
break;
}
i++;
/ 单线程server代码
do_retransmit(sock);

    shutdown(sock, 0);close(sock);*/
}

CLEAN_UP:
close(listen_sock);
vTaskDelete(NULL);
}

void test25() {
app_wifi_main();
#ifdef CONFIG_EXAMPLE_IPV4
xTaskCreate(tcp_server_task, “tcp_server”, 4096, (void*)AF_INET, 15, NULL);
#endif
#ifdef CONFIG_EXAMPLE_IPV6
xTaskCreate(tcp_server_task, “tcp_server”, 4096, (void*)AF_INET6, 5, NULL);
#endif
}

void app_main(void)
{

// /* Print chip information */
// esp_chip_info_t chip_info;
// esp_chip_info(&chip_info);
// printf("This is %s chip with %d CPU core(s), WiFi%s%s, ",
//        CONFIG_IDF_TARGET,
//        chip_info.cores,
//        (chip_info.features & CHIP_FEATURE_BT) ? "/BT" : "",
//        (chip_info.features & CHIP_FEATURE_BLE) ? "/BLE" : "");// printf("silicon revision %d, ", chip_info.revision);// printf("%dMB %s flash\n", spi_flash_get_chip_size() / (1024 * 1024),
//        (chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "embedded" : "external");// printf("Minimum free heap size: %d bytes\n", esp_get_minimum_free_heap_size());// for (int i = 10; i >= 0; i--)
// {
//     printf("Restarting in %d seconds...\n", i);
//     vTaskDelay(1000 / portTICK_PERIOD_MS);
// }
// printf("Restarting now.\n");
// fflush(stdout);
// printf("----test 23----\n");
// test23();// printf("----test 24 基于计数型信号量的生产者和消费者模型代码----\n");
// test24();// esp_restart();
test25();

}

结果：

电脑端tcp client向esp server发送数据，server端把数据回传并添加是哪个线程发送的。