Como usar o sensor de som MAX9814

Como usar o MAX9814

Em muitos projetos de eletrônica de aplicação sonora, é necessário o uso de um sensor de som, o MAX9814 é uma ótima opção para esses casos, o mesmo pode ser utilizado em dispositivos como: Fones de ouvido Bluetooth, Karaokês, gravadores portáteis, câmeras digitais, telefones IP, comunicadores bidirecionais, entre outros. Esse tutorial será dividido nos seguintes tópicos, clique em algum título para ir ao trecho correspondente.

Sensor Max9814

Materiais para teste do módulo Sensor Max9814

Teste do Max9814

Ajuste de ganho

Attack e Release (Pino AR)

Conclusão
 

Sensor MAX9814

O Sensor MAX9814 é uma placa que conta com um microfone de eletredo de 20-20KHz, sendo que o módulo é projetado com um CI destinado a amplificação, o Max9814, agindo em conformidade com a onda sonora.

De forma mais detalhada, o circuito integrado garante ao módulo controle automático de ganho (AGC) para equilibrar o valor lido na entrada, sendo que quando o som detectado é excessivamente alto, o controle o abaixa para que não haja uma sobrecarga no amplificador, e em caso contrário, em que a onda sonora está muito baixa, o amplificador aumenta para que seja realizada a perfeita leitura.

Além disso, é possível configurar o ganho máximo por decibéis, o módulo é pré-configurado para 60dB, mas esse valor pode ser modificado para 50dB ou 40dB, veremos isso na prática mais adiante, outrossim, ainda existe a opção de alterar a proporção de attack/release, de 1:4000 (padrão),  para 1:2000 ou 1:5000.

No CI do módulo, ocorrem três amplificações, o pré amplificador de baixo ruído (LNA) tem um ganho fixo de 12dB, enquanto que no segundo amplificador, o ganho VGA se ajusta automaticamente de 0dB a 20dB, de acordo com o limite do AGC, e o amplificador de saída oferece ganhos variáveis de 8dB, 18dB e 28dB, de acordo com a configuração do Gain. 

Segue diagrama de blocos do CI, retirado do seu respectivo datasheet.

Um dispositivo sem o AGC apresenta cortes no sinal de saída quando muito ganho é aplicado à entrada, sendo que o AGC impede esse corte, identificando quando o sinal excede o limite predefinido, o ganho do ACG é então reduzido para realizar essa correção e não prejudicar a amostragem obtida graficamente.

Essa imagem retirada do datasheet do CI ilustra a diferença de um sensor sem o AGC e com o AGC, note que com o uso do AGC não há corrupção do sinal gerado.

Informações sobre o módulo:

• Tensão de alimentação: 2,7 a 5,5VDC;
• Ganho total: 40dB, 50dB e 60dB;
• Ganho do pré-amplificador: 12dB;
• Ganho VGA: 20dB a 0dB;
• Ganho do amplificador de saída: 8dB/ 18Db/28dB;
• Temperatura de operação: -40°C a 85°C;
• Densidade de ruído: 30nV/ (baixa);
• THD: 0,04% de ponta;
• Polarização interna do microfone: 2V (baixo ruído);
• Tempo de espera do AGC: 30ms;

Para mais informações, confira o datasheet do CI e do módulo.

Datasheet do Módulo

Folha de dados do CI

Agora que você já conheceu o sensor de forma teórica, partiremos para a análise prática do seu funcionamento.

Materiais para teste do Módulo Sensor Max9814

01- Arduino Uno Compatível com Cabo USB;

01- Led Difuso Vermelho- 3mm

01- Sensor de Som - Eletredo AGC- MAX9814;

01- Kit de Jumpers macho-macho


Teste do MAX9814

Com todos os materiais em mãos, iniciaremos a montagem conforme imagem abaixo, não é necessário o uso de um resistor para diminuir a tensão encima do LED, pois a tensão em OUT será de aproximadamente 1,2~2V.

Com o circuito montado, faremos a programação para teste de funcionamento.

Primeiramente declararemos as nossas variáveis e constantes, a constante inteira “janeladeamostra” será de 1000ms (1s) e equivale ao intervalo entre cada exibição de dados coletados pelo sensor, o tempo pode ser alterado mediante a necessidade.

const int janeladeamostra = 1000;
unsigned int amostra;

No void setup definiremos o baud rate do nosso monitor serial, mas primeiramente eu darei uma breve definição do que é o Baud rate.

