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 entrada
en
partes; la frecuencia de salida
ocupa 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
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
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
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
%=======================================================
% 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
