Сенсоры¶

SensorTempEntity¶

Датчик температуры.

Sber Temperature Sensor entity -- maps HA temperature sensors to Sber sensor_temp.

SENSOR_TEMP_CATEGORY `module-attribute` ¶

SENSOR_TEMP_CATEGORY = 'sensor_temp'

Sber device category for temperature sensor entities.

SensorTempEntity ¶

SensorTempEntity(entity_data)

Bases: SimpleReadOnlySensor

Sber temperature sensor entity.

Reports temperature readings from HA sensor entities to the Sber cloud. Temperature is transmitted as an integer value multiplied by 10 (e.g. 22.5 C becomes 225).

Initialize temperature sensor entity.

Parameters:

Name	Type	Description	Default
`entity_data`	`dict`	HA entity registry dict containing entity metadata.	required

Source code in custom_components/sber_mqtt_bridge/devices/sensor_temp.py

def __init__(self, entity_data: dict) -> None:
    """Initialize temperature sensor entity.

    Args:
        entity_data: HA entity registry dict containing entity metadata.
    """
    super().__init__(SENSOR_TEMP_CATEGORY, entity_data)
    self.temperature = 0.0
    self._air_pressure: int | None = None
    self._linked_humidity: int | None = None
    self._temp_unit: str = "c"

fill_by_ha_state ¶

fill_by_ha_state(ha_state)

Parse HA state and update temperature and air pressure values.

Parameters:

Name	Type	Description	Default
`ha_state`	`dict`	HA state dict with 'state' containing the temperature reading. Attributes may include 'pressure' for air pressure.	required

Source code in custom_components/sber_mqtt_bridge/devices/sensor_temp.py

def fill_by_ha_state(self, ha_state: dict) -> None:
    """Parse HA state and update temperature and air pressure values.

    Args:
        ha_state: HA state dict with 'state' containing the temperature reading.
            Attributes may include 'pressure' for air pressure.
    """
    super().fill_by_ha_state(ha_state)
    try:
        temp = float(ha_state.get("state", 0))
        self.temperature = temp if math.isfinite(temp) else 0.0
    except (ValueError, TypeError):
        self.temperature = 0.0
    attrs = ha_state.get("attributes", {})
    unit = attrs.get("unit_of_measurement", "")
    self._temp_unit = "f" if unit == "°F" else "c"
    pressure = attrs.get("pressure")
    if pressure is not None:
        try:
            self._air_pressure = int(pressure)
        except (TypeError, ValueError):
            self._air_pressure = None
    else:
        self._air_pressure = None

update_linked_data ¶

update_linked_data(role, ha_state)

Inject data from a linked entity (humidity, battery, signal).

Parameters:

Name	Type	Description	Default
`role`	`str`	Link role name.	required
`ha_state`	`dict`	HA state dict.	required

Source code in custom_components/sber_mqtt_bridge/devices/sensor_temp.py

def update_linked_data(self, role: str, ha_state: dict) -> None:
    """Inject data from a linked entity (humidity, battery, signal).

    Args:
        role: Link role name.
        ha_state: HA state dict.
    """
    super().update_linked_data(role, ha_state)
    if role == "humidity":
        state_val = ha_state.get("state")
        if state_val not in (None, "unknown", "unavailable"):
            with contextlib.suppress(TypeError, ValueError):
                self._linked_humidity = round(float(state_val))

create_features_list ¶

create_features_list()

Return Sber feature list including humidity and air_pressure when available.

Returns:

Type	Description
`list[str]`	List of Sber feature strings supported by this entity.

Source code in custom_components/sber_mqtt_bridge/devices/sensor_temp.py

def create_features_list(self) -> list[str]:
    """Return Sber feature list including humidity and air_pressure when available.

    Returns:
        List of Sber feature strings supported by this entity.
    """
    features = super().create_features_list()
    features.append("temp_unit_view")
    if self._linked_humidity is not None:
        features.append("humidity")
    if self._air_pressure is not None:
        features.append("air_pressure")
    return features

to_sber_current_state ¶

to_sber_current_state()

Build Sber current state payload with linked humidity and air_pressure.

