STM32 serial port uses DMA to receive data

environment:

Host: WINXP

Development environment: MDK4.23

MCU:STM32F103CBT6

illustrate:

The serial port can be configured to receive data using DMA, but DMA requires a fixed length to generate a receive interrupt. How can we receive data of variable length?

There are three methods:

1. Connect the RX pin to an external clock pin. When a frame is sent by the serial port, this timer can be used to generate a timeout interrupt. This has high real-time performance and can achieve real-time monitoring of 1 byte.

2. Without changing the hardware, start a timer to monitor DMA reception, and generate an interrupt if it times out. This is not very real-time, because the timeout must be greater than the time required to receive the frame, and the accuracy is difficult to control.

3. Some serial ports of STM32 microcontrollers can monitor whether the bus is idle, and generate an interrupt if it is idle. It can be used to monitor whether DMA reception is completed. This method has high real-time performance.

This article adopts the third method. The impact of large data packets at a baud rate of 576000 proves to be feasible.

source code:

1. //Serial port receive DMA buffer  

2. #define UART_RX_LEN 128  

3. extern uint8_t Uart_Rx[UART_RX_LEN];  

1. //Serial port receive DMA buffer  

2. uint8_t Uart_Rx[UART_RX_LEN] = {0};  

1. //---------------------Serial port function configuration---------------------  

2.     //Open the peripheral clock corresponding to the serial port    

3.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);   

4.     //Serial port DMA configuration    

5.     //Start DMA clock  

6.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);  

7.     //DMA send interrupt setting  

8.     NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;  

9.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;  

10.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;  

11.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  

12.     NVIC_Init(&NVIC_InitStructure);  

13.     //DMA1 channel 4 configuration  

14.     DMA_DeInit(DMA1_Channel4);  

15.     //Peripheral address  

16.     DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)(&USART1->DR);  

17.     //Memory address  

18.     DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)Uart_Send_Buffer;  

19.     //dma transmission direction is one-way  

20.     DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;  

21.     //Set the length of the DMA buffer during transmission  

22.     DMA_InitStructure.DMA_BufferSize = 100;  

23.     //Set the DMA peripheral increment mode, a peripheral  

24.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;  

25.     //Set DMA memory increment mode  

26.     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;  

27.     //Peripheral data word length  

28.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;  

29.     //Memory data word length  

30.     DMA_InitStructure.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte;  

31.     //Set DMA transfer mode  

32.     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;  

33.     //Set the DMA priority level  

34.     DMA_InitStructure.DMA_Priority = DMA_Priority_High;  

35.     //Set the variables in the two DMA memories to access each other  

36.     DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;  

37.     DMA_Init(DMA1_Channel4,&DMA_InitStructure);  

38.     DMA_ITConfig(DMA1_Channel4,DMA_IT_TC,ENABLE);  

39.       

40.     // Enable channel 4  

41.     //DMA_Cmd(DMA1_Channel4, ENABLE);  

42.   

43.     //Serial port receiving DMA configuration    

44.     //Start DMA clock  

45.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);  

46.     //DMA1 channel 5 configuration  

47.     DMA_DeInit(DMA1_Channel5);  

48.     //Peripheral address  

49.     DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)(&USART1->DR);  

50.     //Memory address  

51.     DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)Uart_Rx;  

52.     //dma transmission direction is one-way  

53.     DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;  

54.     //Set the length of the DMA buffer during transmission  

55.     DMA_InitStructure.DMA_BufferSize = UART_RX_LEN;  

56.     //Set the DMA peripheral increment mode, a peripheral  

57.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;  

58.     //Set DMA memory increment mode  

59.     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;  

60.     //Peripheral data word length  

61.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;  

62.     //Memory data word length  

63.     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;  

64.     //Set DMA transfer mode  

65.     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;  

66.     //Set the DMA priority level  

67.     DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;  

68.     //Set the variables in the two DMA memories to access each other  

69.     DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;  

70.     DMA_Init(DMA1_Channel5,&DMA_InitStructure);  

71.   

72.     // Enable channel 5  

73.     DMA_Cmd(DMA1_Channel5,ENABLE);  

74.       

75.         

76.     //Initialization parameters    

77.     //USART_InitStructure.USART_BaudRate = DEFAULT_BAUD;    

78.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;    

79.     USART_InitStructure.USART_StopBits = USART_StopBits_1;    

80.     USART_InitStructure.USART_Parity = USART_Parity_No;    

81.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;    

82.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;      

83.     USART_InitStructure.USART_BaudRate = DEFAULT_BAUD;   

84.     // Initialize the serial port   

85.     USART_Init(USART1,&USART_InitStructure);    

86.     //TXE send interrupt, TC transmission completion interrupt, RXNE receive interrupt, PE parity error interrupt, can be multiple     

87.     //USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);  

88.       

89.     //Interrupt configuration  

90.     USART_ITConfig(USART1,USART_IT_TC,DISABLE);  

91.     USART_ITConfig(USART1,USART_IT_RXNE,DISABLE);  

92.     USART_ITConfig(USART1,USART_IT_IDLE,ENABLE);    

93.   

94.     //Configure UART1 interrupt    

95.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_3);  

96.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; //Channel is set to serial port 1 interrupt    

97.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; //Interrupt preemption level 0    

98.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; //Interrupt response priority 0    

99.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //Enable interrupt    

100.     NVIC_Init(&NVIC_InitStructure);     

101.           

102.     //Send using DMA  

103.     USART_DMACmd(USART1,USART_DMAReq_Tx,ENABLE);  

104.     //Receive using DMA  

105.     USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);  

106.     //Start the serial port    

107.     USART_Cmd(USART1, ENABLE);   

1. //Serial port 1 receive interrupt     

2. void USART1_IRQHandler(void)                                 

3. {     

4.     uint32_t temp = 0;  

5.     uint16_t i = 0;  

6.       

7.     if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)  

8.     {  

9.         //USART_ClearFlag(USART1,USART_IT_IDLE);  

10.         temp = USART1->SR;  

11.         temp = USART1->DR; // Clear USART_IT_IDLE flag  

12.         DMA_Cmd(DMA1_Channel5,DISABLE);  

13.   

14.         temp = UART_RX_LEN - DMA_GetCurrDataCounter(DMA1_Channel5);  

15.         for (i = 0;i < temp;i++)  

16.         {  

17.             Data_Receive_Usart = Uart_Rx[i];  

18.             //Start the serial port state machine  

19.             usart_state_run();   

20.         }  

21.   

22.         //Set the transmission data length  

23.         DMA_SetCurrDataCounter(DMA1_Channel5,UART_RX_LEN);  

24.         //Open DMA  

25.         DMA_Cmd(DMA1_Channel5,ENABLE);  

26.     }   

27.       

28.     __nop();   

29. }   

Test Results:

Conditions: The microcontroller runs at 72M and communicates with the PC at a rate of 460800. The PC sends a 9-byte packet every 100ms: c5 5c 6 0 6F 10 5 4e f7.

Test: Each time the MCU receives this packet, an IO jumps to a level, and then processes and returns a packet.

Oscilloscope display:

Zoom in to show: