Cycling-Sensoren - Technische Dokumentation¶

# Total-Sensoren
for hp_idx in range(1, num_hps + 1):
    for mode in CYCLING_MODES:
        sensor_id = f"{mode}_cycling_total"
        sensor = LambdaCyclingSensor(
            hass=hass,
            entry=entry,
            sensor_id=sensor_id,
            name=names["name"],
            entity_id=names["entity_id"],
            unique_id=names["unique_id"],
            unit=template["unit"],
            state_class=template["state_class"],
            device_class=template["device_class"],
            device_type=template["device_type"],
            hp_index=hp_idx,
        )

# Daily-Sensoren
for hp_idx in range(1, num_hps + 1):
    for mode in CYCLING_MODES:
        sensor_id = f"{mode}_cycling_daily"
        sensor = LambdaCyclingSensor(...)

# Yesterday-Sensoren
for hp_idx in range(1, num_hps + 1):
    for mode in CYCLING_MODES:
        sensor_id = f"{mode}_cycling_yesterday"
        sensor = LambdaCyclingSensor(...)

# 2h, 4h, Monthly, Yearly ähnlich

CALCULATED_SENSOR_TEMPLATES = {
    "heating_cycling_total": {
        "name": "Heating Cycling Total",
        "unit": "cycles",
        "precision": 0,
        "data_type": "calculated",
        "state_class": "total_increasing",
        "device_class": None,
        "mode_value": 1,  # CH
        "operating_state": "heating",
        "period": "total",
        "reset_interval": None,
    },
    "heating_cycling_daily": {
        "name": "Heating Cycling Daily",
        "unit": "cycles",
        "precision": 0,
        "data_type": "calculated",
        "state_class": "total",
        "device_class": None,
        "operating_state": "heating",
        "period": "daily",
        "reset_interval": "daily",
    },
    # ... weitere Sensoren
}

# In _async_update_data()
last_op_state = self._last_operating_state.get(str(hp_idx), "UNBEKANNT")
op_state_val = data.get(f"hp{hp_idx}_operating_state", 0)

# Flankenerkennung: State hat sich geändert
if (self._initialization_complete and 
    last_op_state != "UNBEKANNT" and
    last_op_state != mode_val and 
    op_state_val == mode_val):

    # Betriebsmodus-Wechsel erkannt!
    await increment_cycling_counter(
        self.hass,
        mode=mode,
        hp_index=hp_idx,
        name_prefix=self.entry.data.get("name", "eu08l"),
        use_legacy_modbus_names=True,
        cycling_offsets=self._cycling_offsets.get(f"hp{hp_idx}", {}),
    )

async def increment_cycling_counter(
    hass: HomeAssistant,
    mode: str,
    hp_index: int,
    name_prefix: str,
    use_legacy_modbus_names: bool = True,
    cycling_offsets: dict = None,
):
    """
    Increment ALL cycling counters for a given mode and heat pump index.
    This should be called only on a real flank (state change)!

    Increments: Total, Daily, 2H, 4H sensors
    """
    device_prefix = f"hp{hp_index}"

    # Liste aller Sensor-Typen, die erhöht werden sollen
    sensor_types = [
        f"{mode}_cycling_total",
        f"{mode}_cycling_daily", 
        f"{mode}_cycling_2h",
        f"{mode}_cycling_4h"
    ]

    # Für compressor_start: auch monthly hinzufügen
    if mode == "compressor_start":
        sensor_types.append(f"{mode}_cycling_monthly")

    for sensor_id in sensor_types:
        # Finde Entity
        names = generate_sensor_names(...)
        entity_id = names["entity_id"]

        # Hole aktuellen Wert
        state_obj = hass.states.get(entity_id)
        current = int(float(state_obj.state)) if state_obj else 0

        # Offset nur für Total-Sensoren anwenden
        offset = 0
        if cycling_offsets is not None and sensor_id.endswith("_total"):
            device_key = device_prefix
            if device_key in cycling_offsets:
                offset = int(cycling_offsets[device_key].get(sensor_id, 0))

        # Erhöhe um 1
        new_value = int(current + 1)
        final_value = int(new_value + offset)

        # Setze neuen Wert
        cycling_entity = find_cycling_entity(hass, entity_id)
        if cycling_entity:
            cycling_entity.set_cycling_value(final_value)
        else:
            # Fallback: State setzen
            hass.states.async_set(entity_id, final_value, ...)

