diff --git a/apps/abstraction/transformation.py b/apps/abstraction/transformation.py index dd220e2..62c91bf 100644 --- a/apps/abstraction/transformation.py +++ b/apps/abstraction/transformation.py @@ -15,6 +15,7 @@ from apps.abstraction.vendors import ( simulator, zigbee2mqtt, max, + test, shelly, tasmota, hottis_pv_modbus, @@ -40,6 +41,7 @@ for vendor_name, vendor_module in [ ("simulator", simulator), ("zigbee2mqtt", zigbee2mqtt), ("max", max), + ("test", test), ("shelly", shelly), ("tasmota", tasmota), ("hottis_pv_modbus", hottis_pv_modbus), diff --git a/apps/abstraction/vendors/test.py b/apps/abstraction/vendors/test.py new file mode 100644 index 0000000..a25a7bb --- /dev/null +++ b/apps/abstraction/vendors/test.py @@ -0,0 +1,62 @@ +"""test vendor transformations.""" + +import json +import logging +from typing import Any + +logger = logging.getLogger(__name__) + + +def transform_contact_sensor_to_vendor(payload: dict[str, Any]) -> str: + """Transform abstract contact sensor payload to MAX! format. + + Contact sensors are read-only. + """ + logger.warning("Contact sensors are read-only - SET commands should not be used") + return json.dumps(payload) + + +def transform_contact_sensor_to_abstract(payload: str) -> dict[str, Any]: + try: + contact_value = payload.strip().lower() + return { + "contact": "open" if (contact_value == "open") else "closed" + } + except (ValueError, TypeError) as e: + logger.error(f"contact sensor failed to parse: {payload}, error: {e}") + return {"contact": "closed"} + + +def transform_thermostat_to_vendor(payload: dict[str, Any]) -> str: + if "target" not in payload: + logger.warning(f"thermostat payload missing 'target': {payload}") + return "21" + + target_temp = payload["target"] + + if isinstance(target_temp, (int, float)): + int_temp = int(round(target_temp)) + return str(int_temp) + + logger.warning(f"invalid target temperature type: {type(target_temp)}") + return "21" + + +def transform_thermostat_to_abstract(payload: str) -> dict[str, Any]: + target_temp = float(payload.strip()) + + return { + "target": target_temp, + "mode": "heat" + } + + +# Registry of handlers for this vendor +HANDLERS = { + ("contact_sensor", "to_vendor"): transform_contact_sensor_to_vendor, + ("contact_sensor", "to_abstract"): transform_contact_sensor_to_abstract, + ("contact", "to_vendor"): transform_contact_sensor_to_vendor, + ("contact", "to_abstract"): transform_contact_sensor_to_abstract, + ("thermostat", "to_vendor"): transform_thermostat_to_vendor, + ("thermostat", "to_abstract"): transform_thermostat_to_abstract, +} diff --git a/apps/rules/impl/window_setback.py b/apps/rules/impl/window_setback.py index 0f29cf1..cbd5e5c 100644 --- a/apps/rules/impl/window_setback.py +++ b/apps/rules/impl/window_setback.py @@ -18,6 +18,7 @@ class WindowSetbackObjects(BaseModel): thermostats: list[str] = Field(..., min_length=1, description="Thermostats to control") + class WindowSetbackRule(Rule): """ Window setback automation rule. @@ -31,22 +32,55 @@ class WindowSetbackRule(Rule): thermostats: List of thermostat device IDs to control (required, min 1) params: eco_target: Temperature to set when window opens (default: 16.0) - open_min_secs: Minimum seconds window must be open before triggering (default: 20) - close_min_secs: Minimum seconds window must be closed before restoring (default: 20) previous_target_ttl_secs: How long to remember previous temperature (default: 86400) State storage (Redis keys): - rule:{rule_id}:contact:{device_id}:state -> "open" | "closed" - rule:{rule_id}:contact:{device_id}:ts -> ISO timestamp of last change rule:{rule_id}:thermo:{device_id}:current_target -> Current target temp (updated on every STATE) rule:{rule_id}:thermo:{device_id}:previous -> Previous target temp (saved on window open, deleted on restore) - + rule:{rule_id}:contact:{device_id}:is_open -> "1" if open, "0" if closed + rule:{rule_id}:state -> Overall rule state -> "1" if thermostats set to eco, "0" otherwise + Logic: 1. Thermostat STATE events → update current_target in Redis 2. Window opens → copy current_target to previous, then set to eco_target 3. Window closes → restore from previous, then delete previous key """ - + + @staticmethod + def __get_redis_key_current_target(rule_id: str, thermo_id: str) -> str: + """Get Redis key for current target temperature of a thermostat""" + return f"rule:{rule_id}:thermo:{thermo_id}:current_target" + @staticmethod + def __get_redis_key_previous_target(rule_id: str, thermo_id: str) -> str: + """Get Redis key for previous target temperature of a thermostat""" + return f"rule:{rule_id}:thermo:{thermo_id}:previous" + @staticmethod + def __get_redis_key_contact_state(rule_id: str, contact_id: str) -> str: + """Get Redis key for contact sensor state""" + return f"rule:{rule_id}:contact:{contact_id}:is_open" + @staticmethod + def __get_redis_key_rule_state(rule_id: str) -> str: + """Get Redis key for overall rule state""" + return f"rule:{rule_id}:state" + @staticmethod + async def __redis_get(ctx: RuleContext, key: str) -> Any: + """Helper to get value from Redis""" + v = await ctx.redis.get(key) + ctx.logger.debug(f"Redis GET {key} -> {v}") + return v + @staticmethod + async def __redis_set(ctx: RuleContext, key: str, value: Any) -> None: + """Helper to set value in Redis""" + ctx.logger.debug(f"Redis SET {key} = {value}") + await ctx.redis.set(key, value) + @staticmethod + async def __redis_delete(ctx: RuleContext, key: str) -> None: + """Helper to delete key from Redis""" + ctx.logger.debug(f"Redis DEL {key}") + await ctx.redis.delete(key) + + + def __init__(self): super().__init__() self._validated_objects: dict[str, WindowSetbackObjects] = {} @@ -124,49 +158,54 @@ class WindowSetbackRule(Rule): """Handle contact sensor state change.""" device_id = evt['device_id'] contact_state = evt['payload'].get('contact') # "open" or "closed" - event_ts = evt.get('ts', ctx.now().isoformat()) if not contact_state: ctx.logger.warning(f"Contact event missing 'contact' field: {evt}") return - - # Store current state and timestamp - state_key = f"rule:{desc.id}:contact:{device_id}:state" - ts_key = f"rule:{desc.id}:contact:{device_id}:ts" - - await ctx.redis.set(state_key, contact_state) - await ctx.redis.set(ts_key, event_ts) - - if contact_state == 'open': - await self._on_window_opened(desc, ctx) - elif contact_state == 'closed': - await self._on_window_closed(desc, ctx) - - async def _on_window_opened(self, desc: RuleDescriptor, ctx: RuleContext) -> None: - """ - Window opened - save current temperatures, then set thermostats to eco. - - Important: We must save the current target BEFORE setting to eco, - otherwise we'll save the eco temperature instead of the original. - """ - eco_target = desc.params.get('eco_target', 16.0) + + contact_state_key = WindowSetbackRule.__get_redis_key_contact_state(desc.id, device_id) + await WindowSetbackRule.__redis_set(ctx, contact_state_key, '1' if contact_state == 'open' else '0') + + # Check if any contact is open + is_open = False + for contact_id in desc.objects.get('contacts', []): + state_key = WindowSetbackRule.__get_redis_key_contact_state(desc.id, contact_id) + state_val = await WindowSetbackRule.__redis_get(ctx, state_key) + if state_val == '1': + is_open = True + break + + rule_state_key = WindowSetbackRule.__get_redis_key_rule_state(desc.id) + current_rule_state = await WindowSetbackRule.__redis_get(ctx, rule_state_key) + if is_open and current_rule_state != '1': + # At least one contact is open, and we are not already in eco mode + await self._set_eco_mode(desc, ctx) + await WindowSetbackRule.__redis_set(ctx, rule_state_key, '1') + elif not is_open and current_rule_state != '0': + # All contacts are closed, and we are currently in eco mode + await self._unset_eco_mode(desc, ctx) + await WindowSetbackRule.__redis_set(ctx, rule_state_key, '0') + + + async def _set_eco_mode(self, desc: RuleDescriptor, ctx: RuleContext) -> None: + """Set thermostats to eco temperature when window opens.""" + eco_target = desc.params.get('eco_target', 7.0) target_thermostats = desc.objects.get('thermostats', []) - ttl_secs = desc.params.get('previous_target_ttl_secs', 86400) ctx.logger.info( - f"Rule {desc.id}: Window opened, setting {len(target_thermostats)} " + f"Rule {desc.id}: At least one window is opened, setting {len(target_thermostats)} " f"thermostats to eco temperature {eco_target}°C" ) # FIRST: Save current target temperatures as "previous" (before we change them!) for thermo_id in target_thermostats: - current_key = f"rule:{desc.id}:thermo:{thermo_id}:current_target" - current_temp_str = await ctx.redis.get(current_key) + current_key = WindowSetbackRule.__get_redis_key_current_target(desc.id, thermo_id) + current_temp_str = await WindowSetbackRule.__redis_get(ctx, current_key) if current_temp_str: # Save current as previous (with TTL) - prev_key = f"rule:{desc.id}:thermo:{thermo_id}:previous" - await ctx.redis.set(prev_key, current_temp_str, ttl_secs=ttl_secs) + prev_key = WindowSetbackRule.__get_redis_key_previous_target(desc.id, thermo_id) + await WindowSetbackRule.__redis_set(ctx, prev_key, current_temp_str) ctx.logger.debug( f"Saved previous target for {thermo_id}: {current_temp_str}°C" ) @@ -182,25 +221,21 @@ class WindowSetbackRule(Rule): ctx.logger.debug(f"Set {thermo_id} to {eco_target}°C") except Exception as e: ctx.logger.error(f"Failed to set {thermo_id}: {e}") - - async def _on_window_closed(self, desc: RuleDescriptor, ctx: RuleContext) -> None: - """ - Window closed - restore previous temperatures. - - Note: This is simplified. A production implementation would check - close_min_secs and use a timer/scheduler. - """ + + + async def _unset_eco_mode(self, desc: RuleDescriptor, ctx: RuleContext) -> None: + """Restore thermostats to previous temperature when window closes.""" target_thermostats = desc.objects.get('thermostats', []) ctx.logger.info( - f"Rule {desc.id}: Window closed, restoring {len(target_thermostats)} " + f"Rule {desc.id}: All windows closed, restoring {len(target_thermostats)} " f"thermostats to previous temperatures" ) # Restore previous temperatures for thermo_id in target_thermostats: - prev_key = f"rule:{desc.id}:thermo:{thermo_id}:previous" - prev_temp_str = await ctx.redis.get(prev_key) + prev_key = WindowSetbackRule.__get_redis_key_previous_target(desc.id, thermo_id) + prev_temp_str = await WindowSetbackRule.__redis_get(ctx, prev_key) if prev_temp_str: try: @@ -209,7 +244,7 @@ class WindowSetbackRule(Rule): ctx.logger.debug(f"Restored {thermo_id} to {prev_temp}°C") # Delete the previous key after restoring - await ctx.redis.delete(prev_key) + await WindowSetbackRule.__redis_delete(ctx, prev_key) except Exception as e: ctx.logger.error(f"Failed to restore {thermo_id}: {e}") else: @@ -240,10 +275,8 @@ class WindowSetbackRule(Rule): return # No target in this state update # Store current target (always update, even if it's the eco temperature) - current_key = f"rule:{desc.id}:thermo:{device_id}:current_target" - ttl_secs = desc.params.get('previous_target_ttl_secs', 86400) - - await ctx.redis.set(current_key, str(current_target), ttl_secs=ttl_secs) + current_key = WindowSetbackRule.__get_redis_key_current_target(desc.id, device_id) + await WindowSetbackRule.__redis_set(ctx, current_key, str(current_target)) ctx.logger.debug( f"Rule {desc.id}: Updated current target for {device_id}: {current_target}°C" diff --git a/config/devices.yaml b/config/devices.yaml index 47c18bf..702c7c7 100644 --- a/config/devices.yaml +++ b/config/devices.yaml @@ -992,18 +992,6 @@ devices: state: "zigbee2mqtt/0x64028ffffe50e79e" set: "zigbee2mqtt/0x64028ffffe50e79e/set" -- device_id: regallicht_kueche - homekit_aid: 83 - name: Regallicht - type: light - cap_version: "relay@1.0.0" - technology: hottis_led_stripe - features: - power: true - topics: - state: "IoT/RgbLedStripeKitchen/ColorCommand" - set: "IoT/RgbLedStripeKitchen/ColorCommand" - - device_id: regallicht_flur homekit_aid: 84 name: Regallicht Flur @@ -1152,3 +1140,62 @@ devices: topics: state: "zigbee2mqtt/0x842e14fffefe4ba4" set: "zigbee2mqtt/0x842e14fffefe4ba4/set" + +- device_id: kontakt_test_1 + homekit_aid: 97 + name: Kontakt Test 1 + type: contact + cap_version: contact_sensor@1.0.0 + technology: test + topics: + state: test/kontakt1/state + features: {} +- device_id: kontakt_test_2 + homekit_aid: 98 + name: Kontakt Test 2 + type: contact + cap_version: contact_sensor@1.0.0 + technology: test + topics: + state: test/kontakt2/state + features: {} +- device_id: thermostat_test + homekit_aid: 99 + name: Thermostat Test + type: thermostat + cap_version: "thermostat@1.0.0" + technology: test + features: + heating: true + temperature_range: + - 5 + - 30 + temperature_step: 0.5 + topics: + state: "test/thermostat1/state" + set: "test/thermostat1/set" + +- device_id: regallicht_kueche + homekit_aid: 100 + name: Regallicht + type: light + cap_version: "light@1.2.0" + technology: zigbee2mqtt + features: + power: true + brightness: true + topics: + state: "zigbee2mqtt/0x001788010d0ff4ba" + set: "zigbee2mqtt/0x001788010d0ff4ba/set" + +- device_id: licht_dachboden + homekit_aid: 101 + name: Dachboden + type: relay + cap_version: "relay@1.0.0" + technology: hottis_wago_modbus + features: + power: true + topics: + set: "pulsegen/command/6/17" + state: "pulsegen/status/6" diff --git a/config/rules.yaml b/config/rules.yaml index 286e1d3..e9a21ce 100644 --- a/config/rules.yaml +++ b/config/rules.yaml @@ -115,3 +115,17 @@ rules: eco_target: 5.0 open_min_secs: 20 close_min_secs: 20 +- id: window_setback_test + enabled: true + name: Fensterabsenkung Test + type: window_setback@1.0 + objects: + contacts: + - kontakt_test_1 + - kontakt_test_2 + thermostats: + - thermostat_test + params: + eco_target: 7.0 + open_min_secs: 20 + close_min_secs: 20