Construa seu próprio gerador de função com o módulo gerador de função dds arduino e ad9833

Se você é um entusiasta da eletrônica como eu, que quer mexer em diferentes circuitos eletrônicos, às vezes é obrigatório ter um Gerador de Função decente. Mas ter um é um problema porque esse equipamento básico pode custar uma fortuna. Construir seu próprio equipamento de teste não é apenas mais barato, mas também uma ótima maneira de aprimorar seus conhecimentos.

Portanto, neste artigo, vamos construir um Gerador de Sinal simples com Arduino e Módulo Gerador de Função DDS AD9833 que pode produzir ondas senoidais, quadradas e triangulares com uma frequência máxima de 12 MHz na saída. E, finalmente, vamos testar a frequência de saída com a ajuda de nosso osciloscópio.

Anteriormente, construímos um gerador de onda senoidal simples, um gerador de onda quadrada e um gerador de onda triangular com a ajuda de circuitos analógicos básicos. Você pode verificar se está procurando alguns Circuitos Geradores de Forma de Onda básicos. Além disso, se você deseja construir um gerador de função Arduino mais barato sem usar o módulo AD9833, você pode verificar o DIY Arduino Waveform Generator Project.

O que é um gerador de função DDS?

Como o nome indica, um gerador de função é um dispositivo que pode gerar uma forma de onda específica com uma frequência específica após a configuração. Por exemplo, considere que você tem um filtro LC para o qual deseja testar sua resposta de frequência de saída, você pode fazer isso facilmente com a ajuda de um gerador de função. Tudo o que você precisa fazer é definir a frequência de saída e a forma de onda desejadas e, em seguida, diminuir ou aumentar a velocidade para testar a resposta. Este foi apenas um exemplo, você pode fazer mais coisas com ele conforme a lista avança.

DDS significa Direct Digital Synthesis. É um tipo de gerador de forma de onda que usa conversores digital para analógico (DAC) para construir um sinal a partir do zero. Este método é usado especificamente para gerar uma onda senoidal. Mas o IC que estamos usando pode produzir sinais de onda quadrada ou triangular. As operações que acontecem dentro de um chip DDS são digitais, portanto, ele pode mudar a frequência muito rapidamente ou pode mudar de um sinal para outro muito rapidamente. Este dispositivo tem uma resolução de frequência fina com um amplo espectro de frequência.

Compreenda o funcionamento do CI do gerador de funções AD9833

No centro de nosso projeto está o CI gerador de forma de onda programável AD9833, que é projetado e desenvolvido por dispositivos analógicos. É um gerador de forma de onda programável de baixa potência, capaz de produzir ondas senoidais, triangulares e quadradas com uma frequência máxima de 12 MHz. É um IC único que é capaz de alterar a frequência e fase de saída com apenas um programa de software. Ele tem uma interface SPI de 3 fios, por isso a comunicação com este IC se torna muito simples e fácil. O diagrama de blocos funcional deste IC é mostrado abaixo.

O funcionamento deste IC é muito simples. Se observarmos o diagrama de blocos funcional acima, observaremos que temos um Acumulador de Fase cuja função é armazenar todos os valores digitais possíveis de uma onda senoidal, começando de 0 a 2π. Em seguida, temos a ROM SIN cujo trabalho é converter as informações de fase que podem ser posteriormente mapeadas diretamente em amplitude. O SIN ROM usa as informações de fase digital como um endereço para uma tabela de pesquisa e converte as informações de fase em amplitude. E por último, temos um conversor digital para analógico de 10 bits cuja função é receber os dados digitais da ROM SIN e convertê-los nas tensões analógicas correspondentes, é o que obtemos da saída. Na saída, também temos um switch que podemos ligar ou desligar com apenas um pequeno código de software. Falaremos sobre isso mais tarde neste artigo.Os detalhes que você vê acima são uma versão simplificada do que está acontecendo dentro do IC, e a maioria dos detalhes que você vê acima são retirados da folha de dados do AD9833, você também pode verificá-la para mais informações.

