2 Buzzer Diferent Void Tone How Pls

Other Hardware Audio
1

I am trying to put 2 buzzers with different rhythms but at the beginning only one sounds until that one ends the other sounds can you tell me how to make them sound at the same time pls ;c



//Chased JoJo Opening

void song(int buzzerPin=11){
  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 247);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 247);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 247);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 247);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 277);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 277);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 277);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 277);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 587);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 587);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 587);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 587);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 587);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 587);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 330);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 92);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 92);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 92);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 92);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 92);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 92);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 92);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 92);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 123);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 131);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 131);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 131);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 131);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 587);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 659);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 740);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 659);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 587);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 587);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 659);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 740);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 185);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 659);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 587);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 165);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 220);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 220);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 587);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 175);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 92);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 92);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 587);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 554);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 147);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 494);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 139);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 92);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 92);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 370);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 415);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 104);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 440);
  delay(165);
  noTone(buzzerPin);

  tone(buzzerPin, 110);
  delay(165);
  noTone(buzzerPin);
}
void song2 (int buzzerPin2=9){
  tone(buzzerPin2, 139);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 220);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 139);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 220);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 139);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 220);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 220);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 139);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 139);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 65);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 82);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 220);
  delay(165);
  noTone(buzzerPin2);

  tone(buzzerPin2, 117);
  delay(165);
  noTone(buzzerPin2);
}

void setup() {
  // put your setup code here, to run once:
  // call the song function with digital pin
  song(11); 
  song2(9);
  
}



void loop() {

}
2

Welcome to the forum

See Using millis() for timing. A beginners guide, Several things at the same time and the BlinkWithoutDelay example in the IDE

3

@chronustempo
Please read the reference about the tone() function:

Note this:

Only one tone can be generated at a time. If a tone is already playing on a different pin, the call to tone() will have no effect.

4

whats is imposible get 2 tone in diferent buzzer ?

5

Using the tone function - not possible

6

exist other function for use or not ?

7

I do not know such function, but you can look in the google.
Or you can write it yourself using the hardware timer.

But after the problem with function will solved, you will faced with the next issue, described in post#2. Your song functions are blocks each other, you must rewrite it in non-blocking style using the millis()

8

Hi @chronustempo,

What is the overall and final purpose of the buzzing?

Do you just need two signals at a different interval or does it have to be different frequencies?
Have you considered using active buzzers to which you only give power and then they can buzz themselve?

have you considered using a different microcontroller like an ESP32?
https://www.aurorasky.net/html/4_channel_generator.html

You could setup a timer-interrupt at a high frequency as a "basefrequency" and then toggle two pins at different freqeuncies through counting up a variable and each time the variable reaches a certain value toggle IO-pin.

such a timer-isr can run at 20 kHz which would create a maximum frequency of 10 kHz by toggling a pin.
next frequencies would be
count up to 2 f=5 kHz,
count up to 3 f=3,3 kHz,
count up to 4 f=2,5 kHz,
count up to 5 f=2,0 kHz,
count up to 6 f=1,6 kHz,
etc.

a microcontroller called parallax propeller-chip has 8 cores which could be used to create 7 independent frequencies as each core can run his own code completely independant and in parallel to the others.

or a teensy 4.0 / 4.1 microcontroller very fast clock 600 MHz so the timer-interrupt can run at a much higher frequency of 250 kHz and counting up / frequency divider starts from 125 kHz.
best regards Stefan

9

Please don't confuse newbies, this controller is not available in arduino environment.
Moreover, first try to create something on it yourself, and then advise.

10

propeller-chip code in programming language SPIN

code for playing a two-voice piece of music on piezo-buzzers

''This code example is from Propeller Education Kit Labs: Fundamentals, v1.2.
''A .pdf copy of the book is available from www.parallax.com, and also through
''the Propeller Tool software's Help menu (v1.2.6 or newer).
''
''TwoTones.spin
''Play individual notes with each piezospeaker, then play notes with both at the
''same time.

