Author: Robert

Home Assistant
9. März 2025 One Comment

Growatt Speicher in Home Assistant einbinden – So geht’s!

Du hast einen Growatt NOAH 2000 Speicher und möchtest ihn in Home Assistant integrieren, um wichtige Daten wie Temperatur, Heizstatus und Einspeisung zu überwachen? Mit dieser einfachen Anleitung gelingt dir das problemlos!

Schritt 1: MQTT-Integration installieren

Die MQTT-Integration ist notwendig, um die Growatt-Daten auszulesen. So geht’s:

  1. Gehe in Home Assistant auf Einstellungen ➔ Geräte & Dienste.
  2. Klicke unten auf Integration hinzufügen.
  3. Suche nach MQTT und installiere die Integration.
  4. Falls die Installation abgeschlossen ist, sollte sie als “Installation Single allow” erscheinen.

Schritt 2: Growatt MQTT-Integration einrichten

  1. Folge dem entsprechenden GitHub-Link (wird meist vom Entwickler bereitgestellt).
  2. Scrolle auf der Seite nach unten und klicke auf den blauen Button zur Integration.
  3. Es öffnet sich Home Assistant und fragt, ob du die Integration installieren willst – bestätige dies mit “Ja”.
  4. Nach der Installation findest du in der Liste der Geräte und Dienste den Eintrag Noah MQTT.
  5. Klicke darauf und starte das Add-on neu.

Schritt 3: Benutzername und Passwort eintragen

  1. Gehe zur Konfiguration der Integration.
  2. Trage deinen Benutzernamen und dein Passwort ein (dieselben Anmeldedaten, die du auch für die Growatt-App verwendest).
  3. Speichere die Einstellungen.

Schritt 4: Daten im Dashboard anzeigen

Jetzt, da alle Daten ausgelesen werden, kannst du sie in deinem Dashboard darstellen:

  1. Gehe in Home Assistant auf Dashboards verwalten.
  2. Erstelle ein neues Dashboard, z.B. “Growatt Test”.
  3. Klicke auf das neue Dashboard und wähle oben Bearbeiten aus.
  4. Klicke auf das +-Symbol und wähle die Anzeigeform aus (z.B. einen Zeiger-Graph).
  5. Wähle unter “Entität” die entsprechenden Werte aus, z.B.:
    • Temperature (Temperatur)
    • Charging Power (Ladeleistung)
    • System Output Power (Ausgangsleistung)
  6. Vergib passende Namen und setze Einheiten wie “Watt” zur besseren Übersichtlichkeit.

Schritt 5: Optische Gestaltung optimieren

  • Füge weitere Anzeigen hinzu, um z.B. den Ladestatus, die Heizfunktion oder den Batteriefüllstand anzuzeigen.
  • Setze sinnvolle Werte für Minimum und Maximum zur besseren Skalierung deiner Anzeigen (z.B. Maximum 800W für die Einspeisung).

Fazit

Mit dieser Anleitung kannst du deinen Growatt NOAH 2000 Speicher in Home Assistant einbinden und alle relevanten Daten übersichtlich visualisieren. So behältst du stets den Überblick über deinen Stromspeicher und optimierst deinen Eigenverbrauch.

Viel Erfolg beim Einrichten! Wenn dir dieser Beitrag geholfen hat, teile ihn gerne mit anderen!

Home Assistant
29. Januar 2025 2 Comments

EcoTracker von Everhome in Home Assistant integrieren – Eine Schritt-für-Schritt-Anleitung

Immer mehr Smart-Home-Nutzer setzen auf Home Assistant, um ihre Geräte zu steuern und zu überwachen. Mit dem EcoTracker von Everhome kannst du deinen Stromverbrauch in Echtzeit überwachen und nahtlos in Home Assistant integrieren. In diesem Beitrag zeigen wir dir, wie du den EcoTracker in dein Smart-Home-System einbindest, um Verbrauch, Bezug und Einspeisung optimal zu visualisieren.

Schritt 1: Den File Editor aktivieren

Damit wir die Konfigurationsdateien von Home Assistant bearbeiten können, benötigen wir den File Editor. Diesen kannst du wie folgt aktivieren:

  1. Öffne Einstellungen in Home Assistant.

  2. Gehe zum Bereich Add-Ons und suche nach File Editor.

  3. Klicke darauf und aktiviere die Option In Seitenleiste anzeigen.

  4. Jetzt erscheint der File Editor in der Seitenleiste und ist jederzeit zugänglich.

Schritt 2: Die Konfigurationsdatei bearbeiten

Nachdem der File Editor aktiviert ist, öffnen wir die configuration.yaml:

  1. Klicke im File Editor auf den Reiter für Konfigurationsdateien.

  2. Wähle configuration.yaml aus.

  3. Nun sehen wir die Konfigurationsdatei mit verschiedenen Einträgen.

  4. Hier müssen wir die Datenquelle für den EcoTracker hinzufügen.

Tipp: Eine vorgefertigte Konfigurationsdatei findest du weiter unten

Schritt 3: IP-Adresse des Eco Trackers eintragen

Damit Home Assistant mit dem EcoTracker kommunizieren kann, benötigen wir dessen IP-Adresse. Diese finden wir so heraus:

  1. Rufe die Benutzeroberfläche deines Routers auf (die Zugangsdaten findest du auf dem Gerät).

  2. Gehe in den Bereich Netzwerke oder verbundene Geräte.

  3. Suche in der Liste nach EC Tracker – dort wird die IP-Adresse angezeigt.

  4. Notiere dir diese Adresse oder kopiere sie.

Nun fügen wir die IP-Adresse in die configuration.yaml ein:

  • Ersetze den Platzhalter [IP-Adresse] mit der echten IP-Adresse deines Eco Trackers.

  • Speichere die Datei mit dem Save-Button.

Schritt 4: Home Assistant neu starten

Damit die Änderungen übernommen werden, muss Home Assistant neu gestartet werden:

  1. Gehe in die Entwicklerwerkzeuge.

  2. Wähle System neu starten aus.

  3. Warte, bis das System wieder hochgefahren ist.

Nach dem Neustart sollten die Daten des EcoTrackers in Home Assistant verfügbar sein.

Schritt 5: Daten in Home Assistant anzeigen lassen

Nun wollen wir die Verbrauchsdaten in der Oberfläche sichtbar machen:

  1. Öffne Einstellungen → Geräte und Dienste.

  2. Unter Integrationen findest du den Eco Tracker.

  3. Klicke darauf, um die verfügbaren Datenquellen wie Verbrauch, Bezug und Einspeisung anzuzeigen.

Diese Daten fügen wir nun in das Dashboard ein:

  1. Gehe auf die Übersicht.

  2. Aktiviere den Bearbeitungsmodus über den Stift.

  3. Klicke auf das + Symbol, um eine neue Anzeige hinzuzufügen.

  4. Wähle eine Analoganzeige und setze die gewünschte Entität ein (z. B. Verbrauch).

  5. Passe die Skala an (z. B. 0 bis 5000 W) und definiere Farbbereiche für verschiedene Leistungsstufen.

  6. Speichere die Änderungen.

Zusätzlich können auch Zählerstand und Einspeisung als einfache Datenfelder in das Dashboard eingebunden werden.

Fazit

Mit dieser Anleitung kannst du den EcoTracker von Everhome problemlos in Home Assistant integrieren und deine Verbrauchsdaten in Echtzeit überwachen. So hast du volle Kontrolle über deinen Stromverbrauch und kannst die Einspeisung deines Balkonkraftwerks optimal auswerten.

Falls dir diese Anleitung geholfen hat, freuen wir uns über dein Feedback oder einen Kommentar! Schau regelmäßig vorbei für weitere Smart-Home-Tipps und -Anleitungen.

				
					rest:
    resource: http://[IP]/v1/json
    scan_interval: 5
    sensor:
      - name: "ecotracker"
        json_attributes:
          - "power"
          - "energyCounterIn"
          - "energyCounterOut"
          
          
template:
  - sensor:
    - name: "Ecotracker Aktueller Verbrauch"
      device_class: "power"
      state_class: "measurement"
      unit_of_measurement: "W"
      state: >
            {{ state_attr('sensor.ecotracker', 'power') }}
        
    - name: "Ecotracker Bezug"
      device_class: "energy"
      state_class: "total_increasing"
      unit_of_measurement: "KWh"
      state: >
            {{ iif(state_attr('sensor.ecotracker', 'energyCounterIn'), (state_attr('sensor.ecotracker', 'energyCounterIn') | float/1000)| round(2)) }}
    - name: "Ecotracker Einspeisung"
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total_increasing"
      state: >
            {{ iif(state_attr('sensor.ecotracker', 'energyCounterOut'), (state_attr('sensor.ecotracker', 'energyCounterOut') | float/1000)| round(2)) }}
