ESPHome gehört zu den leistungsstärksten Plattformen, um Mikrocontroller in Smart-Home-Systeme wie Home Assistant zu integrieren. Egal ob für einfache Automatisierungen oder anspruchsvolle Anwendungen – ESPHome ermöglicht dir, Sensoren und Aktoren präzise zu steuern und flexibel an deine Anforderungen anzupassen.

In dieser Anleitung lernst du die wichtigsten Funktionen und Konzepte von ESPHome kennen. Wir starten mit der schnellen Einrichtung vorgefertigter Geräte, beleuchten zentrale Funktionen wie Filter, Template-Sensoren und Lambdas und zeigen, wie du mit External Components benutzerdefinierte Module integrieren kannst. Ob Einsteiger oder erfahrener Nutzer – diese Anleitung zeigt dir, wie du das volle Potenzial von ESPHome ausschöpfen kannst.

Warum ESPHome die perfekte Ergänzung zu Home Assistant ist

ESPHome und Home Assistant ergänzen sich ideal und bilden ein leistungsstarkes, flexibles Smart-Home-System. Mit ESPHome kannst du Sensoren und Aktoren lokal steuern, während Home Assistant Automatisierungen, Visualisierungen und die Integration anderer Systeme übernimmt.

Die Kombination dieser beiden Plattformen erlaubt es dir, deine Geräte effizient zu steuern, die Datenlast zu reduzieren und individuelle Lösungen für dein Zuhause zu erstellen. Diese Anleitung hilft dir, sowohl die Standardfunktionen als auch die erweiterten Anpassungsmöglichkeiten von ESPHome zu meistern.

Schnellstart: Fertige Sensoren und Aktoren in ESPHome nutzen

Bevor wir in die Tiefe gehen, schauen wir uns die breite Palette an vorgefertigten Sensoren und Aktoren an, die ESPHome unterstützt. Diese Geräte lassen sich mit wenigen Zeilen YAML-Konfiguration integrieren und sind ideal, um schnell erste Ergebnisse zu erzielen.

Temperatursensoren konfigurieren

Temperatursensoren wie der DHT22, DS18B20 oder BME280 sind leicht einzurichten und liefern präzise Daten für die Temperaturüberwachung und Automatisierungen:

1
2
3
4
5
6
7
8

sensor:
  - platform: dht
    pin: D2
    model: DHT22
    temperature:
      name: "Raumtemperatur"
    humidity:
      name: "Luftfeuchtigkeit"

Lichtsensoren für Umgebungsautomatisierungen

Lichtsensoren wie der BH1750 oder TSL2561 sind ideal für Automatisierungen, die auf Umgebungshelligkeit basieren, etwa das automatische Schließen von Rollos:

1
2
3
4

sensor:
  - platform: bh1750
    name: "Helligkeit"
    address: 0x23

Schalter und Relais einrichten

GPIO-basierte Schalter oder Relaismodule sind vielseitig einsetzbar, beispielsweise zur Steuerung von Lichtern, Ventilatoren oder anderen Geräten:

1
2
3
4

switch:
  - platform: gpio
    pin: D5
    name: "Lichtschalter"

Bewegungsmelder für Sicherheits- und Komfortlösungen

Bewegungsmelder, wie einfache PIR-Sensoren, sind schnell konfiguriert und können Bewegungen erkennen, um Automatisierungen auszulösen:

1
2
3
4

binary_sensor:
  - platform: gpio
    pin: D6
    name: "Bewegungssensor"

LEDs und RGB-Lichter für stimmungsvolle Beleuchtung

ESPHome unterstützt PWM-LEDs und adressierbare LEDs wie die WS2812. Sie eignen sich perfekt für flexible Lichtlösungen:

1
2
3
4
5
6
7
8
9

light:
  - platform: monochromatic
    name: "LED"
    output: pwm_output

