1. 解决:Cortex-M4上，usart自动发送数据方案。  
2.   
3.   
4.     1. usart中断太快。数据还没有处理完。usart中断就会把没处理完的数据上该覆盖掉。导致数据丢失。  
5.   
6.     2.这程序需要在main中处理4个usart口的数据，这样出错的概率会更大。  
7.   
8. 提出如下解决方案：  
9.     第一：规定每条完成的数据长度，步会超过256字节。  
10.     第二：我们规定数据的结束表标志为数据的后三位为,FFFFFF  
11.     第三：定义一个全局的数据，他是一个三维数组该数据用来存放4个usart口发上来的数据。  
12.   
13.   
14. uint8_t usart_data[4][5][256];  
15.     下面解析为什么要定义一个三维数组：  
16.       
17.     第一个下标4：它分别用来接受不同的usart口的数据。  
18.     第二个下标5：它表示每个usart最多能缓存的数据条数是5.  
19.     第三个下标256：它用来表示最多一条数据能存256个字节。  
20.   
21. 下面是程序如果实现。  
22.   
23.     定义如下变量：  
24.         一:接受usart数据缓冲器的定义。它是一个全局的三维数据  
25.             uint8_t usart_data[4][5][256] = {0};  
26.           
27.         二:记录每个usart口，当前接收到的数据条数。  
28.             uint8_t data_in_count[4]={0};    
29.           
30.         三:记录当前接受到的数据数。  
31.             uint8_t data_len[4] = {0};  
32.           
33.         四:用来记录出错的次数。  
34.             uint8_t error_count = 0;  
35.       
36.         五:记录每个usart口，当前处理完的数据。  
37.             uint8_t data_out_count[4];  
38.   
39.   
40. void UART_DATA_handle(uint8_t route)  
41. {  
42.   
43.     if(data_in_count[route]<5)  
44.     {  
45.   
46.         if((usart_data[route][data_in_count[route]][data_len[route]-3]==0xFF)   
47.                 &&(usart_data[route][data_in_count[route]][data_len[route]-2]==0xFF)  
48.                 &&(usart_data[route][data_in_count[route]][data_len[route]-1]==0xFF))  
49.         {  
50.   
51.   
52.             if(usart_data[route][data_in_count[route]][0]==data_len[route])  
53.             {  
54.                 data_in_count[route]++;  
55.                 data_len[route] = 0;  
56.                 if(data_in_count[route]>5)  
57.                 {  
58.                     data_in_count[route]=5;  
59.                 }  
60.                 else  
61.                 {  
62.                     error_count++;  
63.                 }  
64.             }  
65.         }  
66.     }  
67. }  
68.   
69. void USART1_IRQHANDLER(void)  
70. {  
71.     if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  
72.     {  
73.         USART_ClearITPendingBit(USART1, USART_IT_RXNE);                                  
74.           
75.         usart_data[0][data_in_cout[0]][data_len[0]++] = USART_Rece_Data(USART1);  
76.         if(data_len[0]>2)  
77.         {  
78.   
79.             usart_data_route(0);  
80.         }  
81.     }  
82.     return;  
83. }  
84.   
85.   
86. void USART2_IRQHANDLER(void)  
87. {  
88.     if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)  
89.     {  
90.         USART_ClearITPendingBit(USART2, USART_IT_RXNE);                               
91.         usart_data[1][data_in_cout[1]][data_len[1]++] = USART_Rece_Data(USART2);  
92.         if(data_len[1]>2)  
93.         {  
94.           usart_data_route(1);  
95.         }  
96.     }  
97.     return;  
98. }  
99.   
100. void USART3_IRQHANDLER(void)  
101. {  
102.     if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  
103.     {  
104.         USART_ClearITPendingBit(USART3, USART_IT_RXNE);                               
105.         usart_data[2][data_in_count[2]][data_len[2]++] = USART_Rece_Data(USART3);  
106.         if(data_len[2]>2)  
107.         {  
108.           usart_data_route(2);  
109.         }  
110.     }  
111.     return;  
112. }  
113.   
114. void USART4_IRQHANDLER(void)  
115. {  
116.     if(USART_GetITStatus(USART4, USART_IT_RXNE) != RESET)  
117.     {  
118.         USART_ClearITPendingBit(USART4, USART_IT_RXNE);                               
119.         usart_data[3][data_in_count[3]][data_len[3]++] = USART_Rece_Data(USART4);  
120.         if(data_len[3]>2)  
121.         {  
122.           usart_data_route(3);  
123.         }  
124.     }  
125.     return;  
126. }  
127.   
128. /****main*******/  
129.   
130. uint8_t tmp[512] = {0};  
131.   
132. static __INLINE void process_usartdata(uint8_t *tmpdata, uint8_t *usartdata, char *usart_format, int flag){  
133.     int tmp =0,count=0,i=0;  
134.     memset(tmpdata,0x00,512);  
135.     printf(usart_format,flag);  
136.     for(i=0;i<usartdata[0]+1;i++){  
137.         tmp = sprintf(&tmpdata[count],"%02X", *(usartdata+i));  
138.         count += tmp;    
139.     }   
140.     memset(usartdata,0x00,256);  
141.     printf(tmpdata);  
142. }  
143.   
144.   
145.   
146. int main(void)  
147. {   .........  
148.     uint8_t i = 0;  
149.     while(1)  
150.     {  
151.         for(i=0;i<4;i++)  
152.         {     
153.   
154.             if(data_in_count[i]>0){  
155.                 process_usartdata(tmp,usart_data[i][data_out_count[i]],"usart:%d",i);     
156.             }  
157.             data_in_count[i]--;  
158.             data_out_count[i]++;  
159.             if(data_out_count[i]>5)   
160.             {  
161.                 data_out_count[i] = 0;  
162.             }  
163.         }  
164.     }  
165.     ........  

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