Ein FIR-Filter (Finite Impulse Response) ist ein Filter mit endlicher Einheitsimpulsantwort, auch als nichtrekursives Filter bekannt.

FIR-Filter besitzen strikt lineare Phasen-Frequenz-Eigenschaften, und ihre Einheitsimpulsantwort ist endlich, daher sind sie stabile Systeme und werden in der digitalen Kommunikation, der Bildverarbeitung und anderen Bereichen weit verbreitet eingesetzt.

FIR-Filter-Prinzip

FIR-Filter ist ein Filter mit endlicher Einheitsimpulsantwort. Die Direktform-Struktur ist wie folgt:

Der FIR-Filter ist im Wesentlichen die Faltung des Eingangssignals mit der Einheitsimpulsantwortfunktion, ausgedrückt wie folgt:

Der FIR-Filter hat die folgenden Eigenschaften:

  • (1) Die Antwort ist eine endlich lange Sequenz.
  • (2) Die Systemfunktion konvergiert für |z| > 0, alle Pole liegen bei z=0, und es ist ein kausales System.
  • (3) Strukturell ist er nicht rekursiv, ohne Rückkopplung vom Ausgang zum Eingang.
  • (4) Der Phasengang des Eingangssignals ist linear, weil die Koeffizienten der Antwortfunktion h(n) symmetrisch sind.
  • (5) Die relativen Phasendifferenzen zwischen den Frequenzkomponenten des Eingangssignals sind ebenfalls fest.
  • (6) Faltung im Zeitbereich entspricht der Multiplikation im Frequenzbereich, daher entspricht diese Faltung dem Verstärkungsfaktor zum Filtern jeder Frequenzkomponente im Spektrum. Einige Frequenzkomponenten bleiben erhalten, während andere gedämpft werden, wodurch der Filtereffekt erzielt wird.

Paralleles FIR-Filter-Design

Entwurfsbeschreibung

Das Eingangssignal ist ein gemischtes Sinussignal mit Frequenzen von 7.5 MHz und 250 KHz. Nach Durchlaufen des FIR-Filters wird das Hochfrequenzsignal 7.5 MHz entfernt, und nur das 250 KHz-Signal bleibt erhalten. Die Entwurfsparameter sind wie folgt:

输入频率:    7.5MHz 和 250KHz
采样频率:    50MHz
阻带:           1MHz ~ 6MHz
阶数:           15(N-1=15)

Aus der FIR-Filterstruktur ergibt sich, dass bei einer Ordnung von 15 die Implementierung 16 Multiplizierer, 15 Addierer und 15 Sätze Verzögerungsregister erfordert. Um die Daten des ersten Takts zu stabilisieren, kann ein weiterer Satz Verzögerungsregister verwendet werden, sodass insgesamt 16 Sätze Verzögerungsregister verwendet werden. Aufgrund der Symmetrie der FIR-Filterkoeffizienten kann die Anzahl der Multiplizierer halbiert werden, wobei insgesamt 8 Multiplizierer verwendet werden.

Paralleles Design bedeutet, dass die Multiplikation und Addition an den 16 verzögerten Datenelementen gleichzeitig innerhalb eines Taktzyklus durchgeführt werden und anschließend der gefilterte Wert taktgesteuert ausgegeben wird. Der Vorteil dieser Methode ist eine kurze Filterverzögerung, allerdings stellt sie relativ hohe Timing-Anforderungen.

Paralleles Design

Für den in diesem Design verwendeten Multiplizierer-Modulcode siehe den Multiplizierer im vorherigen Pipeline-Design.

Um eine schnelle Simulation zu ermöglichen, können Sie auch direkt das Multiplikationszeichen*verwenden, um die Multiplikationsoperation abzuschließen. Im Design wurde eine Makrodefinition SAFE_DESIGN hinzugefügt, um auszuwählen, welcher Multiplizierer verwendet werden soll.

Die FIR-Filterkoeffizienten können mit matlab erzeugt werden; Details siehe Anhang.

