Layer 1: Fleet Infrastructure
The COTS Federation
To achieve global scalability and rapid hardware iteration, the OMEGA physical layer leverages Commercial Off-The-Shelf (COTS) edge silicon rather than manufacturing custom PCBs. The entire fleet is standardized on the Espressif ESP32-S3 microcontroller, unified by a custom embedded C++ firmware stack.
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. This headless device concurrently catches bursts of telemetry across 8 LoRa channels simultaneously, immediately wrapping the raw RF frames into Semtech UDP packets and forwarding them over high-speed Ethernet to the central Python Broker.
Sensor Node
T-Beam Supreme
The standard marine sensing edge node. It pairs the ESP32-S3 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 manages complex deep-sleep thermodynamic cycles to survive strictly on solar power.
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 executing high-bandwidth bulk-transfer handshakes to move delayed payloads efficiently to the nearest gateway.
Data Pipeline
Lossless Predictive Batching.
Transmitting individual oceanographic measurements (e.g., a temperature reading every 3 seconds) across a low-bandwidth LoRa link introduces catastrophic overhead from packet headers, leading directly to regulatory duty-cycle violations and massive battery drain.
To solve this, the OMEGA edge firmware executes Phase 1 Predictive Batching entirely locally on the ESP32-S3. The node samples sensors into an internal RAM ring buffer. Once the buffer is full, the C++ engine applies a first-order predictive coding algorithm: it transmits the first baseline measurement as a full 32-bit integer, but encodes all subsequent readings as tightly packed 4-bit or 8-bit residuals (the delta from the previous reading).
Result: This mathematically guarantees a completely lossless reconstruction of the high-frequency telemetry array at the Shore Gateway, while physically crushing the LoRa packet size by over 80%.
Mesh Resilience
Store & Forward Architecture.
Oceanographic sensor buoys frequently drift into RF dead zones, pass behind massive waves, or suffer from atmospheric interference. If an edge node attempts to blindly transmit during a network blackout, the data is permanently lost. To guarantee Absolute Data Purity, the DTO v3.0 firmware utilizes an autonomous Store & Forward mechanism.
When the firmware's CSMA-CA (Carrier-Sense Multiple Access) layer detects channel jamming, or the MAC layer fails to receive cryptographic LoRaWAN acknowledgments, the ESP32-S3 instantly aborts transmission. The compressed telemetry payload is serialized and dumped directly into the physical NVRAM/SPIFFS flash memory partition.
The node can survive offline for weeks, quietly accumulating environmental history. 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 flushes its flash buffer, sequentially replaying its queue and seamlessly reconstructing the historical timeline within the Federated Data Broker.
Edge Operations
Power Management & Thermodynamics.
A remote sensor floating in the ocean cannot plug into a wall outlet. It must meticulously harvest and budget its own power. A spinning ESP32-S3 draws roughly 100mA, which will completely drain a lithium cell in two days. The firmware strictly manages these physics.
Deep Sleep Cycling
15µA Survival Mode
Between transmission windows, the firmware issues an esp_deep_sleep_start() command. It physically cuts the MOSFET power rails to the GNSS and LoRa chips, dropping the entire board's consumption from 100mA to 15 micro-amps, mathematically guaranteeing survival through long winter nights.
Local UI Diagnostics
OLED & AXP2101
Deploying a headless node is dangerous if operators cannot visually confirm its operational state. 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.
Remote Lifecycle Management
Over-The-Air (OTA) Pipelines.
Retrieving a deployed remote sensor from the environment simply to update a line of code is logistically prohibitive. The firmware incorporates a robust Over-The-Air (OTA) flashing pipeline over its own DTN mesh network.
The compiled firmware binaries are fragmented, heavily compressed, and signed with a cryptographic private key. The T-ETH-ELITE Gateway transmits these fragments sequentially over the LoRa network. The edge node receives the fragments, buffers them in its external SPI flash memory, and reassembles them.
Crucially, the node then mathematically verifies the cryptographic signature of the reassembled binary. It only switches the boot partition pointer to the new firmware if the validation passes perfectly, completely preventing "bricked" nodes caused by corrupt RF packets.
Tier 1 Proof
OMEGA Measured It: Atmospheric Tide.
A $50 bench barometer logged 104,939 pressure readings. The Welch power spectrum below shows a sharp line at 11.99 hours standing ~580,000x above the noise floor. This is the S2 semidiurnal atmospheric tide, resolved from scratch by OMEGA's own hardware without any external data.
Hardware Reality
Cross-Family LoRa Interop.
Getting a true multi-hop mesh to work isn't about plugging in antennas; it's about making disparate silicon families talk to each other. The network bridges Semtech's SX1262 (T-Beam Supreme) and their newer LR1121 (T3-S3).
Execution: To achieve seamless interop, the firmware had to manually settle sync-word mismatches (enforcing the `0x34` public sync), explicitly declare bandwidth and spreading factor settings that libraries usually abstract away, and implement aggressive polling-based RX with full-chain IRQ mapping. This allowed concurrent sensing, relaying, and USB-forwarding across completely different chipset architectures.
Physical-Layer Reception Evidence
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). These hardware-level signals cannot be fabricated by a UI.
Engineering Reality: The "Transmits but never Receives" Bug
During the bring-up of the LR1121 relay node, it would transmit perfectly but receive absolutely nothing. The RX interrupt count was zero. Instead of guessing, I mapped the full RX-chain IRQ set (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. RX went from 0% to 100%. Read the full journal →
Energy Physics
Power Budgets & Insolation.
A remote node operating in winter might only receive 2 hours of direct solar insolation per day. The node must mathematically budget its stored energy to survive a 14-hour night.
Dark Current
The Silent Killer
Even when not actively transmitting, a spinning ESP32 processor draws a "dark current" of 100mA. Overnight, this will completely drain the lithium cell, causing the physical hardware to freeze.
Deep Sleep
15µA Survival
The firmware physically cuts the MOSFET power rail to auxiliary sensors and LoRa chips, dropping the entire board into a 15 micro-amp deep sleep state between transmissions.
Dynamic Polling
Battery-Aware Rates
If the battery voltage drops below 3.6V, the firmware automatically downscales its sample rate from every 10 minutes to every 60 minutes, mathematically guaranteeing survival until sunrise.
Network Resilience
Offline Survival & Store-and-Forward.
Oceanographic buoys frequently drift into RF dead zones or experience severe atmospheric interference. If an edge node cannot reach the gateway, it must not drop its critical telemetry.
Execution: To solve this, Phase 2 firmware implements an autonomous Store & Forward architecture. When a node detects that a transmission has failed (via missing LoRaWAN ACKs or CSMA-CA channel jamming), it seamlessly reroutes the compressed telemetry payload into its non-volatile SPIFFS memory. The node can survive offline for weeks, quietly accumulating data. When connection to the mesh is re-established, the node automatically flushes its queue, seamlessly reconstructing the timeline in the central database.
Thermodynamics
The 1-Watt Thermal Envelope.
To punch through ocean swells and achieve true over-the-horizon transmission, OMEGA employs custom High Power Amplifiers (HPA) and the T-Beam 1W to push a blistering +30dBm (1 Watt) of RF output power. However, generating 1 Watt of RF inside a hermetically sealed IP67 waterproof enclosure creates a thermal crisis.
Silicon Constraints: The SX1262 chip itself is physically incapable of driving +30dBm; attempting to do so will permanently destroy the silicon. OMEGA safely caps the internal SX1262 PA at +22dBm, routing the signal into the external HPA.
TX-Burst Fan Control: To survive the thermal load, the ESP32-S3 physically spins up an external cooling fan on maximum GPIO drive just seconds before a transmission burst, and spins it down immediately after the packet clears the antenna. This prevents thermal throttling while strictly preserving the power budget during deep sleep.
TX-Burst Cooling Matrix
graph TD
A[Deep Sleep - 15µA] --> B[RTC Wake]
B --> C{Temp Check}
C -- > 45°C --> D[Spin up Fan on Max GPIO]
C -- < 45°C --> E[Passive Cooling Sufficient]
D --> F[SX1262 Fire @ +22dBm]
E --> F
F --> G[External HPA Boosts to +30dBm]
G --> H[LoRa Packet TX]
H --> I[Spin Down Fan]
I --> A
classDef node fill:#101529,stroke:#3b82f6,stroke-width:2px,color:#fff;
class A,B,C,D,E,F,G,H,I node;
Network Graph Theory
Delay Tolerant Networks (DTN).
Transmitting raw JSON over a 900MHz LoRa link is catastrophic. At 1200bps, a standard 400-byte JSON
telemetry envelope would exceed the strict LoRa airtime regulations (duty cycle) and cause massive packet
collisions across the fleet.
The Mathematics of Compression: OMEGA replaces standard JSON-over-LoRa entirely with a custom
versioned Mesh Binary TLV (Type-Length-Value) Protocol for the air interface. By utilizing bit-packed fields and
custom scaling (e.g., deci-Celsius, milligees), a full Sensor + GPS + Health frame is crushed from 283 bytes
down to just 84 bytes (a 70% savings). This outperforms even standard CBOR and Protobuf on the wire, ensuring massive Time-on-Air
(ToA) reductions, extending battery life, and creating the necessary headroom for Store-Carry-Forward operations.
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(
"
Educational Deep Dive: Signal Processing
Lossless Predictive Coding.
To achieve high-frequency sampling over ultra-low bandwidth, OMEGA utilizes 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
Instead of sending raw values, the encoder calculates the residual delta
between the current reading and the previous reading: $R[i] = V[i] - V[i-1]$. In the
ocean, temperatures change slowly. Therefore, 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
Scientific data integrity is paramount. If a sudden anomaly causes a delta
spike that exceeds the maximum packed integer size, the encoder mathematically refuses to
truncate it. It dynamically falls back to sending verbatim scalar values.
Step-by-Step
Implementation: Building a Python Encoder
- Scaling: Floating point math is slow and hard to pack.
First, scale the floats into integers (e.g., $24.5^\circ\text{C} \times 10 = 245$).
- Calculate Deltas: Iterate through the batch. Store the
absolute first value, then calculate the residuals.
- Determine Bit Width: Find the maximum absolute residual. If $max(|R|) < 8$, you can
pack the deltas into 4-bit signed nibbles. If $< 128$, use 8-bit bytes.
def encode_batch(values: list[float], scale: int = 10) -> bytes:
if not values: return b""
# 1. Scale to integers
int_vals = [int(round(v * scale)) for v in values]
# 2. Calculate residual deltas
deltas = []
for i in range(1, len(int_vals)):
deltas.append(int_vals[i] - int_vals[i-1])
# 3. Check variance bounds for 8-bit packing
max_delta = max((abs(d) for d in deltas), default=0)
if max_delta <= 127:
# Pack: [Header Byte] [Initial Value (2B)] [Deltas...]
payload = bytearray()
payload.append(0x01) # Header indicating 8-bit deltas
payload.extend(struct.pack(">h", int_vals[0]))
for d in deltas:
payload.append(d & 0xFF) # Pack as 8-bit signed
return bytes(payload)
else:
# Fallback to uncompressed array if variance is too high
raise ValueError("Variance exceeded bounds for lossless packing.")
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 utilizes a highly customized route-scoring algorithm that dynamically 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 true, 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
Dual-Layer Protocol
The Envelope Protocol v1.0 vs Binary TLV.
A major design decision in OMEGA was determining how to balance massive hardware heterogeneity (satellites, cell modems, LoRa radios, acoustic modems) with extreme bandwidth constraints. The solution is a dual-layer protocol architecture.
The Air Interface (Layer 1): Over 900MHz LoRa, every byte is expensive. Standard formats like CBOR, MessagePack, and Cayenne LPP carry too much structural overhead (~150B per frame). So, OMEGA uses a Custom Mesh Binary TLV Protocol. This drops the payload to 84B, requires zero external firmware parsing libraries, and enables trivial relay paths where intermediary nodes simply bump a single hop_count byte without deserializing the payload.
The Federation Interface (Layer 2): When that 84B binary packet hits a gateway, it is instantly 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.
Long-Range Wi-Fi
IEEE 802.11ah HaLow Bridging.
Standard 900MHz LoRa is restricted to a few hundred bytes per second—perfect for telemetry, but entirely
useless for streaming underwater video feeds. To solve this, OMEGA integrates T-HaLow ESP32-S3 boards.
Execution: The firmware configures one node as an ap-root (Access Point) and
another as a sta-client (Station). This establishes a transparent IEEE 802.11ah Wi-Fi
connection over sub-GHz frequencies. It creates a massive, long-range TCP/IP tunnel that bypasses standard
2.4GHz Wi-Fi limitations, allowing the edge node to stream live RTSP camera feeds directly to the shore
gateway from over a kilometer away.
thalow_gateway_control/platformio.ini
[env:t_halow_ap_companion]
build_flags =
-DOMEGA_NODE_ID="urn:omega-wave: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 Piggybacking.
OMEGA does not reinvent the wheel. While it has its own routing logic, it includes a robust Python bridge
to Meshtastic.
If operators have existing consumer Meshtastic LoRa radios, the OMEGA Gateway can serialize its outbox
payloads and push them over the Meshtastic serial API. This allows OMEGA to hijack established consumer
meshes to bounce encrypted telemetry packets across vast distances for free.
Remote Operations
Cloud CGNAT Tunneling.
Field operations often rely on marine cellular routers, which are trapped behind massive 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,
securely exposing the local React Mission Portal to oceanographic teams thousands of miles away.
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 true, self-healing bidirectional mesh
network.
RF Physics & Firmware
Hardware PA Clamping & RX Boost.
Achieving absolute maximum range requires 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,
this provides a massive mathematical advantage, allowing them to decode marginal cross-family packets that
previously failed at the noise floor. Concurrently, internal Power Amplifiers (PA) are strictly clamped at
+22 dBm to prevent silicon burnout when driving external 1-Watt High Power Amplifiers (HPA).
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, physically acting as network links across disconnected regions.
Identity
ed25519 Trust Model
Trust lives entirely in the data, not the carrier. 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 completely flushes its buffered bundles to the central POST /v1/ingest/frame contract, completing the data's journey home.
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 instantly dropped as stale, completely eliminating rollback issues under extreme packet loss or reordering.
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 catastrophic 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 mathematically 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.
How does OMEGA achieve 15km of range using only 1 Watt of transmission power? It requires manipulating the
fundamental physics of the Link Budget and Chirp Spread Spectrum (CSS) modulation.
The Link Budget
Rx = Tx + Gains - Losses
The Link Budget mathematically determines if a packet survives the journey.
Rx (Receiver Sensitivity) must be greater than the Tx (Transmit Power) minus
Free Space Path Loss. OMEGA uses massive 8dBi fiberglass antennas to mathematically force the
Gains high enough to overcome the oceanic path loss.
Chirp Spread Spectrum
Spreading Factor 12 (SF12)
By spreading the signal across a wider frequency band over a longer time
duration (SF12), OMEGA drastically drops the bit rate (to ~1200 bps), but mathematically increases the
processing gain. This pushes the receiver sensitivity to -137 dBm, allowing the SX1262 radio to literally
pull the signal out from below 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.")
Mesh Phases 3 & 4
Machine Learning over LoRa.
Moving beyond basic scalar telemetry, OMEGA's advanced Delay Tolerant Network (DTN) now supports the
transmission of complex mathematical features and entire Machine Learning architectures across ultra-low
bandwidth links.
Phase 3: FFT Bin Codec
Spectral Feature Bags
Instead of attempting to stream raw acoustic audio or high-frequency
vibration data over a 250bps LoRa link (which is impossible), the edge nodes perform local Fast Fourier
Transforms (FFT). The mesh protocol compresses these frequency bins into a highly optimized
DERIVED-namespace binary payload, transmitting only the critical spectral peaks to the shore
gateway.
Phase 4: OTA ML Protocol
Over-The-Air Edge AI
When the shore gateway needs to update an edge node's classification model
(e.g., detecting a new acoustic signature), it fragments a quantized TensorFlow Lite Micro model into
small TLV chunks. The mesh automatically reconstructs the model on the remote node without requiring
physical retrieval of the buoy.
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)
Acoustic Physics
Snell's Law & Refraction.
Standard radio frequencies cannot penetrate water. To communicate with Remotely Operated Vehicles (ROVs)
and benthic sensors, the surface fleet utilizes acoustic modems broadcasting the NATO-standard JANUS
protocol (STANAG 4748).
Acoustic Modulation: Sound waves travel at ~1,500 m/s underwater, subject to massive
multi-path reflections and thermocline refraction. The JANUS standard uses robust Frequency-Shift Keying
(FSK) to encode binary data into audio chirps. The Python janus_bridge.py module listens for
the distinct 86-bit JANUS wakeup tone, synchronizes the Phase-Locked Loop (PLL), and decodes the subsequent
data blocks into standard JSON envelopes that can be bridged onto the LoRa mesh.
gateway/janus_bridge.py
async def handle_acoustic_fsk_stream(audio_buffer: bytes):
# Detect and decode STANAG 4748 JANUS acoustic frames.
# 1. Execute Fast Fourier Transform (FFT) to detect wakeup tone
power_spectrum = np.abs(np.fft.rfft(audio_buffer))
wakeup_idx = np.argmax(power_spectrum)
if is_janus_frequency(wakeup_idx):
logger.info("Acoustic Wakeup Detected. Synchronizing PLL...")
# 2. Demodulate the FSK payload
binary_stream = _demodulate_fsk(audio_buffer)
# 3. Bridge the acoustic data to the shore API
await inject_telemetry_to_mesh(binary_stream)
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 400-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
mathematically recover data lost to sudden wave noise.
Step 3
FSK Modulation
The encoded bits are fired out of the hydrophone as Frequency-Shift Keyed
audio chirps centered at 11.5 kHz.
Frequency-Shift Keying (FSK) Math
def modulate_fsk(binary_string: str, f_space=11000, f_mark=12000, baud=50, fs=44100):
# Mathematically construct the analog audio wave
t = np.arange(0, 1/baud, 1/fs)
audio_wave = np.array([])
for bit in binary_string:
# 0 = Space (11.0 kHz), 1 = Mark (12.0 kHz)
freq = f_mark if bit == '1' else f_space
# S(t) = A * sin(2π * f * t)
chirp = np.sin(2 * np.pi * freq * t)
# Append the continuous wave
audio_wave = np.concatenate((audio_wave, chirp))
return audio_wave
Acoustic Refraction Physics
Snell's Law & The Sonar
Equation.
Transmitting data underwater is exponentially harder than RF. We must physically fight the ocean's
thermodynamics and the physics of wave attenuation.
The Sonar Equation
TL = 20 log(r) + αr
Transmission Loss (TL) dictates that sound energy decays via spherical
spreading 20 log(r) and chemical absorption αr. Because higher frequencies (like
100kHz) have a massive absorption coefficient α, high-bandwidth data physically cannot travel
more than a few hundred meters. This mathematically forces OMEGA to use low-frequency 11.5kHz chirps to
achieve kilometers of range, crushing our data rate to a mere 50 bps.
Thermocline Refraction
Snell's Law: sin(θ₁)/c₁ = sin(θ₂)/c₂
Ocean water is not uniform. Sound travels faster in warm surface water and
slower in the freezing depths. As the JANUS wave passes through the thermocline layer, Snell's Law
mathematically proves the wave will refract (bend) downwards towards the slower water. This creates
massive "Shadow Zones" near the surface where receiving buoys are physically blocked from hearing the
signal, regardless of transmit power.
Acoustic Subsea Frames
JANUS Initialization.
Because underwater acoustic physics are incredibly hostile, bandwidth is severely limited—often maxing out
at a mere 80 bits per second (bps). Therefore, 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:omega-wave: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
}
}