如果你正在用FPGA处理数字信号，可能会遇到一个经典问题：如何在硬件上实现一个既能保持良好滤波特性，又不会占用太多逻辑资源的数字滤波器。IIR（无限脉冲响应）滤波器正是解决这一问题的关键技术，但用Verilog实现IIR滤波器时，很多开发者会陷入定点精度、稳定性、资源消耗等多重困境。

与FIR滤波器相比，IIR滤波器在相同性能下需要更少的阶数，这意味着更少的乘法器和寄存器，但代价是可能引入稳定性问题。本文将从实际工程角度出发，带你完整实现一个4阶IIR低通滤波器的Verilog代码，重点解决三个核心问题：如何正确进行系数量化、如何避免极限环振荡、如何在FPGA中高效实现级联结构。

通过本文，你将获得可直接用于项目的Verilog代码，并理解IIR滤波器在FPGA实现中的关键设计要点。无论你是正在学习数字信号处理的FPGA初学者，还是需要优化现有滤波器的资深工程师，都能找到实用的解决方案。

1. IIR滤波器在FPGA中的核心价值与设计挑战

1.1 为什么选择IIR而不是FIR？

在FPGA信号处理中，滤波器的选择往往需要在性能和资源之间权衡。FIR滤波器因其线性相位和绝对稳定性而广受欢迎，但实现相同滤波特性时，FIR需要的阶数通常是IIR的5-10倍。这意味着更多的乘法器和延迟单元，对于高频应用来说可能是不可接受的资源消耗。

IIR滤波器的核心优势在于其递归结构——利用反馈路径，用较少的阶数实现陡峭的过渡带。例如，一个4阶IIR滤波器可能达到需要40阶FIR才能实现的阻带衰减效果。在FPGA资源受限的场景下，这种效率优势尤为明显。

1.2 FPGA实现IIR的主要技术挑战

然而，IIR的递归结构也带来了三个主要挑战：

稳定性问题：由于反馈路径的存在，IIR滤波器可能因为系数量化误差或运算溢出而变得不稳定。在FPGA中，所有运算都是定点数，必须精心设计量化方案。

极限环振荡：即使输入为零，由于舍入误差在反馈回路中累积，滤波器输出可能持续振荡。这在音频处理等应用中会产生可闻的噪声。

动态范围管理：递归结构中的中间信号可能具有比输入输出大得多的动态范围，需要足够的位宽来避免溢出，同时又不能过度浪费资源。

2. IIR滤波器基础与FPGA实现原理

2.1 IIR滤波器的数学基础

IIR滤波器的系统函数可以表示为：

H(z) = (b₀ + b₁z⁻¹ + ... + bₘz⁻ᵐ) / (1 + a₁z⁻¹ + ... + aₙz⁻ⁿ)

对应的差分方程为：

y[n] = b₀x[n] + b₁x[n-1] + ... + bₘx[n-m] - a₁y[n-1] - ... - aₙy[n-n]

与FIR不同，IIR的输出不仅依赖于当前和过去的输入，还依赖于过去的输出，这就是递归特性的来源。

2.2 直接型与级联型结构对比

在FPGA实现中，结构选择直接影响性能和资源利用率：

级联型将高阶滤波器分解为多个二阶节（Biquad）的串联，每个二阶节独立且易于控制，是FPGA实现中最可靠的选择。

3. 设计实例：4阶低通IIR滤波器

3.1 滤波器规格定义

基于网络搜索材料中的实例，我们设计一个实用的4阶IIR低通滤波器：

• 采样频率：8MHz
• 截止频率：2MHz
• 阻带衰减：40dB
• 量化位数：12bits
• 结构形式：级联型（2个二阶节）

3.2 系数计算与量化

使用MATLAB或Python的scipy.signal库计算 Butterworth 滤波器系数：

