Electronic Music

1/*
2  ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
3                     Sintetizador  monofônico com 13 teclas Arpejador de oitavas
4                                  by  Glauber Santiago - 2018
5  ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
6
7  ▒▒ Descrição e funcionamento
8  Este é um sintetizador monofônico, um teclado  com 13 notas, de dó a lá, acionadas por 13 pushbuttons. A cada
9  acionamento  de tecla são emitidas 3 notas sucessivas. Uma oitava acima, outra oitava abaixo  e outra na oitava padrão.
10
11  ▒▒ Circuito:
12  Utilizando-se um Arduino UNO  como modelo.
13
14  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.
15  Tecla  1 = 13;
16  Tecla 2 = 12;
17  Tecla 3 = 10;
18  Tecla 4 = 9;
19  Tecla 5 = 8;
20  Tecla 6 = 7;//Este é o A1
21  Tecla 7 = 6;//Este é o A0
22  Tecla 8 = 2;
23  Tecla 9 = 3;
24  Tecla 10 = 4;
25  Tecla 11 = 5;
26  Tecla 12 = 14;
27  Tecla  13 = 15;
28
29  Para o áudio:
30  É necessário o uso do seguinte circuito para  uma adequada utilização da biblioteca do som (o sintetizador):
31
32                   +10µF
33  PIN 11 ---[ 1k ]--+---||--->> Audio out
34                 |
35                ===  10nF
36                 |
37                GND
38  Este esquema foi disponibilizado  pelo elaborador da biblioteca conforme as indicações de site a seguir.
39  Mais  instruções para elaboração do circuito para o áudio estão no seguinte site:
40  http://www.instructables.com/id/Turn-your-Arduino-into-a-4-voice-wavetable-synth-w/
41
42  ▒▒ Software:
43  Para o projeto utilizamos a seguinte biblioteca:
44  Dzl/Illutron  2014
45  dzlsevilgeniuslair.blogspot.dk
46  illutron.dk
47  https://github.com/dzlonline/the_synth/tree/master/the_synth
48
49  Além disso foi utilizado o presente sketch a ser carregado no micro controlador.
50
51
52*/
53
54#include  <synth.h>// Inclui a biblioteca https://github.com/dzlonline/the_synth
55synth  edgar;    //Cria o sintetizador da biblioteca synth.h.
56
57//Constantes para  as notas
58const float notaBotao1  = 65.406 * 0.5; //Dó1
59const float notaBotao2  = 73.416 * 0.5; //Ré1
60const float notaBotao3  = 82.407 * 0.5; //Mi1
61const  float notaBotao4  = 87.307 * 0.5; //Fá1
62const float notaBotao5  = 97.999 * 0.5;  //Sol1
63const float notaBotao6  = 110.000 * 0.5; //Lá1
64const float notaBotao7  = 123.47 * 0.5; //Si1
65const float notaBotao8  = 130.81 * 0.5; //Dó2
66const  float notaBotao9  = 146.83 * 0.5; //Ré2
67const float notaBotao10  = 164.81 * 0.5;  //Mi2
68const float notaBotao11  = 174.61 * 0.5; //Fá2
69const float notaBotao12  = 196.000 * 0.5; //Sol2
70const float notaBotao13  = 220.000 * 0.5; //Lá2
71
72const  int duracao1 = 10;//Esta é a duração do delay para as notas do arpejo.
73const  int duracao2 = 80;//Esta é a duração do delay para as notas do arpejo.
74
75//Pinos  dos botões.
76const int pinoDoBotao1 = 13;
77const int pinoDoBotao2 = 12;
78const  int pinoDoBotao3 = 10;
79const int pinoDoBotao4 = 9;
80const int pinoDoBotao5  = 8;
81const int pinoDoBotao6 = 7;//Este é o A1
82const int pinoDoBotao7 = 6;//Este  é o A0
83const int pinoDoBotao8 = 2;
84const int pinoDoBotao9 = 3;
85const int  pinoDoBotao10 = 4;
86const int pinoDoBotao11 = 5;
87const int pinoDoBotao12 =  14;
88const int pinoDoBotao13 = 15;
89
90//Variável que irá rastrear o estado  dos botões.
91int estadoDoBotao1 = HIGH;
92int estadoDoBotao2 = HIGH;
93int estadoDoBotao3  = HIGH;
94int estadoDoBotao4 = HIGH;
95int estadoDoBotao5 = HIGH;
96int estadoDoBotao6  = HIGH;
97int estadoDoBotao7 = HIGH;
98int estadoDoBotao8 = HIGH;
99int estadoDoBotao9  = HIGH;
100int estadoDoBotao10 = HIGH;
101int estadoDoBotao11 = HIGH;
102int estadoDoBotao12  = HIGH;
103int estadoDoBotao13 = HIGH;
104
105void setup() { //Chave inicial o void  setup.
106
107  edgar.begin();                                   //Inicia o sintetizador
108  //A seguir será realizado o comando de gerar o som. Os parâmetros são os seguintes:
109  //(voice[0-3],waveform[SINE,TRIANGLE,SQUARE,SAW,RAMP,NOISE],pitch[0-127],
110  //envelope[ENVELOPE0-ENVELOPE3], length[0-127], mod[0-127, 64=no mod])
111  edgar.setupVoice(0,  SAW, 1, ENVELOPE2, 110, 64);
112
113  //Ficou: Voz 0, Wafeform TRIANGLE,//Pitch  64, Envelope3, comprimento 127,
114  //Modulação 64.
115
116  //Define que os pinos  digitais serão entradas e usarão do recurso interno do resistor pullup.
117  pinMode(pinoDoBotao1,  INPUT_PULLUP);
118  pinMode(pinoDoBotao2, INPUT_PULLUP);
119  pinMode(pinoDoBotao3,  INPUT_PULLUP);
120  pinMode(pinoDoBotao4, INPUT_PULLUP);
121  pinMode(pinoDoBotao5,  INPUT_PULLUP);
122  pinMode(pinoDoBotao6, INPUT_PULLUP);
123  pinMode(pinoDoBotao7,  INPUT_PULLUP);
124  pinMode(pinoDoBotao8, INPUT_PULLUP);
125  pinMode(pinoDoBotao9,  INPUT_PULLUP);
126  pinMode(pinoDoBotao10, INPUT_PULLUP);
127  pinMode(pinoDoBotao11,  INPUT_PULLUP);
128  pinMode(pinoDoBotao12, INPUT_PULLUP);
129  pinMode(pinoDoBotao13,  INPUT_PULLUP);
130
131}//Chave final do void setup.
132
133void loop()
134{ //Chave  inicial o void loop.
135
136  verificacaoDeApertoDoBotao1(); //Chama a função que  confere se o botão foi apertado.
137  verificacaoDeApertoDoBotao2(); //Chama a função  que confere se o botão foi apertado.
138  verificacaoDeApertoDoBotao3(); //Chama  a função que confere se o botão foi apertado.
139  verificacaoDeApertoDoBotao4();  //Chama a função que confere se o botão foi apertado.
140  verificacaoDeApertoDoBotao5();  //Chama a função que confere se o botão foi apertado.
141  verificacaoDeApertoDoBotao6();  //Chama a função que confere se o botão foi apertado.
142  verificacaoDeApertoDoBotao7();  //Chama a função que confere se o botão foi apertado.
143  verificacaoDeApertoDoBotao8();  //Chama a função que confere se o botão foi apertado.
144  verificacaoDeApertoDoBotao9();  //Chama a função que confere se o botão foi apertado.
145  verificacaoDeApertoDoBotao10();  //Chama a função que confere se o botão foi apertado.
146  verificacaoDeApertoDoBotao11();  //Chama a função que confere se o botão foi apertado.
147  verificacaoDeApertoDoBotao12();  //Chama a função que confere se o botão foi apertado.
148} //Chave final o void  loop.
149
150///////////////////////////////////
151void verificacaoDeApertoDoBotao1()
152{  //Chave inicial do verificacaoDeApertoDoBotao1.
153  //Verifica se o pino digital  do botao foi pressionado.
154  int estado_botao1 = digitalRead(pinoDoBotao1);
155  if (estado_botao1 == LOW && estado_botao1 != estadoDoBotao1)
156  { // Chave inicial  deste if.
157    //Troca estado on/off.
158    //Atualiza estado o botão.
159    estadoDoBotao1  = estado_botao1;
160    //Uso de um delay como forma grosseira de fazer o debouncing.
161    delay (20);
162
163    edgar.setFrequency(0, notaBotao1 * 4); //Aqui a nota  do respectivo botao é indicada.
164    edgar.trigger(0);//Aqui a nota do respectivo  botao é ligada.
165    delay (duracao1);
166    edgar.setFrequency(0, notaBotao1);  //Aqui a nota do respectivo botao é indicada.
167    edgar.trigger(0);//Aqui a nota  do respectivo botao é ligada.
168    delay (duracao2);
169    edgar.setFrequency(0,  notaBotao1 * 2); //Aqui a nota do respectivo botao é indicada.
170    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
171
172  }//Chave final deste if.
173
174  //Verifica  soltura do botão.
175  if (estado_botao1 == HIGH && estado_botao1 != estadoDoBotao1)
176  { //Chave inicial deste if.
177    estadoDoBotao1 = estado_botao1;
178    delay  (10);//Este delay é uma forma grosseira de fazer o debouncing.
179
180    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
181    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
182
183  }//Chave final deste if.
184}//Chave  final do void verificacaoDeApertoDoBotao1.
185
186///////////////////////////////////
187void  verificacaoDeApertoDoBotao2()
188{ //Chave inicial do verificacaoDeApertoDoBotao2.
189  //Verifica se o pino digital do botao foi pressionado.
190  int estado_botao2  = digitalRead(pinoDoBotao2);
191  if (estado_botao2 == LOW && estado_botao2 != estadoDoBotao2)
192  { // Chave inicial deste if.
193    //Troca estado on/off.
194    //Atualiza estado  o botão.
195    estadoDoBotao2 = estado_botao2;
196    //Uso de um delay como forma  grosseira de fazer o debouncing.
197    delay (20);
198
199    edgar.setFrequency(0,  notaBotao2 * 4); //Aqui a nota do respectivo botao é indicada.
200    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
201    delay (duracao1);
202    edgar.setFrequency(0,  notaBotao2); //Aqui a nota do respectivo botao é indicada.
203    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
204    delay (duracao2);
205    edgar.setFrequency(0,  notaBotao2 * 2); //Aqui a nota do respectivo botao é indicada.
206    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
207  }//Chave final deste if.
208
209  //Verifica  soltura do botão.
210  if (estado_botao2 == HIGH && estado_botao2 != estadoDoBotao2)
211  { //Chave inicial deste if.
212    estadoDoBotao2 = estado_botao2;
213    delay  (20);//Este delay é uma forma grosseira de fazer o debouncing.
214
215    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
216    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
217
218  }//Chave final deste if.
219}//Chave  final do void verificacaoDeApertoDoBotao2.
220
221///////////////////////////////////
222void  verificacaoDeApertoDoBotao3()
223{ //Chave inicial do verificacaoDeApertoDoBotao3.
224  //Verifica se o pino digital do botao foi pressionado.
225  int estado_botao3  = digitalRead(pinoDoBotao3);
226  if (estado_botao3 == LOW && estado_botao3 != estadoDoBotao3)
227  { // Chave inicial deste if.
228    //Troca estado on/off.
229    //Atualiza estado  o botão.
230    estadoDoBotao3 = estado_botao3;
231    //Uso de um delay como forma  grosseira de fazer o debouncing.
232    delay (20);
233
234    edgar.setFrequency(0,  notaBotao3 * 4); //Aqui a nota do respectivo botao é indicada.
235    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
236    delay (duracao1);
237    edgar.setFrequency(0,  notaBotao3); //Aqui a nota do respectivo botao é indicada.
238    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
239    delay (duracao2);
240    edgar.setFrequency(0,  notaBotao3 * 2); //Aqui a nota do respectivo botao é indicada.
241    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
242  }//Chave final deste if.
243
244  //Verifica  soltura do botão.
245  if (estado_botao3 == HIGH && estado_botao3 != estadoDoBotao3)
246  { //Chave inicial deste if.
247    estadoDoBotao3 = estado_botao3;
248    delay  (20);//Este delay é uma forma grosseira de fazer o debouncing.
249
250    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
251    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
252
253  }//Chave final deste if.
254}//Chave  final do void verificacaoDeApertoDoBotao4.
255
256///////////////////////////////////
257void  verificacaoDeApertoDoBotao4()
258{ //Chave inicial do verificacaoDeApertoDoBotao.
259  //Verifica se o pino digital do botao foi pressionado.
260  int estado_botao4  = digitalRead(pinoDoBotao4);
261  if (estado_botao4 == LOW && estado_botao4 != estadoDoBotao4)
262  { // Chave inicial deste if.
263    //Troca estado on/off.
264    //Atualiza estado  o botão.
265    estadoDoBotao4 = estado_botao4;
266    //Uso de um delay como forma  grosseira de fazer o debouncing.
267    delay (20);
268
269    edgar.setFrequency(0,  notaBotao4 * 4); //Aqui a nota do respectivo botao é indicada.
270    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
271    delay (duracao1);
272    edgar.setFrequency(0,  notaBotao4); //Aqui a nota do respectivo botao é indicada.
273    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
274    delay (duracao2);
275    edgar.setFrequency(0,  notaBotao4 * 2); //Aqui a nota do respectivo botao é indicada.
276    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
277
278  }//Chave final deste if.
279
280  //Verifica  soltura do botão.
281  if (estado_botao4 == HIGH && estado_botao4 != estadoDoBotao4)
282  { //Chave inicial deste if.
283    estadoDoBotao4 = estado_botao4;
284    delay  (20);//Este delay é uma forma grosseira de fazer o debouncing.
285
286    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
287    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
288
289  }//Chave final deste if.
290}//Chave  final do void verificacaoDeApertoDoBotao4.
291
292void verificacaoDeApertoDoBotao5()
293{  //Chave inicial do verificacaoDeApertoDoBotao.
294  //Verifica se o pino digital  do botao foi pressionado.
295  int estado_botao5 = digitalRead(pinoDoBotao5);
296  if (estado_botao5 == LOW && estado_botao5 != estadoDoBotao5)
297  { // Chave inicial  deste if.
298    //Troca estado on/off.
299    //Atualiza estado o botão.
300    estadoDoBotao5  = estado_botao5;
301    //Uso de um delay como forma grosseira de fazer o debouncing.
302    delay (20);
303
304    edgar.setFrequency(0, notaBotao5 * 4); //Aqui a nota  do respectivo botao é indicada.
305    edgar.trigger(0);//Aqui a nota do respectivo  botao é ligada.
306    delay (duracao1);
307    edgar.setFrequency(0, notaBotao5);  //Aqui a nota do respectivo botao é indicada.
308    edgar.trigger(0);//Aqui a nota  do respectivo botao é ligada.
309    delay (duracao2);
310    edgar.setFrequency(0,  notaBotao5 * 2); //Aqui a nota do respectivo botao é indicada.
311    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
312  }//Chave final deste if.
313
314  //Verifica  soltura do botão.
315  if (estado_botao5 == HIGH && estado_botao5 != estadoDoBotao5)
316  { //Chave inicial deste if.
317    estadoDoBotao5 = estado_botao5;
318    delay  (20);//Este delay é uma forma grosseira de fazer o debouncing.
319
320    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
321    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
322
323  }//Chave final deste if.
324}//Chave  final do void verificacaoDeApertoDoBotao5.
325
326void verificacaoDeApertoDoBotao6()
327{  //Chave inicial do verificacaoDeApertoDoBotao.
328  //Verifica se o pino digital  do botao foi pressionado.
329  int estado_botao6 = digitalRead(pinoDoBotao6);
330  if (estado_botao6 == LOW && estado_botao6 != estadoDoBotao6)
331  { // Chave inicial  deste if.
332    //Troca estado on/off.
333    //Atualiza estado o botão.
334    estadoDoBotao6  = estado_botao6;
335    //Uso de um delay como forma grosseira de fazer o debouncing.
336    delay (20);
337
338    edgar.setFrequency(0, notaBotao6 * 4); //Aqui a nota  do respectivo botao é indicada.
339    edgar.trigger(0);//Aqui a nota do respectivo  botao é ligada.
340    delay (duracao1);
341    edgar.setFrequency(0, notaBotao6);  //Aqui a nota do respectivo botao é indicada.
342    edgar.trigger(0);//Aqui a nota  do respectivo botao é ligada.
343    delay (duracao2);
344    edgar.setFrequency(0,  notaBotao6 * 2); //Aqui a nota do respectivo botao é indicada.
345    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
346
347  }//Chave final deste if.
348
349  //Verifica  soltura do botão.
350  if (estado_botao6 == HIGH && estado_botao6 != estadoDoBotao6)
351  { //Chave inicial deste if.
352    estadoDoBotao6 = estado_botao6;
353    delay  (20);//Este delay é uma forma grosseira de fazer o debouncing.
354
355    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
356    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
357
358  }//Chave final deste if.
359}//Chave  final do void verificacaoDeApertoDoBotao6.
360
361void verificacaoDeApertoDoBotao7()
362{  //Chave inicial do verificacaoDeApertoDoBotao.
363  //Verifica se o pino digital  do botao foi pressionado.
364  int estado_botao7 = digitalRead(pinoDoBotao7);
365  if (estado_botao7 == LOW && estado_botao7 != estadoDoBotao7)
366  { // Chave inicial  deste if.
367    //Troca estado on/off.
368    //Atualiza estado o botão.
369    estadoDoBotao7  = estado_botao7;
370    //Uso de um delay como forma grosseira de fazer o debouncing.
371    delay (20);
372
373    edgar.setFrequency(0, notaBotao7 * 4); //Aqui a nota  do respectivo botao é indicada.
374    edgar.trigger(0);//Aqui a nota do respectivo  botao é ligada.
375    delay (duracao1);
376    edgar.setFrequency(0, notaBotao7);  //Aqui a nota do respectivo botao é indicada.
377    edgar.trigger(0);//Aqui a nota  do respectivo botao é ligada.
378    delay (duracao2);
379    edgar.setFrequency(0,  notaBotao7 * 2); //Aqui a nota do respectivo botao é indicada.
380    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
381
382  }//Chave final deste if.
383
384  //Verifica  soltura do botão.
385  if (estado_botao7 == HIGH && estado_botao7 != estadoDoBotao7)
386  { //Chave inicial deste if.
387    estadoDoBotao7 = estado_botao7;
388    delay  (20);//Este delay é uma forma grosseira de fazer o debouncing.
389
390    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
391    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
392
393  }//Chave final deste if.
394}//Chave  final do void verificacaoDeApertoDoBotao7.
395
396//////////////////////////////////////////////////
397void  verificacaoDeApertoDoBotao8()
398{ //Chave inicial do verificacaoDeApertoDoBotao.
399  //Verifica se o pino digital do botao foi pressionado.
400  int estado_botao8  = digitalRead(pinoDoBotao8);
401  if (estado_botao8 == LOW && estado_botao8 != estadoDoBotao8)
402  { // Chave inicial deste if.
403    //Troca estado on/off.
404    //Atualiza estado  o botão.
405    estadoDoBotao8 = estado_botao8;
406    //Uso de um delay como forma  grosseira de fazer o debouncing.
407    delay (20);
408
409    edgar.setFrequency(0,  notaBotao8 * 4); //Aqui a nota do respectivo botao é indicada.
410    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
411    delay (duracao1);
412    edgar.setFrequency(0,  notaBotao8); //Aqui a nota do respectivo botao é indicada.
413    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
414    delay (duracao2);
415    edgar.setFrequency(0,  notaBotao8 * 2); //Aqui a nota do respectivo botao é indicada.
416    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
417
418  }//Chave final deste if.
419
420  //Verifica  soltura do botão.
421  if (estado_botao8 == HIGH && estado_botao8 != estadoDoBotao8)
422  { //Chave inicial deste if.
423    estadoDoBotao8 = estado_botao8;
424    delay  (20);//Este delay é uma forma grosseira de fazer o debouncing.
425
426    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
427    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
428
429  }//Chave final deste if.
430}//Chave  final do void verificacaoDeApertoDoBotao8.
431
432
433//////////////////////////////////////////////////
434void  verificacaoDeApertoDoBotao9()
435{ //Chave inicial do verificacaoDeApertoDoBotao.
436  //Verifica se o pino digital do botao foi pressionado.
437  int estado_botao9  = digitalRead(pinoDoBotao9);
438  if (estado_botao9 == LOW && estado_botao9 != estadoDoBotao9)
439  { // Chave inicial deste if.
440    //Troca estado on/off.
441    //Atualiza estado  o botão.
442    estadoDoBotao9 = estado_botao9;
443    //Uso de um delay como forma  grosseira de fazer o debouncing.
444    delay (20);
445
446    edgar.setFrequency(0,  notaBotao9 * 4); //Aqui a nota do respectivo botao é indicada.
447    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
448    delay (duracao1);
449    edgar.setFrequency(0,  notaBotao9); //Aqui a nota do respectivo botao é indicada.
450    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
451    delay (duracao2);
452    edgar.setFrequency(0,  notaBotao9 * 2); //Aqui a nota do respectivo botao é indicada.
453    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
454
455  }//Chave final deste if.
456
457  //Verifica  soltura do botão.
458  if (estado_botao9 == HIGH && estado_botao9 != estadoDoBotao9)
459  { //Chave inicial deste if.
460    estadoDoBotao9 = estado_botao9;
461    delay  (20);//Este delay é uma forma grosseira de fazer o debouncing.
462
463    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
464    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
465
466  }//Chave final deste if.
467}//Chave  final do void verificacaoDeApertoDoBotao9.
468
469//////////////////////////////////////////////////
470void  verificacaoDeApertoDoBotao10()
471{ //Chave inicial do verificacaoDeApertoDoBotao.
472  //Verifica se o pino digital do botao foi pressionado.
473  int estado_botao10  = digitalRead(pinoDoBotao10);
474  if (estado_botao10 == LOW && estado_botao10 !=  estadoDoBotao10)
475  { // Chave inicial deste if.
476    //Troca estado on/off.
477    //Atualiza estado o botão.
478    estadoDoBotao10 = estado_botao10;
479    //Uso  de um delay como forma grosseira de fazer o debouncing.
480    delay (20);
481
482    edgar.setFrequency(0, notaBotao10 * 4); //Aqui a nota do respectivo botao é  indicada.
483    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
484    delay (duracao1);
485    edgar.setFrequency(0, notaBotao10); //Aqui a nota do  respectivo botao é indicada.
486    edgar.trigger(0);//Aqui a nota do respectivo  botao é ligada.
487    delay (duracao2);
488    edgar.setFrequency(0, notaBotao10  * 2); //Aqui a nota do respectivo botao é indicada.
489    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
490
491  }//Chave final deste if.
492
493  //Verifica  soltura do botão.
494  if (estado_botao10 == HIGH && estado_botao10 != estadoDoBotao10)
495  { //Chave inicial deste if.
496    estadoDoBotao10 = estado_botao10;
497    delay  (20);//Este delay é uma forma grosseira de fazer o debouncing.
498
499    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
500    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
501
502  }//Chave final deste if.
503}//Chave  final do void verificacaoDeApertoDoBotao10.
504
505//////////////////////////////////////////////////
506void  verificacaoDeApertoDoBotao11()
507{ //Chave inicial do verificacaoDeApertoDoBotao.
508  //Verifica se o pino digital do botao foi pressionado.
509  int estado_botao11  = digitalRead(pinoDoBotao11);
510  if (estado_botao11 == LOW && estado_botao11 !=  estadoDoBotao11)
511  { // Chave inicial deste if.
512    //Troca estado on/off.
513    //Atualiza estado o botão.
514    estadoDoBotao11 = estado_botao11;
515    //Uso  de um delay como forma grosseira de fazer o debouncing.
516    delay (20);
517
518    edgar.setFrequency(0, notaBotao11 * 4); //Aqui a nota do respectivo botao é  indicada.
519    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
520    delay (duracao1);
521    edgar.setFrequency(0, notaBotao11); //Aqui a nota do  respectivo botao é indicada.
522    edgar.trigger(0);//Aqui a nota do respectivo  botao é ligada.
523    delay (duracao2);
524    edgar.setFrequency(0, notaBotao11  * 2); //Aqui a nota do respectivo botao é indicada.
525    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
526
527  }//Chave final deste if.
528
529  //Verifica  soltura do botão.
530  if (estado_botao11 == HIGH && estado_botao11 != estadoDoBotao11)
531  { //Chave inicial deste if.
532    estadoDoBotao11 = estado_botao11;
533    delay  (20);//Este delay é uma forma grosseira de fazer o debouncing.
534
535    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
536    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
537
538  }//Chave final deste if.
539}//Chave  final do void verificacaoDeApertoDoBotao11.
540
541//////////////////////////////////////////////////
542void  verificacaoDeApertoDoBotao12()
543{ //Chave inicial do verificacaoDeApertoDoBotao.
544  //Verifica se o pino digital do botao foi pressionado.
545  int estado_botao12  = digitalRead(pinoDoBotao12);
546  if (estado_botao12 == LOW && estado_botao12 !=  estadoDoBotao12)
547  { // Chave inicial deste if.
548    //Troca estado on/off.
549    //Atualiza estado o botão.
550    estadoDoBotao12 = estado_botao12;
551    //Uso  de um delay como forma grosseira de fazer o debouncing.
552    delay (20);
553
554    edgar.setFrequency(0, notaBotao12 * 4); //Aqui a nota do respectivo botao é  indicada.
555    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
556    delay (duracao1);
557    edgar.setFrequency(0, notaBotao12); //Aqui a nota do  respectivo botao é indicada.
558    edgar.trigger(0);//Aqui a nota do respectivo  botao é ligada.
559    delay (duracao2);
560    edgar.setFrequency(0, notaBotao12  * 2); //Aqui a nota do respectivo botao é indicada.
561    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
562
563  }//Chave final deste if.
564
565  //Verifica  soltura do botão.
566  if (estado_botao12 == HIGH && estado_botao12 != estadoDoBotao12)
567  { //Chave inicial deste if.
568    estadoDoBotao12 = estado_botao12;
569    delay  (20);//Este delay é uma forma grosseira de fazer o debouncing.
570
571    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
572    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
573
574  }//Chave final deste if.
575}//Chave  final do void verificacaoDeApertoDoBotao12.
576
577//////////////////////////////////////////////////
578void  verificacaoDeApertoDoBotao13()
579{ //Chave inicial do verificacaoDeApertoDoBotao.
580  //Verifica se o pino digital do botao foi pressionado.
581  int estado_botao13  = digitalRead(pinoDoBotao13);
582  if (estado_botao13 == LOW && estado_botao13 !=  estadoDoBotao13)
583  { // Chave inicial deste if.
584    //Troca estado on/off.
585    //Atualiza estado o botão.
586    estadoDoBotao13 = estado_botao13;
587    //Uso  de um delay como forma grosseira de fazer o debouncing.
588    delay (20);
589
590    edgar.setFrequency(0, notaBotao13 * 4); //Aqui a nota do respectivo botao é  indicada.
591    edgar.trigger(0);//Aqui a nota do respectivo botao é ligada.
592    delay (duracao1);
593    edgar.setFrequency(0, notaBotao13); //Aqui a nota do  respectivo botao é indicada.
594    edgar.trigger(0);//Aqui a nota do respectivo  botao é ligada.
595    delay (duracao2);
596    edgar.setFrequency(0, notaBotao13  * 2); //Aqui a nota do respectivo botao é indicada.
597    edgar.trigger(0);//Aqui  a nota do respectivo botao é ligada.
598
599  }//Chave final deste if.
600
601  //Verifica  soltura do botão.
602  if (estado_botao13 == HIGH && estado_botao13 != estadoDoBotao13)
603  { //Chave inicial deste if.
604    estadoDoBotao13 = estado_botao13;
605    delay  (20);//Este delay é uma forma grosseira de fazer o debouncing.
606
607    edgar.setFrequency(0,  0);//Aqui é indicado para o botão não tocar nenhuma nota.
608    edgar.trigger(0);//Aqui  o comando de não tocar nenhuma nota é acionado.
609
610  }//Chave final deste if.
611}//Chave  final do void verificacaoDeApertoDoBotao13.
612