freertos中STM32的网络信息发送

之前进行网络通信的时候发现了数据丢包问题，刚好今天周五（你懂得），把解决方法贴出来帮助初学者避坑，开始使用的是正点原子的官方例程，发送函数如下

void tcp_server_send(u8 *buf,u16 len)
{
	memcpy(tcp_server_sendbuf,buf,len);
	tcp_server_SendSize=len;
	tcp_server_flag |= LWIP_SEND_DATA; //标记LWIP有数据要发送
	
}
if((tcp_server_flag & LWIP_SEND_DATA) == LWIP_SEND_DATA) //有数据要发送
				{
					err = netconn_write(newconn ,tcp_server_sendbuf,tcp_server_SendSize,NETCONN_COPY); //发送tcp_server_sendbuf中的数据
					if(err != ERR_OK)
					{
						printf("发送失败\r\n");
						netconn_close(newconn);
						netconn_delete(newconn);
						printf("主机:%d.%d.%d.%d断开与服务器的连接\r\n",remot_addr[0], remot_addr[1],remot_addr[2],remot_addr[3]);
						break;
					}
					tcp_server_flag &= ~LWIP_SEND_DATA;
				}

其在调用tcp_server_send函数时，将消息复制进数组中，然后进行标志位置位，在任务中去判断标志位，发现标志位置位则将缓冲区中的数据发送出去。但是这样存在一个问题，即短时间内多次调用tcp_server_send函数会导致消息漏发，使用队列对其进行改善，发现问题解决，代码如下：

#include "tcp_server_demo.h"
#include "lwip/opt.h"
#include "lwip_comm.h"
#include "led.h"
#include "lwip/lwip_sys.h"
#include "lwip/api.h"
#include "DataPacket.h"

u8 tcp_server_recvbuf[TCP_SERVER_RX_BUFSIZE];	//TCP客户端接收数据缓冲区
u8 tcp_server_sendbuf[TCP_SERVER_SEND_LEN][TCP_SERVER_RX_BUFSIZE]; //TCP客户端接发送据缓冲区
u8 tcp_server_flag;								//TCP服务器数据发送标志位
u16 tcp_server_SendSize[20];		//TCP服务器数据发送标志位

//任务优先级
#define TCP_SERVER_TASK_PRIO	10
//任务堆栈大小	
#define TCP_SERVER_STK_SIZE 	1024
//任务句柄
TaskHandle_t tcp_serverTask_Handler;
//任务函数
void tcp_server_thread(void *p_arg);

err_t err=1;

//TCP服务器数据发送


QueueHandle_t	TCP_SEND_Queue;	//创建TCP发送队列句柄


typedef	struct{
	u8 SEND_buf[100];
	u32 len;
}TCP_SEND_STRUCT;


void tcp_server_send(u8 *buf,u16 len)
{
	BaseType_t sta;
	TCP_SEND_STRUCT *TCP_SEND_Data;	//队列结构体
	//如果网络已连接且队列有剩余空间
	if((err == ERR_OK)&&(uxQueueMessagesWaiting(TCP_SEND_Queue) < TCP_SEND_QUEUE_NUM))	
	{
		TCP_SEND_Data = pvPortMalloc(sizeof(TCP_SEND_STRUCT));	//开辟一个结构体空间
		memcpy(TCP_SEND_Data->SEND_buf, buf, len);
		TCP_SEND_Data->len = len;
		if(TCP_SEND_Queue != 0)
		{
			// 发送消息
			// 参数 1 : 队列句柄
			// 参数 2 ： 队列内容指针
			// 参数 3 ： 允许阻塞时间
			sta = xQueueSend(TCP_SEND_Queue,&TCP_SEND_Data,0);	//入队
			if (sta == errQUEUE_FULL)
			{
				vPortFree(TCP_SEND_Data);
				printf("QTCPsend ERR!=FULL\r\n");
			}
		}
	}
	
}