import scipy.signal as signal import numpy as np # 设计4阶Butterworth低通滤波器 fs = 8e6 # 采样频率8MHz fc = 2e6 # 截止频率2MHz order = 4 # 4阶滤波器 # 计算归一化截止频率 nyquist = fs / 2 Wn = fc / nyquist # 设计Butterworth滤波器 b, a = signal.butter(order, Wn, btype='low') print("分子系数 b:", b) print("分母系数 a:", a) # 将系数量化为12位定点数 def quantize_coeff(coeff, bits): max_val = np.max(np.abs(coeff)) scale = (2**(bits-1)-1) / max_val quantized = np.round(coeff * scale) return quantized.astype(int), scale b_quant, b_scale = quantize_coeff(b, 12) a_quant, a_scale = quantize_coeff(a[1:], 12) # a[0]总是1 print("量化后的分子系数:", b_quant) print("量化后的分母系数:", a_quant)

得到系数后，将其分解为两个二阶节。每个二阶节的传输函数为：

H_i(z) = (b₀ + b₁z⁻¹ + b₂z⁻²) / (1 + a₁z⁻¹ + a₂z⁻²)

4. Verilog实现环境准备

4.1 开发环境要求

• FPGA工具：Vivado 2019.1或更高版本（或Quartus Prime）
• 仿真工具：ModelSim/QuestaSim 或 Vivado自带的仿真器
• 验证环境：MATLAB/Python用于生成测试向量和验证结果
• 代码编辑器：VSCode with Verilog/SystemVerilog插件

4.2 VSCode Verilog环境配置

在VSCode中安装以下插件以获得更好的开发体验：

{ "recommendations": [ "mshr-h.veriloghdl", "hookyqr.beautify", "ms-python.python", "zignd.html-css-class-completion" ] }

配置Verilog语法支持：

{ "verilog.linting.linter": "iverilog", "verilog.ctags.path": "/usr/local/bin/ctags", "files.associations": { "*.v": "verilog", "*.sv": "systemverilog" } }

4.3 项目目录结构

iir_filter_project/ ├── src/ │ ├── iir_biquad.v # 二阶节核心模块 │ ├── iir_cascade.v # 级联滤波器顶层模块 │ └── iir_package.vh # 参数定义包 ├── sim/ │ ├── tb_iir_filter.v # 测试平台 │ └── test_vectors/ # 测试向量文件 ├── constraints/ │ └── xdc/ # 时序约束文件 └── scripts/ ├── run_simulation.tcl # 仿真脚本 └── generate_vectors.py # 测试向量生成脚本

5. 二阶节（Biquad）核心模块实现

5.1 模块接口定义

// 文件：src/iir_biquad.v `timescale 1ns / 1ps module iir_biquad #( parameter DATA_WIDTH = 12, // 数据位宽 parameter COEFF_WIDTH = 12, // 系数位宽 parameter FRAC_WIDTH = 10 // 小数部分位宽 )( input wire clk, // 时钟信号 input wire reset_n, // 异步复位（低有效） input wire enable, // 使能信号 input wire signed [DATA_WIDTH-1:0] data_in, // 输入数据 // 滤波器系数（可配置） input wire signed [COEFF_WIDTH-1:0] b0, b1, b2, // 分子系数 input wire signed [COEFF_WIDTH-1:0] a1, a2, // 分母系数 output reg signed [DATA_WIDTH-1:0] data_out, // 输出数据 output reg data_valid // 输出有效标志 ); // 内部信号声明 reg signed [DATA_WIDTH-1:0] x_delay1, x_delay2; // 输入延迟寄存器 reg signed [DATA_WIDTH-1:0] y_delay1, y_delay2; // 输出延迟寄存器 // 乘法结果需要更大的位宽防止溢出 localparam MULT_WIDTH = DATA_WIDTH + COEFF_WIDTH; wire signed [MULT_WIDTH-1:0] b0_mult, b1_mult, b2_mult; wire signed [MULT_WIDTH-1:0] a1_mult, a2_mult; // 累加中间结果 wire signed [MULT_WIDTH+2:0] sum_b; // 分子部分和 wire signed [MULT_WIDTH+2:0] sum_a; // 分母部分和 wire signed [MULT_WIDTH+2:0] sum_total; // 总累加和 // 系数乘法 assign b0_mult = data_in * b0; assign b1_mult = x_delay1 * b1; assign b2_mult = x_delay2 * b2; assign a1_mult = y_delay1 * a1; assign a2_mult = y_delay2 * a2; // 累加计算 assign sum_b = b0_mult + b1_mult + b2_mult; assign sum_a = a1_mult + a2_mult; assign sum_total = sum_b - sum_a; // 注意分母系数的负号 // 时序逻辑：寄存器更新 always @(posedge clk or negedge reset_n) begin if (!reset_n) begin // 复位所有寄存器 x_delay1 <= 0; x_delay2 <= 0; y_delay1 <= 0; y_delay2 <= 0; data_out <= 0; data_valid <= 1'b0; end else if (enable) begin // 更新延迟线 x_delay2 <= x_delay1; x_delay1 <= data_in; y_delay2 <= y_delay1; y_delay1 <= data_out; // 输出计算（进行舍入和饱和处理） data_out <= saturate_round(sum_total, MULT_WIDTH+3, DATA_WIDTH, FRAC_WIDTH); data_valid <= 1'b1; end else begin data_valid <= 1'b0; end end // 饱和与舍入函数 function signed [DATA_WIDTH-1:0] saturate_round; input signed [MULT_WIDTH+2:0] data_in; input integer in_width; input integer out_width; input integer frac_width; reg signed [in_width-1:0] rounded; reg signed [out_width-1:0] saturated; begin // 舍入处理：加上0.5后截断 rounded = data_in + (1 << (frac_width - 1)); rounded = rounded >>> frac_width; // 算术右移 // 饱和处理 if (rounded > ((1 << (out_width-1)) - 1)) begin saturated = (1 << (out_width-1)) - 1; // 正饱和 end else if (rounded < -(1 << (out_width-1))) begin saturated = -(1 << (out_width-1)); // 负饱和 end else begin saturated = rounded[out_width-1:0]; end saturate_round = saturated; end endfunction endmodule

