6 Player Buzzer-Game

Never have trouble again deciding who is allowed to answer a quiz question. 6 different LED's show who pressed his buzzer first.

Jan 28, 2020

•

9520 views

•

1 respects

Components and supplies

Pushbutton Switch, Momentary

USB-A to Mini-USB Cable

LED (generic)

DC Power Connector, Socket

Resistors

Arduino Nano R3

dc Cable

wooden box

Rotary potentiometer (generic)

Tools and machines

Soldering iron (generic)

Drill, Screwdriver

Solder Wire, Lead Free

Apps and platforms

Arduino IDE

Project description

Code

Code for 6 player buzzer game

c_cpp

code for EDI

1const int S1LED =  A0;
2const int S2LED =  A1;
3const int S3LED =  A2;
4const int S4LED =  A3;
5const int S5LED =  A4;
6const int S6LED =  A5;
7const  int S1TASTER = 8;
8const int S2TASTER = 11;
9const int S3TASTER = 10;
10const  int S4TASTER = 12;
11const int S5TASTER = 9;
12const int S6TASTER = 7;
13const  int Buzzer = 13;
14const int potPin = A7;
15int switchStateS1 = 0;
16int switchStateS2  = 0;
17int switchStateS3 = 0;
18int switchStateS4 = 0;
19int switchStateS5 =  0;
20int switchStateS6 = 0;
21int potVal;
22int Dauer;
23int dauerGesamt;
24#include  "pitches.h"
25void setup() {
26  /*Serial.begin(9600);*/
27  pinMode(S1LED,  OUTPUT);
28  pinMode(S2LED, OUTPUT);
29  pinMode(S3LED, OUTPUT);
30  pinMode(S4LED,  OUTPUT);
31  pinMode(S5LED, OUTPUT);
32  pinMode(S6LED, OUTPUT);
33
34  digitalWrite(S1LED,  HIGH);
35  delay(30);
36  digitalWrite(S2LED, HIGH);
37  delay(30);
38  digitalWrite(S3LED,  HIGH);
39  delay(30);
40  digitalWrite(S4LED, HIGH);
41  delay(30);
42  digitalWrite(S5LED,  HIGH);
43  delay(30);
44  digitalWrite(S6LED, HIGH);
45  delay(30);
46  digitalWrite(S1LED,  LOW);
47  delay(30);
48  digitalWrite(S2LED, LOW);
49  delay(30);
50  digitalWrite(S3LED,  LOW);
51  delay(30);
52  digitalWrite(S4LED, LOW);
53  delay(30);
54  digitalWrite(S5LED,  LOW);
55  delay(30);
56  digitalWrite(S6LED, LOW);
57  delay(30);
58  digitalWrite(S1LED,  HIGH);
59  delay(30);
60  digitalWrite(S2LED, HIGH);
61  delay(30);
62  digitalWrite(S3LED,  HIGH);
63  delay(30);
64  digitalWrite(S4LED, HIGH);
65  delay(30);
66  digitalWrite(S5LED,  HIGH);
67  delay(30);
68  digitalWrite(S6LED, HIGH);
69  delay(30);
70  digitalWrite(S1LED,  LOW);
71  delay(30);
72  digitalWrite(S2LED, LOW);
73  delay(30);
74  digitalWrite(S3LED,  LOW);
75  delay(30);
76  digitalWrite(S4LED, LOW);
77  delay(30);
78  digitalWrite(S5LED,  LOW);
79  delay(30);
80  digitalWrite(S6LED, LOW);
81  delay(30);
82  tone(Buzzer,  NOTE_F3, 200);
83  delay(200);
84  tone(Buzzer, NOTE_A3, 200);
85  delay(400);
86  tone(Buzzer, NOTE_F3, 200);
87  delay(200);
88  tone(Buzzer, NOTE_AS3, 200);
89  delay(400);
90  tone(Buzzer, NOTE_F3, 200);
91  delay(200);
92  tone(Buzzer,  NOTE_C4, 800);
93  delay(800);
94
95
96
97  noTone(Buzzer);
98}
99
100void  loop() {
101Start:
102  int dauerSchluss = 3;
103  int i = 0;
104  potVal = analogRead(potPin);
105  Dauer = map(potVal, 0, 1023, 0, 7);
106
107  switchStateS1 = digitalRead(S1TASTER);
108  switchStateS2 = digitalRead(S2TASTER);
109  switchStateS3 = digitalRead(S3TASTER);
110  switchStateS4 = digitalRead(S4TASTER);
111  switchStateS5 = digitalRead(S5TASTER);
112  switchStateS6 = digitalRead(S6TASTER);
113  /*
114    Serial.print(potVal);
115    Serial.print(" ");
116    Serial.print(Dauer);
117    Serial.print(" ");
118    Serial.print(switchStateS1);
119    Serial.print(switchStateS2);
120    Serial.print(switchStateS3);
121    Serial.print(switchStateS4);
122    Serial.print(switchStateS5);
123    Serial.print(switchStateS6);*/
124
125
126  pinMode(S1TASTER, INPUT);
127  pinMode(S2TASTER, INPUT);
128  pinMode(S3TASTER,  INPUT);
129  pinMode(S4TASTER, INPUT);
130  pinMode(S5TASTER, INPUT);
131  pinMode(S6TASTER,  INPUT);
132  if (Dauer == 1) {
133    dauerGesamt = 3;
134  }
135  else if (Dauer  == 2) {
136    dauerGesamt = 5;
137  }
138  else if (Dauer == 3) {
139    dauerGesamt  = 10;
140  }
141  else if (Dauer == 4) {
142    dauerGesamt = 20;
143  }
144  else  if (Dauer == 5) {
145    dauerGesamt = 30;
146  }
147  else if (Dauer == 6 or Dauer  == 7) {
148    dauerGesamt = 60;
149  }
150  else {
151    dauerGesamt = 3;
152  }
153  /*Serial.print(" ");
154    Serial.println(dauerGesamt);*/
155  if (Dauer  != 0) {
156    //Spieler 1
157    if (switchStateS1 == HIGH) {
158      //Ton bei  Druck
159      digitalWrite(S1LED, HIGH);
160      tone(Buzzer, NOTE_G4, 35);
161      delay(35);
162      tone(Buzzer, NOTE_G5, 35);
163      delay(35);
164      tone(Buzzer,  NOTE_G6, 35);
165      delay(35);
166      noTone(Buzzer);
167      //Warten
168      delay((dauerGesamt + 1 - dauerSchluss - 0.21) * 900);
169      digitalWrite(S1LED,  LOW);
170      //Ende
171      delay((dauerGesamt + 1 - dauerSchluss - 0.21) * 100);
172      while (i < dauerSchluss - 1) {
173        tone(Buzzer, NOTE_G4);
174        digitalWrite(S1LED,  HIGH);
175        digitalWrite(S2LED, HIGH);
176        digitalWrite(S3LED, HIGH);
177        digitalWrite(S4LED, HIGH);
178        digitalWrite(S5LED, HIGH);
179        digitalWrite(S6LED,  HIGH);
180        delay(500);
181        digitalWrite(S2LED, LOW);
182        digitalWrite(S3LED,  LOW);
183        digitalWrite(S4LED, LOW);
184        digitalWrite(S5LED, LOW);
185        digitalWrite(S6LED, LOW);
186        noTone(Buzzer);
187        delay(500);
188        i++;
189      }
190      digitalWrite(S1LED, HIGH);
191      digitalWrite(S2LED,  HIGH);
192      digitalWrite(S3LED, HIGH);
193      digitalWrite(S4LED, HIGH);
194      digitalWrite(S5LED, HIGH);
195      digitalWrite(S6LED, HIGH);
196      tone(Buzzer,  NOTE_G5);
197      delay(500);
198      digitalWrite(S1LED, LOW);
199      digitalWrite(S2LED,  LOW);
200      digitalWrite(S3LED, LOW);
201      digitalWrite(S4LED, LOW);
202      digitalWrite(S5LED, LOW);
203      digitalWrite(S6LED, LOW);
204      noTone(Buzzer);
205      digitalWrite(S1LED, HIGH);
206      delay(30);
207      digitalWrite(S2LED,  HIGH);
208      delay(30);
209      digitalWrite(S3LED, HIGH);
210      delay(30);
211      digitalWrite(S4LED, HIGH);
212      delay(30);
213      digitalWrite(S5LED,  HIGH);
214      delay(30);
215      digitalWrite(S6LED, HIGH);
216      delay(30);
217      digitalWrite(S1LED, LOW);
218      delay(30);
219      digitalWrite(S2LED,  LOW);
220      delay(30);
221      digitalWrite(S3LED, LOW);
222      delay(30);
223      digitalWrite(S4LED, LOW);
224      delay(30);
225      digitalWrite(S5LED,  LOW);
226      delay(30);
227      digitalWrite(S6LED, LOW);
228      delay(30);
229      goto Start;
230    }
231
232    //Spieler 2
233    if (switchStateS2 == HIGH)  {
234      digitalWrite(S2LED, HIGH);
235      //Ton bei Druck
236      tone(Buzzer,  NOTE_B5, 100);
237      delay(100);
238      tone(Buzzer, NOTE_E6, 700);
239      delay(700);
240      noTone(Buzzer);
241      //Warten
242      delay((dauerGesamt + 1 - dauerSchluss  - 0.8) * 900);
243      digitalWrite(S2LED, LOW);
244      //Ende
245      delay((dauerGesamt  + 1 - dauerSchluss - 0.8) * 100);
246      while (i < dauerSchluss - 1) {
247        tone(Buzzer,  NOTE_G4);
248        digitalWrite(S1LED, HIGH);
249        digitalWrite(S2LED, HIGH);
250        digitalWrite(S3LED, HIGH);
251        digitalWrite(S4LED, HIGH);
252        digitalWrite(S5LED,  HIGH);
253        digitalWrite(S6LED, HIGH);
254        delay(500);
255        digitalWrite(S1LED,  LOW);
256        digitalWrite(S3LED, LOW);
257        digitalWrite(S4LED, LOW);
258        digitalWrite(S5LED, LOW);
259        digitalWrite(S6LED, LOW);
260        noTone(Buzzer);
261        delay(500);
262        i++;
263      }
264      digitalWrite(S1LED, HIGH);
265      digitalWrite(S2LED, HIGH);
266      digitalWrite(S3LED, HIGH);
267      digitalWrite(S4LED,  HIGH);
268      digitalWrite(S5LED, HIGH);
269      digitalWrite(S6LED, HIGH);
270      tone(Buzzer, NOTE_G5);
271      delay(500);
272      digitalWrite(S1LED, LOW);
273      digitalWrite(S2LED, LOW);
274      digitalWrite(S3LED, LOW);
275      digitalWrite(S4LED,  LOW);
276      digitalWrite(S5LED, LOW);
277      digitalWrite(S6LED, LOW);
278      noTone(Buzzer);
279      digitalWrite(S2LED, HIGH);
280      delay(30);
281      digitalWrite(S3LED, HIGH);
282      delay(30);
283      digitalWrite(S4LED,  HIGH);
284      delay(30);
285      digitalWrite(S5LED, HIGH);
286      delay(30);
287      digitalWrite(S6LED, HIGH);
288      delay(30);
289      digitalWrite(S1LED,  HIGH);
290      delay(30);
291      digitalWrite(S2LED, LOW);
292      delay(30);
293      digitalWrite(S3LED, LOW);
294      delay(30);
295      digitalWrite(S4LED,  LOW);
296      delay(30);
297      digitalWrite(S5LED, LOW);
298      delay(30);
299      digitalWrite(S6LED, LOW);
300      delay(30);
301      digitalWrite(S1LED,  LOW);
302      goto Start;
303    }
304
305
306    //Spieler 3
307    if (switchStateS3  == HIGH) {
308      digitalWrite(S3LED, HIGH);
309      for (int hz = 2000; hz >  440; hz--) {
310        tone(Buzzer, hz, 50);
311        delay(0.5);
312      }
313
314      //Warten
315      delay((dauerGesamt + 1 - dauerSchluss - 0.4) * 900);
316      digitalWrite(S3LED, LOW);
317      //Ende
318      delay((dauerGesamt + 1  - dauerSchluss - 0.4) * 100);
319      while (i < dauerSchluss - 1) {
320        tone(Buzzer,  NOTE_G4);
321        digitalWrite(S1LED, HIGH);
322        digitalWrite(S2LED, HIGH);
323        digitalWrite(S3LED, HIGH);
324        digitalWrite(S4LED, HIGH);
325        digitalWrite(S5LED,  HIGH);
326        digitalWrite(S6LED, HIGH);
327        delay(500);
328        digitalWrite(S1LED,  LOW);
329        digitalWrite(S2LED, LOW);
330        digitalWrite(S4LED, LOW);
331        digitalWrite(S5LED, LOW);
332        digitalWrite(S6LED, LOW);
333        noTone(Buzzer);
334        delay(500);
335        i++;
336      }
337      digitalWrite(S1LED, HIGH);
338      digitalWrite(S2LED, HIGH);
339      digitalWrite(S3LED, HIGH);
340      digitalWrite(S4LED,  HIGH);
341      digitalWrite(S5LED, HIGH);
342      digitalWrite(S6LED, HIGH);
343      tone(Buzzer, NOTE_G5);
344      delay(500);
345      digitalWrite(S1LED, LOW);
346      digitalWrite(S2LED, LOW);
347      digitalWrite(S3LED, LOW);
348      digitalWrite(S4LED,  LOW);
349      digitalWrite(S5LED, LOW);
350      digitalWrite(S6LED, LOW);
351      noTone(Buzzer);
352      digitalWrite(S3LED, HIGH);
353      delay(30);
354      digitalWrite(S4LED, HIGH);
355      delay(30);
356      digitalWrite(S5LED,  HIGH);
357      delay(30);
358      digitalWrite(S6LED, HIGH);
359      delay(30);
360      digitalWrite(S1LED, HIGH);
361      delay(30);
362      digitalWrite(S2LED,  HIGH);
363      delay(30);
364      digitalWrite(S3LED, LOW);
365      delay(30);
366      digitalWrite(S4LED, LOW);
367      delay(30);
368      digitalWrite(S5LED,  LOW);
369      delay(30);
370      digitalWrite(S6LED, LOW);
371      delay(30);
372      digitalWrite(S1LED, LOW);
373      delay(30);
374      digitalWrite(S2LED,  LOW);
375      goto Start;
376    }
377
378
379    //Spieler 4
380    if (switchStateS4  == HIGH) {
381      digitalWrite(S4LED, HIGH);
382      tone(Buzzer, NOTE_C7, 115);
383      delay(125);
384      tone(Buzzer, NOTE_C7, 240);
385      delay(250);
386      tone(Buzzer, NOTE_C7, 240);
387      delay(250);
388      tone(Buzzer, NOTE_GS6,  115);
389      delay(125);
390      tone(Buzzer, NOTE_C7, 240);
391      delay(250);
392      tone(Buzzer, NOTE_DS7, 115);
393      delay(125);
394      //Warten
395      delay((dauerGesamt  + 1 - dauerSchluss - 1.0) * 900);
396      digitalWrite(S4LED, LOW);
397      //Ende
398      delay((dauerGesamt + 1 - dauerSchluss - 1.0) * 100);
399      while (i < dauerSchluss  - 1) {
400        tone(Buzzer, NOTE_G4);
401        digitalWrite(S1LED, HIGH);
402        digitalWrite(S2LED, HIGH);
403        digitalWrite(S3LED, HIGH);
404        digitalWrite(S4LED,  HIGH);
405        digitalWrite(S5LED, HIGH);
406        digitalWrite(S6LED, HIGH);
407        delay(500);
408        digitalWrite(S1LED, LOW);
409        digitalWrite(S2LED,  LOW);
410        digitalWrite(S3LED, LOW);
411        digitalWrite(S5LED, LOW);
412        digitalWrite(S6LED, LOW);
413        noTone(Buzzer);
414        delay(500);
415        i++;
416      }
417      digitalWrite(S1LED, HIGH);
418      digitalWrite(S2LED,  HIGH);
419      digitalWrite(S3LED, HIGH);
420      digitalWrite(S4LED, HIGH);
421      digitalWrite(S5LED, HIGH);
422      digitalWrite(S6LED, HIGH);
423      tone(Buzzer,  NOTE_G5);
424      delay(500);
425      digitalWrite(S1LED, LOW);
426      digitalWrite(S2LED,  LOW);
427      digitalWrite(S3LED, LOW);
428      digitalWrite(S4LED, LOW);
429      digitalWrite(S5LED, LOW);
430      digitalWrite(S6LED, LOW);
431      noTone(Buzzer);
432      digitalWrite(S4LED, HIGH);
433      delay(30);
434      digitalWrite(S5LED,  HIGH);
435      delay(30);
436      digitalWrite(S6LED, HIGH);
437      delay(30);
438      digitalWrite(S1LED, HIGH);
439      delay(30);
440      digitalWrite(S2LED,  HIGH);
441      delay(30);
442      digitalWrite(S3LED, HIGH);
443      delay(30);
444      digitalWrite(S4LED, LOW);
445      delay(30);
446      digitalWrite(S5LED,  LOW);
447      delay(30);
448      digitalWrite(S6LED, LOW);
449      delay(30);
450      digitalWrite(S1LED, LOW);
451      delay(30);
452      digitalWrite(S2LED,  LOW);
453      delay(30);
454      digitalWrite(S3LED, LOW);
455      goto Start;
456    }
457
458
459
460    //Spieler 5
461    if (switchStateS5 == HIGH) {
462      digitalWrite(S5LED,  HIGH);
463      tone(Buzzer, NOTE_E6, 125);
464      delay(125);
465      tone(Buzzer,  NOTE_G6, 125);
466      delay(125);
467      tone(Buzzer, NOTE_E7, 125);
468      delay(125);
469      tone(Buzzer, NOTE_C7, 125);
470      delay(125);
471      tone(Buzzer, NOTE_D7,  125);
472      delay(125);
473      tone(Buzzer, NOTE_G7, 125);
474      delay(125);
475      noTone(Buzzer);
476
477      //Warten
478      delay((dauerGesamt + 1 - dauerSchluss  - 0.85) * 900);
479      digitalWrite(S5LED, LOW);
480      //Ende
481      delay((dauerGesamt  + 1 - dauerSchluss - 0.85) * 100);
482      while (i < dauerSchluss - 1) {
483        tone(Buzzer,  NOTE_G4);
484        digitalWrite(S1LED, HIGH);
485        digitalWrite(S2LED, HIGH);
486        digitalWrite(S3LED, HIGH);
487        digitalWrite(S4LED, HIGH);
488        digitalWrite(S5LED,  HIGH);
489        digitalWrite(S6LED, HIGH);
490        delay(500);
491        digitalWrite(S5LED,  LOW);
492        digitalWrite(S1LED, LOW);
493        digitalWrite(S2LED, LOW);
494        digitalWrite(S3LED, LOW);
495        digitalWrite(S4LED, LOW);
496        digitalWrite(S6LED,  LOW);
497        noTone(Buzzer);
498        delay(500);
499        i++;
500      }
501
502      digitalWrite(S1LED, HIGH);
503      digitalWrite(S2LED, HIGH);
504      digitalWrite(S3LED,  HIGH);
505      digitalWrite(S4LED, HIGH);
506      digitalWrite(S5LED, HIGH);
507      digitalWrite(S6LED, HIGH);
508      tone(Buzzer, NOTE_G5);
509      delay(500);
510      digitalWrite(S1LED, LOW);
511      digitalWrite(S2LED, LOW);
512      digitalWrite(S3LED,  LOW);
513      digitalWrite(S4LED, LOW);
514      digitalWrite(S5LED, LOW);
515      digitalWrite(S6LED, LOW);
516      noTone(Buzzer);
517      digitalWrite(S5LED,  HIGH);
518      delay(30);
519      digitalWrite(S6LED, HIGH);
520      delay(30);
521      digitalWrite(S1LED, HIGH);
522      delay(30);
523      digitalWrite(S2LED,  HIGH);
524      delay(30);
525      digitalWrite(S3LED, HIGH);
526      delay(30);
527      digitalWrite(S4LED, HIGH);
528      delay(30);
529      digitalWrite(S5LED,  LOW);
530      delay(30);
531      digitalWrite(S6LED, LOW);
532      delay(30);
533      digitalWrite(S1LED, LOW);
534      delay(30);
535      digitalWrite(S2LED,  LOW);
536      delay(30);
537      digitalWrite(S3LED, LOW);
538      delay(30);
539      digitalWrite(S4LED, LOW);
540      goto Start;
541    }
542
543
544
545    //Spieler  6
546    if (switchStateS6 == HIGH) {
547      digitalWrite(S6LED, HIGH);
548      for  (int hz = 440; hz < 1000; hz++) {
549        tone(Buzzer, hz, 50);
550        delay(0.75);
551      }
552
553      //Warten
554      delay((dauerGesamt + 1 - dauerSchluss) *  900);
555      digitalWrite(S6LED, LOW);
556      //Ende
557      delay((dauerGesamt  + 1 - dauerSchluss) * 100);
558      while (i < dauerSchluss - 1) {
559        tone(Buzzer,  NOTE_G4);
560        digitalWrite(S1LED, HIGH);
561        digitalWrite(S2LED, HIGH);
562        digitalWrite(S3LED, HIGH);
563        digitalWrite(S4LED, HIGH);
564        digitalWrite(S5LED,  HIGH);
565        digitalWrite(S6LED, HIGH);
566        delay(500);
567        digitalWrite(S1LED,  LOW);
568        digitalWrite(S2LED, LOW);
569        digitalWrite(S3LED, LOW);
570        digitalWrite(S4LED, LOW);
571        digitalWrite(S5LED, LOW);
572        noTone(Buzzer);
573        delay(500);
574        i++;
575      }
576      digitalWrite(S1LED, HIGH);
577      digitalWrite(S2LED, HIGH);
578      digitalWrite(S3LED, HIGH);
579      digitalWrite(S4LED,  HIGH);
580      digitalWrite(S5LED, HIGH);
581      digitalWrite(S6LED, HIGH);
582      tone(Buzzer, NOTE_G5);
583      delay(500);
584      digitalWrite(S1LED, LOW);
585      digitalWrite(S2LED, LOW);
586      digitalWrite(S3LED, LOW);
587      digitalWrite(S4LED,  LOW);
588      digitalWrite(S5LED, LOW);
589      digitalWrite(S6LED, LOW);
590      noTone(Buzzer);
591      digitalWrite(S6LED, HIGH);
592      delay(30);
593      digitalWrite(S1LED, HIGH);
594      delay(30);
595      digitalWrite(S2LED,  HIGH);
596      delay(30);
597      digitalWrite(S3LED, HIGH);
598      delay(30);
599      digitalWrite(S4LED, HIGH);
600      delay(30);
601      digitalWrite(S5LED,  HIGH);
602      delay(30);
603      digitalWrite(S6LED, LOW);
604      delay(30);
605      digitalWrite(S1LED, LOW);
606      delay(30);
607      digitalWrite(S2LED,  LOW);
608      delay(30);
609      digitalWrite(S3LED, LOW);
610      delay(30);
611      digitalWrite(S4LED, LOW);
612      delay(30);
613      digitalWrite(S5LED,  LOW);
614      delay(30);
615      goto Start;
616    }
617  }
618
619  else if  (potVal < 145) {
620    //Spieler 1
621    if (switchStateS1 == HIGH) {
622      //Ton  bei Druck
623      digitalWrite(S1LED, HIGH);
624      tone(Buzzer, NOTE_G4, 35);
625      delay(35);
626      tone(Buzzer, NOTE_G5, 35);
627      delay(35);
628      tone(Buzzer,  NOTE_G6, 35);
629      delay(35);
630      noTone(Buzzer);
631      delay(dauerGesamt  * 1000);
632      digitalWrite(S1LED, LOW);
633    }
634  }
635
636  //Spieler 2
637  if (switchStateS2 == HIGH) {
638    digitalWrite(S2LED, HIGH);
639    //Ton bei  Druck
640    tone(Buzzer, NOTE_B5, 100);
641    delay(100);
642    tone(Buzzer,  NOTE_E6, 700);
643    delay(700);
644    noTone(Buzzer);
645    delay(dauerGesamt  * 1000);
646    digitalWrite(S2LED, LOW);
647  }
648
649
650  //Spieler 3
651  if  (switchStateS3 == HIGH) {
652    digitalWrite(S3LED, HIGH);
653    for (int hz =  2000; hz > 440; hz--) {
654      tone(Buzzer, hz, 50);
655      delay(0.5);
656    }
657    delay(dauerGesamt * 1000);
658    digitalWrite(S3LED, LOW);
659  }
660
661
662  //Spieler 4
663  if (switchStateS4 == HIGH) {
664    digitalWrite(S4LED, HIGH);
665    tone(Buzzer, NOTE_C7, 115);
666    delay(125);
667    tone(Buzzer, NOTE_C7,  240);
668    delay(250);
669    tone(Buzzer, NOTE_C7, 240);
670    delay(250);
671    tone(Buzzer, NOTE_GS6, 115);
672    delay(125);
673    tone(Buzzer, NOTE_C7,  240);
674    delay(250);
675    tone(Buzzer, NOTE_DS7, 115);
676    delay(125);
677    noTone(Buzzer);
678    delay(dauerGesamt * 1000);
679    digitalWrite(S4LED,  LOW);
680
681  }
682
683
684
685  //Spieler 5
686  if (switchStateS5 == HIGH) {
687    digitalWrite(S5LED, HIGH);
688    tone(Buzzer, NOTE_E6, 125);
689    delay(125);
690    tone(Buzzer, NOTE_G6, 125);
691    delay(125);
692    tone(Buzzer, NOTE_E7,  125);
693    delay(125);
694    tone(Buzzer, NOTE_C7, 125);
695    delay(125);
696    tone(Buzzer, NOTE_D7, 125);
697    delay(125);
698    tone(Buzzer, NOTE_G7,  125);
699    delay(125);
700    noTone(Buzzer);
701    delay(dauerGesamt * 1000);
702    digitalWrite(S5LED, LOW);
703  }
704
705
706
707  //Spieler 6
708  if (switchStateS6  == HIGH) {
709    digitalWrite(S6LED, HIGH);
710    for (int hz = 440; hz < 1000;  hz++) {
711      tone(Buzzer, hz, 50);
712      delay(0.75);
713    }
714    delay(dauerGesamt  * 1000);
715    digitalWrite(S6LED, LOW);
716  }
717
718
719
720}
721