Returns:

Type	Description
`dict[str, dict]`	Dict mapping entity_id to its Sber state representation.

Source code in custom_components/sber_mqtt_bridge/devices/sensor_temp.py

def to_sber_current_state(self) -> dict[str, dict]:
    """Build Sber current state payload with linked humidity and air_pressure.

    Returns:
        Dict mapping entity_id to its Sber state representation.
    """
    result = super().to_sber_current_state()
    result[self.entity_id]["states"].append(
        make_state(SberFeature.TEMP_UNIT_VIEW, make_enum_value(self._temp_unit))
    )
    if self._linked_humidity is not None:
        result[self.entity_id]["states"].append(
            make_state(SberFeature.HUMIDITY, make_integer_value(self._linked_humidity))
        )
    if self._air_pressure is not None:
        result[self.entity_id]["states"].append(
            make_state(SberFeature.AIR_PRESSURE, make_integer_value(self._air_pressure))
        )
    return result

HumiditySensorEntity¶

Датчик влажности.

Sber Humidity Sensor entity -- maps HA humidity sensors to Sber sensor_temp category.

HUMIDITY_SENSOR_CATEGORY `module-attribute` ¶

HUMIDITY_SENSOR_CATEGORY = 'sensor_temp'

Sber device category for humidity sensor entities (shares sensor_temp category).

HumiditySensorEntity ¶

HumiditySensorEntity(entity_data)

Bases: SimpleReadOnlySensor

Sber humidity sensor entity.

Reports humidity readings from HA sensor entities to the Sber cloud. Humidity is transmitted as a plain integer percentage (0-100).

Initialize humidity sensor entity.

Parameters:

Name	Type	Description	Default
`entity_data`	`dict`	HA entity registry dict containing entity metadata.	required

Source code in custom_components/sber_mqtt_bridge/devices/humidity_sensor.py

def __init__(self, entity_data: dict) -> None:
    """Initialize humidity sensor entity.

    Args:
        entity_data: HA entity registry dict containing entity metadata.
    """
    super().__init__(HUMIDITY_SENSOR_CATEGORY, entity_data)
    self.humidity = 0.0
    self._linked_temperature: float | None = None

fill_by_ha_state ¶

fill_by_ha_state(ha_state)

Parse HA state and update humidity value.

Parameters:

Name	Type	Description	Default
`ha_state`	`dict`	HA state dict with 'state' containing the humidity reading.	required

Source code in custom_components/sber_mqtt_bridge/devices/humidity_sensor.py

def fill_by_ha_state(self, ha_state: dict) -> None:
    """Parse HA state and update humidity value.

    Args:
        ha_state: HA state dict with 'state' containing the humidity reading.
    """
    super().fill_by_ha_state(ha_state)
    try:
        self.humidity = float(ha_state.get("state", 0))
    except (ValueError, TypeError):
        self.humidity = 0.0

update_linked_data ¶

update_linked_data(role, ha_state)

Inject data from a linked entity (temperature, battery, signal).

Parameters:

Name	Type	Description	Default
`role`	`str`	Link role name.	required
`ha_state`	`dict`	HA state dict.	required

Source code in custom_components/sber_mqtt_bridge/devices/humidity_sensor.py

def update_linked_data(self, role: str, ha_state: dict) -> None:
    """Inject data from a linked entity (temperature, battery, signal).

    Args:
        role: Link role name.
        ha_state: HA state dict.
    """
    super().update_linked_data(role, ha_state)
    if role == "temperature":
        state_val = ha_state.get("state")
        if state_val not in (None, "unknown", "unavailable"):
            with contextlib.suppress(TypeError, ValueError):
                self._linked_temperature = float(state_val)

create_features_list ¶

create_features_list()

Return Sber feature list including temperature when linked.

Returns:

Type	Description
`list[str]`	List of Sber feature strings supported by this entity.

Source code in custom_components/sber_mqtt_bridge/devices/humidity_sensor.py

def create_features_list(self) -> list[str]:
    """Return Sber feature list including temperature when linked.

    Returns:
        List of Sber feature strings supported by this entity.
    """
    features = super().create_features_list()
    if self._linked_temperature is not None:
        features.append("temperature")
    return features