output:
  - platform: esp8266_pwm
    pin: D7
    id: pwm_output

Energiezähler für effizientes Energiemanagement

Mit Sensoren wie dem PZEM-004T kannst du Spannung, Strom und Leistung messen, um den Energieverbrauch deines Haushalts zu überwachen:

1
2
3
4
5
6
7
8
9

sensor:
  - platform: pzem004t
    update_interval: 60s
    voltage:
      name: "Spannung"
    current:
      name: "Strom"
    power:
      name: "Leistung"

Diese Geräte bieten dir eine solide Grundlage, um mit ESPHome zu starten. Sobald diese grundlegenden Funktionen eingerichtet sind, kannst du dich an fortgeschrittene Anpassungen wagen.

Erweiterte Möglichkeiten: Die Kernkonzepte von ESPHome

Neben der Unterstützung für Standardgeräte bietet ESPHome leistungsstarke Werkzeuge zur Anpassung und Optimierung deiner Konfiguration. Diese Kernkonzepte erlauben es dir, individuelle Anforderungen zu erfüllen und dein System effizienter zu gestalten.

ESPHome Filter: Daten gezielt verarbeiten

Filter sind eine der Kernfunktionen von ESPHome und ermöglichen die Transformation und Anpassung von Sensordaten, bevor sie an Home Assistant übermittelt werden. Mit Filtern kannst du Rohdaten glätten, anpassen oder begrenzen, um sicherzustellen, dass nur relevante und präzise Informationen weitergegeben werden.

Was sind Filter?

Filter sind vorgefertigte oder benutzerdefinierte Datenverarbeitungsmechanismen, die in der YAML-Konfiguration eines Sensors definiert werden. Sie arbeiten inline und verarbeiten die Ausgabe eines Sensors, bevor die Werte über das ESPHome-System an Home Assistant weitergeleitet werden. Filter können einfache Transformationen wie die Umrechnung von Einheiten oder komplexe Berechnungen wie gleitende Mittelwerte umfassen.

Typische Anwendungsfälle von Filtern

Filter finden in einer Vielzahl von Szenarien Anwendung:

• Entfernung von Rauschen: Glätten von Sensordaten, um ungewollte Schwankungen zu eliminieren.
• Umrechnung von Einheiten: Anpassung von Rohwerten in benutzerfreundliche Formate.
• Datenreduktion: Begrenzung der Häufigkeit von Updates oder das Aussortieren irrelevanter Werte.
• Datenvalidierung: Verwerfen von Werten außerhalb eines bestimmten Bereichs.

Verfügbare Filtertypen in ESPHome

ESPHome bietet eine Vielzahl von vorgefertigten Filtern. Hier sind einige der am häufigsten genutzten:

Gleitender Mittelwert

Dieser Filter glättet die Daten über eine definierte Anzahl von Messungen.

1
2
3
4

filters:
  - sliding_window_moving_average:
      window_size: 5
      send_every: 1

Offset-Filter

Ermöglicht die Addition oder Subtraktion eines konstanten Wertes.

1
2

filters:
  - offset: -2.5

Skalierungsfaktor

Multipliziert den Rohwert mit einem konstanten Faktor.

1
2

filters:
  - multiply: 1.8

Delta-Filter

Sendet neue Werte nur, wenn sich der Unterschied zum vorherigen Wert über einen definierten Schwellenwert hinaus verändert hat.

1
2

filters:
  - delta: 0.5

Bereichsbegrenzung

Filtert Werte, die außerhalb eines definierten Bereichs liegen.

1
2
3
4
5

filters:
  - lambda: |-
      if (x < 0) return 0;
      if (x > 100) return 100;
      return x;      

Erweiterte Filter mit Lambdas

Für komplexere Anforderungen kannst du Filter durch Lambdas erweitern. Dies ermöglicht die Implementierung von benutzerdefinierter Logik direkt im Filter.

Beispiel: Dynamische Kalibrierung

