fix force_d

edit readme
fix config bug
2025-12-12 01:24:29 +05:00 · 2021-02-15 19:05:00 +03:00 · 2021-02-11 17:35:58 +03:00 · 2021-02-11 16:03:10 +03:00 · 2021-02-11 12:19:17 +03:00 · 2021-02-11 12:00:01 +03:00
22 changed files with 1449 additions and 642 deletions
--- a/.experiment.py
+++ b/.experiment.py
@@ -0,0 +1,32 @@
 import asyncio
 async def handle_echo(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
    data = await reader.read(100)
    message = data.decode()
    addr = writer.get_extra_info('peername')
    print(f"Received {message!r} from {addr!r}")
    print(f"Send: {message!r}")
    ans = '''HTTP/1.1 200 OK\nContent-Length: 6\n\nhello\n'''.encode()
    writer.write(ans)
    await writer.drain()
    print("Close the connection")
    writer.transport.close()
    writer.close()
    await writer.wait_closed()
 async def main():
    server = await asyncio.start_server(
        handle_echo, '127.0.0.1', 8888)
    addr = server.sockets[0].getsockname()
    print(f'Serving on {addr}')
    async with server:
        await server.serve_forever()
 asyncio.run(main())
--- a/.github/ISSUE_TEMPLATE/bug-report.md
+++ b/.github/ISSUE_TEMPLATE/bug-report.md
@@ -0,0 +1,33 @@
 ---
 name: Bug report
 about: Create a report to help us improve
 title: ''
 labels: ''
 assignees: ''
 ---
 **Описание**
 Описание проблемы
 **Версии систем**
 Enviroment: raspberry/linux/windows/macos/docker
 HA version: 
 mega_hacs version:
 megad firmware version:
 используется mqtt: true/false
 **Ожидаемое поведение**
 Описание правильного поведения
 **Screenshots**
 If applicable, add screenshots to help explain your problem.
 **LOG**
 Просьба прикладывать детальный лог, который можно включить в конфиге так:
 ```yaml
 logger:
  default: info
  logs:
    custom_components.mega: debug
 ```
--- a/custom_components/mega/.experiment.py
+++ b/custom_components/mega/.experiment.py
@@ -1,36 +0,0 @@
 import asyncio
 from bs4 import BeautifulSoup
 import aiohttp
 host = '192.168.88.14/sec'
 # page = '''
 # <html><head><style>input,select{margin:1px}</style></head><body><a href="/sec/?cf=3">Back</a><br>P7/ON<br><a href="/sec/?pt=7&amp;cmd=7:1">ON</a> <a href="/sec/?pt=7&amp;cmd=7:0">OFF</a><br><form action="/sec/"><input type="hidden" name="pn" value="7">Type <select name="pty"><option value="255">NC</option><option value="0">In</option><option value="1" selected="">Out</option><option value="3">DSen</option><option value="4">I2C</option></select><br>Default: <select name="d"><option value="0" selected="">0</option><option value="1">1</option></select><br>Mode <select name="m"><option value="0" selected="">SW</option><option value="3">SW LINK</option><option value="2">DS2413</option></select><br>Group <input name="grp" size="2" value=""><br><input type="submit" value="Save"></form></body></html>
 # <head><style>input,select{margin:1px}</style></head>
 # <body><a href="/sec/?cf=3">Back</a><br>P7/ON<br><a href="/sec/?pt=7&amp;cmd=7:1">ON</a> <a href="/sec/?pt=7&amp;cmd=7:0">OFF</a><br><form action="/sec/"><input type="hidden" name="pn" value="7">Type <select name="pty"><option value="255">NC</option><option value="0">In</option><option value="1" selected="">Out</option><option value="3">DSen</option><option value="4">I2C</option></select><br>Default: <select name="d"><option value="0" selected="">0</option><option value="1">1</option></select><br>Mode <select name="m"><option value="0" selected="">SW</option><option value="3">SW LINK</option><option value="2">DS2413</option></select><br>Group <input name="grp" size="2" value=""><br><input type="submit" value="Save"></form></body>
 # <a href="/sec/?cf=3">Back</a>
 # <br>
 # P7/ON
 # <br>
 # <a href="/sec/?pt=7&amp;cmd=7:1">ON</a>
 # <a href="/sec/?pt=7&amp;cmd=7:0">OFF</a>
 # <br>
 # <form action="/sec/"><input type="hidden" name="pn" value="7">Type <select name="pty"><option value="255">NC</option><option value="0">In</option><option value="1" selected="">Out</option><option value="3">DSen</option><option value="4">I2C</option></select><br>Default: <select name="d"><option value="0" selected="">0</option><option value="1">1</option></select><br>Mode <select name="m"><option value="0" selected="">SW</option><option value="3">SW LINK</option><option value="2">DS2413</option></select><br>Group <input name="grp" size="2" value=""><br><input type="submit" value="Save"></form>
 # <body><a href="/sec/?cf=3">Back</a><br>P7/ON<br><a href="/sec/?pt=7&amp;cmd=7:1">ON</a> <a href="/sec/?pt=7&amp;cmd=7:0">OFF</a><br><form action="/sec/"><input type="hidden" name="pn" value="7">Type <select name="pty"><option value="255">NC</option><option value="0">In</option><option value="1" selected="">Out</option><option value="3">DSen</option><option value="4">I2C</option></select><br>Default: <select name="d"><option value="0" selected="">0</option><option value="1">1</option></select><br>Mode <select name="m"><option value="0" selected="">SW</option><option value="3">SW LINK</option><option value="2">DS2413</option></select><br>Group <input name="grp" size="2" value=""><br><input type="submit" value="Save"></form></body>
 # <html><head><style>input,select{margin:1px}</style></head><body><a href="/sec/?cf=3">Back</a><br>P7/ON<br><a href="/sec/?pt=7&amp;cmd=7:1">ON</a> <a href="/sec/?pt=7&amp;cmd=7:0">OFF</a><br><form action="/sec/"><input type="hidden" name="pn" value="7">Type <select name="pty"><option value="255">NC</option><option value="0">In</option><option value="1" selected="">Out</option><option value="3">DSen</option><option value="4">I2C</option></select><br>Default: <select name="d"><option value="0" selected="">0</option><option value="1">1</option></select><br>Mode <select name="m"><option value="0" selected="">SW</option><option value="3">SW LINK</option><option value="2">DS2413</option></select><br>Group <input name="grp" size="2" value=""><br><input type="submit" value="Save"></form></body></html>
 # '''
 # tree = BeautifulSoup(page, features="lxml")
 # pty = tree.find('select', attrs={'name': 'pty'}).find(selected=True)['value']
 # m = tree.find('select', attrs={'name': 'm'})
 # if m:
 #     m = m.find(selected=True)['value']
 #
 # print(pty, m)
 if __name__ == '__main__':
    asyncio.get_event_loop().run_until_complete(
        scan_port(0)
    )
--- a/custom_components/mega/init.py
+++ b/custom_components/mega/init.py
@@ -1,45 +1,61 @@
 """The mega integration."""
 import asyncio
 import logging
 import typing
 from functools import partial
 import voluptuous as vol
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_PLATFORM, CONF_SCAN_INTERVAL, CONF_ID
+
-from homeassistant.core import HomeAssistant
+from homeassistant.const import (
-from homeassistant.helpers.entity_component import EntityComponent
+    CONF_SCAN_INTERVAL, CONF_ID, CONF_NAME, CONF_DOMAIN,
    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
+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_ALLOW_HOSTS, \
    CONF_CONV_TEMPLATE, CONF_ALL, CONF_FORCE_D
 from .hub import MegaD
-
+from .config_flow import ConfigFlow
 from .http import MegaView
 _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.Optional(CONF_ALLOW_HOSTS): [str],
            # vol.Optional(CONF_FORCE_D, description='Принудительно слать d после срабатывания входа', default=False): bool,
            vol.Required(str, description='id меги из веб-интерфейса'): {
                vol.Optional(CONF_FORCE_D, description='Принудительно слать d после срабатывания входа', default=False): bool,
                vol.Optional(int, description='номер порта'): {
                    vol.Optional(CONF_SKIP, description='исключить порт из сканирования', default=False): bool,
                    vol.Optional(CONF_INVERT, default=False): bool,
                    vol.Optional(CONF_NAME): vol.Any(str, {
                        vol.Required(str): str
                    }),
                    vol.Optional(CONF_DOMAIN): vol.Any('light', 'switch'),
                    vol.Optional(CONF_UNIT_OF_MEASUREMENT, description='единицы измерений, либо строка либо мепинг'):
                        vol.Any(str, {
                            vol.Required(str): str
                        }),
                    vol.Optional(
                        CONF_RESPONSE_TEMPLATE,
                        description='шаблон ответа когда на этот порт приходит'
                                    'сообщение из меги '): cv.template,
                    vol.Optional(CONF_ACTION): cv.script_action, # пока не реализовано
                    vol.Optional(CONF_GET_VALUE, default=True): bool,
                    vol.Optional(CONF_CONV_TEMPLATE): cv.template
                }
            }
        }
    },
    extra=vol.ALLOW_EXTRA,
 )
 PLATFORMS = [
    "light",
    "binary_sensor",
    "sensor",
 ]
 ALIVE_STATE = 'alive'
 DEF_ID = 'def'
 _POLL_TASKS = {}
@@ -48,45 +64,61 @@ _subs = {}
 async def async_setup(hass: HomeAssistant, config: dict):