to_sber_current_state ¶

to_sber_current_state()

Build Sber current state payload with linked temperature.

Returns:

Type	Description
`dict[str, dict]`	Dict mapping entity_id to its Sber state representation.

Source code in custom_components/sber_mqtt_bridge/devices/humidity_sensor.py

def to_sber_current_state(self) -> dict[str, dict]:
    """Build Sber current state payload with linked temperature.

    Returns:
        Dict mapping entity_id to its Sber state representation.
    """
    result = super().to_sber_current_state()
    if self._linked_temperature is not None:
        result[self.entity_id]["states"].append(
            make_state(SberFeature.TEMPERATURE, make_integer_value(int(self._linked_temperature * 10)))
        )
    return result

MotionSensorEntity¶

Датчик движения (PIR).

Sber Motion Sensor entity -- maps HA motion binary sensors to Sber sensor_pir.

MOTION_SENSOR_CATEGORY `module-attribute` ¶

MOTION_SENSOR_CATEGORY = 'sensor_pir'

Sber device category for PIR / motion sensor entities.

MotionSensorEntity ¶

MotionSensorEntity(entity_data)

Bases: SimpleReadOnlySensor

Sber motion sensor entity.

Reports motion detection state from HA binary_sensor entities (device_class=motion) to the Sber cloud via the pir feature.

Per Sber specification, pir uses ENUM type with value "pir" when motion is detected. This is an event-based sensor.

Initialize motion sensor entity.

Parameters:

Name	Type	Description	Default
`entity_data`	`dict`	HA entity registry dict containing entity metadata.	required

Source code in custom_components/sber_mqtt_bridge/devices/motion_sensor.py

def __init__(self, entity_data: dict) -> None:
    """Initialize motion sensor entity.

    Args:
        entity_data: HA entity registry dict containing entity metadata.
    """
    super().__init__(MOTION_SENSOR_CATEGORY, entity_data)
    self.motion_detected = False
    self._tamper: bool | None = None

fill_by_ha_state ¶

fill_by_ha_state(ha_state)

Parse HA state and update motion detection flag and tamper alarm.

Parameters:

Name	Type	Description	Default
`ha_state`	`dict`	HA state dict; 'on' means motion detected.	required

Source code in custom_components/sber_mqtt_bridge/devices/motion_sensor.py

def fill_by_ha_state(self, ha_state: dict) -> None:
    """Parse HA state and update motion detection flag and tamper alarm.

    Args:
        ha_state: HA state dict; 'on' means motion detected.
    """
    super().fill_by_ha_state(ha_state)
    self.motion_detected = ha_state.get("state") == "on"
    attrs = ha_state.get("attributes", {})
    tamper = attrs.get("tamper")
    if tamper is not None:
        self._tamper = bool(tamper)
    else:
        self._tamper = None

create_features_list ¶

create_features_list()

Return Sber feature list including tamper_alarm when available.

Returns:

Type	Description
`list[str]`	List of Sber feature strings supported by this entity.

Source code in custom_components/sber_mqtt_bridge/devices/motion_sensor.py

def create_features_list(self) -> list[str]:
    """Return Sber feature list including tamper_alarm when available.

    Returns:
        List of Sber feature strings supported by this entity.
    """
    features = super().create_features_list()
    if self._tamper is not None:
        features.append("tamper_alarm")
    return features

to_sber_current_state ¶

to_sber_current_state()

Build Sber state, omitting pir key when no motion detected.

PIR is event-based per Sber spec: only emit pir on motion, omit the key entirely when idle.

Source code in custom_components/sber_mqtt_bridge/devices/motion_sensor.py

def to_sber_current_state(self) -> dict[str, dict]:
    """Build Sber state, omitting pir key when no motion detected.

    PIR is event-based per Sber spec: only emit ``pir`` on motion,
    omit the key entirely when idle.
    """
    # Use parent implementation for online, battery, signal
    result = super().to_sber_current_state()
    entity_states = result[self.entity_id]["states"]

    if not self.motion_detected:
        # Remove the pir state entry added by parent
        entity_states[:] = [s for s in entity_states if s.get("key") != "pir"]

    if self._tamper is not None:
        entity_states.append(make_state(SberFeature.TAMPER_ALARM, make_bool_value(self._tamper)))

    return result

