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

pk68

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

Basti97

@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

@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.

claus1993

@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

@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

Basti97

@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.

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.

Basti97

@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

Basti97

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

Ciaran Baulig

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

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

nullfreizeit

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.

med3

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

Eisbaeeer

@med3 ja geht genau so. Habe ich hier auch im Einsatz.

lonetom

Hallo Zusammen
Hat jemand Erfahrung mit einer Urmet 4+N (Innenstelle Urmet 1133 mit elektronischen Signalgeber) Erfahrung?
Welche Änderungen wären erforderlich bei Bedarf?
thx tom

TheHellSite

EDIT: Eben erst gesehen, du hast ja ein anderes Telefon mit einer anderen Spannung.

tobasium

@med3

Ich habe mir das ganze auch gebaut aber mit Tasmota im Einsatz. Es fehlt eben noch ein Gehäuse.
Sobald es klingelt bekomme ich über mehre Kanäle eine Benachrichtigung (Telegram, Alexa)
Über mein normales Telegram Menü kann ich dann Türe öffnen auslösen.

TheHellSite

Hallo @Eisbaeeer ,

erstmal vielen Dank für deine Lösung!!!

Ich habe bei mir ein Siedle HTS 711-0 verbaut.
Aktuell möchte ich dies zwar noch nicht in mein Smart Home integrieren, aber ich bin sehr an einer Funk Klingel Erweiterung interessiert.

Siedle bietet dafür den NSC 602-00 Adapter an. https://www.siedle.de/de-de/produkte/nsc-602-0-nebensignal-controller/
In meinen Augen ist das Abzocke...

Jetzt meine Frage:
Kann ich deine Bauteile zur Klingelerkennung nutzen, um eine Funkerweiterung anzuschließen?
www.heidemann-handel.de/details-produkte/funkkonverter-hx.html
Den Rest für die Smart Home integration benötige ich aktuell nicht.

Viele Grüße
TheHellSite

TheHellSite

Da hier keiner geantwortet hat, habe ich es einfach mal getestet. Mit Erfolg!
Vielen Dank @Eisbaeeer für die ursprüngliche Lösung.

Nachfolgend noch eine Liste der Bauteile und Bilder.

Viele Grüße
TheHellSite

Verwendete Bauteile

Bilder

Gegensprechstelle ohne Funkerweiterung

Gegensprechstelle mit Funkerweiterung

DIY-Adapter und Funkkonverter

Eisbaeeer

@thehellsite Freut mich, wenn es bei Dir funktioniert hat!

f0m3

ups. dummer Post meinerseits, löschen geht aber anscheinend nicht

NEWS

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

Verwendete Bauteile

Bilder

Verwendete Bauteile

Bilder

Support us

634

32.4k

81.4k

1.3m