Principio del DDS

La tecnología DDS (síntesis directa de frecuencia) se basa en el teorema de muestreo de Nyquist y en técnicas de procesamiento digital. Consiste en muestrear sin distorsión una serie de señales analógicas, almacenar las señales digitales obtenidas en una memoria y, bajo el control del reloj, convertir las cantidades digitales en señales analógicas mediante un conversor digital-analógico.

El módulo DDS se compone principalmente de un acumulador de fase, una tabla de consulta (lookup table), un conversor DAC y un filtro pasabajos. La estructura básica es la siguiente.

El acumulador de fase es el componente central del DDS; se utiliza para realizar la acumulación de fase y generar el valor de amplitud correspondiente. El acumulador de fase está formado por unMsumador de ancho de bits y unMregistro de ancho de bits. Mediante el control del reloj, el resultado de la acumulación anterior se retroalimenta a la entrada del sumador para realizar la función de acumulación, de modo que el incremento de fase en cada ciclo de reloj seaK, y el resultado de la acumulación de fase se toma como dirección de salida hacia la sección de tabla de consulta ROM.

La tabla de consulta de amplitud almacena la amplitud digital binaria correspondiente a cada fase. En cada ciclo de reloj, la tabla de consulta direcciona la información de dirección de fase generada por el acumulador de fase y luego genera el valor discreto binario de amplitud correspondiente. Suponiendo que la dirección de la tabla de consulta sea deMbits y que los datos de salida sean deNbits, entonces el tamaño de capacidad de la tabla de consulta es. No es difícil ver que la resolución de fase de la señal de salida es:

El conversor DAC convierte señales digitales en señales analógicas. En realidad, la señal de salida del DAC no es continua; según el peso de cada código, suma la cantidad digital de cada bit de entrada y luego realiza una salida analógica tomando su resolución como unidad. La señal realmente emitida es una señal analógica en forma de escalera, por lo que debe suavizarse, generalmente mediante un filtro.

El filtro pasabajos: debido a que la señal analógica de salida del conversor DAC presenta el defecto de forma escalonada, debe suavizarse para eliminar la mayor parte de las señales espurias y convertir la señal de salida en una señal analógica más ideal.

Cuando el DDS está funcionando, la palabra de control de frecuenciaKyMse suma con el acumulador de fase de bits, y el resultado obtenido se utiliza como valor de fase. En cada ciclo de reloj, se envía a la tabla de consulta ROM en forma de número binario, que convierte la información de fase en valores digitalizados de amplitud sinusoidal; luego, mediante la conversión digital-analógica, se convierte en una señal analógica en forma de escalera. Después de que la señal pasa por el filtrado del sistema y se eliminan la mayoría de las señales espurias, se puede obtener una onda sinusoidal bastante pura.

Desde el punto de vista de la descomposición de frecuencia, la tabla de consulta ROM divide la frecuencia de entradaenpartes; la frecuencia de salidaocupa precisamente el número de partes correspondiente a la palabra de control de frecuencia de pasoK. Por lo tanto, la frecuencia de salida del DDS se puede expresar como:

Desde el punto de vista de la fase, en el tiempo, el incremento de fase controlado por la palabra de control de frecuenciaKes:

Considerando la velocidad angular de la frecuencia de salida en este momento, en el tiempo, el incremento de fase de la frecuencia de salida también se puede expresar como:

A partir de las dos ecuaciones anteriores también se puede deducir la relación entre la frecuencia de salida y la frecuencia de entrada del DDS.

Diseño del DDS

Descripción del diseño

A continuación, solo se diseña el circuito DDS anterior al DAC.

Las características del DDS diseñado son:

  • 1) Frecuencia controlable;
  • 2) Fase inicial controlable;
  • 3) Amplitud controlable;
  • 4) Salida seleccionable de onda sinusoidal, onda triangular y onda cuadrada;
  • 5) Optimización de recursos: el archivo de almacenamiento de formas de onda solo utiliza un cuarto de los datos de la onda sinusoidal.

Generación de la ROM

Para el módulo ROM es mejor utilizar un núcleo IP personalizado, ya que tanto el tiempo como el área se optimizan mejor. La ROM personalizada también requiere especificar un archivo de datos; por ejemplo, el sufijo del archivo de datos ROM de ISE es.coe, y el sufijo del archivo de datos ROM de Quartus II es.mif。

