Building a UAV Arduino Telemetry Node: Nano ESP32 & BNO085 AHRS

To build a reliable UAV Arduino telemetry and Attitude Heading Reference System (AHRS) node in 2026, use the Arduino Nano ESP32 paired with a CEVA BNO085 (or BNO086) sensor fusion IMU and a BMP388 barometer. This specific combination gives you a 240MHz dual-core ESP32-S3 processor for MAVLink parsing and hardware-level quaternion math, bypassing the heavy CPU load and drift issues associated with raw sensor filtering on older 8-bit boards.

While hobbyists often try to strap an Arduino Uno and an MPU6050 to a quadcopter, the vibration noise and I2C bus contention will crash your flight loop. The Nano ESP32 solves this with hardware floating-point units and robust I2C clock stretching, making it the gold standard for custom secondary flight computers and dataloggers.

Selecting the Right IMU for UAV Arduino Builds

The biggest mistake in custom UAV builds is choosing an IMU that requires the microcontroller to run a Mahony or Madgwick filter in software. By offloading sensor fusion to the IMU's internal coprocessor, your Arduino loop stays free to handle telemetry routing and failsafes. Here is how the top UAV-grade sensors compare for custom Arduino builds.

Hardware BOM and Pin Mapping

This build targets the Arduino Nano ESP32 (specifically the board with the ESP32-S3 chip). Do not confuse this with the older Nano 33 BLE Sense; the Nano ESP32 offers vastly superior UART buffers and Wi-Fi/BLE capabilities for ground station telemetry.

Parts List

• MCU: Arduino Nano ESP32 (Board variant: Arduino Nano ESP32 in Arduino IDE)
• IMU: Adafruit BNO085 9-DOF IMU (Product ID: 4754)
• Barometer: Adafruit BMP388 Precision Barometer (Product ID: 3966)
• Passives: 100µF Tantalum Capacitor (for 3.3V rail brownout protection), 4.7kΩ I2C pull-up resistors (if not populated on carrier boards).

Pin Mapping Table

The Nano ESP32 allows GPIO matrix routing, but the Arduino core defaults A4 and A5 to the primary I2C bus. We use digital pins for the BNO085 interrupt and reset lines to keep the I2C bus clear during sensor fusion resets.

Compilable AHRS and Telemetry Code

The following C++ code is fully compilable in the Arduino IDE (2.x or 3.x). It initializes the I2C bus at 400kHz, configures the BNO085 to output Game Rotation Vectors, and reads the BMP388 for barometric altitude. The output is formatted as CSV, which can be immediately parsed by the Arduino Serial Plotter or a custom Python ground station script.

Required Libraries (install via Library Manager): Adafruit BNO08x, Adafruit BMP3XX, Adafruit Unified Sensor.

#include <Wire.h>
#include <Adafruit_BNO08x.h>
#include <Adafruit_BMP3XX.h>

// Pin Definitions for Arduino Nano ESP32
#define BNO_INT_PIN 2
#define BNO_RST_PIN 3
#define SEALEVELPRESSURE_HPA (1013.25)

Adafruit_BNO08x bno08x(BNO_RST_PIN);
sh2_SensorValue_t sensorValue;
Adafruit_BMP3XX bmp;

void setup() {
  Serial.begin(115200);
  while (!Serial) delay(10);
  Serial.println("UAV Arduino Nano ESP32 AHRS Node Booting...");

  // Initialize I2C on default Nano ESP32 pins and set Fast Mode
  Wire.begin(A4, A5);
  Wire.setClock(400000);

  // Initialize BNO085
  if (!bno08x.begin_I2C(BNO08X_I2CADDR_DEFAULT, &Wire, BNO_INT_PIN)) {
    Serial.println("ERROR: Failed to find BNO08x chip");
    while (1) { delay(10); }
  }
  Serial.println("BNO08x Found. Configuring reports...");
  setReports();

  // Initialize BMP388
  if (!bmp.begin_I2C(BMP388_I2CADDR_PRIM, &Wire)) {
    Serial.println("ERROR: Could not find a valid BMP388 sensor");
    while (1) { delay(10); }
  }
  Serial.println("BMP388 Found.");

  // Configure BMP388 oversampling for UAV vibration environments
  bmp.setTemperatureOversampling(BMP3_OVERSAMPLING_8X);
  bmp.setPressureOversampling(BMP3_OVERSAMPLING_4X);
  bmp.setIIRFilterCoeff(BMP3_IIR_FILTER_COEFF_3);
  bmp.setOutputDataRate(BMP3_ODR_50_HZ);

  // CSV Header for Ground Station / Serial Plotter
  Serial.println("Millis, Qw, Qx, Qy, Qz, Pressure_hPa, Altitude_m");
}

void setReports() {
  // Request Game Rotation Vector every 10,000 microseconds (100Hz)
  if (!bno08x.enableReport(SH2_GAME_ROTATION_VECTOR, 10000)) {
    Serial.println("Warning: Could not enable game rotation vector");
  }
}

