Water: Passive Acoustic Vessel Monitor

Overview

This is the water node of my defence hardware program: a hydrophone hanging off a dock (or, later, a mooring), a Raspberry Pi 5 that records and classifies what it hears, and a cheap AIS receiver that tells me what actually went past so the classifier can be trained and scored against reality. Every vessel passage becomes a labelled acoustic event: spectrogram in, vessel class and direction out.

The Canadian context is direct. The Canadian Arctic Sensor Suite Initiative aims for persistent surveillance from seabed to space, and the underwater leg of that is the hard one. DRDC's Northern Watch demonstration ran into problems with installation, ice, technical issues, and data management, the unglamorous parts, not the sensing itself. And in DRDC-linked work at Dalhousie, uncrewed vehicles act as sensor hosts that dock at seabed nodes to recharge and download data, while other DRDC-related work pairs hydrophone arrays with AIS data and ferry GPS as a reference. This build copies exactly those two patterns at hobby scale: AIS as the labelling source, and a dock-and-upload extension as the roadmap.

The sensing path emits nothing. It listens to the water and listens to the 162 MHz AIS band, both receive-only, which keeps it legal, low-power, and hard to detect; the sync uplink transmits only when a link appears. What it practices is the layer Northern Watch struggled with: cheap nodes that stay alive, manage their own data, and sync when a link finally appears.

Proof of Build

The rig on my bench: the hydrophone submerged in a glass test tank, the USB audio interface and Pi 5 with the RTL-SDR dongle beside it, and the laptop running live spectrograms and classification histograms.

Nothing here is simulated. The hydrophone sits in the test tank so the full capture chain (sensor, interface, Pi, classifier) can be exercised with controlled sounds before anything goes near real water. The laptop shows the two views I watch while testing: the live spectrogram of what the hydrophone hears, and the running histogram of classifier outputs.

Bill of Materials

All components are already purchased and on my bench. Total lands around US$700-1,000 before tax and shipping.

Architecture

Figure 1: two receive-only sensors feed the Pi; the AIS stream labels and scores the acoustic classifier; everything buffers locally and syncs over MQTT when a link exists.

Reading a Vessel in Sound

Wiring & Connections

How I Built It

arecord -l
arecord -D hw:CARD=USBAudio -f S32_LE -c 1 -r 48000 -d 10 tank_test.wav
sox tank_test.wav -n stat

sox -n sweep.wav synth 30 sine 100-20000
sox -n boatsig.wav synth 60 brownnoise lowpass 800 gain -6
play boatsig.wav
# quiet 60 s capture with nothing playing:
sox quiet_60s.wav -n stat 2>&1 | grep -E 'RMS|Maximum'

git clone https://github.com/dgiardini/rtl-ais
cd rtl-ais && make
./rtl_ais -d 0 -h 127.0.0.1 -P 10110

mkdir -p /var/log/ais
nc -lu 10110 >> /var/log/ais/nmea.log

import sqlite3
db = sqlite3.connect("/data/ais/truth.db")
q = """
SELECT e.id, e.t_event, a.mmsi, a.lat, a.lon, a.sog, a.ship_type
FROM events e
JOIN ais a ON a.ts BETWEEN e.t_event - :pre AND e.t_event + :post
"""
rows = db.execute(q, {"pre": 300, "post": 300}).fetchall()
# keep matches inside the range gate (haversine to the node), nearest-in-time wins

import librosa, numpy as np
from scipy.signal import spectrogram, find_peaks

y, sr = librosa.load("event_0042.wav", sr=48000, mono=True)
S = librosa.feature.melspectrogram(y=y, sr=sr, n_fft=4096,
                                   hop_length=1024, n_mels=128, fmax=20000)
S_db = librosa.power_to_db(S, ref=np.max)

f, t, Z = spectrogram(y, fs=sr, nperseg=8192)
peaks, _ = find_peaks(Z[:, t.size // 2], prominence=10)
blade_lines_hz = f[peaks]  # stable narrowband lines for this event

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
import joblib

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=7)
clf = RandomForestClassifier(n_estimators=200, max_depth=12, n_jobs=4)
clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))
joblib.dump(clf, "vessel_clf.joblib")

