FPGA 雷达信号处理指南：从采样到目标检测的系统实现

FPGA 雷达信号处理指南：从采样到目标检测的系统实现 | 极客日志

发射信号 → 传播 → 目标反射 → 接收信号 → 信号处理 → 目标检测

R = (c × τ) / 2

v = (Δf × c) / (2 × f0)

Pr = (Pt × Gt × Gr × λ² × σ) / ((4π)³ × R⁴ × L)

原始采样数据 ↓ 正交采样 (I/Q 解调) ↓ 脉冲压缩 (匹配滤波) ↓ FFT(频域分析) ↓ 动目标检测 (MTD) ↓ 恒虚警检测 (CFAR) ↓ 目标参数估计 ↓ 目标跟踪

环节	功能	输入	输出
I/Q 解调	提取基带信号	RF 采样	I/Q 数据
脉冲压缩	提高距离分辨率	I/Q 数据	压缩脉冲
FFT	频域分析	压缩脉冲	频谱
MTD	消除杂波	频谱	动目标
CFAR	自适应检测	动目标	检测结果

┌─────────────┐ │ RF 前端 │ (混频、放大、滤波) └──────┬──────┘ │ ┌──────▼──────┐ │ ADC 采样 │ (多通道、高速) └──────┬──────┘ │ ┌──────▼──────────────────────┐ │ FPGA 信号处理 │ │ ┌──────────────────────┐ │ │ │ I/Q 解调模块 │ │ │ ├──────────────────────┤ │ │ │ 脉冲压缩模块 │ │ │ ├──────────────────────┤ │ │ │ FFT 模块 │ │ │ ├──────────────────────┤ │ │ │ MTD/CFAR 模块 │ │ │ └──────────────────────┘ │ └──────┬──────────────────────┘ │ ┌──────▼──────┐ │ 主处理器 │ (目标跟踪、显示) └─────────────┘

┌─────────────────────────────────────┐ │ FPGA 芯片 │ │ │ │ ┌─────────────────────────────┐ │ │ │ AXI 互联 │ │ │ └──┬──────────────────────┬───┘ │ │ │ │ │ │ ┌──▼──┐ ┌──────┐ ┌────▼──┐ │ │ │ I/Q │ │ 脉冲 │ │ FFT │ │ │ │解调 │ │压缩 │ │ IP 核 │ │ │ └──┬──┘ └──┬───┘ └────┬──┘ │ │ │ │ │ │ │ ┌──▼────────▼───────────▼──┐ │ │ │ MTD/CFAR 处理模块 │ │ │ └──┬──────────────────────┘ │ │ │ │ │ ┌──▼──────────────────────┐ │ │ │ BRAM/DDR 缓存 │ │ │ └──────────────────────────┘ │ │ │ └─────────────────────────────────────┘

s(t) = A·cos(2πf_c·t + φ)

s_c(t) = I(t) + j·Q(t) = A·e^(j(2πf_c·t + φ))

f_s ≥ 2(f_c + B/2) (奈奎斯特采样)

f_s ≥ 2B (降低采样率)

s(t) = A·cos(2πf_c·t + φ)

LO_I(t) = cos(2πf_c·t) LO_Q(t) = -sin(2πf_c·t)

I(t) = s(t)·LO_I(t) = A·cos(2πf_c·t + φ)·cos(2πf_c·t) = A/2·[cos(φ) + cos(4πf_c·t + φ)] Q(t) = s(t)·LO_Q(t) = -A·cos(2πf_c·t + φ)·sin(2πf_c·t) = A/2·[sin(φ) - sin(4πf_c·t + φ)]

I_bb(t) = A/2·cos(φ) Q_bb(t) = A/2·sin(φ)

s_bb(t) = I_bb(t) + j·Q_bb(t) = (A/2)·e^(jφ)

幅度：|s_bb| = A/2 相位：∠s_bb = φ

