Electronic Music

/*
  ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
                     Sintetizador monofônico com 13 teclas Arpejador de oitavas
                                  by Glauber Santiago - 2018
  ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒

  ▒▒ Descrição e funcionamento
  Este é um sintetizador monofônico, um teclado com 13 notas, de dó a lá, acionadas por 13 pushbuttons. A cada
  acionamento de tecla são emitidas 3 notas sucessivas. Uma oitava acima, outra oitava abaixo e outra na oitava padrão.

  ▒▒ Circuito:
  Utilizando-se um Arduino UNO como modelo.

  Um pushbutton entre cada pino conforme a indicação a seguir e o GND. Ou seja, um terminal do pushbutton no GND e o outro no pino.
  Tecla 1 = 13;
  Tecla 2 = 12;
  Tecla 3 = 10;
  Tecla 4 = 9;
  Tecla 5 = 8;
  Tecla 6 = 7;//Este é o A1
  Tecla 7 = 6;//Este é o A0
  Tecla 8 = 2;
  Tecla 9 = 3;
  Tecla 10 = 4;
  Tecla 11 = 5;
  Tecla 12 = 14;
  Tecla 13 = 15;

  Para o áudio:
  É necessário o uso do seguinte circuito para uma adequada utilização da biblioteca do som (o sintetizador):

                   +10µF
  PIN 11 ---[ 1k ]--+---||--->> Audio out
                 |
                === 10nF
                 |
                GND
  Este esquema foi disponibilizado pelo elaborador da biblioteca conforme as indicações de site a seguir.
  Mais instruções para elaboração do circuito para o áudio estão no seguinte site:
  http://www.instructables.com/id/Turn-your-Arduino-into-a-4-voice-wavetable-synth-w/

  ▒▒ Software:
  Para o projeto utilizamos a seguinte biblioteca:
  Dzl/Illutron 2014
  dzlsevilgeniuslair.blogspot.dk
  illutron.dk
  https://github.com/dzlonline/the_synth/tree/master/the_synth

  Além disso foi utilizado o presente sketch a ser carregado no micro controlador.


*/

#include <synth.h>// Inclui a biblioteca https://github.com/dzlonline/the_synth
synth edgar;    //Cria o sintetizador da biblioteca synth.h.

//Constantes para as notas
const float notaBotao1  = 65.406 * 0.5; //Dó1
const float notaBotao2  = 73.416 * 0.5; //Ré1
const float notaBotao3  = 82.407 * 0.5; //Mi1
const float notaBotao4  = 87.307 * 0.5; //Fá1
const float notaBotao5  = 97.999 * 0.5; //Sol1
const float notaBotao6  = 110.000 * 0.5; //Lá1
const float notaBotao7  = 123.47 * 0.5; //Si1
const float notaBotao8  = 130.81 * 0.5; //Dó2
const float notaBotao9  = 146.83 * 0.5; //Ré2
const float notaBotao10  = 164.81 * 0.5; //Mi2
const float notaBotao11  = 174.61 * 0.5; //Fá2
const float notaBotao12  = 196.000 * 0.5; //Sol2
const float notaBotao13  = 220.000 * 0.5; //Lá2

const int duracao1 = 10;//Esta é a duração do delay para as notas do arpejo.
const int duracao2 = 80;//Esta é a duração do delay para as notas do arpejo.

//Pinos dos botões.
const int pinoDoBotao1 = 13;
const int pinoDoBotao2 = 12;
const int pinoDoBotao3 = 10;
const int pinoDoBotao4 = 9;
const int pinoDoBotao5 = 8;
const int pinoDoBotao6 = 7;//Este é o A1
const int pinoDoBotao7 = 6;//Este é o A0
const int pinoDoBotao8 = 2;
const int pinoDoBotao9 = 3;
const int pinoDoBotao10 = 4;
const int pinoDoBotao11 = 5;
const int pinoDoBotao12 = 14;
const int pinoDoBotao13 = 15;

//Variável que irá rastrear o estado dos botões.
int estadoDoBotao1 = HIGH;
int estadoDoBotao2 = HIGH;
int estadoDoBotao3 = HIGH;
int estadoDoBotao4 = HIGH;
int estadoDoBotao5 = HIGH;
int estadoDoBotao6 = HIGH;
int estadoDoBotao7 = HIGH;
int estadoDoBotao8 = HIGH;
int estadoDoBotao9 = HIGH;
int estadoDoBotao10 = HIGH;
int estadoDoBotao11 = HIGH;
int estadoDoBotao12 = HIGH;
int estadoDoBotao13 = HIGH;

