Arduino PWM Frequency Change Tutorial: Timer Prescaler Guide

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.

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.

GPIO (General Purpose Input Output) is the fundamental MCU function enabling signal exchange with external devices. ATmega328P organizes GPIO into three ports: Port B (8 pins), Port C (7 pins), and Port D (8 pins). Pins have special functions: PC6 as reset, PB0-PB2 for SPI SCLK, RXD/TXD for UART, INT0/INT1 for interrupts, AIN0/AIN1 for comparators, and ADC0-ADC5 for conversion. However, ATmega328P has only one ADC handling one conversion at a time. Configuration is achieved through register manipulation, with MCUCR at 0x55 containing control bits for interrupt vectors and brown-out detection.

Timers and counters in the AVR-ATMega328P microcontroller are hardware modules that can count external pulses or generate delays using internal oscillator signals; the device contains three timers (Timer 0 and Timer 2 as 8-bit timers, Timer 1 as a 16-bit timer) with key registers including TCNT for counting values, TIFR for overflow flags, TCCR for control and pre-scaling, and OCR for output compare match functionality.

Timers are essential microcontroller peripherals for timing tasks like blinking LEDs. The Arduino Uno (AT Mega 328P) has three timers: Timer 0 and Timer 2 are 8-bit (count 0-255), while Timer 1 is 16-bit. Timer 0 can count machine cycles or external events, with count sources being multiples of machine cycles (e.g., 8 machine cycles per count). It generates three interrupt sources: overflow (at 255), compare match A, and compare match B. This hardware-based approach solves problems of wasting processor time for delays and complex timing calculations.

Three methods manipulate individual register bits in C: bit masking, bit fields, and direct bit access. Bit masking uses OR and AND operations with masks to modify specific bits while preserving others. Bit fields use processor-defined macros (like LATD0) for cleaner syntax. Direct bit access uses only bit identifiers. Bit masking offers maximum portability across microcontroller families. Bit fields provide clearer code but are less portable. The delay function requires defining the oscillator frequency (e.g., #define _XTAL_FREQ 64000000) for accurate timing calculations.

Bit manipulation is the most important low-level skill in embedded programming. Every GPIO configuration, peripheral clock enable, or sensor flag read involves manipulating individual bits in hardware registers. The four core operations are: Set (reg |= mask) uses OR to turn specific bits on while leaving others unchanged; Clear (reg &= ~mask) uses AND with inverted mask to turn specific bits off; Toggle (reg ^= mask) uses XOR to flip bits automatically without tracking state; Read (reg >> N) & 1) combines right shift with AND to isolate and check a specific bit. AND outputs one only when both inputs are one, making it perfect for masking. OR outputs one if either input is one, making it ideal for setting bits. XOR with zero leaves bits unchanged, XOR with one flips them. The tilde parenthesis pattern ~((1U) << N) is essential for creating inverted masks. Always use OR assign to preserve other bits, use NOT to invert masks for clearing, and use U suffix for unsigned masks to avoid undefined behavior with high bit shifts.

Microcontrollers require configuration of peripherals through setup using configuration registers, involving setting and clearing bits to enable features, clear flags, and change clock sources. C provides bitwise operators: ~ (complement/invert), | (OR), & (AND), and ^ (XOR). These operate bitwise, with each bit position in one argument operated on with the corresponding bit in the other. The tilde (~) inverts all bits. OR with a mask sets bits to 1 where mask has 1s. AND with a mask clears bits to 0 where mask has 0s. XOR toggles bits where mask has 1s. C also provides shorthand assignment operators (|=, &=, ^=) that combine operation with assignment. A critical concept is that clearing bits requires inverting the mask (~mask) before using AND, as header file masks have 1s at bits to set, not clear.

This video teaches how to manipulate specific bits in hardware registers using bitwise operations. The key concepts include: (1) Using bitwise AND to reset specific bits by creating a mask with 0s in target positions and 1s elsewhere, then applying AND to clear only those bits; (2) Using bitwise OR to set specific bits by creating a mask with 1s in target positions and 0s elsewhere, then applying OR to set only those bits. The process involves first resetting unwanted bits and then setting desired bits. Practical implementation uses hexadecimal notation combined with left shift operators for efficient code writing. This technique is essential for configuring microcontroller peripherals like GPIO pins.

Bitwise operators work on binary representations: AND (&), OR (|), XOR (^), NOT (~), left shift (<<), right shift (>>). AND sets bits to 1 only if both are 1, OR sets to 1 if either is 1, XOR sets to 1 if bits differ. NOT inverts all bits. Shifts move bits left/right, equivalent to multiplication/division by 2.

The prescaler determines the division ratio for the timer clock. The CS0, CS1, and CS2 bits (located in TCCRB) control the prescaler value. According to the ATmega328P datasheet: CS0=0, CS1=1, CS2=0 gives prescaler=8; CS0=0, CS1=1, CS2=1 gives prescaler=64; CS0=1, CS1=0, CS2=0 gives prescaler=256. These bits must be set to achieve the desired prescaler value.

This lesson explains how to configure ATmega328P timers using TCCR1A and TCCR1B registers, including setting waveform generation mode bits (WGM13-10) for normal mode (all zeros) and clock select bits (CS12-10) for prescaler selection (e.g., 1024 for maximum slowdown), with the timer counting from 0 to 65535 (2^16-1) before wrapping around.

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.

The ATmega328P is an 8-bit RISC microcontroller with 28 pins, 131 instructions, and 32 general-purpose 8-bit registers. It operates at up to 20 MHz with Harvard architecture enabling pipelining. Memory includes 32KB flash for programs, EEPROM for data (100K write cycles), and RAM for variables. The memory map reserves the first 32 addresses for register mapping. Peripherals include 23 I/O pins across three ports, 12 8-bit timers (two 16-bit), 16 PWM channels, 8-channel 10-bit ADC, and three serial protocols (I2C, SPI, UART). Clock sources include internal RC oscillator (up to 8 MHz), external crystal (up to 20 MHz), or external clock. All peripherals require clock signals and can be configured through frequency multiplication or division.

The ATmega328P data sheet includes several key features: two 8-bit timers/counters, one 16-bit timer/counter, 6 PWM channels, 8 10-bit ADC channels, a programmable USART serial interface, a master/slave SPI serial interface, a programmable watchdog timer, interrupt capabilities, and wake-up on pin change functionality. These features are essential for understanding the microcontroller's capabilities and limitations.