Arduino Due

What is the Arduino Due?

The Arduino Due is the first Arduino with a 32-bit ARM processor. It uses the SAM3X8E ARM Cortex-M3 at 84 MHz, more than five times the clock of the 8-bit Mega 2560, on exactly the same 101.5 × 53.3 mm board shape.

You still write ordinary Arduino sketches with setup() and loop(), but you get far more speed and memory, plus hardware no AVR Arduino has: two true analog outputs (DAC), a 12-bit ADC, two CAN controllers and a native USB port. The one big change is that the whole board runs at 3.3 V, not 5 V.

A map of the Due: the SAM3X8E runs your code; note the two micro-USB ports, the ERASE button, the centre SPI and JTAG headers, and the DAC/CAN pins at the end of the analog header.

The Brain: SAM3X8E ARM Cortex-M3

The SAM3X8E (originally Atmel, now Microchip) is a 32-bit ARM Cortex-M3. Compared with the Uno's ATmega328P it runs 5× faster, handles 32-bit numbers in one instruction, and has 16× the flash and 48× the RAM.

Inside the SAM3X8E: a Cortex-M3 core fed by 512 KB flash and 96 KB SRAM, a 12 MHz crystal multiplied to 84 MHz, DMA, and a big set of peripherals.

• Flash (512 KB, two 256 KB banks) — all of it is yours; the bootloader lives in a separate ROM.
• SRAM (96 KB, 64 KB + 32 KB) — room for large arrays, audio buffers and display frame data.
• SAM-BA boot ROM — a bootloader burned into the chip, so it can never be erased by accident.
• No EEPROM — unlike AVR boards; save settings to an SD card, external EEPROM or a flash library instead.
• Peripherals — 12-bit ADC, two 12-bit DACs, 8-channel PWM, 9 timer channels, four UARTs, SPI, two TWI (I2C), two CAN controllers, USB OTG and DMA.

Full Arduino Due Pinout

Here is the complete Arduino Due pinout. Each header pin shows its Arduino number, its SAM3X8E port (PAx/PBx/PCx/PDx) and its alternate functions: PWM, UART, I2C, ADC channel, DAC, CAN and SPI chip-select.

Every pin around the Due's edge: power + A0–A11 + DAC + CAN on the left, PWM 13–2, serial 0–1 and the communication header 14–21 on the right.

The big 2 × 18 block at the end of the board carries digital pins 22–53. The centre SPI header is also shown here, because on the Due SPI is only available there:

Pins 22–53 with their SAM3X ports (even pins left, odd right; 5V on top, GND at the bottom) and the 6-pin SPI header.

Prefer the short version? These cards summarise every pin group and how many there are:

The Due at a glance: Mega-sized I/O, plus DAC, CAN and native USB.

Every Pin Explained

Now let's go through each group of pins and what it does. The layout matches the Mega 2560, but several functions sit on different pins, so the differences are called out below.

Digital pins (0–53)

54 general-purpose pins driven with pinMode(), digitalWrite() and digitalRead(). HIGH is 3.3 V, not 5 V. Each pin can only supply a small current (about 3–15 mA depending on the pin), and all pins together are limited to 130 mA, so drive LEDs gently and use a transistor or MOSFET for anything bigger. On the Due every digital pin can be an interrupt with attachInterrupt().

Serial (UART): four ports + SerialUSB

Analog inputs (A0–A11)

12 analog inputs on a 12-bit ADC. They read 0–3.3 V as 0–1023 by default (for Uno compatibility) or as 0–4095 after analogReadResolution(12). They double as digital pins 54–65. The ADC reference is fixed at 3.3 V; the AREF pin is tied to it on the board.

DAC0 & DAC1: true analog outputs

Two 12-bit digital-to-analog converters at the end of the analog header. analogWrite(DAC0, value) sets a real, steady voltage from roughly 0.55 V to 2.75 V. There is more on this in the DAC section.

CANRX & CANTX

The logic-level pins of the SAM3X8E's CAN0 controller. A second controller, CAN1, sits on DAC0 (RX) and D53 (TX). Both need an external 3.3 V CAN transceiver to join a real bus.

Power & special pins

