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
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
%=======================================================
% 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