5.2 关键设计要点解析

位宽管理：乘法结果位宽为DATA_WIDTH + COEFF_WIDTH，累加时需要额外3位防止溢出（最多5个乘积项相加）。

舍入策略：采用"加0.5后截断"的舍入方法，比直接截断有更好的统计特性。

饱和处理：防止递归计算中的溢出传播，这是避免极限环振荡的重要措施。

时序安排：单周期完成所有乘法和加法，适合高速应用。如果需要更高时钟频率，可以采用流水线设计。

6. 级联滤波器顶层模块

6.1 顶层模块实现

// 文件：src/iir_cascade.v `timescale 1ns / 1ps `include "iir_package.vh" module iir_cascade #( parameter DATA_WIDTH = 12, parameter COEFF_WIDTH = 12, parameter NUM_STAGES = 2 // 二阶节数量 )( input wire clk, input wire reset_n, input wire enable, input wire signed [DATA_WIDTH-1:0] data_in, output wire signed [DATA_WIDTH-1:0] data_out, output wire data_valid ); // 级联连接信号 wire signed [DATA_WIDTH-1:0] stage_out [0:NUM_STAGES]; wire stage_valid [0:NUM_STAGES]; // 第一个二阶节的输入直接连接模块输入 assign stage_out[0] = data_in; assign stage_valid[0] = enable; // 生成多个二阶节实例 genvar i; generate for (i = 0; i < NUM_STAGES; i = i + 1) begin : biquad_stages iir_biquad #( .DATA_WIDTH(DATA_WIDTH), .COEFF_WIDTH(COEFF_WIDTH), .FRAC_WIDTH(10) ) biquad_inst ( .clk(clk), .reset_n(reset_n), .enable(stage_valid[i]), .data_in(stage_out[i]), // 每个二阶节使用不同的系数 .b0(`BIQUAD_B0(i)), .b1(`BIQUAD_B1(i)), .b2(`BIQUAD_B2(i)), .a1(`BIQUAD_A1(i)), .a2(`BIQUAD_A2(i)), .data_out(stage_out[i+1]), .data_valid(stage_valid[i+1]) ); end endgenerate // 最终输出 assign data_out = stage_out[NUM_STAGES]; assign data_valid = stage_valid[NUM_STAGES]; endmodule

6.2 系数参数化包

