rdsclock 0.2.1__tar.gz → 0.2.2__tar.gz

{rdsclock-0.2.1 → rdsclock-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdsclock
-Version: 0.2.1
+Version: 0.2.2
 Summary: Passive RDS Clock-Time receiver for FM via RTL-SDR, with multi-source consensus for GPS-denied environments
 Author-email: Mateusz Klatt <mateusz@klatt.ie>
 License-Expression: Apache-2.0
@@ -267,12 +267,12 @@ the local antenna picks up.
 
 ## Status
 
-- **0.2.1** — current release. Decoder hot path is now ~7× faster
-  than 0.2.0 (5 min broadcast capture decodes in ~50 s on commodity
-  hardware — fast enough for multi-station real-time consensus on
-  a single thread). See [`CHANGELOG.md`](CHANGELOG.md) for the 0.2.0
-  biphase fix that preceded this and made the decoder actually work
-  on real FM. Pre-1.0; the CLI and on-disk formats may still change.
+- **0.2.2** — current release. Operator-facing polish: 250 kS/s SDR
+  captures can now play at 48 kHz audio via rational resampling, and
+  Programme Service names are displayed only after validation so
+  dynamic-PS stations do not show mixed scrolling fragments. Decoder
+  group counts and PI codes remain locked to the 0.2.1 baseline.
+  Pre-1.0; the CLI and on-disk formats may still change.
 - 240+ tests including a real-IQ regression backed by a 6 s capture
   of Polskie Radio Trójka 98.8 from Warsaw; line coverage **100 %**
   (tracked by SonarCloud).

{rdsclock-0.2.1 → rdsclock-0.2.2}/README.md

@@ -229,12 +229,12 @@ the local antenna picks up.
 
 ## Status
 
-- **0.2.1** — current release. Decoder hot path is now ~7× faster
-  than 0.2.0 (5 min broadcast capture decodes in ~50 s on commodity
-  hardware — fast enough for multi-station real-time consensus on
-  a single thread). See [`CHANGELOG.md`](CHANGELOG.md) for the 0.2.0
-  biphase fix that preceded this and made the decoder actually work
-  on real FM. Pre-1.0; the CLI and on-disk formats may still change.
+- **0.2.2** — current release. Operator-facing polish: 250 kS/s SDR
+  captures can now play at 48 kHz audio via rational resampling, and
+  Programme Service names are displayed only after validation so
+  dynamic-PS stations do not show mixed scrolling fragments. Decoder
+  group counts and PI codes remain locked to the 0.2.1 baseline.
+  Pre-1.0; the CLI and on-disk formats may still change.
 - 240+ tests including a real-IQ regression backed by a 6 s capture
   of Polskie Radio Trójka 98.8 from Warsaw; line coverage **100 %**
   (tracked by SonarCloud).

{rdsclock-0.2.1 → rdsclock-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rdsclock"
-version = "0.2.1"
+version = "0.2.2"
 description = "Passive RDS Clock-Time receiver for FM via RTL-SDR, with multi-source consensus for GPS-denied environments"
 readme = "README.md"
 requires-python = ">=3.12"

{rdsclock-0.2.1 → rdsclock-0.2.2}/src/rdsclock/__init__.py

@@ -19,4 +19,4 @@ Modules:
                      scan / recon / demo.
 """
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

{rdsclock-0.2.1 → rdsclock-0.2.2}/src/rdsclock/audio.py

@@ -10,7 +10,7 @@ audio sink is needed; the rest of the package works without it.
 """
 
 import numpy as np
-from scipy.signal import firwin, lfilter, lfilter_zi
+from scipy.signal import firwin, lfilter, lfilter_zi, resample_poly
 
 from .rtl_tcp import RtlTcpClient
 
@@ -33,12 +33,11 @@ def design_audio_filter(
 ) -> tuple[np.ndarray, int]:
     """Design the mono-audio LPF used during decimation from ``fs_in`` to ``fs_out``.
 
-    Returns ``(taps, decimation_factor)``. ``fs_in`` must be an integer
-    multiple of ``fs_out``.
+    Returns ``(taps, decimation_factor)``. Integer SDR/audio ratios return the
+    real decimation factor; rational ratios return ``1`` so callers can apply
+    polyphase resampling after the same low-pass stage.
     """
-    if fs_in % fs_out != 0:
-        raise ValueError(f"SDR sample rate ({fs_in}) must be a multiple of audio rate ({fs_out})")
-    decim = fs_in // fs_out
+    decim = fs_in // fs_out if fs_in % fs_out == 0 else 1
     nyq = fs_in / 2.0
     taps = firwin(numtaps=numtaps, cutoff=cutoff_hz / nyq).astype(np.float32)
     return taps, decim
@@ -53,13 +52,15 @@ def fm_audio_from_iq(
 ) -> np.ndarray:
     """Convert an IQ buffer into a mono audio float32 buffer at ``fs_out``.
 
-    Steps: FM phase demodulation → LPF (cutoff = ``cutoff_hz``) → decimation
-    to ``fs_out`` → optional peak normalisation to ±0.5 to avoid clipping.
+    Steps: FM phase demodulation → LPF (cutoff = ``cutoff_hz``) → rate
+    conversion to ``fs_out`` → optional peak normalisation to ±0.5 to avoid
+    clipping. Integer SDR/audio ratios use the fast FIR decimation path;
+    rational ratios use polyphase resampling after the same LPF stage.
     """
     taps, decim = design_audio_filter(fs_in, fs_out, cutoff_hz=cutoff_hz)
     fm = fm_demod(iq)
     audio, _ = lfilter(taps, 1.0, fm), None
-    audio = audio[::decim]
+    audio = audio[::decim] if fs_in % fs_out == 0 else resample_poly(audio, fs_out, fs_in)
     if normalise:
         peak = float(np.max(np.abs(audio)) + 1e-6)
         audio = (audio / peak) * 0.5
@@ -88,8 +89,10 @@ def play_iq_live(
         ) from exc
 
     chunk_samples = chunk_samples or fs_sdr // 10  # 100 ms per block
-    taps, decim = design_audio_filter(fs_sdr, fs_audio)
-    zi = lfilter_zi(taps, 1.0)
+    integer_decim = fs_sdr % fs_audio == 0
+    if integer_decim:
+        taps, decim = design_audio_filter(fs_sdr, fs_audio)
+        zi = lfilter_zi(taps, 1.0)
 
     sd.default.samplerate = fs_audio
     sd.default.channels = 1
@@ -117,11 +120,14 @@ def play_iq_live(
             try:
                 while True:
                     iq = client.read_iq(chunk_samples, settle_s=0.0)
-                    fm = fm_demod(iq)
-                    audio, zi = lfilter(taps, 1.0, fm, zi=zi)
-                    audio = audio[::decim]
-                    peak = float(np.max(np.abs(audio)) + 1e-6)
-                    audio = (audio / peak) * 0.5
+                    if integer_decim:
+                        fm = fm_demod(iq)
+                        audio, zi = lfilter(taps, 1.0, fm, zi=zi)
+                        audio = audio[::decim]
+                        peak = float(np.max(np.abs(audio)) + 1e-6)
+                        audio = (audio / peak) * 0.5
+                    else:
+                        audio = fm_audio_from_iq(iq, fs_in=fs_sdr, fs_out=fs_audio)
                     stream.write(audio.astype("float32"))
             except KeyboardInterrupt:
                 print("\nInterrupted by operator (Ctrl+C).")
@@ -151,20 +157,7 @@ def play_iq_file(
     if len(iq) == 0 or np.max(np.abs(iq[:1000])) > 100:
         iq = dsp.read_iq_u8(path)
 
-    # If the file was captured at the standard 250 kS/s, decimate by 5 to
-    # reach 50 kS/s, then by ~1.04 to 48 kHz. We keep it simple: design a
-    # filter using a chosen integer ratio and accept whatever audio rate
-    # the file allows.
-    if fs_in % fs_audio == 0:
-        audio = fm_audio_from_iq(iq, fs_in=fs_in, fs_out=fs_audio)
-    else:
-        # Fall back: drop to the largest fs_audio divisor of fs_in.
-        from math import gcd
-
-        target = gcd(fs_in, fs_audio)
-        audio = fm_audio_from_iq(iq, fs_in=fs_in, fs_out=target)
-        fs_audio = target
-
+    audio = fm_audio_from_iq(iq, fs_in=fs_in, fs_out=fs_audio)
     duration_s = len(audio) / fs_audio
     print(f"Playing {path}: {duration_s:.1f}s of audio @ {fs_audio} Hz (Ctrl+C to stop)…")
     try:

{rdsclock-0.2.1 → rdsclock-0.2.2}/src/rdsclock/rds_groups.py

@@ -13,6 +13,7 @@ Supported types:
     4A       — Clock-Time
 """
 
+from collections import deque
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -31,6 +32,10 @@ class StationInfo:
     pi: int | None = None
     pty: int | None = None
     ps_chars: list[str] = field(default_factory=lambda: [" "] * PS_LEN)
+    _ps_candidate: list[str] = field(default_factory=lambda: [" "] * PS_LEN)
+    _ps_segments_seen: int = 0
+    _ps_history: deque[str] = field(default_factory=lambda: deque(maxlen=4))
+    _ps_stable_count: int = 0
     rt_chars: list[str] = field(default_factory=lambda: [" "] * RT_LEN)
     rt_ab_flag: int | None = None
     clock_times: list[ClockTime] = field(default_factory=list)
@@ -38,8 +43,25 @@ class StationInfo:
 
     @property
     def ps_name(self) -> str:
+        """Validated Programme Service name.
+
+        Dynamic-PS stations often scroll text through the PS field. This value
+        remains empty until the same complete 8-character frame has been seen
+        in two consecutive PS completion cycles, then exposes the validated
+        frame with the historical right-padding stripped.
+        """
         return "".join(self.ps_chars).rstrip()
 
+    @property
+    def validated_ps_name(self) -> str:
+        """Alias for :attr:`ps_name`, explicit about the validation semantics."""
+        return self.ps_name
+
+    @property
+    def latest_ps_candidate(self) -> str:
+        """Most recently received complete 8-character PS frame, without validation."""
+        return self._ps_history[-1] if self._ps_history else ""
+
     @property
     def rt_text(self) -> str:
         text = "".join(self.rt_chars)
@@ -83,8 +105,23 @@ def parse_group(group_bytes: Sequence[int], info: StationInfo) -> StationInfo:
     if group_type == 0:
         seg = b & 0x3  # 2-bit segment address (0..3)
         # Block D carries two PS characters
-        info.ps_chars[seg * 2] = _safe_char((d >> 8) & 0xFF)
-        info.ps_chars[seg * 2 + 1] = _safe_char(d & 0xFF)
+        bit = 1 << seg
+        if not info._ps_segments_seen & bit:
+            info._ps_candidate[seg * 2] = _safe_char((d >> 8) & 0xFF)
+            info._ps_candidate[seg * 2 + 1] = _safe_char(d & 0xFF)
+            info._ps_segments_seen |= bit
+        if info._ps_segments_seen == 0b1111:
+            candidate = "".join(info._ps_candidate)
+            previous = info._ps_history[-1] if info._ps_history else None
+            info._ps_history.append(candidate)
+            if candidate == previous:
+                info._ps_stable_count += 1
+            else:
+                info._ps_stable_count = 1
+            if info._ps_stable_count >= 2:
+                info.ps_chars[:] = list(candidate)
+            info._ps_candidate = [" "] * PS_LEN
+            info._ps_segments_seen = 0
 
     elif group_type == 2:
         ab_flag = (b >> 4) & 0x1

{rdsclock-0.2.1 → rdsclock-0.2.2}/src/rdsclock.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdsclock
-Version: 0.2.1
+Version: 0.2.2
 Summary: Passive RDS Clock-Time receiver for FM via RTL-SDR, with multi-source consensus for GPS-denied environments
 Author-email: Mateusz Klatt <mateusz@klatt.ie>
 License-Expression: Apache-2.0
@@ -267,12 +267,12 @@ the local antenna picks up.
 
 ## Status
 
-- **0.2.1** — current release. Decoder hot path is now ~7× faster
-  than 0.2.0 (5 min broadcast capture decodes in ~50 s on commodity
-  hardware — fast enough for multi-station real-time consensus on
-  a single thread). See [`CHANGELOG.md`](CHANGELOG.md) for the 0.2.0
-  biphase fix that preceded this and made the decoder actually work
-  on real FM. Pre-1.0; the CLI and on-disk formats may still change.
+- **0.2.2** — current release. Operator-facing polish: 250 kS/s SDR
+  captures can now play at 48 kHz audio via rational resampling, and
+  Programme Service names are displayed only after validation so
+  dynamic-PS stations do not show mixed scrolling fragments. Decoder
+  group counts and PI codes remain locked to the 0.2.1 baseline.
+  Pre-1.0; the CLI and on-disk formats may still change.
 - 240+ tests including a real-IQ regression backed by a 6 s capture
   of Polskie Radio Trójka 98.8 from Warsaw; line coverage **100 %**
   (tracked by SonarCloud).

{rdsclock-0.2.1 → rdsclock-0.2.2}/tests/test_audio.py

@@ -41,9 +41,10 @@ class TestDesignAudioFilter:
         assert taps.dtype == np.float32
         assert len(taps) == 129  # default numtaps
 
-    def test_rejects_non_integer_ratio(self):
-        with pytest.raises(ValueError):
-            design_audio_filter(1_000_000, 48_000)
+    def test_non_integer_ratio_returns_filter_without_decimation(self):
+        taps, decim = design_audio_filter(1_000_000, 48_000)
+        assert decim == 1
+        assert taps.dtype == np.float32
 
 
 class TestFmAudioFromIq:
@@ -65,6 +66,18 @@ class TestFmAudioFromIq:
         # Normalisation pushes peak to 0.5.
         assert np.max(np.abs(audio)) == pytest.approx(0.5, rel=0.01)
 
+    def test_rational_resampling_ratio_succeeds(self):
+        fs_in = 250_000
+        fs_out = 48_000
+        n = np.arange(fs_in // 10)
+        iq = np.exp(1j * 2 * np.pi * 1_000 * n / fs_in).astype(np.complex64)
+
+        audio = fm_audio_from_iq(iq, fs_in=fs_in, fs_out=fs_out)
+
+        expected_len = len(iq) * fs_out / fs_in
+        assert abs(len(audio) - expected_len) <= 2
+        assert audio.dtype == np.float32
+
     def test_skip_normalisation(self):
         fs_in = 1_200_000
         n = np.arange(fs_in // 2)

{rdsclock-0.2.1 → rdsclock-0.2.2}/tests/test_coverage_edges.py

@@ -160,7 +160,7 @@ def test_audio_play_file_complex64_and_u8_paths(tmp_path, monkeypatch):
     u8_path = tmp_path / "u8-ish.iq"
     np.full(512, 200 + 0j, dtype=np.complex64).tofile(u8_path)
     play_iq_file(str(u8_path), fs_in=50_000, fs_audio=48_000)
-    assert sd.play_calls[-1][1] == 2_000
+    assert sd.play_calls[-1][1] == 48_000
 
 
 def test_audio_play_file_keyboard_interrupt_stops(tmp_path, monkeypatch, capsys):
@@ -207,6 +207,31 @@ def test_audio_play_live_streams_until_keyboard_interrupt(
     assert "Interrupted" in capsys.readouterr().out
 
 
+def test_audio_play_live_supports_rational_audio_rate(monkeypatch, capsys):
+    sd = _FakeSoundDevice()
+    clients: list[_FakeAudioClient] = []
+
+    class RecordingClient(_FakeAudioClient):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            clients.append(self)
+
+    monkeypatch.setitem(sys.modules, "sounddevice", sd)
+    monkeypatch.setattr("rdsclock.audio.RtlTcpClient", RecordingClient)
+
+    play_iq_live(
+        95.5,
+        fs_sdr=50_000,
+        fs_audio=48_000,
+        chunk_samples=256,
+    )
+
+    assert ("sample_rate", 50_000) in clients[0].calls
+    assert sd.stream_writes
+    assert sd.stream_writes[0].dtype == np.float32
+    assert "Interrupted" in capsys.readouterr().out
+
+
 @pytest.mark.parametrize("func,args", [(play_iq_file, ("x.iq",)), (play_iq_live, (95.5,))])
 def test_audio_play_requires_sounddevice(func, args, monkeypatch):
     real_import = builtins.__import__

{rdsclock-0.2.1 → rdsclock-0.2.2}/tests/test_coverage_extra.py

@@ -171,7 +171,7 @@ class TestAudioPlaybackCoverage:
         ):
             audio.play_iq_file("recording.iq", fs_in=250_000, fs_audio=48_000)
 
-        fm_audio_from_iq.assert_called_once_with(iq, fs_in=250_000, fs_out=2_000)
+        fm_audio_from_iq.assert_called_once_with(iq, fs_in=250_000, fs_out=48_000)
         sd_stop.assert_called_once()
 
 

{rdsclock-0.2.1 → rdsclock-0.2.2}/tests/test_rds_groups.py

@@ -14,30 +14,80 @@ from rdsclock.rds_groups import (
 )
 
 
+def _validated_ps_groups(pi: int, ps_name: str) -> list[bytearray]:
+    groups = encode_ps_groups(pi=pi, ps_name=ps_name)
+    return groups + groups
+
+
 class TestPsParsing:
     def test_single_segment(self):
         g = encode_group_0a(pi=0xABCD, ps_segment_index=0, ps_chars="RM")
         info = StationInfo()
         parse_group(g, info)
         assert info.pi == 0xABCD
-        assert info.ps_name == "RM"
+        assert info.ps_name == ""
+        assert info.latest_ps_candidate == ""
 
     def test_all_segments(self):
-        groups = encode_ps_groups(pi=0x3F44, ps_name="RMF FM  ")
+        groups = _validated_ps_groups(pi=0x3F44, ps_name="RMF FM  ")
         info = parse_groups(groups)
         assert info.pi == 0x3F44
         assert info.ps_name == "RMF FM"
+        assert info.validated_ps_name == "RMF FM"
+        assert info.latest_ps_candidate == "RMF FM  "
 
     def test_short_name_padded(self):
-        groups = encode_ps_groups(pi=0x1234, ps_name="ABC")
+        groups = _validated_ps_groups(pi=0x1234, ps_name="ABC")
         info = parse_groups(groups)
         assert info.ps_name == "ABC"
 
     def test_full_eight_chars(self):
-        groups = encode_ps_groups(pi=0x4321, ps_name="RadioZET")
+        groups = _validated_ps_groups(pi=0x4321, ps_name="RadioZET")
         info = parse_groups(groups)
         assert info.ps_name == "RadioZET"
 
+    def test_single_rotation_is_only_latest_candidate(self):
+        groups = encode_ps_groups(pi=0x3001, ps_name="JEDYNKA ")
+        info = parse_groups(groups)
+        assert info.ps_name == ""
+        assert info.latest_ps_candidate == "JEDYNKA "
+        assert info._ps_stable_count == 1
+
+    def test_static_ps_validates_after_two_rotations(self):
+        groups = _validated_ps_groups(pi=0x3001, ps_name="JEDYNKA ")
+        info = parse_groups(groups)
+        assert info.ps_name == "JEDYNKA"
+        assert info.validated_ps_name == "JEDYNKA"
+        assert info.latest_ps_candidate == "JEDYNKA "
+
+    def test_dynamic_ps_requires_consecutive_matching_completions(self):
+        plus = encode_ps_groups(pi=0x3002, ps_name="+PLUS+  ")
+        web = encode_ps_groups(pi=0x3002, ps_name="WWW.RPL ")
+        info = parse_groups(plus + web + plus)
+        assert info.ps_name == ""
+        assert info.latest_ps_candidate == "+PLUS+  "
+        assert info._ps_stable_count == 1
+
+        for group in plus:
+            parse_group(group, info)
+
+        assert info.ps_name == "+PLUS+"
+        assert info.latest_ps_candidate == "+PLUS+  "
+        assert list(info._ps_history) == ["+PLUS+  ", "WWW.RPL ", "+PLUS+  ", "+PLUS+  "]
+
+    def test_duplicate_segment_does_not_overwrite_candidate_rotation(self):
+        groups = [
+            encode_group_0a(pi=0x3003, ps_segment_index=0, ps_chars="JE"),
+            encode_group_0a(pi=0x3003, ps_segment_index=0, ps_chars="XX"),
+            encode_group_0a(pi=0x3003, ps_segment_index=1, ps_chars="DY"),
+            encode_group_0a(pi=0x3003, ps_segment_index=2, ps_chars="NK"),
+            encode_group_0a(pi=0x3003, ps_segment_index=3, ps_chars="A "),
+        ]
+        info = parse_groups(groups + groups)
+        assert info.ps_name == "JEDYNKA"
+        assert info.latest_ps_candidate == "JEDYNKA "
+        assert info._ps_segments_seen == 0
+
     def test_group_count(self):
         groups = encode_ps_groups(pi=0x1111, ps_name="HELLO   ")
         info = parse_groups(groups)

{rdsclock-0.2.1 → rdsclock-0.2.2}/tests/test_synth.py

@@ -35,7 +35,7 @@ class TestBitstreamSynth:
         bits = rds_groups_to_bits(ps, differential=False)  # no differential coding for simplicity
         groups = find_groups_in_bitstream(bits)
         assert len(groups) >= len(ps)
-        info = parse_groups(groups[: len(ps)])
+        info = parse_groups(groups[: len(ps)] + groups[: len(ps)])
         assert info.pi == 0xCAFE
         assert info.ps_name == "HELLO"