┌─────────────┐ │ RF 信号 │ (77GHz) └──────┬──────┘ │ ┌──┴──┐ │混频 │ └──┬──┘ │ ┌──┴──────────────┐ │ │ ┌───▼────┐ ┌────▼───┐ │ LPF │ │ LPF │ │(I 路) │ │(Q 路) │ └───┬────┘ └────┬───┘ │ │ ┌───▼────┐ ┌────▼───┐ │ ADC │ │ ADC │ └───┬────┘ └────┬───┘ │ │ └────┬───────────┘ │ ┌────▼────┐ │ I/Q 数据 │ (基带) └─────────┘

module iq_demodulator #( parameter DATA_WIDTH = 16, parameter PHASE_WIDTH = 32 )( input clk, input rst_n, // RF 输入 input signed [DATA_WIDTH-1:0] rf_data, input rf_valid, // 本振控制 input [PHASE_WIDTH-1:0] lo_freq, input [PHASE_WIDTH-1:0] lo_phase_init, // I/Q 输出 output signed [DATA_WIDTH-1:0] i_data, output signed [DATA_WIDTH-1:0] q_data, output iq_valid ); // 相位累加器 reg [PHASE_WIDTH-1:0] phase_acc; wire [PHASE_WIDTH-1:0] phase_next; // DDS 正弦波生成 wire signed [DATA_WIDTH-1:0] sin_val, cos_val; // 混频器 wire signed [2*DATA_WIDTH-1:0] i_mix, q_mix; // 相位累加 assign phase_next = phase_acc + lo_freq; always @(posedge clk or negedge rst_n) begin if (!rst_n) phase_acc <= lo_phase_init; else if (rf_valid) phase_acc <= phase_next; end // DDS 查表 dds_lut dds_inst ( .phase(phase_acc[PHASE_WIDTH-1:PHASE_WIDTH-10]), .sin_out(sin_val), .cos_out(cos_val) ); // 混频 assign i_mix = rf_data * cos_val; assign q_mix = rf_data * sin_val; // 低通滤波 (简化示例) assign i_data = i_mix[2*DATA_WIDTH-1:DATA_WIDTH]; assign q_data = q_mix[2*DATA_WIDTH-1:DATA_WIDTH]; assign iq_valid = rf_valid; endmodule

module dds_lut #( parameter PHASE_WIDTH = 10, parameter DATA_WIDTH = 16 )( input [PHASE_WIDTH-1:0] phase, output reg signed [DATA_WIDTH-1:0] sin_out, output reg signed [DATA_WIDTH-1:0] cos_out ); // 四分之一周期查表 (90 个点) reg signed [DATA_WIDTH-1:0] sin_table [0:89]; initial begin // 初始化正弦表 (0 到π/2) sin_table[0] = 16'd0; sin_table[1] = 16'd1144; sin_table[2] = 16'd2287; // ... 更多值 sin_table[89] = 16'd32767; end always @(*) begin case(phase[9:8]) 2'b00: begin // 0 到π/2 sin_out = sin_table[phase[7:0]]; cos_out = sin_table[89-phase[7:0]]; end 2'b01: begin // π/2 到π sin_out = sin_table[89-phase[7:0]]; cos_out = -sin_table[phase[7:0]]; end 2'b10: begin // π到 3π/2 sin_out = -sin_table[phase[7:0]]; cos_out = -sin_table[89-phase[7:0]]; end 2'b11: begin // 3π/2 到 2π sin_out = -sin_table[89-phase[7:0]]; cos_out = sin_table[phase[7:0]]; end endcase end endmodule

