Se você já trabalhou com Arduino em projetos de áudio, provavelmente se deparou com uma limitação clássica: a maioria das placas não consegue gerar um sinal analógico de verdade. A saída disponível é PWM, e embora dê para contornar com filtros, o resultado nunca é lá essas coisas.
O Arduino Nano R4 muda esse cenário. Ele conta com um DAC (Conversor Digital-Analógico) nativo de 12 bits, capaz de gerar sinais analógicos reais, com muito mais fidelidade e sem os ruídos típicos do PWM. E é exatamente isso que vamos explorar neste projeto.
Vamos construir um sintetizador com Arduino Nano R4: um pequeno instrumento eletrônico capaz de gerar ondas senoidais, quadradas e dente-de-serra, com frequência controlada por potenciômetro e troca de forma de onda por botão. Simples, funcional e com som de verdade.
Ao longo do tutorial você vai entender como o DAC funciona na prática, ver duas abordagens diferentes de implementação e sair com um projeto de áudio com Arduino que pode ser a base para criações muito mais elaboradas.
Pronto para transformar sua placa em um instrumento? Vamos lá!
Por que usar DAC para áudio?
Um sinal de áudio é, essencialmente, um sinal analógico – pode assumir qualquer nível dentro de uma faixa. Muitos microcontroladores não são capazes de gerar diretamente um sinal analógico.
Uma solução comum é simular um sinal analógico usando um sinal PWM (Pulse Width Modulation). Um sinal PWM muda constantemente entre dois níveis fixos; a relação entre os tempos que permanece em cada nível altera o nível médio do sinal.
Saiba mais em: O que é PWM? Aprenda a usar o sinal PWM com Arduino.
Para gerar um sinal de áudio, o sinal PWM passa por um filtro passa-baixas, composto por um resistor e um capacitor:
Saiba mais em: Filtro passa baixa vs passa alta: entenda as diferenças
Embora esta solução seja bastante simples e possa ser usada com qualquer microcontrolador que suporte PWM, o resultado é um sinal de baixa fidelidade.
Utilizando-se um DAC (Digital to Analog Converter), é possível gerar um sinal com maior fidelidade.
O que é DAC e como ele funciona?
Um DAC é um conversor digital analógico – ele converte um valor digital em uma tensão.
A precisão do sinal gerado depende do número de bits no valor digital, da faixa de tensão gerada, e da linearidade do conversor. Por exemplo, um DAC de 8 bits ideal, que converta um número de 0 a 255 em uma tensão de 0 a 5V, terá uma precisão de 5V/255 = 0,02 mV (aproximadamente).
Embora a saída do DAC não seja plenamente analógica, ela pode ter um número grande de níveis (2 elevado ao número de bits na entrada).
DACs são usados atualmente nos sistemas mais comuns de áudio, onde o sinal de áudio é transmitido ou armazenado de forma digital. Por exemplo, em CDs, DVDs, streaming e placas de som.
DAC no Arduino Uno R4 e Nano R4
O microcontrolador RA4M1 usado nos Arduino Uno R4 e no Arduino Nano R4 possui o recurso DAC interno. Este DAC é de 12 bits, o que dá uma precisão muito grande.
O ambiente Arduino inclui uma função analogWrite(). Originalmente este função gerava sinais PWM, porém ela utiliza o recurso DAC quando a placa os disponibiliza e o pino especificado é um dos pinos suportados pelo DAC.
No Uno R4 e Nano R4 um único pino é suportado: A0. A resolução padrão do analogWrite() é 8 bits, porém ela pode ser aumentada para 12 bits através da chamada analogWriteResolution(12); é também possível usar uma resolução de 10 bits.
Maior resolução resulta em uma onda mais fiel
A faixa de saída do DAC destas placas é de +0.35 V a +4.5 V. Reparar que não é possível gerar tensões negativas ou mesmo 0V. O resultado é que se você gerar uma onda senoidal, por exemplo, ela estará deslocada para cima do zero (tecnicamente dizemos que o sinal tem um componente DC). Um capacitor em série na saída do DAC absorve esta componente, deixando a média do sinal nos 0V.
Sintetizador com Arduino Nano R4: Materiais necessários
Neste projeto vamos gerar um mini sintetizador de sons, usando um Arduino Nano R4. A frequência será determinada por um potenciômetro ligado a uma entrada analógica e a forma do sinal (senoidal, quadrada ou dente-de-serra) será selecionada por botões..
Um módulo amplificador (usando o integrado LM386) será usado para a ligação de um alto-falante.
Abaixo estão os componentes utilizados no projeto:
- Arduino Nano R4
- Módulo Amplificador
- Potenciômetro linear de 1k
- 3 botões push-button
- Alto falante 2W
- Capacitor de 100nF
- Protoboard
- Fios para interconexão
Sintetizador com Arduino Nano R4: Esquemático
Preparação da IDE Arduino para uso do Nano R4
Siga os seguintes passos antes de conectar a placa ao micro:
- Abra o Gerenciador de Placas
- Digite “Nano R4” no filtro
- Clique no botão Install no item “Arduino Uno R4 Boards”
Aguarde o final da instalação (pode demorar um pouco e pedir confirmação para instalar os drivers) e conecte a placa.
Abra a seleção de placa e porta e escolha “Select other board and port…”. Digite “nano r4” na caixa de seleção, selecione a opção “Arduino Nano R4”, selecione a porta que foi associada à placa e clique em Ok.
Sintetizador com Arduino Nano R4: Código (primeira versão)
Nesta primeira versão vamos usar o analogWrite() para definir a tensão em cada trecho da nossa saída.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 |
/* Mini Sintetizador com DAC usando Arduino Nano R4 Versão 1 - Usando analogWrite() */ // Conexões #define PINO_DAC A0 #define PINO_POT_FREQ A1 #define PINO_BOTAO_QUAD 2 #define PINO_BOTAO_SENO 3 #define PINO_BOTAO_SERRA 4 // Amplitude do sinal de saida (mv) #define AMPLITUDE 1000 #define DAC_MAX (4096*AMPLITUDE/5000) // Frequencia #define FREQ_MIN 100 #define FREQ_MAX 4000 #define PASSOS 16 #define OVERHEAD 200 int freq_atual_hz = 1000; int periodo_us = 1000000 / freq_atual_hz; int passo_us = (periodo_us - OVERHEAD)/PASSOS; // Controle dos botões typedef enum { DESLIGADO = 0, QUADRADA = 1, SENOIDE = 2, SERRA = 4 } MODO; MODO modo_atual = DESLIGADO; int estado_atual = DESLIGADO; // Tabela de valores para gerar senoide e onda dente-de-serra int senoide[PASSOS]; int serra[PASSOS]; // Iniciação void setup() { // Configura os pinos pinMode (PINO_BOTAO_QUAD, INPUT_PULLUP); pinMode (PINO_BOTAO_SENO, INPUT_PULLUP); pinMode (PINO_BOTAO_SERRA, INPUT_PULLUP); //pinMode (PINO_POT_FREQ, INPUT); analogWriteResolution(12); analogWrite(PINO_DAC, 0); Serial.begin(115200); // Calcular valores para senoide for (int passo = 0; passo < PASSOS; passo++) { senoide[passo] = round(DAC_MAX/2 + DAC_MAX/2*sin(2.0*M_PI*passo/PASSOS)); } // Calcular valores para onda dente de serra for (int passo = 0; passo < PASSOS; passo++) { serra[passo] = round(DAC_MAX*passo/PASSOS); } } // Laço Principal - eterno enquanto dure void loop() { // Le o potenciômetro e determina a frequência int freq_nova = map(analogRead(PINO_POT_FREQ),0,1024, FREQ_MIN, FREQ_MAX); if ((100*abs(freq_nova - freq_atual_hz)/freq_atual_hz) > 10) { // Só atualiza se mudou mais de 10% freq_atual_hz = freq_nova; periodo_us = 1000000 / freq_atual_hz; passo_us = (periodo_us - OVERHEAD)/PASSOS; } // Trata os botões int estado_novo = 0; if (digitalRead(PINO_BOTAO_QUAD) == LOW) { estado_novo |= QUADRADA; } if (digitalRead(PINO_BOTAO_SENO) == LOW) { estado_novo |= SENOIDE; } if (digitalRead(PINO_BOTAO_SERRA) == LOW) { estado_novo |= SERRA; } if (estado_novo != estado_atual) { // verifica se algum botão foi solto int soltou = estado_atual & ~estado_novo; estado_atual = estado_novo; if (soltou & QUADRADA) { modo_atual = (modo_atual == QUADRADA) ? DESLIGADO : QUADRADA; } else if (soltou & SENOIDE) { modo_atual = (modo_atual == SENOIDE) ? DESLIGADO : SENOIDE; } else if (soltou & SERRA) { modo_atual = (modo_atual == SERRA) ? DESLIGADO : SERRA; } if (modo_atual == DESLIGADO) { analogWrite(PINO_DAC, 0); } } // Gera um periodo da onda int passo; switch (modo_atual) { case DESLIGADO: delayMicroseconds(periodo_us); break; case QUADRADA: for (passo = 0; passo < PASSOS/2; passo++) { analogWrite(PINO_DAC, 0); delayMicroseconds(passo_us); } for (;passo < PASSOS; passo++) { analogWrite(PINO_DAC, DAC_MAX); delayMicroseconds(passo_us); } break; case SENOIDE: for (passo = 0; passo < PASSOS; passo++) { analogWrite(PINO_DAC, senoide[passo]); delayMicroseconds(passo_us); } break; case SERRA: for (passo = 0; passo < PASSOS; passo++) { analogWrite(PINO_DAC, serra[passo]); delayMicroseconds(passo_us); } break; } } |
No setup() iniciamos os vários pinos que vamos usar:
- Os pinos x,y e z são configurados como entradas com pull-up. Neles estão ligados os três botões. Quando um botão está solto, o pull-up faz com que a leitura resulte em nível alto. Quando o botão é apertado o pino é ligado à terra; a leitura resultará em nível baixo.
- O pino A5 será usado como entrada analógica para leitura do potenciômetro e não necessita de iniciação.
- O pino A0 será usado como saída analógica; na iniciação configuramos a resolução que será usada.
Ainda no setup, pré-calculamos as tensões para geração das ondas senoidais e dente-de-serra. A amplitude máxima é restrita a 1,0V (ver o define AMPLITUDE) para ficar mais adequada ao módulo amplificador.
O loop() precisa cuidar de três coisas:
- A tensão no pino A5 (determinada pelo potenciômetro) é lida e usada para determinar a frequência do sinal que será usado. Vamos gerar frequências de 100 Hz a 4 KHz.
- O estado dos botões é lido e comparado com o anterior. A função correspondente é acionada quando um botão é solto.
- Por último é gerado um ciclo completo do sinal de saída, conforme o tipo e frequência selecionados.
Sintetizador com Arduino Nano R4: Testando o sinal no osciloscópio
Podemos observar a onda gerada conectando um osciloscópio entre os pinos DAC e terra. Gire o potenciômetro para o extremo de máxima frequência e aperte o botão de onda quadrada.
Selecione acoplamento AC no osciloscópio para centrar a onda no 0V ou DC para ver as tensões reais. Ajuste o eixo vertical para 0,5V por divisão e o horizontal para 50μs por divisão. Ajuste o nível de trigger se necessário. Ou, se o seu osciloscópio tiver este recurso, use o ajuste automático.
O sinal gerado apresenta alguns problemas, veja o próximo item
Limitações da primeira versão
Um problema da forma como o sinal é gerado é que entre cada ciclo temos um pequeno período com a saída em nível zero enquanto o potenciômetro e os botões são amostrados. Durante a geração do sinal o processador fica preso nesta tarefa, a velocidade do analog_write também limita a frequência máxima que pode ser gerada (o define OVERHEAD tenta compensar isso)..
Um outro problema é uma falha na implementação atual do analog_write nos modelos R4: a cada analog_write a tensão de saída assume momentaneamente um valor alto, o que pode ser visto na figura anterior.
Sintetizador com Arduino Nano R4: Código (segunda versão)
Para obter um melhor desempenho do DAC, o ambiente Arduino disponibiliza a biblioteca analogWave junto com o suporte aos modelos R4. Ela utiliza o recurso de DMA, no qual dados na memória são movidos diretamente ao periférico DAC, sem interferência direta do processador.
Com esta biblioteca conseguimos gerar sinais de melhor qualidade e com frequência mais alta. Entretanto ela tem algumas limitações (pelo menos no momento):
- A forma da onda é escolhida na iniciação e não pode ser alterada durante a execução do programa.
- O uso do DMA interfere na comunicação USB. Para carregar um novo sketch é necessário um procedimento especial.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 |
/* Mini Sintetizador com DAC usando Arduino Nano R4 Versão 2 - Usando analogWave */ #include "analogWave.h" analogWave wave(DAC); // Conexões #define PINO_POT_FREQ A1 #define PINO_BOTAO_QUAD 2 #define PINO_BOTAO_SENO 3 #define PINO_BOTAO_SERRA 4 // Frequencia #define FREQ_MIN 100 #define FREQ_MAX 10000 int freq_atual_hz = 1000; // Controle dos botões typedef enum { DESLIGADO = 0, QUADRADA = 1, SENOIDE = 2, SERRA = 4 } MODO; MODO modo_atual = DESLIGADO; int estado_atual = DESLIGADO; // Iniciação void setup() { // Configura os pinos pinMode (PINO_BOTAO_QUAD, INPUT_PULLUP); pinMode (PINO_BOTAO_SENO, INPUT_PULLUP); pinMode (PINO_BOTAO_SERRA, INPUT_PULLUP); pinMode (PINO_POT_FREQ, INPUT); wave.amplitude(1.0/5.0); // Determina o tipo de onda a gerar while (modo_atual == DESLIGADO) { int estado_novo = 0; if (digitalRead(PINO_BOTAO_QUAD) == LOW) { estado_novo |= QUADRADA; } if (digitalRead(PINO_BOTAO_SENO) == LOW) { estado_novo |= SENOIDE; } if (digitalRead(PINO_BOTAO_SERRA) == LOW) { estado_novo |= SERRA; } if (estado_novo != estado_atual) { // verifica se algum botão foi solto int soltou = estado_atual & ~estado_novo; estado_atual = estado_novo; if (soltou & QUADRADA) { modo_atual = QUADRADA; } else if (soltou & SENOIDE) { modo_atual = SENOIDE; } else if (soltou & SERRA) { modo_atual = SERRA; } } } // Atualiza a forma de onda switch (modo_atual) { case QUADRADA: wave.square(freq_atual_hz); break; case SENOIDE: wave.sine(freq_atual_hz); break; case SERRA: wave.saw(freq_atual_hz); break; } } // Laço Principal - eterno enquanto dure void loop() { // Le o potenciômetro e determina a frequência int freq_nova = map(analogRead(PINO_POT_FREQ), 0, 1024, FREQ_MIN, FREQ_MAX); if ((100*abs(freq_nova - freq_atual_hz)/freq_atual_hz) > 10) { // Só atualiza se mudou mais de 10% freq_atual_hz = freq_nova; Serial.println(freq_nova); wave.freq(freq_atual_hz); } } |
Após executar este programa, a porta serial não estará mais disponível na USB. Para carregar um programa no Nano R4 siga os seguintes passos:
- Pressione duas vezes o botão de Reset, com intervalo de menos de 0,5 segundo.
- O LED laranja passará a pulsar, ficando continuamente mais forte e mais fraco
- Na IDE Arduino aparecerá uma nova opção de porta serial (no Windows aparece algo como “2-9”). Selecione esta porta.
- Dispare a carga do programa
A onda gerada é bem melhor do que obtivemos com o analogWrite:
Operação e Demonstração
A operação do projeto é bastante simples:
- Pressione um dos botões para escolher a forma de onda
- Gire o potenciômetro para mudar a frequência
- Se necessário, use uma chave de fenda para girar o trimpot no módulo amplificador e ajustar o volume
Na primeira versão, você pode interromper a geração de som apertando uma segunda vez o botão de seleção da forma de onda e alterar a forma de onda a qualquer momento apertando um dos outros botões.
Na segunda versão, para interromper a geração de som e selecionar uma outra forma de onda é necessário apertar primeiro o botão de Reset no Arduino Nano R4.
O vídeo abaixo mostra a operação (estou usando a segunda versão do código).
Conclusão
O recurso de DAC do Arduino Nano R4 é bastante poderoso, apesar de algumas limitações na versão atual do suporte na IDE Arduino.
Você tem algum projeto em mente que pode usar o recurso do DAC? Conte para nós nos comentários.
