Phase 1 & 2: Cleanup redundant code and integrate pattern decoder
## Phase 1: Code Cleanup (~1,859 lines removed) **Deleted Redundant Matchers:** - ❌ strategies_orm.py (356 lines) - Old ORM-based strategies - ❌ simple_matcher.py (351 lines) - Replaced by strategies.py - ❌ rtl433_matcher.py (352 lines) - Replaced by strategies.py **Archived Old Scripts:** - Moved 11 one-time analysis/import scripts to scripts/archive/ - Scripts: analyze_flipper_signatures, analyze_tembed_files, identify_tembed_devices, import_flipper_sqlite, import_tembed_signatures, match_tembed_with_db, match_with_flipper_db, rematch_captures, test_gps_extraction, test_tembed_matching, test_wardriving_import **Consolidated API:** - Renamed main.py → main_orm_legacy.py (archived old ORM-based API) - main_simple.py is now the primary production API ## Phase 2: Pattern Decoder Integration ✅ **CRITICAL FIX: Pattern decoder now integrated into production API!** **Changes:** 1. Updated main_simple.py to use unified SignatureMatcher 2. Added 6 strategies to matcher pipeline: - ExactMatcher (protocol + frequency) - FrequencyMatcher (frequency-based) - BitPatternMatcher (data patterns) - TimingMatcher (timing-based) - RTL433DecoderStrategy (RTL_433 decoder) - PatternBasedStrategy (NEW! Pattern decoder for short captures) 3. Created MockDB class for simplified mode (no real database) 4. Replaced old get_matcher() with get_matcher_engine() 5. Updated upload handler to use MatchResult format 6. All matches now include confidence scores and match methods **Result:** - Pattern decoder is NOW ACTIVE in production 🎉 - Unified matching pipeline with 6 strategies - Cleaner codebase (-1,859 lines) - Single source of truth for matching logic 🎉 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
@@ -1,352 +0,0 @@
|
||||
"""
|
||||
RTL_433 Device Matcher
|
||||
|
||||
Loads and indexes the RTL_433 protocol database for high-accuracy device matching.
|
||||
Provides fuzzy name matching, timing-based matching, and category lookups.
|
||||
|
||||
Author: GigLez Team
|
||||
Date: January 2026
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
from pathlib import Path
|
||||
from typing import List, Dict, Optional, Tuple
|
||||
from dataclasses import dataclass
|
||||
from difflib import SequenceMatcher
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
@dataclass
|
||||
class RTL433Match:
|
||||
"""Match result from RTL_433 database"""
|
||||
device_id: str
|
||||
device_name: str
|
||||
category: str
|
||||
manufacturer: Optional[str]
|
||||
modulation: Optional[str]
|
||||
confidence: float
|
||||
match_method: str
|
||||
timing_data: Optional[Dict] = None
|
||||
|
||||
|
||||
class RTL433Matcher:
|
||||
"""
|
||||
High-performance matcher using RTL_433 protocol database
|
||||
|
||||
Features:
|
||||
- Fast device ID and name lookups
|
||||
- Fuzzy name matching for partial matches
|
||||
- Modulation-based filtering
|
||||
- Timing signature matching
|
||||
- Category-based fallbacks
|
||||
"""
|
||||
|
||||
def __init__(self, database_path: str = "data/rtl_433_protocols.json"):
|
||||
"""
|
||||
Initialize RTL_433 matcher with protocol database
|
||||
|
||||
Args:
|
||||
database_path: Path to rtl_433_protocols.json
|
||||
"""
|
||||
self.database_path = Path(database_path)
|
||||
self.devices: List[Dict] = []
|
||||
self.device_by_id: Dict[str, Dict] = {}
|
||||
self.device_by_name: Dict[str, Dict] = {}
|
||||
self.devices_by_category: Dict[str, List[Dict]] = {}
|
||||
self.devices_by_modulation: Dict[str, List[Dict]] = {}
|
||||
|
||||
self._load_database()
|
||||
self._build_indexes()
|
||||
|
||||
logger.info(f"RTL_433 matcher initialized with {len(self.devices)} devices")
|
||||
|
||||
def _load_database(self):
|
||||
"""Load RTL_433 protocol database from JSON"""
|
||||
try:
|
||||
if not self.database_path.exists():
|
||||
logger.warning(f"RTL_433 database not found: {self.database_path}")
|
||||
return
|
||||
|
||||
with open(self.database_path, 'r') as f:
|
||||
data = json.load(f)
|
||||
self.devices = data.get('devices', [])
|
||||
|
||||
logger.info(f"Loaded {len(self.devices)} RTL_433 protocols")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to load RTL_433 database: {e}")
|
||||
self.devices = []
|
||||
|
||||
def _build_indexes(self):
|
||||
"""Build search indexes for fast lookups"""
|
||||
for device in self.devices:
|
||||
# Index by device ID
|
||||
device_id = device.get('device_id', '').lower()
|
||||
if device_id:
|
||||
self.device_by_id[device_id] = device
|
||||
|
||||
# Index by device name (lowercase for case-insensitive)
|
||||
device_name = device.get('name', '').lower()
|
||||
if device_name:
|
||||
self.device_by_name[device_name] = device
|
||||
|
||||
# Index by category
|
||||
category = device.get('category', 'other')
|
||||
if category not in self.devices_by_category:
|
||||
self.devices_by_category[category] = []
|
||||
self.devices_by_category[category].append(device)
|
||||
|
||||
# Index by modulation
|
||||
modulation = device.get('modulation')
|
||||
if modulation:
|
||||
if modulation not in self.devices_by_modulation:
|
||||
self.devices_by_modulation[modulation] = []
|
||||
self.devices_by_modulation[modulation].append(device)
|
||||
|
||||
logger.info(f"Built indexes: {len(self.device_by_id)} IDs, "
|
||||
f"{len(self.devices_by_category)} categories, "
|
||||
f"{len(self.devices_by_modulation)} modulations")
|
||||
|
||||
def match_by_protocol_name(self, protocol: str) -> List[RTL433Match]:
|
||||
"""
|
||||
Match by protocol/device name
|
||||
|
||||
Tries:
|
||||
1. Exact device ID match
|
||||
2. Exact device name match
|
||||
3. Fuzzy name match (similarity > 0.6)
|
||||
|
||||
Args:
|
||||
protocol: Protocol name from .sub file (e.g., "acurite_rain_896", "Oregon")
|
||||
|
||||
Returns:
|
||||
List of matches sorted by confidence
|
||||
"""
|
||||
matches = []
|
||||
protocol_lower = protocol.lower()
|
||||
|
||||
# 1. Exact device ID match
|
||||
if protocol_lower in self.device_by_id:
|
||||
device = self.device_by_id[protocol_lower]
|
||||
matches.append(RTL433Match(
|
||||
device_id=device['device_id'],
|
||||
device_name=device['name'],
|
||||
category=device.get('category', 'other'),
|
||||
manufacturer=device.get('manufacturer'),
|
||||
modulation=device.get('modulation'),
|
||||
confidence=0.95,
|
||||
match_method='rtl433_exact_id'
|
||||
))
|
||||
return matches
|
||||
|
||||
# 2. Exact device name match
|
||||
if protocol_lower in self.device_by_name:
|
||||
device = self.device_by_name[protocol_lower]
|
||||
matches.append(RTL433Match(
|
||||
device_id=device['device_id'],
|
||||
device_name=device['name'],
|
||||
category=device.get('category', 'other'),
|
||||
manufacturer=device.get('manufacturer'),
|
||||
modulation=device.get('modulation'),
|
||||
confidence=0.90,
|
||||
match_method='rtl433_exact_name'
|
||||
))
|
||||
return matches
|
||||
|
||||
# 3. Fuzzy matching - check all devices
|
||||
for device in self.devices:
|
||||
device_id = device.get('device_id', '').lower()
|
||||
device_name = device.get('name', '').lower()
|
||||
|
||||
# Calculate similarity scores
|
||||
id_similarity = SequenceMatcher(None, protocol_lower, device_id).ratio()
|
||||
name_similarity = SequenceMatcher(None, protocol_lower, device_name).ratio()
|
||||
|
||||
# Also check if protocol is substring
|
||||
substring_match = protocol_lower in device_id or protocol_lower in device_name
|
||||
|
||||
# Take best similarity
|
||||
similarity = max(id_similarity, name_similarity)
|
||||
if substring_match:
|
||||
similarity = max(similarity, 0.7)
|
||||
|
||||
if similarity > 0.6:
|
||||
matches.append(RTL433Match(
|
||||
device_id=device['device_id'],
|
||||
device_name=device['name'],
|
||||
category=device.get('category', 'other'),
|
||||
manufacturer=device.get('manufacturer'),
|
||||
modulation=device.get('modulation'),
|
||||
confidence=0.70 + (similarity * 0.15), # 0.70-0.85 range
|
||||
match_method='rtl433_fuzzy'
|
||||
))
|
||||
|
||||
# Sort by confidence
|
||||
matches.sort(key=lambda x: x.confidence, reverse=True)
|
||||
return matches[:5] # Top 5 matches
|
||||
|
||||
def match_by_modulation(self, modulation: str, category: Optional[str] = None) -> List[RTL433Match]:
|
||||
"""
|
||||
Match devices by modulation type
|
||||
|
||||
Args:
|
||||
modulation: Modulation type (OOK, FSK, etc.)
|
||||
category: Optional category filter
|
||||
|
||||
Returns:
|
||||
List of matches
|
||||
"""
|
||||
matches = []
|
||||
|
||||
devices = self.devices_by_modulation.get(modulation, [])
|
||||
|
||||
# Filter by category if provided
|
||||
if category:
|
||||
devices = [d for d in devices if d.get('category') == category]
|
||||
|
||||
# Return top matches
|
||||
for device in devices[:10]:
|
||||
matches.append(RTL433Match(
|
||||
device_id=device['device_id'],
|
||||
device_name=device['name'],
|
||||
category=device.get('category', 'other'),
|
||||
manufacturer=device.get('manufacturer'),
|
||||
modulation=device.get('modulation'),
|
||||
confidence=0.55, # Lower confidence for modulation-only match
|
||||
match_method='rtl433_modulation'
|
||||
))
|
||||
|
||||
return matches
|
||||
|
||||
def match_by_timing(self, short_pulse: int, long_pulse: int,
|
||||
gap_limit: Optional[int] = None,
|
||||
tolerance: float = 0.15) -> List[RTL433Match]:
|
||||
"""
|
||||
Match devices by timing signature
|
||||
|
||||
Args:
|
||||
short_pulse: Short pulse width in microseconds
|
||||
long_pulse: Long pulse width in microseconds
|
||||
gap_limit: Gap limit in microseconds (optional)
|
||||
tolerance: Matching tolerance (default 15%)
|
||||
|
||||
Returns:
|
||||
List of matches sorted by timing similarity
|
||||
"""
|
||||
matches = []
|
||||
|
||||
for device in self.devices:
|
||||
device_short = device.get('short_width')
|
||||
device_long = device.get('long_width')
|
||||
device_gap = device.get('gap_limit')
|
||||
|
||||
if not (device_short and device_long):
|
||||
continue
|
||||
|
||||
# Calculate timing similarity
|
||||
short_diff = abs(short_pulse - device_short) / device_short
|
||||
long_diff = abs(long_pulse - device_long) / device_long
|
||||
|
||||
# Both must be within tolerance
|
||||
if short_diff <= tolerance and long_diff <= tolerance:
|
||||
# Calculate confidence based on closeness
|
||||
similarity = 1.0 - ((short_diff + long_diff) / 2)
|
||||
|
||||
# Bonus for gap match
|
||||
gap_bonus = 0.0
|
||||
if gap_limit and device_gap:
|
||||
gap_diff = abs(gap_limit - device_gap) / device_gap
|
||||
if gap_diff <= tolerance:
|
||||
gap_bonus = 0.05
|
||||
|
||||
confidence = 0.70 + (similarity * 0.20) + gap_bonus
|
||||
|
||||
matches.append(RTL433Match(
|
||||
device_id=device['device_id'],
|
||||
device_name=device['name'],
|
||||
category=device.get('category', 'other'),
|
||||
manufacturer=device.get('manufacturer'),
|
||||
modulation=device.get('modulation'),
|
||||
confidence=min(confidence, 0.95),
|
||||
match_method='rtl433_timing',
|
||||
timing_data={
|
||||
'short_pulse': device_short,
|
||||
'long_pulse': device_long,
|
||||
'gap_limit': device_gap,
|
||||
'similarity': similarity
|
||||
}
|
||||
))
|
||||
|
||||
# Sort by confidence
|
||||
matches.sort(key=lambda x: x.confidence, reverse=True)
|
||||
return matches[:5]
|
||||
|
||||
def get_devices_by_category(self, category: str) -> List[Dict]:
|
||||
"""Get all devices in a category"""
|
||||
return self.devices_by_category.get(category, [])
|
||||
|
||||
def get_statistics(self) -> Dict:
|
||||
"""Get database statistics"""
|
||||
return {
|
||||
'total_devices': len(self.devices),
|
||||
'categories': {cat: len(devs) for cat, devs in self.devices_by_category.items()},
|
||||
'modulations': {mod: len(devs) for mod, devs in self.devices_by_modulation.items()},
|
||||
'manufacturers': len(set(d.get('manufacturer') for d in self.devices if d.get('manufacturer')))
|
||||
}
|
||||
|
||||
|
||||
# Global singleton instance
|
||||
_rtl433_matcher: Optional[RTL433Matcher] = None
|
||||
|
||||
|
||||
def get_rtl433_matcher() -> RTL433Matcher:
|
||||
"""Get or create RTL_433 matcher singleton"""
|
||||
global _rtl433_matcher
|
||||
if _rtl433_matcher is None:
|
||||
_rtl433_matcher = RTL433Matcher()
|
||||
return _rtl433_matcher
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
# Test the matcher
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
|
||||
matcher = RTL433Matcher()
|
||||
|
||||
print("\n" + "="*60)
|
||||
print("RTL_433 MATCHER TEST")
|
||||
print("="*60)
|
||||
|
||||
# Test 1: Exact match
|
||||
print("\n1. Exact Protocol Match: 'acurite_rain_896'")
|
||||
matches = matcher.match_by_protocol_name('acurite_rain_896')
|
||||
for match in matches:
|
||||
print(f" {match.device_name} ({match.confidence:.2f}) - {match.match_method}")
|
||||
|
||||
# Test 2: Fuzzy match
|
||||
print("\n2. Fuzzy Match: 'Oregon'")
|
||||
matches = matcher.match_by_protocol_name('Oregon')
|
||||
for match in matches:
|
||||
print(f" {match.device_name} ({match.confidence:.2f}) - {match.match_method}")
|
||||
|
||||
# Test 3: Modulation match
|
||||
print("\n3. Modulation Match: 'OOK'")
|
||||
matches = matcher.match_by_modulation('OOK', category='weather')[:3]
|
||||
for match in matches:
|
||||
print(f" {match.device_name} ({match.confidence:.2f})")
|
||||
|
||||
# Test 4: Timing match
|
||||
print("\n4. Timing Match: short=1000µs, long=2000µs")
|
||||
matches = matcher.match_by_timing(1000, 2000)
|
||||
for match in matches:
|
||||
print(f" {match.device_name} ({match.confidence:.2f})")
|
||||
|
||||
# Statistics
|
||||
print("\n" + "="*60)
|
||||
stats = matcher.get_statistics()
|
||||
print(f"Total devices: {stats['total_devices']}")
|
||||
print(f"Categories: {len(stats['categories'])}")
|
||||
print(f"Modulations: {len(stats['modulations'])}")
|
||||
print("="*60)
|
||||
@@ -1,351 +0,0 @@
|
||||
"""
|
||||
Enhanced Device Matcher - RTL_433 + Timing Analysis + Frequency-based categorization
|
||||
|
||||
Integrates:
|
||||
- RTL_433 protocol database (286 devices)
|
||||
- RAW signal timing analysis
|
||||
- Frequency-based categorization
|
||||
- Protocol pattern matching
|
||||
"""
|
||||
|
||||
import logging
|
||||
from typing import List, Dict, Tuple, Optional
|
||||
from dataclasses import dataclass
|
||||
|
||||
# Import enhanced matchers
|
||||
try:
|
||||
from src.matcher.rtl433_matcher import get_rtl433_matcher, RTL433Match
|
||||
from src.parser.raw_parser import parse_raw_data
|
||||
RTL433_AVAILABLE = True
|
||||
except ImportError:
|
||||
RTL433_AVAILABLE = False
|
||||
logging.warning("RTL_433 matcher not available, using fallback matching")
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
@dataclass
|
||||
class DeviceMatch:
|
||||
"""Device identification result"""
|
||||
device_name: str
|
||||
device_category: str
|
||||
confidence: float
|
||||
match_method: str
|
||||
description: str
|
||||
|
||||
|
||||
class SimpleDeviceMatcher:
|
||||
"""
|
||||
Lightweight device matcher using frequency-based categorization
|
||||
|
||||
Based on research from FREQUENCY_DEVICE_CHART.md and industry standards
|
||||
"""
|
||||
|
||||
# Frequency ranges and associated device types
|
||||
FREQUENCY_PATTERNS = {
|
||||
# 313-316 MHz - North America TPMS
|
||||
(313_000_000, 316_000_000): [
|
||||
("TPMS Sensor", "Automotive", 0.7, "Tire Pressure Monitoring System"),
|
||||
("Car Key Fob", "Automotive", 0.5, "Vehicle remote"),
|
||||
],
|
||||
|
||||
# 315 MHz - North America generic
|
||||
(314_500_000, 315_500_000): [
|
||||
("Garage Door Opener", "Home Automation", 0.6, "Generic 315MHz remote"),
|
||||
("Wireless Doorbell", "Home Automation", 0.5, "Simple doorbell"),
|
||||
("Security Sensor", "Security", 0.5, "Door/window sensor"),
|
||||
],
|
||||
|
||||
# 319.5 MHz - GE/Interlogix
|
||||
(319_000_000, 320_000_000): [
|
||||
("GE Security Sensor", "Security", 0.8, "GE/Interlogix professional sensor"),
|
||||
],
|
||||
|
||||
# 345 MHz - Honeywell
|
||||
(344_000_000, 346_000_000): [
|
||||
("Honeywell Security Sensor", "Security", 0.9, "Honeywell door/window sensor"),
|
||||
],
|
||||
|
||||
# 390 MHz - Chamberlain
|
||||
(389_000_000, 391_000_000): [
|
||||
("Chamberlain Garage Door", "Home Automation", 0.9, "Chamberlain Security+ opener"),
|
||||
],
|
||||
|
||||
# 433.05-434.79 MHz - Primary ISM band
|
||||
(433_000_000, 435_000_000): [
|
||||
("Generic 433MHz Device", "Consumer RF", 0.4, "Unidentified 433MHz device"),
|
||||
("Remote Control", "Consumer RF", 0.5, "Generic remote control"),
|
||||
("Wireless Sensor", "Sensors", 0.5, "Temperature/humidity sensor"),
|
||||
],
|
||||
|
||||
# 433.42 MHz - Somfy RTS
|
||||
(433_410_000, 433_430_000): [
|
||||
("Somfy RTS Blind", "Home Automation", 0.95, "Somfy motorized blind/shutter"),
|
||||
],
|
||||
|
||||
# 433.92 MHz - Most common
|
||||
(433_910_000, 433_930_000): [
|
||||
("Weather Station", "Sensors", 0.6, "433MHz weather station"),
|
||||
("Car Key Fob", "Automotive", 0.5, "Vehicle remote control"),
|
||||
("Gate/Garage Opener", "Home Automation", 0.5, "Nice Flor-S / FAAC"),
|
||||
],
|
||||
|
||||
# 868 MHz - Europe smart meters/LoRa
|
||||
(868_000_000, 870_000_000): [
|
||||
("Smart Meter", "Utility", 0.7, "European electricity/gas meter"),
|
||||
("LoRa Sensor", "IoT", 0.6, "Long-range IoT sensor"),
|
||||
("Z-Wave Device", "Home Automation", 0.5, "Z-Wave smart home device"),
|
||||
],
|
||||
|
||||
# 915 MHz - North America IoT
|
||||
(902_000_000, 928_000_000): [
|
||||
("RFID Tag", "Industrial", 0.6, "UHF RFID asset tag"),
|
||||
("Smart Meter", "Utility", 0.6, "North America meter"),
|
||||
("LoRa Sensor", "IoT", 0.5, "Long-range IoT sensor"),
|
||||
("Industrial Sensor", "Industrial", 0.5, "SCADA/telemetry"),
|
||||
],
|
||||
}
|
||||
|
||||
# Protocol-specific device identification
|
||||
PROTOCOL_PATTERNS = {
|
||||
"Princeton": [
|
||||
("Princeton Remote", "Consumer RF", 0.7, "PT2260/PT2262 generic remote"),
|
||||
],
|
||||
"EV1527": [
|
||||
("EV1527 Remote/Sensor", "Consumer RF", 0.8, "Cheap Chinese RF device"),
|
||||
],
|
||||
"Keeloq": [
|
||||
("Keeloq Remote", "Automotive", 0.9, "Encrypted rolling code (car/garage)"),
|
||||
],
|
||||
"HCS301": [
|
||||
("HCS301 Key Fob", "Automotive", 0.9, "Microchip encrypted remote"),
|
||||
],
|
||||
"Oregon": [
|
||||
("Oregon Scientific Weather Station", "Sensors", 0.95, "Oregon Scientific weather sensor"),
|
||||
],
|
||||
"OregonScientific": [
|
||||
("Oregon Scientific Weather Station", "Sensors", 0.95, "Oregon Scientific weather sensor"),
|
||||
],
|
||||
"Acurite": [
|
||||
("Acurite Weather Sensor", "Sensors", 0.95, "Acurite temperature/humidity sensor"),
|
||||
],
|
||||
"LaCrosse": [
|
||||
("LaCrosse Sensor", "Sensors", 0.95, "LaCrosse temperature sensor"),
|
||||
],
|
||||
"Nexus": [
|
||||
("Nexus Sensor", "Sensors", 0.9, "Nexus outdoor sensor"),
|
||||
],
|
||||
"Somfy": [
|
||||
("Somfy RTS", "Home Automation", 0.95, "Somfy motorized blind"),
|
||||
],
|
||||
"Nice": [
|
||||
("Nice Gate Opener", "Home Automation", 0.9, "Nice Flor-S gate remote"),
|
||||
],
|
||||
"FAAC": [
|
||||
("FAAC Gate Opener", "Home Automation", 0.9, "FAAC gate remote"),
|
||||
],
|
||||
}
|
||||
|
||||
# Modulation + frequency patterns
|
||||
MODULATION_PATTERNS = {
|
||||
("OOK", 315_000_000, 316_000_000): [
|
||||
("Generic 315MHz Remote", "Consumer RF", 0.6, "Simple OOK device"),
|
||||
],
|
||||
("OOK", 433_000_000, 435_000_000): [
|
||||
("Generic 433MHz Remote", "Consumer RF", 0.6, "Simple OOK device"),
|
||||
],
|
||||
("FSK", 868_000_000, 870_000_000): [
|
||||
("Smart Device (868MHz FSK)", "IoT", 0.7, "Advanced IoT device"),
|
||||
],
|
||||
("FSK", 902_000_000, 928_000_000): [
|
||||
("Smart Device (915MHz FSK)", "IoT", 0.7, "Advanced IoT device"),
|
||||
],
|
||||
}
|
||||
|
||||
def match(self, frequency: int, protocol: str = None, preset: str = None,
|
||||
raw_data: str = None) -> List[DeviceMatch]:
|
||||
"""
|
||||
Enhanced device matching with RTL_433 and timing analysis
|
||||
|
||||
Args:
|
||||
frequency: Frequency in Hz
|
||||
protocol: Protocol name (e.g., "Princeton", "RAW")
|
||||
preset: Preset/modulation (e.g., "FuriHalSubGhzPresetOok270Async")
|
||||
raw_data: RAW_Data string for timing analysis (optional)
|
||||
|
||||
Returns:
|
||||
List of DeviceMatch objects sorted by confidence
|
||||
"""
|
||||
matches = []
|
||||
|
||||
# PHASE 2: RTL_433 Protocol Database Matching (NEW!)
|
||||
if RTL433_AVAILABLE and protocol and protocol != "RAW":
|
||||
try:
|
||||
rtl433_matcher = get_rtl433_matcher()
|
||||
rtl433_matches = rtl433_matcher.match_by_protocol_name(protocol)
|
||||
|
||||
for rtl_match in rtl433_matches:
|
||||
matches.append(DeviceMatch(
|
||||
device_name=rtl_match.device_name,
|
||||
device_category=rtl_match.category,
|
||||
confidence=rtl_match.confidence,
|
||||
match_method=rtl_match.match_method,
|
||||
description=f"{rtl_match.manufacturer or 'Unknown'} - {rtl_match.modulation or 'Unknown'} modulation"
|
||||
))
|
||||
logger.info(f"RTL_433 match: {rtl_match.device_name} ({rtl_match.confidence:.2f})")
|
||||
except Exception as e:
|
||||
logger.warning(f"RTL_433 matching failed: {e}")
|
||||
|
||||
# PHASE 3: Timing Analysis for RAW captures (NEW!)
|
||||
if RTL433_AVAILABLE and raw_data and protocol == "RAW":
|
||||
try:
|
||||
# Parse RAW signal
|
||||
timing_sig = parse_raw_data(raw_data)
|
||||
if timing_sig:
|
||||
logger.info(f"Timing signature: {timing_sig.short_pulse}µs/{timing_sig.long_pulse}µs, "
|
||||
f"encoding={timing_sig.encoding_type}")
|
||||
|
||||
# Match against RTL_433 timing signatures
|
||||
rtl433_matcher = get_rtl433_matcher()
|
||||
timing_matches = rtl433_matcher.match_by_timing(
|
||||
timing_sig.short_pulse,
|
||||
timing_sig.long_pulse,
|
||||
timing_sig.gap,
|
||||
tolerance=0.15
|
||||
)
|
||||
|
||||
for rtl_match in timing_matches:
|
||||
matches.append(DeviceMatch(
|
||||
device_name=rtl_match.device_name,
|
||||
device_category=rtl_match.category,
|
||||
confidence=rtl_match.confidence,
|
||||
match_method=rtl_match.match_method,
|
||||
description=f"Timing match: {rtl_match.timing_data['similarity']:.2%} similarity"
|
||||
))
|
||||
logger.info(f"Timing match: {rtl_match.device_name} ({rtl_match.confidence:.2f})")
|
||||
except Exception as e:
|
||||
logger.warning(f"Timing analysis failed: {e}")
|
||||
|
||||
# 1. Protocol-based matching (original, lower confidence)
|
||||
if protocol and protocol != "RAW":
|
||||
protocol_matches = self._match_by_protocol(protocol)
|
||||
matches.extend(protocol_matches)
|
||||
|
||||
# 2. Exact frequency matching
|
||||
freq_matches = self._match_by_frequency(frequency)
|
||||
matches.extend(freq_matches)
|
||||
|
||||
# 3. Modulation + frequency matching
|
||||
if preset:
|
||||
modulation = self._extract_modulation(preset)
|
||||
mod_matches = self._match_by_modulation(frequency, modulation)
|
||||
matches.extend(mod_matches)
|
||||
|
||||
# 4. Deduplicate and sort by confidence
|
||||
unique_matches = self._deduplicate_matches(matches)
|
||||
return sorted(unique_matches, key=lambda x: x.confidence, reverse=True)
|
||||
|
||||
def _match_by_protocol(self, protocol: str) -> List[DeviceMatch]:
|
||||
"""Match by protocol name"""
|
||||
matches = []
|
||||
|
||||
for proto_pattern, devices in self.PROTOCOL_PATTERNS.items():
|
||||
if proto_pattern.lower() in protocol.lower():
|
||||
for device_name, category, confidence, description in devices:
|
||||
matches.append(DeviceMatch(
|
||||
device_name=device_name,
|
||||
device_category=category,
|
||||
confidence=confidence,
|
||||
match_method="protocol",
|
||||
description=description
|
||||
))
|
||||
|
||||
return matches
|
||||
|
||||
def _match_by_frequency(self, frequency: int) -> List[DeviceMatch]:
|
||||
"""Match by frequency range"""
|
||||
matches = []
|
||||
|
||||
for (freq_min, freq_max), devices in self.FREQUENCY_PATTERNS.items():
|
||||
if freq_min <= frequency <= freq_max:
|
||||
for device_name, category, confidence, description in devices:
|
||||
# Adjust confidence based on frequency precision
|
||||
freq_center = (freq_min + freq_max) / 2
|
||||
freq_range = freq_max - freq_min
|
||||
distance_from_center = abs(frequency - freq_center)
|
||||
|
||||
# Reduce confidence if far from center
|
||||
if freq_range > 1_000_000: # Wide range (> 1 MHz)
|
||||
confidence_adj = confidence * (1.0 - (distance_from_center / freq_range) * 0.3)
|
||||
else: # Narrow range
|
||||
confidence_adj = confidence
|
||||
|
||||
matches.append(DeviceMatch(
|
||||
device_name=device_name,
|
||||
device_category=category,
|
||||
confidence=max(0.3, confidence_adj), # Min 0.3
|
||||
match_method="frequency",
|
||||
description=description
|
||||
))
|
||||
|
||||
return matches
|
||||
|
||||
def _match_by_modulation(self, frequency: int, modulation: str) -> List[DeviceMatch]:
|
||||
"""Match by modulation + frequency"""
|
||||
matches = []
|
||||
|
||||
for (mod, freq_min, freq_max), devices in self.MODULATION_PATTERNS.items():
|
||||
if mod == modulation and freq_min <= frequency <= freq_max:
|
||||
for device_name, category, confidence, description in devices:
|
||||
matches.append(DeviceMatch(
|
||||
device_name=device_name,
|
||||
device_category=category,
|
||||
confidence=confidence,
|
||||
match_method="modulation+frequency",
|
||||
description=description
|
||||
))
|
||||
|
||||
return matches
|
||||
|
||||
def _extract_modulation(self, preset: str) -> Optional[str]:
|
||||
"""Extract modulation type from preset string"""
|
||||
preset_lower = preset.lower()
|
||||
|
||||
if "ook" in preset_lower:
|
||||
return "OOK"
|
||||
elif "fsk" in preset_lower:
|
||||
return "FSK"
|
||||
elif "ask" in preset_lower:
|
||||
return "ASK"
|
||||
else:
|
||||
return None
|
||||
|
||||
def _deduplicate_matches(self, matches: List[DeviceMatch]) -> List[DeviceMatch]:
|
||||
"""Remove duplicate device names, keeping highest confidence"""
|
||||
seen = {}
|
||||
|
||||
for match in matches:
|
||||
if match.device_name not in seen or match.confidence > seen[match.device_name].confidence:
|
||||
seen[match.device_name] = match
|
||||
|
||||
return list(seen.values())
|
||||
|
||||
def get_best_match(self, frequency: int, protocol: str = None, preset: str = None) -> Optional[DeviceMatch]:
|
||||
"""Get single best match"""
|
||||
matches = self.match(frequency, protocol, preset)
|
||||
return matches[0] if matches else None
|
||||
|
||||
def format_device_string(self, match: DeviceMatch) -> str:
|
||||
"""Format device match as human-readable string"""
|
||||
return f"{match.device_name} ({match.device_category})"
|
||||
|
||||
|
||||
# Singleton instance
|
||||
_matcher = None
|
||||
|
||||
def get_matcher() -> SimpleDeviceMatcher:
|
||||
"""Get singleton matcher instance"""
|
||||
global _matcher
|
||||
if _matcher is None:
|
||||
_matcher = SimpleDeviceMatcher()
|
||||
return _matcher
|
||||
@@ -1,356 +0,0 @@
|
||||
"""
|
||||
Signature matching strategies using SQLAlchemy ORM
|
||||
|
||||
These strategies use the ORM models for cleaner database access
|
||||
"""
|
||||
|
||||
from typing import List
|
||||
from loguru import logger
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from .engine import MatchStrategy, MatchResult
|
||||
from ..parser.metadata import SignalMetadata
|
||||
from ..database.models import Device, Signature
|
||||
|
||||
|
||||
class FrequencyMatcherORM(MatchStrategy):
|
||||
"""
|
||||
Match by frequency proximity (for RAW signals without protocol)
|
||||
|
||||
Confidence: 0.5-0.8 based on frequency proximity and additional factors
|
||||
"""
|
||||
|
||||
def __init__(self, session: Session, tolerance_hz: int = 10000):
|
||||
"""
|
||||
Initialize frequency matcher
|
||||
|
||||
Args:
|
||||
session: SQLAlchemy session
|
||||
tolerance_hz: Frequency tolerance in Hz (default 10kHz)
|
||||
"""
|
||||
self.session = session
|
||||
self.tolerance = tolerance_hz
|
||||
|
||||
def match(self, metadata: SignalMetadata, db=None) -> List[MatchResult]:
|
||||
"""Match by frequency proximity"""
|
||||
matches = []
|
||||
|
||||
freq_min = metadata.frequency - self.tolerance
|
||||
freq_max = metadata.frequency + self.tolerance
|
||||
|
||||
# Query signatures within frequency range
|
||||
signatures = self.session.query(Signature).filter(
|
||||
Signature.frequency.between(freq_min, freq_max)
|
||||
).all()
|
||||
|
||||
logger.debug(f"FrequencyMatcher: Found {len(signatures)} signatures in range")
|
||||
|
||||
for sig in signatures:
|
||||
device = sig.device
|
||||
|
||||
# Calculate confidence based on frequency difference
|
||||
freq_diff = abs(sig.frequency - metadata.frequency)
|
||||
base_confidence = 0.8 * (1.0 - (freq_diff / self.tolerance))
|
||||
base_confidence = max(0.5, min(0.8, base_confidence))
|
||||
|
||||
# Bonus for exact frequency match
|
||||
if freq_diff == 0:
|
||||
base_confidence = 0.9
|
||||
|
||||
matches.append(MatchResult(
|
||||
device_id=device.id,
|
||||
device_name=device.device_name or device.model,
|
||||
manufacturer=device.manufacturer or 'Unknown',
|
||||
confidence=base_confidence,
|
||||
match_method='frequency',
|
||||
match_details={
|
||||
'signature_id': sig.id,
|
||||
'frequency': sig.frequency,
|
||||
'frequency_diff_hz': freq_diff,
|
||||
'tolerance_hz': self.tolerance
|
||||
}
|
||||
))
|
||||
|
||||
logger.debug(f"FrequencyMatcher: Returning {len(matches)} matches")
|
||||
return matches
|
||||
|
||||
|
||||
class TimingMatcherORM(MatchStrategy):
|
||||
"""
|
||||
Timing pattern matching for RAW signals
|
||||
|
||||
Compares RAW_Data timing patterns to find similar signals
|
||||
Confidence: 0.6-0.9 based on timing similarity
|
||||
"""
|
||||
|
||||
def __init__(self, session: Session):
|
||||
"""Initialize timing matcher"""
|
||||
self.session = session
|
||||
|
||||
def match(self, metadata: SignalMetadata, db=None) -> List[MatchResult]:
|
||||
"""Match by timing pattern characteristics"""
|
||||
matches = []
|
||||
|
||||
if not metadata.raw_data or len(metadata.raw_data) == 0:
|
||||
logger.debug("TimingMatcher: No RAW data to match")
|
||||
return matches
|
||||
|
||||
# Calculate statistics from input signal
|
||||
abs_timings = [abs(t) for t in metadata.raw_data]
|
||||
avg_timing = sum(abs_timings) / len(abs_timings)
|
||||
min_timing = min(abs_timings)
|
||||
max_timing = max(abs_timings)
|
||||
|
||||
logger.debug(f"TimingMatcher: Input stats - avg:{avg_timing:.1f}, "
|
||||
f"min:{min_timing}, max:{max_timing}, samples:{len(metadata.raw_data)}")
|
||||
|
||||
# Query signatures with timing information at same frequency
|
||||
signatures = self.session.query(Signature).filter(
|
||||
Signature.frequency == metadata.frequency,
|
||||
Signature.timing_min.isnot(None)
|
||||
).all()
|
||||
|
||||
logger.debug(f"TimingMatcher: Found {len(signatures)} signatures with timing data")
|
||||
|
||||
for sig in signatures:
|
||||
device = sig.device
|
||||
|
||||
# Check if our timing characteristics overlap
|
||||
timing_overlap = self._check_timing_overlap(
|
||||
min_timing, max_timing, avg_timing,
|
||||
sig.timing_min, sig.timing_max
|
||||
)
|
||||
|
||||
if timing_overlap > 0:
|
||||
confidence = 0.6 + (timing_overlap * 0.3) # 0.6-0.9 range
|
||||
|
||||
matches.append(MatchResult(
|
||||
device_id=device.id,
|
||||
device_name=device.device_name or device.model,
|
||||
manufacturer=device.manufacturer or 'Unknown',
|
||||
confidence=confidence,
|
||||
match_method='timing',
|
||||
match_details={
|
||||
'signature_id': sig.id,
|
||||
'input_avg_timing': avg_timing,
|
||||
'input_range': (min_timing, max_timing),
|
||||
'signature_range': (sig.timing_min, sig.timing_max),
|
||||
'overlap_score': timing_overlap
|
||||
}
|
||||
))
|
||||
|
||||
logger.debug(f"TimingMatcher: Returning {len(matches)} matches")
|
||||
return matches
|
||||
|
||||
def _check_timing_overlap(self, in_min, in_max, in_avg, sig_min, sig_max) -> float:
|
||||
"""
|
||||
Check how well timing ranges overlap
|
||||
|
||||
Returns:
|
||||
Overlap score 0.0-1.0
|
||||
"""
|
||||
# Check if ranges overlap at all
|
||||
if in_max < sig_min or in_min > sig_max:
|
||||
return 0.0
|
||||
|
||||
# Calculate overlap percentage
|
||||
overlap_min = max(in_min, sig_min)
|
||||
overlap_max = min(in_max, sig_max)
|
||||
overlap_size = overlap_max - overlap_min
|
||||
|
||||
input_size = in_max - in_min
|
||||
sig_size = sig_max - sig_min
|
||||
|
||||
# Overlap as percentage of smallest range
|
||||
min_size = min(input_size, sig_size)
|
||||
if min_size == 0:
|
||||
# Exact match if both are single values
|
||||
return 1.0 if in_avg == sig_min else 0.0
|
||||
|
||||
overlap_pct = overlap_size / min_size
|
||||
|
||||
# Bonus if average falls within signature range
|
||||
if sig_min <= in_avg <= sig_max:
|
||||
overlap_pct = min(1.0, overlap_pct * 1.2)
|
||||
|
||||
return overlap_pct
|
||||
|
||||
|
||||
class RAWPatternMatcherORM(MatchStrategy):
|
||||
"""
|
||||
Advanced RAW pattern matching using sequence comparison
|
||||
|
||||
Compares actual RAW_Data sequences for similarity
|
||||
Confidence: 0.7-0.95 based on pattern similarity
|
||||
"""
|
||||
|
||||
def __init__(self, session: Session, min_samples: int = 10):
|
||||
"""
|
||||
Initialize RAW pattern matcher
|
||||
|
||||
Args:
|
||||
session: SQLAlchemy session
|
||||
min_samples: Minimum RAW samples needed for matching
|
||||
"""
|
||||
self.session = session
|
||||
self.min_samples = min_samples
|
||||
|
||||
def match(self, metadata: SignalMetadata, db=None) -> List[MatchResult]:
|
||||
"""Match by RAW pattern similarity"""
|
||||
matches = []
|
||||
|
||||
if not metadata.raw_data or len(metadata.raw_data) < self.min_samples:
|
||||
logger.debug(f"RAWPatternMatcher: Not enough samples "
|
||||
f"({len(metadata.raw_data) if metadata.raw_data else 0})")
|
||||
return matches
|
||||
|
||||
# Query signatures with RAW patterns at same frequency
|
||||
signatures = self.session.query(Signature).filter(
|
||||
Signature.frequency == metadata.frequency,
|
||||
Signature.raw_pattern.isnot(None)
|
||||
).all()
|
||||
|
||||
logger.debug(f"RAWPatternMatcher: Comparing against {len(signatures)} signatures")
|
||||
|
||||
for sig in signatures:
|
||||
device = sig.device
|
||||
|
||||
# Parse stored RAW pattern
|
||||
try:
|
||||
sig_raw_data = [int(x) for x in sig.raw_pattern.split(',')]
|
||||
except (ValueError, AttributeError) as e:
|
||||
logger.warning(f"Could not parse raw_pattern for signature {sig.id}: {e}")
|
||||
continue
|
||||
|
||||
if len(sig_raw_data) < self.min_samples:
|
||||
continue
|
||||
|
||||
# Compare patterns
|
||||
similarity = self._compare_raw_sequences(
|
||||
metadata.raw_data,
|
||||
sig_raw_data
|
||||
)
|
||||
|
||||
if similarity > 0.5: # Minimum threshold
|
||||
confidence = 0.7 + (similarity * 0.25) # 0.7-0.95 range
|
||||
|
||||
matches.append(MatchResult(
|
||||
device_id=device.id,
|
||||
device_name=device.device_name or device.model,
|
||||
manufacturer=device.manufacturer or 'Unknown',
|
||||
confidence=confidence,
|
||||
match_method='raw_pattern',
|
||||
match_details={
|
||||
'signature_id': sig.id,
|
||||
'similarity': similarity,
|
||||
'input_samples': len(metadata.raw_data),
|
||||
'signature_samples': len(sig_raw_data)
|
||||
}
|
||||
))
|
||||
|
||||
logger.debug(f"RAWPatternMatcher: Returning {len(matches)} matches")
|
||||
return matches
|
||||
|
||||
def _compare_raw_sequences(self, seq1: List[int], seq2: List[int]) -> float:
|
||||
"""
|
||||
Compare two RAW timing sequences
|
||||
|
||||
Uses normalized cross-correlation approach
|
||||
|
||||
Returns:
|
||||
Similarity score 0.0-1.0
|
||||
"""
|
||||
# Use shorter sequence as reference
|
||||
if len(seq1) > len(seq2):
|
||||
seq1, seq2 = seq2, seq1
|
||||
|
||||
# Normalize sequences (convert to relative timings)
|
||||
norm_seq1 = self._normalize_sequence(seq1)
|
||||
norm_seq2 = self._normalize_sequence(seq2)
|
||||
|
||||
# Find best alignment using sliding window
|
||||
best_similarity = 0.0
|
||||
window_size = min(len(norm_seq1), 50) # Limit comparison window
|
||||
|
||||
for offset in range(max(1, len(norm_seq2) - len(norm_seq1))):
|
||||
similarity = self._compare_windows(
|
||||
norm_seq1[:window_size],
|
||||
norm_seq2[offset:offset+window_size]
|
||||
)
|
||||
best_similarity = max(best_similarity, similarity)
|
||||
|
||||
return best_similarity
|
||||
|
||||
def _normalize_sequence(self, seq: List[int]) -> List[float]:
|
||||
"""
|
||||
Normalize a timing sequence
|
||||
|
||||
Converts absolute timings to relative values (0.0-1.0 range)
|
||||
"""
|
||||
abs_seq = [abs(x) for x in seq]
|
||||
max_val = max(abs_seq) if abs_seq else 1
|
||||
return [x / max_val for x in abs_seq]
|
||||
|
||||
def _compare_windows(self, window1: List[float], window2: List[float]) -> float:
|
||||
"""
|
||||
Compare two timing windows
|
||||
|
||||
Returns similarity score 0.0-1.0
|
||||
"""
|
||||
min_len = min(len(window1), len(window2))
|
||||
if min_len == 0:
|
||||
return 0.0
|
||||
|
||||
# Calculate normalized difference
|
||||
diff_sum = sum(abs(window1[i] - window2[i]) for i in range(min_len))
|
||||
avg_diff = diff_sum / min_len
|
||||
|
||||
# Convert to similarity (0.0 = identical, higher = more different)
|
||||
similarity = max(0.0, 1.0 - avg_diff)
|
||||
|
||||
return similarity
|
||||
|
||||
|
||||
class ExactMatcherORM(MatchStrategy):
|
||||
"""
|
||||
Exact protocol + frequency matching
|
||||
|
||||
For decoded signals with known protocols
|
||||
Confidence: 1.0 for perfect matches
|
||||
"""
|
||||
|
||||
def __init__(self, session: Session):
|
||||
"""Initialize exact matcher"""
|
||||
self.session = session
|
||||
|
||||
def match(self, metadata: SignalMetadata, db=None) -> List[MatchResult]:
|
||||
"""Match by exact protocol and frequency"""
|
||||
matches = []
|
||||
|
||||
if not metadata.protocol or metadata.protocol == 'RAW':
|
||||
return matches
|
||||
|
||||
# Query for exact matches
|
||||
signatures = self.session.query(Signature).filter(
|
||||
Signature.protocol == metadata.protocol,
|
||||
Signature.frequency == metadata.frequency
|
||||
).all()
|
||||
|
||||
for sig in signatures:
|
||||
device = sig.device
|
||||
|
||||
matches.append(MatchResult(
|
||||
device_id=device.id,
|
||||
device_name=device.device_name or device.model,
|
||||
manufacturer=device.manufacturer or 'Unknown',
|
||||
confidence=1.0,
|
||||
match_method='exact',
|
||||
match_details={
|
||||
'signature_id': sig.id,
|
||||
'protocol': sig.protocol,
|
||||
'frequency': sig.frequency
|
||||
}
|
||||
))
|
||||
|
||||
logger.debug(f"ExactMatcher: Returning {len(matches)} matches")
|
||||
return matches
|
||||
Reference in New Issue
Block a user