module lpf_fir #( parameter DATA_WIDTH = 16, parameter TAP_NUM = 32 )( input clk, input rst_n, input signed [DATA_WIDTH-1:0] data_in, input data_valid, output signed [DATA_WIDTH-1:0] data_out, output out_valid ); reg signed [DATA_WIDTH-1:0] shift_reg [0:TAP_NUM-1]; wire signed [DATA_WIDTH+8:0] sum; // FIR 系数 (32 阶低通滤波器) reg signed [15:0] coeff [0:TAP_NUM-1]; integer i; always @(posedge clk or negedge rst_n) begin if (!rst_n) begin for (i = 0; i < TAP_NUM; i = i + 1) shift_reg[i] <= 0; end else if (data_valid) begin shift_reg[0] <= data_in; for (i = 1; i < TAP_NUM; i = i + 1) shift_reg[i] <= shift_reg[i-1]; end end // 卷积计算 assign sum = shift_reg[0] * coeff[0] + shift_reg[1] * coeff[1] + // ... 更多项 shift_reg[TAP_NUM-1] * coeff[TAP_NUM-1]; assign data_out = sum[DATA_WIDTH+7:8]; assign out_valid = data_valid; endmodule

δR = (c × τ) / 2

发射能量：E = A² × τ 信噪比：SNR = (K² × A² × τ) / σ²

D = B × τ₀

原始分辨率：δR = (c × τ₀) / 2 压缩后分辨率：δR' = (c × τ₀) / (2 × D) = c / (2B)

s(t) = A × rect(t/τ₀) × exp(j × π × K × t²)

f(t) = f₀ + K × t

B = K × τ₀

H(f) = K × S*(f) × e^(-j2πft₀)

h(t) = K × s*(t₀ - t)

y(t) = x(t) * h(t) = ∫ x(τ) × h(t-τ) dτ

r(t) = A × rect((t-t₀)/τ₀) × exp(j × π × K × (t-t₀)²)

h(t) = A × rect(t/τ₀) × exp(-j × π × K × t²)

y(t) = A² × τ₀ × sinc(π × B × (t - t₀))

窗函数	主瓣宽度	第一旁瓣	应用
矩形窗	2/B	-13.2dB	基准
Hamming 窗	2.3/B	-43dB	强旁瓣抑制
Hanning 窗	2.3/B	-32dB	平衡
Taylor 窗	2.2/B	-35dB	最优

接收信号 ↓ LFM 信号生成 ↓ 混频 (频率搬移) ↓ FFT(频域变换) ↓ 匹配滤波 (频域乘法) ↓ IFFT(时域变换) ↓ 取幅度 ↓ 压缩脉冲

module pulse_compression #( parameter DATA_WIDTH = 16, parameter FILTER_LEN = 256 )( input clk, input rst_n, // 接收信号 input signed [DATA_WIDTH-1:0] rx_i, input signed [DATA_WIDTH-1:0] rx_q, input rx_valid, // 发射信号 (参考) input signed [DATA_WIDTH-1:0] tx_i, input signed [DATA_WIDTH-1:0] tx_q, // 输出 output signed [DATA_WIDTH+8:0] out_mag, output out_valid ); // 延迟线 reg signed [DATA_WIDTH-1:0] rx_i_delay [0:FILTER_LEN-1]; reg signed [DATA_WIDTH-1:0] rx_q_delay [0:FILTER_LEN-1]; // 累加器 reg signed [DATA_WIDTH+16:0] sum_i, sum_q; integer i; always @(posedge clk or negedge rst_n) begin if (!rst_n) begin for (i = 0; i < FILTER_LEN; i = i + 1) begin rx_i_delay[i] <= 0; rx_q_delay[i] <= 0; end sum_i <= 0; sum_q <= 0; end else if (rx_valid) begin // 移位 for (i = FILTER_LEN-1; i > 0; i = i - 1) begin rx_i_delay[i] <= rx_i_delay[i-1]; rx_q_delay[i] <= rx_q_delay[i-1]; end rx_i_delay[0] <= rx_i; rx_q_delay[0] <= rx_q; // 互相关计算 sum_i <= 0; sum_q <= 0; for (i = 0; i < FILTER_LEN; i = i + 1) begin sum_i <= sum_i + rx_i_delay[i] * tx_i; sum_q <= sum_q + rx_q_delay[i] * tx_q; end end end // 幅度计算 wire signed [DATA_WIDTH+16:0] mag_sq; assign mag_sq = sum_i * sum_i + sum_q * sum_q; assign out_mag = $sqrt(mag_sq); assign out_valid = rx_valid; endmodule