-    """Set up the mega component."""
+    """YAML-конфигурация содержит только кастомизации портов"""
-    conf = config.get(DOMAIN)
+    hass.data[DOMAIN] = {CONF_CUSTOM: config.get(DOMAIN, {})}
-    hass.data[DOMAIN] = {}
+    hass.data[DOMAIN][CONF_HTTP] = view = MegaView(cfg=config.get(DOMAIN, {}))
    hass.data[DOMAIN][CONF_ALL] = {}
    view.allowed_hosts |= set(config.get(DOMAIN, {}).get(CONF_ALLOW_HOSTS, []))
    hass.http.register_view(view)
    hass.services.async_register(
-        DOMAIN, 'save', _save_service, schema=vol.Schema({
+        DOMAIN, 'save', partial(_save_service, hass), schema=vol.Schema({
            vol.Optional('mega_id'): str
        })
    )
    hass.services.async_register(
-        DOMAIN, 'get_port', _get_port, schema=vol.Schema({
+        DOMAIN, 'get_port', partial(_get_port, hass), schema=vol.Schema({
            vol.Optional('mega_id'): str,
-            vol.Optional('port'): int,
+            vol.Optional('port'): vol.Any(int, [int]),
        })
    )
    hass.services.async_register(
-        DOMAIN, 'run_cmd', _run_cmd, schema=vol.Schema({
+        DOMAIN, 'run_cmd', partial(_run_cmd, hass), schema=vol.Schema({
-            vol.Required('port'): int,
+            vol.Optional('port'): int,
            vol.Required('cmd'): str,
            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():
        await _add_mega(hass, id, data)
    for id, hub in hass.data[DOMAIN].__items__():
        _POLL_TASKS[id] = asyncio.create_task(hub.poll())
    return True
-async def _add_mega(hass: HomeAssistant, id, data: dict):
+async def get_hub(hass, entry):
    id = entry.data.get('id', entry.entry_id)
    data = dict(entry.data)
    data.update(entry.options or {})
    data.update(id=id)
    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')
-    hass.data[DOMAIN][id] = hub = MegaD(hass, **data, mqtt=_mqtt, lg=_LOGGER)
+    hub = MegaD(hass, **data, mqtt=_mqtt, lg=_LOGGER, loop=asyncio.get_event_loop())
    hub.mqtt_id = await hub.get_mqtt_id()
    return hub
 async def _add_mega(hass: HomeAssistant, entry: ConfigEntry):
    id = entry.data.get('id', entry.entry_id)
    hub = await get_hub(hass, entry)
    hass.data[DOMAIN][id] = hass.data[DOMAIN]['__def'] = hub
    hass.data[DOMAIN][entry.data.get(CONF_HOST)] = hub
    hass.data[DOMAIN][CONF_ALL][id] = hub
    if not await hub.authenticate():
        raise Exception("not authentificated")
    mid = await hub.get_mqtt_id()
@@ -95,28 +127,33 @@ async def _add_mega(hass: HomeAssistant, id, data: dict):
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
-    id = entry.data.get('id', entry.entry_id)
+    hub: MegaD = await _add_mega(hass, entry)
    data = dict(entry.data)
    data.update(entry.options or {})
    hub = await _add_mega(hass, id, data)
    _hubs[entry.entry_id] = hub
-    _subs[entry.entry_id] = entry.add_update_listener(update)
+    _subs[entry.entry_id] = entry.add_update_listener(updater)
-
+    await hub.start()
    for platform in PLATFORMS:
        hass.async_create_task(
            hass.config_entries.async_forward_entry_setup(
                entry, platform
            )
        )
-    _POLL_TASKS[id] = asyncio.create_task(hub.poll())
+    await hub.updater.async_refresh()
    return True
-async def update(hass: HomeAssistant, entry: ConfigEntry):
+async def updater(hass: HomeAssistant, entry: ConfigEntry):
    """
    Обновляется конфигурация
    :param hass:
    :param entry:
    :return:
    """
    hub: MegaD = hass.data[DOMAIN][entry.data[CONF_ID]]
    hub.poll_interval = entry.options[CONF_SCAN_INTERVAL]
-    hub.port_to_scan = entry.options[CONF_PORT_TO_SCAN]
+    hub.port_to_scan = entry.options.get(CONF_PORT_TO_SCAN, 0)
-    if entry.options[CONF_RELOAD]:
+    entry.data = entry.options
    for platform in PLATFORMS:
        await hass.config_entries.async_forward_entry_unload(entry, platform)
    await async_remove_entry(hass, entry)
    await async_setup_entry(hass, entry)
    return True
@@ -125,44 +162,83 @@ async def update(hass: HomeAssistant, entry: ConfigEntry):
 async def async_remove_entry(hass, entry) -> None:
    """Handle removal of an entry."""
    id = entry.data.get('id', entry.entry_id)
-    hass.data[DOMAIN][id].unsubscribe_all()
+    hub: MegaD = hass.data[DOMAIN][id]
-    task: asyncio.Task = _POLL_TASKS.pop(id)
+    if hub is None:
        return
    _LOGGER.debug(f'remove {id}')
    _hubs.pop(id, None)
    hass.data[DOMAIN].pop(id, None)
    hass.data[DOMAIN][CONF_ALL].pop(id, None)
    task: asyncio.Task = _POLL_TASKS.pop(id, None)
    if task is not None:
        task.cancel()
-    _hubs.pop(entry.entry_id)
+    if hub is None:
-    unsub = _subs.pop(entry.entry_id)
+        return
-    unsub()
+    await hub.stop()
-@bind_hass
+async def async_migrate_entry(hass, config_entry: ConfigEntry):
-async def _save_service(hass: HomeAssistant, mega_id=None):
+    """Migrate old entry."""
    _LOGGER.debug("Migrating from version %s to version %s", config_entry.version, ConfigFlow.VERSION)
    hub = await get_hub(hass, config_entry)
    new = dict(config_entry.data)
    await hub.start()
    cfg = await hub.get_config()
    await hub.stop()
    new.update(cfg)
    _LOGGER.debug(f'new config: %s', new)
    config_entry.data = new
    config_entry.version = ConfigFlow.VERSION
    _LOGGER.info("Migration to version %s successful", config_entry.version)
    return True
 async def _save_service(hass: HomeAssistant, call: ServiceCall):
    mega_id = call.data.get('mega_id')
    if mega_id:
        hub: MegaD = hass.data[DOMAIN][mega_id]
        await hub.save()
    else:
        for hub in hass.data[DOMAIN].values():
            if isinstance(hub, MegaD):
                await hub.save()
@bind_hass
-async def _get_port(hass: HomeAssistant, port=None, mega_id=None):
+async def _get_port(hass: HomeAssistant, call: ServiceCall):
    port = call.data.get('port')
    mega_id = call.data.get('mega_id')
    if mega_id:
        hub: MegaD = hass.data[DOMAIN][mega_id]
        if port is None:
-            await hub.get_all_ports()
+            await hub.get_all_ports(check_skip=True)
-        else:
+        elif isinstance(port, int):
            await hub.get_port(port)
        elif isinstance(port, list):
            for x in port:
                await hub.get_port(x)
    else:
-        for hub in hass.data[DOMAIN].values():
+        for hub in hass.data[DOMAIN][CONF_ALL].values():
            if not isinstance(hub, MegaD):
                continue
            if port is None:
-                await hub.get_all_ports()
+                await hub.get_all_ports(check_skip=True)
-            else:
+            elif isinstance(port, int):
                await hub.get_port(port)
            elif isinstance(port, list):
                for x in port:
                    await hub.get_port(x)
@bind_hass
-async def _run_cmd(hass: HomeAssistant, port: int, cmd: str, mega_id=None):
+async def _run_cmd(hass: HomeAssistant, call: ServiceCall):
    mega_id = call.data.get('mega_id')
    cmd = call.data.get('cmd')
    if mega_id:
        hub: MegaD = hass.data[DOMAIN][mega_id]
-        await hub.send_command(port=port, cmd=cmd)
+        await hub.request(cmd=cmd)
    else:
        for hub in hass.data[DOMAIN].values():
-            await hub.send_command(port=port, cmd=cmd)
+            await hub.request(cmd=cmd)
--- a/custom_components/mega/binary_sensor.py
+++ b/custom_components/mega/binary_sensor.py
@@ -1,6 +1,4 @@
 """Platform for light integration."""
 import asyncio
 import json
 import logging
 import voluptuous as vol
@@ -12,17 +10,18 @@ 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 homeassistant.helpers.restore_state import RestoreEntity
+from homeassistant.helpers.template import Template
-from .entities import BaseMegaEntity
+from .const import EVENT_BINARY_SENSOR, DOMAIN, CONF_CUSTOM, CONF_SKIP, CONF_INVERT, CONF_RESPONSE_TEMPLATE
-
+from .entities import  MegaPushEntity
 from .hub import MegaD
 lg = logging.getLogger(__name__)
@@ -42,20 +41,7 @@ PLATFORM_SCHEMA = SENSOR_SCHEMA.extend(
 async def async_setup_platform(hass, config, add_entities, discovery_info=None):
-    config.pop(CONF_PLATFORM)
+    lg.warning('mega integration does not support yaml for binary_sensors, please use UI configuration')
    ents = []
    for mid, _config in config.items():
        for x in _config:
            if isinstance(x, int):
                ent = MegaBinarySensor(
                    mega_id=mid, port=x
                )
            else:
                ent = MegaBinarySensor(
                    mega_id=mid, port=x[CONF_PORT], name=x[CONF_NAME]
                )
            ents.append(ent)
    add_entities(ents)
    return True
@@ -63,26 +49,61 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
    mid = config_entry.data[CONF_ID]
    hub: MegaD = hass.data['mega'][mid]
    devices = []
-    async for port, pty, m in hub.scan_ports():
+    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {})
-        if pty == "0":
+    for port, cfg in config_entry.data.get('binary_sensor', {}).items():
-            sensor = MegaBinarySensor(mega_id=mid, port=port)
+        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=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)
        self._is_on = None
        self._attrs = None
    @property
    def state_attributes(self):
        return self._attrs
    @property
    def invert(self):
        return self.customize.get(CONF_INVERT, False)
    @property
    def is_on(self) -> bool:
-        if self._is_on is not None:
+        val = self.mega.values.get(self.port, {}).get("value") \
-            return self._is_on
+              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:
            if val in ['ON', 'OFF']:
                return val == 'ON' if not self.invert else val == 'OFF'
            else:
                return val != 1 if not self.invert else val == 1
    def _update(self, payload: dict):
-        val = payload.get("value")
+        self.mega.values[self.port] = payload
-        self._is_on = val == 'ON'
+        if not self.mega.mqtt_inputs:
            return
        template: Template = self.customize.get(CONF_RESPONSE_TEMPLATE, None)
        if template is not None:
            template.hass = self.hass
            ret = template.async_render(payload)
            self.mega.lg.debug(f'response: %s', ret)
            self.hass.async_create_task(
                self.mega.request(pt=self.port, cmd=ret)
            )
        elif self.mega.force_d:
            self.mega.lg.debug(f'response d')
            self.hass.async_create_task(
                self.mega.request(pt=self.port, cmd='d')
            )
--- 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
@@ -8,8 +8,9 @@ from homeassistant import config_entries, core
 from homeassistant.components import mqtt
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_ID, CONF_PASSWORD, CONF_SCAN_INTERVAL
-from homeassistant.core import callback
+from homeassistant.core import callback, HomeAssistant
-from .const import DOMAIN, CONF_PORT_TO_SCAN, CONF_RELOAD, CONF_INVERT  # pylint:disable=unused-import
+from .const import DOMAIN, CONF_PORT_TO_SCAN, CONF_RELOAD, PLATFORMS, CONF_MQTT_INPUTS, \
    CONF_NPORTS, CONF_UPDATE_ALL, CONF_POLL_OUTS  # pylint:disable=unused-import
 from .hub import MegaD
 from . import exceptions
@@ -17,15 +18,30 @@ _LOGGER = logging.getLogger(__name__)
 STEP_USER_DATA_SCHEMA = vol.Schema(
    {
-        vol.Required(CONF_ID, default='def'): str,
+        vol.Required(CONF_ID, default='mega'): 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_POLL_OUTS, default=False): bool,
        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,
    },
 )
 async def get_hub(hass: HomeAssistant, data):
    _mqtt = hass.data.get(mqtt.DOMAIN)
    # if not isinstance(_mqtt, mqtt.MQTT):
    #     raise exceptions.MqttNotConfigured("mqtt must be configured first")
    hub = MegaD(hass, **data, lg=_LOGGER, mqtt=_mqtt, loop=asyncio.get_event_loop())
    hub.mqtt_id = await hub.get_mqtt_id()
    if not await hub.authenticate():
        raise exceptions.InvalidAuth
    return hub
 async def validate_input(hass: core.HomeAssistant, data):
    """Validate the user input allows us to connect.
@@ -33,12 +49,7 @@ async def validate_input(hass: core.HomeAssistant, data):
    """
    if data[CONF_ID] in hass.data.get(DOMAIN, []):
        raise exceptions.DuplicateId('duplicate_id')
-    _mqtt = hass.data.get(mqtt.DOMAIN)
+    hub = await get_hub(hass, data)
    if not isinstance(_mqtt, mqtt.MQTT):
        raise exceptions.MqttNotConfigured("mqtt must be configured first")
    hub = MegaD(hass, **data, lg=_LOGGER, mqtt=_mqtt)
    if not await hub.authenticate():
        raise exceptions.InvalidAuth
    return hub
@@ -46,7 +57,7 @@ async def validate_input(hass: core.HomeAssistant, data):
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
    """Handle a config flow for mega."""
-    VERSION = 1
+    VERSION = 4
    CONNECTION_CLASS = config_entries.CONN_CLASS_ASSUMED
    async def async_step_user(self, user_input=None):
@@ -59,7 +70,16 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
        errors = {}
        try:
-            await validate_input(self.hass, user_input)
+            hub = await validate_input(self.hass, user_input)
            await hub.start()
            config = await hub.get_config(nports=user_input.get(CONF_NPORTS, 37))
            await hub.stop()
            hub.lg.debug(f'config loaded: %s', config)
            config.update(user_input)
            return self.async_create_entry(
                title=user_input.get(CONF_ID, user_input[CONF_HOST]),
                data=config,
            )
        except exceptions.CannotConnect:
            errors["base"] = "cannot_connect"
        except exceptions.InvalidAuth:
@@ -69,11 +89,6 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
        except Exception as exc:  # pylint: disable=broad-except
            _LOGGER.exception("Unexpected exception")
            errors[CONF_ID] = str(exc)
        else:
            return self.async_create_entry(
                title=user_input.get(CONF_ID, user_input[CONF_HOST]),
                data=user_input,
            )
        return self.async_show_form(
            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
@@ -92,18 +107,37 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
    async def async_step_init(self, user_input=None):
        """Manage the options."""
        if user_input is not None:
            reload = user_input.pop(CONF_RELOAD)
            cfg = dict(self.config_entry.data)
            cfg.update(user_input)
            hub = await get_hub(self.hass, self.config_entry.data)
            if reload:
                await hub.start()
                new = await hub.get_config(nports=user_input.get(CONF_NPORTS, 37))
                await hub.stop()
                _LOGGER.debug(f'new config: %s', new)
                cfg = dict(self.config_entry.data)
                for x in PLATFORMS:
                    cfg.pop(x, None)
                cfg.update(new)
            return self.async_create_entry(
                title='',
-                data={**user_input, **{CONF_ID: self.config_entry.data[CONF_ID]}},
+                data=cfg,
            )
        e = self.config_entry.data
        ret = self.async_show_form(
            step_id="init",
            data_schema=vol.Schema({
-                vol.Optional(CONF_SCAN_INTERVAL, default=e[CONF_SCAN_INTERVAL]): int,
+                vol.Optional(CONF_SCAN_INTERVAL, default=e.get(CONF_SCAN_INTERVAL, 0)): int,
                vol.Optional(CONF_POLL_OUTS, default=e.get(CONF_POLL_OUTS, False)): bool,
                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,
            }),
        )
--- 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"
@@ -12,3 +13,36 @@ W1BUS = 'w1bus'
 CONF_PORT_TO_SCAN = 'port_to_scan'
 CONF_RELOAD = 'reload'
 CONF_INVERT = 'invert'
 CONF_PORTS = 'ports'
 CONF_CUSTOM = '__custom'
 CONF_HTTP = '__http'
 CONF_ALL = '__all'
 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'
 CONF_ALLOW_HOSTS = 'allow_hosts'
 CONF_CONV_TEMPLATE = 'conv_template'
 CONF_POLL_OUTS = 'poll_outs'
 CONF_FORCE_D = 'force_d'
 PLATFORMS = [
    "light",
    "switch",
    "binary_sensor",
    "sensor",
 ]
 EVENT_BINARY_SENSOR = f'{DOMAIN}.sensor'
 EVENT_BINARY = f'{DOMAIN}.binary'
 PATT_SPLIT = re.compile('[;/]')
 LONG = 'long'
 RELEASE = 'release'
 LONG_RELEASE = 'long_release'
 PRESS = 'press'
 LUX = 'lux'
 SINGLE_CLICK = 'single'
 DOUBLE_CLICK = 'double'
--- a/custom_components/mega/entities.py
+++ b/custom_components/mega/entities.py
@@ -1,36 +1,90 @@
 import logging
 import asyncio
-import json
+from homeassistant.config_entries import ConfigEntry
-import logging
+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 . import hub as h
 from .const import DOMAIN, CONF_CUSTOM, CONF_INVERT, EVENT_BINARY_SENSOR, LONG, \
    LONG_RELEASE, RELEASE, PRESS, SINGLE_CLICK, DOUBLE_CLICK, EVENT_BINARY
 _events_on = False
 _LOGGER = logging.getLogger(__name__)
-class BaseMegaEntity(RestoreEntity):
+async def _set_events_on():
    global _events_on, _task_set_ev_on
    await asyncio.sleep(10)
    _LOGGER.debug('events on')
    _events_on = True
 def set_events_off():
    global _events_on, _task_set_ev_on
    _events_on = False
    _task_set_ev_on = None
 _task_set_ev_on = None
 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: 'h.MegaD',
            port: int,
            config_entry: ConfigEntry = None,
            id_suffix=None,
            name=None,
-            unique_id=None
+            unique_id=None,
    ):
        super().__init__(mega.updater)
        self._state: State = None
        self.port = port
-        self._mega_id = mega_id
+        self.config_entry = config_entry
        self.mega = mega
        mega.entities.append(self)
        self._mega_id = mega.id
        self._lg = None
-        self._unique_id = unique_id or f"mega_{mega_id}_{port}" + \
+        self._unique_id = unique_id or f"mega_{mega.id}_{port}" + \
                                       (f"_{id_suffix}" if id_suffix else "")
-        self._name = name or f"{mega_id}_{port}" + \
+        self._name = name or f"{mega.id}_{port}" + \
                            (f"_{id_suffix}" if id_suffix else "")
        self._customize: dict = None
    @property
    def customize(self):
        if self.hass is None:
            return {}
        if self._customize is None:
            c = self.hass.data.get(DOMAIN, {}).get(CONF_CUSTOM) or {}
            c = c.get(self._mega_id) or {}
            c = c.get(self.port) or {}
            self._customize = c
        return self._customize
    @property
    def device_info(self):
        return {
            "identifiers": {
                # Serial numbers are unique identifiers within a specific domain
                (DOMAIN, f'{self._mega_id}', self.port),
            },
            "config_entries": [
                self.config_entry,
            ],
            "name": f'{self._mega_id} port {self.port}',
            "manufacturer": 'ab-log.ru',
            # "model": self.light.productname,
            # "sw_version": self.light.swversion,
            "via_device": (DOMAIN, self._mega_id),
        }
    @property
    def lg(self) -> logging.Logger:
@@ -38,38 +92,177 @@ class BaseMegaEntity(RestoreEntity):
            self._lg = self.mega.lg.getChild(self._name or self.unique_id)
        return self._lg
    @property
    def mega(self) -> MegaD:
        return self.hass.data[DOMAIN][self._mega_id]
    @property
    def available(self) -> bool:
        return self.mega.online
    @property
    def name(self):
-        return self._name or f"{self.mega.id}_p{self.port}"
+        c = self.customize.get(CONF_NAME)
        if not isinstance(c, str):
            c = self._name or f"{self.mega.id}_p{self.port}"
        return c
    @property
    def unique_id(self):
        return self._unique_id
    async def async_added_to_hass(self) -> None:
-        await self.mega.subscribe(self.port, callback=self.__update)
+        global _task_set_ev_on
        await super().async_added_to_hass()
        self._state = await self.async_get_last_state()
-        await asyncio.sleep(0.1)
+        if self.mega.mqtt_inputs and _task_set_ev_on is None:
-        await self.mega.get_port(self.port)
+            _task_set_ev_on = asyncio.create_task(_set_events_on())
-    def __update(self, msg):
+    async def get_state(self):
-        try:
+        if self.mega.mqtt is None:
-            value = json.loads(msg.payload)
+            self.async_write_ha_state()
-        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)
        self.is_first_update = True
    def __update(self, value: dict):
        self._update(value)
-        self.hass.async_create_task(self.async_update_ha_state())
+        self.async_write_ha_state()
        self.lg.debug(f'state after update %s', self.state)
        if self.mega.mqtt_inputs and not _events_on:
            _LOGGER.debug('skip event because events are off')
            return
        if not self.entity_id.startswith('binary_sensor'):
            _LOGGER.debug('skip event because not a bnary sens')
            return
        ll: bool = self.mega.last_long.get(self.port, False)
        if safe_int(value.get('click', 0)) == 1:
            self.hass.bus.async_fire(
                event_type=EVENT_BINARY,
                event_data={
                    'entity_id': self.entity_id,
                    'type': SINGLE_CLICK
                }
            )
        elif safe_int(value.get('click', 0)) == 2:
            self.hass.bus.async_fire(
                event_type=EVENT_BINARY,
                event_data={
                    'entity_id': self.entity_id,
                    'type': DOUBLE_CLICK
                }
            )
        elif safe_int(value.get('m', 0)) == 2:
            self.mega.last_long[self.port] = True
            self.hass.bus.async_fire(
                event_type=EVENT_BINARY,
                event_data={
                    'entity_id': self.entity_id,
                    'type': LONG
                }
            )
        elif safe_int(value.get('m', 0)) == 1:
            self.hass.bus.async_fire(
                event_type=EVENT_BINARY,
                event_data={
                    'entity_id': self.entity_id,
                    'type': LONG_RELEASE if ll else RELEASE,
                }
            )
        elif safe_int(value.get('m', None)) == 0:
            self.hass.bus.async_fire(
                event_type=EVENT_BINARY,
                event_data={
                    'entity_id': self.entity_id,
                    'type': PRESS,
                }
            )
            self.mega.last_long[self.port] = False
        return
    def _update(self, payload: dict):
-        raise NotImplementedError
+        pass
    async def async_added_to_hass(self) -> None:
        await super().async_added_to_hass()
        if self.mega.mqtt is not None:
            asyncio.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):
        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:
        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:
                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
        if self.dimmer and brightness == 0:
            cmd = 255
        elif self.dimmer:
            cmd = brightness
        else:
            cmd = 1 if not self.invert else 0
        await self.mega.request(cmd=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"
        await self.mega.request(cmd=f"{self.port}:{cmd}")
        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, TypeError):
        return None
--- a/custom_components/mega/exceptions.py
+++ b/custom_components/mega/exceptions.py
@@ -15,3 +15,7 @@ class DuplicateId(exceptions.HomeAssistantError):
 class InvalidAuth(exceptions.HomeAssistantError):
    """Error to indicate there is invalid auth."""
 class NoPort(Exception):
    pass
--- a/custom_components/mega/http.py
+++ b/custom_components/mega/http.py
@@ -0,0 +1,84 @@
 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 homeassistant.components.http import HomeAssistantView
 from homeassistant.core import HomeAssistant
 from .const import EVENT_BINARY_SENSOR, DOMAIN, CONF_RESPONSE_TEMPLATE
 from .tools import make_ints
 from . import hub as h
 _LOGGER = logging.getLogger(__name__).getChild('http')
 class MegaView(HomeAssistantView):
    url = '/mega'
    name = 'mega'
    requires_auth = False
    def __init__(self, cfg: dict):
        self._try = 0
        self.allowed_hosts = {'::1'}
        self.callbacks = defaultdict(lambda: 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 isinstance(pt, int) and CONF_RESPONSE_TEMPLATE in cfg[mid][pt]
            } for mid in cfg if isinstance(cfg[mid], dict)
        }
        _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: 'h.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()
        data['mega_id'] = hub.id
        ret = 'd'
        if port is not None:
            hub.values[port] = data
            for cb in self.callbacks[hub.id][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={'Server': 's', 'Date': 'n'})
        return ret
    async def later_update(self, hub):
        _LOGGER.debug('force update')
        await asyncio.sleep(1)
        await hub.updater.async_refresh()
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -1,17 +1,58 @@
 import asyncio
 import json
 import logging
-from datetime import datetime
+from collections import defaultdict
-from functools import wraps
+from datetime import datetime, timedelta
 import aiohttp
 import typing
-from bs4 import BeautifulSoup
+import re
 import json
 from bs4 import BeautifulSoup
 from homeassistant.components import mqtt
 from homeassistant.const import (
    DEVICE_CLASS_TEMPERATURE, DEVICE_CLASS_HUMIDITY, DEVICE_CLASS_PRESSURE,
    DEVICE_CLASS_ILLUMINANCE, TEMP_CELSIUS, PERCENTAGE, LIGHT_LUX
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
-from .exceptions import CannotConnect
+from .const import (
    TEMP, HUM, PRESS,
    LUX, PATT_SPLIT, DOMAIN,
    CONF_HTTP, EVENT_BINARY_SENSOR, CONF_CUSTOM, CONF_FORCE_D
 )
 from .entities import set_events_off, BaseMegaEntity
 from .exceptions import CannotConnect, NoPort
 from .tools import make_ints
 TEMP_PATT = re.compile(r'temp:([01234567890\.]+)')
 HUM_PATT = re.compile(r'hum:([01234567890\.]+)')
 PRESS_PATT = re.compile(r'press:([01234567890\.]+)')
 LUX_PATT = re.compile(r'lux:([01234567890\.]+)')
 PATTERNS = {
    TEMP: TEMP_PATT,
    HUM: HUM_PATT,
    PRESS: PRESS_PATT,
    LUX: LUX_PATT
 }
 UNITS = {
    TEMP: TEMP_CELSIUS, 
    HUM: PERCENTAGE,
    PRESS: 'mmHg',
    LUX: LIGHT_LUX
 }
 CLASSES = {
    TEMP: DEVICE_CLASS_TEMPERATURE,
    HUM: DEVICE_CLASS_HUMIDITY,
    PRESS: DEVICE_CLASS_PRESSURE,
    LUX: DEVICE_CLASS_ILLUMINANCE
 }
 I2C_DEVICE_TYPES = {
    "2":  LUX,  # BH1750
    "3":  LUX,  # TSL2591
    "7":  LUX,  # MAX44009
    "70": LUX,  # OPT3001
 }
 class MegaD:
@@ -20,97 +61,151 @@ class MegaD:
    def __init__(
            self,
            hass: HomeAssistant,
            loop: asyncio.AbstractEventLoop,
            host: str,
            password: str,
            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,
            poll_outs=False,
            **kwargs,
    ):
        """Initialize."""
        if mqtt_inputs is None or mqtt_inputs == 'None' or mqtt_inputs is False:
            self.http = hass.data.get(DOMAIN, {}).get(CONF_HTTP)
            if not self.http is None:
                self.http.allowed_hosts |= {host}
        else:
            self.http = None
        self.poll_outs = poll_outs
        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
        self.sec = password
        self.mqtt = mqtt
        self.id = id
        self.lck = asyncio.Lock()
-        self.is_alive = asyncio.Condition()
+        self.last_long = {}
        self._http_lck = asyncio.Lock()
        self._notif_lck = asyncio.Lock()
        self.cnd = asyncio.Condition()
        self.online = True
-        self.entities: typing.List[Entity] = []
+        self.entities: typing.List[BaseMegaEntity] = []
        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._customize = None
        self.values = {}
        self.last_port = None
        self.updater = DataUpdateCoordinator(
            hass,
            self.lg,
            name="sensors",
            update_method=self.poll,
            update_interval=timedelta(seconds=self.poll_interval) if self.poll_interval else None,
        )
        self.notifiers = defaultdict(asyncio.Condition)
        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()
        if self.mqtt is not None:
            set_events_off()
            self.subs = await self.mqtt.async_subscribe(
                topic=f"{self.mqtt_id}/+",
                msg_callback=self._process_msg,
                qos=0,
            )
    async def stop(self):
        if self.subs is not None:
            self.subs()
        for x in self._callbacks.values():
            x.clear()
    async def add_entity(self, ent):
        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 = {x.port for x in self.sensors}
+        ports = []
-        for x in _ports:
+        for x in self.sensors:
-            await self.get_port(x)
+            if only_list and x.http_cmd != 'list':
-            await asyncio.sleep(0.1)
+                continue
            if x.port in ports:
                continue
            await self.get_port(x.port, force_http=True, http_cmd=x.http_cmd)
            ports.append(x.port)
-    async def poll(self):
+    @property
-        """
+    def customize(self):
-        Send get port 0 every poll_interval. When answer is received, mega.<id> becomes online else mega.<id> becomes
+        if self._customize is None:
-        offline
+            c = self.hass.data.get(DOMAIN, {}).get(CONF_CUSTOM) or {}
-        """
+            c = c.get(self.id) or {}
-        self._loop = asyncio.get_event_loop()
+            self._customize = c
        return self._customize
-        while True:
+    @property
-            if len(self.sensors) > 0:
+    def force_d(self):
-                await self.get_sensors()
+        return self.customize.get(CONF_FORCE_D, False)
            else:
                await self.get_port(self.port_to_scan)
-            await asyncio.sleep(1)
+    @property
-            if (datetime.now() - self.last_update).total_seconds() > self.poll_interval:
+    def is_online(self):
-                await self.get_port(self.port_to_scan)
+        return (datetime.now() - self.last_update).total_seconds() < (self.poll_interval + 10)
-                await asyncio.sleep(1)
+
-                if (datetime.now() - self.last_update).total_seconds() > self.poll_interval:
+    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
-            else:
+
    def _notify_online(self):
        if not self.online:
            self.hass.states.async_set(
                f'mega.{self.id}',
                'online',
            )
            self.online = True
-            for x in self.entities:
+    async def poll(self):
-                try:
+        """
-                    await x.async_update_ha_state()
+        Polling ports
-                except RuntimeError:
+        """
-                    pass
+        self.lg.debug('poll')
-            await asyncio.sleep(self.poll_interval - 1)
+        if self.mqtt is None:
-
+            await self.get_all_ports()
-    async def _async_notify(self):
+            await self.get_sensors(only_list=True)
-        async with self.is_alive:
+        elif self.poll_outs:
-            self.is_alive.notify_all()
+            await self.get_all_ports(check_skip=True)
-
+        elif len(self.sensors) > 0:
-    def _notify(self, *args):
+            await self.get_sensors()
-        asyncio.run_coroutine_threadsafe(self._async_notify(), self._loop)
+        else:
            await self.get_port(self.port_to_scan)
        return self.values
    async def get_mqtt_id(self):
        async with aiohttp.request(
@@ -124,91 +219,153 @@ class MegaD:
            return _id or 'megad/' + self.host.split('.')[-1]
    async def send_command(self, port=None, cmd=None):
-        if port:
+        return await self.request(pt=port, cmd=cmd)
-            url = f"http://{self.host}/{self.sec}/?pt={port}&cmd={cmd}"
+
-        else:
+    async def request(self, **kwargs):
-            url = f"http://{self.host}/{self.sec}/?cmd={cmd}"
+        cmd = '&'.join([f'{k}={v}' for k, v in kwargs.items() if v is not None])
-        self.lg.debug('run command: %s', url)
+        url = f"http://{self.host}/{self.sec}/?{cmd}"
-        async with self.lck:
+        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
+                    ret = await req.text()
                    self.lg.debug('response %s', ret)
                    return ret
    async def save(self):
        await self.send_command(cmd='s')
-    async def get_port(self, port, get_value=False):
+    def parse_response(self, ret):
-        if get_value:
+        if ret is None:
-            ftr = asyncio.get_event_loop().create_future()
+            raise NoPort()
        if 'busy' in ret:
            return None
        if ':' in ret:
            ret = PATT_SPLIT.split(ret)
            ret = {'value': 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
-            def cb(msg):
+    async def get_port(self, port, force_http=False, http_cmd='get'):
-                try:
+        """
-                    ftr.set_result(json.loads(msg.payload).get('value'))
+        Запрос состояния порта. Состояние всегда возвращается в виде объекта, всегда сохраняется в центральное
-                except Exception as exc:
+        хранилище values
-                    self.lg.warning(f'could not parse {msg.payload}: {exc}')
+        """
-                    ftr.set_result(None)
+        self.lg.debug(f'get port %s', port)
-            unsub = await self.mqtt.async_subscribe(
+        if self.mqtt is None or force_http:
-                topic=f'{self.mqtt_id}/{port}',
+            if http_cmd == 'list':
-                msg_callback=cb,
+                await self.request(pt=port, cmd='conv')
-                qos=1,
+                await asyncio.sleep(1)
-            )
+            ret = self.parse_response(await self.request(pt=port, cmd=http_cmd))
            ntry = 0
            while http_cmd == 'list' and ret is None and ntry < 3:
                await asyncio.sleep(1)
                ret = self.parse_response(await self.request(pt=port, cmd=http_cmd))
                ntry += 1
            self.lg.debug('parsed: %s', ret)
            self.values[port] = ret
            return ret
-        self.lg.debug(
+        async with self._notif_lck:
-            f'get port: %s', port
+            async with self.notifiers[port]:
-        )
+                cnd = self.notifiers[port]
        async with self.lck:
                await self.mqtt.async_publish(
                    topic=f'{self.mqtt_id}/cmd',
                    payload=f'get:{port}',
-                qos=0,
+                    qos=2,
                    retain=False,
                )
            await asyncio.sleep(0.1)
        if get_value:
                try:
-                return await asyncio.wait_for(ftr, timeout=2)
+                    await asyncio.wait_for(cnd.wait(), timeout=10)
                    return self.values.get(port)
                except asyncio.TimeoutError:
-                self.lg.warning(f'timeout on port {port}')
+                    self.lg.error(f'timeout when getting port {port}')
            finally:
                unsub()
-    async def get_all_ports(self):
+    @property
-        for x in range(37):
+    def ports(self):
-            asyncio.create_task(self.get_port(x))
+        return {e.port for e in self.entities}
    async def get_all_ports(self, only_out=False, check_skip=False):
        if not self.mqtt_inputs:
            ret = await self.request(cmd='all')
            for port, x in enumerate(ret.split(';')):
                if check_skip and not port in self.ports:
                    continue
                ret = self.parse_response(x)
                self.values[port] = ret
        elif not check_skip:
            for x in range(self.nports + 1):
                await self.get_port(x)
        else:
            for x in self.ports:
                await self.get_port(x)
    async def reboot(self, save=True):
        await self.save()
        # await self.send_command(cmd=)
-    async def subscribe(self, port, callback):
+    async def _notify(self, port, value):
        async with self.notifiers[port]:
            cnd = self.notifiers[port]
            cnd.notify_all()
-        @wraps(callback)
+    def _process_msg(self, msg):
-        def wrapper(msg):
+        try:
            d = msg.topic.split('/')
            port = d[-1]
        except ValueError:
            self.lg.warning('can not process %s', msg)
            return
        if port == 'cmd':
            return
        try:
            port = int(port)
        except:
            self.lg.warning('can not process %s', msg)
            return
        self.lg.debug(
            'process incomming message: %s', msg
        )
-            self.last_update = datetime.now()
+        value = None
-            return callback(msg)
+        try:
            value = json.loads(msg.payload)
            if isinstance(value, dict):
                make_ints(value)
            self.values[port] = value
            for cb in self._callbacks[port]:
                cb(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
        finally:
            asyncio.run_coroutine_threadsafe(self._notify(port, value), self.loop)
    def subscribe(self, port, callback):
        port = int(port)
        self.lg.debug(
-            f'subscribe %s %s', port, wrapper
+            f'subscribe %s %s', port, callback
        )
-        subs = await self.mqtt.async_subscribe(
+        if self.mqtt_inputs:
-            topic=f"{self.mqtt_id}/{port}",
+            self._callbacks[port].append(callback)
-            msg_callback=wrapper,
+        else:
-            qos=0,
+            self.http.callbacks[self.id][port].append(callback)
        )
        self.subscriptions.append(subs)
    def unsubscribe_all(self):
        self.lg.info('unsubscribe')
        for x in self.subscriptions:
            self.lg.debug('unsubscribe %s', x)
            x()
    async def authenticate(self) -> bool:
        """Test if we can authenticate with the host."""
@@ -227,6 +384,7 @@ class MegaD:
            return await req.text()
    async def scan_port(self, port):
        async with self.lck:
            if port in self._scanned:
                return self._scanned[port]
            url = f'http://{self.host}/{self.sec}/?pt={port}'
@@ -235,6 +393,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:
@@ -257,9 +417,59 @@ class MegaD:
                    m = m.find(selected=True)['value']
                self._scanned[port] = (pty, m)
                return pty, m
            elif pty in ('2', '4'):  # эта часть не очень проработана, тут есть i2c который может работать неправильно
                m = tree.find('select', attrs={'name': 'd'})
                if m:
                    m = m.find(selected=True)['value']
                self._scanned[port] = (pty, m or '0')
                return pty, m or '0'
-    async def scan_ports(self,):
+    async def scan_ports(self, nports=37):
-        for x in range(37):
+        for x in range(0, nports+1):
            ret = await self.scan_port(x)
            if ret:
                yield [x, *ret]
        self.nports = nports+1
    async def get_config(self, nports=37):
        ret = defaultdict(lambda: defaultdict(list))
        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'] or m is None):
                ret['light'][port].append({'dimmer': m == '1'})
            elif pty in ('3', '2', '4'):
                try:
                    http_cmd = 'get'
                    values = await self.get_port(port, force_http=True)
                    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:
                    self.lg.warning(f'timout on port {port}')
                    continue
                self.lg.debug(f'values: %s', values)
                if values is None:
                    self.lg.warning(f'port {port} is of type sensor but response is None, skipping it')
                    continue
                if isinstance(values, dict) and 'value' in values:
                    values = values['value']
                if isinstance(values, str) and TEMP_PATT.search(values):
                    values = {TEMP: values}
                elif not isinstance(values, dict):
                    if pty == '4' and m in I2C_DEVICE_TYPES:
                        values = {I2C_DEVICE_TYPES[m]: values}
                    else:
                        values = {None: values}
                for key in values:
                    self.lg.debug(f'add sensor {key}')
                    ret['sensor'][port].append(dict(
                        key=key,
                        unit_of_measurement=UNITS.get(key, UNITS[TEMP]),
                        device_class=CLASSES.get(key, CLASSES[TEMP]),
                        id_suffix=key,
                        http_cmd=http_cmd,
                    ))
        return ret
--- a/custom_components/mega/light.py
+++ b/custom_components/mega/light.py
@@ -1,8 +1,5 @@
 """Platform for light integration."""
 import asyncio
 import json
 import logging
 import voluptuous as vol
 from homeassistant.components.light import (
@@ -13,18 +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 homeassistant.helpers.restore_state import RestoreEntity
+from .entities import MegaOutPort
 from .entities import BaseMegaEntity
 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__)
@@ -50,29 +51,7 @@ PLATFORM_SCHEMA = LIGHT_SCHEMA.extend(
 async def async_setup_platform(hass, config, add_entities, discovery_info=None):
-    config.pop(CONF_PLATFORM)
+    lg.warning('mega integration does not support yaml for lights, please use UI configuration')
    ents = []
    for mid, _config in config.items():
        for x in _config["dimmer"]:
            if isinstance(x, int):
                ent = MegaLight(
                    mega_id=mid, port=x, dimmer=True)
            else:
                ent = MegaLight(
                    mega_id=mid, port=x[CONF_PORT], name=x[CONF_NAME], dimmer=True
                )
            ents.append(ent)
        for x in _config["switch"]:
            if isinstance(x, int):
                ent = MegaLight(
                    mega_id=mid, port=x, dimmer=False
                )
            else:
                ent = MegaLight(
                    mega_id=mid, port=x[CONF_PORT], name=x[CONF_NAME], dimmer=False
                )
            ents.append(ent)
    add_entities(ents)
    return True
@@ -80,75 +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 = []
-    async for port, pty, m in hub.scan_ports():
+    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {})
-        if pty == "1" and m in ['0', '1']:
+    for port, cfg in config_entry.data.get('light', {}).items():
-            light = MegaLight(mega_id=mid, port=port, dimmer=m == '1')
+        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=hub, port=port, config_entry=config_entry, **data)
            devices.append(light)
    async_add_devices(devices)
-class MegaLight(LightEntity, BaseMegaEntity):
+class MegaLight(MegaOutPort, LightEntity):
    def __init__(
            self,
            dimmer=False,
            *args, **kwargs
    ):
        super().__init__(
            *args, **kwargs
        )
        self._brightness = None
        self._is_on = None
        self.dimmer = dimmer
    @property
    def brightness(self):
        if self._brightness is not None:
            return self._brightness
        if self._state:
            return self._state.attributes.get("brightness")
    @property
    def supported_features(self):
        return SUPPORT_BRIGHTNESS if self.dimmer else 0
    @property
    def is_on(self) -> bool:
        if self._is_on is not None:
            return self._is_on
        return self._state == 'ON'
    async def async_turn_on(self, brightness=None, **kwargs) -> None:
        brightness = brightness or self.brightness
        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'
--- a/custom_components/mega/manifest.json
+++ b/custom_components/mega/manifest.json
@@ -10,11 +10,10 @@
  "ssdp": [],
  "zeroconf": [],
  "homekit": {},
-  "dependencies": [
+  "after_dependencies": ["mqtt"],
    "mqtt"
  ],
  "codeowners": [
    "@andvikt"
  ],
-  "issue_tracker": "https://github.com/andvikt/mega_hacs/issues"
+  "issue_tracker": "https://github.com/andvikt/mega_hacs/issues",
  "version": "v0.3.17"
 }
--- a/custom_components/mega/sensor.py
+++ b/custom_components/mega/sensor.py
@@ -1,7 +1,5 @@
 """Platform for light integration."""
 import logging
 import typing
 import voluptuous as vol
 from homeassistant.components.sensor import (
@@ -12,15 +10,15 @@ 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 homeassistant.helpers.template import Template
-from .const import CONF_KEY, TEMP, HUM, W1, W1BUS
+from .entities import MegaPushEntity
 from .const import CONF_KEY, TEMP, HUM, W1, W1BUS, CONF_CONV_TEMPLATE
 from .hub import MegaD
 import re
@@ -60,17 +58,11 @@ PLATFORM_SCHEMA = SENSOR_SCHEMA.extend(
 async def async_setup_platform(hass, config, add_entities, discovery_info=None):
-    config.pop(CONF_PLATFORM)
+    lg.warning('mega integration does not support yaml for sensors, please use UI configuration')
    ents = []
    for mid, _config in config.items():
        for x in _config:
            ent = _make_entity(mid, **x)
            ents.append(ent)
    add_entities(ents)
    return True
-def _make_entity(mid: str, port: int, conf: dict):
+def _make_entity(config_entry, mid: str, port: int, conf: dict):
    key = conf[CONF_KEY]
    return Mega1WSensor(
        key=key,
@@ -79,7 +71,8 @@ def _make_entity(mid: str, port: int, conf: dict):
        patt=PATTERNS.get(key),
        unit_of_measurement=UNITS.get(key, UNITS[TEMP]),  # TODO: make other units, make options in config flow
        device_class=CLASSES.get(key, CLASSES[TEMP]),
-        id_suffix=key
+        id_suffix=key,
        config_entry=config_entry
    )
@@ -87,39 +80,29 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
    mid = config_entry.data[CONF_ID]
    hub: MegaD = hass.data['mega'][mid]
    devices = []
-    async for port, pty, m in hub.scan_ports():
+    for port, cfg in config_entry.data.get('sensor', {}).items():
-        if pty == "3":
+        port = int(port)
-            values = await hub.get_port(port, get_value=True)
+        for data in cfg:
-            lg.debug(f'values: %s', values)
+            hub.lg.debug(f'add sensor on port %s with data %s', port, data)
-            if values is None:
+            sensor = Mega1WSensor(
-                continue
+                mega=hub,
            if isinstance(values, str) and TEMP_PATT.search(values):
                    values = {TEMP: values}
            elif not isinstance(values, dict):
                values = {None: values}
            for key in values:
                hub.lg.debug(f'add sensor {W1}:{key}')
                sensor = _make_entity(
                    mid=mid,
                port=port,
-                    conf={
+                config_entry=config_entry,
-                        CONF_TYPE: W1,
+                **data,
-                        CONF_KEY: key,
+            )
                    })
            devices.append(sensor)
                hub.sensors.append(sensor)
    async_add_devices(devices)
-class Mega1WSensor(BaseMegaEntity):
+class Mega1WSensor(MegaPushEntity):
    def __init__(
            self,
            unit_of_measurement,
            device_class,
            patt=None,
            key=None,
            http_cmd='get',
            *args,
            **kwargs
    ):
@@ -132,12 +115,21 @@ class Mega1WSensor(BaseMegaEntity):
        super().__init__(*args, **kwargs)
        self._value = None
        self.key = key
        self.patt = patt
        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):
        _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
@@ -152,26 +144,37 @@ class Mega1WSensor(BaseMegaEntity):
        return self._device_class
    @property
-    def should_poll(self):
+    def state(self):
-        return False
+        ret = None
        if self.key:
            try:
                ret = self.mega.values.get(self.port, {})
                if isinstance(ret, dict):
                    ret = ret.get('value', {})
                    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
        tmpl: Template = self.customize.get(CONF_CONV_TEMPLATE)
        if tmpl is not None and self.hass is not None:
            tmpl.hass = self.hass
            ret = tmpl.async_render({'value': ret})
        return ret
    @property
-    def state(self):
+    def name(self):
-        if self._value is None and self._state is not None:
+        n = super().name
-            return self._state.state
+        c = self.customize.get(CONF_NAME, {})
-        return self._value
+        if isinstance(c, dict):
-
+            c = c.get(self.key)
-    def _update(self, payload: dict):
+        return c or n
        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}')
--- a/custom_components/mega/services.yaml
+++ b/custom_components/mega/services.yaml
@@ -15,7 +15,7 @@ get_port:
      description: ID меги, можно оставить пустым, тогда будут сохранены все зарегистрированные меги
      example: "mega"
    port:
-      description: Номер порта (если не заполнять, будут запрошены все порты сразу)
+      description: Номер порта или список портов (если не заполнять, будут запрошены все порты сразу)
      example: 1
 run_cmd:
@@ -25,9 +25,10 @@ run_cmd:
    mega_id:
      description: ID меги, можно оставить пустым, тогда будут сохранены все зарегистрированные меги
      example: "mega"
    port:
      description: Номер порта (это не порт, которым мы управляем, а порт с которого шлем команду)
      example: 1
    cmd:
      description: Любая поддерживаемая мегой команда
      example: "1:0"
    port:
      description: (Deprecated, больше не нужен) Номер порта (это не порт, которым мы управляем, а порт с которого шлем команду)
      example: 1
--- a/custom_components/mega/strings.json
+++ b/custom_components/mega/strings.json
@@ -11,7 +11,11 @@
          "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%]",
          "poll_outs": "[%key:common::config_flow::data::poll_outs%]"
        }
      }
    },
@@ -32,7 +36,11 @@
          "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%]",
          "update_all": "[%key:common::config_flow::data::update_all%]",
          "poll_outs": "[%key:common::config_flow::data::poll_outs%]"
        }
      }
    }