Home Assistant
24. Januar 2025 No Comments

Voraussetzungen

  • Zugang zur Shelly Weboberfläche
  • Lokales Netzwerk, in dem der Shelly Plug verbunden ist
  • Passendes Skript für den jeweiligen Shelly Plug
  • Home Assistant Basis-Set Solar

1. Skript hochladen und konfigurieren

  1. Navigiere in der Shelly Weboberfläche zu “Scripts”.
  2. Klicke auf “Add Script”.
  3. Füge den Code aus der passenden .txt-Datei in das Skriptfeld ein:
    • Öffne die .txt-Datei mit einem Editor.
    • Kopiere den gesamten Inhalt und füge ihn in das Feld ein.
  4. Speichern:
    • Klicke auf “Save”.
  5. Starten:
    • Drücke auf “Start”, um das Skript auszuführen.

2. Shelly Plug neu einstecken

  1. Ziehe den Shelly Plug aus der Steckdose und stecke ihn wieder ein.
  2. Der Shelly Plug übernimmt die neue Konfiguration aus dem Skript.

IP-Adressen:

  • Produktion (schwarz): 192.168.99.10
  • Verbrauch1: 192.168.99.11
  • Verbrauch2: 192.168.99.12
  • Verbrauch3: 192.168.99.13
  • Verbrauch4: 192.168.99.14
  • Verbrauch5: 192.168.99.15

Download

				
					#Produktion
Shelly.call("Sys.SetConfig", {
  config: {
    "device": {
      "name": "ShellyPlug-Produktion1",
      "eco_mode": true
      }}}
);

Shelly.call("BLE.SetConfig", {
  config: {
    "enable":false
  }}
);

Shelly.call("Wifi.SetConfig", {
  config: {
    "sta":{
    "ssid":"SGSMART21",
    "pass":"SGSMART21",
    "ipv4mode":"static",
    "ip":"192.168.99.10",
    "netmask":"255.255.255.0",
    "gw":"192.168.99.1",
     "nameserver":"192.168.99.1",
     "enable":true
   }}}
);

Shelly.call("Wifi.SetConfig", {
  config: {
    "ap":{
    "enable":false
   }}}
);

Shelly.Reboot
				
			
				
					#Verbrauch1
Shelly.call("Sys.SetConfig", {
  config: {
    "device": {
      "name": "ShellyPlug-Verbrauch1",
      "eco_mode": true
      }}}
);

Shelly.call("BLE.SetConfig", {
  config: {
    "enable":false
  }}
);

Shelly.call("Wifi.SetConfig", {
  config: {
    "sta":{
    "ssid":"SGSMART21",
    "pass":"SGSMART21",
    "ipv4mode":"static",
    "ip":"192.168.99.11",
    "netmask":"255.255.255.0",
    "gw":"192.168.99.1",
     "nameserver":"192.168.99.1",
     "enable":true
   }}}
);

Shelly.call("Wifi.SetConfig", {
  config: {
    "ap":{
    "enable":false
   }}}
);

Shelly.Reboot
				
			
				
					#Verbrauch2
Shelly.call("Sys.SetConfig", {
  config: {
    "device": {
      "name": "ShellyPlug-Verbrauch2",
      "eco_mode": true
      }}}
);

Shelly.call("BLE.SetConfig", {
  config: {
    "enable":false
  }}
);

Shelly.call("Wifi.SetConfig", {
  config: {
    "sta":{
    "ssid":"SGSMART21",
    "pass":"SGSMART21",
    "ipv4mode":"static",
    "ip":"192.168.99.12",
    "netmask":"255.255.255.0",
    "gw":"192.168.99.1",
     "nameserver":"192.168.99.1",
     "enable":true
   }}}
);

Shelly.call("Wifi.SetConfig", {
  config: {
    "ap":{
    "enable":false
   }}}
);

Shelly.Reboot


				
			
				
					#Verbrauch3
Shelly.call("Sys.SetConfig", {
  config: {
    "device": {
      "name": "ShellyPlug-Verbrauch3",
      "eco_mode": true
      }}}
);