DoorSensorEntity¶

Датчик открытия двери/окна.

Sber Door Sensor entity -- maps HA door/window/garage binary sensors to Sber sensor_door.

DOOR_SENSOR_CATEGORY `module-attribute` ¶

DOOR_SENSOR_CATEGORY = 'sensor_door'

Sber device category for door/window contact sensor entities.

DoorSensorEntity ¶

DoorSensorEntity(entity_data)

Bases: SimpleReadOnlySensor

Sber door sensor entity.

Reports open/close state from HA binary_sensor entities (device_class=door, window, garage_door) to the Sber cloud via the doorcontact_state feature.

Per Sber specification, doorcontact_state uses BOOL type: - true = open (contacts disconnected) - false = closed (contacts connected)

Initialize door sensor entity.

Parameters:

Name	Type	Description	Default
`entity_data`	`dict`	HA entity registry dict containing entity metadata.	required

Source code in custom_components/sber_mqtt_bridge/devices/door_sensor.py

def __init__(self, entity_data: dict) -> None:
    """Initialize door sensor entity.

    Args:
        entity_data: HA entity registry dict containing entity metadata.
    """
    super().__init__(DOOR_SENSOR_CATEGORY, entity_data)
    self.is_open = False
    self._tamper: bool | None = None

fill_by_ha_state ¶

fill_by_ha_state(ha_state)

Parse HA state and update open/close status and tamper alarm.

Parameters:

Name	Type	Description	Default
`ha_state`	`dict`	HA state dict; 'on' means door is open.	required

Source code in custom_components/sber_mqtt_bridge/devices/door_sensor.py

def fill_by_ha_state(self, ha_state: dict) -> None:
    """Parse HA state and update open/close status and tamper alarm.

    Args:
        ha_state: HA state dict; 'on' means door is open.
    """
    super().fill_by_ha_state(ha_state)
    self.is_open = ha_state.get("state") == "on"
    attrs = ha_state.get("attributes", {})
    tamper = attrs.get("tamper")
    if tamper is not None:
        self._tamper = bool(tamper)
    else:
        self._tamper = None

create_features_list ¶

create_features_list()

Return Sber feature list including tamper_alarm when available.

Returns:

Type	Description
`list[str]`	List of Sber feature strings supported by this entity.

Source code in custom_components/sber_mqtt_bridge/devices/door_sensor.py

def create_features_list(self) -> list[str]:
    """Return Sber feature list including tamper_alarm when available.

    Returns:
        List of Sber feature strings supported by this entity.
    """
    features = super().create_features_list()
    if self._tamper is not None:
        features.append("tamper_alarm")
    return features

to_sber_current_state ¶

to_sber_current_state()

Build Sber current state payload with tamper_alarm when available.

Returns:

Type	Description
`dict[str, dict]`	Dict mapping entity_id to its Sber state representation.

Source code in custom_components/sber_mqtt_bridge/devices/door_sensor.py

def to_sber_current_state(self) -> dict[str, dict]:
    """Build Sber current state payload with tamper_alarm when available.

    Returns:
        Dict mapping entity_id to its Sber state representation.
    """
    result = super().to_sber_current_state()
    if self._tamper is not None:
        result[self.entity_id]["states"].append(make_state(SberFeature.TAMPER_ALARM, make_bool_value(self._tamper)))
    return result

WaterLeakSensorEntity¶

Датчик протечки воды.

Sber Water Leak Sensor entity -- maps HA moisture binary sensors to Sber sensor_water_leak.

WATER_LEAK_SENSOR_CATEGORY `module-attribute` ¶

WATER_LEAK_SENSOR_CATEGORY = 'sensor_water_leak'

Sber device category for water leak sensor entities.

WaterLeakSensorEntity ¶

WaterLeakSensorEntity(entity_data)

Bases: SimpleReadOnlySensor

