Published June 15, 2026 © MIT

Serial Communication Laboratory Exercise: Performance Analys

Analyzing serial communication performance on the RT-Spark Development Board by measuring baud rates and delays with an oscilloscope.

IntermediateShowcase (no instructions)2 hours7

Serial Communication Laboratory Exercise: Performance Analys

Things used in this project

Hardware components

Jumper wires (generic)

Digilent BNC Oscilloscope x1/x10 Probes (Pair)

RT-Thread RT-Spark Development Board

Arduino MKR WiFi 1010

Software apps and online services

STMicroelectronics STM32CUBEPROG

Story

Introduction: The Invisible Speed of Serial Data

In embedded systems engineering, it is easy to take serial communication for granted. We open a serial terminal, type a command, and watch data instantly appear on the screen. But what actually happens at the hardware level during those fleeting microseconds?

To answer this, this project profiles the performance of a UART (Universal Asynchronous Receiver-Transmitter) link. Using an RT-Thread RT-Spark Development Board (powered by an STM32 MCU) and a digital oscilloscope, we analyze physical bit timings, mathematical computation overhead, and real-world processing delays at the microsecond scale.

The Application: Echo, Compute, and Broadcast

The core of the project relies on a firmware application that listens for user input via serial communication, processes it mathematically, and broadcasts the output across multiple channels.

The main execution loop operates as follows:

Listen & Echo: The firmware polls USART2. Every character typed in the terminal is caught, immediately echoed back to the host computer so the user can track their input, and pushed into a string buffer.

Listen & Echo: The firmware polls USART2. Every character typed in the terminal is caught, immediately echoed back to the host computer so the user can track their input, and pushed into a string buffer.

Trigger Condition: Once a carriage return (\r) or newline (\n) character is detected, the string capture is finalized.

Trigger Condition: Once a carriage return (\r) or newline (\n) character is detected, the string capture is finalized.

Compute: The firmware converts the text buffer into a floating-point value using atof() and computes its square root using the standard C math library's sqrt() function.

Compute: The firmware converts the text buffer into a floating-point value using atof() and computes its square root using the standard C math library's sqrt() function.

Dual Broadcast: The formatted calculation string—e.g., Sqrt(16.00) = 4.0000—is packaged up and simultaneously transmitted over bothUSART2 and USART1.

Dual Broadcast: The formatted calculation string—e.g., Sqrt(16.00) = 4.0000—is packaged up and simultaneously transmitted over bothUSART2 and USART1.

The Bench Setup: Catching Data in Motion

To capture these microsecond transitions, a digital oscilloscope was connected directly to the RT-Spark board's communication pins:

Channel 1 (Yellow): Hooked to the USART2 RX line (monitoring incoming data from the host PC).

Channel 1 (Yellow): Hooked to the USART2 RX line (monitoring incoming data from the host PC).

Channel 2 (Blue): Hooked to the USART2 TX line (monitoring outgoing data leaving the MCU).

Channel 2 (Blue): Hooked to the USART2 TX line (monitoring outgoing data leaving the MCU).

Because UART transmission lines idle high, the oscilloscope was configured to trigger on a falling edge on Channel 1 to catch the exact moment a packet sequence ends.

Experimental Findings & Performance Metrics

Running the system initially at a baseline of 57, 600 baud, the scope captured several critical parameters:

1. Validating Bit Width Math

The minimum pulse duration (the width of a single bit) on the transmission lines was measured. At 57, 600 bits per second, the theoretical duration of a single bit is:

The hardware measurements on the oscilloscope perfectly mirrored this value, validating clock configuration and baud rate accuracy.

2. Profiling the Processing Delay

The key metric of this analysis was measuring the exact processing delay. This is the time gap between the stop bit of the final incoming character (the newline) on USART2 RX and the start bit of the very first byte transmitted back by the MCU on USART2 TX.

During this microscopic window, the microcontroller must:

Terminate the string buffer.

Terminate the string buffer.

Parse the ASCII characters into a double.

Parse the ASCII characters into a double.

Execute the sqrt() floating-point operation.

Execute the sqrt() floating-point operation.

Format the final string payload using snprintf().

Format the final string payload using snprintf().

Initialize the HAL UART Transmit peripheral.

Initialize the HAL UART Transmit peripheral.

Using the oscilloscope's precision cursors, this entire turnaround sequence was clocked at exactly 8.80 µs.

3. Maximizing Throughput

To test the limitations of the link, the configuration was scaled up to find the highest successful communication rate. After adjusting the configuration registers, the setup achieved a stable, error-free communication link at 115, 200 baud, effectively halving data transmission times while maintaining 100% data integrity.

Conclusion

This performance analysis proves that what looks like "instantaneous" execution to a human observer is actually a highly structured, precisely timed sequence of hardware states. Measuring a processing delay of just 8.80 µs highlights the speed of modern ARM Cortex-M architecture when handling intensive data-parsing and floating-point math routines.

When designing responsive telemetry systems or real-time control links, capturing real-world propagation and execution delays on an oscilloscope is the key to building deterministic, industrial-grade firmware.

Code

Serial Communication Laboratory Exercise: Performance Analysis

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body (Paraphrased Version)
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2026 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
uint8_t received_char;
char input_buffer[64];
uint8_t buffer_idx = 0;
uint8_t line_received = 0;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
      // Poll and fetch a single byte from USART1
      if (HAL_UART_Receive(&huart1, &received_char, 1, 10) == HAL_OK)
      {
          // Immediate echo back to the terminal program
          HAL_UART_Transmit(&huart1, &received_char, 1, 10);

          // Check if the current byte signifies a line ending
          if (received_char == '\r' || received_char == '\n')
          {
              if (buffer_idx > 0)
              {
                  input_buffer[buffer_idx] = '\0'; // Properly terminate the string
                  line_received = 1;               // Raise execution flag
              }
          }
          // Push to buffer if there is remaining capacity
          else if (buffer_idx < sizeof(input_buffer) - 1)
          {
              input_buffer[buffer_idx++] = received_char;
          }
      }

      // Execute calculations when a full payload is flagged
      if (line_received)
      {
          double target_value = atof(input_buffer);
          double calculated_root = sqrt(target_value);

          char output_msg[128];
          snprintf(output_msg, sizeof(output_msg), "\r\nSqrt(%.2f) = %.4f\r\n", target_value, calculated_root);

          // Broadcast results across both hardware UART interfaces
          HAL_UART_Transmit(&huart1, (uint8_t*)output_msg, strlen(output_msg), 10);
          HAL_UART_Transmit(&huart2, (uint8_t*)output_msg, strlen(output_msg), 10);

          // Flush metrics for the next incoming sequence
          buffer_idx = 0;
          line_received = 0;
      }
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  /** 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_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 8;
  RCC_OscInitStruct.PLL.PLLN = 168;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  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_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

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

/* 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 */
  __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 CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

Credits

Belle Danielle CHAVEZ

6 projects • 0 followers