Bouw Je Eigen Elektronisch Pianotoetsenbord met Ingebouwde Liedjes

Onderdelen en benodigdheden

Over dit project

Introductie

Om te beginnen: ik ben volledig nieuw in de wereld van elektronica. Ik heb een redelijke achtergrond in programmeren, wat helpt, maar ik sta altijd open voor nieuwe ideeën en suggesties voor mijn projecten.

Onlangs heb ik meer leren kennen over de Piezo Buzzer en de betrokken programmering, en dit is mijn creatie op basis van wat ik tot nu toe heb geleerd. Er is nog veel ruimte voor uitbreiding met nieuwe functies of schakelaars, wat ik later van plan ben, maar voor nu: op naar de volgende uitdaging!

Hieronder zie je een video van hoe het apparaat werkt, inclusief het menu met vooraf geprogrammeerde liedjes. Ik geef toe: technisch gezien zijn liedje 4 en 5 hetzelfde, maar wat kan ik zeggen, ik heb de drang om grotere en betere dingen te creëren en het schrijven van de muziekcode voor meer liedjes was er geen! De basiscode voor zowel de hoofdlus als de individuele liedjeslussen is eenvoudig aan te passen aan je eigen ideeën, dus voel je vrij om alles te veranderen zoals je fit ziet.

Zie het in actie!

[Video zou hier getoond worden]

De hardware instellen

De pianotoetsen...

De pianotoetsenschakelaars zijn aangesloten via een weerstandsladder. De weerstanden zijn in opeenvolgende volgorde geplaatst, waarbij elke schakelaar met de voeding verbonden is. Voor mijn project heb ik gekozen voor (in ohm) 1M, 10k, 4,7k, 1k, 560 en 220. De eerste pianotoets (links) is verbonden met de voeding en ook met de volgende schakelaar in de schakeling. De tweede schakelaar is verbonden met de kleinste weerstand, en elke volgende schakelaar verbindt met de volgende grootste weerstand in de reeks. De laatste schakelaar sluit de verbinding af naar de grond via een 10k ohm weerstand en verbindt alle 7 schakelaars met de "analog in" pin A0 op de Arduino. De hooftsketch definieert welke frequenties bij elke pianotoets horen. Voor dit project gebruikte ik C4, D4, E4, F4, G4, A4 & B4, met C4 als de linkerste schakelaar. Verander de frequentiewaarden of voeg extra schakelaars toe om je project volledig aan te passen!

Het LCD-scherm...

Verbind de LCD-pinnen volgens het onderstaande schakelingsschema. Verbind LCD-pin 3 met de potentiometer voor contrastregeling van het scherm. De buitenpinnen van de potentiometer zijn verbonden met voeding en grond om deze schakeling te voltooien. LCD-pin 15 is verbonden met de voeding via een 220 ohm weerstand. Als een van deze pinnen in je eigen project wijzigt, pas de code dan dienovereenkomstig aan.

De menuknop...

Verbind de menuknop met de voeding en sluit hem af naar de grond via een 10k ohm weerstand. Deze schakelaar moet ook verbonden zijn met pin 7 op de Arduino zodat je hem via code kunt besturen.

De LED...

De LED geeft aan wanneer je in de "menumodus" bent en de pianotoetsen zijn uitgeschakeld. De LED gaat branden zodra de menuknop wordt ingedrukt. Verbind de anode (positief) van de LED met pin 6 van de Arduino, en sluit de LED af naar de grond via een 220 ohm weerstand.

De Piezo buzzer...

Om de Piezo Buzzer te integreren, verbind je één einde met Arduino-pin 8 en de andere kant naar de grond via een 220 ohm weerstand. De tone-functie in de code zoekt deze pin om de aangevraagde noot te spelen.

Hoe de code werkt

De setup...

• De sketch begint met het importeren van de "LiquidCrystal.h" en "pitches.h" bibliotheken zodat we later in de code naar verschillende items uit deze bibliotheken kunnen refereren.
• Vervolgens wordt de code ingesteld door een naam te definiëren voor de menuknop, te bepalen welke pinnen inputs en outputs zijn, en de frequentiewaarden in te stellen voor elk van de 7 pianotoetsen.
• Er is een nieuw tabblad aangemaakt voor elk individueel liedje om de code georganiseerd en begrijpelijk te houden, en om later uit te breiden. Als je liedjes wilt verwijderen of toevoegen, zorg dan dat je de code in de hoofsketch "Electronic Keyboard" ook aanpast.