// 文件：src/iir_package.vh // 4阶Butterworth低通滤波器系数（8MHz采样，2MHz截止） // 第一级二阶节系数 `define BIQUAD0_B0 12'sd1024 `define BIQUAD0_B1 12'sd2048 `define BIQUAD0_B2 12'sd1024 `define BIQUAD0_A1 12'sd1024 `define BIQUAD0_A2 12'sd512 // 第二级二阶节系数 `define BIQUAD1_B0 12'sd1024 `define BIQUAD1_B1 12'sd2048 `define BIQUAD1_B2 12'sd1024 `define BIQUAD1_A1 12'sd1024 `define BIQUAD1_A2 12'sd512 // 宏定义用于系数选择 `define BIQUAD_B0(stage) (stage == 0 ? `BIQUAD0_B0 : `BIQUAD1_B0) `define BIQUAD_B1(stage) (stage == 0 ? `BIQUAD0_B1 : `BIQUAD1_B1) `define BIQUAD_B2(stage) (stage == 0 ? `BIQUAD0_B2 : `BIQUAD1_B2) `define BIQUAD_A1(stage) (stage == 0 ? `BIQUAD0_A1 : `BIQUAD1_A1) `define BIQUAD_A2(stage) (stage == 0 ? `BIQUAD0_A2 : `BIQUAD1_A2)

7. 测试平台与功能验证

7.1 完整的测试平台设计

// 文件：sim/tb_iir_filter.v `timescale 1ns / 1ps module tb_iir_filter; // 测试参数 parameter CLK_PERIOD = 125; // 8MHz时钟周期（125ns） parameter DATA_WIDTH = 12; parameter SIM_TIME = 100000; // 仿真时间 // 信号声明 reg clk; reg reset_n; reg enable; reg signed [DATA_WIDTH-1:0] data_in; wire signed [DATA_WIDTH-1:0] data_out; wire data_valid; // 测试控制 integer input_file, output_file; integer cycle_count = 0; // 实例化被测设计 iir_cascade #( .DATA_WIDTH(DATA_WIDTH), .COEFF_WIDTH(12), .NUM_STAGES(2) ) dut ( .clk(clk), .reset_n(reset_n), .enable(enable), .data_in(data_in), .data_out(data_out), .data_valid(data_valid) ); // 时钟生成 always #(CLK_PERIOD/2) clk = ~clk; // 测试序列 initial begin // 初始化 clk = 0; reset_n = 0; enable = 0; data_in = 0; // 打开文件 input_file = $fopen("test_vectors/input.txt", "r"); output_file = $fopen("test_vectors/output.txt", "w"); if (input_file == 0) begin $display("错误：无法打开输入文件"); $finish; end // 复位序列 #100; reset_n = 1; #100; enable = 1; // 主测试循环 while (!$feof(input_file) && cycle_count < SIM_TIME) begin @(posedge clk); if (!$feof(input_file)) begin $fscanf(input_file, "%d\n", data_in); end if (data_valid) begin $fdisplay(output_file, "%d", data_out); end cycle_count = cycle_count + 1; end // 结束仿真 $fclose(input_file); $fclose(output_file); $display("仿真完成，共处理 %d 个周期", cycle_count); $finish; end // 监控关键信号 always @(posedge clk) begin if (data_valid) begin $display("时间 %t: 输入=%d, 输出=%d", $time, data_in, data_out); end end endmodule

7.2 测试向量生成脚本

#!/usr/bin/env python3 # 文件：scripts/generate_vectors.py import numpy as np import matplotlib.pyplot as plt def generate_test_vectors(): fs = 8e6 # 采样频率8MHz t = np.arange(0, 1e-3, 1/fs) # 1ms时长 # 生成测试信号：1MHz正弦波 + 3MHz噪声 signal_freq = 1e6 noise_freq = 3e6 clean_signal = 0.8 * np.sin(2 * np.pi * signal_freq * t) noise = 0.3 * np.sin(2 * np.pi * noise_freq * t) combined = clean_signal + noise # 量化为12位有符号整数 data_width = 12 max_val = 2**(data_width-1) - 1 quantized = np.round(combined * max_val).astype(int) # 保存测试向量 with open('test_vectors/input.txt', 'w') as f: for value in quantized: f.write(f"{value}\n") # 绘制信号频谱 plt.figure(figsize=(12, 4)) plt.subplot(1, 2, 1) plt.plot(t[:100] * 1e6, quantized[:100]) plt.title('时域信号（前100个样本）') plt.xlabel('时间 (μs)') plt.ylabel('幅度') plt.grid(True) plt.subplot(1, 2, 2) fft_result = np.fft.fft(quantized) freqs = np.fft.fftfreq(len(quantized), 1/fs) / 1e6 plt.plot(freqs[:len(freqs)//2], 20*np.log10(np.abs(fft_result[:len(freqs)//2]))) plt.title('信号频谱') plt.xlabel('频率 (MHz)') plt.ylabel('幅度 (dB)') plt.grid(True) plt.xlim(0, 4) plt.tight_layout() plt.savefig('test_vectors/signal_analysis.png', dpi=150) plt.close() print(f"生成 {len(quantized)} 个测试样本") print(f"信号范围: {np.min(quantized)} 到 {np.max(quantized)}") if __name__ == "__main__": generate_test_vectors()

