现在USART接受上遇到两个问题，想请教一下。
1. USART参数设为 19200 + 8Bit + Even + 1 Stop. 用 IRNE 中断来接受从串口来的字符输入。
   现在能接收到IRNE的中断并能正确读到字符，但是中断例程里同时能检测到帧错误（FE）或者校验错误（PE）。
   而且有这样的规律，若键入字符ASCII码为EVEN位数，则报PE，如果是ODD位数则包FE。
   请问有谁知道这种问题的是什么原因吗？

2. 还是USART接受字符问题。配置同上，接收字串在IRNE中断例程里读取单字节数据。正常串口输入能接收到正确字符，现象同1。
   如果用串口助手发送一串字符串，如“ABCDEFG”，中断里总是检测到 ORE的错误，并且会丢到几个字符。之前以为是系统时钟频率低导致的，
   于是将系统时钟频率由2MHz升到32MHz,问题依旧。请问这是什么原因？

附代码（stm32L07x）：

1. void USARTx_IRQHandler(void)
   
2. {
   
3.         iCnt++;
   
4.         USART_FUNCTION_ISR = 0;          
   
5.         if (LL_USART_IsActiveFlag_RXNE(USARTx_INSTANCE) && LL_USART_IsEnabledIT_RXNE(USARTx_INSTANCE))
   
6.         {
   
7.                 uiRxByte = (uint32_t)LL_USART_ReceiveData8(USARTx_INSTANCE);
   
8.                   //LL_USART_TransmitData8(USARTx_INSTANCE, (uint8_t) uiRxByte);
   
9.                   //LL_USART_TransmitData8(USARTx_DEBUG_INSTANCE, (uint8_t) uiRxByte);
   
10.                   //printf("(%d)-rev(0x%02x)\n",iCnt, uiRxByte);
    
11.                 USART_FUNCTION_ISR |= USART_ISR_RXNE_Msk;
    
12. 
    
13.         }
    
14.         if (LL_USART_IsActiveFlag_TXE(USARTx_INSTANCE) && LL_USART_IsEnabledIT_TXE(USARTx_INSTANCE))
    
15.         {
    
16.                    USART_FUNCTION_ISR |= USART_ISR_TXE_Msk;
    
17.                    //printf ("(%d)-USARTx_IRQHandler-LL_USART_IsActiveFlag_TXE\n",iCnt);
    
18.         }
    
19.         if (LL_USART_IsActiveFlag_ORE(USARTx_INSTANCE))
    
20.         {
    
21.                    //printf("(%d)-OVERUN happened\n",iCnt);
    
22.                    LL_USART_ClearFlag_ORE(USARTx_INSTANCE);
    
23.                           LL_USART_ReceiveData8(USARTx_INSTANCE);
    
24.                    USART_FUNCTION_ISR |= USART_ISR_ORE_Msk;
    
25.         }
    
26.         if (LL_USART_IsActiveFlag_NE(USARTx_INSTANCE))
    
27.         {
    
28.                           //printf("(%d)-Noise detected\n", iCnt);
    
29.                    LL_USART_ClearFlag_NE(USARTx_INSTANCE);
    
30.                           //LL_USART_ReceiveData8(USARTx_INSTANCE);
    
31.                    USART_FUNCTION_ISR |= USART_ISR_NE_Msk;
    
32.         }
    
33.         if (LL_USART_IsActiveFlag_FE(USARTx_INSTANCE))
    
34.         {
    
35.                    //printf("(%d)-Frame Error\n",iCnt);
    
36.                    LL_USART_ClearFlag_FE(USARTx_INSTANCE);
    
37.                           //LL_USART_ReceiveData8(USARTx_INSTANCE);
    
38.                    USART_FUNCTION_ISR |= USART_ISR_FE_Msk;
    
39.         }
    
40.         if (LL_USART_IsActiveFlag_PE(USARTx_INSTANCE))
    
41.         {
    
42.        //printf("(%d)-Parity Error\n",iCnt);
    
43.                    LL_USART_ClearFlag_PE(USARTx_INSTANCE);
    
44.                           //LL_USART_ReceiveData8(USARTx_INSTANCE);
    
45.                    USART_FUNCTION_ISR |= USART_ISR_PE_Msk;
    
46.         }
    
47. }
    
