Hallo zusammen,
ich suche nach einer Klingelerkennung für ein Siedle Haustelefon HTC oder HTG 711, Baujahr 2000.
Das Problem wurde hier ausführlich diskutiert und mithilfe einer vorgeschalteten Z-Diode und dem Homematic Funk-Klingelsignalsensor HM-Sen-DB-PCB gelöst:
https://homematic-forum.de/forum/viewtopic.php?f=27&t=26095 (https://homematic-forum.de/forum/viewtopic.php?f=27&t=26095)
https://www.elv.de/output/controller.aspx?cid=74&detail=10&detail2=49399 (https://www.elv.de/output/controller.aspx?cid=74&detail=10&detail2=49399)
Damit wäre das Problem eigentlich erledigt, und ich vermute auch, dass die Latenzzeit bis zur Klingelerkennung in Fhem sehr klein sein dürfte.
Mit einem SIP-Client auf dem RPi könnte ich dann einen Rundruf an Telefon/Handy starten und wäre dann nicht nur über die Türklingel erreichbar; dafür würde ich dann eine geringe Latenzzeit benötigen.
Ich habe im Forum schon einige Beiträge zum Thema Klingelerkennung und Tasterschaltung im Zusammenhang mit ESP8266 gelesen, allerdings bin ich nicht schlau geworden, wie lange die Klingelerkennung dauert.
Oft war die Rede von Push- oder Emailnachrichten, dann kommt es auf die eine andere Sekunde nicht an.
Kann ich das Ganze auch mit einem ESP8266 machen, vor allen Dingen mit einer kurzen Latenzzeit, so dass neben dem Siedle-Telefon meine Telefone und mein Handy (fast) gleichzeitig klingeln?
Als Lösung schwebt mir folgendes vor:
- Da 18V DC ohne Klingeln und 22V mit Klingeln anliegen, wäre eine entsprechend ausgelegte Z-Diode sicher sinnvoll, bevor man auf einen GPIO geht.
Welche Software könnte ich dafür einsetzen? Geht ESPEasy? - In ESPEasy kann man ein Device zur Spannungsmessung auswählen:
Voltage & Current (DC) - INA219 (https://www.adafruit.com/product/904 (https://www.adafruit.com/product/904).
Mit diesem Gerät müsste es dann ohne Z-Diode gehen.
Kann ich über dieses Gerät 18 oder 22V auf den ESP geben? Müsste ja eigentlich gehen nach der Beschreibung.
Falls jemand eine Klingelerkennung mit einem ESP8266 umgesetzt hat, unabhängig von meiner Voraussetzung mit dem Siedle-Telefon, dann wäre ich daran interessiert, wie die Erfahrung mit der Latenzzeit ist.
Viele Grüße Gisbert
Hall,
Ich habe genau das mit einem ESP8266 umgesetzt. Ich gehe mit einer 18V Z-Diode auf einen Optokoppler und dahinter dann auf einen GPIO des ESP.
Zunächst hatte ich auch ESPEasy im Einsatz, damit war ich jedoch nicht zufrieden. Ich musste eine Impulsverlängerung mit einem NE555 bauen damit der überhaupt zuverlässig die Impulse mitkriegt. Aber auch dann lief ESPEasy bei mir nicht stabil, nach einigen Tagen ontime hat der ESP nicht mehr reagiert und musste resetten werden (an anderer Stelle habe ich seltsamerweise die selbe ESPEasy-Version auf dem selben Board problemlos als Zähler im Einsatz). Letztendlich habe ich mir dann selbst einen einfachen Code in der ArduinoIDE zusammen gebaut der beim Schalten per MQTT an FHEM meldet. FHEM lässt dann über den SIPClient über die Fritzbox das Telefon klingeln. Ohne es je gemessen zu haben würde ich sagen dass die Verzögerung in Summe deutlich unter 1s liegt.
Ein großer Einfluss ist das Telefon selbst, mein altes Mobiltelefon hat erst einige Sekunden nach Beginn des Anrufs beginnen zu klingeln. Das neue Gigaset ist da deutlich flotter.
Die von dir beschriebene Spannungsmessung habe ich per Spannungsteiler auf den internen ADC auch versucht, die Latenz war furchtbar lange, es musste die Klingel mehrere Sekunden lang gedrückt werden damit überhaupt etwas ankam.
Gruß Florian
Hallo Florian,
super, dass du anscheinend eine gut brauchbare Lösung entwickelt hast.
Kannst du mir noch etwas zum eingesetzten Optokoppler sagen, Typ etc? Ich hatte solche Teile noch nicht im Einsatz.
Kannst du deinen Sketch mit mir teilen? MQTT benutze ich bereits in Fhem.
Viele Grüße Gisbert
Der Optokoppler müsste der EL817 sein, es müsste aber auch jeder andere Typ gehen. Wichtig ist der Vorwiderstand in Reihe zur Z-Diode.
Denk Sketch muss ich raus suchen, kann ich die Tage mal hochladen. War aber im Prinzip ein "ESP8266 MQTT Button Example" .
Gruß Florian
Hallo Florian,
vielen Dank für deine Antwort.
Das hört sich ja viel versprechend an, bin dann auf deinen Sketch gespannt.
Welchen Vorwiderstand benötige ich denn?
Ich hab jetzt Z-Dioden mit 20V / 500mW bestellt. Gehen die auch, und was wäre der Vorwiderstand dann, oder müssen es 18V Z-Dioden sein?
Montage in Reihe, d.h. hintereinander. Ist die Reihenfolge Optokoppler / Widerstand wichtig? Falls ja, kannst du sie ausgehend vom Siedlegerät angeben?
Viele Grüße Gisbert
Der Widerstandswert kommt auf deinem Optokoppler an. Im Datenblatt des Optokopplers stehen der LED Strom und die Spannung, dann wird der Widerstand wie der Vorwiderstand einer LED berechnet. Der Strom kann bei den meisten Optokopplern deutlich unter dem Maximalstrom liegen, ist wohl besser für die Lebensdauer und auf Geschwindigkeit kommt es ja hier nicht an. Ich hab es so angeschlossen:
+ Z-Diode Widerstand Optokoppler GND
Hallo Florian,
mal noch eine Frage.
Warum muss man überhaupt über einem Optokoppler auf den ESP8266 gehen?
Wenn ich eine 20V Z-Diode benutze, dann lässt die doch nur die Spannung über 20V durch. Macht im Falle des Klingelns 22 - 20V = 2V; ohne Klingeln liegt keine Spannung an, richtig?
Das müsste der ESP doch vertragen, oder ist die Stromstärke das Problem? Wenn ja, könnte man das mit einem Widerstand begrenzen?
Viele Grüße Gisbert
Das stimmt nicht ganz so, die Z-Diode wird bei Überschreiten der Durchbruchsspannung schlagartig sehr gut leitent, d.h. der Strom steigt schlagartig an und muss dann durch den Widerstand begrenzt werden.
Optokoppler ist bei den Spannungen sicherlich kein Muss, aber es ist eigentlich nicht kompliziert und ich hatte alles da. Zudem hast du eine sichere galvanische Trennung. Vielleicht hätte aber auch ein einfacher Spannungsteiler gereicht :-)
Anbei noch mein Sketch:
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
int BUTTON_PIN = D5; //button is connected to GPIO pin D1
// Update these with values suitable for your network.
const char* ssid = "SSID";
const char* password = "Password";
const char* mqtt_server = "MQTT-server IP";
WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg;
char topic[34] ="topicname"; // adjust char length according to length of topic name
int last_stat;
void setup_wifi() {
delay(100);
// We start by connecting to a WiFi network
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
Serial.print(".");
}
randomSeed(micros());
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
void callback(char* topic, byte* payload, unsigned int length)
{
} //end callback
void reconnect() {
// Loop until we're reconnected
while (!client.connected())
{
Serial.print("Attempting MQTT connection...");
// Create a random client ID
String clientId = "ESP8266Client-";
clientId += String(random(0xffff), HEX);
// Attempt to connect
//if you MQTT broker has clientID,username and password
//please change following line to if (client.connect(clientId,userName,passWord))
if (client.connect(clientId.c_str()))
{
Serial.println("connected");
//once connected to MQTT broker, subscribe command if any
client.subscribe("OsoyooCommand");
} else {
Serial.print("failed, rc=");
Serial.print(client.state());
Serial.println(" try again in 5 seconds");
// Wait 5 seconds before retrying
delay(5000);
}
}
} //end reconnect()
void setup() {
Serial.begin(115200);
setup_wifi();
client.setServer(mqtt_server, 1883);
client.setCallback(callback);
pinMode(BUTTON_PIN,INPUT);
}
void loop() {
if (!client.connected()) {
reconnect();
}
client.loop();
long now = millis();
int status;
status=digitalRead(BUTTON_PIN);
if(status==HIGH && last_stat == 0)
{
String msg= "1";
char message[2];
msg.toCharArray(message,2);
Serial.println(message);
//publish sensor data to MQTT broker
client.publish(topic, message);
last_stat = 1;
delay(1000);
}
else if(status==LOW && last_stat == 1)
{
String msg= "0";
char message[2];
msg.toCharArray(message,2);
Serial.println(message);
Serial.println(msg);
//publish sensor data to MQTT broker
client.publish(topic, message);
last_stat = 0;
}
}
Hallo F.R.
meine Optokoppler PC817 Sharp sind eingetroffen, ich komme jedoch nicht mit der Schaltung zurecht.
Auf der Eingangsseite habe ich einen Vorwiderstand so geschaltet, dass ca. 1.2V auf die LED des Optokopplers gehen.
In meinem Testaufbau habe ich wie im Anhang dargestellt:
V(Input) = 3,4 V
RD = 110 Ohm
Vcc = 3,4 V (im Testaufbau identisch V(Input))
RL = 330 Ohm (Arbeitswiderstand)
Ich messe dann V(Ouptput) = 0,234 V und 8,7 mA - soweit so gut.
Hier: http://henrysbench.capnfatz.com/henrys-bench/arduino-projects-tips-and-more/esp8266ex-gpio-high-and-low-input-thresholds/ (http://henrysbench.capnfatz.com/henrys-bench/arduino-projects-tips-and-more/esp8266ex-gpio-high-and-low-input-thresholds/)
wird gesagt, dass ein ESP8266 mindestens 2,475 V bei einem GPIO benötigt, um beim Input ein HIGH zu registrieren.
Die Stromstärke darf nur max. 12 mA betragen.
Wie muss die Schaltung beim Optokoppler aussehen?
Welcher Arbeitswiderstand muss eingesetzt werden und welche Spannung ergibt sich für den GPIO beim ESP8266?
Viele Grüße Gisbert
Also ich habe den Optokopplerausgang einfach zwischen den GPIO und GND gehängt, ich bin mir nicht mehr sicher ob ich noch einen Widerstand in Reihe hatte um den Strom zu begrenzen.
Welchen Widerstand misst du denn, wenn der Eingang spannungslos ist und welchen wenn die Schaltspannung anliegt?
Hallo F.R. und alle anderen, die Interesse am Nachbau haben.
Seit letzten Sonntag läuft das Projekt rund.
Ich hab das Ganze in einem Gefäß (Marmeladenglas mit durchbohrtem Deckel - eine eigenwillige, dennoch sichere Lösung) im Schaltschrank plaziert, in dem der Siedle-Trafo sitzt.
Ich werde das Projekt hier genau beschreiben, damit andere eine brauchbare Vorlage für ihren eigenen Nachbau haben.
[Edit]: Beschreibung des Projektes
Schaltung laut Anhang
Input: 18V (ohne Klingeln), 22V (mit Klingeln)
Z-Diode 20V, 500mW
RD: 330 Ohm
Optokoppler: PC817 Sharp
VCC: 3.4V (identisch zur Spannung für den ESP8266 (in meinem Fall ein ESP8266-01)
R: 1567 Ohm (3 parallel geschaltete 4700 Ohm Widerstände, ich hatte keine anderen zur Verfügung)
Output: GPIO2
Als ESP8266 hab ich das Modell ESP8266-01 benutzt.
Mit dieser Schaltung liegt an GPIO2 keine Spannung beim Klingeln an (im Sketch <String msg = "0";>) und Spannung, wenn es nicht klingelt (im Sketch <String msg = "1";>).
(Kann sein, dass es genau anders herum ist, da ich mir leider nicht direkt Notizen gemacht habe, und es nicht abwarten konnte, die Schaltung nach dem Testen direkt zu verbauen.
Ich möchte sie jetzt nur ungern für Dokumentationszwecke wieder aus dem Schaltschrank ausbauen.)
Den Sketch habe ich noch etwas erweitert um den WifiManager:
/*
Klingelerkennung an GPIO2
*/
#include <ESP8266WiFi.h>
#include <DNSServer.h>
#include <ESP8266WebServer.h>
#include <WiFiManager.h>
#include <PubSubClient.h>
// Button is connected to GPIO pin 2
int BUTTON_PIN = 2;
// Update these with values suitable for your network.
const char* mqttServer = "192.168.xxx.xx";
const int mqttPort = 1883;
const char* mqttUser = "userID";
const char* mqttPassword = "userPassword";
WiFiClient espClient;
PubSubClient client(espClient);
char msg;
char topic[34] ="Klingelerkennung"; // adjust char length according to length of topic name
int last_stat;
void callback(char* topic, byte* payload, unsigned int length)
{
}
void reconnect()
{
while (!client.connected())
{
Serial.print("Attempting MQTT connection...");
// Create a random client ID
String clientId = "ESP8266Client-";
clientId += String(random(0xffff), HEX);
// Attempt to connect
// if you MQTT broker has clientID, username and password
// please change following line to if (client.connect(clientId,userName,passWord))
if (client.connect(clientId.c_str(), mqttUser, mqttPassword))
{
Serial.println("connected");
//once connected to MQTT broker, subscribe command if any
client.subscribe("Test");
} else
{
Serial.print("failed, rc=");
Serial.print(client.state());
Serial.println(" try again in 5 seconds");
// Wait 5 seconds before retrying
delay(5000);
}
}
}
void setup()
{
Serial.begin(115200);
WiFiManager wifiManager;
wifiManager.autoConnect("Klingelerkennung");
Serial.println("");
Serial.println("WiFi connected");
client.setServer(mqttServer, mqttPort);
client.setCallback(callback);
pinMode(BUTTON_PIN,INPUT);
}
void loop()
{
if (!client.connected())
{
reconnect();
}
client.loop();
int status;
status = digitalRead(BUTTON_PIN);
if(status == HIGH && last_stat == 0)
{
String msg = "1";
char message[2];
msg.toCharArray(message,2);
Serial.println(message);
client.publish(topic, message);
last_stat = 1;
delay(1000);
}
else if(status == LOW && last_stat == 1)
{
String msg = "0";
char message[2];
msg.toCharArray(message,2);
Serial.println(message);
Serial.println(msg);
client.publish(topic, message);
last_stat = 0;
delay(1000);
}
}
Auf den RPi habe ich einen SIP-Client eingerichtet, den ich sinnigerweise Tuerklingel in Fhem und Haustürklingel in der Fritzbox genannt habe:
defmod Tuerklingel SIP
attr Tuerklingel T2S_Device mytext2speech
attr Tuerklingel audio_converter sox
attr Tuerklingel group FRITZBOX
attr Tuerklingel icon it_telephone
attr Tuerklingel room FritzBox
attr Tuerklingel sip_dtmf_loop once
attr Tuerklingel sip_dtmf_send audio
attr Tuerklingel sip_dtmf_size 2
attr Tuerklingel sip_elbc yes
attr Tuerklingel sip_from sip:111@fritz.box - eigene Nummer vergeben
attr Tuerklingel sip_ip 192.168.xxx.xx
attr Tuerklingel sip_listen none
attr Tuerklingel sip_port 5060
attr Tuerklingel sip_registrar 192.168.178.1
attr Tuerklingel sip_ringtime 30
attr Tuerklingel sip_user 111 - eigene Nummer vergeben
Es wird ein Device Klingel angelegt, welches über MQTT Informationen vom ESP8266 erhält:
defmod Klingel MQTT_DEVICE
attr Klingel IODev MyBroker
attr Klingel eventMap 1.000:aus 0.000:an
attr Klingel icon ring
attr Klingel room FritzBox,Mobile
attr Klingel stateFormat Klingel: Klingel.an.aus<br/>Zeitstempel
attr Klingel subscribeReading_Klingelerkennung Klingelerkennung
attr Klingel userReadings Zeitstempel {substr(ReadingsTimestamp('Klingel','Klingelerkennung',''),0,19)}, \
Klingel.an.aus {sprintf('%.3f', ReadingsVal('Klingel','Klingelerkennung',''))}, \
Klingel.diagram {sprintf('%.0f', ReadingsVal('Klingel','Klingelerkennung',''))}
Das Klingelereignis wird zuverlässig mit einem DOIF abgefragt:
defmod Klingeln DOIF ([Klingel:Klingelerkennung] == 0) (setreading Klingel Klingel.diagram 0) (set Tuerklingel call **701 12) \ - 701 ist normale Telefon, dass beim Klingeln an der Haustür läutet, im meinem Fall ein Gruppenanruf, d.h. es läuten alle Telefone im Haus
DOELSEIF ([Klingel:Klingelerkennung] == 1 and ({ReadingsAge('Klingel','Klingelerkennung','')} le 30)) (setreading Klingel Klingel.diagram 1) \
DOELSEIF ([?Klingel:Klingelerkennung] == 1 and [+600]) (setreading Klingel Klingel.diagram 1)
attr Klingeln devStateIcon .*:fts_shutter_1w_0
attr Klingeln do always
attr Klingeln icon ring
attr Klingeln room FritzBox
Beim Klingeln melden sich die Telefone mit "Haustürklingel".
Es ist praktisch keine Verzögerung feststellbar; die Telefone fangen augenblicklich alle an zu bimmeln.
Das Ganze wird dann noch geloggt und als Grafik ausgewertet (siehe Anhang).
Last but not least, der Dank gebührt F.R., ohne dessen Anleitung ich das Projekt nicht hätte realisieren können.
Viele Grüße Gisbert
Hallo,
ich muss mich an die Forumsgemeinde wenden, weil mein ESP seit einer Woche ein seltsames Verhalten zeigt.
Über ein Jahr gabe es nicht die kleinste Klage, alles lief wie am Schnürchen: der ESP, die Subskription per MQTT in Fhem, die Weitergabe zur Fritzbox zum Klingeln der DECT-Telfeone, Meldung per Telegram.
Jetzt ist der ESP seit einer Woche heute bereits das zweite Mal per ping nicht mehr erreichbar, also quasi tot.
Stromlos machen und ihn wieder mit Saft versorgen hat ihn beim letzten Mal sofort wieder belebt.
Aber das kann's ja nicht sein, dass ich nicht mitbekomme, wenn es klingelt, bzw. dass die DECT-Telefone nicht klingeln.
An der Verbindungsqualität zum nächsten AP kann es eigentlich nicht liegen, die war immer erstklassig gut - zumindest, solange er erreichbar war.
Der angehängte Sketch (im Thread oben angehängt) macht ja im wesentlichen nicht mehr als den Zustand des GPIO2 zu senden, wenn er sich geändert hat.
Ich frage mich jetzt, ob eine andere Software, z.B. Tasmota stabiler laufen könnte.
Habt ihr eine Idee, wie ich hier vorgehen könnte?
Viele Grüße Gisbert
eine ganz andere Idee für den Sketch ....
Lege den Optokoppler auf den Reset
in dem Sketch sendest Du einfach nur noch einmal per MQTT Deine Meldung raus und schickst diesen dann in den DeepSleep - er wird ja wieder durch den Reset aufgeweckt. Das sollte auch fast in Realtime sein.
Hallo Ralf,
danke für die Antwort.
Deine Vorschlag verstehe so dreiviertel, aber wie soll ich das umsetzen?
Kannst du einen Vorschlag für den Arduino-Sketch machen, und an welchen PIN des ESP6266-01 müsste ich den Optokoppler dranhängen?
DeepSleep schient bei dem ESP8266-01 anscheinend nur mit einer elendigen Fummelei machbar zu sein, wenn man diesem (https://www.instructables.com/id/Enable-DeepSleep-on-an-ESP8266-01/) Beitrag glauben kann.
Ich hab bisher zumindest mit DeepSleep und ESP's noch keine Erfahrungen gesammelt.
Viele Grüße Gisbert
Hallo Joachim,
vielen Dank für deine Info. Wenn es tatsächlich so ist, dass es ein paar Sekunden dauert, bis das Wlan aufgebaut, und alles weitere in Fhem abgearbeitet ist, dann ist das keine Option für mich. Ich hätte die Reaktion gerne in Echtzeit, oder zumindest so gut wie.
Viele Grüße Gisbert
Hallo Gisbert,
ups ich hab den Beitrag irgendwie gelöscht.
War mir nicht mehr sicher aber ich hab nachgesehen:
wenn du ein externes Signal zum Aufwecken hast/hättest, dann brauchst du die Fummelei nicht machen (ich hab es mal gemacht, echt übel. Weniger das Löten, mehr dass es auch hält ;) ).
Aber ja, das WLAN ruht und wird dann aufgebaut.
Ich habe wo gelesen, dass es auch unter einer Sekunde (mit fixer IP) gehen soll.
Bei meinen Versuchen waren es aber immer mind. 1-2 Sekunden (3-4 mit Senden).
Gruß, Joachim
Zitat von: Gisbert am 02 Februar 2019, 14:45:56
Hallo Ralf,
danke für die Antwort.
Deine Vorschlag verstehe so dreiviertel, aber wie soll ich das umsetzen?
Kannst du einen Vorschlag für den Arduino-Sketch machen, und an welchen PIN des ESP6266-01 müsste ich den Optokoppler dranhängen?
DeepSleep schient bei dem ESP8266-01 anscheinend nur mit einer elendigen Fummelei machbar zu sein, wenn man diesem (https://www.instructables.com/id/Enable-DeepSleep-on-an-ESP8266-01/) Beitrag glauben kann.
Ich hab bisher zumindest mit DeepSleep und ESP's noch keine Erfahrungen gesammelt.
Viele Grüße Gisbert
Du willst ja auch gar nicht wirklich aus dem DeepSleep wieder raus ;-)
Im Prinzip sieht Dein Programm/Sketch jetzt so aus:
ConnectWifi
Publish MQTT Message
DeepSleepmit einem Reset fängt der wieder bei Null an :-)
Hardware:
Reset ist Low Aktiv --> Reset muss kurz auf Masse gezogen werden also ungefähr so
Vcc (3,3V) --> Vorwiederstand ca. 220-470 Ohm (so aus dem Kopf geschätzt) --> Reset
und Ausgang Optokoppler; den anderen Pin vom Optokoppler (-->) dann auf Masse
und wenn dann evtl mehrmals schnell geklingelt wird oder die Taste zu extrem prellt, kommen halt nicht alle davon durch, aber der letzte gewinnt immer und ich vermute mit einer festen IP Adresse kommst Du bestimmt auf ca. 300-400ms bis zum Deep Sleep
Hallo Ralf,
ich hab deinen Vorschlag bzw. die Umsetzung noch nicht verstanden, zumindest nicht soweit, dass ich ihn umsetzen könnte.
Wenn das Problem größer werden sollte, werde ich mich damit näher auseinandersetzen.
Viele Grüße Gisbert