ESP32-E + MTF-02P + BE-880 Demo

This demo brings together three components to test range, motion, and position sensing for a descent payload.
We used the FireBeetle 2 ESP32-E to read both sensors over serial connections and host a live browser dashboard. We viewed the readings over its AerospacePayload Wi-Fi network at http://192.168.4.1, with updates every 250 ms and a CSV export for the recorded samples.
The MicoAir MTF-02P supplies distance and optical-flow readings. The sketch combines flow with measured range to estimate X/Y motion and reports flow quality. It also sends a MAVLink heartbeat to help the sensor in AUTO mode detect the protocol.
The Beitian BE-880 provides GPS data: latitude, longitude, altitude, ground speed, satellite count, and fix status. Together, the two sensors let the dashboard compare local range and estimated motion with GPS position and speed.
Breadboard wiring connecting the FireBeetle ESP32-E, MTF-02P sensor, and Beitian BE-880 GPS module. — Disconnected from power source
Sensor dashboard showing MTF live over MAVLink, GPS fix, range 3.080 metres, flow quality 84, and eight satellites. — Sensor readings with no movement
Demo code

Run in Arduino IDE. Written in Arduino C++, with embedded HTML, CSS, and JavaScript for the dashboard.
/*
  SMUS Aerospace Club - Descent Sensor Test
  FireBeetle 2 ESP32-E + MicoAir MTF-02P + Beitian BE-880

  This version is designed for an MTF-02P left in factory AUTO mode.
  It sends a minimal ArduPilot MAVLink heartbeat once per second so the
  MTF-02P AUTO mode has a supported flight-controller protocol to detect.
  It can read either MicoLink frames or ArduPilot MAVLink output.

  MTF-02P wiring:
    G -> GND
    V -> VCC (5 V when FireBeetle is USB powered)
    R -> GPIO17 / D10
    T -> GPIO16 / D11

  BE-880 wiring:
    GND -> GND
    VCC -> VCC
    TX  -> GPIO34 / A2

  Wi-Fi:
    SSID: AerospacePayload
    Page: http://192.168.4.1
*/

#include <WiFi.h>
#include <WebServer.h>
#include <HardwareSerial.h>
#include <math.h>
#include <string.h>

HardwareSerial MTF(2);
HardwareSerial GPS(1);

static const int MTF_RX = 16;
static const int MTF_TX = 17;
static const int GPS_RX = 34;

const char* AP_SSID = "AerospacePayload";
WebServer server(80);

struct MtfState {
  bool valid = false;
  float distanceM = NAN;
  float velXMps = NAN;
  float velYMps = NAN;
  int16_t flowRawX = 0;
  int16_t flowRawY = 0;
  float flowRateX = NAN;
  float flowRateY = NAN;
  bool haveFlowRate = false;
  String speedSource = "NONE";
  uint8_t flowQuality = 0;
  uint32_t lastFrameMs = 0;
  uint32_t bytesSeen = 0;
  uint32_t micoFrames = 0;
  uint32_t mavFrames = 0;
  uint32_t rangeFrames = 0;
  uint32_t flowFrames = 0;
  uint32_t flowRadFrames = 0;
  uint32_t heartbeatCount = 0;
  String protocol = "NONE";
} mtf;

struct GpsState {
  bool seen = false;
  bool fix = false;
  int sats = 0;
  double lat = NAN;
  double lon = NAN;
  float altitudeM = NAN;
  float speedKmh = NAN;
  uint32_t baud = 0;
  uint32_t lastMs = 0;
} gps;

uint16_t u16le(const uint8_t* p) {
  return (uint16_t)p[0] | ((uint16_t)p[1] << 8);
}

int16_t i16le(const uint8_t* p) {
  return (int16_t)u16le(p);
}

uint32_t u32le(const uint8_t* p) {
  return (uint32_t)p[0] |
         ((uint32_t)p[1] << 8) |
         ((uint32_t)p[2] << 16) |
         ((uint32_t)p[3] << 24);
}

float f32le(const uint8_t* p) {
  float f;
  uint8_t b[4] = {p[0], p[1], p[2], p[3]};
  memcpy(&f, b, 4);
  return f;
}

