STM32F103R6 USART1/UART1 Progamming Example Using STM32CubeIDE

Overview

The STM32F103R6 has up to two USART(Universal Synchronous/Asynchronous Receiver/Transmitter) communication modules, USART1 and USART2. These communication interfaces could be configured as synchronous or asynchronous transmission. Synchronous transmission uses a share clock line that synchronize with data.

A serial communication between two devices using a shared clock source

In asynchronous transmission the device require only a transmitter(Tx) or a receiver (Rx) pin to send or receive the data. Communication device use its dedicated clock source to create precise timing that sample serial data. For asynchronous communication it's called UART(Universal Asynchronous Receiver/Transmitter).

The timing diagram of a serial communication without a dedicated clock line

The signaling difference between a USART and a UART

UART is more convenient than USART because it does not require clock line over the communication interface. In some case it requires more control lines. For electronic hobbyists it is widely used with some device such as,

• the Bluetooth module, 
• the Arduino serial interface that use as program uploading and serial data transmission,
• the ESP8266 WiFi module,
• the Nextion HMI (Human Machine Interface)
• the GSM module.

Some electronic equipment have an on-board UART interface that is useful for checking device booting status, or fixing device firmware issue using command line.

 

The Baud Rate (bits per second) is the numbers of data bits transferred per second. The STM32F1xx has the following Baud Rate.

stm32f101xx-stm32f102xx-stm32f103xx-stm32f105xx-and-stm32f107xx- standard Baud Rate

Using the STM32CubeIDE and its CubeHal, the programmer doesn't need to calculate and configure its internal register as the IDE has a code configuring tool.

UART Programming In STM32CubeIDE Example

There are a lot of library functions in the STM32CubeIDE especially the HAL(Hardware Abstraction Layer) libraries. We still able use ARM Cortex-M3 legacy libraries in this IDE. The following APIs are belong to the IO operation functions group,

- HAL_UART_Transmit()
- HAL_UART_Receive()
- HAL_UART_Transmit_IT()
- HAL_UART_Receive_IT()
- HAL_UART_Transmit_DMA()
- HAL_UART_Receive_DMA()
- HAL_UART_DMAPause()
- HAL_UART_DMAResume()
- HAL_UART_DMAStop()
- HAL_UARTEx_ReceiveToIdle()
- HAL_UARTEx_ReceiveToIdle_IT()
- HAL_UARTEx_ReceiveToIdle_DMA()
- HAL_UARTEx_GetRxEventType()
- HAL_UART_Abort()
- HAL_UART_AbortTransmit()
- HAL_UART_AbortReceive()
- HAL_UART_Abort_IT()

- HAL_UART_AbortTransmit_IT().

However there are additional function such as, Peripheral Control function, Peripheral State and Errors functions group.

In this example I will use a few functions,

- HAL_UART_Init (UART_HandleTypeDef * huart)

For example HAL_UART_Init (&huart1) , or HAL_UART_Init (&huart2)

- HAL_UART_Transmit (UART_HandleTypeDef * huart, const uint8_t * pData, uint16_t
Size, uint32_t Timeout)

For example  HAL_UART_Transmit(&huart1,"Hello",5,1000)

-  HAL_UART_Receive (UART_HandleTypeDef * huart, uint8_t * pData, uint16_t Size,
uint32_t Timeout)

For example HAL_UART_Receive(&huart1,myData,1,1000)

I will show a simple programming using CubeHAL. The firmware will be use with Proteus Simulator.

Simulating Program - Virtual Terminal Acts As UART Receiver/Transmitter.

The STM32F103R6 uses an 8MHz HSI (High Speed Internal RC Clock Source). Its supply voltage is +3.3V but some input pin could withstand up to +5V tolerant. PC0 and PC1 are output pin connect to their own LED. We just type a command to control the output LEDs,

• 1 LED1 ON
• 2 LED1 OFF
• 3 LED2 ON
• 4 LED2 OFF

Now we will start writing the program for this example by creating a new STM32 project. Click on the USART1 in device configuration tool and select Asynchronous in Mode combo box.

