small fix

Added Ukrainian translation

custom_components/mega/__init__.py

@@ -4,40 +4,43 @@ import logging
 from functools import partial
 
 import voluptuous as vol
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_SCAN_INTERVAL, CONF_ID
+from homeassistant.const import (
+    CONF_SCAN_INTERVAL, CONF_ID, CONF_NAME, CONF_DOMAIN,
+    CONF_UNIT_OF_MEASUREMENT,
+)
 from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers.service import bind_hass
 from homeassistant.components import mqtt
 from homeassistant.config_entries import ConfigEntry
-from .const import DOMAIN, CONF_INVERT, CONF_RELOAD
+from .const import DOMAIN, CONF_INVERT, CONF_RELOAD, PLATFORMS, CONF_PORTS, CONF_CUSTOM, CONF_SKIP, CONF_PORT_TO_SCAN
 from .hub import MegaD
+from .config_flow import ConfigFlow
 
 
 _LOGGER = logging.getLogger(__name__)
-CONF_MQTT_ID = "mqtt_id"
-CONF_PORT_TO_SCAN = 'port_to_scan'
-
-MEGA = {
-        vol.Required(CONF_HOST): str,
-        vol.Required(CONF_PASSWORD): str,
-        vol.Optional(CONF_MQTT_ID, default=""): str,
-        vol.Optional(CONF_SCAN_INTERVAL, default=60): int,
-        vol.Optional(CONF_PORT_TO_SCAN, default=0): int,
-    }
-MEGA_MAPPED = {str: MEGA}
 
 CONFIG_SCHEMA = vol.Schema(
     {
-        DOMAIN: vol.Any(MEGA, MEGA_MAPPED)
+        DOMAIN: {
+            vol.Required(str, description='id меги из веб-интерфейса'): {
+                vol.Optional(int, description='номер порта'): {
+                    vol.Optional(CONF_SKIP, description='исключить порт из сканирования', default=False): bool,
+                    vol.Optional(CONF_INVERT, default=False): bool,
+                    vol.Optional(CONF_NAME): vol.Any(str, {
+                        vol.Required(str): str
+                    }),
+                    vol.Optional(CONF_DOMAIN): vol.Any('light', 'switch'),
+                    vol.Optional(CONF_UNIT_OF_MEASUREMENT, description='единицы измерений, либо строка либо мепинг'):
+                        vol.Any(str, {
+                            vol.Required(str): str
+                        }),
+                }
+            }
+        }
     },
     extra=vol.ALLOW_EXTRA,
 )
 
-PLATFORMS = [
-    "light",
-    "binary_sensor",
-    "sensor",
-]
 ALIVE_STATE = 'alive'
 DEF_ID = 'def'
 _POLL_TASKS = {}
@@ -46,9 +49,9 @@ _subs = {}
 
 
 async def async_setup(hass: HomeAssistant, config: dict):
-    """Set up the mega component."""
+    """YAML-конфигурация содержит только кастомизации портов"""
-    conf = config.get(DOMAIN)
+    hass.data[DOMAIN] = {CONF_CUSTOM: config.get(DOMAIN, {})}
-    hass.data[DOMAIN] = {}
+
     hass.services.async_register(
         DOMAIN, 'save', partial(_save_service, hass), schema=vol.Schema({
             vol.Optional('mega_id'): str
@@ -67,25 +70,26 @@ async def async_setup(hass: HomeAssistant, config: dict):
             vol.Optional('mega_id'): str,
         })
     )
-    if conf is None:
-        return True
-    if CONF_HOST in conf:
-        conf = {DEF_ID: conf}
-    for id, data in conf.items():
-        _LOGGER.warning('YAML configuration is deprecated, please use web-interface')
-        await _add_mega(hass, id, data)
-
-    for id, hub in hass.data[DOMAIN].items():
-        _POLL_TASKS[id] = asyncio.create_task(hub.poll())
     return True
 
 
-async def _add_mega(hass: HomeAssistant, id, data: dict):
+async def get_hub(hass, entry):
+    id = entry.data.get('id', entry.entry_id)
+    data = dict(entry.data)
+    data.update(entry.options or {})
     data.update(id=id)
     _mqtt = hass.data.get(mqtt.DOMAIN)
     if _mqtt is None:
         raise Exception('mqtt not configured, please configure mqtt first')
-    hass.data[DOMAIN][id] = hub = MegaD(hass, **data, mqtt=_mqtt, lg=_LOGGER)
+    hub = MegaD(hass, **data, mqtt=_mqtt, lg=_LOGGER, loop=asyncio.get_event_loop())
+    hub.mqtt_id = await hub.get_mqtt_id()
+    return hub
+
+
+async def _add_mega(hass: HomeAssistant, entry: ConfigEntry):
+    id = entry.data.get('id', entry.entry_id)
+    hub = await get_hub(hass, entry)
+    hass.data[DOMAIN][id] = hub
     if not await hub.authenticate():
         raise Exception("not authentificated")
     mid = await hub.get_mqtt_id()
@@ -94,28 +98,33 @@ async def _add_mega(hass: HomeAssistant, id, data: dict):
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
-    id = entry.data.get('id', entry.entry_id)
+    hub: MegaD = await _add_mega(hass, entry)
-    data = dict(entry.data)
-    data.update(entry.options or {})
-    hub = await _add_mega(hass, id, data)
     _hubs[entry.entry_id] = hub
-    _subs[entry.entry_id] = entry.add_update_listener(update)
+    _subs[entry.entry_id] = entry.add_update_listener(updater)
-
+    await hub.start()
     for platform in PLATFORMS:
         hass.async_create_task(
             hass.config_entries.async_forward_entry_setup(
                 entry, platform
             )
         )
-    _POLL_TASKS[id] = asyncio.create_task(hub.poll())
+    await hub.updater.async_refresh()
     return True
 
 
-async def update(hass: HomeAssistant, entry: ConfigEntry):
+async def updater(hass: HomeAssistant, entry: ConfigEntry):
+    """
+    Обновляется конфигурация
+    :param hass:
+    :param entry:
+    :return:
+    """
     hub: MegaD = hass.data[DOMAIN][entry.data[CONF_ID]]
     hub.poll_interval = entry.options[CONF_SCAN_INTERVAL]
-    hub.port_to_scan = entry.options[CONF_PORT_TO_SCAN]
+    hub.port_to_scan = entry.options.get(CONF_PORT_TO_SCAN, 0)
-    if entry.options[CONF_RELOAD]:
+    entry.data = entry.options
+    for platform in PLATFORMS:
+        await hass.config_entries.async_forward_entry_unload(entry, platform)
     await async_remove_entry(hass, entry)
     await async_setup_entry(hass, entry)
     return True
@@ -124,12 +133,35 @@ async def update(hass: HomeAssistant, entry: ConfigEntry):
 async def async_remove_entry(hass, entry) -> None:
     """Handle removal of an entry."""
     id = entry.data.get('id', entry.entry_id)