const int S1LED =  A0;
const int S2LED =  A1;
const int S3LED =  A2;
const int S4LED =  A3;
const int S5LED =  A4;
const int S6LED =  A5;
const  int S1TASTER = 8;
const int S2TASTER = 11;
const int S3TASTER = 10;
const  int S4TASTER = 12;
const int S5TASTER = 9;
const int S6TASTER = 7;
const  int Buzzer = 13;
const int potPin = A7;
int switchStateS1 = 0;
int switchStateS2  = 0;
int switchStateS3 = 0;
int switchStateS4 = 0;
int switchStateS5 =  0;
int switchStateS6 = 0;
int potVal;
int Dauer;
int dauerGesamt;
#include  "pitches.h"
void setup() {
  /*Serial.begin(9600);*/
  pinMode(S1LED,  OUTPUT);
  pinMode(S2LED, OUTPUT);
  pinMode(S3LED, OUTPUT);
  pinMode(S4LED,  OUTPUT);
  pinMode(S5LED, OUTPUT);
  pinMode(S6LED, OUTPUT);

  digitalWrite(S1LED,  HIGH);
  delay(30);
  digitalWrite(S2LED, HIGH);
  delay(30);
  digitalWrite(S3LED,  HIGH);
  delay(30);
  digitalWrite(S4LED, HIGH);
  delay(30);
  digitalWrite(S5LED,  HIGH);
  delay(30);
  digitalWrite(S6LED, HIGH);
  delay(30);
  digitalWrite(S1LED,  LOW);
  delay(30);
  digitalWrite(S2LED, LOW);
  delay(30);
  digitalWrite(S3LED,  LOW);
  delay(30);
  digitalWrite(S4LED, LOW);
  delay(30);
  digitalWrite(S5LED,  LOW);
  delay(30);
  digitalWrite(S6LED, LOW);
  delay(30);
  digitalWrite(S1LED,  HIGH);
  delay(30);
  digitalWrite(S2LED, HIGH);
  delay(30);
  digitalWrite(S3LED,  HIGH);
  delay(30);
  digitalWrite(S4LED, HIGH);
  delay(30);
  digitalWrite(S5LED,  HIGH);
  delay(30);
  digitalWrite(S6LED, HIGH);
  delay(30);
  digitalWrite(S1LED,  LOW);
  delay(30);
  digitalWrite(S2LED, LOW);
  delay(30);
  digitalWrite(S3LED,  LOW);
  delay(30);
  digitalWrite(S4LED, LOW);
  delay(30);
  digitalWrite(S5LED,  LOW);
  delay(30);
  digitalWrite(S6LED, LOW);
  delay(30);
  tone(Buzzer,  NOTE_F3, 200);
  delay(200);
  tone(Buzzer, NOTE_A3, 200);
  delay(400);
  tone(Buzzer, NOTE_F3, 200);
  delay(200);
  tone(Buzzer, NOTE_AS3, 200);
  delay(400);
  tone(Buzzer, NOTE_F3, 200);
  delay(200);
  tone(Buzzer,  NOTE_C4, 800);
  delay(800);



  noTone(Buzzer);
}