De hoofdlus...

• Het toetsenbord begint met de LED uitgeschakeld en alle pianotoetsen actief.
• Zodra de lus detecteert dat de menuknop is ingedrukt, schakelt hij de pianotoetsen uit en zet de LED aan om aan te geven dat je in de "menumodus" bent.

Het menu openen...

• Druk op de menuknop om door de beschikbare liedjes te bladeren, en druk op een van de pianotoetsen om het op het LCD-scherm getoonde liedje te starten.
• Het LCD-scherm toont welk liedje er wordt gespeeld, en keert daarna terug naar hetzelfde punt in het menu zodra het liedje afgelopen is. Vanaf daar kun je het liedje opnieuw spelen of doorgaan met de lijst met beschikbare liedjes.
• Dubbelklikken op de menuknop start het menu opnieuw vanaf het begin.
• Om terug te keren naar het gebruik van de pianotoetsen, blader je door de resterende liedjes in het menu. Zodra het LCD-scherm leeg is en de LED uit is, werken de pianotoetsen weer.

Code

• Electronic Keyboard (hoofdcode)
• Song1
• Song2
• Song3
• Song4
• Song5
• pitches.h

Electronic Keyboard Arduino

De hoofdcode:

// LCD-scherm, Schakelaar & LED Setup
#include <LiquidCrystal.h>
#include "pitches.h"
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
const int LCDswitchPin = 7; // definieer menu/LCD-schakelaar naam
int LCDswitchState = 0; // zet menu/LCD-schakelaar status op uit/laag
int prevLCDswitchState = 0;
int blueLED = 6;
int LCDswitchCounter = 0; // teller voor aantal menuknop indrukken
// (deze code telt de menuknop indrukken, toont ze op je computer,
// en begint weer bij nul na het beëindigen van "menumodus". Heeft momenteel
// geen ander effect op deze sketch, maar is een goed startpunt voor het
// later uitbreiden van het project met nieuwe functies)
// Muzieknoot Toetsen - Stel frequentiewaarden in
int notes[] = {262, 294, 330, 349, 392, 440, 494}; // Noten C, D, E, F, G, A, B
////////////////////////////////////////////////
void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);
  pinMode(LCDswitchPin, INPUT);
  pinMode(blueLED, OUTPUT);
  digitalWrite(blueLED, LOW); // LED blijft uit terwijl pianotoetsen aan staan
} // einde setup
////////////////////////////////////////////////
void loop() {
  LCDswitchState = digitalRead(LCDswitchPin);
  int keyVal = analogRead(A0);
  Serial.println(keyVal);
  lcd.noDisplay();
  digitalWrite(blueLED, LOW); // Zet LED elke keer uit wanneer hoofdlus start
  // ************** START "LCDstart" WANNEER MENUKNOP INGEDRUKT WORDT ***********
  if (LCDswitchState == HIGH) {
    digitalWrite(blueLED, HIGH); // Zet LED aan om te tonen dat pianotoetsen uitgeschakeld zijn en apparaat in "menumodus" is
    lcd.display();
    lcd.clear();
    LCDstart();
  }
  // ***********************************************************************
  ////// TOETSENBORD NOTEN & FREQUENTIE INSTRUCTIES //////
  // Gebruik de weerstandsladder die je hebt gemaakt om de spanning van elke pianotoets te veranderen
  // 220 ohm = C5
  // 560 ohm = D5
  // 1K ohm = E5
  // etc...
  if(keyVal == 1023) {
    tone(8, notes[0]); // C
  } // einde if
  else if(keyVal >= 990 && keyVal <= 1010) {
    tone(8, notes[1]); // D
  } // einde else if
  else if(keyVal >= 960 && keyVal <= 980) {
    tone(8, notes[2]); // E
  } // einde else if
  else if(keyVal >= 900 && keyVal <= 945) {
    tone(8, notes[3]); // F
  } // einde else if
  else if(keyVal >= 650 && keyVal <= 710) {
    tone(8, notes[4]); // G
  } // einde else if
  else if(keyVal >= 500 && keyVal <= 550) {
    tone(8, notes[5]); // A
  } // einde else if
  else if(keyVal >= 5 && keyVal <= 10) {
    tone(8, notes[6]); // B
  } // einde else if
  else if(keyVal <= 1) {
    // als geen schakelaar is ingedrukt, speel geen toon
    noTone(8);
  } // einde else if
} // einde frequentie toon lus
/////////////////////////////////////////////////////
void LCDstart() {
  int keyVal = analogRead(A0);
  LCDswitchState = digitalRead(LCDswitchPin); // controleer status van menuknop
  while (LCDswitchState == LOW) { // blijf lussen zolang menuknop niet ingedrukt is
    LCDswitchState = digitalRead(LCDswitchPin); // controleer status menuknop elke keer dat lus start
    //************* START LIEDJE 1 TITEL LUS ********************
    if (LCDswitchState == HIGH) { // als menuknop ingedrukt is, dan...
      LCDswitchCounter++; // zet knopteller op 1
      Serial.print("aantal knopindrukken: ");
      Serial.println(LCDswitchCounter);
      delay(300); // min. tijd tot teller 1 meer optelt
      Song1title();
      lcd.clear();
      break;
    }
    //************* ANDERS TOON MENU ****************
    else {
      // als menuknop niet ingedrukt is
      LCDswitchCounter = 0; // zet menuknopteller op 0
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("WELK LIEDJE WIL");
      lcd.setCursor(0, 1);
      lcd.print("JE SPELEN");
      delay(50); // terug naar main
    }
  } // einde while
} // einde LCDstart lus
// ************* LIEDJE 1 LUS START HIER **************
void Song1title() {
  int keyVal = analogRead(A0);
  LCDswitchState = digitalRead(LCDswitchPin); // controleer status menuknop opnieuw
  while (LCDswitchState == LOW) { // blijf lussen zolang menuknop niet ingedrukt is
    LCDswitchState = digitalRead(LCDswitchPin); // controleer status menuknop opnieuw
    //************* START LIEDJE 2 TITEL LUS ********************
    if (LCDswitchState == HIGH) { // als menuknop ingedrukt is, dan...
      LCDswitchCounter++; // zet knopteller op 2
      Serial.print("aantal knopindrukken: ");
      Serial.println(LCDswitchCounter);
      delay(300); // min. tijd tot teller 1 meer optelt
      Song2title();
      lcd.clear();
      break;
    } else {
      // als menuknop niet ingedrukt is
      int keyVal = analogRead(A0);
      Serial.println(keyVal);
      if(keyVal >= 2) {
        digitalWrite(blueLED, LOW);
        Song1();
        break;
      } // einde if
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("SUPER MARIO BROS");
      lcd.setCursor(0, 1);
      lcd.print(" THEME SONG");
      delay(50);
    }
  } // einde while liedje 1 -> 2
} // einde Song1title lus
// ************* LIEDJE 2 LUS START HIER **************
void Song2title() {
  int keyVal = analogRead(A0);
  LCDswitchState = digitalRead(LCDswitchPin); // controleer status menuknop opnieuw
  while (LCDswitchState == LOW) { // blijf lussen zolang menuknop niet ingedrukt is
    LCDswitchState = digitalRead(LCDswitchPin); // controleer status menuknop opnieuw
    //************* START LIEDJE 3 TITEL LUS ********************
    if (LCDswitchState == HIGH) { // als menuknop ingedrukt is, dan...
      LCDswitchCounter++; // zet knopteller op 3
      Serial.print("aantal knopindrukken: ");
      Serial.println(LCDswitchCounter);
      delay(300); // min. tijd tot teller 1 meer optelt
      Song3title();
      lcd.clear();
      break;
    } else {
      // als menuknop niet ingedrukt is
      int keyVal = analogRead(A0);
      Serial.println(keyVal);
      if(keyVal >= 2) {
        digitalWrite(blueLED, LOW);
        Song2();
        break;
      } // einde if
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("SUPER MARIO BROS");
      lcd.setCursor(0, 1);
      lcd.print(" UNDERWORLD");
      delay(50);
    }
  } // einde while liedje 2 -> 3
} // einde Song2title lus
// ************* LIEDJE 3 LUS START HIER **************
void Song3title() {
  int keyVal = analogRead(A0);
  LCDswitchState = digitalRead(LCDswitchPin); // controleer status menuknop opnieuw
  while (LCDswitchState == LOW) { // blijf lussen zolang menuknop niet ingedrukt is
    LCDswitchState = digitalRead(LCDswitchPin); // controleer status menuknop opnieuw
    //************* START LIEDJE 4 TITEL LUS ********************
    if (LCDswitchState == HIGH) { // als menuknop ingedrukt is, dan...
      LCDswitchCounter++; // zet knopteller op 4
      Serial.print("aantal knopindrukken: ");
      Serial.println(LCDswitchCounter);
      delay(300); // min. tijd tot teller 1 meer optelt
      Song4title();
      lcd.clear();
      break;
    } else {
      // als menuknop niet ingedrukt is
      int keyVal = analogRead(A0);
      Serial.println(keyVal);
      if(keyVal >= 2) {
        digitalWrite(blueLED, LOW);
        Song3();
        break;
      } // einde if
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(" JEOPARDY");
      lcd.setCursor(0, 1);
      lcd.print(" THEME SONG");
      delay(50);
    }
  } // einde while liedje 3 -> 4
} // einde Song3title lus
// ************* LIEDJE 4 LUS START HIER **************
void Song4title() {
  int keyVal = analogRead(A0);
  LCDswitchState = digitalRead(LCDswitchPin); // controleer status menuknop opnieuw
  while (LCDswitchState == LOW) { // blijf lussen zolang menuknop niet ingedrukt is
    LCDswitchState = digitalRead(LCDswitchPin); // controleer status menuknop opnieuw
    //************* START LIEDJE 5 TITEL LUS ********************
    if (LCDswitchState == HIGH) { // als menuknop ingedrukt is, dan...
      LCDswitchCounter++; // zet knopteller op 5
      Serial.print("aantal knopindrukken: ");
      Serial.println(LCDswitchCounter);
      delay(300); // min. tijd tot teller 1 meer optelt
      Song5title();
      lcd.clear();
      break;
    } else {
      // als menuknop niet ingedrukt is
      int keyVal = analogRead(A0);
      Serial.println(keyVal);
      if(keyVal >= 2) {
        digitalWrite(blueLED, LOW);
        Song4();
        break;
      } // einde if
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(" LIEDJE 4");
      lcd.setCursor(0, 1);
      lcd.print(" TITEL HIER");
      delay(50);
    }
  } // einde while liedje 4 -> 5
} // einde Song4title lus
// ************* LIEDJE 5 LUS START HIER **************
void Song5title() {
  int keyVal = analogRead(A0);
  LCDswitchState = digitalRead(LCDswitchPin); // controleer status menuknop opnieuw
  while (LCDswitchState == LOW) { // blijf lussen zolang menuknop niet ingedrukt is
    LCDswitchState = digitalRead(LCDswitchPin); // controleer status menuknop opnieuw
    //************* START LIEDJE 4 TITEL LUS ********************
    if (LCDswitchState == HIGH) { // als menuknop ingedrukt is, dan...
      LCDswitchCounter = 0; // zet knopteller op 0
      Serial.print("aantal knopindrukken: ");
      Serial.println(LCDswitchCounter);
      delay(300); // min. tijd tot teller 1 meer optelt
      lcd.clear();
    } else {
      // als menuknop niet ingedrukt is
      int keyVal = analogRead(A0);
      Serial.println(keyVal);
      if(keyVal >= 2) {
        digitalWrite(blueLED, LOW);
        Song5();
        break;
      } // einde if
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(" LIEDJE 5");
      lcd.setCursor(0, 1);
      lcd.print(" TITEL HIER");
      delay(50);
    }
  } // einde while liedje 4 -> 5
} // einde Song5title lus

