F4107单进程处理多个usart中断接收到的数据

解决:Cortex-M4上，usart自动发送数据方案。


    1. usart中断太快。数据还没有处理完。usart中断就会把没处理完的数据上该覆盖掉。导致数据丢失。

	2.这程序需要在main中处理4个usart口的数据，这样出错的概率会更大。

提出如下解决方案：
	第一：规定每条完成的数据长度，步会超过256字节。
	第二：我们规定数据的结束表标志为数据的后三位为,FFFFFF
	第三：定义一个全局的数据，他是一个三维数组该数据用来存放4个usart口发上来的数据。


uint8_t usart_data[4][5][256];
	下面解析为什么要定义一个三维数组：
	
	第一个下标4：它分别用来接受不同的usart口的数据。
	第二个下标5：它表示每个usart最多能缓存的数据条数是5.
	第三个下标256：它用来表示最多一条数据能存256个字节。

下面是程序如果实现。

	定义如下变量：
		一:接受usart数据缓冲器的定义。它是一个全局的三维数据
			uint8_t usart_data[4][5][256] = {0};
		
		二:记录每个usart口，当前接收到的数据条数。
			uint8_t data_in_count[4]={0};  
		
		三:记录当前接受到的数据数。
			uint8_t data_len[4] = {0};
		
		四:用来记录出错的次数。
			uint8_t error_count = 0;
	
		五:记录每个usart口，当前处理完的数据。
			uint8_t data_out_count[4];


void UART_DATA_handle(uint8_t route)
{

	if(data_in_count[route]<5)
	{

		if((usart_data[route][data_in_count[route]][data_len[route]-3]==0xFF) 
				&&(usart_data[route][data_in_count[route]][data_len[route]-2]==0xFF)
				&&(usart_data[route][data_in_count[route]][data_len[route]-1]==0xFF))
		{


			if(usart_data[route][data_in_count[route]][0]==data_len[route])
			{
				data_in_count[route]++;
				data_len[route] = 0;
				if(data_in_count[route]>5)
				{
					data_in_count[route]=5;
				}
				else
				{
					error_count++;
				}
			}
		}
	}
}

void USART1_IRQHANDLER(void)
{
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
	{
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);                                
		
		usart_data[0][data_in_cout[0]][data_len[0]++] = USART_Rece_Data(USART1);
		if(data_len[0]>2)
		{

			usart_data_route(0);
		}
	}
	return;
}


void USART2_IRQHANDLER(void)
{
	if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
	{
		USART_ClearITPendingBit(USART2, USART_IT_RXNE);                         	
		usart_data[1][data_in_cout[1]][data_len[1]++] = USART_Rece_Data(USART2);
		if(data_len[1]>2)
		{
		  usart_data_route(1);
		}
	}
	return;
}

void USART3_IRQHANDLER(void)
{
	if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
	{
		USART_ClearITPendingBit(USART3, USART_IT_RXNE);                         	
		usart_data[2][data_in_count[2]][data_len[2]++] = USART_Rece_Data(USART3);
		if(data_len[2]>2)
		{
		  usart_data_route(2);
		}
	}
	return;
}

void USART4_IRQHANDLER(void)
{
	if(USART_GetITStatus(USART4, USART_IT_RXNE) != RESET)
	{
		USART_ClearITPendingBit(USART4, USART_IT_RXNE);                         	
		usart_data[3][data_in_count[3]][data_len[3]++] = USART_Rece_Data(USART4);
		if(data_len[3]>2)
		{
		  usart_data_route(3);
		}
	}
	return;
}

/****main*******/

uint8_t tmp[512] = {0};

static __INLINE void process_usartdata(uint8_t *tmpdata, uint8_t *usartdata, char *usart_format, int flag){
	int tmp =0,count=0,i=0;
	memset(tmpdata,0x00,512);
	printf(usart_format,flag);
	for(i=0;i<usartdata[0]+1;i++){
		tmp = sprintf(&tmpdata[count],"%02X", *(usartdata+i));
		count += tmp;  
	} 
	memset(usartdata,0x00,256);
	printf(tmpdata);
}



int main(void)
{	.........
	uint8_t i = 0;
	while(1)
	{
		for(i=0;i<4;i++)
		{	

			if(data_in_count[i]>0){
				process_usartdata(tmp,usart_data[i][data_out_count[i]],"usart:%d",i);	
			}
			data_in_count[i]--;
			data_out_count[i]++;
			if(data_out_count[i]>5) 
			{
				data_out_count[i] = 0;
			}
		}
	}
	........
}

F4107单进程处理多个usart中断接收到的数据

原文：http://blog.csdn.net/shaohuazuo/article/details/39474237