O buzzer é um componente muito simples e barato, e chega a ser um auto falante alternativo, porém limitado. Por funcionar semelhante a um alto falante, ele pode ser usado para aplicações bem interessantes.

Se você deseja entender a base de funcionamento do buzzer, recomendo que leia o post sobre o efeito piezoelétrico.

Som emitido

Existem dois tipos de buzzer, o passivo e o ativo. A diferença entre os dois é que o som reproduzido pelo passivo acompanha a forma do sinal elétrico que aciona ele. Ou seja, se eu acionar o buzzer com um sinal elétrico que imita o som de uma flauta, o buzzer consegue reproduzir o som da flauta*. Por outro lado, o buzzer ativo apenas emite um apito quando a tensão em seu pino passa de um determinado valor. Portanto, o buzzer ativo possui um timbre próprio e age como se fosse um “instrumento musical” à parte.

Se utilizarmos um pino digital do Arduino para acionar um buzzer passivo, ele irá se comportar como um buzzer ativo, pois o sinal elétrico irá oscilar entre ativo e não ativo. Agora, se utilizarmos um módulo ou uma shield que reproduza arquivos de áudio, o som do buzzer passivo conseguirá reproduzir o som real*.

*É importante evidenciar que o buzzer passivo não consegue reproduzir todas as frequências de forma uniforme. Isto quer dizer que, dependendo da frequência, o som ficará mais baixo ou mais alto. Na prática, isso faz com que uma música fique distorcida. A imagem abaixo é um exemplo da resposta em frequência de um buzzer. Repare que, para esse buzzer, sinais abaixo de 1k são bem atenuados (não consegue reproduzir).

Exemplo prático

Veja abaixo um projeto que fiz utilizando um buzzer passivo o qual reproduz sons personalizados com a ajuda de um conversor DA.

O som é um pouco baixo, mas dá pra ouvir na hora que ligo o dispositivo.

Circuito

O circuito do buzzer é bem simples, pois basta ligar o negativo do buzzer no GND e o positivo em um resistor que pode ser de 100Ω (não tem valor exato). A outra ponta do resistor liga em um pino digital do Arduino. A imagem abaixo ilustra a ligação.

buzzer arduino

Sugestão de compra

Se você estiver precisando de componentes, dê uma olhada na AutoCore Robótica! Adiante estão os buzzers disponíveis lá no site deles para você poder montar o circuito mostrado aqui.

Módulo buzzer passivo 5V
Buzzer passivo 5V p/ placa mãe
Buzzer 5V de 12mm
Buzzer ativo 3V de 12mm

Como usar

Não pretendo usar nenhuma shield para tocar sons aqui, pois acionaremos o buzzer com ondas quadradas pelos pinos digitais do Arduino.

Cada nota musical possui uma certa frequência, então, para tocar uma nota, nós vamos mandar um sinal de onda quadrada pro buzzer em uma determinada frequência. As frequências das notas são aproximadamente:

  • Dó – 262 Hz
  • Ré – 294 Hz
  • Mi – 330 Hz
  • Fá – 349 Hz
  • Sol – 392 Hz
  • Lá – 440 Hz
  • Si – 494 Hz
  • #Dó – 528 Hz

Usando a função do Arduino

Existe um comando que facilita muito nossa vida, que é o tone(). Esse comando gera, automaticamente, um sinal de onda quadrada no pino e na frequência que a gente quiser. E ele possui a seguinte configuração:

tone(pino, frequência em Hz, duração em ms)

O parâmetro da duração pode ser ignorado, mas ele basicamente define a duração do sinal. Como o circuito mostrado lá em cima mostra, eu vou usar o pino 10 para controlar o buzzer.