--- a/custom_components/mega/switch.py
+++ b/custom_components/mega/switch.py
@@ -1,5 +1,4 @@
 """Platform for light integration."""
 import json
 import logging
 import voluptuous as vol
@@ -8,19 +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 homeassistant.core import HomeAssistant
-from homeassistant.helpers.restore_state import RestoreEntity
+from . import hub as h
-from .entities import BaseMegaEntity
+from .entities import MegaOutPort
 from .const import CONF_DIMMER, CONF_SWITCH, DOMAIN, CONF_CUSTOM, CONF_SKIP
-from .hub import MegaD
+_LOGGER = lg = logging.getLogger(__name__)
 from .const import CONF_DIMMER, CONF_SWITCH
 _LOGGER = logging.getLogger(__name__)
 # Validation of the user's configuration
@@ -38,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: 'h.MegaD' = hass.data['mega'][mid]
    devices = []
-    def __init__(self, *args, **kwargs):
+    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {})
-        super().__init__(*args, **kwargs)
+    for port, cfg in config_entry.data.get('light', {}).items():
-        self._is_on = None
+        port = int(port)
        c = customize.get(mid, {}).get(port, {})
        if c.get(CONF_SKIP, False) or c.get(CONF_DOMAIN, 'light') != 'switch':
            continue
        for data in cfg:
            hub.lg.debug(f'add switch on port %s with data %s', port, data)
            light = MegaSwitch(mega=hub, port=port, config_entry=config_entry, **data)
            devices.append(light)
    async_add_devices(devices)
    @property
    def is_on(self) -> bool:
        if self._is_on is not None:
            return self._is_on
        return self._state == 'ON'
