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

`timescale 1ps/1ps
 
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

clear all;close all;clc;
%=======================================================
% 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