Timers, PWM and Timing

What a hardware timer is

A timer is a counter that the chip’s clock increments on its own, whatever the program is doing. It can raise an interrupt when it overflows or reaches a compare value, toggle a pin automatically, capture the count when an input changes, and generate PWM. Because it runs in hardware, a timer keeps exact time without any CPU load, which is why periodic work, PWM and precise measurement are built on timers, not on loops and delay().

Prescaler and compare math

The timer’s clock is the system clock divided by a prescaler (1, 8, 64, 256, 1024 on an AVR). The time of one count is the tick, and the period of an interrupt is the compare value plus one, times the tick.

tick = prescaler ÷ f_clk    period = (compare + 1) × tick    compare = period ÷ tick − 1

// ATmega328P Timer1: interrupt once per second (CTC mode, prescaler 256)
cli();
TCCR1A = 0;
TCCR1B = (1 << WGM12) | (1 << CS12);   // CTC mode, prescaler 256
OCR1A  = 62499;                        // 16e6 / 256 - 1
TIMSK1 = (1 << OCIE1A);                // enable the compare-match interrupt
sei();

ISR(TIMER1_COMPA_vect) { seconds++; }  // keep it short

Timer modes: overflow, CTC, capture, PWM

Mode	What it does	Use
Normal / overflow	Counts to the maximum (255 or 65 535), overflows to 0 and raises an interrupt	A simple periodic tick; a free-running time base
CTC (clear on compare match)	Counts to the compare value, then restarts	Exact periods and frequencies
Input capture	Copies the counter to a register when an input pin changes	Measuring pulse width, frequency and time between events with tick resolution; no ISR jitter
Output compare	Toggles, sets or clears a pin when the counter matches	Generating exact waveforms and delays by hardware
PWM (fast, phase-correct)	Counts and sets the pin high and low at compare values	PWM for LEDs, motors, servos and DACs
Quadrature decoder / external clock	Counts edges from an encoder or pin	Encoders and pulse counting (see GPIO, Interrupts and Debouncing)

Capture is the accurate way to measure. To measure the period of a signal, capture the timer at two successive edges and subtract: the unsigned subtraction survives one counter overflow. The resolution is one tick, so a 4 µs tick measures a 1 kHz signal’s period (1 000 µs) to ±0.4 %.

PWM: frequency, duty and resolution

Pulse-width modulation switches a pin on and off at a fixed frequency and varies the fraction of time it is on, the duty cycle. A load that responds slowly (an LED to the eye, a motor to its inertia, an RC filter) sees the average voltage.

V_average = duty × V_supply    f_PWM = f_clk ÷ (prescaler × counts per period)

• Change the duty cycle by writing the compare register, not by stopping and restarting the timer, so there are no glitches. Most timers latch the new value at the end of the period.
• Dead time between the on-times of two switches in a half-bridge prevents shoot-through; use a timer with a dead-time generator for that.
• PWM is not an analog output. For a smooth voltage add an RC filter (below) or use a DAC.
• Motors and heaters need a driver stage, and a flyback path for inductive loads (see Driving Motors and Actuators).

Servo and ESC pulses

A hobby servo is not controlled by duty cycle but by pulse width: a pulse of 1 to 2 ms repeated every 20 ms (50 Hz), with 1.5 ms at the center. The same signal drives most ESCs (motor controllers).

From PWM to an analog voltage

A simple RC low-pass turns a PWM into a slowly varying voltage. The cut-off frequency f_c = 1 ÷ (2π R C) must be well below the PWM frequency to give a small ripple, and well above the rate at which you need the output to change.

Timing in software without blocking

delay() stops the program, so nothing else runs while it waits. Instead of waiting, compare a running millisecond counter against the time of the last action. Unsigned subtraction handles the counter roll-over automatically: millis() − last ≥ interval stays correct when the 32-bit counter wraps, which happens after 2³² ms = 49.7 days.

const unsigned long BLINK_MS = 500, READ_MS = 100;
unsigned long lastBlink = 0, lastRead = 0;

void loop() {
  unsigned long now = millis();
  if (now - lastBlink >= BLINK_MS) { lastBlink += BLINK_MS; toggle_led(); }  // += keeps long-term accuracy
  if (now - lastRead  >= READ_MS)  { lastRead  += READ_MS;  read_sensor(); }
}

• Add the interval, do not reset to now: last += interval keeps the average period exact even when a pass is late; last = now accumulates the lateness.
• Time stamps: micros() overflows every 71.6 minutes (2³² µs): use it only for short intervals.
• Short delays of a few microseconds (waiting for a sensor, a bit-banged protocol) are fine as busy waits in a driver function; keep them under about 100 µs.
• Jitter: a loop-based schedule runs a task late when the loop is busy. If timing must be exact, use a timer interrupt or a hardware timer output, or an RTOS with priorities (see Firmware Architecture, State Machines and RTOS).

Clock accuracy and drift

Clock source	Typical accuracy	Error per day	Notes
Internal RC oscillator	±1 to ±5 % (factory trimmed ±1 %)	14 to 72 minutes	Drifts with temperature and voltage; fine for timing loops, not for UART at high speed or time-keeping
Ceramic resonator	±0.5 %	7 minutes	Cheap and good enough for UART
Quartz crystal (20 to 50 ppm)	about 0.002 to 0.005 %	4.3 s at 50 ppm	The normal choice; temperature affects it
32.768 kHz watch crystal (RTC)	10 to 20 ppm at 25 °C	1 to 2 s	Low power, used for a real-time clock; the error is largest at temperature extremes
TCXO / GPS-disciplined	0.5 to 2 ppm, or better	under 0.2 s	Time and frequency standards

A 50 ppm clock is off by 50 × 10^-6 × 86 400 s = 4.3 s per day, about 26.3 minutes a year. A device that must keep the right time over months needs a time source (GPS, network time) to correct it, or a better oscillator.

Related

• Embedded Systems: the overview of this guide.
• GPIO, Interrupts and Debouncing: interrupts and debouncing.
• Analog Input and Signal Processing: sampling at a steady rate from a timer.
• Firmware Architecture, State Machines and RTOS: schedulers built on a timer tick.
• Analog Circuits and Sensing and Motion Control and Actuators: filters and motor drives.

FAQ

Why is my PWM at a different frequency than I expected?

The library may use a different timer mode or prescaler than you assumed (Arduino sets different defaults on different pins). Read the timer registers, check the library source and measure with an oscilloscope or logic analyzer.

What is the difference between millis() and a timer interrupt?

millis() is itself driven by a timer interrupt (about every millisecond); it gives a time you can compare. A timer interrupt of your own runs code at exact intervals regardless of what the main loop is doing.

How do I get more PWM channels than there are timers?

Each timer provides several compare channels at the same frequency. For more, use a dedicated PWM driver chip over I²C (such as a PCA9685) or a bit-banged software PWM at a low frequency.

Why does my servo jitter?

Noise on the signal, an unstable supply, or pulses generated by software with variable timing. Use hardware timer pulses, a separate servo supply with the grounds joined, and a decoupling capacitor.

References

• Microcontroller datasheets (timer/counter chapters; prescaler, CTC, PWM modes) for the ATmega328P, RP2040 and STM32.
• Hobby servo and ESC manufacturers’ data (pulse widths and rates); Horowitz and Hill, The Art of Electronics (RC filters).
• White, E., Making Embedded Systems, O’Reilly (timers and time-keeping).

Last reviewed: October 2026. Register names and counts are for the ATmega328P at 16 MHz: check your own chip’s datasheet.