Shelly.call("BLE.SetConfig", {
  config: {
    "enable":false
  }}
);

Shelly.call("Wifi.SetConfig", {
  config: {
    "sta":{
    "ssid":"SGSMART21",
    "pass":"SGSMART21",
    "ipv4mode":"static",
    "ip":"192.168.99.13",
    "netmask":"255.255.255.0",
    "gw":"192.168.99.1",
     "nameserver":"192.168.99.1",
     "enable":true
   }}}
);

Shelly.call("Wifi.SetConfig", {
  config: {
    "ap":{
    "enable":false
   }}}
);

Shelly.Reboot
				
			
				
					#Verbrauch4
Shelly.call("Sys.SetConfig", {
  config: {
    "device": {
      "name": "ShellyPlug-Verbrauch4",
      "eco_mode": true
      }}}
);

Shelly.call("BLE.SetConfig", {
  config: {
    "enable":false
  }}
);

Shelly.call("Wifi.SetConfig", {
  config: {
    "sta":{
    "ssid":"SGSMART21",
    "pass":"SGSMART21",
    "ipv4mode":"static",
    "ip":"192.168.99.14",
    "netmask":"255.255.255.0",
    "gw":"192.168.99.1",
     "nameserver":"192.168.99.1",
     "enable":true
   }}}
);

Shelly.call("Wifi.SetConfig", {
  config: {
    "ap":{
    "enable":false
   }}}
);

Shelly.Reboot
				
			
				
					#Verbrauch5
Shelly.call("Sys.SetConfig", {
  config: {
    "device": {
      "name": "ShellyPlug-Verbrauch5",
      "eco_mode": true
      }}}
);

Shelly.call("BLE.SetConfig", {
  config: {
    "enable":false
  }}
);

Shelly.call("Wifi.SetConfig", {
  config: {
    "sta":{
    "ssid":"SGSMART21",
    "pass":"SGSMART21",
    "ipv4mode":"static",
    "ip":"192.168.99.15",
    "netmask":"255.255.255.0",
    "gw":"192.168.99.1",
     "nameserver":"192.168.99.1",
     "enable":true
   }}}
);

Shelly.call("Wifi.SetConfig", {
  config: {
    "ap":{
    "enable":false
   }}}
);

Shelly.Reboot
Home Assistant
2. Januar 2025 No Comments

Home Assistant: Automatisierung für den Iceriver Kaspa Miner basierend auf Temperatur"

Einleitung

In diesem Beitrag zeigen wir dir Schritt für Schritt, wie du in Home Assistant eine Automatisierung erstellst, um deinen Iceriver Kaspa Miner basierend auf der Temperatur zu steuern. Wir richten alles so ein, dass der Miner automatisch ein- und ausgeschaltet wird, abhängig davon, ob die Raumtemperatur unter oder über einer von dir festgelegten Schwelle liegt.

Diese Anleitung setzt voraus, dass dein Iceriver Miner mit der PBFarmer Firmware kompatibel ist. Diese Firmware bietet erweiterte Steuerungsmöglichkeiten für den Miner und erlaubt die Nutzung von REST-APIs, um den Miner direkt in Home Assistant zu integrieren.

Selbst wenn du ein Anfänger bist, wirst du diesen Beitrag leicht nachvollziehen können. Los geht’s! 🚀

Voraussetzungen

  1. Home Assistant: Installiert und betriebsbereit.
  2. PBFarmer Firmware: Dein Iceriver Miner muss mit der PBFarmer Firmware ausgestattet sein. Hier findest du die Anleitung zur Installation.
  3. Temperatursensor: Ein Sensor wie DHT11, DS18B20 oder ein ähnliches Modell, das mit Home Assistant kompatibel ist.
  4. API-Zugang: Die REST-API der Firmware muss aktiv sein, damit Home Assistant den Miner steuern kann.
 

Schritt 1: Basis-Setup in Home Assistant

