Table of Contents

1 · What is RDS?

RDS (Radio Data System) is a digital communication standard that transmits data as an inaudible signal modulated onto FM broadcasts (87.5–108 MHz). It was standardised under ETSI EN 50067 and has been in use across Europe since the 1980s.

RDS carries among others the following information:

RDS transmits at 1,187.5 bit/s as a BPSK signal on a 57 kHz subcarrier. A complete PS transmission takes approximately 0.35 seconds under error-free conditions.

2 · Why an AI Plugin?

During long-distance FM reception (DX) – especially via tropospheric ducting or Sporadic-E propagation – signals are often weak and affected by multipath interference or co-channel interference. This results in:

• Packet loss: Entire RDS groups are lost in transit
• Bit errors: Individual bits are decoded incorrectly
• Incomplete PS names: Only 2–3 of the 8 characters are received correctly
• Unknown PI codes: Block A contains errors, PI unreadable

3 · What's New in Version 2.0

Version 2.0 is a major upgrade over v1.0. The following table summarises the most important additions and changes:

4 · Architecture – The Two Plugin Components

5 · Simple Explanation – How the Plugin Works

Imagine listening to an announcement in a busy train station with a lot of background noise. The first time you might only catch "...NR...", the second time "...NRJ...". After hearing it 10 times, you can say with high confidence: the announcement said "NRJ".

That is exactly what the plugin does with RDS data: it listens to many erroneous packets, collects them all, and votes statistically on which character at which position is most likely the correct one. In v2.0 it additionally consults the online fmdx.org transmitter database to cross-check and immediately confirm the station name – even before enough votes have been accumulated.

5.1 · Learning by Voting

The station name (PS) consists of 8 character positions. Each position is voted on separately:

After enough votes, a reliable station name emerges. Through its database the plugin already knows thousands of stations – for recognised ones, the full name is available immediately. In v2.0 the fmdx.org database delivers the name even faster, and with correct mixed-case spelling.

5.2 · fmdx.org Reference Database NEW in v2.0

On startup (and every 6 hours) the plugin downloads the full FM transmitter database from maps.fmdx.org/api/?qth={lat},{lon} centred on the receiver's own location. All transmitters within a radius of 3000 km are indexed into an in-memory lookup table keyed by frequency.

Each fmdx.org entry provides:

• PI code – used to strictly verify received PI codes against known transmitters on the current frequency
• PS name variants – one or more 8-character PS strings the station is known to broadcast (e.g. a station may rotate between "Radio 1 " and "BBC R 1 ")
• Station name – the human-readable full name (e.g. "BBC Radio 1")
• Distance – computed via Haversine formula for distance-aware confirmation thresholds

The bulk download is cached on disk as rdsm_fmdx_cache.json. On restart the cache is loaded immediately (no cold-start delay) and a fresh download is scheduled for when the TTL (6 hours) expires.

5.3 · PS Lock Engine and Hybrid Case NEW in v2.0

Once a PS name has been determined with high confidence, it is locked – the displayed name stops changing until the frequency or PI code changes. This eliminates the flickering that occurs when weak reception alternately produces correct and incorrect characters.

The lock is achieved through three priority levels:

After a lock is set, the dynamic jump engine handles stations with multiple PS variants (e.g. alternating station names). When the live buffer matches a different known variant at ≥ 75%, the locked PS jumps to the new variant without unlocking.

5.4 · Frequency Change and Pre-Cache

When tuning to a new frequency, the following sequence runs:

5.5 · Dynamic vs. Static Stations

Some stations scroll their PS name or change it regularly (e.g. to display song information). The plugin detects this automatically:

5.6 · Alternate Frequency (AF) Decoding NEW in v2.0

RDS Group 0A Block C carries up to two AF codes per group. The plugin decodes these codes according to the ETSI EN 50067 formula:

function decodeAFCode(code) {
  // code 1–204 → frequency in MHz: (code + 875) / 10
  // e.g. code 1 → 87.6 MHz, code 204 → 107.9 MHz
  if (code >= 1 && code <= 204) return (code + 875) / 10;
  return null;   // 205–255 are special codes (filler, LF/MF, ...)
}

Decoded frequencies are:

• Stored in the DB entry as entry.af[] (sorted, deduplicated)
• Displayed in the panel's AF flag (shows count; tooltip lists all MHz values)
• Forwarded to the web server's dataHandler in Follow mode

5.7 · RDS Follow Mode

The plugin operates in two modes:

5.8 · The Panel – Display Elements

6 · Technical Deep Dive

6.1 · RDS Group Structure and Error Correction

An RDS group consists of 4 blocks of 26 bits each (16 bits payload + 10 bits CRC checksum). The error correction code is a shortened cyclic code capable of detecting up to 5 bit errors and correcting up to 2 bit errors per block.

The plugin receives these error levels as the array errB[0..3] and converts them into confidence weights:

Group types and their relevance to the plugin

6.2 · fmdx.org Bulk Index and Distance Filter NEW in v2.0

After downloading the bulk transmitter data from maps.fmdx.org/api/?qth={lat},{lon}, the plugin builds an in-memory index. The data flows through the following pipeline:

Reference matching at runtime

When a PI is confirmed on frequency f:

function findBestRefEntry(pi) {
  const refs   = fmdxByFreq[roundFreq(currentFreq)] || [];
  const exact  = refs.filter(r => r.pi === pi.toUpperCase());
  if (exact.length === 0) return null;   // strict: PI must be on THIS freq
  return exact.sort((a,b) => a.distKm - b.distKm)[0];
}

The PS match score between the live raw buffer and each fmdx.org variant is computed position-aware using only clean positions (errB ≤ 1):

function computeRefMatchScore(pi) {
  const ref = findRefEntry(pi);
  if (!ref?.psVariants?.length) return 0;
  let best = 0;
  for (const variant of ref.psVariants) {
    const rv = variant.toUpperCase().padEnd(8, ' ');
    let m = 0, c = 0;
    for (let i = 0; i < 8; i++) {
      if (!cleanPositions[i]) continue;
      c++;
      if (rv[i] === buf[i].toUpperCase()) m++;
    }
    const s = c > 0 ? m/c : 0;
    if (s > best) best = s;
  }
  return best;   // 0.0 – 1.0
}

6.3 · PS Lock Engine – Priority Ladder NEW in v2.0

The PS lock is managed by checkAndLockPS(pi), called after every complete PS round (all 4 segments received):

Hybrid PS construction

function buildHybridPS(referenceStr) {
  let hybrid = "";
  const ref = referenceStr.padEnd(8, ' ');
  for (let i = 0; i < 8; i++) {
    const rawChar = psBuf[i] || ' ';
    const rawErr  = psErrBuf[i];
    const refChar = ref[i];
    // Accept raw case where the letter matches the reference
    if (rawErr <= 2 && rawChar.toUpperCase() === refChar.toUpperCase())
      hybrid += rawChar;       // e.g. 'a' from raw, 'A' from ref → 'a'
    else
      hybrid += refChar;       // reference character as fallback
  }
  return hybrid;
}

6.4 · Voting Engine – Compact Aggregation Format

A compact aggregated format is used instead of a list of individual timestamps:

Format per character position (JSON)

// db[pi].ps[position][character]
{
  "w":         147.3,         // current weighted score (lazy-decayed)
  "count":     18,            // raw number of votes received
  "firstSeen": 1773554046944, // Unix timestamp of first vote (ms)
  "lastSeen":  1773554677188  // Unix timestamp of last vote (ms)
}

Lazy Exponential Decay

The weight w decays exponentially with a half-life of 7 days. The calculation is performed lazily – only on the next access:

function applyDecay(v, now) {
  const ageMs  = now - v.lastSeen;
  const halfMs = 7 * 86400000;              // 7 days in milliseconds
  v.w        = v.w * Math.pow(0.5, ageMs / halfMs);
  v.lastSeen = now;
}

Values below 0.1 weight with fewer than 3 votes are deleted on the next write access (noise suppression).

Consistency Boost

When a character already clearly dominates (weight > 2× all competitors combined), the new vote receives a multiplier of 1.5×. This accelerates convergence for unambiguous stations.

6.5 · Confidence Calculation

The confidence per PS slot is composed from three components:

conf = share      * 0.5   // winner's share of total weight
     + dominance  * 0.3   // gap between winner and runner-up
     + voteFactor * 0.2   // experience factor (saturates at 30+ votes)