48. 
    
49. void USART_Init(       \
    
50.         uint32_t uiBoudRate,  \
    
51.         uint32_t uiDataWidth, \
    
52.         uint32_t uiParity,    \
    
53.         uint32_t uiStopBits)
    
54. {
    
55.     //TODO: Parameters checking
    
56. 
    
57.     /* (1) Enable GPIO clock and configures the USART pins *********************/
    
58. 
    
59.     /* Enable the peripheral clock of GPIO Port */
    
60.     USARTx_GPIO_CLK_ENABLE();
    
61. 
    
62.     /* Configure Tx Pin as : Alternate function, High Speed, Push pull, Pull up */
    
63.     LL_GPIO_SetPinMode(USARTx_TX_GPIO_PORT, USARTx_TX_PIN, LL_GPIO_MODE_ALTERNATE);
    
64.     USARTx_SET_TX_GPIO_AF();
    
65.     LL_GPIO_SetPinSpeed(USARTx_TX_GPIO_PORT, USARTx_TX_PIN, LL_GPIO_SPEED_FREQ_HIGH);
    
66.     LL_GPIO_SetPinOutputType(USARTx_TX_GPIO_PORT, USARTx_TX_PIN, LL_GPIO_OUTPUT_PUSHPULL);
    
67.     LL_GPIO_SetPinPull(USARTx_TX_GPIO_PORT, USARTx_TX_PIN, LL_GPIO_PULL_UP);
    
68. 
    
69.     /* Configure Rx Pin as : Alternate function, High Speed, Push pull, Pull up */
    
70.     LL_GPIO_SetPinMode(USARTx_RX_GPIO_PORT, USARTx_RX_PIN, LL_GPIO_MODE_ALTERNATE);
    
71.     USARTx_SET_RX_GPIO_AF();
    
72.     LL_GPIO_SetPinSpeed(USARTx_RX_GPIO_PORT, USARTx_RX_PIN, LL_GPIO_SPEED_FREQ_HIGH);
    
73.     LL_GPIO_SetPinOutputType(USARTx_RX_GPIO_PORT, USARTx_RX_PIN, LL_GPIO_OUTPUT_PUSHPULL);
    
74.     LL_GPIO_SetPinPull(USARTx_RX_GPIO_PORT, USARTx_RX_PIN, LL_GPIO_PULL_UP);
    
75. 
    
76.     /* (2) NVIC Configuration for USART interrupts */
    
77.     /*  - Set priority for USARTx_IRQn */
    
78.     /*  - Enable USARTx_IRQn */
    
79.     NVIC_SetPriority(USARTx_IRQn, 0);
    
80.     NVIC_EnableIRQ(USARTx_IRQn);
    
81. 
    
82.     /* (2) Enable USART peripheral clock and clock source ***********************/
    
83.     USARTx_CLK_ENABLE();
    
84. 
    
85.     /* Set clock source */
    
86.     USARTx_CLK_SOURCE();
    
87. 
    
88.     /* (3) Configure USART functional parameters ********************************/
    
89. 
    
90.     /* Disable USART prior modifying configuration registers */
    
91.     /* Note: Commented as corresponding to Reset value */
    
92.     LL_USART_Disable(USARTx_INSTANCE);
    
93. 
    
94.     /* TX/RX direction */
    
95.     LL_USART_SetTransferDirection(USARTx_INSTANCE, LL_USART_DIRECTION_TX_RX);
    
96. 
    
97.     /* 8 data bit, 1 start bit, 1 stop bit, no parity */
    
98.     LL_USART_ConfigCharacter(USARTx_INSTANCE, uiDataWidth, uiParity, uiStopBits);
    
99. 
    
100.     LL_USART_SetBaudRate(USARTx_INSTANCE, SystemCoreClock, LL_USART_OVERSAMPLING_16, uiBoudRate);
     
101. 
     
102.     /* (4) Enable USART *********************************************************/
     
103.     LL_USART_Enable(USARTx_INSTANCE);
     
104. 
     
105.     /* Polling USART initialisation */
     
106.     while((!(LL_USART_IsActiveFlag_TEACK(USARTx_INSTANCE))) || (!(LL_USART_IsActiveFlag_REACK(USARTx_INSTANCE))))
     
107.     {
     
108.     }
     
109. 
     
110.     /* Enable RXNE and Error interrupts */
     
111.     LL_USART_EnableIT_ERROR(USARTx_INSTANCE);
     
112. }
     
