1. Worum geht's?

Der Keller hat vier flache Deckenfenster (≈ 80 cm × 20 cm), die sich mechanisch kippen lassen — der Spalt geht aktuell etwa 10 cm auf. Anstatt permanent zu kippen oder permanent zu zu lassen, soll diese Kippstellung motorisch geregelt werden. Ein Mikrocontroller misst Klima außen und innen und öffnet die Fenster nur, wenn das Lüften messbar trocknet (siehe Faustregel).

Der Lösungsansatz ist bewusst klein und konservativ: keine Hightech-Lüftungsanlage, sondern ein gezielter Eingriff an den vorhandenen Fenstern. Die zwei Sicherheits-Defaults sind: im Zweifel zu und nicht zu oft schalten.

2. Systemskizze

┌─────────────────┐                      ┌────────────────────┐
│  Außensensor    │                      │  Kellersensor      │
│  ESP32 + BME280 │   ── WLAN ──▶        │  ESP32 + BME280    │
│  (T, RH, p)     │                      │  (T, RH, p)        │
└─────────────────┘                      └────────────────────┘
         │                                         │
         └──────────── MQTT/ESPHome ───────────────┘
                              │
                  ┌───────────▼───────────┐
                  │   Home Assistant      │
                  │  (Mini-PC / HA Green) │
                  │                       │
                  │   abs. Feuchte        │
                  │   Taupunkt            │
                  │   Logik (siehe §3)    │
                  │   Historie            │
                  └───────┬───────────────┘
                          │ HTTP
                  ┌───────▼───────────────┐
                  │ Shelly Pro 4PM (24V)  │
                  └─┬───┬───┬───┬─────────┘
                    │   │   │   │     ┌────────────┐
                    └───┴───┴───┴────▶│ 4× Ketten- │
                                      │ antrieb    │
                                      └────────────┘
                                               │
                                      ┌────────▼─────────┐
                                      │ 4× Reed-Sensor   │
                                      │ "Fenster offen"  │
                                      └──────────────────┘

Datenfluss in Worten: zwei ESP32 messen alle 30 s Temperatur, relative Feuchte und Luftdruck mit BME280-Sensoren. Aus den Rohwerten berechnet ESPHome (oder Home Assistant) per Magnus-Formel die absolute Feuchte und den Taupunkt. Home Assistant entscheidet anhand der Tabelle in §3, ob die Fenster offen oder zu sein sollen, und schickt einen Befehl an einen Shelly-Pro-4PM, der vier 24-Volt-Kettenantriebe schaltet. Reed-Kontakte melden zurück, ob die Fenster tatsächlich offen sind.

3. Entscheidungstabelle

Die Tabelle wird von oben nach unten ausgewertet. Sobald eine Bedingung greift, wird die zugehörige Aktion ausgeführt — die weiter unten stehenden Bedingungen werden dann nicht mehr geprüft. Werte, die sich später als unpassend erweisen, sind über Home-Assistant-Eingabefelder (`input_number`) zur Laufzeit änderbar — kein Re-Flash nötig.

Die Schwellwerte folgen anerkannten Werten aus der Maker-/Smart-Home-Szene^[1][2][3]: eine Differenz von 1,0 g/m³ absoluter Feuchte ist groß genug, dass Sensorrauschen nicht durchschlägt, und klein genug, dass im Sommer noch genügend Trocknungsfenster übrig bleiben. Statt der absoluten Feuchte funktioniert auch ein Taupunkt-Vergleich (Außen mindestens 2 °C unter Innen) — das Make-Magazin-Projekt nutzt diese Variante^[1].

4. Hardware-Stückliste

Realistische Preisspanne für die komplette Anlage liegt bei ca. 700 – 900 €, ohne Eigenleistung. Die größten Posten sind die Kettenantriebe und der Smart-Home-Hub.

Hinweis zum Kettenantrieb: 24 V ist sicherer (Schutzkleinspannung) und im Wohnumfeld unkritisch zu verkabeln. Die meisten Modelle fahren bei dauerhaft anliegender Spannung in Endlage und ziehen dann nur noch wenige Milliampere — der Motor braucht also keine ständige aktive Steuerung. Auf-/Zu-Befehl genügt.

5. ESPHome-Konfiguration (Sensor außen)

ESPHome^[7] ist die einfachste Bridge zwischen Mikrocontrollern und Home Assistant: man schreibt eine YAML-Datei, drückt „Compile", flasht den ESP32 — fertig. Dieselbe YAML mit anderem Namen wird auf den Innensensor geflasht.

# aussen.yaml — auf den ESP32 außen flashen
substitutions:
  device_name: keller-aussen
  friendly: "Außensensor Keller"

