mirror of
https://github.com/smittix/intercept.git
synced 2026-04-24 06:40:00 -07:00
d8d08a8b1e
New modes: - BT Locate: SAR Bluetooth device location with GPS-tagged signal trail, RSSI-based proximity bands, audio alerts, and IRK auto-extraction from paired devices (macOS plist / Linux BlueZ) - GPS: Real-time position tracking with live map, speed, heading, altitude, satellite info, and track recording via gpsd Bug fixes: - Fix ABBA deadlock between session lock and aggregator lock in BT Locate - Fix bleak scan lifecycle tracking in BluetoothScanner (is_scanning property now cross-checks backend state) - Fix map tile persistence when switching modes - Use 15s max_age window for fresh detections in BT Locate poll loop Documentation: - Update README, FEATURES.md, USAGE.md, and GitHub Pages with new modes Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
486 lines
15 KiB
Python
486 lines
15 KiB
Python
"""
|
|
GPS support for INTERCEPT via gpsd daemon.
|
|
|
|
Provides GPS location data by connecting to the gpsd daemon.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import contextlib
|
|
import logging
|
|
import socket as _socket_mod
|
|
import threading
|
|
from dataclasses import dataclass, field
|
|
from datetime import datetime
|
|
from typing import Callable
|
|
|
|
logger = logging.getLogger('intercept.gps')
|
|
|
|
|
|
@dataclass
|
|
class GPSSatellite:
|
|
"""Individual satellite data from gpsd SKY message."""
|
|
prn: int
|
|
elevation: float | None = None # degrees
|
|
azimuth: float | None = None # degrees
|
|
snr: float | None = None # dB-Hz
|
|
used: bool = False
|
|
constellation: str = 'GPS' # GPS, GLONASS, Galileo, BeiDou, SBAS, QZSS
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
'prn': self.prn,
|
|
'elevation': self.elevation,
|
|
'azimuth': self.azimuth,
|
|
'snr': self.snr,
|
|
'used': self.used,
|
|
'constellation': self.constellation,
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class GPSSkyData:
|
|
"""Sky view data from gpsd SKY message."""
|
|
satellites: list[GPSSatellite] = field(default_factory=list)
|
|
hdop: float | None = None
|
|
vdop: float | None = None
|
|
pdop: float | None = None
|
|
tdop: float | None = None
|
|
gdop: float | None = None
|
|
xdop: float | None = None
|
|
ydop: float | None = None
|
|
nsat: int = 0 # total visible
|
|
usat: int = 0 # total used
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
'satellites': [s.to_dict() for s in self.satellites],
|
|
'hdop': self.hdop,
|
|
'vdop': self.vdop,
|
|
'pdop': self.pdop,
|
|
'tdop': self.tdop,
|
|
'gdop': self.gdop,
|
|
'xdop': self.xdop,
|
|
'ydop': self.ydop,
|
|
'nsat': self.nsat,
|
|
'usat': self.usat,
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class GPSPosition:
|
|
"""GPS position data."""
|
|
latitude: float
|
|
longitude: float
|
|
altitude: float | None = None
|
|
speed: float | None = None # m/s
|
|
heading: float | None = None # degrees
|
|
climb: float | None = None # m/s vertical speed
|
|
satellites: int | None = None
|
|
fix_quality: int = 0 # 0=unknown, 1=no fix, 2=2D fix, 3=3D fix
|
|
timestamp: datetime | None = None
|
|
device: str | None = None
|
|
# Error estimates
|
|
epx: float | None = None # lon error (m)
|
|
epy: float | None = None # lat error (m)
|
|
epv: float | None = None # vertical error (m)
|
|
eps: float | None = None # speed error (m/s)
|
|
ept: float | None = None # time error (s)
|
|
|
|
def to_dict(self) -> dict:
|
|
"""Convert to dictionary for JSON serialization."""
|
|
return {
|
|
'latitude': self.latitude,
|
|
'longitude': self.longitude,
|
|
'altitude': self.altitude,
|
|
'speed': self.speed,
|
|
'heading': self.heading,
|
|
'climb': self.climb,
|
|
'satellites': self.satellites,
|
|
'fix_quality': self.fix_quality,
|
|
'timestamp': self.timestamp.isoformat() if self.timestamp else None,
|
|
'device': self.device,
|
|
'epx': self.epx,
|
|
'epy': self.epy,
|
|
'epv': self.epv,
|
|
'eps': self.eps,
|
|
'ept': self.ept,
|
|
}
|
|
|
|
|
|
def _classify_constellation(prn: int, gnssid: int | None = None) -> str:
|
|
"""Classify satellite constellation from PRN or gnssid."""
|
|
if gnssid is not None:
|
|
mapping = {
|
|
0: 'GPS', 1: 'SBAS', 2: 'Galileo', 3: 'BeiDou',
|
|
4: 'IMES', 5: 'QZSS', 6: 'GLONASS', 7: 'NavIC',
|
|
}
|
|
return mapping.get(gnssid, 'GPS')
|
|
# Fall back to PRN range heuristic
|
|
if 1 <= prn <= 32:
|
|
return 'GPS'
|
|
elif 33 <= prn <= 64:
|
|
return 'SBAS'
|
|
elif 65 <= prn <= 96:
|
|
return 'GLONASS'
|
|
elif 120 <= prn <= 158:
|
|
return 'SBAS'
|
|
elif 201 <= prn <= 264:
|
|
return 'BeiDou'
|
|
elif 301 <= prn <= 336:
|
|
return 'Galileo'
|
|
elif 193 <= prn <= 200:
|
|
return 'QZSS'
|
|
return 'GPS'
|
|
|
|
|
|
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: GPSPosition | None = None
|
|
self._sky: GPSSkyData | None = None
|
|
self._lock = threading.Lock()
|
|
self._running = False
|
|
self._thread: threading.Thread | None = None
|
|
self._socket: _socket_mod.socket | None = None
|
|
self._last_update: datetime | None = None
|
|
self._error: str | None = None
|
|
self._callbacks: list[Callable[[GPSPosition], None]] = []
|
|
self._sky_callbacks: list[Callable[[GPSSkyData], None]] = []
|
|
self._device: str | None = None
|
|
|
|
@property
|
|
def position(self) -> GPSPosition | None:
|
|
"""Get the current GPS position."""
|
|
with self._lock:
|
|
return self._position
|
|
|
|
@property
|
|
def sky(self) -> GPSSkyData | None:
|
|
"""Get the current sky view data."""
|
|
with self._lock:
|
|
return self._sky
|
|
|
|
@property
|
|
def is_running(self) -> bool:
|
|
"""Check if the client is running."""
|
|
return self._running
|
|
|
|
@property
|
|
def last_update(self) -> datetime | None:
|
|
"""Get the time of the last position update."""
|
|
with self._lock:
|
|
return self._last_update
|
|
|
|
@property
|
|
def error(self) -> str | None:
|
|
"""Get any error message."""
|
|
with self._lock:
|
|
return self._error
|
|
|
|
@property
|
|
def device_path(self) -> str:
|
|
"""Return gpsd connection info."""
|
|
return f"gpsd://{self.host}:{self.port}"
|
|
|
|
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 add_sky_callback(self, callback: Callable[[GPSSkyData], None]) -> None:
|
|
"""Add a callback to be called on sky data updates."""
|
|
self._sky_callbacks.append(callback)
|
|
|
|
def remove_sky_callback(self, callback: Callable[[GPSSkyData], None]) -> None:
|
|
"""Remove a sky data update callback."""
|
|
if callback in self._sky_callbacks:
|
|
self._sky_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:
|
|
with contextlib.suppress(Exception):
|
|
self._socket.close()
|
|
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("[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 == 'SKY':
|
|
self._handle_sky(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:
|
|
with contextlib.suppress(ValueError, AttributeError):
|
|
# gpsd uses ISO format: 2024-01-01T12:00:00.000Z
|
|
timestamp = datetime.fromisoformat(time_str.replace('Z', '+00:00'))
|
|
|
|
position = GPSPosition(
|
|
latitude=lat,
|
|
longitude=lon,
|
|
altitude=msg.get('alt'),
|
|
speed=msg.get('speed'), # m/s in gpsd
|
|
heading=msg.get('track'),
|
|
climb=msg.get('climb'),
|
|
fix_quality=mode,
|
|
timestamp=timestamp,
|
|
device=self._device or f"gpsd://{self.host}:{self.port}",
|
|
epx=msg.get('epx'),
|
|
epy=msg.get('epy'),
|
|
epv=msg.get('epv'),
|
|
eps=msg.get('eps'),
|
|
ept=msg.get('ept'),
|
|
)
|
|
|
|
print(f"[GPS] gpsd FIX: {lat:.6f}, {lon:.6f} (mode: {mode})", flush=True)
|
|
self._update_position(position)
|
|
|
|
def _handle_sky(self, msg: dict) -> None:
|
|
"""Handle SKY (satellite sky view) message from gpsd."""
|
|
sats = []
|
|
for sat in msg.get('satellites', []):
|
|
prn = sat.get('PRN', 0)
|
|
gnssid = sat.get('gnssid')
|
|
sats.append(GPSSatellite(
|
|
prn=prn,
|
|
elevation=sat.get('el'),
|
|
azimuth=sat.get('az'),
|
|
snr=sat.get('ss'),
|
|
used=sat.get('used', False),
|
|
constellation=_classify_constellation(prn, gnssid),
|
|
))
|
|
|
|
sky_data = GPSSkyData(
|
|
satellites=sats,
|
|
hdop=msg.get('hdop'),
|
|
vdop=msg.get('vdop'),
|
|
pdop=msg.get('pdop'),
|
|
tdop=msg.get('tdop'),
|
|
gdop=msg.get('gdop'),
|
|
xdop=msg.get('xdop'),
|
|
ydop=msg.get('ydop'),
|
|
nsat=len(sats),
|
|
usat=sum(1 for s in sats if s.used),
|
|
)
|
|
|
|
with self._lock:
|
|
self._sky = sky_data
|
|
|
|
# Notify sky callbacks
|
|
for callback in self._sky_callbacks:
|
|
try:
|
|
callback(sky_data)
|
|
except Exception as e:
|
|
logger.error(f"GPS sky callback error: {e}")
|
|
|
|
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}")
|
|
|
|
|
|
# Global GPS client instance
|
|
_gps_client: GPSDClient | None = None
|
|
_gps_lock = threading.Lock()
|
|
|
|
|
|
def get_gps_reader() -> GPSDClient | None:
|
|
"""Get the global GPS client instance."""
|
|
with _gps_lock:
|
|
return _gps_client
|
|
|
|
|
|
def start_gpsd(host: str = 'localhost', port: int = 2947,
|
|
callback: Callable[[GPSPosition], None] | None = None,
|
|
sky_callback: Callable[[GPSSkyData], None] | 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
|
|
sky_callback: Optional callback for sky data updates
|
|
|
|
Returns:
|
|
True if started successfully
|
|
"""
|
|
global _gps_client
|
|
|
|
with _gps_lock:
|
|
# Stop existing client if any
|
|
if _gps_client:
|
|
_gps_client.stop()
|
|
|
|
_gps_client = GPSDClient(host, port)
|
|
|
|
# Register callbacks BEFORE starting to avoid race condition
|
|
if callback:
|
|
_gps_client.add_callback(callback)
|
|
if sky_callback:
|
|
_gps_client.add_sky_callback(sky_callback)
|
|
|
|
return _gps_client.start()
|
|
|
|
|
|
def stop_gps() -> None:
|
|
"""Stop the global GPS client."""
|
|
global _gps_client
|
|
|
|
with _gps_lock:
|
|
if _gps_client:
|
|
_gps_client.stop()
|
|
_gps_client = None
|
|
|
|
|
|
def get_current_position() -> GPSPosition | None:
|
|
"""Get the current GPS position from the global client."""
|
|
client = get_gps_reader()
|
|
if client:
|
|
return client.position
|
|
return None
|