-    async def async_turn_on(self, **kwargs) -> None:
+class MegaSwitch(MegaOutPort, SwitchEntity):
-        cmd = 1
+    pass
        if await self.mega.send_command(self.port, f"{self.port}:{cmd}"):
            self._is_on = True
        await self.async_update_ha_state()
    async def async_turn_off(self, **kwargs) -> None:
        cmd = "0"
        if await self.mega.send_command(self.port, f"{self.port}:{cmd}"):
            self._is_on = False
        await self.async_update_ha_state()
    def _update(self, payload: dict):
        val = payload.get("value")
        self._is_on = val == 'ON'
--- a/custom_components/mega/tools.py
+++ b/custom_components/mega/tools.py
@@ -0,0 +1,12 @@
 _params = ['m', 'click', 'cnt', 'pt']
 def make_ints(d: dict):
    for x in _params:
        try:
            d[x] = int(d.get(x, 0))
        except (ValueError, TypeError):
            pass
    if 'm' not in d:
        d['m'] = 0
    if 'click' not in d:
        d['click'] = 0
--- 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": {
@@ -17,8 +18,26 @@
                    "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)"
+                    "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
                    "nports": "Number of ports",
                    "update_all": "Update all outs when input",
                    "mqtt_inputs": "Use MQTT",
                    "poll_outs": "Poll outs"
                }
            }
        }
    },
    "options": {
        "step": {
            "init": {
                "data": {
                  "scan_interval": "Scan interval (sec), 0 - don't update",
                  "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
                  "reload": "Reload objects",
                  "mqtt_inputs": "Use MQTT",
                  "update_all": "Update all outs when input",
                  "poll_outs": "Poll outs"
                }
            }
        }
--- a/custom_components/mega/translations/ru.json
+++ b/custom_components/mega/translations/ru.json
@@ -17,8 +17,12 @@
                    "username": "Пользователь",
                    "id": "ID",
                    "mqtt_id": "MQTT id",
-                    "scan_interval": "Периодичность обновлений (сек.)",
+                    "scan_interval": "Периодичность обновлений (сек.), 0 - не обновлять",
-                    "port_to_scan": "Порт, который сканируется когда нет датчиков"
+                    "port_to_scan": "Порт, который сканируется когда нет датчиков",
                    "mqtt_inputs": "Использовать MQTT",
                    "nports": "Кол-во портов",
                    "update_all": "Обновить все выходы когда срабатывает вход",
                    "poll_outs": "Обновлять выходы (регулярно)"
                }
            }
        }
