Serielles FIR-Filter-Design

Entwurfsbeschreibung

Die Entwurfsparameter sind unverändert und stimmen mit den Parametern des parallelen FIR-Filters überein. Das heißt, bei den gemischten Sinuswellen-Eingangssignalen mit Frequenzen von 7.5 MHz und 250 KHz wird nach dem Durchlaufen des FIR-Filters das Hochfrequenzsignal bei 7.5 MHz herausgefiltert, sodass nur das 250 KHz-Signal übrig bleibt.

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

Im seriellen Entwurf werden die 16 verzögerten Datenabtastwerte innerhalb von 16 Taktzyklen sequenziell im Zeitmultiplexverfahren durch Multiplikations- und Additionsoperationen verarbeitet und anschließend der gefilterte Wert unter Taktsteuerung ausgegeben. Unter Berücksichtigung der Symmetrie der FIR-Filterkoeffizienten kann der Zeitraum zur Berechnung eines gefilterten Ausgangswerts auf 8 Zyklen reduziert werden. Im seriellen Entwurf wird pro Zyklus nur eine Multiplikationsoperation durchgeführt, sodass im Entwurf nur ein Multiplizierer benötigt wird. Zu diesem Zeitpunkt müssen alle 8 Taktzyklen gültige Daten eingegeben werden. Um jedoch die Korrektheit der Ausgangssignalfrequenz sicherzustellen, muss der Arbeitstakt das 8-Fache der Abtastfrequenz betragen, d. h. 400 MHz. Der Vorteil dieser Methode ist der geringe Ressourcenverbrauch, aber sie erfordert eine hohe Arbeitsfrequenz und die Daten können nicht kontinuierlich ausgegeben werden.

Serieller Entwurf

Für den im Entwurf verwendeten Multiplizierer-Modulcode siehe den Multiplizierer aus dem vorherigen Pipeline-Entwurf.

Für eine bequeme und schnelle Simulation kann auch direkt das Multiplikationszeichen verwendet werden*, um die Multiplikationsoperation auszuführen. Im Entwurf wird eine Makrodefinition SAFE_DESIGN hinzugefügt, um auszuwählen, welcher Multiplizierer verwendet werden soll.

Die FIR-Filterkoeffizienten können mit MATLAB generiert werden; Details siehe Anhang.

Beispiel

/**********************************************************
>> Beschreibung : FIR-Studie mit serieller Technik
>> V190403 : Fs:50Mhz, fstop:1-6Mhz, order:16, sys clk:400MHz
***********************************************************/

