From 3108927f156e4f7c0fd3367e7f28218cd812c1e2 Mon Sep 17 00:00:00 2001
From: andvikt <39195436+andvikt@users.noreply.github.com>
Date: Wed, 20 Jan 2021 23:25:57 +0300
Subject: [PATCH 01/37] fix offline bug

---
 custom_components/mega/hub.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index b1212b3..fed025a 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -98,11 +98,11 @@ class MegaD:
             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 asyncio.sleep(5)
+            if (datetime.now() - self.last_update).total_seconds() > (self.poll_interval + 10):
                 await self.get_port(self.port_to_scan)
-                await asyncio.sleep(1)
-                if (datetime.now() - self.last_update).total_seconds() > self.poll_interval:
+                await asyncio.sleep(5)
+                if (datetime.now() - self.last_update).total_seconds() > (self.poll_interval + 10):
                     self.lg.warning('mega is offline')
                     self.hass.states.async_set(
                         f'mega.{self.id}',

From 42f44d302019f29a56d27cd05b04f45472a544c8 Mon Sep 17 00:00:00 2001
From: andvikt <39195436+andvikt@users.noreply.github.com>
Date: Wed, 20 Jan 2021 23:33:53 +0300
Subject: [PATCH 02/37] Fix offline bugs

---
 custom_components/mega/hub.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index fed025a..40e3dc4 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -98,10 +98,10 @@ class MegaD:
             else:
                 await self.get_port(self.port_to_scan)
 
-            await asyncio.sleep(5)
+            await asyncio.sleep(1)
             if (datetime.now() - self.last_update).total_seconds() > (self.poll_interval + 10):
                 await self.get_port(self.port_to_scan)
-                await asyncio.sleep(5)
+                await asyncio.sleep(1)
                 if (datetime.now() - self.last_update).total_seconds() > (self.poll_interval + 10):
                     self.lg.warning('mega is offline')
                     self.hass.states.async_set(
@@ -168,7 +168,7 @@ class MegaD:
         ftr = asyncio.get_event_loop().create_future()
 
         def cb(msg):
-
+            self.last_update = datetime.now()
             try:
                 if '"value":NA' in msg.payload.decode():
                     if not ftr.done():

From bb4ce882f585390114aa7fbb6b6672bed7091bf2 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 10:27:02 +0300
Subject: [PATCH 03/37] =?UTF-8?q?=D1=80=D0=B5=D1=84=D0=B0=D0=BA=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80=D0=B8=D0=BD=D0=B3,=20=D0=BA=D0=BE=D0=BD=D1=84?=
 =?UTF-8?q?=D0=B8=D0=B3=20yaml?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 custom_components/mega/__init__.py          |  91 ++++----
 custom_components/mega/binary_sensor.py     |  43 ++--
 custom_components/mega/config_flow.py       |  16 +-
 custom_components/mega/const.py             |   7 +-
 custom_components/mega/entities.py          | 139 +++++++++---
 custom_components/mega/hub.py               | 236 ++++++++++----------
 custom_components/mega/light.py             | 109 ++-------
 custom_components/mega/sensor.py            |  63 +++---
 custom_components/mega/switch.py            |  71 +++---
 custom_components/mega/translations/en.json |   4 +-
 custom_components/mega/translations/ru.json |   4 +-
 readme.md                                   |  26 +++
 12 files changed, 409 insertions(+), 400 deletions(-)

diff --git a/custom_components/mega/__init__.py b/custom_components/mega/__init__.py
index c100bd5..55f3fa6 100644
--- a/custom_components/mega/__init__.py
+++ b/custom_components/mega/__init__.py
@@ -4,36 +4,41 @@ 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, PLATFORMS
+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): 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,
 )
 
-
 ALIVE_STATE = 'alive'
 DEF_ID = 'def'
 _POLL_TASKS = {}
@@ -42,9 +47,9 @@ _subs = {}
 
 
 async def async_setup(hass: HomeAssistant, config: dict):
-    """Set up the mega component."""
-    conf = config.get(DOMAIN)
-    hass.data[DOMAIN] = {}
+    """YAML-конфигурация содержит только кастомизации портов"""
+    hass.data[DOMAIN] = {CONF_CUSTOM: config.get(DOMAIN, {})}
+
     hass.services.async_register(
         DOMAIN, 'save', partial(_save_service, hass), schema=vol.Schema({
             vol.Optional('mega_id'): str
@@ -63,16 +68,6 @@ 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
 
 
@@ -84,7 +79,8 @@ async def get_hub(hass, entry):
     _mqtt = hass.data.get(mqtt.DOMAIN)
     if _mqtt is None:
         raise Exception('mqtt not configured, please configure mqtt first')
-    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
 
 
@@ -100,17 +96,17 @@ async def _add_mega(hass: HomeAssistant, entry: ConfigEntry):
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
-    hub = await _add_mega(hass, entry)
+    hub: MegaD = await _add_mega(hass, entry)
     _hubs[entry.entry_id] = hub
     _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
 
 
@@ -125,6 +121,8 @@ async def updater(hass: HomeAssistant, entry: ConfigEntry):
     hub.poll_interval = entry.options[CONF_SCAN_INTERVAL]
     hub.port_to_scan = entry.options.get(CONF_PORT_TO_SCAN, 0)
     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
@@ -133,34 +131,31 @@ async def updater(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)
-    hub = hass.data[DOMAIN]
+    hub: MegaD = hass.data[DOMAIN][id]
     if hub is None:
         return
     _LOGGER.debug(f'remove {id}')
     _hubs.pop(entry.entry_id)
     task: asyncio.Task = _POLL_TASKS.pop(id, None)
-    if task is None:
-        return
-    task.cancel()
+    if task is not None:
+        task.cancel()
     if hub is None:
         return
-    hub.unsubscribe_all()
-    unsub = _subs.pop(entry.entry_id)
-    if unsub:
-        unsub()
+    await hub.stop()
 
 
 async def async_migrate_entry(hass, config_entry: ConfigEntry):
     """Migrate old entry."""
-    _LOGGER.debug("Migrating from version %s to version 2", config_entry.version)
+    _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)
-    if config_entry.version == 1:
-        cfg = await hub.get_config()
-        new.update(cfg)
-        _LOGGER.debug(f'new config: %s', new)
-        config_entry.data = new
-        config_entry.version = 2
+    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)
 
@@ -189,6 +184,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:
diff --git a/custom_components/mega/binary_sensor.py b/custom_components/mega/binary_sensor.py
index 03b2c03..b4559ba 100644
--- a/custom_components/mega/binary_sensor.py
+++ b/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)
-    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)
+    lg.warning('mega integration does not support yaml for binary_sensors, please use UI configuration')
     return True
 
 
@@ -61,15 +48,19 @@ 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, {})
     for port, cfg in config_entry.data.get('binary_sensor', {}).items():
+        port = int(port)
+        c = customize.get(mid, {}).get(port, {})
+        if c.get(CONF_SKIP, False):
+            continue
         hub.lg.debug(f'add binary_sensor on port %s', port)
-        sensor = MegaBinarySensor(mega_id=mid, port=port, config_entry=config_entry)
+        sensor = MegaBinarySensor(mega=hub, port=port, config_entry=config_entry)
         devices.append(sensor)
     async_add_devices(devices)
 
 
-class MegaBinarySensor(BinarySensorEntity, BaseMegaEntity):
+class MegaBinarySensor(BinarySensorEntity, MegaPushEntity):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -82,5 +73,13 @@ 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)
+        self.hass.bus.async_fire(
+            EVENT_BINARY_SENSOR,
+            data,
+        )
         val = payload.get("value")
         self._is_on = val == 'ON'
\ No newline at end of file
diff --git a/custom_components/mega/config_flow.py b/custom_components/mega/config_flow.py
index 581469f..9717cd9 100644
--- a/custom_components/mega/config_flow.py
+++ b/custom_components/mega/config_flow.py
@@ -1,5 +1,5 @@
 """Пока не сделано"""
-
+import asyncio
 import logging
 
 import voluptuous as vol
@@ -20,7 +20,7 @@ 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,
     },
 )
@@ -30,7 +30,8 @@ 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)
+    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
@@ -51,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 = 2
+    VERSION = 3
     CONNECTION_CLASS = config_entries.CONN_CLASS_ASSUMED
 
     async def async_step_user(self, user_input=None):
@@ -65,7 +66,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
         try:
             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(
@@ -106,7 +109,10 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
             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:
@@ -120,7 +126,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
         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,
diff --git a/custom_components/mega/const.py b/custom_components/mega/const.py
index f8c3b09..60951cd 100644
--- a/custom_components/mega/const.py
+++ b/custom_components/mega/const.py
@@ -12,8 +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",
-]
\ No newline at end of file
+]
+EVENT_BINARY_SENSOR = f'{DOMAIN}.sensor'
\ No newline at end of file
diff --git a/custom_components/mega/entities.py b/custom_components/mega/entities.py
index efc05ac..e5c79f7 100644
--- a/custom_components/mega/entities.py
+++ b/custom_components/mega/entities.py
@@ -1,39 +1,48 @@
-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,
     ):
+        super().__init__(mega.updater)
         self._state: State = None
         self.port = port
         self.config_entry = config_entry
-        self._mega_id = mega_id
+        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:
+            self._customize = self.hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {}).get(self._mega_id).get(self.port, {})
+        return self._customize
 
     @property
     def device_info(self):
@@ -58,38 +67,112 @@ 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}"
+        return self.customize.get(CONF_NAME) or self._name or f"{self.mega.id}_p{self.port}"
 
     @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:
-            value = json.loads(msg.payload)
-        except Exception as exc:
-            self.lg.warning(f'could not parse json ({msg.payload}): {exc}')
-            return
+
+class MegaPushEntity(BaseMegaEntity):
+
+    """
+    Updates on messages from mqtt
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mega.subscribe(self.port, callback=self.__update)
+
+    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)
         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'
\ No newline at end of file
diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index 40e3dc4..c192eb9 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -1,21 +1,21 @@
 import asyncio
-import json
 import logging
 from collections import defaultdict
-from datetime import datetime
-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
-import re
 
 TEMP_PATT = re.compile(r'temp:([01234567890\.]+)')
 HUM_PATT = re.compile(r'hum:([01234567890\.]+)')
@@ -38,6 +38,7 @@ class MegaD:
     def __init__(
             self,
             hass: HomeAssistant,
+            loop: asyncio.AbstractEventLoop,
             host: str,
             password: str,
             mqtt: mqtt.MQTT,
@@ -50,29 +51,51 @@ 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.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:
@@ -80,55 +103,41 @@ class MegaD:
 
     async def get_sensors(self):
         self.lg.debug(self.sensors)
-        _ports = {x.port for x in self.sensors}
-        for x in _ports:
+        for x in self.sensors:
             await self.get_port(x)
-            await asyncio.sleep(0.1)
+
+    @property
+    def is_online(self):
+        return (datetime.now() - self.last_update).total_seconds() < (self.poll_interval + 10)
+
+    def _warn_offline(self):
+        if self.online:
+            self.lg.warning('mega is offline')
+            self.hass.states.async_set(
+                f'mega.{self.id}',
+                'offline',
+            )
+            self.online = False
+
+    def _notify_online(self):
+        if not self.online:
+            self.hass.states.async_set(
+                f'mega.{self.id}',
+                'online',
+            )
+            self.online = True
 
     async def poll(self):
         """
         Send get port 0 every poll_interval. When answer is received, mega.<id> becomes online else mega.<id> becomes
         offline
         """
-        self._loop = asyncio.get_event_loop()
-
-        while True:
-            if len(self.sensors) > 0:
-                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 + 10):
-                await self.get_port(self.port_to_scan)
-                await asyncio.sleep(1)
-                if (datetime.now() - self.last_update).total_seconds() > (self.poll_interval + 10):
-                    self.lg.warning('mega is offline')
-                    self.hass.states.async_set(
-                        f'mega.{self.id}',
-                        'offline',
-                    )
-                    self.online = False
-            else:
-                self.hass.states.async_set(
-                    f'mega.{self.id}',
-                    'online',
-                )
-                self.online = True
-
-            for x in self.entities:
-                try:
-                    await x.async_update_ha_state()
-                except RuntimeError:
-                    pass
-            await asyncio.sleep(self.poll_interval - 1)
-
-    async def _async_notify(self):
-        async with self.is_alive:
-            self.is_alive.notify_all()
-
-    def _notify(self, *args):
-        asyncio.run_coroutine_threadsafe(self._async_notify(), self._loop)
+        self.lg.debug('poll')
+        if len(self.sensors) > 0:
+            await self.get_sensors()
+        else:
+            await self.get_port(self.port_to_scan)
+        return self.values
 
     async def get_mqtt_id(self):
         async with aiohttp.request(
@@ -159,85 +168,63 @@ class MegaD:
         await self.send_command(cmd='s')
 
     async def get_port(self, port):
-        """
-        Опрашивает порт с помощью mqtt. Ждет ответ, возвращает ответ.
-
-        :param port:
-        :return:
-        """
-        ftr = asyncio.get_event_loop().create_future()
-
-        def cb(msg):
-            self.last_update = datetime.now()
-            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.cnd:
+            await self.mqtt.async_publish(
+                topic=f'{self.mqtt_id}/cmd',
+                payload=f'get:{port}',
+                qos=2,
+                retain=False,
             )
-
-        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,
-                    retain=False,
-                )
-                return await asyncio.wait_for(ftr, timeout=2)
-            except asyncio.TimeoutError:
-                self.lg.warning(f'timeout on port {port}')
-            finally:
-                unsub()
+            await asyncio.wait_for(self.cnd.wait(), timeout=15)
 
     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):
-
-        @wraps(callback)
-        def wrapper(msg):
-            self.lg.debug(
-                'process incomming message: %s', msg
-            )
+    async def _notify(self, port, value):
+        async with self.cnd:
             self.last_update = datetime.now()
-            return callback(msg)
+            self.values[port] = value
+            self.cnd.notify()
 
+    def _process_msg(self, msg):
+        try:
+            _, port = msg.topic.split('/')
+        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(
-            f'subscribe %s %s', port, wrapper
+            'process incomming message: %s', msg
         )
-        subs = await self.mqtt.async_subscribe(
-            topic=f"{self.mqtt_id}/{port}",
-            msg_callback=wrapper,
-            qos=0,
-        )
-        self.subscriptions.append(subs)
+        value = None
+        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 unsubscribe_all(self):
-        self.lg.info('unsubscribe')
-        for x in self.subscriptions:
-            self.lg.debug('unsubscribe %s', x)
-            x()
+    def subscribe(self, port, callback):
+        port = int(port)
+        self.lg.debug(
+            f'subscribe %s %s', port, callback
+        )
+        self._callbacks[port].append(callback)
 
     async def authenticate(self) -> bool:
         """Test if we can authenticate with the host."""
@@ -302,11 +289,18 @@ class MegaD:
             elif pty == "1" and m in ['0', '1']:
                 ret['light'][port].append({'dimmer': m == '1'})
             elif pty == '3':
-                values = await self.get_port(port)
+                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 did not respond, skipping it')
+                    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):
@@ -315,10 +309,10 @@ class MegaD:
                     self.lg.debug(f'add sensor {key}')
                     ret['sensor'][port].append(dict(
                         key=key,
-                        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,
                     ))
         return ret
+
+
diff --git a/custom_components/mega/light.py b/custom_components/mega/light.py
index aa4f841..3a4d7c9 100644
--- a/custom_components/mega/light.py
+++ b/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)
-    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)
+    lg.warning('mega integration does not support yaml for lights, please use UI configuration')
     return True
 
 
@@ -77,77 +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, {})
     for port, cfg in config_entry.data.get('light', {}).items():
+        port = int(port)
+        c = customize.get(mid, {}).get(port, {})
+        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_id=mid, port=port, config_entry=config_entry, **data)
+            light = MegaLight(mega=hub, port=port, config_entry=config_entry, **data)
             devices.append(light)
     async_add_devices(devices)
 
 
-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")
+class MegaLight(MegaOutPort, LightEntity):
 
     @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'
-
diff --git a/custom_components/mega/sensor.py b/custom_components/mega/sensor.py
index ac55058..b20a6c9 100644
--- a/custom_components/mega/sensor.py
+++ b/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,13 +57,7 @@ PLATFORM_SCHEMA = SENSOR_SCHEMA.extend(
 
 
 async def async_setup_platform(hass, config, add_entities, discovery_info=None):
-    config.pop(CONF_PLATFORM)
-    ents = []
-    for mid, _config in config.items():
-        for x in _config:
-            ent = _make_entity(mid, **x)
-            ents.append(ent)
-    add_entities(ents)
+    lg.warning('mega integration does not support yaml for sensors, please use UI configuration')
     return True
 
 
@@ -87,12 +79,12 @@ 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():
+        port = int(port)
         for data in cfg:
             hub.lg.debug(f'add sensor on port %s with data %s', port, data)
             sensor = Mega1WSensor(
-                mega_id=mid,
+                mega=hub,
                 port=port,
                 config_entry=config_entry,
                 **data,
@@ -102,13 +94,12 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
     async_add_devices(devices)
 
 
-class Mega1WSensor(BaseMegaEntity):
+class Mega1WSensor(MegaPushEntity):
 
     def __init__(
             self,
             unit_of_measurement,
             device_class,
-            patt=None,
             key=None,
             *args,
             **kwargs
@@ -120,15 +111,25 @@ 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):
-        return self._unit_of_measurement
+        _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
     def unique_id(self):
@@ -141,27 +142,15 @@ 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:
-            return self._state.state
-        return self._value
+        if self.key:
+            ret = self.mega.values.get(self.port, {}).get('value', {}).get(self.key)
+        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', '')
-        if isinstance(val, str) and self.patt is not None:
-            val = self.patt.findall(val)
-            if val:
-                self._value = val[0]
-            else:
-                self.lg.warning(f'could not parse: {payload}')
-        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}')
+        self.mega.values[self.port] = payload
diff --git a/custom_components/mega/switch.py b/custom_components/mega/switch.py
index 1616ae4..1462e63 100644
--- a/custom_components/mega/switch.py
+++ b/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 .const import CONF_DIMMER, CONF_SWITCH
+from homeassistant.core import HomeAssistant
+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):
-        super().__init__(*args, **kwargs)
-        self._is_on = None
+    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {})
+    for port, cfg in config_entry.data.get('light', {}).items():
+        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:
-        cmd = 1
-        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'
+class MegaSwitch(MegaOutPort, SwitchEntity):
+    pass
diff --git a/custom_components/mega/translations/en.json b/custom_components/mega/translations/en.json
index 9e7d18e..8839518 100644
--- a/custom_components/mega/translations/en.json
+++ b/custom_components/mega/translations/en.json
@@ -17,7 +17,7 @@
                     "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)"
                 }
             }
@@ -27,7 +27,7 @@
         "step": {
             "init": {
                 "data": {
-                  "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)",
                   "reload": "Reload objects"
                 }
diff --git a/custom_components/mega/translations/ru.json b/custom_components/mega/translations/ru.json
index 8fbb080..07313be 100644
--- a/custom_components/mega/translations/ru.json
+++ b/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": "Список портов (через ,) с инвертированной логикой"
diff --git a/readme.md b/readme.md
index f9018c2..a6f171f 100644
--- a/readme.md
+++ b/readme.md
@@ -38,6 +38,32 @@ wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.
 
 Вы можете менять названия, иконки и entity_id так же из интерфейса.
 
+По умолчанию все порты настроенные как сенсоры запрашиваются с периодичностью, указанной в настройках. Если это значение
+выставить в 0, сканирование выполняться не будет.
+
+####Так же доступна кастомизация устройств с помощью 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
+      name: какой-то датчик
+      unit_of_measurement:
+        hum: "%" # если датчиков несколько, то можно указывать юниты по их ключам
+    14:
+      name: какой-то датчик
+      hum: "%" # если датчик один, то просто строчкой
+```
+
 ## Сервисы
 Все сервисы доступны в меню разработчика с описанием и примерами использования
 ```yaml

From 9755a9c654f062fdbedd913f7213a13577dce9ca Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 10:27:54 +0300
Subject: [PATCH 04/37] edit readme

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index a6f171f..d9ab9fb 100644
--- a/readme.md
+++ b/readme.md
@@ -41,7 +41,7 @@ wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.
 По умолчанию все порты настроенные как сенсоры запрашиваются с периодичностью, указанной в настройках. Если это значение
 выставить в 0, сканирование выполняться не будет.
 
-####Так же доступна кастомизация устройств с помощью yaml:
+#### Так же доступна кастомизация устройств с помощью yaml:
 ```yaml
 # configuration.yaml
 

From fa1c3330ba61b259d0bd6bbe25b382703379ffce Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 10:48:00 +0300
Subject: [PATCH 05/37] edit readme

---
 custom_components/mega/binary_sensor.py | 17 +++++++----
 custom_components/mega/entities.py      |  2 ++
 readme.md                               | 39 ++++++++++++++++++++++++-
 3 files changed, 52 insertions(+), 6 deletions(-)

diff --git a/custom_components/mega/binary_sensor.py b/custom_components/mega/binary_sensor.py
index b4559ba..5999261 100644
--- a/custom_components/mega/binary_sensor.py
+++ b/custom_components/mega/binary_sensor.py
@@ -65,6 +65,11 @@ class MegaBinarySensor(BinarySensorEntity, MegaPushEntity):
     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:
@@ -77,9 +82,11 @@ class MegaBinarySensor(BinarySensorEntity, MegaPushEntity):
         payload = payload.copy()
         payload.pop(CONF_PORT)
         data.update(payload)
-        self.hass.bus.async_fire(
-            EVENT_BINARY_SENSOR,
-            data,
-        )
+        if not self.is_first_update:
+            self.hass.bus.async_fire(
+                EVENT_BINARY_SENSOR,
+                data,
+            )
         val = payload.get("value")
-        self._is_on = val == 'ON'
\ No newline at end of file
+        self._is_on = val == 'ON'
+        self._attrs = data
diff --git a/custom_components/mega/entities.py b/custom_components/mega/entities.py
index e5c79f7..020c0ac 100644
--- a/custom_components/mega/entities.py
+++ b/custom_components/mega/entities.py
@@ -93,11 +93,13 @@ class MegaPushEntity(BaseMegaEntity):
     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.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):
diff --git a/readme.md b/readme.md
index d9ab9fb..36ebe86 100644
--- a/readme.md
+++ b/readme.md
@@ -56,14 +56,51 @@ mega:
       skip: true
     33:
       # для датчиков можно кастомизировать только имя и unit_of_measurement
+      # для температуры и влажность unit определяется автоматически, для остальных юнита нет 
       name: какой-то датчик
       unit_of_measurement:
         hum: "%" # если датчиков несколько, то можно указывать юниты по их ключам
+        temp: "°C"
     14:
       name: какой-то датчик
-      hum: "%" # если датчик один, то просто строчкой
+      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

From 62bdcfeb1b02e0c6084af4d622a4b24b46ed1d86 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 10:50:34 +0300
Subject: [PATCH 06/37] edit readme

---
 readme.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 36ebe86..295b770 100644
--- a/readme.md
+++ b/readme.md
@@ -3,12 +3,13 @@
 Интеграция с [MegaD-2561](https://www.ab-log.ru/smart-house/ethernet/megad-2561)
 
 ## Основные особенности:
-- Настройка в веб-интерфейсе
+- Настройка в веб-интерфейсе + yaml
 - Все порты автоматически добавляются как устройства (для обычных релейных выходов создается 
   `light`, для шим - `light` с поддержкой яркости, для цифровых входов `binary_sensor`, для датчиков
   `sensor`)
 - Возможность работы с несколькими megad
 - Обратная связь по mqtt
+- События на двойные/долгие нажатия
 - Команды выполняются друг за другом без конкурентного доступа к ресурсам megad, это дает гарантии надежного исполнения
   большого кол-ва команд (например в сценах). Каждая следующая команда отправляется только после получения ответа о
   выполнении предыдущей.

From 6b1635f60f1d655a0a7ac3a63e872a17dde5aafc Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 10:51:32 +0300
Subject: [PATCH 07/37] edit readme

---
 readme.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 295b770..ff97f85 100644
--- a/readme.md
+++ b/readme.md
@@ -15,7 +15,8 @@
   выполнении предыдущей.
 
 ## Зависимости
-**Важно!!** Перед использованием необходимо настроить интеграцию mqtt в HomeAssistant
+**Важно!!** Перед использованием необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
+в HomeAssistant
 
 Для максимальной совместимости необходимо обновить ваш контроллер до последней версии, тк были важные обновления в части
 mqtt

From a8eb50ee44a1796c4c1f7f6fafda26b44d7cfe69 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 10:52:39 +0300
Subject: [PATCH 08/37] edit readme

---
 readme.md | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/readme.md b/readme.md
index ff97f85..3565da9 100644
--- a/readme.md
+++ b/readme.md
@@ -36,12 +36,7 @@ wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.
 ## Настройка
 `Настройки` -> `Интеграции` -> `Добавить интеграцию` в поиске ищем mega
 
-Все имеющиеся у вас порты будут настроены автоматически.
-
-Вы можете менять названия, иконки и entity_id так же из интерфейса.
-
-По умолчанию все порты настроенные как сенсоры запрашиваются с периодичностью, указанной в настройках. Если это значение
-выставить в 0, сканирование выполняться не будет.
+Все имеющиеся у вас порты будут настроены автоматически. Вы можете менять названия, иконки и entity_id так же из интерфейса.
 
 #### Так же доступна кастомизация устройств с помощью yaml:
 ```yaml

From 2a0f60f1b23df823c052502ba1c52c9fb8a05103 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 10:53:15 +0300
Subject: [PATCH 09/37] edit readme

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 3565da9..01f1f09 100644
--- a/readme.md
+++ b/readme.md
@@ -38,7 +38,7 @@ wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.
 
 Все имеющиеся у вас порты будут настроены автоматически. Вы можете менять названия, иконки и entity_id так же из интерфейса.
 
-#### Так же доступна кастомизация устройств с помощью yaml:
+#### Кастомизация устройств с помощью yaml:
 ```yaml
 # configuration.yaml
 

From 2a4a85a20e2f5ee9109dea0d6e7374ca7fef4de5 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 11:12:18 +0300
Subject: [PATCH 10/37] small bugfix

---
 custom_components/mega/entities.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/custom_components/mega/entities.py b/custom_components/mega/entities.py
index 020c0ac..bf2567e 100644
--- a/custom_components/mega/entities.py
+++ b/custom_components/mega/entities.py
@@ -41,7 +41,10 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
         if self.hass is None:
             return {}
         if self._customize is None:
-            self._customize = self.hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {}).get(self._mega_id).get(self.port, {})
+            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

From 3e1499f78b5989667b1bdbda92dcb202ca07c607 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 12:16:32 +0300
Subject: [PATCH 11/37] fix get_port

---
 custom_components/mega/hub.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index c192eb9..5ee5c3d 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -71,6 +71,7 @@ class MegaD:
         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,
@@ -176,7 +177,7 @@ class MegaD:
                 qos=2,
                 retain=False,
             )
-            await asyncio.wait_for(self.cnd.wait(), timeout=15)
+            await asyncio.wait_for(self.cnd.wait_for(lambda: self.last_port == port), timeout=15)
 
     async def get_all_ports(self):
         for x in range(37):
@@ -189,7 +190,8 @@ class MegaD:
         async with self.cnd:
             self.last_update = datetime.now()
             self.values[port] = value
-            self.cnd.notify()
+            self.last_port = port
+            self.cnd.notify_all()
 
     def _process_msg(self, msg):
         try:

From 811f2067bb5612c418927e6e05b95474a7796861 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 12:20:16 +0300
Subject: [PATCH 12/37] fix save_all service

---
 custom_components/mega/__init__.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/custom_components/mega/__init__.py b/custom_components/mega/__init__.py
index 55f3fa6..9e3ea4b 100644
--- a/custom_components/mega/__init__.py
+++ b/custom_components/mega/__init__.py
@@ -169,7 +169,8 @@ async def _save_service(hass: HomeAssistant, call: ServiceCall):
         await hub.save()
     else:
         for hub in hass.data[DOMAIN].values():
-            await hub.save()
+            if isinstance(hub, MegaD):
+                await hub.save()
 
 
 @bind_hass

From ed6a86a721a98dc607e3b01834e6b153fd7e94e4 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 12:24:38 +0300
Subject: [PATCH 13/37] add name cusomisation for multiple sensors

---
 custom_components/mega/__init__.py | 4 +++-
 custom_components/mega/sensor.py   | 6 ++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/custom_components/mega/__init__.py b/custom_components/mega/__init__.py
index 9e3ea4b..22dd59d 100644
--- a/custom_components/mega/__init__.py
+++ b/custom_components/mega/__init__.py
@@ -26,7 +26,9 @@ CONFIG_SCHEMA = vol.Schema(
                 vol.Optional(int, description='номер порта'): {
                     vol.Optional(CONF_SKIP, description='исключить порт из сканирования', default=False): bool,
                     vol.Optional(CONF_INVERT, default=False): bool,
-                    vol.Optional(CONF_NAME): str,
+                    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, {
diff --git a/custom_components/mega/sensor.py b/custom_components/mega/sensor.py
index b20a6c9..aea6c7f 100644
--- a/custom_components/mega/sensor.py
+++ b/custom_components/mega/sensor.py
@@ -154,3 +154,9 @@ class Mega1WSensor(MegaPushEntity):
 
     def _update(self, payload: dict):
         self.mega.values[self.port] = payload
+
+    @property
+    def name(self):
+        n = super().name
+        c = self.customize.get(CONF_NAME, {}).get(self.key)
+        return c or n
\ No newline at end of file

From b5e4b2c8023112faecc6cd584243e0329530ced9 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 12:27:07 +0300
Subject: [PATCH 14/37] add name cusomisation for multiple sensors

---
 custom_components/mega/entities.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/custom_components/mega/entities.py b/custom_components/mega/entities.py
index bf2567e..e8b752c 100644
--- a/custom_components/mega/entities.py
+++ b/custom_components/mega/entities.py
@@ -76,7 +76,10 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
 
     @property
     def name(self):
-        return self.customize.get(CONF_NAME) or 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):

From e0b4fec0cac9046128d1b7de5f17320e8e683ee3 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 12:28:04 +0300
Subject: [PATCH 15/37] add name cusomisation for multiple sensors

---
 readme.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 01f1f09..07ac21d 100644
--- a/readme.md
+++ b/readme.md
@@ -54,7 +54,9 @@ mega:
     33:
       # для датчиков можно кастомизировать только имя и unit_of_measurement
       # для температуры и влажность unit определяется автоматически, для остальных юнита нет 
-      name: какой-то датчик
+      name:
+        hum: "влажность"
+        temp: "температура"
       unit_of_measurement:
         hum: "%" # если датчиков несколько, то можно указывать юниты по их ключам
         temp: "°C"

From 4e2d659c44b9e658d8a8009006499ddd532fbb9f Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Fri, 22 Jan 2021 21:32:55 +0300
Subject: [PATCH 16/37] fix mid

---
 custom_components/mega/hub.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index 5ee5c3d..0f62a7d 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -195,7 +195,8 @@ class MegaD:
 
     def _process_msg(self, msg):
         try:
-            _, port = msg.topic.split('/')
+            d = msg.topic.split('/')
+            port = d[-1]
         except ValueError:
             self.lg.warning('can not process %s', msg)
             return

From 18d0aee391c1e9bb4c2c84c37bfb2c86fd4fbe46 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Sat, 23 Jan 2021 21:08:33 +0300
Subject: [PATCH 17/37] small fix

---
 custom_components/mega/hub.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index 0f62a7d..5ac7247 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -177,7 +177,8 @@ class MegaD:
                 qos=2,
                 retain=False,
             )
-            await asyncio.wait_for(self.cnd.wait_for(lambda: self.last_port == port), timeout=15)
+            await asyncio.wait_for(self.cnd.wait(), timeout=15)
+            await asyncio.sleep(0.05)
 
     async def get_all_ports(self):
         for x in range(37):

From 876a1f0cc83bca9549487b2ce78ab1194c5921be Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Sun, 24 Jan 2021 11:17:09 +0300
Subject: [PATCH 18/37] get port one more fix

---
 custom_components/mega/entities.py |  3 ++-
 custom_components/mega/hub.py      | 36 +++++++++++++++++-------------
 2 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/custom_components/mega/entities.py b/custom_components/mega/entities.py
index e8b752c..b5879c6 100644
--- a/custom_components/mega/entities.py
+++ b/custom_components/mega/entities.py
@@ -1,4 +1,5 @@
 import logging
+import asyncio
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_NAME
 from homeassistant.core import State
@@ -113,7 +114,7 @@ class MegaPushEntity(BaseMegaEntity):
 
     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))
+        asyncio.create_task(self.mega.get_port(self.port))
 
 
 class MegaOutPort(MegaPushEntity):
diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index 5ac7247..c945914 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -58,6 +58,7 @@ class MegaD:
         self.mqtt = mqtt
         self.id = id
         self.lck = asyncio.Lock()
+        self._notif_lck = asyncio.Lock()
         self.cnd = asyncio.Condition()
         self.online = True
         self.entities: typing.List[Entity] = []
@@ -79,6 +80,7 @@ class MegaD:
             update_method=self.poll,
             update_interval=timedelta(seconds=self.poll_interval) if self.poll_interval else None,
         )
+        self.notifiers = defaultdict(asyncio.Condition)
         if not mqtt_id:
             _id = host.split(".")[-1]
             self.mqtt_id = f"megad/{_id}"
@@ -170,15 +172,21 @@ class MegaD:
 
     async def get_port(self, port):
         """Запрос состояния порта. Блокируется пока не придет какое-нибудь сообщение от меги или таймаут"""
-        async with self.cnd:
-            await self.mqtt.async_publish(
-                topic=f'{self.mqtt_id}/cmd',
-                payload=f'get:{port}',
-                qos=2,
-                retain=False,
-            )
-            await asyncio.wait_for(self.cnd.wait(), timeout=15)
-            await asyncio.sleep(0.05)
+        self.lg.debug(f'get port %s', port)
+        async with self._notif_lck:
+            async with self.notifiers[port]:
+                cnd = self.notifiers[port]
+                await self.mqtt.async_publish(
+                    topic=f'{self.mqtt_id}/cmd',
+                    payload=f'get:{port}',
+                    qos=2,
+                    retain=False,
+                )
+                try:
+                    await asyncio.wait_for(cnd.wait(), timeout=10)
+                    return self.values[port]
+                except asyncio.TimeoutError:
+                    self.lg.error(f'timeout when getting port {port}')
 
     async def get_all_ports(self):
         for x in range(37):
@@ -188,11 +196,10 @@ class MegaD:
         await self.save()
 
     async def _notify(self, port, value):
-        async with self.cnd:
-            self.last_update = datetime.now()
+        async with self.notifiers[port]:
+            cnd = self.notifiers[port]
             self.values[port] = value
-            self.last_port = port
-            self.cnd.notify_all()
+            cnd.notify_all()
 
     def _process_msg(self, msg):
         try:
@@ -294,8 +301,7 @@ class MegaD:
                 ret['light'][port].append({'dimmer': m == '1'})
             elif pty == '3':
                 try:
-                    await self.get_port(port)
-                    values = self.values.get(port)
+                    values = await self.get_port(port)
                 except asyncio.TimeoutError:
                     self.lg.warning(f'timout on port {port}')
                     continue

From 8bbb4ab271c106d907ee5a7573363dbf29a41eaf Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 12:25:11 +0300
Subject: [PATCH 19/37] add http support

---
 custom_components/mega/__init__.py          |  37 +++++--
 custom_components/mega/binary_sensor.py     |  23 ++--
 custom_components/mega/config_flow.py       |  15 ++-
 custom_components/mega/const.py             |  11 +-
 custom_components/mega/entities.py          |  66 +++++++-----
 custom_components/mega/http.py              |  95 +++++++++++++++++
 custom_components/mega/hub.py               | 112 +++++++++++++++-----
 custom_components/mega/manifest.json        |   4 +-
 custom_components/mega/sensor.py            |   4 -
 custom_components/mega/strings.json         |   9 +-
 custom_components/mega/translations/en.json |  11 +-
 custom_components/mega/translations/ru.json |  10 +-
 readme.md                                   |  83 +++++++++++----
 13 files changed, 361 insertions(+), 119 deletions(-)
 create mode 100644 custom_components/mega/http.py

diff --git a/custom_components/mega/__init__.py b/custom_components/mega/__init__.py
index 22dd59d..d1d824d 100644
--- a/custom_components/mega/__init__.py
+++ b/custom_components/mega/__init__.py
@@ -4,18 +4,22 @@ import logging
 from functools import partial
 
 import voluptuous as vol
+
 from homeassistant.const import (
     CONF_SCAN_INTERVAL, CONF_ID, CONF_NAME, CONF_DOMAIN,
-    CONF_UNIT_OF_MEASUREMENT,
+    CONF_UNIT_OF_MEASUREMENT, CONF_HOST
 )
 from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers.service import bind_hass
+from homeassistant.helpers.template import Template
+from homeassistant.helpers import config_validation as cv
 from homeassistant.components import mqtt
 from homeassistant.config_entries import ConfigEntry
-from .const import DOMAIN, CONF_INVERT, CONF_RELOAD, PLATFORMS, CONF_PORTS, CONF_CUSTOM, CONF_SKIP, CONF_PORT_TO_SCAN
+from .const import DOMAIN, CONF_INVERT, CONF_RELOAD, PLATFORMS, CONF_PORTS, CONF_CUSTOM, CONF_SKIP, CONF_PORT_TO_SCAN, \
+    CONF_MQTT_INPUTS, CONF_HTTP, CONF_RESPONSE_TEMPLATE, CONF_ACTION, CONF_GET_VALUE
 from .hub import MegaD
 from .config_flow import ConfigFlow
-
+from .http import MegaView
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -34,6 +38,12 @@ CONFIG_SCHEMA = vol.Schema(
                         vol.Any(str, {
                             vol.Required(str): str
                         }),
+                    vol.Optional(
+                        CONF_RESPONSE_TEMPLATE,
+                        description='шаблон ответа когда на этот порт приходит'
+                                    'сообщение из меги '): cv.template,
+                    vol.Optional(CONF_ACTION): cv.script_action,
+                    vol.Optional(CONF_GET_VALUE, default=True): bool,
                 }
             }
         }
@@ -51,7 +61,8 @@ _subs = {}
 async def async_setup(hass: HomeAssistant, config: dict):
     """YAML-конфигурация содержит только кастомизации портов"""
     hass.data[DOMAIN] = {CONF_CUSTOM: config.get(DOMAIN, {})}
-
+    hass.data[DOMAIN][CONF_HTTP] = view = MegaView(cfg=config.get(DOMAIN, {}))
+    hass.http.register_view(view)
     hass.services.async_register(
         DOMAIN, 'save', partial(_save_service, hass), schema=vol.Schema({
             vol.Optional('mega_id'): str
@@ -70,6 +81,7 @@ async def async_setup(hass: HomeAssistant, config: dict):
             vol.Optional('mega_id'): str,
         })
     )
+
     return True
 
 
@@ -78,9 +90,17 @@ async def get_hub(hass, entry):
     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')
+    use_mqtt = data.get(CONF_MQTT_INPUTS, True)
+
+    _mqtt = hass.data.get(mqtt.DOMAIN) if use_mqtt else None
+    if _mqtt is None and use_mqtt:
+        for x in range(5):
+            await asyncio.sleep(5)
+            _mqtt = hass.data.get(mqtt.DOMAIN)
+            if _mqtt is not None:
+                break
+        if _mqtt is None:
+            raise Exception('mqtt not configured, please configure mqtt first')
     hub = MegaD(hass, **data, mqtt=_mqtt, lg=_LOGGER, loop=asyncio.get_event_loop())
     hub.mqtt_id = await hub.get_mqtt_id()
     return hub
@@ -89,7 +109,8 @@ async def get_hub(hass, entry):
 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
+    hass.data[DOMAIN][id] = hass.data[DOMAIN]['__def'] = hub
+    hass.data[DOMAIN][entry.data.get(CONF_HOST)] = hub
     if not await hub.authenticate():
         raise Exception("not authentificated")
     mid = await hub.get_mqtt_id()
diff --git a/custom_components/mega/binary_sensor.py b/custom_components/mega/binary_sensor.py
index 5999261..39607be 100644
--- a/custom_components/mega/binary_sensor.py
+++ b/custom_components/mega/binary_sensor.py
@@ -73,20 +73,13 @@ class MegaBinarySensor(BinarySensorEntity, MegaPushEntity):
 
     @property
     def is_on(self) -> bool:
-        if self._is_on is not None:
-            return self._is_on
-        return self._state == 'ON'
+        val = self.mega.values.get(self.port, {}).get("value") \
+              or self.mega.values.get(self.port, {}).get('m')
+        if val is None and self._state is not None:
+            return self._state == 'ON'
+        elif val is not None:
+            return val == 'ON' or val == 1
 
     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
+        self.mega.values[self.port] = payload
+
diff --git a/custom_components/mega/config_flow.py b/custom_components/mega/config_flow.py
index 9717cd9..44964d4 100644
--- a/custom_components/mega/config_flow.py
+++ b/custom_components/mega/config_flow.py
@@ -9,7 +9,8 @@ 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, HomeAssistant
-from .const import DOMAIN, CONF_PORT_TO_SCAN, CONF_RELOAD, PLATFORMS  # pylint:disable=unused-import
+from .const import DOMAIN, CONF_PORT_TO_SCAN, CONF_RELOAD, PLATFORMS, CONF_MQTT_INPUTS, \
+    CONF_NPORTS, CONF_UPDATE_ALL  # pylint:disable=unused-import
 from .hub import MegaD
 from . import exceptions
 
@@ -22,6 +23,9 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         vol.Required(CONF_PASSWORD, default="sec"): str,
         vol.Optional(CONF_SCAN_INTERVAL, default=0): int,
         vol.Optional(CONF_PORT_TO_SCAN, default=0): int,
+        vol.Optional(CONF_MQTT_INPUTS, default=True): bool,
+        vol.Optional(CONF_NPORTS, default=37): int,
+        vol.Optional(CONF_UPDATE_ALL, default=True): bool,
     },
 )
 
@@ -52,7 +56,7 @@ async def validate_input(hass: core.HomeAssistant, data):
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for mega."""
 
