A technical, beginner-friendly breakdown of the Arduino UNO R3, focusing on the sections covered in Part 1: the board architecture, ATmega328P, processor and memory, digital I/O, UART pins, PWM, analog inputs and I2C pins.
The Arduino UNO R3 is a development board designed for electronics and programming. The board is equipped with the ATmega328P and an ATmega16U2 microcontroller.
The important distinction is between the microcontroller and the development board.
| Term | What it means |
|---|---|
| ATmega328P | The main AVR microcontroller that executes the user's application program and provides the main GPIO and peripheral functions. |
| Arduino UNO R3 | The complete development board built around the ATmega328P, with power circuitry, connectors, clocking, reset circuitry, USB connection and headers. |
The UNO R3 provides 14 digital input/output pins, 6 analog inputs, USB connectivity, an ICSP header and a reset button.
The ATmega328P is the main application microcontroller of the UNO R3. Most of the ATmega328P's I/O pins are available through the UNO R3 headers. The ATmega16U2 provides the USB interface and communicates with the ATmega328P through the board's serial connection.
8-bit AVR-based microcontroller used as the main application processor.
The AVR CPU operates at up to 16 MHz on the UNO R3.
Non-volatile memory used for the application program and bootloader.
Volatile working memory used while the program is running.
Non-volatile memory intended for data that should survive power removal.
Digital I/O, timers, PWM, USART, SPI, I2C and other integrated peripherals.
The ATmega328P includes timers/counters, USART, SPI, I2C, analog comparator, watchdog timer, PWM channels and pin-change interrupt/wake-up capability.
A microcontroller is not just a CPU. It combines a processing core, memory and dedicated hardware peripherals inside a single IC.
| Block | Technical role |
|---|---|
| AVR CPU | Fetches, decodes and executes program instructions. |
| Flash | Stores program code in non-volatile memory. |
| SRAM | Provides volatile working memory during execution. |
| EEPROM | Provides non-volatile data storage. |
| Timers / Counters | Hardware timing, counting and compare functions. |
| USART | Hardware serial communication interface. |
| SPI | Synchronous serial communication peripheral. |
| I2C | Two-wire controller/peripheral communication interface. |
| PWM channels | Hardware-generated pulse-width-modulated outputs. |
| Analog comparator | Hardware comparison of analog input levels. |
| Watchdog timer | Independent timing mechanism used for watchdog operation. |
These blocks are integrated into the ATmega328P rather than being separate external ICs. The ATmega328P includes two 8-bit timers/counters, one 16-bit timer/counter, USART, SPI, I2C, analog comparator, watchdog timer and six PWM channels.
CPU stands for Central Processing Unit. At the microcontroller level, the CPU is the part that executes the instruction stream generated from your program.
Your Arduino program contains an operation such as setting a digital output. After the program is compiled and stored in program memory, the AVR CPU executes the corresponding machine instructions. The required peripheral or GPIO hardware then performs the requested operation.
In other words, the CPU performs the processing, while dedicated hardware peripherals handle functions such as timers, communication and PWM.
| Memory | Capacity | Technical purpose | Power-off behavior |
|---|---|---|---|
| Flash | 32 kB | Program storage | Retains contents |
| SRAM | 2 kB | Runtime working data | Contents are lost |
| EEPROM | 1 kB | Non-volatile application data | Retains contents |
The ATmega328P provides 32 kB of Flash. This is the non-volatile program-memory area used to hold the application firmware.
The ATmega328P has 2 kB SRAM. SRAM is volatile working memory used while the firmware is executing—for example, for variables, temporary values and runtime state.
The ATmega328P has 1 kB EEPROM. EEPROM is non-volatile data memory, so data stored there can remain available after the board loses power.
The ATmega328P provides 32 kB Flash, 2 kB SRAM and 1 kB EEPROM.
The UNO R3 provides 14 digital input/output pins. These pins can be configured as digital inputs or digital outputs, depending on the application.
| Pin group | Range | Basic role |
|---|---|---|
| Digital GPIO | D0–D13 | Digital input or digital output |
The GPIO is configured to observe a digital signal, such as a push-button or digital sensor output.
The GPIO drives a digital logic level to an external circuit, such as an LED or control input.
pinMode(13, OUTPUT);
digitalWrite(13, HIGH);
The Arduino API configures the pin and requests the corresponding digital output state.
| Arduino pin | Label | Serial role |
|---|---|---|
| D0 | RX | Receive |
| D1 | TX | Transmit |
Pins 0 and 1 are associated with the ATmega328P's USART peripheral. The USART supports asynchronous serial communication.
RX means Receive, while TX means Transmit. These signals are used for asynchronous serial communication.
The UNO R3 provides six PWM channels. On the Arduino UNO, these are exposed on digital pins D3, D5, D6, D9, D10 and D11.
| PWM-capable pin | Typical use |
|---|---|
| D3 | PWM output |
| D5 | |
| D6 | |
| D9 | |
| D10 | |
| D11 |
PWM stands for Pulse Width Modulation. Instead of producing a continuously variable analog voltage, the digital output switches between logic states while the fraction of time spent HIGH—the duty cycle—is controlled.
analogWrite(9, 128);
In the Arduino API, a value of 128 corresponds approximately to a 50% duty-cycle command on the standard UNO PWM interface. This can be used for applications such as LED brightness control or, with suitable driver electronics, motor control.
Digital pin D13 is connected to the UNO board's onboard indicator LED. This makes it convenient for basic hardware tests without adding an external LED.
pinMode(13, OUTPUT);
digitalWrite(13, HIGH);
Setting the pin HIGH drives the associated onboard LED circuit; setting it LOW turns the output state off.
Pin 13 is therefore commonly used in introductory Arduino examples to demonstrate that the program is running and that a digital output can be controlled.
The UNO R3 provides six analog inputs. They are labelled A0 through A5. A4 and A5 additionally support the I2C interface.
| Pin | Primary label | Additional function |
|---|---|---|
| A0 | Analog input 0 | GPIO |
| A1 | Analog input 1 | GPIO |
| A2 | Analog input 2 | GPIO |
| A3 | Analog input 3 | GPIO |
| A4 | Analog input 4 | I2C SDA |
| A5 | Analog input 5 | I2C SCL |
An analog input is used when the signal represents a continuously varying voltage rather than only a digital HIGH/LOW state. A potentiometer is a simple example: rotating it changes the voltage presented to the analog input.
The analog pins A4 and A5 have a second role as the two main I2C signal lines.
| Arduino pin | I2C signal | Meaning |
|---|---|---|
| A4 | SDA | Serial Data |
| A5 | SCL | Serial Clock |
The UNO R3 uses A4 as the I2C Data line (SDA) and A5 as the I2C Clock line (SCL).
At the microcontroller level, the ATmega328P includes a dual-mode controller/peripheral I2C interface. This allows the board to communicate with compatible sensors, displays and other I2C devices using the two-wire bus.
This page covers the technical material up to the point reached in Part 1: board definition, ATmega328P architecture, CPU, memory, digital GPIO, RX/TX, PWM, D13, analog inputs and A4/A5 I2C functionality.
Part 2 can continue with the remaining UNO R3 board-level hardware and interfaces. 🚀