Segundo o livro IBM Personal Computers and the Michigan Terminal System, a taxa de transmissão de dados normalmente é medida em Baud (Baud rate), que por sua vez, corresponde à taxa de bits transmitidos por segundo, sendo que a taxa de transmissão de caracteres é de um décimo da taxa de Baud.

Agora que já temos uma noção do que é Baud rate, veja o trecho da programação em que é feita essa definição.

void setup ()
{
   Serial.begin(115200);
}

Em seguida abriremos o laço de repetição, o Void loop, esse laço será responsável por realizar todas as leituras do sensor, primeiro faremos as declarações necessárias para isso.

void loop ()/*laço de repetição */
{
   unsigned long iniciaMs= millis();  
   unsigned int PicoaPico = 0;   
   unsigned int sinalMax = 0;  
   unsigned int sinalMin = 1024;

A princípio pode parecer confuso o envio de 0 para o sinalMax e 1024 para o sinalMin, mas isso já será explicado com o restante da programação.

while (millis() - iniciaMs < janeladeamostra) 
  { 
    amostra = analogRead(0); 
    if (amostra < 1024) 
    { 
      if (amostra > sinalMax) 
       { 
         sinalMax = amostra; 
       } 
       else if (amostra < sinalMin)
       { 
         sinalMin = amostra; 
        } 
      } 
    }

Este trecho demarcado corresponde a leitura do sensor, eu defini que essa leitura fosse repetida diversas vezes no período de 1s, vamos dissecar essa etapa:

Supondo que temos uma leitura de 200 no A0, isso corresponde a nossa amostra.

Então temos que

      if (amostra < 1024)  
      {

Nesse trecho estamos perguntando se a amostra é menor que 1024, no caso do exemplo é 200, então partiremos para a próxima parte do programa.

if (amostra > sinalMax) 
         {

Se 200 for maior que o sinalMax, que é 0, seguimos.

Note que ambas as perguntas sempre serão afirmativas, pois a medição nunca será maior do que 1024 e menor do que 0, mas continuaremos para que você entenda o propósito.

Confirmado os dois fatores, definimos que o valor de sinalMax será o sinal da amostra, ou seja, o 0 agora será 200.

sinalMax = amostra;

Continuando, se a amostra for menor que o sinalMin (1024), vamos para a linha seguinte.

else if (amostra < sinalMin) 
         {

Então o sinalMin será igual ao valor de amostra, que no caso é 200.

sinalM
in = amostra;

Esse procedimento é repetido durante 1s, com os novos valores de sinalMax e sinalMin.

sinalMax = 200

sinalMin = 200

Agora vamos supor que a próxima amostra lida é de 205:

 
amostra = analogRead(0);       
if (amostra < 1024)  /* se amostra(205) é menor do que 1024 √ */ 
 {          
 if (amostra > sinalMax) /* se amostra(205) é maior do que sinalMax(200) √  */ 
   {             
    sinalMax = amostra; /* o valor de sinalMax vai de 200 ->205 */    
  }          
else if (amostra < sinalMin) /* amostra (205) é menor do que sinalMin(200) x */

Como nessa última linha a suposição não é afirmativa, então o programa não vai para a próxima e encerra esse ciclo com:

sinalMax= 205

sinalMin = 200

E dessa forma esses valores vão sendo renovados durante 1s, sendo que ao término é feita a seguinte operação para apresentar o valor em volts no nosso monitor serial.

Primeiro é definido o valor de pico a pico através da subtração (sinalMax-sinalMin).

PicoaPico = sinalMax - sinalMin;

E em seguida aplicamos a fórmula para a conversão do valor análogico na sua representação em volts

double volts = (PicoaPico * 5.0) / 1024;

E por fim printamos na tela com o seguinte comando:

Serial.println(volts);

O programa completo está disponível abaixo, basta copiar, colar na IDE, selecionar a sua placa, porta e carregar.

 
/******************************************************
Exemplo do site Adafruit
Comentários e modificações de autoria da Curto Circuito
******************************************************/
 
const int janeladeamostra = 1000; /* constante inteira "janeladeamostra" é de 1000 (1s para cada medição) */
unsigned int amostra; /* variável inteira de nome "amostra" */
 
void setup ()/* laço de configuração */
{
   Serial.begin(115200); /* Baud rate de 115200 */
}
 
 
void loop()  /* laço de repetição */
{
   unsigned long iniciaMs= millis();  /* Inicio da janela de amostra */
   unsigned int PicoaPico = 0;   /* Nível de pico a pico */
   unsigned int sinalMax = 0;  /* declara sinalMax com valor 0 */
   unsigned int sinalMin = 1024; /* declara sinalMin com valor 1024 */
 
   /* coleta dados por 1000ms (1s) */
   while (millis() - iniciaMs < janeladeamostra)
   {
      amostra = analogRead(0); /* a amostra é equivalente ao valor lido pelo analógico em A0 */
      if (amostra < 1024)  /* se a amostra é menor do que */
      {
         if (amostra > sinalMax) /* se a amostra é maior que 0 */
         {
            sinalMax = amostra;  /* o valor de sinalMax vai de 0 -> amostra */
         }
         else if (amostra < sinalMin) /* se a amostra é menor que 1024 */
         {
            sinalMin = amostra;  /* amostra -> 1024 */
         }
      }
   }
   PicoaPico = sinalMax - sinalMin;  /* sinalMax - sinalMin = amplitude de pico a pico */
   double volts = (PicoaPico * 5.0) / 1024;  /* converte para volts */
 
   Serial.println(volts); /* printa volts no monitor serial */
}

Agora analisaremos o funcionamento do nosso sensor.

Conforme pode ser visto no gif, o led acende quando o dedo é estalado, esse teste também pode ser feito com o uso de uma música, o led acenderá no mesmo ritmo da música, é um teste que demonstra a variação da tensão de saída em concordância com a altitude do som, sendo diretamente proporcional. 

Além da forma de visualização através do Led, podemos ver no monitor serial a variação aproximada da tensão, lembre de ajustar o baud rate no canto inferior direito do seu monitor para 115200.

E a variação da onda em Ferramentas> Plotter Serial, mas para isso é necessário fechar o monitor serial antes.

Eu também medi a saída com o auxílio de um osciloscópio, a imagem gerada com a medição de um som ritmado foi a seguinte:

Ajuste de Ganho

Um outro ponto importante sobre o sensor, mencionado no início do tutorial, é a presença do pino Gain, que corresponde aos ganhos em decibéis(dB), é possível visualizar essa variação mais claramente no osciloscópio, sendo que Gain corresponde ao nível de amplificação da onda.

Se nada é ligado ao pino Gain, você terá um ganho de 60dB, se liga esse pino ao GND, o seu ganho será de 50dB, e se liga ao VDD o seu ganho será o equivalente a 40dB. Note essa pequena variação nas imagens abaixo:

Gain em Float: 60dB

Gain em GND: 50dB

Gain em VDD: 40dB

Attack e Release (Pino AR)

O Attack (Ataque), é a ação do AGC sobre a tensão de entrada, então o tempo de ataque é o tempo que o AGC precisa para agir e realizar a redução, a atenuação de ganho durante o período de ataque é exponencial e definido como uma constante única, sendo essa:

2400 x CCT * (segundos)

*CCT corresponde ao capacitor de temporização externo.

É recomendado o uso de um curto tempo de ataque para o AGC reagir rapidamente a sinais transitórios como breves batidas musicais, e um tempo maior para que o AGC ignore picos de curta duração e apenas reduzam o ganho com a percepção do aumento de volume.

O Release (Liberação) corresponde a liberação do sinal, ou seja, o tempo de liberação é o tempo para que o ganho AGC volte ao seu nível normal depois do pico. Para esse caso, é recomendado o uso de uma proporção pequena para maximizar a velocidade do AGC, e uma proporção grande para o efeito contrário.

Acompanhe a tabela abaixo caso queira fazer essa alteração no tempo de Attack e Release do seu módulo.

Sem o uso do capacitor, temos as seguintes pré-configurações.

Conclusão

Dado o exposto, é possível concluir que o sensor em questão é uma ótima opção para inúmeros projetos que exigem uma percepção sonora, mostrando-se ajustável e sensível na detecção do som, além de contar com a variação automática da amplitude, que é extremamente útil e evita alterações no sinal de saída. Espero que esse tutorial tenha sido esclarecedor, para qualquer dúvida ou sugestão, deixe nos comentários abaixo.

Abraços, Curto Circuito :)

Livro supracitado:

CARNAHAN, Brice. The IBM Personal Computers and the Michigan Terminal System. 1.ed. College of Engineering,
University of Michigan, 1984. 365p.