Sber water leak sensor entity.

Reports leak detection state from HA binary_sensor entities (device_class=moisture) to the Sber cloud via the water_leak_state feature.

Optionally supports tamper_alarm and alarm_mute from HA attributes.

Initialize water leak sensor entity.

Parameters:

Name	Type	Description	Default
`entity_data`	`dict`	HA entity registry dict containing entity metadata.	required

Source code in custom_components/sber_mqtt_bridge/devices/water_leak_sensor.py

def __init__(self, entity_data: dict) -> None:
    """Initialize water leak sensor entity.

    Args:
        entity_data: HA entity registry dict containing entity metadata.
    """
    super().__init__(WATER_LEAK_SENSOR_CATEGORY, entity_data)
    self.leak_detected = False
    self._tamper: bool | None = None
    self._alarm_mute: bool | None = None

fill_by_ha_state ¶

fill_by_ha_state(ha_state)

Parse HA state and update leak detection flag.

Parameters:

Name	Type	Description	Default
`ha_state`	`dict`	HA state dict; 'on' means leak detected.	required

Source code in custom_components/sber_mqtt_bridge/devices/water_leak_sensor.py

def fill_by_ha_state(self, ha_state: dict) -> None:
    """Parse HA state and update leak detection flag.

    Args:
        ha_state: HA state dict; 'on' means leak detected.
    """
    super().fill_by_ha_state(ha_state)
    self.leak_detected = ha_state.get("state") == "on"
    attrs = ha_state.get("attributes", {})
    tamper = attrs.get("tamper")
    if tamper is not None:
        self._tamper = bool(tamper)
    alarm_mute = attrs.get("alarm_mute")
    if alarm_mute is not None:
        self._alarm_mute = bool(alarm_mute)

create_features_list ¶

create_features_list()

Return Sber feature list including tamper_alarm and alarm_mute when available.

Source code in custom_components/sber_mqtt_bridge/devices/water_leak_sensor.py

def create_features_list(self) -> list[str]:
    """Return Sber feature list including tamper_alarm and alarm_mute when available."""
    features = super().create_features_list()
    if self._tamper is not None:
        features.append("tamper_alarm")
    if self._alarm_mute is not None:
        features.append("alarm_mute")
    return features

to_sber_current_state ¶

to_sber_current_state()

Build Sber current state payload with tamper_alarm and alarm_mute.

Source code in custom_components/sber_mqtt_bridge/devices/water_leak_sensor.py

def to_sber_current_state(self) -> dict[str, dict]:
    """Build Sber current state payload with tamper_alarm and alarm_mute."""
    result = super().to_sber_current_state()
    if self._tamper is not None:
        result[self.entity_id]["states"].append(
            make_state(SberFeature.TAMPER_ALARM, make_bool_value(self._tamper))
        )
    if self._alarm_mute is not None:
        result[self.entity_id]["states"].append(
            make_state(SberFeature.ALARM_MUTE, make_bool_value(self._alarm_mute))
        )
    return result

GasSensorEntity¶

Датчик газа.

Sber Gas Sensor entity -- maps HA gas binary sensors to Sber sensor_gas.

GAS_SENSOR_CATEGORY `module-attribute` ¶

GAS_SENSOR_CATEGORY = 'sensor_gas'

Sber device category for gas leak sensor entities.

GasSensorEntity ¶

GasSensorEntity(entity_data)

Bases: SimpleReadOnlySensor

Sber gas sensor entity.

Reports gas leak detection state from HA binary_sensor entities (device_class=gas) to the Sber cloud via the gas_leak_state feature.

Per Sber specification, gas_leak_state uses BOOL type: - true = gas leak detected - false = no gas leak

Optionally supports alarm_mute (BOOL) if the HA entity provides it in attributes.

Initialize gas sensor entity.

Parameters:

Name	Type	Description	Default
`entity_data`	`dict`	HA entity registry dict containing entity metadata.	required

Source code in custom_components/sber_mqtt_bridge/devices/gas_sensor.py

