mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
feat(sdr): local receivers — browser RTL-SDR, Local ADS-B layer and decoder feeds (#732)
Adds a Local ADS-B layer fed by your own receivers: a browser WebUSB RTL-SDR (with FM listening) and local 1090/978 MHz decoder feeds (LOCAL_RECEIVER_FEEDS, local and private addresses only). Local aircraft draw in magenta with class, silhouettes, 3D models, trails and a position sanity filter; the click card names the band and input that heard them. Builds on Sameh Khamis's SDR prototype and the initial GEV port by Mazeyar Moeini Feizabadi (#134); the decoder-feed design follows the notes on #57. Closes #57. Co-authored-by: Sameh Khamis <[email protected]> Co-authored-by: Mazeyar Moeini Feizabadi <[email protected]>
This commit is contained in:
78 files changed
+12267
-108
No files matched your search
@@ -0,0 +1,624 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { readFileSync } from 'node:fs';
|
||||
|
||||
import { classifyAircraft } from '../data/aircraftClass.js';
|
||||
import { recordFromDecoderTrack } from '../sources/adsbRecords.js';
|
||||
import {
|
||||
AdsbStreamDecoder,
|
||||
LOCAL_ADSB_STALE_MS,
|
||||
decodeAdsbMessage,
|
||||
extractAdsbMessages,
|
||||
modeSChecksum,
|
||||
pruneAircraftTracks,
|
||||
updateAircraftTrack,
|
||||
} from './adsbDecoder.js';
|
||||
|
||||
function fromHex(value) {
|
||||
return Uint8Array.from(value.match(/../g), (pair) =>
|
||||
Number.parseInt(pair, 16),
|
||||
);
|
||||
}
|
||||
|
||||
function synthesizeIq(
|
||||
bytes,
|
||||
{ floor = 128, high = 255, preambleTail = null } = {},
|
||||
) {
|
||||
const sampleCount = 16 + 112 * 2 + 8;
|
||||
const iq = new Uint8Array(sampleCount * 2).fill(128);
|
||||
for (let sample = 0; sample < sampleCount; sample += 1)
|
||||
iq[sample * 2] = floor;
|
||||
const pulse = (sample) => {
|
||||
iq[sample * 2] = high;
|
||||
};
|
||||
for (const offset of [0, 2, 7, 9]) pulse(offset);
|
||||
if (Number.isFinite(preambleTail)) {
|
||||
for (let sample = 10; sample < 16; sample += 1)
|
||||
iq[sample * 2] = preambleTail;
|
||||
}
|
||||
for (let index = 0; index < 112; index += 1) {
|
||||
const value = (bytes[index >> 3] >> (7 - (index & 7))) & 1;
|
||||
pulse(16 + index * 2 + (value ? 0 : 1));
|
||||
}
|
||||
return iq.buffer;
|
||||
}
|
||||
|
||||
test('decodes standard callsign, velocity, and altitude examples', () => {
|
||||
const callsign = decodeAdsbMessage(fromHex('8D4840D6202CC371C32CE0576098'));
|
||||
assert.equal(callsign.callsign, 'KLM1023');
|
||||
assert.equal(callsign.icao, '4840D6');
|
||||
|
||||
const velocity = decodeAdsbMessage(fromHex('8D485020994409940838175B284F'));
|
||||
assert.ok(Math.abs(velocity.speedKt - 159.2) < 0.1);
|
||||
assert.ok(Math.abs(velocity.headingDeg - 182.88) < 0.1);
|
||||
assert.equal(velocity.verticalRateFpm, -832);
|
||||
|
||||
const position = decodeAdsbMessage(fromHex('8D40621D58C382D690C8AC2863A7'));
|
||||
assert.equal(position.altitudeFt, 38_000);
|
||||
assert.equal(position.cpr.odd, false);
|
||||
});
|
||||
|
||||
test('globally decodes a valid even/odd CPR pair and expires tracks at 60 seconds', () => {
|
||||
const tracks = new Map();
|
||||
const even = decodeAdsbMessage(fromHex('8D40621D58C382D690C8AC2863A7'), {
|
||||
receivedAt: 1_000,
|
||||
});
|
||||
const odd = decodeAdsbMessage(fromHex('8D40621D58C386435CC412692AD6'), {
|
||||
receivedAt: 1_500,
|
||||
});
|
||||
updateAircraftTrack(tracks, even);
|
||||
const aircraft = updateAircraftTrack(tracks, odd);
|
||||
assert.ok(Math.abs(aircraft.latitude - 52.26578) < 0.0001);
|
||||
assert.ok(Math.abs(aircraft.longitude - 3.93891) < 0.0001);
|
||||
assert.equal(aircraft.lastPositionAt, 1_500);
|
||||
assert.equal(LOCAL_ADSB_STALE_MS, 60_000);
|
||||
assert.equal(
|
||||
pruneAircraftTracks(tracks, 61_499),
|
||||
0,
|
||||
'contact survives below 60 seconds',
|
||||
);
|
||||
assert.equal(
|
||||
pruneAircraftTracks(tracks, 61_500),
|
||||
1,
|
||||
'contact expires at 60 seconds',
|
||||
);
|
||||
assert.equal(tracks.size, 0);
|
||||
});
|
||||
|
||||
test('extracts a CRC-valid Mode S frame from synthetic 2 Msps IQ', () => {
|
||||
const bytes = fromHex('8D4840D6202CC371C32CE0576098');
|
||||
assert.equal(modeSChecksum(bytes), 0);
|
||||
const frames = extractAdsbMessages(synthesizeIq(bytes), 2_000_000);
|
||||
assert.equal(frames.length, 1);
|
||||
assert.deepEqual(frames[0], bytes);
|
||||
});
|
||||
|
||||
test('accepts a valid weak frame above an elevated local noise floor', () => {
|
||||
const bytes = fromHex('8D4840D6202CC371C32CE0576098');
|
||||
const frames = extractAdsbMessages(
|
||||
synthesizeIq(bytes, { floor: 140, high: 150 }),
|
||||
2_000_000,
|
||||
);
|
||||
assert.equal(frames.length, 1);
|
||||
assert.deepEqual(frames[0], bytes);
|
||||
});
|
||||
|
||||
test('accepts a real-shaped preamble with energy trailing its final pulse', () => {
|
||||
const bytes = fromHex('8D4840D6202CC371C32CE0576098');
|
||||
const frames = extractAdsbMessages(
|
||||
synthesizeIq(bytes, {
|
||||
floor: 138,
|
||||
high: 148,
|
||||
preambleTail: 145,
|
||||
}),
|
||||
2_000_000,
|
||||
);
|
||||
assert.equal(frames.length, 1);
|
||||
assert.deepEqual(frames[0], bytes);
|
||||
});
|
||||
|
||||
test('preserves a Mode S frame split across consecutive USB blocks', () => {
|
||||
const bytes = fromHex('8D4840D6202CC371C32CE0576098');
|
||||
const iq = new Uint8Array(synthesizeIq(bytes));
|
||||
const decoder = new AdsbStreamDecoder();
|
||||
assert.deepEqual(decoder.extract(iq.slice(0, 300).buffer, 2_000_000), []);
|
||||
assert.deepEqual(decoder.extract(iq.slice(300).buffer, 2_000_000), [bytes]);
|
||||
decoder.reset();
|
||||
assert.deepEqual(decoder.extract(iq.slice(300).buffer, 2_000_000), []);
|
||||
});
|
||||
|
||||
test('rejects corrupt frames and unsupported sample rates', () => {
|
||||
const bytes = fromHex('8D4840D6202CC371C32CE0576098');
|
||||
bytes[5] ^= 0x01;
|
||||
assert.notEqual(modeSChecksum(bytes), 0);
|
||||
assert.equal(decodeAdsbMessage(bytes), null);
|
||||
assert.deepEqual(extractAdsbMessages(synthesizeIq(bytes), 1_024_000), []);
|
||||
});
|
||||
|
||||
const AUSTIN_RECEIVER = Object.freeze({ latitude: 30.27, longitude: -97.8 });
|
||||
const fixtureFrames = readFileSync(
|
||||
new URL('../data/fixtures/adsb-austin-frames.txt', import.meta.url),
|
||||
'utf8',
|
||||
)
|
||||
.split('\n')
|
||||
.map((line) => line.trim())
|
||||
.filter(Boolean)
|
||||
.map((line) => fromHex(line.replace(/^\*|;$/g, '')));
|
||||
const dump1090 = JSON.parse(
|
||||
readFileSync(
|
||||
new URL(
|
||||
'../data/fixtures/adsb-austin-dump1090-aircraft.json',
|
||||
import.meta.url,
|
||||
),
|
||||
'utf8',
|
||||
),
|
||||
);
|
||||
|
||||
// The capture keeps receive order but not receive times, so frames are spaced
|
||||
// 100 ms apart: every even/odd pair then falls inside the 10 s CPR window.
|
||||
function decodeFixture(receiverLocation) {
|
||||
const tracks = new Map();
|
||||
fixtureFrames.forEach((bytes, index) => {
|
||||
const message = decodeAdsbMessage(bytes, { receivedAt: (index + 1) * 100 });
|
||||
if (message) updateAircraftTrack(tracks, message, receiverLocation);
|
||||
});
|
||||
return tracks;
|
||||
}
|
||||
|
||||
test('real Austin frames decode to the same aircraft, callsigns and positions as dump1090', () => {
|
||||
assert.equal(fixtureFrames.length, 112);
|
||||
const tracks = decodeFixture(AUSTIN_RECEIVER);
|
||||
const heard = [...tracks.keys()].map((icao) => icao.toLowerCase()).sort();
|
||||
assert.deepEqual(heard, dump1090.aircraft.map((entry) => entry.hex).sort());
|
||||
for (const oracle of dump1090.aircraft) {
|
||||
const track = tracks.get(oracle.hex.toUpperCase());
|
||||
if (oracle.flight)
|
||||
assert.equal(track.callsign, oracle.flight.trim(), oracle.hex);
|
||||
if (Number.isFinite(oracle.alt_baro))
|
||||
assert.equal(track.altitudeFt, oracle.alt_baro, oracle.hex);
|
||||
if (Number.isFinite(oracle.gs))
|
||||
assert.ok(Math.abs(track.speedKt - oracle.gs) < 0.5, oracle.hex);
|
||||
if (Number.isFinite(oracle.track))
|
||||
assert.ok(Math.abs(track.headingDeg - oracle.track) < 0.5, oracle.hex);
|
||||
if (Number.isFinite(oracle.baro_rate))
|
||||
assert.equal(track.verticalRateFpm, oracle.baro_rate, oracle.hex);
|
||||
if (!Number.isFinite(oracle.lat)) continue;
|
||||
assert.ok(
|
||||
Math.abs(track.latitude - oracle.lat) < 0.01,
|
||||
`${oracle.hex} latitude`,
|
||||
);
|
||||
assert.ok(
|
||||
Math.abs(track.longitude - oracle.lon) < 0.01,
|
||||
`${oracle.hex} longitude`,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
test('receiver-relative CPR positions an even-only aircraft that dump1090 left unpositioned', () => {
|
||||
// SKW3301 (a15c54) sent three airborne positions, all even-parity, so no
|
||||
// global even/odd pair exists. dump1090 ran without a receiver location and
|
||||
// could not position it; with one, the local decode places it near AUS.
|
||||
const skywest = fixtureFrames.filter(
|
||||
(bytes) =>
|
||||
decodeAdsbMessage(bytes)?.icao === 'A15C54' &&
|
||||
decodeAdsbMessage(bytes).cpr,
|
||||
);
|
||||
assert.equal(skywest.length, 3);
|
||||
assert.ok(
|
||||
skywest.every((bytes) => decodeAdsbMessage(bytes).cpr.odd === false),
|
||||
);
|
||||
|
||||
const located = decodeFixture(AUSTIN_RECEIVER).get('A15C54');
|
||||
assert.ok(Math.abs(located.latitude - 30.1599) < 0.01);
|
||||
assert.ok(Math.abs(located.longitude + 97.7903) < 0.01);
|
||||
|
||||
const unlocated = decodeFixture(null);
|
||||
assert.equal(unlocated.get('A15C54').latitude, null);
|
||||
const positioned = [...unlocated.values()]
|
||||
.filter((track) => Number.isFinite(track.latitude))
|
||||
.map((track) => track.icao.toLowerCase())
|
||||
.sort();
|
||||
assert.deepEqual(
|
||||
positioned,
|
||||
dump1090.aircraft
|
||||
.filter((entry) => Number.isFinite(entry.lat))
|
||||
.map((entry) => entry.hex)
|
||||
.sort(),
|
||||
'without a receiver location the positioned set matches dump1090 exactly',
|
||||
);
|
||||
});
|
||||
|
||||
// A second real capture over Austin with receive times: 846 extended
|
||||
// squitters from six aircraft, each frame timed by interpolating between the
|
||||
// frames whose decoded position matches a dump1090 fix (dump1090's `t -
|
||||
// seen_pos`), plus dump1090's own positions for the same interval.
|
||||
const timed = JSON.parse(
|
||||
readFileSync(
|
||||
new URL('../data/fixtures/adsb-austin-capture-timed.json', import.meta.url),
|
||||
'utf8',
|
||||
),
|
||||
);
|
||||
|
||||
function nauticalMiles(a, b) {
|
||||
const toRad = Math.PI / 180;
|
||||
const dLat = (b.lat - a.lat) * toRad;
|
||||
const dLon = (b.lon - a.lon) * toRad;
|
||||
const h =
|
||||
Math.sin(dLat / 2) ** 2 +
|
||||
Math.cos(a.lat * toRad) * Math.cos(b.lat * toRad) * Math.sin(dLon / 2) ** 2;
|
||||
return 2 * 3440.065 * Math.asin(Math.sqrt(h));
|
||||
}
|
||||
|
||||
function replayTimed({ inject = null, receiver = timed.receiver } = {}) {
|
||||
const tracks = new Map();
|
||||
const stats = {};
|
||||
const accepted = new Map();
|
||||
for (const [receivedAt, hex] of timed.frames) {
|
||||
const message = decodeAdsbMessage(fromHex(hex), { receivedAt });
|
||||
if (!message) continue;
|
||||
for (const extra of inject?.(message) || []) {
|
||||
updateAircraftTrack(tracks, extra, receiver, stats);
|
||||
}
|
||||
const track = updateAircraftTrack(tracks, message, receiver, stats);
|
||||
if (message.cpr && track.lastPositionAt === receivedAt) {
|
||||
const key = message.icao.toLowerCase();
|
||||
if (!accepted.has(key)) accepted.set(key, []);
|
||||
accepted.get(key).push({
|
||||
at: receivedAt,
|
||||
lat: track.latitude,
|
||||
lon: track.longitude,
|
||||
});
|
||||
}
|
||||
}
|
||||
return { tracks, stats, accepted };
|
||||
}
|
||||
|
||||
function dump1090Final(hex) {
|
||||
const [, lat, lon] = timed.dump1090[hex].fixes.at(-1);
|
||||
return { lat, lon };
|
||||
}
|
||||
|
||||
test('identification messages decode to the dump1090 emitter category strings', () => {
|
||||
const { tracks } = replayTimed();
|
||||
const decoded = Object.fromEntries(
|
||||
Object.keys(timed.dump1090).map((hex) => [
|
||||
hex,
|
||||
tracks.get(hex.toUpperCase()).category,
|
||||
]),
|
||||
);
|
||||
assert.deepEqual(decoded, {
|
||||
'0d0c07': 'A2',
|
||||
a3627d: 'A3',
|
||||
a0b702: 'A7',
|
||||
a5b3a7: 'A3',
|
||||
abe7c5: 'A3',
|
||||
a27e81: 'A1',
|
||||
});
|
||||
for (const [hex, oracle] of Object.entries(timed.dump1090))
|
||||
assert.equal(decoded[hex], oracle.category, hex);
|
||||
// Category set D (type code 1) and C (type code 2) follow the same rule.
|
||||
const message = decodeAdsbMessage(fromHex('8D4840D6202CC371C32CE0576098'));
|
||||
assert.equal(message.typeCode, 4);
|
||||
assert.equal(message.category, 'A0');
|
||||
});
|
||||
|
||||
test('145TX, a rotorcraft (A7), classifies as a helicopter', () => {
|
||||
const { tracks } = replayTimed();
|
||||
const heli = tracks.get('A0B702');
|
||||
assert.equal(heli.callsign, '145TX');
|
||||
assert.equal(classifyAircraft({ category: heli.category }), 'helicopter');
|
||||
assert.equal(
|
||||
classifyAircraft({ category: tracks.get('A27E81').category }),
|
||||
'light',
|
||||
);
|
||||
});
|
||||
|
||||
test('the speed check refuses none of the capture and every track ends on dump1090', () => {
|
||||
const { tracks, stats, accepted } = replayTimed();
|
||||
assert.equal(stats.positionsRejected || 0, 0);
|
||||
for (const hex of Object.keys(timed.dump1090)) {
|
||||
const track = tracks.get(hex.toUpperCase());
|
||||
assert.equal(track.rejectedPositions, 0, `${hex} rejected a fix`);
|
||||
const fixes = accepted.get(hex);
|
||||
assert.ok(fixes.length >= 20, `${hex}: ${fixes.length} fixes`);
|
||||
const delta = nauticalMiles(fixes.at(-1), dump1090Final(hex));
|
||||
assert.ok(delta < 0.3, `${hex} ends ${delta.toFixed(3)} nm from dump1090`);
|
||||
}
|
||||
});
|
||||
|
||||
test("N26VB's 1.0 nm step spans a 27 s reception gap at its reported speed", () => {
|
||||
// The field report read this as a bad decode. The step follows single odd
|
||||
// frames decoded against the receiver location, which dump1090 (run without
|
||||
// one) never positions; the implied speed matches the reported 134 kt.
|
||||
const { tracks, accepted } = replayTimed();
|
||||
const fixes = accepted.get('a27e81');
|
||||
let widest = null;
|
||||
for (let index = 1; index < fixes.length; index += 1) {
|
||||
const step = nauticalMiles(fixes[index - 1], fixes[index]);
|
||||
if (!widest || step > widest.step)
|
||||
widest = {
|
||||
step,
|
||||
seconds: (fixes[index].at - fixes[index - 1].at) / 1000,
|
||||
};
|
||||
}
|
||||
assert.ok(Math.abs(widest.step - 1.0) < 0.05, `${widest.step} nm`);
|
||||
assert.ok(widest.seconds > 25, `${widest.seconds} s`);
|
||||
const impliedKt = widest.step / (widest.seconds / 3600);
|
||||
assert.ok(Math.abs(impliedKt - 134) < 10, `${impliedKt.toFixed(0)} kt`);
|
||||
assert.equal(tracks.get('A27E81').rejectedPositions, 0);
|
||||
});
|
||||
|
||||
test('a corrupt even/odd pair is refused and the track stays on dump1090', () => {
|
||||
// Pair a foreign odd frame (ENY3344, 27 nm away) with N26VB's fresh even
|
||||
// frame: the global decode lands far off the track, as a mixed-up pair does.
|
||||
const foreign = timed.frames
|
||||
.map(([, hex]) => decodeAdsbMessage(fromHex(hex)))
|
||||
.find((message) => message?.icao === 'A3627D' && message.cpr?.odd);
|
||||
let injected = 0;
|
||||
const { tracks, stats, accepted } = replayTimed({
|
||||
inject(message) {
|
||||
if (message.icao !== 'A27E81' || message.cpr?.odd !== false) return [];
|
||||
if (injected >= 2) return [];
|
||||
injected += 1;
|
||||
return [
|
||||
{
|
||||
...foreign,
|
||||
icao: 'A27E81',
|
||||
receivedAt: message.receivedAt - 1,
|
||||
cpr: { ...foreign.cpr, receivedAt: message.receivedAt - 1 },
|
||||
},
|
||||
];
|
||||
},
|
||||
});
|
||||
const track = tracks.get('A27E81');
|
||||
assert.ok(track.rejectedPositions >= 1);
|
||||
assert.equal(stats.positionsRejected, track.rejectedPositions);
|
||||
for (const fix of accepted.get('a27e81'))
|
||||
assert.ok(
|
||||
nauticalMiles(fix, { lat: 30.32, lon: -97.91 }) < 3,
|
||||
'no accepted fix leaves the track',
|
||||
);
|
||||
assert.ok(
|
||||
nauticalMiles(accepted.get('a27e81').at(-1), dump1090Final('a27e81')) < 0.3,
|
||||
);
|
||||
});
|
||||
|
||||
test('a lone frame decodes relative to the aircraft own recent position', () => {
|
||||
const tracks = new Map();
|
||||
const even = decodeAdsbMessage(fromHex('8D40621D58C382D690C8AC2863A7'), {
|
||||
receivedAt: 1_000,
|
||||
});
|
||||
const odd = decodeAdsbMessage(fromHex('8D40621D58C386435CC412692AD6'), {
|
||||
receivedAt: 1_500,
|
||||
});
|
||||
updateAircraftTrack(tracks, even);
|
||||
updateAircraftTrack(tracks, odd);
|
||||
// 20 s later the pair has expired and there is no receiver location.
|
||||
const later = decodeAdsbMessage(fromHex('8D40621D58C386435CC412692AD6'), {
|
||||
receivedAt: 20_000,
|
||||
});
|
||||
const track = updateAircraftTrack(tracks, later, null);
|
||||
assert.equal(track.lastPositionAt, 20_000);
|
||||
assert.ok(Math.abs(track.latitude - 52.26578) < 0.0001);
|
||||
assert.ok(Math.abs(track.longitude - 3.93891) < 0.0001);
|
||||
});
|
||||
|
||||
test('three refused global fixes in a row re-anchor the track', () => {
|
||||
const tracks = new Map();
|
||||
const stats = {};
|
||||
updateAircraftTrack(
|
||||
tracks,
|
||||
decodeAdsbMessage(fromHex('8D40621D58C382D690C8AC2863A7'), {
|
||||
receivedAt: 1_000,
|
||||
}),
|
||||
);
|
||||
updateAircraftTrack(
|
||||
tracks,
|
||||
decodeAdsbMessage(fromHex('8D40621D58C386435CC412692AD6'), {
|
||||
receivedAt: 1_500,
|
||||
}),
|
||||
);
|
||||
// Austin pairs relabelled as this aircraft: global decodes 8,000 km away.
|
||||
const austin = timed.frames
|
||||
.map(([, hex]) => decodeAdsbMessage(fromHex(hex)))
|
||||
.filter((message) => message?.icao === 'A0B702' && message.cpr);
|
||||
const firstOdd = austin.find((message) => message.cpr.odd);
|
||||
const firstEven = austin.find((message) => !message.cpr.odd);
|
||||
let at = 2_000;
|
||||
const feed = (message) => {
|
||||
at += 500;
|
||||
return updateAircraftTrack(
|
||||
tracks,
|
||||
{
|
||||
...message,
|
||||
icao: '40621D',
|
||||
receivedAt: at,
|
||||
cpr: { ...message.cpr, receivedAt: at },
|
||||
},
|
||||
null,
|
||||
stats,
|
||||
);
|
||||
};
|
||||
feed(firstEven);
|
||||
let track = feed(firstOdd);
|
||||
assert.equal(track.rejectedPositions, 2);
|
||||
assert.ok(Math.abs(track.latitude - 52.26578) < 0.0001, 'still anchored');
|
||||
track = feed(firstEven);
|
||||
assert.equal(stats.positionsRejected, 2, 'the third global fix re-anchors');
|
||||
assert.ok(Math.abs(track.latitude - 30.2) < 0.2, 'moved to the new stream');
|
||||
assert.equal(track.rejectStreak, 0);
|
||||
});
|
||||
|
||||
// Surface position examples from "The 1090MHz Riddle" (J. Sun), surface
|
||||
// position chapter: ICAO C8200A, even 8CC8200A3AC8F009BCDEF2..., odd
|
||||
// 8FC8200A3AB8F5F893096B..., receiver (-43.496, 172.558); published result
|
||||
// (-43.48564, 172.53942). The book prints the parity field as zeros, so the
|
||||
// 24-bit parity is recomputed here to make the frames CRC-valid.
|
||||
function withParity(hex) {
|
||||
const bytes = fromHex(hex);
|
||||
// The Mode S parity is the CRC remainder of the first 88 bits.
|
||||
const parity = modeSChecksum(bytes.slice(0, 11));
|
||||
bytes[11] = (parity >> 16) & 0xff;
|
||||
bytes[12] = (parity >> 8) & 0xff;
|
||||
bytes[13] = parity & 0xff;
|
||||
assert.equal(modeSChecksum(bytes), 0);
|
||||
return bytes;
|
||||
}
|
||||
const SURFACE_EVEN = withParity('8CC8200A3AC8F009BCDEF2000000');
|
||||
const SURFACE_ODD = withParity('8FC8200A3AB8F5F893096B000000');
|
||||
const SURFACE_RECEIVER = { latitude: -43.496, longitude: 172.558 };
|
||||
|
||||
test('surface position messages decode movement, track and ground state', () => {
|
||||
// Odd frame ME field, read by hand: TC 00111 (7), MOV 0101011 (43),
|
||||
// S 1, TRK 0001111 (15), T 0, F 1. MOV 39–93 is 15 kt + 1 kt per step
|
||||
// (43 → 19 kt); TRK is in 360/128° steps (15 → 42.1875°).
|
||||
const odd = decodeAdsbMessage(SURFACE_ODD, { receivedAt: 2_000 });
|
||||
assert.equal(odd.icao, 'C8200A');
|
||||
assert.equal(odd.typeCode, 7);
|
||||
assert.equal(odd.onGround, true);
|
||||
assert.equal(odd.speedKt, 19);
|
||||
assert.equal(odd.headingDeg, 42.1875);
|
||||
assert.equal(odd.altitudeFt, null, 'no altitude on the surface');
|
||||
assert.equal(odd.cpr.surface, true);
|
||||
assert.equal(odd.cpr.odd, true);
|
||||
// Even frame: MOV 0101100 (44 → 20 kt), same track.
|
||||
const even = decodeAdsbMessage(SURFACE_EVEN);
|
||||
assert.equal(even.speedKt, 20);
|
||||
assert.equal(even.cpr.odd, false);
|
||||
|
||||
// A real Schiphol frame with a valid parity (Riddle ground-speed example):
|
||||
// MOV 0101010 (42 → 18 kt), S 1, TRK 0110010 (50 → 140.625°).
|
||||
const schiphol = decodeAdsbMessage(fromHex('8C4841753AAB238733C8CD4020B1'));
|
||||
assert.equal(schiphol.icao, '484175');
|
||||
assert.equal(schiphol.speedKt, 18);
|
||||
assert.equal(schiphol.headingDeg, 140.625);
|
||||
|
||||
// MOV 1 is "stopped"; MOV 0 and a track status of 0 carry no value.
|
||||
const stopped = withParity('8CC8200A3810F009BCDEF2000000');
|
||||
const still = decodeAdsbMessage(stopped);
|
||||
assert.equal(still.speedKt, 0);
|
||||
assert.equal(still.headingDeg, undefined, 'track status 0: no track');
|
||||
});
|
||||
|
||||
test('a surface even/odd pair decodes to the published position and marks the aircraft on the ground', () => {
|
||||
const tracks = new Map();
|
||||
// Airborne first: the landing must clear the old altitude.
|
||||
const airborne = decodeAdsbMessage(fromHex('8D40621D58C382D690C8AC2863A7'));
|
||||
updateAircraftTrack(
|
||||
tracks,
|
||||
// Its altitude only: the CPR belongs to another aircraft.
|
||||
{ ...airborne, icao: 'C8200A', receivedAt: 0, cpr: null },
|
||||
SURFACE_RECEIVER,
|
||||
);
|
||||
updateAircraftTrack(
|
||||
tracks,
|
||||
decodeAdsbMessage(SURFACE_EVEN, { receivedAt: 1_000 }),
|
||||
SURFACE_RECEIVER,
|
||||
);
|
||||
const track = updateAircraftTrack(
|
||||
tracks,
|
||||
decodeAdsbMessage(SURFACE_ODD, { receivedAt: 2_000 }),
|
||||
SURFACE_RECEIVER,
|
||||
);
|
||||
assert.ok(
|
||||
Math.abs(track.latitude - -43.48564) < 0.00001,
|
||||
`${track.latitude}`,
|
||||
);
|
||||
assert.ok(
|
||||
Math.abs(track.longitude - 172.53942) < 0.00001,
|
||||
`${track.longitude}`,
|
||||
);
|
||||
assert.equal(track.lastPositionAt, 2_000);
|
||||
assert.equal(track.onGround, true);
|
||||
assert.equal(track.altitudeFt, null);
|
||||
assert.equal(track.speedKt, 19);
|
||||
const record = recordFromDecoderTrack(track);
|
||||
assert.equal(record.onGround, true);
|
||||
assert.equal(record.altitudeFt, null);
|
||||
assert.ok(Math.abs(record.lat - -43.48564) < 0.00001);
|
||||
|
||||
// An airborne position afterwards clears the ground state.
|
||||
const departed = updateAircraftTrack(
|
||||
tracks,
|
||||
{ ...airborne, icao: 'C8200A', receivedAt: 3_000, cpr: null },
|
||||
SURFACE_RECEIVER,
|
||||
);
|
||||
assert.equal(departed.onGround, false);
|
||||
assert.equal(departed.altitudeFt, 38_000);
|
||||
});
|
||||
|
||||
test('a surface track is seeded by a pair; a single frame then decodes against its own fix', () => {
|
||||
// The receiver is not established to be within 45 NM of the aircraft, so a
|
||||
// lone surface frame does not decode against it (even though this one is).
|
||||
const receiver = { latitude: -43.5, longitude: 172.5 };
|
||||
const tracks = new Map();
|
||||
let track = updateAircraftTrack(
|
||||
tracks,
|
||||
decodeAdsbMessage(SURFACE_EVEN, { receivedAt: 1_000 }),
|
||||
receiver,
|
||||
);
|
||||
assert.equal(track.lastPositionAt, null, 'no single-frame receiver fix');
|
||||
// The even/odd pair seeds the track at the published position.
|
||||
track = updateAircraftTrack(
|
||||
tracks,
|
||||
decodeAdsbMessage(SURFACE_ODD, { receivedAt: 2_000 }),
|
||||
receiver,
|
||||
);
|
||||
assert.ok(Math.abs(track.latitude - -43.48564) < 0.00001);
|
||||
assert.ok(Math.abs(track.longitude - 172.53942) < 0.00001);
|
||||
// With no receiver location, the aircraft's own recent fix is the reference
|
||||
// (the other frame of the pair is too old to pair with).
|
||||
track = updateAircraftTrack(
|
||||
tracks,
|
||||
decodeAdsbMessage(SURFACE_EVEN, { receivedAt: 40_000 }),
|
||||
null,
|
||||
);
|
||||
assert.equal(track.lastPositionAt, 40_000);
|
||||
assert.ok(Math.abs(track.latitude - -43.4856) < 0.001);
|
||||
assert.ok(Math.abs(track.longitude - 172.5394) < 0.001);
|
||||
// An own fix the aircraft may have left by 45 NM or more (unknown speed,
|
||||
// four minutes old) is no single-frame reference either.
|
||||
tracks.set('C8200A', { ...track, speedKt: null, category: null });
|
||||
track = updateAircraftTrack(
|
||||
tracks,
|
||||
decodeAdsbMessage(SURFACE_ODD, { receivedAt: 280_000 }),
|
||||
null,
|
||||
);
|
||||
assert.equal(track.lastPositionAt, 40_000, 'reference too old to trust');
|
||||
// Without any reference a lone surface frame is ambiguous: no position.
|
||||
const blind = updateAircraftTrack(
|
||||
new Map(),
|
||||
decodeAdsbMessage(SURFACE_ODD, { receivedAt: 1_000 }),
|
||||
null,
|
||||
);
|
||||
assert.equal(blind.lastPositionAt, null);
|
||||
assert.equal(blind.onGround, true);
|
||||
});
|
||||
|
||||
// "The 1090MHz Riddle", surface position chapter: Schiphol pair of ICAO
|
||||
// 484175, published position about (52.3206, 4.7347).
|
||||
const SCHIPHOL_EVEN = fromHex('8C4841753AAB238733C8CD4020B1');
|
||||
const SCHIPHOL_ODD = fromHex('8C4841753A9A153237AEF0F275BE');
|
||||
|
||||
test('a far receiver never places a lone surface frame; the next valid pair seeds the track', () => {
|
||||
// About 80 NM from the airport: beyond half a surface zone (45 NM).
|
||||
const receiver = { latitude: 51, longitude: 4.375 };
|
||||
const tracks = new Map();
|
||||
let track = updateAircraftTrack(
|
||||
tracks,
|
||||
decodeAdsbMessage(SCHIPHOL_EVEN, { receivedAt: 1_000 }),
|
||||
receiver,
|
||||
);
|
||||
assert.equal(track.lastPositionAt, null, 'no position from one frame');
|
||||
assert.equal(track.latitude, null, 'never (50.823040, 4.602622)');
|
||||
track = updateAircraftTrack(
|
||||
tracks,
|
||||
decodeAdsbMessage(SCHIPHOL_ODD, { receivedAt: 2_000 }),
|
||||
receiver,
|
||||
);
|
||||
assert.equal(track.lastPositionAt, 2_000);
|
||||
assert.equal(track.rejectedPositions, 0, 'the valid pair is accepted');
|
||||
assert.ok(Math.abs(track.latitude - 52.3206) < 0.002, `${track.latitude}`);
|
||||
assert.ok(Math.abs(track.longitude - 4.7347) < 0.002, `${track.longitude}`);
|
||||
assert.equal(track.onGround, true);
|
||||
});
|
||||
Reference in new issue
Block a user