The 3.3 V Logic Rule (Read This First)

This is the most important thing to know about the Due: its pins are 3.3 V and are not 5 V tolerant. A 5 V signal on any pin can permanently damage the SAM3X8E. Here is how to connect 5 V parts safely.

Left: a 10 k / 20 k divider drops a 5 V output to ≈3.3 V. Right: a bidirectional level shifter for I2C, UART or SPI in both directions.

• 3.3 V sensors and modules (most modern I2C/SPI sensors, ESP modules, SD cards): connect directly.
• 5 V outputs into the Due (HC-SR04 echo, 5 V UART TX): use a resistor divider or a shifter.
• Due outputs into 5 V inputs: 3.3 V HIGH is often but not always enough; a level shifter makes it reliable.
• Analog sensors powered at 5 V can output up to 5 V, so power them from 3.3V or divide the signal.

Powering the Due

The Due takes 5 V from either USB port, or 7–12 V from the DC jack or VIN. A switching regulator makes 5 V, and a second regulator makes the 3.3 V that the SAM3X8E and every I/O pin run on.

USB or the DC jack → 5 V rail → 3.3 V regulator → 3.3 V rail for the chip and every I/O pin.

The Two USB Ports: Programming vs Native

The Due has two micro-USB ports. They look the same but connect to the chip in completely different ways.

The Programming port goes through an ATmega16U2 to UART0 (Serial); the Native port goes straight into the SAM3X8E (SerialUSB).

PWM Output (~)

PWM fakes an analog voltage by switching a pin on and off quickly. The Due has 12 PWM pins (2–13) swinging 0–3.3 V, with resolution up to 12 bits.

On a 3.3 V board, 50% duty averages 1.65 V. Use analogWriteResolution(12) for 0–4095 steps.

// smooth 12-bit LED fade on PWM pin 9
void setup() { analogWriteResolution(12); }
void loop() {
  for (int v = 0; v <= 4095; v += 8)  { analogWrite(9, v); delayMicroseconds(500); }
  for (int v = 4095; v >= 0; v -= 8) { analogWrite(9, v); delayMicroseconds(500); }
}

Analog Input: the 12-bit ADC

The Due's 12 analog inputs feed a 12-bit ADC: 4096 steps across 0–3.3 V, about 0.8 mV per step, four times finer than the Uno's 10-bit ADC. Work out other resolutions with the ADC Resolution Calculator.

A potentiometer on A0 → 0–4095. Convert to volts with v * 3.3 / 4095.0.

// read all 12 analog inputs at full 12-bit resolution
void setup() { Serial.begin(115200); analogReadResolution(12); }
void loop() {
  for (int i = 0; i < 12; i++) {
    Serial.print(analogRead(A0 + i)); Serial.print(' ');
  }
  Serial.println();
  delay(250);
}

DAC: True Analog Output

This is something no Uno, Nano or Mega can do. DAC0 and DAC1 output a real, smooth analog voltage rather than a PWM square wave, with 12-bit resolution, so the Due can generate audio and waveforms directly.

A sine wave built from 12-bit steps on DAC0. The output spans about 0.55 V (value 0) to 2.75 V (value 4095).

Communication: UART, SPI, I2C & CAN

The Due has more buses than any classic Arduino: four UARTs plus SerialUSB, SPI, two I2C buses and two CAN controllers.

UART × 4, SPI on the centre header, Wire (20/21) + Wire1 (SDA1/SCL1), and CAN0 + CAN1.

CAN bus

CAN is the rugged two-wire network used in cars, e-bikes, robots and industrial machines. The SAM3X8E handles the CAN protocol in hardware; add a 3.3 V CAN transceiver (such as an SN65HVD230 module) and 120 Ω terminators at both ends of the bus.

Every node needs a transceiver; the bus is a twisted pair with a 120 Ω resistor at each end.

How Code Gets onto the Due

Uploading works differently from AVR boards. The IDE first erases the flash with a “1200-baud touch”, then bossac writes your program through the SAM-BA boot ROM.

Write → compile (ARM GCC) → USB → erase → bossac + SAM-BA flash → run.

Due vs Mega 2560 vs Uno