def __init__(self, entity_data: dict) -> None:
    """Initialize gas sensor entity.

    Args:
        entity_data: HA entity registry dict containing entity metadata.
    """
    super().__init__(GAS_SENSOR_CATEGORY, entity_data)
    self.gas_detected: bool = False
    self._tamper: bool | None = None
    self._alarm_mute: bool | None = None

fill_by_ha_state ¶

fill_by_ha_state(ha_state)

Parse HA state and update gas leak detection flag, tamper and alarm_mute.

Parameters:

Name	Type	Description	Default
`ha_state`	`dict`	HA state dict; 'on' means gas leak detected.	required

Source code in custom_components/sber_mqtt_bridge/devices/gas_sensor.py

def fill_by_ha_state(self, ha_state: dict) -> None:
    """Parse HA state and update gas leak detection flag, tamper and alarm_mute.

    Args:
        ha_state: HA state dict; 'on' means gas leak detected.
    """
    super().fill_by_ha_state(ha_state)
    self.gas_detected = ha_state.get("state") == "on"
    attrs = ha_state.get("attributes", {})
    tamper = attrs.get("tamper")
    if tamper is not None:
        self._tamper = bool(tamper)
    alarm_mute = attrs.get("alarm_mute")
    if alarm_mute is not None:
        self._alarm_mute = bool(alarm_mute)

create_features_list ¶

create_features_list()

Return Sber feature list including tamper_alarm and alarm_mute when available.

Source code in custom_components/sber_mqtt_bridge/devices/gas_sensor.py

def create_features_list(self) -> list[str]:
    """Return Sber feature list including tamper_alarm and alarm_mute when available."""
    features = super().create_features_list()
    if self._tamper is not None:
        features.append("tamper_alarm")
    if self._alarm_mute is not None:
        features.append("alarm_mute")
    return features

to_sber_current_state ¶

to_sber_current_state()

Build Sber current state payload with tamper_alarm and alarm_mute.

Source code in custom_components/sber_mqtt_bridge/devices/gas_sensor.py

def to_sber_current_state(self) -> dict[str, dict]:
    """Build Sber current state payload with tamper_alarm and alarm_mute."""
    result = super().to_sber_current_state()
    if self._tamper is not None:
        result[self.entity_id]["states"].append(
            make_state(SberFeature.TAMPER_ALARM, make_bool_value(self._tamper))
        )
    if self._alarm_mute is not None:
        result[self.entity_id]["states"].append(
            make_state(SberFeature.ALARM_MUTE, make_bool_value(self._alarm_mute))
        )
    return result

SmokeSensorEntity¶

Датчик дыма.

Sber Smoke Sensor entity -- maps HA smoke binary sensors to Sber sensor_smoke.

SMOKE_SENSOR_CATEGORY `module-attribute` ¶

SMOKE_SENSOR_CATEGORY = 'sensor_smoke'

Sber device category for smoke sensor entities.

SmokeSensorEntity ¶

SmokeSensorEntity(entity_data)

Bases: SimpleReadOnlySensor

Sber smoke sensor entity.

Reports smoke detection state from HA binary_sensor entities (device_class=smoke) to the Sber cloud via the smoke_state feature.

Per Sber specification, smoke_state uses BOOL type: - true = smoke detected - false = no smoke

Optionally supports alarm_mute (BOOL) if the HA entity provides it in attributes.

Initialize smoke sensor entity.

Parameters:

Name	Type	Description	Default
`entity_data`	`dict`	HA entity registry dict containing entity metadata.	required

Source code in custom_components/sber_mqtt_bridge/devices/smoke_sensor.py

def __init__(self, entity_data: dict) -> None:
    """Initialize smoke sensor entity.

    Args:
        entity_data: HA entity registry dict containing entity metadata.
    """
    super().__init__(SMOKE_SENSOR_CATEGORY, entity_data)
    self.smoke_detected: bool = False
    self._tamper: bool | None = None
    self._alarm_mute: bool | None = None

fill_by_ha_state ¶

fill_by_ha_state(ha_state)

Parse HA state and update smoke detection flag, tamper and alarm_mute.

Parameters:

Name	Type	Description	Default
`ha_state`	`dict`	HA state dict; 'on' means smoke detected.	required