Ein Sensorwert wird basierend auf einer externen Bedingung kalibriert:

1
2
3
4
5
6
7

filters:
  - lambda: |-
      if (id(condition).state) {
        return x * 1.1;  // Skalierung bei aktivem Zustand
      } else {
        return x;
      }      

Beispiel: Ausschluss unplausibler Daten

Ein Wert wird nur übertragen, wenn er innerhalb eines bestimmten Bereichs liegt:

1
2
3
4
5
6
7

filters:
  - lambda: |-
      if (x < 10 || x > 50) {
        return {};  // Ignoriere den Wert
      } else {
        return x;
      }      

Optimierung und Best Practices

• Kombination von Filtern: Mehrere Filter können in einer Pipeline kombiniert werden, um komplexe Verarbeitungen zu ermöglichen.
• Performanz beachten: Zu viele Filter oder komplexe Berechnungen können die Leistung beeinträchtigen.
• Verwendung mit Template-Sensoren: Filter lassen sich ideal mit Template-Sensoren kombinieren, um Aggregationen oder weitere Anpassungen vorzunehmen.
• Test und Validierung: Verwende das ESPHome-Log, um die Ergebnisse der Filter zu überprüfen und sicherzustellen, dass sie wie erwartet funktionieren.

Weitere Informationen

Eine vollständige Liste der Filter und deren Anwendung findest du in der ESPHome-Dokumentation zu Filtern. Nutze diese Ressource, um die Verarbeitungsmöglichkeiten deiner Sensordaten zu erweitern und dein Smart-Home-System noch effizienter zu gestalten.

ESPHome Template-Sensoren: Flexibilität durch Berechnungen und Aggregationen

Template-Sensoren gehören zu den leistungsfähigsten Tools in ESPHome, da sie es ermöglichen, Daten aus anderen Sensoren zu kombinieren, zu berechnen und individuell anzupassen. Sie bieten eine einfache Möglichkeit, komplexe Berechnungen oder bedingte Logik in deiner YAML-Konfiguration umzusetzen.

Was sind Template-Sensoren?

Ein Template-Sensor ist ein virtueller Sensor, der auf Basis anderer Sensoren oder Werte berechnet wird. Anstatt direkt physikalische Werte zu erfassen, wie es bei Standard-Sensoren der Fall ist, definiert ein Template-Sensor, wie seine Daten basierend auf Eingabewerten generiert werden.

Template-Sensoren können für eine Vielzahl von Szenarien verwendet werden, darunter:

• Datenaggregation: Berechnung von Durchschnittswerten oder Summen.
• Bedingte Logik: Zustandsänderungen basierend auf Schwellenwerten.
• Einheitliche Darstellung: Anpassung von Einheiten oder Formaten.
• Kombination von Daten: Nutzung mehrerer Eingaben zur Berechnung eines neuen Werts.

Typische Anwendungsfälle

Template-Sensoren sind extrem vielseitig und können in nahezu jedem Kontext eingesetzt werden. Beispiele umfassen:

Durchschnittstemperatur berechnen

Ein Template-Sensor aggregiert die Daten zweier Temperatursensoren:

1
2
3
4
5

sensor:
  - platform: template
    name: "Durchschnittstemperatur"
    lambda: |-
      return (id(temp1).state + id(temp2).state) / 2.0;      

Bedingte Zustände anzeigen

Der Sensor zeigt an, ob die Raumtemperatur einen kritischen Wert überschreitet:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

sensor:
  - platform: template
    name: "Temperaturstatus"
    lambda: |-
      if (id(temp_sensor).state > 30.0) {
        return 1;  // Kritischer Zustand
      } else {
        return 0;  // Normalzustand
      }      
    unit_of_measurement: "Status"
    icon: "mdi:thermometer-alert"

Prozentuale Anzeige

Ein Template-Sensor berechnet den Prozentsatz basierend auf einem Maximumwert:

1
2
3
4
5
6
7
8

sensor:
  - platform: template
    name: "Batterieladung"
    lambda: |-
      return (id(current_voltage).state / 12.6) * 100.0;      
    unit_of_measurement: "%"
    icon: "mdi:battery"
    accuracy_decimals: 1

Konfiguration und wichtige Eigenschaften

Template-Sensoren bieten zahlreiche Konfigurationsoptionen, um die Darstellung und Verarbeitung zu optimieren. Einige der wichtigsten Eigenschaften sind:

• unit_of_measurement: Legt die Einheit des Wertes fest, z. B. “°C”, “%” oder “W”.
• accuracy_decimals: Bestimmt die Anzahl der Nachkommastellen im Ergebnis.
• icon: Ermöglicht das Festlegen eines spezifischen Icons zur Darstellung im Frontend von Home Assistant.
• state_class: Wird verwendet, um aggregierte Werte wie Summen oder Durchschnittswerte zu berechnen (z. B. für Energie-Statistiken).

Beispiel:

1
2
3
4
5
6
7
8
9

sensor:
  - platform: template
    name: "Leistungsaufnahme"
    lambda: |-
      return id(current_sensor).state * id(voltage_sensor).state;      
    unit_of_measurement: "W"
    accuracy_decimals: 2
    state_class: "measurement"
    icon: "mdi:flash"

Erweiterte Anwendungen von Template-Sensoren

Nutzung mehrerer Eingabewerte

Template-Sensoren können Werte aus mehreren Quellen kombinieren. Beispielsweise könnte ein Sensor den Energieverbrauch berechnen, indem Spannung und Stromstärke multipliziert werden:

1
2
3
4
5
6
7
8

sensor:
  - platform: template
    name: "Energieverbrauch"
    lambda: |-
      return id(voltage).state * id(current).state;      
    unit_of_measurement: "W"
    accuracy_decimals: 1
    icon: "mdi:power-plug"

Komplexe Bedingungslogik

Ein Sensor könnte beispielsweise unterschiedliche Werte basierend auf Tageszeit oder Zustand ausgeben:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

sensor:
  - platform: template
    name: "Tageszeitabhängiger Wert"
    lambda: |-
      if (id(current_time).now().hour < 12) {
        return id(morning_sensor).state;
      } else {
        return id(evening_sensor).state;
      }      
    unit_of_measurement: "Einheit"
    icon: "mdi:clock"

Optimierung und Best Practices

• Kombination mit Filtern: Template-Sensoren lassen sich hervorragend mit Filtern kombinieren, um Daten vor der Weiterverarbeitung zu validieren oder zu glätten.
• Ressourcenmanagement: Template-Sensoren, die intensive Berechnungen enthalten, sollten effizient geschrieben werden, um den Mikrocontroller nicht zu überlasten.
• Debugging: Verwende ESP_LOGD, um Zwischenwerte zu protokollieren und Fehler zu beheben.

Weitere Informationen

Die offizielle ESPHome-Dokumentation zu Template-Sensoren bietet eine umfassende Beschreibung der verfügbaren Optionen und Anwendungen. Nutze Template-Sensoren, um dein Smart-Home-System noch vielseitiger und individueller zu gestalten.

ESPHome Lambdas: Benutzerdefinierte Logik flexibel einsetzen

Lambdas sind eines der Kernkonzepte von ESPHome, mit denen du benutzerdefinierte Codeblöcke in C++ direkt in deiner YAML-Konfiguration verwenden kannst. Sie bieten die Möglichkeit, komplexe Datenmanipulationen und Logiken direkt auf dem Mikrocontroller zu implementieren, bevor diese an Home Assistant weitergeleitet werden. Diese Flexibilität macht Lambdas zu einem unverzichtbaren Werkzeug für individuelle Anpassungen in Smart-Home-Projekten.

