How mitgor/plfm_radar works
1. This repository is not a single application; it is a full radar system package centered on AERIS-10, an open-source 10.5 GHz pulse-LFM phased-array radar. The repo combines system documentation, electromagnetic/RF design artifacts, firmware, FPGA logic, and Python tooling.
2. The top-level structure is organized by discipline. 00_notation, 01_physics, 02_hardware, 03_software, and 04_research are the conceptual design layer; 4_Schematics and Boards Layout, 5_Simulations, 7_Components Datasheets and Application notes, 8_Utils, and 9_Firmware contain the executable/engineering assets.
3. The repository’s main hardware architecture is modular. It includes a power management board, a frequency synthesizer board, a main radar board, optional power amplifier boards for the extended version, and antenna arrays. The readme describes two system variants: AERIS-10N with an 8x16 patch array and AERIS-10X with a 32x16 slotted waveguide array.
4. The signal chain begins with chirp generation and RF conversion. The DAC generates LFM chirps, mixers translate between IF and RF, ADAR1000 phase shifters provide electronic beam steering, and front-end RF chips handle transmit/receive amplification. The board files and simulation folders show that the RF path was designed and verified as separate subsystems.
5. The FPGA is the primary real-time digital signal-processing boundary. In 9_2_FPGA, the design includes ADC/DAC interfaces, chirp LUT loading, DDC, CIC decimation, FIR filtering, matched filtering, FFT blocks, Doppler processing, edge detection, USB packet handling, and a top-level radar system. This is where raw radar samples become range/Doppler products and detection outputs.
6. The STM32 microcontroller acts as system manager rather than the main DSP engine. In 9_1_Microcontroller, the code and support libraries manage power sequencing, clocking, frequency synthesizers, phase shifters, ADCs/DACs on the PA boards, GPS, IMU, barometer, stepper motor, RF switches, and FPGA coordination. This is the control plane for the hardware.
7. The Python GUI in 9_3_GUI is the operator and visualization layer. Multiple GUI versions and demo scripts suggest an evolving desktop interface that reads radar data, plots targets, and integrates map/position data. It is the human-facing endpoint of the radar pipeline.
8. Data flow is roughly: design parameters and notation feed physics models, which inform hardware schematics and simulations; the assembled hardware captures and conditions RF/ADC data; the FPGA processes the samples into detections; the STM32 configures and sequences the system; the Python GUI presents results and operator controls. The architecture is therefore a closed-loop sensing system with separate control, processing, and visualization paths.
9. The physics and research folders are important because they define the system’s algorithms and validation basis. Topics include FMCW/LFM theory, beamforming, detection, noise analysis, calibration, CFAR variants, clutter rejection, pulse compression, tracking, and adaptive beamforming. These folders act as the theoretical source for the implemented pipeline.
10. The simulations folder provides engineering verification for RF and antenna design decisions. It contains EM and circuit models for waveguides, filters, via fencing, RF switches, DAC reconstruction filters, and antenna patterns, plus scripts for generating beam patterns and detection curves. These artifacts sit between theory and hardware layout.
11. There is a strong documentation and provenance layer throughout the repo. The planning files, project requirements, roadmap, and phase summaries show structured development tracking; the datasheets folder anchors component selection; and the schematic/production file directories preserve manufacturable outputs. For an architecture diagram, this repo should be drawn as a layered radar platform: theory and planning on top, RF hardware in the middle, FPGA/MCU control and processing below, and Python visualization at the edge.
Main entry points: RADAR_Main_Board.sch Schematics · main.cpp MCU Firmware · 01_fmcw_theory.md Physics · radar_system_top.v FPGA Logic
Components 20
Foundations
Notation, physics, theory, research, and planning docs.
- README · Top-level system description and variant summary.
README.md - Planning · Requirements, roadmap, architecture, and phase summaries.
.planning/PROJECT.md - Notation · Shared symbols and parameter conventions.
00_notation/conventions.md - Physics · FMCW/LFM, beamforming, detection, noise, and calibration models.
01_physics/01_fmcw_theory.md - Research · Advanced detection, clutter rejection, tracking, and beamforming research.
04_research/01_cfar_variants.md - Hardware Docs · Radar subsystem breakdown, timing, power, and transforms.
02_hardware/01_system_overview.md - Software Docs · FPGA, STM32, GUI, and USB protocol architecture.
03_software/01_fpga_pipeline.md
Engineering Assets
Hardware design files, simulations, datasheets, and utility scripts.
- Schematics · Board schematics and production layout assets.
4_Schematics and Boards Layout/4_6_Schematics/MainBoard/RADAR_Main_Board.sch - Simulations · EM, circuit, and antenna models used to validate RF design choices.
5_Simulations/wg_alumina_slotted_openems.m - Datasheets · Vendor datasheets and application notes for selected parts.
7_Components Datasheets and Application notes/ADAR1000.pdf - Utils · Radar equations, waveform generation, and helper scripts.
8_Utils/Python/RADAR_eq.py - Antenna Models · Patch and slotted-waveguide array design and pattern generation.
5_Simulations/array_pattern_Kaiser25dB_like.py
Runtime Firmware
Real-time control, FPGA processing, and operator interface.
- MCU Firmware · System manager for sequencing, peripherals, and radar coordination.
9_Firmware/9_1_Microcontroller/9_1_3_C_Cpp_Code/main.cpp - FPGA Logic · Chirp generation, DDC, filtering, matched filtering, FFT, Doppler, and USB streaming.
9_Firmware/9_2_FPGA/radar_system_top.v - GUI · Desktop visualization and operator control front end.
9_Firmware/9_3_GUI/GUI_V6.py
System Hardware
Main radar boards and RF/power subassemblies.
- Power Board · System power regulation and sequencing board.
4_Schematics and Boards Layout/4_6_Schematics/PowerBoard/PowerBoard.sch - Synth Board · Frequency synthesis and clock distribution board.
4_Schematics and Boards Layout/4_6_Schematics/FrequencySynthesizerBoard/Clocks_Freq_Synth_board.sch - Main Board · Primary radar RF, ADC/DAC, and digital interface board.
4_Schematics and Boards Layout/4_6_Schematics/MainBoard/RADAR_Main_Board.sch - PA Board · Extended-version transmit power amplifier stage.
4_Schematics and Boards Layout/4_6_Schematics/PowerAmplifierBoard/RF_PA.sch - RF Frontend · Mixer, phase-shifter, amplifier, and switch architecture linking IF to RF.
02_hardware/02_rf_frontend.md
Connections 31
- README → Planning: frames · Repository planning and provenance support the system description.
- README → Hardware Docs: summarizes · The README defines the overall radar architecture and variants.
- Notation → Physics: standardizes · Shared symbols and parameters feed the theory documents.
- Physics → Research: extends · Research builds on the base radar theory and detection models.
- Physics → Utils: drives · Utility scripts encode equations and waveform calculations from theory.
- Physics → Antenna Models: informs · Array synthesis and beam patterns derive from beamforming theory.
- Physics → Simulations: validates · Simulation artifacts verify RF and EM assumptions from theory.
- Hardware Docs → RF Frontend: defines · Hardware docs describe the RF chain and its subsystem boundaries.
- Hardware Docs → Antenna Models: defines · The hardware architecture includes antenna array choices and beam steering.
- RF Frontend → Main Board: implemented by · The main board hosts the core radar RF and digital interfaces.
- RF Frontend → Synth Board: clocked by · Frequency generation and LO distribution come from the synth board.
- RF Frontend → PA Board: extended by · The optional PA board boosts transmit power in the X variant.
- Power Board → Main Board: feeds · Power sequencing and regulation supply the radar core board.
- Power Board → MCU Firmware: controlled by · The MCU firmware manages power-up and peripheral enablement.
- Datasheets → Schematics: sources · Component datasheets underpin schematic and board design choices.
- Simulations → Schematics: verifies · Simulation results inform board layout and RF implementation.
- Schematics → Power Board: contains · Board schematics capture the manufacturable power hardware.
- Schematics → Synth Board: contains · Board schematics capture the synthesizer and clock hardware.
- Schematics → Main Board: contains · Board schematics capture the main radar board.
- Schematics → PA Board: contains · Board schematics capture the optional PA board.
- MCU Firmware → Main Board: configures · The STM32 firmware sequences and configures the hardware.
- MCU Firmware → Synth Board: programs · It programs the synthesizer and clock devices.
- MCU Firmware → PA Board: manages · It handles PA-board peripherals and auxiliaries in the extended system.
- MCU Firmware → FPGA Logic: coordinates · The control plane orchestrates FPGA operation and data capture.
- FPGA Logic → GUI: streams · Processed radar products are sent to the operator interface.
- FPGA Logic → Main Board: runs on · The FPGA logic is the real-time digital boundary of the main board.
- Antenna Models → Main Board: interfaces with · Array design connects to the radar board and front-end beamforming.
- Research → FPGA Logic: guides · Algorithm research informs filtering, detection, and tracking blocks.
- Software Docs → MCU Firmware: specifies · The software architecture documents the STM32 control layer.
- Software Docs → FPGA Logic: specifies · The software architecture documents the FPGA DSP pipeline.
- Software Docs → GUI: specifies · The software architecture documents the operator UI layer.