class LambdaCyclingSensor(RestoreEntity, SensorEntity):
    """Cycling total sensor (echte Entity, Wert wird von increment_cycling_counter gesetzt)."""

    def __init__(self, ...):
        self._cycling_value = 0
        self._yesterday_value = 0  # Nur für Total-Sensoren
        self._last_2h_value = 0    # Nur für Total-Sensoren
        self._last_4h_value = 0    # Nur für Total-Sensoren
        self._applied_offset = 0   # Nur für Total-Sensoren

    def set_cycling_value(self, value):
        """Set the cycling value and update state."""
        self._cycling_value = int(value)
        self.async_write_ha_state()

    @property
    def native_value(self):
        """Return the current cycling value."""
        value = getattr(self, "_cycling_value", 0)
        return int(value) if value is not None else 0

# In LambdaCyclingSensor.async_added_to_hass()
from .automations import (
    SIGNAL_RESET_DAILY, 
    SIGNAL_RESET_2H, 
    SIGNAL_RESET_4H, 
    SIGNAL_RESET_MONTHLY, 
    SIGNAL_RESET_YEARLY
)

# Wrapper-Funktion für asynchrone Handler (einheitlich für alle Perioden)
@callback
def _wrap_reset(entry_id: str):
    self.hass.async_create_task(self._handle_reset(entry_id))

# Registriere für alle Perioden
self._unsub_dispatcher = async_dispatcher_connect(
    self.hass, SIGNAL_RESET_DAILY, _wrap_reset
)
self._unsub_2h_dispatcher = async_dispatcher_connect(
    self.hass, SIGNAL_RESET_2H, _wrap_reset
)
self._unsub_4h_dispatcher = async_dispatcher_connect(
    self.hass, SIGNAL_RESET_4H, _wrap_reset
)
self._unsub_monthly_dispatcher = async_dispatcher_connect(
    self.hass, SIGNAL_RESET_MONTHLY, _wrap_reset
)
self._unsub_yearly_dispatcher = async_dispatcher_connect(
    self.hass, SIGNAL_RESET_YEARLY, _wrap_reset
)

async def _handle_reset(self, entry_id: str):
    """Handle reset signal for all periods (einheitlich, wie Energy)."""
    if entry_id != self._entry.entry_id:
        return

    # Prüfe Periode basierend auf sensor_id und reset_interval
    if self._sensor_id.endswith("_daily") and self._reset_interval == "daily":
        self._cycling_value = 0
        self.async_write_ha_state()
        _LOGGER.info(f"Daily sensor {self.entity_id} reset to 0")
    elif self._sensor_id.endswith("_2h") and self._reset_interval == "2h":
        self._cycling_value = 0
        self.async_write_ha_state()
        _LOGGER.info(f"2H sensor {self.entity_id} reset to 0")
    elif self._sensor_id.endswith("_4h") and self._reset_interval == "4h":
        self._cycling_value = 0
        self.async_write_ha_state()
        _LOGGER.info(f"4H sensor {self.entity_id} reset to 0")
    elif self._sensor_id.endswith("_monthly") and self._reset_interval == "monthly":
        self._cycling_value = 0
        self.async_write_ha_state()
        _LOGGER.info(f"Monthly sensor {self.entity_id} reset to 0")
    elif self._sensor_id.endswith("_yearly") and self._reset_interval == "yearly":
        self._cycling_value = 0
        self.async_write_ha_state()
        _LOGGER.info(f"Yearly sensor {self.entity_id} reset to 0")

