Arduino Timer Interrupts: Timer Registers Explained

Phase correct PWM uses a symmetric counting approach where the timer counts up to a top value, then counts back down to zero. The pulse occurs at the same count value during both the up and down phases, placing it exactly in the middle of each period. This creates a more symmetrical waveform with reduced harmonic distortion compared to standard PWM, though it operates at half the effective frequency.

STM32 microcontrollers utilize built-in timers (also called counters) to generate PWM signals. Each timer can be configured with multiple channels, each controlling a separate output pin. Key configuration parameters include the prescaler (determining clock division), counter mode (up/down counting), counter period (maximum count value), and auto-reload preload (automatic restart). For PWM generation, each channel must be configured with PWM Generation mode, a pulse width value determining the duty cycle, and polarity settings. The pulse width value is typically expressed as a fraction of the counter period—for example, a pulse width of 25 out of 256 possible values produces approximately a 10% duty cycle.

This section explains how Fast PWM mode works on the ATmega328P timer. The timer counts up from 0 to the value in ICR1 (top value), then automatically resets. When the counter reaches OCR1A or OCR1B, the corresponding PWM pin goes HIGH. When the counter reaches ICR1, the pin goes LOW and the timer restarts. The frequency is determined by the ICR1 value: higher ICR1 means longer period and lower frequency. The minimum ICR1 is 3 and maximum is 65535. The video shows how to configure Timer 1 in Fast PWM mode using TCCR1A and TCCR1B registers, setting mode 14 for Fast PWM with ICR1 as top.

The ATmega328P microcontroller contains three timers: Timer0 (8-bit), Timer1 (16-bit), and Timer2 (8-bit). These timers generate PWM signals through compare units (OCR1A, OCR1B, OCR2A, OCR2B). The timer counts clock cycles and triggers actions when reaching specific values. The system clock is 16 MHz, but a prescaler divides this before counting. Common prescaler values are 1, 8, 64, 256, and 1024. A prescaler of 64 means the counter increments once every 64 system clock cycles. The timer overflows when reaching the TOP value (255 for 8-bit, 65535 for 16-bit), then resets to 0. PWM is generated using compare units that automatically switch the PWM pin when the timer reaches a specific value. The Timer Control Registers (TCCR1A, TCCR1B, TCCR1C) configure the prescaler, WGM (Waveform Generation Mode), and COM (Compare Match) bits.

This video demonstrates how to configure Arduino's Timer 1 using direct register access for PWM generation, enabling precise control of PWM frequency (2, 5, and 10 KHz) and duty cycle with higher resolution than Arduino's built-in PWM functions. The tutorial covers configuring COM1A and COM1B bits for PWM polarity, setting WGM bits for PWM mode, selecting prescaler values for timer frequency, calculating the maximum timer value (OCR1A) using the formula: Max = (System Frequency / (2 × PWM Frequency)) - 1, and implementing dead time between complementary PWM outputs for power electronics applications.

Input capture mode is a timer feature for measuring external signal frequencies by capturing counter values at signal transitions. The process involves: (1) Configuring timer parameters including clock source (e.g., 8 MHz), prescaler (e.g., 50,000), and capture polarity (rising edge), (2) Starting the timer to increment the counter, (3) Capturing counter values at each rising edge of the external signal, (4) Calculating the period by subtracting consecutive capture values (C2 - C1), and (5) Computing frequency using the formula: Frequency = System Clock Frequency / (C2 - C1). This technique enables precise measurement of any external signal frequency connected to capture pins, with accuracy determined by the system clock and prescaler settings.

The Input Capture (IC) mode of STM32 General Purpose Timers measures external signal frequency by capturing the timer counter value at each rising edge of the input signal; the time period is calculated as the difference between consecutive capture values, and frequency is derived from this period (e.g., with a 1 kHz timer clock and 7 count difference, the signal period is 7ms and frequency is approximately 142.86 Hz).

To measure frequency of a periodic square wave, the timer captures time between rising edges. Configuration involves setting each rising edge to reset the counter to zero. The counter counts clock ticks until the next rising edge, at which point the value is captured and converted to time units. Period in seconds equals captured ticks divided by clock frequency; frequency equals reciprocal of period. Multiple measurements can be averaged for noisy inputs. This technique is used in tachometers to calculate RPM from blade crossing events.

The STM32F1 timer's input capture function measures signal period length by detecting edges (rising or falling) on input pins and storing the corresponding timer counter values in capture registers; the captured value is converted to actual time by multiplying with the prescaler and dividing by the timer frequency (72,000,000 Hz for STM32F1), enabling precise measurement of external signal frequencies.

This lecture introduces the Timer Input Capture module in microcontrollers. The module captures the value of a timer when an external signal edge is detected on a specific input pin. This functionality is essential for measuring the frequency and period of external signals. The lecture covers the working principles of the input capture option module, including how the microcontroller samples the timer value at the moment of signal transition. The content explains that this feature is commonly used in applications requiring precise timing measurements, such as frequency analysis, pulse width measurement, and timing synchronization. The instructor emphasizes understanding the fundamental concepts of how the input capture module operates within the microcontroller's timer system.