Componentes necessários para construir o gerador de funções baseado em AD9833

Os componentes necessários para construir o gerador de função baseado em AD9833 estão listados abaixo, nós projetamos este circuito com componentes muito genéricos, o que torna o processo de replicação muito fácil.

Arduino Nano - 1
AD9833 Gerador de Função DDS - 1
Tela OLED de 128 X 64 - 1
Codificador Rotativo Genérico - 1
Jack Barril DC - 1
Regulador de tensão LM7809 - 1
Capacitor 470uF - 1
Capacitor 220uF - 1
Capacitor 104pF - 1
Resistor 10K - 6
Interruptores táteis - 4
Terminal de parafuso 5,04 mm - 1
Cabeçalho Feminino - 1
Fonte de alimentação 12V - 1

Gerador de Função Baseado em AD9833 - Diagrama Esquemático

O diagrama de circuito completo para o gerador de função baseado em AD9833 e Arduino é mostrado abaixo.

Vamos usar o AD9833 com Arduino para gerar a frequência desejada. E nesta seção, vamos explicar todos os detalhes com a ajuda do esquema; deixe-me dar uma breve visão geral do que está acontecendo com o circuito. Vamos começar com o módulo AD9833. O módulo AD9833 é o módulo gerador de função e está conectado ao Arduino de acordo com o esquema. Para alimentar o circuito, estamos usando um IC regulador de tensão LM7809, com um capacitor de desacoplamento decente, isso é necessário porque o ruído da fonte pode interferir no sinal de saída resultando em uma saída indesejada. Como sempre, o Arduino está funcionando como o cérebro para este projeto. Para exibir a frequência definida e outras informações valiosas, conectamos um módulo de display OLED 128 X 64. Para alterar a faixa de frequência, estamos usando três interruptores. O primeiro define a frequência em Hz, o segundo define a frequência de saída em KHz e o terceiro define a frequência em MHz, também temos outro botão que pode ser usado para habilitar ou desabilitar a saída. Finalmente, temos o codificador rotativo,e temos que anexar algum resistor pull-up com ele, caso contrário essas chaves não funcionarão porque estamos verificando o evento de pressionamento de botão no método de pool. O codificador rotativo é usado para alterar a frequência e a chave tátil dentro do codificador rotativo é usada para selecionar a forma de onda definida.

AD9833 Based Function Generator - Arduino Code

O código completo usado neste projeto pode ser encontrado no final desta página. Depois de adicionar os arquivos de cabeçalho e arquivos de origem necessários, você poderá compilar diretamente o arquivo Arduino. Você pode baixar a biblioteca Ad9833 Arduino e outras bibliotecas do link fornecido abaixo ou então você pode usar o método do gerenciador de placa para instalar a biblioteca.

Baixe a Biblioteca AD9833 de Bill Williams
Baixe a biblioteca OLED SSD1306 da Adafruit
Baixe a biblioteca Adafruit GFX

A explicação do código no ino. arquivo é o seguinte. Primeiro, começamos incluindo todas as bibliotecas necessárias. A biblioteca para o módulo AD9833 DDS é primeiro seguida pela biblioteca para OLED e a biblioteca matemática é necessária para alguns de nossos cálculos.

#include // Biblioteca para Módulo AD9833 #include // Wire Library for OLED #include // Biblioteca de suporte para OLED #include // Biblioteca OLED #include // Biblioteca de matemática

Em seguida, definimos todos os pinos de entrada e saída necessários para os botões, switch, codificador rotativo e OLEDs.

#define SCREEN_WIDATA_PINH 128 // Largura do display OLED em pixels #define SCREEN_HEIGHT 64 // Altura do display OLED, em pixels #define SET_FREQUENCY_HZ A2 // Botão para definir a freqüência em Hz #define SET_FREQUENCY_KHZ A3 // Pushbutton para definir a freqüência em KhZF # A6 // Botão para definir a frequência em MHz #define ENABLE_DISABLE_OUTPUT_PIN A7 // Botão para ativar / desativar a saída #define FNC_PIN 4 // Fsync exigido pelo módulo AD9833 #define CLK_PIN 8 // Pino do relógio do codificador #define DATA_PIN 7 / / Pino de dados do codificador # define BTN_PIN 9 // Botão interno do codificador