// ---------------- MicoLink parser ----------------
static const uint8_t MICOLINK_HEAD = 0xEF;
static const uint8_t MICOLINK_RANGE_MSG = 0x51;
static const uint8_t MAX_PAYLOAD = 64;

struct MicoParser {
  uint8_t state = 0;
  uint8_t msgId = 0;
  uint8_t len = 0;
  uint8_t payload[MAX_PAYLOAD];
  uint8_t idx = 0;
  uint8_t sum = 0;
} mp;

void decodeMicoFrame() {
  if (mp.msgId != MICOLINK_RANGE_MSG || mp.len < 20) return;

  uint32_t distanceMm = u32le(&mp.payload[4]);
  int16_t flowRawX = i16le(&mp.payload[12]);
  int16_t flowRawY = i16le(&mp.payload[14]);

  mtf.distanceM = distanceMm > 0 ? distanceMm / 1000.0f : NAN;
  mtf.flowQuality = mp.payload[16];

  if (distanceMm > 0) {
    float h = distanceMm / 1000.0f;
    mtf.velXMps = (flowRawX * h) / 100.0f;
    mtf.velYMps = (flowRawY * h) / 100.0f;
    mtf.speedSource = "MICOLINK_RAW+RANGE";
    mtf.valid = true;
  }

  mtf.lastFrameMs = millis();
  mtf.micoFrames++;
  mtf.protocol = "MICOLINK";
}

void parseMicoByte(uint8_t b) {
  switch (mp.state) {
    case 0:
      if (b == MICOLINK_HEAD) {
        mp.sum = b;
        mp.state = 1;
      }
      break;
    case 1: mp.sum += b; mp.state = 2; break; // dev id
    case 2: mp.sum += b; mp.state = 3; break; // sys id
    case 3: mp.msgId = b; mp.sum += b; mp.state = 4; break;
    case 4: mp.sum += b; mp.state = 5; break; // seq
    case 5:
      mp.len = b;
      mp.sum += b;
      mp.idx = 0;
      if (mp.len > MAX_PAYLOAD) mp.state = 0;
      else mp.state = (mp.len == 0) ? 7 : 6;
      break;
    case 6:
      mp.payload[mp.idx++] = b;
      mp.sum += b;
      if (mp.idx >= mp.len) mp.state = 7;
      break;
    case 7:
      if (mp.sum == b) decodeMicoFrame();
      mp.state = 0;
      mp.idx = 0;
      break;
    default:
      mp.state = 0;
      mp.idx = 0;
      break;
  }
}

// ---------------- MAVLink parser ----------------
// No external MAVLink library is required. We only decode the two messages
// used by MicoAir's ArduPilot mode: OPTICAL_FLOW_RAD (106) and
// DISTANCE_SENSOR (132).
struct MavParser {
  uint8_t version = 0;
  uint8_t state = 0;
  uint8_t len = 0;
  uint8_t incompat = 0;
  uint32_t msgId = 0;
  uint8_t payload[255];
  uint16_t idx = 0;
  uint8_t sigLeft = 0;
} mv;

