Alfred
/
sdr-wideband-suite
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Wideband autonomous SDR analysis engine forked from sdr-visual-suite
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
346 Commity
3 Gałęzie
111MB
Drzewo: edd4df0e5d
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z 'edd4df0e5d'
${ noResults }
sdr-wideband-suite/internal/config/config.go

739 wiersze
25KB
Czysty Wina Historia 

  1. package config

  2. 

  3. import (

  4. 	"math"

  5. 	"os"

  6. 	"strings"

  7. 	"time"

  8. 

  9. 	"gopkg.in/yaml.v3"

  10. )

  11. 

  12. type Band struct {

  13. 	Name    string  `yaml:"name" json:"name"`

  14. 	StartHz float64 `yaml:"start_hz" json:"start_hz"`

  15. 	EndHz   float64 `yaml:"end_hz" json:"end_hz"`

  16. }

  17. 

  18. type MonitorWindow struct {

  19. 	Label      string  `yaml:"label" json:"label"`

  20. 	Zone       string  `yaml:"zone" json:"zone"`

  21. 	StartHz    float64 `yaml:"start_hz" json:"start_hz"`

  22. 	EndHz      float64 `yaml:"end_hz" json:"end_hz"`

  23. 	CenterHz   float64 `yaml:"center_hz" json:"center_hz"`

  24. 	SpanHz     float64 `yaml:"span_hz" json:"span_hz"`

  25. 	Priority   float64 `yaml:"priority" json:"priority"`

  26. 	AutoRecord bool    `yaml:"auto_record" json:"auto_record"`

  27. 	AutoDecode bool    `yaml:"auto_decode" json:"auto_decode"`

  28. }

  29. 

  30. type DetectorConfig struct {

  31. 	ThresholdDb      float64 `yaml:"threshold_db" json:"threshold_db"`

  32. 	MinDurationMs    int     `yaml:"min_duration_ms" json:"min_duration_ms"`

  33. 	HoldMs           int     `yaml:"hold_ms" json:"hold_ms"`

  34. 	EmaAlpha         float64 `yaml:"ema_alpha" json:"ema_alpha"`

  35. 	HysteresisDb     float64 `yaml:"hysteresis_db" json:"hysteresis_db"`

  36. 	MinStableFrames  int     `yaml:"min_stable_frames" json:"min_stable_frames"`

  37. 	GapToleranceMs   int     `yaml:"gap_tolerance_ms" json:"gap_tolerance_ms"`

  38. 	CFARMode         string  `yaml:"cfar_mode" json:"cfar_mode"`

  39. 	CFARGuardHz      float64 `yaml:"cfar_guard_hz" json:"cfar_guard_hz"`

  40. 	CFARTrainHz      float64 `yaml:"cfar_train_hz" json:"cfar_train_hz"`

  41. 	CFARGuardCells   int     `yaml:"cfar_guard_cells,omitempty" json:"cfar_guard_cells,omitempty"`

  42. 	CFARTrainCells   int     `yaml:"cfar_train_cells,omitempty" json:"cfar_train_cells,omitempty"`

  43. 	CFARRank         int     `yaml:"cfar_rank" json:"cfar_rank"`

  44. 	CFARScaleDb      float64 `yaml:"cfar_scale_db" json:"cfar_scale_db"`

  45. 	CFARWrapAround   bool    `yaml:"cfar_wrap_around" json:"cfar_wrap_around"`

  46. 	EdgeMarginDb     float64 `yaml:"edge_margin_db" json:"edge_margin_db"`

  47. 	MaxSignalBwHz    float64 `yaml:"max_signal_bw_hz" json:"max_signal_bw_hz"`

  48. 	MergeGapHz       float64 `yaml:"merge_gap_hz" json:"merge_gap_hz"`

  49. 	ClassHistorySize int     `yaml:"class_history_size" json:"class_history_size"`

  50. 	ClassSwitchRatio float64 `yaml:"class_switch_ratio" json:"class_switch_ratio"`

  51. 

  52. 	// Deprecated (backward compatibility)

  53. 	CFAREnabled *bool `yaml:"cfar_enabled,omitempty" json:"cfar_enabled,omitempty"`

  54. }

  55. 

  56. type LogConfig struct {

  57. 	Level       string   `yaml:"level" json:"level"`

  58. 	Categories  []string `yaml:"categories" json:"categories"`

  59. 	RateLimitMs int      `yaml:"rate_limit_ms" json:"rate_limit_ms"`

  60. 	Stdout      bool     `yaml:"stdout" json:"stdout"`

  61. 	StdoutColor bool     `yaml:"stdout_color" json:"stdout_color"`

  62. 	File        string   `yaml:"file" json:"file"`

  63. 	FileLevel   string   `yaml:"file_level" json:"file_level"`

  64. 	TimeFormat  string   `yaml:"time_format" json:"time_format"`

  65. 	DisableTime bool     `yaml:"disable_time" json:"disable_time"`

  66. }

  67. 

  68. type RecorderConfig struct {

  69. 	Enabled     bool     `yaml:"enabled" json:"enabled"`

  70. 	MinSNRDb    float64  `yaml:"min_snr_db" json:"min_snr_db"`

  71. 	MinDuration string   `yaml:"min_duration" json:"min_duration"`

  72. 	MaxDuration string   `yaml:"max_duration" json:"max_duration"`

  73. 	PrerollMs   int      `yaml:"preroll_ms" json:"preroll_ms"`

  74. 	RecordIQ    bool     `yaml:"record_iq" json:"record_iq"`

  75. 	RecordAudio bool     `yaml:"record_audio" json:"record_audio"`

  76. 	AutoDemod   bool     `yaml:"auto_demod" json:"auto_demod"`

  77. 	AutoDecode  bool     `yaml:"auto_decode" json:"auto_decode"`

  78. 	MaxDiskMB   int      `yaml:"max_disk_mb" json:"max_disk_mb"`

  79. 	OutputDir   string   `yaml:"output_dir" json:"output_dir"`

  80. 	ClassFilter []string `yaml:"class_filter" json:"class_filter"`

  81. 	RingSeconds int      `yaml:"ring_seconds" json:"ring_seconds"`

  82. 

  83. 	// Audio quality settings (AQ-2, AQ-3, AQ-5)

  84. 	DeemphasisUs     float64 `yaml:"deemphasis_us" json:"deemphasis_us"`             // De-emphasis time constant in µs. 50=Europe, 75=US/Japan, 0=disabled. Default: 50

  85. 	ExtractionTaps   int     `yaml:"extraction_fir_taps" json:"extraction_fir_taps"` // FIR tap count for extraction filter. Default: 101, max 301

  86. 	ExtractionBwMult float64 `yaml:"extraction_bw_mult" json:"extraction_bw_mult"`   // BW multiplier for extraction. Default: 1.2 (20% wider than detected)

  87. 	DebugLiveAudio   bool    `yaml:"debug_live_audio" json:"debug_live_audio"`

  88. }

  89. 

  90. type DecoderConfig struct {

  91. 	FT8Cmd   string `yaml:"ft8_cmd" json:"ft8_cmd"`

  92. 	WSPRCmd  string `yaml:"wspr_cmd" json:"wspr_cmd"`

  93. 	DMRCmd   string `yaml:"dmr_cmd" json:"dmr_cmd"`

  94. 	DStarCmd string `yaml:"dstar_cmd" json:"dstar_cmd"`

  95. 	FSKCmd   string `yaml:"fsk_cmd" json:"fsk_cmd"`

  96. 	PSKCmd   string `yaml:"psk_cmd" json:"psk_cmd"`

  97. }

  98. 

  99. type DebugConfig struct {

  100. 	AudioDumpEnabled bool `yaml:"audio_dump_enabled" json:"audio_dump_enabled"`

  101. 	CPUMonitoring    bool `yaml:"cpu_monitoring" json:"cpu_monitoring"`

  102. 	Telemetry        TelemetryConfig `yaml:"telemetry" json:"telemetry"`

  103. }

  104. 

  105. type TelemetryConfig struct {

  106. 	Enabled           bool   `yaml:"enabled" json:"enabled"`

  107. 	HeavyEnabled      bool   `yaml:"heavy_enabled" json:"heavy_enabled"`

  108. 	HeavySampleEvery  int    `yaml:"heavy_sample_every" json:"heavy_sample_every"`

  109. 	MetricSampleEvery int    `yaml:"metric_sample_every" json:"metric_sample_every"`

  110. 	MetricHistoryMax  int    `yaml:"metric_history_max" json:"metric_history_max"`

  111. 	EventHistoryMax   int    `yaml:"event_history_max" json:"event_history_max"`

  112. 	RetentionSeconds  int    `yaml:"retention_seconds" json:"retention_seconds"`

  113. 	PersistEnabled    bool   `yaml:"persist_enabled" json:"persist_enabled"`

  114. 	PersistDir        string `yaml:"persist_dir" json:"persist_dir"`

  115. 	RotateMB          int    `yaml:"rotate_mb" json:"rotate_mb"`

  116. 	KeepFiles         int    `yaml:"keep_files" json:"keep_files"`

  117. }

  118. 

  119. type PipelineGoalConfig struct {

  120. 	Intent            string          `yaml:"intent" json:"intent"`

  121. 	MonitorStartHz    float64         `yaml:"monitor_start_hz" json:"monitor_start_hz"`

  122. 	MonitorEndHz      float64         `yaml:"monitor_end_hz" json:"monitor_end_hz"`

  123. 	MonitorSpanHz     float64         `yaml:"monitor_span_hz" json:"monitor_span_hz"`

  124. 	MonitorWindows    []MonitorWindow `yaml:"monitor_windows" json:"monitor_windows"`

  125. 	SignalPriorities  []string        `yaml:"signal_priorities" json:"signal_priorities"`

  126. 	AutoRecordClasses []string        `yaml:"auto_record_classes" json:"auto_record_classes"`

  127. 	AutoDecodeClasses []string        `yaml:"auto_decode_classes" json:"auto_decode_classes"`

  128. }

  129. 

  130. type PipelineConfig struct {

  131. 	Mode    string             `yaml:"mode" json:"mode"`

  132. 	Profile string             `yaml:"profile,omitempty" json:"profile,omitempty"`

  133. 	Goals   PipelineGoalConfig `yaml:"goals" json:"goals"`

  134. }

  135. 

  136. type SurveillanceConfig struct {

  137. 	AnalysisFFTSize  int    `yaml:"analysis_fft_size" json:"analysis_fft_size"`

  138. 	FrameRate        int    `yaml:"frame_rate" json:"frame_rate"`

  139. 	Strategy         string `yaml:"strategy" json:"strategy"`

  140. 	DisplayBins      int    `yaml:"display_bins" json:"display_bins"`

  141. 	DisplayFPS       int    `yaml:"display_fps" json:"display_fps"`

  142. 	DerivedDetection string `yaml:"derived_detection" json:"derived_detection"`

  143. }

  144. 

  145. type RefinementConfig struct {

  146. 	Enabled           bool    `yaml:"enabled" json:"enabled"`

  147. 	MaxConcurrent     int     `yaml:"max_concurrent" json:"max_concurrent"`

  148. 	DetailFFTSize     int     `yaml:"detail_fft_size" json:"detail_fft_size"`

  149. 	MinCandidateSNRDb float64 `yaml:"min_candidate_snr_db" json:"min_candidate_snr_db"`

  150. 	MinSpanHz         float64 `yaml:"min_span_hz" json:"min_span_hz"`

  151. 	MaxSpanHz         float64 `yaml:"max_span_hz" json:"max_span_hz"`

  152. 	AutoSpan          *bool   `yaml:"auto_span" json:"auto_span"`

  153. }

  154. 

  155. type ResourceConfig struct {

  156. 	PreferGPU           bool `yaml:"prefer_gpu" json:"prefer_gpu"`

  157. 	MaxRefinementJobs   int  `yaml:"max_refinement_jobs" json:"max_refinement_jobs"`

  158. 	MaxRecordingStreams int  `yaml:"max_recording_streams" json:"max_recording_streams"`

  159. 	MaxDecodeJobs       int  `yaml:"max_decode_jobs" json:"max_decode_jobs"`

  160. 	DecisionHoldMs      int  `yaml:"decision_hold_ms" json:"decision_hold_ms"`

  161. }

  162. 

  163. type ProfileConfig struct {

  164. 	Name         string              `yaml:"name" json:"name"`

  165. 	Description  string              `yaml:"description" json:"description"`

  166. 	Pipeline     *PipelineConfig     `yaml:"pipeline,omitempty" json:"pipeline,omitempty"`

  167. 	Surveillance *SurveillanceConfig `yaml:"surveillance,omitempty" json:"surveillance,omitempty"`

  168. 	Refinement   *RefinementConfig   `yaml:"refinement,omitempty" json:"refinement,omitempty"`

  169. 	Resources    *ResourceConfig     `yaml:"resources,omitempty" json:"resources,omitempty"`

  170. }

  171. 

  172. type Config struct {

  173. 	Bands          []Band             `yaml:"bands" json:"bands"`

  174. 	CenterHz       float64            `yaml:"center_hz" json:"center_hz"`

  175. 	SampleRate     int                `yaml:"sample_rate" json:"sample_rate"`

  176. 	FFTSize        int                `yaml:"fft_size" json:"fft_size"`

  177. 	GainDb         float64            `yaml:"gain_db" json:"gain_db"`

  178. 	TunerBwKHz     int                `yaml:"tuner_bw_khz" json:"tuner_bw_khz"`

  179. 	UseGPUFFT      bool               `yaml:"use_gpu_fft" json:"use_gpu_fft"`

  180. 	ClassifierMode string             `yaml:"classifier_mode" json:"classifier_mode"`

  181. 	AGC            bool               `yaml:"agc" json:"agc"`

  182. 	DCBlock        bool               `yaml:"dc_block" json:"dc_block"`

  183. 	IQBalance      bool               `yaml:"iq_balance" json:"iq_balance"`

  184. 	Pipeline       PipelineConfig     `yaml:"pipeline" json:"pipeline"`

  185. 	Surveillance   SurveillanceConfig `yaml:"surveillance" json:"surveillance"`

  186. 	Refinement     RefinementConfig   `yaml:"refinement" json:"refinement"`

  187. 	Resources      ResourceConfig     `yaml:"resources" json:"resources"`

  188. 	Profiles       []ProfileConfig    `yaml:"profiles" json:"profiles"`

  189. 	Detector       DetectorConfig     `yaml:"detector" json:"detector"`

  190. 	Recorder       RecorderConfig     `yaml:"recorder" json:"recorder"`

  191. 	Decoder        DecoderConfig      `yaml:"decoder" json:"decoder"`

  192. 	Debug          DebugConfig        `yaml:"debug" json:"debug"`

  193. 	Logging        LogConfig          `yaml:"logging" json:"logging"`

  194. 	WebAddr        string             `yaml:"web_addr" json:"web_addr"`

  195. 	EventPath      string             `yaml:"event_path" json:"event_path"`

  196. 	FrameRate      int                `yaml:"frame_rate" json:"frame_rate"`

  197. 	WaterfallLines int                `yaml:"waterfall_lines" json:"waterfall_lines"`

  198. 	WebRoot        string             `yaml:"web_root" json:"web_root"`

  199. }

  200. 

  201. func Default() Config {

  202. 	return Config{

  203. 		Bands: []Band{

  204. 			{Name: "example", StartHz: 99.5e6, EndHz: 100.5e6},

  205. 		},

  206. 		CenterHz:       100.0e6,

  207. 		SampleRate:     2_048_000,

  208. 		FFTSize:        2048,

  209. 		GainDb:         30,

  210. 		TunerBwKHz:     1536,

  211. 		UseGPUFFT:      false,

  212. 		ClassifierMode: "combined",

  213. 		AGC:            false,

  214. 		DCBlock:        false,

  215. 		IQBalance:      false,

  216. 		Pipeline: PipelineConfig{

  217. 			Mode: "legacy",

  218. 			Goals: PipelineGoalConfig{

  219. 				Intent: "general-monitoring",

  220. 			},

  221. 		},

  222. 		Surveillance: SurveillanceConfig{

  223. 			AnalysisFFTSize:  2048,

  224. 			FrameRate:        15,

  225. 			Strategy:         "single-resolution",

  226. 			DisplayBins:      2048,

  227. 			DisplayFPS:       15,

  228. 			DerivedDetection: "auto",

  229. 		},

  230. 		Refinement: RefinementConfig{

  231. 			Enabled:           true,

  232. 			MaxConcurrent:     8,

  233. 			DetailFFTSize:     0,

  234. 			MinCandidateSNRDb: 0,

  235. 			MinSpanHz:         0,

  236. 			MaxSpanHz:         0,

  237. 			AutoSpan:          boolPtr(true),

  238. 		},

  239. 		Resources: ResourceConfig{

  240. 			PreferGPU:           true,

  241. 			MaxRefinementJobs:   8,

  242. 			MaxRecordingStreams: 16,

  243. 			MaxDecodeJobs:       16,

  244. 			DecisionHoldMs:      2000,

  245. 		},

  246. 		Profiles: []ProfileConfig{

  247. 			{

  248. 				Name:        "legacy",

  249. 				Description: "Current single-band pipeline behavior",

  250. 				Pipeline:    &PipelineConfig{Mode: "legacy", Profile: "legacy", Goals: PipelineGoalConfig{Intent: "general-monitoring"}},

  251. 				Surveillance: &SurveillanceConfig{

  252. 					AnalysisFFTSize:  2048,

  253. 					FrameRate:        15,

  254. 					Strategy:         "single-resolution",

  255. 					DisplayBins:      2048,

  256. 					DisplayFPS:       15,

  257. 					DerivedDetection: "auto",

  258. 				},

  259. 				Refinement: &RefinementConfig{

  260. 					Enabled:           true,

  261. 					MaxConcurrent:     8,

  262. 					DetailFFTSize:     0,

  263. 					MinCandidateSNRDb: 0,

  264. 					MinSpanHz:         0,

  265. 					MaxSpanHz:         0,

  266. 					AutoSpan:          boolPtr(true),

  267. 				},

  268. 				Resources: &ResourceConfig{

  269. 					PreferGPU:           false,

  270. 					MaxRefinementJobs:   8,

  271. 					MaxRecordingStreams: 16,

  272. 					MaxDecodeJobs:       16,

  273. 					DecisionHoldMs:      2000,

  274. 				},

  275. 			},

  276. 			{

  277. 				Name:        "wideband-balanced",

  278. 				Description: "Baseline multi-resolution wideband surveillance",

  279. 				Pipeline: &PipelineConfig{Mode: "wideband-balanced", Profile: "wideband-balanced", Goals: PipelineGoalConfig{

  280. 					Intent:           "wideband-surveillance",

  281. 					SignalPriorities: []string{"digital", "wfm"},

  282. 				}},

  283. 				Surveillance: &SurveillanceConfig{

  284. 					AnalysisFFTSize:  4096,

  285. 					FrameRate:        12,

  286. 					Strategy:         "multi-resolution",

  287. 					DisplayBins:      2048,

  288. 					DisplayFPS:       12,

  289. 					DerivedDetection: "auto",

  290. 				},

  291. 				Refinement: &RefinementConfig{

  292. 					Enabled:           true,

  293. 					MaxConcurrent:     16,

  294. 					DetailFFTSize:     0,

  295. 					MinCandidateSNRDb: 0,

  296. 					MinSpanHz:         4000,

  297. 					MaxSpanHz:         200000,

  298. 					AutoSpan:          boolPtr(true),

  299. 				},

  300. 				Resources: &ResourceConfig{

  301. 					PreferGPU:           true,

  302. 					MaxRefinementJobs:   16,

  303. 					MaxRecordingStreams: 16,

  304. 					MaxDecodeJobs:       12,

  305. 					DecisionHoldMs:      2000,

  306. 				},

  307. 			},

  308. 			{

  309. 				Name:        "wideband-aggressive",

  310. 				Description: "Higher surveillance/refinement budgets for dense wideband monitoring",

  311. 				Pipeline: &PipelineConfig{Mode: "wideband-aggressive", Profile: "wideband-aggressive", Goals: PipelineGoalConfig{

  312. 					Intent:           "high-density-wideband-surveillance",

  313. 					SignalPriorities: []string{"digital", "wfm", "trunk"},

  314. 				}},

  315. 				Surveillance: &SurveillanceConfig{

  316. 					AnalysisFFTSize:  8192,

  317. 					FrameRate:        10,

  318. 					Strategy:         "multi-resolution",

  319. 					DisplayBins:      4096,

  320. 					DisplayFPS:       10,

  321. 					DerivedDetection: "auto",

  322. 				},

  323. 				Refinement: &RefinementConfig{

  324. 					Enabled:           true,

  325. 					MaxConcurrent:     32,

  326. 					DetailFFTSize:     0,

  327. 					MinCandidateSNRDb: 0,

  328. 					MinSpanHz:         6000,

  329. 					MaxSpanHz:         250000,

  330. 					AutoSpan:          boolPtr(true),

  331. 				},

  332. 				Resources: &ResourceConfig{

  333. 					PreferGPU:           true,

  334. 					MaxRefinementJobs:   32,

  335. 					MaxRecordingStreams: 24,

  336. 					MaxDecodeJobs:       16,

  337. 					DecisionHoldMs:      2000,

  338. 				},

  339. 			},

  340. 			{

  341. 				Name:        "archive",

  342. 				Description: "Record-first monitoring profile",

  343. 				Pipeline: &PipelineConfig{Mode: "archive", Profile: "archive", Goals: PipelineGoalConfig{

  344. 					Intent:           "archive-and-triage",

  345. 					SignalPriorities: []string{"wfm", "nfm", "digital"},

  346. 				}},

  347. 				Surveillance: &SurveillanceConfig{

  348. 					AnalysisFFTSize:  4096,

  349. 					FrameRate:        12,

  350. 					Strategy:         "single-resolution",

  351. 					DisplayBins:      2048,

  352. 					DisplayFPS:       12,

  353. 					DerivedDetection: "auto",

  354. 				},

  355. 				Refinement: &RefinementConfig{

  356. 					Enabled:           true,

  357. 					MaxConcurrent:     12,

  358. 					DetailFFTSize:     0,

  359. 					MinCandidateSNRDb: 0,

  360. 					MinSpanHz:         4000,

  361. 					MaxSpanHz:         200000,

  362. 					AutoSpan:          boolPtr(true),

  363. 				},

  364. 				Resources: &ResourceConfig{

  365. 					PreferGPU:           true,

  366. 					MaxRefinementJobs:   12,

  367. 					MaxRecordingStreams: 24,

  368. 					MaxDecodeJobs:       12,

  369. 					DecisionHoldMs:      2500,

  370. 				},

  371. 			},

  372. 			{

  373. 				Name:        "digital-hunting",

  374. 				Description: "Digital-first refinement and decode focus",

  375. 				Pipeline: &PipelineConfig{Mode: "digital-hunting", Profile: "digital-hunting", Goals: PipelineGoalConfig{

  376. 					Intent:           "digital-surveillance",

  377. 					SignalPriorities: []string{"ft8", "wspr", "fsk", "psk", "dmr"},

  378. 				}},

  379. 				Surveillance: &SurveillanceConfig{

  380. 					AnalysisFFTSize:  4096,

  381. 					FrameRate:        12,

  382. 					Strategy:         "multi-resolution",

  383. 					DisplayBins:      2048,

  384. 					DisplayFPS:       12,

  385. 					DerivedDetection: "auto",

  386. 				},

  387. 				Refinement: &RefinementConfig{

  388. 					Enabled:           true,

  389. 					MaxConcurrent:     16,

  390. 					DetailFFTSize:     0,

  391. 					MinCandidateSNRDb: 0,

  392. 					MinSpanHz:         3000,

  393. 					MaxSpanHz:         120000,

  394. 					AutoSpan:          boolPtr(true),

  395. 				},

  396. 				Resources: &ResourceConfig{

  397. 					PreferGPU:           true,

  398. 					MaxRefinementJobs:   16,

  399. 					MaxRecordingStreams: 12,

  400. 					MaxDecodeJobs:       16,

  401. 					DecisionHoldMs:      2000,

  402. 				},

  403. 			},

  404. 		},

  405. 		Detector: DetectorConfig{

  406. 			ThresholdDb:      -20,

  407. 			MinDurationMs:    250,

  408. 			HoldMs:           500,

  409. 			EmaAlpha:         0.2,

  410. 			HysteresisDb:     3,

  411. 			MinStableFrames:  3,

  412. 			GapToleranceMs:   500,

  413. 			CFARMode:         "GOSCA",

  414. 			CFARGuardHz:      500,

  415. 			CFARTrainHz:      5000,

  416. 			CFARGuardCells:   3,

  417. 			CFARTrainCells:   24,

  418. 			CFARRank:         36,

  419. 			CFARScaleDb:      6,

  420. 			CFARWrapAround:   true,

  421. 			EdgeMarginDb:     3.0,

  422. 			MaxSignalBwHz:    150000,

  423. 			MergeGapHz:       5000,

  424. 			ClassHistorySize: 10,

  425. 			ClassSwitchRatio: 0.6,

  426. 		},

  427. 		Recorder: RecorderConfig{

  428. 			Enabled:          false,

  429. 			MinSNRDb:         10,

  430. 			MinDuration:      "1s",

  431. 			MaxDuration:      "300s",

  432. 			PrerollMs:        500,

  433. 			RecordIQ:         true,

  434. 			RecordAudio:      false,

  435. 			AutoDemod:        true,

  436. 			AutoDecode:       false,

  437. 			MaxDiskMB:        0,

  438. 			OutputDir:        "data/recordings",

  439. 			RingSeconds:      8,

  440. 			DeemphasisUs:     50,

  441. 			ExtractionTaps:   101,

  442. 			ExtractionBwMult: 1.2,

  443. 		},

  444. 		Decoder:        DecoderConfig{},

  445. 		Debug: DebugConfig{

  446. 			AudioDumpEnabled: false,

  447. 			CPUMonitoring:    false,

  448. 			Telemetry: TelemetryConfig{

  449. 				Enabled:           true,

  450. 				HeavyEnabled:      false,

  451. 				HeavySampleEvery:  12,

  452. 				MetricSampleEvery: 2,

  453. 				MetricHistoryMax:  12000,

  454. 				EventHistoryMax:   4000,

  455. 				RetentionSeconds:  900,

  456. 				PersistEnabled:    false,

  457. 				PersistDir:        "debug/telemetry",

  458. 				RotateMB:          16,

  459. 				KeepFiles:         8,

  460. 			},

  461. 		},

  462. 		Logging: LogConfig{

  463. 			Level:       "informal",

  464. 			Categories:  []string{},

  465. 			RateLimitMs: 500,

  466. 			Stdout:      true,

  467. 			StdoutColor: true,

  468. 			File:        "logs/trace.log",

  469. 			FileLevel:   "",

  470. 			TimeFormat:  "15:04:05",

  471. 			DisableTime: false,

  472. 		},

  473. 		WebAddr: ":8080",

  474. 		EventPath:      "data/events.jsonl",

  475. 		FrameRate:      15,

  476. 		WaterfallLines: 200,

  477. 		WebRoot:        "web",

  478. 	}

  479. }

  480. 

  481. func Load(path string) (Config, error) {

  482. 	cfg := Default()

  483. 	if b, err := os.ReadFile(autosavePath(path)); err == nil {

  484. 		if err := yaml.Unmarshal(b, &cfg); err == nil {

  485. 			return applyDefaults(cfg), nil

  486. 		}

  487. 	}

  488. 	b, err := os.ReadFile(path)

  489. 	if err != nil {

  490. 		return cfg, err

  491. 	}

  492. 	if err := yaml.Unmarshal(b, &cfg); err != nil {

  493. 		return cfg, err

  494. 	}

  495. 	return applyDefaults(cfg), nil

  496. }

  497. 

  498. func applyDefaults(cfg Config) Config {

  499. 	if cfg.Detector.MinDurationMs <= 0 {

  500. 		cfg.Detector.MinDurationMs = 250

  501. 	}

  502. 	if cfg.Detector.HoldMs <= 0 {

  503. 		cfg.Detector.HoldMs = 500

  504. 	}

  505. 	if cfg.Detector.MinStableFrames <= 0 {

  506. 		cfg.Detector.MinStableFrames = 3

  507. 	}

  508. 	if cfg.Detector.GapToleranceMs <= 0 {

  509. 		cfg.Detector.GapToleranceMs = cfg.Detector.HoldMs

  510. 	}

  511. 	if cfg.Detector.CFARMode == "" {

  512. 		if cfg.Detector.CFAREnabled != nil {

  513. 			if *cfg.Detector.CFAREnabled {

  514. 				cfg.Detector.CFARMode = "OS"

  515. 			} else {

  516. 				cfg.Detector.CFARMode = "OFF"

  517. 			}

  518. 		} else {

  519. 			cfg.Detector.CFARMode = "GOSCA"

  520. 		}

  521. 	}

  522. 	if cfg.Detector.CFARGuardHz <= 0 && cfg.Detector.CFARGuardCells > 0 {

  523. 		cfg.Detector.CFARGuardHz = float64(cfg.Detector.CFARGuardCells) * 62.5

  524. 	}

  525. 	if cfg.Detector.CFARTrainHz <= 0 && cfg.Detector.CFARTrainCells > 0 {

  526. 		cfg.Detector.CFARTrainHz = float64(cfg.Detector.CFARTrainCells) * 62.5

  527. 	}

  528. 	if cfg.Detector.CFARGuardHz <= 0 {

  529. 		cfg.Detector.CFARGuardHz = 500

  530. 	}

  531. 	if cfg.Detector.CFARTrainHz <= 0 {

  532. 		cfg.Detector.CFARTrainHz = 5000

  533. 	}

  534. 	if cfg.Detector.CFARGuardCells <= 0 {

  535. 		cfg.Detector.CFARGuardCells = 3

  536. 	}

  537. 	if cfg.Detector.CFARTrainCells <= 0 {

  538. 		cfg.Detector.CFARTrainCells = 24

  539. 	}

  540. 	if cfg.Detector.CFARRank <= 0 || cfg.Detector.CFARRank > 2*cfg.Detector.CFARTrainCells {

  541. 		cfg.Detector.CFARRank = int(math.Round(0.75 * float64(2*cfg.Detector.CFARTrainCells)))

  542. 		if cfg.Detector.CFARRank <= 0 {

  543. 			cfg.Detector.CFARRank = 1

  544. 		}

  545. 	}

  546. 	if cfg.Detector.CFARScaleDb <= 0 {

  547. 		cfg.Detector.CFARScaleDb = 6

  548. 	}

  549. 	if cfg.Detector.EdgeMarginDb <= 0 {

  550. 		cfg.Detector.EdgeMarginDb = 3.0

  551. 	}

  552. 	if cfg.Detector.MaxSignalBwHz <= 0 {

  553. 		cfg.Detector.MaxSignalBwHz = 150000

  554. 	}

  555. 	if cfg.Detector.MergeGapHz <= 0 {

  556. 		cfg.Detector.MergeGapHz = 5000

  557. 	}

  558. 	if cfg.Detector.ClassHistorySize <= 0 {

  559. 		cfg.Detector.ClassHistorySize = 10

  560. 	}

  561. 	if cfg.Detector.ClassSwitchRatio <= 0 || cfg.Detector.ClassSwitchRatio > 1 {

  562. 		cfg.Detector.ClassSwitchRatio = 0.6

  563. 	}

  564. 	if cfg.Pipeline.Mode == "" {

  565. 		cfg.Pipeline.Mode = "legacy"

  566. 	}

  567. 	if cfg.Pipeline.Goals.Intent == "" {

  568. 		cfg.Pipeline.Goals.Intent = "general-monitoring"

  569. 	}

  570. 	if cfg.Pipeline.Goals.MonitorSpanHz <= 0 && cfg.Pipeline.Goals.MonitorStartHz != 0 && cfg.Pipeline.Goals.MonitorEndHz != 0 && cfg.Pipeline.Goals.MonitorEndHz > cfg.Pipeline.Goals.MonitorStartHz {

  571. 		cfg.Pipeline.Goals.MonitorSpanHz = cfg.Pipeline.Goals.MonitorEndHz - cfg.Pipeline.Goals.MonitorStartHz

  572. 	}

  573. 	if cfg.Surveillance.AnalysisFFTSize <= 0 {

  574. 		cfg.Surveillance.AnalysisFFTSize = cfg.FFTSize

  575. 	}

  576. 	if cfg.Surveillance.FrameRate <= 0 {

  577. 		cfg.Surveillance.FrameRate = cfg.FrameRate

  578. 	}

  579. 	if cfg.Surveillance.Strategy == "" {

  580. 		cfg.Surveillance.Strategy = "single-resolution"

  581. 	}

  582. 	if cfg.Logging.Level == "" {

  583. 		cfg.Logging.Level = "informal"

  584. 	}

  585. 	if cfg.Logging.RateLimitMs <= 0 {

  586. 		cfg.Logging.RateLimitMs = 500

  587. 	}

  588. 	if cfg.Logging.File == "" {

  589. 		cfg.Logging.File = "logs/trace.log"

  590. 	}

  591. 	if cfg.Surveillance.DerivedDetection == "" {

  592. 		cfg.Surveillance.DerivedDetection = "auto"

  593. 	}

  594. 	switch strings.ToLower(strings.TrimSpace(cfg.Surveillance.DerivedDetection)) {

  595. 	case "auto", "on", "off", "true", "false", "enabled", "disabled", "enable", "disable":

  596. 	default:

  597. 		cfg.Surveillance.DerivedDetection = "auto"

  598. 	}

  599. 	if cfg.Surveillance.DisplayBins <= 0 {

  600. 		cfg.Surveillance.DisplayBins = cfg.FFTSize

  601. 	}

  602. 	if cfg.Surveillance.DisplayFPS <= 0 {

  603. 		cfg.Surveillance.DisplayFPS = cfg.FrameRate

  604. 	}

  605. 	if !cfg.Refinement.Enabled {

  606. 		// keep explicit false if user disabled it; enable by default only when unset-like zero config

  607. 		if cfg.Refinement.MaxConcurrent == 0 && cfg.Refinement.MinCandidateSNRDb == 0 {

  608. 			cfg.Refinement.Enabled = true

  609. 		}

  610. 	}

  611. 	if cfg.Refinement.MaxConcurrent <= 0 {

  612. 		cfg.Refinement.MaxConcurrent = 8

  613. 	}

  614. 	if cfg.Refinement.DetailFFTSize <= 0 {

  615. 		cfg.Refinement.DetailFFTSize = cfg.Surveillance.AnalysisFFTSize

  616. 	}

  617. 	if cfg.Refinement.DetailFFTSize&(cfg.Refinement.DetailFFTSize-1) != 0 {

  618. 		cfg.Refinement.DetailFFTSize = cfg.Surveillance.AnalysisFFTSize

  619. 	}

  620. 	if cfg.Refinement.MinSpanHz < 0 {

  621. 		cfg.Refinement.MinSpanHz = 0

  622. 	}

  623. 	if cfg.Refinement.MaxSpanHz < 0 {

  624. 		cfg.Refinement.MaxSpanHz = 0

  625. 	}

  626. 	if cfg.Refinement.MaxSpanHz > 0 && cfg.Refinement.MinSpanHz > cfg.Refinement.MaxSpanHz {

  627. 		cfg.Refinement.MaxSpanHz = cfg.Refinement.MinSpanHz

  628. 	}

  629. 	if cfg.Refinement.AutoSpan == nil {

  630. 		cfg.Refinement.AutoSpan = boolPtr(true)

  631. 	}

  632. 	if cfg.Resources.MaxRefinementJobs <= 0 {

  633. 		cfg.Resources.MaxRefinementJobs = cfg.Refinement.MaxConcurrent

  634. 	}

  635. 	if cfg.Resources.MaxRecordingStreams <= 0 {

  636. 		cfg.Resources.MaxRecordingStreams = 16

  637. 	}

  638. 	if cfg.Resources.DecisionHoldMs < 0 {

  639. 		cfg.Resources.DecisionHoldMs = 0

  640. 	}

  641. 	if cfg.Resources.DecisionHoldMs == 0 {

  642. 		cfg.Resources.DecisionHoldMs = 2000

  643. 	}

  644. 	if cfg.FrameRate <= 0 {

  645. 		cfg.FrameRate = 15

  646. 	}

  647. 	if cfg.WaterfallLines <= 0 {

  648. 		cfg.WaterfallLines = 200

  649. 	}

  650. 	if cfg.WebRoot == "" {

  651. 		cfg.WebRoot = "web"

  652. 	}

  653. 	if cfg.WebAddr == "" {

  654. 		cfg.WebAddr = ":8080"

  655. 	}

  656. 	if cfg.EventPath == "" {

  657. 		cfg.EventPath = "data/events.jsonl"

  658. 	}

  659. 	if cfg.SampleRate <= 0 {

  660. 		cfg.SampleRate = 2_048_000

  661. 	}

  662. 	if cfg.ClassifierMode == "" {

  663. 		cfg.ClassifierMode = "combined"

  664. 	}

  665. 	switch cfg.ClassifierMode {

  666. 	case "rule", "math", "combined":

  667. 	default:

  668. 		cfg.ClassifierMode = "combined"

  669. 	}

  670. 	if cfg.FFTSize <= 0 {

  671. 		cfg.FFTSize = 2048

  672. 	}

  673. 	if cfg.Surveillance.AnalysisFFTSize > 0 {

  674. 		cfg.FFTSize = cfg.Surveillance.AnalysisFFTSize

  675. 	} else {

  676. 		cfg.Surveillance.AnalysisFFTSize = cfg.FFTSize

  677. 	}

  678. 	if cfg.TunerBwKHz <= 0 {

  679. 		cfg.TunerBwKHz = 1536

  680. 	}

  681. 	if cfg.CenterHz == 0 {

  682. 		cfg.CenterHz = 100.0e6

  683. 	}

  684. 	if cfg.Recorder.OutputDir == "" {

  685. 		cfg.Recorder.OutputDir = "data/recordings"

  686. 	}

  687. 	if cfg.Recorder.RingSeconds <= 0 {

  688. 		cfg.Recorder.RingSeconds = 8

  689. 	}

  690. 	if cfg.Recorder.DeemphasisUs == 0 {

  691. 		cfg.Recorder.DeemphasisUs = 50

  692. 	}

  693. 	if cfg.Recorder.ExtractionTaps <= 0 {

  694. 		cfg.Recorder.ExtractionTaps = 101

  695. 	}

  696. 	if cfg.Recorder.ExtractionTaps > 301 {

  697. 		cfg.Recorder.ExtractionTaps = 301

  698. 	}

  699. 	if cfg.Recorder.ExtractionTaps%2 == 0 {

  700. 		cfg.Recorder.ExtractionTaps++ // must be odd

  701. 	}

  702. 	if cfg.Recorder.ExtractionBwMult <= 0 {

  703. 		cfg.Recorder.ExtractionBwMult = 1.2

  704. 	}

  705. 	if cfg.Debug.Telemetry.HeavySampleEvery <= 0 {

  706. 		cfg.Debug.Telemetry.HeavySampleEvery = 12

  707. 	}

  708. 	if cfg.Debug.Telemetry.MetricSampleEvery <= 0 {

  709. 		cfg.Debug.Telemetry.MetricSampleEvery = 2

  710. 	}

  711. 	if cfg.Debug.Telemetry.MetricHistoryMax <= 0 {

  712. 		cfg.Debug.Telemetry.MetricHistoryMax = 12000

  713. 	}

  714. 	if cfg.Debug.Telemetry.EventHistoryMax <= 0 {

  715. 		cfg.Debug.Telemetry.EventHistoryMax = 4000

  716. 	}

  717. 	if cfg.Debug.Telemetry.RetentionSeconds <= 0 {

  718. 		cfg.Debug.Telemetry.RetentionSeconds = 900

  719. 	}

  720. 	if cfg.Debug.Telemetry.PersistDir == "" {

  721. 		cfg.Debug.Telemetry.PersistDir = "debug/telemetry"

  722. 	}

  723. 	if cfg.Debug.Telemetry.RotateMB <= 0 {

  724. 		cfg.Debug.Telemetry.RotateMB = 16

  725. 	}

  726. 	if cfg.Debug.Telemetry.KeepFiles <= 0 {

  727. 		cfg.Debug.Telemetry.KeepFiles = 8

  728. 	}

  729. 	return cfg

  730. }

  731. 

  732. func (c Config) FrameInterval() time.Duration {

  733. 	fps := c.FrameRate

  734. 	if fps <= 0 {

  735. 		fps = 15

  736. 	}

  737. 	return time.Second / time.Duration(fps)

  738. }