void  loop() {
Start:
  int dauerSchluss = 3;
  int i = 0;
  potVal = analogRead(potPin);
  Dauer = map(potVal, 0, 1023, 0, 7);

  switchStateS1 = digitalRead(S1TASTER);
  switchStateS2 = digitalRead(S2TASTER);
  switchStateS3 = digitalRead(S3TASTER);
  switchStateS4 = digitalRead(S4TASTER);
  switchStateS5 = digitalRead(S5TASTER);
  switchStateS6 = digitalRead(S6TASTER);
  /*
    Serial.print(potVal);
    Serial.print(" ");
    Serial.print(Dauer);
    Serial.print(" ");
    Serial.print(switchStateS1);
    Serial.print(switchStateS2);
    Serial.print(switchStateS3);
    Serial.print(switchStateS4);
    Serial.print(switchStateS5);
    Serial.print(switchStateS6);*/


  pinMode(S1TASTER, INPUT);
  pinMode(S2TASTER, INPUT);
  pinMode(S3TASTER,  INPUT);
  pinMode(S4TASTER, INPUT);
  pinMode(S5TASTER, INPUT);
  pinMode(S6TASTER,  INPUT);
  if (Dauer == 1) {
    dauerGesamt = 3;
  }
  else if (Dauer  == 2) {
    dauerGesamt = 5;
  }
  else if (Dauer == 3) {
    dauerGesamt  = 10;
  }
  else if (Dauer == 4) {
    dauerGesamt = 20;
  }
  else  if (Dauer == 5) {
    dauerGesamt = 30;
  }
  else if (Dauer == 6 or Dauer  == 7) {
    dauerGesamt = 60;
  }
  else {
    dauerGesamt = 3;
  }
  /*Serial.print(" ");
    Serial.println(dauerGesamt);*/
  if (Dauer  != 0) {
    //Spieler 1
    if (switchStateS1 == HIGH) {
      //Ton bei  Druck
      digitalWrite(S1LED, HIGH);
      tone(Buzzer, NOTE_G4, 35);
      delay(35);
      tone(Buzzer, NOTE_G5, 35);
      delay(35);
      tone(Buzzer,  NOTE_G6, 35);
      delay(35);
      noTone(Buzzer);
      //Warten
      delay((dauerGesamt + 1 - dauerSchluss - 0.21) * 900);
      digitalWrite(S1LED,  LOW);
      //Ende
      delay((dauerGesamt + 1 - dauerSchluss - 0.21) * 100);
      while (i < dauerSchluss - 1) {
        tone(Buzzer, NOTE_G4);
        digitalWrite(S1LED,  HIGH);
        digitalWrite(S2LED, HIGH);
        digitalWrite(S3LED, HIGH);
        digitalWrite(S4LED, HIGH);
        digitalWrite(S5LED, HIGH);
        digitalWrite(S6LED,  HIGH);
        delay(500);
        digitalWrite(S2LED, LOW);
        digitalWrite(S3LED,  LOW);
        digitalWrite(S4LED, LOW);
        digitalWrite(S5LED, LOW);
        digitalWrite(S6LED, LOW);
        noTone(Buzzer);
        delay(500);
        i++;
      }
      digitalWrite(S1LED, HIGH);
      digitalWrite(S2LED,  HIGH);
      digitalWrite(S3LED, HIGH);
      digitalWrite(S4LED, HIGH);
      digitalWrite(S5LED, HIGH);
      digitalWrite(S6LED, HIGH);
      tone(Buzzer,  NOTE_G5);
      delay(500);
      digitalWrite(S1LED, LOW);
      digitalWrite(S2LED,  LOW);
      digitalWrite(S3LED, LOW);
      digitalWrite(S4LED, LOW);
      digitalWrite(S5LED, LOW);
      digitalWrite(S6LED, LOW);
      noTone(Buzzer);
      digitalWrite(S1LED, HIGH);
      delay(30);
      digitalWrite(S2LED,  HIGH);
      delay(30);
      digitalWrite(S3LED, HIGH);
      delay(30);
      digitalWrite(S4LED, HIGH);
      delay(30);
      digitalWrite(S5LED,  HIGH);
      delay(30);
      digitalWrite(S6LED, HIGH);
      delay(30);
      digitalWrite(S1LED, LOW);
      delay(30);
      digitalWrite(S2LED,  LOW);
      delay(30);
      digitalWrite(S3LED, LOW);
      delay(30);
      digitalWrite(S4LED, LOW);
      delay(30);
      digitalWrite(S5LED,  LOW);
      delay(30);
      digitalWrite(S6LED, LOW);
      delay(30);
      goto Start;
    }

    //Spieler 2
    if (switchStateS2 == HIGH)  {
      digitalWrite(S2LED, HIGH);
      //Ton bei Druck
      tone(Buzzer,  NOTE_B5, 100);
      delay(100);
      tone(Buzzer, NOTE_E6, 700);
      delay(700);
      noTone(Buzzer);
      //Warten
      delay((dauerGesamt + 1 - dauerSchluss  - 0.8) * 900);
      digitalWrite(S2LED, LOW);
      //Ende
      delay((dauerGesamt  + 1 - dauerSchluss - 0.8) * 100);
      while (i < dauerSchluss - 1) {
        tone(Buzzer,  NOTE_G4);
        digitalWrite(S1LED, HIGH);
        digitalWrite(S2LED, HIGH);
        digitalWrite(S3LED, HIGH);
        digitalWrite(S4LED, HIGH);
        digitalWrite(S5LED,  HIGH);
        digitalWrite(S6LED, HIGH);
        delay(500);
        digitalWrite(S1LED,  LOW);
        digitalWrite(S3LED, LOW);
        digitalWrite(S4LED, LOW);
        digitalWrite(S5LED, LOW);
        digitalWrite(S6LED, LOW);
        noTone(Buzzer);
        delay(500);
        i++;
      }
      digitalWrite(S1LED, HIGH);
      digitalWrite(S2LED, HIGH);
      digitalWrite(S3LED, HIGH);
      digitalWrite(S4LED,  HIGH);
      digitalWrite(S5LED, HIGH);
      digitalWrite(S6LED, HIGH);
      tone(Buzzer, NOTE_G5);
      delay(500);
      digitalWrite(S1LED, LOW);
      digitalWrite(S2LED, LOW);
      digitalWrite(S3LED, LOW);
      digitalWrite(S4LED,  LOW);
      digitalWrite(S5LED, LOW);
      digitalWrite(S6LED, LOW);
      noTone(Buzzer);
      digitalWrite(S2LED, HIGH);
      delay(30);
      digitalWrite(S3LED, HIGH);
      delay(30);
      digitalWrite(S4LED,  HIGH);
      delay(30);
      digitalWrite(S5LED, HIGH);
      delay(30);
      digitalWrite(S6LED, HIGH);
      delay(30);
      digitalWrite(S1LED,  HIGH);
      delay(30);
      digitalWrite(S2LED, LOW);
      delay(30);
      digitalWrite(S3LED, LOW);
      delay(30);
      digitalWrite(S4LED,  LOW);
      delay(30);
      digitalWrite(S5LED, LOW);
      delay(30);
      digitalWrite(S6LED, LOW);
      delay(30);
      digitalWrite(S1LED,  LOW);
      goto Start;
    }


    //Spieler 3
    if (switchStateS3  == HIGH) {
      digitalWrite(S3LED, HIGH);
      for (int hz = 2000; hz >  440; hz--) {
        tone(Buzzer, hz, 50);
        delay(0.5);
      }

      //Warten
      delay((dauerGesamt + 1 - dauerSchluss - 0.4) * 900);
      digitalWrite(S3LED, LOW);
      //Ende
      delay((dauerGesamt + 1  - dauerSchluss - 0.4) * 100);
      while (i < dauerSchluss - 1) {
        tone(Buzzer,  NOTE_G4);
        digitalWrite(S1LED, HIGH);
        digitalWrite(S2LED, HIGH);
        digitalWrite(S3LED, HIGH);
        digitalWrite(S4LED, HIGH);
        digitalWrite(S5LED,  HIGH);
        digitalWrite(S6LED, HIGH);
        delay(500);
        digitalWrite(S1LED,  LOW);
        digitalWrite(S2LED, LOW);
        digitalWrite(S4LED, LOW);
        digitalWrite(S5LED, LOW);
        digitalWrite(S6LED, LOW);
        noTone(Buzzer);
        delay(500);
        i++;
      }
      digitalWrite(S1LED, HIGH);
      digitalWrite(S2LED, HIGH);
      digitalWrite(S3LED, HIGH);
      digitalWrite(S4LED,  HIGH);
      digitalWrite(S5LED, HIGH);
      digitalWrite(S6LED, HIGH);
      tone(Buzzer, NOTE_G5);
      delay(500);
      digitalWrite(S1LED, LOW);
      digitalWrite(S2LED, LOW);
      digitalWrite(S3LED, LOW);
      digitalWrite(S4LED,  LOW);
      digitalWrite(S5LED, LOW);
      digitalWrite(S6LED, LOW);
      noTone(Buzzer);
      digitalWrite(S3LED, HIGH);
      delay(30);
      digitalWrite(S4LED, HIGH);
      delay(30);
      digitalWrite(S5LED,  HIGH);
      delay(30);
      digitalWrite(S6LED, HIGH);
      delay(30);
      digitalWrite(S1LED, HIGH);
      delay(30);
      digitalWrite(S2LED,  HIGH);
      delay(30);
      digitalWrite(S3LED, LOW);
      delay(30);
      digitalWrite(S4LED, LOW);
      delay(30);
      digitalWrite(S5LED,  LOW);
      delay(30);
      digitalWrite(S6LED, LOW);
      delay(30);
      digitalWrite(S1LED, LOW);
      delay(30);
      digitalWrite(S2LED,  LOW);
      goto Start;
    }


    //Spieler 4
    if (switchStateS4  == HIGH) {
      digitalWrite(S4LED, HIGH);
      tone(Buzzer, NOTE_C7, 115);
      delay(125);
      tone(Buzzer, NOTE_C7, 240);
      delay(250);
      tone(Buzzer, NOTE_C7, 240);
      delay(250);
      tone(Buzzer, NOTE_GS6,  115);
      delay(125);
      tone(Buzzer, NOTE_C7, 240);
      delay(250);
      tone(Buzzer, NOTE_DS7, 115);
      delay(125);
      //Warten
      delay((dauerGesamt  + 1 - dauerSchluss - 1.0) * 900);
      digitalWrite(S4LED, LOW);
      //Ende
      delay((dauerGesamt + 1 - dauerSchluss - 1.0) * 100);
      while (i < dauerSchluss  - 1) {
        tone(Buzzer, NOTE_G4);
        digitalWrite(S1LED, HIGH);
        digitalWrite(S2LED, HIGH);
        digitalWrite(S3LED, HIGH);
        digitalWrite(S4LED,  HIGH);
        digitalWrite(S5LED, HIGH);
        digitalWrite(S6LED, HIGH);
        delay(500);
        digitalWrite(S1LED, LOW);
        digitalWrite(S2LED,  LOW);
        digitalWrite(S3LED, LOW);
        digitalWrite(S5LED, LOW);
        digitalWrite(S6LED, LOW);
        noTone(Buzzer);
        delay(500);
        i++;
      }
      digitalWrite(S1LED, HIGH);
      digitalWrite(S2LED,  HIGH);
      digitalWrite(S3LED, HIGH);
      digitalWrite(S4LED, HIGH);
      digitalWrite(S5LED, HIGH);
      digitalWrite(S6LED, HIGH);
      tone(Buzzer,  NOTE_G5);
      delay(500);
      digitalWrite(S1LED, LOW);
      digitalWrite(S2LED,  LOW);
      digitalWrite(S3LED, LOW);
      digitalWrite(S4LED, LOW);
      digitalWrite(S5LED, LOW);
      digitalWrite(S6LED, LOW);
      noTone(Buzzer);
      digitalWrite(S4LED, HIGH);
      delay(30);
      digitalWrite(S5LED,  HIGH);
      delay(30);
      digitalWrite(S6LED, HIGH);
      delay(30);
      digitalWrite(S1LED, HIGH);
      delay(30);
      digitalWrite(S2LED,  HIGH);
      delay(30);
      digitalWrite(S3LED, HIGH);
      delay(30);
      digitalWrite(S4LED, LOW);
      delay(30);
      digitalWrite(S5LED,  LOW);
      delay(30);
      digitalWrite(S6LED, LOW);
      delay(30);
      digitalWrite(S1LED, LOW);
      delay(30);
      digitalWrite(S2LED,  LOW);
      delay(30);
      digitalWrite(S3LED, LOW);
      goto Start;
    }



    //Spieler 5
    if (switchStateS5 == HIGH) {
      digitalWrite(S5LED,  HIGH);
      tone(Buzzer, NOTE_E6, 125);
      delay(125);
      tone(Buzzer,  NOTE_G6, 125);
      delay(125);
      tone(Buzzer, NOTE_E7, 125);
      delay(125);
      tone(Buzzer, NOTE_C7, 125);
      delay(125);
      tone(Buzzer, NOTE_D7,  125);
      delay(125);
      tone(Buzzer, NOTE_G7, 125);
      delay(125);
      noTone(Buzzer);

      //Warten
      delay((dauerGesamt + 1 - dauerSchluss  - 0.85) * 900);
      digitalWrite(S5LED, LOW);
      //Ende
      delay((dauerGesamt  + 1 - dauerSchluss - 0.85) * 100);
      while (i < dauerSchluss - 1) {
        tone(Buzzer,  NOTE_G4);
        digitalWrite(S1LED, HIGH);
        digitalWrite(S2LED, HIGH);
        digitalWrite(S3LED, HIGH);
        digitalWrite(S4LED, HIGH);
        digitalWrite(S5LED,  HIGH);
        digitalWrite(S6LED, HIGH);
        delay(500);
        digitalWrite(S5LED,  LOW);
        digitalWrite(S1LED, LOW);
        digitalWrite(S2LED, LOW);
        digitalWrite(S3LED, LOW);
        digitalWrite(S4LED, LOW);
        digitalWrite(S6LED,  LOW);
        noTone(Buzzer);
        delay(500);
        i++;
      }

      digitalWrite(S1LED, HIGH);
      digitalWrite(S2LED, HIGH);
      digitalWrite(S3LED,  HIGH);
      digitalWrite(S4LED, HIGH);
      digitalWrite(S5LED, HIGH);
      digitalWrite(S6LED, HIGH);
      tone(Buzzer, NOTE_G5);
      delay(500);
      digitalWrite(S1LED, LOW);
      digitalWrite(S2LED, LOW);
      digitalWrite(S3LED,  LOW);
      digitalWrite(S4LED, LOW);
      digitalWrite(S5LED, LOW);
      digitalWrite(S6LED, LOW);
      noTone(Buzzer);
      digitalWrite(S5LED,  HIGH);
      delay(30);
      digitalWrite(S6LED, HIGH);
      delay(30);
      digitalWrite(S1LED, HIGH);
      delay(30);
      digitalWrite(S2LED,  HIGH);
      delay(30);
      digitalWrite(S3LED, HIGH);
      delay(30);
      digitalWrite(S4LED, HIGH);
      delay(30);
      digitalWrite(S5LED,  LOW);
      delay(30);
      digitalWrite(S6LED, LOW);
      delay(30);
      digitalWrite(S1LED, LOW);
      delay(30);
      digitalWrite(S2LED,  LOW);
      delay(30);
      digitalWrite(S3LED, LOW);
      delay(30);
      digitalWrite(S4LED, LOW);
      goto Start;
    }



    //Spieler  6
    if (switchStateS6 == HIGH) {
      digitalWrite(S6LED, HIGH);
      for  (int hz = 440; hz < 1000; hz++) {
        tone(Buzzer, hz, 50);
        delay(0.75);
      }

      //Warten
      delay((dauerGesamt + 1 - dauerSchluss) *  900);
      digitalWrite(S6LED, LOW);
      //Ende
      delay((dauerGesamt  + 1 - dauerSchluss) * 100);
      while (i < dauerSchluss - 1) {
        tone(Buzzer,  NOTE_G4);
        digitalWrite(S1LED, HIGH);
        digitalWrite(S2LED, HIGH);
        digitalWrite(S3LED, HIGH);
        digitalWrite(S4LED, HIGH);
        digitalWrite(S5LED,  HIGH);
        digitalWrite(S6LED, HIGH);
        delay(500);
        digitalWrite(S1LED,  LOW);
        digitalWrite(S2LED, LOW);
        digitalWrite(S3LED, LOW);
        digitalWrite(S4LED, LOW);
        digitalWrite(S5LED, LOW);
        noTone(Buzzer);
        delay(500);
        i++;
      }
      digitalWrite(S1LED, HIGH);
      digitalWrite(S2LED, HIGH);
      digitalWrite(S3LED, HIGH);
      digitalWrite(S4LED,  HIGH);
      digitalWrite(S5LED, HIGH);
      digitalWrite(S6LED, HIGH);
      tone(Buzzer, NOTE_G5);
      delay(500);
      digitalWrite(S1LED, LOW);
      digitalWrite(S2LED, LOW);
      digitalWrite(S3LED, LOW);
      digitalWrite(S4LED,  LOW);
      digitalWrite(S5LED, LOW);
      digitalWrite(S6LED, LOW);
      noTone(Buzzer);
      digitalWrite(S6LED, HIGH);
      delay(30);
      digitalWrite(S1LED, HIGH);
      delay(30);
      digitalWrite(S2LED,  HIGH);
      delay(30);
      digitalWrite(S3LED, HIGH);
      delay(30);
      digitalWrite(S4LED, HIGH);
      delay(30);
      digitalWrite(S5LED,  HIGH);
      delay(30);
      digitalWrite(S6LED, LOW);
      delay(30);
      digitalWrite(S1LED, LOW);
      delay(30);
      digitalWrite(S2LED,  LOW);
      delay(30);
      digitalWrite(S3LED, LOW);
      delay(30);
      digitalWrite(S4LED, LOW);
      delay(30);
      digitalWrite(S5LED,  LOW);
      delay(30);
      goto Start;
    }
  }

  else if  (potVal < 145) {
    //Spieler 1
    if (switchStateS1 == HIGH) {
      //Ton  bei Druck
      digitalWrite(S1LED, HIGH);
      tone(Buzzer, NOTE_G4, 35);
      delay(35);
      tone(Buzzer, NOTE_G5, 35);
      delay(35);
      tone(Buzzer,  NOTE_G6, 35);
      delay(35);
      noTone(Buzzer);
      delay(dauerGesamt  * 1000);
      digitalWrite(S1LED, LOW);
    }
  }

  //Spieler 2
  if (switchStateS2 == HIGH) {
    digitalWrite(S2LED, HIGH);
    //Ton bei  Druck
    tone(Buzzer, NOTE_B5, 100);
    delay(100);
    tone(Buzzer,  NOTE_E6, 700);
    delay(700);
    noTone(Buzzer);
    delay(dauerGesamt  * 1000);
    digitalWrite(S2LED, LOW);
  }


  //Spieler 3
  if  (switchStateS3 == HIGH) {
    digitalWrite(S3LED, HIGH);
    for (int hz =  2000; hz > 440; hz--) {
      tone(Buzzer, hz, 50);
      delay(0.5);
    }
    delay(dauerGesamt * 1000);
    digitalWrite(S3LED, LOW);
  }


  //Spieler 4
  if (switchStateS4 == HIGH) {
    digitalWrite(S4LED, HIGH);
    tone(Buzzer, NOTE_C7, 115);
    delay(125);
    tone(Buzzer, NOTE_C7,  240);
    delay(250);
    tone(Buzzer, NOTE_C7, 240);
    delay(250);
    tone(Buzzer, NOTE_GS6, 115);
    delay(125);
    tone(Buzzer, NOTE_C7,  240);
    delay(250);
    tone(Buzzer, NOTE_DS7, 115);
    delay(125);
    noTone(Buzzer);
    delay(dauerGesamt * 1000);
    digitalWrite(S4LED,  LOW);

  }



  //Spieler 5
  if (switchStateS5 == HIGH) {
    digitalWrite(S5LED, HIGH);
    tone(Buzzer, NOTE_E6, 125);
    delay(125);
    tone(Buzzer, NOTE_G6, 125);
    delay(125);
    tone(Buzzer, NOTE_E7,  125);
    delay(125);
    tone(Buzzer, NOTE_C7, 125);
    delay(125);
    tone(Buzzer, NOTE_D7, 125);
    delay(125);
    tone(Buzzer, NOTE_G7,  125);
    delay(125);
    noTone(Buzzer);
    delay(dauerGesamt * 1000);
    digitalWrite(S5LED, LOW);
  }



  //Spieler 6
  if (switchStateS6  == HIGH) {
    digitalWrite(S6LED, HIGH);
    for (int hz = 440; hz < 1000;  hz++) {
      tone(Buzzer, hz, 50);
      delay(0.75);
    }
    delay(dauerGesamt  * 1000);
    digitalWrite(S6LED, LOW);
  }



}

