Arduino Uno

What is the Arduino Uno?

The Arduino Uno is an open-source microcontroller development board built around the 8-bit ATmega328P. It gives you an easy way to read sensors, drive outputs and run your own code — programmed over a single USB cable with the free Arduino IDE.

Everything on the board exists to serve that one chip: connectors to power it, a crystal to clock it, a USB chip to program it, and rows of header pins to connect it to the world.

A map of the Uno R3: the ATmega328P runs your code; everything else powers it, clocks it or connects it.

The Brain: ATmega328P

At the centre of the board sits the ATmega328P — a complete little computer on one chip: a CPU, three kinds of memory, and a set of built-in peripherals, all clocked at 16 MHz.

Inside the ATmega328P: CPU + 32 KB flash / 2 KB SRAM / 1 KB EEPROM + GPIO, ADC, timers and serial buses.

• Flash (32 KB) — stores your program; about 0.5 KB is used by the bootloader.
• SRAM (2 KB) — working memory for variables while the program runs.
• EEPROM (1 KB) — small non-volatile store that survives power-off (settings, calibration).
• Peripherals — 10-bit ADC, three timers (for PWM & timing), and hardware UART, SPI and I2C.

Full Arduino Uno Pinout

Here is the complete pinout. Every pin carries an Arduino number, its AVR port name (PBx / PCx / PDx) and any alternate function — ADC, PWM (~), SPI, I2C or UART.

The full Uno R3 pinout — digital pins on the right, power & analog on the left, colour-coded by function.

Prefer a simpler view? This colour-coded map groups the pins by what they do:

Quick overview: digital (0–13), PWM ~, analog (A0–A5) and power pins.

Every Pin Explained

Let's go through each group of pins and exactly what it does.

Digital pins (D0–D13)

14 general-purpose pins that read or write two states only — HIGH (5 V) or LOW (0 V). Set direction with pinMode(), then use digitalWrite() or digitalRead(). Each pin handles ~20 mA (40 mA absolute max). Several have special roles:

Analog input pins (A0–A5)

6 pins connected to a 10-bit ADC that converts 0–5 V into a number from 0 to 1023 using analogRead(). They can also be used as digital pins 14–19. Two are special:

• A4 = SDA and A5 = SCL — the hardware I2C bus.
• AREF lets you supply an external analog reference voltage for the ADC.

Power pins

Powering the Uno

You can power the Uno three ways: over USB (5 V), from a 7–12 V DC jack, or through the VIN pin. An on-board regulator makes the clean 5 V the chip needs.

USB or jack → regulator → clean 5 V (and 3.3 V from a second LDO). The board auto-selects the source.

Digital I/O

Digital pins are the simplest: output a HIGH/LOW to drive an LED or relay, or read a HIGH/LOW input from a button or sensor.

Output drives an LED (via a 220 Ω resistor); input reads a button with a 10k pull-down so the pin never floats.

// digital output + input
void setup() {
  pinMode(13, OUTPUT);      // LED pin
  pinMode(2, INPUT);        // button pin
}
void loop() {
  int pressed = digitalRead(2);      // HIGH or LOW
  digitalWrite(13, pressed);         // LED follows the button
}

PWM Output (~)

The Uno can't output a true analog voltage, but it can fake one with PWM — switching a pin on and off fast. The fraction of time it stays ON (the duty cycle) sets the average level.

Higher duty → higher average voltage. Use analogWrite(pin, 0–255) on the six ~ pins.

// fade the LED on a PWM pin (~9)
void setup() { pinMode(9, OUTPUT); }
void loop() {
  for (int v = 0; v <= 255; v++) { analogWrite(9, v); delay(5); }
  for (int v = 255; v >= 0; v--) { analogWrite(9, v); delay(5); }
}

Analog Input (ADC)

The six analog pins measure a continuous voltage. The 10-bit ADC turns 0–5 V into a number from 0 to 1023 — ideal for potentiometers, light sensors and temperature sensors.