Ein Lambda ist im Wesentlichen ein anonymer Funktionsblock, der spezifische Berechnungen oder Bedingungen umsetzen kann. Mit Lambdas lassen sich beispielsweise Daten anpassen, filtern oder berechnen. Sie arbeiten direkt auf dem Gerät, wodurch die Datenlast reduziert wird und die Verarbeitung effizienter erfolgt. Lambdas können überall in ESPHome eingesetzt werden, etwa in Kombination mit Sensoren, Schaltern, Lichtern und Automatisierungen.

Einsatzbereiche und technische Details von Lambdas

Lambdas werden in der Programmiersprache C++ geschrieben, was eine hohe Flexibilität und direkte Integration mit ESPHome-Komponenten ermöglicht. Mit id(name) kannst du auf jedes definierte Objekt zugreifen, etwa Sensoren oder Aktoren. Sie unterstützen Rückgabewerte, die etwa in Filtern oder Template-Sensoren verwendet werden können. Außerdem können komplexe Logiken mit Bedingungen, Schleifen und externen Funktionen umgesetzt werden, was die Lesbarkeit und Wiederverwendbarkeit erhöht.

Ein Beispiel für den Einsatz von Lambdas ist die Anpassung von Sensordaten. Hier kann ein Rohwert eines Temperatursensors direkt umgerechnet und an Home Assistant gesendet werden:

1
2
3
4
5
6
7
8

sensor:
  - platform: dht
    pin: D2
    temperature:
      name: "Raumtemperatur"
      filters:
        - lambda: |-
            return x * 1.8 + 32;  // Umrechnung von Celsius in Fahrenheit            

Ein weiteres Beispiel ist die dynamische Steuerung der Helligkeit einer LED basierend auf der Tageszeit. Mithilfe eines Lambdas kann die Helligkeit nachts reduziert und tagsüber maximiert werden:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

light:
  - platform: monochromatic
    name: "Dimmbare LED"
    output: pwm_output
    on_turn_on:
      - lambda: |-
          int hour = id(current_time).now().hour;
          if (hour >= 20 || hour < 6) {
            id(pwm_output).set_level(0.5);  // Reduzierte Helligkeit nachts
          } else {
            id(pwm_output).set_level(1.0);  // Maximale Helligkeit tagsüber
          }          

Neben diesen praxisnahen Beispielen können Lambdas auch für Debugging und Logging verwendet werden. Über ESP_LOGD, ESP_LOGI oder ESP_LOGW lassen sich Zustände oder Warnungen direkt in den ESPHome-Logs ausgeben. Dies ist besonders hilfreich, um die korrekte Funktion von Automatisierungen oder Sensoren zu überprüfen:

1
2
3
4
5
6
7
8
9

sensor:
  - platform: dht
    pin: D2
    temperature:
      name: "Raumtemperatur"
      filters:
        - lambda: |-
            ESP_LOGD("sensor", "Aktuelle Temperatur: %f", x);
            return x;            

Erweiterte Anwendungen von Lambdas: Inspiration aus der Lambda Magic-Dokumentation

Die ESPHome Lambda Magic zeigt viele erweiterte Anwendungsbeispiele, die die Vielseitigkeit von Lambdas verdeutlichen. Ein faszinierendes Beispiel ist die dynamische Anpassung eines RGB-Lichts basierend auf einem externen Sensorwert:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

light:
  - platform: rgb
    name: "Dynamisches RGB-Licht"
    red: output_red
    green: output_green
    blue: output_blue
    on_turn_on:
      - lambda: |-
          float brightness = id(sensor_helligkeit).state / 100.0;
          id(output_red).set_level(brightness);
          id(output_green).set_level(brightness * 0.8);
          id(output_blue).set_level(brightness * 0.6);          