@@ -27,10 +31,14 @@
        "step": {
            "init": {
                "data": {
-                  "scan_interval": "Периодичность обновлений (сек.)",
+                  "scan_interval": "Периодичность обновлений (сек.), 0 - не обновлять",
                  "port_to_scan": "Порт, который сканируется когда нет датчиков",
                  "reload": "Обновить объекты",
-                  "invert": "Список портов (через ,) с инвертированной логикой"
+                  "invert": "Список портов (через ,) с инвертированной логикой",
                  "mqtt_inputs": "Использовать MQTT",
                    "nports": "Кол-во портов",
                    "update_all": "Обновить все выходы когда срабатывает вход",
                    "poll_outs": "Обновлять выходы (регулярно)"
                }
            }
        }
--- a/custom_components/mega/translations/uk.json
+++ b/custom_components/mega/translations/uk.json
@@ -0,0 +1,47 @@
 {
    "config": {
        "abort": {
            "already_configured": "Вже налаштовано"
        },
        "error": {
            "cannot_connect": "Неможливо підключитись",
            "invalid_auth": "Неправильний пароль",
            "unknown": "Невідома помилка",
            "duplicate_id": "Дублікат ID"
        },
        "step": {
            "user": {
                "data": {
                    "host": "Хост",
                    "password": "Пароль",
                    "username": "Користувач",
                    "id": "ID",
                    "mqtt_id": "MQTT id",
                    "scan_interval": "Період оновлення (сек.), 0 - не оновлювати",
                    "port_to_scan": "Порт для сканування при відсутності датчиків",
                    "mqtt_inputs": "Використовувати MQTT",
                    "nports": "Кількість портів",
                    "update_all": "Оновити всі виходи коли спрацьовує вхід",
                    "poll_outs": "Оновити виходи"
                }
            }
        }
    },
    "options": {
        "step": {
            "init": {
                "data": {
                  "scan_interval": "Період оновлення (сек.)",
                  "port_to_scan": "Порт для сканування при відсутності датчиків",
                  "reload": "Оновити об'єкти",
                  "invert": "Список портів з інвертованою логікою (через ,)",
                  "mqtt_inputs": "Використовувати MQTT",
                  "nports": "Кількість портів",
                  "update_all": "Оновити всі виходи коли спрацьовує вхід",
                    "poll_outs": "Оновити виходи"
                }
            }
        }
    },
    "title": "mega"
 }
