Introduction: DIY: Altes Wählscheiben Telefon Als Gegensprechanlagen Ersatz
In dieser Anleitung wird gezeigt, wie ein altes Wählscheibentelefon zu einer Gegensprechanlage umgebaut werden kann. Die umgebaute Anlage soll alle Funktionen einer herkömmlichen Wohnungsgesprächsanlage vollständig ersetzen. Dazu gehört die Nutzung der Glocken für das Klingeln, die Steuerung des Türöffners sowie die Verwendung des Wählscheibentelefonhörers für die Gegensprechfunktion, einschließlich der Erkennung, wann der Hörer aufgelegt wird.
Supplies
Benötigte Bauteile:
- Ein altes Wählscheibentelefon (mit Glocken und Klingelvorrichtung)
- Ein zweites Modell der entsprechenden Gegensprechanlage (nur die Empfangsstation in der Wohnung wird benötigt, günstig auf eBay erhältlich)
- ESP32 (oder ein anderer Mikrocontroller mit eingebautem Analog-Digital-Wandler, z. B. Arduino Uno/Nano oder ESP8266)
- 12V Netzteil
- Tiefsetzsteller (Step-Down-Konverter) für 3,3V ESP-Spannung (z. B. Hailege 2596S-ADJ)
Für das Klingeln auf den Glocken:
- 2x Logic-Level n-Kanal Mosfets (z. B. RFP30N06LE)
- 2x 47k Ohm Widerstände
- Telefon mit verbauten Glocken und Klingelvorrichtung
Für das Erkennen des Klingelns auf der originalen Gegensprechanlage:
- 1x Optokoppler LTV 817C
- 1x Diode 1N4148
- 100 Ohm Widerstand
- 330 Ohm Widerstand (oder 230 Ohm + 100 Ohm)
Für die Umsetzung der Auflegefunktion und des Türöffners:
- 2x Relais (empfohlen wird ein 4er Relais)
- 2x 10k Ohm Widerstände
Sonstige Utensilien:
- Draht
- Lochplatine
- eventuell 3D-gedruckte Teile, falls Platzprobleme im Wählscheibentelefon auftreten
Benötigtes Werkzeug:
- Lötkolben und Lötutensilien
- Voltmeter (Messgerät)
- eventuell einen 3D-Drucker, falls 3D-gedruckte Teile verwendet werden
Step 1: Bestandsaufnahme Des Wählscheiben Telefons
Bevor der Umbau beginnt, ist es wichtig, das alte Wählscheiben Telefon zu begutachten und die darin enthaltene Technik zu analysieren.
- Das Wählscheiben Telefon wird aufgeschraubt und alle technischen Komponenten, die nicht für die Gegensprechanlage benötigt werden, entfernt. Die benötigten Komponenten sind der Klingelmechanismus und der Auflegemechanismus.
- Der Klingelmechanismus wird identifiziert. Im Wählscheibentelefon befindet sich der Klingelmechanismus, der in meinem Beispiel aus zwei Glocken besteht. Zwischen den Glocken befindet sich ein Schlegel, der die Glocken anschlägt. Der Schlegel ist auf einer Wippe gelagert, an deren oberen Ende sich zwei Magneten befinden. Diese Magnete werden von darunterliegenden Spulen angezogen und müssen abwechselnd eingeschaltet werden, um das Klingeln zu ermöglichen.
- Der Auflegemechanismus wird identifiziert. Beim Wählscheibentelefon ist der Auflegemechanismus gefedert. Der Bügel, auf dem der Hörer liegt, ist beweglich und drückt auf den gefederten Knopf. Wenn der Hörer abgelegt wird, reicht der Auflegedruck aus, um den gefederten Mechanismus einzudrücken und somit eine Verbindung zwischen zwei Kontakten zu trennen.
Die gewonnenen Informationen werden später für die Umsetzung des Umbaus benötigt.
Step 2: Bestandsaufnahme Der Originalen Gegensprechanlage
Als nächster Schritt ist die Untersuchung der Hauptplatine der vorhandenen Gegensprechanlage von Bedeutung. Bei dem vorliegenden Fall handelt es sich um eine Gegensprechanlage von Elcom, aber dieser Umbau sollte auch mit den meisten herkömmlichen Anlagen möglich sein. Viele Gegensprechanlagen basieren auf geschlossenen Bussystemen, wodurch ein direkter Ersatz des Empfangsteils (das Gerät, das in der Wohnung hängt) schwierig ist. Daher nutze ich in diesem Umbau die Platine des originalen Empfangsteils der Gegensprechanlage. Von der Platine des Empfangsteils können alle Signale, die für den Umbau benötigt werden ermittelt und gemessen werden. Empfohlen wird der Erwerb eines zusätzlichen Empfangsteils (das Gerät, das in der Wohnung hängt) der Gegensprechanlage auf Plattformen wie eBay (schon ab 20€), um im schlimmsten Fall das originale Teil nicht zu beschädigen. Wenn bereits ein Modell vorhanden ist oder das verbaute Gerät opfert werden kann, wird empfohlen, es vorsichtig zu öffnen und nach den folgenden Punkten zu suchen:
- Lautsprecheranschluss: Hier wird später das Klingelsignal abgegriffen. Dafür müssen die Anschlusspunkte auf der Platine, die mit dem Lautsprecher in Verbindung stehen ermittelt werden. Markiert diese Punkte auf der Platine, um sie später für den Umbau nutzen zu können.
- Auflegeerkennung: In meinem Fall handelt es sich um einen magnetisch sensitiven Widerstand. Im Hörer war ein Magnet verbaut, der den Widerstand hochohmig werden ließ, wenn er in seine Nähe kam. Bei den meisten Gegensprechanlagen ist dies jedoch ein einfacher Schalter, den man leicht austauschen kann. Sucht nach den Anschlüssen auf der Platine, an denen der Erkennungsmechanismus angeschlossen ist. Markiert diese Punkte auf der Platine, um sie später für den Umbau nutzen zu können.
- Türöffner: Der Türöffner wird meist durch einen Knopf aktiviert. Oft sind zwei Graphitpads die beim drücken einer Membran verbunden werden. Verfolgt die Leiterbahnen, die zu dem entsprechenden Pads führen, bis ihr eine Durchführung durch die Platine findet (diese sind verzinnt, und dort kann man leicht einen Draht anlöten). Ein Graphit Pad war bei mir mit GND (Masse) verbunden und hatte deswegen keine Leiterbahn.falls das der fall ist, sucht nach einem GND-Anschluss, indem ihr zwischen der Padhälfte und verschiedenen Wias (Durchführungen durch die Platine) auf der Platine den Widerstand misst. Dort, wo der Widerstand 0 Ohm beträgt, habt ihr den richtigen Anschluss gefunden. Markiert diese Punkte auf der Platine, um sie später für den Umbau nutzen zu können.
Die gefundenen Punkte sind grundlegend, um mit dem Umbau des alten Wählscheibentelefons zur Gegensprechanlage fortzufahren.
Step 3: Umbau Des Hörers
Als erstes wird der alte Hörer des Wählscheibentelefons umgebaut, um ihn schließlich an die originale Platine der Gegensprechanlage anzuschließen.
- Vorbereitung des Hörers:
- Die alte Technik wird aus dem Hörer des Wählscheibentelefons entfernt, jedoch bleiben die Kontaktpads des alten Lautsprechers und Mikrofons intakt.
- Optional - das alte Kabel des Hörers kann durch ein neues ersetzt werden. Eine stoffumantelte Variante verleiht dem Hörer eine ansprechende Optik.
- Verbindungen zum Mikrofon und Lautsprecher der Original-Gegensprechanlage:
- Das Mikrofon und der Lautsprecher werden von der Original-Gegensprechanlage genommen und nun in den vorbereiteten Hörer des Wählscheibentelefons gelötet.
- Achte darauf, die richtigen Drahtverbindungen herzustellen, die oft farblich markiert sind. Vor dem Umbau sollten die entsprechenden Verbindungen gemessen und notiert werden.
- Anschließen des Hörers an die Hauptplatine:
- Der umgebaute Hörer muss nun mit der Hauptplatine der Original-Gegensprechanlage verbunden werden. Dazu wird der Stecker auf der Hauptplatine ausgetauscht, da der ursprüngliche Netzwerkstecker (zumindest bei meinem Modell) nicht einfach auf ein neues Kabel übertragbar ist.
- Die Verwendung von JST XH Steckern wird empfohlen, da sie eine flexible Lösung bieten und mehrfache Auseinanderbauten ermöglichen. Alternativ kann das Kabel auch direkt angelötet werden.
Achte darauf, dass die zuvor notierten Zuordnungen der Drähte auch mit dem neuen Kabel übereinstimmen.
Step 4: Umsetzung Der Klingelfunktion
Um die Klingelfunktion zu realisieren, wird zunächst das Klingeln erkannt und anschließend der Mechanismus für das Klingeln angesteuert.
4.1) Erkennung des Klingelns:
Zur Umsetzung der Klingelfunktion wird ein Microcontroller, in meinem beispiel der ESP32 jeder andere Microcontroller geht jedoch auch, verwendet, um alle Funktionen zu steuern. Das Klingeln wird erkannt, indem die Spannung über dem Originalen Lautsprecher gemessen wird. Da der Lautsprecher im Endumbau nicht mehr verwendet wird und durch die Glocken des Wählscheibentelefons ersetzt wird, setze ich einen 100-Ohm-Widerstand als Ersatz ein. Dieser Widerstand ersetzt die Impedanz des Lautsprechers ausreichend, da es hier nicht auf die Feinheiten der Spannungsmessung ankommt. Es genügt, die Spannung über diesem Widerstand zu messen, um herauszufinden, ob geklingelt wird.
Jedoch muss beachtet werden, dass alle gängigen Mikrocontroller Spannungen gegen den Minuspol (GND) messen. Das bedeutet, dass der Minuspol der Spannungsversorgung des ESP mit dem Minuspol des Lautsprecherersatzwiderstands verbunden werden muss. Das ist problematisch, denn die Stromkreise der Originalen Gegensprechanlage und des Mikrocontrollers sollten nicht direkt verbunden sein, da dadurch unvorhersehbare Wechselwirkungen zwischen den Platinen entstehen können.
Um dieses Problem zu lösen, verwende ich eine galvanische Trennung, die durch verschiedene elektrische Bauteile, beispielsweise einen Optokoppler, realisiert werden kann. In diesem Fall wird ein Optokoppler eingesetzt, der aus einer Diode und einem photosensitiven Transistor besteht. Die Diode des Optokopplers wird in Reihe zum Ersatzwiderstand geschaltet, und die Spannung wird auf der Transistorseite gemessen. Wenn das Klingeln eine Spannungsänderung am Lautsprecherersatzwiderstand verursacht, flackert die Diode bzw. ihre Leuchtleistung ändert sich. Dies kann über den Phototransistor erfasst werden, um festzustellen, ob geklingelt wird.
Der Schaltplan für die Realisierung des Messens über den Optokoppler ist in einer der oben stehenden Abbildungen dargestellt.
Nachfolgend ist der Code für die Erkennung der Klingel auf dem Microcontroller:
uint8_t state;
uint8_t tonabfolge_state;
bool once = 0;
#define klingel_pin_1 GPIO_NUM_5
#define klingel_pin_2 GPIO_NUM_17
#define analog_pin GPIO_NUM_27
int beginn_zeit = 0;
int klingel_zeit = 0;
struct klingel_erkennen
{
bool timer_active = false;
uint32_t timestemp = 0;
uint8_t count_voltage_dips = 0;
const uint16_t time_interval = 2000;
bool reset_timer_active = false;
uint32_t reset_timer = 0;
const uint16_t reset_timer_interval = 10000;
} Klingel_erkennen;
void erkennung_klingeln()
{
if (Klingel_erkennen.reset_timer_active)
{
if (millis() - Klingel_erkennen.reset_timer > Klingel_erkennen.reset_timer_interval)
{
Klingel_erkennen.reset_timer_active = false;
}
}
else
{
if (analogRead(analog_pin) < 1000)
{
if (!Klingel_erkennen.timer_active)
{
Klingel_erkennen.timer_active = true;
Klingel_erkennen.timestemp = millis();
Klingel_erkennen.count_voltage_dips = 1;
}
else
{
Klingel_erkennen.count_voltage_dips++;
}
}
if (Klingel_erkennen.timer_active)
{
if (millis() - Klingel_erkennen.timestemp > Klingel_erkennen.time_interval)
{
Klingel_erkennen.count_voltage_dips = 0;
Klingel_erkennen.timer_active = false;
}
if (Klingel_erkennen.count_voltage_dips >= 3)
{
Klingel_erkennen.count_voltage_dips = 0;
Klingel_erkennen.timer_active = false;
klingeln(true);
Klingel_erkennen.reset_timer_active = true;
Klingel_erkennen.reset_timer = millis();
}
}
}
};
4.2) Läuten der Glocken:
Jetzt, wo ich weiß, ob geklingelt wurde, muss der Klingelvorgang auf die Glocken umgesetzt werden.
Um das Klingeln zu erzeugen, muss der im Schritt 1 erklärte Mechanismus zum Läuten in Aktion versetzt werden. Dazu werden die Spulen im Mechanismus abwechselnd aktiviert. Basierend auf meinen Experimenten habe ich festgestellt, dass ein guter klanglicher und mechanischer Effekt mit einer Aktivierungs- und Deaktivierungszeit von jeweils 10 ms pro Spule erreicht wird, was eine Periodensignallänge von 20 ms ergibt.
Ich nutze den ESP32, um das Ansteuersignal für die beiden Spulen zu erzeugen. Nachfolgend ist der Code für den ESP, der benötigt wird, um das Steuersignal für die Glocken zu erstellen.
Hier ist der Code, um die Glocken zum Läuten zu bringen:
void klingeln(bool start_stop)
{
if (start_stop)
{
state = 1;
tonabfolge_state = 1;
}
else
{
state = 0;
tonabfolge_state = 0;
}
}
void handle_klingeln()
{
// Serial.println(state);
switch (state)
{
case 0: // stop state
if (digitalRead(klingel_pin_2) != LOW)
{
digitalWrite(klingel_pin_2, LOW);
}
if (digitalRead(klingel_pin_1) != LOW)
{
digitalWrite(klingel_pin_1, LOW);
}
break;
case 1:
beginn_zeit = millis();
klingel_zeit = millis();
state++;
break;
case 2:
if (millis() - klingel_zeit > klingel_intervall_ms)
{
digitalWrite(klingel_pin_1, HIGH);
digitalWrite(klingel_pin_2, LOW);
klingel_zeit = millis();
state++;
}
break;
case 3:
if (millis() - klingel_zeit > klingel_intervall_ms)
{
digitalWrite(klingel_pin_1, LOW);
digitalWrite(klingel_pin_2, HIGH);
klingel_zeit = millis();
state = 2;
}
break;
}
}
Wenn ein angenehmes Klingelmuster wie "riing riiiiiiiiiing" gewünscht ist, kann der Code erweitert werden, um die Länge der beiden Töne anzupassen. Das Klingelmuster lässt sich auch in einer State-Maschine implementieren und ist einfach ausbaufähig.
... klingel statemaschin ...
switch (tonabfolge_state)
{
case 0:
{
}
break;
case 1:
{
if (millis() - beginn_zeit > klingel_dauer_1_ms)
{
state = 0;
tonabfolge_state++;
beginn_zeit = millis();
}
}
break;
case 2:
{
if (millis() - beginn_zeit > klingel_dauer_pause_ms)
{
state = 1;
tonabfolge_state++;
}
}
break;
case 3:
{
if (millis() - beginn_zeit > klingel_dauer_2_ms)
{
state = 0;
tonabfolge_state = 0;
}
}
break;
}
}
Da die Spannung des ESP bei 3,3V liegt und die Spulen 12V (oder sogar 32V) benötigen, und die Spulen auch einen relativ hohen Strombedarf haben (bis zu 100mA gemessen), kann der ESP die Spulen nicht direkt ansteuern.
Ursprünglich wurde die Verwendung eines Relais in Betracht gezogen, jedoch stieß dies auf Probleme, da die Relais beim Schaltvorgang zu laut sind und nicht schnell genug arbeiten, um den 10-ms-On-Time-Takt zu realisieren.
Deshalb wurden zwei MOSFETs verwendet, um die Spannung für die Spulen zu schalten. Den Schaltplan dazu findest du in obrigen Abbildung
Step 5: Auflege Erkennung
Im Schritt 1 wurde bereits erläutert, wie das Auflegesignal vom Wählscheibentelefon erzeugt wird und welcher Mechanismus bzw. Schalter sich auf der Platine der originalen Gegensprechanlage befindet. Um das Signal vom Wählscheibentelefon zu erfassen und an die Gegensprechanlage weiterzuleiten, wird ein ESP-Mikrocontroller verwendet. Dieser wertet den Schalter mit Hilfe eines Pulldown-Widerstands zur Erkennung des Auflegens aus. Die entsprechende Schaltung ist in Abbildung [Abb. 1] dargestellt.
Nach erfolgreicher Erkennung des Auflegesignals ist es entscheidend, dieses Signal an die Platine der originalen Gegensprechanlage weiterzuleiten. Wie bereits zuvor beschrieben, ist hierbei eine galvanische Trennung der Stromkreise zwischen der Gegensprechanlagen-Platine und dem ESP erforderlich. Zu diesem Zweck wird ein Relais verwendet, das anstelle des Magnetwiderstands oder eines möglichen Schalters platziert wird. Wenn der Widerstand hochohmig sein soll, bleibt das Relais geöffnet, und wenn er niederohmig sein soll, wird es geschlossen.
Die Erkennung des Signals und die Steuerung des Relais erfolgen mithilfe des folgenden Codes:
bool hoerer_abgelegt = true;
void handle_knoepfe()
{
if (hoerer_abgelegt != digitalRead(hoerer_pin))
{
hoerer_abgelegt = !hoerer_abgelegt;
if (hoerer_abgelegt)
{
digitalWrite(relay_pin_0, HIGH);
}
else
{
digitalWrite(relay_pin_0, LOW);
}
}
};
Step 6: Türöffner
Um die Türöffnung auf Knopfdruck zu realisieren, werden die in Schritt 1 identifizierten Platinendurchführungen verwendet. An diesen wird jeweils ein Draht angelötet, die beiden Drähte werden dann mit einem Relais verbunden. Dieses Relais ermöglicht es, die beiden Drahtenden miteinander zu verbinden oder zu trennen. Das Relais dient als galvanische Trennung.
Glücklicherweise besitzt das Wählscheiben-Telefon bereits einen passenden Knopf auf der Vorderseite, der sich hervorragend als Türöffner eignet. Dieser Knopf wird für die Gegensprechanlage verwendet. Zur Erkennung des Türöffnungsdrucks wird erneut ein Pulldown-Widerstand verwendet, der mit dem ESP verbunden ist. Die Schaltung dazu ist in der oberen Abbildung dargestellt. Beim Erstellen des Codes für die Erkennung des Drückens und die Ausführung auf der Platine musste berücksichtigt werden, dass der Knopf ein Öffner ist, d.h. er ist im nicht gedrückten Zustand geschlossen. Daher musste dieses Signal im Code negiert werden, damit es korrekt erkannt wird.
Hier ist der verwendete Code:
bool summer_betaetigt = false;
void handle_knoepfe()
{
if (summer_betaetigt != digitalRead(summer_pin))
{
summer_betaetigt = !summer_betaetigt;
if (summer_betaetigt)
{
digitalWrite(relay_pin_1, LOW);
}
else
{
digitalWrite(relay_pin_1, HIGH);
}
}
};
Step 7: Zusammenbau
Nun ist es an der Zeit, alles zusammenzufügen. Aufgrund der Größe meines Wählscheibentelefons habe ich eine 3D-gedruckte Hülle für meine Technik entworfen, die unter das Telefon passt und somit fast unsichtbar ist.
Eine gelötete Platine implementiert alle gewünschten Funktionen. Einige Stecker wurden auf die Platine gelötet, um ein einfaches Auseinanderbauen zu ermöglichen. Die Versorgungsspannung wird von einem herkömmlichen 12V-Netzteil bereitgestellt, das mit einem dafür typischen Rundstecker in das 3D-gedruckte Gehäuse eingelassen ist.
Um die Versorgungsspannung für den ESP zu erzeugen, wurde ein Step-Down-Konverter verwendet, der die 12V-Spannung auf 5V reduziert, die dann vom ESP intern auf 3,3V weiter heruntergesetzt wird.
Bei meinem Umbau passten die verwendeten vier Relais in das Gehäuse des Wählscheibentelefons, obwohl ich nur zwei Anschlüsse benötigte.
Unten findet ihr den Gesamtcode für den ESP32 (der leicht auf andere Mikrocontroller angepasst werden kann) und den verwendeten Schaltplan für die Hauptplatine sowie alle weiteren benötigten Schaltpläne.
#include <Arduino.h>
#define klingel_intervall_ms 10
#define klingel_dauer_1_ms 500
#define klingel_dauer_pause_ms 200
#define klingel_dauer_2_ms 1000
uint8_t state;
uint8_t tonabfolge_state;
bool once = 0;
#define klingel_pin_1 GPIO_NUM_5
#define klingel_pin_2 GPIO_NUM_17
#define hoerer_pin GPIO_NUM_4
#define summer_pin GPIO_NUM_2
#define relay_pin_0 GPIO_NUM_33
#define relay_pin_1 GPIO_NUM_25
#define relay_pin_2 GPIO_NUM_14
#define relay_pin_3 GPIO_NUM_12
#define analog_pin GPIO_NUM_27
int beginn_zeit = 0;
int klingel_zeit = 0;
bool hoerer_abgelegt = true;
bool summer_betaetigt = false;
struct klingel_erkennen
{
bool timer_active = false;
uint32_t timestemp = 0;
uint8_t count_voltage_dips = 0;
const uint16_t time_interval = 2000;
bool reset_timer_active = false;
uint32_t reset_timer = 0;
const uint16_t reset_timer_interval = 10000;
} Klingel_erkennen;
void setup()
{
// put your setup code here, to run once:
Serial.begin(115200);
pinMode(klingel_pin_1, OUTPUT);
digitalWrite(klingel_pin_1, LOW); // LOW - mosfet offen
pinMode(klingel_pin_2, OUTPUT);
digitalWrite(klingel_pin_2, LOW);
pinMode(relay_pin_0, OUTPUT);
digitalWrite(relay_pin_0, HIGH);
pinMode(relay_pin_1, OUTPUT);
digitalWrite(relay_pin_1, HIGH);
pinMode(relay_pin_2, OUTPUT);
digitalWrite(relay_pin_2, LOW);
pinMode(relay_pin_3, OUTPUT);
digitalWrite(relay_pin_3, LOW);
pinMode(hoerer_pin, INPUT); // hoerer
pinMode(summer_pin, INPUT); // Summer
hoerer_abgelegt = digitalRead(hoerer_pin);
summer_betaetigt = digitalRead(summer_pin);
state = 0;
tonabfolge_state = 0;
}
void klingeln(bool start_stop)
{
if (start_stop)
{
state = 1;
tonabfolge_state = 1;
}
else
{
state = 0;
tonabfolge_state = 0;
}
}
void handle_klingeln()
{
// Serial.println(state);
switch (state)
{
case 0: // stop state
if (digitalRead(klingel_pin_2) != LOW)
{
digitalWrite(klingel_pin_2, LOW);
}
if (digitalRead(klingel_pin_1) != LOW)
{
digitalWrite(klingel_pin_1, LOW);
}
break;
case 1:
beginn_zeit = millis();
klingel_zeit = millis();
state++;
break;
case 2:
if (millis() - klingel_zeit > klingel_intervall_ms)
{
digitalWrite(klingel_pin_1, HIGH);
digitalWrite(klingel_pin_2, LOW);
klingel_zeit = millis();
state++;
}
break;
case 3:
if (millis() - klingel_zeit > klingel_intervall_ms)
{
digitalWrite(klingel_pin_1, LOW);
digitalWrite(klingel_pin_2, HIGH);
klingel_zeit = millis();
state = 2;
}
break;
}
switch (tonabfolge_state)
{
case 0:
{
}
break;
case 1:
{
if (millis() - beginn_zeit > klingel_dauer_1_ms)
{
state = 0;
tonabfolge_state++;
beginn_zeit = millis();
}
}
break;
case 2:
{
if (millis() - beginn_zeit > klingel_dauer_pause_ms)
{
state = 1;
tonabfolge_state++;
}
}
break;
case 3:
{
if (millis() - beginn_zeit > klingel_dauer_2_ms)
{
state = 0;
tonabfolge_state = 0;
}
}
break;
}
}
void erkennung_klingeln()
{
if (Klingel_erkennen.reset_timer_active)
{
if (millis() - Klingel_erkennen.reset_timer > Klingel_erkennen.reset_timer_interval)
{
Klingel_erkennen.reset_timer_active = false;
}
}
else
{
if (analogRead(analog_pin) < 1000)
{
if (!Klingel_erkennen.timer_active)
{
Klingel_erkennen.timer_active = true;
Klingel_erkennen.timestemp = millis();
Klingel_erkennen.count_voltage_dips = 1;
}
else
{
Klingel_erkennen.count_voltage_dips++;
}
}
if (Klingel_erkennen.timer_active)
{
if (millis() - Klingel_erkennen.timestemp > Klingel_erkennen.time_interval)
{
Klingel_erkennen.count_voltage_dips = 0;
Klingel_erkennen.timer_active = false;
}
if (Klingel_erkennen.count_voltage_dips >= 3)
{
Klingel_erkennen.count_voltage_dips = 0;
Klingel_erkennen.timer_active = false;
klingeln(true);
Klingel_erkennen.reset_timer_active = true;
Klingel_erkennen.reset_timer = millis();
}
}
}
};
void handle_knoepfe()
{
if (hoerer_abgelegt != digitalRead(hoerer_pin))
{
hoerer_abgelegt = !hoerer_abgelegt;
if (hoerer_abgelegt)
{
digitalWrite(relay_pin_0, HIGH);
}
else
{
digitalWrite(relay_pin_0, LOW);
}
}
if (summer_betaetigt != digitalRead(summer_pin))
{
summer_betaetigt = !summer_betaetigt;
if (summer_betaetigt)
{
digitalWrite(relay_pin_1, LOW);
}
else
{
digitalWrite(relay_pin_1, HIGH);
}
}
};
void loop()
{
while (true)
{
// if (millis() > 5000 and !once)
// {
// Serial.println("start klingel");
// once = true;
// klingeln(true);
// }
handle_klingeln();
erkennung_klingeln();
handle_knoepfe();
Serial.print("hoerer_pin:");
Serial.print(hoerer_abgelegt);
Serial.print(" summer_pin:");
Serial.println(summer_betaetigt);
}
}
