De Arduinofoon is een oude PTT telefoon die is omgebouwd tot mini-jukebox met behulp van een Arduino Uno microcontroller en een MP3 speler. Als je de hoorn van de haak neemt hoor je de kiestoon en als je daarna een nummer kiest tussen de 0 en de 9 hoor je vervolgens een muziekje.

[embedyt] https://www.youtube.com/watch?v=fRIGBQZESts[/embedyt]

Het schema

Deze onderdelen heb je nodig:

• 1 draaischijftelefoon type T65
• meeraderig montagedraad in verschillende kleuren
• krimpkous 4 mm doorsnede
• 1 Arduino UNO R3 (een originele of een kloon kan ook)
• 1 MP3 speler type FN-M981
• 1 voedingsplug 9-12 Volt minimaal 1 Ampère met 2,1mm ronde steker
• 1 micro SD kaartje voor de muziek (1 Gb is meer dan voldoende)
• 1 SD kaarthouder om het micro SD kaartje op de PC te kunnen aansluiten
• 6 weerstanden 1 kOhm 1/8 Watt
• 1 weerstand 22 kOhm 1/8 watt
• 1 transistor type BC547
• 1 condensator 1uf
• 1 DC contrasteker 2,1 mm met bedrading
• 1 DC steker 2,1 mm met bedrading
• 1 zekeringhouder met een glaszekering 1A traag voor inbouw in bedrading
• 1 rijtje aansluitpinnetjes voor de Arduino UNO
• 1 stukje experimenteerprint 6×8 gaatjes 0,1 inch afstand met eilandjes koper
• 1 plaatje hardboard volgens tekening, 3,2 mm dik
• 2 M3 boutjes 10 mm lang
• 2 M3 boutjes 20 mm lang
• 4 M3 moertjes
• 2 M5 moeren, gebruikt als afstandshouders
• dubbelzijdig plakband

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;
}