Arduino Micro

What is the Arduino Micro?

The Arduino Micro is a tiny, breadboard-friendly board built around the ATmega32U4 — the same native-USB chip as the Leonardo. That means it can appear to a PC as a real USB keyboard or mouse, with no separate USB chip.

Think of it as the Leonardo's brain in the Nano's body: all the 32U4's abilities, in a package that drops straight into a breadboard.

A map of the Micro: the native-USB ATmega32U4 does both the computing and the USB — on a board barely bigger than a stick of gum.

The Brain: ATmega32U4

Like the Leonardo, the Micro runs the ATmega32U4 — an 8-bit AVR at 16 MHz with a built-in USB controller, so the chip is its own USB device.

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 (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 Micro Pinout

Here is the complete pinout. The pin functions match the Leonardo exactly: I2C on D2/D3, SPI on the ICSP header, and six analog inputs (A6–A11) on digital pins.

The full Micro 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 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. The Micro shares the Leonardo's assignments, so the same gotchas apply.

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). With A0–A5 usable as digital, that's 20 in total.

Analog input pins (12 total)

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

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

The buses (and where they live)

Power pins

VIN (7–12 V in), 5V (regulated out), 3.3V (~50 mA), GND, IOREF and RESET. There is no DC barrel jack — power comes from micro-USB or VIN.

Native USB — Keyboard & Mouse (HID)

This is the Micro's headline trick. 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 Micro!");
    delay(1000);                    // avoid repeats
  }
}

Powering the Micro

Power it from micro-USB (5 V), or feed 7–12 V into the VIN pin through the on-board regulator. There is no barrel jack.

Micro-USB or VIN → 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 Micro 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 Micro has 12 analog inputs. 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 Micro has the usual three buses — on the same pins as the Leonardo, which differ from the Uno.

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

How Code Gets onto the Micro

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

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

Micro vs Leonardo vs Nano

The Micro sits neatly between two boards: it has the Leonardo's native-USB chip and the Nano's tiny breadboard body.

Same 32U4 abilities as the Leonardo (native USB, HID, 12 analog), in a Nano-sized breadboard form.

Choose the Micro for compact projects that need USB keyboard/mouse tricks; the Leonardo if you also want Uno shield headers; the Nano if you don't need native USB/HID.

Code Examples

The everyday building blocks — plus one only the 32U4 boards 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 (32U4)
  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

Small, breadboard-ready, and USB-native — here are four to start with.

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>
int last = 0;
void setup() { Mouse.begin(); last = analogRead(A0); }
void loop() {
  int now = analogRead(A0);
  if (now - last > 8)  { Mouse.move(0, 0, 1);  last = now; }  // wheel up
  if (last - now > 8)  { Mouse.move(0, 0, -1); last = now; }  // wheel down
  delay(50);
}

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

Specifications

The Arduino Micro at a glance.

Key numbers for the Micro — MCU, clock, memory, pins, native USB and size.

Key Terms — Glossary

Related Topics & Common Searches

Explore these Power4All guides:

People Also Search For

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

Frequently Asked Questions

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

Conclusion & Key Takeaways

The Arduino Micro is the Leonardo's USB-native power in a breadboard-sized package — ideal for compact keyboard/mouse gadgets.

Continue Learning