Pi 5, recording + inference bursts   ~6-8 W peak, ~4 W typical
USB audio interface (bus powered)    ~2.5 W
RTL-SDR Blog V4                      ~1.5 W
--------------------------------------------------------
continuous draw                      ~8 W  ->  ~190 Wh/day
12 V 50 Ah LiFePO4, 80% usable       ~480 Wh -> ~2.5 days reserve
40 W panel, ~3 sun-hours (poor day)  ~120 Wh/day -> deficit
40 W panel, summer day               covers load + recharges

{
  "node": "water1",
  "ts": "2026-09-19T14:22:07Z",
  "class": "small-power",
  "direction": "approaching",
  "confidence": 0.0,
  "ais_mmsi": null,
  "audio_ref": "snip/2026-09-19T14-22Z.flac",
  "sig": "ed25519:..."
}

mosquitto_pub -h cop.local -t "nodes/water1/detections" \
  -f outbox/2026-09-19T14-22Z.json -q 1

[Unit]
Description=Hydrophone recorder
After=sound.target

[Service]
ExecStart=/usr/local/bin/hydro-record.sh
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

#!/bin/bash
# rotated 10-minute files at 48 kHz; arecord only expands the strftime
# tokens when --use-strftime is given
exec arecord -D hw:CARD=USBAudio -f S32_LE -c 1 -r 48000 \
  --use-strftime --max-file-time 600 /data/audio/%Y-%m-%d_%H-%M-%S.wav

# /boot/firmware/config.txt gets:
# dtparam=watchdog=on

#!/bin/bash
if nmcli -t -f SSID dev wifi list | grep -q '^docknode$'; then
  rsync -av --partial --remove-source-files \
    /data/outbox/ pi@docknode:/data/incoming/water1/
fi

Why AIS Is the Perfect Labelling Machine

Figure: the labelling pipeline. AIS tracks supply class labels through a time-and-range gate; the dataset is split by passage so one vessel's legs never leak across train and test; the trained model runs per event on the Pi 5.

Testing & Metrics

The protocol is five numbered runs, bench first, field later. Targets are stated up front; nothing below is a reported result, where a run has not finished, the status says so.

T1, Capture-chain soak (bench)

Setup: hydrophone in the test tank, Pi recording continuously at 48 kHz for 12 hours. Procedure: run the rotated recorder, then scan every file for gaps, ALSA xrun overruns, and drift between file-name timestamps and file lengths. Metric: zero dropped buffers; zero missing 10-minute files.

T2, Tank known-signal replay (bench)

Setup: reference sweep and recorded vessel signatures played into the tank. Procedure: capture each replay, compute the spectrogram, and compare against the reference; repeat the quiet-capture noise-floor measurement across an overnight soak. Metric: sweep visible across 100 Hz-20 kHz; noise floor stable within a few dB across the soak.

T3, AIS decode sanity (bench + roof antenna)

Setup: RTL-SDR with the marine antenna in its intended field position. Procedure: log for 48 hours, parse every sentence, and cross-check a sample of decoded MMSIs against a public AIS map. Metric: checksum-valid sentence rate (target above 95% while traffic is present); sampled vessels matching the public track.

T4, Field detection vs AIS (dock deployment)

Setup: node deployed at the dock for multi-day collection windows, AIS logging in parallel. Procedure: for every AIS-logged passage inside the listening gate, check the acoustic event log for a matching detection; count unmatched passages and unmatched events. Metric: detection rate (target: at least 80% of in-gate AIS passages matched to an acoustic event) and false-event rate (target: under 2 per hour). Status: not started, field collection has not begun, no numbers exist yet.

T5, Classifier scoring and sync loss test

