mirror of
https://github.com/smittix/intercept.git
synced 2026-04-24 06:40:00 -07:00
feat: Add VHF DSC Channel 70 monitoring and decoding
- Implement DSC message decoding (Distress, Urgency, Safety, Routine) - Add MMSI country identification via MID lookup - Integrate position extraction and map markers for distress alerts - Implement device conflict detection to prevent SDR collisions with AIS - Add permanent storage for critical alerts and visual UI overlays
This commit is contained in:
Marc
575
routes/dsc.py
Normal file
575
routes/dsc.py
Normal file
@@ -0,0 +1,575 @@
|
||||
"""VHF DSC (Digital Selective Calling) routes.
|
||||
|
||||
DSC operates on VHF Channel 70 (156.525 MHz) for maritime
|
||||
distress and safety communications per ITU-R M.493.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import pty
|
||||
import queue
|
||||
import select
|
||||
import shutil
|
||||
import subprocess
|
||||
import threading
|
||||
import time
|
||||
from datetime import datetime
|
||||
from typing import Any, Generator
|
||||
|
||||
from flask import Blueprint, jsonify, request, Response
|
||||
|
||||
import app as app_module
|
||||
from utils.constants import (
|
||||
DSC_VHF_FREQUENCY_MHZ,
|
||||
DSC_SAMPLE_RATE,
|
||||
DSC_TERMINATE_TIMEOUT,
|
||||
)
|
||||
from utils.database import (
|
||||
store_dsc_alert,
|
||||
get_dsc_alerts,
|
||||
get_dsc_alert,
|
||||
acknowledge_dsc_alert,
|
||||
get_dsc_alert_summary,
|
||||
)
|
||||
from utils.dsc.parser import parse_dsc_message
|
||||
from utils.sse import format_sse
|
||||
from utils.validation import validate_device_index, validate_gain
|
||||
from utils.sdr import SDRFactory, SDRType
|
||||
from utils.dependencies import get_tool_path
|
||||
|
||||
logger = logging.getLogger('intercept.dsc')
|
||||
|
||||
dsc_bp = Blueprint('dsc', __name__, url_prefix='/dsc')
|
||||
|
||||
# Module state (track if running independent of process state)
|
||||
dsc_running = False
|
||||
|
||||
|
||||
def _get_dsc_decoder_path() -> str | None:
|
||||
"""Get path to DSC decoder."""
|
||||
# Check for our custom decoder
|
||||
project_bin = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'bin', 'dsc-decoder')
|
||||
if os.path.isfile(project_bin) and os.access(project_bin, os.X_OK):
|
||||
return project_bin
|
||||
|
||||
# Check system PATH
|
||||
system_decoder = shutil.which('dsc-decoder')
|
||||
if system_decoder:
|
||||
return system_decoder
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def _check_dsc_tools() -> dict:
|
||||
"""Check availability of DSC decoding tools."""
|
||||
rtl_fm_path = get_tool_path('rtl_fm')
|
||||
decoder_path = _get_dsc_decoder_path()
|
||||
|
||||
# Check for scipy/numpy (needed for decoder)
|
||||
scipy_available = False
|
||||
try:
|
||||
import scipy
|
||||
import numpy
|
||||
scipy_available = True
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
return {
|
||||
'rtl_fm': {
|
||||
'available': rtl_fm_path is not None,
|
||||
'path': rtl_fm_path
|
||||
},
|
||||
'dsc_decoder': {
|
||||
'available': decoder_path is not None,
|
||||
'path': decoder_path
|
||||
},
|
||||
'scipy': {
|
||||
'available': scipy_available,
|
||||
'note': 'Required for DSC signal processing'
|
||||
},
|
||||
'ready': rtl_fm_path is not None and decoder_path is not None and scipy_available
|
||||
}
|
||||
|
||||
|
||||
def stream_dsc_decoder(master_fd: int, decoder_process: subprocess.Popen) -> None:
|
||||
"""
|
||||
Stream DSC decoder output to queue using PTY for unbuffered output.
|
||||
|
||||
Args:
|
||||
master_fd: PTY master file descriptor
|
||||
decoder_process: Decoder subprocess
|
||||
"""
|
||||
global dsc_running
|
||||
|
||||
try:
|
||||
app_module.dsc_queue.put({'type': 'status', 'status': 'started'})
|
||||
|
||||
buffer = ""
|
||||
while dsc_running:
|
||||
try:
|
||||
ready, _, _ = select.select([master_fd], [], [], 1.0)
|
||||
except Exception:
|
||||
break
|
||||
|
||||
if ready:
|
||||
try:
|
||||
data = os.read(master_fd, 1024)
|
||||
if not data:
|
||||
break
|
||||
buffer += data.decode('utf-8', errors='replace')
|
||||
|
||||
while '\n' in buffer:
|
||||
line, buffer = buffer.split('\n', 1)
|
||||
line = line.strip()
|
||||
if not line:
|
||||
continue
|
||||
|
||||
# Parse DSC message
|
||||
parsed = parse_dsc_message(line)
|
||||
if parsed:
|
||||
# Generate unique message ID
|
||||
msg_id = f"{parsed['source_mmsi']}_{int(time.time() * 1000)}"
|
||||
parsed['id'] = msg_id
|
||||
|
||||
# Store in transient DataStore
|
||||
app_module.dsc_messages.set(msg_id, parsed)
|
||||
|
||||
# Queue for SSE
|
||||
try:
|
||||
app_module.dsc_queue.put_nowait(parsed)
|
||||
except queue.Full:
|
||||
logger.warning("DSC queue full, dropping message")
|
||||
|
||||
# Store critical alerts permanently
|
||||
if parsed.get('is_critical'):
|
||||
_store_critical_alert(parsed)
|
||||
else:
|
||||
# Raw output for debugging
|
||||
app_module.dsc_queue.put({
|
||||
'type': 'raw',
|
||||
'text': line
|
||||
})
|
||||
except OSError:
|
||||
break
|
||||
|
||||
# Check if process is still running
|
||||
if decoder_process.poll() is not None:
|
||||
break
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"DSC decoder error: {e}")
|
||||
app_module.dsc_queue.put({
|
||||
'type': 'error',
|
||||
'error': str(e)
|
||||
})
|
||||
finally:
|
||||
try:
|
||||
os.close(master_fd)
|
||||
except OSError:
|
||||
pass
|
||||
decoder_process.wait()
|
||||
dsc_running = False
|
||||
app_module.dsc_queue.put({'type': 'status', 'status': 'stopped'})
|
||||
|
||||
with app_module.dsc_lock:
|
||||
app_module.dsc_process = None
|
||||
app_module.dsc_rtl_process = None
|
||||
|
||||
|
||||
def _store_critical_alert(msg: dict) -> None:
|
||||
"""Store critical DSC alert (DISTRESS/URGENCY) to database."""
|
||||
try:
|
||||
store_dsc_alert(
|
||||
source_mmsi=msg.get('source_mmsi', ''),
|
||||
format_code=str(msg.get('format_code', '')),
|
||||
category=msg.get('category', 'UNKNOWN'),
|
||||
source_name=msg.get('source_name'),
|
||||
dest_mmsi=msg.get('dest_mmsi'),
|
||||
nature_of_distress=msg.get('nature_of_distress'),
|
||||
latitude=msg.get('latitude'),
|
||||
longitude=msg.get('longitude'),
|
||||
raw_message=msg.get('raw_message')
|
||||
)
|
||||
logger.info(f"Stored {msg.get('category')} alert from {msg.get('source_mmsi')}")
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to store DSC alert: {e}")
|
||||
|
||||
|
||||
def monitor_rtl_stderr(process: subprocess.Popen) -> None:
|
||||
"""Monitor rtl_fm stderr for errors."""
|
||||
global dsc_running
|
||||
|
||||
try:
|
||||
for line in process.stderr:
|
||||
if not dsc_running:
|
||||
break
|
||||
err_text = line.decode('utf-8', errors='replace').strip()
|
||||
if err_text:
|
||||
logger.debug(f"[RTL_FM] {err_text}")
|
||||
|
||||
# Check for device busy error
|
||||
if 'usb_claim_interface' in err_text.lower():
|
||||
app_module.dsc_queue.put({
|
||||
'type': 'error',
|
||||
'error': 'SDR device busy',
|
||||
'error_type': 'DEVICE_BUSY',
|
||||
'suggestion': 'Use a different SDR device or stop other SDR processes'
|
||||
})
|
||||
|
||||
# Check for other common errors
|
||||
if 'no supported devices' in err_text.lower():
|
||||
app_module.dsc_queue.put({
|
||||
'type': 'error',
|
||||
'error': 'No SDR device found',
|
||||
'error_type': 'NO_DEVICE'
|
||||
})
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
@dsc_bp.route('/status')
|
||||
def get_status() -> Response:
|
||||
"""Get DSC decoder status."""
|
||||
global dsc_running
|
||||
|
||||
with app_module.dsc_lock:
|
||||
running = (
|
||||
dsc_running and
|
||||
app_module.dsc_process is not None and
|
||||
app_module.dsc_process.poll() is None
|
||||
)
|
||||
|
||||
# Get message counts
|
||||
message_count = len(app_module.dsc_messages)
|
||||
alert_summary = get_dsc_alert_summary()
|
||||
|
||||
return jsonify({
|
||||
'running': running,
|
||||
'frequency': DSC_VHF_FREQUENCY_MHZ,
|
||||
'message_count': message_count,
|
||||
'alerts': alert_summary
|
||||
})
|
||||
|
||||
|
||||
@dsc_bp.route('/tools')
|
||||
def check_tools() -> Response:
|
||||
"""Check DSC decoder tool availability."""
|
||||
tools = _check_dsc_tools()
|
||||
return jsonify(tools)
|
||||
|
||||
|
||||
@dsc_bp.route('/start', methods=['POST'])
|
||||
def start_decoding() -> Response:
|
||||
"""Start DSC decoder."""
|
||||
global dsc_running
|
||||
|
||||
with app_module.dsc_lock:
|
||||
if app_module.dsc_process and app_module.dsc_process.poll() is None:
|
||||
return jsonify({
|
||||
'status': 'error',
|
||||
'message': 'DSC decoder already running'
|
||||
}), 409
|
||||
|
||||
# Check tools
|
||||
tools = _check_dsc_tools()
|
||||
if not tools['ready']:
|
||||
missing = []
|
||||
if not tools['rtl_fm']['available']:
|
||||
missing.append('rtl_fm')
|
||||
if not tools['dsc_decoder']['available']:
|
||||
missing.append('dsc-decoder')
|
||||
if not tools['scipy']['available']:
|
||||
missing.append('scipy/numpy')
|
||||
|
||||
return jsonify({
|
||||
'status': 'error',
|
||||
'message': f'Missing required tools: {", ".join(missing)}'
|
||||
}), 400
|
||||
|
||||
data = request.json or {}
|
||||
|
||||
# Validate device
|
||||
try:
|
||||
device = validate_device_index(data.get('device', '0'))
|
||||
except ValueError as e:
|
||||
return jsonify({
|
||||
'status': 'error',
|
||||
'message': str(e)
|
||||
}), 400
|
||||
|
||||
# Validate gain
|
||||
try:
|
||||
gain = validate_gain(data.get('gain', '40'))
|
||||
except ValueError as e:
|
||||
return jsonify({
|
||||
'status': 'error',
|
||||
'message': str(e)
|
||||
}), 400
|
||||
|
||||
# Check if device is in use by AIS
|
||||
try:
|
||||
from routes import ais as ais_module
|
||||
if hasattr(ais_module, 'ais_running') and ais_module.ais_running:
|
||||
# AIS is running - check if same device
|
||||
if hasattr(ais_module, 'ais_device') and str(ais_module.ais_device) == str(device):
|
||||
return jsonify({
|
||||
'status': 'error',
|
||||
'error_type': 'DEVICE_BUSY',
|
||||
'message': f'SDR device {device} is in use by AIS tracking',
|
||||
'suggestion': 'Use a different SDR device or stop AIS tracking first',
|
||||
'in_use_by': 'ais'
|
||||
}), 409
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
# Clear queue
|
||||
while not app_module.dsc_queue.empty():
|
||||
try:
|
||||
app_module.dsc_queue.get_nowait()
|
||||
except queue.Empty:
|
||||
break
|
||||
|
||||
# Build rtl_fm command
|
||||
rtl_fm_path = tools['rtl_fm']['path']
|
||||
decoder_path = tools['dsc_decoder']['path']
|
||||
|
||||
# rtl_fm command for DSC decoding
|
||||
# DSC uses narrow FM at 156.525 MHz with 48kHz sample rate
|
||||
rtl_cmd = [
|
||||
rtl_fm_path,
|
||||
'-f', f'{DSC_VHF_FREQUENCY_MHZ}M',
|
||||
'-s', str(DSC_SAMPLE_RATE),
|
||||
'-d', str(device),
|
||||
'-g', str(gain),
|
||||
'-M', 'fm', # FM demodulation
|
||||
'-l', '0', # No squelch for DSC
|
||||
'-E', 'dc' # DC blocking filter
|
||||
]
|
||||
|
||||
# Decoder command
|
||||
decoder_cmd = [decoder_path]
|
||||
|
||||
full_cmd = ' '.join(rtl_cmd) + ' | ' + ' '.join(decoder_cmd)
|
||||
logger.info(f"Starting DSC decoder: {full_cmd}")
|
||||
|
||||
try:
|
||||
# Start rtl_fm subprocess
|
||||
rtl_process = subprocess.Popen(
|
||||
rtl_cmd,
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE
|
||||
)
|
||||
|
||||
# Start stderr monitor thread
|
||||
stderr_thread = threading.Thread(
|
||||
target=monitor_rtl_stderr,
|
||||
args=(rtl_process,),
|
||||
daemon=True
|
||||
)
|
||||
stderr_thread.start()
|
||||
|
||||
# Create PTY for decoder output
|
||||
master_fd, slave_fd = pty.openpty()
|
||||
|
||||
# Start decoder subprocess
|
||||
decoder_process = subprocess.Popen(
|
||||
decoder_cmd,
|
||||
stdin=rtl_process.stdout,
|
||||
stdout=slave_fd,
|
||||
stderr=slave_fd,
|
||||
close_fds=True
|
||||
)
|
||||
|
||||
os.close(slave_fd)
|
||||
rtl_process.stdout.close()
|
||||
|
||||
# Store process references
|
||||
app_module.dsc_process = decoder_process
|
||||
app_module.dsc_rtl_process = rtl_process
|
||||
dsc_running = True
|
||||
|
||||
# Start output streaming thread
|
||||
output_thread = threading.Thread(
|
||||
target=stream_dsc_decoder,
|
||||
args=(master_fd, decoder_process),
|
||||
daemon=True
|
||||
)
|
||||
output_thread.start()
|
||||
|
||||
return jsonify({
|
||||
'status': 'started',
|
||||
'frequency': DSC_VHF_FREQUENCY_MHZ,
|
||||
'device': device,
|
||||
'gain': gain,
|
||||
'command': full_cmd
|
||||
})
|
||||
|
||||
except FileNotFoundError as e:
|
||||
return jsonify({
|
||||
'status': 'error',
|
||||
'message': f'Tool not found: {e.filename}'
|
||||
}), 400
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to start DSC decoder: {e}")
|
||||
return jsonify({
|
||||
'status': 'error',
|
||||
'message': str(e)
|
||||
}), 500
|
||||
|
||||
|
||||
@dsc_bp.route('/stop', methods=['POST'])
|
||||
def stop_decoding() -> Response:
|
||||
"""Stop DSC decoder."""
|
||||
global dsc_running
|
||||
|
||||
with app_module.dsc_lock:
|
||||
if not app_module.dsc_process:
|
||||
return jsonify({'status': 'not_running'})
|
||||
|
||||
dsc_running = False
|
||||
|
||||
# Terminate rtl_fm process first
|
||||
if app_module.dsc_rtl_process:
|
||||
try:
|
||||
app_module.dsc_rtl_process.terminate()
|
||||
app_module.dsc_rtl_process.wait(timeout=DSC_TERMINATE_TIMEOUT)
|
||||
except subprocess.TimeoutExpired:
|
||||
try:
|
||||
app_module.dsc_rtl_process.kill()
|
||||
except OSError:
|
||||
pass
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
# Terminate decoder process
|
||||
if app_module.dsc_process:
|
||||
try:
|
||||
app_module.dsc_process.terminate()
|
||||
app_module.dsc_process.wait(timeout=DSC_TERMINATE_TIMEOUT)
|
||||
except subprocess.TimeoutExpired:
|
||||
try:
|
||||
app_module.dsc_process.kill()
|
||||
except OSError:
|
||||
pass
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
app_module.dsc_process = None
|
||||
app_module.dsc_rtl_process = None
|
||||
|
||||
return jsonify({'status': 'stopped'})
|
||||
|
||||
|
||||
@dsc_bp.route('/stream')
|
||||
def stream() -> Response:
|
||||
"""SSE stream for real-time DSC messages."""
|
||||
def generate() -> Generator[str, None, None]:
|
||||
last_keepalive = time.time()
|
||||
keepalive_interval = 30.0
|
||||
|
||||
while True:
|
||||
try:
|
||||
msg = app_module.dsc_queue.get(timeout=1)
|
||||
last_keepalive = time.time()
|
||||
yield format_sse(msg)
|
||||
except queue.Empty:
|
||||
now = time.time()
|
||||
if now - last_keepalive >= keepalive_interval:
|
||||
yield format_sse({'type': 'keepalive'})
|
||||
last_keepalive = now
|
||||
|
||||
response = Response(generate(), mimetype='text/event-stream')
|
||||
response.headers['Cache-Control'] = 'no-cache'
|
||||
response.headers['X-Accel-Buffering'] = 'no'
|
||||
response.headers['Connection'] = 'keep-alive'
|
||||
return response
|
||||
|
||||
|
||||
@dsc_bp.route('/messages')
|
||||
def get_messages() -> Response:
|
||||
"""Get current DSC messages from transient store."""
|
||||
messages = list(app_module.dsc_messages.values())
|
||||
|
||||
# Sort by timestamp (newest first)
|
||||
messages.sort(key=lambda m: m.get('timestamp', ''), reverse=True)
|
||||
|
||||
return jsonify({
|
||||
'count': len(messages),
|
||||
'messages': messages
|
||||
})
|
||||
|
||||
|
||||
@dsc_bp.route('/alerts')
|
||||
def get_alerts_endpoint() -> Response:
|
||||
"""Get stored DSC alerts (paginated)."""
|
||||
# Parse query params
|
||||
category = request.args.get('category')
|
||||
acknowledged = request.args.get('acknowledged')
|
||||
limit = min(int(request.args.get('limit', 50)), 200)
|
||||
offset = int(request.args.get('offset', 0))
|
||||
|
||||
# Convert acknowledged param
|
||||
ack_filter = None
|
||||
if acknowledged is not None:
|
||||
ack_filter = acknowledged.lower() in ('true', '1', 'yes')
|
||||
|
||||
alerts = get_dsc_alerts(
|
||||
category=category,
|
||||
acknowledged=ack_filter,
|
||||
limit=limit,
|
||||
offset=offset
|
||||
)
|
||||
|
||||
summary = get_dsc_alert_summary()
|
||||
|
||||
return jsonify({
|
||||
'alerts': alerts,
|
||||
'count': len(alerts),
|
||||
'summary': summary,
|
||||
'pagination': {
|
||||
'limit': limit,
|
||||
'offset': offset
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
@dsc_bp.route('/alerts/<int:alert_id>')
|
||||
def get_alert(alert_id: int) -> Response:
|
||||
"""Get a specific DSC alert by ID."""
|
||||
alert = get_dsc_alert(alert_id)
|
||||
if not alert:
|
||||
return jsonify({
|
||||
'status': 'error',
|
||||
'message': 'Alert not found'
|
||||
}), 404
|
||||
|
||||
return jsonify(alert)
|
||||
|
||||
|
||||
@dsc_bp.route('/alerts/<int:alert_id>/acknowledge', methods=['POST'])
|
||||
def acknowledge_alert(alert_id: int) -> Response:
|
||||
"""Acknowledge a DSC alert."""
|
||||
data = request.json or {}
|
||||
notes = data.get('notes')
|
||||
|
||||
success = acknowledge_dsc_alert(alert_id, notes)
|
||||
if not success:
|
||||
return jsonify({
|
||||
'status': 'error',
|
||||
'message': 'Alert not found'
|
||||
}), 404
|
||||
|
||||
return jsonify({
|
||||
'status': 'acknowledged',
|
||||
'alert_id': alert_id
|
||||
})
|
||||
|
||||
|
||||
@dsc_bp.route('/alerts/summary')
|
||||
def get_alerts_summary() -> Response:
|
||||
"""Get summary of unacknowledged DSC alerts."""
|
||||
summary = get_dsc_alert_summary()
|
||||
return jsonify(summary)
|
||||
Reference in New Issue
Block a user