-    VERSION = 3
+    VERSION = 4
     CONNECTION_CLASS = config_entries.CONN_CLASS_ASSUMED
 
     async def async_step_user(self, user_input=None):
@@ -67,7 +71,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
         try:
             hub = await validate_input(self.hass, user_input)
             await hub.start()
-            config = await hub.get_config()
+            config = await hub.get_config(nports=user_input.get(CONF_NPORTS, 37))
             await hub.stop()
             hub.lg.debug(f'config loaded: %s', config)
             config.update(user_input)
@@ -110,7 +114,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
             hub = await get_hub(self.hass, self.config_entry.data)
             if reload:
                 await hub.start()
-                new = await hub.get_config()
+                new = await hub.get_config(nports=user_input.get(CONF_NPORTS, 37))
                 await hub.stop()
 
                 _LOGGER.debug(f'new config: %s', new)
@@ -128,7 +132,10 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
             data_schema=vol.Schema({
                 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_MQTT_INPUTS, default=e.get(CONF_MQTT_INPUTS, True)): bool,
+                vol.Optional(CONF_NPORTS, default=e.get(CONF_NPORTS, 37)): int,
                 vol.Optional(CONF_RELOAD, default=False): bool,
+                # vol.Optional(CONF_UPDATE_ALL, default=e.get(CONF_UPDATE_ALL, True)): bool,
                 # vol.Optional(CONF_INVERT, default=''): str,
             }),
         )