USART1 Configuration

Optionally we select PC0 and PC1 as output with labels.
 

GPIO Setting

We can also set the debug interface and timer source. After all setting are done we will click on Device Configuration Tool Code Generation button or Save button to generate source codes in the main.c file.

After the code generation is created we will need to add some user codes in the main.c file.

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
 
/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef huart1;
 
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */
 
/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
 
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();
 
  /* Configure the system clock */
  SystemClock_Config();
 
  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  HAL_UART_Transmit(&huart1,"STM32F103 UART1 Example #3\r\n",32,1000);
  uint8_t myData=0;
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    HAL_UART_Receive(&huart1,&myData,1,1000);
    switch(myData){
    case '1':	HAL_GPIO_WritePin(GPIOC,LED1_Pin,GPIO_PIN_SET);
    			HAL_UART_Transmit(&huart1,&myData,1,1000);
    			HAL_UART_Transmit(&huart1," LED1 ON\r\n",12,1000);
    			myData=0;
    			break;
    case '2':	HAL_GPIO_WritePin(GPIOC,LED1_Pin,GPIO_PIN_RESET);
    			HAL_UART_Transmit(&huart1,&myData,1,1000);
    			HAL_UART_Transmit(&huart1," LED1 OFF\r\n",12,1000);
    			myData=0;
    			break;
    case '3':	HAL_GPIO_WritePin(GPIOC,LED2_Pin,GPIO_PIN_SET);
    			HAL_UART_Transmit(&huart1,&myData,1,1000);
    			HAL_UART_Transmit(&huart1," LED2 ON\r\n",12,1000);
    			myData=0;
    			break;
    case '4':  	HAL_GPIO_WritePin(GPIOC,LED2_Pin,GPIO_PIN_RESET);
    			HAL_UART_Transmit(&huart1,&myData,1,1000);
    			HAL_UART_Transmit(&huart1," LED2 OFF\r\n",12,1000);
    			myData=0;
    			break;
    }
  }
  /* USER CODE END 3 */
}
 
/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  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;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
 
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    Error_Handler();
  }
}
 
/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{
 
  /* USER CODE BEGIN USART1_Init 0 */
 
  /* USER CODE END USART1_Init 0 */
 
  /* USER CODE BEGIN USART1_Init 1 */
 
  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */
 
  /* USER CODE END USART1_Init 2 */
 
}
 
/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
 
  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, LED1_Pin|LED2_Pin, GPIO_PIN_RESET);
 
  /*Configure GPIO pins : LED1_Pin LED2_Pin */
  GPIO_InitStruct.Pin = LED1_Pin|LED2_Pin;
  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);
 
}
 
/* USER CODE BEGIN 4 */
 
/* USER CODE END 4 */
 
/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}
 
#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
 
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
 

It requires 6.24KB of Flash and 1.62KB of RAM. Click here to download its source file.

Making A DIY SN74HC595 Serial 10-Digit 7-Segment Display Board

Shift Registers are very useful for expanding the controller I/O ports. However driving a dot matrix display, or multiple seven-segment display also need this kind of chip. Because only multiplexing could not achieve a good displaying task.

Eight-Digit and Ten-Digit Serial Seven-Segment Display Using SN74HC595N

It's not important to make any DIY display like this. But I have many common-cathode type seven-segments display, SN74HC595N shift registers, copper clad board, etc. So I want to use them all rather than keep them new in my own repair shop.

The design was complicated due to multiple count of connection between register to register, and register to display. So I tried to eliminate some components especially the current cutting resistors.

The shift register chip output pin voltage is +5V while the display need around 2V to operate. Without using dozens of current cutting resistors, I reduce the voltage by making voltage division. I add 3 rectifier diodes in series with each common cathodes of the display to divide the voltage.

Eight-Digit Seven-Segment Display

For the first time I design, I was unwilling to do this task due to difficulty in PCB fabrication, and laser printing toner problem. Because the ink cartridge was old. So I only made an 8-digit display.

