Auf mein vorheriges Projekt aufbauend, eine Erweiterung. Ich hatte ja schon im Projekt Telefonklingel erwähnt das ich noch ein paar Ideen habe. Da ich eh schon ein Arduino zur Ansteuerung des Trafos benutze, ergeben sich noch weitere Möglichkeiten, als zwei Telefone das ist eher langweilig. Aber mehrere Telefone anschließen und dann soll es auch kein Kuddelmuddel geben. Denn man soll ja jedes Telefon anrufen können.

Was soll nun passieren. Der Arduino soll die drei Telefone überwachen. Er prüft ob ein Hörer abgehoben ist dann wird überprüft welche Zahl über die Wählscheibe gewählt wird, danach soll das angerufene Telefon klingeln. Das angerufene Telefon wird nun überwacht, ob dort der Hörer abgehoben wird. Ist das der Fall dann werden beide Telefonen mit einander verbunden. Nun wird überwacht ob einer von beiden Teilnehmer auflegt. Ist dass der Fall dann wird die Verbindung wieder getrennt und die Überwachung der drei Telefone ist wieder aktiv.

Und es soll die maximale Nutzung auf eine Minute begrenzt werden. Wenn man einen Teilnehmer anruft, der aber nicht anwesend ist, spätestens nach einer Minute alles wieder im Überwachungsmodus schaltet. Auch Gespräche werden bei einer maximalen Länge von einer Minute getrennt. Ich denke das dies völlig ausreichend ist, da bei einer Hausanlage nur kurze Infos abgesprochen werden. Zum Beispiel ‚Das Essen ist fertig oder Der Besuch ist da‘. Und wenn die Minute nicht ausreichend ist kann man ja nochmal wählen 😉

Als nächstes kommt noch ein Freiton und Besetztton hinzu. Aber erstmal das Programm welches auf den Arduino kommt. Hier muss schon einiges beachtet werden, den drei Relais je Telefon und ein Klingelrelais müssen gesteuert werden hinzu kommt die Überwachung die über Optokoppler realisiert wird. Dann muss alles richtig verbunden werden und das alles soll über die a/b Leitung der Telefone geschehen.

Oben zu sehen ist die Schaltung. Die Anschlüsse sind natürlich abhängig von der Programmierung. Aber es lassen sich noch mehr Telefone in die Anlage integrieren. Also man kann die Anlage mit einer Telefonschaltung erweitern. Mit einem Arduino Nano geht das dann so weit, wie noch freie IO Pins vorhanden sind. Lässt sich aber auch mit entsprechenden Erweiterungen noch mehr ausbauen. Für mich sind aber drei Telefone ausreichend.

Oben zu sehen, die Schaltung ist soweit erstmal als Versuchsaufbau mit einem Steckboard realisiert. Nicht so leicht alle Steckverbindungen in den richtigen Reihen einzuordnen. Aber mit einem Adlerauge bekommt man dass auch hin 😉 Nach dem alles mit entsprechendem Programm zu meiner Zufriedenheit funktioniert, wird es auf eine Platine aufgebaut. Und anschließend alles in einem Gehäuse unter gebracht. Zu dem kommt noch proTelefon ein Batteriefach mit ins Gehäuse. Damit werden die Telefone versorgt. Denn wenn die Telefone zusammengeschaltet sind müssen die ja eine Gleichspannung haben um auch Gespräche zuzulassen. Die Batterien halten ewig, da im Leerlauf kein Spannungskreislauf besteht. Die Schaltung kommt ohne weiteres mit 5V & 1A aus. Also die USB Versorgung des Arduino’s reicht völlig aus. Besser aber ein Netzteil mit 5V & 2A benutzen.

Ja ich denke das könnte auch viele interessieren die noch ein paar Wählscheibentelefone zu Hause haben und diese gerne als Haustelefon betreiben möchten. Also mit Wählscheibenfunktion und die Möglichkeit noch mehr Telefone anzuschließen. Mein nächstes Projekt steht auch schon an. Eine Telefonbox welche ein Telefon klingeln lässt wenn man sich dem annähert, und beim abheben des Hörers wird eine Audiodatei mit Begrüßung, oder was auch immer, abgespielt. Das gute, es wird eine Telefonbuchse TAE oder wie die sich nennt angeschlossen. So kann man dann auch andere Telefone einstecken. Das Projekt wird dann sehr wahrscheinlich ans Radio und Telefonmuseum in Rheda-Wiedenbrück gehen. Denn genau da gehört sowas hin 😉 Aber hier eine kleines Video zu diesem Projekt.

Für die jenigen welche den Sketch haben möchten. Und sich bissel auskennen. Habe ich nun Folgend das Programm angehängt. Das Programm darf gerne kopiert werden. Eine Abänderung zur Anpassung der Belegung und Erweiterungen sind auch gestattet. Nur der Hinweiß zu dieser Homepage sollte bei Weitergabe mit inbegriffen sein.