Song1 Arduino

Code voor het 1e liedje. Bevat momenteel het Mario Bros Theme Song.

//***************** LIEDJE 1 NOTEN HIER **************************
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////// VOLLEDIGE TUTORIAL VOOR HET MAKEN VAN DE MARIO LIEDJES VIND JE HIER: /////////////////////////
///////// https://www.linuxcircle.com/2013/03/31/playing-mario-bros-tune-with-arduino-and-piezo-buzzer/ ///////////////////////////////////////////////////////////////////////////////////////////////////////
void Song1() {
  lcd.clear();
  // noten in de melodie:
  int melody[] = { NOTE_E7, NOTE_E7, 0, NOTE_E7, 0, NOTE_C7, NOTE_E7, 0, NOTE_G7, 0, 0, 0, NOTE_G6, 0, 0, 0, NOTE_C7, 0, 0, NOTE_G6, 0, 0, NOTE_E6, 0, 0, NOTE_A6, 0, NOTE_B6, 0, NOTE_AS6, NOTE_A6, 0, NOTE_G6, NOTE_E7, NOTE_G7, NOTE_A7, 0, NOTE_F7, NOTE_G7, 0, NOTE_E7, 0, NOTE_C7, NOTE_D7, NOTE_B6, 0, 0, NOTE_C7, 0, 0, NOTE_G6, 0, 0, NOTE_E6, 0, 0, NOTE_A6, 0, NOTE_B6, 0, NOTE_AS6, NOTE_A6, 0, NOTE_G6, NOTE_E7, NOTE_G7, NOTE_A7, 0, NOTE_F7, NOTE_G7, 0, NOTE_E7, 0, NOTE_C7, NOTE_D7, NOTE_B6, 0, 0 };
  // nootduur: 4 = kwartnoot, 8 = achtste noot, etc.:
  int noteDurations[] = { 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 9, 9, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 9, 9, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, };
  lcd.setCursor(1, 0);
  lcd.print("Nu aan het spelen...");
  lcd.setCursor(0, 1);
  lcd.print("MARIO THEME SONG");
  int size = sizeof(melody) / sizeof(int);
  for (int thisNote = 0; thisNote < size; thisNote++) {
    // om de nootduur te berekenen, deel één seconde
    // door het noottype. bv. kwartnoot = 1000 / 4, achtste noot = 1000/8, etc.
    int noteDuration = 1000 / noteDurations[thisNote];
    tone(8, melody[thisNote], noteDuration);
    // om de noten te onderscheiden, stel een minimumtijd tussen ze in.
    // de nootduur + 30% werkt goed:
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    // stop de toon:
    tone(8, 0, noteDuration);
  }
  Song1title();
} // einde Song1 lus