The ATmega328P has 10-bit ADC resolution with internal 1.1V bandgap reference and 5 analog channels (ADC0-ADC4). The ADMUX register controls channel selection (MUX0-MUX3) and reference selection (REFS1-REFS0: 00=internal bandgap, 01=AVCC, 10=external AREF). The ADCSRB register enables the ADC (ADEN), starts conversion (ADSC), and enables auto-trigger mode (ADATE). The ADCSRB also controls auto-trigger sources for periodic conversions. The ADC should be disabled (ADEN=0) when not in use to save power. The ADC operates in three modes: (1) Single conversion - starts on ADSC bit set, waits for completion, (2) Free-running - continuously converts after each completion (ADATE=1), (3) Auto-trigger - starts conversion based on external triggers (analog comparator, external interrupt, timer). Channel selection must be done before starting conversion, as the ADC finishes the current conversion before switching channels. The ADSC bit remains set during conversion and clears when complete, serving as both start command and completion indicator.

The ATmega328P microcontroller in Arduino UNO has three timers (Timer 0, 1, and 2) with different bit depths and reserved functions: Timer 0 (8-bit, counts to 255) handles millis() and micros() functions and PWM on pins 5-6; Timer 1 (16-bit, counts to 65535) controls the Servo library and PWM on pins 9-10; Timer 2 (8-bit, counts to 255) manages the tone() function and PWM on pins 3-11. When using Timer 1 in comparison mode, you configure the OCR1A register with a comparison value and enable the interrupt vector (TIMER1_COMPA_vect) to generate precise timing intervals, such as creating a 500ms timing base by calculating the appropriate OCR1A value based on the clock frequency and prescaler settings.

The ATmega328P microcontroller contains multiple peripheral systems: timers for timing functions (millis, micros), analog-to-digital converters for reading analog signals, and communication buses including UART for serial programming, I2C for component communication, and SPI for high-speed data transfer. Pins are multi-functional, serving as digital I/O, analog inputs, clock signals, or interrupt inputs, though not all functions simultaneously.

The ATmega328p microcontroller features a 10-bit Analog-to-Digital Converter (ADC) that converts analog voltage signals into digital values using three key registers: ADMUX (for voltage reference selection, channel selection, and data justification), ADCSRA (for enabling the ADC, starting conversions, and checking conversion completion status), and ADCL/ADCH (for storing the 10-bit digital result). To implement a simple voltmeter, configure ADMUX with internal 5V reference and left adjustment (ignoring the two least significant bits), set ADCSRA with appropriate prescaler division (e.g., 64), enable the ADC, trigger a conversion, wait for the conversion complete flag, read the result from ADCH, and display it on output ports. The ADC requires external power connections on pins 20 (VCC) and 22 (GND) to function properly.

This tutorial explains how to configure microcontroller GPIO pins using C bitwise operations. The key concepts include: (1) Bitwise operations (AND, OR, XOR, NOT, and shift operations) for manipulating individual bits in registers; (2) Three essential registers for GPIO configuration: DDRx (Data Direction Register) to set pins as input (0) or output (1), PORTx to control output levels and enable pull-up resistors for inputs, and PINx to read the current state of pins; (3) Practical techniques for setting specific bits to 1 or 0 without affecting other bits using bitwise AND/OR with masks; (4) Complete workflow from creating a project in Atmel Studio to programming the ATMEGA328P microcontroller and testing with hardware components like LEDs and buttons.

The Arduino millis() function enables non-blocking multitasking by tracking elapsed milliseconds since startup, allowing multiple independent timing operations without halting program execution; this is achieved by storing a 'time for action' variable in each loop iteration and checking if millis() exceeds this threshold to trigger actions, unlike delay() which blocks the entire program.

Blocking delay functions (like delay_ms) stop program execution until the delay completes, wasting processor cycles. Non-blocking delay implementations use hardware timers and interrupt handlers to periodically update a time variable, allowing the program to continue executing other tasks during delays. The HAL_GetTick() function returns the current value of a global variable that increments on each timer interrupt. This variable is maintained by the system timer interrupt handler, which calls HAL_IncTick() to increment it. This provides a reliable time base for non-blocking delays and timing functions in embedded applications.

The video uses a post-it note analogy to explain non-blocking timers. Just as you might use a post-it note to remember to call someone at a specific time by periodically checking your watch against the note, Arduino can use a similar approach. You set a 'timer' (post-it) with a target time, and then periodically check if the current time has reached that target. When it does, you perform the action and set a new timer. This allows the program to continue running other tasks while waiting for the timer to expire, solving the blocking problem that delay() creates.

Millis mode is a non-blocking timing approach in microcontrollers that uses a timer to create delays without halting CPU execution. Unlike delay() which blocks program execution, millis mode allows the CPU to continue executing other tasks while waiting for time to pass. The millis() system uses Timer 0 configured to generate 1-millisecond interrupts, incrementing a global variable. Each task requires currentMillis, previousMillis, and interval variables. The task function calculates delta as currentMillis minus previousMillis, and executes when delta >= interval. After execution, previousMillis is updated. A 32-bit millis() overflows after approximately 49 days and 17 hours, while a 64-bit version lasts approximately 548 million years. Memory optimization can be achieved by storing intervals as constants in flash memory and using structs to organize task variables. The static keyword ensures variables persist across function calls. This enables true multitasking where multiple tasks run independently with different timing schedules without interfering with each other, making it essential for applications requiring multiple independent timing operations like controlling multiple LEDs with different blink rates or updating displays at different intervals.

Non-blocking delays use timer interrupts instead of blocking delay functions, allowing concurrent task execution. The technique calculates tick intervals (e.g., 48 MHz ÷ 9,600 = 5 kHz → 200 μs per tick) and counts ticks to measure elapsed time. When the counter reaches the target value, tasks execute and the timer resets. This approach enables efficient multitasking where the CPU handles sensor readings, communications, and other operations between scheduled events, maximizing system responsiveness.