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