void decodeMavFrame() {
  if (mv.msgId == 132 && mv.len >= 14) { // DISTANCE_SENSOR
    uint16_t currentCm = u16le(&mv.payload[8]);
    if (currentCm > 0) {
      mtf.distanceM = currentCm / 100.0f;
      mtf.valid = true;
    }
    mtf.lastFrameMs = millis();
    mtf.mavFrames++;
    mtf.rangeFrames++;
    mtf.protocol = "MAVLINK";
    return;
  }

  // ArduPilot-mode MicoAir sensors use MAVLink OPTICAL_FLOW (message 100).
  // The MTF-02P seen in this demo sends the base MAVLink-1 fields, so the
  // optional flow_rate_x/y extension fields are usually absent.  To make the
  // demo useful anyway, use the best speed source available in this order:
  //   1) flow_rate_x/y + range (if present)
  //   2) flow_comp_m_x/y (if populated)
  //   3) MicoAir raw flow + range estimate (same height scaling used by
  //      MicoLink: raw units are approximately cm/s at 1 m).
  if (mv.msgId == 100 && mv.len >= 26) { // OPTICAL_FLOW
    float compX = f32le(&mv.payload[8]);
    float compY = f32le(&mv.payload[12]);
    float groundDistance = f32le(&mv.payload[16]);
    int16_t rawX = i16le(&mv.payload[20]);
    int16_t rawY = i16le(&mv.payload[22]);
    uint8_t quality = mv.payload[25];

    mtf.flowRawX = rawX;
    mtf.flowRawY = rawY;
    mtf.flowQuality = quality;

    if (isfinite(groundDistance) && groundDistance > 0.0f) {
      mtf.distanceM = groundDistance;
    }

    mtf.haveFlowRate = false;
    mtf.flowRateX = NAN;
    mtf.flowRateY = NAN;
    mtf.speedSource = "NONE";

    // Best case: MAVLink 2 extension fields provide angular flow rate.
    if (mv.len >= 34) {
      float rateX = f32le(&mv.payload[26]);
      float rateY = f32le(&mv.payload[30]);
      if (isfinite(rateX) && isfinite(rateY) &&
          (fabs(rateX) > 1e-7f || fabs(rateY) > 1e-7f)) {
        mtf.flowRateX = rateX;
        mtf.flowRateY = rateY;
        mtf.haveFlowRate = true;
        if (isfinite(mtf.distanceM) && mtf.distanceM > 0.0f) {
          mtf.velXMps = rateY * mtf.distanceM;
          mtf.velYMps = -rateX * mtf.distanceM;
          mtf.speedSource = "RATE+RANGE";
        }
      }
    }

    // Some MAVLink OPTICAL_FLOW senders fill these already-compensated m/s
    // fields.  MicoAir may leave them at zero, so only prefer them when they
    // contain motion.
    if (mtf.speedSource == "NONE" && isfinite(compX) && isfinite(compY) &&
        (fabs(compX) > 1e-6f || fabs(compY) > 1e-6f)) {
      mtf.velXMps = compX;
      mtf.velYMps = compY;
      mtf.speedSource = "FLOW_COMP";
    }

    // Reliable fallback for this exact MTF-02P demo: scale the module's raw
    // flow by measured height.  At rest this intentionally reports 0.000 m/s
    // instead of '--', and while translating over a textured surface the
    // numbers change immediately.
    if (mtf.speedSource == "NONE" && isfinite(mtf.distanceM) && mtf.distanceM > 0.0f) {
      mtf.velXMps = ((float)rawX * mtf.distanceM) / 100.0f;
      mtf.velYMps = ((float)rawY * mtf.distanceM) / 100.0f;
      mtf.speedSource = "RAW+RANGE";
    }

    mtf.valid = true;
    mtf.lastFrameMs = millis();
    mtf.mavFrames++;
    mtf.flowFrames++;
    mtf.protocol = "MAVLINK";
    return;
  }

  // PX4-mode sensors may instead use OPTICAL_FLOW_RAD (message 106).
  if (mv.msgId == 106 && mv.len >= 44) { // OPTICAL_FLOW_RAD
    uint32_t integrationUs = u32le(&mv.payload[8]);
    float integratedX = f32le(&mv.payload[12]);
    float integratedY = f32le(&mv.payload[16]);
    float flowDistance = f32le(&mv.payload[36]);
    mtf.flowQuality = mv.payload[43];

    float h = (isfinite(flowDistance) && flowDistance >= 0.0f) ? flowDistance : mtf.distanceM;
    if (isfinite(h) && h > 0.0f) mtf.distanceM = h;

    if (integrationUs > 0 && isfinite(h) && h > 0.0f) {
      float dt = integrationUs / 1000000.0f;
      mtf.velXMps = (integratedY / dt) * h;
      mtf.velYMps = -(integratedX / dt) * h;
      mtf.speedSource = "FLOW_RAD+RANGE";
      mtf.valid = true;
    }

    mtf.lastFrameMs = millis();
    mtf.mavFrames++;
    mtf.flowRadFrames++;
    mtf.protocol = "MAVLINK";
    return;
  }
}

