Fritzbox-Tuerklingel V2

Fritzbox WLAN Türklingel Version 2

Das ist jetzt die Version 2 meiner Interpretation der Fritzbox Türklingel.
Die Version 1 gibt es hier: Version 1

Es hat sich in der Kommunikation mit Nachbauern gezeigt das die meisten Probleme mit der Arduino IDE haben. Entweder läuft sie garnicht oder produziert nur Mist. Kein Geheimnis und auch keine neue Erkenntnis. Da aber einige individuelle Parameter eingegeben werden müssen musste die Arduino IDE irgendwie umgangen werden.
Die Lösung ist der "Wifimanager". Er vertrug sich zwar zunächst nicht mit der TR064 Library, das lies sich aber durch Anpassungen beheben.
Drei Parameter: die Daten für das TR064 Protokoll müssen leider über die Arduino IDE eingestellt werden. Der Wifimanager konnte zwar die entsprechenden Eingabefelder bereitstellen. Doch die so erfassten Daten führten zu unkontrollierten HW Watchdog Resets der ESP8266 HW.

Über den Wifimanager können SSID und das Passwort erfasst werden. Das funktioniert problemlos. Bei einem vorprogrammierten Modul trage ich diese Parameter fest ein. Bei einem Wechsel der Wlan Umgebung kann dann über die Config Taste eine neue Wifi Verbindung konfiguriert werden.

Ist der Config Modus aktiviert erscheint in der WLAN-Übersicht des PC folgendes WLAN:

Auf VERBINDEN drücken danach wird der Standardbrowser geöffnet:

Auf "Configure WiFi" drücken. Die WiFi Umgebung wird gescant und die gefunden Wifi werden angezeigt:

Das gewünschte Netz anwählen und das passende Password eingeben. Danach wird die WiFi Klingel zurückgesetzt und es wird ein Ruf abgesetzt der das Telefon klingeln lässt. Hat es geklappt ist die Konfiguration abgeschlossen.

-------------------------------------------------------------------------------------------------------------------------------------------------------------------
Desweiteren wurde die HW angepasst. Hinzu gekommen sind:

- Config LED
- Config Taste
- Stromversorgungsanschluß

Details werden später beschrieben.

Die alte Beschreibung mit den Anpassungen für die neuen Funktionen.
-------------------------------------------------------------------------------------------------------------------------------------------------------------------

Seitdem AVM seine Fritzboxen auf TR064 Protokoll umgestellt hat und Telnet eingestellt hat, ist es sehr einfach geworden eine Fritzbox per WLAN anzusteuern. Seid 2018 ist das so und es sind auch gleich Projekte im I-Net aufgetaucht. Ein sehr beliebtes Projekt ist die Wifi Klingel. D.h. es klingelt Jemand an der Haustür und das Telefon klingelt mit. Das ist sehr praktisch wenn man im Haus unterwegs ist an Orten an denen man die Türklingel nicht mehr hört, aber ein DECT Telefon noch Empfang hat.
In Zeiten der analogen Telefonanlagen war das kein Problem es gab sogar Türsprechstationen die telefonieren konnte, alles über Zweidraht Verbindungen. In Zeiten der IP-Telefonie muss man etwas andere Wege gehen.

Benötigt wird eine Schnittstelle zur Klingelanlage und eine ESP8266 WLAN Platine, in meinem Projekt kommt die WEMOS D1 mini Platine zum Einsatz. Sie ist zu den Arduino Treibern für den ESP8266 Chipsatz kompatibel.

Die Schnittstelle
Alle Projekte die ich bisher im I-net gefunden hatte benutzten einen Brückgleichrichter und einen Optokoppler um eine potentialfreie Verbindung zur WLAN Platine herzustellen. Ich mußte feststellen das diese Schaltung in mehrfach Hausanlagen sehr störanfällig ist. Es klingelt auch dann wenn man nicht gemeint ist sondern der Nachbar. Der Grund sind die langen Kabelwege und die Wechselspannung in den ungeschirmten Klingelleitungen sorgen dafür das der Optokoppler reagiert obwohl er nicht gemeint ist.

Jetzt könnte man anfangen vor den Optokoppler Filterschaltungen zu setzen. Das war mir zu aufwendig denn es gibt einen einfacheren Weg. Klingelanlagen sind für die Ansteuerung Induktiver Bauteile konstruiert. Also wird ein Relais genommen das zur Spannung der Klingelanlage passt. Eine Einweggleichrichtung mit Siebung davor und zum Schutz vor zu hoher Spannung am Relais, eine Zenerdiode passend zur Spulenspannung des Relais. Jetzt klingelt es nur noch wenn man auch gemeint ist ;). Die beiden Schließer im verwendeten Reedrelais steuern eine LED an und den Reset Eingang des WEMOS D1.