-    hass.data[DOMAIN][id].unsubscribe_all()
+    hub: MegaD = hass.data[DOMAIN][id]
-    task: asyncio.Task = _POLL_TASKS.pop(id)
+    if hub is None:
-    task.cancel()
+        return
+    _LOGGER.debug(f'remove {id}')
     _hubs.pop(entry.entry_id)
-    unsub = _subs.pop(entry.entry_id)
+    task: asyncio.Task = _POLL_TASKS.pop(id, None)
-    unsub()
+    if task is not None:
+        task.cancel()
+    if hub is None:
+        return
+    await hub.stop()
+
+
+async def async_migrate_entry(hass, config_entry: ConfigEntry):
+    """Migrate old entry."""
+    _LOGGER.debug("Migrating from version %s to version %s", config_entry.version, ConfigFlow.VERSION)
+    hub = await get_hub(hass, config_entry)
+    new = dict(config_entry.data)
+    await hub.start()
+    cfg = await hub.get_config()
+    await hub.stop()
+    new.update(cfg)
+    _LOGGER.debug(f'new config: %s', new)
+    config_entry.data = new
+    config_entry.version = ConfigFlow.VERSION
+
+    _LOGGER.info("Migration to version %s successful", config_entry.version)
+
+    return True
 
 
 async def _save_service(hass: HomeAssistant, call: ServiceCall):
@@ -139,6 +171,7 @@ async def _save_service(hass: HomeAssistant, call: ServiceCall):
         await hub.save()
     else:
         for hub in hass.data[DOMAIN].values():
+            if isinstance(hub, MegaD):
                 await hub.save()
 
 
@@ -154,6 +187,8 @@ async def _get_port(hass: HomeAssistant, call: ServiceCall):
             await hub.get_port(port)
     else:
         for hub in hass.data[DOMAIN].values():
+            if not isinstance(hub, MegaD):
+                continue
             if port is None:
                 await hub.get_all_ports()
             else:

custom_components/mega/binary_sensor.py

@@ -1,6 +1,5 @@
 """Platform for light integration."""
 import logging
-import asyncio
 
 import voluptuous as vol
 
@@ -11,16 +10,17 @@ from homeassistant.components.binary_sensor import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONF_NAME,
-    CONF_PLATFORM,
     CONF_PORT,
     CONF_UNIQUE_ID,
-    CONF_ID
+    CONF_ID,
+    CONF_ENTITY_ID,
 )
 from homeassistant.core import HomeAssistant
-from .entities import BaseMegaEntity
+from .const import EVENT_BINARY_SENSOR, DOMAIN, CONF_CUSTOM, CONF_SKIP
-
+from .entities import  MegaPushEntity
 from .hub import MegaD
 
+
 lg = logging.getLogger(__name__)
 
 
@@ -40,20 +40,7 @@ PLATFORM_SCHEMA = SENSOR_SCHEMA.extend(
 
 
 async def async_setup_platform(hass, config, add_entities, discovery_info=None):
-    config.pop(CONF_PLATFORM)
+    lg.warning('mega integration does not support yaml for binary_sensors, please use UI configuration')
-    ents = []
-    for mid, _config in config.items():
-        for x in _config:
-            if isinstance(x, int):
-                ent = MegaBinarySensor(
-                    mega_id=mid, port=x
-                )
-            else:
-                ent = MegaBinarySensor(
-                    mega_id=mid, port=x[CONF_PORT], name=x[CONF_NAME]
-                )
-            ents.append(ent)
-    add_entities(ents)
     return True
 
 
@@ -61,23 +48,28 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
     mid = config_entry.data[CONF_ID]
     hub: MegaD = hass.data['mega'][mid]
     devices = []
-
+    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {})
-    async def scan():
+    for port, cfg in config_entry.data.get('binary_sensor', {}).items():
-        async for port, pty, m in hub.scan_ports():
+        port = int(port)
-            if pty == "0":
+        c = customize.get(mid, {}).get(port, {})
-                sensor = MegaBinarySensor(mega_id=mid, port=port)
+        if c.get(CONF_SKIP, False):
+            continue
+        hub.lg.debug(f'add binary_sensor on port %s', port)
+        sensor = MegaBinarySensor(mega=hub, port=port, config_entry=config_entry)
         devices.append(sensor)
-
     async_add_devices(devices)
 
-    asyncio.create_task(scan())
 
-
+class MegaBinarySensor(BinarySensorEntity, MegaPushEntity):
-class MegaBinarySensor(BinarySensorEntity, BaseMegaEntity):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._is_on = None
+        self._attrs = None
+
+    @property
+    def state_attributes(self):
+        return self._attrs
 
     @property
     def is_on(self) -> bool:
@@ -86,5 +78,15 @@ class MegaBinarySensor(BinarySensorEntity, BaseMegaEntity):
         return self._state == 'ON'
 
     def _update(self, payload: dict):
+        data = {CONF_ENTITY_ID: self.entity_id}
+        payload = payload.copy()
+        payload.pop(CONF_PORT)
+        data.update(payload)
+        if not self.is_first_update:
+            self.hass.bus.async_fire(
+                EVENT_BINARY_SENSOR,
+                data,
+            )
         val = payload.get("value")
         self._is_on = val == 'ON'
+        self._attrs = data

custom_components/mega/config_flow.py

@@ -1,5 +1,5 @@
 """Пока не сделано"""
-
+import asyncio
 import logging
 
 import voluptuous as vol
@@ -8,8 +8,8 @@ from homeassistant import config_entries, core
 from homeassistant.components import mqtt
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_ID, CONF_PASSWORD, CONF_SCAN_INTERVAL
-from homeassistant.core import callback
+from homeassistant.core import callback, HomeAssistant
-from .const import DOMAIN, CONF_PORT_TO_SCAN, CONF_RELOAD  # pylint:disable=unused-import
+from .const import DOMAIN, CONF_PORT_TO_SCAN, CONF_RELOAD, PLATFORMS  # pylint:disable=unused-import
 from .hub import MegaD
 from . import exceptions
 
@@ -20,12 +20,23 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         vol.Required(CONF_ID, default='def'): str,
         vol.Required(CONF_HOST, default="192.168.0.14"): str,
         vol.Required(CONF_PASSWORD, default="sec"): str,
-        vol.Optional(CONF_SCAN_INTERVAL, default=60): int,
+        vol.Optional(CONF_SCAN_INTERVAL, default=0): int,
         vol.Optional(CONF_PORT_TO_SCAN, default=0): int,
     },
 )
 
 
+async def get_hub(hass: HomeAssistant, data):
+    _mqtt = hass.data.get(mqtt.DOMAIN)
+    if not isinstance(_mqtt, mqtt.MQTT):
+        raise exceptions.MqttNotConfigured("mqtt must be configured first")
+    hub = MegaD(hass, **data, lg=_LOGGER, mqtt=_mqtt, loop=asyncio.get_event_loop())
+    hub.mqtt_id = await hub.get_mqtt_id()
+    if not await hub.authenticate():
+        raise exceptions.InvalidAuth
+    return hub
+
+
 async def validate_input(hass: core.HomeAssistant, data):
     """Validate the user input allows us to connect.
 
@@ -33,12 +44,7 @@ async def validate_input(hass: core.HomeAssistant, data):
     """
     if data[CONF_ID] in hass.data.get(DOMAIN, []):
         raise exceptions.DuplicateId('duplicate_id')