Ein weiteres kreatives Beispiel ist die Nutzung von Lambdas für komplexe Animationen oder Zustandswechsel. So kann beispielsweise ein Lüfter in mehreren Geschwindigkeitsstufen basierend auf der Temperatur gesteuert werden:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

switch:
  - platform: template
    name: "Lüftersteuerung"
    lambda: |-
      if (id(temp_sensor).state > 30.0) {
        id(luefter).turn_on();
        id(luefter).set_speed(3);
      } else if (id(temp_sensor).state > 25.0) {
        id(luefter).turn_on();
        id(luefter).set_speed(2);
      } else {
        id(luefter).turn_off();
      }      

Diese Art der Steuerung zeigt, wie vielseitig Lambdas sein können, um intelligente Logiken direkt auf dem Mikrocontroller umzusetzen.

Integration von externen Funktionen in Lambdas

Eine häufige Herausforderung bei komplexeren Projekten ist die Wiederverwendbarkeit von Logik. Mit externen Funktionen lassen sich solche Herausforderungen elegant lösen. Im folgenden Beispiel wird eine Funktion definiert, die einen Rohwert eines Spannungssensors umrechnet:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

sensor:
  - platform: adc
    pin: A0
    name: "Spannungssensor"
    filters:
      - lambda: |-
          float convert_voltage(float raw_value) {
            return raw_value * 3.3;  // Umwandlung des ADC-Werts in Spannung
          }
          return convert_voltage(x);          

Durch diese Struktur kannst du komplexere Berechnungen aus der Hauptlogik auslagern und wiederverwenden, was die Wartbarkeit und Lesbarkeit der Konfiguration verbessert.

Optimierung und Best Practices

Beim Einsatz von Lambdas sollte stets die Performance berücksichtigt werden. Komplexe Berechnungen oder häufige Aufrufe können die Verarbeitungsgeschwindigkeit beeinflussen, insbesondere bei Geräten mit begrenzten Ressourcen. Es empfiehlt sich, Lambdas übersichtlich zu halten und komplexere Logik in externe Funktionen auszulagern.

Um Lambdas effizient zu nutzen, solltest du die umfassende ESPHome-Dokumentation konsultieren. Dort findest du detaillierte Informationen zu verfügbaren Funktionen, Anwendungsbeispielen und Tipps zur Fehlerbehebung. Mit der richtigen Herangehensweise kannst du Lambdas einsetzen, um die Funktionalität und Effizienz deines Smart-Home-Systems erheblich zu steigern.

ESPHome External Components: Erweiterte Funktionen modular integrieren

External Components sind ein zentraler Bestandteil der Erweiterungsmöglichkeiten in ESPHome. Sie ermöglichen es, benutzerdefinierte Funktionen und komplexe Logiken in Form von separaten Modulen in dein Smart-Home-System zu integrieren. Dies ist besonders hilfreich, wenn du über die Standardkomponenten hinausgehende Funktionalitäten benötigst oder eigene Hardware mit ESPHome nutzen möchtest.

Was sind External Components?

External Components sind benutzerdefinierte oder vorgefertigte Module, die in ESPHome eingebunden werden können. Sie erweitern die ESPHome-Funktionalität und können direkt aus externen Repositories geladen werden. External Components bieten eine saubere Möglichkeit, wiederverwendbare und wartbare Module zu erstellen, ohne die Hauptkonfiguration zu überladen.

Die wichtigsten Vorteile von External Components sind:

• Modularität: Code kann in separaten Dateien oder Repositories organisiert werden.
• Wiederverwendbarkeit: Komponenten können in mehreren Projekten eingesetzt werden.
• Erweiterbarkeit: Benutzerdefinierte Funktionen können einfach hinzugefügt werden.

Aufbau einer External Component

Eine External Component besteht aus drei Hauptbestandteilen:

1. YAML-Konfiguration: Hier wird definiert, welche Quellen eingebunden werden und wie die Komponenten verwendet werden.