// Upper bound: 0.97 (never 100% confidence from DB alone)

Confidence Scale – Colour Mapping in the Panel

Normal: rgb(v) where v = 20 + conf × 220  ·  ref-match: warm gold rgb(r,g,b)  ·  ref-seed: amber  ·  bigram: v = 15 + conf × 30

PS source types (v2.0)

6.6 · PI Verification Pipeline CHANGED in v2.0

The pipeline is extended in v2.0 with distance-aware confirmation thresholds and fmdx.org seeding:

6.7 · Database Format and Storage Management CHANGED in v2.0

File structure (rdsm_memory.json)

{
  "_meta": {
    "rdsFollowMode": false,     // restored on restart
    "savedAt": 1773556231184,
    "dbVersion": 1              // NEW: triggers one-time wipe if mismatch
  },
  "D3C3": {
    "freq":          "104.00",       // rounded frequency (±0.1 MHz)
    "ps":            { "0": { "N": {w,count,firstSeen,lastSeen}, ... }, ... },
    "psResolved":    "NRJ     ",    // current best voting result
    "psConf":        [0.97,0.95,0.93,0,0,0,0,0],
    "psVerifiedRaw": "NRJ     ",    // NEW: stored when all 8 chars verified
    "psVerifiedRawTs": 1773554677188, // NEW: timestamp of verification
    "psIsDynamic":   false,
    "psLastRaw":     ["N","R","J"," "," "," "," "," "],
    "psLastRawTs":   1773554677188,
    "pty":           10,
    "tp":            true,
    "ta":            false,
    "ms":            1,
    "stereo":        true,
    "ecc":           "E1",
    "af":            [89.5, 94.1, 98.0],   // NEW: cached AF list (MHz)
    "seen":          1773554677188,
    "seenCount":     847
  }
}

DB Version Migration

When the server starts and finds a database without _meta.dbVersion === 1, it performs a one-time automatic wipe. This clears the old uppercase-only votes so that mixed-case learning can begin from scratch. The rdsFollowMode setting is preserved across the wipe.

Retention periods and limits

fmdx.org cache file (rdsm_fmdx_cache.json)

{
  "_ts": 1773556231184,   // download timestamp
  "raw": { ... }          // original maps.fmdx.org response
}

The raw response is stored verbatim so that buildFmdxIndex() can be called again with updated own coordinates (e.g. after a GPS fix) without re-downloading.

6.8 · WebSocket Protocol CHANGED in v2.0

Communication between the server plugin and the browser runs over WebSocket on the path /data_plugins. All messages are JSON.

Example rdsm_ai payload (v2.0)

{
  "type":       "rdsm_ai",
  "pi":         "D3C3",
  "ps": [
    { "char": "A", "conf": 0.97, "src": "ref-match"    },
    { "char": "n", "conf": 0.95, "src": "ref-match"    },
    { "char": "t", "conf": 0.90, "src": "ai-voted-high" },
    // ... 5 more slots
  ],
  "rt": { "text": "Dua Lipa - Levitating", "score": 0.72, "src": "raw-rt" },
  "af":         [89.5, 94.1, 98.0],         // NEW: AF list in MHz
  "psName":     "Antenne Bayern",            // NEW: full station name
  "psNameSrc":  "fmdx",                      // NEW: 'fmdx' | null
  "psVariants": ["Antenne ", "ANTENNE "],    // NEW: all known PS variants
  "stats": {
    "freq":          "104.00",
    "seenCount":     847,
    "psVoteTotal":   312,
    "psIsDynamic":   false,
    "psLocked":      true,             // NEW
    "refStation":    "Antenne Bayern", // NEW
    "refDistKm":     142,              // NEW
    "refMatchScore": 95                // NEW (0–100)
  },
  "ts": 1773556231184
}

Example rdsm_freq payload (v2.0)

{
  "type":  "rdsm_freq",
  "freq":  "104.00",
  "reset": true,           // NEW: signals full panel reset
  "pi":    null,
  "ps":    null,
  "stats": {              // NEW: initial zeroed stats
    "freq": "104.00", "seenCount": 0, "psVoteTotal": 0,
    "psIsDynamic": false, "psLocked": false,
    "refStation": null, "refDistKm": null, "refMatchScore": 0
  }
}