void parseMavByte(uint8_t b) {
  switch (mv.state) {
    case 0:
      if (b == 0xFE) { // MAVLink v1
        mv.version = 1;
        mv.state = 1;
        mv.msgId = 0;
        mv.idx = 0;
      } else if (b == 0xFD) { // MAVLink v2
        mv.version = 2;
        mv.state = 20;
        mv.msgId = 0;
        mv.idx = 0;
      }
      break;

    // MAVLink v1: magic, len, seq, sysid, compid, msgid, payload, crc(2)
    case 1: mv.len = b; mv.state = 2; break;
    case 2: mv.state = 3; break; // seq
    case 3: mv.state = 4; break; // sysid
    case 4: mv.state = 5; break; // compid
    case 5:
      mv.msgId = b;
      mv.idx = 0;
      mv.state = (mv.len == 0) ? 7 : 6;
      break;
    case 6:
      mv.payload[mv.idx++] = b;
      if (mv.idx >= mv.len) mv.state = 7;
      break;
    case 7: mv.state = 8; break; // crc low
    case 8:
      decodeMavFrame();
      mv.state = 0;
      break; // crc high

    // MAVLink v2: magic, len, incompat, compat, seq, sysid, compid,
    // msgid[3], payload, crc[2], optional signature[13]
    case 20: mv.len = b; mv.state = 21; break;
    case 21: mv.incompat = b; mv.state = 22; break;
    case 22: mv.state = 23; break; // compat
    case 23: mv.state = 24; break; // seq
    case 24: mv.state = 25; break; // sysid
    case 25: mv.state = 26; break; // compid
    case 26: mv.msgId = b; mv.state = 27; break;
    case 27: mv.msgId |= ((uint32_t)b << 8); mv.state = 28; break;
    case 28:
      mv.msgId |= ((uint32_t)b << 16);
      mv.idx = 0;
      mv.state = (mv.len == 0) ? 30 : 29;
      break;
    case 29:
      mv.payload[mv.idx++] = b;
      if (mv.idx >= mv.len) mv.state = 30;
      break;
    case 30: mv.state = 31; break; // crc low
    case 31:
      decodeMavFrame();
      if (mv.incompat & 0x01) {
        mv.sigLeft = 13;
        mv.state = 32;
      } else {
        mv.state = 0;
      }
      break;
    case 32:
      if (mv.sigLeft > 0) mv.sigLeft--;
      if (mv.sigLeft == 0) mv.state = 0;
      break;
    default:
      mv.state = 0;
      break;
  }
}

// ---------------- ArduPilot heartbeat for MTF AUTO mode ----------------
uint16_t crcAccumulate(uint8_t data, uint16_t crc) {
  uint8_t tmp = data ^ (uint8_t)(crc & 0xFF);
  tmp ^= (tmp << 4);
  return (crc >> 8) ^ ((uint16_t)tmp << 8) ^ ((uint16_t)tmp << 3) ^ ((uint16_t)tmp >> 4);
}

void sendArduPilotHeartbeat() {
  static uint8_t seq = 0;
  uint8_t payload[9] = {
    0, 0, 0, 0, // custom_mode
    2,          // MAV_TYPE_QUADROTOR
    3,          // MAV_AUTOPILOT_ARDUPILOTMEGA
    0,          // base_mode
    4,          // MAV_STATE_ACTIVE
    3           // mavlink_version
  };

  uint8_t header[5] = {9, seq++, 1, 1, 0};
  uint16_t crc = 0xFFFF;
  for (int i = 0; i < 5; i++) crc = crcAccumulate(header[i], crc);
  for (int i = 0; i < 9; i++) crc = crcAccumulate(payload[i], crc);
  crc = crcAccumulate(50, crc); // HEARTBEAT CRC extra

  MTF.write((uint8_t)0xFE);
  MTF.write(header, sizeof(header));
  MTF.write(payload, sizeof(payload));
  MTF.write((uint8_t)(crc & 0xFF));
  MTF.write((uint8_t)(crc >> 8));
  mtf.heartbeatCount++;
}

// ---------------- GPS / NMEA ----------------
char nmeaLine[128];
size_t nmeaPos = 0;

int hexNibble(char c) {
  if (c >= '0' && c <= '9') return c - '0';
  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
  if (c >= 'a' && c <= 'f') return c - 'a' + 10;
  return -1;
}

bool validNmeaChecksum(const char* s) {
  if (!s || s[0] != '$') return false;
  const char* star = strchr(s, '*');
  if (!star || !star[1] || !star[2]) return false;
  uint8_t sum = 0;
  for (const char* p = s + 1; p < star; ++p) sum ^= (uint8_t)(*p);
  int hi = hexNibble(star[1]);
  int lo = hexNibble(star[2]);
  if (hi < 0 || lo < 0) return false;
  return sum == (uint8_t)((hi << 4) | lo);
}