A potentiometer on A0 → the ADC reads 0–1023. Convert to volts with v * 5.0 / 1023.0.

// read a sensor and print volts
void setup() { Serial.begin(9600); }
void loop() {
  int raw = analogRead(A0);          // 0..1023
  float volts = raw * 5.0 / 1023.0;
  Serial.println(volts);
  delay(200);
}

Communication: UART, SPI & I2C

Three standard buses let the Uno talk to other chips — sensors, displays, memory cards and even other Arduinos.

UART (D0/D1), SPI (D10–D13) and I2C (A4/A5) — three ways to connect devices.

How Code Gets onto the Uno

You write a sketch in the Arduino IDE, and one USB cable does the rest. No separate programmer needed.

Write → compile → USB (via the ATmega16U2) → the bootloader writes it to flash → run.

Every sketch has two functions: setup() runs once at power-up, and loop() repeats forever.

void setup() {
  // runs once — set up pins, start Serial, etc.
}
void loop() {
  // runs over and over — your main program
}

Code Examples

A few short, copy-paste sketches that cover the everyday building blocks.

1. Blink the on-board LED

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);       // pin 13
}
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

2. Print to the Serial Monitor

void setup() {
  Serial.begin(9600);
  Serial.println("Hello from the Uno!");
}
void loop() {
  Serial.println(millis());           // ms since power-up
  delay(1000);
}

3. Read a button (internal pull-up)

void setup() {
  pinMode(2, INPUT_PULLUP);           // no external resistor needed
  pinMode(13, OUTPUT);
}
void loop() {
  // pressed = LOW with a pull-up
  if (digitalRead(2) == LOW) digitalWrite(13, HIGH);
  else                        digitalWrite(13, LOW);
}

Beginner Mini-Projects

Put it together. Each project needs only a few cheap parts and the code is complete — upload and go.

Project 1 wiring — the classic Blink. Pin 13 already has an on-board LED, so this works even with no parts.

void setup() { pinMode(13, OUTPUT); }
void loop() {
  digitalWrite(13, HIGH); delay(500);
  digitalWrite(13, LOW);  delay(500);
}

void setup() {
  pinMode(2, INPUT_PULLUP);
  pinMode(13, OUTPUT);
}
void loop() {
  if (digitalRead(2) == LOW)   // button pressed
    digitalWrite(13, HIGH);
  else
    digitalWrite(13, LOW);
}

void setup() { pinMode(9, OUTPUT); }
void loop() {
  int raw = analogRead(A0);              // 0..1023
  int level = map(raw, 0, 1023, 0, 255); // scale to PWM
  analogWrite(9, level);                  // brightness follows the knob
}

void setup() {
  pinMode(13, OUTPUT);
  Serial.begin(9600);
}
void loop() {
  int light = analogRead(A0);      // bright = high, dark = low
  Serial.println(light);
  if (light < 300) digitalWrite(13, HIGH);  // dark → LED on
  else             digitalWrite(13, LOW);
  delay(100);
}

Specifications

The Arduino Uno R3 at a glance.

Key numbers for the Uno R3 — MCU, clock, memory, pins, voltage and current.

Key Terms — Glossary

Related Topics & Common Searches

The Uno connects to a whole world of parts. Explore these Power4All guides:

People Also Search For

arduino uno · arduino uno pinout · arduino uno r3 · atmega328p · arduino digital pins · arduino pwm pins · arduino analog pins · arduino power pins · arduino spi pins · arduino i2c pins · arduino blink code · analogRead · analogWrite · digitalWrite · arduino uno specifications · arduino projects for beginners · arduino code examples.

Frequently Asked Questions

Quick answers to the questions people ask most about the Arduino Uno.

Conclusion & Key Takeaways

The Arduino Uno is the perfect first board: a capable ATmega328P wrapped in a beginner-friendly layout you can program with one USB cable.

Continue Learning