Bevor wir die Automatisierung erstellen, benötigen wir einige Grundvoraussetzungen:

  1. Temperatursensor einrichten:
    Stelle sicher, dass dein Temperatursensor bereits in Home Assistant eingebunden ist. Überprüfe in Einstellungen > Geräte & Dienste, ob der Sensor aktiv ist.

    Beispiel:

    • Name des Sensors: sensor.wz_growzeltklein_mining_temp

  2. Schieberegler hinzufügen:
    Ein Schieberegler in Home Assistant hilft dir, die gewünschte Temperaturschwelle einzustellen. Diesen fügst du in der Datei configuration.yaml hinzu:

				
					input_number:
  miner_temperature_threshold:
    name: Temperaturschwelle
    min: 15
    max: 35
    step: 0.5
    unit_of_measurement: "°C"
    icon: mdi:thermometer

Nach dem Speichern dieser Datei starte Home Assistant neu: Einstellungen > Systemeinstellungen > Neu starten.

Schritt 2: REST-Command für den Iceriver Miner einrichten

Füge in der Datei configuration.yaml die Befehle hinzu, um den Miner ein- und auszuschalten:

				
					rest_command:
  ks0_wake:
    url: "https://<IP-Adresse-des-Miners>/api/machine/wake"
    method: GET
    verify_ssl: false
    headers:
      Authorization: Bearer <API-Schlüssel>

  ks0_sleep:
    url: "https://<IP-Adresse-des-Miners>/api/machine/sleep"
    method: GET
    verify_ssl: false
    headers:
      Authorization: Bearer <API-Schlüssel>

Hinweis: Ersetze <IP-Adresse-des-Miners> durch die IP-Adresse deines Iceriver Miners und <API-Schlüssel> durch den API-Schlüssel der PBFarmer Firmware.

Schritt 3: Automatisierung erstellen

Jetzt erstellen wir die Automatisierung, die den Miner alle 5 Minuten prüft und steuert.

  1. Gehe zu Einstellungen > Automatisierungen > Neue Automatisierung hinzufügen.

  2. Wähle “Manuell konfigurieren” und füge den folgenden Code ein:

				
					alias: "Miner Steuerung alle 5 Minuten"
description: "Prüft alle 5 Minuten die Temperatur und den Schieberegler und schaltet den Miner entsprechend."
triggers:
  - platform: time_pattern
    minutes: "/5"
actions:
  - choose:
      - conditions:
          - condition: template
            value_template: >-
              {{ states("sensor.wz_growzeltklein_mining_temp") | float <
              states("input_number.miner_temperature_threshold") | float }}
        sequence:
          - service: rest_command.ks0_wake
            data: {}
      - conditions:
          - condition: template
            value_template: >-
              {{ states("sensor.wz_growzeltklein_mining_temp") | float >=
              states("input_number.miner_temperature_threshold") | float }}
        sequence:
          - service: rest_command.ks0_sleep
            data: {}
mode: single

4. Speichere die Automatisierung und aktiviere sie.

Schritt 4: Dashboard anpassen

Wir erstellen ein schönes Dashboard, um die Steuerung zu vereinfachen. 

				
					views:
  - title: Home
    sections:
      - type: grid
        cards:
          - type: heading
            heading: Kaspa Miner
            heading_style: title
          - type: button
            show_name: true
            show_icon: true
            tap_action:
              action: call-service
              service: rest_command.ks0_sleep
            icon: mdi:toggle-switch-variant-off
            name: KS0 Sleep
          - type: button
            show_name: true
            show_icon: true
            tap_action:
              action: call-service
              service: rest_command.ks0_wake
            icon: mdi:light-switch
            name: KS0 Wake
          - type: gauge
            entity: sensor.wz_growzelt_shelly1_switch_0_power
            name: Stromverbrauch
          - graph: line
            type: sensor
            detail: 1
            entity: sensor.wz_growzelt_shelly1_switch_0_power
            name: Stromverbrauch
            grid_options:
              columns: 12
              rows: 2
      - type: grid
        cards:
          - type: heading
            heading: Growzelt
            heading_style: title
          - type: entities
            entities:
              - entity: automation.miner_steuerung_basierend_auf_temperatur
                name: Automatische Steuerung
              - entity: input_number.miner_temperature_threshold
                name: Temp Schwelle
          - type: gauge
            name: Temperatur Growzelt
            entity: sensor.wz_growzeltklein_mining_temp
            min: 0
            max: 50
          - graph: line
            type: sensor
            detail: 1
            name: Temperatur
            grid_options:
              columns: 12
              rows: 2
            entity: sensor.wz_growzeltklein_mining_temp

Fazit