Setup: the labelled dataset from T4, split by passage. Procedure: score vessel class and direction with a per-class confusion matrix (no single headline number); separately, cut the uplink for 24 hours, generate events, reconnect, and reconcile broker messages against the outbox archive. Metric: per-class precision/recall (first bar: 80%+ macro recall); sync test target is exactly 100% backlog delivery, zero losses, and duplicates reconciled at the broker (QoS 1 can redeliver after a lost PUBACK, so the receiver dedups on message id).

Targets, Measured Evidence, and Current Status

Evidence and targets are kept separate: the "measured to date" column holds only what has actually been recorded, and the target column holds what the build is aiming at.

As of writing, T1-T3 are running on the bench and T4-T5 have not started; I will publish the dataset and the numbers with each completed run, and I won't quote a detection rate until it comes out of a scored AIS window.

Troubleshooting & Lessons

• Mains hum in the tank recordings. The first bench captures showed a hard 60 Hz line with harmonics marching up the low end, a ground loop between the interface, the bench supply, and the tank speaker amp. Fix: power the interface and Pi from the same supply, run the replay speaker on a separate circuit, and use the balanced XLR path end to end. Lesson: measure the noise floor before trusting any tank result.
• ALSA card index shuffles between boots. The interface was hw:1,0 on one boot and hw:2,0 on the next, and the recorder silently captured from the wrong device. Fix: address the card by name (hw:CARD=USBAudio) backed by a udev rule keyed to the USB vendor/product ID. The systemd unit now survives reboots without edits.
• Overruns when the SDR shares the USB bus. Capturing at the exploratory 96 kHz while rtl_ais streamed over the same USB controller produced periodic xrun overruns (bench observation). Fix: a larger ALSA buffer (--buffer-time 200000), the SDR on a different port via a short extension, and a scheduling-priority bump for the recorder. The 48 kHz baseline is the defensible rate; 96 kHz stays exploratory.
• Timestamp mismatch between AIS and audio. Early labels were off by minutes because the Pi's clock drifted after sitting offline. Fix: chrony with NTP whenever the uplink exists, plus logging the monotonic clock next to wall time on every event so drift is measurable instead of invisible. Lesson: labelling errors from clock skew look exactly like classifier errors until you check the raw alignment by ear.
• Condensation in the IP67 box. A sealed box on a dock breathes with temperature swings and fogs from the inside. Fix: desiccant packs, a breathable waterproof vent gland, and all cable glands on the bottom face. Cheap insurance, water inside the box ends the node far more reliably than any software bug.

Status & Roadmap

• Done: all components purchased and on the bench; capture chain working at 48 kHz (96 kHz exploratory) through the USB interface; test-tank rig assembled; rtl_ais decoding live AIS traffic with MMSI/position/timestamp logging into SQLite; spectrogram + blade-line feature pipeline running on the Pi 5; systemd recorder with watchdog on the bench image.
• In progress: T1-T3 bench test runs; labelling join between acoustic events and AIS tracks; first classifier training as the labelled dataset accumulates; IP67 housing, weighted hydrophone assembly, and MPPT power logging.
• Next: solar/MPPT field integration and first dock deployment (T4); AIS-scored detection-rate runs and classifier confusion matrix (T5); MQTT sync into the common operating picture; then the autonomous-boat docking-node extension.

Related Builds

• Canadian Defence Hardware Program, the program hub; this is the water node (Phase 2).
• Multi-Domain Common Operating Picture, where this node's signed detections end up.
• DDIL-Proof DevOps, the store-and-forward patterns the field sync reuses.
• Arctic Domain Awareness Digital Twin, the same AIS-as-truth idea over open data at Arctic scale.

Build Narrative: Phase by Phase

Phase 1: capture chain. The hydrophone feeds a USB audio interface that the Pi 5 sees as a standard ALSA capture device, no drivers, no vendor software. For the XLR version of the H2d I enable the interface's 48 V phantom power. Recording is plain Linux tooling at 48 kHz, the defensible baseline (96 kHz stays explicitly exploratory): small-boat outboard blade-rate harmonics live in the low-kilohertz band, inside the hydrophone's approximately flat sensitivity range, and useful content above 20 kHz is not established, so the higher rate is not required. Gain staging in alsamixer targets peaks around -12 dBFS.

