STM32 DMA with Interrupt | STM32 Programming tutorial

Serial communication with UART or USART is common way to transfer message between MCU and PC or other devices. The UART of the Nucleo-64 board can be configured to either use interrupt or not. If UART is configured with interrupt then the data transfer happens without involvement of the CPU. That is CPU of the microcontroller like STM32F0401RE is not tied to polling the status of the data transfer. When interrupt is used then the responsibility of data transfer task is handled by the interrupt handler or callback functions and not the CPU. After the data transfer is complete the callback function triggers notice to the CPU that the data transfer from the UART is complete. In the previous stm32 programming tutorial it was shown how to program STM32 UART with Polling and STM32 UART with interrupt. Here it is shown how to write program for STM32 for data transfer with UART DMA interrupt.

Before writing the code for the transfer of data using DMA, we have first to configure the UART pins to use the DMA feature. This can be done from the STM32Cube IDE. The usual steps is to start a new STM32 project and then configure, the peripherals- PC8 pin as output and UART2 to use the DMA feature. The clock system can also be configured according to your need. This step on how to start STM32 project and setting the pins can be found in earlier tutorial videos like in the tutorial STM32 Nucleo Led Blink Tutorial with Proteus Simulation.

The hal functions used for data transfer using UART with DMA interrupt are:

• HAL_UART_Transmit_DMA(): Sends data using DMA.
• HAL_UART_Receive_DMA(): Receives data using DMA.
• HAL_UART_ErrorCallback(): Callback for UART errors.

To illustrate these data transfer functions we will use them to transfer message from PC via COM port to control a LED to the Nucleo-2 UART2. The message sent from serial terminal like Tera term are letters H,h,L or l for low and high to turn off or on the LED which is connected to the PC8 pin of the STM32 board.

UART DMA Transmit

For example if we want to print some message then we can use the DMA transmit is as follows:

uint8_t welcome_msg[] = "UART DMA Demo\r\nPress 'H' for LED ON, 'L' for LED OFF\r\n";

UART DMA Receive

For receive, we use the receive function as follows:

Here, this execution of this DMA reception to capture 1 byte into rx_buffer. The DMA continuously listens for incoming data without CPU intervention.

The following code illustrates where these functions are located in the main.c file:

These are the main functions and callbacks that are commonly used in the data transfer using UART DMA method. There are other additional codes, required for microcontroller system and peripheral configuration. The whole program(main.c) for the DMA data transfer with Nucleo-64 UART.

#include "main.h"
#include <string.h>

/* Private variables */
UART_HandleTypeDef huart2;
DMA_HandleTypeDef hdma_usart2_rx;
DMA_HandleTypeDef hdma_usart2_tx;

#define RX_BUFFER_SIZE   32
#define TX_BUFFER_SIZE   32

uint8_t rx_buffer[RX_BUFFER_SIZE];
uint8_t tx_buffer[TX_BUFFER_SIZE];
uint8_t welcome_msg[] = "UART DMA Demo\r\nPress 'H' for LED ON, 'L' for LED OFF\r\n";

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_DMA_Init(void);
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart);

int main(void)
{
    HAL_Init();
    SystemClock_Config();
    MX_DMA_Init();        // Initialize DMA before UART
    MX_GPIO_Init();
    MX_USART2_UART_Init();
    
    // Send welcome message using DMA
    HAL_UART_Transmit_DMA(&huart2, welcome_msg, strlen((char*)welcome_msg));
    
    // Start continuous DMA reception
    HAL_UART_Receive_DMA(&huart2, rx_buffer, 1);

    while (1)
    {
        HAL_Delay(100);  // Small delay to prevent busy waiting
    }
}

/* DMA Reception Complete Callback */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if(huart->Instance == USART2)
    {
        // Echo received character
        HAL_UART_Transmit_DMA(&huart2, rx_buffer, 1);
        
        switch(rx_buffer[0])
        {
            case 'H':
            case 'h':
                HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, GPIO_PIN_SET);
                HAL_UART_Transmit_DMA(&huart2, (uint8_t*)"\r\nLED ON\r\n", 10);
                break;
                
            case 'L':
            case 'l':
                HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, GPIO_PIN_RESET);
                HAL_UART_Transmit_DMA(&huart2, (uint8_t*)"\r\nLED OFF\r\n", 11);
                break;
        }
        
        // Restart DMA reception
        HAL_UART_Receive_DMA(&huart2, rx_buffer, 1);
    }
}

/* UART Error Callback */
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
    if(huart->Instance == USART2)
    {
        HAL_UART_Transmit_DMA(&huart2, (uint8_t*)"\r\nUART Error!\r\n", 14);
        HAL_UART_Receive_DMA(&huart2, rx_buffer, 1);  // Restart reception
    }
}

void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  // Configure HSI 16MHz oscillator
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;   // Disable PLL
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  // Configure the clock dividers
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;    // Use HSI directly
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;       // 16MHz
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;        // 16MHz for UART2
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;        // 16MHz

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_DMA_Init(void)
{
    __HAL_RCC_DMA1_CLK_ENABLE();

    HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 0, 0);  // RX DMA
    HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
    HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 0, 0);  // TX DMA
    HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn);
}

static void MX_USART2_UART_Init(void)
{
    huart2.Instance = USART2;
    huart2.Init.BaudRate = 9600;
    huart2.Init.WordLength = UART_WORDLENGTH_8B;
    huart2.Init.StopBits = UART_STOPBITS_1;
    huart2.Init.Parity = UART_PARITY_NONE;
    huart2.Init.Mode = UART_MODE_TX_RX;
    huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart2.Init.OverSampling = UART_OVERSAMPLING_16;
    
    if(HAL_UART_Init(&huart2) != HAL_OK)
    {
        Error_Handler();
    }
}

static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, GPIO_PIN_RESET);

  /*Configure GPIO pin : B1_Pin */
  GPIO_InitStruct.Pin = B1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : LD2_Pin */
  GPIO_InitStruct.Pin = LD2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LD2_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : PC8 */
  GPIO_InitStruct.Pin = GPIO_PIN_8;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
}

void Error_Handler(void)
{
  __disable_irq();
  while (1)
  {
  }
}

#ifdef  USE_FULL_ASSERT

void assert_failed(uint8_t *file, uint32_t line)
{
}
#endif /* USE_FULL_ASSERT */

 To show how this DMA with interrupt UART code works to control a LED via serial communication watch the following video.

In the STM32F401RE (used in the Nucleo-64), DMA (Direct Memory Access) with interrupts combines the efficiency of DMA with the responsiveness of interrupts for UART communication, such as controlling an LED. DMA offloads data transfer from the CPU by moving data directly between memory and peripherals (e.g., USART2 TX/RX) using predefined channels, freeing the CPU for other tasks. When configured with interrupts, the DMA controller triggers an interrupt upon completing a transfer (e.g., Transfer Complete, TC) or encountering an event (e.g., error). For example, in HAL_UART_Transmit_DMA(&huart2, data, size), the DMA moves data to USART2’s transmit register; once finished, it raises an interrupt, calling a callback like HAL_UART_TxCpltCallback(). This notifies the program (e.g., setting a flag) without polling, enabling efficient, non-blocking LED control via serial commands while allowing the CPU to handle additional logic concurrently. Setup requires configuring the DMA channel, direction (memory-to-peripheral or vice versa), and enabling its interrupt in the NVIC, making it ideal for high-speed or continuous data tasks with event-driven responses.