# In automations.py
async def _update_yesterday_sensors_async(hass: HomeAssistant, entry_id: str) -> None:
    """Update yesterday sensors with current daily values before reset."""
    cycling_entities = hass.data["lambda_heat_pumps"][entry_id]["cycling_entities"]

    # Für jeden Daily-Sensor den entsprechenden Yesterday-Sensor aktualisieren
    for entity_id, entity in cycling_entities.items():
        if entity_id.endswith("_daily"):
            # Erstelle Yesterday-Entity-ID
            yesterday_entity_id = entity_id.replace("_daily", "_yesterday")

            # Hole den aktuellen Daily-Wert
            daily_state = hass.states.get(entity_id)
            daily_value = int(float(daily_state.state))

            # Setze Yesterday-Sensor auf Daily-Wert
            yesterday_entity = cycling_entities.get(yesterday_entity_id)
            if yesterday_entity:
                yesterday_entity.set_cycling_value(daily_value)

# In LambdaCyclingSensor._apply_cycling_offset()
async def _apply_cycling_offset(self):
    """Apply cycling offset from configuration."""
    config = await load_lambda_config(self.hass)
    cycling_offsets = config.get("cycling_offsets", {})

    device_key = f"hp{self._hp_index}"
    current_offset = cycling_offsets[device_key].get(self._sensor_id, 0)
    applied_offset = getattr(self, "_applied_offset", 0)

    # Berechne Differenz
    offset_difference = current_offset - applied_offset

    if offset_difference != 0:
        old_value = self._cycling_value
        self._cycling_value = int(self._cycling_value + offset_difference)
        self._applied_offset = current_offset
        self.async_write_ha_state()

class LambdaCyclingSensor(RestoreEntity, SensorEntity):
    async def async_added_to_hass(self):
        """Initialize the sensor when added to Home Assistant."""
        await super().async_added_to_hass()

        # RestoreEntity provides async_get_last_state() method
        last_state = await self.async_get_last_state()
        await self.restore_state(last_state)

    async def restore_state(self, last_state):
        """Restore state from database to prevent reset on reload."""
        if last_state is not None:
            last_value = last_state.state
            if last_value not in (None, "unknown", "unavailable"):
                self._cycling_value = int(float(last_value))

            # Restore applied offset
            if hasattr(last_state, 'attributes') and last_state.attributes:
                self._applied_offset = last_state.attributes.get("applied_offset", 0)

        # Apply cycling offset for total sensors
        if self._sensor_id.endswith("_total"):
            await self._apply_cycling_offset()

# In sensor.py async_setup_entry()
if entry.entry_id not in hass.data["lambda_heat_pumps"]:
    hass.data["lambda_heat_pumps"][entry.entry_id] = {}

if "cycling_entities" not in hass.data["lambda_heat_pumps"][entry.entry_id]:
    hass.data["lambda_heat_pumps"][entry.entry_id]["cycling_entities"] = {}

# Registriere Entity
hass.data["lambda_heat_pumps"][entry.entry_id]["cycling_entities"][entity_id] = sensor

cycling_entity = find_cycling_entity(hass, entity_id)
if cycling_entity is None:
    # Fallback: State setzen
    hass.states.async_set(entity_id, final_value, ...)
    _LOGGER.warning(f"Cycling entity {entity_id} not found, using fallback state update")

state_obj = hass.states.get(entity_id)
if state_obj is None:
    # Dynamische Meldungsunterdrückung
    warning_count = coordinator._cycling_warnings.get(entity_id, 0)
    if warning_count < coordinator._max_cycling_warnings:
        _LOGGER.debug(f"Entity {entity_id} state not available yet")
    else:
        _LOGGER.warning(f"Entity {entity_id} state not available after {max} attempts")
    continue

if not self._initialization_complete:
    _LOGGER.debug("Flankenerkennung während Initialisierung unterdrückt")
    return

_LOGGER.info(f"Cycling counter incremented: {entity_id} = {final_value} (was {current}, offset {offset})")
_LOGGER.debug(f"Cycling sensor {entity_id} value set to {value}")
_LOGGER.warning(f"Cycling entity {entity_id} not found, using fallback state update")