Source code in custom_components/sber_mqtt_bridge/devices/smoke_sensor.py

def fill_by_ha_state(self, ha_state: dict) -> None:
    """Parse HA state and update smoke detection flag, tamper and alarm_mute.

    Args:
        ha_state: HA state dict; 'on' means smoke detected.
    """
    super().fill_by_ha_state(ha_state)
    self.smoke_detected = ha_state.get("state") == "on"
    attrs = ha_state.get("attributes", {})
    tamper = attrs.get("tamper")
    if tamper is not None:
        self._tamper = bool(tamper)
    alarm_mute = attrs.get("alarm_mute")
    if alarm_mute is not None:
        self._alarm_mute = bool(alarm_mute)

create_features_list ¶

create_features_list()

Return Sber feature list including tamper_alarm and alarm_mute when available.

Source code in custom_components/sber_mqtt_bridge/devices/smoke_sensor.py

def create_features_list(self) -> list[str]:
    """Return Sber feature list including tamper_alarm and alarm_mute when available."""
    features = super().create_features_list()
    if self._tamper is not None:
        features.append("tamper_alarm")
    if self._alarm_mute is not None:
        features.append("alarm_mute")
    return features

to_sber_current_state ¶

to_sber_current_state()

Build Sber current state payload with tamper_alarm and alarm_mute.

Source code in custom_components/sber_mqtt_bridge/devices/smoke_sensor.py

def to_sber_current_state(self) -> dict[str, dict]:
    """Build Sber current state payload with tamper_alarm and alarm_mute."""
    result = super().to_sber_current_state()
    if self._tamper is not None:
        result[self.entity_id]["states"].append(
            make_state(SberFeature.TAMPER_ALARM, make_bool_value(self._tamper))
        )
    if self._alarm_mute is not None:
        result[self.entity_id]["states"].append(
            make_state(SberFeature.ALARM_MUTE, make_bool_value(self._alarm_mute))
        )
    return result

Сенсоры¶

SensorTempEntity¶

SENSOR_TEMP_CATEGORY module-attribute ¶

SensorTempEntity ¶

fill_by_ha_state ¶

update_linked_data ¶

create_features_list ¶

to_sber_current_state ¶

HumiditySensorEntity¶

HUMIDITY_SENSOR_CATEGORY module-attribute ¶

HumiditySensorEntity ¶

fill_by_ha_state ¶

update_linked_data ¶

create_features_list ¶

to_sber_current_state ¶

MotionSensorEntity¶

MOTION_SENSOR_CATEGORY module-attribute ¶

MotionSensorEntity ¶

fill_by_ha_state ¶

create_features_list ¶

to_sber_current_state ¶

DoorSensorEntity¶

DOOR_SENSOR_CATEGORY module-attribute ¶

DoorSensorEntity ¶

fill_by_ha_state ¶

create_features_list ¶

to_sber_current_state ¶

WaterLeakSensorEntity¶

WATER_LEAK_SENSOR_CATEGORY module-attribute ¶

WaterLeakSensorEntity ¶

fill_by_ha_state ¶

create_features_list ¶

to_sber_current_state ¶

GasSensorEntity¶

GAS_SENSOR_CATEGORY module-attribute ¶

GasSensorEntity ¶

fill_by_ha_state ¶

create_features_list ¶

to_sber_current_state ¶

SmokeSensorEntity¶

SMOKE_SENSOR_CATEGORY module-attribute ¶

SmokeSensorEntity ¶

fill_by_ha_state ¶

create_features_list ¶

to_sber_current_state ¶

SENSOR_TEMP_CATEGORY `module-attribute` ¶

HUMIDITY_SENSOR_CATEGORY `module-attribute` ¶

MOTION_SENSOR_CATEGORY `module-attribute` ¶

DOOR_SENSOR_CATEGORY `module-attribute` ¶

WATER_LEAK_SENSOR_CATEGORY `module-attribute` ¶

GAS_SENSOR_CATEGORY `module-attribute` ¶

SMOKE_SENSOR_CATEGORY `module-attribute` ¶