Depois disso, definimos todas as variáveis necessárias que são exigidas neste código. Primeiro, definimos um contador de variável inteira que armazenará o valor do codificador rotativo. As próximas duas variáveis clockPin e clockPinState armazenam a estátua do pino necessária para entender a direção do codificador. Temos uma variável de tempo que contém os valores atuais do contador do temporizador, esta variável é usada para debouncing do botão. Em seguida, temos um módulo de variável longa sem sinalFrequency que mantém a frequência calculada que será aplicada. Em seguida, temos o atraso de debounce. Este atraso pode ser ajustado conforme necessário. Em seguida, temos três variáveis booleanas set_frequency_hz,set_frequency_Khz e set_frequency_Mhz essas três variáveis são usadas para determinar a configuração atual do módulo. Falaremos sobre isso com mais detalhes posteriormente neste artigo. Em seguida, temos a variável que armazena o status da forma de onda de saída, a forma de onda de saída padrão é uma onda senoidal. E, finalmente, temos a variável encoder_btn_count que contém a contagem do botão do codificador que é usado para definir a forma de onda de saída.

contador interno = 1; // Este valor do contador aumentará ou diminuirá se quando o codificador rotativo for girado int clockPin; // Espaço reservado para o status do pino usado pelo codificador rotativo int clockPinState; // Espaço reservado para o status do pino usado pelo codificador rotativo unsigned long time = 0; // Usado para eliminar o módulo longo sem sinalFrequency; // usado para definir a frequência de saída long debounce = 220; // Atraso de debounce bool btn_state; // usado para habilitar desabilitar saída do Módulo AD98333 bool set_frequency_hz = 1; // Frequência padrão do Módulo AD9833 bool set_frequency_khz; bool set_frequency_mhz; String waveSelect = "SIN"; // Forma de onda de inicialização do módulo int encoder_btn_count = 0; // usado para verificar o botão do codificador, pressione Em seguida, temos nossos dois objetos, um é para o display OLED e outro é para o módulo AD9833.Exibição Adafruit_SSD1306 (SCREEN_WIDATA_PINH, SCREEN_HEIGHT, & Wire, -1); AD9833 gen (FNC_PIN);

Em seguida, temos nossa função setup (), nessa função de configuração, começamos habilitando o Serial para depuração. Inicializamos o módulo AD9833 com a ajuda do método begin (). Em seguida, definimos todos os pinos do codificador rotativo atribuídos como Entrada. E armazenamos o valor do pino do clock na variável clockPinState, esta é uma etapa necessária para o codificador rotativo.

Em seguida, definimos todos os pinos do botão como entrada e habilitamos a exibição OLED com a ajuda do método display.begin () e também verificamos se há erros com uma instrução if . Quando isso é feito, limpamos a tela e imprimimos uma tela inicial de inicialização, adicionamos um atraso de 2 segundos que também é o atraso da tela inicial e, finalmente, chamamos a função update_display () que limpa a tela e atualiza o exibir mais uma vez. Os detalhes do método update_display () serão discutidos posteriormente neste artigo.