double nmeaCoordToDecimal(const char* v, const char* hemi) {
  if (!v || !*v || !hemi || !*hemi) return NAN;
  double raw = atof(v);
  int degrees = (int)(raw / 100.0);
  double minutes = raw - degrees * 100.0;
  double out = degrees + minutes / 60.0;
  if (hemi[0] == 'S' || hemi[0] == 'W') out = -out;
  return out;
}

int splitCsv(char* line, char* fields[], int maxFields) {
  int n = 0;
  char* p = line;
  fields[n++] = p;
  while (*p && n < maxFields) {
    if (*p == ',') {
      *p = '\0';
      fields[n++] = p + 1;
    } else if (*p == '*') {
      *p = '\0';
      break;
    }
    ++p;
  }
  return n;
}

void parseNmeaLine(char* line) {
  if (!validNmeaChecksum(line)) return;
  gps.seen = true;
  gps.lastMs = millis();

  char* fields[24];
  int n = splitCsv(line, fields, 24);
  if (n < 2) return;

  const char* type = fields[0];
  bool isGGA = strstr(type, "GGA") != nullptr;
  bool isRMC = strstr(type, "RMC") != nullptr;

  if (isGGA && n > 9) {
    gps.fix = atoi(fields[6]) > 0;
    gps.sats = atoi(fields[7]);
    if (fields[2][0] && fields[3][0]) gps.lat = nmeaCoordToDecimal(fields[2], fields[3]);
    if (fields[4][0] && fields[5][0]) gps.lon = nmeaCoordToDecimal(fields[4], fields[5]);
    if (fields[9][0]) gps.altitudeM = atof(fields[9]);
  }

  if (isRMC && n > 7) {
    if (fields[2][0]) gps.fix = fields[2][0] == 'A';
    if (fields[3][0] && fields[4][0]) gps.lat = nmeaCoordToDecimal(fields[3], fields[4]);
    if (fields[5][0] && fields[6][0]) gps.lon = nmeaCoordToDecimal(fields[5], fields[6]);
    if (fields[7][0]) gps.speedKmh = atof(fields[7]) * 1.852f;
  }
}

void parseGpsByte(char b) {
  if (b == '\r') return;
  if (b == '\n') {
    if (nmeaPos > 6) {
      nmeaLine[nmeaPos] = '\0';
      parseNmeaLine(nmeaLine);
    }
    nmeaPos = 0;
    return;
  }
  if (nmeaPos < sizeof(nmeaLine) - 1) nmeaLine[nmeaPos++] = b;
  else nmeaPos = 0;
}

bool sniffGpsAtBaud(uint32_t baud, uint32_t durationMs) {
  GPS.end();
  delay(50);
  GPS.begin(baud, SERIAL_8N1, GPS_RX, -1);
  uint32_t start = millis();
  int dollar = 0;
  int goodChars = 0;
  while (millis() - start < durationMs) {
    while (GPS.available()) {
      char c = (char)GPS.read();
      if (c == '$') dollar++;
      if ((c >= 32 && c <= 126) || c == '\r' || c == '\n') goodChars++;
      parseGpsByte(c);
    }
    if (dollar >= 2 && goodChars > 50) {
      gps.baud = baud;
      return true;
    }
    delay(1);
  }
  return false;
}

void detectGpsBaud() {
  const uint32_t bauds[] = {38400, 9600, 115200};
  for (uint32_t b : bauds) {
    nmeaPos = 0;
    if (sniffGpsAtBaud(b, 1800)) return;
  }
  GPS.end();
  GPS.begin(38400, SERIAL_8N1, GPS_RX, -1);
  gps.baud = 38400;
}

