Meet the Seeeduino XIAO Family

Table of Contents

1 Introduction: The Smallest Arduino-Compatible Boards You’ll Ever Use
2 General Purpose Boards: Your Foundation for Embedded Projects
3 Wireless & BLE Boards: Connecting Your Projects to the World
4 Advanced MCU Boards: Industrial-Grade and Ultra-Low-Power Solutions
5 Accessories & Prototyping Tools: Expanding the XIAO Ecosystem
6 XIAO-Compatible Boards: Alternatives and Variants
7 Conclusion: Your Tiny Powerhouse Awaits

Today, we are taking a look at the entire Seeeduino XIAO family of microcontrollers. These small wonders now come with a variety of microcontrollers and features, making them ideal for almost every project.

Introduction: The Smallest Arduino-Compatible Boards You’ll Ever Use

In the world of microcontrollers, size matters—especially when you’re working on compact projects, wearables, or densely-packed designs. Enter the Seeeduino XIAO family: a remarkable collection of tiny yet powerful microcontrollers that pack professional-grade features into a thumb-sized form factor.

Measuring just 20mm x 17.5mm (about the size of a postage stamp), these boards have revolutionized compact embedded design since their introduction in 2020. What began as a single board—the XIAO SAMD21—has evolved into a comprehensive ecosystem of 13 different variants, each leveraging different microcontroller architectures while maintaining a standardized footprint and pinout.

The genius of the XIAO family lies in its consistency. Despite featuring processors from ARM, Espressif, Nordic, Renesas, and Silicon Labs, every XIAO board shares the same physical dimensions, mounting holes, and basic pin arrangement. This standardization means you can design a project around one board and easily swap in another with different capabilities—perhaps upgrading from a basic model to one with wireless connectivity, or switching to an ultra-low-power variant for battery operation.

The evolution of the XIAO family reflects the changing landscape of embedded development. The original SAMD21 established the form factor and proved the concept. The RP2040 brought dual-core processing and the revolutionary PIO (Programmable I/O) subsystem. Wireless variants added WiFi, Bluetooth, and even Matter/Thread support. “Sense” variants integrated cameras and microphones for AI and edge computing applications. Most recently, advanced MCU options have pushed into industrial and ultra-low-power territories.

What makes these boards particularly appealing is their versatility. They’re breadboard-friendly despite their compact size, feature USB-C connectivity, support multiple programming environments (Arduino IDE, CircuitPython, MicroPython), and are priced accessibly—typically between $5 and $15. Whether you’re a student learning embedded programming, a hobbyist building IoT devices, or a professional prototyping a product, there’s likely a XIAO board perfectly suited to your needs.

In this comprehensive guide, we’ll explore the entire XIAO family, organized by capability and use case. We’ll examine general-purpose boards for everyday projects, wireless-enabled boards for IoT applications, and advanced MCU boards for specialized requirements. Along the way, we’ll provide practical code examples and explore the growing ecosystem of accessories and compatible boards that make working with the XIAO family even more convenient.

Let’s dive into this tiny but mighty family of microcontrollers and discover which one is right for your next project.

General Purpose Boards: Your Foundation for Embedded Projects

The general-purpose XIAO boards represent the foundation of the family—reliable workhorses suitable for countless applications from learning to production. These three boards share compact size and ease of use while offering distinct advantages based on their underlying processors.

XIAO SAMD21: The Original

The XIAO SAMD21 was the board that started it all, and it remains a solid choice for straightforward projects. Built around the Microchip ATSAMD21G18A microcontroller (the same chip used in the Arduino Zero), it offers a familiar development experience with excellent Arduino ecosystem support.

Key Specifications:

Processor: ARM Cortex-M0+ at 48MHz
Memory: 256KB Flash, 32KB SRAM
Digital I/O: 11 pins (all PWM capable)
Analog Inputs: 11 pins (10-bit ADC)
Analog Outputs: 1 pin (10-bit DAC)
Interfaces: UART, I2C, SPI
USB: Native USB support (can act as USB device)
Power: 3.3V operation, 5V tolerant inputs
Current Draw: ~25mA active, ~10μA deep sleep

The SAMD21’s true analog output (DAC) is a standout feature rarely found on boards this size, making it ideal for audio generation, waveform synthesis, or analog control applications. Its mature Arduino core means extensive library support and rock-solid stability.

Best For: First-time users, educational projects, applications requiring analog output, projects needing proven stability.

XIAO RP2040: The Performance Leader

When Raspberry Pi released the RP2040 chip in 2021, Seeed Studio quickly recognized its potential and created the XIAO RP2040. This board brings desktop-class processing power to the XIAO form factor with features that push embedded capabilities forward.

Key Specifications:

Processor: Dual ARM Cortex-M0+ cores at 133MHz
Memory: 2MB Flash, 264KB SRAM
Digital I/O: 11 pins
Analog Inputs: 4 pins (12-bit ADC)
PIO: 8 programmable state machines
Interfaces: UART, I2C, SPI (multiple instances)
USB: Native USB 1.1 device and host
Power: 3.3V operation
Current Draw: ~45mA active (both cores)

The RP2040’s revolutionary feature is PIO (Programmable I/O)—eight independent state machines that can implement custom protocols, handle precise timing, or manage communication interfaces without CPU intervention. This makes seemingly impossible tasks trivial, like driving WS2812 LEDs with perfect timing or implementing unusual communication protocols.

With dual cores, you can dedicate one processor to time-critical tasks while the other handles higher-level logic. The generous 2MB of flash means you can store substantial programs, data, or even multiple firmware images.

Best For: Projects requiring high performance, custom protocols, parallel processing, complex timing requirements, or substantial code storage.

XIAO RP2350: The Latest Evolution

Released in 2024, the XIAO RP2350 represents Raspberry Pi’s second-generation silicon, bringing significant improvements while maintaining software compatibility with the RP2040.

Key Specifications:

Processor: Dual ARM Cortex-M33 at 150MHz OR dual RISC-V Hazard3 at 150MHz (switchable!)
Memory: 4MB Flash, 520KB SRAM
Security: Secure boot, signed updates, OTP memory
Digital I/O: 11 pins
Analog Inputs: 4 pins (12-bit ADC, improved accuracy)
PIO: 12 programmable state machines (4 more than RP2040)
Interfaces: UART, I2C, SPI (multiple instances)
USB: Native USB 1.1 device and host
FPU: Hardware floating-point acceleration
Power: 3.3V operation
Current Draw: ~50mA active (both cores)

The RP2350’s standout feature is architectural flexibility—you can choose at boot time whether to run ARM Cortex-M33 or RISC-V code. The enhanced security features (secure boot, signed firmware updates) make it suitable for commercial products where code protection matters. The larger memory and additional PIO state machines provide even more headroom for complex applications.

The Cortex-M33 cores offer significant improvements over M0+: hardware floating-point acceleration, DSP extensions, and faster instruction execution. For signal processing, audio, or mathematical applications, this translates to substantial performance gains.

Best For: Performance-critical applications, secure products, projects needing maximum memory, future-proof designs, or anyone interested in RISC-V development.

Comparison: Which General Purpose Board Should You Choose?

Choose SAMD21 if you need proven stability, true analog output, or are teaching beginners
Choose RP2040 if you need high performance, PIO capabilities, or dual-core processing at the best price point
Choose RP2350 if you want the latest features, maximum performance, enhanced security, or the largest memory capacity

All three boards use the same pinout and work with Arduino IDE, CircuitPython, and MicroPython, making migration between them straightforward. Many projects can run on any of the three with little or no code changes.

Practical Example: Dual-Core Processing with XIAO RP2040

This demonstration showcases the RP2040’s most distinctive feature—true dual-core processing. While most microcontrollers force you to juggle multiple tasks in a single loop, the RP2040 lets you dedicate an entire processor core to specific tasks, making previously difficult programming scenarios remarkably simple.

What Makes This Demo Special:

The RP2040’s dual Cortex-M0+ cores can run completely independently. In this example, Core 0 handles the user interface (LED control via potentiometer and button input), while Core 1 continuously reads the temperature/humidity sensor and reports data over serial. Neither core interferes with the other—they run truly in parallel.

This architectural advantage makes the RP2040 ideal for applications that require simultaneous execution of timing-critical tasks, such as motor control, while processing sensor data or maintaining network communication during real-time control loops.

Required Library:

Install via Arduino Library Manager:

“Adafruit AHTX0” by Adafruit

The Code:

Here is the sketch we will use with the RP2040:

/*
  XIAO RP2040  | Demo: Dual-core + I2C sensor + LED PWM
  xiao-rp2040-demo.ino
  Pot on A0, AHT20 on D4/D5, LED on D10, Pushbutton on D1->GND
  Demonstrates dual-core operation
  
  DroneBot Workshop 2025
  https://dronebotworkshop.com
*/

//Include required libraries
#include <Wire.h>
#include <Adafruit_AHTX0.h>
#include "pico/multicore.h"

// XIAO Connections
const int LED_PIN = D10;
const int POT_PIN = A0;
const int BTN_PIN = D1;

// Operating Variables
volatile uint16_t potRaw = 0;
volatile bool btnPressed = false;

// AHT20 Object
Adafruit_AHTX0 aht;

void core1Task() {
  // Core 1: read AHT20 periodically and report over Serial
  sensors_event_t humidity, temp;
  for (;;) {
    if (aht.getEvent(&humidity, &temp)) {
      Serial.print("Temp: ");
      Serial.print(temp.temperature, 1);
      Serial.print(" C  Humidity: ");
      Serial.print(humidity.relative_humidity, 1);
      Serial.println(" %");
    } else {
      Serial.println("AHT20 read failed");
    }
    delay(1000);
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  pinMode(BTN_PIN, INPUT_PULLUP);

// I2C on D4/D5
  Wire.setSDA(D4);
  Wire.setSCL(D5);
  Wire.begin();

if (!aht.begin(&Wire)) {
    Serial.println("AHT20 not found. Check wiring.");
  }

analogWriteResolution(8);  // smooth 0-255 PWM
  multicore_launch_core1(core1Task);
}

void loop() {
  // Core 0: LED PWM from potentiometer, button toggles blink/solid mode
  static bool blinkMode = false;

if (digitalRead(BTN_PIN) == LOW) {
    blinkMode = !blinkMode;
    delay(250);  // debounce
  }

potRaw = analogRead(POT_PIN);  // 0..1023
  uint8_t pwm = map(potRaw, 0, 1023, 0, 255);
  if (!blinkMode) {
    analogWrite(LED_PIN, pwm);  // solid brightness
    delay(5);
  } else {
    analogWrite(LED_PIN, pwm);
    delay(150);
    analogWrite(LED_PIN, 0);
    delay(150);
  }
}

XIAO RP2040 | Demo: Dual-core + I2C sensor + LED PWM

xiao-rp2040-demo.ino

Pot on A0, AHT20 on D4/D5, LED on D10, Pushbutton on D1->GND

Demonstrates dual-core operation

DroneBot Workshop 2025

https://dronebotworkshop.com

//Include required libraries

#include <Wire.h>

#include <Adafruit_AHTX0.h>

#include "pico/multicore.h"

// XIAO Connections

const int LED_PIN = D10;

const int POT_PIN = A0;

const int BTN_PIN = D1;

// Operating Variables

volatile uint16_t potRaw = 0;

volatile bool btnPressed = false;

// AHT20 Object

Adafruit_AHTX0 aht;

void core1Task() {

// Core 1: read AHT20 periodically and report over Serial

sensors_event_t humidity, temp;

for (;;) {

if (aht.getEvent(&humidity, &temp)) {

Serial.print("Temp: ");

Serial.print(temp.temperature, 1);

Serial.print(" C Humidity: ");

Serial.print(humidity.relative_humidity, 1);

Serial.println(" %");

} else {

Serial.println("AHT20 read failed");

}

delay(1000);

}

void setup() {

Serial.begin(115200);

pinMode(LED_PIN, OUTPUT);

pinMode(BTN_PIN, INPUT_PULLUP);

// I2C on D4/D5

Wire.setSDA(D4);

Wire.setSCL(D5);

Wire.begin();

if (!aht.begin(&Wire)) {

Serial.println("AHT20 not found. Check wiring.");

}

analogWriteResolution(8); // smooth 0-255 PWM

multicore_launch_core1(core1Task);

}

void loop() {

// Core 0: LED PWM from potentiometer, button toggles blink/solid mode

static bool blinkMode = false;

if (digitalRead(BTN_PIN) == LOW) {

blinkMode = !blinkMode;

delay(250); // debounce

}

potRaw = analogRead(POT_PIN); // 0..1023

uint8_t pwm = map(potRaw, 0, 1023, 0, 255);

if (!blinkMode) {

analogWrite(LED_PIN, pwm); // solid brightness

delay(5);

} else {

analogWrite(LED_PIN, pwm);

delay(150);

analogWrite(LED_PIN, 0);

delay(150);

}

Code Explanation:

This sketch elegantly demonstrates dual-core architecture through task separation:

Core 1 (Background Task): The core1Task() function runs continuously on the second processor core, launched by multicore_launch_core1() in setup. This core has one job: read the AHT20 sensor every second and report temperature and humidity to the serial monitor. It never returns—the infinite for(;;) loop ensures continuous operation.

Core 0 (Main Loop): Meanwhile, Core 0 runs the familiar Arduino loop() function, handling user interaction. It reads the potentiometer to control LED brightness via PWM, and monitors the pushbutton to toggle between steady and blinking modes. The button press switches the LED between smooth dimming (controlled by the pot) and a blinking pattern at the set brightness level.

Key Features Demonstrated:

True Parallelism: Temperature readings happen every second regardless of what Core 0 is doing. There’s no careful timing coordination or task scheduling needed—each core simply does its job.
PWM Control: The RP2040’s hardware PWM provides flicker-free LED dimming across the full brightness range (0-255).
I2C Communication: The AHT20 sensor connects via the standard I2C bus, explicitly configured on pins D4 (SDA) and D5 (SCL) for consistency across XIAO boards.
No Conflicts: The volatile keyword on shared variables isn’t even needed here because the cores don’t share data—they operate completely independently.

Expected Behavior:

When you upload and run this code:

The Serial Monitor displays temperature and humidity readings every second (from Core 1)
The LED brightness adjusts smoothly as you turn the potentiometer (Core 0)
Pressing the button switches between steady dimming and blinking modes (Core 0)
Both behaviors run simultaneously without interference

Why This Matters:

Traditional single-core microcontrollers would need to carefully interleave these tasks, using timers or complex state machines to ensure the sensor reads happen regularly while maintaining responsive button handling and smooth LED control. The RP2040 makes this trivial—just assign each task to a core and they run independently.

This architectural advantage becomes even more valuable in complex applications: imagine one core handling WiFi communication while the other manages motor control, or one core processing sensor data while the other updates a display. The RP2040’s dual cores transform difficult multitasking scenarios into straightforward programming.

Wireless & BLE Boards: Connecting Your Projects to the World

The wireless XIAO boards transform the family from standalone microcontrollers into IoT powerhouses. These six boards (nine including Sense variants) bring Bluetooth Low Energy, WiFi, and cutting-edge protocols like Matter and Thread to the compact XIAO form factor.

XIAO nRF52840: Bluetooth Low Energy Pioneer

Built around Nordic Semiconductor’s nRF52840, this board excels at Bluetooth Low Energy applications with exceptional power efficiency.

Key Specifications:

Processor: ARM Cortex-M4F at 64MHz with FPU
Memory: 1MB Flash, 256KB RAM
Wireless: Bluetooth 5.3, BLE, Thread, Zigbee capable
Digital I/O: 11 pins
Analog Inputs: 6 pins (12-bit ADC)
Interfaces: UART, I2C, SPI, NFC
USB: Native USB support
Battery: Built-in LiPo charging circuit
Power: 3.3V, ~5mA in deep sleep with BLE
Current Draw: ~15mA active BLE, ~5μA deep sleep

The nRF52840’s standout feature is power efficiency. With careful design, BLE projects can run for months on a small battery. The integrated battery charging circuit eliminates the need for external power management, and Nordic’s SoftDevice (BLE stack) is mature and feature-rich.

Best For: Battery-powered BLE peripherals, wearables, wireless sensors, beacon projects, low-power IoT devices.

XIAO nRF52840 Sense: BLE with Integrated Sensors

The Sense variant adds an impressive sensor suite to the nRF52840 platform, making it ideal for edge AI and sophisticated sensing applications.

Additional Features Beyond nRF52840:

IMU: 6-axis LSM6DS3TR-C (accelerometer + gyroscope)
Microphone: PDM (Pulse Density Modulation) digital microphone
Use Cases: Motion sensing, gesture recognition, voice activation, TinyML applications

The integrated IMU provides motion, orientation, and vibration sensing without external components. The PDM microphone enables voice commands, sound level monitoring, or audio event detection. Combined with TinyML frameworks like TensorFlow Lite Micro, you can implement on-device AI inference for gesture recognition or keyword spotting.

Best For: Wearable devices, gesture controllers, voice-activated projects, fitness trackers, edge AI applications.

XIAO ESP32C3: Affordable WiFi + BLE

The ESP32C3 brings Espressif’s popular wireless platform to the XIAO form factor at an incredibly competitive price point.

Key Specifications:

Processor: RISC-V single-core at 160MHz
Memory: 400KB SRAM, 4MB Flash
Wireless: WiFi 4 (802.11 b/g/n), BLE 5.0
Digital I/O: 11 pins
Analog Inputs: 4 pins (12-bit ADC)
Interfaces: UART, I2C, SPI
USB: Native USB (Serial/JTAG)
Battery: Built-in LiPo charging
Power: 3.3V operation
Current Draw: ~80mA active WiFi, ~130μA deep sleep

The ESP32C3 is Espressif’s first RISC-V microcontroller, offering a compelling combination of features and affordability. WiFi and BLE coexistence allows simultaneous operation of both radios. Deep sleep modes enable battery operation for sensor networks that wake periodically to transmit data.

Best For: Cost-sensitive IoT projects, WiFi-connected sensors, home automation, BLE beacons with WiFi updates, learning ESP32 development.

XIAO ESP32C6: Next-Generation Connectivity

The ESP32C6 represents Espressif’s latest wireless technology, adding WiFi 6, improved BLE, and support for emerging IoT standards.

Key Specifications:

Processor: RISC-V dual-core (one at 160MHz, one low-power at 20MHz)
Memory: 512KB SRAM, 4MB Flash
Wireless: WiFi 6 (802.11 ax), BLE 5.3, IEEE 802.15.4 (Thread/Zigbee)
Security: Secure boot, flash encryption, hardware crypto
Digital I/O: 11 pins (more if WiFi/BLE unused)
Analog Inputs: 7 pins (12-bit ADC)
Interfaces: UART, I2C, SPI (multiple)
USB: Native USB (Serial/JTAG)
Battery: Built-in LiPo charging
Power: 3.3V operation
Current Draw: ~100mA active WiFi 6

The ESP32C6’s key advancement is WiFi 6 (802.11ax), bringing improved efficiency, better performance in congested environments, and lower latency. The IEEE 802.15.4 radio enables participation in Thread and Zigbee mesh networks. Matter protocol support (over WiFi or Thread) ensures compatibility with modern smart home ecosystems.

The dual RISC-V cores include a low-power core for handling simple tasks during sleep, dramatically reducing power consumption for sensor applications that need periodic WiFi connectivity.

Best For: Matter/Thread smart home devices, WiFi 6 networks, future-proof designs, projects requiring enhanced security, modern IoT applications.

XIAO ESP32S3: AI and Multimedia Powerhouse

The ESP32S3 is Espressif’s flagship chip, bringing substantial processing power and multimedia capabilities to the XIAO platform.

Key Specifications:

Processor: Dual-core Xtensa LX7 at 240MHz
Memory: 512KB SRAM, 8MB Flash, 8MB PSRAM
Wireless: WiFi 4 (802.11 b/g/n), BLE 5.0
AI Acceleration: Vector instructions for neural networks
Digital I/O: 11 pins
Analog Inputs: 9 pins (12-bit ADC)
Interfaces: UART, I2C, SPI, I2S (digital audio), camera interface
USB: Native USB (Serial/JTAG) + USB OTG
Battery: Built-in LiPo charging
Power: 3.3V operation
Current Draw: ~150mA active WiFi

The ESP32S3’s substantial memory (including 8MB of PSRAM) enables complex applications previously impossible on microcontrollers. Vector instructions accelerate neural network inference, making it ideal for TinyML applications. The I2S interface supports high-quality digital audio, while USB OTG allows the board to act as a USB host.

Best For: AI/ML applications, audio processing, complex IoT systems, projects with substantial code or data, and edge computing applications.

XIAO ESP32S3 Sense: Camera and Microphone Integration

The Sense variant transforms the ESP32S3 into a complete vision and audio processing platform.

Additional Features Beyond ESP32S3:

Camera: OV2640 2-megapixel camera module
Microphone: Digital PDM microphone
SD Card: MicroSD card slot (uses SPI interface)
Use Cases: Computer vision, image recognition, video streaming, audio recording

The integrated camera enables applications from QR code scanning to sophisticated AI vision systems. When combined with the ESP32S3’s processing power and memory, you can implement real-time image recognition, face detection, or object tracking. The microSD slot provides substantial storage for data logging, audio recording, or storing captured images.

Best For: Computer vision projects, security cameras, AI image recognition, QR/barcode scanners, wildlife cameras, audio/video recording.

Comparison: Which Wireless Board Should You Choose?

For Battery-Powered BLE Projects:

nRF52840 offers the best battery life and most mature BLE stack
nRF52840 Sense adds motion and audio sensing

For WiFi Connectivity:

ESP32C3 provides the most affordable WiFi option
ESP32C6 offers WiFi 6 and Matter/Thread for future-proof designs
ESP32S3 delivers maximum processing power for complex applications
ESP32S3 Sense adds camera and audio for multimedia projects

For Learning:

ESP32C3 offers the gentlest learning curve with extensive documentation
nRF52840 provides the best BLE development experience

Practical Example: WiFi Web Dashboard with XIAO ESP32C3

This demonstration showcases the ESP32C3’s wireless capabilities by creating a fully functional web-based control panel accessible from any device on your network. The board hosts a miniature web server that displays real-time sensor data and allows remote LED control—all without requiring any external services or cloud platforms.

What Makes This Demo Special:

The ESP32C3 transforms a simple microcontroller project into a networked device accessible from phones, tablets, and computers. The web interface auto-refreshes to show live sensor readings, and you can control the LED either through the web page or the physical button—demonstrating both remote and local control operating simultaneously.

This example illustrates why the ESP32 family has become the go-to choice for IoT projects: full WiFi capability, adequate processing power to serve web pages, and sufficient memory to handle HTML content—all in the compact XIAO form factor.

Required Library:

Install via Arduino Library Manager:

“Adafruit AHTX0” by Adafruit
WiFi and WebServer libraries (included with ESP32 board support)

Important Setup Step:

Before uploading, you must edit lines 18-19 in the code to match your WiFi network:

/*
  XIAO ESP32C3 | WiFi Web Dashboard Demo
  xiao-esp32c3-demo.ino
  AHT20 + Pot readout + LED control
  Web interface with auto-refresh and remote control
  
  DroneBot Workshop 2025
  https://dronebotworkshop.com
*/

// Include required libraries
#include <WiFi.h>
#include <WebServer.h>
#include <Wire.h>
#include <Adafruit_AHTX0.h>

// -------- USER CONFIG --------
const char* SSID = "YOUR_SSID";
const char* PASS = "YOUR_PASSWORD";
// -----------------------------

// Pins (one schematic across demos)
const int LED_PIN = D10;
const int POT_PIN = A0;
const int BTN_PIN = D1;  // pushbutton to GND (active LOW)

Adafruit_AHTX0 aht;
WebServer server(80);

volatile bool ledOn = false;  // explicit LED state

// ---------- HTML ----------
String htmlPage(float t, float h, int pot) {
  String s = F(
    "<!doctype html><html><head>"
    "<meta name='viewport' content='width=device-width,initial-scale=1'>"
    "<meta http-equiv='refresh' content='2'>"
    "<title>XIAO C3 Dashboard</title>"
    "<style>body{font-family:system-ui,Segoe UI,Roboto,Arial;max-width:600px;margin:24px auto;padding:0 12px}"
    "button{padding:10px 16px;font-size:1rem}</style>"
    "</head><body><h2>XIAO ESP32-C3 Mini Dashboard</h2>");
  s += "<p><b>Temperature:</b> " + String(t, 1) + " &deg;C<br>";
  s += "<b>Humidity:</b> " + String(h, 1) + " %<br>";
  s += "<b>Potentiometer:</b> " + String(pot) + " / 4095<br>";
  s += "<b>LED:</b> " + String(ledOn ? "ON" : "OFF") + "</p>";
  s += F("<form action='/toggle' method='POST'>"
         "<button type='submit'>Toggle LED</button>"
         "</form>");
  s += F("</body></html>");
  return s;
}

// ---------- Helpers ----------
void applyLed() {
  digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
}

void handleRoot() {
  sensors_event_t hum, temp;
  aht.getEvent(&hum, &temp);      // returns false if read fails; values remain default
  int pot = analogRead(POT_PIN);  // ESP32-C3 ADC: 0..4095
  server.send(200, "text/html", htmlPage(temp.temperature, hum.relative_humidity, pot));
}

// PRG: POST /toggle flips state, then redirect to "/"
void handleTogglePost() {
  ledOn = !ledOn;
  applyLed();
  server.sendHeader("Location", "/");
  server.send(303);  // See Other
}

// Guard: any GET /toggle goes home
void handleToggleGet() {
  server.sendHeader("Location", "/");
  server.send(302);  // Found
}

// Quiet the favicon noise
void handleFavicon() {
  server.send(204);  // No Content
}

// Debounced, edge-detected button press (falling edge)
bool readButtonPressed() {
  static uint8_t stable = HIGH, last = HIGH;
  static uint32_t lastChange = 0;
  uint8_t raw = digitalRead(BTN_PIN);
  if (raw != last) {
    last = raw;
    lastChange = millis();
  }
  if (millis() - lastChange > 25 && raw != stable) {  // ~25 ms debounce
    stable = raw;
    if (stable == LOW) return true;  // falling edge => press
  }
  return false;
}

void setup() {
  Serial.begin(115200);

pinMode(LED_PIN, OUTPUT);
  applyLed();

pinMode(BTN_PIN, INPUT_PULLUP);

// Standardized I2C on D4/D5 across XIAO family
  Wire.begin(D4, D5);
  if (!aht.begin(&Wire)) {
    Serial.println("AHT20 not found — check wiring or pull-ups.");
  } else {
    Serial.println("AHT20 ready.");
  }

WiFi.begin(SSID, PASS);
  Serial.print("Connecting");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("IP: ");
  Serial.println(WiFi.localIP());

// Routes
  server.on("/", HTTP_GET, handleRoot);
  server.on("/toggle", HTTP_POST, handleTogglePost);
  server.on("/toggle", HTTP_GET, handleToggleGet);
  server.on("/favicon.ico", HTTP_GET, handleFavicon);
  server.begin();
}

void loop() {
  server.handleClient();

if (readButtonPressed()) {
    ledOn = !ledOn;
    applyLed();
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

XIAO ESP32C3 | WiFi Web Dashboard Demo

xiao-esp32c3-demo.ino

AHT20 + Pot readout + LED control

Web interface with auto-refresh and remote control

DroneBot Workshop 2025

https://dronebotworkshop.com

// Include required libraries

#include <WiFi.h>

#include <WebServer.h>

#include <Wire.h>

#include <Adafruit_AHTX0.h>

// -------- USER CONFIG --------

const char* SSID = "YOUR_SSID";

const char* PASS = "YOUR_PASSWORD";

// -----------------------------

// Pins (one schematic across demos)

const int LED_PIN = D10;

const int POT_PIN = A0;

const int BTN_PIN = D1; // pushbutton to GND (active LOW)

Adafruit_AHTX0 aht;

WebServer server(80);

volatile bool ledOn = false; // explicit LED state

// ---------- HTML ----------

String htmlPage(float t, float h, int pot) {

String s = F(

"<!doctype html><html><head>"

"<meta name='viewport' content='width=device-width,initial-scale=1'>"

"<meta http-equiv='refresh' content='2'>"

"<title>XIAO C3 Dashboard</title>"

"<style>body{font-family:system-ui,Segoe UI,Roboto,Arial;max-width:600px;margin:24px auto;padding:0 12px}"

"button{padding:10px 16px;font-size:1rem}</style>"

"</head><body><h2>XIAO ESP32-C3 Mini Dashboard</h2>");

s += "<p><b>Temperature:</b> " + String(t, 1) + " °C<br>";

s += "<b>Humidity:</b> " + String(h, 1) + " %<br>";

s += "<b>Potentiometer:</b> " + String(pot) + " / 4095<br>";

s += "<b>LED:</b> " + String(ledOn ? "ON" : "OFF") + "</p>";

s += F("<form action='/toggle' method='POST'>"

"<button type='submit'>Toggle LED</button>"

"</form>");

s += F("</body></html>");

return s;

}

// ---------- Helpers ----------

void applyLed() {

digitalWrite(LED_PIN, ledOn ? HIGH : LOW);

}

void handleRoot() {

sensors_event_t hum, temp;

aht.getEvent(&hum, &temp); // returns false if read fails; values remain default

int pot = analogRead(POT_PIN); // ESP32-C3 ADC: 0..4095

server.send(200, "text/html", htmlPage(temp.temperature, hum.relative_humidity, pot));

}

// PRG: POST /toggle flips state, then redirect to "/"

void handleTogglePost() {

ledOn = !ledOn;

applyLed();

server.sendHeader("Location", "/");

server.send(303); // See Other

}

// Guard: any GET /toggle goes home

void handleToggleGet() {

server.sendHeader("Location", "/");

server.send(302); // Found

}

// Quiet the favicon noise

void handleFavicon() {

server.send(204); // No Content

}

// Debounced, edge-detected button press (falling edge)

bool readButtonPressed() {

static uint8_t stable = HIGH, last = HIGH;

static uint32_t lastChange = 0;

uint8_t raw = digitalRead(BTN_PIN);

if (raw != last) {

last = raw;

lastChange = millis();

}

if (millis() - lastChange > 25 && raw != stable) { // ~25 ms debounce

stable = raw;

if (stable == LOW) return true; // falling edge => press

}

return false;

}

void setup() {

Serial.begin(115200);

pinMode(LED_PIN, OUTPUT);

applyLed();

pinMode(BTN_PIN, INPUT_PULLUP);

// Standardized I2C on D4/D5 across XIAO family

Wire.begin(D4, D5);

if (!aht.begin(&Wire)) {

Serial.println("AHT20 not found — check wiring or pull-ups.");

} else {

Serial.println("AHT20 ready.");

}

WiFi.begin(SSID, PASS);

Serial.print("Connecting");

while (WiFi.status() != WL_CONNECTED) {

delay(500);

Serial.print(".");

}

Serial.println();

Serial.print("IP: ");

Serial.println(WiFi.localIP());

// Routes

server.on("/", HTTP_GET, handleRoot);

server.on("/toggle", HTTP_POST, handleTogglePost);

server.on("/toggle", HTTP_GET, handleToggleGet);

server.on("/favicon.ico", HTTP_GET, handleFavicon);

server.begin();

}

void loop() {

server.handleClient();

if (readButtonPressed()) {

ledOn = !ledOn;

applyLed();

}

Code Explanation:

This sketch creates a complete web server with clean HTML output and proper HTTP handling:

WiFi Connection: The setup() function connects to your WiFi network and displays the assigned IP address in the Serial Monitor. This IP address is what you’ll enter in your web browser to access the dashboard.

Web Server Routes: The code defines several URL endpoints:

/ (root) — Main dashboard page displaying all sensor data
/toggle (POST) — Handles the “Toggle LED” button click
/toggle (GET) — Redirects to home if someone tries to access toggle directly
/favicon.ico — Prevents error messages from browsers requesting an icon

HTML Generation: The htmlPage() function creates a complete, responsive HTML page that works on any device. The page includes a meta refresh tag that automatically reloads every 2 seconds, providing live sensor updates without JavaScript. The styling uses system fonts and responsive design for a clean, professional appearance.

LED Control: The LED can be controlled two ways:

Physical Button: The readButtonPressed() function provides debounced button reading with edge detection, toggling the LED only on button press (not hold)
Web Button: Clicking “Toggle LED” in the browser sends a POST request that changes the LED state and redirects back to the main page

Sensor Reading: The AHT20 temperature/humidity sensor is read each time someone accesses the page. The potentiometer value (0-4095 from the ESP32C3’s 12-bit ADC) updates with each page load, showing the current position.

Expected Behavior:

After uploading the code:

Open Serial Monitor (115200 baud) to see connection status
Note the IP address displayed (example: 192.168.1.175)
Open a web browser on any device connected to the same WiFi network
Navigate to the IP address (http://192.168.1.175)
The dashboard displays temperature, humidity, potentiometer value, and LED status
The page auto-refreshes every 2 seconds with updated sensor readings
Click “Toggle LED” to turn the LED on/off remotely
Press the physical button to toggle the LED locally
Both control methods work simultaneously and the web page reflects the current state

Why This Approach Works Well:

This demo uses a simplified web interface that doesn’t require JavaScript, websockets, or complex frameworks. The meta refresh tag provides automatic updates, and the POST/Redirect/GET pattern (PRG pattern) prevents the browser’s “resubmit form?” dialog. This keeps the code simple and maintainable while providing a fully functional web interface.

The ESP32C3’s 400KB of RAM is more than adequate for serving this HTML content, and the RISC-V processor at 160MHz handles web requests with ease while simultaneously managing sensor reading and GPIO control.

Practical Applications:

This pattern forms the foundation for countless IoT projects:

Environmental Monitoring: Deploy sensors around your home or garden, and access data remotely
Home Automation: Control lights, fans, or other devices from any device on your network
Equipment Monitoring: Track the status of 3D printers, aquarium controllers, or other equipment
Data Logging: Combine with SD card or cloud services for long-term data storage
Multi-Sensor Systems: Expand to dozens of sensors while maintaining simple web access

Advanced MCU Boards: Industrial-Grade and Ultra-Low-Power Solutions

The advanced XIAO boards target specialized applications requiring industrial reliability, ultra-low power consumption, or cutting-edge wireless protocols. These four boards push beyond general-purpose capabilities into professional territories.

XIAO RA4M1: Renesas Reliability

Built on Renesas’ RA4M1 microcontroller from their industrial-focused RA family, this board brings enterprise-grade reliability to the XIAO platform.

Key Specifications:

Processor: ARM Cortex-M4 at 48MHz with FPU
Memory: 256KB Flash, 32KB SRAM
Digital I/O: 11 pins
Analog: 8 ADC inputs (12/14-bit selectable), 2 DAC outputs (12-bit)
Timers: 16-bit and 32-bit timers, PWM, input capture
Interfaces: UART, I2C, SPI, CAN (Flexible Serial Communication)
USB: Full-speed USB 2.0
Security: AES hardware acceleration, TRNG
Power: 3.3V operation, excellent EMI characteristics
Current Draw: ~20mA active, ~7μA deep sleep

The RA4M1 stands out for industrial applications requiring reliability and precision. Renesas’ Flexible Software Package (FSP) provides extensive peripheral drivers and middleware tested for automotive and industrial use. The dual 12-bit DACs enable true analog output for control applications, while the robust timer system supports complex PWM and motor control scenarios.

Hardware CAN bus support (requires external transceiver) makes this board suitable for automotive diagnostics, industrial automation, or robotics communication. The AES accelerator and true random number generator enable secure communications.

Best For: Industrial automation, motor control, precision analog applications, CAN bus projects, secure embedded systems, professional product development.

XIAO MG24: Silicon Labs Matter/Thread Pioneer

The MG24 (Mighty Gecko 24) leverages Silicon Labs’ expertise in ultra-low-power wireless, bringing Matter, Thread, and exceptional battery life to the XIAO ecosystem.

Key Specifications:

Processor: ARM Cortex-M33 at 78MHz with DSP and FPU
Memory: 1536KB Flash, 256KB RAM
Wireless: Bluetooth 5.3 LE, IEEE 802.15.4 (Thread/Zigbee), proprietary 2.4GHz
Digital I/O: 11 pins
Analog: 10 ADC inputs (12-bit)
Security: Secure Vault (high security), secure boot, secure debug
Interfaces: UART, I2C, SPI, I2S
USB: Full-speed USB
Power: 3.3V operation
Current Draw: ~7mA active BLE, ~1.4μA deep sleep (retaining RAM)

The MG24’s headline feature is Matter protocol support—the emerging smart home standard backed by Apple, Google, Amazon, and others. Matter operates over Thread (a mesh networking protocol) or WiFi, and the MG24 supports Thread natively. This enables creation of smart home devices compatible with HomeKit, Google Home, and Alexa simultaneously.

Silicon Labs’ radio is exceptionally efficient, enabling battery-powered devices that run for years. The Secure Vault provides tamper detection, secure key storage, and certified cryptographic operations, meeting PSA Level 3 and other security standards.

Best For: Matter/Thread smart home devices, ultra-low-power wireless sensors, mesh networking, security-critical IoT, professional smart home product development.

XIAO MG24 Sense: Matter with Integrated Sensors

The Sense variant adds a complete sensor suite to the MG24, creating a ready-to-deploy smart sensor platform.

Additional Features Beyond MG24:

IMU: 6-axis BMI270 (accelerometer + gyroscope) – ultra-low-power design
Microphone: PDM digital microphone
Use Cases: Motion-activated Matter devices, voice control, gesture recognition in smart home

The BMI270 is specifically designed for wearables and IoT, featuring on-chip motion processing that reduces CPU wake-ups and extends battery life dramatically. Combined with MG24’s ultra-low-power radio, you can create battery-powered motion sensors that last years while maintaining constant Matter/Thread connectivity.

Best For: Battery-powered Matter sensors, motion-activated smart home devices, voice-controlled IoT, professional ultra-low-power products.

XIAO nRF54L15: Nordic’s Next Generation (Newest Addition)

The nRF54L15 represents Nordic’s latest wireless platform, bringing enhanced capabilities while maintaining legendary power efficiency.

Key Specifications:

Processor: ARM Cortex-M33 at 128MHz with FPU and DSP
Memory: 1.5MB Flash, 256KB RAM
Wireless: Bluetooth 5.4 LE, Direction Finding, 802.15.4 (Thread/Zigbee)
Digital I/O: 11 pins
Analog: Enhanced ADC (multiple channels, 12-bit)
Security: ARM TrustZone, Secure Boot, Crypto accelerator
Interfaces: UART, I2C, SPI, I2S, PDM
USB: Full-speed USB
Power: 3.3V operation
Current Draw: ~4mA active BLE, <1μA deep sleep

The nRF54L15 advances Nordic’s wireless leadership with Bluetooth 5.4 features including enhanced connection management and improved power efficiency. Bluetooth Direction Finding enables precise location tracking using angle-of-arrival or angle-of-departure techniques. The enhanced processing power supports simultaneous BLE and Thread connectivity.

ARM TrustZone creates hardware-enforced security zones, allowing secure and non-secure code to coexist safely—critical for commercial products requiring code protection or secure firmware updates.

Best For: Advanced BLE applications, asset tracking with direction finding, Thread mesh networks, secure wireless products, next-generation IoT devices.

Comparison: Which Advanced Board Should You Choose?

For Industrial Applications:

RA4M1 provides the reliability, precision analog, and CAN bus support industrial projects require

For Ultra-Low-Power Wireless:

MG24 offers the lowest power consumption with Matter/Thread support
MG24 Sense adds motion and audio sensing for battery-powered smart sensors
nRF54L15 provides enhanced BLE features and direction finding

For Smart Home Products:

MG24/MG24 Sense are ideal for Matter-compatible devices
nRF54L15 excels for advanced BLE applications

For Security-Critical Projects:

MG24 offers PSA Level 3 certified security
nRF54L15 provides ARM TrustZone for code isolation
RA4M1 includes hardware crypto for secure communications

Practical Example: Motion Detection with XIAO MG24 Sense

This demonstration showcases the MG24 Sense’s integrated 6-axis IMU (Inertial Measurement Unit) for motion detection. Unlike the previous demos that used external sensors, the MG24 Sense includes sophisticated motion-sensing hardware built directly into the board—no additional components required.

What Makes This Demo Special:

The MG24 Sense board integrates an LSM6DS3 6-axis IMU (accelerometer + gyroscope) directly on the PCB. This “Sense” variant adds motion detection, orientation sensing, and gesture recognition capabilities without external wiring. Combined with the MG24’s ultra-low-power design, this enables battery-powered motion-sensing applications that can run for months or even years.

This example calculates a “motion value” by summing the absolute values of acceleration on all three axes (X, Y, Z). When you shake or move the board and the motion exceeds a threshold (2.5 g), the LED illuminates, providing instant visual feedback on the IMU’s capabilities.

The Code:

/*
  XIAO MG24 Sense Demo
  xiao-mg24-sense-demo.ino
  Reads IMU values and calculates Motion value
  Also reads AHT20 and Potentiometer values
  
  DroneBot Workshop 2025
  https://dronebotworkshop.com
*/

// Include Required Libraries
#include <Wire.h>
#include <Adafruit_AHTX0.h>
#include "LSM6DS3.h"

//Objects for IMU and AHT20
Adafruit_AHTX0 aht;
LSM6DS3 imu;

// Pin definitions (MG24 uses numbers only)
const int LED_PIN = 10;
const int BUTTON_PIN = 1;
const int POT_PIN = 0;

bool ledEnabled = false;

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT_PULLUP);

Wire.begin();  // Default I2C pins D4 (SDA), D5 (SCL)

if (!aht.begin()) {
    Serial.println("AHT20 not found");
  }

if (!imu.begin()) {
    Serial.println("IMU not found");
  }

Serial.println("XIAO MG24 Sense Demo Started");
}

void loop() {
  // Pushbutton toggles LED mode
  if (digitalRead(BUTTON_PIN) == LOW) {
    ledEnabled = !ledEnabled;
    delay(300);  // debounce
  }

// Read potentiometer
  int potValue = analogRead(POT_PIN);

// Read AHT20 sensor
  sensors_event_t humidity, temp;
  aht.getEvent(&humidity, &temp);

// Read IMU acceleration
  float ax = imu.readFloatAccelX();
  float ay = imu.readFloatAccelY();
  float az = imu.readFloatAccelZ();
  float motion = abs(ax) + abs(ay) + abs(az);

// Print sensor data
  Serial.print("Pot: "); Serial.print(potValue);
  Serial.print(" | Temp: "); Serial.print(temp.temperature);
  Serial.print(" °C | Humidity: "); Serial.print(humidity.relative_humidity);
  Serial.print(" %");
  Serial.print(" | Accel X: "); Serial.print(ax, 2);
  Serial.print(" Y: "); Serial.print(ay, 2);
  Serial.print(" Z: "); Serial.print(az, 2);
  Serial.print(" | Motion: "); Serial.println(motion, 2);

// LED logic
  if (ledEnabled && motion > 2.5) {
    digitalWrite(LED_PIN, HIGH);
  } else {
    digitalWrite(LED_PIN, LOW);
  }

delay(500);
}

XIAO MG24 Sense Demo

xiao-mg24-sense-demo.ino

Reads IMU values and calculates Motion value

Also reads AHT20 and Potentiometer values

DroneBot Workshop 2025

https://dronebotworkshop.com

// Include Required Libraries

#include <Wire.h>

#include <Adafruit_AHTX0.h>

#include "LSM6DS3.h"

//Objects for IMU and AHT20

Adafruit_AHTX0 aht;

LSM6DS3 imu;

// Pin definitions (MG24 uses numbers only)

const int LED_PIN = 10;

const int BUTTON_PIN = 1;

const int POT_PIN = 0;

bool ledEnabled = false;

void setup() {

Serial.begin(115200);

pinMode(LED_PIN, OUTPUT);

pinMode(BUTTON_PIN, INPUT_PULLUP);

Wire.begin(); // Default I2C pins D4 (SDA), D5 (SCL)

if (!aht.begin()) {

Serial.println("AHT20 not found");

}

if (!imu.begin()) {

Serial.println("IMU not found");

}

Serial.println("XIAO MG24 Sense Demo Started");

}

void loop() {

// Pushbutton toggles LED mode

if (digitalRead(BUTTON_PIN) == LOW) {

ledEnabled = !ledEnabled;

delay(300); // debounce

}

// Read potentiometer

int potValue = analogRead(POT_PIN);

// Read AHT20 sensor

sensors_event_t humidity, temp;

aht.getEvent(&humidity, &temp);

// Read IMU acceleration

float ax = imu.readFloatAccelX();

float ay = imu.readFloatAccelY();

float az = imu.readFloatAccelZ();

float motion = abs(ax) + abs(ay) + abs(az);

// Print sensor data

Serial.print("Pot: "); Serial.print(potValue);

Serial.print(" | Temp: "); Serial.print(temp.temperature);

Serial.print(" °C | Humidity: "); Serial.print(humidity.relative_humidity);

Serial.print(" %");

Serial.print(" | Accel X: "); Serial.print(ax, 2);

Serial.print(" Y: "); Serial.print(ay, 2);

Serial.print(" Z: "); Serial.print(az, 2);

Serial.print(" | Motion: "); Serial.println(motion, 2);

// LED logic

if (ledEnabled && motion > 2.5) {

digitalWrite(LED_PIN, HIGH);

} else {

digitalWrite(LED_PIN, LOW);

}

delay(500);

}

Code Explanation:

This sketch demonstrates the MG24 Sense’s integrated motion sensing capabilities:

IMU Initialization: The LSM6DS3 IMU is initialized during setup() using the default I2C bus. The library handles all the complex sensor configuration automatically. If initialization fails, an error message displays—though this is rare since the IMU is built into the board.

Motion Calculation: Each loop iteration reads the three-axis accelerometer data:

ax — Acceleration in X direction (forward/back)
ay — Acceleration in Y direction (left/right)
az — Acceleration in Z direction (up/down)

The motion value is calculated by summing the absolute values: motion = |ax| + |ay| + |az|. This provides a simple but effective measure of total movement. When the board is stationary, motion hovers around 1.0 (Earth’s gravity). When you shake it, motion increases dramatically—often exceeding 5.0 or more.

Interactive LED Control: The pushbutton toggles “LED mode” on and off. When enabled (ledEnabled = true), the LED illuminates whenever motion exceeds the threshold of 2.5 g. This creates an interactive demonstration: press the button to enable motion detection, then shake the board to see the LED respond.

Multi-Sensor Integration: While the focus is on the IMU, the sketch also reads:

Temperature and humidity from the external AHT20 sensor
Analog value from the potentiometer (0-4095 on MG24’s 12-bit ADC)

All sensor data streams to the Serial Monitor every 500 milliseconds, providing a complete view of the board’s sensing capabilities.

Expected Behavior:

After uploading the code:

Open Serial Monitor (115200 baud)
Observe continuous sensor readings scrolling by
Note the acceleration values (X, Y, Z) and calculated motion value
When stationary, motion should read approximately 1.0 (gravity)
Press the button to enable LED motion detection mode
Shake or move the board—the LED lights when motion exceeds 2.5
Adjust the potentiometer and observe the value changing (0-4095)
Breathe on the AHT20 to see temperature and humidity readings change

Understanding the Motion Values:

The accelerometer measures acceleration in “g” units (where 1g = 9.8 m/s²):

Stationary: ~1.0 (detecting Earth’s gravity)
Gentle tilt: 1.0-1.5
Quick movement: 2.0-3.0
Shake/impact: 3.0-10.0+

The threshold of 2.5 provides good sensitivity—it responds to deliberate motion while ignoring small vibrations or tilts.

Why This Matters:

The integrated IMU transforms the MG24 Sense into a complete motion sensing platform. Applications include:

Practical Applications:

Wearable Devices: Fitness trackers, gesture controllers, fall detection
Security Systems: Motion-activated alarms, door/window sensors
Robotics: Self-balancing robots, orientation sensing, impact detection
Gaming Controllers: Motion-based game inputs, gesture recognition
Industrial Monitoring: Vibration monitoring, equipment health tracking
Smart Home: Automatic lighting (lights on when you enter), presence detection

The MG24’s ultra-low-power capabilities make battery-powered motion sensing practical. With careful power management, a motion-sensing device can run for months on a small coin cell battery—the IMU consumes only microamps in low-power mode.

Accessories & Prototyping Tools: Expanding the XIAO Ecosystem

One of the greatest strengths of the XIAO family is the growing ecosystem of accessories and expansion boards designed specifically for this form factor. Seeed Studio has developed a comprehensive range of prototyping tools that make working with XIAO boards faster, easier, and more versatile.

Grove Shield for XIAO

The Grove Shield transforms your XIAO into a Grove-compatible development platform, providing instant access to hundreds of Grove sensors and modules without soldering.

Features:

8 Grove connectors (I2C, UART, Digital, Analog)
Reset button accessible while mounted
Power LED indicator
Breadboard-style pin headers for additional connections
Compact design maintaining XIAO’s small footprint

Why It’s Useful: Grove’s plug-and-play connectors eliminate wiring errors and speed up prototyping dramatically. The standardized 4-pin cables handle power, ground, and signal lines automatically. With over 300 Grove modules available (sensors, displays, actuators, communication modules), you can quickly test ideas and build functional prototypes without any soldering.

Typical Use Cases:

Rapid prototyping and experimentation
Educational projects and workshops
Testing multiple sensors quickly
Building functional demos without custom PCBs

XIAO Expansion Board

The XIAO Expansion Board provides a complete development and prototyping platform with integrated peripherals and ample connection options.

Features:

OLED Display: Built-in 0.96″ OLED (128×64 pixels)
Grove Connectors: Multiple Grove ports for easy expansion
Battery Management: LiPo battery connector with charging circuit
SD Card Slot: MicroSD card socket for data logging
Buttons: User programmable buttons
Buzzer: Onboard buzzer for audio feedback
RTC: Real-time clock with backup battery holder
Pin Breakouts: All XIAO pins accessible via headers
Prototyping Area: Small solderable area for custom circuits

Why It’s Useful: This all-in-one board eliminates the need for separate display modules, SD card adapters, and battery management circuits. It’s particularly valuable for standalone projects that need local display, data logging, and battery operation. The integrated RTC enables time-stamped data logging even when the main processor is asleep.

Typical Use Cases:

Data logger projects
Standalone monitoring devices
Battery-powered displays
Educational demonstrations
IoT edge devices with local display

Battery Management Expansions

Several battery-focused expansion boards provide clean power solutions for portable projects:

Features Across Various Battery Boards:

LiPo Charging: Automatic charging when USB connected
Power Management: Low-dropout regulators for stable 3.3V
Battery Protection: Over-charge, over-discharge, short-circuit protection
Power Switch: Physical on/off switch
Charge Indicator: LED showing charging status
Solar Input: Some variants include solar panel connectors

Why They’re Useful: Professional battery management requires careful handling of lithium batteries. These boards integrate protection circuits, charge controllers, and power switches in a compact package. Solar variants enable truly autonomous outdoor deployments.

Typical Use Cases:

Wearable devices
Remote sensors
Wildlife monitoring cameras
Solar-powered weather stations
Portable measurement instruments

Breadboard Adapter/Breakout Boards

These simple but invaluable boards break out all XIAO pins to standard 0.1″ (2.54mm) spacing for easy breadboard use.

Features:

Standard Pin Spacing: All pins accessible on breadboard-friendly headers
Silkscreen Labels: Clear pin identification
Multiple Mounting: Can be used on breadboard or as standalone breakout
Dual Row Headers: Some variants provide pins on both sides

Why They’re Useful: While XIAO boards are breadboard-compatible, the tight pin spacing can be challenging. These adapters provide comfortable spacing and make it easier to use standard jumper wires, prototype shields, and testing equipment.

Typical Use Cases:

Classroom teaching and learning
Rapid prototyping with standard components
Testing and troubleshooting
Creating semi-permanent test setups

CAN Bus Expansion Board

For XIAO boards with CAN capability (RA4M1), specialized CAN bus expansion boards provide the necessary transceiver and termination:

Features:

CAN Transceiver: TJA1051 or similar high-speed CAN transceiver
Screw Terminals: Convenient CANH/CANL connections
Termination: Optional 120Ω termination resistor
Protection: ESD protection on CAN lines
Status LEDs: TX/RX activity indicators

Why It’s Useful: CAN bus requires differential signaling that microcontrollers can’t generate directly. This board provides the physical layer interface, making automotive diagnostics, industrial communication, and robotics projects straightforward.

Typical Use Cases:

Automotive OBD-II readers
Industrial control networks
Robotics communication
Agricultural equipment interfaces

Motor Driver Shields

Compact motor driver expansions enable robotics and motion control applications:

Features:

Dual H-Bridge: Drive two DC motors or one stepper motor
PWM Speed Control: Variable speed control via PWM
Current Ratings: Typically 1-2A per channel
Protection: Thermal shutdown, short-circuit protection
Encoder Inputs: Some variants include encoder connection headers

Why They’re Useful: Motor control requires higher currents than XIAO boards can source directly. These shields provide power amplification while maintaining compatibility with Arduino motor libraries.

Typical Use Cases:

Small robots and rovers
Camera pan/tilt mechanisms
Automated blinds/shutters
Educational robotics projects

Display Expansion Options

Beyond the expansion board’s integrated OLED, several display options exist:

E-Ink Displays:

Ultra-low-power displays that maintain image without power
Perfect for battery-operated informational displays
Available in various sizes (1.54″, 2.13″, etc.)

TFT LCD Displays:

Color displays with touch capability
SPI interface for reasonable refresh rates
Suitable for user interfaces and data visualization

LED Matrix Shields:

8×8 or larger LED matrices
Great for scrolling text, simple animations
Low cost and easy to use

Why They’re Useful: Different applications have different display needs. E-ink excels for battery life, TFT provides color and touch, LED matrices work well for simple notifications.

Sensor Expansion Boards

Some expansion boards integrate commonly-used sensors:

Common Integrated Sensors:

IMU: Accelerometer and gyroscope (6-axis or 9-axis)
Environmental: Temperature, humidity, pressure
Light: Ambient light, UV, gesture sensors
Audio: MEMS microphones, I2S audio codecs

Why They’re Useful: Integrated sensors eliminate wiring and provide tested, working configurations. They’re particularly valuable for specific application areas like wearables (IMU), weather monitoring (environmental), or audio projects (microphone).

Custom PCB Footprint

One of the most powerful aspects of the XIAO ecosystem is the standardized footprint, enabling custom PCB designs:

Standard XIAO Footprint Specifications:

Dimensions: 20mm x 17.5mm
Mounting Holes: 4 holes at 11.4mm x 11.4mm spacing (M1.5 or M2)
Pin Pitch: 2.54mm (0.1″) on castellated edges
Through-Hole Pads: Allow soldering from top or bottom

Why It’s Useful: When moving from prototype to product, you can design a custom PCB with the XIAO footprint. This allows you to:

Create production-ready devices while keeping development flexibility
Swap different XIAO variants to change capabilities without redesigning PCB
Create application-specific carrier boards with exactly the sensors/connectors needed
Maintain upgrade paths (start with RP2040, upgrade to RP2350 later)

Design Considerations:

Leave access to USB connector
Provide test points for serial debugging
Consider battery connector placement
Include a reset button or circuit
Route I2C, SPI buses to convenient locations

Choosing the Right Accessories

For Beginners:

Start with Grove Shield for easy sensor experimentation
Add breadboard adapter for comfortable prototyping

For Battery Projects:

Use dedicated battery expansion board with protection
Consider expansion board with integrated battery management

For Data Logging:

XIAO Expansion Board provides display + SD card
Add RTC for time-stamped data

For Product Development:

Prototype with Grove Shield or breadboard
Design custom PCB using standard XIAO footprint
Maintain flexibility to swap XIAO variants

For Education:

Grove Shield simplifies wiring for students
Expansion boards provide complete learning platforms
Clear documentation and examples speed learning

The XIAO accessory ecosystem continues expanding as the platform grows. Third-party developers and hobbyists are creating compatible boards, cases, and mounting systems. This growing ecosystem makes XIAO an increasingly attractive platform for projects of all scales—from weekend experiments to professional products.

XIAO-Compatible Boards: Alternatives and Variants

While Seeed Studio pioneered the XIAO form factor, other manufacturers recognized the value of this standardized platform and created compatible boards. These alternatives maintain the same footprint and basic pinout, offering different chip choices or integrated features.

Adafruit QT Py Series

Adafruit’s QT Py line closely matches the XIAO form factor while incorporating Adafruit’s signature STEMMA QT (I2C) connector and design philosophy.

Physical Specifications:

Size: 21mm x 18mm (slightly larger than XIAO)
Mounting: Compatible with XIAO mounting holes
USB: USB-C connector
I2C Connector: Built-in STEMMA QT/Qwiic JST connector

Available Variants:

QT Py SAMD21:

Same ATSAMD21 chip as XIAO SAMD21
Excellent CircuitPython support (Adafruit’s specialty)
NeoPixel LED onboard
Extensive Adafruit library ecosystem

QT Py RP2040:

Raspberry Pi RP2040 chip
8MB flash (more than XIAO RP2040)
STEMMA QT connector for easy I2C sensors
Native USB support

QT Py ESP32-S2:

WiFi-enabled variant
Native USB with TinyUSB support
4MB flash
STEMMA QT connector

QT Py ESP32-S3:

Dual-core with WiFi + Bluetooth
8MB flash, 2MB PSRAM
USB host and device
Additional GPIO broken out

QT Py ESP32 Pico:

Compact ESP32 variant
WiFi + Bluetooth Classic + BLE
Lower cost option

Key Differences from XIAO:

STEMMA QT Connector: Built-in I2C connector makes Adafruit’s extensive sensor ecosystem plug-and-play
CircuitPython Focus: Adafruit prioritizes CircuitPython support with excellent documentation
NeoPixel LED: Integrated addressable RGB LED on most variants
Slightly Larger: About 1mm wider and taller
Price: Generally comparable or slightly higher than XIAO equivalents

Best For:

CircuitPython development
Quick I2C sensor prototyping with STEMMA QT ecosystem
Projects using Adafruit’s extensive libraries and tutorials
Users who prefer Adafruit’s documentation style

DFRobot Beetle Series

DFRobot’s Beetle ESP32-C3 and similar boards offer XIAO-compatible options with their own design touches.

Beetle ESP32-C3:

Chip: Espressif ESP32-C3 (RISC-V)
Wireless: WiFi + BLE 5.0
Size: Matches XIAO footprint
Battery: LiPo charging circuit
Features: Similar capabilities to XIAO ESP32C3

Key Differences from XIAO:

Pin Labels: DFRobot’s silkscreen layout differs slightly
Color Schemes: Different PCB colors and aesthetic choices
Documentation: DFRobot-specific tutorials and examples
Regional Availability: May be more readily available in certain markets

Best For:

Users familiar with DFRobot ecosystem
Projects using DFRobot’s sensor modules
Regional availability considerations

Choosing Between XIAO and Compatible Boards

Choose Seeed XIAO When:

Widest variant selection needed (12+ different chips)
Sense variants with integrated cameras/microphones required
Consistency across large projects matters
Access to Seeed’s specific accessories and expansion boards
Official support and documentation preferred

Choose Adafruit QT Py When:

CircuitPython is primary development environment
STEMMA QT I2C ecosystem is valuable
Adafruit’s extensive tutorials and learning resources preferred
Integrated NeoPixel LED is useful

Choose DFRobot Beetle When:

Already using DFRobot sensor ecosystem
Regional availability favors DFRobot
Specific DFRobot features are needed

Ecosystem Interoperability

The beauty of the XIAO form factor is that accessories and carrier boards generally work across different manufacturers’ boards:

Compatible Accessories:

Custom PCBs with XIAO footprint accept any compatible board
Mounting holes align across manufacturers
Basic power and I/O connections work universally
Grove and similar connector shields are largely compatible

Incompatible Elements:

Manufacturer-specific wireless protocols or libraries
Platform-specific power management
Unique features (STEMMA QT, specific sensors)
Software libraries and examples

Future of XIAO-Compatible Ecosystem

The XIAO form factor appears to be establishing itself as a de facto standard for ultra-compact development boards. As more manufacturers adopt this footprint, we can expect:

Positive Trends:

More chip varieties in compatible footprint
Specialized variants for specific applications
Third-party accessory development
Price competition benefiting users

Challenges:

Maintaining true compatibility across manufacturers
Documentation fragmentation
Quality variation in clone products
Potential confusion for beginners

Despite these challenges, the XIAO-compatible ecosystem represents an exciting development in embedded hardware—a standardized physical platform that allows chip-level flexibility. Whether you choose Seeed’s original XIAO boards, Adafruit’s QT Py variants, or alternatives from other manufacturers, you’re participating in a growing ecosystem that brings professional capabilities to hobby-friendly dimensions.

Conclusion: Your Tiny Powerhouse Awaits

The Seeeduino XIAO family represents a remarkable achievement in embedded systems design—professional-grade microcontrollers compressed into a form factor that fits on your thumbnail. From the original SAMD21 to the latest advanced wireless and industrial variants, these boards prove that size doesn’t limit capability.

What Makes XIAO Special

Standardization with Variety: The genius of the XIAO platform lies in its paradox—complete standardization of physical form, yet enormous variety in capabilities. Design your project around one board, then swap in another with different features without changing your PCB or enclosure. Start with a basic RP2040, upgrade to an ESP32S3 Sense for camera functionality, or switch to an MG24 for ultra-low power—all using the same mounting holes and basic pinout.

Complete Ecosystem: Unlike many microcontroller families, XIAO offers a comprehensive ecosystem of accessories, expansion boards, and compatible alternatives. Grove shields, battery management, displays, and sensor integration boards accelerate development from initial concept to functional prototype. When you’re ready to move to production, the standardized footprint lets you design custom carrier boards while maintaining flexibility.

Wide Performance Range: The XIAO family spans from simple learning boards to sophisticated IoT platforms:

Entry-level (SAMD21, RP2040): Perfect for learning, basic projects, reliable workhorses
Mid-range (RP2350, ESP32C3, nRF52840): Wireless connectivity, enhanced processing, great price-performance
Advanced (ESP32S3 Sense, MG24 Sense, nRF54L15, RA4M1): Edge AI, computer vision, ultra-low power, industrial reliability

Future-Proof Platform: As new microcontrollers emerge, the XIAO platform will likely expand to incorporate them. Your investment in learning the XIAO ecosystem, building accessories, and designing carrier boards remains valuable as new variants appear. The growing third-party support from Adafruit, DFRobot, and others validates the platform’s longevity.

Choosing Your XIAO Board

With 13 variants (and counting), selecting the right XIAO might seem daunting. Here’s a decision framework:

Start with These Questions:

Do you need wireless?
- No: Choose RP2040, RP2350, SAMD21, or RA4M1
- BLE only: Choose nRF52840 or nRF52840 Sense
- WiFi + BLE: Choose ESP32C3, C6, S3, or S3 Sense
- Matter/Thread: Choose MG24 or MG24 Sense
Do you need integrated sensors?
- Camera + Microphone: ESP32S3 Sense is your only option
- IMU + Microphone: nRF52840 Sense or MG24 Sense
- No sensors needed: Choose non-Sense variants
What’s your power source?
- USB-powered: Any board works well
- Battery, frequent wake: nRF52840 or MG24 offer best efficiency
- Battery, ultra-low power: MG24 or MG24 Sense excel here
What’s your priority?
- Learning/Education: SAMD21, RP2040, or ESP32C3
- Performance: RP2350 or ESP32S3
- Cost: SAMD21 or ESP32C3
- Industrial reliability: RA4M1
- Future protocols: MG24 (Matter/Thread) or ESP32C6 (WiFi 6)

Recommended Starting Points

First XIAO Board: Start with the RP2040 or RP2350. These boards offer excellent performance, ample memory, unique PIO capabilities, and are well-documented. They’re powerful enough for complex projects yet friendly for beginners.

First Wireless Board: Choose ESP32C3 for the best combination of features, documentation, and price. It brings WiFi and BLE without overwhelming complexity.

For Serious Projects: Consider the ESP32S3 or ESP32S3 Sense for maximum capability, or the MG24 for ultra-low-power wireless applications.

The Seeeduino XIAO family democratizes advanced embedded systems. Features once reserved for expensive development boards or complex designs are now accessible in a package small enough to fit anywhere. Whether you’re a student learning microcontrollers, a hobbyist building IoT devices, or a professional prototyping products, there’s a XIAO board that fits your needs.

The compact size doesn’t mean compromised capability—it means thinking differently about where embedded systems can go. Wearables, tiny robots, hidden sensors, dense arrays of interconnected devices, or countless other applications become practical when your microcontroller is the size of a postage stamp.

Start small, think big, and let the XIAO family power your next creation. The only limit is your imagination—and with 13 boards to choose from, you’ll find one that matches your vision perfectly.

Happy making, and welcome to the XIAO family!

Meet the Seeeduino XIAO Family

Tagged on: Arduino Tutorial ESP32 Tutorial

Introduction: The Smallest Arduino-Compatible Boards You’ll Ever Use

General Purpose Boards: Your Foundation for Embedded Projects

XIAO SAMD21: The Original

XIAO RP2040: The Performance Leader

XIAO RP2350: The Latest Evolution

Comparison: Which General Purpose Board Should You Choose?

Practical Example: Dual-Core Processing with XIAO RP2040

Wireless & BLE Boards: Connecting Your Projects to the World

XIAO nRF52840: Bluetooth Low Energy Pioneer

XIAO nRF52840 Sense: BLE with Integrated Sensors

XIAO ESP32C3: Affordable WiFi + BLE

XIAO ESP32C6: Next-Generation Connectivity

XIAO ESP32S3: AI and Multimedia Powerhouse

XIAO ESP32S3 Sense: Camera and Microphone Integration

Comparison: Which Wireless Board Should You Choose?

Practical Example: WiFi Web Dashboard with XIAO ESP32C3

Advanced MCU Boards: Industrial-Grade and Ultra-Low-Power Solutions

XIAO RA4M1: Renesas Reliability

XIAO MG24: Silicon Labs Matter/Thread Pioneer

XIAO MG24 Sense: Matter with Integrated Sensors

XIAO nRF54L15: Nordic’s Next Generation (Newest Addition)

Comparison: Which Advanced Board Should You Choose?

Practical Example: Motion Detection with XIAO MG24 Sense

Accessories & Prototyping Tools: Expanding the XIAO Ecosystem

Grove Shield for XIAO

XIAO Expansion Board

Battery Management Expansions

Breadboard Adapter/Breakout Boards

CAN Bus Expansion Board

Motor Driver Shields

Display Expansion Options

Sensor Expansion Boards

Custom PCB Footprint

Choosing the Right Accessories

XIAO-Compatible Boards: Alternatives and Variants

Adafruit QT Py Series

DFRobot Beetle Series

Choosing Between XIAO and Compatible Boards

Ecosystem Interoperability

Future of XIAO-Compatible Ecosystem

Conclusion: Your Tiny Powerhouse Awaits

What Makes XIAO Special

Choosing Your XIAO Board

Recommended Starting Points

Related