Controlando módulo DDS AD9850 com Raspberry Pi

Um DDS( Direct digital synthesizer ) é um sintetizador de frequências controlado digitalmente utilizando uma frequência de referência, geralmente um cristal.

O AD9850 é um chip DDS da Analog Devices bem famoso por ser possível encontrar um módulo de baixo custo(5-8 dólares) que o utiliza, digo isso pois o chip diretamente na Analog Devices saí por $12.14 cada quando comprado em quantidades de 1000 peças. O milagre desse valor ainda é incerto e apesar de algumas teorias de que são chips defeituosos com erros de produção, muitos usuários que o compram comentam que não vieram com problemas.

O módulo utiliza um cristal de 125Mhz como referência podendo gerar uma onda senoidal de até 40Mhz ou uma onda quadrada de até 1Mhz. Na realidade é possível gerar mais do que os 40Mhz especificados, mas cada vez mais que se aumenta a frequência a distorção e harmônicos aumenta, no caso da onda quadrada ela se torna cada vez menos quadrada. Além disso o chip conta com a função power-down controlada digitalmente para colocar o chip em sleep mode, modo de baixo consumo e é possível controlar o deslocamento de fase, com uma precisão de 11,61°, que é um tanto baixa, são somente 5 bits para controlar a fase.

O controle de frequência/fase/power é feito por um valor de 40 bits em um registrador interno. O envio desses bits pode ser feito por comunicação paralela enviando 8 bits por vez, ou serial enviando diretamente os 40 bits, um a cada pulso de clock no pino W_CLK, é o tipo de comunicação que usaremos.

Primeiramente precisaremos conectar os pinos do módulo no Raspberry Pi.

Legenda dos pinos

Os pinos vão ser conectados do seguinte modo:

VCC = 3.3V
GND = GND
W_CLK = GPIO11
FQ_UD = GPIO25
DATA = GPIO9
RESET = GPIO8
Pinos ZOUT e QOUT são respectivamente as saídas do sinal senoidal e quadrado.

Ilustração

É possível utilizar em outros GPIOs caso necessite, para isso será preciso alterar no código fonte para os valores que desejar.

#define W_CLK "11"
#define FU_UD "25"
#define DATA "9"
#define RESET "8"

No meu caso utilizei uma protoboard para ligação, caso a utilize, tome cuidado para colocar o módulo DDS, pois por causa dos vários pinos o encaixe se torna difícil.

Protoboard

Na parte de programação iremos utilizar o seguinte código fonte.

/* * DDS AD9850 Controller * * EverPi - blog.everpi.net * */ #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <stdlib.h> #include <string.h> #include <stdio.h> #include <errno.h> #define W_CLK "11" #define FU_UD "25" #define DATA "9" #define RESET "8" #define HIGH "1" #define LOW "0" #define HELP \ "\n \033[1mDDS AD9850 Controller by blog.everpi.net\n\n" \ "\tUsage: [option] [frequency in HZ] [phase]\n" \ "\t -o\tchip shutdown\n\n"\ "\tPhase is optional, 31 Max.\033[0m\n\n" #define _ERR(c) if(c == -1){ fprintf(stderr,"%s\n",strerror(errno)); return 1; } int send_bits(char data); int spread(double freq); int gpio_export(char *gp){ int fd = 0; int er = 0; fd = open("/sys/class/gpio/export", O_WRONLY); _ERR(fd); er = write(fd,gp,2); close(fd); _ERR(er); return 0; } int gpio_direction(char *gp, char *direction){ int fd = 0; int er = 0; char gpio_path[64]; snprintf(gpio_path,64,"/sys/class/gpio/gpio%s/direction",gp); do{ fd = open(gpio_path, O_WRONLY); if(errno == ENOENT){ gpio_export(gp); }else _ERR(fd); }while(fd == -1); usleep(100000); er = write(fd,direction,3); close(fd); _ERR(er); return 0; } int gpio_value(char *gp, char *value){ int fd = 0; int er = 0; char gpio_path[64]; snprintf(gpio_path,64,"/sys/class/gpio/gpio%s/value",gp); fd = open(gpio_path, O_WRONLY); _ERR(fd); er = write(fd,value,1); close(fd); _ERR(er); return 0; } int gpio_pulse(char *gp){ gpio_value(gp,HIGH); gpio_value(gp,LOW); return 0; } int dds_frequency(double freq, unsigned char phase){ int bytes = 4; int tuning_word = freq * (4294967296.0 / 125000000.0); #ifdef DEBUG printf("tuning_word(int):%d\n",tuning_word); #endif while(bytes){ send_bits(tuning_word & 0xff); tuning_word = tuning_word >> 8; bytes--; } send_bits(phase); // 8 bits restantes, 5 para phase, 1 power-down, 3 de testes do fabricante gpio_pulse(FU_UD); return 0; } int send_bits(char data){ int bits = 8; while(bits){ if(data & 1){ gpio_value(DATA,HIGH); }else gpio_value(DATA,LOW); gpio_pulse(W_CLK); data = data >> 1; bits--; } return 0; } int main(int argc, char *argv[]){ unsigned char phase = 0; int frequency = 0; if(argc < 2){ printf("%s",HELP); return 0; } gpio_direction(W_CLK,"out"); gpio_direction(FU_UD,"out"); gpio_direction(DATA,"out"); gpio_direction(RESET,"out"); gpio_value(W_CLK,LOW); gpio_value(FU_UD,LOW); gpio_value(DATA,LOW); gpio_value(RESET,LOW); gpio_pulse(RESET); gpio_pulse(W_CLK); gpio_pulse(FU_UD); if(argv[1][1] == 'o'){ dds_frequency(0,0x4); // set power down bit 00000100 return 0; } if(argc > 3 && phase <= 31){ phase = strtol(argv[2],NULL,10); } frequency = strtol(argv[1],NULL,10); if(frequency <= 40000000){ dds_frequency(frequency, phase << 3 ); }else{ printf("Frequency max:40000000\n"); return -1; } return 0; }

Compile com gcc dds.c -o dds

Ao executarmos sem argumentos temos as seguintes opções:

#./dds

  DDS AD9850 Controller for Raspberry Pi by blog.everpi.net

    Usage:  [option] [frequency in HZ] [phase]
             -o    chip shutdown

    Phase is optional, 31 Max.


A frequência é passada em Hertz, então se queremos por exemplo 1Khz:

./dds 1000

É necessário executar como usuário root.

1Khz Senoidal

Ou na saída quadrada ( QOUT ):

1Khz quadrada

A opção -o é utilizada sozinha e faz com que o chip entre no modo power-down falado no início do post. Essa opção é útil em projetos que dependam de uma bateria e possam desligar o DDS em certos momentos.

Como meu osciloscópio vai somente até 20Mhz, à 40Mhz posso testar utilizando o dongle SDR que já comentei sobre em posts passados.

AD9850 gerando 40Mhz

Como último teste do DDS, utilizei ele para gerar o clock para um Atmel Atmega 328P retirado do meu Arduino.

Clock gerado para Atmega

Abaixo podemos ver o vídeo de um simples led piscando e ao alterar a frequência de clock de 16Mhz para 8Mhz e 20Mhz, o intervalo que ele pisca vai ser diferente.



Controlar o DDS AD9850 pelo Raspberry Pi não é uma tarefa tão difícil e seu baixo custo torna ele talvez o mais acessível sintetizador de frequências de 40Mhz da atualidade.

Está gostando do blog? Ajude-nos a divulgar e curta nossa página no Facebook ou siga-nos no Twitter.