From 76cfc71b194654111ba35f335c9c4106e56ee50c Mon Sep 17 00:00:00 2001 From: Jason <83615043+JJassonn69@users.noreply.github.com> Date: Thu, 16 Apr 2026 21:35:01 +0545 Subject: [PATCH] fix(gui): align radar parameters to FPGA truth (radar_scene.py) - Bandwidth 500 MHz -> 20 MHz, sample rate 4 MHz -> 100 MHz (DDC output) - Range formula: deramped FMCW -> matched-filter c/(2*Fs)*decimation - Velocity formula: use PRI (167 us) and chirps_per_subframe (16) - Carrier frequency: 10.525 GHz -> 10.5 GHz per radar_scene.py - Range per bin: 4.8 m -> 24 m, max range: 307 m -> 1536 m - Fix simulator target spawn range to match new coverage (50-1400 m) - Remove dead BANDWIDTH constant, add SAMPLE_RATE to V65 Tk - All 174 tests pass, ruff clean --- 9_Firmware/9_3_GUI/GUI_V65_Tk.py | 20 +++++------ 9_Firmware/9_3_GUI/test_v7.py | 30 +++++++++-------- 9_Firmware/9_3_GUI/v7/map_widget.py | 2 +- 9_Firmware/9_3_GUI/v7/models.py | 51 ++++++++++++++++------------- 9_Firmware/9_3_GUI/v7/workers.py | 4 +-- 5 files changed, 58 insertions(+), 49 deletions(-) diff --git a/9_Firmware/9_3_GUI/GUI_V65_Tk.py b/9_Firmware/9_3_GUI/GUI_V65_Tk.py index 0ecae7b..659e280 100644 --- a/9_Firmware/9_3_GUI/GUI_V65_Tk.py +++ b/9_Firmware/9_3_GUI/GUI_V65_Tk.py @@ -98,9 +98,10 @@ class DemoTarget: __slots__ = ("azimuth", "classification", "id", "range_m", "snr", "velocity") - # Physical range grid: 64 bins x ~4.8 m/bin = ~307 m max - _RANGE_PER_BIN: float = (3e8 / (2 * 500e6)) * 16 # ~4.8 m - _MAX_RANGE: float = _RANGE_PER_BIN * NUM_RANGE_BINS # ~307 m + # Physical range grid: 64 bins x ~24 m/bin = ~1536 m max + # Bin spacing = c / (2 * Fs) * decimation, where Fs = 100 MHz DDC output. + _RANGE_PER_BIN: float = (3e8 / (2 * 100e6)) * 16 # ~24 m + _MAX_RANGE: float = _RANGE_PER_BIN * NUM_RANGE_BINS # ~1536 m def __init__(self, tid: int): self.id = tid @@ -187,10 +188,10 @@ class DemoSimulator: mag = np.zeros((NUM_RANGE_BINS, NUM_DOPPLER_BINS), dtype=np.float64) det = np.zeros((NUM_RANGE_BINS, NUM_DOPPLER_BINS), dtype=np.uint8) - # Range/Doppler scaling (approximate) - range_per_bin = (3e8 / (2 * 500e6)) * 16 # ~4.8 m/bin + # Range/Doppler scaling: bin spacing = c/(2*Fs)*decimation + range_per_bin = (3e8 / (2 * 100e6)) * 16 # ~24 m/bin max_range = range_per_bin * NUM_RANGE_BINS - vel_per_bin = 1.484 # m/s per Doppler bin (from WaveformConfig) + vel_per_bin = 5.34 # m/s per Doppler bin (radar_scene.py: lam/(2*16*PRI)) for t in targets: if t.range_m > max_range or t.range_m < 0: @@ -385,7 +386,7 @@ class RadarDashboard: UPDATE_INTERVAL_MS = 100 # 10 Hz display refresh # Radar parameters used for range-axis scaling. - BANDWIDTH = 500e6 # Hz — chirp bandwidth + SAMPLE_RATE = 100e6 # Hz — DDC output I/Q rate (matched filter input) C = 3e8 # m/s — speed of light def __init__(self, root: tk.Tk, mock: bool, @@ -526,9 +527,8 @@ class RadarDashboard: def _build_display_tab(self, parent): # Compute physical axis limits - range_res = self.C / (2.0 * self.BANDWIDTH) # ~0.3 m per FFT bin - # After decimation 1024→64, each range bin = 16 FFT bins - range_per_bin = range_res * 16 + # Bin spacing = c / (2 * Fs_ddc) for matched-filter processing. + range_per_bin = self.C / (2.0 * self.SAMPLE_RATE) * 16 # ~24 m max_range = range_per_bin * NUM_RANGE_BINS doppler_bin_lo = 0 diff --git a/9_Firmware/9_3_GUI/test_v7.py b/9_Firmware/9_3_GUI/test_v7.py index 4f70ecd..636c5d4 100644 --- a/9_Firmware/9_3_GUI/test_v7.py +++ b/9_Firmware/9_3_GUI/test_v7.py @@ -65,9 +65,9 @@ class TestRadarSettings(unittest.TestCase): def test_defaults(self): s = _models().RadarSettings() - self.assertEqual(s.system_frequency, 10e9) - self.assertEqual(s.coverage_radius, 50000) - self.assertEqual(s.max_distance, 50000) + self.assertEqual(s.system_frequency, 10.5e9) + self.assertEqual(s.coverage_radius, 1536) + self.assertEqual(s.max_distance, 1536) class TestGPSData(unittest.TestCase): @@ -425,26 +425,28 @@ class TestWaveformConfig(unittest.TestCase): def test_defaults(self): from v7.models import WaveformConfig wc = WaveformConfig() - self.assertEqual(wc.sample_rate_hz, 4e6) - self.assertEqual(wc.bandwidth_hz, 500e6) - self.assertEqual(wc.chirp_duration_s, 300e-6) - self.assertEqual(wc.center_freq_hz, 10.525e9) + self.assertEqual(wc.sample_rate_hz, 100e6) + self.assertEqual(wc.bandwidth_hz, 20e6) + self.assertEqual(wc.chirp_duration_s, 30e-6) + self.assertEqual(wc.pri_s, 167e-6) + self.assertEqual(wc.center_freq_hz, 10.5e9) self.assertEqual(wc.n_range_bins, 64) self.assertEqual(wc.n_doppler_bins, 32) + self.assertEqual(wc.chirps_per_subframe, 16) self.assertEqual(wc.fft_size, 1024) self.assertEqual(wc.decimation_factor, 16) def test_range_resolution(self): - """range_resolution_m should be ~5.62 m/bin with ADI defaults.""" + """range_resolution_m should be ~23.98 m/bin (matched filter, 100 MSPS).""" from v7.models import WaveformConfig wc = WaveformConfig() - self.assertAlmostEqual(wc.range_resolution_m, 5.621, places=1) + self.assertAlmostEqual(wc.range_resolution_m, 23.983, places=1) def test_velocity_resolution(self): - """velocity_resolution_mps should be ~1.484 m/s/bin.""" + """velocity_resolution_mps should be ~5.34 m/s/bin (PRI=167us, 16 chirps).""" from v7.models import WaveformConfig wc = WaveformConfig() - self.assertAlmostEqual(wc.velocity_resolution_mps, 1.484, places=2) + self.assertAlmostEqual(wc.velocity_resolution_mps, 5.343, places=1) def test_max_range(self): """max_range_m = range_resolution * n_range_bins.""" @@ -466,7 +468,7 @@ class TestWaveformConfig(unittest.TestCase): """Non-default parameters correctly change derived values.""" from v7.models import WaveformConfig wc1 = WaveformConfig() - wc2 = WaveformConfig(bandwidth_hz=1e9) # double BW → halve range res + wc2 = WaveformConfig(sample_rate_hz=200e6) # double Fs → halve range bin self.assertAlmostEqual(wc2.range_resolution_m, wc1.range_resolution_m / 2, places=2) def test_zero_center_freq_velocity(self): @@ -925,9 +927,9 @@ class TestExtractTargetsFromFrame(unittest.TestCase): """Detection at range bin 10 → range = 10 * range_resolution.""" from v7.processing import extract_targets_from_frame frame = self._make_frame(det_cells=[(10, 16)]) # dbin=16 = center → vel=0 - targets = extract_targets_from_frame(frame, range_resolution=5.621) + targets = extract_targets_from_frame(frame, range_resolution=23.983) self.assertEqual(len(targets), 1) - self.assertAlmostEqual(targets[0].range, 10 * 5.621, places=2) + self.assertAlmostEqual(targets[0].range, 10 * 23.983, places=1) self.assertAlmostEqual(targets[0].velocity, 0.0, places=2) def test_velocity_sign(self): diff --git a/9_Firmware/9_3_GUI/v7/map_widget.py b/9_Firmware/9_3_GUI/v7/map_widget.py index fa0fcb1..951418a 100644 --- a/9_Firmware/9_3_GUI/v7/map_widget.py +++ b/9_Firmware/9_3_GUI/v7/map_widget.py @@ -98,7 +98,7 @@ class RadarMapWidget(QWidget): ) self._targets: list[RadarTarget] = [] self._pending_targets: list[RadarTarget] | None = None - self._coverage_radius = 50_000 # metres + self._coverage_radius = 1_536 # metres (64 bins x ~24 m/bin) self._tile_server = TileServer.OPENSTREETMAP self._show_coverage = True self._show_trails = False diff --git a/9_Firmware/9_3_GUI/v7/models.py b/9_Firmware/9_3_GUI/v7/models.py index c4b277c..07952d4 100644 --- a/9_Firmware/9_3_GUI/v7/models.py +++ b/9_Firmware/9_3_GUI/v7/models.py @@ -108,12 +108,12 @@ class RadarSettings: range_resolution and velocity_resolution should be calibrated to the actual waveform parameters. """ - system_frequency: float = 10e9 # Hz (carrier, used for velocity calc) - range_resolution: float = 781.25 # Meters per range bin (default: 50km/64) - velocity_resolution: float = 1.0 # m/s per Doppler bin (calibrate to waveform) - max_distance: float = 50000 # Max detection range (m) - map_size: float = 50000 # Map display size (m) - coverage_radius: float = 50000 # Map coverage radius (m) + system_frequency: float = 10.5e9 # Hz (carrier, used for velocity calc) + range_resolution: float = 24.0 # Meters per range bin (c/(2*Fs)*decim) + velocity_resolution: float = 1.0 # m/s per Doppler bin (calibrate to waveform) + max_distance: float = 1536 # Max detection range (m) + map_size: float = 2000 # Map display size (m) + coverage_radius: float = 1536 # Map coverage radius (m) @dataclass @@ -199,39 +199,46 @@ class WaveformConfig: Encapsulates the radar waveform so that range/velocity resolution can be derived automatically instead of hardcoded in RadarSettings. - Defaults match the ADI CN0566 Phaser capture parameters used in - the golden_reference cosim (4 MSPS, 500 MHz BW, 300 us chirp). + Defaults match the AERIS-10 production system parameters from + radar_scene.py / plfm_chirp_controller.v: + 100 MSPS DDC output, 20 MHz chirp BW, 30 us long chirp, + 167 us long-chirp PRI, X-band 10.5 GHz carrier. """ - sample_rate_hz: float = 4e6 # ADC sample rate - bandwidth_hz: float = 500e6 # Chirp bandwidth - chirp_duration_s: float = 300e-6 # Chirp ramp time - center_freq_hz: float = 10.525e9 # Carrier frequency + sample_rate_hz: float = 100e6 # DDC output I/Q rate (matched filter input) + bandwidth_hz: float = 20e6 # Chirp bandwidth (not used in range calc; + # retained for time-bandwidth product / display) + chirp_duration_s: float = 30e-6 # Long chirp ramp time + pri_s: float = 167e-6 # Pulse repetition interval (chirp + listen) + center_freq_hz: float = 10.5e9 # Carrier frequency (radar_scene.py: F_CARRIER) n_range_bins: int = 64 # After decimation - n_doppler_bins: int = 32 # After Doppler FFT + n_doppler_bins: int = 32 # Total Doppler bins (2 sub-frames x 16) + chirps_per_subframe: int = 16 # Chirps in one Doppler sub-frame fft_size: int = 1024 # Pre-decimation FFT length decimation_factor: int = 16 # 1024 → 64 @property def range_resolution_m(self) -> float: - """Meters per decimated range bin (FMCW deramped baseband). + """Meters per decimated range bin (matched-filter pulse compression). - For deramped FMCW: bin spacing = c * Fs * T / (2 * N_FFT * BW). - After decimation the bin spacing grows by *decimation_factor*. + For FFT-based matched filtering, each IFFT output bin spans + c / (2 * Fs) in range, where Fs is the I/Q sample rate at the + matched-filter input (DDC output). After decimation the bin + spacing grows by *decimation_factor*. """ c = 299_792_458.0 - raw_bin = ( - c * self.sample_rate_hz * self.chirp_duration_s - / (2.0 * self.fft_size * self.bandwidth_hz) - ) + raw_bin = c / (2.0 * self.sample_rate_hz) return raw_bin * self.decimation_factor @property def velocity_resolution_mps(self) -> float: - """m/s per Doppler bin. lambda / (2 * n_doppler * chirp_duration).""" + """m/s per Doppler bin. + + lambda / (2 * chirps_per_subframe * PRI), matching radar_scene.py. + """ c = 299_792_458.0 wavelength = c / self.center_freq_hz - return wavelength / (2.0 * self.n_doppler_bins * self.chirp_duration_s) + return wavelength / (2.0 * self.chirps_per_subframe * self.pri_s) @property def max_range_m(self) -> float: diff --git a/9_Firmware/9_3_GUI/v7/workers.py b/9_Firmware/9_3_GUI/v7/workers.py index c29f3bd..6bf115f 100644 --- a/9_Firmware/9_3_GUI/v7/workers.py +++ b/9_Firmware/9_3_GUI/v7/workers.py @@ -334,7 +334,7 @@ class TargetSimulator(QObject): self._add_random_target() def _add_random_target(self): - range_m = random.uniform(5000, 40000) + range_m = random.uniform(50, 1400) azimuth = random.uniform(0, 360) velocity = random.uniform(-100, 100) elevation = random.uniform(-5, 45) @@ -368,7 +368,7 @@ class TargetSimulator(QObject): for t in self._targets: new_range = t.range - t.velocity * 0.5 - if new_range < 500 or new_range > 50000: + if new_range < 10 or new_range > 1536: continue # target exits coverage — drop it new_vel = max(-150, min(150, t.velocity + random.uniform(-2, 2)))