2. Python-Modul: Dieses Modul beschreibt die Konfigurationslogik und stellt sicher, dass die Komponenten korrekt initialisiert werden.

3. C++-Code: Hier wird die eigentliche Funktionalität der Komponente implementiert, wie das Verarbeiten von Sensordaten oder die Steuerung von Aktoren.

Konfiguration von External Components

External Components werden über die YAML-Konfiguration definiert. Hier ein einfaches Beispiel für die Einbindung eines Moduls aus einem GitHub-Repository:

1
2
3
4

external_components:
  - source: github://benutzername/repository
    components: [ my_custom_component ]
    refresh: 60s

• source: Gibt die Quelle der Komponente an (z. B. ein GitHub-Repository).
• components: Listet die spezifischen Komponenten auf, die aus dem Repository verwendet werden sollen.
• refresh: Definiert das Intervall, in dem die Komponente aktualisiert wird.

Beispiel: Ein benutzerdefinierter Sensor mit External Components

Dieses Beispiel zeigt, wie ein Sensor erstellt wird, der Daten von einem UART und einem ADC kombiniert. Dies ist nützlich, wenn du Messwerte aus verschiedenen Quellen miteinander verarbeiten möchtest, beispielsweise um Rohdaten von externen Sensoren zu interpretieren und daraus aggregierte Informationen zu generieren.

Der komplexe Sensor liefert mehrere Messwerte an Home Assistant, etwa für Spannung, Temperatur und Statusindikatoren wie “Warnung” oder “Fehler”.

YAML-Konfiguration

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

external_components:
  - source: github://benutzername/mein-sensor-repo

uart:
  id: uart_bus
  tx_pin: GPIO1
  rx_pin: GPIO3
  baud_rate: 9600

adc:
  - id: voltage_sensor
    pin: A0

my_complex_sensor:
  uart_id: uart_bus
  adc_id: voltage_sensor
  update_interval: 5s

sensor:
  - platform: custom
    lambda: |-
      auto my_sensor = id(my_complex_sensor);
      return {my_sensor->get_temperature_sensor(), my_sensor->get_status_sensor()};      
    sensors:
      - name: "Temperatur"
        unit_of_measurement: "°C"
      - name: "Status"
        unit_of_measurement: ""
        icon: "mdi:alert"

binary_sensor:
  - platform: custom
    lambda: |-
      return {id(my_complex_sensor)->get_error_binary_sensor()};      
    binary_sensors:
      - name: "Fehlerstatus"

Python-Modul zur Definition der Komponente

Die Konfigurationslogik der External Component wird in Python definiert. Sie erlaubt, dass der Sensor mehrere Entitäten wie Temperatursensoren und Status-Binary-Sensoren bereitstellt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import uart, sensor, binary_sensor
from esphome.const import CONF_ID, CONF_UART_ID, CONF_ADC_ID, UNIT_CELSIUS, ICON_THERMOMETER

my_ns = cg.esphome_ns.namespace('my_complex_sensor')
MyComplexSensor = my_ns.class_('MyComplexSensor', cg.PollingComponent)

CONFIG_SCHEMA = cv.Schema({
    cv.GenerateID(): cv.declare_id(MyComplexSensor),
    cv.GenerateID(uart.UARTComponent): cv.use_id(uart.UARTComponent),
    cv.GenerateID(sensor.Sensor): cv.use_id(sensor.Sensor),
    cv.Optional('update_interval', default='10s'): cv.update_interval,
}).extend(uart.UART_DEVICE_SCHEMA)

async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)

    uart_component = await cg.get_variable(config[CONF_UART_ID])
    cg.add(var.set_uart(uart_component))

    adc_component = await cg.get_variable(config[CONF_ADC_ID])
    cg.add(var.set_adc(adc_component))

    temperature_sensor = await sensor.new_sensor({
        "name": "Temperatur",
        "unit_of_measurement": UNIT_CELSIUS,
        "icon": ICON_THERMOMETER
    })
    cg.add(var.register_temperature_sensor(temperature_sensor))

    error_binary_sensor = await binary_sensor.new_binary_sensor({
        "name": "Fehlerstatus"
    })
    cg.add(var.register_error_binary_sensor(error_binary_sensor))