// ---------------- Basic web page ----------------
const char INDEX_HTML[] PROGMEM = R"HTML(
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>Sensor Test</title>
<style>
body{font-family:Arial,sans-serif;max-width:560px;margin:36px auto;padding:0 16px;color:#111;background:white}
h1{font-size:20px;margin:0 0 4px}p{font-size:13px;color:#666;margin:0 0 24px}
.status{font-family:monospace;font-size:14px;margin:7px 0}
table{width:100%;border-collapse:collapse;margin-top:22px}td{padding:8px 0;border-bottom:1px solid #ddd;font-size:14px}td:last-child{text-align:right;font-family:monospace}
button{margin-top:20px;background:white;border:1px solid #111;padding:7px 10px}.debug{font:12px monospace;color:#666;margin-top:12px;line-height:1.5}
</style>
</head>
<body>
<h1>Sensor Test</h1>
<p>MTF-02P and GPS</p>
<div class="status" id="mtf">MTF: STARTING</div>
<div class="status" id="gps">GPS: STARTING</div>
<table>
<tr><td>Range</td><td><span id="range">--</span> m</td></tr>
<tr><td>Flow X (raw)</td><td id="rawx">0</td></tr>
<tr><td>Flow Y (raw)</td><td id="rawy">0</td></tr>
<tr><td>Estimated X speed</td><td><span id="vx">--</span> m/s</td></tr>
<tr><td>Estimated Y speed</td><td><span id="vy">--</span> m/s</td></tr>
<tr><td>Flow quality</td><td id="q">0</td></tr>
<tr><td>Satellites</td><td id="sats">0</td></tr>
<tr><td>GPS speed</td><td><span id="spd">--</span> km/h</td></tr>
<tr><td>GPS altitude</td><td><span id="alt">--</span> m</td></tr>
<tr><td>Latitude</td><td id="lat">--</td></tr>
<tr><td>Longitude</td><td id="lon">--</td></tr>
</table>
<button onclick="downloadCsv()">Download CSV</button>
<div class="debug" id="debug"></div>
<script>
const hist=[];
function fmt(v,n){return v===null?'--':Number(v).toFixed(n)}
async function tick(){
 try{
  const r=await fetch('/data',{cache:'no-store'}); const d=await r.json();
  let m='MTF: WAITING FOR AUTO MODE';
  if(d.mtf_age_ms<1200)m='MTF: LIVE ('+d.mtf_protocol+')';
  else if(d.mtf_bytes>0)m='MTF: BYTES RECEIVED, NO VALID FRAMES';
  document.getElementById('mtf').textContent=m;
  document.getElementById('gps').textContent='GPS: '+(d.gps_fix?'FIX':(d.gps_age_ms<3000?'DATA, NO FIX':'WAITING'));
  document.getElementById('range').textContent=fmt(d.range_m,3);
  document.getElementById('rawx').textContent=d.flow_raw_x;
  document.getElementById('rawy').textContent=d.flow_raw_y;
  document.getElementById('vx').textContent=fmt(d.vx,3);
  document.getElementById('vy').textContent=fmt(d.vy,3);
  document.getElementById('q').textContent=d.flow_q;
  document.getElementById('sats').textContent=d.sats;
  document.getElementById('spd').textContent=fmt(d.speed_kmh,2);
  document.getElementById('alt').textContent=fmt(d.alt_m,1);
  document.getElementById('lat').textContent=d.lat===null?'--':Number(d.lat).toFixed(6);
  document.getElementById('lon').textContent=d.lon===null?'--':Number(d.lon).toFixed(6);
  document.getElementById('debug').textContent='MTF bytes: '+d.mtf_bytes+' | range frames: '+d.range_frames+' | flow frames: '+d.flow_frames+' | flow-rad frames: '+d.flow_rad_frames+' | speed: '+d.speed_source+' | rate fields: '+((d.flow_rate_x!==null||d.flow_rate_y!==null)?'yes':'no')+' | AP heartbeats: '+d.heartbeats+' | GPS baud: '+d.gps_baud;
  hist.push([d.ms,d.range_m,d.flow_raw_x,d.flow_raw_y,d.flow_rate_x,d.flow_rate_y,d.vx,d.vy,d.flow_q,d.speed_source,d.gps_fix,d.sats,d.lat,d.lon,d.speed_kmh,d.alt_m,d.mtf_protocol]);
  if(hist.length>18000)hist.shift();
 }catch(e){}
}
function downloadCsv(){
 const rows=[['esp_ms','range_m','flow_raw_x','flow_raw_y','flow_rate_x_rad_s','flow_rate_y_rad_s','estimated_x_speed_m_s','estimated_y_speed_m_s','flow_quality','speed_source','gps_fix','satellites','latitude','longitude','gps_speed_kmh','gps_altitude_m','mtf_protocol'],...hist];
 const csv=rows.map(r=>r.join(',')).join('\n');
 const blob=new Blob([csv],{type:'text/csv'}); const u=URL.createObjectURL(blob); const a=document.createElement('a'); a.href=u; a.download='sensor_test.csv'; a.click(); setTimeout(()=>URL.revokeObjectURL(u),1000);
}
setInterval(tick,250);tick();
</script>
</body>
</html>
)HTML";

String jsonNum(double v, int decimals) {
  if (isnan(v) || isinf(v)) return "null";
  return String(v, decimals);
}

void handleData() {
  uint32_t now = millis();
  uint32_t mtfAge = mtf.lastFrameMs ? now - mtf.lastFrameMs : 9999999;
  uint32_t gpsAge = gps.lastMs ? now - gps.lastMs : 9999999;

  String s;
  s.reserve(650);
  s += "{\"ms\":" + String(now);
  s += ",\"range_m\":" + jsonNum(mtf.distanceM, 4);
  s += ",\"flow_raw_x\":" + String(mtf.flowRawX);
  s += ",\"flow_raw_y\":" + String(mtf.flowRawY);
  s += ",\"flow_rate_x\":" + jsonNum(mtf.flowRateX, 6);
  s += ",\"flow_rate_y\":" + jsonNum(mtf.flowRateY, 6);
  s += ",\"vx\":" + jsonNum(mtf.velXMps, 4);
  s += ",\"vy\":" + jsonNum(mtf.velYMps, 4);
  s += ",\"flow_q\":" + String(mtf.flowQuality);
  s += ",\"speed_source\":\"" + mtf.speedSource + "\"";
  s += ",\"mtf_age_ms\":" + String(mtfAge);
  s += ",\"mtf_bytes\":" + String(mtf.bytesSeen);
  s += ",\"mico_frames\":" + String(mtf.micoFrames);
  s += ",\"mav_frames\":" + String(mtf.mavFrames);
  s += ",\"range_frames\":" + String(mtf.rangeFrames);
  s += ",\"flow_frames\":" + String(mtf.flowFrames);
  s += ",\"flow_rad_frames\":" + String(mtf.flowRadFrames);
  s += ",\"heartbeats\":" + String(mtf.heartbeatCount);
  s += ",\"mtf_protocol\":\"" + mtf.protocol + "\"";
  s += ",\"gps_fix\":" + String(gps.fix ? "true" : "false");
  s += ",\"sats\":" + String(gps.sats);
  s += ",\"lat\":" + jsonNum(gps.lat, 7);
  s += ",\"lon\":" + jsonNum(gps.lon, 7);
  s += ",\"speed_kmh\":" + jsonNum(gps.speedKmh, 3);
  s += ",\"alt_m\":" + jsonNum(gps.altitudeM, 2);
  s += ",\"gps_baud\":" + String(gps.baud);
  s += ",\"gps_age_ms\":" + String(gpsAge) + "}";
  server.send(200, "application/json", s);
}

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

  MTF.begin(115200, SERIAL_8N1, MTF_RX, MTF_TX);
  detectGpsBaud();

  WiFi.mode(WIFI_AP);
  WiFi.softAP(AP_SSID);
  server.on("/", [](){ server.send_P(200, "text/html; charset=utf-8", INDEX_HTML); });
  server.on("/data", handleData);
  server.begin();

  Serial.println("AerospacePayload ready");
  Serial.println(WiFi.softAPIP());
}

void loop() {
  static uint32_t lastHeartbeat = 0;
  uint32_t now = millis();
  if (now - lastHeartbeat >= 1000) {
    lastHeartbeat = now;
    sendArduPilotHeartbeat();
  }

  while (MTF.available()) {
    uint8_t b = (uint8_t)MTF.read();
    mtf.bytesSeen++;
    parseMicoByte(b);
    parseMavByte(b);
  }

  while (GPS.available()) parseGpsByte((char)GPS.read());
  server.handleClient();
}
ESP32-E + MTF-02P + BE-880 Demo

Circuit

Sensor Data

Demo code