CON
   
  _clkmode = xtal1 + pll16x                  ' System clock → 80 MHz
  _xinfreq = 5_000_000


OBJ

  SqrWave : "SquareWave"


PUB PlayTones | index, pin, duration

  'Initialize counter modules
  repeat index from 0 to 1
    pin := byte[@pins][index]
    spr[8 + index] := (%00100 << 26) + pin
    dira[pin]~~

  'Look up tones and durations in DAT section and play them.
  repeat index from 0 to 4
    frqa := SqrWave.NcoFrqReg(word[@Anotes][index])
    frqb := SqrWave.NcoFrqReg(word[@Bnotes][index])
    duration := clkfreq/(byte[@durations][index])
    waitcnt(duration + cnt)  


DAT
pins       byte  27, 3

'index           0        1        2        3        4 
durations  byte  1,       2,       1,       2,       1
anotes     word  1047,    0,       0,       0,       1047
bnotes     word  0,       0,       1319,    0,       1319

a propeller-chip can do things other microcontrollers can only dream of
4 voice vocal synthetisation

{{
***************************************
*  Singing Demo v1.0                  *
*  Author: Chip Gracey                *
*  Copyright (c) 2006 Parallax, Inc.  *
*  See end of file for terms of use.  *
***************************************

This is a quick demo which runs 4 VocalTract objects concurrently to sing a 4-part harmony from the 16th century.
It also uses the StereoSpatializer object (which is very under-utilized here) to spread them out into a stereo image.
This runs on the Propeller Demo Board, but really just modulates pin 11 and 10 for the left and right audio signals.
If you have a Propeller Demo Board, just plug in some headphones or speakers. After the song is over, it stops.
}}


CON

  _clkmode = xtal1 + pll16x
  _xinfreq = 5_000_000

  #0
  
' Notes and octaves
'
' Ab       A       A#       Bb       B       C       C#       Db       D       D#       Eb       E       F       F#       Gb       G       G#
'─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  o0Af[4], o0A[4], o0As[0], o0Bf[4], o0B[4], o0C[4], o0Cs[0], o0Df[4], o0D[4], o0Ds[0], o0Ef[4], o0E[4], o0F[4], o0Fs[0], o0Gf[4], o0G[4], o0Gs[0] 
  o1Af[4], o1A[4], o1As[0], o1Bf[4], o1B[4], o1C[4], o1Cs[0], o1Df[4], o1D[4], o1Ds[0], o1Ef[4], o1E[4], o1F[4], o1Fs[0], o1Gf[4], o1G[4], o1Gs[0] 
  o2Af[4], o2A[4], o2As[0], o2Bf[4], o2B[4], o2C[4], o2Cs[0], o2Df[4], o2D[4], o2Ds[0], o2Ef[4], o2E[4], o2F[4], o2Fs[0], o2Gf[4], o2G[4], o2Gs[0] 
  o3Af[4], o3A[4], o3As[0], o3Bf[4], o3B[4], o3C[4], o3Cs[0], o3Df[4], o3D[4], o3Ds[0], o3Ef[4], o3E[4], o3F[4], o3Fs[0], o3Gf[4], o3G[4], o3Gs[0] 
  o4Af[4], o4A[4], o4As[0], o4Bf[4], o4B[4], o4C[4], o4Cs[0], o4Df[4], o4D[4], o4Ds[0], o4Ef[4], o4E[4], o4F[4], o4Fs[0], o4Gf[4], o4G[4], o4Gs[0] 
  o5Af[4], o5A[4], o5As[0], o5Bf[4], o5B

  #1, pausenote, halfnote

  'names of vocal tract parameters as offsets for indirectly accessing 4 sets
  #0, aa,ga,gp,vp,vr,f1,f2,f3,f4,na,nf,fa,ff

  shift = -24                   'this pitch shift may be changed: try 0 (normal), -48 (-1 octave), -4 (-1 key)
  
  buffer_size = $1000           'this may be reduced to $10 to save memory, but echoes go away


OBJ

  v[4]    : "VocalTract"
  stereo  : "StereoSpatializer"