void setup () {Serial.begin (9600); // Habilita Serial @ 9600 baud gen.Begin (); // Este DEVE ser o primeiro comando após declarar o objeto AD9833 pinMode (CLK_PIN, INPUT); // Configurando Pins como entrada pinMode (DATA_PIN, INPUT); pinMode (BTN_PIN, INPUT_PULLUP); clockPinState = digitalRead (CLK_PIN); pinMode (SET_FREQUENCY_HZ, INPUT); // Definindo pinos como entrada pinMode (SET_FREQUENCY_KHZ, INPUT); pinMode (SET_FREQUENCY_MHZ, INPUT); pinMode (ENABLE_DISABLE_OUTPUT_PIN, INPUT); if (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// Endereço 0x3D para 128x64 Serial.println (F ("SSD1306 alocação falhou")); para (;;); } display.clearDisplay (); // Limpa a tela display.setTextSize (2); // Definir tamanho do texto display.setTextColor (WHITE); // define a cor do LCD display.setCursor (30, 0); // Definir posição do cursor display.println ("AD9833"); // Imprima esta tela de texto.setCursor (17, 20); // Define a posição do cursor display.println ("Function"); // Imprime este texto display.setCursor (13, 40); // Define a posição do cursor display.println ("Generator"); // Imprime este Texto display.display (); // Atualiza o Display delay (2000); // Atraso de 2 SEC update_display (); // Chame a função update_display}

Em seguida, temos nossa função loop (), todas as principais funcionalidades são escritas na seção de loop.

Primeiro, lemos o pino Clock do codificador Rotary e o armazenamos na variável clockPin que declaramos anteriormente. A seguir, na instrução if , verificamos se o valor anterior do pino e o valor atual do pino são semelhantes ou não e também verificamos o valor atual do pino. Se for tudo verdade, verificamos o pino de dados; se for verdade, isso significa que o codificador está girando no sentido anti - horário e diminuímos o valor do contador com a ajuda do comando counter--. Caso contrário, incrementamos o valor do contador com o comando counter ++. Finalmente, colocamos outra instrução if para definir o valor mínimo para 1. Em seguida, atualizamos o clockPinState com o clockPin atualvalor para uso futuro.

loop vazio () {clockPin = digitalRead (CLK_PIN); if (clockPin! = clockPinState && clockPin == 1) {if (digitalRead (DATA_PIN)! = clockPin) {contador -; } else {contador ++; // O codificador está girando no sentido horário, então incremente} if (contador <1) contador = 1; Serial.println (contador); update_display (); }

Em seguida, temos nosso código para detectar o pressionamento de um botão. Nesta seção, detectamos o botão dentro do codificador com a ajuda de algumas declarações if aninhadas, if (digitalRead (BTN_PIN) == LOW && millis () - tempo> denunciar), nesta declaração, primeiro verificamos se o botão o pino está baixo ou não, se estiver baixo, então está pressionado. Então, novamente verificamos o valor do temporizador com o atraso de debounce, se ambas as declarações forem verdadeiras, então declaramos que foi uma ação de pressionamento de botão bem-sucedida, se assim for, incrementamos o valor encoder_btn_count. Em seguida, declaramos outra instrução if para definir o valor máximo do contador para 2, precisamos dela porque a estamos usando para definir a forma de onda de saída.As três declarações if consecutivas fazem isso, se o valor for zero, a forma de onda senoidal é selecionada, se for um, é uma onda quadrada e se o valor for 2, é uma onda triangular. Em todas essas três instruções if, atualizamos a tela com a função update_display () . E, finalmente, atualizamos a variável de tempo com o valor atual do contador do temporizador.

// Se detectarmos um sinal LOW, o botão é pressionado if (digitalRead (BTN_PIN) == LOW && millis () - tempo> debounce) {encoder_btn_count ++; // Incrementa os valores if (encoder_btn_count> 2) // se o valor é maior que 2, redefina-o para 0 {encoder_btn_count = 0; } if (encoder_btn_count == 0) {// se o valor for 0 onda senoidal é selecionada waveSelect = "SIN"; // atualiza a variável da string com o valor sin update_display (); // atualiza o display} if (encoder_btn_count == 1) {// se o valor for 1 onda quadrada é selecionado waveSelect = "SQR"; // atualiza a variável da string com o valor SQR update_display (); // atualiza o display} if (encoder_btn_count == 2) {// se o valor é 1 Onda triangular é selecionada waveSelect = "TRI"; // atualiza a variável string com o valor TRI update_display ();// atualiza o display} time = millis (); // atualize a variável de tempo}

Em seguida, definimos todo o código necessário para configurar todos os botões com um atraso de depuração. Como os botões estão conectados aos pinos analógicos do Arduino, estamos usando o comando de leitura analógica para identificar um pressionamento de botão se o valor da leitura analógica atingir abaixo de 30, então detectamos o pressionamento de um botão bem-sucedido e esperamos 200 ms para verifique se é um toque de botão real ou apenas um ruído. Se esta afirmação for verdadeira, atribuímos às variáveis booleanas valores que são usados para definir os valores Hz, Khz e Mhz do gerador de função. Em seguida, atualizamos a exibição e atualizamos a variável de tempo. Fazemos isso para todos os quatro botões conectados ao Arduino.

if (analogRead (SET_FREQUENCY_HZ) <30 && millis () - tempo> debounce) {set_frequency_hz = 1; // atualiza os valores booleanos set_frequency_khz = 0; set_frequency_mhz = 0; update_display (); // atualizar o tempo de exibição = millis (); // atualizar a variável de tempo} if (analogRead (SET_FREQUENCY_KHZ) <30 && millis () - time> debounce) {set_frequency_hz = 0; // atualiza os valores booleanos set_frequency_khz = 1; set_frequency_mhz = 0; moduleFrequency = contador * 1000; update_display (); // atualizar o tempo de exibição = millis (); // atualizar a variável de tempo} if (analogRead (SET_FREQUENCY_MHZ) <30 && millis () - tempo> debounce) {// verificar o pino analógico com atraso de debounce set_frequency_hz = 0; // atualiza os valores booleanos set_frequency_khz = 0; set_frequency_mhz = 1; moduleFrequency = counter * 1000000; update_display ();// atualiza o tempo de exibição = millis (); // atualiza a variável de tempo} if (analogRead (ENABLE_DISABLE_OUTPUT_PIN) <30 && millis () - tempo> debounce) {// verificar o pino analógico com atraso de debounce btn_state =! btn_state; // Inverte o estado do botão gen.EnableOutput (btn_state); // Habilita / desabilita a saída do gerador de função dependendo do estado do botão update_display (); // atualiza o tempo de exibição = millis (); // atualiza a variável de tempo}}// atualize a variável de tempo}}// atualize a variável de tempo}}

Finalmente, temos nossa função update_display (). Nesta função, fizemos muito mais do que apenas atualizar este display porque uma certa parte do display não pode ser atualizada em um OLED. Para atualizá-lo, você deve pintá-lo com novos valores. Isso torna o processo de codificação muito mais difícil.

Dentro desta função, começamos limpando a tela. Em seguida, definimos nosso tamanho de texto necessário. Depois disso, configuramos nosso cursor e imprimimos o Gerador de função com display.println ("Função de função"); comando. Definimos novamente o tamanho do texto para 2 e o cursor para (0,20) com a ajuda da função display.setCursor (0, 20).

É aqui que imprimimos as informações de que onda é.

display.clearDisplay (); // Primeiro limpe o display display.setTextSize (1); // define o tamanho do texto display.setCursor (10, 0); // Define a posição do cursor display.println ("Function Generator"); // imprimir o texto display.setTextSize (2); // definir o texto Tamanho display.setCursor (0, 20); // Definir a posição do cursor

Em seguida, verificamos as variáveis booleanas para obter detalhes de frequência e atualizamos o valor na variável moduleFrequency. Fazemos isso para os valores Hz, kHz e MHz. A seguir, verificamos a variável waveSelect e identificamos qual onda está selecionada. Agora, temos os valores para definir o tipo de onda e a frequência.

if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {// verifique se o botão para definir a frequência em Hz está pressionado moduleFrequency = counter; // atualize a variável moduleFrequency com o valor do contador atual} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {// verifique se o botão para definir a frequência em KHz está pressionado moduleFrequency = counter * 1000; // atualize a variável moduleFrequency com o valor do contador atual, mas multiplicamos 1000 para defini-lo em KHZ} se (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {// verifique se o botão para definir a frequência em MHz está pressionado moduleFrequency = contador * 1000000; if (moduleFrequency> 12000000) {moduleFrequency = 12000000;// não deixe a frequência ser maior que o contador de 12Mhz = 12; }} if (waveSelect == "SIN") {// A onda senoidal é selecionada display.println ("SIN"); gen.ApplySignal (SINE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "SQR") {// A onda Sqr é selecionada display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave é selecionado display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // atualize o módulo AD9833. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// A onda Sqr é selecionada display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave é selecionado display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // atualize o módulo AD9833. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// A onda Sqr é selecionada display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave é selecionado display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // atualize o módulo AD9833. Serial.println (moduleFrequency); }

Ajustamos o cursor novamente e atualizamos os valores do contador. Mais uma vez verificamos o booleano para atualizar a faixa de frequência no display, temos que fazer isso porque o princípio de funcionamento do OLED é muito estranho.

display.setCursor (45, 20); display.println (contador); // imprime as informações do contador no display. if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Hz"); // imprime Hz no display display.display (); // quando tudo configurado, atualize o display} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Khz"); display.display (); // quando tudo definido atualiza o display} if (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {display.setCursor (90, 20); display.println ("Mhz"); display.display (); // quando tudo pronto atualiza o display}

A seguir, verificamos a variável de pressionamento de botão para imprimir a saída ligada / desligada no OLED. Novamente, isso precisa ser feito por causa do módulo OLED.

if (btn_state) {display.setTextSize (1); display.setCursor (65, 45); display.print ("Saída LIGADA"); // imprime a saída no display display.display (); display.setTextSize (2); } else {display.setTextSize (1); display.setCursor (65, 45); display.print ("Saída DESLIGADA"); // imprime a saída no display display.display (); display.setTextSize (2); }

Isso marca o fim do nosso processo de codificação. Se você estiver confuso neste ponto, pode verificar os comentários no código para melhor compreensão.

Testando o Gerador de Função Baseado em AD9833

Para testar o circuito, a configuração acima é usada. Como você pode ver, conectamos um adaptador de alimentação de 12 Vcc ao conector de barril CC e conectamos o osciloscópio Hantek à saída do circuito. Também conectamos o osciloscópio ao laptop para visualizar e medir a frequência de saída.

Feito isso, definimos a frequência de saída para 5Khz com a ajuda do codificador rotativo e testamos a onda senoidal de saída e, com certeza, é uma onda senoidal de 5Khz na saída.

Em seguida, alteramos a forma de onda de saída para uma onda triangular, mas a frequência permaneceu a mesma, a forma de onda de saída é mostrada abaixo.

Então mudamos a saída para uma onda quadrada e observamos a saída, e era uma onda quadrada perfeita.

Também alteramos as faixas de frequência e testamos a saída, e ela estava funcionando bem.

Outras melhorias

Este circuito é apenas uma prova de conceito e precisa de mais melhorias. Primeiro, precisamos de uma placa de circuito impresso de boa qualidade e um conector BNC de boa qualidade para a saída, caso contrário, não poderemos obter uma frequência mais alta. A amplitude do módulo é muito baixa, então para melhorar isso, precisamos de alguns circuitos de amplificador operacional para amplificar a tensão de saída. Um potenciômetro pode ser conectado para variar a amplitude de saída. Um interruptor para compensar o sinal pode ser conectado; este também é um recurso obrigatório. Além disso, o código precisa de muitas melhorias, pois é um pouco problemático. Finalmente, as telas OLED precisam ser alteradas, caso contrário, será impossível escrever um código facilmente compreensível.

Isso marca o fim deste tutorial, espero que tenha gostado do artigo e aprendido algo novo. Se você tiver alguma dúvida sobre o artigo, pode deixá-la na seção de comentários abaixo ou pode usar nosso Fórum de Eletrônica.