module freq_domain_compression #( parameter FFT_SIZE = 256, parameter DATA_WIDTH = 16 )( input clk, input rst_n, // 接收信号 (I/Q) input signed [DATA_WIDTH-1:0] rx_i, input signed [DATA_WIDTH-1:0] rx_q, input rx_valid, // 匹配滤波器系数 (预计算) input signed [DATA_WIDTH-1:0] h_i, input signed [DATA_WIDTH-1:0] h_q, // 输出 output signed [DATA_WIDTH+8:0] out_mag, output out_valid ); // FFT 输出 wire signed [DATA_WIDTH+4:0] fft_i, fft_q; wire fft_valid; // 乘法结果 wire signed [2*DATA_WIDTH+8:0] mul_i, mul_q; // IFFT 输出 wire signed [DATA_WIDTH+4:0] ifft_i, ifft_q; wire ifft_valid; // FFT 模块 fft_core fft_inst ( .clk(clk), .rst_n(rst_n), .data_i(rx_i), .data_q(rx_q), .data_valid(rx_valid), .fft_i(fft_i), .fft_q(fft_q), .fft_valid(fft_valid) ); // 频域乘法 (复数乘法) assign mul_i = fft_i * h_i - fft_q * h_q; assign mul_q = fft_i * h_q + fft_q * h_i; // IFFT 模块 ifft_core ifft_inst ( .clk(clk), .rst_n(rst_n), .data_i(mul_i[2*DATA_WIDTH+7:DATA_WIDTH]), .data_q(mul_q[2*DATA_WIDTH+7:DATA_WIDTH]), .data_valid(fft_valid), .ifft_i(ifft_i), .ifft_q(ifft_q), .ifft_valid(ifft_valid) ); // 幅度计算 assign out_mag = $sqrt(ifft_i*ifft_i + ifft_q*ifft_q); assign out_valid = ifft_valid; endmodule

X(k) = Σ(n=0 to N-1) x(n) × W_N^(nk)

N 点 FFT = 两个 N/2 点 FFT + 旋转因子乘法

X_out[0] = X_in[0] + X_in[1] × W X_out[1] = X_in[0] - X_in[1] × W

f_d = (2 × v × f_c) / c

Δv = (c × Δf) / (2 × f_c × M)

v_max = (c × f_s) / (4 × f_c)

每级增长：1 bit 总增长：log₂(N) bit

每级增长：1.58 bit (约 3 bit) 总增长：1.58 × log₄(N) bit

输出宽度 = 输入宽度 + log₂(N) + 1

输出宽度 = 16 + 10 + 1 = 27 bit

数据传输 = TVALID & TREADY

时域信号 → FFT → 频域乘法 → IFFT → 时域结果

对每个距离单元：1. 提取该距离的所有脉冲 2. 进行 FFT 3. 取幅度谱

module fft_processor #( parameter FFT_SIZE = 1024, parameter DATA_WIDTH = 16 )( input clk, input rst_n, // 输入 input signed [DATA_WIDTH-1:0] data_i, input signed [DATA_WIDTH-1:0] data_q, input data_valid, // 输出 output signed [DATA_WIDTH+10:0] fft_mag, output fft_valid ); // FFT IP 核例化 fft_ip_v9_0 fft_inst ( .aclk(clk), .aresetn(rst_n), // 配置接口 .s_axis_config_tdata({ 10'd10, // NFFT = 1024 1'b0, // FWD = FFT 3'b001 // SCALE = 1/N }), .s_axis_config_tvalid(1'b1), // 数据输入 .s_axis_data_tdata({data_q, data_i}), .s_axis_data_tvalid(data_valid), .s_axis_data_tlast(data_valid), // 数据输出 .m_axis_data_tdata({fft_q, fft_i}), .m_axis_data_tvalid(fft_valid), // 事件信号 .event_frame_started(), .event_fft_overflow() ); // 幅度计算 wire signed [DATA_WIDTH+10:0] mag_sq; assign mag_sq = fft_i*fft_i + fft_q*fft_q; assign fft_mag = $sqrt(mag_sq); endmodule