Phase 2: bench validation in the test tank. Before any dock deployment, the whole chain was validated in the glass test tank on the bench, the setup in the proof photo. Swept tones and recorded vessel signatures were played through a tank-coupled speaker, and the captured spectrograms were checked against what was played. The rule held: if the chain cannot hear a known signal in a tank, it has no business on a dock.

Phase 3: AIS ground-truth receiver. An RTL-SDR Blog V4 with a 162 MHz marine antenna covers both AIS channels (161.975 and 162.025 MHz). rtl_ais, built from source, demodulates both channels into NMEA !AIVDM sentences, which a small Python daemon parses into a SQLite database with MMSI, position, speed, course, and timestamp. A decoded MMSI was hand-checked against a public AIS web map before I trusted it.

Phase 4: labelling: join AIS tracks to acoustic events. The AIS log is the labelling machine. A strong acoustic event whose time window lines up with an AIS track inside the listening gate becomes a labelled sample, vessel class from the AIS ship-type field, approach versus departure from the range trend. Overlapping vessels are flagged ambiguous, never guessed.

Phase 5: features and classifier. Every event becomes a mel spectrogram (librosa) plus tracked narrowband propeller blade-rate lines, with the Doppler sign of the lines and the amplitude envelope giving approach/departure. A small random forest over spectrogram statistics and blade-line features runs on the Pi 5, trained with the split done by vessel passage, not by event, to stop dataset leakage.

Phase 6: field power and housing. The dock kit is an IP67 box with glands on the bottom face and a weighted hydrophone assembly that hangs below dock slap. A 12 V LiFePO4 battery charges from a 30 to 50 W panel through an MPPT controller, with a buck delivering a measured 5.1 V at the Pi header. The power budget gets a week of logged battery voltage on the bench before it is trusted in the field; field power endurance is its own test and has not run yet.

Phase 7: store-and-forward reporting. Detections, confidences, and short audio snippets buffer locally on high-endurance storage. A sync daemon watches the outbox and publishes signed MQTT messages with QoS 1 when a link exists, moving files to a sent archive only after the broker acknowledges. Recorder and decoder run under systemd with auto-restart, and the Pi hardware watchdog reboots a hung system.

What You Need

The build deliberately avoids anything exotic. The two parts people underestimate are the marine antenna (AIS is short-range VHF and wants height) and the power budget (sized for grey Canadian weeks, not summer days).

Challenges and Lessons Learned

• Silent files that looked like successful recordings. Phantom power left off on the XLR path produced files that opened fine but contained nothing. Lesson: always play a known signal through the chain and verify the spectrogram shows it; never trust a file just because it exists.
• Mains hum polluted the low end. The room's 60 Hz hum and its harmonics crept into bench captures. Lesson: measure the quiet-capture noise floor first so you know what the room contributes, and expect field audio to differ from tank audio (tank echoes smear blade lines, so line-tracking thresholds get tuned on field data).
• An indoor AIS antenna decoded almost nothing. AIS is short-range VHF; the decoder only started producing useful truth once the antenna had height and line of sight. Lesson: ground truth has antenna requirements too.
• Dataset leakage almost inflated the accuracy. Events from the same vessel passage in both train and test splits would have let the classifier memorize instead of generalize. Lesson: split by vessel passage, never by event.
• The buck drifted under load and the Pi browned out mid-write. The regulator was set on an unloaded bench. Lesson: set 5.1 V measured at the Pi's header with everything running, and log the MPPT's voltage/current for a week before trusting field power.

What Is Next

• Solar/MPPT field integration and the first dock deployment (T4), with the node unattended for weeks.
• AIS-scored detection-rate runs and the classifier confusion matrix (T5), split by vessel class.
• Signed MQTT detection feed into the multi-domain common operating picture.
• The autonomous-boat docking-node extension: a small boat that patrols, returns to a dock node to recharge and upload physically, reusing the same buffer format and sync discipline.
• Once enough labelled field audio accumulates, evaluate whether a deeper model beats the random forest baseline, only if the simple one plateaus.