Code for 6 player buzzer game

c_cpp

code for EDI

1const int S1LED =  A0;
2const int S2LED =  A1;
3const int S3LED =
4  A2;
5const int S4LED =  A3;
6const int S5LED =  A4;
7const int S6LED =  A5;
8const
9  int S1TASTER = 8;
10const int S2TASTER = 11;
11const int S3TASTER = 10;
12const
13  int S4TASTER = 12;
14const int S5TASTER = 9;
15const int S6TASTER = 7;
16const
17  int Buzzer = 13;
18const int potPin = A7;
19int switchStateS1 = 0;
20int switchStateS2
21  = 0;
22int switchStateS3 = 0;
23int switchStateS4 = 0;
24int switchStateS5 =
25  0;
26int switchStateS6 = 0;
27int potVal;
28int Dauer;
29int dauerGesamt;
30#include
31  "pitches.h"
32void setup() {
33  /*Serial.begin(9600);*/
34  pinMode(S1LED,
35  OUTPUT);
36  pinMode(S2LED, OUTPUT);
37  pinMode(S3LED, OUTPUT);
38  pinMode(S4LED,
39  OUTPUT);
40  pinMode(S5LED, OUTPUT);
41  pinMode(S6LED, OUTPUT);
42
43  digitalWrite(S1LED,
44  HIGH);
45  delay(30);
46  digitalWrite(S2LED, HIGH);
47  delay(30);
48  digitalWrite(S3LED,
49  HIGH);
50  delay(30);
51  digitalWrite(S4LED, HIGH);
52  delay(30);
53  digitalWrite(S5LED,
54  HIGH);
55  delay(30);
56  digitalWrite(S6LED, HIGH);
57  delay(30);
58  digitalWrite(S1LED,
59  LOW);
60  delay(30);
61  digitalWrite(S2LED, LOW);
62  delay(30);
63  digitalWrite(S3LED,
64  LOW);
65  delay(30);
66  digitalWrite(S4LED, LOW);
67  delay(30);
68  digitalWrite(S5LED,
69  LOW);
70  delay(30);
71  digitalWrite(S6LED, LOW);
72  delay(30);
73  digitalWrite(S1LED,
74  HIGH);
75  delay(30);
76  digitalWrite(S2LED, HIGH);
77  delay(30);
78  digitalWrite(S3LED,
79  HIGH);
80  delay(30);
81  digitalWrite(S4LED, HIGH);
82  delay(30);
83  digitalWrite(S5LED,
84  HIGH);
85  delay(30);
86  digitalWrite(S6LED, HIGH);
87  delay(30);
88  digitalWrite(S1LED,
89  LOW);
90  delay(30);
91  digitalWrite(S2LED, LOW);
92  delay(30);
93  digitalWrite(S3LED,
94  LOW);
95  delay(30);
96  digitalWrite(S4LED, LOW);
97  delay(30);
98  digitalWrite(S5LED,
99  LOW);
100  delay(30);
101  digitalWrite(S6LED, LOW);
102  delay(30);
103  tone(Buzzer,
104  NOTE_F3, 200);
105  delay(200);
106  tone(Buzzer, NOTE_A3, 200);
107  delay(400);
108
109  tone(Buzzer, NOTE_F3, 200);
110  delay(200);
111  tone(Buzzer, NOTE_AS3, 200);
112
113  delay(400);
114  tone(Buzzer, NOTE_F3, 200);
115  delay(200);
116  tone(Buzzer,
117  NOTE_C4, 800);
118  delay(800);
119
120
121
122  noTone(Buzzer);
123}
124
125void
126  loop() {
127Start:
128  int dauerSchluss = 3;
129  int i = 0;
130  potVal = analogRead(potPin);
131
132  Dauer = map(potVal, 0, 1023, 0, 7);
133
134  switchStateS1 = digitalRead(S1TASTER);
135
136  switchStateS2 = digitalRead(S2TASTER);
137  switchStateS3 = digitalRead(S3TASTER);
138
139  switchStateS4 = digitalRead(S4TASTER);
140  switchStateS5 = digitalRead(S5TASTER);
141
142  switchStateS6 = digitalRead(S6TASTER);
143  /*
144    Serial.print(potVal);
145
146    Serial.print(" ");
147    Serial.print(Dauer);
148    Serial.print(" ");
149
150    Serial.print(switchStateS1);
151    Serial.print(switchStateS2);
152    Serial.print(switchStateS3);
153
154    Serial.print(switchStateS4);
155    Serial.print(switchStateS5);
156    Serial.print(switchStateS6);*/
157
158
159
160  pinMode(S1TASTER, INPUT);
161  pinMode(S2TASTER, INPUT);
162  pinMode(S3TASTER,
163  INPUT);
164  pinMode(S4TASTER, INPUT);
165  pinMode(S5TASTER, INPUT);
166  pinMode(S6TASTER,
167  INPUT);
168  if (Dauer == 1) {
169    dauerGesamt = 3;
170  }
171  else if (Dauer
172  == 2) {
173    dauerGesamt = 5;
174  }
175  else if (Dauer == 3) {
176    dauerGesamt
177  = 10;
178  }
179  else if (Dauer == 4) {
180    dauerGesamt = 20;
181  }
182  else
183  if (Dauer == 5) {
184    dauerGesamt = 30;
185  }
186  else if (Dauer == 6 or Dauer
187  == 7) {
188    dauerGesamt = 60;
189  }
190  else {
191    dauerGesamt = 3;
192
193  }
194  /*Serial.print(" ");
195    Serial.println(dauerGesamt);*/
196  if (Dauer
197  != 0) {
198    //Spieler 1
199    if (switchStateS1 == HIGH) {
200      //Ton bei
201  Druck
202      digitalWrite(S1LED, HIGH);
203      tone(Buzzer, NOTE_G4, 35);
204
205      delay(35);
206      tone(Buzzer, NOTE_G5, 35);
207      delay(35);
208      tone(Buzzer,
209  NOTE_G6, 35);
210      delay(35);
211      noTone(Buzzer);
212      //Warten
213
214      delay((dauerGesamt + 1 - dauerSchluss - 0.21) * 900);
215      digitalWrite(S1LED,
216  LOW);
217      //Ende
218      delay((dauerGesamt + 1 - dauerSchluss - 0.21) * 100);
219
220      while (i < dauerSchluss - 1) {
221        tone(Buzzer, NOTE_G4);
222        digitalWrite(S1LED,
223  HIGH);
224        digitalWrite(S2LED, HIGH);
225        digitalWrite(S3LED, HIGH);
226
227        digitalWrite(S4LED, HIGH);
228        digitalWrite(S5LED, HIGH);
229        digitalWrite(S6LED,
230  HIGH);
231        delay(500);
232        digitalWrite(S2LED, LOW);
233        digitalWrite(S3LED,
234  LOW);
235        digitalWrite(S4LED, LOW);
236        digitalWrite(S5LED, LOW);
237
238        digitalWrite(S6LED, LOW);
239        noTone(Buzzer);
240        delay(500);
241
242        i++;
243      }
244      digitalWrite(S1LED, HIGH);
245      digitalWrite(S2LED,
246  HIGH);
247      digitalWrite(S3LED, HIGH);
248      digitalWrite(S4LED, HIGH);
249
250      digitalWrite(S5LED, HIGH);
251      digitalWrite(S6LED, HIGH);
252      tone(Buzzer,
253  NOTE_G5);
254      delay(500);
255      digitalWrite(S1LED, LOW);
256      digitalWrite(S2LED,
257  LOW);
258      digitalWrite(S3LED, LOW);
259      digitalWrite(S4LED, LOW);
260
261      digitalWrite(S5LED, LOW);
262      digitalWrite(S6LED, LOW);
263      noTone(Buzzer);
264
265      digitalWrite(S1LED, HIGH);
266      delay(30);
267      digitalWrite(S2LED,
268  HIGH);
269      delay(30);
270      digitalWrite(S3LED, HIGH);
271      delay(30);
272
273      digitalWrite(S4LED, HIGH);
274      delay(30);
275      digitalWrite(S5LED,
276  HIGH);
277      delay(30);
278      digitalWrite(S6LED, HIGH);
279      delay(30);
280
281      digitalWrite(S1LED, LOW);
282      delay(30);
283      digitalWrite(S2LED,
284  LOW);
285      delay(30);
286      digitalWrite(S3LED, LOW);
287      delay(30);
288
289      digitalWrite(S4LED, LOW);
290      delay(30);
291      digitalWrite(S5LED,
292  LOW);
293      delay(30);
294      digitalWrite(S6LED, LOW);
295      delay(30);
296
297      goto Start;
298    }
299
300    //Spieler 2
301    if (switchStateS2 == HIGH)
302  {
303      digitalWrite(S2LED, HIGH);
304      //Ton bei Druck
305      tone(Buzzer,
306  NOTE_B5, 100);
307      delay(100);
308      tone(Buzzer, NOTE_E6, 700);
309      delay(700);
310
311      noTone(Buzzer);
312      //Warten
313      delay((dauerGesamt + 1 - dauerSchluss
314  - 0.8) * 900);
315      digitalWrite(S2LED, LOW);
316      //Ende
317      delay((dauerGesamt
318  + 1 - dauerSchluss - 0.8) * 100);
319      while (i < dauerSchluss - 1) {
320        tone(Buzzer,
321  NOTE_G4);
322        digitalWrite(S1LED, HIGH);
323        digitalWrite(S2LED, HIGH);
324
325        digitalWrite(S3LED, HIGH);
326        digitalWrite(S4LED, HIGH);
327        digitalWrite(S5LED,
328  HIGH);
329        digitalWrite(S6LED, HIGH);
330        delay(500);
331        digitalWrite(S1LED,
332  LOW);
333        digitalWrite(S3LED, LOW);
334        digitalWrite(S4LED, LOW);
335
336        digitalWrite(S5LED, LOW);
337        digitalWrite(S6LED, LOW);
338        noTone(Buzzer);
339
340        delay(500);
341        i++;
342      }
343      digitalWrite(S1LED, HIGH);
344
345      digitalWrite(S2LED, HIGH);
346      digitalWrite(S3LED, HIGH);
347      digitalWrite(S4LED,
348  HIGH);
349      digitalWrite(S5LED, HIGH);
350      digitalWrite(S6LED, HIGH);
351
352      tone(Buzzer, NOTE_G5);
353      delay(500);
354      digitalWrite(S1LED, LOW);
355
356      digitalWrite(S2LED, LOW);
357      digitalWrite(S3LED, LOW);
358      digitalWrite(S4LED,
359  LOW);
360      digitalWrite(S5LED, LOW);
361      digitalWrite(S6LED, LOW);
362
363      noTone(Buzzer);
364      digitalWrite(S2LED, HIGH);
365      delay(30);
366
367      digitalWrite(S3LED, HIGH);
368      delay(30);
369      digitalWrite(S4LED,
370  HIGH);
371      delay(30);
372      digitalWrite(S5LED, HIGH);
373      delay(30);
374
375      digitalWrite(S6LED, HIGH);
376      delay(30);
377      digitalWrite(S1LED,
378  HIGH);
379      delay(30);
380      digitalWrite(S2LED, LOW);
381      delay(30);
382
383      digitalWrite(S3LED, LOW);
384      delay(30);
385      digitalWrite(S4LED,
386  LOW);
387      delay(30);
388      digitalWrite(S5LED, LOW);
389      delay(30);
390
391      digitalWrite(S6LED, LOW);
392      delay(30);
393      digitalWrite(S1LED,
394  LOW);
395      goto Start;
396    }
397
398
399    //Spieler 3
400    if (switchStateS3
401  == HIGH) {
402      digitalWrite(S3LED, HIGH);
403      for (int hz = 2000; hz >
404  440; hz--) {
405        tone(Buzzer, hz, 50);
406        delay(0.5);
407      }
408
409
410      //Warten
411      delay((dauerGesamt + 1 - dauerSchluss - 0.4) * 900);
412
413      digitalWrite(S3LED, LOW);
414      //Ende
415      delay((dauerGesamt + 1
416  - dauerSchluss - 0.4) * 100);
417      while (i < dauerSchluss - 1) {
418        tone(Buzzer,
419  NOTE_G4);
420        digitalWrite(S1LED, HIGH);
421        digitalWrite(S2LED, HIGH);
422
423        digitalWrite(S3LED, HIGH);
424        digitalWrite(S4LED, HIGH);
425        digitalWrite(S5LED,
426  HIGH);
427        digitalWrite(S6LED, HIGH);
428        delay(500);
429        digitalWrite(S1LED,
430  LOW);
431        digitalWrite(S2LED, LOW);
432        digitalWrite(S4LED, LOW);
433
434        digitalWrite(S5LED, LOW);
435        digitalWrite(S6LED, LOW);
436        noTone(Buzzer);
437
438        delay(500);
439        i++;
440      }
441      digitalWrite(S1LED, HIGH);
442
443      digitalWrite(S2LED, HIGH);
444      digitalWrite(S3LED, HIGH);
445      digitalWrite(S4LED,
446  HIGH);
447      digitalWrite(S5LED, HIGH);
448      digitalWrite(S6LED, HIGH);
449
450      tone(Buzzer, NOTE_G5);
451      delay(500);
452      digitalWrite(S1LED, LOW);
453
454      digitalWrite(S2LED, LOW);
455      digitalWrite(S3LED, LOW);
456      digitalWrite(S4LED,
457  LOW);
458      digitalWrite(S5LED, LOW);
459      digitalWrite(S6LED, LOW);
460
461      noTone(Buzzer);
462      digitalWrite(S3LED, HIGH);
463      delay(30);
464
465      digitalWrite(S4LED, HIGH);
466      delay(30);
467      digitalWrite(S5LED,
468  HIGH);
469      delay(30);
470      digitalWrite(S6LED, HIGH);
471      delay(30);
472
473      digitalWrite(S1LED, HIGH);
474      delay(30);
475      digitalWrite(S2LED,
476  HIGH);
477      delay(30);
478      digitalWrite(S3LED, LOW);
479      delay(30);
480
481      digitalWrite(S4LED, LOW);
482      delay(30);
483      digitalWrite(S5LED,
484  LOW);
485      delay(30);
486      digitalWrite(S6LED, LOW);
487      delay(30);
488
489      digitalWrite(S1LED, LOW);
490      delay(30);
491      digitalWrite(S2LED,
492  LOW);
493      goto Start;
494    }
495
496
497    //Spieler 4
498    if (switchStateS4
499  == HIGH) {
500      digitalWrite(S4LED, HIGH);
501      tone(Buzzer, NOTE_C7, 115);
502
503      delay(125);
504      tone(Buzzer, NOTE_C7, 240);
505      delay(250);
506
507      tone(Buzzer, NOTE_C7, 240);
508      delay(250);
509      tone(Buzzer, NOTE_GS6,
510  115);
511      delay(125);
512      tone(Buzzer, NOTE_C7, 240);
513      delay(250);
514
515      tone(Buzzer, NOTE_DS7, 115);
516      delay(125);
517      //Warten
518      delay((dauerGesamt
519  + 1 - dauerSchluss - 1.0) * 900);
520      digitalWrite(S4LED, LOW);
521      //Ende
522
523      delay((dauerGesamt + 1 - dauerSchluss - 1.0) * 100);
524      while (i < dauerSchluss
525  - 1) {
526        tone(Buzzer, NOTE_G4);
527        digitalWrite(S1LED, HIGH);
528
529        digitalWrite(S2LED, HIGH);
530        digitalWrite(S3LED, HIGH);
531        digitalWrite(S4LED,
532  HIGH);
533        digitalWrite(S5LED, HIGH);
534        digitalWrite(S6LED, HIGH);
535
536        delay(500);
537        digitalWrite(S1LED, LOW);
538        digitalWrite(S2LED,
539  LOW);
540        digitalWrite(S3LED, LOW);
541        digitalWrite(S5LED, LOW);
542
543        digitalWrite(S6LED, LOW);
544        noTone(Buzzer);
545        delay(500);
546
547        i++;
548      }
549      digitalWrite(S1LED, HIGH);
550      digitalWrite(S2LED,
551  HIGH);
552      digitalWrite(S3LED, HIGH);
553      digitalWrite(S4LED, HIGH);
554
555      digitalWrite(S5LED, HIGH);
556      digitalWrite(S6LED, HIGH);
557      tone(Buzzer,
558  NOTE_G5);
559      delay(500);
560      digitalWrite(S1LED, LOW);
561      digitalWrite(S2LED,
562  LOW);
563      digitalWrite(S3LED, LOW);
564      digitalWrite(S4LED, LOW);
565
566      digitalWrite(S5LED, LOW);
567      digitalWrite(S6LED, LOW);
568      noTone(Buzzer);
569
570      digitalWrite(S4LED, HIGH);
571      delay(30);
572      digitalWrite(S5LED,
573  HIGH);
574      delay(30);
575      digitalWrite(S6LED, HIGH);
576      delay(30);
577
578      digitalWrite(S1LED, HIGH);
579      delay(30);
580      digitalWrite(S2LED,
581  HIGH);
582      delay(30);
583      digitalWrite(S3LED, HIGH);
584      delay(30);
585
586      digitalWrite(S4LED, LOW);
587      delay(30);
588      digitalWrite(S5LED,
589  LOW);
590      delay(30);
591      digitalWrite(S6LED, LOW);
592      delay(30);
593
594      digitalWrite(S1LED, LOW);
595      delay(30);
596      digitalWrite(S2LED,
597  LOW);
598      delay(30);
599      digitalWrite(S3LED, LOW);
600      goto Start;
601
602    }
603
604
605
606    //Spieler 5
607    if (switchStateS5 == HIGH) {
608      digitalWrite(S5LED,
609  HIGH);
610      tone(Buzzer, NOTE_E6, 125);
611      delay(125);
612      tone(Buzzer,
613  NOTE_G6, 125);
614      delay(125);
615      tone(Buzzer, NOTE_E7, 125);
616      delay(125);
617
618      tone(Buzzer, NOTE_C7, 125);
619      delay(125);
620      tone(Buzzer, NOTE_D7,
621  125);
622      delay(125);
623      tone(Buzzer, NOTE_G7, 125);
624      delay(125);
625
626      noTone(Buzzer);
627
628      //Warten
629      delay((dauerGesamt + 1 - dauerSchluss
630  - 0.85) * 900);
631      digitalWrite(S5LED, LOW);
632      //Ende
633      delay((dauerGesamt
634  + 1 - dauerSchluss - 0.85) * 100);
635      while (i < dauerSchluss - 1) {
636        tone(Buzzer,
637  NOTE_G4);
638        digitalWrite(S1LED, HIGH);
639        digitalWrite(S2LED, HIGH);
640
641        digitalWrite(S3LED, HIGH);
642        digitalWrite(S4LED, HIGH);
643        digitalWrite(S5LED,
644  HIGH);
645        digitalWrite(S6LED, HIGH);
646        delay(500);
647        digitalWrite(S5LED,
648  LOW);
649        digitalWrite(S1LED, LOW);
650        digitalWrite(S2LED, LOW);
651
652        digitalWrite(S3LED, LOW);
653        digitalWrite(S4LED, LOW);
654        digitalWrite(S6LED,
655  LOW);
656        noTone(Buzzer);
657        delay(500);
658        i++;
659      }
660
661
662      digitalWrite(S1LED, HIGH);
663      digitalWrite(S2LED, HIGH);
664      digitalWrite(S3LED,
665  HIGH);
666      digitalWrite(S4LED, HIGH);
667      digitalWrite(S5LED, HIGH);
668
669      digitalWrite(S6LED, HIGH);
670      tone(Buzzer, NOTE_G5);
671      delay(500);
672
673      digitalWrite(S1LED, LOW);
674      digitalWrite(S2LED, LOW);
675      digitalWrite(S3LED,
676  LOW);
677      digitalWrite(S4LED, LOW);
678      digitalWrite(S5LED, LOW);
679
680      digitalWrite(S6LED, LOW);
681      noTone(Buzzer);
682      digitalWrite(S5LED,
683  HIGH);
684      delay(30);
685      digitalWrite(S6LED, HIGH);
686      delay(30);
687
688      digitalWrite(S1LED, HIGH);
689      delay(30);
690      digitalWrite(S2LED,
691  HIGH);
692      delay(30);
693      digitalWrite(S3LED, HIGH);
694      delay(30);
695
696      digitalWrite(S4LED, HIGH);
697      delay(30);
698      digitalWrite(S5LED,
699  LOW);
700      delay(30);
701      digitalWrite(S6LED, LOW);
702      delay(30);
703
704      digitalWrite(S1LED, LOW);
705      delay(30);
706      digitalWrite(S2LED,
707  LOW);
708      delay(30);
709      digitalWrite(S3LED, LOW);
710      delay(30);
711
712      digitalWrite(S4LED, LOW);
713      goto Start;
714    }
715
716
717
718    //Spieler
719  6
720    if (switchStateS6 == HIGH) {
721      digitalWrite(S6LED, HIGH);
722      for
723  (int hz = 440; hz < 1000; hz++) {
724        tone(Buzzer, hz, 50);
725        delay(0.75);
726
727      }
728
729      //Warten
730      delay((dauerGesamt + 1 - dauerSchluss) *
731  900);
732      digitalWrite(S6LED, LOW);
733      //Ende
734      delay((dauerGesamt
735  + 1 - dauerSchluss) * 100);
736      while (i < dauerSchluss - 1) {
737        tone(Buzzer,
738  NOTE_G4);
739        digitalWrite(S1LED, HIGH);
740        digitalWrite(S2LED, HIGH);
741
742        digitalWrite(S3LED, HIGH);
743        digitalWrite(S4LED, HIGH);
744        digitalWrite(S5LED,
745  HIGH);
746        digitalWrite(S6LED, HIGH);
747        delay(500);
748        digitalWrite(S1LED,
749  LOW);
750        digitalWrite(S2LED, LOW);
751        digitalWrite(S3LED, LOW);
752
753        digitalWrite(S4LED, LOW);
754        digitalWrite(S5LED, LOW);
755        noTone(Buzzer);
756
757        delay(500);
758        i++;
759      }
760      digitalWrite(S1LED, HIGH);
761
762      digitalWrite(S2LED, HIGH);
763      digitalWrite(S3LED, HIGH);
764      digitalWrite(S4LED,
765  HIGH);
766      digitalWrite(S5LED, HIGH);
767      digitalWrite(S6LED, HIGH);
768
769      tone(Buzzer, NOTE_G5);
770      delay(500);
771      digitalWrite(S1LED, LOW);
772
773      digitalWrite(S2LED, LOW);
774      digitalWrite(S3LED, LOW);
775      digitalWrite(S4LED,
776  LOW);
777      digitalWrite(S5LED, LOW);
778      digitalWrite(S6LED, LOW);
779
780      noTone(Buzzer);
781      digitalWrite(S6LED, HIGH);
782      delay(30);
783
784      digitalWrite(S1LED, HIGH);
785      delay(30);
786      digitalWrite(S2LED,
787  HIGH);
788      delay(30);
789      digitalWrite(S3LED, HIGH);
790      delay(30);
791
792      digitalWrite(S4LED, HIGH);
793      delay(30);
794      digitalWrite(S5LED,
795  HIGH);
796      delay(30);
797      digitalWrite(S6LED, LOW);
798      delay(30);
799
800      digitalWrite(S1LED, LOW);
801      delay(30);
802      digitalWrite(S2LED,
803  LOW);
804      delay(30);
805      digitalWrite(S3LED, LOW);
806      delay(30);
807
808      digitalWrite(S4LED, LOW);
809      delay(30);
810      digitalWrite(S5LED,
811  LOW);
812      delay(30);
813      goto Start;
814    }
815  }
816
817  else if
818  (potVal < 145) {
819    //Spieler 1
820    if (switchStateS1 == HIGH) {
821      //Ton
822  bei Druck
823      digitalWrite(S1LED, HIGH);
824      tone(Buzzer, NOTE_G4, 35);
825
826      delay(35);
827      tone(Buzzer, NOTE_G5, 35);
828      delay(35);
829      tone(Buzzer,
830  NOTE_G6, 35);
831      delay(35);
832      noTone(Buzzer);
833      delay(dauerGesamt
834  * 1000);
835      digitalWrite(S1LED, LOW);
836    }
837  }
838
839  //Spieler 2
840
841  if (switchStateS2 == HIGH) {
842    digitalWrite(S2LED, HIGH);
843    //Ton bei
844  Druck
845    tone(Buzzer, NOTE_B5, 100);
846    delay(100);
847    tone(Buzzer,
848  NOTE_E6, 700);
849    delay(700);
850    noTone(Buzzer);
851    delay(dauerGesamt
852  * 1000);
853    digitalWrite(S2LED, LOW);
854  }
855
856
857  //Spieler 3
858  if
859  (switchStateS3 == HIGH) {
860    digitalWrite(S3LED, HIGH);
861    for (int hz =
862  2000; hz > 440; hz--) {
863      tone(Buzzer, hz, 50);
864      delay(0.5);
865
866    }
867    delay(dauerGesamt * 1000);
868    digitalWrite(S3LED, LOW);
869  }
870
871
872
873  //Spieler 4
874  if (switchStateS4 == HIGH) {
875    digitalWrite(S4LED, HIGH);
876
877    tone(Buzzer, NOTE_C7, 115);
878    delay(125);
879    tone(Buzzer, NOTE_C7,
880  240);
881    delay(250);
882    tone(Buzzer, NOTE_C7, 240);
883    delay(250);
884
885    tone(Buzzer, NOTE_GS6, 115);
886    delay(125);
887    tone(Buzzer, NOTE_C7,
888  240);
889    delay(250);
890    tone(Buzzer, NOTE_DS7, 115);
891    delay(125);
892
893    noTone(Buzzer);
894    delay(dauerGesamt * 1000);
895    digitalWrite(S4LED,
896  LOW);
897
898  }
899
900
901
902  //Spieler 5
903  if (switchStateS5 == HIGH) {
904
905    digitalWrite(S5LED, HIGH);
906    tone(Buzzer, NOTE_E6, 125);
907    delay(125);
908
909    tone(Buzzer, NOTE_G6, 125);
910    delay(125);
911    tone(Buzzer, NOTE_E7,
912  125);
913    delay(125);
914    tone(Buzzer, NOTE_C7, 125);
915    delay(125);
916
917    tone(Buzzer, NOTE_D7, 125);
918    delay(125);
919    tone(Buzzer, NOTE_G7,
920  125);
921    delay(125);
922    noTone(Buzzer);
923    delay(dauerGesamt * 1000);
924
925    digitalWrite(S5LED, LOW);
926  }
927
928
929
930  //Spieler 6
931  if (switchStateS6
932  == HIGH) {
933    digitalWrite(S6LED, HIGH);
934    for (int hz = 440; hz < 1000;
935  hz++) {
936      tone(Buzzer, hz, 50);
937      delay(0.75);
938    }
939    delay(dauerGesamt
940  * 1000);
941    digitalWrite(S6LED, LOW);
942  }
943
944
945
946}
947

