Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Praktische Anwendungen (Showcase)
    4. Siedle Klingel / Türöffner mit ESP8266 und MQTT

    NEWS

    • ioBroker@Smart Living Forum Solingen, 14.06. - Agenda added

    • ioBroker goes Matter ... Matter Adapter in Stable

    • Monatsrückblick - April 2025

    Siedle Klingel / Türöffner mit ESP8266 und MQTT

    This topic has been deleted. Only users with topic management privileges can see it.
    • Karsten Müller
      Karsten Müller @Eisbaeeer last edited by

      @eisbaeeer Hi, bist du sicher mit b & c? Ich habe auch das Siedle NG 602 im Keller (in der Wohnung eine HTS811-0, die ich nach deiner Anleitung mqttisieren möchte, Teile sind bestellt). Zwischen b und c messe ich 13,4V Wechselstrom (!), da würde vermutlich der bestellte LM2596S DC-DC Wandler nicht funktionieren, oder?
      Zwischen + und - messe ich 23,3V Gleichstrom, könnte auch dieser genommen werden?

      (wobei es momentan schwierig bis unmöglich scheint, irgendwelche Kabel in den beengten Verhältnissen im Sicherungskasten im Keller zu identifizieren, die möglicherweise ein Gegenstück beim Handapparat in der Wohnung haben...)

      IMG_20210412_203759.jpg
      IMG_20210412_203843.jpg
      IMG_20210412_201718.jpg

      Ich habe derzeit schon einen Nuki Opener im Betrieb (3-Parteien-Haus). Die Hauptfunktion (tagsüber Türöffner betätigen wenn es klingelt, "Arztpraxenmodus") funktioniert perfekt und sofort. Leider funktioniert die Klingelsignalweitergabe (an die Nuki Bridge vermutlich?) dort sehr unzuverlässig, "letztes Klingeln" wird oft erst nach Stunden im iobroker aktualisiert, nachdem es soweit ich mich erinnern kann irgendwann schonmal besser funktioniert hatte (benutze Nuki und Nuki Extended Adapter).

      Aber selbst wenn das besser gehen würde, auf den NodeMCU-Bastelspaß freue ich mich trotzdem, zudem würde ich gerne zusätzlich noch das Etagenruf-Signal abgreifen, was der Opener nicht macht - so dass ich anders reagieren kann, wenn jemand an der Tür klingelt (dann ist es vermutlich nicht der Postbote, dem der Opener automatisch die Haustür geöffnet hat und der nur sein Paket im Treppenhaus ablegt).

      Bleibt die Hauptfrage, wie ich den NodeMCU mit Strom versorge. Ohne USB-Netzteil, direkt aus dem Inneren der Siedle wär natürlich schick.
      Kann man nicht ggf. auch die ~15V (/24V beim Klingeln) von Klemme 1 und 7 nehmen? Habe noch keine Erfahrung mit StepDown-Reglern - lassen sich die so einstellen, dass da von 15V - 24V Eingangsspannung immer 5V Ausgangsspannung anliegen? Oder stell ich den bei 15V in auf 5V out, und wenn jemand klingelt liegen plötzlich 8V an und grillen meinen NodeMCU?

      Eisbaeeer 1 Reply Last reply Reply Quote 0
      • Eisbaeeer
        Eisbaeeer Developer @Karsten Müller last edited by Eisbaeeer

        @karsten-müller Ja dein Netzteil ist auch ein anderes. Meines liefert 24V Gleichspannung, deines eben 12V. Sollte aber kein Problem sein, wenn du noch freie Drähte zur Innenstation hast. Es gibt eben unterschiedliche Systeme bei Siedle, welche aber auf ähnlicher Schaltung basieren. Im folgenden Link unten ist genau dein Netzteil verwendet. Dort findest du auch die Schaltpläne für die Stromversorgung.

        https://there.oughta.be/a/smart-doorbell

        Grüße Eisbaeeer

        1 Reply Last reply Reply Quote 0
        • Karsten Müller
          Karsten Müller last edited by Karsten Müller

          IMG_20210417_203332.jpg IMG_20210418_150818.jpg IMG_20210418_185704.jpg
          Danke für die Tipps und die grundsätzliche Schaltung von @Eisbaeeer (meine Elektronikkenntnisse sind ziemlich beschränkt, wusste vorher nicht wirklich was eine Z-Diode macht)! Falls es jemand interessiert, hier noch die tasmota-basierte fertige Umsetzung.

          Damit es am Handapparat aufgeräumter aussieht, habe ich den Nuki Opener gleich noch mit in ein 3D-gedrucktes Gehäuse gepackt, und da es mit dem Strom aus dem Keller vom Siedle-Netzteil nicht geklappt hat und ich daher eh Strom per USB zuführen musste (Loch durch die Wand gebohrt, auf der anderen Seite der Wand gibt es eine Steckdose), konnte ich den Nuki Opener gleich auch noch von Batterie- auf Netzbetrieb umstellen.

          Da ich bisher ESP-mäßig mit tasmota am vertrautesten bin, habe ich das auch hier verwendet. Ich greife sowohl das normale Klingelsignal der Haustür (GPIO4 / D2, Siedle-seitig an Klemme 1 und Klemme 7) als auch den Etagenruftaster (GPIO5 / D1, Siedle-seitig an Klemme 1 und ETR) ab (für letzteres @Eisbaeeer 's Schaltung einfach ohne die Zenerdiode, da hier im nicht gedrückten Zustand 0V anliegen, gedrückt ebenfalls ~24V, Widerstand daher ebenfalls 470Ω).
          59f3dcb8-7240-4b52-a50b-5b6e4e6c02d9-image.png
          Template:
          {"NAME":"SIEDLE Klingel","GPIO":[1,1,321,1,160,161,1,1,1,0,0,0,0,1],"FLAG":0,"BASE":18}

          Switchmode1 und Switchmode2 auf 2 gesetzt, damit die Switches ON sind wenn die Klingel gedrückt wird, und OFF im ungedrückten Zustand.

          Damit die Switches mqtt-Nachrichten schicken, brauchts noch entsprechende Rules, wie unter https://tasmota.github.io/docs/Buttons-and-Switches/#detach-switches-based-on beschrieben.

          Backlog SwitchMode1 2; SwitchTopic1 0
          Backlog Rule1 on Switch1#state do Publish stat/tasmota-doorbell/SWITCH1 %value% endon; Rule1 1
          Backlog SwitchMode2 2; SwitchTopic2 0
          Backlog Rule2 on Switch2#state do Publish stat/tasmota-doorbell/SWITCH2 %value% endon; Rule2 1

          Da ich derzeit iobroker hauptsächlich zur Visualisierung verwende, die meiste Logik aber in FHEM steckt, verarbeite ich die mqtt-Nachrichten dort weiter. Beim Klingeln an der Haustür wird lediglich eine Telegram-Nachricht "Jemand klingelt an der Haustür" verschickt - interessiert mich nur bedingt, da das meist der Paketbote ist, dem vom Nuki Opener tagsüber automatisch die Tür geöffnet wird.
          7a633520-e268-4959-87f6-c5b0ca5489b0-image.png
          Beim Klingen an der Wohnungstür (da will also wirklich jemand persönlich zu uns) gibt's neben einer Nachricht dann noch akustische (Alexa-Durchsagen) und optische (Lichter blinken in verschiedenen Räumen) Signale, damit man das auch in Ecken der Wohnung mitbekommt wo man die Klingel vielleicht nicht hört.

          1 Reply Last reply Reply Quote 0
          • Eisbaeeer
            Eisbaeeer Developer last edited by Eisbaeeer

            Zum Thema Türöffner habe ich nochmals nachgelegt. Ich habe nun meine Außenstation mit einem RFID-Leser nachgerüstet und auch die Siedle Beleuchtung "enhanced".
            Jetzt kann ich per Weboberfläche Zutrittsberechtigungen vergeben und muss nicht die ganze Schließanlage tauschen, wenn mal ein Schlüssel verloren geht.
            Hier ein paar Bilder vom Umbau:

            20210429_220729.jpg
            20210501_144436.jpg
            20210501_145117.jpg
            20210501_153354.jpg
            20210501_162042.jpg
            20210501_162056.jpg

            Leider kann man hier ja keine Videos hochladen. Aber den Rest kann man sich ja vorstellen 😉

            Web.png

            Basti97 Ciaran Baulig Mr English 3 Replies Last reply Reply Quote 0
            • Basti97
              Basti97 Most Active @Eisbaeeer last edited by

              @eisbaeeer Ich bin gerade über deine Firmware gestoßen. Und da habe ich ein paar Fragen.
              Lässt sich die Software über MQTT steuern? Gibt es irgendwo eine Beschreibung was sie alles kann
              Wie muss ich das ganze anschließen?
              Gruß Basti

              Eisbaeeer 1 Reply Last reply Reply Quote 0
              • Eisbaeeer
                Eisbaeeer Developer @Basti97 last edited by Eisbaeeer

                @basti97 Hi Basti
                Ich habe diese Quelle für mich angepasst, bzw. einfach um die WS2812 Funktionen erweitert:

                Master-repo: marelab/esp-rfid

                Du kannst über MQTT so ziemlich alles machen. Hier mal ein Auszug aus der API:

                • Reading all user data over MQTT
                • Sending User data to RFID-DOOR/ESP-RFID over MQTT
                • Sending door open command over MQTT
                • Sending Sync of a RFID-DOOR (IP/Hostname) over MQTT
                • Configure Sync interval over ESP-RFID GUI
                • Deleting all User of a ESP-RFID device over MQTT

                Die Befehle müssen als JSON gesendet werden. Z.B. Tür öffnen mit;

                {
                    cmd:'opendoor',
                    doorip:'(The ESP-RFID IP of the door to open as String)'
                }
                

                Es gibt auch eine fertige Hardware, die ohne weitere Komponenten auskommt.
                Diese findest du hier: maelab RFID-DOOR

                Grüße Eisbaeeer

                P Basti97 2 Replies Last reply Reply Quote 1
                • P
                  pk68 @Eisbaeeer last edited by

                  Hallo Zusammen,

                  mal eine offtopic Frage. Da auf den Bildern hier auch Videosprechanlagen zu sehen sind, kennt jemand eine Möglichkeit das analoge Videosignal in den ioBroker zu bekommen? Ziel wäre, wenn jemand bei Abwesentheit an der Tür klingelt, ein Foto per Telegram aufs Handy zu bekommen.

                  Gruß

                  F 1 Reply Last reply Reply Quote 0
                  • F
                    FloxD @pk68 last edited by FloxD

                    @pk68 Hatte ich auch darüber nachgedacht, dann aber verworfen. Stattdessen in das Aussengehäuse ein Loch gebohrt und eine zusätzliche Fish-eye-Linse (75mm Kabel) mit ESP32 (Materialkosten <10 Euro)untergebracht und bekomme jetzt Fotos der Klingelnden per Telegram 😊

                    D074383F-18F0-4B67-B4E8-3E2A4D4E6F7C.jpeg

                    P 1 Reply Last reply Reply Quote 0
                    • P
                      pk68 @FloxD last edited by

                      @floxd Ja genau so eine Lösung schwebt mir vor. 👍 Leider ist diese Lösung bei einem Mehrfamilienhaus nicht realisierbar.

                      1 Reply Last reply Reply Quote 0
                      • Basti97
                        Basti97 Most Active @Eisbaeeer last edited by

                        @eisbaeeer Danke wie wird dann aus den Siedle Bus ausgewertet. Ob es nun oben (Wohnungstür) oder unten (Haustür) klingelt.
                        Weißt du wo ich das Abgreifen kann und wie ich das umwandeln muss.

                        Eisbaeeer 1 Reply Last reply Reply Quote 0
                        • Eisbaeeer
                          Eisbaeeer Developer @Basti97 last edited by

                          @basti97 Hi. Bei Siedle wird das mit 7.1 und 7.2 unterschieden. Die Punktierung sind die entsprechenden Stockwerke bzw. Wohnungen. Schau dir mal das Schaltbild der Siedle Anlage an. Da sieht man das ganz gut.
                          Die RFID Schaltung wertet aber das Türklingeln nicht mit aus. Das musst du dann schon an dem jeweiligen Handapparat machen.

                          Basti97 ChristophCaina 2 Replies Last reply Reply Quote 0
                          • C
                            claus1993 @michif100 last edited by

                            @michif100 said in Siedle Klingel / Türöffner mit ESP8266 und MQTT:

                            Hallo zusammen,

                            bei mir klappt alles wunderbar, also mit HTS-811 und 18/24 V DC.
                            Benutze eine 20V Z-Diode und 480 Ohm Widerstand vor dem Ontokoppler.
                            Aktuell betreibe ich die NodeMCU per USB.

                            habe bei mir die gleiche Siedle Anlage verbaut und habe ein paar Fragen an dich. Hoffe du kannst mir behilflich sein damit ich zukünftig auch mein Klingelsignal im ioBroker habe 🙂

                            An welchen Klemmen von Siedle hast du den die Bauteile angeklemmt?
                            Wo hast du die Spannung abgenommen?

                            Eisbaeeer 1 Reply Last reply Reply Quote 0
                            • Eisbaeeer
                              Eisbaeeer Developer @claus1993 last edited by Eisbaeeer

                              @claus1993 Hatte ich schon hier beschrieben.

                              Du benötigst die Klemmen 7 und 1. Die Versorgungsspannung musst du dir irgend wo herholen. Im besten Fall hast du noch 2 Adern frei und kannst dir vom Netzteil die benötigte Spannung holen.
                              Gruß Eisbaeeer

                              1 Reply Last reply Reply Quote 1
                              • Basti97
                                Basti97 Most Active @Eisbaeeer last edited by

                                @eisbaeeer
                                Ich habe diese Klingel von Siedle mit folgender Bezeichnung HTS 71101

                                Und so sieht die Platine aus. Bis jetzt habe ich nur das Etagen Klingeln abgegriffen.
                                Die weiteren Punkte habe ich noch nicht gefunden.
                                s-l1600.jpg

                                945fc44e-1cdd-41c9-b0fa-a53b2edf5281-grafik.png

                                Wenn ich das richtig gelesen habe kann ich nur mit der Software meine Tür per RFID öffnen bzw verwalten. Da ich mich bis jetzt sonst noch nie mit Bus fähigen Klingelanlagen beschäftigt habe.

                                1 Reply Last reply Reply Quote 0
                                • Basti97
                                  Basti97 Most Active @Banjo89 last edited by

                                  @banjo89 Ich habe zwar unten bereits ein Kommentar wie man die Siedle HTS711 smart machen kann. Nun habe ich gesehen das du die gleiche Version wie ich habe. Kannst du mir bitte mal Beschreiben wie du das ganze umgesetzt hast + benötigte Bauelemente. Bis jetzt werte ich nur den Etagen Klingel per Logo 8 aus. Bei dir sieht es auf dem ersten Blick so einfach aus. 🙂

                                  Danke für deine Hilfe 🙂

                                  1 Reply Last reply Reply Quote 0
                                  • Basti97
                                    Basti97 Most Active last edited by

                                    @Banjo89 Kannst du mir bitte dein Schaltplan zu deiner siedle schicken da ich verscheinlich eine ähnliche habe.😁😁

                                    1 Reply Last reply Reply Quote 0
                                    • Ciaran Baulig
                                      Ciaran Baulig @Eisbaeeer last edited by

                                      @eisbaeeer kannst deinen Umbau mit rfid mal ein wenig genauer erläutern/Pläne ergänzen? Finde die Idee mega!

                                      1 Reply Last reply Reply Quote 0
                                      • S
                                        StefanR1984 last edited by StefanR1984

                                        Edit: Hat sich erledigt. Läuft super! Besten Dank. Lag an einer kalten Lötstelle.

                                        Vlg

                                        Hallo zusammen,

                                        ich bin neu im Forum und habe eine Frage bezüglich der ESP8266 mit einer Siedle HTA 711-01

                                        Es liegt zwischen 1 und 7 20V Spannung an und ich bin nach Eisbeers Bauplan vorgeganen.

                                        Zur Ausführung des Scipts verwende ich einen ESP8266 mit einem Arduino Script:

                                        // https://www.mikrocontroller.net/topic/444994?goto=new#new
                                        
                                        #include <ESP8266WiFi.h>
                                        #include <WiFiUdp.h>
                                        #include <WiFiClientSecure.h> 
                                        #include <UniversalTelegramBot.h>
                                        #include <ArduinoJson.h>
                                        
                                        
                                        //------------------------------------------------
                                        // configuration with fix ip
                                        //------------------------------------------------
                                        
                                        // MAC-ID: 
                                        
                                        // Telegram BOT Token (Get from Botfather)
                                        #define botToken "********************************************"
                                        
                                        WiFiClientSecure secured_client;
                                        UniversalTelegramBot bot(botToken, secured_client);
                                        
                                        //Deine User ID oder Chat_ID
                                        #define userID "********************************************"
                                        
                                        
                                        
                                        X509List cert(TELEGRAM_CERTIFICATE_ROOT);
                                        
                                        
                                        
                                        // wlan param
                                        const char* ssid    = "********************************************";
                                        const char* WLANKEY = "********************************************";   
                                        
                                        // sip params
                                        const char *sipip       = "192.168.5.1";
                                        int         sipport     = 5060;
                                        const char *sipuser     = "********************************************";         // angelegter Nutzername vom Telefoniegerät
                                        const char *sippasswd   = "********************************************";           // PW vom Nutzername vom Telefoniegerät
                                        
                                        // dial params
                                        const char *sipdialnr   = "**701";                // Rundruf an alle         
                                        const char *sipdialtext = "Haustuer";
                                        
                                        // network params
                                        const char *ip          = "192.168.5.20";     // ESP IP Adresse eintragen
                                        const char *gw          = "192.168.5.1";      
                                        const char *mask        = "255.255.255.0";
                                        const char *dns         = "192.168.5.1";
                                        //------------------------------------------------
                                        
                                        #define DEBUGLOG
                                        WiFiUDP Udp;
                                        
                                        /////////////////////////////////////////////////////////////////////////////////////////////////////
                                        //
                                        // hardware and api independent Sip class
                                        //
                                        /////////////////////////////////////////////////////////////////////////////////////////////////////
                                        
                                        class Sip
                                        {
                                            char       *pbuf;
                                            size_t      lbuf;
                                            char        caRead[256];
                                        
                                            const char *pSipIp;
                                            int         iSipPort;
                                            const char *pSipUser;
                                            const char *pSipPassWd;
                                            const char *pMyIp;
                                            int         iMyPort;
                                            const char *pDialNr;
                                            const char *pDialDesc;
                                        
                                            uint32_t    callid;
                                            uint32_t    tagid;
                                            uint32_t    branchid;
                                        
                                            uint32_t    iAuthCnt;       // original 'int'
                                            uint32_t    iRingTime;
                                            uint32_t    iMaxTime;
                                            uint32_t    iDialRetries;   // original 'int'
                                            int         iLastCSeq;
                                            void        AddSipLine(const char* constFormat , ... );
                                            bool        AddCopySipLine(const char *p, const char *psearch);
                                            bool        ParseParameter(char *dest, int destlen, const char *name, const char *line, char cq = '\"');
                                            bool        ParseReturnParams(const char *p);
                                            int         GrepInteger(const char *p, const char *psearch);
                                            void        Ack(const char *pIn);
                                            void        Cancel(int seqn);
                                            void        Bye(int cseq);
                                            void        Ok(const char *pIn);
                                            void        Invite(const char *pIn = 0);
                                        
                                            uint32_t    Millis();
                                            uint32_t    Random();
                                            int         SendUdp();
                                            void        MakeMd5Digest(char *pOutHex33, char *pIn);
                                        
                                          public:
                                            Sip(char *pBuf, size_t lBuf);
                                            void        Init(const char *SipIp, int SipPort, const char *MyIp, int MyPort, const char *SipUser, const char *SipPassWd, int MaxDialSec = 10); //10
                                            void        HandleUdpPacket(const char *p);
                                            bool        Dial(const char *DialNr, const char *DialDesc = "");
                                            bool        IsBusy() {
                                              return iRingTime != 0;
                                            }
                                        };
                                        
                                        Sip::Sip(char *pBuf, size_t lBuf)
                                        {
                                          pbuf = pBuf;
                                          lbuf = lBuf;
                                          pDialNr = "";
                                          pDialDesc = "";
                                        }
                                        
                                        bool Sip::Dial(const char *DialNr, const char *DialDesc)
                                        {
                                          if (iRingTime)
                                            return false;
                                        
                                          iDialRetries = 0;
                                          pDialNr = DialNr;
                                          pDialDesc = DialDesc;
                                          Invite();
                                          iDialRetries++;
                                          iRingTime = Millis();
                                          return true;
                                        }
                                        
                                        void Sip::Cancel(int cseq)
                                        {
                                          if (caRead[0] == 0)
                                            return;
                                          pbuf[0] = 0;
                                          AddSipLine("%s sip:%s@%s SIP/2.0",  "CANCEL", pDialNr, pSipIp);
                                          AddSipLine("%s",  caRead);
                                          AddSipLine("CSeq: %i %s",  cseq, "CANCEL");
                                          AddSipLine("Max-Forwards: 70");
                                          AddSipLine("User-Agent: sip-client/0.0.1");
                                          AddSipLine("Content-Length: 0");
                                          AddSipLine("");
                                          SendUdp();
                                        }
                                        
                                        void Sip::Bye(int cseq)
                                        {
                                          if (caRead[0] == 0)
                                            return;
                                          pbuf[0] = 0;
                                          AddSipLine("%s sip:%s@%s SIP/2.0",  "BYE", pDialNr, pSipIp);
                                          AddSipLine("%s",  caRead);
                                          AddSipLine("CSeq: %i %s", cseq, "BYE");
                                          AddSipLine("Max-Forwards: 70");
                                          AddSipLine("User-Agent: sip-client/0.0.1");
                                          AddSipLine("Content-Length: 0");
                                          AddSipLine("");
                                          SendUdp();
                                        }
                                        
                                        void Sip::Ack(const char *p)
                                        {
                                          char ca[32];
                                          bool b = ParseParameter(ca, (int)sizeof(ca), "To: <", p, '>');
                                          if (!b)
                                            return;
                                        
                                          pbuf[0] = 0;
                                          AddSipLine("ACK %s SIP/2.0", ca);
                                          AddCopySipLine(p, "Call-ID: ");
                                          int cseq = GrepInteger(p, "\nCSeq: ");
                                          AddSipLine("CSeq: %i ACK",  cseq);
                                          AddCopySipLine(p, "From: ");
                                          AddCopySipLine(p, "Via: ");
                                          AddCopySipLine(p, "To: ");
                                          AddSipLine("Content-Length: 0");
                                          AddSipLine("");
                                          SendUdp();
                                        }
                                        
                                        void Sip::Ok(const char *p)
                                        {
                                          pbuf[0] = 0;
                                          AddSipLine("SIP/2.0 200 OK");
                                          AddCopySipLine(p, "Call-ID: ");
                                          AddCopySipLine(p, "CSeq: ");
                                          AddCopySipLine(p, "From: ");
                                          AddCopySipLine(p, "Via: ");
                                          AddCopySipLine(p, "To: ");
                                          AddSipLine("Content-Length: 0");
                                          AddSipLine("");
                                          SendUdp();
                                        }
                                        
                                        void Sip::Init(const char *SipIp, int SipPort, const char *MyIp, int MyPort, const char *SipUser, const char *SipPassWd, int MaxDialSec)
                                        {
                                          caRead[0] = 0;
                                          pbuf[0] = 0;
                                          pSipIp = SipIp;
                                          iSipPort = SipPort;
                                          pSipUser = SipUser;
                                          pSipPassWd = SipPassWd;
                                          pMyIp = MyIp;
                                          iMyPort = MyPort;
                                          iAuthCnt = 0;
                                          iRingTime = 0;
                                          iMaxTime = MaxDialSec * 2000;   // 1500
                                        }
                                        
                                        void Sip::AddSipLine(const char* constFormat , ... )
                                        {
                                          va_list arglist;
                                          va_start( arglist, constFormat);
                                          uint16_t l = (uint16_t)strlen(pbuf);
                                          char *p = pbuf + l;
                                          vsnprintf(p, lbuf - l, constFormat, arglist );
                                          va_end( arglist );
                                          l = (uint16_t)strlen(pbuf);
                                          if (l < (lbuf - 2))
                                          {
                                            pbuf[l] = '\r';
                                            pbuf[l + 1] = '\n';
                                            pbuf[l + 2] = 0;
                                          }
                                        }
                                        
                                        // call invite without or with the response from peer
                                        void Sip::Invite(const char *p)
                                        {
                                          // prevent loops
                                          if (p && iAuthCnt > 3)
                                            return;
                                        
                                          // using caRead for temp. store realm and nonce
                                          char *caRealm = caRead;
                                          char *caNonce = caRead + 128;
                                        
                                          char *haResp = 0;
                                          int   cseq = 1;
                                          if (!p)
                                          {
                                            iAuthCnt = 0;
                                            if (iDialRetries == 0)
                                            {
                                              callid = Random();
                                              tagid = Random();
                                              branchid = Random();
                                            }
                                          }
                                          else
                                          {
                                            cseq = 2;
                                            if (   ParseParameter(caRealm, 128, " realm=\"", p)
                                                   && ParseParameter(caNonce, 128, " nonce=\"", p))
                                            {
                                              // using output buffer to build the md5 hashes
                                              // store the md5 haResp to end of buffer
                                              char *ha1Hex = pbuf;
                                              char *ha2Hex = pbuf + 33;
                                              haResp = pbuf + lbuf - 34;
                                              char *pTemp = pbuf + 66;
                                        
                                              snprintf(pTemp, lbuf - 100, "%s:%s:%s", pSipUser, caRealm, pSipPassWd);
                                              MakeMd5Digest(ha1Hex, pTemp);
                                        
                                              snprintf(pTemp, lbuf - 100, "INVITE:sip:%s@%s", pDialNr, pSipIp);
                                              MakeMd5Digest(ha2Hex, pTemp);
                                        
                                              snprintf(pTemp, lbuf - 100, "%s:%s:%s", ha1Hex, caNonce, ha2Hex);
                                              MakeMd5Digest(haResp, pTemp);
                                            }
                                            else
                                            {
                                              caRead[0] = 0;
                                              return;
                                            }
                                          }
                                          pbuf[0] = 0;
                                          AddSipLine("INVITE sip:%s@%s SIP/2.0", pDialNr, pSipIp);
                                          AddSipLine("Call-ID: %010u@%s",  callid, pMyIp);
                                          AddSipLine("CSeq: %i INVITE",  cseq);
                                          AddSipLine("Max-Forwards: 70");
                                          // not needed for fritzbox
                                          // AddSipLine("User-Agent: sipdial by jl");
                                          AddSipLine("From: \"%s\"  <sip:%s@%s>;tag=%010u", pDialDesc, pSipUser, pSipIp, tagid);
                                          AddSipLine("Via: SIP/2.0/UDP %s:%i;branch=%010u;rport=%i", pMyIp, iMyPort, branchid, iMyPort);
                                          AddSipLine("To: <sip:%s@%s>", pDialNr, pSipIp);
                                          AddSipLine("Contact: \"%s\" <sip:%s@%s:%i;transport=udp>", pSipUser, pSipUser, pMyIp, iMyPort);
                                          if (p)
                                          {
                                            // authentication
                                            AddSipLine("Authorization: Digest username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"sip:%s@%s\", response=\"%s\"", pSipUser, caRealm, caNonce, pDialNr, pSipIp, haResp);
                                            iAuthCnt++;
                                          }
                                          AddSipLine("Content-Type: application/sdp");
                                          // not needed for fritzbox
                                          // AddSipLine("Allow: INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
                                          AddSipLine("Content-Length: 0");
                                          AddSipLine("");
                                          caRead[0] = 0;
                                          SendUdp();
                                        }
                                        
                                        // parse parameter value from http formated string
                                        bool Sip::ParseParameter(char *dest, int destlen, const char *name, const char *line, char cq)
                                        {
                                          const char *qp;
                                          const char *r;
                                          if ((r = strstr(line, name)) != NULL)
                                          {
                                            r = r + strlen(name);
                                            qp = strchr(r, cq);
                                            int l = qp - r;
                                            if (l < destlen)
                                            {
                                              strncpy(dest, r, l);
                                              dest[l] = 0;
                                              return true;
                                            }
                                          }
                                          return false;
                                        }
                                        
                                        // search a line in response date (p) and append on
                                        // pbuf
                                        bool Sip::AddCopySipLine(const char *p, const char *psearch)
                                        {
                                          char *pa = strstr((char*)p, psearch);
                                          if (pa)
                                          {
                                            char *pe = strstr(pa, "\r");
                                            if (pe == 0)
                                              pe = strstr(pa, "\n");
                                            if (pe > pa)
                                            {
                                              char c = *pe;
                                              *pe = 0;
                                              AddSipLine("%s", pa);
                                              *pe = c;
                                              return true;
                                            }
                                          }
                                          return false;
                                        }
                                        
                                        int Sip::GrepInteger(const char *p, const char *psearch)
                                        {
                                          int param = -1;
                                          const char *pc = strstr(p, psearch);
                                          if (pc)
                                          {
                                            param = atoi(pc + strlen(psearch));
                                          }
                                          return param;
                                        }
                                        
                                        // copy Call-ID, From, Via and To from response
                                        // to caRead
                                        // using later for BYE or CANCEL the call
                                        bool Sip::ParseReturnParams(const char *p)
                                        {
                                          pbuf[0] = 0;
                                          AddCopySipLine(p, "Call-ID: ");
                                          AddCopySipLine(p, "From: ");
                                          AddCopySipLine(p, "Via: ");
                                          AddCopySipLine(p, "To: ");
                                          if (strlen(pbuf) >= 2)
                                          {
                                            strcpy(caRead, pbuf);
                                            caRead[strlen(caRead) - 2] = 0;
                                          }
                                          return true;
                                        }
                                        
                                        void Sip::HandleUdpPacket(const char *p)
                                        {
                                          uint32_t iWorkTime = iRingTime ? (Millis() - iRingTime) : 0;
                                          if (iRingTime && iWorkTime > iMaxTime)
                                          {
                                            // Cancel(3);
                                            Bye(3);
                                            iRingTime = 0;
                                          }
                                        
                                          if (!p)
                                          {
                                            // max 5 dial retry when loos first invite packet
                                            //     int                int              uint32         int
                                            if (iAuthCnt == 0 && iDialRetries < 5 && (iWorkTime > (iDialRetries * 200)) )
                                            {
                                              iDialRetries++;
                                              delay(30);
                                              Invite();
                                            }
                                            return;
                                          }
                                        
                                          if (strstr(p, "SIP/2.0 401 Unauthorized") == p)
                                          {
                                            Ack(p);
                                            // call Invite with response data (p) to build auth md5 hashes
                                            Invite(p);
                                          }
                                          else if (strstr(p, "BYE") == p)
                                          {
                                            Ok(p);
                                            iRingTime = 0;
                                          }
                                          else if (strstr(p, "SIP/2.0 200") == p)    // OK
                                          {
                                            ParseReturnParams(p);
                                            Ack(p);
                                          }
                                          else if (   strstr(p, "SIP/2.0 183 ") == p // Session Progress
                                                      || strstr(p, "SIP/2.0 180 ") == p ) // Ringing
                                          {
                                            ParseReturnParams(p);
                                          }
                                          else if (strstr(p, "SIP/2.0 100 ") == p)   // Trying
                                          {
                                            ParseReturnParams(p);
                                            Ack(p);
                                          }
                                          else if (   strstr(p, "SIP/2.0 486 ") == p // Busy Here
                                                      || strstr(p, "SIP/2.0 603 ") == p // Decline
                                                      || strstr(p, "SIP/2.0 487 ") == p) // Request Terminatet
                                          {
                                            Ack(p);
                                            iRingTime = 0;
                                          }
                                          else if (strstr(p, "INFO") == p)
                                          {
                                            iLastCSeq = GrepInteger(p, "\nCSeq: ");
                                            Ok(p);
                                          }
                                        }
                                        
                                        /////////////////////////////////////////////////////////////////////////////////////////////////////
                                        //
                                        // hardware dependent interface functions
                                        //
                                        /////////////////////////////////////////////////////////////////////////////////////////////////////
                                        
                                        int Sip::SendUdp()
                                        {
                                          Udp.beginPacket(pSipIp, iSipPort);
                                          Udp.write(pbuf, strlen(pbuf));
                                          Udp.endPacket();
                                        #ifdef DEBUGLOG
                                          Serial.printf("\r\n----- send %i bytes -----------------------\r\n%s", strlen(pbuf), pbuf);
                                          Serial.printf("------------------------------------------------\r\n");
                                        #endif
                                          return 0;
                                        }
                                        
                                        // generate a 30 bit random number
                                        uint32_t Sip::Random()
                                        {
                                          // return ((((uint32_t)rand())&0x7fff)<<15) + ((((uint32_t)rand())&0x7fff));
                                          return secureRandom(0x3fffffff);
                                        }
                                        
                                        uint32_t Sip::Millis()
                                        {
                                          return (uint32_t)millis() + 1;
                                        }
                                        
                                        void Sip::MakeMd5Digest(char *pOutHex33, char *pIn)
                                        {
                                          MD5Builder aMd5;
                                          aMd5.begin();
                                          aMd5.add(pIn);
                                          aMd5.calculate();
                                          aMd5.getChars(pOutHex33);
                                        }
                                        
                                        /////////////////////////////////////////////////////////////////////////////////////////////////////
                                        //
                                        // Arduino setup() and loop()
                                        //
                                        /////////////////////////////////////////////////////////////////////////////////////////////////////
                                        
                                        char caSipIn[2048];
                                        char caSipOut[2048];
                                        Sip aSip(caSipOut, sizeof(caSipOut));
                                        
                                        void setup()
                                        {
                                          
                                          Serial.begin(115200);
                                          Serial.println();
                                        
                                          WiFi.disconnect(true);
                                          delay(10);
                                          WiFi.mode(WIFI_STA);
                                          delay(10);
                                        
                                          WiFi.begin("********************************************", "********************************************");  // SSID und WLAN-Key eintragen
                                          
                                          Serial.print("Connecting");
                                        
                                          while (WiFi.status() != WL_CONNECTED)
                                          {
                                            delay(100);
                                            Serial.print(".");
                                          }
                                        
                                          Serial.println();
                                          Serial.print("Connected, IP address: ");
                                          Serial.println( WiFi.macAddress() );
                                          Serial.println( WiFi.localIP() );
                                          Serial.println( ESP.getChipId() );
                                          
                                        
                                          int i = 0;
                                          for (i = 0; i < 100; i++)
                                          {
                                            if (WiFi.status() == WL_CONNECTED)
                                              break;
                                            delay(100);
                                            Serial.print(".");
                                          }
                                        
                                          if (i >= 100)
                                          {
                                            // without connection go to sleep
                                            delay(500);
                                            ESP.deepSleep(0);
                                          }
                                        
                                          WiFi.persistent(true);
                                          Serial.printf("\r\nWiFi connected to: %s\r\n", WiFi.localIP().toString().c_str());
                                          Udp.begin(sipport);
                                          aSip.Init(sipip, sipport, ip, sipport, sipuser, sippasswd, 15);
                                          aSip.Dial(sipdialnr, sipdialtext);
                                        
                                          secured_client.setTrustAnchors(&cert);
                                          bot.sendMessage(userID, "Es hat an der Tür geklingelt!", "");
                                          
                                        }
                                        
                                        int deepSleepDelay = 0;
                                        void loop(void)
                                        {
                                          
                                          int packetSize = Udp.parsePacket();
                                          if (packetSize > 0)
                                          {
                                            caSipIn[0] = 0;
                                            packetSize = Udp.read(caSipIn, sizeof(caSipIn));
                                            if (packetSize > 0)
                                            {
                                              caSipIn[packetSize] = 0;
                                              #ifdef DEBUGLOG
                                              IPAddress remoteIp = Udp.remoteIP();
                                              Serial.printf("\r\n----- read %i bytes from: %s:%i ----\r\n", (int)packetSize, remoteIp.toString().c_str(), Udp.remotePort());
                                              Serial.print(caSipIn);
                                              Serial.printf("----------------------------------------------------\r\n");      
                                              #endif
                                            }
                                          }
                                          aSip.HandleUdpPacket((packetSize > 0) ? caSipIn : 0 );
                                        
                                          if (!aSip.IsBusy() && deepSleepDelay == 0)
                                            deepSleepDelay = millis();
                                        
                                          if (deepSleepDelay && (millis() - deepSleepDelay) > 3000) {
                                            ESP.deepSleep(0);
                                          }
                                        }
                                        

                                        Das Script funktioniert und wenn ich GND und RST kurzschließe wird das Script ausgeführt.

                                        Sobald ich das Konstrukt aus Zener Diode - Widerstand - Optokoppler an die Klingel anschließe und diese betätige, tut sich leider nichts.

                                        Anbei noch eine Liste meiner verwendeten Bauteile:

                                        Board:
                                        https://www.reichelt.com/de/en/developer-boards-nodemcu-esp8266-wi-fi-module-debo-jt-esp8266-p219900.html?&trstct=pos_4

                                        Optokoppler
                                        https://www.reichelt.com/1-fach-optokoppler-5kv-35v-50ma-50-600-dip-4-ltv-817-p76173.html?CCOUNTRY=445&LANGUAGE=de&trstct=pos_0&&r=1

                                        Widerstand
                                        https://www.reichelt.de/widerstand-metalloxyd-560-ohm-0207-1-0-w-5--1w-560-p1832.html?trstct=magaz_txtlink

                                        Zener Diode
                                        https://www.ebay.de/itm/380928180250?var=650272010680

                                        Ich hoffe mir kann hier jemand helfen 🙂

                                        Eine Vermutung wäre, dass ich den Widerstand zu hoch gewählt habe?

                                        Danke und VLG

                                        Stefan

                                        1 Reply Last reply Reply Quote 0
                                        • N
                                          nullfreizeit last edited by

                                          Hallo zusammen,

                                          habe eine Siedle Anlage mit dem Netzteil BNG 650 im Keller und 3 x das Haustelefon AIB 150. Würde gerne das Klingelsignal abgreifen und den Türöffner betätigen. Gibt es hier schon eine Abhilfe/Ideen? Vielen Dank.

                                          1 Reply Last reply Reply Quote 0
                                          • M
                                            med3 last edited by

                                            Hi, weiß jemand ob das mit einem Siedle HT 611-01 genau so funktioniert?

                                            Eisbaeeer tobasium 2 Replies Last reply Reply Quote 0
                                            • First post
                                              Last post

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            872
                                            Online

                                            31.7k
                                            Users

                                            79.8k
                                            Topics

                                            1.3m
                                            Posts

                                            63
                                            221
                                            82978
                                            Loading More Posts
                                            • Oldest to Newest
                                            • Newest to Oldest
                                            • Most Votes
                                            Reply
                                            • Reply as topic
                                            Log in to reply
                                            Community
                                            Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                                            The ioBroker Community 2014-2023
                                            logo