Seit vielen Jahren ist der ESP8266 eine feste Größe in der Maker-Welt. Einen zusätzlichen Schub für dessen Popularität kam sicher von seinem Einsatz in kommerziell erhältlichen Geräten von Sonoff, Shelly & Co. Und so steuert dieser billige, aber leistungsfähige Microcontroller mit seinen WLAN Fähigkeiten weite Teile der nerdiger Heimautomation.

Die kommerziellen Geräte und sogar manche Module bringen schon eine Firmware mit, aber gewöhnlich gebietet die Maker-Ehre, diese umgehend durch eine open-source Firmware zu ersetzen, die man besser konfigurieren kann und die typischerweise viel mehr Funktionen bietet. Am populärsten dürfte TASMOTA sein – und auch für mich war das bisher immer die erste Wahl in solchen Fällen.

TASMOTA läuft stabil, bietet einen eigenen kleinen Web-Server im Device und spricht auch problemlos mit einem MQTT Server. Ein Update over the air ist nach der initialen Installation auch kein Problem. Was will man also mehr?

Naja – zum Einen hat mich schlicht die Neugierde gestochen und zum Anderen habe ich mich eigentlich schon gewundert, wozu ich den MQTT Server eigentlich brauche: Warum redet die Firmware nicht direkt mit Homeassistant (oder was auch immer Ihr im Einsatz habt)? Und zuguterletzt ist die Unterstützung für den ESP32 in TASMOTA immer noch in der Beta Phase.

Und so habe ich beschlossen, einfach mal etwas anderes auszuprobieren. Auswahl gibt es genug: Z.B. ESPeasy, ESPhome oder ESPurna. Irgendwie hat mich das Konzept von ESPhome angesprochen und so werden wir das heute mal ausprobieren.

Ein Projekt muss also her!

Und das war schnell gefunden: Ich würde gerne die Außenbeleuchtung des Hauses fernsteuern und ggf. automatisieren, damit ich mich mit strahlendem Licht verwöhnen kann, wenn ich im Winter mal abends vom Einkaufen komme, denn es ist lästig dann immer mit Kisten und Tüten im dunklen Hof rumzutappen, nur weil die Sonne zu dieser Jahreszeit zu faul ist, mich abends zu illuminieren.

Irgendwo habe ich noch einen Shelly rumliegen – der sollte doch ideal sein für dieses Vorhaben. Dann brauchen wir noch einen USB-UART Adapter zum Firmware-Flashen und schon kann es losgehen.

Firmware konfigurieren und compilieren

Als erstes müssen wir mal das Konzept von ESPhome verstehen: Von Tasmota ist man es gewöhnt die Firmware zu flashen und dann die Konfiguration im laufenden Modul vorzunehmen. Bei ESPhome läuft das umgekehrt. D.h. zuerst baut man eine Konfiguration in Form eines YAML Files und lässt sich dann die Firmware compilieren.

Also los! zunächst ESPhome Software auf dem Laptop installieren:

pipx install esphome

und dann ein config File erstellen:

esphome wizard außenbeleuchtung.yml

Nun ein paar Fragen zum konkreten Gerät und WLAN beantworten und schon haben wir ein config File. Jedenfalls theoretisch, denn der Wizard kennt den Shelly nicht und so habe ich erstmal ein generisches Board ausgewählt. Diesem Basis config File fehlt aber noch jede echte Funktion. D.h. wir müssen noch definieren, welche GPIO pins in unserem Device das Relais schalten bzw. an den Schalter angeklemmt werden. Hier findet Ihr die nötige Information für unseren Shelly 1 (und viele andere Geräte):

Dieses neue Wissen lassen wir nun in unser config File einfließen und schreiben je eine switch, light und binary_sensor Sektion. Und so sieht das dann am Ende aus:

esphome:
  name: aussenbeleuchtung

esp8266:
  board: esp01_1m

# Enable logging
logger:

# Enable Home Assistant API
api:
  password: "KdEmwzrv5916as1o"

ota:
  password: "KdEmwzrv5916as1o"

wifi:
  ssid: "philnet"
  password: "tb2wV4Szxv6Nqe6W"

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Shelly Außenbeleuchtung Setup"
    password: "syHeaBfGhBVGuso9"

captive_portal:


# Device Specific Config
output:
  - platform: gpio
    pin: GPIO4
    id: shelly_1_relay

light:
  - platform: binary
    name: "Shelly 1 Light"
    output: shelly_1_relay
    id: lightid

binary_sensor:
  - platform: gpio
    pin:
      number: GPIO5
      #mode: INPUT_PULLUP
      #inverted: True
    name: "Switch Shelly 1"
    on_press:
      then:
        - light.toggle: lightid
    internal: true
    id: switchid

Das wollen wir nun compilieren:

esphome compile außenbeleuchtung.yml

Und so sollte das aussehen:

INFO Reading configuration außenbeleuchtung.yml...
INFO Generating C++ source...
INFO Compiling app...
Processing aussenbeleuchtung (board: esp01_1m; framework: arduino; platform: platformio/espressif8266 @ 2.6.3)
--------------------------------------------------------------------------------------
HARDWARE: ESP8266 80MHz, 80KB RAM, 1MB Flash
Library Manager: Installing ottowinter/ESPAsyncTCP-esphome @ 1.2.3

Unpacking  [------------------------------------]    0%
Unpacking  [#-----------------------------------]    3%

   [...]

Unpacking  [##################################--]   96%
Unpacking  [####################################]  100%
Library Manager: ESPAsyncTCP-esphome @ 1.2.3 has been installed!
Library Manager: Installing esphome/ESPAsyncWebServer-esphome @ 2.1.0

Unpacking  [------------------------------------]    0%
Unpacking  [#-----------------------------------]    2%
Unpacking  [##----------------------------------]    5%
Unpacking  [###---------------------------------]    8%

   [...]

Unpacking  [##################################--]   97%
Unpacking  [####################################]  100%
Library Manager: ESPAsyncWebServer-esphome @ 2.1.0 has been installed!
Library Manager: Installing dependencies...
Library Manager: ESPAsyncTCP-esphome @ 1.2.3 is already installed
Library Manager: Installing esphome/AsyncTCP-esphome

Unpacking  [------------------------------------]    0%
Unpacking  [##----------------------------------]    6%

   [...]

Unpacking  [#################################---]   93%
Unpacking  [####################################]  100%
Library Manager: AsyncTCP-esphome @ 1.2.2 has been installed!
Library Manager: Installing Hash
Library Manager: Installing ESP8266WiFi
Dependency Graph
|-- <ESPAsyncTCP-esphome> 1.2.3
|-- <ESPAsyncWebServer-esphome> 2.1.0
|   |-- <ESPAsyncTCP-esphome> 1.2.3
|   |-- <Hash> 1.0
|   |-- <ESP8266WiFi> 1.0
|-- <DNSServer> 1.1.1
|-- <ESP8266WiFi> 1.0
|-- <ESP8266mDNS> 1.2
Compiling .pioenvs/aussenbeleuchtung/src/esphome/components/api/api_connection.cpp.o
Compiling .pioenvs/aussenbeleuchtung/src/esphome/components/api/api_frame_helper.cpp.o
Compiling .pioenvs/aussenbeleuchtung/src/esphome/components/api/api_pb2.cpp.o
Compiling .pioenvs/aussenbeleuchtung/src/esphome/components/api/api_pb2_service.cpp.o

   [...]

Compiling .pioenvs/aussenbeleuchtung/FrameworkArduino/umm_malloc/umm_malloc.cpp.o
Compiling .pioenvs/aussenbeleuchtung/FrameworkArduino/umm_malloc/umm_poison.c.o
Archiving .pioenvs/aussenbeleuchtung/libFrameworkArduino.a
Indexing .pioenvs/aussenbeleuchtung/libFrameworkArduino.a
Linking .pioenvs/aussenbeleuchtung/firmware.elf
RAM:   [====      ]  38.5% (used 31532 bytes from 81920 bytes)
Flash: [====      ]  41.6% (used 425572 bytes from 1023984 bytes)
Building .pioenvs/aussenbeleuchtung/firmware.bin
============================ [SUCCESS] Took 12.95 seconds ============================
INFO Successfully compiled program.

Wenn das ohne Fehler durchläuft, dann sind wir bereit für den nächsten Schritt.

Flash!

Zur Programmierung (flashen) brauchen wir einen USB-UART-Adapter. Z.B. so einen:

Mit dem muss der Shelly nun verkabelt werden. Freundlicherweise ist die UART Schnittstelle beim Shelly von außen erreichbar. Hier das Pinout (Bild © shelly.cloud):

Und so muss das ganze angeschlossen werden:

Achtung! Der ESP Chip im Shelly läuft mit 3.3V – auf keinen Fall 5V anlegen, wenn er länger leben soll.

Wie man im Pinout sehen kann, gibt es da auch noch einen Jumper der entsprechend der zu schaltenden Spannung gesetzt werden muss. Für die Programmierung ist das egal, aber nun wäre ein guter Zeitpunkt, das zu prüfen.

Jetzt ist es an der Zeit, die Firmware zu compilieren und auf den Shelly zu flashen. Also den USB2UART Adapter anschließen:

Anschließend ist etwas Geschick gefragt, denn wir müssen den ESP in den flash mode bringen. Dazu muss GPIO0 auf Masse gezogen sein, wenn wir den USB-UART Adapter einstecken. Manche Leute bauen sich dazu ein spezielles Kabel mit einem Schalter, aber dazu bin ich grade zu faul und deswegen mach ich das mit einer Büroklammer. Und der Moment der Wahrheit:

esphome upload außenbeleuchtung.yml

Und wenn alles gut ging, dann schaut das in etwa so aus:

Found multiple options, please choose one:
  [1] /dev/ttyUSB0 (USB2.0-Serial)
  [2] Over The Air (aussenbeleuchtung.local)
(number): 1
esptool.py v3.2
Serial port /dev/ttyUSB0
Connecting....
Chip is ESP8266EX
Features: WiFi
Crystal is 26MHz
MAC: 80:7d:3a:f0:22:ab
Uploading stub...
Running stub...
Stub running...
Changing baud rate to 460800
Changed.
Configuring flash size...
Auto-detected Flash size: 2MB
Flash will be erased from 0x00000000 to 0x00068fff...
Flash params set to 0x0330
Compressed 429744 bytes to 297901...
Wrote 429744 bytes (297901 compressed) at 0x00000000 in 6.9 seconds (effective 500.6 kbit/s)...
Hash of data verified.

Leaving...
Hard resetting via RTS pin...
INFO Successfully uploaded program.

Wenn das erfolgreich war, dann können zukünftige Firmware Uploads ohne den Adapter durchgeführt werden. ESPhome sucht das entsprechende Gerät dann im lokalen Netz und sendet das Firmware File direkt an den ESP.

Ausprobieren

Bevor wir alles an Ort und Stelle einbauen, wollen wir erstmal einen kleinen Testaufbau machen.

Mein Außenlicht hängt an einem Stromstoßschalter in der Verteilung, der von zwei Tastern angesteuert wird. Einer dieser Taster wird in Zukunft an den Shelly geklemmt, der dann den Stromstoßschalter ansteuert. Und genau so machen wir unseren Testaufbau: einen Taster, eine Glühbirne und zum Schluss den Strom anschließen – Kinder, nicht zuhause nachmachen, denn Strom is böse (Abbildung © shelly.cloud).

Und im echten Leben sieht der Aufbau so aus:

Sieht doch schon ganz gut aus. Man möge mir verzeihen, dass ich einen blauen Draht verwendet habe, um die Phase auf den I Eingang des Shelly zu schalten. Oh und bitte gleich auch, dass ich eine ökologisch völlig unkorrekte Glühbirne nehme. Gut dass mein Blog keine Kommentarfunktion hat... ;-)

Aber tut es auch, was es soll?

Taster drücken – Licht an, loslassen – Licht aus. Auf den ersten Blick mag es so aussehen, als würde das noch nicht wie gewünscht funktionieren, weil wir den Taster halten müssen, damit das Licht brennt. Aber nicht vergessen: Der Taster soll ja letztendlich den Stromstoßschalter steuern, d.h. das passt schon so.

Integration in Homeassistant

Bis jetzt haben wir noch nichts gewonnen, denn die Schaltung tut einfach nur das, was auch ohne den Shelly schon ging. Als nächstes binden wir unseren Shelly also in Homeassistant ein. Damit das funktioniert muss der Shelly im WLAN sein – also Strom dran. Danach gehen wir in Homeassistant nach Configuration > Devices & Services und wählen dort Add Integrations und suchen dann nach ESPhome. Der folgende Dialog will den hostname des Shelly wissen (aussenbeleuchtung) und schon ist er verfügbar.

Im Grunde geht nun schon alles, aber wir müssen wg. des Stromstoßschalters den virtuellen Schalter ein und wieder ausschalten, um das Licht einzuschalten. Das ist doof, also brauchen wir einen virtuellen Taster. Das können wir erreichen, indem wir in HA ein script erzeugen. Das geht ganz leicht unter Configuration > Automations & Scenes > Scripts. Ihr braucht drei Komponenten: 1. Außenlicht an 2. delay 250ms 3. Außenlicht aus

In YAML sieht das Ergebnis dan so aus:

alias: Außenlicht
sequence:
  - type: turn_on
    device_id: 829099e30125c023320cb8131fa7203d
    entity_id: light.aussenlicht
    domain: light
  - delay:
      hours: 0
      minutes: 0
      seconds: 0
      milliseconds: 250
  - type: turn_off
    device_id: 829099e30125c023320cb8131fa7203d
    entity_id: light.aussenlicht
    domain: light
mode: single
icon: mdi:lightbulb-on-outline

Alles was nun noch fehlt, ist ein GUI Button dafür einzubinden uns schon funktioniert das.

Endmontage

Technisch funktioniert nun alles korrekt. Was bleibt ist der Einbau hinter dem Taster. Ich hoffe mal, das passt da wirklich rein. Ich werde berichten...

Und zum Schluss noch ein Tip: Wenn man mehrere ESPhome Geräte im Einsatz hat kann es schnell unübersichtlich werden. Und irgendwie wollen die Dinger auch gewartet werden. Dabei hilft:

esphome dashboard ./

Das ist sehr praktisch um seine ESP-Armee unter Kontrolle zu haben.