每个滤波器对应一个速度 滤波器数 = FFT 点数 速度分辨率 = c × Δf / (2 × f_c × M)

H_k(f) = 1, 当 f = f_d_k H_k(f) = 0, 当 f ≠ f_d_k

脉冲压缩后信号 ↓ 相干积累 (多脉冲) ↓ FFT(多普勒分析) ↓ 取幅度谱 ↓ MTD 输出 (距离 - 多普勒矩阵)

y(n) = Σ(m=0 to M-1) x(n,m) × e^(j2πf_d×m×T_r)

行数 = 距离单元数 (脉冲压缩后) 列数 = 多普勒单元数 (FFT 点数)

门限 = 缩放因子 × 噪声功率估计

P_fa = 虚警数 / 总检测数

P_fa = 常数 (与噪声功率无关)

|参考 | 保护 | 检测 | 保护 | 参考 | | 8 | 2 | 1 | 2 | 8 |

T = α × (1/N) × Σ(参考单元功率)

T = α × max(前参考，后参考)

T = α × min(前参考，后参考)

T = α × 第 k 大 (所有参考单元)

参考窗口 = 距离方向 × 多普勒方向 T = α × (1/N) × Σ(参考窗口功率)

距离 ↑ │ R R R R R │ R P P P R │ R P C P R │ R P P P R │ R R R R R └─────────→ 多普勒

module mtd_processor #( parameter RANGE_BINS = 256, parameter DOPPLER_BINS = 64, parameter DATA_WIDTH = 16 )( input clk, input rst_n, // 脉冲压缩输入 input signed [DATA_WIDTH-1:0] pc_i, input signed [DATA_WIDTH-1:0] pc_q, input pc_valid, input [7:0] range_idx, input [5:0] pulse_idx, // MTD 输出 output signed [DATA_WIDTH+8:0] mtd_mag, output mtd_valid, output [7:0] out_range, output [5:0] out_doppler ); // 相干积累缓存 reg signed [DATA_WIDTH+6:0] accum_i [0:RANGE_BINS-1][0:DOPPLER_BINS-1]; reg signed [DATA_WIDTH+6:0] accum_q [0:RANGE_BINS-1][0:DOPPLER_BINS-1]; // FFT 输出 wire signed [DATA_WIDTH+10:0] fft_i, fft_q; wire fft_valid; // 相干积累 always @(posedge clk or negedge rst_n) begin if (!rst_n) begin // 清空缓存 end else if (pc_valid) begin accum_i[range_idx][pulse_idx] <= accum_i[range_idx][pulse_idx] + pc_i; accum_q[range_idx][pulse_idx] <= accum_q[range_idx][pulse_idx] + pc_q; end end // FFT 处理 (对每个距离单元) fft_ip_v9_0 fft_inst ( .aclk(clk), .aresetn(rst_n), .s_axis_data_tdata({accum_q[range_idx], accum_i[range_idx]}), .s_axis_data_tvalid(pc_valid), .m_axis_data_tdata({fft_q, fft_i}), .m_axis_data_tvalid(fft_valid) ); // 幅度计算 assign mtd_mag = $sqrt(fft_i*fft_i + fft_q*fft_q); assign mtd_valid = fft_valid; endmodule

module ca_cfar #( parameter DATA_WIDTH = 16, parameter REF_CELLS = 16, parameter GUARD_CELLS = 2 )( input clk, input rst_n, // 输入 input [DATA_WIDTH-1:0] data_in, input data_valid, // 输出 output target_detected, output [DATA_WIDTH+8:0] threshold ); // 参考单元缓存 reg [DATA_WIDTH-1:0] ref_buffer [0:REF_CELLS-1]; wire [DATA_WIDTH+8:0] ref_sum; // 缩放因子 (可调) parameter SCALE_FACTOR = 16'd2; // 参考单元求和 assign ref_sum = ref_buffer[0] + ref_buffer[1] + ... + ref_buffer[REF_CELLS-1]; // 门限计算 assign threshold = (ref_sum >> 4) * SCALE_FACTOR; // 目标检测 assign target_detected = (data_in > threshold) ? 1'b1 : 1'b0; // 缓存管理 always @(posedge clk or negedge rst_n) begin if (!rst_n) begin // 清空缓存 end else if (data_valid) begin ref_buffer[0] <= data_in; ref_buffer[1] <= ref_buffer[0]; // ... 移位 ref_buffer[REF_CELLS-1] <= ref_buffer[REF_CELLS-2]; end end endmodule