Beispiel

/***********************************************************
>> V201001 : Fs:50Mhz, fstop:1Mhz-6Mhz, order: 15
************************************************************/

`define SAFE_DESIGN
 
module fir_guide    (
    input                rstn,  // Reset, Low-aktiv
    input                clk,   // Betriebsfrequenz, d. h. Abtastfrequenz
    input                en,    // Gültigkeitssignal der Eingangsdaten
    input        [11:0]  xin,   // Eingangssignaldaten mit gemischten Frequenzen
    output               valid, // Gültigkeitssignal der Ausgangsdaten
    output       [28:0]  yout   // Ausgangsdaten, niederfrequentes Signal, d. h. 250KHz
    );
 
    //Daten-Enable-Verzögerung
    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 Sätze von Schieberegistern
    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] ; // Periodische Schiebeoperation
            end
        end
    end
 
   //Aufgrund der Symmetrie der FIR-Filterkoeffizienten sind nur 8 Multiplizierer erforderlich
   //(2) Koeffizienten sind symmetrisch; die ersten und letzten Daten aus den 16 Schieberegistern addieren
    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 Multiplizierer
    // Filterkoeffizienten, bereits um einen bestimmten Faktor verstärkt
    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
    // Pipeline-Multiplizierer
    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]), // Alle Ausgangsfreigaben sind exakt gleich
              .res        (mout[k])
            );
        end
    endgenerate
    wire valid_mult7     = valid_mult[7] ;
 
`else
    // Wenn die Timing-Anforderungen nicht streng sind, können Sie direkt das Multiplikationszeichen verwenden
    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) Akkumulation, 8 Gruppen von 25-Bit-Daten -> 1 Gruppe von 29-Bit-Daten
    // Datenvalid-Verzögerung
    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
    // Während der Addition über mehrere Zyklen pipelinen, um das Timing zu optimieren
    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
    // Das Akkumulationsergebnis in einem Schritt berechnen, aber in der Praxis ist das Timing sehr gefährlich
    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

Die Testbench ist wie folgt geschrieben. Ihre Hauptfunktion besteht darin, die Sinuswellen-Mischsignaldaten von 250KHz und 7.5MHz kontinuierlich und ohne Unterbrechung einzugeben. Die gemischten Eingangssignaldaten können auch von matlab erzeugt werden; siehe Anhang für Details.

Beispiel