//tcp服务器任务
static void tcp_server_thread(void *arg)
{
	u32 data_len = 0;
	struct pbuf *q;
	err_t recv_err;
	u8 remot_addr[4];
	struct netconn *conn, *newconn;
	static ip_addr_t ipaddr;
	static u16_t 			port;
	
	TCP_SEND_STRUCT *TCP_SEND_DATA;	//队列结构体
	
	
	LWIP_UNUSED_ARG(arg);

	conn = netconn_new(NETCONN_TCP);  //创建一个TCP链接
	netconn_bind(conn,IP_ADDR_ANY,TCP_SERVER_PORT);  //绑定端口 8号端口
	netconn_listen(conn);  		//进入监听模式
	conn->recv_timeout = 10;  	//禁止阻塞线程 等待10ms
	while (1) 
	{
		err = netconn_accept(conn,&newconn);  //接收连接请求
		if(err==ERR_OK)newconn->recv_timeout = 10;

		if (err == ERR_OK)    //处理新连接的数据
		{ 
			struct netbuf *recvbuf;

			netconn_getaddr(newconn,&ipaddr,&port,0); //获取远端IP地址和端口号
			
			remot_addr[3] = (uint8_t)(ipaddr.addr >> 24); 
			remot_addr[2] = (uint8_t)(ipaddr.addr>> 16);
			remot_addr[1] = (uint8_t)(ipaddr.addr >> 8);
			remot_addr[0] = (uint8_t)(ipaddr.addr);
			printf("主机%d.%d.%d.%d连接上服务器,主机端口号为:%d\r\n",remot_addr[0], remot_addr[1],remot_addr[2],remot_addr[3],port);
			
			while(1)
			{
				if(xQueueReceive(TCP_SEND_Queue, &TCP_SEND_DATA, (TickType_t)0)) // 接收消息// 参数 1 : 队列句柄// 参数 2 ： 队列内容返回保存指针// 参数 3 ： 允许阻塞时间
				{
					err = netconn_write(newconn ,TCP_SEND_DATA->SEND_buf,TCP_SEND_DATA->len,NETCONN_COPY); //发送队列中的数据
					if(err != ERR_OK)
					{
						printf("发送失败\r\n");
						netconn_close(newconn);
						netconn_delete(newconn);
						printf("主机:%d.%d.%d.%d断开与服务器的连接\r\n",remot_addr[0], remot_addr[1],remot_addr[2],remot_addr[3]);
						break;
					}
					vPortFree(TCP_SEND_DATA); //消息队列传递的是指针，所以这里释放
				}
				
				if((recv_err = netconn_recv(newconn,&recvbuf)) == ERR_OK)  	//接收到数据
				{		
					taskENTER_CRITICAL();           //进入临界区
					memset(tcp_server_recvbuf,0,TCP_SERVER_RX_BUFSIZE);  //数据接收缓冲区清零
					for(q=recvbuf->p;q!=NULL;q=q->next)  //遍历完整个pbuf链表
					{
						//判断要拷贝到TCP_SERVER_RX_BUFSIZE中的数据是否大于TCP_SERVER_RX_BUFSIZE的剩余空间，如果大于
						//的话就只拷贝TCP_SERVER_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据
						if(q->len > (TCP_SERVER_RX_BUFSIZE-data_len)) memcpy(tcp_server_recvbuf+data_len,q->payload,(TCP_SERVER_RX_BUFSIZE-data_len));//拷贝数据
						else memcpy(tcp_server_recvbuf+data_len,q->payload,q->len);
						data_len += q->len;  	
						if(data_len > TCP_SERVER_RX_BUFSIZE) break; //超出TCP客户端接收数组,跳出	
					}
					taskEXIT_CRITICAL();            //退出临界区
					unpack_data(tcp_server_recvbuf,data_len);//数据解析
					data_len=0;  //复制完成后data_len要清零。	
					netbuf_delete(recvbuf);
				}else if(recv_err == ERR_CLSD)  //关闭连接
				{
					netconn_close(newconn);
					netconn_delete(newconn);
					printf("主机:%d.%d.%d.%d断开与服务器的连接\r\n",remot_addr[0], remot_addr[1],remot_addr[2],remot_addr[3]);
					break;
				}
			}
		}
	}
}


//创建TCP服务器线程
//返回值:0 TCP服务器创建成功
//		其他 TCP服务器创建失败
u8 tcp_server_init(void)
{

	
	taskENTER_CRITICAL();           //进入临界区
	
	//创建队列,队列数量为TCP_SEND_QUEUE_NUM,每条消息长度为TCP_SERVER_RX_BUFSIZE
	TCP_SEND_Queue = xQueueCreate(TCP_SEND_QUEUE_NUM,sizeof(TCP_SEND_STRUCT *));
	
	xTaskCreate((TaskFunction_t )tcp_server_thread,             
                (const char*    )"tcp_server_thread",           
                (uint16_t       )TCP_SERVER_STK_SIZE,        
                (void*          )NULL,                  
                (UBaseType_t    )TCP_SERVER_TASK_PRIO,        
                (TaskHandle_t*  )&tcp_serverTask_Handler);   //创建TCP服务器线程
	taskEXIT_CRITICAL();            //退出临界区
	
	return 0;
}