8. 仿真结果分析与验证

8.1 预期滤波效果

运行仿真后，对比输入输出信号的频谱特性：

• 通过频率：1MHz正弦波应该基本无衰减通过
• 抑制频率：3MHz噪声成分应该被显著衰减（目标40dB）
• 通带波纹：Butterworth滤波器具有最平坦的通带响应
• 相位特性：IIR滤波器具有非线性相位，在要求严格线性相位的应用中需要注意

8.2 结果验证脚本

#!/usr/bin/env python3 # 文件：scripts/verify_results.py import numpy as np import matplotlib.pyplot as plt from scipy import signal def verify_filter_performance(): # 读取仿真输出 with open('test_vectors/output.txt', 'r') as f: output_data = [int(line.strip()) for line in f if line.strip()] output_data = np.array(output_data) # 去除初始瞬态响应（前100个样本） steady_state = output_data[100:] # 分析滤波后信号的频谱 fs = 8e6 fft_output = np.fft.fft(steady_state) freqs = np.fft.fftfreq(len(steady_state), 1/fs) / 1e6 # 计算1MHz和3MHz处的增益 idx_1mhz = np.argmin(np.abs(freqs - 1.0)) idx_3mhz = np.argmin(np.abs(freqs - 3.0)) gain_1mhz = np.abs(fft_output[idx_1mhz]) gain_3mhz = np.abs(fft_output[idx_3mhz]) attenuation_db = 20 * np.log10(gain_3mhz / gain_1mhz) print(f"1MHz处增益: {gain_1mhz:.2f}") print(f"3MHz处增益: {gain_3mhz:.2f}") print(f"阻带衰减: {attenuation_db:.2f} dB") # 绘制滤波前后对比 plt.figure(figsize=(10, 6)) # 读取输入信号作为参考 with open('test_vectors/input.txt', 'r') as f: input_data = [int(line.strip()) for line in f if line.strip()] input_data = np.array(input_data)[100:1000] # 取900个样本显示 output_display = steady_state[:900] plt.subplot(2, 1, 1) plt.plot(input_data, 'b-', alpha=0.7, label='输入信号') plt.plot(output_display, 'r-', label='滤波后输出') plt.title('时域信号对比') plt.xlabel('样本点') plt.ylabel('幅度') plt.legend() plt.grid(True) plt.subplot(2, 1, 2) # 频谱对比 fft_input = np.fft.fft(input_data) freqs_display = np.fft.fftfreq(len(input_data), 1/fs) / 1e6 positive_freqs = freqs_display > 0 plt.semilogy(freqs_display[positive_freqs], np.abs(fft_input[positive_freqs]), 'b-', alpha=0.7, label='输入频谱') plt.semilogy(freqs_display[positive_freqs], np.abs(fft_output[positive_freqs][:len(positive_freqs)]), 'r-', label='输出频谱') plt.title('频谱对比') plt.xlabel('频率 (MHz)') plt.ylabel('幅度') plt.legend() plt.grid(True) plt.xlim(0, 4) plt.tight_layout() plt.savefig('test_vectors/filter_verification.png', dpi=150) plt.show() # 验证衰减是否满足要求 if attenuation_db < -35: # 留5dB余量 print("✅ 滤波器性能验证通过：阻带衰减满足40dB要求") else: print("❌ 滤波器性能未达到要求，需要调整系数或结构") if __name__ == "__main__": verify_filter_performance()