Die Stromversorgung
Die Schaltung muss mit Strom versorgt werden. Jetzt könnte man auf die Idee kommen die Versorgungsspannung aus dem Klingeltrafo zu beziehen. Bei Klingelanlagen für nur eine Partei funktioniert das. Wobei man aufpassen muss viele Klingeltrafos haben einen extrem hohen Innenwiderstand was zu starken Spannungszusammenbrüchen führt. Vor allem wenn der Türöffner betätigt wird. Der Effekt: es klingelt nochmal. Diese Eigenschaft der Klingeltrafos ist gewollt, es macht sie Dauerkurzschlußfest. In Mehrparteien Anlagen wird die Sprechstation mit einer Gleichspannung versorgt. Aber auch die kann man nicht nutzen. Denn der Gleichspannung wird das Sprachsignal überlagert. Zapft man diese Spannung an wirds still in der Sprechanlage. Ich habe mich für Batterie Betrieb entschieden. Mit dem verwendeten WLAN Modul komme ich auf eine Laufzeit von Minimum ~390 Tagen mit normalen AA Batterien. Das WEMOS Modul zieht im DeepSleep Modus nur noch 90µA. Wird geklingelt werden 90-100mA für kurze Zeit gezogen.

In der letzten Zeit tauchen vermehrt Clone des WEMOS D1 Mini auf bei denen der Deep Sleep Modus nicht funktioniert und die Batterie schnell entleert wird. Nur der Originale LOLIN WEMOS D1 mini unterstützt den Deep Sleep Modus korrekt. Als Workaround kann die Schaltung direkt über den USB Anschluss der Fritzbox mit 5V versorgt werden.

Programmierung WLAN-Modul
Die Programmierung des WLAN Modules erfolgt über die Arduino IDE. Beschreibungen dazu gibt es zahlreiche im Internet.

Funktionen

Auf der Platine befinden sich zwei Taster:
- Test-Taster zum kontrollieren der WLAN Verbindung. Die grüne LED bleibt dunkel aber die roten reagieren wie oben beschrieben.
- Config-Taster. Um in den Config Modus zu gelangen Config Taste drücken und festhalten, Test Taste drücken und loslassen. Config Taste solange festhalten bis die Config LED leuchtet.

Auf der Platine befindet sich ein DIP-Switch:
- Mit Dip-Switch 1-3 kann in Sekunden Schritten Binär die Klingelzeit eingestellt werden.

Viel Spass beim nachbauen.
Hans Borngräber

Das Prinzip

