Refactor radar system

python_app/generator_sweep/config.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 import logging
+import math
 
 logger = logging.getLogger(__name__)
 
@@ -121,17 +122,13 @@ def _build_frequency_grid(model: GeneratorSweepConfig) -> tuple[int, ...]:
 
     if has_step:
         _validate_positive_int(step_hz, "generator_sweep.step_hz")
-        frequencies: list[int] = []
-        current_hz = start_hz
-        while current_hz < stop_hz:
-            frequencies.append(current_hz)
-            current_hz += step_hz
-        if not frequencies or frequencies[-1] != stop_hz:
-            frequencies.append(stop_hz)
-        return tuple(frequencies)
+        _require((stop_hz - start_hz + step_hz - 1) // step_hz + 1 <= 1_000_000,
+                 "generator sweep grid must not exceed 1000000 frequencies")
+        return (*range(start_hz, stop_hz, step_hz), stop_hz)
 
     _validate_positive_int(points, "generator_sweep.points")
     _require(points >= 2, "generator_sweep.points must be >= 2 when start_hz != stop_hz")
+    _require(points <= 1_000_000, "generator sweep grid must not exceed 1000000 frequencies")
     span_hz = stop_hz - start_hz
     frequencies = tuple(
         int(round(start_hz + (span_hz * index) / float(points - 1)))
@@ -148,6 +145,16 @@ def _build_frequency_grid(model: GeneratorSweepConfig) -> tuple[int, ...]:
 
 def resolve_generator_sweep_config(model: GeneratorSweepConfig) -> ResolvedGeneratorSweepConfig:
     """Validate and resolve runtime configuration for generator sweep mode."""
+    for name in ("points", "settle_timeout_ms", "post_lock_delay_us", "pwm_frequency_hz",
+                 "sweep_start_pin", "curr_step_pin", "pwm_pin", "curr_step_initial_level",
+                 "strict_protocol_version", "port"):
+        value = getattr(model, name)
+        _require(type(value) is int, f"generator_sweep.{name} must be an integer")
+    for name in ("start_hz", "stop_hz", "step_hz", "hold_time_ms", "status_poll_ms", "power_dbm", "pwm_duty_cycle"):
+        value = getattr(model, name)
+        _require(type(value) in (int, float) and math.isfinite(value),
+                 f"generator_sweep.{name} must be a finite number")
+    _require(model.points >= 0 and model.step_hz >= 0, "generator_sweep points and step_hz must be >= 0")
     log_level = _resolve_log_level(model.log_level)
     frequencies_hz = _build_frequency_grid(model)
     hold_time_ms = float(model.hold_time_ms)

python_app/generator_sweep/runner.py

@@ -142,24 +142,19 @@ class GeneratorSweepRunner:
 
     def _close(self) -> None:
         """Best-effort cleanup of PWM, GPIO, and device state."""
-        self._pwm.disable()
-
-        device = self._device
+        device, self._device = self._device, None
+        cleanup = [self._pwm.disable]
         if device is not None:
+            cleanup.extend([
+                lambda: device.generator.set_idle(timeout_s=1.0) if device.is_connected else None,
+                device.disconnect,
+            ])
+        cleanup.extend([self._markers.reset_to_idle, self._markers.close, self._pwm.close])
+        for action in cleanup:
             try:
-                if device.is_connected:
-                    device.generator.set_idle(timeout_s=1.0)
-            except Exception as exc:  # noqa: BLE001
-                logger.warning("Failed to set LibreVNA idle mode during shutdown: %s", exc)
-            finally:
-                device.disconnect()
-                self._device = None
-
-        try:
-            self._markers.reset_to_idle()
-        finally:
-            self._markers.close()
-            self._pwm.close()
+                action()
+            except Exception as exc:
+                logger.warning("Generator sweep cleanup failed: %s", exc)
 
     def _run_single_sweep(self) -> None:
         """Execute one pass from the first configured frequency to the last."""