Optimierung der intelligenten Beleuchtung mit Home Assistant und KI

Optimierung der intelligenten Beleuchtung mit Home Assistant und KI

Die Automatisierung des Zuhauses, insbesondere der Beleuchtung, kann durch den Einsatz von Systemen wie Home Assistant erheblich verbessert werden. Eine Herausforderung besteht jedoch in der Komplexität der Konfiguration, insbesondere bei einer wachsenden Anzahl von Geräten. Hier wird untersucht, wie diese Herausforderungen mit KI-Unterstützung bewältigt werden können.

Die Evolution eines Smart Homes

Die Reise mit Home Assistant begann bescheiden mit der Steuerung von Lampen über einen IKEA Smart Hub. Mit zunehmender Komplexität durch weitere Geräte und Automatisierungen stieß die ursprüngliche Raspberry Pi-basierte Lösung an ihre Grenzen. Die Verlagerung auf eine virtuelle Maschine (VM) auf einem Home-Server, zusammen mit der Migration der Datenbanken zu MySQL und InfluxDB, schaffte Abhilfe. Diese Anpassung ermöglichte die Integration einer wachsenden Anzahl von Geräten in das Smart Home.

Adaptive Lighting: Eine Herausforderung

Ein zentrales Feature ist Adaptive Lighting, das die Farbtemperatur und Helligkeit der Lampen automatisch an die Tageszeit anpasst. Der Umstieg von älteren Lösungen wie Flux auf die Adaptive Lighting Integration über den Home Assistant Community Store (HACS) brachte deutliche Verbesserungen. Adaptive Lighting erlaubt das Einstellen der Farbtemperatur und Helligkeit im Tagesverlauf.

Allerdings gibt es Herausforderungen bei der Verwaltung dieser Einstellungen. Weder Flux noch Adaptive Lighting können Lichtgruppen direkt ansprechen, was die Konfiguration für eine große Anzahl von Lampen mühsam macht. Zudem verfügen nicht alle Lampen, selbst innerhalb derselben Marke, über die gleichen Funktionen, was separate Konfigurationen erforderlich macht. Trotz des Aufwands ist der Nutzen einer automatischen Anpassung der Farbtemperatur an den zirkadianen Rhythmus beachtlich.

KI als Konfigurationshelfer

Der Einsatz von KI-basierten Code-Assistenten wie Cursor ermöglicht es, die YAML Konfiguration von Home Assistant zu vereinfachen. Ein Skript, das mit Cursor erstellt wurde, analysiert die Lampen, identifiziert ihre Eigenschaften und gibt Debugging-Informationen aus. Dieses Skript dient als Grundlage für die korrekte Einrichtung von Adaptive Lighting.

python
import requests
import json
import os
from datetime import datetime

TOKEN = os.getenv("HA_TOKEN") # Set this to your long-lived access token (Bearer: <token>)

# Function to get entity state
def get_entity_state(entity_id):
 url = "http://localhost:8123/api/states/" + entity_id
 headers = {
 "Authorization": TOKEN,
 "content-type": "application/json",
 }

 response = requests.get(url, headers=headers)
 if response.status_code == 200:
 return response.json()
 else:
 print(f"Error getting state for {entity_id}: {response.status_code}")
 return None

def get_all_lights():
 """Get all light entities from Home Assistant."""
 url = "http://localhost:8123/api/states"
 headers = {
 "Authorization": TOKEN,
 "content-type": "application/json",
 }

 response = requests.get(url, headers=headers)
 if response.status_code == 200:
 entities = response.json()
 lights = []
 for entity in entities:
 entity_id = entity['entity_id']
 if entity_id.startswith('light.'):
 lights.append(entity_id)
 return sorted(lights)
 else:
 print(f"Error getting entities: {response.status_code}")
 return []

def get_adaptive_switch_state(name):
 switch_id = f"switch.adaptive_lighting_{name.lower()}"
 state = get_entity_state(switch_id)
 if state:
 print(f"Adaptive switch {switch_id} full state: {json.dumps(state, indent=2)}")
 return state