/*
   Wifi Türklingel Version 2.0 28.12.2020
   (c)Hans Borngräber
   Einstellungen FritzBox siehe seperate Doku
   IDE 1.8.13
   Historie:
   17.10.2019   Integration Batterie Überwachung an Port A0
   06.08.2020   Wifi Daten können Online eingetragen werden per Wifi Manager
   28.12.2020   Debug_level auf NONE gesetzt, in TR064.cpp. Ergibt stabileren Betrieb bei langsamen WLAN.
*/
#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <tr064.h>
#include <DNSServer.h>
#include <ESP8266WebServer.h>
#include <WiFiManager.h>
WiFiServer server(80);                                                                // Web server port number auf 80 setzen
const char USER[] = "***********";                                                    // Fritzbox - Benutzer   <-- muss angepasst werden auf eigene Werte
const char PASSWORD[] = "************";                                               // Fritzbox - Passwort   <-- muss angepasst werden auf eigene Werte
const char FRITZBOX_IP[] = "192.168.178.1";                                           // Fritzbox IP-Adresse   <-- muss angepasst werden auf eigene Werte
const int FRITZBOX_PORT = 49000;                                                      // TR064 - Standard Port
TR064 tr064_connection(FRITZBOX_PORT, FRITZBOX_IP, USER, PASSWORD);                   // An der Fritz-Box anmelden
int Messbereich = 6;                                                                  // Messbereich 6V, über Spannungsteiler eingestellt.
int Messport = A0;                                                                    // Port A0 Analog Eingang
int WLAN = 4;                                                                         // Port D2 WLAN LED
int TR064_LED = 5;                                                                    // Port D1 TR064 LED
int DipSW1 = 13;                                                                      // Port D7 Dip-Switch 1
int DipSW2 = 12;                                                                      // Port D6 Dip-Switch 2
int DipSW3 = 14;                                                                      // Port D5 Dip-Switch 3
int Configsw = 16;                                                                    // Port D0 Config-Switch
int Configled = 0;                                                                    // Port D3 Config-Led
//---------------------------------------------------------------------------------------------------------------------------------------
void setup()
{  pinMode (Configsw, INPUT);                                                        // Config Taste
 pinMode (DipSW1, INPUT);                                                            // Dip-Switch 1
 pinMode (DipSW2, INPUT);                                                            // Dip-Switch 2
 pinMode (DipSW3, INPUT);                                                            // Dip-Switch 3
 Serial.begin(74880);                                                                // Geschwindigkeit serielle Schnittstelle 74880 Baud. Standard WEMOS D1.
 pinMode (Configled, OUTPUT);                                                        // Config LED
 digitalWrite (Configled, HIGH);                                                     // Config LED aus
 pinMode(WLAN, OUTPUT);                                                              // WLAN LED
 digitalWrite(WLAN, HIGH);                                                           // WLAN LED aus
 pinMode(TR064_LED, OUTPUT);                                                         // TR064_LED LED
 digitalWrite(TR064_LED, HIGH);                                                      // TR064_LED LED aus
 WiFiManager wifiManager;                                                            // WiFiManager
 digitalWrite (Configled, LOW);                                                      // Config LED ein
 if (digitalRead(Configsw) == LOW) {                                                 // Configuration löschen wenn Configtaste gedrückt
   wifiManager.resetSettings();
   Serial.println ("***************************");                                   // --------- Debug Meldung
   Serial.println ("Konfigurations Modus aktiv.");                                   // --------- Debug Meldung
   digitalWrite (Configled, LOW);                                                    // Config LED ein
 }
 wifiManager.autoConnect("Wifi-Klingel");                                            // SSID und Passwort werden aus dem eeprom gelesen. Kommt keine Verbindung damit zustande wird
                                                                                     // ein Accesspoint gestartet. Die Schleife läuft solange bis Parameter eingetragen wurden.
 digitalWrite (Configled, HIGH);                                                     // Config LED aus
 Serial.println("Verbunden mit dem WLAN.");                                          // --------- Debug Meldung
 digitalWrite(WLAN, LOW);                                                            // Wifi Verbindung hergestellt. WLAN LED ein
 server.begin();
}
//---------------------------------------------------------------------------------------------------------------------------------------
void loop()
{
 int (verz) = 0;                                                                     // Variable für DipSwitch Wert
 int (Klingelzeit) = 2000;                                                           // Variable für Klingelzeit = 2 sec.
 if (digitalRead(DipSW1) == HIGH) {                                                  // DipSwitch 1 auslesen wenn 1 dann verz +1
   verz = 1;
 }
 if (digitalRead(DipSW2) == HIGH) {                                                  // DipSwitch 2 auslesen wenn 1 dann verz +2
   verz = verz + 2;
 }
 if (digitalRead(DipSW3) == HIGH) {                                                  // DipSwitch 3 auslesen wenn 1 dann verz +4
   verz = verz + 4;
 }
 Klingelzeit = Klingelzeit * verz;                                                   // Klingelzeit mit DipSwitch Wert multiplizieren
 tr064_connection.init();                                                            // TR064 Verbindung herstellen
 
 Serial.println("---------------------------");                                      // --------- Debug Meldung
 Serial.print("Klingelzeit: ");                                                      // --------- Debug Meldung
 Serial.println(Klingelzeit, DEC);                                                   // --------- Debug Meldung
 if (Klingelzeit > 0) {                                                              // Wenn Klingelzeit > 0 wird ein Call abgesetzt
   String tr064_service = "urn:dslforum-org:service:X_VoIP:1";                       // Betriebsart Voice over IP einschalten
   String call_params[][2] = {{"NewX_AVM-DE_PhoneNumber", "**9"}};                   // Die Telefonnummer **9 ist der Fritzbox-Rundruf.
   tr064_connection.action(tr064_service, "X_AVM-DE_DialNumber", call_params, 1);    // Ruf absetzen
   digitalWrite(TR064_LED, LOW);                                                     // TR064_LED LED ein
   delay(Klingelzeit);                                                               // Eingestellte Zeit klingeln
   tr064_connection.action(tr064_service, "X_AVM-DE_DialHangup");                    // Telefon auflegen. Ruf beendet
   digitalWrite(TR064_LED, HIGH);                                                    // TR064_LED LED aus
 }
 else {
   for (int i = 1; i <= 5; i++) {                                                    // Blinkschleife wenn Klingelzeit = 0. Wird 5x durchlaufen
     digitalWrite(TR064_LED, LOW);                                                   // TR064_LED LED ein
     delay(200);                                                                     // Blinkzeit ein 200ms
     digitalWrite(TR064_LED, HIGH);                                                  // TR064_LED LED aus
     delay(200);                                                                     // Blinkzeit aus 200ms
   }
 }
 int Batteriespg = analogRead(Messport);                                             // Batteriespannung messen, an Port A0
 float Spannung = Batteriespg * ( Messbereich / 1023.0);                             // Spannung ausrechnen
 Serial.print ("Messwert: ");                                                        // --------- Debug Meldung
 Serial.println (Spannung);                                                          // --------- Debug Meldung
 if (Spannung > 4.3) {                                                               // Wenn gemessene Spannung größer 4,3V, 2 rote LED blinken lassen
   Serial.println("Batteriespannung OK");                                            // --------- Debug Meldung
   for (int i = 1; i <= 5; i++) {                                                    // Blinkschleife
     digitalWrite(TR064_LED, LOW);                                                   // LED TR064_LED ein
     digitalWrite(WLAN, LOW);                                                        // LED WLAN LED ein
     delay(100);                                                                     // Blinkzeit ein 100ms
     digitalWrite(TR064_LED, HIGH);                                                  // LED TR064_LED aus
     digitalWrite(WLAN, HIGH);                                                       // LED WLAN LED aus
     delay(200);                                                                     // Blinkzeit aus 200ms
   }
 }
 Serial.println ("Gehe jetzt schlafen");                                             // --------- Debug Meldung
 ESP.deepSleep(0);                                                                   // Powersafe Modus ein. Aufwachen mit Reset
}