Crash_Override/OVMS3-idf
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

example: optimize the robust of TCP connect

Browse source
This commit is contained in:
zhangyanjiao 2017-07-21 11:40:30 +08:00
parent 43b81c8f11
commit e782928b50
3 changed files with 217 additions and 169 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

108
examples/performance/tcp_perf/main/tcp_main.c
View file

@ -36,75 +36,91 @@ step3:
#include "tcp_perf.h" #include "tcp_perf.h"
//this task establish a TCP connection and receive data from TCP //this task establish a TCP connection and receive data from TCP
static void tcp_conn(void *pvParameters) static void tcp_conn(void *pvParameters)
{ {
ESP_LOGI(TAG, "task tcp_conn."); while (1) {
/*wating for connecting to AP*/
xEventGroupWaitBits(tcp_event_group, WIFI_CONNECTED_BIT,false, true, portMAX_DELAY);
ESP_LOGI(TAG, "sta has connected to ap."); g_rxtx_need_restart = false;
/*create tcp socket*/ ESP_LOGI(TAG, "task tcp_conn.");
int socket_ret;
/*wating for connecting to AP*/
xEventGroupWaitBits(tcp_event_group, WIFI_CONNECTED_BIT, false, true, portMAX_DELAY);
ESP_LOGI(TAG, "sta has connected to ap.");
int socket_ret = ESP_FAIL;
TaskHandle_t tx_rx_task = NULL;
#if EXAMPLE_ESP_TCP_MODE_SERVER #if EXAMPLE_ESP_TCP_MODE_SERVER
ESP_LOGI(TAG, "tcp_server will start after 3s..."); if (socket_ret == ESP_FAIL) {
vTaskDelay(3000 / portTICK_RATE_MS); /*create tcp socket*/
ESP_LOGI(TAG, "create_tcp_server."); ESP_LOGI(TAG, "tcp_server will start after 3s...");
socket_ret=create_tcp_server(); vTaskDelay(3000 / portTICK_RATE_MS);
ESP_LOGI(TAG, "create_tcp_server.");
socket_ret = create_tcp_server();
}
#else /*EXAMPLE_ESP_TCP_MODE_SERVER*/ #else /*EXAMPLE_ESP_TCP_MODE_SERVER*/
ESP_LOGI(TAG, "tcp_client will start after 20s..."); if (socket_ret == ESP_FAIL) {
vTaskDelay(20000 / portTICK_RATE_MS); ESP_LOGI(TAG, "tcp_client will start after 20s...");
ESP_LOGI(TAG, "create_tcp_client."); vTaskDelay(20000 / portTICK_RATE_MS);
socket_ret = create_tcp_client(); ESP_LOGI(TAG, "create_tcp_client.");
socket_ret = create_tcp_client();
}
#endif #endif
if(socket_ret == ESP_FAIL) { if (socket_ret == ESP_FAIL) {
ESP_LOGI(TAG, "create tcp socket error,stop."); ESP_LOGI(TAG, "create tcp socket error,stop.");
vTaskDelete(NULL); continue;
} }
/*create a task to tx/rx data*/
/*create a task to tx/rx data*/
TaskHandle_t tx_rx_task;
#if EXAMPLE_ESP_TCP_PERF_TX #if EXAMPLE_ESP_TCP_PERF_TX
xTaskCreate(&send_data, "send_data", 4096, NULL, 4, &tx_rx_task); if (tx_rx_task == NULL) {
if (pdPASS != xTaskCreate(&send_data, "send_data", 4096, NULL, 4, &tx_rx_task)) {
ESP_LOGE(TAG, "Send task create fail!");
}
}
#else /*EXAMPLE_ESP_TCP_PERF_TX*/ #else /*EXAMPLE_ESP_TCP_PERF_TX*/
xTaskCreate(&recv_data, "recv_data", 4096, NULL, 4, &tx_rx_task); if (tx_rx_task == NULL) {
if (pdPASS != xTaskCreate(&recv_data, "recv_data", 4096, NULL, 4, &tx_rx_task)) {
ESP_LOGE(TAG, "Recv task create fail!");
}
}
#endif #endif
int bps; double bps;
while (1) {
total_data = 0; while (1) {
vTaskDelay(3000 / portTICK_RATE_MS);//every 3s g_total_data = 0;
bps = total_data / 3; vTaskDelay(3000 / portTICK_RATE_MS);//every 3s
if (total_data <= 0) { bps = (g_total_data * 8.0 / 3.0) / 1000000.0;
int err_ret = check_working_socket();
if (err_ret == ECONNRESET || ECONNABORTED) { if (g_rxtx_need_restart) {
ESP_LOGW(TAG, "tcp disconnected... stop.\n"); printf("send or receive task encoutner error, need to restart\n");
break; break;
} }
}
#if EXAMPLE_ESP_TCP_PERF_TX #if EXAMPLE_ESP_TCP_PERF_TX
ESP_LOGI(TAG, "tcp send %d byte per sec!", bps); ESP_LOGI(TAG, "tcp send %.2f Mbits per sec!\n", bps);
#if EXAMPLE_ESP_TCP_DELAY_INFO #if EXAMPLE_ESP_TCP_DELAY_INFO
ESP_LOGI(TAG, "tcp send packet total:%d succeed:%d failed:%d\n" ESP_LOGI(TAG, "tcp send packet total:%d succeed:%d failed:%d\n"
"time(ms):0-30:%d 30-100:%d 100-300:%d 300-1000:%d 1000+:%d\n", "time(ms):0-30:%d 30-100:%d 100-300:%d 300-1000:%d 1000+:%d\n",
total_pack, send_success, send_fail, delay_classify[0], g_total_pack, g_send_success, g_send_fail, g_delay_classify[0],
delay_classify[1], delay_classify[2], delay_classify[3], delay_classify[4]); g_delay_classify[1], g_delay_classify[2], g_delay_classify[3], g_delay_classify[4]);
#endif /*EXAMPLE_ESP_TCP_DELAY_INFO*/ #endif /*EXAMPLE_ESP_TCP_DELAY_INFO*/
#else #else
ESP_LOGI(TAG, "tcp recv %d byte per sec!\n", bps); ESP_LOGI(TAG, "tcp recv %.2f Mbits per sec!\n", bps);
#endif /*EXAMPLE_ESP_TCP_PERF_TX*/ #endif /*EXAMPLE_ESP_TCP_PERF_TX*/
}
close_socket();
} }
close_socket();
vTaskDelete(tx_rx_task);
vTaskDelete(NULL); vTaskDelete(NULL);
} }
void app_main(void) void app_main(void)
{ {
#if EXAMPLE_ESP_WIFI_MODE_AP #if EXAMPLE_ESP_WIFI_MODE_AP

233
examples/performance/tcp_perf/main/tcp_perf.c
View file

@ -29,15 +29,16 @@ static struct sockaddr_in server_addr;
static struct sockaddr_in client_addr; static struct sockaddr_in client_addr;
static unsigned int socklen = sizeof(client_addr); static unsigned int socklen = sizeof(client_addr);
static int connect_socket = 0; static int connect_socket = 0;
bool g_rxtx_need_restart = false;
int total_data = 0; int g_total_data = 0;
#if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO #if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO
int total_pack = 0; int g_total_pack = 0;
int send_success = 0; int g_send_success = 0;
int send_fail = 0; int g_send_fail = 0;
int delay_classify[5] = { 0 }; int g_delay_classify[5] = { 0 };
#endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/ #endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/
@ -46,7 +47,7 @@ int delay_classify[5] = { 0 };
static esp_err_t event_handler(void *ctx, system_event_t *event) static esp_err_t event_handler(void *ctx, system_event_t *event)
{ {
switch(event->event_id) { switch (event->event_id) {
case SYSTEM_EVENT_STA_START: case SYSTEM_EVENT_STA_START:
esp_wifi_connect(); esp_wifi_connect();
break; break;
@ -57,22 +58,22 @@ static esp_err_t event_handler(void *ctx, system_event_t *event)
case SYSTEM_EVENT_STA_CONNECTED: case SYSTEM_EVENT_STA_CONNECTED:
break; break;
case SYSTEM_EVENT_STA_GOT_IP: case SYSTEM_EVENT_STA_GOT_IP:
ESP_LOGI(TAG, "got ip:%s\n", ESP_LOGI(TAG, "got ip:%s\n",
ip4addr_ntoa(&event->event_info.got_ip.ip_info.ip)); ip4addr_ntoa(&event->event_info.got_ip.ip_info.ip));
xEventGroupSetBits(tcp_event_group, WIFI_CONNECTED_BIT); xEventGroupSetBits(tcp_event_group, WIFI_CONNECTED_BIT);
break; break;
case SYSTEM_EVENT_AP_STACONNECTED: case SYSTEM_EVENT_AP_STACONNECTED:
ESP_LOGI(TAG, "station:"MACSTR" join,AID=%d\n", ESP_LOGI(TAG, "station:"MACSTR" join,AID=%d\n",
MAC2STR(event->event_info.sta_connected.mac), MAC2STR(event->event_info.sta_connected.mac),
event->event_info.sta_connected.aid); event->event_info.sta_connected.aid);
xEventGroupSetBits(tcp_event_group, WIFI_CONNECTED_BIT); xEventGroupSetBits(tcp_event_group, WIFI_CONNECTED_BIT);
break; break;
case SYSTEM_EVENT_AP_STADISCONNECTED: case SYSTEM_EVENT_AP_STADISCONNECTED:
ESP_LOGI(TAG, "station:"MACSTR"leave,AID=%d\n", ESP_LOGI(TAG, "station:"MACSTR"leave,AID=%d\n",
MAC2STR(event->event_info.sta_disconnected.mac), MAC2STR(event->event_info.sta_disconnected.mac),
event->event_info.sta_disconnected.aid); event->event_info.sta_disconnected.aid);
xEventGroupClearBits(tcp_event_group, WIFI_CONNECTED_BIT); xEventGroupClearBits(tcp_event_group, WIFI_CONNECTED_BIT);
break; break;
default: default:
break; break;
} }
@ -83,9 +84,9 @@ static esp_err_t event_handler(void *ctx, system_event_t *event)
void send_data(void *pvParameters) void send_data(void *pvParameters)
{ {
int len = 0; int len = 0;
char databuff[EXAMPLE_DEFAULT_PKTSIZE]; char *databuff = (char *)malloc(EXAMPLE_DEFAULT_PKTSIZE * sizeof(char));
memset(databuff, EXAMPLE_PACK_BYTE_IS, EXAMPLE_DEFAULT_PKTSIZE); memset(databuff, EXAMPLE_PACK_BYTE_IS, EXAMPLE_DEFAULT_PKTSIZE);
vTaskDelay(100/portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
ESP_LOGI(TAG, "start sending..."); ESP_LOGI(TAG, "start sending...");
#if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO #if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO
//delaytime //delaytime
@ -93,66 +94,89 @@ void send_data(void *pvParameters)
struct timeval tv_finish; struct timeval tv_finish;
unsigned long send_delay_ms; unsigned long send_delay_ms;
#endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/ #endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/
while(1) { while (1) {
int to_write = EXAMPLE_DEFAULT_PKTSIZE;
#if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO #if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO
total_pack++; g_total_pack++;
gettimeofday(&tv_start, NULL); gettimeofday(&tv_start, NULL);
#endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/ #endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/
//send function //send function
len = send(connect_socket, databuff, EXAMPLE_DEFAULT_PKTSIZE, 0); while (to_write > 0) {
len = send(connect_socket, databuff + (EXAMPLE_DEFAULT_PKTSIZE - to_write), to_write, 0);
if (len > 0) {
g_total_data += len;
to_write -= len;
} else {
int err = get_socket_error_code(connect_socket);
#if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO
g_send_fail++;
#endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/
if (err != ENOMEM) {
show_socket_error_reason("send_data", connect_socket);
break;
}
}
}
#if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO #if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO
gettimeofday(&tv_finish, NULL); gettimeofday(&tv_finish, NULL);
#endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/ #endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/
if(len > 0) { if (g_total_data > 0) {
total_data += len;
#if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO #if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO
send_success++; g_send_success++;
send_delay_ms = (tv_finish.tv_sec - tv_start.tv_sec) * 1000 send_delay_ms = (tv_finish.tv_sec - tv_start.tv_sec) * 1000
+ (tv_finish.tv_usec - tv_start.tv_usec) / 1000; + (tv_finish.tv_usec - tv_start.tv_usec) / 1000;
if(send_delay_ms < 30) if (send_delay_ms < 30) {
delay_classify[0]++; g_delay_classify[0]++;
else if(send_delay_ms < 100) } else if (send_delay_ms < 100) {
delay_classify[1]++; g_delay_classify[1]++;
else if(send_delay_ms < 300) } else if (send_delay_ms < 300) {
delay_classify[2]++; g_delay_classify[2]++;
else if(send_delay_ms < 1000) } else if (send_delay_ms < 1000) {
delay_classify[3]++; g_delay_classify[3]++;
else } else {
delay_classify[4]++; g_delay_classify[4]++;
}
#endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/ #endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/
} else {
} else { break;
}
#if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO
send_fail++;
#endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/
if (LOG_LOCAL_LEVEL >= ESP_LOG_DEBUG) {
show_socket_error_reason(connect_socket);
}
} /*if(len > 0)*/
} }
g_rxtx_need_restart = true;
free(databuff);
vTaskDelete(NULL);
} }
//receive data //receive data
void recv_data(void *pvParameters) void recv_data(void *pvParameters)
{ {
int len = 0; int len = 0;
char databuff[EXAMPLE_DEFAULT_PKTSIZE]; char *databuff = (char *)malloc(EXAMPLE_DEFAULT_PKTSIZE * sizeof(char));
while (1) { while (1) {
len = recv(connect_socket, databuff, EXAMPLE_DEFAULT_PKTSIZE, 0); int to_recv = EXAMPLE_DEFAULT_PKTSIZE;
if (len > 0) { while (to_recv > 0) {
total_data += len; len = recv(connect_socket, databuff + (EXAMPLE_DEFAULT_PKTSIZE - to_recv), to_recv, 0);
} else { if (len > 0) {
if (LOG_LOCAL_LEVEL >= ESP_LOG_DEBUG) { g_total_data += len;
show_socket_error_reason(connect_socket); to_recv -= len;
} else {
show_socket_error_reason("recv_data", connect_socket);
break;
} }
vTaskDelay(100 / portTICK_RATE_MS); }
} if (g_total_data > 0) {
continue;
} else {
break;
}
} }
g_rxtx_need_restart = true;
free(databuff);
vTaskDelete(NULL);
} }
@ -162,27 +186,28 @@ esp_err_t create_tcp_server()
ESP_LOGI(TAG, "server socket....port=%d\n", EXAMPLE_DEFAULT_PORT); ESP_LOGI(TAG, "server socket....port=%d\n", EXAMPLE_DEFAULT_PORT);
server_socket = socket(AF_INET, SOCK_STREAM, 0); server_socket = socket(AF_INET, SOCK_STREAM, 0);
if (server_socket < 0) { if (server_socket < 0) {
show_socket_error_reason(server_socket); show_socket_error_reason("create_server", server_socket);
return ESP_FAIL; return ESP_FAIL;
} }
server_addr.sin_family = AF_INET; server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(EXAMPLE_DEFAULT_PORT); server_addr.sin_port = htons(EXAMPLE_DEFAULT_PORT);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY); server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) { if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
show_socket_error_reason(server_socket); show_socket_error_reason("bind_server", server_socket);
close(server_socket); close(server_socket);
return ESP_FAIL; return ESP_FAIL;
} }
if (listen(server_socket, 5) < 0) { if (listen(server_socket, 5) < 0) {
show_socket_error_reason(server_socket); show_socket_error_reason("listen_server", server_socket);
close(server_socket); close(server_socket);
return ESP_FAIL; return ESP_FAIL;
} }
connect_socket = accept(server_socket, (struct sockaddr*)&client_addr, &socklen); connect_socket = accept(server_socket, (struct sockaddr *)&client_addr, &socklen);
if (connect_socket<0) { if (connect_socket < 0) {
show_socket_error_reason(connect_socket); show_socket_error_reason("accept_server", connect_socket);
close(server_socket); close(server_socket);
return ESP_FAIL; return ESP_FAIL;
} }
/*connection established，now can send/recv*/ /*connection established，now can send/recv*/
ESP_LOGI(TAG, "tcp connection established!"); ESP_LOGI(TAG, "tcp connection established!");
@ -192,19 +217,19 @@ esp_err_t create_tcp_server()
esp_err_t create_tcp_client() esp_err_t create_tcp_client()
{ {
ESP_LOGI(TAG, "client socket....serverip:port=%s:%d\n", ESP_LOGI(TAG, "client socket....serverip:port=%s:%d\n",
EXAMPLE_DEFAULT_SERVER_IP, EXAMPLE_DEFAULT_PORT); EXAMPLE_DEFAULT_SERVER_IP, EXAMPLE_DEFAULT_PORT);
connect_socket = socket(AF_INET, SOCK_STREAM, 0); connect_socket = socket(AF_INET, SOCK_STREAM, 0);
if (connect_socket < 0) { if (connect_socket < 0) {
show_socket_error_reason(connect_socket); show_socket_error_reason("create client", connect_socket);
return ESP_FAIL; return ESP_FAIL;
} }
server_addr.sin_family = AF_INET; server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(EXAMPLE_DEFAULT_PORT); server_addr.sin_port = htons(EXAMPLE_DEFAULT_PORT);
server_addr.sin_addr.s_addr = inet_addr(EXAMPLE_DEFAULT_SERVER_IP); server_addr.sin_addr.s_addr = inet_addr(EXAMPLE_DEFAULT_SERVER_IP);
ESP_LOGI(TAG, "connecting to server..."); ESP_LOGI(TAG, "connecting to server...");
if (connect(connect_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) { if (connect(connect_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
show_socket_error_reason(connect_socket); show_socket_error_reason("client connect", connect_socket);
return ESP_FAIL; return ESP_FAIL;
} }
ESP_LOGI(TAG, "connect to server success!"); ESP_LOGI(TAG, "connect to server success!");
return ESP_OK; return ESP_OK;
@ -233,7 +258,7 @@ void wifi_init_sta()
ESP_LOGI(TAG, "wifi_init_sta finished."); ESP_LOGI(TAG, "wifi_init_sta finished.");
ESP_LOGI(TAG, "connect to ap SSID:%s password:%s \n", ESP_LOGI(TAG, "connect to ap SSID:%s password:%s \n",
EXAMPLE_DEFAULT_SSID,EXAMPLE_DEFAULT_PWD); EXAMPLE_DEFAULT_SSID, EXAMPLE_DEFAULT_PWD);
} }
//wifi_init_softap //wifi_init_softap
void wifi_init_softap() void wifi_init_softap()
@ -249,13 +274,13 @@ void wifi_init_softap()
.ap = { .ap = {
.ssid = EXAMPLE_DEFAULT_SSID, .ssid = EXAMPLE_DEFAULT_SSID,
.ssid_len = 0, .ssid_len = 0,
.max_connection=EXAMPLE_MAX_STA_CONN, .max_connection = EXAMPLE_MAX_STA_CONN,
.password = EXAMPLE_DEFAULT_PWD, .password = EXAMPLE_DEFAULT_PWD,
.authmode = WIFI_AUTH_WPA_WPA2_PSK .authmode = WIFI_AUTH_WPA_WPA2_PSK
}, },
}; };
if (strlen(EXAMPLE_DEFAULT_PWD) ==0) { if (strlen(EXAMPLE_DEFAULT_PWD) == 0) {
wifi_config.ap.authmode = WIFI_AUTH_OPEN; wifi_config.ap.authmode = WIFI_AUTH_OPEN;
} }
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP)); ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
@ -263,7 +288,7 @@ void wifi_init_softap()
ESP_ERROR_CHECK(esp_wifi_start()); ESP_ERROR_CHECK(esp_wifi_start());
ESP_LOGI(TAG, "wifi_init_softap finished.SSID:%s password:%s \n", ESP_LOGI(TAG, "wifi_init_softap finished.SSID:%s password:%s \n",
EXAMPLE_DEFAULT_SSID, EXAMPLE_DEFAULT_PWD); EXAMPLE_DEFAULT_SSID, EXAMPLE_DEFAULT_PWD);
} }
@ -273,17 +298,22 @@ int get_socket_error_code(int socket)
{ {
int result; int result;
u32_t optlen = sizeof(int); u32_t optlen = sizeof(int);
if(getsockopt(socket, SOL_SOCKET, SO_ERROR, &result, &optlen) == -1) { int err = getsockopt(socket, SOL_SOCKET, SO_ERROR, &result, &optlen);
ESP_LOGE(TAG, "getsockopt failed"); if (err == -1) {
return -1; ESP_LOGE(TAG, "getsockopt failed:%s", strerror(err));
return -1;
} }
return result; return result;
} }
int show_socket_error_reason(int socket) int show_socket_error_reason(const char *str, int socket)
{ {
int err = get_socket_error_code(socket); int err = get_socket_error_code(socket);
ESP_LOGW(TAG, "socket error %d %s", err, strerror(err));
if (err != 0) {
ESP_LOGW(TAG, "%s socket error %d %s", str, err, strerror(err));
}
return err; return err;
} }
@ -293,19 +323,21 @@ int check_working_socket()
#if EXAMPLE_ESP_TCP_MODE_SERVER #if EXAMPLE_ESP_TCP_MODE_SERVER
ESP_LOGD(TAG, "check server_socket"); ESP_LOGD(TAG, "check server_socket");
ret = get_socket_error_code(server_socket); ret = get_socket_error_code(server_socket);
if(ret != 0) { if (ret != 0) {
ESP_LOGW(TAG, "server socket error %d %s", ret, strerror(ret)); ESP_LOGW(TAG, "server socket error %d %s", ret, strerror(ret));
}
if (ret == ECONNRESET) {
return ret;
} }
if(ret == ECONNRESET)
return ret;
#endif #endif
ESP_LOGD(TAG, "check connect_socket"); ESP_LOGD(TAG, "check connect_socket");
ret = get_socket_error_code(connect_socket); ret = get_socket_error_code(connect_socket);
if(ret != 0) { if (ret != 0) {
ESP_LOGW(TAG, "connect socket error %d %s", ret, strerror(ret)); ESP_LOGW(TAG, "connect socket error %d %s", ret, strerror(ret));
}
if (ret != 0) {
return ret;
} }
if(ret != 0)
return ret;
return 0; return 0;
} }
@ -315,4 +347,3 @@ void close_socket()
close(server_socket); close(server_socket);
} }

13
examples/performance/tcp_perf/main/tcp_perf.h
View file

@ -46,13 +46,14 @@ extern "C" {
extern EventGroupHandle_t tcp_event_group; extern EventGroupHandle_t tcp_event_group;
#define WIFI_CONNECTED_BIT BIT0 #define WIFI_CONNECTED_BIT BIT0
extern int total_data; extern int g_total_data;
extern bool g_rxtx_need_restart;
#if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO #if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO
extern int total_pack; extern int g_total_pack;
extern int send_success; extern int g_send_success;
extern int send_fail; extern int g_send_fail;
extern int delay_classify[5]; extern int g_delay_classify[5];
#endif/*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/ #endif/*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/
@ -78,7 +79,7 @@ void close_socket();
int get_socket_error_code(int socket); int get_socket_error_code(int socket);
//show socket error code. return: error code //show socket error code. return: error code
int show_socket_error_reason(int socket); int show_socket_error_reason(const char* str, int socket);
//check working socket //check working socket
int check_working_socket(); int check_working_socket();