From 3b7b10ac4268600267f74227e176bb4814942294 Mon Sep 17 00:00:00 2001 From: martin Date: Sun, 31 May 2026 19:05:25 +0000 Subject: [PATCH] Fix: upload plain YAML (was accidentally double base64-encoded) --- .../automation/shelly_charger_monitor.yaml | 227 +++++++++++++++++- 1 file changed, 226 insertions(+), 1 deletion(-) diff --git a/blueprints/automation/shelly_charger_monitor.yaml b/blueprints/automation/shelly_charger_monitor.yaml index bba14fd..04eee65 100644 --- a/blueprints/automation/shelly_charger_monitor.yaml +++ b/blueprints/automation/shelly_charger_monitor.yaml @@ -1 +1,226 @@ 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 \ No newline at end of file +blueprint: + name: Ladegerät überwachen (Shelly Plug S) + description: > + Erkennt automatisch, wann ein Ladevorgang beginnt und endet – anhand der + Leistungsaufnahme des Shelly Plug S. Sendet Push-Benachrichtigungen bei + Start und Ende des Ladevorgangs. Berechnet die geladene Energiemenge (kWh) + und die Stromkosten. Kann für mehrere Geräte (z. B. E-Bike und Gartengeräte) + als separate Automationen eingerichtet werden. + domain: automation + input: + power_sensor: + name: Leistungssensor + description: Shelly Plug S Leistungssensor (W) – z. B. sensor.shelly_plug_s_power + selector: + entity: + domain: sensor + device_class: power + + energy_sensor: + name: Energiesensor + description: > + Shelly Plug S Energiesensor (kWh oder Wh, kumulativ) – + z. B. sensor.shelly_plug_s_energy + selector: + entity: + domain: sensor + device_class: energy + + energy_unit: + name: Einheit des Energiesensors + description: > + Bitte in Home Assistant nachschauen, welche Einheit der Sensor anzeigt. + Neuere Shelly-Integrationen liefern kWh, ältere Wh. + default: kWh + selector: + select: + options: + - kWh + - Wh + + device_name: + name: Gerätename + description: Wird in den Push-Nachrichten angezeigt (z. B. E-Bike oder Gartengeräte) + default: Gerät + selector: + text: + + start_power_threshold: + name: Einschalt-Schwellwert (W) + description: > + Ladevorgang gilt als gestartet, wenn die Leistung diesen Wert übersteigt. + Typischer Wert: 10 W. Standby-Leistung des Shelly liegt bei ca. 0,5–1 W. + default: 10 + selector: + number: + min: 1 + max: 500 + step: 1 + unit_of_measurement: W + mode: slider + + stop_power_threshold: + name: Ausschalt-Schwellwert (W) + description: > + Ladevorgang gilt als beendet, wenn die Leistung unter diesen Wert fällt. + Sollte kleiner als der Einschalt-Schwellwert sein. + default: 5 + selector: + number: + min: 1 + max: 100 + step: 1 + unit_of_measurement: W + mode: slider + + start_debounce_seconds: + name: Startbestätigung (Sekunden) + description: > + Die Leistung muss diesen Zeitraum stabil über dem Einschalt-Schwellwert + liegen, bevor der Ladestart erkannt wird. Vermeidet Fehlalarme durch + kurze Lastspitzen. + default: 30 + selector: + number: + min: 5 + max: 300 + step: 5 + unit_of_measurement: s + mode: slider + + stop_debounce_seconds: + name: Stopbestätigung (Sekunden) + description: > + Wartezeit nach dem Unterschreiten des Ausschalt-Schwellwerts, bevor das + Ende des Ladevorgangs bestätigt wird. Verhindert Fehlalarme wenn das + Ladegerät kurz Strom schwankt (z. B. Balancing-Phase beim Akku). + default: 120 + selector: + number: + min: 30 + max: 600 + step: 30 + unit_of_measurement: s + mode: slider + + electricity_price: + name: Strompreis (€/kWh) + description: Aktueller Strompreis für die Kostenberechnung + default: 0.30 + selector: + number: + min: 0.01 + max: 1.00 + step: 0.01 + unit_of_measurement: €/kWh + mode: box + + notify_target_1: + name: Benachrichtigungsgerät 1 + description: Gerät für Push-Nachrichten (z. B. dein Smartphone). Leer lassen für keine Benachrichtigung. + default: "" + selector: + notify: + + notify_target_2: + name: Benachrichtigungsgerät 2 (optional) + description: Zweites Gerät für Push-Nachrichten (optional). + default: "" + selector: + notify: + +variables: + power_sensor: !input power_sensor + energy_sensor: !input energy_sensor + energy_unit: !input energy_unit + device_name: !input device_name + stop_power_threshold: !input stop_power_threshold + stop_debounce_seconds: !input stop_debounce_seconds + electricity_price: !input electricity_price + notify_target_1: !input notify_target_1 + notify_target_2: !input notify_target_2 + notify_targets: > + {{ [notify_target_1, notify_target_2] | select('ne', '') | list }} + +trigger: + - platform: numeric_state + entity_id: !input power_sensor + above: !input start_power_threshold + for: + seconds: !input start_debounce_seconds + +action: + - variables: + start_time: "{{ now() }}" + start_power: "{{ states(power_sensor) | float(0) | round(1) }}" + start_energy_raw: "{{ states(energy_sensor) | float(0) }}" + start_energy_kwh: > + {{ (states(energy_sensor) | float(0)) / 1000 + if energy_unit == 'Wh' + else (states(energy_sensor) | float(0)) }} + + - if: + - condition: template + value_template: "{{ notify_targets | length > 0 }}" + then: + - service: notify.send_message + target: + entity_id: "{{ notify_targets }}" + data: + title: "🔋 Laden gestartet – {{ device_name }}" + message: > + Ladevorgang erkannt: {{ start_power }} W. + Gestartet um {{ start_time | as_timestamp | timestamp_custom('%H:%M Uhr') }}. + + - wait_for_trigger: + - platform: numeric_state + entity_id: !input power_sensor + below: !input stop_power_threshold + timeout: + hours: 24 + continue_on_timeout: true + + - delay: + seconds: "{{ stop_debounce_seconds }}" + + - variables: + end_time: "{{ now() }}" + end_energy_kwh: > + {{ (states(energy_sensor) | float(0)) / 1000 + if energy_unit == 'Wh' + else (states(energy_sensor) | float(0)) }} + charged_kwh: > + {{ [((states(energy_sensor) | float(0)) / 1000 + if energy_unit == 'Wh' + else (states(energy_sensor) | float(0))) + - start_energy_kwh, 0] | max | round(3) }} + total_cost: > + {{ ([((states(energy_sensor) | float(0)) / 1000 + if energy_unit == 'Wh' + else (states(energy_sensor) | float(0))) + - start_energy_kwh, 0] | max * electricity_price) | round(2) }} + duration_seconds: > + {{ (now() - start_time).total_seconds() | int }} + duration_text: > + {% set s = (now() - start_time).total_seconds() | int %} + {% set h = (s // 3600) %} + {% set m = ((s % 3600) // 60) %} + {% if h > 0 %}{{ h }} h {{ m }} min{% else %}{{ m }} min{% endif %} + + - if: + - condition: template + value_template: "{{ notify_targets | length > 0 }}" + then: + - service: notify.send_message + target: + entity_id: "{{ notify_targets }}" + data: + title: "✅ Laden fertig – {{ device_name }}" + message: > + Ladevorgang abgeschlossen. + Dauer: {{ duration_text }} + Geladen: {{ charged_kwh }} kWh + Kosten: ca. {{ total_cost }} € + +mode: single +max_exceeded: silent