def check_light_capabilities(light_attrs, group_name, light_id, adaptive_config):
 """Check if light capabilities match adaptive lighting settings."""
 warnings = []

 # Check color temperature support
 if ('color_temp_kelvin' in adaptive_config and
 'supported_color_modes' in light_attrs and
 'color_temp' not in light_attrs['supported_color_modes']):
 warnings.append(f"WARNING: {light_id} in {group_name} group doesn't support color temperature, "
 f"but adaptive lighting is trying to set it. Supported modes: {light_attrs['supported_color_modes']}")

 # Check brightness support
 if ('brightness_pct' in adaptive_config and
 'supported_color_modes' in light_attrs and
 'brightness' not in light_attrs['supported_color_modes']):
 warnings.append(f"WARNING: {light_id} in {group_name} group doesn't support brightness, "
 f"but adaptive lighting is trying to set it. Supported modes: {light_attrs['supported_color_modes']}")

 return warnings

def analyze_current_state(lights, group_name):
 print(f"\n=== {group_name} Current State ===")
 print(f"Analyzing at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

 # Get adaptive lighting switch state
 switch_state = get_adaptive_switch_state(group_name)
 adaptive_config = {}
 if switch_state:
 print(f"Adaptive Lighting Switch: {switch_state['state']}")
 print(f"Last changed: {switch_state.get('last_changed', 'unknown')}")
 print(f"Attributes: {json.dumps(switch_state.get('attributes', {}), indent=2)}")
 adaptive_config = switch_state.get('attributes', {})
 else:
 print("Adaptive Lighting Switch: Not found")

 now = datetime.now()
 current_time = now.strftime("%H:%M:%S")
 print(f"Current Time: {current_time}")

 # Track brightness statistics
 brightness_stats = {
 'min': float('inf'),
 'max': float('-inf'),
 'total': 0,
 'count': 0
 }

 # Group lights by capabilities
 light_types = {}
 capability_warnings = []

 for light in lights:
 state = get_entity_state(light)
 if not state:
 print(f"{light}: Not found or offline")
 continue

 attrs = state['attributes']
 status = []
 capabilities = []

 # Check capabilities against adaptive lighting settings
 if adaptive_config:
 warnings = check_light_capabilities(attrs, group_name, light, adaptive_config)
 capability_warnings.extend(warnings)

 # Basic state
 if state['state'] == 'on':
 if 'brightness' in attrs:
 brightness_pct = round((attrs['brightness'] / 255) * 100)
 status.append(f"brightness: {brightness_pct}%")
 # Update brightness statistics
 brightness_stats['min'] = min(brightness_stats['min'], brightness_pct)
 brightness_stats['max'] = max(brightness_stats['max'], brightness_pct)
 brightness_stats['total'] += brightness_pct
 brightness_stats['count'] += 1

 if 'color_temp_kelvin' in attrs:
 status.append(f"temp: {attrs['color_temp_kelvin']}K")
 elif 'color_temp' in attrs:
 status.append(f"mired: {attrs['color_temp']}")

 print(f"{light}: ON - {', '.join(status)}")
 else:
 print(f"{light}: OFF")

 # Detailed capabilities
 if 'supported_color_modes' in attrs:
 capabilities.append(f"modes:{attrs['supported_color_modes']}")
 if 'min_color_temp_kelvin' in attrs and 'max_color_temp_kelvin' in attrs:
 capabilities.append(f"temp:{attrs['min_color_temp_kelvin']}-{attrs['max_color_temp_kelvin']}")
 if 'supported_features' in attrs:
 capabilities.append(f"features:{attrs['supported_features']}")

 # Group by capabilities
 cap_key = ','.join(sorted(capabilities))
 if cap_key not in light_types:
 light_types[cap_key] = []
 light_types[cap_key].append(light)

 # Print capability warnings
 if capability_warnings:
 print("\n=== Capability Warnings ===")
 for warning in capability_warnings:
 print(warning)

 # Print brightness statistics
 if brightness_stats['count'] > 0:
 print(f"\n=== {group_name} Brightness Statistics ===")
 print(f"Minimum brightness: {brightness_stats['min']}%"
 print(f"Maximum brightness: {brightness_stats['max']}%"
 print(f"Average brightness: {brightness_stats['total'] / brightness_stats['count']:.1f}%"
 print(f"Number of lights on: {brightness_stats['count']}")

 # Print summary of light types
 print(f"\n=== {group_name} Light Types ===")
 for cap_key, lights in light_types.items():
 print(f"\nCapabilities: {cap_key}")
 print("Lights:")
 for light in lights:
 print(f" - {light}")

def group_lights_by_capability(lights):
 """Group lights by their capabilities."""
 color_temp_lights = []
 brightness_lights = []
 other_lights = []

 for light in lights:
 state = get_entity_state(light)
 if not state:
 continue

 attrs = state['attributes']
 if 'supported_color_modes' in attrs:
 if 'color_temp' in attrs['supported_color_modes']:
 color_temp_lights.append(light)
 elif 'brightness' in attrs['supported_color_modes']:
 brightness_lights.append(light)
 else:
 other_lights.append(light)
 else:
 other_lights.append(light)

 return {
 'Color Temperature': color_temp_lights,
 'Brightness Only': brightness_lights,
 'Other': other_lights
 }

# Main execution
if   name   == "  main  ":
 all_lights = get_all_lights()
 print("\n=== All Lights Analysis ===")
 print(f"Found {len(all_lights)} lights in total")

 # Group lights by capability
 grouped_lights = group_lights_by_capability(all_lights)

 # Analyze each capability group
 for group_name, lights in grouped_lights.items():
 if lights: # Only analyze groups that have lights
 analyze_current_state(lights, group_name)

Indem man die Ausgabe des Skripts an Cursor übergibt, zusammen mit der alten Konfiguration, kann man das aktualisierte YAML für das neue Adaptive Lighting System generieren lassen. KI unterstützt auch bei der Fehlersuche, indem sie Protokolle analysiert und Lösungsvorschläge liefert.

Optimierte Adaptive Lighting Konfigurationen

Nach umfangreichen Tests wurden optimierte Konfigurationen für verschiedene IKEA Lampentypen entwickelt, die sanfte Übergänge und gute Sichtbarkeit gewährleisten:

**Für IKEA LED Lampe GU10 345 Lumen, smart/wireless dimmable white spectrum:**

yaml
- name: adapt_brightness_standard_color_temp
 lights:
 - light.light_1
 - light.light_2
 min_brightness: 50
 max_brightness: 100
 min_color_temp: 2202
 max_color_temp: 4000
 sleep_brightness: 1
 sleep_color_temp: 2202
 transition: 45
 interval: 90
 initial_transition: 1
 prefer_rgb_color: false

**Für IKEA LED Lampe E27 806 Lumen, wireless dimmable color and white spectrum/globe opal white:**

yaml
- name: adapt_brightness_extended_color_temp
 lights:
 - light.light_3
 - light.light_4
 min_brightness: 70
 max_brightness: 100
 min_color_temp: 2000
 max_color_temp: 6535
 sleep_brightness: 1
 sleep_color_temp: 2000
 transition: 45
 interval: 90
 initial_transition: 1
 prefer_rgb_color: false

**Für IKEA LED Lampe GU10 345 Lumen, smart/wireless dimmable warm white:**

yaml
- name: adapt_brightness_brightness_only
 lights:
 - light.light_5
 - light.light_6
 min_brightness: 50
 max_brightness: 100
 sleep_brightness: 1
 transition: 45
 interval: 90
 initial_transition: 1

Ausblick: Smarte Heizkörperthermostate

Als nächstes Projekt steht die Aufrüstung der Heizkörper mit Zigbee-basierten smarten Thermostatventilen (TRVs) an. Ziel ist es, dass jeder Raum die optimale Temperatur hält, indem er Daten vom zentralen Nest-Thermostat bezieht. Dies soll zu einer effizienteren und komfortableren Temperaturregelung im gesamten Haus führen.

Fazit

Die Integration von KI in die Konfiguration von Smart-Home-Systemen wie Home Assistant, insbesondere im Bereich der Beleuchtung, ermöglicht eine erhebliche Vereinfachung und Automatisierung. Die Kombination aus Adaptive Lighting und KI-Unterstützung schafft ein intelligenteres und benutzerfreundlicheres Zuhause. Es bleibt abzuwarten, inwieweit zukünftige Entwicklungen im Bereich der Smart-Home-Technologien und KI die Möglichkeiten zur Automatisierung und Optimierung des Wohnraums weiter verbessern werden.

Die Kommentare sind geschlossen.