Mit dieser Einrichtung steuert Home Assistant deinen Iceriver Kaspa Miner automatisch basierend auf der Temperatur. Du kannst die Schwelle jederzeit anpassen, die aktuelle Temperatur überwachen und sicherstellen, dass dein Miner effizient läuft.

Wichtig: Die Kompatibilität mit der PBFarmer Firmware ist Voraussetzung. Weitere Informationen findest du auf der offiziellen GitHub-Seite der Firmware.

Hast du Fragen oder Anregungen? Hinterlasse uns einen Kommentar! 😊

Solarmodule-Gladbeck
27. Oktober 2024 One Comment

Nulleinspeisung mit dem Hoymiles Wechselrichter: Komponenten und Anleitung

Eine Nulleinspeisung ermöglicht es dir, den gesamten erzeugten Strom deiner Photovoltaikanlage selbst zu nutzen, ohne Überschüsse ins öffentliche Netz einzuspeisen. Für Besitzer eines Hoymiles Wechselrichters stellen wir heute eine Lösung vor, die neben der passenden Firmware auf drei zentrale Komponenten setzt. Mit der folgenden Anleitung und den vorgestellten Produkten realisierst du deine Nulleinspeisung und erhältst die volle Kontrolle über deine PV-Anlage.

1. OpenDTU für den Hoymiles Wechselrichter und die OpenDTUOnBattery Firmware

OpenDTU

Die OpenDTU bietet die Kommunikation zwischen deinem Hoymiles Wechselrichter und deinem Netzwerk. Die kostenlose Firmware OpenDTUOnBattery erweitert die Funktionalität, sodass du auch Batteriesysteme in dein Setup integrieren kannst. Mit dieser Kombination gelingt dir nicht nur die Steuerung und Überwachung deiner Anlage, sondern auch die gezielte Einspeisesteuerung.

Produkte & Links:

2. 50A Einschaltstrombegrenzung für Akkusicherheit

50A Einschaltstrombegrenzung

Falls du eigene Akkus an den Hoymiles Wechselrichter anschließen möchtest, ist eine 50A Einschaltstrombegrenzung notwendig. Diese Komponente verhindert, dass hohe Einschaltströme deinen Wechselrichter oder die angeschlossenen Akkus beschädigen. So bleibt dein System langfristig stabil und sicher.

Produkt-Link: 50A Einschaltstrombegrenzung

3. Everhome Ecotracker zur Leistungsermittlung

Everhome Ecotracker

Der Everhome Ecotracker misst die Leistung und den Verbrauch deines Systems und liefert dir wertvolle Daten, die du direkt im OpenDTU-Modul ablesen kannst. Mit dem Ecotracker optimierst du die Eigenverbrauchsquote deiner Anlage und vermeidest unnötige Einspeisung ins Netz.

Produkt-Link: Everhome Ecotracker

So funktioniert deine Nulleinspeisung

Mit diesen Komponenten und der passenden Firmware erreichst du eine präzise Nulleinspeisung. Die OpenDTU ermöglicht die Steuerung und den Überblick über deinen Hoymiles Wechselrichter und das Batteriesystem, während der Ecotracker die Leistungsdaten liefert. Die 50A Einschaltstrombegrenzung schützt dabei dein System vor hohen Strömen beim Anschluss der Akkus.

Vollständig interne Netzwerkkommunikation

Die gesamte Kommunikation zwischen den Komponenten erfolgt ausschließlich intern im lokalen Netzwerk. Dadurch wird eine schnellere Erkennung und Umschaltung ermöglicht, ohne Verzögerungen durch eine externe Cloud. Du hast volle Kontrolle über dein System und behältst alle Daten lokal, was die Sicherheit und Zuverlässigkeit deines Setups zusätzlich erhöht.

Fazit

Durch die Kombination die OpenDTU mit der kostenlosen Firmware OpenDTUOnBattery, der 50A Einschaltstrombegrenzung und des Everhome Ecotrackers baust du dir ein leistungsstarkes und gut kontrollierbares PV-System auf. Dein Hoymiles Wechselrichter wird so zu einem vollständig eigenständigen System, das nur den Strom verbraucht, den du selbst erzeugst.

Hinweis

Dieser Artikel wird regelmäßig ergänzt und erweitert, um dir die aktuellsten Informationen und Tipps rund um die Nulleinspeisung mit dem Hoymiles Wechselrichter zu bieten. Es lohnt sich also, öfter vorbeizuschauen!