-    _mqtt = hass.data.get(mqtt.DOMAIN)
+    hub = await get_hub(hass, data)
-    if not isinstance(_mqtt, mqtt.MQTT):
-        raise exceptions.MqttNotConfigured("mqtt must be configured first")
-    hub = MegaD(hass, **data, lg=_LOGGER, mqtt=_mqtt)
-    if not await hub.authenticate():
-        raise exceptions.InvalidAuth
 
     return hub
 
@@ -46,7 +52,7 @@ async def validate_input(hass: core.HomeAssistant, data):
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for mega."""
 
-    VERSION = 1
+    VERSION = 3
     CONNECTION_CLASS = config_entries.CONN_CLASS_ASSUMED
 
     async def async_step_user(self, user_input=None):
@@ -59,7 +65,16 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
         errors = {}
 
         try:
-            await validate_input(self.hass, user_input)
+            hub = await validate_input(self.hass, user_input)
+            await hub.start()
+            config = await hub.get_config()
+            await hub.stop()
+            hub.lg.debug(f'config loaded: %s', config)
+            config.update(user_input)
+            return self.async_create_entry(
+                title=user_input.get(CONF_ID, user_input[CONF_HOST]),
+                data=config,
+            )
         except exceptions.CannotConnect:
             errors["base"] = "cannot_connect"
         except exceptions.InvalidAuth:
@@ -69,11 +84,6 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
         except Exception as exc:  # pylint: disable=broad-except
             _LOGGER.exception("Unexpected exception")
             errors[CONF_ID] = str(exc)
-        else:
-            return self.async_create_entry(
-                title=user_input.get(CONF_ID, user_input[CONF_HOST]),
-                data=user_input,
-            )
 
         return self.async_show_form(
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
@@ -92,16 +102,31 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
 
     async def async_step_init(self, user_input=None):
         """Manage the options."""
+
         if user_input is not None:
+            reload = user_input.pop(CONF_RELOAD)
+            cfg = dict(self.config_entry.data)
+            cfg.update(user_input)
+            hub = await get_hub(self.hass, self.config_entry.data)
+            if reload:
+                await hub.start()
+                new = await hub.get_config()
+                await hub.stop()
+
+                _LOGGER.debug(f'new config: %s', new)
+                cfg = dict(self.config_entry.data)
+                for x in PLATFORMS:
+                    cfg.pop(x, None)
+                cfg.update(new)
             return self.async_create_entry(
                 title='',
-                data={**user_input, **{CONF_ID: self.config_entry.data[CONF_ID]}},
+                data=cfg,
             )
         e = self.config_entry.data
         ret = self.async_show_form(
             step_id="init",
             data_schema=vol.Schema({
-                vol.Optional(CONF_SCAN_INTERVAL, default=e[CONF_SCAN_INTERVAL]): int,
+                vol.Optional(CONF_SCAN_INTERVAL, default=e.get(CONF_SCAN_INTERVAL, 0)): int,
                 vol.Optional(CONF_PORT_TO_SCAN, default=e.get(CONF_PORT_TO_SCAN, 0)): int,
                 vol.Optional(CONF_RELOAD, default=False): bool,
                 # vol.Optional(CONF_INVERT, default=''): str,

custom_components/mega/const.py

@@ -12,3 +12,13 @@ W1BUS = 'w1bus'
 CONF_PORT_TO_SCAN = 'port_to_scan'
 CONF_RELOAD = 'reload'
 CONF_INVERT = 'invert'
+CONF_PORTS = 'ports'
+CONF_CUSTOM = '__custom'
+CONF_SKIP = 'skip'
+PLATFORMS = [
+    "light",
+    "switch",
+    "binary_sensor",
+    "sensor",
+]
+EVENT_BINARY_SENSOR = f'{DOMAIN}.sensor'

custom_components/mega/entities.py

@@ -1,36 +1,68 @@
-import asyncio
-
-import json
 import logging
-
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_NAME
 from homeassistant.core import State
-from .hub import MegaD
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from homeassistant.helpers.restore_state import RestoreEntity
-from .const import DOMAIN
+from .hub import MegaD
+from .const import DOMAIN, CONF_CUSTOM, CONF_INVERT
 
 
-class BaseMegaEntity(RestoreEntity):
+class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
     """
     Base Mega's entity. It is responsible for storing reference to mega hub
     Also provides some basic entity information: unique_id, name, availiability
-    It also makes subscription to port states
+    All base entities are polled in order to be online or offline
     """
     def __init__(
             self,
-            mega_id: str,
+            mega: MegaD,
             port: int,
+            config_entry: ConfigEntry = None,
             id_suffix=None,
             name=None,
-            unique_id=None
+            unique_id=None,
     ):
+        super().__init__(mega.updater)
         self._state: State = None
         self.port = port
-        self._mega_id = mega_id
+        self.config_entry = config_entry
+        self.mega = mega
+        self._mega_id = mega.id
         self._lg = None
-        self._unique_id = unique_id or f"mega_{mega_id}_{port}" + \
+        self._unique_id = unique_id or f"mega_{mega.id}_{port}" + \
                                        (f"_{id_suffix}" if id_suffix else "")
-        self._name = name or f"{mega_id}_{port}" + \
+        self._name = name or f"{mega.id}_{port}" + \
                             (f"_{id_suffix}" if id_suffix else "")
+        self._customize: dict = None
+
+    @property
+    def customize(self):
+        if self.hass is None:
+            return {}
+        if self._customize is None:
+            c = self.hass.data.get(DOMAIN, {}).get(CONF_CUSTOM) or {}
+            c = c.get(self._mega_id) or {}
+            c = c.get(self.port) or {}
+            self._customize = c
+        return self._customize
+
+    @property
+    def device_info(self):
+        return {
+            "identifiers": {
+                # Serial numbers are unique identifiers within a specific domain
+                (DOMAIN, f'{self._mega_id}', self.port),
+            },
+            "config_entries": [
+                self.config_entry,
+            ],
+            "name": f'port {self.port}',
+            "manufacturer": 'ab-log.ru',
+            # "model": self.light.productname,
+            # "sw_version": self.light.swversion,
+            "via_device": (DOMAIN, self._mega_id),
+        }
 
     @property
     def lg(self) -> logging.Logger:
@@ -38,38 +70,117 @@ class BaseMegaEntity(RestoreEntity):
             self._lg = self.mega.lg.getChild(self._name or self.unique_id)
         return self._lg
 
-    @property
-    def mega(self) -> MegaD:
-        return self.hass.data[DOMAIN][self._mega_id]
-
     @property
     def available(self) -> bool:
         return self.mega.online
 
     @property
     def name(self):
-        return self._name or f"{self.mega.id}_p{self.port}"
+        c = self.customize.get(CONF_NAME)
+        if not isinstance(c, str):
+            c = self._name or f"{self.mega.id}_p{self.port}"
+        return c
 
     @property
     def unique_id(self):
         return self._unique_id
 
     async def async_added_to_hass(self) -> None:
-        await self.mega.subscribe(self.port, callback=self.__update)
+        await super().async_added_to_hass()
         self._state = await self.async_get_last_state()
-        await asyncio.sleep(0.1)
-        await self.mega.get_port(self.port)
 
-    def __update(self, msg):
+
-        try:
+class MegaPushEntity(BaseMegaEntity):
-            value = json.loads(msg.payload)
+
-        except Exception as exc:
+    """
-            self.lg.warning(f'could not parse json ({msg.payload}): {exc}')
+    Updates on messages from mqtt
-            return
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mega.subscribe(self.port, callback=self.__update)
+        self.is_first_update = True
+
+    def __update(self, value: dict):
         self._update(value)