VAR

  byte  vt[4*13]      'vocal tracts
   
  word  input[4]      'spatializer parameters
  word  angle[4]
  word  depth[4]
  word  knobs

  long  state[4], rnd

  long  buffer[buffer_size]


PUB start | i

  repeat i from 0 to 3
    v[i].start(@vt[i*13], -1, -1, -1)   'start a vocal tract
    v[i].set_attenuation(1)            
    input[i] := v[i].sample_ptr         'set spatializer inputs
    angle[i] := i * $5555               'spread out channels evenly across sound stage

  knobs := %000_110_110_000             'set spatializer echoes
  stereo.start(@input, @buffer, buffer_size, 11, -1, 10, -1) 'start spatializer

  set_formants(0, 275, 850, 2400, 3520) 'set each vocal tract to a different vowel sound
  set_formants(1, 700, 1800, 2550, 3400)
  set_formants(2, 280, 2040, 3040, 3600)
  set_formants(3, 650, 1200, 2500, 3500)

  repeat i from 0 to 3
    set(i, vp, 4)                       'set vibrato pitch range                
    set(i, vr, lookupz(i: 66,68,71,75)) 'give each vocal tract a slightly different vibrato rate
    go(i, 1000 + ?rnd ~> 24)            'let each vocal tract slide to formants while silent, plus randomize start times                
    v[i].set_pace(100)                  'try changing the pace from 100% to higher and lower values (ie 50, 200)

  repeat
    advance(0)   'basso                 'try commenting out some of these lines to hear fewer parts
    advance(1)   'tenor                       
    advance(2)   'alto
    advance(3)   'soprano


PRI set_formants(tract, sf1, sf2, sf3, sf4)

  vt[tract*13+f1] := sf1 / 19
  vt[tract*13+f2] := sf2 / 19
  vt[tract*13+f3] := sf3 / 19
  vt[tract*13+f4] := sf4 / 19
  

PRI set(tract, parameter, value)

  vt[tract*13+parameter] := value
  

PRI get(tract, parameter) : value

  return vt[tract*13+parameter]
  

PRI go(tract, time)

  v[tract].go(time)


PRI advance(tract) | note, vol, time

  if state[tract] == -1
    return

  vol := volume[tract]          'get volume for each vocal tract
  if note := byte[@@parts[tract]][state[tract]++]
    set(tract, gp, note & $FC + shift)
    if note & 1                 'pausenote
      set(tract, ga, vol)
      go(tract, 200)
      go(tract, 1000)     
      set(tract, ga, 0)
      go(tract, 500)
      go(tract, 750)
    elseif note & 2             'halfnote
      set(tract, ga, vol)
      go(tract, 200)
      go(tract, 50)
      go(tract, 200)     
      go(tract, 50)
    else                        'normal
      time := 200
      ifnot get(tract, ga)
        go(tract, 2)
        time := 500
      set(tract, ga, vol)
      go(tract, time)
      go(tract, 1000 - time + ?rnd ~> 27)
  else
    set(tract, ga, 0)           'end of notes
    go(tract, 200)
    go(tract, 2000)
    state[tract]~~

    
DAT

soprano byte o3G
        byte o3G                'measure
        byte o3Fs
        byte o3E
        byte o3D
        byte o3G                'measure
        byte o4A
        byte o4B + pausenote
        byte o4B
        byte o4B                'measure
        byte o4B
        byte o4A
        byte o3G
        byte o4C                'measure
        byte o4B
        byte o4A + pausenote
        byte o3G
        byte o4A                'measure
        byte o4B
        byte o4A
        byte o3G
        byte o3E                'measure
        byte o3Fs
        byte o3G + pausenote
        byte o4D
        byte o4B                'measure
        byte o3G
        byte o4A
        byte o4C
        byte o4B                'measure
        byte o4A
        byte o3G + pausenote
        byte 0
        