void setup() { //Chave inicial o void setup.

  edgar.begin();                                   //Inicia o sintetizador
  //A seguir será realizado o comando de gerar o som. Os parâmetros são os seguintes:
  //(voice[0-3],waveform[SINE,TRIANGLE,SQUARE,SAW,RAMP,NOISE],pitch[0-127],
  //envelope[ENVELOPE0-ENVELOPE3], length[0-127], mod[0-127, 64=no mod])
  edgar.setupVoice(0, SAW, 1, ENVELOPE2, 110, 64);

  //Ficou: Voz 0, Wafeform TRIANGLE,//Pitch 64, Envelope3, comprimento 127,
  //Modulação 64.

  //Define que os pinos digitais serão entradas e usarão do recurso interno do resistor pullup.
  pinMode(pinoDoBotao1, INPUT_PULLUP);
  pinMode(pinoDoBotao2, INPUT_PULLUP);
  pinMode(pinoDoBotao3, INPUT_PULLUP);
  pinMode(pinoDoBotao4, INPUT_PULLUP);
  pinMode(pinoDoBotao5, INPUT_PULLUP);
  pinMode(pinoDoBotao6, INPUT_PULLUP);
  pinMode(pinoDoBotao7, INPUT_PULLUP);
  pinMode(pinoDoBotao8, INPUT_PULLUP);
  pinMode(pinoDoBotao9, INPUT_PULLUP);
  pinMode(pinoDoBotao10, INPUT_PULLUP);
  pinMode(pinoDoBotao11, INPUT_PULLUP);
  pinMode(pinoDoBotao12, INPUT_PULLUP);
  pinMode(pinoDoBotao13, INPUT_PULLUP);

}//Chave final do void setup.

void loop()
{ //Chave inicial o void loop.

  verificacaoDeApertoDoBotao1(); //Chama a função que confere se o botão foi apertado.
  verificacaoDeApertoDoBotao2(); //Chama a função que confere se o botão foi apertado.
  verificacaoDeApertoDoBotao3(); //Chama a função que confere se o botão foi apertado.
  verificacaoDeApertoDoBotao4(); //Chama a função que confere se o botão foi apertado.
  verificacaoDeApertoDoBotao5(); //Chama a função que confere se o botão foi apertado.
  verificacaoDeApertoDoBotao6(); //Chama a função que confere se o botão foi apertado.
  verificacaoDeApertoDoBotao7(); //Chama a função que confere se o botão foi apertado.
  verificacaoDeApertoDoBotao8(); //Chama a função que confere se o botão foi apertado.
  verificacaoDeApertoDoBotao9(); //Chama a função que confere se o botão foi apertado.
  verificacaoDeApertoDoBotao10(); //Chama a função que confere se o botão foi apertado.
  verificacaoDeApertoDoBotao11(); //Chama a função que confere se o botão foi apertado.
  verificacaoDeApertoDoBotao12(); //Chama a função que confere se o botão foi apertado.
} //Chave final o void loop.

