Add Airspy SDR support and persist GPS coordinates

Airspy support:
- Add AIRSPY to SDRType enum and driver mappings
- Create AirspyCommandBuilder using SoapySDR tools (rx_fm, readsb, rtl_433)
- Register in SDRFactory and add to hardware type dropdown
- Supports Airspy R2/Mini (24MHz-1.8GHz) and HF+ devices

GPS coordinate persistence:
- Save observer location to localStorage when manually entered or via geolocation
- Restore saved coordinates on page load in both index.html and adsb_dashboard.html
- Coordinates are shared between both pages

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

utils/gps.py

@@ -15,7 +15,7 @@ import threading
 import time
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Optional, Callable
+from typing import Optional, Callable, Union
 
 logger = logging.getLogger('intercept.gps')
 
@@ -457,24 +457,264 @@ class GPSReader:
                 logger.error(f"GPS callback error: {e}")
 
 
+class GPSDClient:
+    """
+    Connects to gpsd daemon for GPS data.
+
+    gpsd provides a unified interface for GPS devices and handles
+    device management, making it ideal when gpsd is already running.
+    """
+
+    DEFAULT_HOST = 'localhost'
+    DEFAULT_PORT = 2947
+
+    def __init__(self, host: str = DEFAULT_HOST, port: int = DEFAULT_PORT):
+        self.host = host
+        self.port = port
+        self._position: Optional[GPSPosition] = None
+        self._lock = threading.Lock()
+        self._running = False
+        self._thread: Optional[threading.Thread] = None
+        self._socket: Optional['socket.socket'] = None
+        self._last_update: Optional[datetime] = None
+        self._error: Optional[str] = None
+        self._callbacks: list[Callable[[GPSPosition], None]] = []
+        self._device: Optional[str] = None
+
+    @property
+    def position(self) -> Optional[GPSPosition]:
+        """Get the current GPS position."""
+        with self._lock:
+            return self._position
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the client is running."""
+        return self._running
+
+    @property
+    def last_update(self) -> Optional[datetime]:
+        """Get the time of the last position update."""
+        with self._lock:
+            return self._last_update
+
+    @property
+    def error(self) -> Optional[str]:
+        """Get any error message."""
+        with self._lock:
+            return self._error
+
+    @property
+    def device_path(self) -> str:
+        """Return gpsd connection info (for compatibility with GPSReader)."""
+        return f"gpsd://{self.host}:{self.port}"
+
+    @property
+    def baudrate(self) -> int:
+        """Return 0 for gpsd (for compatibility with GPSReader)."""
+        return 0
+
+    def add_callback(self, callback: Callable[[GPSPosition], None]) -> None:
+        """Add a callback to be called on position updates."""
+        self._callbacks.append(callback)
+
+    def remove_callback(self, callback: Callable[[GPSPosition], None]) -> None:
+        """Remove a position update callback."""
+        if callback in self._callbacks:
+            self._callbacks.remove(callback)
+
+    def start(self) -> bool:
+        """Start receiving GPS data from gpsd."""
+        import socket
+
+        if self._running:
+            return True
+
+        try:
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self._socket.settimeout(5.0)
+            self._socket.connect((self.host, self.port))
+
+            # Enable JSON watch mode
+            watch_cmd = '?WATCH={"enable":true,"json":true}\n'
+            self._socket.send(watch_cmd.encode('ascii'))
+
+            self._running = True
+            self._error = None
+
+            self._thread = threading.Thread(target=self._read_loop, daemon=True)
+            self._thread.start()
+
+            logger.info(f"Connected to gpsd at {self.host}:{self.port}")
+            print(f"[GPS] Connected to gpsd at {self.host}:{self.port}", flush=True)
+            return True
+
+        except Exception as e:
+            self._error = str(e)
+            logger.error(f"Failed to connect to gpsd at {self.host}:{self.port}: {e}")
+            if self._socket:
+                try:
+                    self._socket.close()
+                except Exception:
+                    pass
+                self._socket = None
+            return False
+
+    def stop(self) -> None:
+        """Stop receiving GPS data."""
+        self._running = False
+
+        if self._socket:
+            try:
+                # Disable watch mode
+                self._socket.send(b'?WATCH={"enable":false}\n')
+                self._socket.close()
+            except Exception:
+                pass
+            self._socket = None
+
+        if self._thread:
+            self._thread.join(timeout=2.0)
+            self._thread = None
+
+        logger.info(f"Disconnected from gpsd at {self.host}:{self.port}")
+
+    def _read_loop(self) -> None:
+        """Background thread loop for reading gpsd data."""
+        import json
+        import socket
+
+        buffer = ""
+        message_count = 0
+
+        print(f"[GPS] gpsd read loop started", flush=True)
+
+        while self._running and self._socket:
+            try:
+                self._socket.settimeout(1.0)
+                data = self._socket.recv(4096)
+
+                if not data:
+                    logger.warning("gpsd connection closed")
+                    with self._lock:
+                        self._error = "Connection closed by gpsd"
+                    break
+
+                buffer += data.decode('ascii', errors='ignore')
+
+                # Process complete JSON lines
+                while '\n' in buffer:
+                    line, buffer = buffer.split('\n', 1)
+                    line = line.strip()
+
+                    if not line:
+                        continue
+
+                    try:
+                        msg = json.loads(line)
+                        msg_class = msg.get('class', '')
+
+                        message_count += 1
+                        if message_count <= 5 or message_count % 20 == 0:
+                            print(f"[GPS] gpsd msg [{message_count}]: {msg_class}", flush=True)
+
+                        if msg_class == 'TPV':
+                            self._handle_tpv(msg)
+                        elif msg_class == 'DEVICES':
+                            # Track connected device
+                            devices = msg.get('devices', [])
+                            if devices:
+                                self._device = devices[0].get('path', 'unknown')
+                                print(f"[GPS] gpsd device: {self._device}", flush=True)
+
+                    except json.JSONDecodeError:
+                        logger.debug(f"Invalid JSON from gpsd: {line[:50]}")
+
+            except socket.timeout:
+                continue
+            except Exception as e:
+                logger.error(f"gpsd read error: {e}")
+                with self._lock:
+                    self._error = str(e)
+                break
+
+    def _handle_tpv(self, msg: dict) -> None:
+        """Handle TPV (Time-Position-Velocity) message from gpsd."""
+        # mode: 0=unknown, 1=no fix, 2=2D fix, 3=3D fix
+        mode = msg.get('mode', 0)
+
+        if mode < 2:
+            # No fix yet
+            return
+
+        lat = msg.get('lat')
+        lon = msg.get('lon')
+
+        if lat is None or lon is None:
+            return
+
+        # Parse timestamp
+        timestamp = None
+        time_str = msg.get('time')
+        if time_str:
+            try:
+                # gpsd uses ISO format: 2024-01-01T12:00:00.000Z
+                timestamp = datetime.fromisoformat(time_str.replace('Z', '+00:00'))
+            except (ValueError, AttributeError):
+                pass
+
+        position = GPSPosition(
+            latitude=lat,
+            longitude=lon,
+            altitude=msg.get('alt'),
+            speed=msg.get('speed'),  # m/s in gpsd (not knots)
+            heading=msg.get('track'),
+            fix_quality=mode,
+            timestamp=timestamp,
+            device=self._device or f"gpsd://{self.host}:{self.port}",
+        )
+
+        print(f"[GPS] gpsd FIX: {lat:.6f}, {lon:.6f} (mode: {mode})", flush=True)
+        self._update_position(position)
+
+    def _update_position(self, position: GPSPosition) -> None:
+        """Update the current position and notify callbacks."""
+        with self._lock:
+            self._position = position
+            self._last_update = datetime.utcnow()
+            self._error = None
+
+        # Notify callbacks
+        for callback in self._callbacks:
+            try:
+                callback(position)
+            except Exception as e:
+                logger.error(f"GPS callback error: {e}")
+
+
+# Type alias for GPS source (either serial reader or gpsd client)
+GPSSource = Union[GPSReader, GPSDClient]
+
 # Global GPS reader instance
-_gps_reader: Optional[GPSReader] = None
+_gps_reader: Optional[GPSSource] = None
 _gps_lock = threading.Lock()
 
 
-def get_gps_reader() -> Optional[GPSReader]:
-    """Get the global GPS reader instance."""
+def get_gps_reader() -> Optional[GPSSource]:
+    """Get the global GPS reader/client instance."""
     with _gps_lock:
         return _gps_reader
 
 
-def start_gps(device_path: str, baudrate: int = 9600) -> bool:
+def start_gps(device_path: str, baudrate: int = 9600,
+               callback: Optional[Callable[[GPSPosition], None]] = None) -> bool:
     """
     Start the global GPS reader.
 
     Args:
         device_path: Path to the GPS serial device
         baudrate: Serial baudrate (default 9600)