alto    byte o3D
        byte o3D                'measure
        byte o3D
        byte o3B
        byte o3B
        byte o3B                'measure
        byte o3D
        byte o3D + pausenote
        byte o3D
        byte o3D                'measure
        byte o3D
        byte o3D
        byte o3B
        byte o3E                'measure
        byte o3D
        byte o3D + pausenote
        byte o3B
        byte o3D                'measure
        byte o3D
        byte o3D
        byte o3D
        byte o3C                'measure
        byte o3C
        byte o3D + pausenote
        byte o3D
        byte o3D                'measure
        byte o3E
        byte o3Fs
        byte o4A
        byte o3G                'measure
        byte o3Fs
        byte o3D + pausenote
        byte 0

tenor   byte o3B
        byte o3B                'measure
        byte o3A
        byte o2G
        byte o2Fs
        byte o2G                'measure
        byte o2Fs
        byte o2G + pausenote
        byte o2G
        byte o2G                'measure
        byte o2G
        byte o2Fs
        byte o2G
        byte o2G                'measure
        byte o2G
        byte o2Fs + pausenote
        byte o2G
        byte o2Fs               'measure
        byte o2G
        byte o2Fs
        byte o2G
        byte o2G                'measure
        byte o3A
        byte o3B + pausenote
        byte o3B
        byte o2G                'measure
        byte o3B
        byte o3D
        byte o3E
        byte o3D                'measure
        byte o3D + halfnote
        byte o3C + halfnote
        byte o3B + pausenote
        byte 0

basso   byte o2G
        byte o2G                'measure
        byte o2D
        byte o2E
        byte o2B
        byte o2E                'measure
        byte o2D
        byte o2G + pausenote
        byte o2G
        byte o1G                'measure
        byte o2B
        byte o2D
        byte o2E
        byte o2C                'measure
        byte o1G
        byte o2D + pausenote
        byte o2E
        byte o2D                'measure
        byte o2G
        byte o2D
        byte o2B
        byte o2C + halfnote     'measure
        byte o2B + halfnote
        byte o2A
        byte o1G + pausenote
        byte o2G
        byte o2G                'measure
        byte o2E
        byte o2D
        byte o2A
        byte o2B + halfnote     'measure
        byte o2C + halfnote
        byte o2D
        byte o1G
        byte 0

parts   word @basso, @tenor, @alto, @soprano

volume  byte 50-10, 120-40, 170-35, 60-10

{{
┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│                                                   TERMS OF USE: MIT License                                                  │                                                            
├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation    │ 
│files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy,    │
│modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software│
│is furnished to do so, subject to the following conditions:                                                                   │
│                                                                                                                              │
│The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.│
│                                                                                                                              │
│THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE          │
│WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR         │
│COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,   │
│ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                         │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
}}```
11

And what does that prove? Are you suggesting that OP learn another programming language for it?
The problem of two tones is easily solved on any controller with a hard timer, no 8 cores are required here.

12

there is more than arduino. If you have learned one programming lnaguage learning a second is 5 times faster

13

Do you have any ideas why this perfect chip does not conquered the world yet? From the 2006? :slight_smile:

14

the more detailed you describe the real project and the finalpurpose of the two tone buzzing the better suggestions can be made how to achieve this purpose

15

because there are so many people like you that rather stick to what they know instead of learning something new. Most people have read - what ? no interrupts - and turned away instead of studying the controller more in detail

16

There are many programmers who have been programming for years, do not even know one language. For example, do not understand pointers in C

17

emphasizes what I'm saying. Rather stick to what they know instead of learning something new.
Additionally high advanced software-developpers are very bad teachers. Beaten with a lot of expert-blindness for beginner difficulties

18

If you're using an ESP32, its possible to use multiple buzzers (up to 16). The tone and note function in this library is non-blocking.

I haven't created an example with multiple buzzers yet ... something to try though.

19

I don't think this will mean much to someone who refers to "Void Tone".

20

Two libraries that can help:

"Tone by Brett Hagman"

"ToneLibrary by Brett Hagman, Daniel Centore"

You can install them with Library Manager (Tools -> Manage libraries...)