Os tons ou frequências audíveis são amplamente utilizados em eletrônica. Estes podem ser ouvidos em alarmes para casas e carros, nas sirenes de ambulâncias, em jogos e brinquedos para crianças e até em equipamentos médicos, industriais, de telecomunicações, etc. Por exemplo, tons são amplamente usados para dar algum aviso a pessoas cegas. Neste artigo vamos aprender como gerar e usar tons e frequências com a placa Arduino Uno.
Na Figura 1 podemos ver a placa do Arduino Uno e a Figura 2 o IDE ou a Interface de Desenvolvimento para escrever programas para o Arduino Uno, comumente chamado de Sketch. Este IDE pode ser baixado do site do Arduino.
Para a geração de tons na placa Arduino, o Timer 2 do microcontrolador é usado. O Timer 2 é um circuito de microcontrolador periférico, que pode ser configurado para gerar frequências e temporizações. As ondas geradas pelo Timer são quadradas. Embora esses sons não sejam muito musicais, eles são amplamente utilizados em inúmeras aplicações eletrônicas. Para a geração de tons na placa Arduino, usamos a função tone (), que será explicada em detalhes posteriormente neste artigo.
FREQUÊNCIAS SONORAS OU SONORAS.
O som ou as frequências audíveis, é baseado no movimento do ar. Se algo consegue fazer o ar se mover, nossos ouvidos conseguem capturar esse movimento e o cérebro o interpreta de acordo com sua frequência e timbre característico do objeto que emite o som. Para o ouvido humano pegar um som, ele precisa se mover por um certo número de vezes. Em eletrônica e física, o segundo é usado como tempo de referência para medir sons. Assim, é necessário que os sons vibrem entre 20 e 20.000 vezes por segundo para serem ouvidos pelo ouvido humano. Normalmente, a unidade Hertz é usada para substituir os tempos em que algo pode se mover ou vibrar. Portanto, é comum dizer: Hertz ou vibrações (oscilações) por segundo. Como a frequência é maior, os sons são mais agudos e, como são mais baixos, os sons são mais graves. Por exemplo, um violino tem notas muito altas, mas um contrabaixo emite sons muito baixos ou graves. Podemos também notar que a voz do homem é menor ou mais grave em relação à mulher, que tem voz mais alta ou mais alta.
Para poder ouvir os sons emitidos pela placa Arduino Uno, é necessário usar um componente eletrônico chamado Speaker ou Speaker. Este componente é capaz de reproduzir as frequências e oscilações emitidas pelo temporizador do microcontrolador. Veja a Figura 3.
O símbolo eletrônico representando um alto-falante também é mostrado nesta figura. Existem muitos modelos de alto-falantes, mas todos executam a mesma função, convertem impulsos eletrônicos em sons ou tons. A figura 4 mostra outro modelo de alto-falante ou alto-falante.
Tudo na natureza ou universo é vibração, então sons, luz, ondas magnéticas, ondas celestes, ondas cósmicas, etc., são ondas ou oscilações. Estes são classificados ou agrupados em um diagrama chamado espectro de ondas. Portanto, o som faz parte do chamado espectro de ondas. Veja a Figura 5.
Existem sons menores que 20 Hertz, geralmente chamados de infrassons e há sons acima de 20.000 Hertz, chamados ultrassom, e o ouvido humano não captura esses sons. Veja a Figura 6.
Muitos animais se conseguem ouvir e emitem esses sons. Também muitos dispositivos eletrônicos fazem isso. Um exemplo é o sonar que os barcos marítimos levam para conhecer a profundidade em que estão no mar. Outro exemplo de ultrassom, são assobios ou assobios usados para chamar cães, que os humanos não ouvem, mas o cão faz.
Neste artigo vamos nos concentrar nos tons ou frequências audíveis e especialmente na escala musical. Instrumentos musicais emitem tons ou frequências de acordo com um padrão estabelecido chamado escala. Para entender os exemplos de códigos deste artigo, é necessário ter em mente as frequências das notas musicais. Se observarmos um piano ou teclado, notaremos que ele é formado por muitas teclas. Cada um emite um som ou tom específico, isto é, faz vibrar o instrumento por um determinado número de vezes ou ciclos por segundo. A escala musical é dividida em várias escalas. Por exemplo, as teclas do piano na parte central pertencem à escala 4 e é por isso que é comum referenciá-las como:
C4 262 Hertz = Dó
CS4 277 Hertz = Dó sustenido.
D4 294 Hertz = Re
DS4 311 Hertz = Re sustenido.
E4 330 Hertz = Mi
F4 349 Hertz = Fa
FS4 370 Hertz = Fa sustenido
G4 392 Hertz = Sol
GS4 415 Hertz = Sol sustenido
A4 440 Hertz = La
AS4 466 Hertz = La sustenido
B4 494 Hertz = Si
Posteriormente, em uma das práticas deste artigo, é criado um arquivo para declarar as frequências dos tons mais comumente usados em instrumentos musicais. Observe que cada escala é formada por 12 notas (tons e semitons). Também é necessário ter em mente que a duração de cada nota ou tom precisa de um tempo. Cada tempo em música é geralmente representado pela figura musical chamada semínima e cada meio tempo é representado pela figura musical chamada Colcheia. Veja a Figura 7.
Estes números representam a duração que uma nota ou tom é tocado, são usados nas partituras para escrever as músicas. Veja a Figura 8.
A função de tone().
Para gerar tons ou frequências na placa Arduino Uno, é necessário usar a função tone (). Existem 2 protótipos ou versões desta função:
tone (pin, frequency, duration)
Os parâmetros que esta função recebe são:
pin: o pino no qual os tons serão gerados.
frequency: a frequência do tom em Hertz ou ciclos por segundo.
duration: a duração do tom em milissegundos.
A outra versão é semelhante à anterior, mas é reproduzida indefinidamente até que a função tone () seja chamada novamente ou a função noTone () seja chamada. O protótipo para esta função é:
tone (pin, frequency)
Os parâmetros que esta função recebe são:
pin: o pino no qual os tons serão gerados.
frequência: a frequência do tom em Hertz ou ciclos por segundo.
Neste artigo, veremos exemplos e códigos de prática nos quais usamos a função tone () e noTone (), para gerar sons ou tons. A função noTone () é usada para interromper um som ou um tom disparado pela função tone (). A função noTone () recebe apenas um parâmetro, que é o pino onde um tom está sendo gerado. Os exemplos para praticar sons e tons podem ser encontrados no menu Arquivo-> Exemplos do Arduino IDE. Veja a Figura 9.
TOQUE UMA FREQUÊNCIA QUE MUDE COM A VARIAÇÃO DA LUZ.
Para executar essa prática de código de exemplo, é necessário montar um circuito conforme mostrado na Figura 10.
O tom vai mudar ou variar de acordo com a intensidade da luz recebida no fotorresistor. A frequência ou tom sairá pelo pino 9 da placa Arduino. O código de exemplo para esta prática pode ser encontrado no menu: File-> Examples-> 02.Digital-> tonePitchFollower. O seguinte é o código de exemplo:
void setup() {
// initialize serial communications (for debugging only):
Serial.begin(9600);
}
void loop() {
// read the sensor:
int sensorReading = analogRead(A0);
// print the sensor reading so you know its range
Serial.println(sensorReading);
// map the analog input range (in this case, 400 - 1000 from the photoresistor)
// to the output pitch range (120 - 1500Hz)
// change the minimum and maximum input numbers below depending on the range
// your sensor's giving:
int thisPitch = map(sensorReading, 400, 1000, 120, 1500);
// play the pitch:
tone(9, thisPitch, 10);
delay(1); // delay in between reads for stability
}
Na função setup (), a comunicação serial é inicializada, apenas para fins de depuração. Na função loop (), a primeira coisa que fazemos é ler a entrada analógica na qual o fotoresistente está conectado. Para isso usamos a função:
int sensorReading = analogRead (A0);
O valor lido do sensor é armazenado na variável sensorReading. Este valor é enviado pela porta serial, com o objetivo de conhecer seu valor e poder observá-lo com o monitor serial. Para isso usamos a função:
Serial.println (sensorReading);
Em seguida, mapeamos o valor lido do sensor para um intervalo de valores que varia de 120 Hz a 1500 Hz. Para isso, usamos a seguinte função:
int thisPitch = map (sensorReading, 400, 1000, 120, 1500);
Depois que o valor é mapeado, ele é armazenado na variável: thisPitch. Agora podemos usar este valor para gerar o tom, usando a seguinte função:
tone(9, thisPitch, 10);
Como visto acima, o primeiro parâmetro é o pino pelo qual o tom é gerado, neste caso, o pino 9. O segundo parâmetro é a frequência de campo, a qual, neste caso, é armazenado na variável thisPitch. E o último parâmetro é a duração do tom, que neste caso é de 10 milissegundos.
Finalmente, usamos um atraso entre as leituras do sensor para estabilizar os tons. Para isso usamos a função:
delay (1);
Este código de exemplo pode ser utilizado com outros tipos de sensores e obter um tom de acordo com o seu nível de intensidade, muito útil, por exemplo para guiar cegos ou emitir alarmes.
TOCAR UMA MELODIA
A melodia é a parte da música que caracteriza uma música ou tema. Esta prática e código de exemplo reproduzem uma melodia. Para realizar essa prática é necessário montar um circuito como o mostrado na Figura 11.
O código de exemplo pode ser encontrado no menu: File-> Examples-> 02.Digital-> toneMelody. O seguinte é o código de exemplo:
#include "pitches.h"
// notes in the melody:
int melody[] = {
NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4
};
// note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = {
4, 8, 8, 4, 4, 4, 4, 4
};
void setup() {
// iterate over the notes of the melody:
for (int thisNote = 0; thisNote < 8; thisNote++) {
// to calculate the note duration, take one second divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000 / noteDurations[thisNote];
tone(8, melody[thisNote], noteDuration);
// to distinguish the notes, set a minimum time between them.
// the note's duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
noTone(8);
}
}
void loop() {
// no need to repeat the melody.
}O código para tocar melodias começa incluindo um arquivo principal, onde as frequências para os tons ou notas musicais são definidas. A linha de programa usada para fazer isso é:
#include "pitches.h"
Como este arquivo é usado para definir as notas musicais, é necessário usar a linha do programa:
#define
O que é feito com este comando, ou seja, o compilador, quando encontra uma definição dentro do programa, a substitui pelo valor encontrado na frente do nome da definição.
Por exemplo, na definição a seguir, o que o compilador faz é substituir PIN_LED pelo valor 13:
#define PIN_LED 13
As alterações são feitas em tempo de compilação. Ou seja, quando o código é gerado para armazenar na memória FLASH do microcontrolador, é quando esses valores são substituídos.
O conteúdo do arquivo pitches.h é o seguinte:
/************************************************
* Public Constants
************************************************/
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
Depois de incluir o arquivo de cabeçalho, uma matriz de inteiros é declarada representando as notas da melodia que você deseja reproduzir. A linha do programa para isso é:
int melody [] = {
NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4
};
Em seguida, uma matriz com os tempos de duração de cada nota é declarada. Isso é feito com a seguinte linha de programa:
int noteDurations [] = {
4, 8, 8, 4, 4, 4, 4, 4
};
Depois, há a função setup (), que é chamada ao energizar o circuito ou após uma reinicialização. Dentro dessa função, usamos uma instrução de controle para gerar um loop. A linha de código para isso é:
for (int thisNote = 0; thisNote <8; thisNote ++) {
Como a melodia tem 8 notas, a instrução for é responsável por interagir com todas as notas declaradas na matriz de melodia.
A primeira coisa que fazemos é calcular o valor do tempo que a nota deve durar. Para fazer isso, usamos a seguinte linha de programa:
int noteDuration = 1000 / noteDurations [thisNote];
Podemos ver que para fazer esse cálculo, tomamos como base um segundo (1000 milissegundos) e o dividimos pelo tipo de nota, assim:
Para 4 de nota: 1000/4. Isso dará 250 milissegundos. (semínima)
Para 8 de nota: 1000/8. Isso dará 125 milissegundos. (Colcheia)
O valor da duração de tempo da nota é armazenado na variável noteDuration.
Então a função tone () é chamada para executar a nota. Fazemos isso com a linha de código:
tone (8, melody [thisNote], noteDuration);
Para distinguir uma nota da outra, é necessário dar um tempo de atraso maior que a duração da nota. Fazemos isso com as seguintes linhas de código:
int pauseBetweenNotes = noteDuration * 1,30;
delay (pauseBetweenNotes);
Na variável pauseBetweenNotes, o valor é armazenado, que é a duração da nota, mais 30%. Este valor é usado na função delay () para fazer o desafio.
Finalmente, ele para de tocar a nota. Isso é feito com a linha de código:
noTone (8);
Neste programa de exemplo, a função loop () não tem instrução porque a melodia é tocada apenas uma vez. Se você quiser que a melodia toque indefinidamente, você pode copiar o código da função setup (), na função loop (), e assim a melodia será executada indefinidamente.
Muitos aplicativos usam melodias para atrair a atenção de usuários como cartões de Natal, bonecas ou jogos para crianças, alguns dispensadores de comida, jogos de azar, etc. Usando um código como este programa, é possível tocar praticamente qualquer melodia.
TOCAR TONS MÚLTIPLOS
Esta prática e código de exemplo, reproduz vários tons em vários pinos. Para realizar essa prática é necessário montar um circuito como o mostrado na Figura 12.
São necessários três alto-falantes de 8 ohm conectados nos pinos 6, 7 e 8 da placa Arduino. O código de exemplo pode ser encontrado no menu: File-> Examples-> 02.Digital-> toneMultiple. O seguinte é o código de exemplo:
void setup() {
}
void loop() {
// turn off tone function for pin 8:
noTone(8);
// play a note on pin 6 for 200 ms:
tone(6, 440, 200);
delay(200);
// turn off tone function for pin 6:
noTone(6);
// play a note on pin 7 for 500 ms:
tone(7, 494, 500);
delay(500);
// turn off tone function for pin 7:
noTone(7);
// play a note on pin 8 for 300 ms:
tone(8, 523, 300);
delay(300);
}Este programa inicia executando a função setup (), que neste caso não possui nenhuma linha de código em execução. Então a função loop () é chamada, que começa chamando a função:
noTone (8);
Esta função desativa o tom que está sendo transmitido no pino 8 da placa Arduino Uno.
Então a função é chamada:
tone (6, 440, 200);
que executa a frequência 440 no pino 6 por um tempo de 200 milissegundos. Lembre-se de que essa frequência é a nota LA da escala musical 4. Em seguida, chamamos a função delay () para atrasar a hora em que a nota é tocada. A linha de código a seguir executa esse atraso:
delay (200);
Uma vez que este tempo passou, chamamos a função:
noTone (6);
Isso desativa o tom (desligar) que está sendo executado no pino 6 da placa do Arduino.
Então as funções são chamadas:
tone (7, 494, 500);
delay (500);
que são responsáveis por tocar um tom de 494 hertz, no pino 7 da placa Arduino, por um tempo de 500 milissegundos. Lembre-se de que essa frequência é a nota SI da escala musical 4. Então a função é chamada:
noTone (7);
que é responsável por desligar a nota ou tom que está sendo executado no pino 7 da placa Arduino.
Então as funções são chamadas:
tone (8, 523, 300);
delay (300);
que são responsáveis por gerar um tom de 523 Hz no pino 8 da placa Arduino, por um tempo de 300 milissegundos. A função delay () é chamada para aguardar esse tempo.
CONCLUSÃO
Como podemos ver, é muito fácil gerar tons com a placa Arduino. A imaginação e a prática desempenham um papel muito importante aqui, porque você pode criar vários aplicativos para diferentes projetos. Existem bibliotecas que expandem a capacidade da placa Arduino para gerar tons e frequências diferentes. Há também placas auxiliares (shields) que, conectadas à placa Arduino, podem reproduzir arquivos de áudio como os que usamos nos computadores, por exemplo, arquivos de áudio WAV. Outra aplicação é a criação de instrumentos musicais. Em artigos futuros, criaremos alguns instrumentos fáceis de construir e muito didáticos para o desenvolvimento do conhecimento eletrônico, como a música.
