How to Generate PWM in STM32 using Timers (HAL & STM32CubeMX)

Pulse Width Modulation (PWM) is one of the most common techniques in embedded systems. In simple words, PWM controls the amount of power delivered to devices by switching a signal on and off very fast. Because of this, you can dim an LED, control the speed of a motor, or even generate audio signals with just a microcontroller pin.

In STM32 microcontrollers, PWM generation becomes very simple because the timers have built-in support. You only need to configure the timer, select the channel, and set the frequency and duty cycle. After that, the hardware takes care of generating a clean PWM signal.

Compared to manually toggling GPIOs, using timers is much more accurate and efficient. As a result, PWM in STM32 is widely used in robotics, automation, motor drivers, LED brightness control, and many other real-world projects.

In this tutorial, you will learn step by step how to configure PWM on STM32 using STM32CubeMX and the HAL library. First, we will look at the basic concept of PWM and timers. Then, we will configure the project in CubeMX, generate code, and finally test the output on real hardware.

Hardware Required for STM32 PWM Tutorial

To follow this tutorial, you will need the following hardware:

• STM32F446 Dev Board (e.g., STM32F4, STM32F7, STM32H7, or any board with ADC support)
• Breadboard (for easy circuit connections)
• Jumper Wires (male-to-male for connections)
• USB Cable (to connect the STM32 board to the PC for programming and debugging)

What is PWM?

Pulse Width Modulation (PWM) is a technique to control the average voltage or power delivered to a device by switching a signal between ON and OFF very quickly. The main idea is simple: the longer the signal stays ON compared to OFF, the more power the device receives. This ratio is called the duty cycle, while the speed of switching is called the frequency.

For example, a 50% duty cycle means the signal stays ON for half the time and OFF for the other half. As a result, the device receives about half of the maximum possible power. By adjusting the duty cycle, you can dim LEDs, control motor speed, or manage the intensity of heaters.

PWM is efficient because the switching happens fast, and the power loss is very low compared to analog methods like resistors or voltage regulators.

PWM in Microcontrollers (MCU)

Microcontrollers (MCUs) like the STM32 have built-in timers that make PWM generation very easy. Instead of manually toggling pins, the hardware timers automatically create precise PWM signals at the frequency and duty cycle you choose.

With STM32, you can configure PWM using STM32CubeMX and then control it in code with the HAL library. This approach ensures accuracy and frees up the CPU for other tasks.

In real-world projects, PWM in microcontrollers is everywhere — from controlling DC motors in robots to adjusting LED brightness in displays. Because it is both powerful and simple, PWM is often the first concept you learn when starting with STM32.

STM32 Timer Overview for PWM

Timer modes relevant to PWM

STM32 microcontrollers include powerful timers that can directly generate PWM signals. These timers run independently from the CPU, which means you can produce accurate waveforms without using much processing power.

For PWM, the most commonly used timer modes are:

• Up-counting mode: The timer starts counting from 0 and goes up to the value in the Auto-Reload Register (ARR). After reaching this value, the timer resets and starts again.
• PWM Mode 1: The output stays HIGH while the counter is less than the compare value (CCR). It switches LOW when the counter goes above the CCR value.
• PWM Mode 2: The opposite of Mode 1. The output stays LOW when the counter is less than CCR and becomes HIGH afterward.

By selecting the right mode, you can decide how your PWM waveform behaves.

The image above shows how the timer counter compares with ARR and CCR to generate a PWM output.

• The blue line is the counter increasing up to ARR.
• The red line (CCR) decides when the output switches from HIGH to LOW.
• The green waveform is the actual PWM signal produced.

Frequency and duty cycle basics

Every PWM signal has two important properties: frequency and duty cycle.

• PWM frequency tells how many times the signal completes a full cycle in one second. It depends on three parameters: timer clock, prescaler (PSC), and ARR.
  Formula:PWM frequency = Timer clock / (PSC + 1) / (ARR + 1)
• Duty cycle defines the percentage of ON-time in each cycle. It depends on the compare register (CCR) value.
  Formula:Duty cycle (%) = (CCR / (ARR + 1)) × 100

For example, if ARR = 999 and CCR = 500, then the duty cycle = 50%. This means the signal stays HIGH for half the time and LOW for the other half.

The image above shows PWM signals with 25%, 50%, and 75% duty cycles.

Configuring PWM using STM32CubeMX

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

STM32 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.

STM32 PWM Timer Configuration

I am going to use the Timer 1 to generate the PWM signal. 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 ?

In STM32 timers, the Prescaler (PSC) and Auto-Reload Register (ARR) work in a way that they automatically add +1 to the value you enter. This means if you write a value of PSC = 71, the timer actually divides the clock by 72. Similarly, if you set ARR = 999, the counter counts up to 1000.

That’s why, when calculating values for frequency or period, we subtract 1 in the formula to match the hardware behavior.

Writing Code with HAL for PWM

The STM32 HAL library makes it easier to configure and control PWM signals without dealing directly with low-level registers. Let’s break down the process step by step.

Initializing the Timer