diff --git a/custom_components/mega/const.py b/custom_components/mega/const.py
index 60951cd..3b0a313 100644
--- a/custom_components/mega/const.py
+++ b/custom_components/mega/const.py
@@ -1,4 +1,5 @@
 """Constants for the mega integration."""
+import re
 
 DOMAIN = "mega"
 CONF_MEGA_ID = "mega_id"
@@ -14,11 +15,19 @@ CONF_RELOAD = 'reload'
 CONF_INVERT = 'invert'
 CONF_PORTS = 'ports'
 CONF_CUSTOM = '__custom'
+CONF_HTTP = '__http'
 CONF_SKIP = 'skip'
+CONF_MQTT_INPUTS = 'mqtt_inputs'
+CONF_NPORTS = 'nports'
+CONF_RESPONSE_TEMPLATE = 'response_template'
+CONF_ACTION = 'action'
+CONF_UPDATE_ALL = 'update_all'
+CONF_GET_VALUE = 'get_value'
 PLATFORMS = [
     "light",
     "switch",
     "binary_sensor",
     "sensor",
 ]
-EVENT_BINARY_SENSOR = f'{DOMAIN}.sensor'
\ No newline at end of file
+EVENT_BINARY_SENSOR = f'{DOMAIN}.sensor'
+PATT_SPLIT = re.compile('[;/]')
\ No newline at end of file
diff --git a/custom_components/mega/entities.py b/custom_components/mega/entities.py
index b5879c6..a263a56 100644
--- a/custom_components/mega/entities.py
+++ b/custom_components/mega/entities.py
@@ -29,6 +29,7 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
         self.port = port
         self.config_entry = config_entry
         self.mega = mega
+        mega.entities.append(self)
         self._mega_id = mega.id
         self._lg = None
         self._unique_id = unique_id or f"mega_{mega.id}_{port}" + \
@@ -90,6 +91,10 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
         await super().async_added_to_hass()
         self._state = await self.async_get_last_state()
 
+    async def get_state(self):
+        if self.mega.mqtt is None:
+            self.async_write_ha_state()
+
 
 class MegaPushEntity(BaseMegaEntity):
 
@@ -114,7 +119,8 @@ class MegaPushEntity(BaseMegaEntity):
 
     async def async_added_to_hass(self) -> None:
         await super().async_added_to_hass()
-        asyncio.create_task(self.mega.get_port(self.port))
+        if self.mega.mqtt is not None:
+            asyncio.create_task(self.mega.get_port(self.port))
 
 
 class MegaOutPort(MegaPushEntity):
@@ -137,16 +143,26 @@ class MegaOutPort(MegaPushEntity):
 
     @property
     def brightness(self):
-        if self._brightness is not None:
-            return self._brightness
-        if self._state:
+        val = self.mega.values.get(self.port, {}).get("value")
+        if val is None and self._state is not None:
             return self._state.attributes.get("brightness")
+        elif val is not None:
+            try:
+                val = int(val)
+                return val
+            except Exception:
+                pass
 
     @property
     def is_on(self) -> bool:
-        if self._is_on is not None:
-            return self._is_on
-        return self._state == 'ON'
+        val = self.mega.values.get(self.port, {}).get("value")
+        if val is None and self._state is not None:
+            return self._state == 'ON'
+        elif val is not None:
+            if not self.invert:
+                return val == 'ON' or str(val) == '1' or (safe_int(val) is not None and safe_int(val) > 0)
+            else:
+                return val == 'OFF' or str(val) == '0' or (safe_int(val) is not None and safe_int(val) == 0)
 
     async def async_turn_on(self, brightness=None, **kwargs) -> None:
         brightness = brightness or self.brightness or 255
@@ -157,31 +173,23 @@ class MegaOutPort(MegaPushEntity):
             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()
+        await self.mega.send_command(self.port, f"{self.port}:{cmd}")
+        self.mega.values[self.port] = {'value': cmd}
+        await self.get_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()
+        await self.mega.send_command(self.port, f"{self.port}:{cmd}")
+        self.mega.values[self.port] = {'value': cmd}
+        await self.get_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'
\ No newline at end of file
+def safe_int(v):
+    if v in ['ON', 'OFF']:
+        return None
+    try:
+        return int(v)
+    except ValueError:
+        return None
\ No newline at end of file
diff --git a/custom_components/mega/http.py b/custom_components/mega/http.py
new file mode 100644
index 0000000..9db655d
--- /dev/null
+++ b/custom_components/mega/http.py
@@ -0,0 +1,95 @@
+import asyncio
+import logging
+
+import typing
+from collections import defaultdict
+
+from aiohttp.web_request import Request
+from aiohttp.web_response import Response
+
+from homeassistant.helpers.template import Template
+from .const import EVENT_BINARY_SENSOR, CONF_HTTP, DOMAIN, CONF_CUSTOM, CONF_RESPONSE_TEMPLATE
+from homeassistant.components.http import HomeAssistantView
+from homeassistant.core import callback, HomeAssistant
+from . import hub
+
+_LOGGER = logging.getLogger(__name__).getChild('http')
+
+
+class MegaView(HomeAssistantView):
+    """Handle Yandex Smart Home unauthorized requests."""
+
+    url = '/mega'
+    name = 'mega'
+    requires_auth = False
+
+    def __init__(self, cfg: dict):
+        self._try = 0
+        self.allowed_hosts = {'::1'}
+        self.callbacks: typing.DefaultDict[int, typing.List[typing.Callable[[dict], typing.Coroutine]]] \
+            = defaultdict(list)
+        self.templates: typing.Dict[str, typing.Dict[str, Template]] = {
+            mid: {
+                pt: cfg[mid][pt][CONF_RESPONSE_TEMPLATE]
+                for pt in cfg[mid]
+                if CONF_RESPONSE_TEMPLATE in cfg[mid][pt]
+            } for mid in cfg
+        }
+        _LOGGER.debug('templates: %s', self.templates)
+
+    async def get(self, request: Request) -> Response:
+        auth = False
+        for x in self.allowed_hosts:
+            if request.remote.startswith(x):
+                auth = True
+                break
+        if not auth:
+            _LOGGER.warning(f'unauthorised attempt to connect from {request.remote}')
+            return Response(status=401)
+
+        hass: HomeAssistant = request.app['hass']
+        hub: 'hub.MegaD' = hass.data.get(DOMAIN).get(request.remote)  # TODO: проверить какой remote
+        if hub is None and request.remote == '::1':
+            hub = hass.data.get(DOMAIN).get('__def')
+        if hub is None:
+            return Response(status=400)
+        data = dict(request.query)
+        hass.bus.async_fire(
+            EVENT_BINARY_SENSOR,
+            data,
+        )
+        _LOGGER.debug(f"Request: %s from '%s'", data, request.remote)
+        make_ints(data)
+        port = data.get('pt')
+        data = data.copy()
+        ret = 'd'
+        if port is not None:
+            for cb in self.callbacks[port]:
+                cb(data)
+            template: Template = self.templates.get(hub.id, {}).get(port)
+            if hub.update_all:
+                asyncio.create_task(self.later_update(hub))
+            if template is not None:
+                template.hass = hass
+                ret = template.async_render(data)
+        _LOGGER.debug('response %s', ret)
+        ret = Response(body=ret or 'd', content_type='text/plain', headers={})
+        ret.headers.clear()
+        return ret
+
+    async def later_update(self, hub):
+        _LOGGER.debug('force update')
+        await asyncio.sleep(1)
+        await hub.updater.async_refresh()
+
+
+def make_ints(d: dict):
+    for x in d:
+        try:
+            d[x] = float(d[x])
+        except ValueError:
+            pass
+    if 'm' not in d:
+        d['m'] = 0
+    if 'click' not in d:
+        d['click'] = 0
\ No newline at end of file
diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index c945914..9fb0f78 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -14,8 +14,9 @@ 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
+from .const import TEMP, HUM, PATT_SPLIT, DOMAIN, CONF_HTTP
+from .exceptions import CannotConnect, MqttNotConfigured
+from .http import MegaView
 
 TEMP_PATT = re.compile(r'temp:([01234567890\.]+)')
 HUM_PATT = re.compile(r'hum:([01234567890\.]+)')
