Arduino Pro Mini

What is the Arduino Pro Mini?

The Arduino Pro Mini is the bare essentials version of the Arduino: the same 8-bit ATmega328P as the Uno and Nano, on the smallest, cheapest board possible — with no USB and almost nothing else.

That makes it perfect for permanent, space-tight builds where you don't need a USB port after uploading. To program it, you plug in a cheap FTDI / USB-serial adapter.

A map of the Pro Mini: the ATmega328P runs your code; the 6-pin FTDI header is how you upload it — there is no USB.

The Brain: ATmega328P

The Pro Mini uses the same ATmega328P as the Uno and Nano — a complete little computer on one chip: a CPU, three kinds of memory and built-in peripherals.

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

On the 5V board it's clocked at 16 MHz; on the 3.3V board at 8 MHz (a lower voltage can't safely run as fast). Either way the code you write is identical.

Full Arduino Pro Mini Pinout

Here is the complete pinout. The digital and analog pins match the Uno/Nano, so the same libraries work — the differences are the missing USB and the RAW / VCC power pins.

The full Pro Mini pinout — digital on the right, analog & power on the left, and the 6-pin FTDI header on top. A6/A7 are analog-only.

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

Quick overview: digital (0–13), PWM ~, analog (A0–A7) and power (RAW / VCC / GND / RST).

Every Pin Explained

Let's go through each group of pins.

Digital pins (D0–D13)

14 general-purpose pins that read or write HIGH or LOW with pinMode(), digitalWrite() and digitalRead(). Each handles ~20 mA (40 mA max). Special roles (same as the Uno):

Analog input pins (A0–A7)

8 analog inputs (two more than the Uno), each a 10-bit ADC reading 0–VCC as 0–1023:

• A0–A5 can also be used as digital pins; A6 & A7 are analog-only.
• A4 = SDA and A5 = SCL — the hardware I2C bus (same as the Uno).

Power pins (this is where it differs)

Programming with an FTDI Adapter

This is the one thing that's really different about the Pro Mini: with no USB on board, you upload code through a cheap external FTDI / USB-serial adapter plugged into the 6-pin header.

PC → FTDI adapter (USB→serial) → the 6-pin header. TX and RX cross over; DTR auto-resets the board into its bootloader.

The 6-pin header, in order: DTR, TXO, RXI, VCC, GND, GND (labels vary slightly by board). Connect DTR→DTR, adapter TX→board RXI, adapter RX→board TXO, plus VCC and GND.

Powering the Pro Mini

Two ways in: a rough voltage on RAW (through the on-board regulator), or the exact regulated voltage straight into VCC.

RAW → regulator → VCC, or feed VCC directly. Note the two board versions and their input ranges.

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

PWM Output (~)

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

Higher duty → higher average voltage. Use analogWrite(pin, 0–255) on the six ~ 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 8 analog pins measure a continuous voltage. The 10-bit ADC turns 0–VCC into 0–1023.

A potentiometer on A0 → the ADC reads 0–1023. On the 3.3V board, full-scale is 3.3 V, not 5 V.

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

Communication: UART, SPI & I2C

The Pro Mini has the same three buses as the Uno, on the same pins.

UART (D0/D1, the FTDI port), SPI (D10–D13) and I2C (A4/A5).

The Upload Flow

No USB means the FTDI adapter is part of the chain — its DTR line auto-resets the board so the bootloader catches your sketch.

Write → compile → FTDI adapter (USB→serial) → DTR auto-reset into the bootloader → run from flash.

Pro Mini vs Uno

Same brain and code — the Pro Mini simply drops everything you don't strictly need, to be as small and cheap as possible.

No USB, no DC jack, no shield headers — but the same ATmega328P as the Uno, with two extra analog pins.

Choose the Pro Mini for finished, space-tight, low-cost builds; the Nano if you want the same tiny size but with USB on board; the Uno for learning and shields.

Code Examples

The everyday building blocks — identical to the Uno and Nano.

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 (through the FTDI adapter)

void setup() {
  Serial.begin(9600);          // via the FTDI adapter
  Serial.println("Hello from the Pro Mini!");
}
void loop() { Serial.println(millis()); delay(1000); }

3. Read a button (internal pull-up)

void setup() {
  pinMode(2, INPUT_PULLUP);           // no external resistor needed
  pinMode(13, OUTPUT);
}
void loop() {
  digitalWrite(13, digitalRead(2) == LOW ? HIGH : LOW);
}

Beginner Mini-Projects

Because it's so small and cheap, the Pro Mini is ideal for leaving inside a finished project. Each sketch below is complete.

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) digitalWrite(13, HIGH);
  else                       digitalWrite(13, LOW);
}

void setup() { Serial.begin(9600); }
void loop() {
  int raw = analogRead(A0);
  Serial.println(raw);
  delay(2000);                   // (add sleep libs to save power)
}

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

Specifications

The Arduino Pro Mini at a glance.

Key numbers for the Pro Mini — MCU, versions, memory, pins and power.

Key Terms — Glossary

Related Topics & Common Searches

Explore these Power4All guides:

People Also Search For

arduino pro mini · arduino pro mini pinout · atmega328p · ftdi programming · arduino pro mini ftdi wiring · arduino pro mini vs nano · arduino pro mini vs uno · 5v 16mhz · 3.3v 8mhz · raw vcc · arduino pro mini analog pins · arduino pro mini spi i2c · arduino pro mini upload · arduino pro mini specifications · arduino pro mini projects · arduino pro mini code.

Frequently Asked Questions

Quick answers to the questions people ask most about the Arduino Pro Mini.

Conclusion & Key Takeaways

The Arduino Pro Mini is the Uno's brain shrunk to the bare minimum — perfect once your project is finished and you no longer need a USB port.

Continue Learning