`timescale 1ps/1ps
 
module test ;
   //Eingabe
    reg          clk ;
    reg          rst_n ;
    reg          en ;
    reg [11:0]   xin ;
    //Ausgabe
    wire         valid ;
    wire [28:0]  yout ;
 
    parameter    SIMU_CYCLE   = 64'd2000 ;  // 50MHz Abtastfrequenz
    parameter    SIN_DATA_NUM = 200 ;      // Simulationsperiode

//=====================================
// 50MHz clk-Erzeugung
    localparam   TCLK_HALF     = 10_000;
    initial begin
        clk = 1'b0 ;
        forever begin
            # TCLK_HALF ;
            clk = ~clk ;
        end
    end
 
//============================
// zurücksetzen und beenden
    initial begin
        rst_n = 1'b0 ;
        # 30   rst_n = 1'b1 ;
        # (TCLK_HALF * 2 * SIMU_CYCLE) ;
        $finish ;
    end
 
//=======================================
// Signaldaten in Register einlesen
    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  // Periodische Datenzufuhrsteuerung
                    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

Simulationsergebnisse

Aus den Simulationsergebnissen in der unten stehenden Abbildung geht hervor, dass das Signal nach dem FIR-Filter nur ein niederfrequentes Signal (250KHz) enthält und das hochfrequente Signal (7.5MHz) herausgefiltert wurde. Außerdem ist die Ausgangswellenform kontinuierlich und kann kontinuierlich ausgegeben werden.

Wie im roten Kreis gezeigt, ist jedoch der Beginn der Wellenform unregelmäßig. Vergrößern Sie diesen Teil.

Nach dem Vergrößern des Anfangs der Wellenform, wie in der unten stehenden Abbildung gezeigt, ist zu erkennen, dass die Zeitdauer der unregelmäßigen Wellenform, d. h. das Zeitintervall zwischen den beiden vertikalen Linien, 16 Taktzyklen beträgt.

Da die Daten seriell eingegeben werden und im Design 16 Sätze von Verzögerungsregistern verwendet werden, sollte der erste normale Punkt nach der Filterung um 16 Taktzyklen vom ersten Ausgabezeitpunkt der gefilterten Daten verzögert sein. Das heißt, das Datenausgabe-Gültigkeitssignal valid sollte um weitere 16 Taktzyklen verzögert werden, wodurch die Ausgangswellenform perfekter wird.

Anhang: Verwendung von MATLAB

Erzeugen von FIR-Filterkoeffizienten

Öffnen Sie MATLAB und geben Sie den Befehl im Befehlsfenster ein: fdatool.

Dann öffnet sich das folgende Fenster; stellen Sie die Parameter entsprechend dem FIR-Filter ein.

Die hier ausgewählte FIR-Implementierungsmethode ist Least-Squares (Methode der kleinsten Quadrate). Unterschiedliche Implementierungsmethoden erzeugen unterschiedliche Filtereffekte.

Klicken Sie auf Datei -> Export

Exportieren Sie die Filterparameter und speichern Sie sie in der Variablen coef, wie in der folgenden Abbildung gezeigt.

Zu diesem Zeitpunkt sollten die coef-Variablen Gleitkommadaten sein. Multiplizieren Sie sie mit einem bestimmten Faktor, um sie zu erweitern, und nehmen Sie dann ihre ungefähren Festkommadaten als FIR-Filterparameter im Design. Hier ist der Erweiterungsfaktor 2048, und die Ergebnisse sind wie folgt.

Erzeugen des gemischten Eingangssignals

Der Referenzcode zum Erzeugen des gemischten Eingangssignals mit MATLAB lautet wie folgt.

Das Signal ist vorzeichenlose Festkommadaten mit einer Bitbreite von 12 Bit, gespeichert in einer Dateicosx0p25m7p5m12bit.txt。

Beispiel

clear all;close all;clc;
%=======================================================
% Erzeugen von Cos-Wellen-Daten mit txt-Hex-Format
%=======================================================

fc          = 0.25e6 ;      %Mittenfrequenz
fn          = 7.5e6 ;       %Clutter-Frequenz
Fs          = 50e6 ;        %Abtastfrequenz
T           = 1/fc ;        %Signalperiode
Num         = Fs * T ;      %Anzahl der Signalabtastpunkte in einer Periode
t           = (0:Num-1)/Fs ;      %Diskrete Zeit
cosx        = cos(2*pi*fc*t) ;    %Mittenfrequenz-Sinussignal
cosn        = cos(2*pi*fn*t) ;    %Clutter-Signal
cosy        = mapminmax(cosx + cosn) ;     %Amplitude erweitert auf den Bereich (-1,1)
cosy_dig    = floor((2^11-1) * cosy + 2^11) ;     %Amplitude erweitert auf0~4095
fid         = fopen('cosx0p25m7p5m12bit.txt', 'wt') ;  %Datendatei schreiben
fprintf(fid, '%x\n', cosy_dig) ;
fclose(fid) ;
 
%Zeitbereichs-Wellenform
figure(1);
subplot(121);plot(t,cosx);hold on ;
plot(t,cosn) ;
subplot(122);plot(t,cosy_dig) ;
 
%Frequenzbereichs-Wellenform
fft_cosy    = fftshift(fft(cosy, Num)) ;
f_axis      = (-Num/2 : Num/2 - 1) * (Fs/Num) ;
figure(5) ;
plot(f_axis, abs(fft_cosy)) ;

Quellcode-Download

Herunterladen