+        callback: Optional callback for position updates (registered before start to avoid race condition)
 
     Returns:
         True if started successfully
@@ -487,11 +727,45 @@ def start_gps(device_path: str, baudrate: int = 9600) -> bool:
             _gps_reader.stop()
 
         _gps_reader = GPSReader(device_path, baudrate)
+
+        # Register callback BEFORE starting to avoid race condition
+        if callback:
+            _gps_reader.add_callback(callback)
+
+        return _gps_reader.start()
+
+
+def start_gpsd(host: str = 'localhost', port: int = 2947,
+               callback: Optional[Callable[[GPSPosition], None]] = None) -> bool:
+    """
+    Start the global GPS client connected to gpsd.
+
+    Args:
+        host: gpsd host (default localhost)
+        port: gpsd port (default 2947)
+        callback: Optional callback for position updates
+
+    Returns:
+        True if started successfully
+    """
+    global _gps_reader
+
+    with _gps_lock:
+        # Stop existing reader if any
+        if _gps_reader:
+            _gps_reader.stop()
+
+        _gps_reader = GPSDClient(host, port)
+
+        # Register callback BEFORE starting to avoid race condition
+        if callback:
+            _gps_reader.add_callback(callback)
+
         return _gps_reader.start()
 
 
 def stop_gps() -> None:
-    """Stop the global GPS reader."""
+    """Stop the global GPS reader/client."""
     global _gps_reader
 
     with _gps_lock:

utils/sdr/__init__.py

@@ -30,6 +30,7 @@ from .detection import detect_all_devices
 from .rtlsdr import RTLSDRCommandBuilder
 from .limesdr import LimeSDRCommandBuilder
 from .hackrf import HackRFCommandBuilder
+from .airspy import AirspyCommandBuilder
 from .validation import (
     SDRValidationError,
     validate_frequency,
@@ -49,6 +50,7 @@ class SDRFactory:
         SDRType.RTL_SDR: RTLSDRCommandBuilder,
         SDRType.LIME_SDR: LimeSDRCommandBuilder,
         SDRType.HACKRF: HackRFCommandBuilder,
+        SDRType.AIRSPY: AirspyCommandBuilder,
     }
 
     @classmethod
@@ -214,6 +216,7 @@ __all__ = [
     'RTLSDRCommandBuilder',
     'LimeSDRCommandBuilder',
     'HackRFCommandBuilder',
+    'AirspyCommandBuilder',
     # Validation
     'SDRValidationError',
     'validate_frequency',

utils/sdr/airspy.py

@@ -0,0 +1,153 @@
+"""
+Airspy command builder implementation.
+
+Uses SoapySDR-based tools for FM demodulation and signal capture.
+Airspy R2/Mini supports 24 MHz to 1.8 GHz frequency range.
+Airspy HF+ supports 9 kHz - 31 MHz and 60-260 MHz.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .base import CommandBuilder, SDRCapabilities, SDRDevice, SDRType
+
+
+class AirspyCommandBuilder(CommandBuilder):
+    """Airspy command builder using SoapySDR tools."""
+
+    # Airspy R2/Mini capabilities (most common)
+    # HF+ has different range but same interface
+    CAPABILITIES = SDRCapabilities(
+        sdr_type=SDRType.AIRSPY,
+        freq_min_mhz=24.0,       # 24 MHz (HF+ goes lower)
+        freq_max_mhz=1800.0,     # 1.8 GHz
+        gain_min=0.0,
+        gain_max=45.0,           # LNA (0-15) + Mixer (0-15) + VGA (0-15)
+        sample_rates=[2500000, 3000000, 6000000, 10000000],
+        supports_bias_t=True,
+        supports_ppm=False,      # Airspy has TCXO, no PPM needed
+        tx_capable=False
+    )
+
+    def _build_device_string(self, device: SDRDevice) -> str:
+        """Build SoapySDR device string for Airspy."""
+        driver = device.driver if device.driver in ('airspy', 'airspyhf') else 'airspy'
+        if device.serial and device.serial != 'N/A':
+            return f'driver={driver},serial={device.serial}'
+        return f'driver={driver}'
+
+    def _format_gain(self, gain: float) -> str:
+        """
+        Format gain string for Airspy.
+
+        Airspy has three gain stages:
+        - LNA: 0-15 dB
+        - Mixer: 0-15 dB
+        - VGA: 0-15 dB
+
+        This distributes the requested gain across stages.
+        """
+        if gain <= 15:
+            return f'LNA={int(gain)},MIX=0,VGA=0'
+        elif gain <= 30:
+            return f'LNA=15,MIX={int(gain - 15)},VGA=0'
+        else:
+            vga = min(15, int(gain - 30))
+            return f'LNA=15,MIX=15,VGA={vga}'
+
+    def build_fm_demod_command(
+        self,
+        device: SDRDevice,
+        frequency_mhz: float,
+        sample_rate: int = 22050,
+        gain: Optional[float] = None,
+        ppm: Optional[int] = None,
+        modulation: str = "fm",
+        squelch: Optional[int] = None
+    ) -> list[str]:
+        """
+        Build SoapySDR rx_fm command for FM demodulation.
+
+        For pager decoding with Airspy.
+        """
+        device_str = self._build_device_string(device)
+
+        cmd = [
+            'rx_fm',
+            '-d', device_str,
+            '-f', f'{frequency_mhz}M',
+            '-M', modulation,
+            '-s', str(sample_rate),
+        ]
+
+        if gain is not None and gain > 0:
+            cmd.extend(['-g', self._format_gain(gain)])
+
+        if squelch is not None and squelch > 0:
+            cmd.extend(['-l', str(squelch)])
+
+        # Output to stdout
+        cmd.append('-')
+
+        return cmd
+
+    def build_adsb_command(
+        self,
+        device: SDRDevice,
+        gain: Optional[float] = None
+    ) -> list[str]:
+        """
+        Build dump1090/readsb command with SoapySDR support for ADS-B decoding.
+
+        Uses readsb which has better SoapySDR support.
+        """
+        device_str = self._build_device_string(device)
+
+        cmd = [
+            'readsb',
+            '--net',
+            '--device-type', 'soapysdr',
+            '--device', device_str,
+            '--quiet'
+        ]
+
+        if gain is not None:
+            cmd.extend(['--gain', str(int(gain))])
+
+        return cmd
+
+    def build_ism_command(
+        self,
+        device: SDRDevice,
+        frequency_mhz: float = 433.92,
+        gain: Optional[float] = None,
+        ppm: Optional[int] = None
+    ) -> list[str]:
+        """
+        Build rtl_433 command with SoapySDR support for ISM band decoding.
+
+        rtl_433 has native SoapySDR support via -d flag.
+        """
+        device_str = self._build_device_string(device)
+
+        cmd = [
+            'rtl_433',
+            '-d', device_str,
+            '-f', f'{frequency_mhz}M',
+            '-F', 'json'
+        ]
+
+        if gain is not None and gain > 0:
+            cmd.extend(['-g', str(int(gain))])
+
+        return cmd
+
+    def get_capabilities(self) -> SDRCapabilities:
+        """Return Airspy capabilities."""
+        return self.CAPABILITIES
+
+    @classmethod
+    def get_sdr_type(cls) -> SDRType:
+        """Return SDR type."""
+        return SDRType.AIRSPY

utils/sdr/base.py

@@ -18,6 +18,7 @@ class SDRType(Enum):
     RTL_SDR = "rtlsdr"
     LIME_SDR = "limesdr"
     HACKRF = "hackrf"
+    AIRSPY = "airspy"
     # Future support
     # USRP = "usrp"
     # BLADE_RF = "bladerf"

utils/sdr/detection.py

@@ -28,11 +28,13 @@ def _get_capabilities_for_type(sdr_type: SDRType) -> SDRCapabilities:
     from .rtlsdr import RTLSDRCommandBuilder
     from .limesdr import LimeSDRCommandBuilder
     from .hackrf import HackRFCommandBuilder
+    from .airspy import AirspyCommandBuilder
 
     builders = {
         SDRType.RTL_SDR: RTLSDRCommandBuilder,
         SDRType.LIME_SDR: LimeSDRCommandBuilder,
         SDRType.HACKRF: HackRFCommandBuilder,
+        SDRType.AIRSPY: AirspyCommandBuilder,
     }
 
     builder_class = builders.get(sdr_type)
@@ -60,6 +62,8 @@ def _driver_to_sdr_type(driver: str) -> Optional[SDRType]:
         'lime': SDRType.LIME_SDR,
         'limesdr': SDRType.LIME_SDR,
         'hackrf': SDRType.HACKRF,
+        'airspy': SDRType.AIRSPY,
+        'airspyhf': SDRType.AIRSPY,  # Airspy HF+ uses same builder
         # Future support
         # 'uhd': SDRType.USRP,
         # 'bladerf': SDRType.BLADE_RF,