-        self.hass.async_create_task(self.async_update_ha_state())
+        self.async_write_ha_state()
         self.lg.debug(f'state after update %s', self.state)
+        self.is_first_update = False
         return
 
     def _update(self, payload: dict):
-        raise NotImplementedError
+        pass
+
+    async def async_added_to_hass(self) -> None:
+        await super().async_added_to_hass()
+        self.hass.async_create_task(self.mega.get_port(self.port))
+
+
+class MegaOutPort(MegaPushEntity):
+
+    def __init__(
+            self,
+            dimmer=False,
+            *args, **kwargs
+    ):
+        super().__init__(
+            *args, **kwargs
+        )
+        self._brightness = None
+        self._is_on = None
+        self.dimmer = dimmer
+
+    @property
+    def invert(self):
+        return self.customize.get(CONF_INVERT, False)
+
+    @property
+    def brightness(self):
+        if self._brightness is not None:
+            return self._brightness
+        if self._state:
+            return self._state.attributes.get("brightness")
+
+    @property
+    def is_on(self) -> bool:
+        if self._is_on is not None:
+            return self._is_on
+        return self._state == 'ON'
+
+    async def async_turn_on(self, brightness=None, **kwargs) -> None:
+        brightness = brightness or self.brightness or 255
+
+        if self.dimmer and brightness == 0:
+            cmd = 255
+        elif self.dimmer:
+            cmd = brightness
+        else:
+            cmd = 1 if not self.invert else 0
+        if await self.mega.send_command(self.port, f"{self.port}:{cmd}"):
+            self._is_on = True
+            self._brightness = brightness
+        await self.async_update_ha_state()
+
+    async def async_turn_off(self, **kwargs) -> None:
+
+        cmd = "0" if not self.invert else "1"
+
+        if await self.mega.send_command(self.port, f"{self.port}:{cmd}"):
+            self._is_on = False
+        await self.async_update_ha_state()
+
+    def _update(self, payload: dict):
+        val = payload.get("value")
+        try:
+            val = int(val)
+        except Exception:
+            pass
+        if isinstance(val, int):
+            self._is_on = val
+            if val > 0:
+                self._brightness = val
+        else:
+            if not self.invert:
+                self._is_on = val == 'ON'
+            else:
+                self._is_on = val == 'OFF'

custom_components/mega/hub.py

@@ -1,18 +1,36 @@
 import asyncio
-import json
 import logging
-from datetime import datetime
+from collections import defaultdict
-from functools import wraps
+from datetime import datetime, timedelta
 
 import aiohttp
 import typing
-from bs4 import BeautifulSoup
+import re
+import json
 
+from bs4 import BeautifulSoup
 from homeassistant.components import mqtt
+from homeassistant.const import DEVICE_CLASS_TEMPERATURE, DEVICE_CLASS_HUMIDITY
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from .const import TEMP, HUM
 from .exceptions import CannotConnect
 
+TEMP_PATT = re.compile(r'temp:([01234567890\.]+)')
+HUM_PATT = re.compile(r'hum:([01234567890\.]+)')
+PATTERNS = {
+    TEMP: TEMP_PATT,
+    HUM: HUM_PATT,
+}
+UNITS = {
+    TEMP: '°C',
+    HUM: '%'
+}
+CLASSES = {
+    TEMP: DEVICE_CLASS_TEMPERATURE,
+    HUM: DEVICE_CLASS_HUMIDITY
+}
 
 class MegaD:
     """MegaD Hub"""
@@ -20,6 +38,7 @@ class MegaD:
     def __init__(
             self,
             hass: HomeAssistant,
+            loop: asyncio.AbstractEventLoop,
             host: str,
             password: str,
             mqtt: mqtt.MQTT,
@@ -32,29 +51,52 @@ class MegaD:
             **kwargs,
     ):
         """Initialize."""
+        self.loop: asyncio.AbstractEventLoop = None
         self.hass = hass
         self.host = host
         self.sec = password
         self.mqtt = mqtt
         self.id = id
         self.lck = asyncio.Lock()
-        self.is_alive = asyncio.Condition()
+        self.cnd = asyncio.Condition()
         self.online = True
         self.entities: typing.List[Entity] = []
         self.poll_interval = scan_interval
-        self.subscriptions = []
+        self.subs = None
         self.lg: logging.Logger = lg.getChild(self.id)
         self._scanned = {}
         self.sensors = []
         self.port_to_scan = port_to_scan
-        self.inverted = inverted or []
         self.last_update = datetime.now()
+        self._callbacks: typing.DefaultDict[int, typing.List[typing.Callable[[dict], typing.Coroutine]]] = defaultdict(list)
+        self._loop = loop
+        self.values = {}
+        self.last_port = None
+        self.updater = DataUpdateCoordinator(
+            hass,
+            self.lg,
+            name="sensors",
+            update_method=self.poll,
+            update_interval=timedelta(seconds=self.poll_interval) if self.poll_interval else None,
+        )
         if not mqtt_id:
             _id = host.split(".")[-1]
             self.mqtt_id = f"megad/{_id}"
         else:
             self.mqtt_id = mqtt_id
-            self._loop: asyncio.AbstractEventLoop = None
+
+    async def start(self):
+        self.loop = asyncio.get_event_loop()
+        self.subs = await self.mqtt.async_subscribe(
+            topic=f"{self.mqtt_id}/+",
+            msg_callback=self._process_msg,
+            qos=0,
+        )
+
+    async def stop(self):
+        self.subs()
+        for x in self._callbacks.values():
+            x.clear()
 
     async def add_entity(self, ent):
         async with self.lck:
@@ -62,55 +104,41 @@ class MegaD:
 
     async def get_sensors(self):
         self.lg.debug(self.sensors)
-        _ports = {x.port for x in self.sensors}
+        for x in self.sensors:
-        for x in _ports:
             await self.get_port(x)
-            await asyncio.sleep(0.1)
 
-    async def poll(self):
+    @property
-        """
+    def is_online(self):
-        Send get port 0 every poll_interval. When answer is received, mega.<id> becomes online else mega.<id> becomes
+        return (datetime.now() - self.last_update).total_seconds() < (self.poll_interval + 10)
-        offline
-        """
-        self._loop = asyncio.get_event_loop()
 