The Due and Mega 2560 share a board shape and pin count, but inside they are very different machines.

Faster, bigger and better connected, but 3.3 V and without EEPROM. The Uno is shown for scale.

Choose the Due for speed, audio/DSP, the DAC, CAN, native USB or big memory. Choose the Mega for 5 V shields and modules, EEPROM or 16 analog inputs. Choose the Uno for learning. Need Wi-Fi? Look at the ESP32.

Code Examples

Standard Arduino code runs unchanged. These examples also use the Due's own features: 12-bit I/O, the DAC and SerialUSB.

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. Output a steady analog voltage on DAC0

void setup() {
  analogWriteResolution(12);          // 0-4095
  analogWrite(DAC0, 2048);            // about 1.65 V, mid-scale
}
void loop() {}

3. Print over the Native USB port

void setup() {
  SerialUSB.begin(115200);            // Native port (baud is ignored, it's full-speed USB)
  while (!SerialUSB);                 // wait for the PC to open the port
}
void loop() {
  SerialUSB.println(millis());
  delay(500);
}

4. Interrupt on any pin

volatile int presses = 0;
void onPress() { presses++; }
void setup() {
  Serial.begin(115200);
  pinMode(30, INPUT_PULLUP);                               // any Due pin works
  attachInterrupt(digitalPinToInterrupt(30), onPress, FALLING);
}
void loop() { Serial.println(presses); delay(500); }

Beginner Mini-Projects

Four complete projects. The first works on any Arduino; the others show off what makes the Due special.

Project 1 wiring. At 3.3 V a 220 Ω resistor gives about 6 mA, comfortably within the pin's limit. Check other values with the LED resistor calculator.

void setup() { pinMode(13, OUTPUT); }
void loop() {
  digitalWrite(13, HIGH); delay(500);
  digitalWrite(13, LOW);  delay(500);
}

const int N = 100;
uint16_t table[N];
void setup() {
  analogWriteResolution(12);
  for (int i = 0; i < N; i++)
    table[i] = 2048 + 2047 * sin(2 * PI * i / N);
}
void loop() {
  for (int i = 0; i < N; i++) {
    analogWrite(DAC0, table[i]);
    delayMicroseconds(10);                   // sets the frequency
  }
}

void setup() { Serial.begin(115200); analogReadResolution(12); }
void loop() {
  long sum = 0;
  for (int i = 0; i < 64; i++) sum += analogRead(A0);  // average 64 samples
  float volts = (sum / 64.0) * 3.3 / 4095.0;
  Serial.print(volts, 4); Serial.println(" V");
  delay(300);
}

#include <Keyboard.h>
void setup() { pinMode(2, INPUT_PULLUP); Keyboard.begin(); }
void loop() {
  if (digitalRead(2) == LOW) {
    Keyboard.println("Hello from Arduino Due!");
    delay(500);                                // simple debounce
  }
}

Specifications

The Arduino Due at a glance.

Key numbers for the Due: MCU, clock, voltages, memory, pins, buses and size.

Key Terms — Glossary

Related Topics & Common Searches

The Due connects to a whole workbench of parts. Explore these Power4All guides:

People Also Search For

arduino due · arduino due pinout · arduino due pin diagram · sam3x8e pinout · arduino due 3.3v or 5v · is arduino due 5v tolerant · arduino due dac · arduino due dac0 dac1 · arduino due 12 bit adc · analogReadResolution · analogWriteResolution · arduino due pwm pins · arduino due analog pins · arduino due serial ports · arduino due serialusb · arduino due native usb vs programming port · arduino due can bus · arduino due spi pins · arduino due i2c sda1 scl1 · arduino due erase button · arduino due upload error no device found · arduino sam boards · arduino due vs mega · arduino due vs uno · arduino due specifications · arduino due projects · arduino due keyboard · 32 bit arduino · arm cortex-m3 arduino.

Frequently Asked Questions

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

Conclusion & Key Takeaways

The Arduino Due brings 32-bit ARM power to the familiar Arduino workflow. It is Mega-sized, much faster, and full of features the 8-bit boards lack. Just remember that it runs at 3.3 V.

Continue Learning