BLE is a wireless communication protocol designed for short-range, low-power applications. Unlike classic Bluetooth, BLE consumes significantly less power while maintaining reliable data transmission, making it ideal for battery-powered IoT devices.

Central vs Peripheral Roles

Both XIAO boards use the same pin layout. The nRF52840 chip handles all BLE communication internally — no additional hardware required beyond the microcontroller.

Function: Advertises a BLE service with a readable characteristic. When the Central connects, it reads this characteristic to receive data from the Peripheral.

#include <ArduinoBLE.h>

BLEService sensorService("180C");
BLEStringCharacteristic sensorLevel("2A56", BLERead | BLENotify, 20);

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);
  
  if (!BLE.begin()) {
    Serial.println("BLE failed!");
    while (1);
  }
  
  BLE.setLocalName("XIAO_Peripheral");
  BLE.setAdvertisedService(sensorService);
  sensorService.addCharacteristic(sensorLevel);
  BLE.addService(sensorService);
  sensorLevel.writeValue("Ready");
  
  BLE.advertise();
  Serial.println("Peripheral started, advertising...");
}

void loop() {
  BLEDevice central = BLE.central();
  
  if (central) {
    digitalWrite(LED_BUILTIN, HIGH);
    Serial.print("Connected to: ");
    Serial.println(central.address());
    
    while (central.connected()) {
      int sensorValue = random(0, 100);
      String dataStr = "Value: " + String(sensorValue);
      sensorLevel.writeValue(dataStr);
      Serial.println(dataStr);
      delay(1000);
    }
    
    digitalWrite(LED_BUILTIN, LOW);
    Serial.println("Disconnected");
  }
}

Function: Scans for BLE devices, discovers the Peripheral, establishes connection, and continuously reads characteristic data.

#include <ArduinoBLE.h>

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);
  
  if (!BLE.begin()) {
    Serial.println("BLE failed!");
    while (1);
  }
  
  BLE.setLocalName("XIAO_Central");
  BLE.advertise();
  Serial.println("Central started, scanning...");
  BLE.scanForUuid("180C");
}

void loop() {
  BLEDevice peripheral = BLE.available();
  
  if (peripheral) {
    if (peripheral.localName() == "XIAO_Peripheral") {
      BLE.stopScan();
      Serial.println("Found Peripheral!");
      
      if (peripheral.connect()) {
        digitalWrite(LED_BUILTIN, HIGH);
        Serial.println("Connected!");
        
        if (peripheral.discoverAttributes()) {
          BLECharacteristic sensorLevel = peripheral.characteristic("2A56");
          
          while (peripheral.connected()) {
            if (sensorLevel) {
              String value = sensorLevel.value();
              Serial.print("Received: ");
              Serial.println(value);
            }
            delay(1000);
          }
        }
      }
      
      digitalWrite(LED_BUILTIN, LOW);
      Serial.println("Disconnected, scanning again...");
      BLE.scanForUuid("180C");
    }
  }
}

XIAO #1 (Peripheral) starts broadcasting its presence and available service (UUID 180C) on BLE advertising channels.

XIAO #2 (Central) scans for devices advertising service 180C. When it detects the Peripheral, it stops scanning and prepares to connect.

Central initiates connection. After handshake completes, the two devices are paired and secure channel is established.

Central queries Peripheral for available services and characteristics. Discovers service 180C and characteristic 2A56.

Central reads characteristic 2A56 repeatedly (every 1 second). Peripheral sends sensor data. Both serial monitors display successful communication.

Individual Assignment: Distributed control system combining XIAO nRF52840 (Brain) with Raspberry Pi Pico 2W (Worker) for coordinated sensor, display, and motor control via UART.

System Architecture: Brain + Worker

🧠 The Brain (XIAO nRF52840): Decision-making unit with OLED display. Monitors button input, displays alerts, and sends commands to Worker via UART.

⚙️ The Worker (Raspberry Pi Pico 2W): Execution unit with sensors and motor control. Reads distance sensor (HC-SR04), listens for commands via UART, and controls motor speed via DRV8833 driver.

Why UART Instead of I2C?

Initial plan was I2C for inter-board communication, but the Pico had only one I2C pair (SDA/SCL), and the OLED display already claimed those pins. Switching to UART (TX/RX) freed up I2C for the display. Key lesson: design communication headers first, populate components second.

Distributed system architecture: XIAO Brain coordinating Pico Worker via UART communication

Motor Control Challenge: Why GPIO Alone Fails

The Problem: Motor wouldn't spin when controlled by GPIO pins because they can only source ~20mA, but motor requires 200+mA. Without sufficient current, motor stalls silently.

The Solution: DRV8833 Motor Driver acts as power amplifier, taking 3.3V control signal and switching 5V–12V to motor, delivering 200+mA needed.

What I Learned: Five Key Insights

5. Pragmatism Over Perfection: HC-SR04 rated 5V, but ran at 3.3V to avoid voltage dividers. Range dropped to ~1 meter, wiring stayed clean. Working "sub-spec" system beats stuck-in-planning "perfect" one.

Hardware Integration Process: Two XIAO nRF52840 boards with proper power and communication wiring. Both boards feature the Seeed Studio nRF52840 SoC with integrated BLE antenna.

PCB Layout & Pinout

Left: XIAO nRF52840 pinout with GPIO assignments. Right: Seeed IoT device (XIAO expansion) showing proper connection points. Blue and Green wires indicate power/data lines between boards.

Real Hardware Implementation

Physical setup: Left board (Central) connected to right board (Peripheral) with color-coded wires. Blue wire = power/signal, Green wire = data, Yellow wire = additional control/ground lines.