• Vor kurzem habe ich ein TikTok-Video veröffentlicht, indem ich die Vorteile eines smarten Türschlosses aufzeige. Konkret habe ich dabei einen ESP8266 D1 Mini mithilfe von Homebridge in ein HomeKit Schloss verwandelt. Die Nachfrage nach einem Tutorial war erstaunlich groß - aus diesem Grund habe ich mich an die Arbeit gemacht und eine Lösung gefunden, die völlig ohne Bridge auskommt: Ein smartes Türschloss nativ in HomeKit eingebunden - Marke: DIY mit einem ESP8266.

    esp8266_makesmart_native_homekit_lock


    Falls du planst, dass das Schloss ein Relaismodul betätigt, dann empfehle ich dir meine Firmware zu verwenden. Dort musst du erstens nichts programmieren und zweiten dauert das ganze nur 5 Minuten. :heh: HomeKit Schloss mit ESP8266 in 5 Minuten

    Falls du aus dem Schloss etwas eigenes machen möchtest, lies einfach weiter.

    Vorbereitungen

    Ganz ohne Programmierung kommt man leider auch mit dieser Möglichkeit nicht aus. Wobei sich das Programmieren lediglich erstens: auf das Ändern der Zugangsdaten des eigenen WLAN beschränkt, und zweitens: Man muss selber festlegen, was passieren soll, wenn das Schloss geöffnet oder geschlossen wird. Das Öffnen und Schließen kann zum Beispiel das einfache Betätigen eines Relaismoduls sein. Aber mehr dazu später.

    Falls du noch keine Ahnung hast, wie du einen ESP8266 D1 Mini programmieren kannst, kann ich dir diesen Artikel empfehlen. Sobald du soweit bist, kannst du hier fortfahren.

    HOMEKIT-ESP8266 - Arduino IDE Library hinzufügen

    Um den bereitgestellten Programmcode verwenden zu können, muss eine Library innerhalb der Arduino IDE installiert werden. Das geht mithilfe des Bibliotheksverwalter. Öffnen könnt ihr ihn über das Menü der Arduino IDE. Die Library trägt den Namen HomeKit-ESP8266 und ist von Mixiaoxiao

    Arduino IDE
    └───Werkzeuge
        └───Bibliotheken verwalten...
    

    homekit-esp8266-bibliothek-installieren-arduino-ide

    Das native HomeKit Schloss - der Code

    Um den ESP8266 in ein natives HomeKit Schloss zu verwandeln, ist mehr als nur eine Datei Programmcode notwendig. Genauer gesagt sind es drei Dateien. Diese drei Dateien habe ich alle schon für euch vorbereitet. Downloaden könnt ihr die Dateien direkt hier:

    makesmart_homekit_lock.zip

    Entpackt das .zip-Archiv an einem beliebigen Ort auf eurem Computer. In dem entpackten Order befinden sich drei Dateien:

    makesmart_homekit_lock
    ├── makesmart_homekit_lock.ino
    ├── my_accessory.c
    └── wifi_info.h
    

    makesmart_homekit_lock.ino

    • enthält den eigentlich Code - was passiert wann?

    my_accessory.c

    • in dieser Datei wird das Schloss für HomeKit definiert

    wifi_info.h

    • enthält Daten zur Verbindung mit dem WLAN

    Ihr müsst lediglich die Datei makesmart_homekit_lock.ino öffnen, die anderen beiden Dateien öffnen sich dann ebenfalls.

    Anpassungen im Code

    1. WLAN-Zugangsdaten

    Zuerst solltet ihr in der Datei wifi_info.h die Zugangsdaten zu eurem WLAN anpassen.
    Das geht mithilfe der beiden folgenden Zeilen:

    const char *ssid = "WLAN-SSID";
    const char *password = "WLAN-PASS";
    

    2. Was soll das Schloss machen?

    Jetzt kommt es ganz darauf an, was ihr mit dem Schloss betätigen möchtet. In meinem TikTok Video habe ich die Gegensprechanlage parallel geschalten und konnte so die Türe unten im Treppenhaus über das Schloss in HomeKit öffnen. :schmartie: Aber genau hier kommt der großartige Vorteil der Library ins Spiel. Ihr könnt alles umsetzen, was ich in der Arduino IDE eben umsetzen könnt. 🔥

    Ich habe zwei Funktionen für euch vorbereitet, ihr findet sie ganz am Ende von makesmart_homekit_lock.ino.

    /* Diese beiden Funktionen werden aufgerufen, wenn das Schloss in HomeKit betätigt wird */
    void open_lock(){
      Serial.println("Schloss öffnen"); 
      // hier beliebige Aktion einfügen 
    }
    
    void close_lock(){
      Serial.println("Schloss schließen");  
      // hier beliebige Aktion einfügen
    }
    

    Wie die Kommentare schon sagen, werden die Funktionen aufgerufen, wenn das Schloss geöffnet oder geschlossen wird.

    Um ein Relais anzusteuern, müsste der Code folgendermaßen bearbeitet werden:

    /* Diese beiden Funktionen werden aufgerufen, wenn das Schloss in HomeKit betätigt wird */
    void open_lock(){
      Serial.println("Schloss öffnen"); 
      // hier beliebige Aktion einfügen 
      digitalWrite(relay, HIGH);
    }
    
    void close_lock(){
      Serial.println("Schloss schließen");  
      // hier beliebige Aktion einfügen
      digitalWrite(relay, LOW);
    }
    

    Zusätzlich dazu muss man dann noch oben in der Datei die Variable relay definieren und den Pin im setup() als Output setzen.

    int relay = 15; // Pin D8 
    void setup() {
      pinMode(relay, OUTPUT);
      Serial.begin(115200);
      wifi_connect();
      homekit_storage_reset();
      my_homekit_setup();
    }
    

    Fehlt nur noch die Verdrahtung des Relais mit dem ESP8266 D1 Mini. Das ist in diesem Beispiel die selbe wie beim ESP8266 D1 Mini Relais als HomeKit Schalter ohne Bridge. Ein weiteres Tutorial über natives HomeKit Zubehör mit dem ESP8266.

    esp8266_homekit_lock_schaltplan

    KY-19 Relaismodul ESP8266 D1 Mini
    S D8
    + 5V
    - G

    Und fertig ist das native HomeKit Schloss mit einem ESP8266 D1 Mini und einem Relais. :programmingparrot:

    Falls du planst, das mit dem Relais wirklich 1:1 so umzusetzen wie auf dem Video, kannst du statt dieser Anleitung hier auch meine Firmware verwenden und Zeit sparen. :heh:

    HomeKit Schloss mit dem ESP8266 in unter 5 Minuten


    Weitere Informationen

    Wie bereits erwähnt könnt ihr in die Funktionen close_lock() open_lock() alles einfügen, was man innerhalb der Arduino IDE umsetzen kann. Vielleicht habt ihr ja ein paar Ideen oder Anwendungen? Vielleicht wirklich mit einem elektronischen Schloss? Oder vielleicht sogar ein Servo-Motor? Ich würde mich freuen davon zu hören.

    ¹Produktempfehlungen

    Produkte zum Warenkorb hinzufügen



    Der Upload

    Bevor ihr den Sketch auf den ESP8266 D1 Mini hochladet, solltet ihr die Taktrate der CPU des D1 Minis anpassen. Für die Library sind 160 MHz von Vorteil, da sie dann stabiler läuft.

    Arduino IDE
    └─── Werkzeuge
        └─── CPU Frequency: 160 MHz
    

    Zudem solltet ihr folgende Einstellung bzgl. des Uploads ändern, um komisches- oder Fehlverhalten während der Entwicklung & Programmierung zu verhindern.

    Arduino IDE
    └─── Werkzeuge
        └─── Erase Flash: All Flash Contents
    

    Zum Schluss

    Wenn ihr mit eurem Setup zufrieden seid und das Schloss fertig eingerichtet wurde, solltet ihr die Zeile homekit_storage_reset(); im setup() auskommentieren, da ihr den D1 Mini nach einem Stromverlust sonst immer wieder neu koppeln müsst. Wenn die Zeile auskommentiert ist, wird der Storage nicht resettet und der D1 Mini kann nach dem Programmen an seinen Platz verlegt, und ab sofort als natives HomeKit Schloss verwendet werden. 🔥

    void setup() {
      Serial.begin(115200);
      wifi_connect();
      //homekit_storage_reset();
      my_homekit_setup();
    }
    

    Habt ihr noch Bock auf etwas zum Thema Smarthome? Dann schaut gerne in die HomeKit-Community. Wenn ihr eher am Programmieren interessiert seid und mehr zum Thema ESP8266 & Co. erfahren möchtet? Dann schaut doch lieber in die ESP8266-Community.

    Suchst du gezielt nach weiteren Tutorials mit dieser Library? Dann schau doch mal in der Community unter dem Tag homekit-esp8266 vorbei. :programmingparrot:


    Link: zur makesmart HomeKit Lock-Firmware

    #Arduino-IDE #D1-Mini #ESP8266 #HomeKit #HomeKit-ESP8266 #Smarthome


    Möchtest du mich und die makesmart Plattform direkt unterstützen? Dann überleg’ dir doch, ob du die Produkte für dein nächstes Projekt nicht im makesmart.shop kaufen möchtest. Danke! 🙂

    Bis dann!

    ¹Affiliate Link. Affiliate Links sind Referenzen des Autors. Bei Kauf wird eine Provision ausgeschüttet. Mehr Informationen.


  • Ich habe einen kleinen Nachtrag für euch - zuerst war es nur für mich selber zum Testen aber dann dachte ich mir, es kann für viele die nicht so viel Ahnung von ESP8266 & Co. haben unter Umständen auch sehr nützlich sein, deshalb teile ich es einfach nochmal mit euch.

    Ich habe aus der eben ausgeführten Anleitung eine kleine Firmware gebastelt. Und zwar für die Leute, die das ganze wirklich mit einem Relais betreiben möchten.

    Das heißt ihr habt mir dieser Kurzanleitung genau das selbe Ergebnis wie oben, nur ohne Programmierung und dem ganzen anderen Overhead. :programmingparrot:

    • Schloss offen -> Relais am D1 Mini schaltet durch
    • Schloss geschlossen -> Relais am D1 Mini schaltet nicht durch

    Im Gegensatz zur anderen Anleitung bei der ihr richtig viele Freiheiten habt und theoretisch aus dem Schloss alles machen könnt, was ihr nur wollt, braucht ihr für diese Anleitung genau die folgenden drei Produkte um das Schloss lauffähig zu bekommen:

    Zusätzlich dazu benötigt ihr noch ein micro-USB Kabel um die Firmware auf den ESP8266 D1 Mini laden zu können.


    Die Anleitung

    Downloads

    Zuerst musst du meine Firmware downloaden, der Link dazu ist hier:

    Dazu benötigst du ein Programm zum Flashen der Firmware. Unter MacOS habe ich den NodeMCU PyFlasher verwendet. Lade ihn für dein Betriebssystem herunter:

    Firmware auf den ESP8266 D1 Mini flashen

    Zum Flashen wird der NodeMCU PyFlasher verwendet :schmartie:
    Übernehmt die Einstellungen 1:1 vom folgenden Bild:

    makesmart nodemcu pyflasher einstellungen homekit

    Das einzige was bei euch abweicht sollte sind folgende Parameter:

    • der Serial port (kann unter Umständen auch gleich sein)
    • der NodeMCU firmware Pfad zur Firmware

    Ganz wichtig ist: yes, wipes all data muss unbedingt aktiviert sein.


    Die Einrichtung

    Wenn die Firmware auf den ESP8266 D1 Mini aufgespielt wurde, könnt ihr das Relais verdrahten. Nehmt dazu diesen Schaltplan:

    esp8266 nativ homekit schloss schaltplan

    Verbindet euren ESP8266 anschließend mit dem Netzteil. Es wird ein Wlan-Hotspot mit dem Namen makesmartLock erstellt. Das Passwort lautet: makesmart


    Geht nun auf den Button WLAN konfigurieren und wählt euer Heimnetzwerk aus der Liste aus. Gebt anschließend noch euer Passwort ein.

    makesmart lock homekit wlan portal

    Wenn die Verbindung mit dem WLAN erfolgreich war, blinkt der ESP8266 D1 Mini ein paar Mal blau. Falls er nicht blinken sollte, dann starte den ESP8266 einfach neu indem du die Stromverbindung trennst.

    Pairen mit der Home App

    Um den ESP8266 dann mit der Home App zu pairen kannst du diesen QR-Code verwenden:

    makesmart lock qr code pairing

    Wenn du lieber manuell und mit Code pairen möchtest, verwende den Code: 123-45-678.

    makesmart homekit Schloss

    Jetzt hast das Schloss erfolgreich in deine Home App eingebunden.

    Möchtest du mich und die makesmart Plattform direkt unterstützen? Dann überleg’ dir doch, ob du die Produkte für dein nächstes Projekt nicht im makesmart.shop kaufen möchtest. Danke! 🙂


  • @cooper

    Hi,

    erst einmal VIELEN DANK, dass du dir die Mühe gemach hast und diesen Code bereitgestellt hast!

    Hat mich als Anfänger RIESIG gefreut 🙂
    Ich bin mir sicher , dass andere auch erfreut waren 🙂

    Ich habe da mal eine Frage :

    An welcher Stelle im Code kann ich ein "delay (5000); " setzen, damit das Schloß nach dem öffnen wieder selbstständig schielßt und der Relay-Pin wieder automatisch auf “LOW” gesetzt wird ?

    Danke im Voraus für deine Antwort

    Gruß

    Alex


  • @alex-0 Eigentlich hier:

    /* Diese beiden Funktionen werden aufgerufen, wenn das Schloss in HomeKit betätigt wird */
    void open_lock(){
      Serial.println("Schloss öffnen"); 
      // hier beliebige Aktion einfügen 
    }
    
    void close_lock(){
      Serial.println("Schloss schließen");  
      // hier beliebige Aktion einfügen
    }
    

    Nur musst du dann den Status wieder an Homekit zurücksenden, wenn du den Status automatisch nach 5 Sek wieder ändern lässt:

      // HomeKit-Status aktualisieren
    homekit_characteristic_notify(&cha_lock_current_state, cha_lock_current_state.value);
    

    Habs nicht greatest aber sollte funktionieren.

    Es kann aber sein, dass delay(5000) zu viel ist und das Schloss dann nicht mehr erreichbar ist. Musst halt mal testen. 👍


    Jetzt nachträglich hätte man das Zurücksetzen des Status auch direkt in die Funktionen packen können. 😅 Dann wäre es noch einfacherer gewesen.


  • @cooper Vielen Dank ich werde dann mal testen …😅


  • @cooper

    Also das mit dem “delay(5000);” funktioniert , aber das Schloss bleibt nach dem Zurücksetzen “digitalWrite(relay, LOW);” auf und geht nicht zurück in den Status “ZU”

    Vielleicht habe ich was falsch gemacht im Code ?! 🙂


    /* Diese beiden Funktionen werden aufgerufen, wenn das Schloss in HomeKit betätigt wird */
    void open_lock(){
    Serial.println(“Schloss öffnen”);
    // hier beliebige Aktion einfügen
    digitalWrite(relay, HIGH);
    delay(5000);
    digitalWrite(relay, LOW);
    homekit_characteristic_notify(&cha_lock_current_state, cha_lock_current_state.value);

    }

    void close_lock(){
    Serial.println(“Schloss schließen”);
    // hier beliebige Aktion einfügen
    digitalWrite(relay, LOW);
    }


  • @alex-0 Verwende bitte Code Tags. 🙉

    Dann musst du die Variable aktualisieren, die gesendet wird. Diese enthält den current state.

    homekit_characteristic_notify(&cha_lock_current_state, cha_lock_current_state.value);
    

    d.h du musst den current state auf closed setzen und dann den aktualisieren current state an Homekit zurück übertragen.

    Kannst dir ja die Funktion zur Hilfe nehmen:

    void set_lock(const homekit_value_t value) {
      uint8_t state = value.int_value;
      cha_lock_current_state.value.int_value = state;
      if(state == 0){
        // Schloss wurde via HomeKit geöffnet
        open_lock();
      }
      if(state == 1){
        // Schloss wurde via HomeKit geschlossen
        close_lock();
      }
      // HomeKit-Status aktualisieren
      homekit_characteristic_notify(&cha_lock_current_state, cha_lock_current_state.value);
    }
    

    wahrscheinlich reicht es, wenn du dich auf die Zeilen beschränkst:

    cha_lock_current_state.value.int_value = state;
      if(state == 0){
        // Schloss wurde via HomeKit geöffnet
        open_lock();
      }
      if(state == 1){
        // Schloss wurde via HomeKit geschlossen
        close_lock();
      }
    
    cha_lock_current_state.value.int_value = // 0 oder 1;
    

    dann zurück übertragen

    homekit_characteristic_notify(&cha_lock_current_state, cha_lock_current_state.value);
    

    denke des sollte hinhauen


  • @cooper

    Hi ,

    vielen Dank für deine Mühe…

    Leider bin ich im Moment noch nicht in der Lage den Code so anzupassen, dass er mit einem ( Delay 5000;) funktioniert …
    Trotz deiner Hinweise habe ich es leider nicht hinbekommen …

    Deshalb wollte ich fragen, ob du in deinem Code, netterweise noch diese Funktion ergänzen könntest?!

    Copy und Paste bekomme ich auf jeden Fall hin😅😅

    Wäre echt super …

    Leider fehlt mir hier als Anfänger das Verständnis für die Materie😅

    Vielen Dank im Voraus 💪🏻


  • @alex-0 Tut mir leid, dann musst dich leider erstmal mit der aktuellen Version zufriedengeben. 🙉

    Leider keine Zeit jedes Snippet selber umzusetzen. :heh:


  • @alex-0
    Hast Du es in der Zwischenzeit hinbekommen?
    Habe schon alles mögliche ausprobiert, aber in der App wird der Status des Schlosses nicht wieder auf “geschlossen” gesetzt.

Ähnliche Themen

  • 2
  • 1
  • 1
  • 1
  • 1