Para facilitar la simulación, aquí se escribe el módulo ROM con código, con un ancho de dirección de 8 bits y un ancho de datos de 10 bits.

Para ahorrar espacio, solo se almacena un cuarto de la forma de onda sinusoidal y, luego, mediante traslaciones basadas en la simetría, se obtiene la forma de onda de datos de un período completo de onda sinusoidal.

Para lograr una mayor diversidad de modos del DDS, también se añadieron programas ROM para la onda triangular y la onda cuadrada.

El código de implementación es el siguiente (todo está incluido en el archivo mem.v).

Ejemplo

module mem(
    input           clk,            //reference clock
    input           rstn ,          //resetn, low effective
    input           en ,            //start to generating waves
    input [1:0]     sel ,           //waves selection

    input [7:0]     addr ,
    output          dout_en ,
    output [9:0]    dout);          //data out, 10bit width

    //data out fROM ROMs
    wire [9:0]           q_tri ;
    wire [9:0]           q_square ;
    wire [9:0]           q_cos ;

    //ROM addr
    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} ;         //delay one cycle for en
        end
    end
    assign dout      = en_r[1] ? (q_tri | q_square | q_cos) : 10'b0 ;
    assign dout_en   = en_r[1] ;

    //ROM instiation
    cos_ROM      u_cos_ROM (
       .clk     (clk),
       .en      (en_r[0] & (sel == 2'b0)),  //sel = 0, cos wave
       .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, square wave
       .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, triangle wave
       .addr    (addr[7:0]),
       .q       (q_tri[9:0]));

endmodule

//square waves ROM
module square_ROM (
    input               clk,
    input               en,
    input [7:0]         addr,
    output reg [9:0]     q);
   
    //1 in first half cycle, and 0 in second half cycle
    always @(posedge clk) begin
        if (en) begin
            q <= { 10{(addr < 128)} };    
        end
        else begin
            q <= 'b0 ;
        end
    end
endmodule

 //triangle waves ROM
module tri_ROM (
    input               clk,
    input               en,
    input [7:0]         addr,
    output reg [9:0]     q);
    //rising edge, addr -> 0x0, 0x3f
    always @(posedge clk) begin
        if (en) begin
            if (addr < 128) begin
                q <= {addr[6:0], 3'b0};   //rising edge  
            end
            else begin //falling edge
                q <= 10'h3ff - {addr[6:0], 3'b0} ;
            end
        end
        else begin
            q <= 'b0 ;
        end
    end
endmodule

//Better use mem ip.
//This format is easy for simulation
module cos_ROM (
    input               clk,
    input               en,
    input [7:0]         addr,
    output reg [9:0]     q);

   wire [8:0]           ROM_t [0 : 64] ;
   //as the symmetry of cos function, just store 1/4 data of one cycle
   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 ; //Desplazar hacia arriba
            end
            else if (addr[7:6] == 2'b01 ) begin //2nd, addr[64, 127]
                q <= 10'd512 - ROM_t[64-addr[5:0]] ; //Invertir dos veces
            end
            else if (addr[7:6] == 2'b10 ) begin //3rd, addr[128, 192]
                q <= 10'd512 - ROM_t[addr[5:0]]; //Invertir y desplazar a la derecha
            end
            else begin     //4th quadrant, addr [193, 256]
                q <= 10'd512 + ROM_t[64-addr[5:0]]; //Invertir y desplazar hacia arriba
            end
        end
        else begin
            q <= 'b0 ;
        end
    end
endmodule

Módulo de control del DDS

Ejemplo

module dds(
    input           clk,            //reference clock
    input           rstn ,          //resetn, low effective
    input           wave_en ,       //start to generating waves

    input [1:0]     wave_sel ,      //waves selection
    input [1:0]     wave_amp ,      //waves amplitude control
    input [7:0]     phase_init,     //initial phase
    input [7:0]     f_word ,        //frequency control word

    output [9:0]    dout,           //data out, 10bit width
    output          dout_en);

    //phase acculator
    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 addr
    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 instiation
    wire [9:0]   dout_temp ;
    mem  u_mem_wave(
        .clk     (clk),                 //reference clock
        .rstn    (rstn),                //resetn, low effective
        .en      (wave_en),             //start to generating waves
        .sel     (wave_sel[1:0]),       //waves selection
        .addr    (mem_addr_r[7:0]),
        .dout_en (dout_en),
        .dout    (dout_temp[9:0]));     //data out, 10bit width

    //amplitude
    //0 -> dout/1   //1 -> dout/2   //2 -> dout/4   //3 -> dout/8
    assign       dout = dout_temp >> wave_amp ;
endmodule

testbench

Ejemplo

`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 and other constant regs
    initial begin
        clk           = 1'b0 ;
        rstn          = 1'b0 ;
        #100 ;
        rstn          = 1'b1 ;
        #10 ;
        forever begin
            #5 ;      clk = ~clk ;   //system clock, 100MHz
        end
    end

    //(2)signal setup ;
    parameter    clk_freq    = 100000000 ; //100MHz
    integer      freq_dst    = 2000000 ;   //2MHz
    integer      phase_coe   = 2;          //1/4 cycle, that is pi/2

    initial begin
        wave_en           = 1'b0 ;
        //(a)cos wave, pi/2 phase
        wave_amp          = 2'd1 ;
        wave_sel          = 2'd0 ;
        phase_init        = 256/phase_coe ;   //pi/8 initialing-phase
        f_word            = (1<<8) * freq_dst / clk_freq; //get the frequency control word
        #500 ;
        @ (negedge clk) ;
        wave_en           = 1'b1 ;        //start generating waves
        # 2000 ;
        //(b)triangle wave, pi/4 initialing-phase
        wave_en           = 1'b0 ;
        wave_sel          = 2'd2 ;
        phase_init        = 256/4 ;
        wave_amp          = 2'd2 ;
        # 50 ;
        wave_en           = 1'b1 ;
    end

    //(3) module instantiaion
    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) finish the simulation
    always begin
        #100;
        if ($time >= 100000) $finish ;
    end
endmodule

Resultados de la simulación

Como se muestra en la siguiente figura, la señal de salida se ajusta a una visualización analógica.

  • 1) Se observa que la frecuencia de la onda sinusoidal es de 2 MHz, correspondiente a la palabra de control de frecuencia;
  • 2) La fase inicial de la onda sinusoidal es de 1/2 de período y la fase inicial de la onda triangular es de 1/4 de período, lo que coincide con la configuración;
  • 3) La onda triangular tiene asignada la mitad del valor de la onda sinusoidal, por lo que la amplitud también se puede controlar;
  • 4) Las formas de onda de salida son la onda sinusoidal y la onda triangular, y se pueden conmutar correctamente
  • 5) La forma de onda sinusoidal no presenta anomalías; solo se utilizan los datos de 1/4 de período de la onda sinusoidal para completar la salida de la onda sinusoidal completa.

Debido a la limitación de espacio, la simulación solo probó algunas características. El lector puede modificar los parámetros para probar otras características, como otras frecuencias, la salida de onda cuadrada, etc.

Apéndice: uso de MATLAB

Generación de datos de onda sinusoidal de 1/4 de período

La descripción del uso de MATLAB para generar los datos de la onda sinusoidal de 1/4 de período es la siguiente, y también se simuló el proceso de concatenación de la onda sinusoidal completa.

Ejemplo

clear all;close all;clc;
%=======================================================
% generating 1/4 cos wave data with txt hex format
%=======================================================

N   = 64 ;                    %común256datos, tomar1/4
n   = 0:N ;
w   = n/N *pi/2 ;             %cuantificar a pi/2dentro
st  = (2^10 /2 -1)*cos(w) ;   %Los datos de la onda sinusoidal se toman de 10 bits
st  = floor(st) ;

%%Concatenación del primer cuadrante
st1  = st+512 ;
figure(5) ;plot(n, st1) ;
hold on ;

%%Concatenación del segundo cuadrante
n2  = 64 + n ;
st2 = 512 - st(64-n+1);
plot(n2, st2);
hold on

%%Concatenación del tercer cuadrante
n3  = 128 + n ;
st3 = 512 - st ;
plot(n3, st3) ;
hold on ;

%%Concatenación del cuarto cuadrante
n4 = 192 + n ;
st4 = 512 + st(64-n+1) ;
plot(n4, st4) ;
hold on ;

Descarga del código fuente

Download