GPIO, timers, interrupts and PWM

Why this matters

Everything an MCU does with the outside world starts at its pins: reading buttons and sensor signals, driving LEDs, and commanding servos or ESCs with pulses accurate to microseconds. Counting time with the CPU is inaccurate and wastes time needed for other work, so MCUs have timers that generate pulses by themselves, and interrupts that wake the CPU when something happens.

GPIO

A GPIO (general-purpose input/output) pin can be set as an input or output. An unconnected input “floats” and reads random values, so it needs a pull-up (to the positive supply) or pull-down (to ground), usually available inside the chip. A button to ground with a pull-up reads 1 when released and 0 when pressed.

Timers and PWM

A timer counts the clock $f_{\text{TIM}}$ after dividing it by a prescaler (PSC), then counts up to the auto-reload (ARR) value and restarts. According to ST’s timer cookbook (AN4776), the cycle frequency is $f_{\text{TIM}}/((\text{PSC}+1)(\text{ARR}+1))$. The CCR value sets where the pin switches from high to low, and so sets the pulse width.

PWM servos and ESCs read the pulse width as the command. ArduPilot’s output defaults are SERVOx_MIN 1100, SERVOx_TRIM 1500 and SERVOx_MAX 1900 µs; the pulse frequency depends on the device, so check the documentation of the servo or ESC used.

f_tim = 84_000_000
tick_hz = 1_000_000                       # count in 1 µs steps
psc = f_tim // tick_hz - 1
period_us = 20_000
arr = period_us - 1
f_pwm = f_tim / ((psc + 1) * (arr + 1))
print(f"PSC = {psc}, ARR = {arr}, f_PWM = {f_pwm:.1f} Hz")
for pulse_us in (1100, 1500, 1900):
    print(f"pulse {pulse_us} µs -> CCR = {pulse_us}, duty = {pulse_us / (arr + 1):.2%}")

PSC = 83, ARR = 19999, f_PWM = 50.0 Hz
pulse 1100 µs -> CCR = 1100, duty = 5.50%
pulse 1500 µs -> CCR = 1500, duty = 7.50%
pulse 1900 µs -> CCR = 1900, duty = 9.50%

Polling and interrupts

• Polling: the main program checks the status repeatedly. Simple, but it wastes CPU and can miss short events
• Interrupts: the hardware pauses the main program to call an ISR (interrupt service routine), then resumes. The ISR must be as short as possible: set a flag and let the main program do the heavy work

Mechanical buttons have contacts that bounce briefly when pressed, appearing as several presses. They must be debounced, accepting a new value only once it has been stable long enough.

samples = [1] * 5 + [0, 1, 0, 1, 1, 0, 0, 1, 0] + [0] * 20 + [1, 0, 1] + [1] * 15
raw_presses = sum(1 for a, b in zip(samples, samples[1:]) if a == 1 and b == 0)

stable, candidate, count, presses = 1, 1, 0, 0
for s in samples:
    count = count + 1 if s == candidate else 1
    candidate = s
    if count >= 5 and candidate != stable:
        stable = candidate
        presses += stable == 0
print(f"raw falling edges: {raw_presses}, debounced presses: {presses}")

raw falling edges: 5, debounced presses: 1

Module lab

Common mistakes

Summary

• GPIO inputs need a pull-up or pull-down
• PWM frequency is $f_{\text{TIM}}/((\text{PSC}+1)(\text{ARR}+1))$, and CCR sets the pulse width
• ArduPilot’s default pulses are 1100–1900 µs with 1500 µs centre
• Interrupts respond to events at once; ISRs must be short, and buttons must be debounced

Check your understanding

1. With $f_{\text{TIM}}=48$ MHz, PSC = 47 and ARR = 999, what is the PWM frequency?
2. In question 1, what is the duty cycle if CCR = 250?
3. To count in 1 µs steps from a 150 MHz clock, what PSC is needed?
4. What is ArduPilot’s default centre pulse (SERVOx_TRIM)?
5. Why should an ISR be as short as possible?