esphome:
  name: ${device_name}
  friendly_name: ${friendly}

esp32:
  board: esp32dev
  framework: { type: arduino }

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

api:
ota:
  - platform: esphome
logger:

i2c: { sda: 21, scl: 22, frequency: 100kHz }

sensor:
  - platform: bme280_i2c
    address: 0x76
    update_interval: 30s
    temperature:
      name: "Außentemperatur"
      id: t_out
      filters: [ filter_out: nan ]
    humidity:
      name: "Außenluftfeuchte"
      id: rh_out
    pressure:
      name: "Luftdruck außen"

  # Berechnung der absoluten Feuchte (Magnus + ideale Gasgleichung)
  - platform: template
    name: "Außenluft absolute Feuchte"
    unit_of_measurement: "g/m³"
    accuracy_decimals: 2
    update_interval: 30s
    lambda: |-
      const float a = 7.5f;
      const float b = 237.3f;
      const float t  = id(t_out).state;
      const float rh = id(rh_out).state;
      if (isnan(t) || isnan(rh)) return NAN;
      const float es = 6.1078f * powf(10.0f, (a * t) / (b + t));
      const float e  = (rh / 100.0f) * es;
      return 216.679f * e / (t + 273.15f);

  # Taupunkt (Magnus-Umkehrung)
  - platform: template
    name: "Taupunkt außen"
    unit_of_measurement: "°C"
    accuracy_decimals: 1
    update_interval: 30s
    lambda: |-
      const float a = 7.5f;
      const float b = 237.3f;
      const float t  = id(t_out).state;
      const float rh = id(rh_out).state;
      if (isnan(t) || isnan(rh)) return NAN;
      const float es = 6.1078f * powf(10.0f, (a * t) / (b + t));
      const float e  = (rh / 100.0f) * es;
      const float v  = log10f(e / 6.1078f);
      return (b * v) / (a - v);

Für den Innensensor reicht es, device_name und die Sensor-Anzeigenamen anzupassen ("Innentemperatur" etc.). Beide ESPs erscheinen dann automatisch in Home Assistant unter Geräte → ESPHome.

6. Home-Assistant-Integration

Home Assistant ist 2026 die mit Abstand reichste Smart-Home-Plattform (3 000+ Integrationen, monatliches Release-Tempo, native Mobile-App, beste Community^[8]) und per Definition lokal — alles läuft über eigenes WLAN, kein Cloud-Zwang. Für dieses Projekt sind drei Bausteine nötig: ein Template-Sensor für die Steuergröße, ein Binary Sensor mit der Logiktabelle und eine Automation, die den Fenster-Cover schaltet.

# configuration.yaml-Auszug — alle Schwellwerte zur Laufzeit änderbar
input_number:
  ah_diff_open:
    name: "Schwellwert Δ abs. Feuchte (Öffnen)"
    min: 0.2
    max: 5.0
    step: 0.1
    initial: 1.0
    unit_of_measurement: "g/m³"
  t_out_min:
    name: "Min Außentemperatur"
    min: -10
    max: 20
    step: 0.5
    initial: 2.0
    unit_of_measurement: "°C"
  t_out_max:
    name: "Max Außentemperatur"
    min: 20
    max: 40
    step: 0.5
    initial: 28.0
    unit_of_measurement: "°C"
  t_in_min:
    name: "Min Kellertemperatur"
    min: 0
    max: 15
    step: 0.5
    initial: 6.0
    unit_of_measurement: "°C"

input_boolean:
  fenster_override_zu:
    name: "Fenster zwangsweise schließen"
  fenster_override_auf:
    name: "Fenster zwangsweise öffnen"

template:
  - sensor:
      - name: "Keller absolute Feuchte"
        unique_id: keller_abs_humidity
        unit_of_measurement: "g/m³"
        state: >
          {% set t  = states('sensor.keller_innen_innentemperatur') | float(none) %}
          {% set rh = states('sensor.keller_innen_innenluftfeuchte') | float(none) %}
          {% if t is none or rh is none %}
            unknown
          {% else %}
            {% set es = 6.1078 * (10 ** ((7.5 * t) / (237.3 + t))) %}
            {% set e  = (rh / 100) * es %}
            {{ (216.679 * e / (t + 273.15)) | round(2) }}
          {% endif %}

  - binary_sensor:
      - name: "Lüften lohnt"
        unique_id: lueften_lohnt
        device_class: opening
        state: >
          {% set ah_out = states('sensor.aussensensor_aussenluft_absolute_feuchte') | float(none) %}
          {% set ah_in  = states('sensor.keller_absolute_feuchte') | float(none) %}
          {% set t_out  = states('sensor.aussensensor_aussentemperatur')  | float(none) %}
          {% set t_in   = states('sensor.keller_innen_innentemperatur')   | float(none) %}
          {% set d      = states('input_number.ah_diff_open') | float(1.0) %}
          {% set tmin_a = states('input_number.t_out_min')   | float(2.0) %}
          {% set tmax_a = states('input_number.t_out_max')   | float(28.0) %}
          {% set tmin_i = states('input_number.t_in_min')    | float(6.0) %}
          {% if None in [ah_out, ah_in, t_out, t_in] %}
            off
          {% elif is_state('input_boolean.fenster_override_zu','on') %}
            off
          {% elif is_state('input_boolean.fenster_override_auf','on') %}
            on
          {% elif t_out < tmin_a or t_out > tmax_a or t_in < tmin_i %}
            off
          {% else %}
            {{ (ah_in - ah_out) >= d }}
          {% endif %}

