Hieronder de code...

/*
  De Arduinofoon.
  Een MP3 speler ingebouwd in een ouderwetse PTT kiesschijftelefoon type T65.
  Elk gedraaid nummer laat een MP3 melodie horen.
  Bij opnemen van de hoorn klinkt de kiestoon.
  Afgeleid van de wonderfoon met Raspberry PI3 maar nu met een Arduino UNO R3.
  Zie bijbehorend aansluitschema met technische gegevens Arduinofoon 1.5.
  Softwareversie 1.4a.
  Alex Pikkert Mei 2019.
  MP3 speler aansluitingen:
  pin 2 next
  pin 4 previous
  pin 5 repeat
  pin 6 pause
  pin 12 5 Volt power MP3 speler ON/OFF via schakeltransistor.
*/
#include <EEPROM.h>
int dialHasFinishedRotatingAfterMs = 100;
int debounceDelay = 10;
int needToSend = 0;
int count; // dit is de variable waar de kiesschijf keuze ( 1 tot 0 wordt 1 tot 10) in vastgelegd wordt.
int lastState = LOW;
int trueState = LOW;
long lastStateChangeTime = 0;
int reading = 0;
int address = 3; // het EEPROM adres waar het songnummer opgeslagen wordt.
int lastSong; // opgeslagen songnummer in EEPROM.
int i; // teller hoeveel keer de MP3 speler vooruit of achteruit gezet moet worden.
int j; // teller welke actuele song gedraaid is met de kiesschijf.
int dialtoneOut = 7; // de uitgang met een 425 Herz kiestoon. Let op: pin 3 en 11 NIET gebruiken. (Zie "tone" uitleg op de Arduino reference site).
int hookContact = 8; // contact gesloten (LOW) als de hoorn van de haak genomen is.
int dialEnabled = 9; // contact gesloten (LOW) als de kiesschijf actief is.
int dialPulses = 10; // contact gesloten LOW) en alleen open als er een puls gegenereerd wordt.
int mp3Power = 12; // als deze poort HIGH is dan is de MP3 speler aan.
//******************************************************************************************
void(* resetFunc) (void) = 0;
void setup()
{
//  Serial.begin(9600);
//  delay(250);
  pinMode(dialPulses, INPUT_PULLUP); // ingang voor het pulscontact van de kiesschijf.
  pinMode(dialEnabled, INPUT_PULLUP); // ingang voor het contact van de kieschijf als die geactiveerd is.
  pinMode(hookContact, INPUT_PULLUP); // ingang voor het contact van de telefoonhoorn opgenomen/neergelegd.
  // PULLUP is nodig om instabiele ingang te voorkomen bij geopend en dus zwevend contact.
  // als een contact open is wordt de ingang hooggehouden (HIGH) door de interne pullup weerstand van de Arduino.
  pinMode(mp3Power, OUTPUT); // deze poort is 0 of 5 volt om de MP3 speler uit- of in te schakelen.
 pinMode(13, OUTPUT);
 
//delay(1000);

 if (digitalRead(hookContact) == LOW) // als de hoorn opgenomen is doe het volgende:
  {
//    Serial.println("Opgenomen");
    digitalWrite(13, HIGH);
    mp3PowerON(); // zet de MP3 speler aan.
    delay(2000); //wacht even tot de MP3 speler gestart is.
    pause(); // zet de MP3 speler op pauze.
    tone(dialtoneOut, 425); // zet de kiestoon aan.
  }
  else{
    digitalWrite(13, LOW);
//    Serial.println("Verbinding verbroken");
//    Serial.println("Hoorn ligt op de haak!");
  }
}
//******************************************************************************************
void loop()
{
  // als de kiesschijf actief is, detecteer het nummer en zet de kiestoon uit.
  // als de kiesschijf in rust is, selecteer de song door de MP3 speler vooruit of achteruit te zetten.
  // als de hoorn op de haak gelegd wordt ga dan in de wachtlus en zet indien nodig de kiestoon uit.

//  Serial.println(hookContact);
  if (digitalRead(dialEnabled) == LOW) {
    numberDialed();
    noTone(dialtoneOut);
 //   Serial.println("song: "+count);
  }
  else {
    selectSong();
  }
  if (digitalRead(8) == HIGH) {
    //Serial.println("ALWEER WACHTEN");
    mp3Wait();
  }
}
//subroutines ******************************************************************************************
// zet de MP3 speler vooruit of achteruit afhankelijk van het verschil tussen vorige en de actuele song.
void selectSong()
{
//  Serial.println("Song gekozen");
//  Serial.println(count); 
  switch (count) {
    case 1: j = 1; Song(); break;
    case 2: j = 2; Song(); break;
    case 3: j = 3; Song(); break;
    case 4: j = 4; Song(); break;
    case 5: j = 5; Song(); break;
    case 6: j = 6; Song(); break;
    case 7: j = 7; Song(); break;
    case 8: j = 8; Song(); break;
    case 9: j = 9; Song(); break;
    case 10: j = 10; Song(); break;
    default:
      // als de waarde nergens past, voer dan de default instructie uit.
      // de default instructie is optioneel.
      break;
  }
}
// ga naar de actuele song.
void Song()
{
  lastSong = EEPROM.read(address); // opgeslagen songnummer van de vorige song.
  if (lastSong == j) {
    next();  // als zelfde nummer gekozen is ga dan toch afspelen.
    prev();
  }
  EEPROM.update(address, j); // sla de actuele song op in het geheugen.
  if (lastSong < j) {
    for (i = lastSong; i < j; i++) {
      next(); // ga het verschil tussen de vorige en actuele song verder.
    }
  }
  if (lastSong > j) {
    for (i = j; i < lastSong; i++) {
      prev(); // ga het verschil tussen de vorige en actuele song terug.
    }
  }
  delay(400); repeat(); delay(5000); // wacht even en geef dan een repeat commando zodat steeds dezelfde song gespeeld wordt.
}
// besturing van de MP3 speler.
void next()
{
  pinMode(2, OUTPUT);
  tone(dialtoneOut, 425,200);
  delay( 200);
  noTone(dialtoneOut);
  pinMode(2, INPUT);
  delay(400);
  count = 0;
}
void prev()
{
  pinMode(4, OUTPUT);
  tone(dialtoneOut, 425,200);
  delay(200);
  noTone(dialtoneOut);
  pinMode(4, INPUT);
  delay(400);
  count = 0;
}
void repeat()
{
  pinMode(5, OUTPUT);
  delay(200);
  pinMode(5, INPUT);
  delay(400);
  count = 0;
}
void pause()
{
  pinMode(6, OUTPUT);
  delay(200);
  pinMode(6, INPUT);
  delay(400);
  count = 0;
}
// zet de MP3 speler uit.
void mp3PowerOFF()
{
  digitalWrite(mp3Power, LOW);
}
// zet de MP3 speler aan.
void mp3PowerON()
{
  digitalWrite(mp3Power, HIGH);
}
// wachtlus als de hoorn op de haak gelegd wordt. kiestoon gaat uit en als hoorn opgenomen wordt dan volgt een soft reset.
void mp3Wait()
{ 
  noTone(dialtoneOut); mp3PowerOFF();
  digitalWrite(13, LOW);
  //if (digitalRead(8) == HIGH) Serial.println("Haak is High");
  //if (digitalRead(8) == LOW) Serial.println("Haak is LOW");
  while (digitalRead(8) == HIGH) {} ;
//  Serial.println("Herstart...");
//  delay(100);
  asm volatile (" jmp 0");

//  delay(1000);
//  resetFunc();
}
// detectie van het gekozen nummer, vastgelegd in de variabele count.
void numberDialed()
{
  reading = digitalRead(dialPulses);
  if ((millis() - lastStateChangeTime) > dialHasFinishedRotatingAfterMs)
  { if (needToSend == 1) {
      needToSend = 0;
      count = 0;
    }
  }
  if (reading != lastState) {
    lastStateChangeTime = millis();
  }
  if ((millis() - lastStateChangeTime) > debounceDelay)
  { if (reading != trueState)
    { trueState = reading; if (trueState == HIGH) {
        count++;
        needToSend = 1;
      }
    }
  }
  lastState = reading;
}