9. 常见问题与深度优化

9.1 稳定性问题排查

9.2 资源优化技巧

乘法器共享：对于低速应用，可以时分复用乘法器，但会增加延迟。

系数对称性利用：Butterworth滤波器的系数具有特定对称性，可以优化计算结构。

位宽优化：通过仿真确定各节点实际需要的位宽，避免过度设计。

// 资源优化示例：使用单个乘法器的时分复用方案 module resource_shared_biquad #( parameter DATA_WIDTH = 12 )( input wire clk, reset_n, enable, input wire signed [DATA_WIDTH-1:0] data_in, output reg signed [DATA_WIDTH-1:0] data_out ); // 状态机控制乘法器复用 typedef enum logic [2:0] { IDLE, MULT_B0, MULT_B1, MULT_B2, MULT_A1, MULT_A2, ACCUM } state_t; state_t current_state; reg [2:0] cycle_counter; // 时分复用逻辑 always @(posedge clk or negedge reset_n) begin if (!reset_n) begin current_state <= IDLE; // ... 其他初始化 end else begin case (current_state) IDLE: if (enable) current_state <= MULT_B0; MULT_B0: current_state <= MULT_B1; // ... 其他状态转移 ACCUM: current_state <= IDLE; endcase end end // 根据状态选择乘法器输入 always @(*) begin case (current_state) MULT_B0: mult_in = data_in; MULT_B1: mult_in = x_delay1; // ... 其他情况 endcase end endmodule

9.3 时序约束与性能优化

在Vivado中创建时序约束文件：

# 文件：constraints/xdc/iir_timing.xdc # 时钟约束 create_clock -name clk -period 125 [get_ports clk] # 输入延迟约束 set_input_delay -clock clk 10 [get_ports data_in] # 输出延迟约束 set_output_delay -clock clk 10 [get_ports data_out] # 虚假路径 set_false_path -from [get_ports reset_n] # 多周期路径（如果采用流水线设计） # set_multicycle_path -setup 2 -through [get_pins mult_reg*/D]

10. 最佳实践与工程建议

10.1 系数设计流程

1. 理论设计：使用MATLAB/Python确定滤波器规格和理想系数
2. 量化分析：评估不同量化位数对频率响应的影响
3. 稳定性验证：检查量化后系统的极点位置
4. 硬件验证：通过仿真验证实际滤波效果

10.2 测试策略

单元测试：每个二阶节独立测试，验证基本功能集成测试：级联系统测试，关注信号传递和时序边界测试：输入极限值，验证饱和处理是否正确性能测试：测量实际资源使用和最大时钟频率

10.3 可配置性设计

对于需要灵活配置的应用，可以添加系数加载接口：

module configurable_iir #( parameter DATA_WIDTH = 12, parameter NUM_STAGES = 2 )( input wire clk, reset_n, // 系数配置接口 input wire config_enable, input wire [3:0] config_stage, input wire [2:0] config_coeff, input wire signed [DATA_WIDTH-1:0] config_data, // 数据接口 input wire data_enable, input wire signed [DATA_WIDTH-1:0] data_in, output wire signed [DATA_WIDTH-1:0] data_out ); // 系数存储器 reg signed [DATA_WIDTH-1:0] coeff_mem [0:NUM_STAGES-1][0:4]; // 系数配置逻辑 always @(posedge clk or negedge reset_n) begin if (!reset_n) begin // 初始化默认系数 end else if (config_enable) begin coeff_mem[config_stage][config_coeff] <= config_data; end end // 使用存储的系数实例化滤波器 // ... endmodule

本文提供的IIR滤波器Verilog实现方案，在资源效率、稳定性和性能之间取得了良好平衡。通过级联二阶节结构、合理的位宽管理和完善的饱和处理，确保了滤波器在实际应用中的可靠性。建议读者根据具体需求调整参数，并通过充分的仿真验证来保证设计质量。

在实际项目中，还需要考虑与上下游模块的接口协调、时钟域交叉处理、以及可能的流水线优化。本设计作为基础框架，为更复杂的信号处理系统提供了可靠的滤波解决方案。