Build and Debug a BLE Arduino Peripheral (Nano 33 BLE)

If you want to build a BLE Arduino project without wiring up external radio modules, you need a board with a native Bluetooth Low Energy chip. In 2026, the most reliable official option is the Arduino Nano 33 BLE (featuring the Nordic nRF52840). Unlike the older Nano 33 IoT (which uses a separate WiFi/BLE coprocessor) or the Sense variant (which adds environmental sensors you might not need), the standard Nano 33 BLE gives you a pure, low-power Cortex-M4F with integrated 2.4GHz radio.

This guide walks through building a dual-characteristic BLE peripheral: it broadcasts a potentiometer reading and accepts a remote command to toggle the onboard LED. We will cover the exact hardware, provide fully compilable firmware with error handling, and detail the specific debugging steps when the radio refuses to cooperate.

Hardware Spec Sheet and Pin Mapping

Before writing firmware, verify your bill of materials. The nRF52840 is a 3.3V logic device. Feeding 5V into its I/O pins will permanently damage the silicon. The board's onboard regulator handles VIN up to 21V, but all GPIO outputs are strictly 3.3V.

Pin Mapping Table

The Firmware: Complete BLE Arduino Code

The following code uses the official ArduinoBLE library. It defines a custom 128-bit UUID service with two characteristics: one for reading the analog sensor (Notify/Read) and one for writing the LED state (Write/Read).

Target Board Variant: Arduino Nano 33 BLE. Tested on Arduino IDE 2.3.x with ArduinoBLE v1.3.7.

#include <ArduinoBLE.h>

// --- Pin Definitions ---
const int PIN_POT = A0;
const int PIN_LED = LED_BUILTIN; // Maps to Pin 13 on Nano 33 BLE

// --- 128-bit UUIDs ---
// Always use unique UUIDs for custom services to avoid OS-level caching conflicts
const char* SERVICE_UUID    = "19B10000-E8F2-537E-4F6C-D104768A1214";
const char* SENSOR_CHAR_UUID = "19B10001-E8F2-537E-4F6C-D104768A1214";
const char* LED_CHAR_UUID   = "19B10002-E8F2-537E-4F6C-D104768A1214";

// --- BLE Objects ---
BLEService fluxService(SERVICE_UUID);
BLEIntCharacteristic sensorChar(SENSOR_CHAR_UUID, BLERead | BLENotify);
BLEBoolCharacteristic ledChar(LED_CHAR_UUID, BLERead | BLEWrite);

void setup() {
  Serial.begin(115200);
  // Wait up to 3 seconds for Serial Monitor to attach
  while (!Serial && millis() < 3000); 

  pinMode(PIN_LED, OUTPUT);
  pinMode(PIN_POT, INPUT);

  // Initialize the BLE hardware
  if (!BLE.begin()) {
    Serial.println("ERROR: BLE failed to initialize!");
    while (1) { blinkError(); }
  }

  // Configure advertising parameters
  BLE.setLocalName("FluxBLE_Node01");
  BLE.setAdvertisedService(fluxService);
  
  // Attach characteristics to the service
  fluxService.addCharacteristic(sensorChar);
  fluxService.addCharacteristic(ledChar);
  BLE.addService(fluxService);

  // Set initial default values
  sensorChar.writeValue(0);
  ledChar.writeValue(false);

  // Start advertising
  if (!BLE.advertise()) {
    Serial.println("ERROR: Starting advertisement failed!");
    while (1) { blinkError(); }
  }
  
  Serial.println("BLE Peripheral is now advertising...");
}

void loop() {
  // Listen for incoming BLE connections
  BLEDevice central = BLE.central();

  if (central) {
    Serial.print("Connected to central MAC: ");
    Serial.println(central.address());

    // Stay in this loop as long as the central device remains connected
    while (central.connected()) {
      // Read sensor and update characteristic
      int potVal = analogRead(PIN_POT);
      sensorChar.writeValue(potVal);

      // Check if the central device wrote a new LED state
      if (ledChar.written()) {
        bool ledState = ledChar.value();
        digitalWrite(PIN_LED, ledState ? HIGH : LOW);
        Serial.print("LED state changed to: ");
        Serial.println(ledState);
      }
      
      delay(100); // 10Hz update rate balances responsiveness and power draw
    }
    Serial.println("Disconnected from central.");
  }
}

void blinkError() {
  digitalWrite(PIN_LED, HIGH); delay(150);
  digitalWrite(PIN_LED, LOW); delay(150);
}

Debugging: First Three Things to Check When It Fails

BLE stacks are notoriously unforgiving regarding initialization timing and memory allocation. If your board isn't showing up in the nRF Connect app, check these three failure points in order.

Extending and Simplifying the Build

To Simplify: If you only need to broadcast data (like a temperature beacon) and don't need two-way communication, strip out the ledChar and the BLE.central() polling loop. Instead, use the BLE.setAdvertisingInterval() function and rely purely on the advertisement payload. This drops the active current draw from ~4.3mA (during a connection event) down to roughly 12µA average, allowing a 200mAh LiPo coin cell to run the board for over a year.

To Extend: To add Over-The-Air (OTA) firmware updates, you must integrate the ArduinoBLE library with a custom DFU (Device Firmware Update) characteristic. The nRF52840 supports secure DFU natively, but bridging it to the Arduino environment requires partitioning the flash memory. For a simpler extension, add a BLEDescriptor to your characteristics to define the unit of measurement (e.g., "mV" or "Percentage"), which allows generic BLE apps to display your data correctly without custom coding.

Frequently Asked Questions

Can I use a standard Arduino Uno for BLE Arduino projects?

No, not natively. The classic Arduino Uno R3 (ATmega328P) lacks any wireless silicon. You can add BLE by wiring an external module like the Adafruit Bluefruit LE SPI Friend or an HM-10 UART module. However, this requires managing two separate microcontrollers, handling serial buffering, and dealing with voltage level shifting (5V to 3.3V). For new designs in 2026, buying a native BLE board like the Nano 33 BLE or an ESP32-C3 is significantly cheaper and more reliable than bolting a module onto an Uno.

Why does my BLE Arduino disconnect when I open the Serial Monitor?

This happens because opening the Serial Monitor in the Arduino IDE asserts the DTR (Data Terminal Ready) line, which triggers a hardware reset on the Nano 33 BLE. When the board resets, the BLE stack tears down, dropping the connection to your phone. To prevent this, either connect your phone after opening the Serial Monitor, or use a dedicated terminal program (like PuTTY or Tera Term) that allows you to disable DTR assertion when opening the COM port.

How do I connect a BLE Arduino to an ESP32 instead of a smartphone?

To make an ESP32 act as the "Central" device that connects to your Nano 33 BLE "Peripheral", you must use the ArduinoBLE library's Central API on the ESP32 (or the ESP32's native BLE library). You will write a separate sketch for the ESP32 that calls BLE.scanForUuid("19B10000-E8F2-537E-4F6C-D104768A1214"). Once the ESP32 discovers the Nano 33 BLE, it uses central.connect() and then queries the characteristics using the exact same UUIDs defined in the peripheral's firmware. Ensure both devices are within 3 meters during initial pairing to avoid RSSI timeout errors.