Arduino Leonardo

What is the Arduino Leonardo?

The Arduino Leonardo looks like an Uno, but its brain is the ATmega32U4 — a chip with USB built right in. That single change means the board needs no separate USB-serial chip, and it can pretend to be a USB keyboard or mouse.

Everything else is Uno-familiar: 5 V logic, the same shield shape and the same Arduino IDE. Just a few pins move around (more on that below).

A map of the Leonardo: the ATmega32U4 does both the computing and the USB — there is no separate USB chip.

The Brain: ATmega32U4

The ATmega32U4 is the same family as the Uno's chip, but with one big addition: a built-in USB controller. It runs at 16 MHz and carries a little more RAM.

Inside the ATmega32U4: CPU + 32 KB flash / 2.5 KB SRAM / 1 KB EEPROM + GPIO, 12-channel ADC, timers, and a native USB controller.

• Flash (32 KB) — stores your program; ~4 KB is the (larger, USB) bootloader.
• SRAM (2.5 KB) — working memory for variables.
• EEPROM (1 KB) — non-volatile store that survives power-off.
• Native USB — the stand-out feature: the chip is its own USB device (keyboard, mouse, or serial).

Full Arduino Leonardo Pinout

Here is the complete pinout. The header shape matches the Uno, but note the differences: I2C is on D2/D3, SPI is on the ICSP header, and six analog inputs (A6–A11) live on digital pins.

The full Leonardo pinout — digital on the right, power & analog on the left. SCL = D3, SDA = D2; A6–A11 share digital pins.

Prefer a simpler view? This colour-coded map groups the header pins by function:

Quick overview — note D2 = SDA, D3 = SCL and the extra analog pins on the digital header.

Every Pin Explained

Let's go through each group of pins. Where the Leonardo differs from the Uno, it's flagged — those differences trip up a lot of beginners.

Digital pins (0–13)

14 header pins that read or write HIGH (5 V) or LOW (0 V) with pinMode(), digitalWrite() and digitalRead(). Each handles ~20 mA (40 mA max). The A0–A5 pins can also be used as digital, giving 20 in total.

Analog input pins (12 total)

The Leonardo has 12 analog inputs, each a 10-bit ADC reading 0–5 V as 0–1023:

• A0–A5 on the analog header.
• A6–A11 share digital pins 4, 6, 8, 9, 10, 12 — read them with analogRead(A6) … analogRead(A11).

The buses (and where they moved)

Power pins

VIN (7–12 V in), 5V (regulated out), 3.3V (~50 mA), GND, IOREF, RESET and AREF — the same as the Uno.

Native USB — Keyboard & Mouse (HID)

This is why the Leonardo exists. Because the 32U4 speaks USB itself, the board can present to a PC as a real USB keyboard or mouse — something the Uno and Nano can't do.

The PC sees a genuine HID device. Type with Keyboard.print(), move the cursor with Mouse.move().

// type a line when a button on pin 2 is pressed
#include <Keyboard.h>
void setup() {
  pinMode(2, INPUT_PULLUP);
  Keyboard.begin();
}
void loop() {
  if (digitalRead(2) == LOW) {      // pressed
    Keyboard.println("Hello from Leonardo!");
    delay(1000);                    // avoid repeats
  }
}

Powering the Leonardo

Power it from micro-USB (5 V), a 7–12 V DC jack, or the VIN pin. An on-board regulator makes the clean 5 V the chip needs.

Micro-USB or the DC jack → regulator → clean 5 V (and 3.3 V from a second regulator).

Digital I/O

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(7, INPUT);        // button pin
}
void loop() {
  digitalWrite(13, digitalRead(7));   // LED follows the button
}

PWM Output (~)

PWM fakes an analog voltage by switching a pin on and off fast. The Leonardo has 7 PWM pins: 3, 5, 6, 9, 10, 11, 13.

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

// fade an 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 Leonardo has 12 analog inputs — six more than the Uno. Each 10-bit reading turns 0–5 V into 0–1023.

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

// read an "extra" analog input (A6 is on digital pin 4)
void setup() { Serial.begin(9600); }
void loop() {
  int raw = analogRead(A6);          // 0..1023
  float volts = raw * 5.0 / 1023.0;
  Serial.println(volts);
  delay(200);
}

Serial, SPI & I2C

The Leonardo has the usual three buses — but on different pins from the Uno, so it's worth a close look.

Serial1 on D0/D1 (separate from USB Serial), SPI on the ICSP header, I2C on D2/D3.

How Code Gets onto the Leonardo

The 32U4 handles USB itself, so there's no separate USB chip in the upload path. Write a sketch, connect micro-USB, pick Arduino Leonardo, and upload.

Write → compile → native USB (32U4) → the bootloader writes it to flash → run.

Leonardo vs Uno

Same shape, same 5 V code — but the 32U4 changes what the board can do and where a few pins live.

Native USB and HID, more analog pins, and moved buses set the Leonardo apart from the Uno.

Choose the Leonardo for USB keyboard/mouse projects and more analog inputs; the Uno for the most tutorials, easiest uploads and the widest shield support.

Code Examples

The everyday building blocks — plus one that only the Leonardo can run.

1. Blink the on-board LED

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

2. Print to the Serial Monitor (wait for USB)

void setup() {
  Serial.begin(9600);
  while (!Serial) { ; }          // wait for the USB port (Leonardo)
  Serial.println("Ready!");
}
void loop() { Serial.println(millis()); delay(1000); }

3. Talk to a module on Serial1

void setup() {
  Serial.begin(9600);       // USB to PC
  Serial1.begin(9600);      // module on pins 0/1
}
void loop() {
  if (Serial1.available()) Serial.write(Serial1.read());
}

Beginner Mini-Projects

Start with the classics, then try the HID trick that makes the Leonardo special.

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);
}

#include <Keyboard.h>
void setup() { pinMode(2, INPUT_PULLUP); Keyboard.begin(); }
void loop() {
  if (digitalRead(2) == LOW) {
    Keyboard.print("power4all.in");
    delay(800);              // debounce / avoid repeats
  }
}

#include <Mouse.h>
void setup() { pinMode(3, INPUT_PULLUP); Mouse.begin(); }
void loop() {
  if (digitalRead(3) == LOW) { Mouse.move(3, 0); delay(200); Mouse.move(-3, 0); delay(200); }
}

#include <Wire.h>
void setup() {
  Serial.begin(9600);
  Wire.begin();                // SDA=2, SCL=3 on the Leonardo
}
void loop() {
  Wire.beginTransmission(0x3C);   // example device address
  byte err = Wire.endTransmission();
  Serial.println(err == 0 ? "found" : "not found");
  delay(1000);
}

Specifications

The Arduino Leonardo at a glance.

Key numbers for the Leonardo — MCU, clock, memory, pins, native USB and buses.

Key Terms — Glossary

Related Topics & Common Searches

Explore these Power4All guides:

People Also Search For

arduino leonardo · arduino leonardo pinout · atmega32u4 · arduino keyboard · arduino mouse · arduino hid · native usb arduino · leonardo vs uno · arduino leonardo i2c pins · arduino leonardo spi · serial1 · arduino leonardo analog pins · arduino leonardo specifications · arduino leonardo projects · arduino leonardo code.

Frequently Asked Questions

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

Conclusion & Key Takeaways

The Arduino Leonardo is the Uno's USB-native cousin — same easy code, plus the power to be a keyboard or mouse.

Continue Learning