Anleitung (folgt)

Solarmodule-Gladbeck Home Assistant
11. Oktober 2024 One Comment

Steuerung der LED-Helligkeit mit Home Assistant und Shelly Power Sensor

Im Zeitalter der intelligenten Heimautomatisierung gibt es unzählige Möglichkeiten, unsere Haushaltsgeräte effizienter und intelligenter zu steuern. Eine dieser spannenden Anwendungen ist die stufenlose Steuerung von LED-Lichtern, die abhängig von der Stromleistung arbeiten. In diesem Beitrag zeige ich dir, wie du mit Home Assistant und einem Shelly Power Sensor die Helligkeit von LEDs automatisierst, um sie basierend auf der Leistung anzupassen.

Was du brauchst:

  • Home Assistant kompatible Hardware (Green Smart Home Hub 5% Rabattcode: solar5)
  • Shelly Plug S: Ein Energieüberwachungsgerät, das die aktuelle Leistung misst.
  • WLED-kompatible LEDs und einen WLED Controller: Adressierbare LEDs, die du mit WLED steuern kannst.
  • Automatisierungskenntnisse: Grundlegende YAML-Kenntnisse für Home Assistant.

Schritt 1: Shelly Power Sensor einbinden

Bevor du mit der Automatisierung beginnst, musst du sicherstellen, dass dein Shelly Plug Sensor in Home Assistant integriert ist. Hierzu verwendest du als Beispiel den folgenden Sensor:

				
					sensor.shelly_bkw_test_switch_0_power

Dieser Sensor überwacht die Leistung deines Geräts und meldet sie an Home Assistant.

Schritt 2: Automatisierung erstellen

Um die LED-Helligkeit basierend auf der gemessenen Leistung stufenlos zu steuern, fügst du in Home Assistant die folgende YAML-Konfiguration ein:

				
					alias: "LED-Helligkeit basierend auf Leistung (bis 800W)"
description: "Ändert die Helligkeit der LEDs stufenlos zu rot, basierend auf der Leistung bis maximal 800W."
trigger:
  - platform: state
    entity_id: sensor.shelly_bkw_test_switch_0_power
action:
  - service: persistent_notification.create
    data:
      message: >
        Berechnete Helligkeit:  
        {% set power = states('sensor.shelly_bkw_test_switch_0_power') | float(0) %}
        {% if power > 800 %}
          255
        {% elif power < 0 %}
          0
        {% else %}
          {{ (power / 800 * 255) | int }}
        {% endif %}
  - service: light.turn_on
    target:
      entity_id: light.wled_2
    data_template:
      brightness: >
        {% set power = states('sensor.shelly_bkw_test_switch_0_power') | float(0) %}
        {% if power > 800 %}
          255
        {% elif power < 0 %}
          0
        {% else %}
          {{ (power / 800 * 255) | int }}
        {% endif %}
      rgb_color:
        - 255
        - 0
        - 0
      effect: "Solid"

Was passiert in dieser Automatisierung?

Die Automatisierung löst jedes Mal aus, wenn sich der Leistungswert des Shelly-Sensors ändert. Basierend auf der aktuellen Leistung (zwischen 0 und 800 Watt) wird die Helligkeit der LEDs angepasst:

  • 0W-800W: Die Helligkeit wird proportional berechnet, sodass bei steigender Leistung die LEDs heller werden.
  • Farben: Die LEDs leuchten immer rot, können aber durch RGB-Werte beliebig angepasst werden.
  • Effekt: Die LEDs bleiben statisch (keine Animation).

Schritt 4: Testen der Automatisierung

Jetzt kannst du deine Geräte über den Shelly Power Sensor überwachen und die Helligkeit deiner LEDs entsprechend anpassen. Die Automatisierung passt die Helligkeit dynamisch an, sodass du die Strombelastung visualisieren kannst.

Wie man LED Farbe basierend auf der Leistung eines Shelly-Sensors in Home Assistant steuert

Einleitung:

Möchtest du deine LED-Beleuchtung so steuern, dass die Farbe automatisch wechselt, abhängig von der gemessenen Leistung eines Shelly-Sensors? In diesem Beitrag zeige ich dir, wie du Home Assistant nutzen kannst, um eine Automatisierung zu erstellen, die die LEDs auf deinem WLED-Controller stufenlos von Rot über Blau bis Grün ändert – basierend auf der aktuellen Leistungsaufnahme. Dazu verwenden wir einen Shelly-Sensor und Home Assistant, um den Effekt zu steuern.