First, initialize the timer for PWM mode. When you generate code from STM32CubeMX, it automatically creates initialization functions such as MX_TIMx_Init(). This function sets the prescaler (PSC), auto-reload register (ARR), and configures the timer in PWM mode.

In addition, CubeMX configures the GPIO pin linked to your timer channel in Alternate Function mode, so that the PWM signal can appear on the physical pin.

Starting PWM Output

After initialization, start the PWM output using the HAL function:

HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);

HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);

Here:

• htim1 is the timer handle generated by CubeMX.
• TIM_CHANNEL_1 selects the PWM channel (Channel 1 in this case).

You can repeat the same function with TIM_CHANNEL_2, TIM_CHANNEL_3, or TIM_CHANNEL_4 if your timer supports multiple channels.

Changing Duty Cycle in Code

To change the duty cycle at runtime, update the Capture/Compare Register (CCR). For example:

TIM1->CCR1 = 30;  // Set duty cycle value <= ARR

TIM1->CCR1 = 30;  // Set duty cycle value <= ARR

• The value written to CCR1 controls the ON-time of the signal.
• A higher CCR value means a longer pulse (higher duty cycle).
• A smaller CCR value means a shorter pulse (lower duty cycle).

The duty cycle is calculated using the formula:

This method allows you to dynamically adjust brightness of an LED, speed of a motor, or any other load connected to the PWM pin.

Complete PWM Code

You can refer to the main function below to change the duty cycle at the Runtime.

int main(void)
{
  HAL_Init();
  SystemClock_Config();  // System clock setup
  MX_GPIO_Init();        // GPIO init
  MX_TIM1_Init();        // Timer1 init with PWM

  while (1)
  {
    /* Example: Update duty cycle dynamically */
    for (int duty = 0; duty <= 99; duty += 10)
    {
      __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, duty);  // TIM1->CCR1 = duty;
      HAL_Delay(500);  // Wait 500ms before changing duty cycle
    }
  }
}

int main(void)
{
  HAL_Init();
  SystemClock_Config();  // System clock setup
  MX_GPIO_Init();        // GPIO init
  MX_TIM1_Init();        // Timer1 init with PWM

  while (1)
  {
    /* Example: Update duty cycle dynamically */
    for (int duty = 0; duty <= 99; duty += 10)
    {
      __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, duty);  // TIM1->CCR1 = duty;
      HAL_Delay(500);  // Wait 500ms before changing duty cycle
    }
  }
}

The code above gradually changes the PWM duty cycle from 0% to 100%. It increases the duty cycle in 10% steps, and each step occurs every 500 milliseconds.

STM32 PWM Generation Result

The image below show the PWM pulse captured on the Logic Analyser.

PWM waveform above has 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.

The gif below shows the duty cycle changing every 500ms (press the Play Button). It varies from 0 to 100% in step of 10%.

Applications of PWM in STM32

LED Dimming

PWM allows precise control over LED brightness by adjusting the duty cycle. This technique is widely used in lighting systems and displays to achieve energy-efficient illumination.

Motor Control

By varying the duty cycle, PWM enables control over motor speed and torque. This is essential in applications like robotics, fans, and servo motors, where precise motion control is required.

Communication Protocols

PWM can be utilized in communication systems to encode data. By modulating the pulse width, information can be transmitted between devices, making it useful in various signaling applications.

Troubleshooting PWM Issues

Incorrect Frequency Output

Ensure that the timer’s prescaler and auto-reload register (ARR) are correctly configured to achieve the desired frequency. Double-check the system clock settings in STM32CubeMX to confirm that the timer is receiving the correct clock source.

Duty Cycle Not Updating

If changes to the duty cycle aren’t reflected in the output, verify that the compare register (CCR) is being updated correctly. Additionally, ensure that the timer is running and not in a stopped state.

Pin or Channel Mismatch

Confirm that the PWM output pin is correctly mapped to the timer channel in STM32CubeMX. Mismatches between the configured pin and the actual hardware connection can lead to no output signal.

Conclusion

This tutorial successfully demonstrates how to generate a PWM signal using an STM32 microcontroller. We learned how to configure timers in STM32CubeMX, start PWM output using HAL functions, and adjust the duty cycle to observe changes in the waveform. You can apply this knowledge to practical applications such as dimming LEDs, controlling motor speed, or generating analog-style signals.

In the next tutorials, we will explore advanced topics like PWM input measurement, using DMA with PWM, and generating three-phase PWM signals for motor control. These lessons will help you take your STM32 projects to the next level.

STM32 Timer Tutorial Series

STM32 TIMERS #2. How to Measure PWM Input

STM32 TIMERS #3. How to use the ENCODER Mode

STM32 Input Capture Example – HAL_TIM_IC_CaptureCallback for Frequency, Pulse Width

STM32 TIMERS #5. Timer synchronization || Slave Trigger mode

STM32 TIMERS #6. Timer synchronization || Generate 3 Phase PWM

STM32 TIMERS #7. Timer synchronization || Slave Reset mode

STM32 TIMERS #8. Make 48 bit Counter by Cascading Timers

STM32 Timers #9. One Pulse Mode

1 2 Next »

PROJECT DOWNLOAD

STM32 PWM Output Project FAQs