{"id":1729,"date":"2026-07-13T00:37:05","date_gmt":"2026-07-13T00:37:05","guid":{"rendered":"https:\/\/www.nvixeon.com\/stm32-uart-dma-guide-non-blocking-serial-communication-with-circular-buffers\/"},"modified":"2026-07-13T01:39:16","modified_gmt":"2026-07-13T01:39:16","slug":"stm32-uart-dma-guide-non-blocking-serial-communication-with-circular-buffers","status":"publish","type":"post","link":"https:\/\/www.nvixeon.com\/fr\/stm32-uart-dma-guide-non-blocking-serial-communication-with-circular-buffers\/","title":{"rendered":"STM32 UART DMA Guide: Non-Blocking Serial Communication with Circular Buffers"},"content":{"rendered":"

If you have ever polled a UART with HAL_UART_Receive<\/code> in a loop, you already know the problem: the CPU sits there waiting for bytes that may never come, or arrive faster than you can read them. DMA solves this by letting the peripheral move bytes into memory on its own, freeing the CPU to do everything else. This guide covers the pattern most production STM32 firmware actually uses: UART RX in circular DMA mode combined with idle-line detection.<\/p>\n

Why Circular DMA Instead of Normal Mode<\/h2>\n

Normal DMA mode fills a fixed-size buffer once and then stops, which is fine if you know exactly how many bytes are coming. Real serial data rarely works that way \u2014 GPS strings, AT command responses, and sensor packets all vary in length. Circular mode keeps DMA running indefinitely, wrapping back to the start of the buffer once it reaches the end, so the peripheral never stalls waiting for you to reset it.<\/p>\n

Adding Idle-Line Detection<\/h2>\n

Circular DMA alone does not tell you when a message ends, since it just keeps filling the buffer. Idle-line detection solves this: the UART peripheral raises an interrupt when the line goes quiet for one frame period after receiving data, which is a reliable signal that a message is complete.<\/p>\n

huart1.Instance = USART1;\nhuart1.Init.BaudRate = 115200;\nhuart1.Init.WordLength = UART_WORDLENGTH_8B;\nhuart1.Init.StopBits = UART_STOPBITS_1;\nhuart1.Init.Parity = UART_PARITY_NONE;\nhuart1.Init.Mode = UART_MODE_TX_RX;\nHAL_UART_Init(&huart1);\n\n__HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);\nHAL_UART_Receive_DMA(&huart1, rx_buffer, RX_BUFFER_SIZE);\n<\/code><\/pre>\n
Handling the Idle Interrupt<\/h2>\n
In the interrupt handler, clear the idle flag and calculate how many bytes actually arrived by comparing the DMA’s remaining-count register against the buffer size. This tells you the message length without needing a length prefix or terminator byte.<\/p>\n
void USART1_IRQHandler(void) {\n  if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE)) {\n    __HAL_UART_CLEAR_IDLEFLAG(&huart1);\n    uint16_t remaining = __HAL_DMA_GET_COUNTER(huart1.hdmarx);\n    uint16_t received_len = RX_BUFFER_SIZE - remaining;\n    process_message(rx_buffer, received_len);\n  }\n  HAL_UART_IRQHandler(&huart1);\n}\n<\/code><\/pre>\n
Keep the Interrupt Handler Short<\/h2>\n
Do not parse the message inside the interrupt handler itself. Copy it into a queue or set a flag and handle the actual parsing in your main loop or an RTOS task. This keeps interrupt latency low, which matters if you have other time-critical peripherals like PWM or ADC running on the same chip.<\/p>\n
TX Side: DMA Out Too<\/h2>\n
The same principle applies to transmission. Use HAL_UART_Transmit_DMA<\/code> for anything longer than a few bytes, and check HAL_UART_GetState<\/code> or wait for the TX complete callback before queuing the next transmission, rather than blocking with HAL_UART_Transmit<\/code>.<\/p>\n
Where This Pattern Breaks Down<\/h2>\n
Circular DMA with idle detection works well for message-based protocols, but if your data has no natural pause between frames \u2014 continuous streaming sensor data, for example \u2014 you will need a different strategy, typically DMA half-transfer and full-transfer interrupts to process the buffer in two halves while the other half keeps filling. That is worth its own guide, but the setup above will cover the vast majority of UART use cases on STM32.<\/p>","protected":false},"excerpt":{"rendered":"
Blocking UART reads stall your main loop and drop bytes at high baud rates. This guide shows how to receive variable-length UART data on STM32 using DMA in circular mode with idle-line detection, so your CPU stays free for everything else.<\/p>","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_post_was_ever_published":false},"categories":[60,62],"tags":[],"class_list":["post-1729","post","type-post","status-publish","format-standard","hentry","category-stm32f4","category-tutorials-guides"],"blocksy_meta":[],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t