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

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

@ -36,74 +36,90 @@ 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)
{ {
while (1) {
g_rxtx_need_restart = false;
ESP_LOGI(TAG, "task tcp_conn."); ESP_LOGI(TAG, "task tcp_conn.");
/*wating for connecting to AP*/ /*wating for connecting to AP*/
xEventGroupWaitBits(tcp_event_group, WIFI_CONNECTED_BIT, false, true, portMAX_DELAY); xEventGroupWaitBits(tcp_event_group, WIFI_CONNECTED_BIT, false, true, portMAX_DELAY);
ESP_LOGI(TAG, "sta has connected to ap."); ESP_LOGI(TAG, "sta has connected to ap.");
/*create tcp socket*/ int socket_ret = ESP_FAIL;
int socket_ret;
TaskHandle_t tx_rx_task = NULL;
#if EXAMPLE_ESP_TCP_MODE_SERVER #if EXAMPLE_ESP_TCP_MODE_SERVER
if (socket_ret == ESP_FAIL) {
/*create tcp socket*/
ESP_LOGI(TAG, "tcp_server will start after 3s..."); ESP_LOGI(TAG, "tcp_server will start after 3s...");
vTaskDelay(3000 / portTICK_RATE_MS); vTaskDelay(3000 / portTICK_RATE_MS);
ESP_LOGI(TAG, "create_tcp_server."); ESP_LOGI(TAG, "create_tcp_server.");
socket_ret = create_tcp_server(); socket_ret = create_tcp_server();
}
#else /*EXAMPLE_ESP_TCP_MODE_SERVER*/ #else /*EXAMPLE_ESP_TCP_MODE_SERVER*/
if (socket_ret == ESP_FAIL) {
ESP_LOGI(TAG, "tcp_client will start after 20s..."); ESP_LOGI(TAG, "tcp_client will start after 20s...");
vTaskDelay(20000 / portTICK_RATE_MS); vTaskDelay(20000 / portTICK_RATE_MS);
ESP_LOGI(TAG, "create_tcp_client."); ESP_LOGI(TAG, "create_tcp_client.");
socket_ret = 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) {
#else /*EXAMPLE_ESP_TCP_PERF_TX*/ if (pdPASS != xTaskCreate(&send_data, "send_data", 4096, NULL, 4, &tx_rx_task)) {
xTaskCreate(&recv_data, "recv_data", 4096, NULL, 4, &tx_rx_task); ESP_LOGE(TAG, "Send task create fail!");
#endif
int bps;
while (1) {
total_data = 0;
vTaskDelay(3000 / portTICK_RATE_MS);//every 3s
bps = total_data / 3;
if (total_data <= 0) {
int err_ret = check_working_socket();
if (err_ret == ECONNRESET || ECONNABORTED) {
ESP_LOGW(TAG, "tcp disconnected... stop.\n");
break;
} }
} }
#else /*EXAMPLE_ESP_TCP_PERF_TX*/
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
double bps;
while (1) {
g_total_data = 0;
vTaskDelay(3000 / portTICK_RATE_MS);//every 3s
bps = (g_total_data * 8.0 / 3.0) / 1000000.0;
if (g_rxtx_need_restart) {
printf("send or receive task encoutner error, need to restart\n");
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)
{ {

137
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*/
@ -83,7 +84,7 @@ 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...");
@ -94,65 +95,88 @@ void send_data(void *pvParameters)
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
delay_classify[4]++;
#endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/
} else { } else {
g_delay_classify[4]++;
#if EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO }
send_fail++;
#endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/ #endif /*EXAMPLE_ESP_TCP_PERF_TX && EXAMPLE_ESP_TCP_DELAY_INFO*/
} else {
break;
}
}
g_rxtx_need_restart = true;
free(databuff);
vTaskDelete(NULL);
}
if (LOG_LOCAL_LEVEL >= ESP_LOG_DEBUG) {
show_socket_error_reason(connect_socket);
}
} /*if(len > 0)*/
}
}
//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;
while (to_recv > 0) {
len = recv(connect_socket, databuff + (EXAMPLE_DEFAULT_PKTSIZE - to_recv), to_recv, 0);
if (len > 0) { if (len > 0) {
total_data += len; g_total_data += len;
to_recv -= len;
} else { } else {
if (LOG_LOCAL_LEVEL >= ESP_LOG_DEBUG) { show_socket_error_reason("recv_data", connect_socket);
show_socket_error_reason(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,25 +186,26 @@ 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;
} }
@ -195,7 +220,7 @@ esp_err_t create_tcp_client()
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;
@ -203,7 +228,7 @@ esp_err_t create_tcp_client()
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!");
@ -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) {
ESP_LOGE(TAG, "getsockopt failed:%s", strerror(err));
return -1; 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;
} }
@ -296,16 +326,18 @@ int check_working_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) if (ret == ECONNRESET) {
return ret; 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) if (ret != 0) {
return ret; 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();