-        while True:
+    def _warn_offline(self):
-            if len(self.sensors) > 0:
+        if self.online:
-                await self.get_sensors()
-            else:
-                await self.get_port(self.port_to_scan)
-
-            await asyncio.sleep(1)
-            if (datetime.now() - self.last_update).total_seconds() > self.poll_interval:
-                await self.get_port(self.port_to_scan)
-                await asyncio.sleep(1)
-                if (datetime.now() - self.last_update).total_seconds() > self.poll_interval:
             self.lg.warning('mega is offline')
             self.hass.states.async_set(
                 f'mega.{self.id}',
                 'offline',
             )
             self.online = False
-            else:
+
+    def _notify_online(self):
+        if not self.online:
             self.hass.states.async_set(
                 f'mega.{self.id}',
                 'online',
             )
             self.online = True
 
-            for x in self.entities:
+    async def poll(self):
-                try:
+        """
-                    await x.async_update_ha_state()
+        Send get port 0 every poll_interval. When answer is received, mega.<id> becomes online else mega.<id> becomes
-                except RuntimeError:
+        offline
-                    pass
+        """
-            await asyncio.sleep(self.poll_interval - 1)
+        self.lg.debug('poll')
-
+        if len(self.sensors) > 0:
-    async def _async_notify(self):
+            await self.get_sensors()
-        async with self.is_alive:
+        else:
-            self.is_alive.notify_all()
+            await self.get_port(self.port_to_scan)
-
+        return self.values
-    def _notify(self, *args):
-        asyncio.run_coroutine_threadsafe(self._async_notify(), self._loop)
 
     async def get_mqtt_id(self):
         async with aiohttp.request(
@@ -141,85 +169,66 @@ class MegaD:
         await self.send_command(cmd='s')
 
     async def get_port(self, port):
-        """
+        """Запрос состояния порта. Блокируется пока не придет какое-нибудь сообщение от меги или таймаут"""
-        Опрашивает порт с помощью mqtt. Ждет ответ, возвращает ответ.
+        async with self.cnd:
-
-        :param port:
-        :return:
-        """
-        ftr = asyncio.get_event_loop().create_future()
-
-        def cb(msg):
-
-            try:
-                if '"value":NA' in msg.payload.decode():
-                    if not ftr.done():
-                        ftr.set_result(None)
-                    return
-                ret = json.loads(msg.payload).get('value')
-                if not ftr.done():
-                    ftr.set_result(ret)
-            except Exception as exc:
-                ret = None
-                self.lg.exception(f'while parsing response from port {port}: {msg.payload}')
-                ftr.set_result(None)
-
-            self.lg.debug(
-                f'port: %s response: %s', port, ret
-            )
-
-        async with self.lck:
-            unsub = await self.mqtt.async_subscribe(
-                topic=f'{self.mqtt_id}/{port}',
-                msg_callback=cb,
-                qos=1,
-            )
-            try:
             await self.mqtt.async_publish(
                 topic=f'{self.mqtt_id}/cmd',
                 payload=f'get:{port}',
-                    qos=1,
+                qos=2,
                 retain=False,
             )
-                return await asyncio.wait_for(ftr, timeout=2)
+            await asyncio.wait_for(self.cnd.wait(), timeout=15)
-            except asyncio.TimeoutError:
+            await asyncio.sleep(0.05)
-                self.lg.warning(f'timeout on port {port}')
-            finally:
-                unsub()
 
     async def get_all_ports(self):
         for x in range(37):
-            asyncio.create_task(self.get_port(x))
+            await self.get_port(x)
 
     async def reboot(self, save=True):
         await self.save()
-        # await self.send_command(cmd=)
 
-    async def subscribe(self, port, callback):
+    async def _notify(self, port, value):
+        async with self.cnd:
+            self.last_update = datetime.now()
+            self.values[port] = value
+            self.last_port = port
+            self.cnd.notify_all()
 
-        @wraps(callback)
+    def _process_msg(self, msg):
-        def wrapper(msg):
+        try:
+            d = msg.topic.split('/')
+            port = d[-1]
+        except ValueError:
+            self.lg.warning('can not process %s', msg)
+            return
+
+        if port == 'cmd':
+            return
+        try:
+            port = int(port)
+        except:
+            self.lg.warning('can not process %s', msg)
+            return
         self.lg.debug(
             'process incomming message: %s', msg
         )
-            self.last_update = datetime.now()
+        value = None
-            return callback(msg)
+        try:
+            value = json.loads(msg.payload)
+            for cb in self._callbacks[port]:
+                cb(value)
+        except Exception as exc:
+            self.lg.warning(f'could not parse json ({msg.payload}): {exc}')
+            return
+        finally:
+            asyncio.run_coroutine_threadsafe(self._notify(port, value), self.loop)
 
+    def subscribe(self, port, callback):
+        port = int(port)
         self.lg.debug(
-            f'subscribe %s %s', port, wrapper
+            f'subscribe %s %s', port, callback
         )
-        subs = await self.mqtt.async_subscribe(
+        self._callbacks[port].append(callback)
-            topic=f"{self.mqtt_id}/{port}",
-            msg_callback=wrapper,
-            qos=0,
-        )
-        self.subscriptions.append(subs)
-
-    def unsubscribe_all(self):
-        self.lg.info('unsubscribe')
-        for x in self.subscriptions:
-            self.lg.debug('unsubscribe %s', x)
-            x()
 
     async def authenticate(self) -> bool:
         """Test if we can authenticate with the host."""
@@ -238,6 +247,7 @@ class MegaD:
             return await req.text()
 
     async def scan_port(self, port):
+        async with self.lck:
             if port in self._scanned:
                 return self._scanned[port]
             url = f'http://{self.host}/{self.sec}/?pt={port}'
@@ -274,3 +284,39 @@ class MegaD:
             ret = await self.scan_port(x)
             if ret:
                 yield [x, *ret]
+
+    async def get_config(self):
+        ret = defaultdict(lambda: defaultdict(list))
+        async for port, pty, m in self.scan_ports():
+            if pty == "0":
+                ret['binary_sensor'][port].append({})
+            elif pty == "1" and m in ['0', '1']:
+                ret['light'][port].append({'dimmer': m == '1'})
+            elif pty == '3':
+                try:
+                    await self.get_port(port)
+                    values = self.values.get(port)
+                except asyncio.TimeoutError:
+                    self.lg.warning(f'timout on port {port}')
+                    continue
+                self.lg.debug(f'values: %s', values)
+                if values is None:
+                    self.lg.warning(f'port {port} is of type sensor but response is None, skipping it')
+                    continue
+                if isinstance(values, dict) and 'value' in values:
+                    values = values['value']
+                if isinstance(values, str) and TEMP_PATT.search(values):
+                    values = {TEMP: values}
+                elif not isinstance(values, dict):
+                    values = {None: values}
+                for key in values:
+                    self.lg.debug(f'add sensor {key}')
+                    ret['sensor'][port].append(dict(
+                        key=key,
+                        unit_of_measurement=UNITS.get(key, UNITS[TEMP]),
+                        device_class=CLASSES.get(key, CLASSES[TEMP]),
+                        id_suffix=key,
+                    ))
+        return ret
+
+

custom_components/mega/light.py

@@ -1,6 +1,5 @@
 """Platform for light integration."""
 import logging
-import asyncio
 import voluptuous as vol
 
 from homeassistant.components.light import (
@@ -11,17 +10,22 @@ from homeassistant.components.light import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONF_NAME,
-    CONF_PLATFORM,
     CONF_PORT,
     CONF_UNIQUE_ID,
-    CONF_ID
+    CONF_ID,
+    CONF_DOMAIN,
 )
 from homeassistant.core import HomeAssistant
-from .entities import BaseMegaEntity
+from .entities import MegaOutPort
 
 from .hub import MegaD
-from .const import CONF_DIMMER, CONF_SWITCH
+from .const import (
-
+    CONF_DIMMER,
+    CONF_SWITCH,
+    DOMAIN,
+    CONF_CUSTOM,
+    CONF_SKIP,
+)
 
 lg = logging.getLogger(__name__)
 
@@ -47,29 +51,7 @@ PLATFORM_SCHEMA = LIGHT_SCHEMA.extend(
 
 
 async def async_setup_platform(hass, config, add_entities, discovery_info=None):
-    config.pop(CONF_PLATFORM)
+    lg.warning('mega integration does not support yaml for lights, please use UI configuration')
-    ents = []
-    for mid, _config in config.items():
-        for x in _config["dimmer"]:
-            if isinstance(x, int):
-                ent = MegaLight(
-                    mega_id=mid, port=x, dimmer=True)
-            else:
-                ent = MegaLight(
-                    mega_id=mid, port=x[CONF_PORT], name=x[CONF_NAME], dimmer=True
-                )
-            ents.append(ent)
-        for x in _config["switch"]:
-            if isinstance(x, int):
-                ent = MegaLight(
-                    mega_id=mid, port=x, dimmer=False
-                )
-            else:
-                ent = MegaLight(
-                    mega_id=mid, port=x[CONF_PORT], name=x[CONF_NAME], dimmer=False
-                )
-            ents.append(ent)
-    add_entities(ents)
     return True
 
 
@@ -77,79 +59,22 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
     mid = config_entry.data[CONF_ID]
     hub: MegaD = hass.data['mega'][mid]
     devices = []
-
+    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {})
-    async def scan_ports():
+    for port, cfg in config_entry.data.get('light', {}).items():
-        async for port, pty, m in hub.scan_ports():
+        port = int(port)
-            if pty == "1" and m in ['0', '1']:
+        c = customize.get(mid, {}).get(port, {})
-                light = MegaLight(mega_id=mid, port=port, dimmer=m == '1')
+        if c.get(CONF_SKIP, False) or c.get(CONF_DOMAIN, 'light') != 'light':
+            continue
+        for data in cfg:
+            hub.lg.debug(f'add light on port %s with data %s', port, data)
+            light = MegaLight(mega=hub, port=port, config_entry=config_entry, **data)
             devices.append(light)
     async_add_devices(devices)
 
-    asyncio.create_task(scan_ports())
 
-
+class MegaLight(MegaOutPort, LightEntity):
-class MegaLight(LightEntity, BaseMegaEntity):
-
-    def __init__(
-            self,
-            dimmer=False,
-            *args, **kwargs
-    ):
-        super().__init__(
-            *args, **kwargs
-        )
-        self._brightness = None
-        self._is_on = None
-        self.dimmer = dimmer
-
-    @property
-    def brightness(self):
-        if self._brightness is not None:
-            return self._brightness
-        if self._state:
-            return self._state.attributes.get("brightness")
 
     @property
     def supported_features(self):
         return SUPPORT_BRIGHTNESS if self.dimmer else 0
 
-    @property
-    def is_on(self) -> bool:
-        if self._is_on is not None:
-            return self._is_on
-        return self._state == 'ON'
-
-    async def async_turn_on(self, brightness=None, **kwargs) -> None:
-        brightness = brightness or self.brightness or 255
-        if self.dimmer and brightness == 0:
-            cmd = 255
-        elif self.dimmer:
-            cmd = brightness
-        else:
-            cmd = 1
-        if await self.mega.send_command(self.port, f"{self.port}:{cmd}"):
-            self._is_on = True
-            self._brightness = brightness
-        await self.async_update_ha_state()
-
-    async def async_turn_off(self, **kwargs) -> None:
-
-        cmd = "0"
-
-        if await self.mega.send_command(self.port, f"{self.port}:{cmd}"):
-            self._is_on = False
-        await self.async_update_ha_state()
-
-    def _update(self, payload: dict):
-        val = payload.get("value")
-        try:
-            val = int(val)
-        except Exception:
-            pass
-        if isinstance(val, int):
-            self._is_on = val
-            if val > 0:
-                self._brightness = val
-        else:
-            self._is_on = val == 'ON'
-

custom_components/mega/sensor.py

@@ -1,5 +1,4 @@
 """Platform for light integration."""
-import asyncio
 import logging
 import voluptuous as vol
 
@@ -11,14 +10,13 @@ from homeassistant.components.sensor import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONF_NAME,
-    CONF_PLATFORM,
     CONF_PORT,
     CONF_UNIQUE_ID,
     CONF_ID,
-    CONF_TYPE,
+    CONF_TYPE, CONF_UNIT_OF_MEASUREMENT,
 )
 from homeassistant.core import HomeAssistant
