Arduino Nano

What is the Arduino Nano?

The Arduino Nano is a compact, breadboard-friendly microcontroller board built around the same 8-bit ATmega328P as the Arduino Uno. It packs that chip, a USB-serial bridge and two rows of pins onto a board barely bigger than a stick of gum.

You get the Uno's brain and 100% of its code compatibility, but small enough to drop straight into a breadboard or solder into a finished project.

A map of the Nano: the ATmega328P runs your code; the CH340, regulator and crystal support it, and two 15-pin rows connect it.

The Brain: ATmega328P

The Nano uses the very same ATmega328P as the Uno — here in a tiny surface-mount package. It's a complete computer on one chip: a CPU, three kinds of memory and 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; on the Nano ~2 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.
• Peripherals — 10-bit ADC, three timers (for PWM & timing), and hardware UART, SPI and I2C.

Full Arduino Nano Pinout

Here is the complete pinout — all 30 pins in two rows of 15. 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 Nano pinout — D0–D12 down one side, D13/analog/power down the other. Note A6 & A7 are analog-only.

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

Quick overview: digital (0–13), PWM ~, analog (A0–A7) 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–A7)

The Nano has eight analog inputs (two more than the Uno), each connected to a 10-bit ADC that converts 0–5 V into a number from 0 to 1023 using analogRead(). A few points:

• A0–A5 can also be used as digital pins; A6 & A7 are analog-only (they have no digital or port function).
• 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 Nano

The Nano has no DC barrel jack. Power it over mini-USB (5 V), from 7–12 V on VIN through the on-board regulator, or with a regulated 5 V on the 5V pin.

Mini-USB gives a clean 5 V; VIN (7–12 V) is dropped to 5 V by the regulator, which also feeds the 3.3 V pin.

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 Nano 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 (3, 5, 6, 9, 10, 11).

// 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 eight 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 (try A6/A7 too)
  float volts = raw * 5.0 / 1023.0;
  Serial.println(volts);
  delay(200);
}

Communication: UART, SPI & I2C

Three standard buses let the Nano 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 Nano

You write a sketch in the Arduino IDE, and one mini-USB cable does the rest. A CH340 (or FT232) chip turns USB into serial.

Write → compile → USB (via the CH340) → 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
}

Arduino Nano vs Uno

Same brain, same code — so which do you pick? The Nano is smaller and breadboard-ready with two extra analog pins; the Uno is bigger, takes shields and has a DC jack.

Both use the ATmega328P at 16 MHz. The Nano wins on size and analog pins; the Uno wins on shields, sockets and the DC jack.

Choose the Nano for compact, breadboard and permanent builds where space matters. Choose the Uno for learning with shields, easy chip swaps and a barrel-jack supply.

Code Examples

A few short, copy-paste sketches — they run identically on the Nano and the Uno.

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 Nano!");
}
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

Because the Nano plugs straight into a breadboard, these are especially quick to wire. 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() { Serial.begin(9600); }
void loop() {
  int a = analogRead(A6);      // analog-only pin
  int b = analogRead(A7);      // analog-only pin
  Serial.print(a); Serial.print(","); Serial.println(b);
  delay(200);
}

Specifications

The Arduino Nano at a glance.

Key numbers for the Nano — MCU, clock, memory, pins, voltage, USB and size.

Key Terms — Glossary

Related Topics & Common Searches

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

People Also Search For

arduino nano · arduino nano pinout · arduino nano r3 · atmega328p · arduino nano vs uno · arduino nano analog pins · arduino nano pwm pins · arduino nano power pins · arduino nano spi i2c · ch340 driver · arduino nano a6 a7 · analogRead · analogWrite · digitalWrite · arduino nano specifications · arduino nano projects · arduino nano code examples.

Frequently Asked Questions

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

Conclusion & Key Takeaways

The Arduino Nano is the Uno's pocket-sized twin: the same capable ATmega328P and code, on a board that lives on a breadboard.

Continue Learning