指标	非流水线	流水线
吞吐量	1 个/N个周期	1 个/周期
延迟	N 个周期	N 个周期
时钟	低	高
资源	少	多

┌─────────┐ │ ADC 采样 │ (第 1 级) └────┬────┘ │ ┌────▼──────────┐ │ I/Q 解调 │ (第 2-3 级) └────┬──────────┘ │ ┌────▼──────────┐ │ 脉冲压缩 │ (第 4-6 级) └────┬──────────┘ │ ┌────▼──────────┐ │ FFT │ (第 7-15 级) └────┬──────────┘ │ ┌────▼──────────┐ │ MTD/CFAR │ (第 16-18 级) └────┬──────────┘ │ ┌────▼──────────┐ │ 输出 │ (第 19 级) └───────────────┘

module pipeline_stage #( parameter WIDTH = 16, parameter STAGES = 3 )( input clk, input rst_n, input [WIDTH-1:0] data_in, input valid_in, output [WIDTH-1:0] data_out, output valid_out ); reg [WIDTH-1:0] pipe_data [0:STAGES-1]; reg [STAGES-1:0] pipe_valid; always @(posedge clk or negedge rst_n) begin if (!rst_n) begin pipe_data[0] <= 0; pipe_valid[0] <= 1'b0; end else begin pipe_data[0] <= data_in; pipe_valid[0] <= valid_in; end end genvar i; generate for (i = 1; i < STAGES; i = i + 1) begin always @(posedge clk or negedge rst_n) begin if (!rst_n) begin pipe_data[i] <= 0; pipe_valid[i] <= 1'b0; end else begin pipe_data[i] <= pipe_data[i-1]; pipe_valid[i] <= pipe_valid[i-1]; end end end endgenerate assign data_out = pipe_data[STAGES-1]; assign valid_out = pipe_valid[STAGES-1]; endmodule

容量 > 100Kb → BRAM 容量 < 10Kb → 分布式 RAM 10Kb ~ 100Kb → 权衡

地址：0, 1, 2, 3, ... 优点：缓存友好，带宽高

地址：随机 缺点：缓存不友好，延迟高

module dual_port_ram #( parameter ADDR_WIDTH = 10, parameter DATA_WIDTH = 16, parameter DEPTH = 1024 )( input clk, // 读端口 input [ADDR_WIDTH-1:0] rd_addr, output reg [DATA_WIDTH-1:0] rd_data, // 写端口 input [ADDR_WIDTH-1:0] wr_addr, input [DATA_WIDTH-1:0] wr_data, input wr_en ); reg [DATA_WIDTH-1:0] mem [0:DEPTH-1]; always @(posedge clk) begin rd_data <= mem[rd_addr]; end always @(posedge clk) begin if (wr_en) mem[wr_addr] <= wr_data; end endmodule

create_clock -period 5 -name clk [get_ports clk]

频率 = 1000 / 周期 (ns) 例：周期=5ns → 频率=200MHz

create_clock -period 5 -name adc_clk [get_ports adc_clk] create_clock -period 10 -name proc_clk [get_ports proc_clk] create_clock -period 20 -name out_clk [get_ports out_clk]

reg sync1, sync2; always @(posedge clk_dst) begin sync1 <= signal_src; sync2 <= sync1; end assign signal_dst = sync2;

// 源时钟域 always @(posedge clk_src) begin if (data_valid && ack) req <= ~req; end // 目标时钟域 always @(posedge clk_dst) begin req_sync <= req; ack <= (req_sync == req); end