6.9 · dataHandler Patch – Property Locking CHANGED in v2.0

v1.0 stripped RDS lines from the native decoder's input stream, breaking external tools. v2.0 uses a different approach: the native decoder receives the complete raw stream, but all writes to the protected fields are intercepted via JavaScript property descriptors:

dh.handleData = function(wss, receivedData, rdsWss) {
  // 1. AI parsing runs first
  interceptLines(receivedData);

  if (aiExclusiveMode) return;

  if (rdsFollowMode && piConfirmed) {
    // 2. Apply AI values
    applyFollowToDataHandler();

    // 3. Lock all RDS fields with no-op setters
    const locked = {};
    fields.forEach(f => {
      locked[f] = dh.dataToSend[f];
      Object.defineProperty(dh.dataToSend, f, {
        get: () => locked[f],
        set: () => {},          // native decoder writes are silently discarded
        configurable: true
      });
    });

    // 4. Run native decoder with FULL raw data (rdsWss/RDS Expert gets it all)
    const result = orig.call(this, wss, receivedData, rdsWss);

    // 5. Restore normal writable properties
    fields.forEach(f => {
      Object.defineProperty(dh.dataToSend, f, {
        value: locked[f], writable: true, configurable: true
      });
    });
    return result;
  }

  // Follow OFF: native decoder runs normally
  return orig.call(this, wss, receivedData, rdsWss);
};

The locked fields include: pi, ps, ps_errors, pty, tp, ta, ms, rt0, rt1, rt0_errors, rt1_errors, rt_flag, ecc, country_iso, country_name, af.

6.10 · Bigram Predictor CHANGED in v2.0

The bigram predictor is an extended fallback of last resort. In v2.0 it is only reached when no raw data, no DB vote above 30% confidence, and no fmdx.org reference seed is available for a position. The table has been significantly expanded:

// Excerpt from the v2.0 bigram table:
BIGRAM = {
  ' ': { 'R':25, 'S':20, 'M':18, 'F':15, ... },
  'F': { 'M':40, 'R':12, 'L': 8,  ... },
  'A': { 'D':15, 'N':14, 'S':12, ... },
  // ... 26 letter rows + digit rows
}

// Confidence of a bigram guess:
conf = (bestScore / totalScore) * 0.25   // max. 25% – clearly a guess

In practice, bigram predictions are almost never visible to the user because one of the higher-priority sources (raw RDS, DB votes, or fmdx.org) fills every slot within a few seconds of reception.

6.11 · GPS WebSocket Listener NEW in v2.0

The server plugin connects as a WebSocket client to its own /data_plugins endpoint to receive GPS messages from a connected GPS plugin:

// Message type: 'GPS' with value.lat, value.lon, value.status
ws.on('message', (raw) => {
  const msg = JSON.parse(raw);
  if (msg.type === 'GPS' && msg.value.status === 'active') {
    if (lat !== ownLat || lon !== ownLon) {
      ownLat = lat; ownLon = lon;
      // Rebuild fmdx.org index from cached raw data with new location
      if (fmdxLoadedAt > 0) buildFmdxIndex(cachedRaw);
    }
  }
});

Reconnection is attempted every 15 seconds on disconnect. The GPS listener starts 5 seconds after plugin initialisation to allow the GPS plugin to connect first. If no GPS data is received, the static location from config.json is used.

7 · REST API CHANGED in v2.0

The plugin registers one HTTP endpoint. (The per-PI detail endpoint from v1.0 was removed in v2.0; all per-station information is now delivered via WebSocket in the rdsm_ai message.)

Example response for /api/rdsm/stats

{
  "stationCount":  312,
  "fmdxFreqCount": 4872,       // NEW: frequencies in fmdx.org index
  "rdsFollowMode": false,
  "aiExclusiveMode": false,
  "piConfirmed":   true,
  "psLocked":      true,         // NEW
  "currentPI":     "D3C3",
  "currentFreq":   "104.00"
}

8 · Configuration Parameters

RDS AI Decoder · Documentation v2.0 · Author: Highpoint · March 2026
github.com/Highpoint2000/RDS-AI-Decoder