///////////////////////////////////
void verificacaoDeApertoDoBotao1()
{ //Chave inicial do verificacaoDeApertoDoBotao1.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao1 = digitalRead(pinoDoBotao1);
  if (estado_botao1 == LOW && estado_botao1 != estadoDoBotao1)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao1 = estado_botao1;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao1 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao1); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao1 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.

  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao1 == HIGH && estado_botao1 != estadoDoBotao1)
  { //Chave inicial deste if.
    estadoDoBotao1 = estado_botao1;
    delay (10);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao1.

///////////////////////////////////
void verificacaoDeApertoDoBotao2()
{ //Chave inicial do verificacaoDeApertoDoBotao2.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao2 = digitalRead(pinoDoBotao2);
  if (estado_botao2 == LOW && estado_botao2 != estadoDoBotao2)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao2 = estado_botao2;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao2 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao2 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao2 == HIGH && estado_botao2 != estadoDoBotao2)
  { //Chave inicial deste if.
    estadoDoBotao2 = estado_botao2;
    delay (20);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao2.

///////////////////////////////////
void verificacaoDeApertoDoBotao3()
{ //Chave inicial do verificacaoDeApertoDoBotao3.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao3 = digitalRead(pinoDoBotao3);
  if (estado_botao3 == LOW && estado_botao3 != estadoDoBotao3)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao3 = estado_botao3;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao3 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao3); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao3 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao3 == HIGH && estado_botao3 != estadoDoBotao3)
  { //Chave inicial deste if.
    estadoDoBotao3 = estado_botao3;
    delay (20);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao4.

///////////////////////////////////
void verificacaoDeApertoDoBotao4()
{ //Chave inicial do verificacaoDeApertoDoBotao.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao4 = digitalRead(pinoDoBotao4);
  if (estado_botao4 == LOW && estado_botao4 != estadoDoBotao4)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao4 = estado_botao4;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao4 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao4 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.

  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao4 == HIGH && estado_botao4 != estadoDoBotao4)
  { //Chave inicial deste if.
    estadoDoBotao4 = estado_botao4;
    delay (20);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao4.

void verificacaoDeApertoDoBotao5()
{ //Chave inicial do verificacaoDeApertoDoBotao.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao5 = digitalRead(pinoDoBotao5);
  if (estado_botao5 == LOW && estado_botao5 != estadoDoBotao5)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao5 = estado_botao5;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao5 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao5); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao5 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao5 == HIGH && estado_botao5 != estadoDoBotao5)
  { //Chave inicial deste if.
    estadoDoBotao5 = estado_botao5;
    delay (20);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao5.

void verificacaoDeApertoDoBotao6()
{ //Chave inicial do verificacaoDeApertoDoBotao.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao6 = digitalRead(pinoDoBotao6);
  if (estado_botao6 == LOW && estado_botao6 != estadoDoBotao6)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao6 = estado_botao6;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao6 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao6); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao6 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.

  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao6 == HIGH && estado_botao6 != estadoDoBotao6)
  { //Chave inicial deste if.
    estadoDoBotao6 = estado_botao6;
    delay (20);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao6.

void verificacaoDeApertoDoBotao7()
{ //Chave inicial do verificacaoDeApertoDoBotao.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao7 = digitalRead(pinoDoBotao7);
  if (estado_botao7 == LOW && estado_botao7 != estadoDoBotao7)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao7 = estado_botao7;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao7 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao7); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao7 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.

  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao7 == HIGH && estado_botao7 != estadoDoBotao7)
  { //Chave inicial deste if.
    estadoDoBotao7 = estado_botao7;
    delay (20);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao7.

//////////////////////////////////////////////////
void verificacaoDeApertoDoBotao8()
{ //Chave inicial do verificacaoDeApertoDoBotao.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao8 = digitalRead(pinoDoBotao8);
  if (estado_botao8 == LOW && estado_botao8 != estadoDoBotao8)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao8 = estado_botao8;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao8 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao8); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao8 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.

  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao8 == HIGH && estado_botao8 != estadoDoBotao8)
  { //Chave inicial deste if.
    estadoDoBotao8 = estado_botao8;
    delay (20);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao8.


//////////////////////////////////////////////////
void verificacaoDeApertoDoBotao9()
{ //Chave inicial do verificacaoDeApertoDoBotao.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao9 = digitalRead(pinoDoBotao9);
  if (estado_botao9 == LOW && estado_botao9 != estadoDoBotao9)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao9 = estado_botao9;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao9 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao9); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao9 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.

  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao9 == HIGH && estado_botao9 != estadoDoBotao9)
  { //Chave inicial deste if.
    estadoDoBotao9 = estado_botao9;
    delay (20);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao9.

//////////////////////////////////////////////////
void verificacaoDeApertoDoBotao10()
{ //Chave inicial do verificacaoDeApertoDoBotao.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao10 = digitalRead(pinoDoBotao10);
  if (estado_botao10 == LOW && estado_botao10 != estadoDoBotao10)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao10 = estado_botao10;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao10 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao10); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao10 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.

  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao10 == HIGH && estado_botao10 != estadoDoBotao10)
  { //Chave inicial deste if.
    estadoDoBotao10 = estado_botao10;
    delay (20);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao10.

//////////////////////////////////////////////////
void verificacaoDeApertoDoBotao11()
{ //Chave inicial do verificacaoDeApertoDoBotao.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao11 = digitalRead(pinoDoBotao11);
  if (estado_botao11 == LOW && estado_botao11 != estadoDoBotao11)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao11 = estado_botao11;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao11 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao11); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao11 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.

  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao11 == HIGH && estado_botao11 != estadoDoBotao11)
  { //Chave inicial deste if.
    estadoDoBotao11 = estado_botao11;
    delay (20);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao11.

//////////////////////////////////////////////////
void verificacaoDeApertoDoBotao12()
{ //Chave inicial do verificacaoDeApertoDoBotao.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao12 = digitalRead(pinoDoBotao12);
  if (estado_botao12 == LOW && estado_botao12 != estadoDoBotao12)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao12 = estado_botao12;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao12 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao12); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao12 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.

  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao12 == HIGH && estado_botao12 != estadoDoBotao12)
  { //Chave inicial deste if.
    estadoDoBotao12 = estado_botao12;
    delay (20);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao12.

//////////////////////////////////////////////////
void verificacaoDeApertoDoBotao13()
{ //Chave inicial do verificacaoDeApertoDoBotao.
  //Verifica se o pino digital do botao foi pressionado.
  int estado_botao13 = digitalRead(pinoDoBotao13);
  if (estado_botao13 == LOW && estado_botao13 != estadoDoBotao13)
  { // Chave inicial deste if.
    //Troca estado on/off.
    //Atualiza estado o botão.
    estadoDoBotao13 = estado_botao13;
    //Uso de um delay como forma grosseira de fazer o debouncing.
    delay (20);

    edgar.setFrequency(0, notaBotao13 * 4); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao1);
    edgar.setFrequency(0, notaBotao13); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
    delay (duracao2);
    edgar.setFrequency(0, notaBotao13 * 2); //Aqui a nota do respectivo botao é indicada.
    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.

  }//Chave final deste if.

  //Verifica soltura do botão.
  if (estado_botao13 == HIGH && estado_botao13 != estadoDoBotao13)
  { //Chave inicial deste if.
    estadoDoBotao13 = estado_botao13;
    delay (20);//Este delay é uma forma grosseira de fazer o debouncing.

    edgar.setFrequency(0, 0);//Aqui é indicado para o botão não tocar nenhuma nota.
    edgar.trigger(0);//Aqui o comando de não tocar nenhuma nota é acionado.

  }//Chave final deste if.
}//Chave final do void verificacaoDeApertoDoBotao13.