Arduino Test Program

 I use Proteus 8.10 to design the schematic and PCB.

Schematic Design

PCB contains a lot of wire connections due to a large amount of registers an displays. It seems to be a double side PCB, but I use jumper wire instead.
 

PCB View In Proteus

I previewed this design in 3D viewer. Most of components are lack of 3D packages.

Design 3D View

I use toner transfer method to make this DIY PCB. Using sing any online PCB order cost around 10 US Dollars excluding shipping cost. However it is not necessary here.

 

Component Side Label Transferring

Copper Side After Etching

Copper Side After Soldering

Copper Side Before Etching

I spent one day to finish this DIY electronic hobby project.

Finished PCBA Assembling

It works well but the display doesn't have Dot Point.

I firstly test this PCBA With Arduino Program Due To Ease Of Use.

I store this design file in Github.

Arduino Test Program #1 Using SPI

#include <SPI.h>
 
 
void setup() {
  // put your setup code here, to run once:
  SPI.begin();
  pinMode(10,OUTPUT);
 
 
}
 
void loop() {
  // put your main code here, to run repeatedly:
 digitalWrite(10,LOW);
  SPI.transfer(0x3F);
  SPI.transfer(0x06);
  SPI.transfer(0x5B);
  SPI.transfer(0x4F);
  SPI.transfer(0x6D);
  SPI.transfer(0x7D);
  SPI.transfer(0x07);
  SPI.transfer(0x7F);
  digitalWrite(10,HIGH);
  delay(3000);
}

Arduino Test Program #2

#include <SPI.h>
 
unsigned char ssd[16]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,
                      0x77,0x7C,0x39,0x5E,0x79,0x71};
 
unsigned char msg1[10]={0x08,0x08,0x76,0x79,0x38,0x38,0x5C,0x08,0x08,0x08};
void setup() {
  // put your setup code here, to run once:
  SPI.begin();
  pinMode(10,OUTPUT);
}
 
void loop() {
  // put your main code here, to run repeatedly:
  /*
 digitalWrite(10,LOW);
 
  for(int i=9;i>=0;i--)
    SPI.transfer(ssd[i]);
  digitalWrite(10,HIGH); 
  delay(5000);
 
  digitalWrite(10,LOW);
 
  for(int i=15;i>=10;i--)
    SPI.transfer(ssd[i]);
  digitalWrite(10,HIGH); 
  delay(5000);
  */
   for(int i=9;i>=0;i--){
   digitalWrite(10,LOW);
 
  SPI.transfer(msg1[i]);
  delay(1000);
  digitalWrite(10,HIGH); 
   }
}

Eight-Digit Seven-Segment Display

I add two more digits to previous design. The PCB design is  quit bigger.

Arduino Test Program

 Arduino Test Program for this PCBA

or #include <SPI.h>
 
unsigned char ssd[16]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,
                      0x77,0x7C,0x39,0x5E,0x79,0x71};
void setup() {
  // put your setup code here, to run once:
  SPI.begin();
  pinMode(10,OUTPUT);
 
 
}
 
void loop() {
  // put your main code here, to run repeatedly:
 digitalWrite(10,LOW);
 /*
  SPI.transfer(ssd[0]);
  SPI.transfer(ssd[1]);
 
  SPI.transfer(ssd[2]);
  SPI.transfer(ssd[3]);
 
  SPI.transfer(ssd[4]);
  SPI.transfer(ssd[5]);
 
  SPI.transfer(ssd[6]);
  SPI.transfer(ssd[7]);
 
  SPI.transfer(ssd[8]);
  SPI.transfer(ssd[9]);
  */
  for(int i=9;i>=0;i--)
    SPI.transfer(ssd[i]);
  digitalWrite(10,HIGH); 
  delay(5000);
 
  digitalWrite(10,LOW);
 
  for(int i=15;i>=10;i--)
    SPI.transfer(ssd[i]);
  digitalWrite(10,HIGH); 
  delay(5000);
}

Click here to download load this PCBA design file.