Für die anderen die mit programmieren nicht so viel an der Mütze haben, wir sehen uns im nächsten Projekt.

// ================== PIN BELEGUNG ==================

//================ WWW.NRWFUNK.DE =================

#define RELAY_T1 8
#define RELAY_T2 9
#define RELAY_T3 10
#define RELAY_RING 7
#define MOSFET 6

#define DIAL1 2
#define DIAL2 3
#define DIAL3 4

// ================== VARIABLEN ==================
volatile int pulseCount = 0;
volatile int activeDial = 0;
unsigned long lastPulseTime = 0;

// ================== SETUP ==================
void setup() {

pinMode(RELAY_T1, OUTPUT);
pinMode(RELAY_T2, OUTPUT);
pinMode(RELAY_T3, OUTPUT);
pinMode(RELAY_RING, OUTPUT);
pinMode(MOSFET, OUTPUT);

pinMode(DIAL1, INPUT_PULLUP);
pinMode(DIAL2, INPUT_PULLUP);
pinMode(DIAL3, INPUT_PULLUP);

attachInterrupt(digitalPinToInterrupt(DIAL1), pulse1, RISING);
attachInterrupt(digitalPinToInterrupt(DIAL2), pulse2, RISING);
attachInterrupt(digitalPinToInterrupt(DIAL3), pulse3, RISING);

allIdle();
}

// ================== RESET ==================
void allIdle() {
digitalWrite(RELAY_T1, LOW);
digitalWrite(RELAY_T2, LOW);
digitalWrite(RELAY_T3, LOW);
digitalWrite(RELAY_RING, LOW);
}

// ================== IMPULSE ==================
void pulse1() { handlePulse(1); }
void pulse2() { handlePulse(2); }
void pulse3() { handlePulse(3); }

void handlePulse(int phone) {
static unsigned long last = 0;

if (millis() – last > 10) {
pulseCount++;
activeDial = phone;
lastPulseTime = millis();
}
last = millis();
}

// ================== EINSTELLIGE WAHL ==================
int readDial(int &caller) {

pulseCount = 0;
activeDial = 0;

while (pulseCount == 0);
while (millis() – lastPulseTime < 800);

int number = pulseCount;
if (number == 10) number = 0;

caller = activeDial;
return number;
}

// ================== KLINGEL ==================
void ringSignal(int duration_ms) {

unsigned long start = millis();

while (millis() – start < duration_ms) {
digitalWrite(MOSFET, HIGH);
delay(20);
digitalWrite(MOSFET, LOW);
delay(20);
}
}

// ================== HOOK ÜBER a/b ==================
bool checkOffHook(int dialPin) {
return digitalRead(dialPin) == LOW;
}

// ================== KLINGELN ==================
bool callPhone(int targetRelay, int dialPin) {

for (int i = 0; i < 20; i++) {

digitalWrite(targetRelay, HIGH);

digitalWrite(RELAY_RING, HIGH);

ringSignal(1000);

digitalWrite(RELAY_RING, LOW);

digitalWrite(targetRelay, LOW);

delay(150);

if (checkOffHook(dialPin)) {

  return true;

}

delay(2850);

}

return false;
}

// ================== VERBINDEN ==================
void connectPhones(int r1, int r2) {

allIdle();
delay(50);

digitalWrite(r1, HIGH);
digitalWrite(r2, HIGH);

unsigned long start = millis();

while (millis() – start < 20000) {
delay(50);
}

digitalWrite(r1, LOW);
digitalWrite(r2, LOW);
}

// ================== LOOP ==================
void loop() {

int caller = 0;
int number = readDial(caller);

// ===== ROUTING (4 / 5 / 6) =====

if (caller == 1 && number == 5) {
if (callPhone(RELAY_T2, DIAL2)) {
connectPhones(RELAY_T1, RELAY_T2);
}
}

if (caller == 1 && number == 6) {
if (callPhone(RELAY_T3, DIAL3)) {
connectPhones(RELAY_T1, RELAY_T3);
}
}

if (caller == 2 && number == 4) {
if (callPhone(RELAY_T1, DIAL1)) {
connectPhones(RELAY_T2, RELAY_T1);
}
}

if (caller == 2 && number == 6) {
if (callPhone(RELAY_T3, DIAL3)) {
connectPhones(RELAY_T2, RELAY_T3);
}
}

if (caller == 3 && number == 4) {
if (callPhone(RELAY_T1, DIAL1)) {
connectPhones(RELAY_T3, RELAY_T1);
}
}

if (caller == 3 && number == 5) {
if (callPhone(RELAY_T2, DIAL2)) {
connectPhones(RELAY_T3, RELAY_T2);
}
}
}

Bis zur letzten geschweiften Klammer kopieren und in euer Projekt einfügen. Viel Spass beim Projekt.