Arduino Mega 2560

What is the Arduino Mega 2560?

The Arduino Mega 2560 is the big-board member of the Arduino family, built around the 8-bit ATmega2560. It looks like a stretched Uno — same 5 V logic and IDE — but with far more pins, memory and serial ports.

Use it when a project simply needs more: dozens of sensors and outputs, a big LED matrix, a 3D-printer controller, or several serial devices at once.

A map of the Mega: the ATmega2560 runs your code; note the extra 22–53 digital block and the row of 16 analog inputs.

The Brain: ATmega2560

The ATmega2560 is a bigger cousin of the Uno's chip — same 8-bit AVR core at 16 MHz, but with roughly 8× the flash, 4× the RAM and far more I/O.

Inside the ATmega2560: CPU + 256 KB flash / 8 KB SRAM / 4 KB EEPROM + 86 I/O, 16-channel ADC, timers and four serial ports.

• Flash (256 KB) — room for big programs; ~8 KB is the bootloader.
• SRAM (8 KB) — four times the Uno's, for larger buffers and arrays.
• EEPROM (4 KB) — non-volatile store for settings and calibration.
• Peripherals — 16-channel 10-bit ADC, six timers (15 PWM outputs), and four hardware UARTs plus SPI and I2C.

Full Arduino Mega 2560 Pinout

Here is the complete pinout, colour-coded by function. Every one of the 54 digital pins and 16 analog inputs is shown, with PWM (~), serial, SPI and I2C pins highlighted.

Every pin on the Mega, by function: digital 0–53 (PWM in purple), analog A0–A15, plus serial, SPI, I2C and interrupt pins.

Prefer the short version? These cards summarise the pin groups and their counts:

The Mega at a glance — far more of everything than the Uno.

Every Pin Explained

Let's go through each group of pins and exactly what it does. Where the Mega differs from the Uno, it's called out.

Digital pins (0–53)

54 general-purpose pins that read or write HIGH (5 V) or LOW (0 V) with pinMode(), digitalWrite() and digitalRead(). Each handles ~20 mA (40 mA max). Pins 22–53 form the big double-row block at the end of the board — ideal for wiring lots of LEDs, buttons or a keypad.

Serial (UART) — four ports

The Mega's stand-out feature: four hardware serial ports, so it can talk to several serial devices at once (see the diagram below).

Analog input pins (A0–A15)

16 analog inputs (more than any other classic Arduino), each a 10-bit ADC reading 0–5 V as 0–1023 via analogRead(). They double as digital pins 54–69.

Power pins

Powering the Mega

Like the Uno, the Mega takes power from 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.

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

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 — the same on all 54 pins.

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

// blink one of the 22-53 block pins
void setup() { pinMode(30, OUTPUT); pinMode(2, INPUT_PULLUP); }
void loop() {
  if (digitalRead(2) == LOW) digitalWrite(30, HIGH);
  else                       digitalWrite(30, LOW);
}

PWM Output (~)

PWM fakes an analog voltage by switching a pin on and off fast. The Mega has 15 PWM pins (vs 6 on the Uno): 2–13 and 44–46.

Higher duty → higher average voltage. Use analogWrite(pin, 0–255) on any of the 15 ~ 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 Mega's 16 analog pins measure a continuous voltage. The 10-bit ADC turns 0–5 V into 0–1023 — enough inputs for a whole panel of sensors or potentiometers.

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

// read all 16 analog inputs
void setup() { Serial.begin(9600); }
void loop() {
  for (int i = 0; i < 16; i++) {
    Serial.print(analogRead(A0 + i)); Serial.print(' ');
  }
  Serial.println();
  delay(300);
}

Four Serial Ports

This is the Mega's signature feature. Where the Uno has one serial port, the Mega has four — so it can log to the PC and talk to GPS, Bluetooth and another board, all at the same time.

Four independent UARTs — Serial, Serial1, Serial2, Serial3 — each with its own RX/TX pins.

// use two serial ports at once
void setup() {
  Serial.begin(9600);      // USB / PC monitor
  Serial1.begin(9600);     // e.g. a GPS on pins 19/18
}
void loop() {
  if (Serial1.available())
    Serial.write(Serial1.read());   // forward GPS data to the PC
}

SPI & I2C

Besides the four UARTs, the Mega has hardware SPI and I2C — note the pins differ from the Uno.

SPI on 50–53 (and ICSP), I2C on 20 (SDA) / 21 (SCL), plus the four UARTs.

How Code Gets onto the Mega

Exactly like the Uno: write a sketch in the Arduino IDE, connect USB, pick Arduino Mega 2560 as the board, and upload.

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

Mega vs Uno vs Nano

All three run the same 16 MHz AVR code. The Mega simply has more of everything — pick it when you outgrow the smaller boards.

54 pins, 16 analog, 4 serial ports and 256 KB flash set the Mega apart from the Uno and Nano.

Choose the Mega when you run out of pins, memory or serial ports; the Uno for learning and shields; the Nano for compact, breadboard builds.

Code Examples

The everyday building blocks — identical to the Uno, just with more pins to choose from.

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. Chase LEDs across the 22–53 block

void setup() {
  for (int p = 22; p <= 29; p++) pinMode(p, OUTPUT);
}
void loop() {
  for (int p = 22; p <= 29; p++) {
    digitalWrite(p, HIGH); delay(80); digitalWrite(p, LOW);
  }
}

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

The Mega shines when a project needs lots of I/O. Each project below 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() {
  for (int p = 22; p <= 29; p++) pinMode(p, OUTPUT);
}
void loop() {
  for (int p = 22; p <= 29; p++) {
    digitalWrite(p, HIGH); delay(100); digitalWrite(p, LOW);
  }
}

void setup() {
  Serial.begin(9600);      // to PC
  Serial1.begin(9600);     // to the module
}
void loop() {
  if (Serial1.available()) Serial.write(Serial1.read());
  if (Serial.available())  Serial1.write(Serial.read());
}

void setup() { Serial.begin(9600); }
void loop() {
  for (int i = 0; i < 16; i++) {
    Serial.print("A"); Serial.print(i); Serial.print("=");
    Serial.print(analogRead(A0 + i)); Serial.print("  ");
  }
  Serial.println();
  delay(500);
}

Specifications

The Arduino Mega 2560 at a glance.

Key numbers for the Mega — MCU, clock, memory, pins, serial ports and size.

Key Terms — Glossary

Related Topics & Common Searches

The Mega drives a whole workbench of parts. Explore these Power4All guides:

People Also Search For

arduino mega 2560 · arduino mega pinout · atmega2560 · arduino mega analog pins · arduino mega pwm pins · arduino mega serial ports · arduino mega spi i2c · mega vs uno · arduino mega power pins · arduino mega 54 pins · analogRead · analogWrite · digitalWrite · arduino mega specifications · arduino mega projects · arduino mega code examples.

Frequently Asked Questions

Quick answers to the questions people ask most about the Arduino Mega 2560.

Conclusion & Key Takeaways

The Arduino Mega 2560 is the Arduino you reach for when a project gets big — the same easy code, with room to spare.

Continue Learning