The Receipts

This Hardware Really Received This.

A radio mesh is easy to describe and hard to prove. So before any tour of boards and protocols, here is the physical evidence: measurements this hardware actually made, logged by the receiver at the moment they happened.

205 Real Radio Frames, Caught Out of the Air

Live database querying confirms 205 radio frames received by an SX1302 gateway from OMEGA nodes, logging physical RF metrics of RSSI -89 to -31 dBm (avg -38.7) and SNR -15 to +12.5 dB (avg +9.2). RSSI is the raw strength of each incoming signal; SNR is how far it stood above the background noise. The receiver logged every one of these straight off the radio as the frame landed.

Histogram of RSSI for real LoRa frames

A $50 Barometer Resolved a Planet-Scale Tide

A $50 bench barometer logged 104,939 pressure readings. The Welch power spectrum below (a standard technique for finding repeating rhythms in noisy data) shows a sharp line at 11.99 hours standing ~580,000x above the noise floor. That is the S2 semidiurnal atmospheric tide (the whole atmosphere's twice-a-day rise and fall in pressure), resolved from scratch by OMEGA's own hardware without any external data.

Atmospheric tide spectrum from OMEGA barometer
The Fleet

One Fleet, All Off-the-Shelf Parts

OMEGA builds on off-the-shelf parts anyone can buy: the same ESP32 microcontrollers and LoRa radio boards hobbyists use (the T-Beam Supreme on an ESP32; the T3-S3 relay and the gateway on the newer ESP32-S3). Custom circuit boards would have been slow and expensive. The whole fleet runs one shared C++ firmware, so a fix written once works everywhere. Three roles do all the work:

Shore Gateway

T-ETH-ELITE

The DTO v3.0 master ingestion point. A LilyGo T-ETH-ELITE baseboard stacked with a T-SX1302 8-channel concentrator shield. It runs with no screen attached and listens on all 8 LoRa channels at once, catching bursts of readings as they arrive and forwarding them over Ethernet to the central software that gathers the fleet's data.

Sensor Node

T-Beam Supreme

The standard marine sensing edge node. It pairs an ESP32 with a Semtech SX1262 LoRa transceiver and an ultra-low-power u-blox MAX-M10S GNSS module. Capable of +22dBm output, it gathers localized environmental data and runs on a solar-charged 18650 cell (~60 mA average draw); deep-sleep duty-cycling to stretch runtime is on the roadmap.

Mesh Relay

T3-S3 LR1121

A sensor-less mesh router deployed on high-elevation coastal structures or moored buoys. It operates across multiple frequency bands (Sub-GHz and 2.4 GHz LoRa), bridging disconnected sensor clusters and moving batches of held-up readings to the nearest gateway in one efficient transfer.

How It Works

How a Reading Travels.

Follow one reading from the water to the shore database. Six steps, each shaped by a real constraint (of the ocean, of the battery, or of radio law).

1. Sample. A sensor node gathers localized environmental data: say, a temperature reading every 3 seconds. Sent naively as one packet per reading over a low-bandwidth LoRa link, that stream would drown in its own packet headers: runaway overhead, regulatory duty-cycle violations (the law caps how long a radio may occupy the air), and heavy battery drain.

2. Shrink it: send only the change. Ocean readings drift slowly; the temperature a few seconds from now is very close to the last one. So the node collects a batch of readings, sends the first one in full, then sends only the tiny difference from each reading to the next (a few bits each instead of a full 32). The gateway adds the differences back up to rebuild the exact original series: nothing lost, but far fewer bytes over the air. (How the encoder works, below.)

3. Listen before transmitting. Before the node fires anything, it listens to make sure the channel is clear, the same "wait for a gap" courtesy your Wi-Fi uses. (How that works in silicon, below.)

4. If the air is jammed, store and wait. Buoys drift into RF dead zones, pass behind large swells, or suffer atmospheric interference. Blindly transmitting into a network blackout loses the data permanently. So no reading is ever lost: when the node detects a failed transmission (via missing LoRaWAN ACKs [acknowledgment replies] or CSMA-CA channel jamming), the Phase 2 firmware writes the compressed reading to its on-board SD card buffer and holds on. The node can survive offline for weeks, quietly accumulating environmental history.

5. Bulk transfer ashore. Once a connection to the mesh is re-established (proven by receiving a network heartbeat from a passing LR1121 relay or the T-ETH-ELITE), the node automatically flushes its SD-card buffer, sequentially replaying its queue and reconstructing the historical timeline within the Federated Data Broker, the central database on shore.

6. Two formats, one meaning. Over the air the reading rides in a dense 84-byte binary frame; the moment it reaches the gateway, it is translated into a standard, self-describing envelope the rest of the world can read. (The dual-layer protocol, below.)

The Hard Problems

The Fights That Shaped the Hardware.

The pipeline above reads clean. Getting there wasn't. Each of these was hit for real (at the bench, in the power budget, or in the airtime rules), and each comes with the fix that shipped.

The "Transmits but Never Receives" Bug

The problem: during the bring-up of the LR1121 relay node, it would transmit perfectly but receive absolutely nothing. The RX interrupt count was zero. The fix: I mapped the full RX-chain IRQ set: the chip's interrupt signals for preamble/sync/header/CRC. Zero partials localized the failure to the state machine, not the RF frontend. Root cause: RadioLib's startReceive() only arms continuous RX cleanly from STANDBY. Fixing it required a single line (radio.standby() before arming), and RX went from 0% to 100%. Read the full journal →

Two Chip Families, Total Silence

The problem: the hard part sat in the firmware, getting two different radio chips to understand each other. The sensor buoys use one LoRa chip (Semtech's SX1262) and the relays use a newer one (the LR1121). They ought to be compatible, but each ships with slightly different default settings, and any mismatch means total silence. The fix: the firmware manually settles sync-word mismatches (enforcing the 0x34 public sync), explicitly declares the bandwidth and spreading-factor settings that libraries usually abstract away, and implements aggressive polling-based RX with full-chain IRQ mapping. That allowed concurrent sensing, relaying, and USB-forwarding across completely different chipset architectures.

Living Within a Power Budget

The problem: a remote sensor floating in the ocean cannot plug into a wall outlet. It must budget its own power. Where it stands: the documented power budget is roughly 60 mA average draw, which works out to on the order of 50 hours of runtime on a single 18650 lithium cell before recharge. Battery voltage is sampled by the on-board ADC and reported in the telemetry stream, so operators can watch each node's state of charge from shore rather than guessing. Roadmap Deep-sleep cycling between transmission windows and dynamic, battery-aware sample-rate scaling are designed as future work to stretch the budget beyond the current ~50 h figure. They are not yet shipped; today the only MOSFET on the board drives the cooling fan, not the sensor rails.

Fitting the Ocean Into Legal Airtime

The problem: raw JSON doesn't fit over a 900MHz LoRa link. At 1200bps, a standard 283-byte JSON telemetry envelope would exceed the strict LoRa airtime regulations (duty cycle) and cause packet collisions across the fleet. The fix: replace JSON on the air entirely with a custom versioned Mesh Binary TLV (Type-Length-Value) protocol. Bit-packed fields and custom scaling (e.g., deci-Celsius, milligees) crush a full Sensor + GPS + Health frame from 283 bytes down to 84 bytes, a 70% savings. That beats standard CBOR and Protobuf on the wire. Time-on-Air (ToA) drops sharply, battery life stretches, and Store-Carry-Forward gets the headroom it needs. Protocol details below →

The Encoder

Lossless Predictive Coding.

To achieve high-frequency sampling over ultra-low bandwidth, OMEGA uses Multi-Sample Batching backed by a first-order predictive encoder. If you send 30 floats over LoRa, the payload is 120 bytes. Using this algorithm, you can compress that to roughly 20 bytes.

The Core Concept

First-Order Predictor

The encoder sends the residual delta between the current reading and the previous reading: $R[i] = V[i] - V[i-1]$. In the ocean, temperatures change slowly, so the residuals ($R$) are very small numbers (like +0.1 or -0.2) which can be bit-packed into 4-bit nibbles.

Data Purity

Strictly Lossless Fallback

The science depends on the numbers surviving intact. If a sudden anomaly causes a delta spike that exceeds the maximum packed integer size, the encoder refuses to truncate it and falls back to sending verbatim scalar values.

Dual-Layer Protocol

One Format for the Air, Another for Shore.

One of OMEGA's biggest design decisions was how to balance a wide mix of hardware (satellites, cell modems, LoRa radios, acoustic modems) against tight bandwidth constraints. The answer is a dual-layer protocol architecture.

The Air Interface (Layer 1): Over 900MHz LoRa, every byte is expensive. OMEGA uses a Custom Mesh Binary TLV Protocol that drops the payload to 84B, requires zero external firmware parsing libraries, and enables trivial relay paths where intermediary nodes bump a single hop_count byte without deserializing the payload. Standard formats like CBOR, MessagePack, and Cayenne LPP carry roughly 150B of structural overhead per frame.

The Federation Interface (Layer 2): When that 84B binary packet hits a gateway, it is translated into the OMEGA Envelope Protocol v1.0. This is a self-describing, globally standard format (using Canonical UTF-8 JSON or SenML CBOR for constrained IP bearers). Because "identity and meaning travel with the data", external databases, web portals, and federated science platforms never need to know the raw binary structure of the mesh. The Envelope Protocol ensures that a reading from a LoRa node and a reading from a NATO JANUS acoustic buoy look exactly the same to the backend.

gateway/mesh_binary_codec.py 
def decode_mesh_frame(packet_bytes: bytes) -> dict[str, Any]:
    # 1. Parse the 11-byte OMEGA Binary Routing Header
    version, origin_id, dest_id, hops, frame_type, sequence = struct.unpack(
        "<BHHBBII", packet_bytes[:11]
    )

    payload = {"origin": NODE_ID_REGISTRY.get(origin_id, "urn:OA:node:unknown"),
               "sequence": sequence, "hops": hops}

    # 2. Extract Phase 1-4 Binary TLVs
    offset = 11
    while offset < len(packet_bytes):
        tlv_type = packet_bytes[offset]
        length = packet_bytes[offset + 1]
        value = packet_bytes[offset + 2 : offset + 2 + length]

        # 3. Predictor reconstruction & fixed-point scaling
        payload.update(decode_tlv_value(tlv_type, value))
        offset += 2 + length

    return payload
RF Physics

CSMA-CA Collision Avoidance.

When deploying 50+ floating sensor nodes in a small coastal bay, transmitting simultaneously on the 915MHz LoRa band guarantees a storm of packet collisions. OMEGA firmware implements low-level Carrier Sense Multiple Access with Collision Avoidance (CSMA-CA).

Execution: Before any node fires a transmission, it drops its SX1262 transceiver into CAD (Channel Activity Detection) mode. The silicon scans the physical RF spectrum for existing LoRa preamble chirps. If the channel is active, the node backs off for a randomized exponential interval (slotted ALOHA). This decentralized coordination allows dense mesh networks to self-regulate without a master polling node.

Mathematical Physics

The Mathematics of LoRa.

OMEGA's edge node is a LilyGo T-Beam 1W-class LoRa node. How far it actually reaches comes down to the Link Budget and Chirp Spread Spectrum (CSS) modulation, with the important caveat that the antenna gain and the real-world field range have not yet been characterized.

The Link Budget

Rx = Tx + Gains - Losses

The Link Budget determines whether a packet survives the journey: Rx (receiver sensitivity) must beat the Tx (transmit power) plus antenna gains minus path loss. In normal builds the firmware ships at roughly +13 to +17 dBm. The antenna gain is not yet characterized, so the gain term and the resulting field range remain open.

Chirp Spread Spectrum

Spreading Factor 12 (SF12)

By spreading the signal across a wider band over a longer symbol duration (SF12), the bit rate drops (to ~1200 bps) but the processing gain rises. The documented decode floor at SF12 is about -134 dBm, letting the SX1262 pull a signal out from near the thermal noise floor.

CSMA-CA Algorithmic Logic 
async def transmit_with_csmaca(payload: bytes):
    """Carrier Sense Multiple Access with Collision Avoidance"""
    max_retries = 5
    for attempt in range(max_retries):
        # 1. Channel Activity Detection (CAD)
        if radio.is_channel_free():
            radio.transmit(payload)
            return True

        # 2. Mathematical Random Backoff (Exponential)
        backoff_ms = random.randint(100, 500 * (2 ** attempt))
        await asyncio.sleep(backoff_ms / 1000.0)

    raise ChannelBusyError("RF environment completely saturated.")
RF Power & PA Thermal Management

The High-Power Amplifier Path.

To push through ocean swells, OMEGA pairs the LilyGo T-Beam 1W board (which carries its own on-board amplifier) with an external High Power Amplifier (HPA) stage. The hardware is +30 dBm-capable, but the firmware runs it conservatively; the transmit-power setting ships at +20 dBm in normal operation rather than driving the chain flat out.

How the chain is driven: the SX1262 is hard-clamped at +22 dBm and the external HPA does the rest. The PA is switched in over the radio's DIO2 RF-switch control line, and the firmware applies an 800 µs PA ramp so the amplifier settles into the burst. This keeps the silicon inside its safe operating area while still feeding the HPA a clean drive level.

Proactive fan cooling: the firmware spins up a GPIO/MOSFET-driven cooling fan before each transmit burst and runs a short post-TX cooldown after the packet clears. This is straightforward proactive PA thermal management (keeping the amplifier stage in a comfortable temperature band during back-to-back bursts), not a response to any thermal emergency.

TX-Burst Cooling Sequence
flowchart LR A[Burst
scheduled] --> B[Fan on] --> C[800 µs
PA ramp] --> D[TX burst
~+20 dBm] --> E[Cooldown] --> F[Fan off] classDef node fill:#101529,stroke:#3b82f6,stroke-width:2px,color:#fff; class A,B,C,D,E,F node;
RF Physics & Firmware

Hardware PA Clamping & RX Boost.

Getting the most range out of the radio takes hardware-level tuning of the silicon. OMEGA firmware interfaces directly with the Semtech SX126x radio registers to bypass standard defaults.

Execution: The firmware enables RxBoostedGainMode, physically increasing the Low-Noise Amplifier (LNA) gain by ~3 dB at the cost of ~2 mA extra RX current. For short-duty mesh nodes that trade is worth taking: they decode marginal cross-family packets that previously failed at the noise floor. Internal Power Amplifiers (PA) are strictly clamped at +22 dBm to prevent silicon burnout when driving external 1-Watt High Power Amplifiers (HPA).

Edge Operations

Watching a Headless Node's Vitals.

Local UI Diagnostics

OLED & AXP2101

An operator standing over a headless node needs to read its state on sight. The firmware queries the AXP2101 PMU (Power Management Unit) via I2C, rendering real-time battery voltage, charge percentage, CPU die temperature, and acquired GNSS coordinates directly to a local SH1106 OLED screen.

Resilient Telemetry

The "Mule" Store & Forward Model.

A true Delay Tolerant Network (DTN) assumes that end-to-end paths may never exist simultaneously. OMEGA shifts from connection-oriented routing to self-contained bundle routing.

Bounded Spread

Store & Carry

When a node captures a mesh frame, it deduplicates the payload via its origin/sequence and places it in a finite carry buffer. Mobile nodes (like boats or ASVs) physically carry these stored bundles as they travel, acting as network links across disconnected regions.

Identity

ed25519 Trust Model

Trust lives entirely in the data. Because each bundle is cryptographically signed with the origin node's ed25519 public key, anyone can run an OMEGA gateway or act as a mule. A malicious carrier can delay a bundle, but they can never forge or tamper with the payload.

Delivery

Opportunistic Offload

The instant any mule or relay detects IP reachability (whether via its own cellular modem, a Wi-Fi HaLow link to shore, or an open hotspot), it flushes its buffered bundles to the central POST /v1/ingest/frame contract, completing the data's journey home.

Routing Algorithms

Route Cost & AutoInterface.

In a mixed-bearer environment, the mesh gateway must constantly decide whether to send a packet over a fast but incredibly expensive satellite link (Iridium), a fast but short-range cellular link (LTE), or a slow but completely free sub-GHz RF link (LoRa).

OMEGA uses a custom route-scoring algorithm that weighs Route Cost (the financial or bandwidth penalty of the transmission) against Route Weight (the physical latency or topological distance of the hop). The Python mesh router ranks every physical interface mapped to a target node.

Operational Use: For local mesh clustering, OMEGA implements a Reticulum-inspired AutoInterface. When a new edge node or Buoy is powered on, it immediately begins broadcasting UDP multicasts over its active hardware interfaces. Nearby nodes intercept these multicasts, extract the cryptographic public key, and instantly map a valid route to the new node without requiring a human to statically assign an IP address. It is zero-configuration networking in the field.

Acknowledgment-Aware Outboxes

When a packet is dispatched over the DTN, it sits in an `awaiting_ack` state. If the target node fails to acknowledge within the timeout, the packet falls back to a heavier bearer.

gateway/fleet.py Route Scoring 
def calculate_best_route(target_id: str, interfaces: dict) -> str:
    valid_routes = [iface for iface in interfaces.values() if iface.can_reach(target_id)]
    valid_routes.sort(key=lambda x: (x.route_cost, x.route_weight))
    return valid_routes[0].id if valid_routes else None
Distributed Systems

DTN Command Versioning.

Uplink telemetry is inherently order-independent, but bidirectional downlink commands (like telling a node to change its transmission power) are stateful. In a store-and-forward network, a delayed command might arrive at a node days after a newer command was already applied.

The Newest-Wins Rule: OMEGA solves this by enforcing declarative, versioned commands. Every command carries a monotonic operator version and a target key. The node tracks the applied version per-key in Non-Volatile Storage (NVS). When a command arrives, it only executes if cmd.version > applied[key]. Older arrivals are dropped as stale, which eliminates rollback issues under extreme packet loss or reordering.

Bidirectional Mesh

Cloud-to-Node Command Architecture.

In Phase 1, edge nodes were purely telemetry broadcasters. With the new binary protocol, OMEGA implements a fully bidirectional mesh. The shore gateway can now construct binary COMMAND frames and route them over the mesh directly to specific nodes.

Execution: By injecting a dest_id into the binary header, commands like restart, set-telemetry-interval, or set-tx-power are routed across the ocean. Intermediary nodes receive the packet, check the destination, and automatically re-transmit (relay) the packet if it is not meant for them. This creates a self-healing bidirectional mesh network.

Long-Range Wi-Fi (Designed)

IEEE 802.11ah HaLow IP Backhaul.

LoRa is a great telemetry bearer but a poor IP pipe. To give the fleet an optional higher-throughput backhaul link, OMEGA has a companion-firmware architecture for 802.11ah (HaLow) on T-HaLow ESP32-S3 boards. HaLow here is strictly an IP backhaul between a node and shore; it is not a mesh bearer, and it is not intended for video.

Status (designed, not yet brought up): the build flags below configure one side as an ap-root and the peer as an sta-client to form a sub-GHz TCP/IP link. On the hardware, the HaLow radio (the TX-AH module) runs its own firmware and is driven over SPI by the host ESP32; that SPI path is not yet implemented, so bring-up is pending the vendor hardware. The companion firmware and its peering configuration exist on paper and in the build, but no live HaLow link has been stood up yet.

thalow_gateway_control/platformio.ini 
[env:t_halow_ap_companion]
build_flags =
  -DOMEGA_NODE_ID="urn:OA:node:shore-gateway:thalow-ap"
  -DOMEGA_DEVICE_ID="t-halow-ap-companion"
  -DOMEGA_HALOW_ROLE="ap-root"
  -DOMEGA_HALOW_PEER_HINT="buoy-sta"
Protocol Bridging

Meshtastic & MeshCore Bridging.

OMEGA ships a runnable Meshtastic bridge built on the official Meshtastic Python SDK (bidirectional, over both serial and TCP, and tested against real radios), alongside a MeshCore mesh-interface framework for the same role.

It is meant as a last-resort bearer: if operators already have Meshtastic or MeshCore radios in the area, the OMEGA gateway can serialize its outbox payloads and piggyback them across that existing mesh. The arrangement is reciprocal: OMEGA also forwards the host mesh's own traffic in return, so it pays its own way in airtime on someone else's network.

Remote Operations

Cloud CGNAT Tunneling.

Field operations often rely on marine cellular routers, which are trapped behind Carrier-Grade NAT (CGNAT) firewalls. The scripts/tunnel-up.ps1 daemon automates the execution of Cloudflared or Ngrok. It securely punches a reverse TCP tunnel from the edge node gateway out to the public internet, exposing the local React Mission Portal to oceanographic teams thousands of miles away.

Underwater Link (Experimental)

The Acoustic Bridge: What's Real, What Isn't.

Standard radio frequencies cannot penetrate water. The NATO-standard JANUS protocol (STANAG 4748) is the intended way to reach Remotely Operated Vehicles (ROVs) and benthic sensors. Being honest about scope: the OMEGA side of it is currently a message format and a software bridge, not an on-device modem.

Where OMEGA actually sits: sound travels at ~1,500 m/s underwater, subject to heavy multi-path and thermocline refraction, and JANUS uses Frequency-Shift Keying (FSK) to carry data over that channel. OMEGA does not do the FFT wakeup detection, PLL synchronization, or FSK demodulation itself. Instead, janus_bridge.py defines the JANUS message format and forwards JANUS JSON to and from an external acoustic / SDR modem, which owns the real DSP. The bridge's job is translating those messages onto the LoRa mesh; there is no on-device signal processing.

gateway/janus_bridge.py 
async def forward_janus_message(janus_json: dict):
    # The bridge does NOT demodulate audio. The external acoustic/SDR
    # modem owns the FFT wakeup, PLL sync, and FSK demod; it hands us
    # decoded JANUS messages as JSON, and we hand it JSON to transmit.

    # 1. Validate the JANUS message envelope
    if not is_valid_janus_envelope(janus_json):
        return

    # 2. Translate the JANUS payload into an OMEGA Envelope frame
    frame = janus_to_envelope(janus_json)

    # 3. Bridge it onto the LoRa mesh
    await inject_telemetry_to_mesh(frame)
NATO Protocols

NATO-Standard Binary Framing.

To combat severe multipath fading, OMEGA implements the NATO-standard JANUS acoustic protocol (STANAG 4748). The gateway strips JSON into highly compressed binary frames, packing telemetry into a dense 50-baud acoustic chirp stream.

Step 1

SenML CBOR Packing

Standard 283-byte JSON telemetry is converted into the Envelope Protocol v1.0 constrained form (SenML CBOR), reducing overhead for the 50-baud acoustic channel.

Step 2

JANUS Interleaving

The binary payload is fed through convolutional encoding and interleaving to recover data lost to sudden wave noise.

Step 3

FSK Modulation

The external acoustic modem fires the encoded bits out of the hydrophone as Frequency-Shift Keyed audio chirps centered at 11.5 kHz.

Acoustic Subsea Frames

JANUS Initialization.

Because the underwater acoustic channel is so hostile, bandwidth is severely limited, often only tens of bits per second, so OMEGA cannot stream complex JSON over a hydrophone.

How it works: The JSON structure below represents the source representation of the simulated NATO-standard JANUS initialization frame before it undergoes SenML CBOR serialization per the Envelope Protocol v1.0 specifications. The payload explicitly defines the center_frequency_hz and the rx_level_db. The Gateway crushes this into a binary string and uses it to align the hydrophone's physical oscillator. Once aligned, the actual data transferred via the acoustic bridge is strictly limited to heavily compressed initialization vectors and critical emergency stop commands, preserving the fragile acoustic channel.

janus-announce.example.json 
{
  "message_id": "janus-msg-0001",
  "observed_at": "2026-04-18T19:20:00Z",
  "link_id": "buoy-02-acoustic",
  "message_type": "announce",
  "origin": {
    "node_id": "urn:OA:node:site-a:buoy-02",
    "device_id": "acoustic-bridge-main",
    "role": "surface-gateway"
  },
  "destination": {
    "scope": "broadcast"
  },
  "janus": {
    "class_id": 16,
    "app_type": "gateway-announce",
    "cargo_encoding": "json",
    "cargo": {
      "capabilities": [
        "command-envelope",
        "telemetry-bridge"
      ],
      "surface_backhaul": [
        "lora",
        "wifi-halow",
        "cellular"
      ],
      "notes": "Buoy bridge ready for sparse telemetry and supervisory commands."
    }
  },
  "transport": {
    "provider": "software-defined-modem",
    "center_frequency_hz": 11520,
    "snr_db": 11.4,
    "rx_level_db": -78.0
  }
}
Remote Lifecycle Management

Over-The-Air (OTA) Foundation.

Retrieving a deployed remote sensor from the environment simply to update a line of code is logistically prohibitive, so OMEGA is building toward firmware-over-mesh. What exists today is the gateway-side foundation: a firmware-image registry where each build is signed with an Ed25519 key, carries a sha256 integrity hash, and goes through explicit version negotiation before a node is offered an update.

The registry now supports a channelized stable/beta rollout: beta nodes canary a new build in the field before it is promoted to the stable channel, so a bad image is caught on a small population rather than the whole fleet.

Not yet built: the on-device half of the pipeline (chunked transfer of the image over the mesh, A/B boot-partition swapping, and automatic rollback on a failed flash) is designed but not yet implemented. Until that lands, OTA is a gateway capability, not an end-to-end one.

Mesh Phases 3 & 4

Machine Learning over LoRa.

Beyond basic scalar telemetry, OMEGA's binary mesh protocol reserves namespace and command slots for moving complex spectral features (and eventually whole ML models) across ultra-low-bandwidth links. These are forward-compatible protocol provisions (Phases 3 & 4): defined in the codec, not yet running on edge hardware.

Phase 3: Designed

FFT Spectral Feature Bags

Streaming raw acoustic or high-frequency vibration data over a 250bps LoRa link is impossible, so the protocol reserves a DERIVED-namespace TLV for on-edge spectral features: a node would run a local FFT and transmit only the critical frequency-bin peaks. The TLV slot is reserved in the codec; the on-edge FFT compute is a forward-compatible hook, not yet wired to a sensor.

Phase 4: Designed

Over-The-Air Edge AI

To update an edge node's classification model without retrieving the buoy, the codec can fragment a quantized TensorFlow Lite Micro model into small TLV chunks for OTA transmission. The chunk-encoder exists in mesh_binary_codec.py (below); on-node reconstruction and activation are designed but not yet wired in firmware.

gateway/mesh_binary_codec.py (Phase 4 Model Loading) 
def build_ota_model_chunk(model_id: str, chunk_index: int, payload_bytes: bytes) -> bytes:
    """Encodes a single chunk of an ML model for OTA LoRa transmission."""
    # 1. Header with Model ID and Chunk Offset
    header = struct.pack("<8sH", model_id.encode('utf-8')[:8], chunk_index)

    # 2. Append compressed model weights
    chunk_data = zlib.compress(payload_bytes, level=9)

    # 3. Wrap in Mesh Phase 4 TLV Envelope
    return tlv_encode(TAG_OTA_MODEL_CHUNK, header + chunk_data)
Engineering Reality

What Is and Isn't Proven.

Honest Gaps

Link-level reception is real and proven: 205 frames decoded by the gateway, with measured RSSI and SNR. What is not yet field-demonstrated is multi-hop mesh routing: relaying a frame across intermediate nodes to a destination has not been shown in the field. Much of the field-hardening firmware is written but not yet flashed to deployed hardware, and the bench RF window that produced these results was only about 6 to 7 days. The reception evidence is solid; the end-to-end mesh and long-duration field behavior are still open.

Next: The Backend Gateway → Read the Engineering Journal