Song2 Arduino

Code voor het 2e liedje. Bevat momenteel het Mario Bros Underworld Song.

//***************** LIEDJE 2 NOTEN HIER **************************
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////// VOLLEDIGE TUTORIAL VOOR HET MAKEN VAN DE MARIO LIEDJES VIND JE HIER: /////////////////////////
///////// https://www.linuxcircle.com/2013/03/31/playing-mario-bros-tune-with-arduino-and-piezo-buzzer/ ///////////////////////////////////////////////////////////////////////////////////////////////////////
void Song2() {
  lcd.clear();
  // noten in de melodie:
  int melody[] = { NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4, NOTE_AS3, NOTE_AS4, 0, 0, NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4, NOTE_AS3, NOTE_AS4, 0, 0, NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4, NOTE_DS3, NOTE_DS4, 0, 0, NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4, NOTE_DS3, NOTE_DS4, 0, 0, NOTE_DS4, NOTE_CS4, NOTE_D4, NOTE_CS4, NOTE_DS4, NOTE_DS4, NOTE_GS3, NOTE_G3, NOTE_CS4, NOTE_C4, NOTE_FS4, NOTE_F4, NOTE_E3, NOTE_AS4, NOTE_A4, NOTE_GS4, NOTE_DS4, NOTE_B3, NOTE_AS3, NOTE_A3, NOTE_GS3, 0, 0, 0 };
  // nootduur: 4 = kwartnoot, 8 = achtste noot, etc.:
  int noteDurations[] = { 12, 12, 12, 12, 12, 12, 6, 3, 12, 12, 12, 12, 12, 12, 6, 3, 12, 12, 12, 12, 12, 12, 6, 3, 12, 12, 12, 12, 12, 12, 6, 6, 18, 18, 18, 6, 6, 6, 6, 6, 6, 18, 18, 18, 18, 18, 18, 10, 10, 10, 10, 10, 10, 3, 3, 3 };
  lcd.setCursor(1, 0);
  lcd.print("Nu aan het spelen...");
  lcd.setCursor(0, 1);
  lcd.print("MARIO UNDERWORLD");
  int size = sizeof(melody) / sizeof(int);
  for (int thisNote = 0; thisNote < size; thisNote++) {
    int noteDuration = 1000 / noteDurations[thisNote];
    tone(8, melody[thisNote], noteDuration);
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    tone(8, 0, noteDuration);
  }
  Song2title();
} // einde Song2 lus

