STM32 UART Interrupts LED Control | STM32 Programming Tutorial 5

In the last UART controlled LED STM32 programming tutorial a led connected to STM32 Nucleo-64 board was controlled with message received from PC through the UART. In that tutorial HAL uart function HAL_UART_Transmit() and HAL_UART_Receive() were used along with the uart initialization function HAL_UART_Init(). You can read about how to use these hal uart function in the tutorial STM32 UART LED Control without interrupt. But there is another uart related Hal function with interrupt whose syntax is HAL_UART_Transmit_IT() for transmit and HAL_UART_Transmit_IT() for receive. These function allows users to create application wherein if there is any data received or transmitted interrupt is set. Then the interrupt routine with callback hal HAL_UART_TxCpltCallback() functions.

Hardware Circuit and Interfacing

For this STM32 UART programming tutorial, the following nucleo uart circuit diagram is used.

A LED is connected to the PC8 pin on the nucleo-64 board(download the proteus SM32 nucleo-64 simulation model if you need). The UART pins of the Nucleo-64 board are connected to MAX232 TTL to RS232 converter IC which is in turn connected to the serial DP9 connector. Now we can perform serial send and receive or perform communication between the PC and the STM32 nucleo board via serial connection.

STM32 UART Interrupt

Software and Programming

Programming of the Nucleo board with interrupt based UART serial communication involves creating a new STM32 project in STMCube IDE, naming the project, configuring so that hex file output is created, configuring the clock, configuring usart pins and the other required pins. Here specifically since we want to use the uart2 interface(by default UART2 is enabled during the project creation) with interrupt we have to configure the UART2 to use the interrupt feature from the

The C program code with interrupt based UART serial communication between PC and STM32 nucleo board to control a LED(in fact anything such as switches, sensors etc) connected to the PC8 pin is below.

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

/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef huart2;
uint8_t rx_data[1];
uint8_t welcome_msg[] = "UART LED Control\r\nPress 'H' for LED ON, 'L' for LED OFF\r\n";
volatile uint8_t uart_tx_complete = 1;  // Flag for TX completion

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


int main(void)
{
    // Initialize system and peripherals
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_USART2_UART_Init();
    
    // Send welcome message
    HAL_UART_Transmit(&huart2, welcome_msg, strlen((char*)welcome_msg), HAL_MAX_DELAY);
    HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, GPIO_PIN_RESET);  // LED initially OFF

    while (1)
    {
        if(HAL_UART_Receive(&huart2, rx_data, 1, HAL_MAX_DELAY) == HAL_OK)
        {
            // Echo received character
            while(!uart_tx_complete);
            uart_tx_complete = 0;
            HAL_UART_Transmit_IT(&huart2, rx_data, 1);
            
            switch(rx_data[0])
            {
                case 'H':
                case 'h':
                    HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, GPIO_PIN_SET);
                    while(!uart_tx_complete);
                    uart_tx_complete = 0;
                    HAL_UART_Transmit_IT(&huart2, (uint8_t*)"\r\nLED ON\r\n", 10);
                    break;
                    
                case 'L':
                case 'l':
                    HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, GPIO_PIN_RESET);
                    while(!uart_tx_complete);
                    uart_tx_complete = 0;
                    HAL_UART_Transmit_IT(&huart2, (uint8_t*)"\r\nLED OFF\r\n", 11);
                    break;
                    
                default:
                    while(!uart_tx_complete);
                    uart_tx_complete = 0;
                    HAL_UART_Transmit_IT(&huart2, (uint8_t*)"\r\nInvalid Command!\r\n", 19);
                    break;
            }
        }
    }
}


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_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;
    
    HAL_UART_Init(&huart2);
    HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(USART2_IRQn);
}


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 HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
    if(huart->Instance == USART2)
    {
        uart_tx_complete = 1;
    }
}

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 */