@@ -32,6 +33,10 @@ CLASSES = {
     HUM: DEVICE_CLASS_HUMIDITY
 }
 
+class NoPort(Exception):
+    pass
+
+
 class MegaD:
     """MegaD Hub"""
 
@@ -44,13 +49,24 @@ class MegaD:
             mqtt: mqtt.MQTT,
             lg: logging.Logger,
             id: str,
+            mqtt_inputs: bool = True,
             mqtt_id: str = None,
             scan_interval=60,
             port_to_scan=0,
+            nports=38,
             inverted: typing.List[int] = None,
+            update_all=True,
             **kwargs,
     ):
         """Initialize."""
+        if mqtt_inputs is None or mqtt_inputs == 'None' or mqtt_inputs is False:
+            self.http = hass.data[DOMAIN][CONF_HTTP]
+            self.http.allowed_hosts |= {host}
+        else:
+            self.http = None
+        self.update_all = update_all if update_all is not None else True
+        self.nports = nports
+        self.mqtt_inputs = mqtt_inputs
         self.loop: asyncio.AbstractEventLoop = None
         self.hass = hass
         self.host = host
@@ -58,6 +74,7 @@ class MegaD:
         self.mqtt = mqtt
         self.id = id
         self.lck = asyncio.Lock()
+        self._http_lck = asyncio.Lock()
         self._notif_lck = asyncio.Lock()
         self.cnd = asyncio.Condition()
         self.online = True
@@ -89,14 +106,16 @@ class MegaD:
 
     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,
-        )
+        if self.mqtt is not None:
+            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()
+        if self.subs is not None:
+            self.subs()
         for x in self._callbacks.values():
             x.clear()
 
