PWM in STM32: Generate PWM Signal Using Timers (HAL + CubeMX)

Pulse Width Modulation (PWM) is a powerful technique used in STM32 microcontrollers to control devices like LEDs, motors, and buzzers. In this tutorial, you’ll learn how to generate PWM signals using STM32 timers with STM32CubeMX and the HAL library. We’ll cover everything from timer configuration, frequency and duty cycle calculations, to writing the actual code for PWM output. Whether you’re a beginner or looking to refresh your skills, this step-by-step guide will help you implement PWM in STM32 easily and efficiently. Let’s get started with generating PWM on STM32 using CubeMX and HAL functions.

To better understand the steps, I’ve also created a detailed walkthrough video. You can follow along with the explanations below while watching the video here:

This is the first tutorial in the STM32 Timers Series using HAL and CubeMX. In this tutorial we will primarily focus on generating PWM output signal using the Timer in STM32.

Introducing the Pulse Width Modulation

Pulse Width Modulation (PWM) is a technique used to control the amount of power delivered to electronic devices by varying the width (duration) of digital pulses. Instead of adjusting voltage levels directly, PWM rapidly switches the signal between ON and OFF states. The proportion of time the signal stays ON in one cycle is called the duty cycle, and it determines the effective power delivered to the load.

PWM is widely used in applications such as motor speed control, LED brightness, servo positioning, and digital-to-analog signal emulation. In microcontrollers like STM32, PWM signals are typically generated using timers configured with specific frequency and duty cycle values.

PWM consist of two main components:-
1.) Duty cycle
2.) Frequency

By cycling a digital signal ON and OFF at a fast enough rate and at a certain duty cycle, the output will appear like a constant voltage analogue signal. For eg: To create a 2V signal from a digital source which is either HIGH(5V) or low (0). We can use PWM with duty cycle of 40% here. This 40% duty cycle would yield an average voltage of 5×0.4=2V.

Important Features of PWM:

1. Precise Duty Cycle Control
   Allows fine-grained control over output power by adjusting the ON duration within each cycle.
2. Efficient Power Usage
   Minimizes energy loss by switching devices fully ON or OFF, making it ideal for power-sensitive applications.
3. Wide Range of Applications
   Used in motor control, LED dimming, audio modulation, signal generation, and more.
4. Timer-Based Hardware Generation
   PWM is generated using internal timers in microcontrollers, ensuring accurate and consistent output without heavy CPU usage.

What Is a PWM Signal and How Does It Work?

PWM (Pulse Width Modulation) is a method used by microcontrollers to simulate analog output using digital signals. By rapidly switching a pin ON and OFF, the output appears as a steady voltage.

• Duty cycle determines how long the signal stays ON in one cycle.
• PWM frequency controls how fast the ON/OFF transitions happen.
• Common use cases include motor speed control, LED dimming, and signal generation.

Example: A 40% duty cycle on a 5V system gives an average output of 2V.

STM32CubeMX Configuration

I am using the famous STM32F103C8 (BluePill) for this project. We will start with the Clock Configuration.

Clock Configuration

The clock configuration for the project is shown in the image below.

• External Crystal (8MHz) is used to provide the clock via the PLL and the system is running at maximum 72MHz clock.
• I am going to use the TIM1 for the PWM, which is connected to the APB2 Bus.
• The APB2 Timer clock is at 72MHz right now and that makes TIM1 clock = 72MHz.

PWM Configuration

The Timer1 PWM configuration is shown in the image below.

The detailed description of the image is mentioned below.

Timer Setting

• Clock Source: Internal Clock
  This sets the timer to use the internal APB2 clock as its source. It’s essential for generating precise time-based signals like PWM without relying on external clocks.
• Channel1: PWM Generation CH1
  This enables PWM output on Channel 1 of TIM1. It’s what makes the timer output a PWM signal rather than just counting.

Counter Settings

• Prescaler (PSC = 72-1)
  This divides the timer’s input clock frequency by 72.
  For example, if the APB clock is 72 MHz, the timer counts at 1 MHz after prescaling.
• Counter Mode: Up
  The timer counts from 0 up to the value in the AutoReload Register (ARR), then resets and starts over. This is the typical mode for PWM.
• Counter Period (ARR = 100-1)
  Sets the maximum count value (100 – 1 = 99), which defines the PWM frequency in combination with the prescaler.
  PWM Frequency = Timer Clock / (PSC + 1) / (ARR + 1)
  → For 72 MHz APB clock:
  → PWM Frequency = 72 MHz / 72 / 100 = 10 kHz

PWM Generation Channel 1 Settings

• Mode: PWM mode 1
  This sets the PWM output to PWM Mode 1, which means:
  • Output is HIGH when the counter is less than the pulse value.
  • Output is LOW when the counter is greater than or equal to the pulse value.
• Pulse (CCR1) = 0
  This defines the initial duty cycle — in this case, it’s 0, meaning no ON time.
  The output will stay LOW until this value is changed in code.

Pin Mapping (PA8 – TIM1_CH1)

• PA8 (TIM1_CH1)
  This is the GPIO pin where the PWM signal will appear.
  It is automatically configured as an alternate function output for TIM1 Channel 1. You can connect an LED, motor driver, or other device to this pin to control it with PWM.

Why do we need to use -1 ?

This is the setup as per the registers in STM32. The Prescaler Register and the ARR Registers are setup in a way, that they add a 1 to the value.

So whatever value we enter for the PSC, 1 will be added to that value. This is why we enter 1 less than the actual value.

PWM Set Function & Code Example in STM32

In the code below, we set PWM duty cycle by assigning a value to CCR1, which controls the pulse width. This directly affects the duty cycle of the output waveform.

 int main()
{
  ....
  TIM1->CCR1 = 30;
  HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
  while (1)
  {}
}

 int main()
{
  ....
  TIM1->CCR1 = 30;
  HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
  while (1)
  {}
}

• Inside the main function, set the pulse value in the Capture Compare Register (CCR).
• Since I am using Channel 1, the Register is CCR1. similarly, You can CCR2 for channel2, CCR3 for channel3 and so on.
• Finally Start the Timer in PWM mode

The value set in the CCR decides the width of the pulse. The formula to calculate the duty cycle is shown below

RESULT

Below is the image showing the PWM pulse captured on the Logic Analyser.

The image shows a PWM waveform with the following characteristics:

• Frequency: 10 kHz — each complete cycle lasts 100 microseconds.
• Duty Cycle: 30% — the signal stays HIGH for 30 microseconds and LOW for 70 microseconds in each cycle.
• The waveform clearly displays consistent pulse spacing and width, confirming stable PWM output.

This project successfully demonstrates how to generate a PWM signal using an STM32 microcontroller. We used CubeMX and HAL to configure timers, set the duty cycle, and analyze the PWM output waveform. You can apply this logic to other applications like dimming LEDs, controlling motors, or generating analog-style signals.

PROJECT DOWNLOAD

Project FAQs