-from .entities import BaseMegaEntity
+from .entities import MegaPushEntity
 from .const import CONF_KEY, TEMP, HUM, W1, W1BUS
 from .hub import MegaD
 import re
@@ -59,17 +57,11 @@ PLATFORM_SCHEMA = SENSOR_SCHEMA.extend(
 
 
 async def async_setup_platform(hass, config, add_entities, discovery_info=None):
-    config.pop(CONF_PLATFORM)
+    lg.warning('mega integration does not support yaml for sensors, please use UI configuration')
-    ents = []
-    for mid, _config in config.items():
-        for x in _config:
-            ent = _make_entity(mid, **x)
-            ents.append(ent)
-    add_entities(ents)
     return True
 
 
-def _make_entity(mid: str, port: int, conf: dict):
+def _make_entity(config_entry, mid: str, port: int, conf: dict):
     key = conf[CONF_KEY]
     return Mega1WSensor(
         key=key,
@@ -78,7 +70,8 @@ def _make_entity(mid: str, port: int, conf: dict):
         patt=PATTERNS.get(key),
         unit_of_measurement=UNITS.get(key, UNITS[TEMP]),  # TODO: make other units, make options in config flow
         device_class=CLASSES.get(key, CLASSES[TEMP]),
-        id_suffix=key
+        id_suffix=key,
+        config_entry=config_entry
     )
 
 
@@ -86,42 +79,27 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
     mid = config_entry.data[CONF_ID]
     hub: MegaD = hass.data['mega'][mid]
     devices = []
-
+    for port, cfg in config_entry.data.get('sensor', {}).items():
-    async def scan():
+        port = int(port)
-        async for port, pty, m in hub.scan_ports():
+        for data in cfg:
-            if pty == "3":
+            hub.lg.debug(f'add sensor on port %s with data %s', port, data)
-                values = await hub.get_port(port)
+            sensor = Mega1WSensor(
-                lg.debug(f'values: %s', values)
+                mega=hub,
-                if values is None:
-                    continue
-                if isinstance(values, str) and TEMP_PATT.search(values):
-                    values = {TEMP: values}
-                elif not isinstance(values, dict):
-                    values = {None: values}
-                for key in values:
-                    hub.lg.debug(f'add sensor {W1}:{key}')
-                    sensor = _make_entity(
-                        mid=mid,
                 port=port,
-                        conf={
+                config_entry=config_entry,
-                            CONF_TYPE: W1,
+                **data,
-                            CONF_KEY: key,
+            )
-                        })
             devices.append(sensor)
-                    hub.sensors.append(sensor)
 
     async_add_devices(devices)
 
-    asyncio.create_task(scan())
 
-
+class Mega1WSensor(MegaPushEntity):
-class Mega1WSensor(BaseMegaEntity):
 
     def __init__(
             self,
             unit_of_measurement,
             device_class,
-            patt=None,
             key=None,
             *args,
             **kwargs
@@ -133,14 +111,24 @@ class Mega1WSensor(BaseMegaEntity):
         :param patt: pattern to extract value, must have at least one group that will contain parsed value
         """
         super().__init__(*args, **kwargs)
+        self.mega.sensors.append(self)
         self._value = None
         self.key = key
-        self.patt = patt
         self._device_class = device_class
         self._unit_of_measurement = unit_of_measurement
+        if self.port not in self.mega.sensors:
+            self.mega.sensors.append(self.port)
 
     @property
     def unit_of_measurement(self):
+        _u = self.customize.get(CONF_UNIT_OF_MEASUREMENT, None)
+        if _u is None:
+            return self._unit_of_measurement
+        elif isinstance(_u, str):
+            return _u
+        elif isinstance(_u, dict) and self.key in _u:
+            return _u[self.key]
+        else:
             return self._unit_of_measurement
 
     @property
@@ -154,27 +142,21 @@ class Mega1WSensor(BaseMegaEntity):
     def device_class(self):
         return self._device_class
 
-    @property
-    def should_poll(self):
-        return False
-
     @property
     def state(self):
-        if self._value is None and self._state is not None:
+        if self.key:
-            return self._state.state
+            ret = self.mega.values.get(self.port, {}).get('value', {}).get(self.key)
-        return self._value
+        else:
+            ret = self.mega.values.get(self.port, {}).get('value')
+        if ret is None and self._state is not None:
+            ret = self._state.state
+        return ret
 
     def _update(self, payload: dict):
-        val = payload.get('value', '')
+        self.mega.values[self.port] = payload
-        if isinstance(val, str) and self.patt is not None:
+
-            val = self.patt.findall(val)
+    @property
-            if val:
+    def name(self):
-                self._value = val[0]
+        n = super().name
-            else:
+        c = self.customize.get(CONF_NAME, {}).get(self.key)
-                self.lg.warning(f'could not parse: {payload}')
+        return c or n
-        elif isinstance(val, dict) and self.key is not None:
-            self._value = val.get(self.key)
-        elif isinstance(val, (float, int)):
-            self._value = val
-        else:
-            self.lg.warning(f'could not parse: {payload}')

custom_components/mega/switch.py

@@ -7,15 +7,19 @@ from homeassistant.components.switch import (
     PLATFORM_SCHEMA as LIGHT_SCHEMA,
     SwitchEntity,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONF_NAME,
-    CONF_PLATFORM,
     CONF_PORT,
+    CONF_ID,
+    CONF_DOMAIN,
 )
-from .entities import BaseMegaEntity
+from homeassistant.core import HomeAssistant
-from .const import CONF_DIMMER, CONF_SWITCH
+from .entities import MegaD
+from .entities import MegaOutPort
+from .const import CONF_DIMMER, CONF_SWITCH, DOMAIN, CONF_CUSTOM, CONF_SKIP
 
-_LOGGER = logging.getLogger(__name__)
+_LOGGER = lg = logging.getLogger(__name__)
 
 
 # Validation of the user's configuration
@@ -33,50 +37,29 @@ PLATFORM_SCHEMA = LIGHT_SCHEMA.extend(
     extra=vol.ALLOW_EXTRA,
 )
 
-async def async_setup_platform(hass, config, add_entities, discovery_info=None):
-    config.pop(CONF_PLATFORM)
-    ents = []
-    for mid, _config in config.items():
-        mega = hass.data["mega"][mid]
-        for x in _config:
-            if isinstance(x, int):
-                ent = MegaSwitch(hass, mega=mega, port=x)
-            else:
-                ent = MegaSwitch(
-                    hass, mega=mega, port=x[CONF_PORT], name=x[CONF_NAME]
-                )
-            ents.append(ent)
 
-    add_entities(ents)
+async def async_setup_platform(hass, config, add_entities, discovery_info=None):
+    lg.warning('mega integration does not support yaml for switches, please use UI configuration')
     return True
 
 
-class MegaSwitch(SwitchEntity, BaseMegaEntity):
+async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, async_add_devices):
+    mid = config_entry.data[CONF_ID]
+    hub: MegaD = hass.data['mega'][mid]
+    devices = []
 
-    def __init__(self, *args, **kwargs):
+    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {})
-        super().__init__(*args, **kwargs)
+    for port, cfg in config_entry.data.get('light', {}).items():
-        self._is_on = None
+        port = int(port)
+        c = customize.get(mid, {}).get(port, {})
+        if c.get(CONF_SKIP, False) or c.get(CONF_DOMAIN, 'light') != 'switch':
+            continue
+        for data in cfg:
+            hub.lg.debug(f'add switch on port %s with data %s', port, data)
+            light = MegaSwitch(mega=hub, port=port, config_entry=config_entry, **data)
+            devices.append(light)
+    async_add_devices(devices)
 
-    @property
-    def is_on(self) -> bool:
-        if self._is_on is not None:
-            return self._is_on
-        return self._state == 'ON'
 
-    async def async_turn_on(self, **kwargs) -> None:
+class MegaSwitch(MegaOutPort, SwitchEntity):
-        cmd = 1
+    pass
-        if await self.mega.send_command(self.port, f"{self.port}:{cmd}"):
-            self._is_on = True
-        await self.async_update_ha_state()
-
-    async def async_turn_off(self, **kwargs) -> None:
-
-        cmd = "0"
-
-        if await self.mega.send_command(self.port, f"{self.port}:{cmd}"):
-            self._is_on = False
-        await self.async_update_ha_state()
-
-    def _update(self, payload: dict):
-        val = payload.get("value")
-        self._is_on = val == 'ON'

custom_components/mega/translations/en.json

@@ -17,11 +17,22 @@
                     "username": "Username",
                     "id": "ID",
                     "mqtt_id": "MQTT id",
-                    "scan_interval": "Scan interval (sec) (used for aliveness and sensors)",
+                    "scan_interval": "Scan interval (sec), 0 - don't update",
                     "port_to_scan": "Port to poll aliveness (needed only if no sensors used)"
                 }
             }
         }
     },
+    "options": {
+        "step": {
+            "init": {
+                "data": {
+                  "scan_interval": "Scan interval (sec), 0 - don't update",
+                  "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
+                  "reload": "Reload objects"
+                }
+            }
+        }
+    },
     "title": "mega"
 }

custom_components/mega/translations/ru.json

@@ -17,7 +17,7 @@
                     "username": "Пользователь",
                     "id": "ID",
                     "mqtt_id": "MQTT id",
-                    "scan_interval": "Периодичность обновлений (сек.)",
+                    "scan_interval": "Периодичность обновлений (сек.), 0 - не обновлять",
                     "port_to_scan": "Порт, который сканируется когда нет датчиков"
                 }
             }
@@ -27,7 +27,7 @@
         "step": {
             "init": {
                 "data": {
-                  "scan_interval": "Периодичность обновлений (сек.)",
+                  "scan_interval": "Периодичность обновлений (сек.), 0 - не обновлять",
                   "port_to_scan": "Порт, который сканируется когда нет датчиков",
                   "reload": "Обновить объекты",
                   "invert": "Список портов (через ,) с инвертированной логикой"

custom_components/mega/translations/uk.json

@@ -0,0 +1,39 @@
+{
+    "config": {
+        "abort": {
+            "already_configured": "Вже налаштовано"
+        },
+        "error": {
+            "cannot_connect": "Неможливо підключитись",
+            "invalid_auth": "Неправильний пароль",
+            "unknown": "Невідома помилка",
+            "duplicate_id": "Дублікат ID"
+        },
+        "step": {
+            "user": {
+                "data": {
+                    "host": "Хост",
+                    "password": "Пароль",
+                    "username": "Користувач",
+                    "id": "ID",
+                    "mqtt_id": "MQTT id",
+                    "scan_interval": "Період оновлення (сек.)",
+                    "port_to_scan": "Порт для сканування при відсутності датчиків"
+                }
+            }
+        }
+    },
+    "options": {
+        "step": {
+            "init": {
+                "data": {
+                  "scan_interval": "Період оновлення (сек.)",
+                  "port_to_scan": "Порт для сканування при відсутності датчиків",
+                  "reload": "Оновити об'єкти",
+                  "invert": "Список портів з інвертованою логікою (через ,)"
+                }
+            }
+        }
+    },
+    "title": "mega"
+}

readme.md

@@ -3,23 +3,28 @@
 Интеграция с [MegaD-2561](https://www.ab-log.ru/smart-house/ethernet/megad-2561)
 
 ## Основные особенности:
+- Настройка в веб-интерфейсе + yaml
 - Все порты автоматически добавляются как устройства (для обычных релейных выходов создается 
-  `light`, для шим - `light` с поддержкой яркости, для цифровых входов `binary_sensor`, для температурных датчиков
+  `light`, для шим - `light` с поддержкой яркости, для цифровых входов `binary_sensor`, для датчиков
   `sensor`)
 - Возможность работы с несколькими megad
 - Обратная связь по mqtt
-- Команды выполняются друг за другом без конкурентного доступа к ресурсам megad
+- События на двойные/долгие нажатия
-- Поддержка температурных датчиков в режиме шины
+- Команды выполняются друг за другом без конкурентного доступа к ресурсам megad, это дает гарантии надежного исполнения
+  большого кол-ва команд (например в сценах). Каждая следующая команда отправляется только после получения ответа о
+  выполнении предыдущей.
 
 ## Зависимости
-**Важно!!** Перед использованием необходимо настроить интеграцию mqtt в HomeAssistant
+**Важно!!** Перед использованием необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
+в HomeAssistant
 
 Для максимальной совместимости необходимо обновить ваш контроллер до последней версии, тк были важные обновления в части
 mqtt
 
 ## Установка
-Рекомендованнй способ с поддержкой обновлений - через [HACS](https://hacs.xyz/docs/installation/installation).
+Рекомендованный способ с поддержкой обновлений - [HACS](https://hacs.xyz/docs/installation/installation):
-После установки перейти в меню HACS - Integrations - Explore, в поиске ищем MegaD
+
+HACS - Integrations - Explore, в поиске ищем MegaD. 
 
 Альтернативный способ установки:
 ```shell
@@ -27,12 +32,74 @@ mqtt
 wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.sh | bash -
 ```
 Не забываем перезагрузить HA
-## Устройства
-Поддерживаются устройства: light, switch, binary_sensor, sensor. light может работать как диммер
 
-## Настройка из веб-интерфейса
+## Настройка
 `Настройки` -> `Интеграции` -> `Добавить интеграцию` в поиске ищем mega
 
+Все имеющиеся у вас порты будут настроены автоматически. Вы можете менять названия, иконки и entity_id так же из интерфейса.
+
+#### Кастомизация устройств с помощью yaml:
+```yaml
+# configuration.yaml
+
+mega:
+  hello: # ID меги, как в UI 
+    7: # номер порта
+      domain: switch # тип устройства (switch или light, по умолчанию для цифровых выходов используется light)
+      invert: true # инвертировать или нет (по умолчанию false)
+      name: Насос # имя устройства
+    8:
+      # исключить из сканирования
+      skip: true
+    33:
+      # для датчиков можно кастомизировать только имя и unit_of_measurement
+      # для температуры и влажность unit определяется автоматически, для остальных юнита нет 
+      name:
+        hum: "влажность"
+        temp: "температура"
+      unit_of_measurement:
+        hum: "%" # если датчиков несколько, то можно указывать юниты по их ключам
+        temp: "°C"
+    14:
+      name: какой-то датчик
+      unit_of_measurement: "°C" # если датчик один, то просто строчкой
+```
+
+## События
+`binary_sensor` срабатывает когда цифровой выход принимает значение 'ON', вместе с этим
+он сохраняет полученные параметры от меги в аттрибутах. Атрибутами можно пользоваться так:
+```yaml
+- alias: some double click
+  trigger:
+    - platform: state
+      entity_id: binary_sensor.mega_1
+      attribute: cnt
+      to: 2
+  action:
+    - service: light.toggle
+      entity_id: light.some_light
+```
+Однако, особенность state-триггера в атоматизациях HA в том, что он срабатывает только когда state меняется. Это может 
+мешать, тк если вы повторно совершите двойной клик, стейт уже не поменяется, поэтому рекомендуется
+пользоваться event-триггером.
+
+При каждом срабатывании `binary_sensor` так же сообщает о событии типа `mega.sensor`.
+События можно использовать в автоматизациях, например так:
+```yaml
+- alias: some double click
+  trigger:
+    - platform: event
+      event_type: mega.sensor
+      event_data:
+        entity_id: binary_sensor.mega_1
+        cnt: 2
+  action:
+    - service: light.toggle
+      entity_id: light.some_light
+```
+Чтобы понять, какие события происходят, лучше всего воспользоваться панелью разработчика и подписаться
+на вкладке события на событие `mega.sensor`, понажимать кнопки.
+
 ## Сервисы
 Все сервисы доступны в меню разработчика с описанием и примерами использования
 ```yaml
@@ -65,7 +132,6 @@ mega.run_cmd:
     cmd:
       description: Любая поддерживаемая мегой команда
       example: "1:0"
-
 ```
 
 ## Отладка