113. 
     
114. void main(void)
     
115. {
     
116.    ...
     
117.     while(1)
     
118.     {
     
119.                if (i == iCnt) continue;
     
120.              
     
121.                __disable_irq();
     
122.                       i = iCnt;
     
123.                if (pSerialGetByte(&cReadByte))
     
124.                      {
     
125.                                printf("(%d) - Read(0x%02x)\n", i , cReadByte);
     
126.                      }
     
127.                      if (USART_ISR_TXE_Msk & USART_FUNCTION_ISR)
     
128.                      {
     
129.                                        printf("(%d) - USART_ISR_TXE_Msk\n", i );
     
130.                      }
     
131.                      if (USART_ISR_ORE_Msk & USART_FUNCTION_ISR)
     
132.                      {
     
133.                                        printf("(%d) - USART_ISR_ORE_Msk\n", i );
     
134.                      }
     
135.                      if (USART_ISR_FE_Msk & USART_FUNCTION_ISR)
     
136.                      {
     
137.                                              printf("(%d) - USART_ISR_FE_Msk\n", i );
     
138.                      }
     
139.                      if (USART_ISR_NE_Msk & USART_FUNCTION_ISR)
     
140.                      {
     
141.                                              printf("(%d) - USART_ISR_NE_Msk\n", i );
     
142.                      }
     
143.                      if (USART_ISR_PE_Msk & USART_FUNCTION_ISR)
     
144.                      {
     
145.                                              printf("(%d) - USART_ISR_PE_Msk\n", i );
     
146.                      }
     
147.                      __enable_irq();
     
148.     }
     
149. }

复制代码

可能是处理时间已经过载，或是接收标志位没清除之类的配置问题。有人说，出现ORE错误是因为上一帧数据未取走下一帧数据就来了，可以尝试2个方向解决问题：1降低波特率，2，改用DMA方式

LL_USART_ReceiveData8 这个函数是不是一次只能接收一个字节？
如果是的话，那么问题来了：按照楼主的说法，用串口助手发送一串字符串，如“ABCDEFG”，这是多个字节，如果中断处理函数没有一个字节处理完再打开中断处理 下一个字节，肯定是有问题的。


当我授渔好了，根据 官方 例程“stm32cube_fw_f1_v160.zip”（下载官方软件STM32CubeMX底下搜索路径“STM32Cube\Repository”，L0系列也有自己找）
路径下找到自己要的应用例程，例如楼主找 LL库下用 串口中断方式通讯，而且是连续不断的打开中断处理，那么找路径“Cube_FW_F1_V1.6.0\Projects\STM32F103RB-Nucleo\Examples_LL\USART\USART_Communication_Rx_IT_Continuous\MDK-ARM”下点击“Project.uvprojx”打开工程。
官方的串口中断处理回调函数是这样的，参考一下：

1. void USART_CharReception_Callback(void)
   
2. {
   
3. uint8_t *ptemp;
   
4. 
   
5.   /* Read Received character. RXNE flag is cleared by reading of DR register */
   
6.   pBufferReadyForReception[uwNbReceivedChars++] = LL_USART_ReceiveData8(USARTx_INSTANCE);
   
7. 
   
8.   /* Checks if Buffer full indication has been set */
   
9.   if (uwNbReceivedChars >= RX_BUFFER_SIZE)
   
10.   {
    
11.     /* Set Buffer swap indication */
    
12.     uwBufferReadyIndication = 1;
    
13. 
    
14.     /* Swap buffers for next bytes to be received */
    
15.     ptemp = pBufferReadyForUser;
    
16.     pBufferReadyForUser = pBufferReadyForReception;
    
17.     pBufferReadyForReception = ptemp;
    
18.     uwNbReceivedChars = 0;
    
19.   }
    
20. }

复制代码

官方有轮子，就不需要自己造轮子，关注怎么用官方给的轮子去造车子就好了。

__disable_irq(); 不能关闭中断,这样来数据时就会丢失数据