STM32 serial port DMA timeout reception method can greatly save CPU time

This method uses a timer to periodically query the data received by DMA. If it exceeds the set period, it is considered that the data packet has ended, and the data is copied to the buffer and handed over to other programs for processing. It can receive data packets of any size, especially suitable for protocols such as MODBUS. It has been used for GPS, GPRS, etc., and is very practical. This method takes up very little CPU time, especially when the baud rate is very high, the effect is more obvious.
When the data reception of a serial port times out, the data is copied to the buffer in the timer interrupt. The data flag UART1_Flag can be judged in the main program. When it is greater than 0, it means that data has been received and can be processed. After processing, this variable can be cleared.
When the interval between two data packets is small, the timer period can be shortened.

//Timeout definition
#define UART1_TimeoutComp 2 //20ms
#define UART2_TimeoutComp 10 //100ms
#define UART3_TimeoutComp 10 //100ms

#define SRC_USART1_DR (&(USART1->DR)) //Serial port receive register as source
#define SRC_USART2_DR (&(USART2->DR)) //Serial port receive register as source
#define SRC_USART3_DR (&(USART3->DR)) //Serial port receive register as source


extern u16 UART1_Flag,UART2_Flag,UART3_Flag;
extern u8 uart1_data[200],uart3_data[500],uart2_data[500];

u8 UART1_Timeout,UART2_Timeout,UART3_Timeout;
u16 UART1_FlagTemp,UART2_FlagTemp,UART3_FlagTemp;
u8 uart1_data_temp[200],uart2_data_temp[500],uart3_data_temp[500];

u16 uart1_Flag_last=0,uart2_Flag_last=0,uart3_Flag_last=0;

//Timer initialization
void TimerInit(void)
{
   //Timer initialization data structure definition
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
   //Initialize timer for timeout reception, 20ms

        //Reset counter
        TIM_DeInit(TIM2);                                                        

        TIM_TimeBaseStructure.TIM_Period = 100; //Count upper limit, 100*100us = 10000us = 10ms
        TIM_TimeBaseStructure.TIM_Prescaler = 4799; //Pre-divided 4800, 48MHz main frequency, divided clock period 100us
        TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //No frequency division
        TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //Count up
        TIM_TimeBaseStructure.TIM_RepetitionCounter=0;
        //Initialize
        TIM_TimeBaseInit(TIM2,&TIM_TimeBaseStructure);

        //Clear interrupt
    TIM_ClearFlag(TIM2, TIM_FLAG_Update);


        //Enable timer interrupt
        TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE);
       TIM_UpdateDisableConfig(TIM2,DISABLE); 
        //Timer clear
        TIM_SetCounter(TIM2,0);
        //Timer start        
      TIM_Cmd(TIM2,ENABLE);        
}


//DMA initialization, only one channel is listed, the other two channels are the same
void DMA5_Init(void)
{
  DMA_InitTypeDef DMA_InitStructure;

  DMA_DeInit(DMA1_Channel5); //Reset DMA channel 1 register to default value
  DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)SRC_USART1_DR; //Source BUF is (&(USART1->DR))
  DMA_InitStructure.DMA_MemoryBaseAddr = (u32)uart1_data_temp; //Destination BUF is to be written into which array DMA_InitStructure.DMA_DIR 
  = DMA_DIR_PeripheralSRC; //Peripheral as source //Is the peripheral the destination or source of data transmission 
  DMA_InitStructure.DMA_BufferSize = 200; //The size unit of DMA buffer is set below
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //Peripheral address register does not incrementDMA_InitStructure.DMA_MemoryInc
  = DMA_MemoryInc_Enable; //Memory address incrementDMA_InitStructure.DMA_PeripheralDataSize
  = DMA_PeripheralDataSize_Byte; //Peripheral bytes are in unitsDMA_InitStructure.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte
  ; //Memory bytes are in unitsDMA_InitStructure.DMA_Mode
  = DMA_Mode_Circular; //Work in circular cache modeDMA_InitStructure.DMA_Priority
  = DMA_Priority_High; //One of the 4 priorities (high priority) VeryHigh/High/Medium/Low
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; //Non-memory to memoryDMA_Init 
  (DMA1_Channel5, &DMA_InitStructure); //Initialize DMA channel 1 register according to the parameters specified in DMA_InitStructDMA_ITConfig 
  (DMA1_Channel5, DMA_IT_TC, ENABLE); //DMA5 transfer completion 
  interruptUSART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE); //Enable USART1 receive DMA requestDMA_Cmd

  (DMA1_Channel5, ENABLE); //Formally allow DMA         
}