Song3 Arduino

Code voor het 3e liedje. Bevat momenteel het Jeopardy Theme Song.

//***************** LIEDJE 3 NOTEN HIER **************************
void Song3() {
  lcd.clear();
  // noten in de melodie:
  int melody[] = { NOTE_C2, NOTE_F3, NOTE_C3, NOTE_A2, NOTE_A2, NOTE_C3, NOTE_F3, NOTE_C3, NOTE_C3, NOTE_F3, NOTE_C3, NOTE_F3, NOTE_AS3, NOTE_G3, NOTE_F3, NOTE_E3, NOTE_D3, NOTE_CS3, NOTE_C2, NOTE_F3, NOTE_C3, NOTE_A2, NOTE_A2, // herhaal regel 1 en 2 NOTE_C3, NOTE_F3, NOTE_C3, NOTE_AS3, 0, NOTE_G3, NOTE_F3, NOTE_E3, NOTE_D3, NOTE_CS3, NOTE_C3};
  // nootduur: 4 = kwartnoot, 8 = achtste noot, etc.:
  int noteDurations[] = { 4, 4, 4, 8, 8, 4, 4, 2, 4, 4, 4, 4, 3, 8, 8, 8, 8, 8, 4, 4, 4, 8, 8, // herhaal regel 1 en 2 4, 4, 2, 4, 8, 8, 4, 4, 4, 4, 4, 4, 0};
  lcd.setCursor(1, 0);
  lcd.print("Nu aan het spelen...");
  lcd.setCursor(0, 1);
  lcd.print(" JEOPARDY");
  for (int thisNote = 0; noteDurations[thisNote] != 0; thisNote++) {
    int noteDuration = 2000/noteDurations[thisNote];
    tone(8, melody[thisNote],noteDuration * 0.9);
    delay(noteDuration);
  }
  Song3title();
} // einde Song3 lus

Song4 Arduino

Code voor het 4e liedje. Bevat momenteel een korte, generieke melodie.

//***************** LIEDJE 4 NOTEN HIER **************************
void Song4() {
  lcd.clear();
  // noten in de melodie:
  int melody[] = { NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4 };
  // nootduur: 4 = kwartnoot, 8 = achtste noot, etc.:
  int noteDurations[] = { 4, 8, 8, 4, 4, 4, 4, 4 };
  lcd.setCursor(1, 0);
  lcd.print("Nu aan het spelen...");
  lcd.setCursor(0, 1);
  lcd.print(" LIEDJE 4 TITEL");
  int thisNote = 0;
  for (int thisNote = 0; thisNote < 8; thisNote++) {
    int noteDuration = 1000 / noteDurations[thisNote];
    tone(8, melody[thisNote], noteDuration);
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(8); // stop de toon:
  } // einde for
  Song4title();
} // einde Song4 lus

Song5 Arduino

Code voor het 5e liedje. Bevat momenteel een korte, generieke melodie.

//***************** LIEDJE 5 NOTEN HIER **************************
void Song5() {
  lcd.clear();
  // noten in de melodie:
  int melody[] = { NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4 };
  // nootduur: 4 = kwartnoot, 8 = achtste noot, etc.:
  int noteDurations[] = { 4, 8, 8, 4, 4, 4, 4, 4 };
  lcd.setCursor(1, 0);
  lcd.print("Nu aan het spelen...");
  lcd.setCursor(0, 1);
  lcd.print(" LIEDJE 5 TITEL");
  int thisNote = 0;
  for (int thisNote = 0; thisNote < 8; thisNote++) {
    int noteDuration = 1000 / noteDurations[thisNote];
    tone(8, melody[thisNote], noteDuration);
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(8); // stop de toon:
  } // einde for
  Song5title();
} // einde Song5 lus

pitches.h Arduino

Bibliotheek met muzieknoten voor liedjes. Bewaar in dezelfde map als je andere toetsenbord/liedjes-sketches.

//*************************************************
//** DEFINIEER MUZIEKNOTEN
//*************************************************
#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55
#define NOTE_AS1 58
#define NOTE_B1  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A2  110
#define NOTE_AS2 117
#define NOTE_B2  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A4  440
#define NOTE_AS4 466
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A5  880
#define NOTE_AS5 932
#define NOTE_B5  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A6  1760
#define NOTE_AS6 1865
#define NOTE_B6  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A7  3520
#define NOTE_AS7 3729
#define NOTE_B7  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978

Schema's

Schakelingsschema's zijn beschikbaar in de projectrepository.