C++-Implementierung der Funktionalität

Der folgende Code implementiert die Funktionalität der External Component und ermöglicht das Bereitstellen mehrerer Sensoren:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include "esphome.h"
namespace esphome {
namespace my_complex_sensor {

class MyComplexSensor : public PollingComponent {
 public:
  void set_uart(UARTComponent *uart) { this->uart = uart; }
  void set_adc(Sensor *adc) { this->adc = adc; }

  void setup() override {
    ESP_LOGI("my_complex_sensor", "Sensor initialisiert");
  }

  void update() override {
    uint8_t data[4];
    this->uart->read_array(data, 4);

    float adc_value = this->adc->state;
    float temperature = calculate_temperature(data, adc_value);

    this->temperature_sensor->publish_state(temperature);

    if (temperature > 100.0) {
      this->error_binary_sensor->publish_state(true);
    } else {
      this->error_binary_sensor->publish_state(false);
    }
  }

  Sensor *get_temperature_sensor() { return this->temperature_sensor; }
  BinarySensor *get_error_binary_sensor() { return this->error_binary_sensor; }

 private:
  UARTComponent *uart;
  Sensor *adc;
  Sensor *temperature_sensor;
  BinarySensor *error_binary_sensor;

  float calculate_temperature(uint8_t *data, float adc_value) {
    return (data[0] + adc_value) / 2.0;  // Beispielrechnung
  }
};

}  // namespace my_complex_sensor
}  // namespace esphome

Best Practices

• Mehrere Entitäten: Stelle sicher, dass alle relevanten Datenpunkte in Form von Sensoren oder Binary-Sensoren verfügbar gemacht werden.
• Modularität: Halte die Logik übersichtlich, indem du separate Methoden oder Funktionen für wiederkehrende Berechnungen nutzt.
• Logging: Nutze umfangreiches Debugging, um die korrekte Funktion der Sensoren zu gewährleisten.
• Versionskontrolle: Verknüpfe deine External Components mit spezifischen Tags oder Branches, um stabile Versionen sicherzustellen.

Mit External Components kannst du ESPHome um nahezu unbegrenzte Funktionalitäten erweitern. Sie bieten eine saubere und wiederverwendbare Möglichkeit, benutzerdefinierte Logik und Hardware in dein Smart-Home-System zu integrieren. Nutze External Components, um dein Smart Home noch leistungsfähiger und individueller zu gestalten. Weitere Details findest du in der ESPHome-Dokumentation zu External Components.

Fazit

ESPHome ist ein unglaublich vielseitiges Werkzeug, das sich sowohl für Einsteiger als auch für erfahrene Smart-Home-Enthusiasten eignet. Mit seiner Unterstützung für eine Vielzahl von Geräten und den leistungsstarken Anpassungsfunktionen kannst du nahezu jedes Szenario umsetzen – von einfachen Lichtersteuerungen bis hin zu komplexen Überwachungssystemen.

Diese Anleitung hat dir gezeigt, wie du mit vorgefertigten Geräten schnell loslegen kannst und welche Möglichkeiten dir die Kernkonzepte von ESPHome bieten. Kombiniere die Grundlagen mit fortgeschrittenen Funktionen wie Lambdas, Filtern, Template-Sensoren und External Components, um dein Smart Home perfekt auf deine Bedürfnisse abzustimmen.

Nutze die vorgestellten Beispiele und Werkzeuge, um dein Zuhause smarter, effizienter und komfortabler zu gestalten. Mit ESPHome und Home Assistant steht dir eine Welt voller Möglichkeiten offen!