Los tonos o frecuencias audibles son muy usadas en electrónica. Estas se pueden escuchar en las alarmas para casas y autos, en las sirenas de las ambulancias, en los juegos y juguetes de niños y hasta en equipos médicos, industriales, de telecomunicaciones, etc. Por ejemplo los tonos son muy usados para dar algún aviso a las personas ciegas. En este artículo aprenderemos como generar y utilizar tonos y frecuencias con la placa Arduino Uno.
En la Figura 1 podemos ver la tarjeta Arduino Uno y el la Figura 2 el IDE o Interface de Desarrollo para escribir programas para Arduino Uno, comúnmente llamados Sketch . Esta IDE puede ser descargada del sitio web de Arduino.
Para la generación de tonos en la placa Arduino, es usado el Timer 2 del microcontrolador. El Timer 2 es un circuito periférico de microcontrolador, que puede ser configurado para generar frecuencias y temporizaciones. Las ondas generadas por el Timer son cuadradas. Aunque estos sonidos no son muy musicales, son muy utilizados en infinidad de aplicaciones electrónicas. Para la generación de tonos en la placa Arduino, usamos la función tone(), la cual explicaremos con detalle más adelante en este artículo.
EL SONIDO O FRECUENCIAS AUDIBLES.
El sonido o frecuencias audibles, está basado en el movimiento del aire. Si algo consigue hacer mover el aire, nuestros oídos consiguen captar este movimiento y el cerebro lo interpreta de acuerdo a su frecuencia y timbre característico del objeto emisor del sonido. Para que el oído humano capte algún sonido, es necesario que se mueva por un determinado número de veces. En electrónica y en física, es usado el segundo como tiempo de referencia para medir los sonidos. Así, es necesario que los sonidos vibren entre 20 veces y 20.000 veces por segundo para ser escuchados por el oído humano. Normalmente, es usada la unidad de Hertz, para remplazar las veces que algo puede moverse o vibrar. Por eso, es común decir: Hertz o vibraciones (oscilaciones) por segundo. A medida que la frecuencia es más alta, los sonidos son más agudos y a medida que son más bajos, los sonidos son más graves. Por ejemplo, un violín tiene notas muy altas, pero un contrabajo, emite sonidos muy graves o bajos. También podemos notar que la voz del hombre es más baja o grave con relación a la mujer, que tiene una voz más alta o aguda.
Para poder escuchar los tonos o sonidos emitidos por la placa Arduino Uno, es necesario usar un componente electrónico llamadoParlante o Altavoz . Este componente, es capaz de reproducir las frecuencias y oscilaciones emitidas por el timer del microcontrolador. Vea la Figura 3.
El símbolo electrónico que representa un parlante, es mostrado también en esta figura. Existen muchos modelos de parlantes, pero todos realizan la misma función, convertir impulsos electrónicos en sonidos o tonos. La Figura 4 muestra otro modelo de parlante o altavoz.
Todo en la naturaleza o universo es vibración, así los sonidos, luz, ondas magnéticas, ondas celébrales, ondas cósmicas, etc, son ondas u oscilaciones. Estas son clasificas o agrupadas en un diagrama o cuadro llamado espectro de ondas. Por eso, el sonido forma parte del llamado espectro de ondas. Vea la Figura 5.
Existen sonidos más bajos que 20 Hertz, normalmente llamados sub-sonidos y existen sonidos más altos que 20.000 Hertz, llamados ultrasonidos, más el oído humano no capta estos sonidos. Vea la Figura 6.
Muchos animales si consiguen escuchar y emitir estos sonidos. También muchos dispositivos electrónicos lo hacen. Un ejemplo es el sonar que los barcos marítimos llevan para conocer la profundidad a la cual se encuentran en el mar. Otro ejemplo de ultrasonidos, son los pitos o silbatos usados para llamar a los perros, los cuales, los humanos no escuchamos, pero el perro sí.
En este artículo nos enfocaremos en los tonos o frecuencias audibles y especialmente en la escala musical. Los instrumentos musicales emiten tonos o frecuencias de acuerdo a un padrón establecido llamado escala. Para entender los códigos ejemplos de este artículo, es necesario tener en mente las frecuencias de las notas musicales. Si observamos un piano o teclado, notaremos que es formado por muchas teclas. Cada una emite un sonido o tono especifico, es decir hace vibrar el instrumento por un determinado número de veces o ciclos por segundo. La escala musical está divida a su vez en varias escalas. Por ejemplo, las teclas de piano en la parte central, pertenecen a la 4 escala y por eso es común referenciarlas como:
C4 -262 Hertz= Do
CS4 - 277 Hertz = Do sostenido.
D4 - 294 Hertz = Re
DS4 - 311 Hertz = Re sostenido.
E4 - 330 Hertz = Mi
F4 - 349 Hertz = Fa
FS4 - 370 Hertz = Fa sostenido
G4 - 392 Hertz = Sol
GS4 - 415 Hertz = Sol sostenido
A4 - 440 Hertz = La
AS4 - 466 Hertz = La sostenido
B4 - 494 Hertz = Si
Más adelante, en una de las prácticas de este artículo, es creado un archivo, para declarar las frecuencias de los tonos más comúnmente usados en instrumentos musicales. Observemos que cada escala es formada por 12 notas (tonos y semitonos). También es necesario tener en cuenta que la duración de cada nota o tono, necesita un tiempo. Cada tiempo en música es representado generalmente por la figura musical llama Negra o Cuartos de Nota y cada medio tiempo es representado por la figura musical llamada Corchea u Octavos de Nota. Vea la Figura 7.
Estas figuras que representan la duración que una nota o tono se tocada, son usadas en las partituras musicales para escribir las canciones. Vea la Figura 8.
LA FUNCION tone().
Para generar tonos o frecuencias en la placa Arduino Uno, es necesario utilizar la función tone(). Existen 2 prototipos o versiones de esta función:
tone(pin, frequency, duration)
Los parámetros que recibe esta función son:
pin: el pin sobre el cual se van a generar los tonos.
frequency: la frecuencia del tono en Hertz o ciclos por segundo.
duration: la duración del tono en milisegundos.
La otra versión es similar a la anterior, pero esta se toca indefinidamente hasta que se llame nuevamente a la función tone() o se llame la función noTone(). El prototipo para esta función es:
tone(pin, frequency)
Los parámetros que recibe esta función son:
pin: el pin sobre el cual se van a generar los tonos.
frequency: la frecuencia del tono en Hertz o ciclos por segundo.
En este artículo veremos códigos ejemplos y practicas donde usamos la función tone() y noTone(), para generar sonidos o tonos. La función noTone(), es usada para parar un sonido o tono disparado (triggered) por la función tone(). La función noTone(), solo recibe un parámetro, que es el pin por donde se esté generando algún tono. Los ejemplos para practicar con sonidos y tonos, pueden ser encontrados en el menú Archivo->Ejemplos de la IDE de Arduino. Vea la Figura 9.
TOCAR UNA FRECUENCIA QUE CAMBIE CON LA VARIACION DE LUZ.
Para realizar esta práctica de código ejemplo, es necesario montar un circuito como mostrado en la Figura 10.
El tono cambiara o variara de acuerdo a la intensidad de luz recibida en la fotorresistencia. La frecuencia o tono saldrá por el pin 9 de la placa Arduino. El código ejemplo para esta práctica puede ser encontrado en el menú: Archivo->Ejemplos->02.Digital->tonePitchFollower. El siguiente es el código ejemplo:
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 }
En la función setup() se inicializa la comunicación serial, solamente para propósitos de depuración. En la función loop(), lo primero que hacemos es leer la entrada analógica donde está conectada la fotorresistencia. Para esto utilizamos la función:
int sensorReading = analogRead(A0);
El valor leído del sensor, es almacenado en la variable sensorReading. Este valor es enviado por el puerto serial, con el propósito de conocer su valor y poder observarlo con el monitor serial. Para esto usamos la función:
Serial.println(sensorReading);
Después mapeamos el valor leído del sensor para un rango de valores que van desde 120 Hz hasta 1500 Hz. Para esto usamos la siguiente función:
int thisPitch = map(sensorReading, 400, 1000, 120, 1500);
Después de mapeado el valor, este es almacenado en la variable: thisPitch. Ahora podemos usar este valor para generar el tono, usando la siguiente función:
tone(9, thisPitch, 10);
Como visto anteriormente, el primer parámetro, es el pin por el cual se generara el tono, en este caso el pin 9. El segundo parámetro, es la frecuencia del tono, que en este caso esta almacenada en la variable thisPitch. Y el último parámetro, es la duración del tono, que en este caso es de 10 milisegundos.
Finalmente, usamos un retardo (delay) entre las lecturas del sensor para estabilizar los tonos. Para esto usamos la función:
delay(1);
Este código ejemplo puede ser usado con otros tipos de sensor y obtener así un tono de acuerdo a su nivel de intensidad, muy útil, por ejemplo para guiar ciegos, o emitir alarmas.
TOCAR UNA MELODIA.
La melodía es la parte de la música que caracteriza un tema o canción. Esta práctica y código ejemplo toca una melodía. Para realizar esta práctica es necesario montar un circuito como el mostrado en la Figura 11.
El código ejemplo puedes ser encontrado en el menú: Archivo->Ejemplos->02.Digital->toneMelody. El siguiente es el código ejemplo:
#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. }
El código para tocar melodías, comienza incluyendo un archivo cabecera (head), donde son definidas las frecuencias para los tonos o notas musicales. La línea de programa usada para hacer esto es:
#include "pitches.h"
Como este archivo es usado para definir las notas musicales, es necesario usar la línea de programa:
#define
Lo que se hace con este comando, es decir al compilador que cuando encuentre una definición dentro del programa, la remplace por el valor encontrado al frente del nombre de la definición.
Por ejemplo en la siguiente definición, lo que hace el compilador es remplazar PIN_LED por el valor 13:
#define PIN_LED 13
Los cambios se hacen en tiempo de compilación. Es decir que cuando se genera el código para almacenar en la memoria FLASH del microcontrolador, es cuando se reemplaza estos valores.
El contenido de archivo pitches.h es el siguiente:
************************************************
* 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
Después, de haber incluido el archivo cabecera, es declarado un array de números enteros representando las notas de la melodía que se desea tocar. La línea de programa para esto es:
int melody[] = {
NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4
};
Después es declarado un array con los tiempos de duración para cada nota. Esto se hace con la siguiente línea de programa:
int noteDurations[] = {
4, 8, 8, 4, 4, 4, 4, 4
};
Después está la función setup(), la cual es llamada al alimentar con voltaje el circuito o después de un reset. Dentro de esta función usamos una instrucción de control para generar un bucle (loop). La línea de código para esto es:
for (int thisNote = 0; thisNote < 8; thisNote++) {
Como la melodía tiene 8 notas, la instrucción for se encarga de interactuar por todo las notas declaradas en el array de la melodía.
Lo primero que hacemos es calcular el valor del tiempo que debe durar la nota. Para hacer esto usamos la siguiente línea de programa:
int noteDuration = 1000 / noteDurations[thisNote];
Podemos observar que para hacer este cálculo, tomamos como base un Segundo (1000 milisegundos) y lo dividimos por el tipo de nota, así:
Para 4 de nota: 1000/4. Esto dará 250 milisegundos. (Negras)
Para 8 de nota: 1000/8. Esto dará 125 milisegundos. (Corcheas)
El valor de la duración de tiempo de la nota, es almacenado en la variable noteDuration.
Después es llamada la función tone(), para ejecutar la nota. Esto lo hacemos con la línea de código:
tone(8, melody[thisNote], noteDuration);
Para distinguir una nota de otra, es necesario dar un tiempo de retardo mayor al de la duración de la nota. Esto lo hacemos con las siguientes líneas de código:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
En la variable pauseBetweenNotes se almacena el valor, que es la duración de la nota, más el 30%. Este valor es usado en la función delay() para hacer el retado.
Finalmente, se para de tocar la nota. Esto se hace con la línea de código:
noTone(8);
En este programa ejemplo la función loop(), no tiene ninguna instrucción por que la melodía solo se toca una vez. Si desea que la melodía se toque indefinidamente, se puede copiar el código de la función setup(), en la función loop(), y así la melodía se ejecutara indefinidamente.
Muchas aplicaciones usan melodías para llamar la atención de los usuarios como por ejemplo las tarjetas navideñas, los muñecos o juegos para niños, algunos dispensadores de alimentos, los juegos de azar, etc. Usando un código como el de este programa es posible prácticamente tocar cualquier melodía.
TOCAR MULTIPLES TONOS.
Esta práctica y código ejemplo, toca múltiples tonos sobre múltiples pines. Para realizar esta práctica es necesario montar un circuito como el mostrado en la Figura 12.
Son necesarios tres parlantes de 8 ohms conectados sobre los pines 6, 7 y 8 de la placa Arduino. El código ejemplo puedes ser encontrado en el menú:Archivo->Ejemplos->02.Digital->toneMultiple . El siguiente es el código ejemplo:
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 comienza ejecutando la función setup(), que para este caso, no tiene ejecuta ninguna línea de código. Después es llamada la función loop(), la cual comienza llamando la función:
noTone(8);
Esta función apaga (turn off) el tono que se esté emitiendo en el pin 8 de la placa Arduino Uno.
Después es llamada la función:
tone(6, 440, 200);
la cual ejecuta la frecuencia 440 sobre el pin 6 por un tiempo de 200 milisegundos. Recordemos que esta frecuencia es la nota LA de la 4 escala musical. Después, llamamos la función delay(), para retardar el tiempo que la nota es tocada. La siguiente línea de código ejecuta este retardo:
delay(200);
Una vez pasado este tiempo, llamamos la función:
noTone(6);
Esto apaga el tono (turn off) que se está ejecutando en el pin 6 de la placa Arduino.
Después son llamadas las funciones:
tone(7, 494, 500);
delay(500);
las cuales se encargan de tocar un tono de 494 hertz, sobre el pin 7 de la placa Arduino, por un tiempo de 500 milisegundos. Recordemos que esta frecuencia es la nota SI de la 4 escala musical. Después es llamad la función:
noTone(7);
la cual se encarga de apagar la nota o tono que se esté ejecutando en el pin 7 de la placa Arduino.
Después son llamadas las funciones:
tone(8, 523, 300);
delay(300);
las cuales se encargan de generar un tono de 523 Hz en el pin 8 de la placa Arduino, por un tiempo de 300 milisegundos. La función delay() es llamada para esperar por este tiempo.
CONCLUCION.
Como podemos notar, es muy fácil generar tonos con la placa Arduino. La imaginación y la práctica juegan un papel muy importante aquí, porque se pueden crear múltiples aplicaciones para diferentes proyectos. Existen bibliotecas que expanden la capacidad de la tarjeta Arduino para generar tonos y frecuencias. También existen placas auxiliares (shields) que conectadas a la placa Arduino uno, pueden ejecutar archivos de audio como los que usamos en los computadores, por ejemplo archivos de audio WAV. Otra aplicación es la creación de instrumentos musicales. En próximos artículos crearemos algunos instrumentos fáciles de construir y muy didácticos para el desarrollo del conocimiento electrónico, como musical.