const int S1LED =  A0;
const int S2LED =  A1;
const int S3LED =
  A2;
const int S4LED =  A3;
const int S5LED =  A4;
const int S6LED =  A5;
const
  int S1TASTER = 8;
const int S2TASTER = 11;
const int S3TASTER = 10;
const
  int S4TASTER = 12;
const int S5TASTER = 9;
const int S6TASTER = 7;
const
  int Buzzer = 13;
const int potPin = A7;
int switchStateS1 = 0;
int switchStateS2
  = 0;
int switchStateS3 = 0;
int switchStateS4 = 0;
int switchStateS5 =
  0;
int switchStateS6 = 0;
int potVal;
int Dauer;
int dauerGesamt;
#include
  "pitches.h"
void setup() {
  /*Serial.begin(9600);*/
  pinMode(S1LED,
  OUTPUT);
  pinMode(S2LED, OUTPUT);
  pinMode(S3LED, OUTPUT);
  pinMode(S4LED,
  OUTPUT);
  pinMode(S5LED, OUTPUT);
  pinMode(S6LED, OUTPUT);

  digitalWrite(S1LED,
  HIGH);
  delay(30);
  digitalWrite(S2LED, HIGH);
  delay(30);
  digitalWrite(S3LED,
  HIGH);
  delay(30);
  digitalWrite(S4LED, HIGH);
  delay(30);
  digitalWrite(S5LED,
  HIGH);
  delay(30);
  digitalWrite(S6LED, HIGH);
  delay(30);
  digitalWrite(S1LED,
  LOW);
  delay(30);
  digitalWrite(S2LED, LOW);
  delay(30);
  digitalWrite(S3LED,
  LOW);
  delay(30);
  digitalWrite(S4LED, LOW);
  delay(30);
  digitalWrite(S5LED,
  LOW);
  delay(30);
  digitalWrite(S6LED, LOW);
  delay(30);
  digitalWrite(S1LED,
  HIGH);
  delay(30);
  digitalWrite(S2LED, HIGH);
  delay(30);
  digitalWrite(S3LED,
  HIGH);
  delay(30);
  digitalWrite(S4LED, HIGH);
  delay(30);
  digitalWrite(S5LED,
  HIGH);
  delay(30);
  digitalWrite(S6LED, HIGH);
  delay(30);
  digitalWrite(S1LED,
  LOW);
  delay(30);
  digitalWrite(S2LED, LOW);
  delay(30);
  digitalWrite(S3LED,
  LOW);
  delay(30);
  digitalWrite(S4LED, LOW);
  delay(30);
  digitalWrite(S5LED,
  LOW);
  delay(30);
  digitalWrite(S6LED, LOW);
  delay(30);
  tone(Buzzer,
  NOTE_F3, 200);
  delay(200);
  tone(Buzzer, NOTE_A3, 200);
  delay(400);

  tone(Buzzer, NOTE_F3, 200);
  delay(200);
  tone(Buzzer, NOTE_AS3, 200);

  delay(400);
  tone(Buzzer, NOTE_F3, 200);
  delay(200);
  tone(Buzzer,
  NOTE_C4, 800);
  delay(800);



  noTone(Buzzer);
}