//Serial port initialization, only one channel is listed, the other two channels are        
the samevoid USART1_Configuration(void)
{
    //Serial port initialization data structure definitionUSART_InitTypeDef
        USART_InitStructure; 

        //Initialize the serial port to 38400,n,8,1
        USART_InitStructure.USART_BaudRate = 38400 ;
        USART_InitStructure.USART_WordLength = USART_WordLength_8b;
        USART_InitStructure.USART_StopBits = USART_StopBits_1;
        USART_InitStructure.USART_Parity = USART_Parity_No ; USART_InitStructure.USART_HardwareFlowControl
        = USART_HardwareFlowControl_None;
        USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
        //Initialize
        USART_Init(USART1, &USART_InitStructure);
        
        //Start the serial port, no need to receive interrupt
        USART_Cmd(USART1, ENABLE);
        
        //Default is set to input state   
        DMA5_Init();
}

//Timer interrupt service routine
void TIM2_IRQHandler(void)
{
  u16 i;   
  //Clear timer interrupt
  TIM_ClearITPendingBit(TIM2, TIM_FLAG_Update); 

  UART1_Timeout++;
  UART2_Timeout++;
  UART3_Timeout++;
//------------------------------------------------------------------
  i=DMA_GetCurrDataCounter(DMA1_Channel5);
  DMA_ClearITPendingBit(DMA1_IT_GL5); //Clear all interrupt flagsif

  (i!=uart1_Flag_last) //Unfinished transmission
  {
          UART1_Timeout=0;
        uart1_Flag_last=i;
  }
  else
  {
    if(UART1_Timeout>UART1_TimeoutComp) //Timeout
        {
           if(i<200) //Data received
           {
                  UART1_FlagTemp=200-i; //Get the number of bytes receivedfor
              
                (i=0;i                  uart1_data[i]=uart1_data_temp[i];
                UART1_Flag=UART1_FlagTemp;
                
                DMA_ClearFlag(DMA1_FLAG_TC5);
                DMA_Cmd(DMA1_Channel5, DISABLE); //Formally allow DMA                 
                DMA5_Init();                  
           }
           UART1_Timeout=0;
        }
  }
  //------------------------------------------------------------------
  i=DMA_GetCurrDataCounter(DMA1_Channel6);
  DMA_ClearITPendingBit(DMA1_IT_GL6); //Clear all interrupt flags

  if(i!=uart2_Flag_last) //Unfinished transmission
  {
          UART2_Timeout=0;
        uart2_Flag_last=i;
  }
  else
  {
    if(UART2_Timeout>UART2_TimeoutComp) //Timeout occurs
        {
           if(i<500) //Data is received
           {
                  UART2_FlagTemp=500-i; //Get the number of bytes receivedfor

                (i=0;i                  [i]=uart2_data_temp[i];
                UART2_Flag=UART2_FlagTemp;
                
                DMA_ClearFlag(DMA1_FLAG_TC6);
                DMA_Cmd(DMA1_Channel6, DISABLE); //Formally allow DMA                 
                DMA6_Init();
                                
           }
           UART2_Timeout=0;
        }
  }
  //------------------------------------------------------------------
  i=DMA_GetCurrDataCounter(DMA1_Channel3);
  DMA_ClearITPendingBit(DMA1_IT_GL3); //Clear all interrupt flagsif

  (i!=uart3_Flag_last) //Unfinished transmission
  {
          UART3_Timeout=0;
        uart3_Flag_last=i;
  }
  else
  {
    if(UART3_Timeout>UART3_TimeoutComp) //Timeout occurs
        {
           if(i<500) //Data received
           {
                  UART3_FlagTemp=500-i; //Get the number of bytes receivedfor

                (i=0;i                  [i]=uart3_data_temp[i];
                UART3_Flag=UART3_FlagTemp;
                
                DMA_ClearFlag(DMA1_FLAG_TC3);
                DMA_Cmd(DMA1_Channel3, DISABLE); //Formally allow DMA                 
                DMA3_Init();  
                
           }
           UART3_Timeout=0;
        }
  }  
}