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 EingangsfrequenzintoTeile. Die Anzahl der Teile, die von der Ausgangsfrequenz belegt werdenist genau das Schrittfrequenz-SteuerwortK. Daher kann die DDS-Ausgangsfrequenz ausgedrückt werden als:

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

Betrachtet man die Winkelgeschwindigkeit der Ausgangsfrequenz zu diesem Zeitpunkt, innerhalb der Zeitdas 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

module mem(
    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

module dds(
    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

`timescale 1ns/1ns

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

clear all;close all;clc;
%=======================================================
% 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