void
  loop() {
Start:
  int dauerSchluss = 3;
  int i = 0;
  potVal = analogRead(potPin);

  Dauer = map(potVal, 0, 1023, 0, 7);

  switchStateS1 = digitalRead(S1TASTER);

  switchStateS2 = digitalRead(S2TASTER);
  switchStateS3 = digitalRead(S3TASTER);

  switchStateS4 = digitalRead(S4TASTER);
  switchStateS5 = digitalRead(S5TASTER);

  switchStateS6 = digitalRead(S6TASTER);
  /*
    Serial.print(potVal);

    Serial.print(" ");
    Serial.print(Dauer);
    Serial.print(" ");

    Serial.print(switchStateS1);
    Serial.print(switchStateS2);
    Serial.print(switchStateS3);

    Serial.print(switchStateS4);
    Serial.print(switchStateS5);
    Serial.print(switchStateS6);*/



  pinMode(S1TASTER, INPUT);
  pinMode(S2TASTER, INPUT);
  pinMode(S3TASTER,
  INPUT);
  pinMode(S4TASTER, INPUT);
  pinMode(S5TASTER, INPUT);
  pinMode(S6TASTER,
  INPUT);
  if (Dauer == 1) {
    dauerGesamt = 3;
  }
  else if (Dauer
  == 2) {
    dauerGesamt = 5;
  }
  else if (Dauer == 3) {
    dauerGesamt
  = 10;
  }
  else if (Dauer == 4) {
    dauerGesamt = 20;
  }
  else
  if (Dauer == 5) {
    dauerGesamt = 30;
  }
  else if (Dauer == 6 or Dauer
  == 7) {
    dauerGesamt = 60;
  }
  else {
    dauerGesamt = 3;

  }
  /*Serial.print(" ");
    Serial.println(dauerGesamt);*/
  if (Dauer
  != 0) {
    //Spieler 1
    if (switchStateS1 == HIGH) {
      //Ton bei
  Druck
      digitalWrite(S1LED, HIGH);
      tone(Buzzer, NOTE_G4, 35);

      delay(35);
      tone(Buzzer, NOTE_G5, 35);
      delay(35);
      tone(Buzzer,
  NOTE_G6, 35);
      delay(35);
      noTone(Buzzer);
      //Warten

      delay((dauerGesamt + 1 - dauerSchluss - 0.21) * 900);
      digitalWrite(S1LED,
  LOW);
      //Ende
      delay((dauerGesamt + 1 - dauerSchluss - 0.21) * 100);

      while (i < dauerSchluss - 1) {
        tone(Buzzer, NOTE_G4);
        digitalWrite(S1LED,
  HIGH);
        digitalWrite(S2LED, HIGH);
        digitalWrite(S3LED, HIGH);

        digitalWrite(S4LED, HIGH);
        digitalWrite(S5LED, HIGH);
        digitalWrite(S6LED,
  HIGH);
        delay(500);
        digitalWrite(S2LED, LOW);
        digitalWrite(S3LED,
  LOW);
        digitalWrite(S4LED, LOW);
        digitalWrite(S5LED, LOW);

        digitalWrite(S6LED, LOW);
        noTone(Buzzer);
        delay(500);

        i++;
      }
      digitalWrite(S1LED, HIGH);
      digitalWrite(S2LED,
  HIGH);
      digitalWrite(S3LED, HIGH);
      digitalWrite(S4LED, HIGH);

      digitalWrite(S5LED, HIGH);
      digitalWrite(S6LED, HIGH);
      tone(Buzzer,
  NOTE_G5);
      delay(500);
      digitalWrite(S1LED, LOW);
      digitalWrite(S2LED,
  LOW);
      digitalWrite(S3LED, LOW);
      digitalWrite(S4LED, LOW);

      digitalWrite(S5LED, LOW);
      digitalWrite(S6LED, LOW);
      noTone(Buzzer);

      digitalWrite(S1LED, HIGH);
      delay(30);
      digitalWrite(S2LED,
  HIGH);
      delay(30);
      digitalWrite(S3LED, HIGH);
      delay(30);

      digitalWrite(S4LED, HIGH);
      delay(30);
      digitalWrite(S5LED,
  HIGH);
      delay(30);
      digitalWrite(S6LED, HIGH);
      delay(30);

      digitalWrite(S1LED, LOW);
      delay(30);
      digitalWrite(S2LED,
  LOW);
      delay(30);
      digitalWrite(S3LED, LOW);
      delay(30);

      digitalWrite(S4LED, LOW);
      delay(30);
      digitalWrite(S5LED,
  LOW);
      delay(30);
      digitalWrite(S6LED, LOW);
      delay(30);

      goto Start;
    }

    //Spieler 2
    if (switchStateS2 == HIGH)
  {
      digitalWrite(S2LED, HIGH);
      //Ton bei Druck
      tone(Buzzer,
  NOTE_B5, 100);
      delay(100);
      tone(Buzzer, NOTE_E6, 700);
      delay(700);

      noTone(Buzzer);
      //Warten
      delay((dauerGesamt + 1 - dauerSchluss
  - 0.8) * 900);
      digitalWrite(S2LED, LOW);
      //Ende
      delay((dauerGesamt
  + 1 - dauerSchluss - 0.8) * 100);
      while (i < dauerSchluss - 1) {
        tone(Buzzer,
  NOTE_G4);
        digitalWrite(S1LED, HIGH);
        digitalWrite(S2LED, HIGH);

        digitalWrite(S3LED, HIGH);
        digitalWrite(S4LED, HIGH);
        digitalWrite(S5LED,
  HIGH);
        digitalWrite(S6LED, HIGH);
        delay(500);
        digitalWrite(S1LED,
  LOW);
        digitalWrite(S3LED, LOW);
        digitalWrite(S4LED, LOW);

        digitalWrite(S5LED, LOW);
        digitalWrite(S6LED, LOW);
        noTone(Buzzer);

        delay(500);
        i++;
      }
      digitalWrite(S1LED, HIGH);

      digitalWrite(S2LED, HIGH);
      digitalWrite(S3LED, HIGH);
      digitalWrite(S4LED,
  HIGH);
      digitalWrite(S5LED, HIGH);
      digitalWrite(S6LED, HIGH);

      tone(Buzzer, NOTE_G5);
      delay(500);
      digitalWrite(S1LED, LOW);

      digitalWrite(S2LED, LOW);
      digitalWrite(S3LED, LOW);
      digitalWrite(S4LED,
  LOW);
      digitalWrite(S5LED, LOW);
      digitalWrite(S6LED, LOW);

      noTone(Buzzer);
      digitalWrite(S2LED, HIGH);
      delay(30);

      digitalWrite(S3LED, HIGH);
      delay(30);
      digitalWrite(S4LED,
  HIGH);
      delay(30);
      digitalWrite(S5LED, HIGH);
      delay(30);

      digitalWrite(S6LED, HIGH);
      delay(30);
      digitalWrite(S1LED,
  HIGH);
      delay(30);
      digitalWrite(S2LED, LOW);
      delay(30);

      digitalWrite(S3LED, LOW);
      delay(30);
      digitalWrite(S4LED,
  LOW);
      delay(30);
      digitalWrite(S5LED, LOW);
      delay(30);

      digitalWrite(S6LED, LOW);
      delay(30);
      digitalWrite(S1LED,
  LOW);
      goto Start;
    }


    //Spieler 3
    if (switchStateS3
  == HIGH) {
      digitalWrite(S3LED, HIGH);
      for (int hz = 2000; hz >
  440; hz--) {
        tone(Buzzer, hz, 50);
        delay(0.5);
      }


      //Warten
      delay((dauerGesamt + 1 - dauerSchluss - 0.4) * 900);

      digitalWrite(S3LED, LOW);
      //Ende
      delay((dauerGesamt + 1
  - dauerSchluss - 0.4) * 100);
      while (i < dauerSchluss - 1) {
        tone(Buzzer,
  NOTE_G4);
        digitalWrite(S1LED, HIGH);
        digitalWrite(S2LED, HIGH);

        digitalWrite(S3LED, HIGH);
        digitalWrite(S4LED, HIGH);
        digitalWrite(S5LED,
  HIGH);
        digitalWrite(S6LED, HIGH);
        delay(500);
        digitalWrite(S1LED,
  LOW);
        digitalWrite(S2LED, LOW);
        digitalWrite(S4LED, LOW);

        digitalWrite(S5LED, LOW);
        digitalWrite(S6LED, LOW);
        noTone(Buzzer);

        delay(500);
        i++;
      }
      digitalWrite(S1LED, HIGH);

      digitalWrite(S2LED, HIGH);
      digitalWrite(S3LED, HIGH);
      digitalWrite(S4LED,
  HIGH);
      digitalWrite(S5LED, HIGH);
      digitalWrite(S6LED, HIGH);

      tone(Buzzer, NOTE_G5);
      delay(500);
      digitalWrite(S1LED, LOW);

      digitalWrite(S2LED, LOW);
      digitalWrite(S3LED, LOW);
      digitalWrite(S4LED,
  LOW);
      digitalWrite(S5LED, LOW);
      digitalWrite(S6LED, LOW);

      noTone(Buzzer);
      digitalWrite(S3LED, HIGH);
      delay(30);

      digitalWrite(S4LED, HIGH);
      delay(30);
      digitalWrite(S5LED,
  HIGH);
      delay(30);
      digitalWrite(S6LED, HIGH);
      delay(30);

      digitalWrite(S1LED, HIGH);
      delay(30);
      digitalWrite(S2LED,
  HIGH);
      delay(30);
      digitalWrite(S3LED, LOW);
      delay(30);

      digitalWrite(S4LED, LOW);
      delay(30);
      digitalWrite(S5LED,
  LOW);
      delay(30);
      digitalWrite(S6LED, LOW);
      delay(30);

      digitalWrite(S1LED, LOW);
      delay(30);
      digitalWrite(S2LED,
  LOW);
      goto Start;
    }


    //Spieler 4
    if (switchStateS4
  == HIGH) {
      digitalWrite(S4LED, HIGH);
      tone(Buzzer, NOTE_C7, 115);

      delay(125);
      tone(Buzzer, NOTE_C7, 240);
      delay(250);

      tone(Buzzer, NOTE_C7, 240);
      delay(250);
      tone(Buzzer, NOTE_GS6,
  115);
      delay(125);
      tone(Buzzer, NOTE_C7, 240);
      delay(250);

      tone(Buzzer, NOTE_DS7, 115);
      delay(125);
      //Warten
      delay((dauerGesamt
  + 1 - dauerSchluss - 1.0) * 900);
      digitalWrite(S4LED, LOW);
      //Ende

      delay((dauerGesamt + 1 - dauerSchluss - 1.0) * 100);
      while (i < dauerSchluss
  - 1) {
        tone(Buzzer, NOTE_G4);
        digitalWrite(S1LED, HIGH);

        digitalWrite(S2LED, HIGH);
        digitalWrite(S3LED, HIGH);
        digitalWrite(S4LED,
  HIGH);
        digitalWrite(S5LED, HIGH);
        digitalWrite(S6LED, HIGH);

        delay(500);
        digitalWrite(S1LED, LOW);
        digitalWrite(S2LED,
  LOW);
        digitalWrite(S3LED, LOW);
        digitalWrite(S5LED, LOW);

        digitalWrite(S6LED, LOW);
        noTone(Buzzer);
        delay(500);

        i++;
      }
      digitalWrite(S1LED, HIGH);
      digitalWrite(S2LED,
  HIGH);
      digitalWrite(S3LED, HIGH);
      digitalWrite(S4LED, HIGH);

      digitalWrite(S5LED, HIGH);
      digitalWrite(S6LED, HIGH);
      tone(Buzzer,
  NOTE_G5);
      delay(500);
      digitalWrite(S1LED, LOW);
      digitalWrite(S2LED,
  LOW);
      digitalWrite(S3LED, LOW);
      digitalWrite(S4LED, LOW);

      digitalWrite(S5LED, LOW);
      digitalWrite(S6LED, LOW);
      noTone(Buzzer);

      digitalWrite(S4LED, HIGH);
      delay(30);
      digitalWrite(S5LED,
  HIGH);
      delay(30);
      digitalWrite(S6LED, HIGH);
      delay(30);

      digitalWrite(S1LED, HIGH);
      delay(30);
      digitalWrite(S2LED,
  HIGH);
      delay(30);
      digitalWrite(S3LED, HIGH);
      delay(30);

      digitalWrite(S4LED, LOW);
      delay(30);
      digitalWrite(S5LED,
  LOW);
      delay(30);
      digitalWrite(S6LED, LOW);
      delay(30);

      digitalWrite(S1LED, LOW);
      delay(30);
      digitalWrite(S2LED,
  LOW);
      delay(30);
      digitalWrite(S3LED, LOW);
      goto Start;

    }



    //Spieler 5
    if (switchStateS5 == HIGH) {
      digitalWrite(S5LED,
  HIGH);
      tone(Buzzer, NOTE_E6, 125);
      delay(125);
      tone(Buzzer,
  NOTE_G6, 125);
      delay(125);
      tone(Buzzer, NOTE_E7, 125);
      delay(125);

      tone(Buzzer, NOTE_C7, 125);
      delay(125);
      tone(Buzzer, NOTE_D7,
  125);
      delay(125);
      tone(Buzzer, NOTE_G7, 125);
      delay(125);

      noTone(Buzzer);

      //Warten
      delay((dauerGesamt + 1 - dauerSchluss
  - 0.85) * 900);
      digitalWrite(S5LED, LOW);
      //Ende
      delay((dauerGesamt
  + 1 - dauerSchluss - 0.85) * 100);
      while (i < dauerSchluss - 1) {
        tone(Buzzer,
  NOTE_G4);
        digitalWrite(S1LED, HIGH);
        digitalWrite(S2LED, HIGH);

        digitalWrite(S3LED, HIGH);
        digitalWrite(S4LED, HIGH);
        digitalWrite(S5LED,
  HIGH);
        digitalWrite(S6LED, HIGH);
        delay(500);
        digitalWrite(S5LED,
  LOW);
        digitalWrite(S1LED, LOW);
        digitalWrite(S2LED, LOW);

        digitalWrite(S3LED, LOW);
        digitalWrite(S4LED, LOW);
        digitalWrite(S6LED,
  LOW);
        noTone(Buzzer);
        delay(500);
        i++;
      }


      digitalWrite(S1LED, HIGH);
      digitalWrite(S2LED, HIGH);
      digitalWrite(S3LED,
  HIGH);
      digitalWrite(S4LED, HIGH);
      digitalWrite(S5LED, HIGH);

      digitalWrite(S6LED, HIGH);
      tone(Buzzer, NOTE_G5);
      delay(500);

      digitalWrite(S1LED, LOW);
      digitalWrite(S2LED, LOW);
      digitalWrite(S3LED,
  LOW);
      digitalWrite(S4LED, LOW);
      digitalWrite(S5LED, LOW);

      digitalWrite(S6LED, LOW);
      noTone(Buzzer);
      digitalWrite(S5LED,
  HIGH);
      delay(30);
      digitalWrite(S6LED, HIGH);
      delay(30);

      digitalWrite(S1LED, HIGH);
      delay(30);
      digitalWrite(S2LED,
  HIGH);
      delay(30);
      digitalWrite(S3LED, HIGH);
      delay(30);

      digitalWrite(S4LED, HIGH);
      delay(30);
      digitalWrite(S5LED,
  LOW);
      delay(30);
      digitalWrite(S6LED, LOW);
      delay(30);

      digitalWrite(S1LED, LOW);
      delay(30);
      digitalWrite(S2LED,
  LOW);
      delay(30);
      digitalWrite(S3LED, LOW);
      delay(30);

      digitalWrite(S4LED, LOW);
      goto Start;
    }



    //Spieler
  6
    if (switchStateS6 == HIGH) {
      digitalWrite(S6LED, HIGH);
      for
  (int hz = 440; hz < 1000; hz++) {
        tone(Buzzer, hz, 50);
        delay(0.75);

      }

      //Warten
      delay((dauerGesamt + 1 - dauerSchluss) *
  900);
      digitalWrite(S6LED, LOW);
      //Ende
      delay((dauerGesamt
  + 1 - dauerSchluss) * 100);
      while (i < dauerSchluss - 1) {
        tone(Buzzer,
  NOTE_G4);
        digitalWrite(S1LED, HIGH);
        digitalWrite(S2LED, HIGH);

        digitalWrite(S3LED, HIGH);
        digitalWrite(S4LED, HIGH);
        digitalWrite(S5LED,
  HIGH);
        digitalWrite(S6LED, HIGH);
        delay(500);
        digitalWrite(S1LED,
  LOW);
        digitalWrite(S2LED, LOW);
        digitalWrite(S3LED, LOW);

        digitalWrite(S4LED, LOW);
        digitalWrite(S5LED, LOW);
        noTone(Buzzer);

        delay(500);
        i++;
      }
      digitalWrite(S1LED, HIGH);

      digitalWrite(S2LED, HIGH);
      digitalWrite(S3LED, HIGH);
      digitalWrite(S4LED,
  HIGH);
      digitalWrite(S5LED, HIGH);
      digitalWrite(S6LED, HIGH);

      tone(Buzzer, NOTE_G5);
      delay(500);
      digitalWrite(S1LED, LOW);

      digitalWrite(S2LED, LOW);
      digitalWrite(S3LED, LOW);
      digitalWrite(S4LED,
  LOW);
      digitalWrite(S5LED, LOW);
      digitalWrite(S6LED, LOW);

      noTone(Buzzer);
      digitalWrite(S6LED, HIGH);
      delay(30);

      digitalWrite(S1LED, HIGH);
      delay(30);
      digitalWrite(S2LED,
  HIGH);
      delay(30);
      digitalWrite(S3LED, HIGH);
      delay(30);

      digitalWrite(S4LED, HIGH);
      delay(30);
      digitalWrite(S5LED,
  HIGH);
      delay(30);
      digitalWrite(S6LED, LOW);
      delay(30);

      digitalWrite(S1LED, LOW);
      delay(30);
      digitalWrite(S2LED,
  LOW);
      delay(30);
      digitalWrite(S3LED, LOW);
      delay(30);

      digitalWrite(S4LED, LOW);
      delay(30);
      digitalWrite(S5LED,
  LOW);
      delay(30);
      goto Start;
    }
  }

  else if
  (potVal < 145) {
    //Spieler 1
    if (switchStateS1 == HIGH) {
      //Ton
  bei Druck
      digitalWrite(S1LED, HIGH);
      tone(Buzzer, NOTE_G4, 35);

      delay(35);
      tone(Buzzer, NOTE_G5, 35);
      delay(35);
      tone(Buzzer,
  NOTE_G6, 35);
      delay(35);
      noTone(Buzzer);
      delay(dauerGesamt
  * 1000);
      digitalWrite(S1LED, LOW);
    }
  }

  //Spieler 2

  if (switchStateS2 == HIGH) {
    digitalWrite(S2LED, HIGH);
    //Ton bei
  Druck
    tone(Buzzer, NOTE_B5, 100);
    delay(100);
    tone(Buzzer,
  NOTE_E6, 700);
    delay(700);
    noTone(Buzzer);
    delay(dauerGesamt
  * 1000);
    digitalWrite(S2LED, LOW);
  }


  //Spieler 3
  if
  (switchStateS3 == HIGH) {
    digitalWrite(S3LED, HIGH);
    for (int hz =
  2000; hz > 440; hz--) {
      tone(Buzzer, hz, 50);
      delay(0.5);

    }
    delay(dauerGesamt * 1000);
    digitalWrite(S3LED, LOW);
  }



  //Spieler 4
  if (switchStateS4 == HIGH) {
    digitalWrite(S4LED, HIGH);

    tone(Buzzer, NOTE_C7, 115);
    delay(125);
    tone(Buzzer, NOTE_C7,
  240);
    delay(250);
    tone(Buzzer, NOTE_C7, 240);
    delay(250);

    tone(Buzzer, NOTE_GS6, 115);
    delay(125);
    tone(Buzzer, NOTE_C7,
  240);
    delay(250);
    tone(Buzzer, NOTE_DS7, 115);
    delay(125);

    noTone(Buzzer);
    delay(dauerGesamt * 1000);
    digitalWrite(S4LED,
  LOW);

  }



  //Spieler 5
  if (switchStateS5 == HIGH) {

    digitalWrite(S5LED, HIGH);
    tone(Buzzer, NOTE_E6, 125);
    delay(125);

    tone(Buzzer, NOTE_G6, 125);
    delay(125);
    tone(Buzzer, NOTE_E7,
  125);
    delay(125);
    tone(Buzzer, NOTE_C7, 125);
    delay(125);

    tone(Buzzer, NOTE_D7, 125);
    delay(125);
    tone(Buzzer, NOTE_G7,
  125);
    delay(125);
    noTone(Buzzer);
    delay(dauerGesamt * 1000);

    digitalWrite(S5LED, LOW);
  }



  //Spieler 6
  if (switchStateS6
  == HIGH) {
    digitalWrite(S6LED, HIGH);
    for (int hz = 440; hz < 1000;
  hz++) {
      tone(Buzzer, hz, 50);
      delay(0.75);
    }
    delay(dauerGesamt
  * 1000);
    digitalWrite(S6LED, LOW);
  }



}

Downloadable files

6 Player Buzzer Game

Schematic in Fritzing

6 Player Buzzer Game

Schematic in png

6 Player Buzzer Game

Schematic in Fritzing

6 Player Buzzer Game

Comments

Only logged in users can leave comments

renzosmania

0 Followers

•

0 Projects

Intro