`define SAFE_DESIGN
 
module fir_serial_low(
    input                rstn,
    input                clk,   // Arbeitstakt des Systems, 400MHz
    input                en ,   // Gültigkeitssignal der Eingangsdaten
    input        [11:0]  xin,   // Eingangsdaten des Mischfrequenzsignals
    output               valid, // Gültigkeitssignal der Ausgangsdaten
    output       [28:0]  yout   // Ausgangsdaten
    );
 
   //Verzögerung der Eingabedaten-Freigabe
    reg [11:0]            en_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            en_r[11:0]      <= 'b0 ;
        end
        else begin
            en_r[11:0]      <= {en_r[10:0], en} ;
        end
    end
 
    //FIR-Koeffizient
    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 ;
 
    //(1) Abschnitt zum Verschieben der Eingabedaten
    reg [2:0]            cnt ;
    integer              i, j ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            cnt <= 3'b0 ;
        end
        else if (en || cnt != 0) begin
            cnt <= cnt + 1'b1 ;    //8-Zyklen-Zählung
        end
    end
 
    reg [11:0]           xin_reg[15:0];
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            for (i=0; i<16; i=i+1) begin
                xin_reg[i]  <= 12'b0;
            end
        end
        else if (cnt == 3'd0 && en) begin    //Gültige Daten einmal alle 8 Zyklen lesen
            xin_reg[0] <= xin ;
            for (j=0; j<15; j=j+1) begin
                xin_reg[j+1] <= xin_reg[j] ; // Datenverschiebung
            end
        end
    end
 
    //(2) Koeffizienten sind symmetrisch; addiere die ersten und letzten Daten der 16 Schieberegister
    reg  [11:0]          add_a, add_b ;
    reg  [11:0]          coe_s ;
    wire [12:0]          add_s ;
    wire [2:0]           xin_index = cnt>=1 ? cnt-1 : 3'd7 ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            add_a  <= 13'b0 ;
            add_b  <= 13'b0 ;
            coe_s  <= 12'b0 ;
        end
        else if (en_r[xin_index]) begin //von en_r[1]
            add_a  <= xin_reg[xin_index] ;
            add_b  <= xin_reg[15-xin_index] ;
            coe_s  <= coe[xin_index] ;
        end
    end
    assign add_s = {add_a} + {add_b} ;  
 
    //(3) Multiplikationsoperation, wobei nur ein Multiplizierer verwendet wird
    reg        [24:0]    mout ;
`ifdef SAFE_DESIGN
    wire                 en_mult ;
    wire [3:0]           index_mult = cnt>=2 ? cnt-1 : 4'd7 + cnt[0] ;
    mult_man #(13, 12)   u_mult_single    //Instanziiere den selbst entworfenen Pipeline-Multiplizierer
        (.clk        (clk),
         .rstn       (rstn),
         .data_rdy   (en_r[index_mult]),  //Achte auf die zeitliche Übereinstimmung der Daten
         .mult1      (add_s),
         .mult2      (coe_s),
         .res_rdy    (en_mult),  
         .res        (mout)
        );
 