void loop() {
  // Handle unexpected IMU resets (common under heavy EMI)
  if (bno08x.wasReset()) {
    Serial.println("BNO08x was reset by hardware fault");
    setReports();
  }

  // Read IMU Quaternion Data
  if (bno08x.getSensorEvent(&sensorValue)) {
    if (sensorValue.sensor.id == SH2_GAME_ROTATION_VECTOR) {
      float qw = sensorValue.un.gameRotationVector.real;
      float qx = sensorValue.un.gameRotationVector.i;
      float qy = sensorValue.un.gameRotationVector.j;
      float qz = sensorValue.un.gameRotationVector.k;

      // Read Barometer Data
      if (!bmp.performReading()) {
        Serial.println("BMP388 read fail");
        return;
      }
      float alt = bmp.readAltitude(SEALEVELPRESSURE_HPA);

      // Output CSV Telemetry
      Serial.print(millis()); Serial.print(",");
      Serial.print(qw, 4); Serial.print(",");
      Serial.print(qx, 4); Serial.print(",");
      Serial.print(qy, 4); Serial.print(",");
      Serial.print(qz, 4); Serial.print(",");
      Serial.print(bmp.pressure / 100.0, 2); Serial.print(",");
      Serial.println(alt, 2);
    }
  }
  delay(10); // Yield to ESP32 RTOS background tasks
}

Debugging: First Three Things to Check When It Fails

When integrating this node into a carbon-fiber UAV frame, you will inevitably hit hardware faults. Here is the exact decision path for the most common failure modes.

1. Serial Monitor outputs: ERROR: Failed to find BNO08x chip

• Cause A (Most Likely): I2C pull-up resistors are missing or insufficient. The Nano ESP32's internal pull-ups are too weak for the BNO085's capacitance at 400kHz.
• Fix: Solder 4.7kΩ resistors between the SDA/SCL lines and the 3.3V rail. If using an Adafruit breakout, verify the jumper pads on the back are closed.
• Cause B: GPIO matrix routing mismatch. The ESP32-S3 allows any pin to be I2C, but the Arduino core expects A4/A5.
• Fix: Ensure your Wire.begin(A4, A5) call matches the physical wires. Do not use raw ESP-IDF GPIO numbers (like GPIO11) in the Arduino Wire library.

2. Serial Monitor outputs: ERROR: Could not find a valid BMP388 sensor

• Cause A: I2C Address conflict. The BMP388 defaults to 0x77, but if the SDO pin is floating, it may latch to 0x76.
• Fix: Explicitly tie the BMP388 SDO pin to GND to force address 0x77 (BMP388_I2CADDR_PRIM).
• Cause B: 3.3V Rail Brownout. The BNO085 spikes to ~130mA during its initial sensor fusion calibration. If your drone's BEC (Battery Eliminator Circuit) is undersized, the voltage dips, and the BMP388 drops off the bus.
• Fix: Add a 100µF Tantalum capacitor directly across the 3V3 and GND pins on the Nano ESP32 header.

3. Symptom: Yaw Drift or NaN Quaternion Values in Flight

• Cause: High-frequency BLDC motor vibration is aliasing into the IMU's accelerometer, confusing the sensor fusion algorithm. This is especially prevalent on rigid carbon fiber frames without dampening.
• Fix: Mount the BNO085 breakout board using Sorbothane dampening pads or double-sided foam tape. In code, ensure you are using the SH2_GAME_ROTATION_VECTOR (which ignores the magnetometer) rather than the standard SH2_ROTATION_VECTOR, as magnetic noise from ESCs will cause violent yaw snaps.

Extending and Simplifying the Build

Depending on your UAV platform, you may need to scale this telemetry node up or down.

How to Extend: Adding MAVLink over UART

To feed this data directly into a primary flight controller or a ground station like QGroundControl, you can extend the code to parse and transmit MAVLink packets. 1. Wire the Nano ESP32's D0 (RX) and D1 (TX) to your primary FC's Telemetry port. 2. Import the mavlink C header library into your Arduino sketch. 3. Map the BNO085 quaternions to the MAVLINK_MSG_ID_ATTITUDE_QUATERNION message and the BMP388 altitude to MAVLINK_MSG_ID_SCALED_PRESSURE. 4. Use Serial1 (Hardware UART 1) on the ESP32 to transmit at 57600 baud, keeping the USB Serial free for local debugging.

How to Simplify: Indoor / Micro-Drone Builds

If you are building an indoor micro-drone or a racing quad where barometric altitude is irrelevant (and prop-wash would corrupt the BMP388 anyway), drop the BMP388 entirely. This reduces I2C bus capacitance, frees up 4KB of flash memory, and removes the bmp.performReading() blocking call from your loop, allowing you to push the BNO085 polling rate closer to its 400Hz maximum for ultra-low latency FPV acrobatics.