sensor.py

Go to the documentation of this file.

"""Support for KWB Easyfire."""
 
from __future__ import annotations
 
from pykwb import kwb
import voluptuous as vol
 
from homeassistant.components.sensor import (
    PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
    SensorEntity,
)
from homeassistant.const import (
    CONF_DEVICE,
    CONF_HOST,
    CONF_NAME,
    CONF_PORT,
    CONF_TYPE,
    EVENT_HOMEASSISTANT_STOP,
)
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
DEFAULT_RAW = False
DEFAULT_NAME = "KWB"
 
MODE_SERIAL = 0
MODE_TCP = 1
 
CONF_RAW = "raw"
 
SERIAL_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
    {
        vol.Optional(CONF_RAW, default=DEFAULT_RAW): cv.boolean,
        vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
        vol.Required(CONF_DEVICE): cv.string,
        vol.Required(CONF_TYPE): "serial",
    }
)
 
ETHERNET_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
    {
        vol.Optional(CONF_RAW, default=DEFAULT_RAW): cv.boolean,
        vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
        vol.Required(CONF_HOST): cv.string,
        vol.Required(CONF_PORT): cv.port,
        vol.Required(CONF_TYPE): "tcp",
    }
)
 
PLATFORM_SCHEMA = vol.Schema(vol.Any(SERIAL_SCHEMA, ETHERNET_SCHEMA))
 
 
def setup_platform(
    hass: HomeAssistant,
    config: ConfigType,
    add_entities: AddEntitiesCallback,
    discovery_info: DiscoveryInfoType | None = None,
) -> None:
    """Set up the KWB component."""
    host = config.get(CONF_HOST)
    port = config.get(CONF_PORT)
    device = config.get(CONF_DEVICE)
    connection_type = config.get(CONF_TYPE)
    raw = config.get(CONF_RAW)
    client_name = config.get(CONF_NAME)
 
    if connection_type == "serial":
        easyfire = kwb.KWBEasyfire(MODE_SERIAL, "", 0, device)
    elif connection_type == "tcp":
        easyfire = kwb.KWBEasyfire(MODE_TCP, host, port)
    else:
        return
 
    easyfire.run_thread()
 
    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, lambda event: easyfire.stop_thread())
 
    add_entities(
        KWBSensor(easyfire, sensor, client_name)
        for sensor in easyfire.get_sensors()
        if (sensor.sensor_type != kwb.PROP_SENSOR_RAW)
        or (sensor.sensor_type == kwb.PROP_SENSOR_RAW and raw)
    )
 
 
class KWBSensor(SensorEntity):
    """Representation of a KWB Easyfire sensor."""
 
    def __init__(self, easyfire, sensor, client_name):
        """Initialize the KWB sensor."""
        self._easyfire_easyfire = easyfire
        self._sensor_sensor = sensor
        self._client_name_client_name = client_name
        self._name_name = self._sensor_sensor.name
 
    @property
    def name(self):
        """Return the name."""
        return f"{self._client_name} {self._name}"
 
    @property
    def available(self) -> bool:
        """Return if sensor is available."""
        return self._sensor_sensor.available
 
    @property
    def native_value(self):
        """Return the state of value."""
        if self._sensor_sensor.value is not None and self._sensor_sensor.available:
            return self._sensor_sensor.value
        return None
 
    @property
    def native_unit_of_measurement(self):
        """Return the unit of measurement of this entity, if any."""
        return self._sensor_sensor.unit_of_measurement