--- a/readme.md
+++ b/readme.md
@@ -1,111 +1,217 @@
 # MegaD HomeAssistant custom component
-Интеграция с [MegaD-2561](https://www.ab-log.ru/smart-house/ethernet/megad-2561)
+
 # MegaD HomeAssistant integration
 [![hacs_badge](https://img.shields.io/badge/HACS-Custom-orange.svg)](https://github.com/custom-components/hacs)
 [![Donate](https://img.shields.io/badge/donate-Yandex-red.svg)](https://yoomoney.ru/to/410013955329136)
 Интеграция с [MegaD-2561, MegaD-328](https://www.ab-log.ru/smart-house/ethernet/megad-2561)
 ## Основные особенности:
- Настройка как из yaml так и из веб-интерфейса
+- Настройка в веб-интерфейсе + yaml
- При настройки из веба все порты автоматически добавляются как устройства (для обычных релейных выходов создается 
+- Все порты автоматически добавляются как устройства (для обычных релейных выходов создается 
-  `light`, для шим - `light` с поддержкой яркости, для цифровых входов `binary_sensor`, для температурных датчиков
+  `light`, для шим - `light` с поддержкой яркости, для цифровых входов `binary_sensor`, для датчиков
  `sensor`)
 - Возможность работы с несколькими megad
- Обратная связь по mqtt
+- Обратная связь по mqtt или http (на выбор)
- Команды выполняются друг за другом без конкурентного доступа к ресурсам megad
+- События на двойные/долгие нажатия
-## Устройства
+- Команды выполняются друг за другом без конкурентного доступа к ресурсам megad, это дает гарантии надежного исполнения
-Поддерживаются устройства: light, switch, binary_sensor, sensor. light может работать как диммер
+  большого кол-ва команд (например в сценах). Каждая следующая команда отправляется только после получения ответа о
  выполнении предыдущей.
 ## Установка
-Рекомендованнй способ - через [HACS](https://hacs.xyz/docs/installation/installation).
+Рекомендованный способ с поддержкой обновлений - [HACS](https://hacs.xyz/docs/installation/installation):
-После установки HACS, нужно перейти в меню hacs -> integrations, далее в верхнем правом углу
+
-нажать три точки, где будет `Custom repositories`, открыть, нажать add и добавить `https://github.com/andvikt/mega_hacs.git`
+HACS - Integrations - Explore, в поиске ищем MegaD. 
 Альтернативный способ установки:
 ```shell
 # из папки с конфигом
 wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.sh | bash -
 ```
-Перезагрузить HA
+Не забываем перезагрузить HA
-Для обновления повторить
+## Настройка
 ## Зависимости
 Перед использованием необходимо настроить интеграцию mqtt в HomeAssistant
 ## Настройка из веб-интерфейса
 `Настройки` -> `Интеграции` -> `Добавить интеграцию` в поиске ищем mega
-## Пример настройки с помощью yaml:
+Все имеющиеся у вас порты будут настроены автоматически. Вы можете менять названия, иконки и 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"
      # можно так же указать шаблон для конвертации значения, может быть полезно для ацп-входа
      # текущее значение порта передается в шаблон в переменной "value"
      conv_template: "{{(value|float)/100}}"
    14:
      name: какой-то датчик
      unit_of_measurement: "°C" # если датчик один, то просто строчкой
 ```
 ## Зависимости
 Для совместимости c mqtt необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
 в HomeAssistant, а так же обновить ваш контроллер до последней версии, тк были важные обновления в части mqtt
 ## HTTP in
 Начиная с версии `0.3.1` интеграция стала поддерживать обратную связь без mqtt, используя http-сервер. Для этого в настройках
 интеграции необходимо снять галку с `использовать mqtt`
 **Внимание!** Не используйте srv loop на контроллере, это может приводить к ложным срабатываниям входов. Вместо srv loop 
 интеграция будет сама обновлять все состояния портов с заданным интервалом
 В самой меге необходимо прописать настройки:
 ```yaml
 srv: "192.168.1.4:8123" # ip:port вашего HA
 script: "mega" # это api интеграции, к которому будет обращаться контроллер
 ```
 #### Ответ на входящие события от контроллера
 Контроллер ожидает ответ от сервера, который может быть сценарием (по умолчанию интеграция отвечает `d`, что означает 
 запустить то что прописано в поле act в настройках порта).
 Поддерживаются шаблоны HA. Это может быть использовано, например, для запоминания яркости (тк сам контроллер этого не 
 умеет). В шаблоне можно использовать параметры, которые передает контроллер (m, click, pt, mdid, mega_id)
 Примеры:
 ```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 %}
 ```
 Начиная с версии v0.3.17 ответ можно слать так же и в режиме MQTT. Аналогично, темплейт должен возвращать готовую команду
 такую же как требует команда cmd, так же можно использовать d, но d не отправляется по умолчанию, это сделано чтобы не 
 сломать текущую логику у пользователей предыдущих версий. Чтобы включить для всех входов в режиме mqtt отправку команды 
 d необходимо в конфиге прописать следующее:
 ```yaml
 mega:
  mega1:
-    host: 192.168.0.14
+    force_d: true
    name: hello
    password: sec
    mqtt_id: mega # это id в конфиге меги
 light:
  - platform: mega
    mega1:
      switch:
        - 1 # можно просто перечислить порты
        - 2
        - 3
      dimmer:
        - port: 7
          name: hello # можно использовать расширенный вариант с названиями
        - 9
        - 10
 binary_sensor:
  - platform: mega
    mega1:
      - port: 16
        name: sensor1
      - port: 18
        name: sensor2
 sensor:
  - platform: mega
    mega1:
      - port: 10
        name: some temp
        type: w1
        key: temp
      - port: 10
        name: some hum
        type: w1
        key: hum
 switch:
  - platform: mega
    mega1:
      - 11
 ```
 **Внимание!** Нельзя использовать чекбокс напротив поля act если планируется использовать ответ сервера - у вас и 
 сработает act и команда от сервера, а вслучае ответа d сработает act два раза.
 Так же следует понимать, что это не "ответ" в нормальном понимании - это вызов следом за полученным mqtt-сообщением
 http команды такого вида `http://megaurl/?pt=port&cmd=rendered_template`, где `port` - это номер порта сработавшего входа,
 а `cmd` - текст команды, который получен из темплейта. Те это имитация ответа. У этого подхода есть минус - задержка в 
 исполнении будет значительно выше чем при ответе в режиме http, но тем не менее эта задержка скорее всего не будет 
 сильно заметна.
 ## binary_sensor и события
 Входы будут доступны как binary_sensor, а так же в виде событий `mega.sensor` и `mega.binary`.
 Для корректной работы binary_sensor имеет смысл использовать режим P&R, для остальных режимов - лучше пользоваться 
 событиями.
 События можно использовать в автоматизациях, например так:
 ```yaml
 # Пример события с полями как есть прямо из меги
 - alias: some double click
  trigger:
    - platform: event
      event_type: mega.sensor
      event_data:
        pt: 1
        click: 2
  action:
    - service: light.toggle
      entity_id: light.some_light
 ```
 События могут содержать следующие поля: 
 - `mega_id`: id как в конфиге HA
 - `pt`: номер порта
 - `cnt`: счетчик срабатываний
 - `mdid`: if как в конфиге контроллера
 - `click`: клик (подробнее в документации меги)
 - `value`: текущее значение (только для mqtt)
 - `port`: номер порта
 Начиная с версии 0.3.7 появилось так же событие типа `mega.binary`:
 ```yaml
 # Пример события с полями как есть прямо из меги
 - alias: some long click
  trigger:
    - platform: event
      event_type: mega.binary
      event_data:
        entity_id: binary_sensor.some_id
        type: long
  action:
    - service: light.toggle
      entity_id: light.some_light
 ```
 Возможные варианты поля `type`:
 - `long`: долгое нажатие
 - `release`: размыкание (с гарантией** что не было долгого нажатия)
 - `long_release`: размыкание после долгого нажатия
 - `press`: замыкание
 - `single`: одинарный клик (в режиме кликов)
 - `double`: двойной клик
 **гарантия есть только при использовании http-метода синхронизации, mqtt не гарантирует порядок доставки сообщений, хотя 
 маловероятно, что порядок будет нарушен, но все же сам протокол не дает таких гарантий.
 Чтобы понять, какие события происходят, лучше всего воспользоваться панелью разработчика и подписаться
 на вкладке события на событие `mega.sensor`, понажимать кнопки.
 ## Сервисы
 Все сервисы доступны в меню разработчика с описанием и примерами использования
 ```yaml
-save:
+mega.save:
  description: Сохраняет текущее состояние портов (?cmd=s)
  fields:
    mega_id:
      description: ID меги, можно оставить пустым, тогда будут сохранены все зарегистрированные меги
      example: "mega"
-get_port:
+mega.get_port:
  description: Запросить текущий статус порта (или всех)
  fields:
    mega_id:
-      description: ID меги, можно оставить пустым, тогда будут сохранены все зарегистрированные меги
+      description: ID меги, можно оставить пустым, тогда будут порты всех зарегистрированных мег
      example: "mega"
    port:
      description: Номер порта (если не заполнять, будут запрошены все порты сразу)
      example: 1
-run_cmd:
+mega.run_cmd:
  description: Выполнить любую произвольную команду
  fields:
    mega_id:
-      description: ID меги, можно оставить пустым, тогда будут сохранены все зарегистрированные меги
+      description: ID меги
      example: "mega"
    port:
      description: Номер порта (это не порт, которым мы управляем, а порт с которого шлем команду)
@@ -113,18 +219,33 @@ run_cmd:
    cmd:
      description: Любая поддерживаемая мегой команда
      example: "1:0"
 ```
 ## Состояния
 Так же каждое устройство megad опрашивается на предмет работоспособности, текущий статус
 хранится в mega.<id>
 ## Отладка
-Если возникают проблемы, можно включить детальный лог, для этого в конфиг добавить:
+Интеграция находится в активной разработке, при возникновении проблем [заводите issue](https://github.com/andvikt/mega_hacs/issues/new/choose)
 Просьба прикладывать детальный лог, который можно включить в конфиге так:
 ```yaml
 logger:
  default: info
  logs:
    custom_components.mega: debug
 ```
 #### Отладка ответов http-сервера
 Для отладки ответов сервера можно самим имитировать запросы контроллера, если у вас есть доступ к консоли
 HA:
 ```shell
 curl -v -X GET 'http://localhost:8123/mega?pt=5&m=1'
 ```
 Если доступа нет, нужно в файл конфигурации добавить 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`, либо скрипт, который вы настроили
Author	SHA1	Message	Date
Andrey	39642700ca	fix force_d	2021-02-15 19:05:00 +03:00
Andrey	07589e8e3a	edit readme	2021-02-11 17:35:58 +03:00
Andrey	5a6903c67e	fix config bug	2021-02-11 16:03:10 +03:00
Andrey	6758fd8d8e	add server response in mqtt mode	2021-02-11 12:19:17 +03:00
Andrey	a9896c82fe	add server response in mqtt mode	2021-02-11 12:00:01 +03:00
Andrey	5ed0b74eff	add server response in mqtt mode	2021-02-11 11:57:17 +03:00
Andrey	4fccb23c39	remove port from command sendings	2021-02-10 14:05:16 +03:00
Andrey	03e4d3ff7e	Merge remote-tracking branch 'origin/master'	2021-02-09 22:15:27 +03:00
Andrey	7907e0cd85	edit readme	2021-02-09 22:04:39 +03:00
andvikt	5211ee5330	Merge pull request #8 from r7sa/master Улучшение поддержки I2C устройств Спасибо большое!	2021-02-09 21:35:05 +03:00
Andrey	4e0f1dddcb	add readme about srv loop	2021-02-09 21:30:26 +03:00
Sergey	742a0a9a09	- добавлены два новых класса устройства (давление, освещённость) - улучшена поддержка I2C устройств, возвращающих только одно значение	2021-02-07 12:29:40 +03:00
Andrey	59443989a0	add poll outs	2021-02-06 09:43:10 +03:00
Andrey	5b86ceefe4	Merge remote-tracking branch 'origin/master'	2021-02-05 21:06:40 +03:00
Andrey	8cf000beae	fix get_port	2021-02-05 21:06:27 +03:00
andvikt	99317da9f6	Update bug-report.md	2021-02-05 20:47:58 +03:00
Andrey	97911d0241	fix get_port	2021-02-05 20:21:14 +03:00
Andrey	d9925a2de0	i2c sensors	2021-02-05 20:08:28 +03:00
Andrey	f197a09072	invert inputs	2021-01-31 17:38:44 +03:00
Andrey	e8d92cfa36	invert inputs	2021-01-31 17:36:56 +03:00
Andrey	5f94186a14	edit readme	2021-01-31 12:10:17 +03:00
Andrey	f09610355b	add version to manifest	2021-01-31 11:46:43 +03:00
Andrey	70e182fec3	Merge remote-tracking branch 'origin/master'	2021-01-31 11:42:11 +03:00
Andrey	ef3152a086	add adc port and template rendering values	2021-01-31 11:41:27 +03:00
andvikt	9b9443864c	Update readme.md	2021-01-29 17:57:33 +03:00
andvikt	b7669ac407	Update readme.md	2021-01-29 17:55:45 +03:00
andvikt	2b308a71a1	Update readme.md	2021-01-29 17:55:12 +03:00
Andrey	8f67652c0e	Merge remote-tracking branch 'origin/master'	2021-01-29 09:53:49 +03:00
Andrey	f83cdaa583	event monitoring propper restarting	2021-01-29 09:53:10 +03:00
andvikt	8dfa5926ad	Merge pull request #4 from Foroxon/master Ukrainian translation updating	2021-01-29 09:09:40 +03:00
Andrey	3978ce2203	fix 1-wire updating while busy	2021-01-29 09:08:34 +03:00
Andrey	72cf516353	fix mqtt sensor	2021-01-28 12:17:38 +03:00
Andrey	3b6459468b	fix mqtt sensor	2021-01-28 12:04:43 +03:00
Andrey	c36c1369aa	fix binary sensors	2021-01-28 10:29:16 +03:00
Andrey	6d3391bc45	add new events, fix binsensor	2021-01-27 21:40:55 +03:00
Vladyslav Heneraliuk	2e025eb0c2	updated Ukrainian translation	2021-01-26 12:16:42 +02:00
Vladyslav Heneraliuk	20d5b8ff40	Merge pull request #1 from andvikt/master Sync	2021-01-26 12:10:46 +02:00
Andrey	a7d7738a5c	fix mqtt	2021-01-26 08:34:27 +03:00
Andrey	c0b1247b9e	smaller headers	2021-01-25 21:35:06 +03:00
Andrey	1548e8c364	fix multiple megas	2021-01-25 20:17:15 +03:00
Andrey	39c4ab0e3b	fix device name	2021-01-25 18:45:23 +03:00
Andrey	a002e48e04	fix old mega out type 0	2021-01-25 18:13:25 +03:00
Andrey	dc6bdfc8f4	fix yaml exclusion	2021-01-25 17:56:47 +03:00
Andrey	e51b50797c	fix yaml exclusion	2021-01-25 17:46:26 +03:00
Andrey	c4205c7ddc	fix sw-link	2021-01-25 17:23:33 +03:00
Andrey	6164966d0b	fix scanning	2021-01-25 17:21:55 +03:00
Andrey	ff6225a959	fix scanning	2021-01-25 17:18:42 +03:00
Andrey	57f355d479	fix scanning	2021-01-25 16:37:48 +03:00
Andrey	7d6273539e	fix scanning	2021-01-25 15:57:10 +03:00
Andrey	5da2973351	fix scanning	2021-01-25 15:52:24 +03:00
Andrey	5eadd295f1	Merge branch 'master' of https://github.com/andvikt/mega_hacs	2021-01-25 15:48:29 +03:00
Andrey	5bf432a27f	change readme	2021-01-25 15:47:55 +03:00
Andrey	d934e87ae5	force use http while scanning	2021-01-25 15:46:40 +03:00
andvikt	0b54db9c44	Update issue templates	2021-01-25 13:05:31 +03:00
Andrey	2d15b60929	add allowed hosts config	2021-01-25 12:54:15 +03:00
Andrey	b0b4fdd6cf	fix dependencies	2021-01-25 12:29:31 +03:00
Andrey	8bbb4ab271	add http support	2021-01-25 12:25:11 +03:00
Andrey	876a1f0cc8	get port one more fix	2021-01-24 11:17:09 +03:00
Andrey	18d0aee391	small fix	2021-01-23 21:08:33 +03:00
Andrey	4e2d659c44	fix mid	2021-01-22 21:32:55 +03:00
Andrey	e0b4fec0ca	add name cusomisation for multiple sensors	2021-01-22 12:28:04 +03:00
Andrey	b5e4b2c802	add name cusomisation for multiple sensors	2021-01-22 12:27:07 +03:00
Andrey	ed6a86a721	add name cusomisation for multiple sensors	2021-01-22 12:24:38 +03:00
Andrey	811f2067bb	fix save_all service	2021-01-22 12:20:16 +03:00
Andrey	3e1499f78b	fix get_port	2021-01-22 12:16:32 +03:00
Andrey	2a4a85a20e	small bugfix	2021-01-22 11:12:18 +03:00
Andrey	2a0f60f1b2	edit readme	2021-01-22 10:53:15 +03:00
Andrey	a8eb50ee44	edit readme	2021-01-22 10:52:39 +03:00
Andrey	6b1635f60f	edit readme	2021-01-22 10:51:32 +03:00
Andrey	62bdcfeb1b	edit readme	2021-01-22 10:50:34 +03:00
Andrey	fa1c3330ba	edit readme	2021-01-22 10:48:00 +03:00
Andrey	9755a9c654	edit readme	2021-01-22 10:27:54 +03:00
Andrey	bb4ce882f5	рефакторинг, конфиг yaml	2021-01-22 10:27:02 +03:00
andvikt	c3b9474d56	Merge pull request #3 from Foroxon/master Added Ukrainian translation	2021-01-20 23:45:39 +03:00
andvikt	42f44d3020	Fix offline bugs	2021-01-20 23:33:53 +03:00
andvikt	3108927f15	fix offline bug	2021-01-20 23:25:57 +03:00
Vladyslav Heneraliuk	686d86aec5	renamed UA translation file	2021-01-18 11:30:24 +02:00
Vladyslav Heneraliuk	8d1b828362	added Ukrainian translation	2021-01-18 11:15:39 +02:00
Andrey	8539b8a6ee	fix eng lang in options	2021-01-18 09:32:25 +03:00
Andrey	405fbe4777	fix eng lang in options	2021-01-18 09:28:38 +03:00
Andrey	ed4928011b	add refresh devices	2021-01-15 16:05:10 +03:00
Andrey	ed9011a6e1	edit readme	2021-01-15 09:23:32 +03:00
Andrey	c7e8bcb83e	edit readme	2021-01-15 09:20:52 +03:00
Andrey	21fd00083c	edit readme	2021-01-15 09:13:12 +03:00
Andrey	c4f4510941	add device registry	2021-01-15 09:10:42 +03:00
Andrey	254015be4c	edit readme	2021-01-15 08:45:27 +03:00
Andrey	adb65529a2	hotfix	2021-01-14 23:05:30 +03:00
Andrey	768d46d952	hotfix	2021-01-14 22:48:07 +03:00
Andrey	359c6b99b7	hotfix	2021-01-14 22:27:07 +03:00
Andrey	79dc46226a	hotfix	2021-01-14 22:19:56 +03:00
Andrey	012d12437b	hotfix	2021-01-14 21:40:19 +03:00
Andrey	7063575957	hotfix	2021-01-14 21:35:15 +03:00
Andrey	6a43198d81	hotfix	2021-01-14 21:33:44 +03:00
Andrey	242386bfe8	edit readme	2021-01-14 21:25:48 +03:00
Andrey	34d31d2879	edit readme	2021-01-14 21:07:30 +03:00
Andrey	6a02a7e98c	башфикс сервисов, ускорение загрузки	2021-01-14 20:46:05 +03:00
Andrey	d6191ba46a	fix services	2021-01-05 09:02:35 +03:00
Andrey	f19d3daeff	add yaml deprecation	2021-01-04 09:59:44 +03:00
Andrey	d56cffa68f	fix 37 port	2021-01-02 09:56:47 +03:00
Andrey	a958d56e6b	fix brightness	2020-12-30 08:58:57 +03:00