# 主时钟 create_clock -period 5 -name clk [get_ports clk] # 输入延迟 set_input_delay -clock clk -min 1 [get_ports data_in] set_input_delay -clock clk -max 2 [get_ports data_in] # 输出延迟 set_output_delay -clock clk -min 0.5 [get_ports data_out] set_output_delay -clock clk -max 1.5 [get_ports data_out] # 虚假路径 set_false_path -from [get_clocks clk_src] -to [get_clocks clk_dst] # 多周期路径 set_multicycle_path 2 -from [get_pins reg1/Q] -to [get_pins reg2/D]

┌──────────────┐ │ 77GHz RF 前端 │ └──────┬───────┘ │ (ADC 采样，400MHz) ┌──────▼──────────────────────────────────┐ │ FPGA 信号处理 (Zynq-7045) │ │ │ │ ┌─────────────────────────────────┐ │ │ │ I/Q 解调 (DDS+ 混频+LPF) │ │ │ │ 资源：2K LUT, 4 DSP │ │ │ └──────────┬──────────────────────┘ │ │ │ │ │ ┌──────────▼──────────────────────┐ │ │ │ 脉冲压缩 (时域 FIR) │ │ │ │ 资源：5K LUT, 32 DSP │ │ │ └──────────┬──────────────────────┘ │ │ │ │ │ ┌──────────▼──────────────────────┐ │ │ │ FFT(1024 点，Xilinx IP 核) │ │ │ │ 资源：3K LUT, 20 BRAM │ │ │ └──────────┬──────────────────────┘ │ │ │ │ │ ┌──────────▼──────────────────────┐ │ │ │ MTD/CFAR(二维处理) │ │ │ │ 资源：4K LUT, 8 BRAM │ │ │ └──────────┬──────────────────────┘ │ │ │ │ │ ┌──────────▼──────────────────────┐ │ │ │ 目标参数估计 │ │ │ │ 资源：2K LUT, 10 DSP │ │ │ └──────────┬──────────────────────┘ │ │ │ │ │ ┌──────────▼──────────────────────┐ │ │ │ 输出接口 (AXI/UART) │ │ │ │ 资源：1K LUT │ │ │ └──────────────────────────────────┘ │ │ │ │ 总资源：17K LUT, 66 DSP, 28 BRAM │ │ 利用率：8%, 7%, 5% │ └──────┬──────────────────────────────────┘ │ ┌──────▼──────────┐ │ 主处理器 (ARM) │ │ 目标跟踪/显示 │ └─────────────────┘

输入：400MHz 采样的 RF 信号 处理：DDS 生成 77GHz 本振 → 混频 → LPF 输出：200MHz I/Q 数据 延迟：3 个周期

输入：I/Q 数据 (200MHz) 处理：256 阶 FIR 匹配滤波 输出：压缩脉冲 (200MHz) 延迟：256 个周期

输入：压缩脉冲 (200MHz) 处理：1024 点 FFT 输出：频域数据 (200MHz) 延迟：1024 个周期

输入：频域数据 (200MHz) 处理：相干积累 → 二维 CFAR 输出：检测结果 (50MHz) 延迟：64 个周期

采样率：400MHz 处理延迟：~2μs 实时处理：✓ (满足要求)

检测概率：95% 虚警概率：10^-7 检测增益：18dB

理论分辨率：0.15m 实际精度：±0.1m

理论分辨率：0.5 km/h 实际精度：±0.3 km/h

资源	使用	总量	利用率
LUT	17K	215K	8%
BRAM	28	545	5%
DSP	66	900	7%
FF	12K	430K	3%

I/Q 缓存：2 BRAM (256×32bit) 脉冲压缩：4 BRAM (1024×16bit) FFT 中间：8 BRAM (1024×32bit) MTD 矩阵：10 BRAM (256×64×16bit) 其他：4 BRAM

静态功耗：2W 动态功耗：3W 总功耗：5W

主时钟：200MHz (5ns 周期) ADC 时钟：400MHz (2.5ns 周期) 输出时钟：50MHz (20ns 周期)

