El filtro FIR (Finite Impulse Response) es un filtro de respuesta de impulso unitario de duración finita, también denominado filtro no recursivo.
El filtro FIR tiene una estricta característica de frecuencia de fase lineal; además, su respuesta unitaria es de duración finita, por lo que es un sistema estable y se utiliza ampliamente en comunicaciones digitales, procesamiento de imágenes y otros campos.
Principio del filtro FIR
El filtro FIR es un filtro de respuesta de impulso unitario de duración finita. La estructura directa es la siguiente:

En esencia, el filtro FIR es la convolución de la señal de entrada con la función de respuesta de impulso unitario, cuya expresión es la siguiente:

El filtro FIR tiene las siguientes características:
- (1) La respuesta es una secuencia de duración finita.
- (2) La función del sistema converge cuando |z| > 0, todos los polos están en z=0, y pertenece a un sistema causal.
- (3) Estructuralmente es no recursivo, sin realimentación de salida a entrada.
- (4) La respuesta de fase de la señal de entrada es lineal, porque los coeficientes de la función de respuesta h(n) son simétricos.
- (5) La diferencia de fase relativa entre las distintas frecuencias de la señal de entrada también permanece fija e invariable.
- (6) La convolución en el dominio del tiempo equivale a la multiplicación en el dominio de la frecuencia; por lo tanto, esta convolución equivale a seleccionar los factores de ganancia de cada componente de frecuencia en el espectro. Algunos componentes de frecuencia se conservan y otros se atenúan, logrando así el efecto de filtrado.
Diseño de filtro FIR paralelo
Descripción del diseño
La señal mixta de ondas senoidales de entrada tiene frecuencias de 7.5MHz y 250 KHz. Después del filtro FIR, la señal de alta frecuencia de 7.5MHz se elimina y solo se conserva la señal de 250 KHz. Los parámetros de diseño son los siguientes:
输入频率: 7.5MHz 和 250KHz 采样频率: 50MHz 阻带: 1MHz ~ 6MHz 阶数: 15(N-1=15)
Según la estructura del filtro FIR, cuando el orden es 15, la implementación del FIR requiere 16 multiplicadores, 15 sumadores y 15 grupos de registros de retardo. Para estabilizar los datos del primer ciclo, se puede usar un grupo adicional de registros de retardo, es decir, un total de 16 grupos de registros de retardo. Debido a la simetría de los coeficientes del filtro FIR, la cantidad de multiplicadores se puede reducir a la mitad, es decir, se usan 8 multiplicadores.
El diseño paralelo consiste en realizar simultáneamente operaciones de multiplicación y suma sobre los 16 datos retardados en un solo ciclo de reloj, y luego generar el valor filtrado impulsado por el reloj. La ventaja de este método es que el retardo de filtrado es corto, pero tiene requisitos de temporización relativamente altos.
Diseño paralelo
El código del módulo multiplicador utilizado en el diseño puede consultarse en el multiplicador de diseño pipeline mencionado anteriormente.
Para facilitar una simulación rápida, también se puede usar directamente el operador de multiplicación*para realizar la operación de multiplicación. En el diseño se añade la definición de macro SAFE_DESIGN para seleccionar qué tipo de multiplicador utilizar.
Los coeficientes del filtro FIR se pueden generar con matlab; ver el apéndice para más detalles.
Ejemplo
>> V201001 : Fs:50Mhz, fstop:1Mhz-6Mhz, order: 15
************************************************************/
`define SAFE_DESIGN
module fir_guide (
input rstn, // reset, activo en bajo
input clk, // frecuencia de trabajo, es decir, frecuencia de muestreo
input en, // señal de datos de entrada válidos
input [11:0] xin, // datos de señal de entrada de frecuencia mixta
output valid, // señal de datos de salida válidos
output [28:0] yout // datos de salida, señal de baja frecuencia, es decir, 250KHz
);
//data en delay
reg [3:0] en_r ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
en_r[3:0] <= 'b0 ;
end
else begin
en_r[3:0] <= {en_r[2:0], en} ;
end
end
//(1) 16 grupos de registros de desplazamiento
reg [11:0] xin_reg[15:0];
reg [3:0] i, j ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
for (i=0; i<15; i=i+1) begin
xin_reg[i] <= 12'b0;
end
end
else if (en) begin
xin_reg[0] <= xin ;
for (j=0; j<15; j=j+1) begin
xin_reg[j+1] <= xin_reg[j] ; // operación de desplazamiento periódico
end
end
end
//Only 8 multipliers needed because of the symmetry of FIR filter coefficient
//(2) Coeficientes simétricos: los datos de los 16 registros de desplazamiento se suman entre el primero y el último
reg [12:0] add_reg[7:0];
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
for (i=0; i<8; i=i+1) begin
add_reg[i] <= 13'd0 ;
end
end
else if (en_r[0]) begin
for (i=0; i<8; i=i+1) begin
add_reg[i] <= xin_reg[i] + xin_reg[15-i] ;
end
end
end
//(3) 8 multiplicadores
// Coeficientes del filtro, ya amplificados por un cierto factor
wire [11:0] coe[7:0] ;
assign coe[0] = 12'd11 ;
assign coe[1] = 12'd31 ;
assign coe[2] = 12'd63 ;
assign coe[3] = 12'd104 ;
assign coe[4] = 12'd152 ;
assign coe[5] = 12'd198 ;
assign coe[6] = 12'd235 ;
assign coe[7] = 12'd255 ;
reg [24:0] mout[7:0];
`ifdef SAFE_DESIGN
// multiplicador pipeline
wire [7:0] valid_mult ;
genvar k ;
generate
for (k=0; k<8; k=k+1) begin
mult_man #(13, 12)
u_mult_paral (
.clk (clk),
.rstn (rstn),
.data_rdy (en_r[1]),
.mult1 (add_reg[k]),
.mult2 (coe[k]),
.res_rdy (valid_mult[k]), // todas las habilitaciones de salida son idénticas
.res (mout[k])
);
end
endgenerate
wire valid_mult7 = valid_mult[7] ;
`else
// si el requisito de temporización no es alto, se puede usar directamente el operador *
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
for (i=0 ; i<8; i=i+1) begin
mout[i] <= 25'b0 ;
end
end
else if (en_r[1]) begin
for (i=0 ; i<8; i=i+1) begin
mout[i] <= coe[i] * add_reg[i] ;
end
end
end
wire valid_mult7 = en_r[2];
`endif
//(4) Acumulación: 8 grupos de datos de 25 bits -> 1 grupo de datos de 29 bits
// retardo de datos válidos
reg [3:0] valid_mult_r ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
valid_mult_r[3:0] <= 'b0 ;
end
else begin
valid_mult_r[3:0] <= {valid_mult_r[2:0], valid_mult7} ;
end
end
`ifdef SAFE_DESIGN
// en la operación de suma, se segmenta en múltiples ciclos en pipeline para optimizar la temporización
reg [28:0] sum1 ;
reg [28:0] sum2 ;
reg [28:0] yout_t ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
sum1 <= 29'd0 ;
sum2 <= 29'd0 ;
yout_t <= 29'd0 ;
end
else if(valid_mult7) begin
sum1 <= mout[0] + mout[1] + mout[2] + mout[3] ;
sum2 <= mout[4] + mout[5] + mout[6] + mout[7] ;
yout_t <= sum1 + sum2 ;
end
end
`else
// calcular el resultado acumulado en un paso, pero en la práctica la temporización es muy peligrosa
reg signed [28:0] sum ;
reg signed [28:0] yout_t ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
sum <= 29'd0 ;
yout_t <= 29'd0 ;
end
else if (valid_mult7) begin
sum <= mout[0] + mout[1] + mout[2] + mout[3] + mout[4] + mout[5] + mout[6] + mout[7];
yout_t <= sum ;
end
end
`endif
assign yout = yout_t ;
assign valid = valid_mult_r[0];
endmodule
testbench
El testbench se escribe de la siguiente manera; su función principal es introducir de forma continua e ininterrumpida los datos de la señal mixta de ondas senoidales de 250KHz y 7.5MHz. Los datos de la señal mixta de entrada también se pueden generar con matlab; ver el apéndice.
Ejemplo
module test ;
//input
reg clk ;
reg rst_n ;
reg en ;
reg [11:0] xin ;
//output
wire valid ;
wire [28:0] yout ;
parameter SIMU_CYCLE = 64'd2000 ; // frecuencia de muestreo de 50MHz
parameter SIN_DATA_NUM = 200 ; // período de simulación
//=====================================
// 50MHz clk generating
localparam TCLK_HALF = 10_000;
initial begin
clk = 1'b0 ;
forever begin
# TCLK_HALF ;
clk = ~clk ;
end
end
//============================
// reset and finish
initial begin
rst_n = 1'b0 ;
# 30 rst_n = 1'b1 ;
# (TCLK_HALF * 2 * SIMU_CYCLE) ;
$finish ;
end
//=======================================
// read signal data into register
reg [11:0] stimulus [0: SIN_DATA_NUM-1] ;
integer i ;
initial begin
$readmemh("../tb/cosx0p25m7p5m12bit.txt", stimulus) ;
i = 0 ;
en = 0 ;
xin = 0 ;
# 200 ;
forever begin
@(negedge clk) begin
en = 1'b1 ;
xin = stimulus[i] ;
if (i == SIN_DATA_NUM-1) begin // control de entrada de datos de forma periódica
i = 0 ;
end
else begin
i = i + 1 ;
end
end
end
end
fir_guide u_fir_paral (
.xin (xin),
.clk (clk),
.en (en),
.rstn (rst_n),
.valid (valid),
.yout (yout));
endmodule
Resultados de la simulación
A partir del resultado de la simulación en la siguiente figura, se puede ver que la señal después del filtro FIR contiene solo una señal de baja frecuencia (250KHz), y la señal de alta frecuencia (7.5MHz) ha sido eliminada. Además, la forma de onda de salida es continua y puede emitirse de forma sostenida.
Sin embargo, como se muestra en el círculo rojo, la parte inicial de la forma de onda presenta un estado irregular; se amplía esta parte.

Después de ampliar el extremo inicial de la forma de onda, como se muestra a continuación, se observa que el período de la forma de onda irregular, es decir, el intervalo entre las dos líneas verticales, es de 16 ciclos de reloj.
Debido a que los datos se introducen en serie y en el diseño se utilizan 16 grupos de registros de retardo, el primer punto normal después del filtrado debe retrasarse 16 ciclos de reloj respecto al momento de salida del primer dato filtrado. Es decir, la señal de datos de salida válidos (valid) debe retrasarse 16 ciclos de reloj adicionales para que la forma de onda de salida sea más perfecta.

Apéndice: uso de matlab
Generación de los coeficientes del filtro FIR
Abra matlab y escriba el comando `fdatool` en la ventana de comandos.
A continuación se abrirá la siguiente ventana; configure los parámetros según el filtro FIR.
Aquí se selecciona el método de mínimos cuadrados (Least-squares) para la implementación del FIR; diferentes métodos de implementación producen diferentes efectos de filtrado.

Haga clic en File -> Export
Exporte los parámetros del filtro y guárdelos en la variable `coef`, como se muestra en la siguiente figura.

En este momento, la variable `coef` debe contener datos de tipo flotante. Multiplíquela por un cierto factor para ampliarla y luego tome sus datos aproximados de tipo punto fijo como parámetros del filtro FIR en el diseño. Aquí se toma como factor de ampliación 2048; el resultado se muestra a continuación.

Generación de la señal mixta de entrada
El siguiente es el código de referencia para generar la señal mixta de entrada con matlab.La señal son datos de punto fijo sin signo, con un ancho de bits de 12bit, almacenados en un archivo.cosx0p25m7p5m12bit.txt。
Ejemplo
%=======================================================
% generating a cos wave data with txt hex format
%=======================================================
fc = 0.25e6 ; %frecuencia central
fn = 7.5e6 ; %frecuencia de la señal interferente
Fs = 50e6 ; %frecuencia de muestreo
T = 1/fc ; %período de la señal
Num = Fs * T ; %número de puntos de muestreo de la señal en un período
t = (0:Num-1)/Fs ; %tiempo discreto
cosx = cos(2*pi*fc*t) ; %señal senoidal de la frecuencia central
cosn = cos(2*pi*fn*t) ; %señal de interferencia
cosy = mapminmax(cosx + cosn) ; %La amplitud se amplía a (-1,1) entre
cosy_dig = floor((2^11-1) * cosy + 2^11) ; %La amplitud se amplía a0~4095
fid = fopen('cosx0p25m7p5m12bit.txt', 'wt') ; %escribir archivo de datos
fprintf(fid, '%x\n', cosy_dig) ;
fclose(fid) ;
%forma de onda en el dominio del tiempo
figure(1);
subplot(121);plot(t,cosx);hold on ;
plot(t,cosn) ;
subplot(122);plot(t,cosy_dig) ;
%forma de onda en el dominio de la frecuencia
fft_cosy = fftshift(fft(cosy, Num)) ;
f_axis = (-Num/2 : Num/2 - 1) * (Fs/Num) ;
figure(5) ;
plot(f_axis, abs(fft_cosy)) ;
Descarga del código fuente
Download