Para começar a programar, precisamos escolher uma música para tocar e pegar as notas musicais dela. Resolvi pegar as notas da música de abertura de Game of Thrones e reproduzi isso no código, mas fiz só o comecinho dela. A última observação importante a ser dita é que o tempo de espera entre cada nota deve ser colocado de acordo com o ritmo da música, então, para encontrar um valor bom, eu criei uma variável chamada tempo para controlar o tempo dos delays e o tempo que cada nota dura, assim basta mudar o valor dessa variável até que a música esteja em um bom ritmo.

Código completo

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
/*  
  Feito pelo site MundoProjetado
  Código que toca um pedaço da música
  de abertura de Game of Thrones
*/

void setup(){
  pinMode(10,OUTPUT);
}

void loop(){
  /*
  Frequência das notas:
  Dó - 262 Hz
  Ré - 294 Hz
  Mi - 330 Hz
  Fá - 349 Hz
  Sol - 392 Hz
  Lá - 440 Hz
  Si - 494 Hz
  #Dó - 528 Hz
  */

  delay(1000);
  int tempo = 400;
  tone(10,440,tempo); //LA
  delay(tempo);
  tone(10,294,tempo); //RE
  delay(tempo);
  tone(10,349,tempo/2); //FA - O tempo/2 faz com que demore metade do valor estipulado anteriormente, pois essa parte é mais rápida
  delay(tempo/2);
  tone(10,392,tempo/2); //SOL
  delay(tempo/2);
  tone(10,440,tempo); //LA
  delay(tempo);
  tone(10,294,tempo); //RE
  delay(tempo);
  tone(10,349,tempo/2); //FA
  delay(tempo/2);
  tone(10,392,tempo/2); //SOL
  delay(tempo/2);
  tone(10,330,tempo); //MI
  delay(tempo);
}

Criando a função

Caso você não deseja usar a função tone(), basta criar uma. Para isso, nós precisamos dos mesmos parâmetros da função tone: o pino que deve ser acionado, a frequência e a duração. Basicamente a função identifica o período da frequência que você deseja e deixa o pino em nível alto durante metade do período e em nível baixo durante a outra metade. E ele repete até dar o tempo que foi definido no parâmetro “duracao”.

Código completo

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
/*Feito pelo site MundoProjetado
Código que toca um pedaço da música
de abertura de Game of Thrones
*/

void tom(char pino, int frequencia, int duracao);

void setup(){
  pinMode(10,OUTPUT);
}
void loop(){
  /*
  Frequência das notas:
  Dó - 262 Hz
  Ré - 294 Hz
  Mi - 330 Hz
  Fá - 349 Hz
  Sol - 392 Hz
  Lá - 440 Hz
  Si - 494 Hz
  #Dó - 528 Hz
  */

  delay(1000);
  int tempo = 400;
  tom(10,440,tempo); //LA
  delay(tempo);
  tom(10,294,tempo); //RE
  delay(tempo);
  tom(10,349,tempo/2); //FA
  delay(tempo/2);
  tom(10,392,tempo/2); //SOL
  delay(tempo/2);
  tom(10,440,tempo); //LA
  delay(tempo);
  tom(10,294,tempo); //RE
  delay(tempo);
  tom(10,349,tempo/2); //FA
  delay(tempo/2);
  tom(10,392,tempo/2); //SOL
  delay(tempo/2);
  tom(10,330,tempo); //MI
  delay(tempo);
}

void tom(char pino, int frequencia, int duracao){
  float periodo = 1000.0/frequencia; //Periodo em ms
  for (int i = 0; i< duracao/(periodo);i++){ //Executa a rotina de dentro o tanta de vezes que a frequencia desejada cabe dentro da duracao
    digitalWrite(pino,HIGH);
    delayMicroseconds(periodo*500); //Metade do periodo em ms
    digitalWrite(pino, LOW);
    delayMicroseconds(periodo*500);
  }
}

Desse último jeito, é possível até implementar no PIC, basta trocar os comandos de digitalWrite para o PORT e alterar os delays.

Tocando música com o Arduino – Buzzer