`else
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            mout   <= 25'b0 ;
        end
        else if (|en_r[8:1]) begin
            mout   <= coe_s * add_s ;  //Direkte Multiplikation
        end
    end
    wire                 en_mult = en_r[2];
`endif
 
    //(4) Akkumulation, 8 Gruppen von 25-Bit-Daten -> 1 Gruppe von 29-Bit-Daten
    reg        [28:0]    sum ;
    reg                  valid_r ;
    //Mult-Ausgabe-En-Zähler
    reg [4:0]            cnt_acc_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            cnt_acc_r <= 'b0 ;
        end
        else if (cnt_acc_r == 5'd7) begin  //8 Zyklen zählen
            cnt_acc_r <= 'b0 ;
        end
        else if (en_mult || cnt_acc_r != 0) begin //Solange en gültig ist, wird weitergezählt
            cnt_acc_r <= cnt_acc_r + 1'b1 ;
        end
    end
 
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            sum      <= 29'd0 ;
            valid_r  <= 1'b0 ;
        end
        else if (cnt_acc_r == 5'd7) begin //Gefilterten Wert im 8. Akkumulationszyklus ausgeben
            sum      <= sum + mout;
            valid_r  <= 1'b1 ;
        end
        else if (en_mult && cnt_acc_r == 0) begin //Initialisierung
            sum      <= mout ;
            valid_r  <= 1'b0 ;
        end
        else if (cnt_acc_r != 0) begin //Akkumulieren zwischen Zyklen
            sum      <= sum + mout ;
            valid_r  <= 1'b0 ;
        end
    end
 
    //Gültige Ausgabedaten bei der Taktflanke zwischenspeichern, damit sich das Ausgangssignal nicht zu häufig ändert
    reg [28:0]           yout_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            yout_r <= 'b0 ;
        end
        else if (valid_r) begin
            yout_r <= sum ;
        end
    end
    assign yout = yout_r ;
 
    //Gültigkeitsverzögerung der Ausgabedaten; das heißt, die ersten 15 gefilterten Werte verwerfen
    reg [4:0]    cnt_valid ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            cnt_valid      <= 'b0 ;
        end
        else if (valid_r && cnt_valid != 5'd16) begin
            cnt_valid      <= cnt_valid + 1'b1 ;
        end
    end
    assign valid = (cnt_valid == 5'd16) & valid_r ;

endmodule

testbench

Der Testbench wird wie folgt geschrieben. Seine Hauptfunktion besteht darin, die gemischten Sinuswellensignaldaten 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.

Hier beträgt die Arbeitsfrequenz 400MHz, aber die Eingangsdaten und das Eingangsdaten-Gültigkeitssignal sollten beide mit einer Frequenz von 50MHz eingegeben werden.

Beispiel

module test ;
    //Eingabe
    reg          clk ;
    reg          rst_n ;
    reg          en ;
    reg  [11:0]  xin ;
    //Ausgabe
    wire [28:0]  yout ;
    wire         valid ;

    parameter    SIMU_CYCLE   = 64'd1000 ;
    parameter    SIN_DATA_NUM = 200 ;

//=====================================
// 8*50MHz clk-Generierung
    localparam   TCLK_HALF     = (10_000 >>3);
    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 * 8  * SIMU_CYCLE) ;
        $finish ;
    end
 
//=======================================
// cos-Daten in Register einlesen
    reg          [11:0] stimulus [0: SIN_DATA_NUM-1] ;
    integer      i ;
    initial begin
        $readmemh("../tb/cosx0p25m7p5m12bit.txt", stimulus) ;
        en = 0 ;
        i = 0 ;
        xin = 0 ;
        # 200 ;
        forever begin
            repeat(7)  @(negedge clk) ; //7 Zyklen im Leerlauf, Daten im 8. Zyklus bereitstellen
            en          = 1 ;
            xin         = stimulus[i] ;
            @(negedge clk) ;
            en          = 0 ;         //Das Eingangsdaten-Gültigkeitssignal muss nur einen Zyklus lang andauern
            if (i == SIN_DATA_NUM-1)  i = 0 ;
            else  i = i + 1 ;
        end
    end
 
    fir_serial_low       u_fir_serial (
        .clk         (clk),
        .rstn        (rst_n),
        .en          (en),
        .xin         (xin),
        .valid       (valid),
        .yout        (yout));

endmodule

Simulationsergebnisse

Aus den Simulationsergebnissen in der folgenden Abbildung ist ersichtlich, dass das Signal nach dem FIR-Filter nur ein niederfrequentes Signal (250KHz) enthält und das hochfrequente Signal (7.5MHz) herausgefiltert wurde. Für eine ästhetischere Wellenform werden die gefilterten Daten nach den ersten 16 Samples als gültige Ausgabe verwendet.

Die lokal vergrößerte Wellenform ist in der folgenden Abbildung dargestellt. Zu diesem Zeitpunkt sind das Eingangsdaten-Gültigkeitssignal en und das Ausgangsdaten-Gültigkeitssignal valid Pulssignale mit derselben Periode (50MHz) und nicht kontinuierlich gültig. Da der Arbeitstakt jedoch 400MHz beträgt, erscheint die Ausgabe auch als Sinuswellensignal mit einer Frequenz von 250KHz bei einer Abtastfrequenz von 50MHz.

Anhang: MATLAB-Verwendung (gleich wie"Parallel FIR Filter Design"konsistent)

FIR-Filterkoeffizienten erzeugen

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

Dann öffnet sich das folgende Fenster. Stellen Sie es gemäß den FIR-Filterparametern ein, wie unten gezeigt.

Die hier ausgewählte FIR-Implementierungsmethode ist die Methode der kleinsten Quadrate (Least-squares). Unterschiedliche Implementierungsmethoden erzeugen auch 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 sollte die coef-Variable Gleitkommadaten enthalten. Multiplizieren Sie sie mit einem bestimmten Faktor, um sie hochzuskalieren, und nehmen Sie dann ihre ungefähren Festkommadaten als FIR-Filterparameter im Design. Hier ist der Skalierungsfaktor 2048, und die Ergebnisse sind wie folgt.

Gemischtes Eingangssignal erzeugen

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

Das Signal besteht aus vorzeichenlosen Festkommadaten mit einer Bitbreite von 12 Bit, gespeichert in der 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 pro 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 (-1,1) Bereich
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