Schritt 1: Integration des Shelly-Sensors in Home Assistant

Um die Leistung des Shelly-Sensors in Home Assistant nutzen zu können, musst du zuerst sicherstellen, dass der Shelly-Sensor korrekt in Home Assistant integriert ist.

  1. Gehe in Home Assistant zu Einstellungen > Geräte & Dienste.
  2. Suche nach deinem Shelly-Gerät und füge es hinzu, falls es noch nicht integriert ist.
  3. Stelle sicher, dass der Leistungssensor des Shelly-Geräts korrekt in Home Assistant angezeigt wird. In diesem Beispiel verwenden wir die Entität sensor.shelly_bkw_test_switch_0_power.

Schritt 2: Erstellen der Automatisierung in Home Assistant

Die Automatisierung sorgt dafür, dass die LEDs bei verschiedenen Leistungsbereichen in unterschiedlichen Farben leuchten:

  • Rot bei 0–267W,
  • Blau bei 267–534W,
  • Grün bei 534–800W.

Füge diesen Code in die YAML-Konfiguration deiner Automatisierung in Home Assistant ein:

				
					alias: "LED-Farbe basierend auf Leistung (mit Debug)"
description: "Ändert die Farbe der LEDs basierend auf der Leistung in verschiedenen Bereichen (Rot, Blau, Grün) und gibt eine Debug-Nachricht aus."
trigger:
  - platform: state
    entity_id: sensor.shelly_bkw_test_switch_0_power  # Shelly-Sensor überwacht jede Änderung der Leistung
action:
  - service: persistent_notification.create
    data:
      message: >
        Leistung: {{ states('sensor.shelly_bkw_test_switch_0_power') }} W
        Farbe: >
          {% set power = states('sensor.shelly_bkw_test_switch_0_power') | float(0) %}
          {% if power <= 267 %}
            Rot (255, 0, 0)
          {% elif power <= 534 %}
            Blau (0, 0, 255)
          {% else %}
            Grün (0, 255, 0)
          {% endif %}
  - service: light.turn_on
    target:
      entity_id: light.wled_2  # Deine WLED-Entität
    data_template:
      brightness: 255  # Maximale Helligkeit
      rgb_color: >
        {% set power = states('sensor.shelly_bkw_test_switch_0_power') | float(0) %}
        {% if power <= 267 %}
          [255, 0, 0]  # Rot (0 - 267 W)
        {% elif power <= 534 %}
          [0, 0, 255]  # Blau (267 - 534 W)
        {% else %}
          [0, 255, 0]  # Grün (534 - 800 W)
        {% endif %}
      effect: "Solid"  # Setzt die LEDs in den statischen Modus

Schritt 3: Testen der Automatisierung

Nachdem du die Automatisierung gespeichert hast, kannst du testen, ob alles wie gewünscht funktioniert:

  1. Überwache die Leistungsänderungen deines Shelly-Sensors.
  2. Schau, wie sich die Farbe deiner LEDs ändert: Rot, Blau oder Grün je nach Leistungsbereich.
  3. In Home Assistant wirst du auch eine Debug-Benachrichtigung erhalten, die dir die aktuelle Leistung und die Farbe anzeigt, die basierend auf der Leistung berechnet wurde.

Schritt 4: Anpassungen und Erweiterungen

Du kannst die Farben oder Leistungsbereiche nach Belieben anpassen, um sie an deine speziellen Anforderungen anzupassen. Außerdem kannst du weitere Effekte oder benutzerdefinierte Logik für die LED-Steuerung hinzufügen.

Fazit:

Mit dieser einfachen Automatisierung kannst du deine LEDs basierend auf der Leistungsaufnahme eines Shelly-Sensors steuern. Dies ist besonders nützlich, um den Energieverbrauch visuell darzustellen oder einfach ein dynamisches Beleuchtungssystem zu schaffen. Home Assistant und WLED bieten zusammen flexible und leistungsstarke Möglichkeiten, dein Zuhause smarter zu machen.

Viel Spaß beim Experimentieren mit deiner LED-Steuerung in Home Assistant!

1 2 3 … 8