@@ -136,6 +155,9 @@ class MegaD:
         offline
         """
         self.lg.debug('poll')
+        if self.mqtt is None:
+            await self.get_all_ports()
+            return
         if len(self.sensors) > 0:
             await self.get_sensors()
         else:
@@ -154,25 +176,51 @@ class MegaD:
             return _id or 'megad/' + self.host.split('.')[-1]
 
     async def send_command(self, port=None, cmd=None):
-        if port:
-            url = f"http://{self.host}/{self.sec}/?pt={port}&cmd={cmd}"
-        else:
-            url = f"http://{self.host}/{self.sec}/?cmd={cmd}"
-        self.lg.debug('run command: %s', url)
-        async with self.lck:
+        return await self.request(pt=port, cmd=cmd)
+
+    async def request(self, **kwargs):
+        cmd = '&'.join([f'{k}={v}' for k, v in kwargs.items() if v is not None])
+        url = f"http://{self.host}/{self.sec}/?{cmd}"
+        self.lg.debug('request: %s', url)
+        async with self._http_lck:
             async with aiohttp.request("get", url=url) as req:
                 if req.status != 200:
                     self.lg.warning('%s returned %s (%s)', url, req.status, await req.text())
-                    return False
+                    return None
                 else:
-                    return True
+                    return await req.text()
 
     async def save(self):
         await self.send_command(cmd='s')
 
+    def parse_response(self, ret):
+        if ret is None:
+            raise NoPort()
+        if ':' in ret:
+            ret = PATT_SPLIT.split(ret)
+            ret = dict([
+                x.split(':') for x in ret if x.count(':') == 1
+            ])
+        elif 'ON' in ret:
+            ret = {'value': 'ON'}
+        elif 'OFF' in ret:
+            ret = {'value': 'OFF'}
+        else:
+            ret = {'value': ret}
+        return ret
+
     async def get_port(self, port):
-        """Запрос состояния порта. Блокируется пока не придет какое-нибудь сообщение от меги или таймаут"""
+        """
+        Запрос состояния порта. Состояние всегда возвращается в виде объекта, всегда сохраняется в центральное
+        хранилище values
+        """
         self.lg.debug(f'get port %s', port)
+        if self.mqtt is None:
+            ret = await self.request(pt=port, cmd='get')
+            ret = self.parse_response(ret)
+            self.values[port] = ret
+            return ret
+
         async with self._notif_lck:
             async with self.notifiers[port]:
                 cnd = self.notifiers[port]
@@ -184,13 +232,19 @@ class MegaD:
                 )
                 try:
                     await asyncio.wait_for(cnd.wait(), timeout=10)
-                    return self.values[port]
+                    return self.values.get(port)
                 except asyncio.TimeoutError:
                     self.lg.error(f'timeout when getting port {port}')
 
     async def get_all_ports(self):
-        for x in range(37):
-            await self.get_port(x)
+        if not self.mqtt_inputs:
+            ret = await self.request(cmd='all')
+            for port, x in enumerate(ret.split(';')):
+                ret = self.parse_response(x)
+                self.values[port] = ret
+        else:
+            for x in range(self.nports + 1):
+                await self.get_port(x)
 
     async def reboot(self, save=True):
         await self.save()
@@ -198,7 +252,6 @@ class MegaD:
     async def _notify(self, port, value):
         async with self.notifiers[port]:
             cnd = self.notifiers[port]
-            self.values[port] = value
             cnd.notify_all()
 
     def _process_msg(self, msg):
@@ -222,6 +275,7 @@ class MegaD:
         value = None
         try:
             value = json.loads(msg.payload)
+            self.values[port] = value
             for cb in self._callbacks[port]:
                 cb(value)
         except Exception as exc:
@@ -235,7 +289,10 @@ class MegaD:
         self.lg.debug(
             f'subscribe %s %s', port, callback
         )
-        self._callbacks[port].append(callback)
+        if self.mqtt_inputs:
+            self._callbacks[port].append(callback)
+        else:
+            self.http.callbacks[port].append(callback)
 
     async def authenticate(self) -> bool:
         """Test if we can authenticate with the host."""
@@ -263,6 +320,8 @@ class MegaD:
             )
             async with aiohttp.request('get', url) as req:
                 html = await req.text()
+                if req.status != 200:
+                    return
             tree = BeautifulSoup(html, features="lxml")
             pty = tree.find('select', attrs={'name': 'pty'})
             if pty is None:
@@ -286,15 +345,16 @@ class MegaD:
                 self._scanned[port] = (pty, m)
                 return pty, m
 
-    async def scan_ports(self,):
-        for x in range(38):
+    async def scan_ports(self, nports=37):
+        for x in range(nports+1):
             ret = await self.scan_port(x)
             if ret:
                 yield [x, *ret]
+        self.nports = nports+1
 
-    async def get_config(self):
+    async def get_config(self, nports=37):
         ret = defaultdict(lambda: defaultdict(list))
-        async for port, pty, m in self.scan_ports():
+        async for port, pty, m in self.scan_ports(nports):
             if pty == "0":
                 ret['binary_sensor'][port].append({})
             elif pty == "1" and m in ['0', '1']:
diff --git a/custom_components/mega/manifest.json b/custom_components/mega/manifest.json
index ab1ad32..09c225b 100644
--- a/custom_components/mega/manifest.json
+++ b/custom_components/mega/manifest.json
@@ -10,9 +10,7 @@
   "ssdp": [],
   "zeroconf": [],
   "homekit": {},
-  "dependencies": [
-    "mqtt"
-  ],
+  "dependencies": [],
   "codeowners": [
     "@andvikt"
   ],
diff --git a/custom_components/mega/sensor.py b/custom_components/mega/sensor.py
index aea6c7f..93888f1 100644
--- a/custom_components/mega/sensor.py
+++ b/custom_components/mega/sensor.py
@@ -111,7 +111,6 @@ class Mega1WSensor(MegaPushEntity):
         :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._device_class = device_class
@@ -152,9 +151,6 @@ class Mega1WSensor(MegaPushEntity):
             ret = self._state.state
         return ret
 
-    def _update(self, payload: dict):
-        self.mega.values[self.port] = payload
-
     @property
     def name(self):
         n = super().name
diff --git a/custom_components/mega/strings.json b/custom_components/mega/strings.json
index 1388da7..7f08693 100644
--- a/custom_components/mega/strings.json
+++ b/custom_components/mega/strings.json
@@ -11,7 +11,10 @@
           "mqtt_id": "[%key:common::config_flow::data::mqtt_id%]",
           "scan_interval": "[%key:common::config_flow::data::mqtt_id%]",
           "port_to_scan": "[%key:common::config_flow::data::port_to_scan%]",
-          "invert": "[%key:common::config_flow::data::invert%]"
+          "invert": "[%key:common::config_flow::data::invert%]",
+          "mqtt_inputs": "[%key:common::config_flow::data::mqtt_inputs%]",
+          "nports": "[%key:common::config_flow::data::nports%]",
+          "update_all": "[%key:common::config_flow::data::update_all%]"
         }
       }
     },
@@ -32,7 +35,9 @@
           "scan_interval": "[%key:common::config_flow::data::scan_interval%]",
           "port_to_scan": "[%key:common::config_flow::data::port_to_scan%]",
           "reload": "[%key:common::config_flow::data::reload%]",
-          "invert": "[%key:common::config_flow::data::invert%]"
+          "invert": "[%key:common::config_flow::data::invert%]",
+          "mqtt_inputs": "[%key:common::config_flow::data::mqtt_inputs%]",
+          "nports": "[%key:common::config_flow::data::nports%]"
         }
       }
     }
diff --git a/custom_components/mega/translations/en.json b/custom_components/mega/translations/en.json
index 8839518..06e2a22 100644
--- a/custom_components/mega/translations/en.json
+++ b/custom_components/mega/translations/en.json
@@ -7,7 +7,8 @@
             "cannot_connect": "Failed to connect",
             "invalid_auth": "Invalid authentication",
             "unknown": "Unexpected error",
-            "duplicate_id": "Duplicate ID"
+            "duplicate_id": "Duplicate ID",
+            "mqtt_inputs": "Use MQTT"
         },
         "step": {
             "user": {
@@ -18,7 +19,9 @@
                     "id": "ID",
                     "mqtt_id": "MQTT id",
                     "scan_interval": "Scan interval (sec), 0 - don't update",
-                    "port_to_scan": "Port to poll aliveness (needed only if no sensors used)"
+                    "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
+                    "nports": "Number of ports",
+                    "update_all": "Update all outs when input"
                 }
             }
         }
@@ -29,7 +32,9 @@
                 "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"
+                  "reload": "Reload objects",
+                  "mqtt_inputs": "Use MQTT",
+                  "update_all": "Update all outs when input"
                 }
             }
         }
diff --git a/custom_components/mega/translations/ru.json b/custom_components/mega/translations/ru.json
index 07313be..9eb0033 100644
--- a/custom_components/mega/translations/ru.json
+++ b/custom_components/mega/translations/ru.json
@@ -18,7 +18,10 @@
                     "id": "ID",
                     "mqtt_id": "MQTT id",
                     "scan_interval": "Периодичность обновлений (сек.), 0 - не обновлять",
-                    "port_to_scan": "Порт, который сканируется когда нет датчиков"
+                    "port_to_scan": "Порт, который сканируется когда нет датчиков",
+                    "mqtt_inputs": "Использовать MQTT",
+                    "nports": "Кол-во портов",
+                    "update_all": "Обновить все выходы когда срабатывает вход"
                 }
             }
         }
@@ -30,7 +33,10 @@
                   "scan_interval": "Периодичность обновлений (сек.), 0 - не обновлять",
                   "port_to_scan": "Порт, который сканируется когда нет датчиков",
                   "reload": "Обновить объекты",
-                  "invert": "Список портов (через ,) с инвертированной логикой"
+                  "invert": "Список портов (через ,) с инвертированной логикой",
+                  "mqtt_inputs": "Использовать MQTT",
+                    "nports": "Кол-во портов",
+                    "update_all": "Обновить все выходы когда срабатывает вход"
                 }
             }
         }
diff --git a/readme.md b/readme.md
index 07ac21d..f0461dd 100644
--- a/readme.md
+++ b/readme.md
@@ -8,18 +8,71 @@
   `light`, для шим - `light` с поддержкой яркости, для цифровых входов `binary_sensor`, для датчиков
   `sensor`)
 - Возможность работы с несколькими megad
-- Обратная связь по mqtt
+- Обратная связь по mqtt или http (на выбор)
 - События на двойные/долгие нажатия
 - Команды выполняются друг за другом без конкурентного доступа к ресурсам megad, это дает гарантии надежного исполнения
   большого кол-ва команд (например в сценах). Каждая следующая команда отправляется только после получения ответа о
   выполнении предыдущей.
 
 ## Зависимости
-**Важно!!** Перед использованием необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
-в HomeAssistant
+**Важно!!** Для максимальной совместимости необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
+в HomeAssistant, а так же обновить ваш контроллер до последней версии, тк были важные обновления в части mqtt
 
-Для максимальной совместимости необходимо обновить ваш контроллер до последней версии, тк были важные обновления в части
-mqtt
+## HTTP in
+Начиная с версии `0.3.1` интеграция стала поддерживать обратную связь без mqtt, используя http-сервер. Для этого в настройках
+интеграции необходимо снять галку с `использовать mqtt`
+
+В самой меге необходимо прописать настройки:
+```yaml
+srv: "192.168.1.4:8123" # ip:port вашего HA
+script: "mega" # это api интеграции, к которому будет обращаться контроллер
+```
+
+Входы будут доступны как binary_sensor, а так же в виде событий `mega.sensor`.
+События можно обрабатывать так:
+```yaml
+- alias: some double click
+  trigger:
+    - platform: event
+      event_type: mega.sensor
+      event_data:
+        pt: 1
+  action:
+    - service: light.toggle
+      entity_id: light.some_light
+```
+Для binary_sensor имеет смысл использовать режим P&R, для остальных режимов - лучше пользоваться событиями.
+
+## Ответ на входящие события от контроллера
+Контроллер ожидает ответ от сервера, который может быть сценарием (по умолчанию интеграция отвечает `d`, что означает 
+запустить то что прописано в поле act в настройках порта).
+
+Поддерживаеются шаблоны HA. Это может быть использовано, например, для запоминания яркости (тк сам контроллер этого не 
+умеет). В шаблоне можно использовать параметры, которые передает контроллер (m, click, pt, value)
+
+Примеры:
+```yaml
+mega:
+  mega1: # id меги, который вы сами придумываете в конфиге в UI
+    4: # номер порта, с которого ожидаются события
+      response_template: 5:2 # простейший пример без шаблона. Каждый раз когда будет приходить сообщение на этот порт, 
+                             # будем менять состояние на противоположное
+    5:
+      # пример с использованием шаблона, порт 1 будет выключен если он сейчас включен и включен с последней сохраненной 
+      # яркостью если он сейчас выключен     
+      response_template: >-
+        {% if is_state('light.some_port_1', 'on') %}
+        1:0
+        {% else %}
+        1:{{state_attr('light.some_port_1', 'brightness')}}
+        {% endif %}
+    6:
+      # в шаблон так же передаются все параметры, которые передает контроллер (pt, cnt, m, click)
+      # эти параметры можно использовать в условиях или непосредственно в шаблоне в виде {{pt}}
+      response_template: >-
+        {% if m==2 %}1:0{% else %}d{% endif %}
+    
+```
 
 ## Установка
 Рекомендованный способ с поддержкой обновлений - [HACS](https://hacs.xyz/docs/installation/installation):
@@ -66,22 +119,8 @@ mega:
 ```
 
 ## События
-`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` срабатывает когда цифровой выход принимает значение 'ON'. `binary_sensor` имеет смысл использовать
+только с режимом входа P&R
 
 При каждом срабатывании `binary_sensor` так же сообщает о событии типа `mega.sensor`.
 События можно использовать в автоматизациях, например так:
@@ -91,7 +130,7 @@ mega:
     - platform: event
       event_type: mega.sensor
       event_data:
-        entity_id: binary_sensor.mega_1
+        pt: 1
         cnt: 2
   action:
     - service: light.toggle

From b0b4fdd6cf9149db63c1c20f827fd22f30b943ad Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 12:29:31 +0300
Subject: [PATCH 20/37] fix dependencies

---
 custom_components/mega/manifest.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/custom_components/mega/manifest.json b/custom_components/mega/manifest.json
index 09c225b..8d2d30d 100644
--- a/custom_components/mega/manifest.json
+++ b/custom_components/mega/manifest.json
@@ -10,7 +10,7 @@
   "ssdp": [],
   "zeroconf": [],
   "homekit": {},
-  "dependencies": [],
+  "after_dependencies": ["mqtt"],
   "codeowners": [
     "@andvikt"
   ],

From 2d15b60929d5c3e458e17951d7ff7ee804c0d3f9 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 12:54:15 +0300
Subject: [PATCH 21/37] add allowed hosts config

---
 custom_components/mega/__init__.py |  4 +++-
 custom_components/mega/const.py    |  1 +
 readme.md                          | 38 +++++++++++++++++++++---------
 3 files changed, 31 insertions(+), 12 deletions(-)

diff --git a/custom_components/mega/__init__.py b/custom_components/mega/__init__.py
index d1d824d..d4d14e5 100644
--- a/custom_components/mega/__init__.py
+++ b/custom_components/mega/__init__.py
@@ -16,7 +16,7 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.components import mqtt
 from homeassistant.config_entries import ConfigEntry
 from .const import DOMAIN, CONF_INVERT, CONF_RELOAD, PLATFORMS, CONF_PORTS, CONF_CUSTOM, CONF_SKIP, CONF_PORT_TO_SCAN, \
-    CONF_MQTT_INPUTS, CONF_HTTP, CONF_RESPONSE_TEMPLATE, CONF_ACTION, CONF_GET_VALUE
+    CONF_MQTT_INPUTS, CONF_HTTP, CONF_RESPONSE_TEMPLATE, CONF_ACTION, CONF_GET_VALUE, CONF_ALLOW_HOSTS
 from .hub import MegaD
 from .config_flow import ConfigFlow
 from .http import MegaView
@@ -26,6 +26,7 @@ _LOGGER = logging.getLogger(__name__)
 CONFIG_SCHEMA = vol.Schema(
     {
         DOMAIN: {
+            vol.Optional(CONF_ALLOW_HOSTS): [str],
             vol.Required(str, description='id меги из веб-интерфейса'): {
                 vol.Optional(int, description='номер порта'): {
                     vol.Optional(CONF_SKIP, description='исключить порт из сканирования', default=False): bool,
@@ -62,6 +63,7 @@ async def async_setup(hass: HomeAssistant, config: dict):
     """YAML-конфигурация содержит только кастомизации портов"""
     hass.data[DOMAIN] = {CONF_CUSTOM: config.get(DOMAIN, {})}
     hass.data[DOMAIN][CONF_HTTP] = view = MegaView(cfg=config.get(DOMAIN, {}))
+    view.allowed_hosts |= set(config.get(DOMAIN, {}).get(CONF_ALLOW_HOSTS, []))
     hass.http.register_view(view)
     hass.services.async_register(
         DOMAIN, 'save', partial(_save_service, hass), schema=vol.Schema({
diff --git a/custom_components/mega/const.py b/custom_components/mega/const.py
index 3b0a313..00b694a 100644
--- a/custom_components/mega/const.py
+++ b/custom_components/mega/const.py
@@ -23,6 +23,7 @@ CONF_RESPONSE_TEMPLATE = 'response_template'
 CONF_ACTION = 'action'
 CONF_UPDATE_ALL = 'update_all'
 CONF_GET_VALUE = 'get_value'
+CONF_ALLOW_HOSTS = 'allow_hosts'
 PLATFORMS = [
     "light",
     "switch",
diff --git a/readme.md b/readme.md
index f0461dd..3406c75 100644
--- a/readme.md
+++ b/readme.md
@@ -14,6 +14,18 @@
   большого кол-ва команд (например в сценах). Каждая следующая команда отправляется только после получения ответа о
   выполнении предыдущей.
 
+## Установка
+Рекомендованный способ с поддержкой обновлений - [HACS](https://hacs.xyz/docs/installation/installation):
+
+HACS - Integrations - Explore, в поиске ищем MegaD. 
+
+Альтернативный способ установки:
+```shell
+# из папки с конфигом
+wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.sh | bash -
+```
+Не забываем перезагрузить HA
+
 ## Зависимости
 **Важно!!** Для максимальной совместимости необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
 в HomeAssistant, а так же обновить ваш контроллер до последней версии, тк были важные обновления в части mqtt
@@ -73,19 +85,23 @@ mega:
         {% if m==2 %}1:0{% else %}d{% endif %}
     
 ```
-
-## Установка
-Рекомендованный способ с поддержкой обновлений - [HACS](https://hacs.xyz/docs/installation/installation):
-
-HACS - Integrations - Explore, в поиске ищем MegaD. 
-
-Альтернативный способ установки:
+## Отладка ответов
+Для отладки ответов сервера можно самим имитировать запросы контроллера, если у вас есть доступ к консоли
+HA:
 ```shell
-# из папки с конфигом
-wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.sh | bash -
+curl -v -X GET 'http://localhost:8123/mega?pt=5&m=1'
 ```
-Не забываем перезагрузить HA
-
+Если доступа нет, нужно в файл конфигурации добавить ip компьюетра, с которого вы хотите делать запросы, например:
+```yaml
+mega:
+  allow_hosts:
+    - 192.168.1.1
+```
+И тогда можно с локальной машины делать запросы на ваш сервер HA:
+```shell
+curl -v -X GET 'http://192.168.88.1.4:8123/mega?pt=5&m=1'
+```
+В ответ будет приходить либо `d`, либо скрипт, который вы настроили
 ## Настройка
 `Настройки` -> `Интеграции` -> `Добавить интеграцию` в поиске ищем mega
 

From 0b54db9c44ad3f879074e4aea203c94de64816f6 Mon Sep 17 00:00:00 2001
From: andvikt <39195436+andvikt@users.noreply.github.com>
Date: Mon, 25 Jan 2021 13:05:31 +0300
Subject: [PATCH 22/37] Update issue templates

---
 .github/ISSUE_TEMPLATE/bug-report.md | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 .github/ISSUE_TEMPLATE/bug-report.md

diff --git a/.github/ISSUE_TEMPLATE/bug-report.md b/.github/ISSUE_TEMPLATE/bug-report.md
new file mode 100644
index 0000000..691be27
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug-report.md
@@ -0,0 +1,26 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Описание**
+A clear and concise description of what the bug is.
+
+**Версии систем**
+Enviroment: raspberry/linux/windows/macos/docker
+HA version: 
+mega_hacs version:
+megad firmware version:
+
+**Ожидаемое поведение**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**LOG**
+Прочитайте в документации как включить подробный лог интеграции и приложите его здесь

From d934e87ae52892417b83b66f457df5b7a014ba64 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 15:46:40 +0300
Subject: [PATCH 23/37] force use http while scanning

---
 custom_components/mega/hub.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index 9fb0f78..102a095 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -209,13 +209,13 @@ class MegaD:
             ret = {'value': ret}
         return ret
 
-    async def get_port(self, port):
+    async def get_port(self, port, force_http=False):
         """
         Запрос состояния порта. Состояние всегда возвращается в виде объекта, всегда сохраняется в центральное
         хранилище values
         """
         self.lg.debug(f'get port %s', port)
-        if self.mqtt is None:
+        if self.mqtt is None or force_http:
             ret = await self.request(pt=port, cmd='get')
             ret = self.parse_response(ret)
             self.values[port] = ret
@@ -346,7 +346,7 @@ class MegaD:
                 return pty, m
 
     async def scan_ports(self, nports=37):
-        for x in range(nports+1):
+        for x in range(1, nports+1):
             ret = await self.scan_port(x)
             if ret:
                 yield [x, *ret]
@@ -361,7 +361,7 @@ class MegaD:
                 ret['light'][port].append({'dimmer': m == '1'})
             elif pty == '3':
                 try:
-                    values = await self.get_port(port)
+                    values = await self.get_port(port, force_http=True)
                 except asyncio.TimeoutError:
                     self.lg.warning(f'timout on port {port}')
                     continue

From 5bf432a27f116c1d718df6612f668fa49b71db1f Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 15:47:55 +0300
Subject: [PATCH 24/37] change readme

---
 readme.md | 64 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 33 insertions(+), 31 deletions(-)

diff --git a/readme.md b/readme.md
index 3406c75..fef62ed 100644
--- a/readme.md
+++ b/readme.md
@@ -26,8 +26,40 @@ wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.
 ```
 Не забываем перезагрузить HA
 
+## Настройка
+`Настройки` -> `Интеграции` -> `Добавить интеграцию` в поиске ищем 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" # если датчик один, то просто строчкой
+```
+
 ## Зависимости
-**Важно!!** Для максимальной совместимости необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
+Для совместимости c mqtt необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
 в HomeAssistant, а так же обновить ваш контроллер до последней версии, тк были важные обновления в части mqtt
 
 ## HTTP in
@@ -102,37 +134,7 @@ mega:
 curl -v -X GET 'http://192.168.88.1.4:8123/mega?pt=5&m=1'
 ```
 В ответ будет приходить либо `d`, либо скрипт, который вы настроили
-## Настройка
-`Настройки` -> `Интеграции` -> `Добавить интеграцию` в поиске ищем 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'. `binary_sensor` имеет смысл использовать

From 5da2973351674329a0eaaf41e8313558cf2ddcbe Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 15:52:24 +0300
Subject: [PATCH 25/37] fix scanning

---
 custom_components/mega/config_flow.py | 4 ++--
 custom_components/mega/sensor.py      | 4 +++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/custom_components/mega/config_flow.py b/custom_components/mega/config_flow.py
index 44964d4..9a64d4c 100644
--- a/custom_components/mega/config_flow.py
+++ b/custom_components/mega/config_flow.py
@@ -32,8 +32,8 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
 
 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")
+    # 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():
diff --git a/custom_components/mega/sensor.py b/custom_components/mega/sensor.py
index 93888f1..950cca9 100644
--- a/custom_components/mega/sensor.py
+++ b/custom_components/mega/sensor.py
@@ -154,5 +154,7 @@ class Mega1WSensor(MegaPushEntity):
     @property
     def name(self):
         n = super().name
-        c = self.customize.get(CONF_NAME, {}).get(self.key)
+        c = self.customize.get(CONF_NAME, {})
+        if isinstance(c, dict):
+            c = c.get(self.key)
         return c or n
\ No newline at end of file

From 7d6273539e8943ab6576e5398f8ee9700798e05d Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 15:57:10 +0300
Subject: [PATCH 26/37] fix scanning

---
 custom_components/mega/hub.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index 102a095..b8ef49b 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -126,7 +126,7 @@ class MegaD:
     async def get_sensors(self):
         self.lg.debug(self.sensors)
         for x in self.sensors:
-            await self.get_port(x)
+            await self.get_port(x, force_http=True)
 
     @property
     def is_online(self):

From 57f355d479200e5aaf3c1ab288948649c2b3ba9c Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 16:37:48 +0300
Subject: [PATCH 27/37] fix scanning

---
 custom_components/mega/hub.py    | 16 +++++++++++++---
 custom_components/mega/sensor.py |  4 ++--
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index b8ef49b..1dec7d9 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -125,8 +125,12 @@ class MegaD:
 
     async def get_sensors(self):
         self.lg.debug(self.sensors)
+        ports = []
         for x in self.sensors:
-            await self.get_port(x, force_http=True)
+            if x.port in ports:
+                continue
+            await self.get_port(x.port, force_http=True, http_cmd=x.http_cmd)
+            ports.append(x.port)
 
     @property
     def is_online(self):
@@ -157,6 +161,7 @@ class MegaD:
         self.lg.debug('poll')
         if self.mqtt is None:
             await self.get_all_ports()
+            await self.get_sensors()
             return
         if len(self.sensors) > 0:
             await self.get_sensors()
@@ -209,14 +214,14 @@ class MegaD:
             ret = {'value': ret}
         return ret
 
-    async def get_port(self, port, force_http=False):
+    async def get_port(self, port, force_http=False, http_cmd='get'):
         """
         Запрос состояния порта. Состояние всегда возвращается в виде объекта, всегда сохраняется в центральное
         хранилище values
         """
         self.lg.debug(f'get port %s', port)
         if self.mqtt is None or force_http:
-            ret = await self.request(pt=port, cmd='get')
+            ret = await self.request(pt=port, cmd=http_cmd)
             ret = self.parse_response(ret)
             self.values[port] = ret
             return ret
@@ -361,7 +366,11 @@ class MegaD:
                 ret['light'][port].append({'dimmer': m == '1'})
             elif pty == '3':
                 try:
+                    http_cmd = 'get'
                     values = await self.get_port(port, force_http=True)
+                    if values is None:
+                        values = await self.get_port(port, force_http=True, http_cmd='list')
+                        http_cmd = 'list'
                 except asyncio.TimeoutError:
                     self.lg.warning(f'timout on port {port}')
                     continue
@@ -382,6 +391,7 @@ class MegaD:
                         unit_of_measurement=UNITS.get(key, UNITS[TEMP]),
                         device_class=CLASSES.get(key, CLASSES[TEMP]),
                         id_suffix=key,
+                        http_cmd=http_cmd,
                     ))
         return ret
 
diff --git a/custom_components/mega/sensor.py b/custom_components/mega/sensor.py
index 950cca9..97e1b47 100644
--- a/custom_components/mega/sensor.py
+++ b/custom_components/mega/sensor.py
@@ -101,6 +101,7 @@ class Mega1WSensor(MegaPushEntity):
             unit_of_measurement,
             device_class,
             key=None,
+            http_cmd='get',
             *args,
             **kwargs
     ):
@@ -115,8 +116,7 @@ class Mega1WSensor(MegaPushEntity):
         self.key = key
         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)
+        self.mega.sensors.append(self)
 
     @property
     def unit_of_measurement(self):

From ff6225a959346df02cd2d22f8483ec92d3644083 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 17:18:42 +0300
Subject: [PATCH 28/37] fix scanning

---
 custom_components/mega/config_flow.py       |  2 +-
 custom_components/mega/hub.py               | 17 +++++++++++++----
 custom_components/mega/sensor.py            | 15 ++++++++++++++-
 custom_components/mega/strings.json         |  3 ++-
 custom_components/mega/translations/en.json |  3 ++-
 5 files changed, 32 insertions(+), 8 deletions(-)

diff --git a/custom_components/mega/config_flow.py b/custom_components/mega/config_flow.py
index 9a64d4c..f454bd9 100644
--- a/custom_components/mega/config_flow.py
+++ b/custom_components/mega/config_flow.py
@@ -25,7 +25,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         vol.Optional(CONF_PORT_TO_SCAN, default=0): int,
         vol.Optional(CONF_MQTT_INPUTS, default=True): bool,
         vol.Optional(CONF_NPORTS, default=37): int,
-        vol.Optional(CONF_UPDATE_ALL, default=True): bool,
+        # vol.Optional(CONF_UPDATE_ALL, default=True): bool,
     },
 )
 
diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index 1dec7d9..ce43dc2 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -123,10 +123,12 @@ class MegaD:
         async with self.lck:
             self.entities.append(ent)
 
-    async def get_sensors(self):
+    async def get_sensors(self, only_list=False):
         self.lg.debug(self.sensors)
         ports = []
         for x in self.sensors:
+            if only_list and x.http_cmd != 'list':
+                continue
             if x.port in ports:
                 continue
             await self.get_port(x.port, force_http=True, http_cmd=x.http_cmd)
@@ -161,7 +163,7 @@ class MegaD:
         self.lg.debug('poll')
         if self.mqtt is None:
             await self.get_all_ports()
-            await self.get_sensors()
+            await self.get_sensors(only_list=True)
             return
         if len(self.sensors) > 0:
             await self.get_sensors()
@@ -193,7 +195,9 @@ class MegaD:
                     self.lg.warning('%s returned %s (%s)', url, req.status, await req.text())
                     return None
                 else:
-                    return await req.text()
+                    ret = await req.text()
+                    self.lg.debug('response %s', ret)
+                    return ret
 
     async def save(self):
         await self.send_command(cmd='s')
@@ -223,6 +227,11 @@ class MegaD:
         if self.mqtt is None or force_http:
             ret = await self.request(pt=port, cmd=http_cmd)
             ret = self.parse_response(ret)
+            self.lg.debug('parsed: %s', ret)
+            if http_cmd == 'list' and isinstance(ret, dict) and 'value' in ret:
+                await asyncio.sleep(1)
+                ret = await self.request(pt=port, http_cmd=http_cmd)
+                ret = self.parse_response(ret)
             self.values[port] = ret
             return ret
 
@@ -368,7 +377,7 @@ class MegaD:
                 try:
                     http_cmd = 'get'
                     values = await self.get_port(port, force_http=True)
-                    if values is None:
+                    if values is None or (isinstance(values, dict) and str(values.get('value')) in ('', 'None')):
                         values = await self.get_port(port, force_http=True, http_cmd='list')
                         http_cmd = 'list'
                 except asyncio.TimeoutError:
diff --git a/custom_components/mega/sensor.py b/custom_components/mega/sensor.py
index 97e1b47..cf3a7d3 100644
--- a/custom_components/mega/sensor.py
+++ b/custom_components/mega/sensor.py
@@ -117,6 +117,7 @@ class Mega1WSensor(MegaPushEntity):
         self._device_class = device_class
         self._unit_of_measurement = unit_of_measurement
         self.mega.sensors.append(self)
+        self.http_cmd = http_cmd
 
     @property
     def unit_of_measurement(self):
@@ -143,12 +144,24 @@ class Mega1WSensor(MegaPushEntity):
 
     @property
     def state(self):
+        ret = None
         if self.key:
-            ret = self.mega.values.get(self.port, {}).get('value', {}).get(self.key)
+            try:
+                ret = self.mega.values.get(self.port, {})
+                if isinstance(ret, dict):
+                    ret = ret.get(self.key)
+            except:
+                self.lg.error(self.mega.values.get(self.port, {}).get('value', {}))
+                return
         else:
             ret = self.mega.values.get(self.port, {}).get('value')
         if ret is None and self._state is not None:
             ret = self._state.state
+        try:
+            ret = float(ret)
+            ret = str(ret)
+        except:
+            ret = None
         return ret
 
     @property
diff --git a/custom_components/mega/strings.json b/custom_components/mega/strings.json
index 7f08693..9fab033 100644
--- a/custom_components/mega/strings.json
+++ b/custom_components/mega/strings.json
@@ -37,7 +37,8 @@
           "reload": "[%key:common::config_flow::data::reload%]",
           "invert": "[%key:common::config_flow::data::invert%]",
           "mqtt_inputs": "[%key:common::config_flow::data::mqtt_inputs%]",
-          "nports": "[%key:common::config_flow::data::nports%]"
+          "nports": "[%key:common::config_flow::data::nports%]",
+          "update_all": "[%key:common::config_flow::data::update_all%]"
         }
       }
     }
diff --git a/custom_components/mega/translations/en.json b/custom_components/mega/translations/en.json
index 06e2a22..39960df 100644
--- a/custom_components/mega/translations/en.json
+++ b/custom_components/mega/translations/en.json
@@ -21,7 +21,8 @@
                     "scan_interval": "Scan interval (sec), 0 - don't update",
                     "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
                     "nports": "Number of ports",
-                    "update_all": "Update all outs when input"
+                    "update_all": "Update all outs when input",
+                    "mqtt_inputs": "Use MQTT"
                 }
             }
         }

From 6164966d0baeb48fb43e4abd2396238412fda078 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 17:21:55 +0300
Subject: [PATCH 29/37] fix scanning

---
 custom_components/mega/hub.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index ce43dc2..0d2d5b6 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -360,7 +360,7 @@ class MegaD:
                 return pty, m
 
     async def scan_ports(self, nports=37):
-        for x in range(1, nports+1):
+        for x in range(0, nports+1):
             ret = await self.scan_port(x)
             if ret:
                 yield [x, *ret]

From c4205c7ddc658ec02c2d3a8814c024ad938f3f0b Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 17:23:33 +0300
Subject: [PATCH 30/37] fix sw-link

---
 custom_components/mega/hub.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index 0d2d5b6..41833a1 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -371,7 +371,7 @@ class MegaD:
         async for port, pty, m in self.scan_ports(nports):
             if pty == "0":
                 ret['binary_sensor'][port].append({})
-            elif pty == "1" and m in ['0', '1']:
+            elif pty == "1" and m in ['0', '1', '3']:
                 ret['light'][port].append({'dimmer': m == '1'})
             elif pty == '3':
                 try:

From e51b50797c8f13b2050aa4ac37611828c2714cf9 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 17:46:26 +0300
Subject: [PATCH 31/37] fix yaml exclusion

---
 custom_components/mega/hub.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index 41833a1..dc93cd7 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -60,7 +60,7 @@ class MegaD:
     ):
         """Initialize."""
         if mqtt_inputs is None or mqtt_inputs == 'None' or mqtt_inputs is False:
-            self.http = hass.data[DOMAIN][CONF_HTTP]
+            self.http = hass.data.get(DOMAIN, {}).get(CONF_HTTP)
             self.http.allowed_hosts |= {host}
         else:
             self.http = None

From dc6bdfc8f4eecf0bf9d2b07f0995048fc9599dab Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 17:56:47 +0300
Subject: [PATCH 32/37] fix yaml exclusion

---
 custom_components/mega/hub.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index dc93cd7..e6510ee 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -61,7 +61,8 @@ class MegaD:
         """Initialize."""
         if mqtt_inputs is None or mqtt_inputs == 'None' or mqtt_inputs is False:
             self.http = hass.data.get(DOMAIN, {}).get(CONF_HTTP)
-            self.http.allowed_hosts |= {host}
+            if not self.http is None:
+                self.http.allowed_hosts |= {host}
         else:
             self.http = None
         self.update_all = update_all if update_all is not None else True

From a002e48e046958a029d7638bf463932f2ef8a9f6 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 18:13:25 +0300
Subject: [PATCH 33/37] fix old mega out type 0

---
 custom_components/mega/hub.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index e6510ee..7de399d 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -372,7 +372,7 @@ class MegaD:
         async for port, pty, m in self.scan_ports(nports):
             if pty == "0":
                 ret['binary_sensor'][port].append({})
-            elif pty == "1" and m in ['0', '1', '3']:
+            elif pty == "1" and (m in ['0', '1', '3'] or m is None):
                 ret['light'][port].append({'dimmer': m == '1'})
             elif pty == '3':
                 try:

From 39c4ab0e3b8de99d44a182167bd4d0d95f7289c7 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 18:45:23 +0300
Subject: [PATCH 34/37] fix device name

---
 custom_components/mega/entities.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/custom_components/mega/entities.py b/custom_components/mega/entities.py
index a263a56..5182b5b 100644
--- a/custom_components/mega/entities.py
+++ b/custom_components/mega/entities.py
@@ -59,7 +59,7 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
             "config_entries": [
                 self.config_entry,
             ],
-            "name": f'port {self.port}',
+            "name": f'{self._mega_id} port {self.port}',
             "manufacturer": 'ab-log.ru',
             # "model": self.light.productname,
             # "sw_version": self.light.swversion,

From 1548e8c364e848e42a874d0ff07691c37e6e50e6 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 20:17:15 +0300
Subject: [PATCH 35/37] fix multiple megas

---
 custom_components/mega/http.py | 5 ++---
 custom_components/mega/hub.py  | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/custom_components/mega/http.py b/custom_components/mega/http.py
index 9db655d..061d00d 100644
--- a/custom_components/mega/http.py
+++ b/custom_components/mega/http.py
@@ -26,8 +26,7 @@ class MegaView(HomeAssistantView):
     def __init__(self, cfg: dict):
         self._try = 0
         self.allowed_hosts = {'::1'}
-        self.callbacks: typing.DefaultDict[int, typing.List[typing.Callable[[dict], typing.Coroutine]]] \
-            = defaultdict(list)
+        self.callbacks = defaultdict(lambda: defaultdict(list))
         self.templates: typing.Dict[str, typing.Dict[str, Template]] = {
             mid: {
                 pt: cfg[mid][pt][CONF_RESPONSE_TEMPLATE]
@@ -64,7 +63,7 @@ class MegaView(HomeAssistantView):
         data = data.copy()
         ret = 'd'
         if port is not None:
-            for cb in self.callbacks[port]:
+            for cb in self.callbacks[hub.id][port]:
                 cb(data)
             template: Template = self.templates.get(hub.id, {}).get(port)
             if hub.update_all:
diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index 7de399d..85964f3 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -307,7 +307,7 @@ class MegaD:
         if self.mqtt_inputs:
             self._callbacks[port].append(callback)
         else:
-            self.http.callbacks[port].append(callback)
+            self.http.callbacks[self.id][port].append(callback)
 
     async def authenticate(self) -> bool:
         """Test if we can authenticate with the host."""

From c0b1247b9e87dfe9af1ae0777f40884a385abe7a Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Mon, 25 Jan 2021 21:35:06 +0300
Subject: [PATCH 36/37] smaller headers

---
 custom_components/mega/http.py  | 20 +++++---------------
 custom_components/mega/hub.py   | 10 +++++++++-
 custom_components/mega/tools.py | 10 ++++++++++
 readme.md                       | 11 ++++++++++-
 4 files changed, 34 insertions(+), 17 deletions(-)
 create mode 100644 custom_components/mega/tools.py

diff --git a/custom_components/mega/http.py b/custom_components/mega/http.py
index 061d00d..ab52f3b 100644
--- a/custom_components/mega/http.py
+++ b/custom_components/mega/http.py
@@ -8,10 +8,10 @@ from aiohttp.web_request import Request
 from aiohttp.web_response import Response
 
 from homeassistant.helpers.template import Template
-from .const import EVENT_BINARY_SENSOR, CONF_HTTP, DOMAIN, CONF_CUSTOM, CONF_RESPONSE_TEMPLATE
+from .const import EVENT_BINARY_SENSOR, DOMAIN, CONF_RESPONSE_TEMPLATE
 from homeassistant.components.http import HomeAssistantView
-from homeassistant.core import callback, HomeAssistant
-from . import hub
+from homeassistant.core import HomeAssistant
+from .tools import make_ints
 
 _LOGGER = logging.getLogger(__name__).getChild('http')
 
@@ -61,6 +61,7 @@ class MegaView(HomeAssistantView):
         make_ints(data)
         port = data.get('pt')
         data = data.copy()
+        data['mega_id'] = hub.id
         ret = 'd'
         if port is not None:
             for cb in self.callbacks[hub.id][port]:
@@ -72,8 +73,7 @@ class MegaView(HomeAssistantView):
                 template.hass = hass
                 ret = template.async_render(data)
         _LOGGER.debug('response %s', ret)
-        ret = Response(body=ret or 'd', content_type='text/plain', headers={})
-        ret.headers.clear()
+        ret = Response(body=ret or 'd', content_type='text/plain', headers={'Server': 's', 'Date': 'n'})
         return ret
 
     async def later_update(self, hub):
@@ -82,13 +82,3 @@ class MegaView(HomeAssistantView):
         await hub.updater.async_refresh()
 
 
-def make_ints(d: dict):
-    for x in d:
-        try:
-            d[x] = float(d[x])
-        except ValueError:
-            pass
-    if 'm' not in d:
-        d['m'] = 0
-    if 'click' not in d:
-        d['click'] = 0
\ No newline at end of file
diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index 85964f3..0628253 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -14,9 +14,10 @@ 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, PATT_SPLIT, DOMAIN, CONF_HTTP
+from .const import TEMP, HUM, PATT_SPLIT, DOMAIN, CONF_HTTP, EVENT_BINARY_SENSOR
 from .exceptions import CannotConnect, MqttNotConfigured
 from .http import MegaView
+from .tools import make_ints
 
 TEMP_PATT = re.compile(r'temp:([01234567890\.]+)')
 HUM_PATT = re.compile(r'hum:([01234567890\.]+)')
@@ -290,9 +291,16 @@ class MegaD:
         value = None
         try:
             value = json.loads(msg.payload)
+            value = make_ints(value)
             self.values[port] = value
             for cb in self._callbacks[port]:
                 cb(value)
+            value = value.copy()
+            value['mega_id'] = self.id
+            self.hass.bus.async_fire(
+                EVENT_BINARY_SENSOR,
+                value,
+            )
         except Exception as exc:
             self.lg.warning(f'could not parse json ({msg.payload}): {exc}')
             return
diff --git a/custom_components/mega/tools.py b/custom_components/mega/tools.py
new file mode 100644
index 0000000..482e717
--- /dev/null
+++ b/custom_components/mega/tools.py
@@ -0,0 +1,10 @@
+def make_ints(d: dict):
+    for x in d:
+        try:
+            d[x] = float(d[x])
+        except ValueError:
+            pass
+    if 'm' not in d:
+        d['m'] = 0
+    if 'click' not in d:
+        d['click'] = 0
\ No newline at end of file
diff --git a/readme.md b/readme.md
index fef62ed..68279c5 100644
--- a/readme.md
+++ b/readme.md
@@ -92,7 +92,7 @@ script: "mega" # это api интеграции, к которому будет
 запустить то что прописано в поле act в настройках порта).
 
 Поддерживаеются шаблоны HA. Это может быть использовано, например, для запоминания яркости (тк сам контроллер этого не 
-умеет). В шаблоне можно использовать параметры, которые передает контроллер (m, click, pt, value)
+умеет). В шаблоне можно использовать параметры, которые передает контроллер (m, click, pt, mdid, mega_id)
 
 Примеры:
 ```yaml
@@ -154,6 +154,15 @@ curl -v -X GET 'http://192.168.88.1.4:8123/mega?pt=5&m=1'
     - service: light.toggle
       entity_id: light.some_light
 ```
+События могут содержать следующие поля: 
+- mega_id: id как в конфиге HA
+- pt: номер порта
+- cnt: счетчик срабатываний
+- mdid: if как в конфиге контроллера
+- click: клик (подробнее в документации меги)
+- value: текущее значение (только для mqtt)
+- port: номер порта
+
 Чтобы понять, какие события происходят, лучше всего воспользоваться панелью разработчика и подписаться
 на вкладке события на событие `mega.sensor`, понажимать кнопки.
 

From a7d7738a5ccef7be7d71d4cf9677d13a0fe5f944 Mon Sep 17 00:00:00 2001
From: Andrey <andvikt@gmail.com>
Date: Tue, 26 Jan 2021 08:34:27 +0300
Subject: [PATCH 37/37] fix mqtt

---
 custom_components/mega/entities.py |  7 +++++--
 custom_components/mega/hub.py      | 16 +++++++++-------
 custom_components/mega/tools.py    |  2 +-
 readme.md                          | 24 ++++++++++++++++++++++++
 4 files changed, 39 insertions(+), 10 deletions(-)

diff --git a/custom_components/mega/entities.py b/custom_components/mega/entities.py
index 5182b5b..270fc4b 100644
--- a/custom_components/mega/entities.py
+++ b/custom_components/mega/entities.py
@@ -155,10 +155,12 @@ class MegaOutPort(MegaPushEntity):
 
     @property
     def is_on(self) -> bool:
-        val = self.mega.values.get(self.port, {}).get("value")
+        val = self.mega.values.get(self.port, {})
+
         if val is None and self._state is not None:
             return self._state == 'ON'
         elif val is not None:
+            val = val.get("value")
             if not self.invert:
                 return val == 'ON' or str(val) == '1' or (safe_int(val) is not None and safe_int(val) > 0)
             else:
@@ -186,10 +188,11 @@ class MegaOutPort(MegaPushEntity):
         self.mega.values[self.port] = {'value': cmd}
         await self.get_state()
 
+
 def safe_int(v):
     if v in ['ON', 'OFF']:
         return None
     try:
         return int(v)
-    except ValueError:
+    except (ValueError, TypeError):
         return None
\ No newline at end of file
diff --git a/custom_components/mega/hub.py b/custom_components/mega/hub.py
index 0628253..0c6debb 100644
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -291,16 +291,18 @@ class MegaD:
         value = None
         try:
             value = json.loads(msg.payload)
-            value = make_ints(value)
+            if isinstance(value, dict):
+                make_ints(value)
             self.values[port] = value
             for cb in self._callbacks[port]:
                 cb(value)
-            value = value.copy()
-            value['mega_id'] = self.id
-            self.hass.bus.async_fire(
-                EVENT_BINARY_SENSOR,
-                value,
-            )
+            if isinstance(value, dict):
+                value = value.copy()
+                value['mega_id'] = self.id
+                self.hass.bus.async_fire(
+                    EVENT_BINARY_SENSOR,
+                    value,
+                )
         except Exception as exc:
             self.lg.warning(f'could not parse json ({msg.payload}): {exc}')
             return
diff --git a/custom_components/mega/tools.py b/custom_components/mega/tools.py
index 482e717..d1d8876 100644
--- a/custom_components/mega/tools.py
+++ b/custom_components/mega/tools.py
@@ -2,7 +2,7 @@ def make_ints(d: dict):
     for x in d:
         try:
             d[x] = float(d[x])
-        except ValueError:
+        except (ValueError, TypeError):
             pass
     if 'm' not in d:
         d['m'] = 0
diff --git a/readme.md b/readme.md
index 68279c5..52c802c 100644
--- a/readme.md
+++ b/readme.md
@@ -81,12 +81,36 @@ script: "mega" # это api интеграции, к которому будет
       event_type: mega.sensor
       event_data:
         pt: 1
+        click: 2
   action:
     - service: light.toggle
       entity_id: light.some_light
 ```
 Для binary_sensor имеет смысл использовать режим P&R, для остальных режимов - лучше пользоваться событиями.
 
+Примеры использования binary_sensor:
+```yaml
+- alias: обработка долгих/коротких нажатий
+  trigger:
+    - platform: state
+      entity_id: binary_sensor.some_sensor
+      to: on
+      for: 1 # задержка на секунду
+
+  action:
+    - choose:
+          # если кнопка все еще нажата - значит это долгое нажатие
+        - conditions: "{{ is_state('binary_sensor.some_sensor', 'on')}}"
+          sequence:
+          - service: light.turn_on
+            entity_id: light.some_light
+          # если кнопка уже не нажата - значит это короткое нажатие
+        - conditions: "{{ is_state('binary_sensor.some_sensor', 'off')}}"
+          sequence:
+          - service: light.turn_off
+            entity_id: light.some_light
+```
+
 ## Ответ на входящие события от контроллера
 Контроллер ожидает ответ от сервера, который может быть сценарием (по умолчанию интеграция отвечает `d`, что означает 
 запустить то что прописано в поле act в настройках порта).