DDS-Prinzip
DDS (Direct Digital Synthesis)-Technologie ist ein Verfahren, das auf dem Nyquist-Abtasttheorem und der digitalen Verarbeitungstechnologie basiert, eine verzerrungsfreie Abtastung einer Reihe analoger Signale durchführt, die erhaltenen digitalen Signale im Speicher ablegt und unter der Steuerung eines Takts die digitalen Werte durch Digital-Analog-Umwandlung in analoge Signale umwandelt.
Das DDS-Modul besteht hauptsächlich aus einem Phasenakkumulator, einer Lookup-Tabelle, einem DAC-Wandler und einem Tiefpassfilter. Der grundlegende Aufbau ist wie folgt.

Der Phasenakkumulator ist die Kernkomponente von DDS und wird verwendet, um die Phasenakkumulation zu realisieren und die entsprechende Amplitude auszugeben. Der Phasenakkumulator besteht aus einem Addierer mitMBitbreite und einem Register mitMBitbreite. Unter Taktsteuerung wird das vorherige Akkumulationsergebnis auf den Addierer-Eingang zurückgeführt, um die Akkumulationsfunktion zu realisieren, sodass das Phaseninkrement in jedem Taktzyklus istK, und das Phasenakkumulationsergebnis wird als Adressausgabe an den ROM-Lookup-Tabellenabschnitt ausgegeben.
Die Amplituden-Lookup-Tabelle speichert die binäre digitale Amplitude, die jeder Phase entspricht. In jedem Taktzyklus adressiert die Lookup-Tabelle die vom Phasenakkumulator ausgegebene Phasenadressinformation und gibt dann den entsprechenden diskreten binären digitalen Amplitudenwert aus. Angenommen, die Lookup-Tabellenadresse istMBits, und die Ausgabedaten sindNBits, dann ist die Kapazität der Lookup-Tabelle
. Es ist leicht zu erkennen, dass die Phasenauflösung des Ausgangssignals beträgt:

Der DAC-Wandler wandelt digitale Signale in analoge Signale um. Tatsächlich ist das vom DAC ausgegebene Signal nicht kontinuierlich. Stattdessen summiert er entsprechend der Gewichtung jedes Codebits den digitalen Wert jedes Eingangsbits und führt dann eine analoge Ausgabe in Einheiten seiner Auflösung durch. Das tatsächliche Ausgangssignal ist ein treppenförmiges analoges lineares Signal, daher muss es geglättet werden, was im Allgemeinen mit einem Filter erfolgt.
Tiefpassfilter: Da das vom DAC-Wandler ausgegebene analoge Signal treppenförmige Defekte aufweist, muss es geglättet werden, um die meisten Störsignale herauszufiltern und das Ausgangssignal zu einem relativ idealen analogen Signal zu machen.
Wenn DDS arbeitet, wird das FrequenzsteuerwortKundMzum Phasenakkumulator der entsprechenden Bitbreite addiert, und das Ergebnis wird als Phasenwert verwendet. In jedem Taktzyklus wird es in binärer Form an die ROM-Lookup-Tabelle gesendet, wodurch die Phaseninformation in einen digitalisierten sinusförmigen Amplitudenwert umgewandelt wird, der dann durch Digital-Analog-Wandlung in ein stufenförmiges analoges Signal umgewandelt wird. Nachdem das Signal eine Systemfilterung durchlaufen hat, um die meisten Störsignale zu entfernen, kann eine relativ reine Sinuswelle erhalten werden.
Aus Sicht der Frequenzzerlegung teilt die ROM-Lookup-Tabelle die Eingangsfrequenz
into
Teile. Die Anzahl der Teile, die von der Ausgangsfrequenz belegt werden
ist genau das Schrittfrequenz-SteuerwortK. Daher kann die DDS-Ausgangsfrequenz ausgedrückt werden als:

Aus Sicht der Phase, innerhalb der Zeit
das Phaseninkrement des durch das FrequenzsteuerwortKgesteuerten Ausgangssignals ist:

Betrachtet man die Winkelgeschwindigkeit der Ausgangsfrequenz zu diesem Zeitpunkt
, innerhalb der Zeit
das Phaseninkrement der Ausgangsfrequenz kann auch ausgedrückt werden als:

Aus den beiden obigen Gleichungen kann auch die Beziehung zwischen der DDS-Ausgangsfrequenz und der Eingangsfrequenz abgeleitet werden.
DDS-Design
Entwurfsbeschreibung
Im Folgenden wird nur die DDS-Schaltung vor dem DAC entworfen.
Der entworfene DDS hat die folgenden Eigenschaften:
- 1) Steuerbare Frequenz;
- 2) Steuerbare Startphase;
- 3) Steuerbare Amplitude;
- 4) Auswählbare Ausgabe von Sinuswelle, Dreieckswelle und Rechteckwelle;
- 5) Ressourcenoptimierung: Die Wellenform-Speicherdatei verwendet nur ein Viertel der Sinuswellendaten.
ROM generieren
For the ROM module, it is best to use a customized IP core, as both timing and area will be better optimized. A customized ROM also requires specifying a data file. For example, the suffix of the ROM data file in ISE is.coe, und das Suffix der ROM-Datendatei in Quartus II ist.mif。
Um die Simulation zu erleichtern, wird das ROM-Modul hier in Code geschrieben, mit einer Adressbreite von 8 Bit und einer Datenbreite von 10 Bit.
Um Platz zu sparen, wird nur ein Viertel der Sinuswellenform gespeichert und dann entsprechend der Symmetrie verschoben, um eine vollständige Periode der Sinuswellen-Datenwellenform zu erhalten.
Um verschiedene DDS-Modi zu erreichen, werden auch ROM-Programme für die Dreieckswelle und die Rechteckwelle hinzugefügt.
Der Implementierungscode lautet wie folgt (alles in der Datei mem.v enthalten).
Beispiel
input clk, //Referenztakt
input rstn , //resetn, low-aktiv
input en , //Beginn der Wellenerzeugung
input [1:0] sel , //Wellenauswahl
input [7:0] addr ,
output dout_en ,
output [9:0] dout); //Datenausgabe, 10 Bit Breite
//Datenausgabe aus ROMs
wire [9:0] q_tri ;
wire [9:0] q_square ;
wire [9:0] q_cos ;
//ROM-Adresse
reg [1:0] en_r ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
en_r <= 2'b0 ;
end
else begin
en_r <= {en_r[0], en} ; //en um einen Takt verzögern
end
end
assign dout = en_r[1] ? (q_tri | q_square | q_cos) : 10'b0 ;
assign dout_en = en_r[1] ;
//ROM-Instanziierung
cos_ROM u_cos_ROM (
.clk (clk),
.en (en_r[0] & (sel == 2'b0)), //sel = 0, Kosinuswelle
.addr (addr[7:0]),
.q (q_cos[9:0]));
square_ROM u_square_ROM (
.clk (clk),
.en (en_r[0] & sel == 2'b01), //sel = 1, Rechteckwelle
.addr (addr[7:0]),
.q (q_square[9:0]));
tri_ROM u_tri_ROM (
.clk (clk),
.en (en_r[0] & sel == 2'b10), //sel = 2, Dreieckswelle
.addr (addr[7:0]),
.q (q_tri[9:0]));
endmodule
//Rechteckwellen-ROM
module square_ROM (
input clk,
input en,
input [7:0] addr,
output reg [9:0] q);
//1 in der ersten Halbperiode und 0 in der zweiten Halbperiode
always @(posedge clk) begin
if (en) begin
q <= { 10{(addr < 128)} };
end
else begin
q <= 'b0 ;
end
end
endmodule
//Dreieckswellen-ROM
module tri_ROM (
input clk,
input en,
input [7:0] addr,
output reg [9:0] q);
//steigende Flanke, addr -> 0x0, 0x3f
always @(posedge clk) begin
if (en) begin
if (addr < 128) begin
q <= {addr[6:0], 3'b0}; //steigende Flanke
end
else begin //fallende Flanke
q <= 10'h3ff - {addr[6:0], 3'b0} ;
end
end
else begin
q <= 'b0 ;
end
end
endmodule
//Besser mem ip verwenden.
//Dieses Format eignet sich gut für die Simulation
module cos_ROM (
input clk,
input en,
input [7:0] addr,
output reg [9:0] q);
wire [8:0] ROM_t [0 : 64] ;
//Aufgrund der Symmetrie der cos-Funktion nur 1/4 der Daten eines Zyklus speichern
assign ROM_t[0:64] = {
511, 510, 510, 509, 508, 507, 505, 503,
501, 498, 495, 492, 488, 485, 481, 476,
472, 467, 461, 456, 450, 444, 438, 431,
424, 417, 410, 402, 395, 386, 378, 370,
361, 352, 343, 333, 324, 314, 304, 294,
283, 273, 262, 251, 240, 229, 218, 207,
195, 183, 172, 160, 148, 136, 124, 111,
99 , 87 , 74 , 62 , 50 , 37 , 25 , 12 ,
0 } ;
always @(posedge clk) begin
if (en) begin
if (addr[7:6] == 2'b00 ) begin //Quadrant 1, addr[0, 63]
q <= ROM_t[addr[5:0]] + 10'd512 ; //nach oben verschieben
end
else if (addr[7:6] == 2'b01 ) begin //2., addr[64, 127]
q <= 10'd512 - ROM_t[64-addr[5:0]] ; //zweimal spiegeln
end
else if (addr[7:6] == 2'b10 ) begin //3., addr[128, 192]
q <= 10'd512 - ROM_t[addr[5:0]]; //spiegeln und nach rechts verschieben
end
else begin //4. Quadrant, addr [193, 256]
q <= 10'd512 + ROM_t[64-addr[5:0]]; //spiegeln und nach oben verschieben
end
end
else begin
q <= 'b0 ;
end
end
endmodule
DDS-Steuermodul
Beispiel
input clk, //Referenztakt
input rstn , //resetn, low-aktiv
input wave_en , //mit der Wellenerzeugung beginnen
input [1:0] wave_sel , //Wellenauswahl
input [1:0] wave_amp , //Wellenamplitudensteuerung
input [7:0] phase_init, //Anfangsphase
input [7:0] f_word , //Frequenzsteuerwort
output [9:0] dout, //Datenausgabe, 10 Bit Breite
output dout_en);
//Phasenakkumulator
reg [7:0] phase_acc_r ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
phase_acc_r <= 'b0 ;
end
else if (wave_en) begin
phase_acc_r <= phase_acc_r + f_word ;
end
else begin
phase_acc_r <= 'b0 ;
end
end
//ROM-Adresse
reg [7:0] mem_addr_r ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
mem_addr_r <= 'b0 ;
end
else if (wave_en) begin
mem_addr_r <= phase_acc_r + phase_init ;
end
else begin
mem_addr_r <= 'b0 ;
end
end
//ROM-Instanziierung
wire [9:0] dout_temp ;
mem u_mem_wave(
.clk (clk), //Referenztakt
.rstn (rstn), //resetn, niedrig aktiv
.en (wave_en), //Start der Wellengenerierung
.sel (wave_sel[1:0]), //Wellenauswahl
.addr (mem_addr_r[7:0]),
.dout_en (dout_en),
.dout (dout_temp[9:0])); //Datenausgang, 10bit Breite
//Amplitude
//0 -> dout/1 //1 -> dout/2 //2 -> dout/4 //3 -> dout/8
assign dout = dout_temp >> wave_amp ;
endmodule
testbench
Beispiel
module test ;
reg clk ;
reg rstn ;
reg wave_en ;
reg [1:0] wave_sel ;
reg [1:0] wave_amp ;
reg [7:0] phase_init ;
reg [7:0] f_word ;
wire [9:0] dout ;
wire dout_en ;
//(1)clk, reset und andere konstante Register
initial begin
clk = 1'b0 ;
rstn = 1'b0 ;
#100 ;
rstn = 1'b1 ;
#10 ;
forever begin
#5 ; clk = ~clk ; //Systemtakt, 100MHz
end
end
//(2)Signal-Setup ;
parameter clk_freq = 100000000 ; //100MHz
integer freq_dst = 2000000 ; //2MHz
integer phase_coe = 2; //1/4 Zyklus, das ist pi/2
initial begin
wave_en = 1'b0 ;
//(a) Kosinuswelle, pi/2 Phase
wave_amp = 2'd1 ;
wave_sel = 2'd0 ;
phase_init = 256/phase_coe ; //pi/8 Anfangsphase
f_word = (1<<8) * freq_dst / clk_freq; //Frequenzsteuerwort ermitteln
#500 ;
@ (negedge clk) ;
wave_en = 1'b1 ; //Wellen erzeugen starten
# 2000 ;
//(b)Dreieckswelle, pi/4 Anfangsphase
wave_en = 1'b0 ;
wave_sel = 2'd2 ;
phase_init = 256/4 ;
wave_amp = 2'd2 ;
# 50 ;
wave_en = 1'b1 ;
end
//(3) Modulinstanziierung
dds u_dds(
.clk (clk),
.rstn (rstn),
.wave_en (wave_en),
.wave_sel (wave_sel[1:0]),
.wave_amp (wave_amp[1:0]),
.phase_init (phase_init[7:0]),
.f_word (f_word[7:0]),
.dout (dout[9:0]),
.dout_en (dout_en));
//(4) Simulation beenden
always begin
#100;
if ($time >= 100000) $finish ;
end
endmodule
Simulationsergebnisse
Wie in der folgenden Abbildung gezeigt, wird das Ausgangssignal auf analoge Anzeige eingestellt.
- 1) Es ist zu sehen, dass die Sinuswellenfrequenz 2 MHz beträgt, was dem Frequenzsteuerwort entspricht;
- 2) Die Anfangsphase der Sinuswelle beträgt 1/2 Periode, und die Anfangsphase der Dreieckswelle beträgt 1/4 Periode, was den Einstellungen entspricht;
- 3) Der Dreieckswelle wird die Hälfte der Amplitude der Sinuswelle zugewiesen, und die Amplitude ist ebenfalls steuerbar;
- 4) Die Ausgangswellenformen sind die Sinuswelle und die Dreieckswelle, und sie können normal umgeschaltet werden;
- 5) Die Sinuswellenform weist keine Auffälligkeiten auf; es werden nur Sinuswellendaten einer 1/4 Periode verwendet, um die vollständige Sinuswellenausgabe zu erzeugen.
Aufgrund von Platzbeschränkungen wurden in der Simulation nur einige Funktionen getestet. Leser können die Parameter ändern, um andere Funktionen zu testen, wie andere Frequenzen, Rechteckwellenausgabe usw.
Anhang: Verwendung von Matlab
Erzeugen von 1/4-Perioden-Sinuswellendaten
Die Verwendung von Matlab zum Erzeugen von Sinuswellendaten mit 1/4 Periode wird wie folgt beschrieben, und das Verfahren zum Zusammensetzen der vollständigen Sinuswelle wird ebenfalls simuliert.
Beispiel
%=======================================================
% Erzeugen 1/4 Cos-Wellendaten mit txt-Hex-Format
%=======================================================
N = 64 ; %gemeinsame256Datenpunkte, nehmen1/4
n = 0:N ;
w = n/N *pi/2 ; %Auf pi quantisieren/2innerhalb
st = (2^10 /2 -1)*cos(w) ; %Sinuswellendaten benötigen 10 Bits
st = floor(st) ;
%%Füge den ersten Quadranten zusammen
st1 = st+512 ;
figure(5) ;plot(n, st1) ;
hold on ;
%%Füge den zweiten Quadranten zusammen
n2 = 64 + n ;
st2 = 512 - st(64-n+1);
plot(n2, st2);
hold on
%%Füge den dritten Quadranten zusammen
n3 = 128 + n ;
st3 = 512 - st ;
plot(n3, st3) ;
hold on ;
%%Füge den vierten Quadranten zusammen
n4 = 192 + n ;
st4 = 512 + st(64-n+1) ;
plot(n4, st4) ;
hold on ;
Quellcode-Download
Herunterladen
