One complete radar frame (64 range x 32 Doppler).

FT2232H USB 2.0 Hi-Speed FIFO bridge communication. Uses pyftdi in 245 Synchronous FIFO mode (Channel A). VID:PID = 0x0403:0x6010 (FTDI d

Parsed status response from FPGA (6-word / 26-byte packet).

FT601 USB 3.0 SuperSpeed FIFO bridge — premium board only. The FT601 has a 32-bit data bus and runs at 100 MHz. VID:PID = 0x0403:0x6030

Load replay data and serve RadarFrames on demand. Parameters ---------- path : str File or directory path to load. software_f

Physical waveform parameters for converting bins to SI units. Encapsulates the radar waveform so that range/velocity resolution can be derive

Manages replay playback in a background thread for the Tkinter dashboard. Imports ``ReplayEngine`` and ``SoftwareFPGA`` from ``v7`` lazily so

Single simulated target with kinematics.

Bit-accurate replica of the AERIS-10 FPGA signal processing chain. All registers mirror FPGA reset defaults from ``radar_system_top.v``. Sett

Represents a radar target.

GPS position and orientation data.

Host-side signal processing pipeline configuration. These control host-side DSP that runs AFTER the FPGA processing pipeline. FPGA-side MTI,

Parse GPS (and general) data arriving from the STM32 via USB CDC. Supports: - Text format: ``GPS:lat,lon,alt,pitch\\r\\n`` - Bin

Complete matched filter: FFT(signal) * conj(FFT(ref)) -> IFFT Uses a single FFTEngine instance (as in RTL, engine is reused).

Background thread: reads from USB (FT2232H), parses 11-byte packets, assembles frames, and pushes complete frames to the display queue.

Full radar processing pipeline: fusion, clustering, association, tracking.

Represents a detected radar target.

Record radar frames to HDF5 files for offline analysis.

Radar system display/map configuration. FPGA register parameters (chirp timing, CFAR, MTI, gain, etc.) are controlled directly via 4-byte opc

Bit-accurate model of cic_decimator_4x_enhanced.v 5-stage CIC with 4x decimation. Integrators: 48-bit wrapping arithmetic (modular).

One field in the 11-byte data packet.

Timer-driven demo target generator for the Tkinter dashboard. Produces synthetic ``RadarFrame`` objects and a target list each tick, pushing

Bit-accurate model of doppler_processor_optimized.v (dual 16-pt FFT architecture). The staggered-PRF frame has 32 chirps total: - Sub-

Bit-accurate model of fft_engine.v 1024-point radix-2 DIT FFT/IFFT. Internal: 32-bit signed working data. Twiddle: 16-bit Q15 from q

Bit-accurate model of fir_lowpass_parallel_enhanced.v 32-tap FIR with 5-stage pipelined binary adder tree. Input: 18-bit signed. Output

GPS position and orientation data

A GPIO pin with direction.

Bit-accurate model of ddc_400m mixer. ADC 8-bit unsigned -> 18-bit signed conversion: adc_signed = {1'b0, adc_data, 9'b0} - {1'b0, 8'h

Bit-accurate model of nco_400m_enhanced.v 6-stage pipeline: Stage 1: phase_accumulator += ftw; phase_accum_reg = prev accumulator

One opcode as declared in a single layer.

Header/footer/size constants for a packet type.

Represents a detected radar target

Interface for STM32 USB CDC (Virtual COM Port). Used ONLY for receiving GPS data from the MCU. FPGA register commands are sent via the

Generates realistic simulated radar data

AGC tuning parameters (mirrors FPGA host registers 0x28-0x2C).

Per-frame AGC metrics returned by process_agc_frame().

Mutable internal AGC state — persists across frames.

Track line counts per subsystem and severity.

Result of counting bits in a Verilog concatenation.

Bit-accurate model of ddc_input_interface.v Converts 18-bit FIR output to 16-bit with rounding: adc_i = ddc_i[17:2] + ddc_i[1] 2-

Interface for FT601 USB 3.0 SuperSpeed controller

Bit-accurate model of frequency_matched_filter.v Conjugate multiply: (a + jb) * conj(c + jd) = (ac+bd) + j(bc-ad) 4-stage pipeline:

Background worker that reads GPS frames from the STM32 USB CDC interface and emits parsed GPSData objects. Signals: gpsReceived(

Bridge object exposed to JavaScript for bidirectional communication. This allows Python to call JavaScript functions and vice versa.

Bridge object registered with QWebChannel for JS ↔ Python calls.

Main application window for the radar dashboard

Main tkinter application: real-time radar visualization and control.

Main application window with 5 tabs.

Background worker that reads radar data from FT2232H, parses 0xAA/0xBB packets via production RadarAcquisition, runs optional host-side DSP,

Custom widget embedding a Leaflet.js map via QWebEngineView. Provides methods for updating radar position, targets, and coverage.

Embeds a Leaflet.js interactive map inside a QWebEngineView. Public methods mirror the V6 map API: set_radar_position(gps), set_target

Radar system configuration

Bit-accurate model of range_bin_decimator.v Three modes: 00: Simple decimation (take center sample at index 8) 01: Peak detectio

Matplotlib canvas showing the 64x32 Range-Doppler map with dark theme.

Background worker for replay data playback. Emits the same signals as ``RadarDataWorker`` so the dashboard treats live and replay identically

One field in the STM32 SET...END settings packet.

Full AERIS-10 signal processing chain. For sample-by-sample co-simulation with RTL, use the step-based API (nco, mixer, cic, fir individ

Host-side smoke test controller.

One field inside a status_words[] entry.

Simulates radar targets for demonstration purposes

Generates simulated radar targets for demo/testing. Uses a QTimer on the main thread (or whichever thread owns this object). Emits ``tar

Test packet parsing and command building against usb_data_interface.v.

Thread-safe bridge: emits a Qt signal so the slot runs on the GUI thread.

Sends log records to a QObject signal (safe from any thread).

Logging handler that posts messages to a queue for main-thread append. Using widget.after() from background threads crashes Python 3.12 due to

Forward-declare to avoid pulling in the full ADAR1000_Manager header here. The .cpp includes the real header.