automation:
  - alias: "Kellerfenster schalten"
    mode: single
    trigger:
      - platform: state
        entity_id: binary_sensor.lueften_lohnt
        for: "00:01:00"          # 1 min stabil, kein Flattern
    action:
      - choose:
          - conditions: "{{ trigger.to_state.state == 'on' }}"
            sequence:
              - service: cover.open_cover
                target: { entity_id: cover.kellerfenster }
        default:
          - service: cover.close_cover
            target: { entity_id: cover.kellerfenster }

  - alias: "Mindest-Schaltzyklus 15 min"
    trigger:
      - platform: state
        entity_id: cover.kellerfenster
    action:
      - delay: "00:15:00"       # 15 min Sperre nach jeder Bewegung

Frontend / Historie

Im Home-Assistant-Dashboard zeigt eine einzige Karte alle Live-Werte (Außen, Keller, Δabs. Feuchte, Status), eine zweite zeigt die letzten 24 Stunden als Diagramm (Builtin history-graph oder statistics-graph; für Langzeit empfiehlt sich die recorder-Defaults bei kleinen Datenmengen). Logbuch-Eintrag jeder Schaltaktion ist automatisch da.

Externer Zugriff: Home Assistant ist im VPN sowieso erreichbar (Port 8123) — extra DDNS oder Cloud-Service nicht nötig.

7. Bauen oder kaufen?

Es gibt fertige Geräte, die eine ähnliche Logik in einer Box umsetzen — meist mit Lüfter statt Fenster, aber das Funktionsprinzip ist dasselbe:

• Make-Magazin „Taupunktlüfter" — der Klassiker (DIY, ESP-basiert, Code auf GitHub^[9]), extrem gut dokumentiert, größtenteils Vorbild für diese Skizze^[1].
• Ambientika Südwind — kommerzielle dezentrale Lüftung mit Funksensoren und Taupunktsteuerung; 1 000 – 1 500 € pro Gerät^[10].
• SE Ventilation — eigene Marken-Steuerung mit schimmelschutz-orientierter Auslegung^[3].
• KD Elektroniksysteme „Entfeuchtungssteuerung" — kompakt für Mietwohnungen^[11].

Der Eigenbau lohnt sich, wenn man vier Antriebe gleichzeitig ansteuern will, die Schwellwerte selbst festlegen möchte und ohnehin schon ein Home Assistant betreibt. Ein einzelnes fertiges Gerät ist günstiger pro Schaltkanal, aber proprietär und meist auf 1 – 2 Lüfter ausgelegt.

8. Offene Punkte

• Abstimmung mit dem Vermieter: Kettenantriebe an Bestandsfenstern sind eine bauliche Veränderung — entsprechend gemeinsam mit dem Vermieter planen (Rückbaufähigkeit, Versicherung, Wartung). Die Datengrundlage aus Heizung und Lüften macht den Mehrwert für das gesamte Haus nachvollziehbar.
• Strom für die Antriebe: 24 V-Leitung muss zu jedem der vier Fenster verlegt werden. Wenn Strom-Steigerleitung für Smart-Home-Aktoren fehlt, ist das der größte Aufwand.
• Sicherung: Die Fenster sollten Mindestöffnung (10 cm Spalt) auch im offenen Zustand mechanisch nicht zu weit aufgehen können — nicht-ausstellbare Kettenantriebe wählen oder Endlagenanschlag setzen, sonst ist das ein Einbruchpunkt.
• Kondensat im Antrieb: Antriebe in Außenfenstern müssen für Außenanwendung freigegeben sein (IP44+).
• Erweiterung: Wenn man wirklich trocknen will, kann ein Bautrockner als sekundärer Aktor in die gleiche Logik eingebunden werden (Bedingung: Fenster zu UND ρ_w,keller > Schwelle).