最长路径：FFT 输出 → CFAR 检测 延迟：4.8ns 时序裕度：0.2ns

工具：ModelSim/Vivado 时间：1ms (5000 个采样) 信号：合成 LFM 信号 + 高斯噪声

1. 加载比特流到 FPGA 2. 配置 ADC 采样参数 3. 发送测试信号 4. 采集处理结果 5. 与仿真结果对比

检测率 = 正确检测数 / 总目标数 虚警率 = 虚警数 / 总检测数 定位误差 = |估计值 - 真实值|

单目标检测率：99% 多目标检测率：95% 虚警率：< 10^-7 距离误差：< 0.1m 速度误差：< 0.3 km/h

原因：组合逻辑过深 解决：增加流水线级数，降低时钟频率

原因：缓存过大 解决：使用 DDR 存储，分块处理

原因：CFAR 参数不合适 解决：调整缩放因子，优化参考窗口

原因：时钟频率过高 解决：降低采样率，使用时钟门控

FPGA 雷达信号处理指南：从采样到目标检测的系统实现

概述

一、雷达信号处理基础概念与系统架构

1.1 雷达工作原理快速入门

1.1.1 基本工作流程

1.1.2 距离与速度测量

1.1.3 雷达方程

1.2 雷达信号处理流程

1.3 FPGA 在雷达系统中的角色

1.4 系统架构设计

1.4.1 典型系统框图

1.4.2 FPGA 内部架构

1.4.3 关键设计考虑

二、正交采样与 I/Q 解调

2.1 正交采样基础

2.1.1 为什么需要正交采样

2.1.2 复信号与实信号

2.1.3 采样率选择

2.2 I/Q 解调原理

2.2.1 解调数学原理

2.2.2 复信号表示

2.2.3 I/Q 解调框图

2.2.4 本振信号生成

2.3 FPGA 实现

2.3.1 I/Q 解调模块架构

2.3.2 DDS 查表实现

2.3.3 低通滤波器

2.3.4 关键设计要点

三、脉冲压缩与匹配滤波

3.1 脉冲压缩原理

3.1.1 问题的提出

3.1.2 脉冲压缩的解决方案

3.1.3 线性调频 (LFM) 信号

3.2 匹配滤波器设计

3.2.1 匹配滤波原理

3.2.2 LFM 匹配滤波

3.2.3 旁瓣抑制

3.3 FPGA 实现

3.3.1 脉冲压缩处理流程

3.3.2 时域匹配滤波实现

3.3.3 频域匹配滤波实现

3.3.4 关键设计要点

四、FFT 与频域分析

4.1 FFT 在雷达中的应用

4.1.1 为什么需要 FFT

4.1.2 DFT 与 FFT

4.1.3 Cooley-Tukey FFT 算法

4.1.4 多普勒处理

4.2 FPGA FFT IP 核使用

4.2.1 FFT IP 核特性

4.2.2 位宽管理

4.2.3 AXI4-Stream 接口

4.3 频域处理

4.3.1 频域滤波

4.3.2 多普勒谱图

4.3.3 FPGA 实现框架

4.3.4 性能指标

五、动目标检测 (MTD) 与 CFAR

5.1 MTD 原理

5.1.1 MTD 的作用

5.1.2 多普勒滤波器组

5.1.3 MTD 处理流程

5.1.4 距离 - 多普勒图

5.2 CFAR 算法

5.2.1 CFAR 基本原理

5.2.2 CA-CFAR 算法

5.2.3 其他 CFAR 算法

5.2.4 二维 CFAR

5.3 FPGA 实现

5.3.1 MTD 处理模块

5.3.2 CA-CFAR 检测模块

5.3.3 性能指标

六、FPGA 实现架构与优化

6.1 流水线架构设计

6.1.1 流水线的必要性

6.1.2 雷达信号处理流水线

6.1.3 流水线寄存器插入

6.2 内存优化

6.2.1 BRAM vs 分布式 RAM

6.2.2 内存访问优化