¡Liberate del La a 440 Hz!
¡Hola a todos amigos!
Espero encontrarlos muy bien en este caluroso mes de marzo.
He aquí un Arduino muy barroco al que le encanta tararear Bach. Lo interesante de este Arduino es que es capaz de afinar la escala a partir de un La medio ingresado por el usuario, con ayuda de la función tuneScale() se genera una escala igualmente temperada de 12 notas como output a partir de dicho «la» medio, recibido como input.
Para este sketch, basta cambiar el valor de la4 en la línea de código número 12.
De esta manera nuestro Arduino rompió la jaula de la entonación en «La 440 Hz» a la que se le había querido encasillar en una precoz etapa del bosquejo.
La motivación para escribir este código fue escuchar las diferencias de afinación en escalas igualmente temperadas al elegir un La medio en el intervalo [400,450]Hz como «guía de afinación». Pues, se sabe que la afinación con un la de 440 Hz, no fue normalizada sino hasta 1995 con ISO 16, antes del cual se consideraba aceptable cualquier «la» del intervalo [400,450]Hz, siendo un La de alrededor de 430 Hz el predominante en muchas escuelas.
La curiosidad de escuchar una misma melodía con variaciones en la afinación de la escala igualmente temperada, fue motivación suficiente para escribir el siguiente bosquejo con el cual puedes elegir el valor de tu la medio o «guía de afinación» para después apreciar un fragmento del hermoso preludio No.1 en do mayor, parte del clavecín bien temperado, escrito por el maestro Bach.
A continuación se comparte el bosquejo de Arduino para su propio deleite:
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Tune me & I Play you Bach – Arduino Bach player with user defined tuning – tlachinolliatl@gmai.com /////
// Visit our life Blog at: /////
// http://www.atl.travel.blog /////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// The inspiration behind this code was to hear the differences in equal temperament tuning varying the value of the key note A4 ////
// standardly tuned at 440 Hz with some controversy about better harmonic generation with 432 cicles per second (Hz). ////
// Overall, there was a tendency towards the end of the 18th century for the frequency of the A above middle C to be in the range ////
// of 400 to about 450 Hz. ////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// change following value for tuning the scale
double la4 = 400; // checar como puede modificar este valor el usuario durante ejecución
//recomendación: definir los tiempos, h de half: d, w, h, q
int h=250; // aquí solo se definió h, ya que para esta melodía no habrá variación de tiempo en las notas.
// cent function recieves number of cents n and returns proportion factor to use it in tuneScale function to create user tuned scale
double centFactor(int n){
double proportion;
double power;
power = (double)n/12; // por no hacer el casting todo valía nepe
proportion = pow(2, power);
return proportion;
}
// The Tune function
double * tuneScale(double la4){
static double scale[12]; // arreglo para guardar las notas generadas
// a partir de middleA podemos obtener Do de una octava mas arriba, que es la que utilizaremos
// por medio de la siguiente formula de Cents, introducida por Alexander Ellis en 1875
// b = a*2^(n/1200)
// se obtiene cualquier nota b por medio de la nota a y el numero n de cents en el intervalo de a hasta b
double do5;
do5 = la4*centFactor(3);
for (int i = 0; i < 12; i++) {
scale[i] = do5*centFactor(i);
}
return scale;
}
double * scale = tuneScale(la4); // creation of the scale from tuneScale function and predefined la4
double C = scale[0], //definimos las frecuencias de las notas
Cs = scale[1],
D = scale[2],
Ds = scale[3],
E = scale[4],
F = scale[5],
Fs = scale[6],
G = scale[7],
Gs = scale[8],
A = scale[9],
As = scale[10],
B = scale[11],
PAU = 30000; //pausa
int random_tonal_row, random_note = 0;
// array of 15 tonal rows consisting of 16 notes each
double melody[15][16] = { // consider array as [number of melody rows][number of notes on each melody row]
// The Well-Tempered Clavier, BWV 846: Prelude No. 1 in C major (Fragment)
{ C/2, E/2, G/2, C, E, G/2, C, E, C/2, E/2, G/2, C, E, G/2, C, E },
{ C/2, D/2, A/2, D, F, A/2, D, F, C/2, D/2, A/2, D, F, A/2, D, F },
{ B/4, D/2, G/2, D, F, G/2, D, F, B/4, D/2, G/2, D, F, G/2, D, F },
{ C/2, E/2, G/2, C, E, G/2, C, E, C/2, E/2, G/2, C, E, G/2, C, E} ,
{ C/2 , E/2 , A/2 , E, A, A/2, E, A, C/2 , E/2 , A/2 , E, A, A/2, E, A },
{ C/2, D/2, Fs/2, A/2, D, Fs/2, A/2, D, C/2, D/2, Fs/2, A/2, D, Fs/2, A/2, D },
{ B/4, D/2, G/2, D, G, G/2, B/2, G, B/4, D/2, G/2, D, G, G/2, B/2, G },
{ B/4, C/2, E/2, G/2, C, E/2, G/2, C, B/4, C/2, E/2, G/2, C, E/2, G/2, C },
{ A/4, C/2, E/2, G/2, C, E/2, G/2, C, A/4, C/2, E/2, G/2, C, E/2, G/2, C },
{ Fs/4, A/4, D/2, A/2, C, D/2, A/2, C, Fs/4, A/4, D/2, A/2, C, D/2, A/2, C },
{ G/4, B/4, D/2, G/2, B/2, D/2, G/2, B/2, G/4, B/4, D/2, G/2, B/2, D/2, G/2, B/2 },
{ G/4, As/4, E/2, G/2, Cs, E/2, G/2, Cs, G/4, As/4, E/2, G/2, Cs, E/2, G/2, Cs },
{ F/4, A/4, D/2, A/2, D, D/2, A/2, D, F/4, A/4, D/2, A/2, D, D/2, A/2, D },
{ F/4, D/2, F/2, Gs/2, B/2, F/2, Gs/2, B/2, F/4, D/2, F/2, Gs/2, B/2, F/2, Gs/2, B/2 },
{ E/4, C/2, E/2, G/2, C, E/2, G/2, C, E/4, C/2, E/2, G/2, C, E/2, G/2, C }
};
void setup() {
// put your setup code here, to run once:
pinMode(11, OUTPUT); // fija pin 11 como salida
Serial.begin(9600); //for freakin' printin'
}
void loop() {
for (int i = 0; i < 15; i++) {
//random_tonal_row = random(0,15); // definimos renglon tonal de manera aleatoria. Para random(min,max) el mínimo es inclusivo mientras el maximo es exlcusivo
Serial.println();
// imprimimos en serial para rescatar posibles combincaciones interesantes al utilizar random
//Serial.print(":");
for(int j = 0 ; j < 16; j++){
Serial.print(melody[i][j]);
//random_note = random(0,17); // 17 no existe es para agregar posible pausa
//Serial.print(random_note);
Serial.print("\t"); // tabulador para distinguir renglones tonales de mas de dos digitos
tone(11, melody[i][j]); //da el tono a la frecuencia de la nota del ciclo, le pasamos el renglon tonal aleatorio para las 16 notas o podemos pasarle también random note.
delay(h);//se mantiene con la nota el tiempo definido, para tiempos mas complejos se puede hacer un arreglo similar a melody
noTone(11); //finaliza la nota
}
}
//Serial.println();
}
El código anterior pueden descargarlo en el enlace compartido a continuación:
¡Haz clic aquí para descargar Arduino_i_play_u_bach sketch!
Cualquier pregunta, duda, aclaración o recomendación acerca del código por favor háganla saber escribiendo un correo en la sección de contacto.
Aquí pueden escuchar un par de grabaciones de audio con fines demostrativos donde se compara la apreciación de un fragmento de BWV 846: Prelude No. 1 in C major ejecutado con una escala igualmente temparada en la entonación normalizada con A4 = 440 Hz seguida de una entonación de 400 Hz. ¿Cual te parece mas armónica?
Escuchar BWV 846 afinado en base a «la» medio de 400Hz
Escuchar BWV 846 afinado en base a «la» medio de 440Hz
Ejercicios propuestos:
- Modifica el código para que la melodía sea reproducida al revés.
- Modifica el código para que se reproduzcan los renglones tonales de forma aleatoria.
- Modifica el código para que reproduzca las notas de la melodía de forma aleatoria.
¡Saludos y feliz primavera!
Atl Tlachinolli 
