问题表现
在MCU系统负载较重、串口收发数据频率很高、多个中断存在（如同时有定时器更新中断、外部中断、DMA中断、串口接收中断）的情况下，容易出现串口溢出错误（ORE）。该错误的主要显现形式是：程序莫名卡死在串口中断之中（单片机失去响应）。

解决方法
ORE标志位在USART_SR寄存器，当我们打开串口接收中断时，同时也就打开了ORE中断，串口的overload错误会导致程序反复进入串口中断服务程序。在中断服务程序中增加处理overload的处理，顺序执行对USART_SR和USART_DR寄存器的读操作可以复位ORE位，以防止程序反复进入串口中断服务程序。示例代码如下：

& d- Y- `# e3 T' C在STM32中断函数增加USART_IT_ORE等异常中断的处理，执行USART_GetFlagStatus(USART1, USART_FLAG_ORE)，会对USART_SR进行了一次读操作，然后再执行USART_ReceiveByte(USART1)，会对USART_DR进行一次读操作，从而复位了ORE位。
* Q3 ]) p' e1 x$ D- t+ D
! L% A$ z6 p+ X; {9 N7 |! X4 l/**
6 y; E0 S" ~2 m$ q. O( N  * @brief  Checks whether the specified USART flag is set or not.
  * @param  USARTx: Select the USART or the UART peripheral.
  *   This parameter can be one of the following values:
  *   USART1, USART2, USART3, UART4 or UART5.
/ h: r5 |5 b+ n4 p5 |  * @param  USART_FLAG: specifies the flag to check.
  *   This parameter can be one of the following values:
# k: |: O( E8 S& \$ U7 k9 k  *     @arg USART_FLAG_CTS:  CTS Change flag (not available for UART4 and UART5)
3 q+ O7 [" |# E, _  *     @arg USART_FLAG_LBD:  LIN Break detection flag
  *     @arg USART_FLAG_TXE:  Transmit data register empty flag
  *     @arg USART_FLAG_TC:   Transmission Complete flag
- H- W& H) h5 a: f  N( e/ ^& \  *     @arg USART_FLAG_RXNE: Receive data register not empty flag
  *     @arg USART_FLAG_IDLE: Idle Line detection flag
  *     @arg USART_FLAG_ORE:  OverRun Error flag
  *     @arg USART_FLAG_NE:   Noise Error flag
  *     @arg USART_FLAG_FE:   Framing Error flag
  *     @arg USART_FLAG_PE:   Parity Error flag
  * @retval The new state of USART_FLAG (SET or RESET).
) k5 p/ ^, w' s( w! t4 u; p  */
& n' y/ P( U9 x& m  z2 H) T! lFlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG)
{
  FlagStatus bitstatus = RESET;
* P1 m- I7 K: R0 R5 a+ v  /* Check the parameters */
  assert_param(IS_USART_ALL_PERIPH(USARTx));
. Y$ p( ?0 k8 m: T( |4 M  assert_param(IS_USART_FLAG(USART_FLAG));
1 X  G% w% j3 A% f  /* The CTS flag is not available for UART4 and UART5 */
  if (USART_FLAG == USART_FLAG_CTS)
  {
7 Q" L  S8 M; c7 @    assert_param(IS_USART_123_PERIPH(USARTx));
/ ?4 @: y0 I' e# V  O  }  

: V: T4 y1 ]- N' e& f6 C  if ((USARTx->SR & USART_FLAG) != (uint16_t)RESET)
; }8 _& q$ o, G: s8 W  {
    bitstatus = SET;
  }
  else
( Q% Y0 ?( |! I% I7 Y. e: l' S% O2 S  {
# O6 V+ t! s; f2 f+ K, O) p    bitstatus = RESET;
  }
0 v( l+ F9 v( _4 G4 W2 X- c: c  return bitstatus;
}


( l. M- ^& R* W4 x) d) l) \
1 S6 i# N" Z$ O6 }! \/**
  * @brief  Returns the most recent received data by the USARTx peripheral.
. w7 q' @3 w, |) H3 ?  * @param  USARTx: Select the USART or the UART peripheral.
  *   This parameter can be one of the following values:
  *   USART1, USART2, USART3, UART4 or UART5.
: ~8 U7 V7 N7 H# w  * @retval The received data.
  */
uint16_t USART_ReceiveByte(USART_TypeDef* USARTx)
{
# {1 s2 s; M7 C4 [' Z" `* f  /* Check the parameters */
8 G" l( L/ @' J% r) ~# l  assert_param(IS_USART_ALL_PERIPH(USARTx));

) J  u9 f. X* F$ }3 F  /* Receive Data */
# G9 m3 z- n) r8 |5 [$ [$ X  return (uint16_t)(USARTx->DR & (uint16_t)0x01FF);
}
2 A; g/ _, x* S# t
. o/ F" ~: g$ ^. u& _* u! ~

void USART1_IRQHandler(void)
{
        /**
* Y7 R# P2 t% U% ^4 L         * 如果使能串口接收中断，那么ORE为1时也会产生中断。
         * 在应用中对ORE标志进行处理，当判断发生ORE中断的时候，
         * 我们再读一次USART_DR的值，
         * 这样如果没有新的Overrun 溢出事件发生的时候，ORE会被清除,
; I( s, C& I6 g/ g! K9 U         * 然后程序就不会因为ORE未被清除而一直不断的进入串口中断
         */
         
        //没有使能USART_IT_ERR中断时，ORE中断只能使用USART_GetFlagStatus(USART1, USART_FLAG_ORE)读到
, l1 W) N/ w2 W2 R        if(USART_GetFlagStatus(USART1, USART_FLAG_ORE) != RESET)
        {
                //(void)USARTx->SR;
                //(vois)USARTx->DR; //先读SR再读DR寄存器
0 b% h3 W. N' J( |: e: s               
                USART_ReceiveByte(USART1);
               
# Y: c% j- E3 b% ~( z0 B8 Z) q                //USART_ClearFlag(USART1, USART_FLAG_ORE);
/ n( ]8 H9 Y* y( l1 `7 O        }
2 H. e8 m* [- T       
        //处理接收到的数据（示例为FIFO缓冲队列）
        if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
" l  g' W  {5 P" ?) J% I6 Z        {
                USART_ClearITPendingBit(USART1, USART_IT_RXNE);
                *USART_RevPointer[0][0] = (u8) USART_ReceiveByte(USART1);
0 o1 W  ^1 h5 ^9 [2 Z8 y                USART_RevPointer[0][0]++;
8 [9 e  V6 h+ ?                USART_RevCount[0]++;
: T4 Z, Y6 \! C/ A# p+ Q3 O
                if (USART_RevPointer[0][0] >= USART_RevBuffer[0] + USART_BufferSize[0])
                        USART_RevPointer[0][0] = USART_RevBuffer[0];
        }
2 _6 b* x9 h8 j}


6 V/ j* i& Q+ f, b0 k