добавлена возможность восстановления состояний выходов после перезагрузки меги

Merge pull request #16 from Foroxon/master
UA translation update
2025-12-12 01:24:29 +05:00 · 2021-02-24 10:56:11 +03:00 · 2021-02-22 16:15:16 +03:00 · 2021-02-22 10:28:17 +02:00 · 2021-02-22 10:18:26 +02:00 · 2021-02-22 09:53:58 +03:00
21 changed files with 1013 additions and 320 deletions
--- a/.experiment.py
+++ b/.experiment.py
@@ -0,0 +1,35 @@
 import asyncio
 from asyncio import Event, FIRST_COMPLETED
 import signal
 stop = Event()
 loop = asyncio.get_event_loop()
 async def handler(
        reader: asyncio.StreamReader,
        writer: asyncio.StreamWriter,
 ):
    await reader.read(100)
    ans = b'HTTP/1.1 200 OK\r\nContent-Length:1\r\n\r\nd'
    writer.write(ans)
    await writer.drain()
    writer.close()
    await writer.wait_closed()
 async def serve():
    server = await asyncio.start_server(
        handler,
        host='0.0.0.0',
        port=8888,
    )
    async with server:
        await asyncio.wait((server.serve_forever(), stop.wait()), return_when=FIRST_COMPLETED)
 if __name__ == '__main__':
    loop.add_signal_handler(
        signal.SIGINT, stop.set
    )
    loop.run_until_complete(serve())
--- a/.github/ISSUE_TEMPLATE/bug-report.md
+++ b/.github/ISSUE_TEMPLATE/bug-report.md
@@ -0,0 +1,27 @@
 ---
 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**
 Просьба прикладывать детальный лог, подробная инструкция как включать отладку по [ссылке](https://github.com/andvikt/mega_hacs/wiki/Отладка)
--- 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
@@ -4,35 +4,64 @@ import logging
 from functools import partial
 import voluptuous as vol
 from homeassistant.const import (
    CONF_SCAN_INTERVAL, CONF_ID, CONF_NAME, CONF_DOMAIN,
-    CONF_UNIT_OF_MEASUREMENT,
+    CONF_UNIT_OF_MEASUREMENT, CONF_HOST, CONF_VALUE_TEMPLATE
 )
 from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers.service import bind_hass
 from homeassistant.helpers import config_validation as cv
 from homeassistant.components import mqtt
 from homeassistant.config_entries import ConfigEntry
-from .const import DOMAIN, CONF_INVERT, CONF_RELOAD, PLATFORMS, CONF_PORTS, CONF_CUSTOM, CONF_SKIP, CONF_PORT_TO_SCAN
+from .const import DOMAIN, CONF_INVERT, CONF_RELOAD, PLATFORMS, CONF_PORTS, CONF_CUSTOM, CONF_SKIP, CONF_PORT_TO_SCAN, \
    CONF_MQTT_INPUTS, CONF_HTTP, CONF_RESPONSE_TEMPLATE, CONF_ACTION, CONF_GET_VALUE, CONF_ALLOW_HOSTS, \
    CONF_CONV_TEMPLATE, CONF_ALL, CONF_FORCE_D, CONF_DEF_RESPONSE
 from .hub import MegaD
 from .config_flow import ConfigFlow
-
+from .http import MegaView
 _LOGGER = logging.getLogger(__name__)
 CUSTOMIZE_PORT = {
    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,
    vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
 }
 CUSTOMIZE_DS2413 = {
    vol.Optional(str.lower, description='адрес и индекс устройства'): CUSTOMIZE_PORT
 }
 CONFIG_SCHEMA = vol.Schema(
    {
        DOMAIN: {
            vol.Optional(CONF_ALLOW_HOSTS): [str],
            vol.Required(str, description='id меги из веб-интерфейса'): {
-                vol.Optional(int, description='номер порта'): {
+                vol.Optional(CONF_FORCE_D, description='Принудительно слать d после срабатывания входа', default=False): bool,
-                    vol.Optional(CONF_SKIP, description='исключить порт из сканирования', default=False): bool,
+                vol.Optional(
-                    vol.Optional(CONF_INVERT, default=False): bool,
+                    CONF_DEF_RESPONSE,
-                    vol.Optional(CONF_NAME): str,
+                    description='Ответ по умолчанию',
-                    vol.Optional(CONF_DOMAIN): vol.Any('light', 'switch'),
+                    default=None
-                    vol.Optional(CONF_UNIT_OF_MEASUREMENT, description='единицы измерений, либо строка либо мепинг'):
+                ): vol.Any(cv.template, None),
-                        vol.Any(str, {
+                vol.Optional(int, description='номер порта'): vol.Any(
-                            vol.Required(str): str
+                    CUSTOMIZE_PORT,
-                        }),
+                    CUSTOMIZE_DS2413,
-                }
+                )
            }
        }
    },
@@ -49,7 +78,10 @@ _subs = {}
 async def async_setup(hass: HomeAssistant, config: dict):
    """YAML-конфигурация содержит только кастомизации портов"""
    hass.data[DOMAIN] = {CONF_CUSTOM: config.get(DOMAIN, {})}
-
+    hass.data[DOMAIN][CONF_HTTP] = view = MegaView(cfg=config.get(DOMAIN, {}))
    hass.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', partial(_save_service, hass), schema=vol.Schema({
            vol.Optional('mega_id'): str
@@ -58,16 +90,17 @@ async def async_setup(hass: HomeAssistant, config: dict):
    hass.services.async_register(
        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', partial(_run_cmd, hass), schema=vol.Schema({
-            vol.Required('port'): int,
+            vol.Optional('port'): int,
            vol.Required('cmd'): str,
            vol.Optional('mega_id'): str,
        })
    )
    return True
@@ -76,9 +109,17 @@ async def get_hub(hass, entry):
    data = dict(entry.data)
    data.update(entry.options or {})
    data.update(id=id)
-    _mqtt = hass.data.get(mqtt.DOMAIN)
+    use_mqtt = data.get(CONF_MQTT_INPUTS, True)
-    if _mqtt is None:
+
-        raise Exception('mqtt not configured, please configure mqtt first')
+    _mqtt = hass.data.get(mqtt.DOMAIN) if use_mqtt else None
    if _mqtt is None and use_mqtt:
        for x in range(5):
            await asyncio.sleep(5)
            _mqtt = hass.data.get(mqtt.DOMAIN)
            if _mqtt is not None:
                break
        if _mqtt is None:
            raise Exception('mqtt not configured, please configure mqtt first')
    hub = MegaD(hass, **data, mqtt=_mqtt, lg=_LOGGER, loop=asyncio.get_event_loop())
    hub.mqtt_id = await hub.get_mqtt_id()
    return hub
@@ -88,6 +129,7 @@ async def _add_mega(hass: HomeAssistant, entry: ConfigEntry):
    id = entry.data.get('id', entry.entry_id)
    hub = await get_hub(hass, entry)
    hass.data[DOMAIN][id] = hub
    hass.data[DOMAIN][CONF_ALL][id] = hub
    if not await hub.authenticate():
        raise Exception("not authentificated")
    mid = await hub.get_mqtt_id()
@@ -135,7 +177,9 @@ async def async_remove_entry(hass, entry) -> None:
    if hub is None:
        return
    _LOGGER.debug(f'remove {id}')
-    _hubs.pop(entry.entry_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()
@@ -169,7 +213,8 @@ async def _save_service(hass: HomeAssistant, call: ServiceCall):
        await hub.save()
    else:
        for hub in hass.data[DOMAIN].values():
-            await hub.save()
+            if isinstance(hub, MegaD):
                await hub.save()
@bind_hass
@@ -179,27 +224,32 @@ async def _get_port(hass: HomeAssistant, call: ServiceCall):
    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, call: ServiceCall):
    port = call.data.get('port')
    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
@@ -16,7 +16,8 @@ from homeassistant.const import (
    CONF_ENTITY_ID,
 )
 from homeassistant.core import HomeAssistant
-from .const import EVENT_BINARY_SENSOR, DOMAIN, CONF_CUSTOM, CONF_SKIP
+from homeassistant.helpers.template import Template
 from .const import EVENT_BINARY_SENSOR, DOMAIN, CONF_CUSTOM, CONF_SKIP, CONF_INVERT, CONF_RESPONSE_TEMPLATE
 from .entities import  MegaPushEntity
 from .hub import MegaD
@@ -71,22 +72,38 @@ class MegaBinarySensor(BinarySensorEntity, MegaPushEntity):
    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')
-        return self._state == 'ON'
+        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):
-        data = {CONF_ENTITY_ID: self.entity_id}
+        self.mega.values[self.port] = payload
-        payload = payload.copy()
+        if not self.mega.mqtt_inputs:
-        payload.pop(CONF_PORT)
+            return
-        data.update(payload)
+
-        if not self.is_first_update:
+        template: Template = self.customize.get(CONF_RESPONSE_TEMPLATE, None)
-            self.hass.bus.async_fire(
+        if template is not None:
-                EVENT_BINARY_SENSOR,
+            template.hass = self.hass
-                data,
+            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)
            )
-        val = payload.get("value")
+        elif self.mega.force_d:
-        self._is_on = val == 'ON'
+            self.mega.lg.debug(f'response d')
-        self._attrs = data
+            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
@@ -9,7 +9,9 @@ from homeassistant.components import mqtt
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_ID, CONF_PASSWORD, CONF_SCAN_INTERVAL
 from homeassistant.core import callback, HomeAssistant
-from .const import DOMAIN, CONF_PORT_TO_SCAN, CONF_RELOAD, PLATFORMS  # pylint:disable=unused-import
+from .const import DOMAIN, CONF_PORT_TO_SCAN, CONF_RELOAD, PLATFORMS, CONF_MQTT_INPUTS, \
    CONF_NPORTS, CONF_UPDATE_ALL, CONF_POLL_OUTS, CONF_FAKE_RESPONSE, CONF_FORCE_D, \
    CONF_ALLOW_HOSTS, CONF_PROTECTED, CONF_RESTORE_ON_RESTART  # pylint:disable=unused-import
 from .hub import MegaD
 from . import exceptions
@@ -17,19 +19,28 @@ _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=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=False): bool,
        vol.Optional(CONF_NPORTS, default=37): int,
        vol.Optional(CONF_UPDATE_ALL, default=True): bool,
        vol.Optional(CONF_FAKE_RESPONSE, default=True): bool,
        vol.Optional(CONF_FORCE_D, default=True): bool,
        vol.Optional(CONF_RESTORE_ON_RESTART, default=True): bool,
        vol.Optional(CONF_PROTECTED, default=True): bool,
        vol.Optional(CONF_ALLOW_HOSTS, default='::1;127.0.0.1'): str,
    },
 )
 async def get_hub(hass: HomeAssistant, data):
    _mqtt = hass.data.get(mqtt.DOMAIN)
-    if not isinstance(_mqtt, mqtt.MQTT):
+    # if not isinstance(_mqtt, mqtt.MQTT):
-        raise exceptions.MqttNotConfigured("mqtt must be configured first")
+    #     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():
@@ -52,7 +63,7 @@ async def validate_input(hass: core.HomeAssistant, data):
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
    """Handle a config flow for mega."""
-    VERSION = 3
+    VERSION = 11
    CONNECTION_CLASS = config_entries.CONN_CLASS_ASSUMED
    async def async_step_user(self, user_input=None):
@@ -67,7 +78,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
        try:
            hub = await validate_input(self.hass, user_input)
            await hub.start()
-            config = await hub.get_config()
+            config = await hub.get_config(nports=user_input.get(CONF_NPORTS, 37))
            await hub.stop()
            hub.lg.debug(f'config loaded: %s', config)
            config.update(user_input)
@@ -102,7 +113,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
    async def async_step_init(self, user_input=None):
        """Manage the options."""
-
+        hub = await get_hub(self.hass, self.config_entry.data)
        if user_input is not None:
            reload = user_input.pop(CONF_RELOAD)
            cfg = dict(self.config_entry.data)
@@ -110,7 +121,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
            hub = await get_hub(self.hass, self.config_entry.data)
            if reload:
                await hub.start()
-                new = await hub.get_config()
+                new = await hub.get_config(nports=user_input.get(CONF_NPORTS, 37))
                await hub.stop()
                _LOGGER.debug(f'new config: %s', new)
@@ -127,8 +138,17 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
            step_id="init",
            data_schema=vol.Schema({
                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_FAKE_RESPONSE, default=e.get(CONF_FAKE_RESPONSE, True)): bool,
                vol.Optional(CONF_FORCE_D, default=e.get(CONF_FORCE_D, False)): bool,
                vol.Optional(CONF_RESTORE_ON_RESTART, default=e.get(CONF_RESTORE_ON_RESTART, False)): bool,
                vol.Optional(CONF_PROTECTED, default=e.get(CONF_PROTECTED, True)): bool,
                vol.Optional(CONF_ALLOW_HOSTS, default='::1;127.0.0.1'): str,
                # 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"
@@ -14,11 +15,38 @@ 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_FAKE_RESPONSE = 'fake_response'
 CONF_GET_VALUE = 'get_value'
 CONF_ALLOW_HOSTS = 'allow_hosts'
 CONF_PROTECTED = 'protected'
 CONF_CONV_TEMPLATE = 'conv_template'
 CONF_POLL_OUTS = 'poll_outs'
 CONF_FORCE_D = 'force_d'
 CONF_DEF_RESPONSE = 'def_response'
 CONF_RESTORE_ON_RESTART = 'restore_on_restart'
 PLATFORMS = [
    "light",
    "switch",
    "binary_sensor",
    "sensor",
 ]
-EVENT_BINARY_SENSOR = f'{DOMAIN}.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,11 +1,32 @@
 import logging
 import asyncio
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_NAME
 from homeassistant.core import State
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from homeassistant.helpers.restore_state import RestoreEntity
-from .hub import MegaD
+from . import hub as h
-from .const import DOMAIN, CONF_CUSTOM, CONF_INVERT
+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__)
 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):
@@ -16,18 +37,25 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
    """
    def __init__(
            self,
-            mega: MegaD,
+            mega: 'h.MegaD',
            port: int,
            config_entry: ConfigEntry = None,
            id_suffix=None,
            name=None,
            unique_id=None,
            http_cmd='get',
            addr: str=None,
            index=None,
    ):
        super().__init__(mega.updater)
        self.http_cmd = http_cmd
        self._state: State = None
        self.port = port
        self.config_entry = config_entry
        self.mega = mega
        mega.entities.append(self)
        self._mega_id = mega.id
        self._lg = None
        self._unique_id = unique_id or f"mega_{mega.id}_{port}" + \
@@ -35,6 +63,10 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
        self._name = name or f"{mega.id}_{port}" + \
                            (f"_{id_suffix}" if id_suffix else "")
        self._customize: dict = None
        self.index = index
        self.addr = addr
        if self.http_cmd == 'ds2413':
            self.mega.ds2413_ports |= {self.port}
    @property
    def customize(self):
@@ -44,7 +76,11 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
            c = self.hass.data.get(DOMAIN, {}).get(CONF_CUSTOM) or {}
            c = c.get(self._mega_id) or {}
            c = c.get(self.port) or {}
            if self.addr is not None and self.index is not None and isinstance(c, dict):
                idx = self.addr.lower() + f'_a' if self.index == 0 else '_b'
                c = c.get(idx, {})
            self._customize = c
        return self._customize
    @property
@@ -57,7 +93,7 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
            "config_entries": [
                self.config_entry,
            ],
-            "name": f'port {self.port}',
+            "name": f'{self._mega_id} port {self.port}',
            "manufacturer": 'ab-log.ru',
            # "model": self.light.productname,
            # "sw_version": self.light.swversion,
@@ -76,15 +112,26 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
    @property
    def name(self):
-        return self.customize.get(CONF_NAME) or self._name or f"{self.mega.id}_p{self.port}"
+        c = self.customize.get(CONF_NAME)
        if not isinstance(c, str):
            c = self._name or f"{self.mega.id}_p{self.port}"
        return c
    @property
    def unique_id(self):
        return self._unique_id
    async def async_added_to_hass(self) -> None:
        global _task_set_ev_on
        await super().async_added_to_hass()
        self._state = await self.async_get_last_state()
        if self.mega.mqtt_inputs and _task_set_ev_on is None:
            _task_set_ev_on = asyncio.create_task(_set_events_on())
    async def get_state(self):
        self.lg.debug(f'state is %s', self.state)
        if not self.mega.mqtt_inputs:
            self.async_write_ha_state()
 class MegaPushEntity(BaseMegaEntity):
@@ -102,7 +149,55 @@ class MegaPushEntity(BaseMegaEntity):
        self._update(value)
        self.async_write_ha_state()
        self.lg.debug(f'state after update %s', self.state)
-        self.is_first_update = False
+        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):
@@ -110,7 +205,8 @@ class MegaPushEntity(BaseMegaEntity):
    async def async_added_to_hass(self) -> None:
        await super().async_added_to_hass()
-        self.hass.async_create_task(self.mega.get_port(self.port))
+        if self.mega.mqtt is not None:
            asyncio.create_task(self.mega.get_port(self.port))
 class MegaOutPort(MegaPushEntity):
@@ -127,22 +223,66 @@ class MegaOutPort(MegaPushEntity):
        self._is_on = None
        self.dimmer = dimmer
    # @property
    # def assumed_state(self) -> bool:
    #     return True if self.index is not None or self.mega.mqtt is None else False
    @property
    def invert(self):
        return self.customize.get(CONF_INVERT, False)
    @property
    def brightness(self):
-        if self._brightness is not None:
+        if not self.dimmer:
-            return self._brightness
+            return
-        if self._state:
+        val = self.mega.values.get(self.port, {}).get("value")
        if val is None and self._state is not None:
            return self._state.attributes.get("brightness")
        elif val is not None:
            try:
                val = int(val)
                return val
            except Exception:
                pass
    @property
    def is_on(self) -> bool:
-        if self._is_on is not None:
+        val = self.mega.values.get(self.port, {})
-            return self._is_on
+
-        return self._state == 'ON'
+        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 isinstance(val, str) and self.index is not None and self.addr is not None:
                if not isinstance(val, dict):
                    self.mega.lg.warning(f'{self.entity_id}: {val} is not a dict')
                    return
                _val = val.get(self.addr, val.get(self.addr.lower(), val.get(self.addr.upper())))
                if not isinstance(_val, str):
                    self.mega.lg.warning(f'{self.entity_id}: can not get {self.addr} from {val}, recieved {_val}')
                    return
                _val = _val.split('/')
                if len(_val) >= 2:
                    self.mega.lg.debug('%s parsed values: %s[%s]="%s"', self.entity_id, _val, self.index, _val)
                    val = _val[self.index]
                else:
                    self.mega.lg.warning(f'{self.entity_id}: {_val} has wrong length')
                    return
            elif self.index is not None and self.addr is None:
                self.mega.lg.warning(f'{self.entity_id} does not has addr')
                return
            self.mega.lg.debug('%s.state = %s', self.entity_id, val)
            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)
    @property
    def cmd_port(self):
        if self.index is not None:
            return f'{self.port}A' if self.index == 0 else f'{self.port}B'
        else:
            return self.port
    async def async_turn_on(self, brightness=None, **kwargs) -> None:
        brightness = brightness or self.brightness or 255
@@ -153,31 +293,46 @@ class MegaOutPort(MegaPushEntity):
            cmd = brightness
        else:
            cmd = 1 if not self.invert else 0
-        if await self.mega.send_command(self.port, f"{self.port}:{cmd}"):
+        _cmd = {"cmd": f"{self.cmd_port}:{cmd}"}
-            self._is_on = True
+        if self.addr:
-            self._brightness = brightness
+            _cmd['addr'] = self.addr
-        await self.async_update_ha_state()
+        await self.mega.request(**_cmd)
        if self.index is not None:
            # обновление текущего стейта для ds2413
            await self.mega.get_port(
                port=self.port,
                force_http=True,
                conv=False,
                http_cmd='list',
            )
        else:
            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"
-
+        _cmd = {"cmd": f"{self.cmd_port}:{cmd}"}
-        if await self.mega.send_command(self.port, f"{self.port}:{cmd}"):
+        if self.addr:
-            self._is_on = False
+            _cmd['addr'] = self.addr
-        await self.async_update_ha_state()
+        await self.mega.request(**_cmd)
-
+        if self.index is not None:
-    def _update(self, payload: dict):
+            # обновление текущего стейта для ds2413
-        val = payload.get("value")
+            await self.mega.get_port(
-        try:
+                port=self.port,
-            val = int(val)
+                force_http=True,
-        except Exception:
+                conv=False,
-            pass
+                http_cmd='list',
-        if isinstance(val, int):
+            )
            self._is_on = val
            if val > 0:
                self._brightness = val
        else:
-            if not self.invert:
+            self.mega.values[self.port] = {'value': cmd}
-                self._is_on = val == 'ON'
+        await self.get_state()
-            else:
+
-                self._is_on = val == 'OFF'
+
 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,129 @@
 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.protected = True
        self.allowed_hosts = {'::1', '127.0.0.1'}
        self.notified_attempts = defaultdict(lambda : False)
        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)
        self.hubs = {}
    async def get(self, request: Request) -> Response:
        _LOGGER.debug('request from %s %s', request.remote, request.headers)
        hass: HomeAssistant = request.app['hass']
        if self.protected:
            auth = False
            for x in self.allowed_hosts:
                if request.remote.startswith(x):
                    auth = True
                    break
            if not auth:
                msg = f"Non-authorised request from {request.remote} to `/mega`. "\
                      f"If you want to accept requests from this host "\
                      f"please add it to allowed hosts in `mega` UI-configuration"
                if not self.notified_attempts[request.remote]:
                    await hass.services.async_call(
                        'persistent_notification',
                        'create',
                        {
                            "notification_id": request.remote,
                            "title": "Non-authorised request",
                            "message": msg
                        }
                    )
                _LOGGER.warning(msg)
                return Response(status=401)
        remote = request.headers.get('X-Real-IP', request.remote)
        hub: 'h.MegaD' = self.hubs.get(remote)
        if hub is None and 'mdid' in request.query:
            hub = self.hubs.get(request.query['mdid'])
            if hub is None:
                _LOGGER.warning(f'can not find mdid={request.query["mdid"]} in {list(self.hubs)}')
        if hub is None and request.remote in ['::1', '127.0.0.1']:
            hub = self.hubs.get('__def')
        elif 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)
        if data.get('st') == '1' and hub.restore_on_restart:
            asyncio.create_task(self.later_restore(hub))
            return Response(status=200)
        port = data.get('pt')
        data = data.copy()
        update_all = True
        if 'v' in data:
            update_all = False
            data['value'] = data.pop('v')
        data['mega_id'] = hub.id
        ret = 'd' if hub.force_d else ''
        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, hub.def_response)
            if hub.update_all and 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)
        Response(body='' if hub.fake_response else ret, content_type='text/plain')
        if hub.fake_response and 'value' not in data and 'pt' in data:
            if 'd' in ret:
                await hub.request(pt=port, cmd=ret)
            else:
                await hub.request(cmd=ret)
        return ret
    async def later_restore(self, hub):
        """
        Восстановление всех выходов с небольшой задержкой. Задержка нужна чтобы ответ прошел успешно
        :param hub:
        :return:
        """
        await asyncio.sleep(0.2)
        await hub.restore_states()
    async def later_update(self, hub):
        await asyncio.sleep(1)
        _LOGGER.debug('force update')
        await hub.updater.async_refresh()
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -10,27 +10,50 @@ import json
 from bs4 import BeautifulSoup
 from homeassistant.components import mqtt
-from homeassistant.const import DEVICE_CLASS_TEMPERATURE, DEVICE_CLASS_HUMIDITY
+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 .const import TEMP, HUM
+from .const import (
-from .exceptions import CannotConnect
+    TEMP, HUM, PRESS,
    LUX, PATT_SPLIT, DOMAIN,
    CONF_HTTP, EVENT_BINARY_SENSOR, CONF_CUSTOM, CONF_FORCE_D, CONF_DEF_RESPONSE
 )
 from .entities import set_events_off, BaseMegaEntity, MegaOutPort
 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: '°C',
+    TEMP: TEMP_CELSIUS, 
-    HUM: '%'
+    HUM: PERCENTAGE,
    PRESS: 'mmHg',
    LUX: LIGHT_LUX
 }
 CLASSES = {
    TEMP: DEVICE_CLASS_TEMPERATURE,
-    HUM: DEVICE_CLASS_HUMIDITY
+    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:
    """MegaD Hub"""
@@ -44,13 +67,37 @@ class MegaD:
            mqtt: mqtt.MQTT,
            lg: logging.Logger,
            id: str,
            mqtt_inputs: bool = True,
            mqtt_id: str = None,
            scan_interval=60,
            port_to_scan=0,
-            inverted: typing.List[int] = None,
+            nports=38,
            update_all: bool=True,
            poll_outs: bool=False,
            fake_response: bool=True,
            force_d: bool=None,
            allow_hosts: str=None,
            protected=True,
            restore_on_restart=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}
                self.http.hubs[host] = self
                if len(self.http.hubs) == 1:
                    self.http.hubs['__def'] = self
                if mqtt_id:
                    self.http.hubs[mqtt_id] = self
        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.fake_response = fake_response
        self.mqtt_inputs = mqtt_inputs
        self.loop: asyncio.AbstractEventLoop = None
        self.hass = hass
        self.host = host
@@ -58,9 +105,13 @@ class MegaD:
        self.mqtt = mqtt
        self.id = id
        self.lck = asyncio.Lock()
        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.ds2413_ports = set()
        self.poll_interval = scan_interval
        self.subs = None
        self.lg: logging.Logger = lg.getChild(self.id)
@@ -70,7 +121,9 @@ class MegaD:
        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,
@@ -78,22 +131,37 @@ class MegaD:
            update_method=self.poll,
            update_interval=timedelta(seconds=self.poll_interval) if self.poll_interval else None,
        )
        self.notifiers = defaultdict(asyncio.Condition)
        if not mqtt_id:
            _id = host.split(".")[-1]
            self.mqtt_id = f"megad/{_id}"
        else:
            self.mqtt_id = mqtt_id
        self.restore_on_restart = restore_on_restart
        if force_d is not None:
            self.customize[CONF_FORCE_D] = force_d
        try:
            if allow_hosts is not None:
                allow_hosts = set(allow_hosts.split(';'))
                hass.data[DOMAIN][CONF_HTTP].allowed_hosts |= allow_hosts
            hass.data[DOMAIN][CONF_HTTP].protected = protected
        except Exception:
            self.lg.exception('while setting allowed hosts')
    async def start(self):
        self.loop = asyncio.get_event_loop()
-        self.subs = await self.mqtt.async_subscribe(
+        if self.mqtt is not None:
-            topic=f"{self.mqtt_id}/+",
+            set_events_off()
-            msg_callback=self._process_msg,
+            self.subs = await self.mqtt.async_subscribe(
-            qos=0,
+                topic=f"{self.mqtt_id}/+",
-        )
+                msg_callback=self._process_msg,
                qos=0,
            )
    async def stop(self):
-        self.subs()
+        if self.subs is not None:
            self.subs()
        for x in self._callbacks.values():
            x.clear()
@@ -101,10 +169,32 @@ class MegaD:
        async with self.lck:
            self.entities.append(ent)
-    async def get_sensors(self):
+    async def get_sensors(self, only_list=False):
        self.lg.debug(self.sensors)
        ports = []
        for x in self.sensors:
-            await self.get_port(x)
+            if only_list and x.http_cmd != 'list':
                continue
            if x.port in ports:
                continue
            await self.get_port(x.port, force_http=True, http_cmd=x.http_cmd)
            ports.append(x.port)
    @property
    def customize(self):
        if self._customize is None:
            c = self.hass.data.get(DOMAIN, {}).get(CONF_CUSTOM) or {}
            c = c.get(self.id) or {}
            self._customize = c
        return self._customize
    @property
    def force_d(self):
        return self.customize.get(CONF_FORCE_D, False)
    @property
    def def_response(self):
        return self.customize.get(CONF_DEF_RESPONSE, None)
    @property
    def is_online(self):
@@ -127,16 +217,35 @@ class MegaD:
            )
            self.online = True
    async def _get_ds2413(self):
        """
        обновление ds2413 устройств
        :return:
        """
        for x in self.ds2413_ports:
            self.lg.debug(f'poll ds2413 for %s', x)
            await self.get_port(
                port=x,
                force_http=True,
                http_cmd='list',
                conv=False
            )
    async def poll(self):
        """
-        Send get port 0 every poll_interval. When answer is received, mega.<id> becomes online else mega.<id> becomes
+        Polling ports
        offline
        """
        self.lg.debug('poll')
-        if len(self.sensors) > 0:
+        if self.mqtt is None:
            await self.get_all_ports()
            await self.get_sensors(only_list=True)
        elif self.poll_outs:
            await self.get_all_ports(check_skip=True)
        elif len(self.sensors) > 0:
            await self.get_sensors()
        else:
            await self.get_port(self.port_to_scan)
        await self._get_ds2413()
        return self.values
    async def get_mqtt_id(self):
@@ -151,49 +260,116 @@ 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):
+    def parse_response(self, ret, cmd='get'):
-        """Запрос состояния порта. Блокируется пока не придет какое-нибудь сообщение от меги или таймаут"""
+        if ret is None:
-        async with self.cnd:
+            raise NoPort()
-            await self.mqtt.async_publish(
+        if 'busy' in ret:
-                topic=f'{self.mqtt_id}/cmd',
+            return None
-                payload=f'get:{port}',
+        if ':' in ret:
-                qos=2,
+            if ';' in ret:
-                retain=False,
+                ret = ret.split(';')
-            )
+            elif '/' in ret and not cmd == 'list':
-            await asyncio.wait_for(self.cnd.wait(), timeout=15)
+                ret = ret.split('/')
            else:
                ret = [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
-    async def get_all_ports(self):
+    async def get_port(self, port, force_http=False, http_cmd='get', conv=True):
-        for x in range(37):
+        """
-            await self.get_port(x)
+        Запрос состояния порта. Состояние всегда возвращается в виде объекта, всегда сохраняется в центральное
        хранилище values
        """
        self.lg.debug(f'get port %s', port)
        if self.mqtt is None or force_http:
            if http_cmd == 'list' and conv:
                await self.request(pt=port, cmd='conv')
                await asyncio.sleep(1)
            ret = self.parse_response(await self.request(pt=port, cmd=http_cmd), 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
        async with self._notif_lck:
            async with self.notifiers[port]:
                cnd = self.notifiers[port]
                await self.mqtt.async_publish(
                    topic=f'{self.mqtt_id}/cmd',
                    payload=f'get:{port}',
                    qos=2,
                    retain=False,
                )
                try:
                    await asyncio.wait_for(cnd.wait(), timeout=10)
                    return self.values.get(port)
                except asyncio.TimeoutError:
                    self.lg.error(f'timeout when getting port {port}')
    @property
    def ports(self):
        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 port in self.ds2413_ports:
                    continue
                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()
    async def _notify(self, port, value):
-        async with self.cnd:
+        async with self.notifiers[port]:
-            self.last_update = datetime.now()
+            cnd = self.notifiers[port]
-            self.values[port] = value
+            cnd.notify_all()
            self.cnd.notify()
    def _process_msg(self, msg):
        try:
-            _, port = msg.topic.split('/')
+            d = msg.topic.split('/')
            port = d[-1]
        except ValueError:
            self.lg.warning('can not process %s', msg)
            return
@@ -211,8 +387,18 @@ class MegaD:
        value = None
        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
@@ -224,7 +410,10 @@ class MegaD:
        self.lg.debug(
            f'subscribe %s %s', port, callback
        )
-        self._callbacks[port].append(callback)
+        if self.mqtt_inputs:
            self._callbacks[port].append(callback)
        else:
            self.http.callbacks[self.id][port].append(callback)
    async def authenticate(self) -> bool:
        """Test if we can authenticate with the host."""
@@ -252,6 +441,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:
@@ -274,24 +465,52 @@ 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(38):
+        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):
+    async def get_config(self, nports=37):
        ret = defaultdict(lambda: defaultdict(list))
-        async for port, pty, m in self.scan_ports():
+        ret['mqtt_id'] = await self.get_mqtt_id()
        async for port, pty, m in self.scan_ports(nports):
            if pty == "0":
                ret['binary_sensor'][port].append({})
-            elif pty == "1" and m in ['0', '1']:
+            elif pty == "1" and (m in ['0', '1', '3'] or m is None):
                ret['light'][port].append({'dimmer': m == '1'})
-            elif pty == '3':
+            elif pty == "1" and m == "2":
                # ds2413
                _data = await self.get_port(port=port, force_http=True, http_cmd='list', conv=False)
                data = _data.get('value', {})
                if not isinstance(data, dict):
                    self.lg.warning(f'can not add ds2413 on port {port}, it has wrong data: {_data}')
                    continue
                for addr, state in data.items():
                    ret['light'][port].extend([
                        {"index": 0, "addr": addr, "id_suffix": f'{addr}_a', "http_cmd": 'ds2413'},
                        {"index": 1, "addr": addr, "id_suffix": f'{addr}_b', "http_cmd": 'ds2413'},
                    ])
            elif pty in ('3', '2', '4'):
                try:
-                    await self.get_port(port)
+                    http_cmd = 'get'
-                    values = self.values.get(port)
+                    if m == '5' and pty == '3':
                        # 1-wire bus
                        values = await self.get_port(port, force_http=True, http_cmd='list')
                        http_cmd = 'list'
                    else:
                        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
@@ -304,7 +523,10 @@ class MegaD:
                if isinstance(values, str) and TEMP_PATT.search(values):
                    values = {TEMP: values}
                elif not isinstance(values, dict):
-                    values = {None: values}
+                    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(
@@ -312,7 +534,16 @@ class MegaD:
                        unit_of_measurement=UNITS.get(key, UNITS[TEMP]),
                        device_class=CLASSES.get(key, CLASSES[TEMP]),
                        id_suffix=key,
                        http_cmd=http_cmd,
                    ))
        return ret
    async def restore_states(self):
        for x in self.entities:
            if isinstance(x, MegaOutPort):
                if x.is_on:
                    await x.async_turn_on(brightness=x.brightness)
                else:
                    await x.async_turn_off()
--- 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.4.2b1"
 }
--- a/custom_components/mega/sensor.py
+++ b/custom_components/mega/sensor.py
@@ -13,11 +13,12 @@ from homeassistant.const import (
    CONF_PORT,
    CONF_UNIQUE_ID,
    CONF_ID,
-    CONF_TYPE, CONF_UNIT_OF_MEASUREMENT,
+    CONF_TYPE, CONF_UNIT_OF_MEASUREMENT, CONF_VALUE_TEMPLATE,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.template import Template
 from .entities import MegaPushEntity
-from .const import CONF_KEY, TEMP, HUM, W1, W1BUS
+from .const import CONF_KEY, TEMP, HUM, W1, W1BUS, CONF_CONV_TEMPLATE
 from .hub import MegaD
 import re
@@ -111,13 +112,11 @@ class Mega1WSensor(MegaPushEntity):
        :param patt: pattern to extract value, must have at least one group that will contain parsed value
        """
        super().__init__(*args, **kwargs)
        self.mega.sensors.append(self)
        self._value = None
        self.key = key
        self._device_class = device_class
        self._unit_of_measurement = unit_of_measurement
-        if self.port not in self.mega.sensors:
+        self.mega.sensors.append(self)
            self.mega.sensors.append(self.port)
    @property
    def unit_of_measurement(self):
@@ -144,13 +143,36 @@ class Mega1WSensor(MegaPushEntity):
    @property
    def state(self):
        ret = None
        if self.key:
-            ret = self.mega.values.get(self.port, {}).get('value', {}).get(self.key)
+            try:
                ret = self.mega.values.get(self.port, {})
                if isinstance(ret, dict):
                    ret = ret.get('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, self.customize.get(CONF_VALUE_TEMPLATE))
        if tmpl is not None and self.hass is not None:
            tmpl.hass = self.hass
            ret = tmpl.async_render({'value': ret})
        return ret
-    def _update(self, payload: dict):
+    @property
-        self.mega.values[self.port] = payload
+    def name(self):
        n = super().name
        c = self.customize.get(CONF_NAME, {})
        if isinstance(c, dict):
            c = c.get(self.key)
        return c or n
--- 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,16 @@
          "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%]",
          "fake_response": "[%key:common::config_flow::data::fake_response%]",
          "force_d": "[%key:common::config_flow::data::force_d%]",
          "protected": "[%key:common::config_flow::data::protected%]",
          "allow_hosts": "[%key:common::config_flow::data::allow_hosts%]",
          "restore_on_restart": "[%key:common::config_flow::data::restore_on_restart%]",
          "poll_outs": "[%key:common::config_flow::data::poll_outs%]"
        }
      }
    },
@@ -32,7 +41,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
@@ -15,7 +15,7 @@ from homeassistant.const import (
    CONF_DOMAIN,
 )
 from homeassistant.core import HomeAssistant
-from .entities import MegaD
+from . import hub as h
 from .entities import MegaOutPort
 from .const import CONF_DIMMER, CONF_SWITCH, DOMAIN, CONF_CUSTOM, CONF_SKIP
@@ -45,7 +45,7 @@ async def async_setup_platform(hass, config, add_entities, discovery_info=None):
 async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, async_add_devices):
    mid = config_entry.data[CONF_ID]
-    hub: MegaD = hass.data['mega'][mid]
+    hub: 'h.MegaD' = hass.data['mega'][mid]
    devices = []
    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {})
--- a/custom_components/mega/tools.py
+++ b/custom_components/mega/tools.py
@@ -0,0 +1,13 @@
 _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": {
@@ -18,7 +19,16 @@
                    "id": "ID",
                    "mqtt_id": "MQTT id",
                    "scan_interval": "Scan interval (sec), 0 - don't update",
-                    "port_to_scan": "Port to poll aliveness (needed only if no sensors used)"
+                    "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
                    "nports": "Number of ports",
                    "update_all": "Update all outs when input",
                    "mqtt_inputs": "Use MQTT (Deprecated)",
                    "fake_response": "Fake response",
                    "force_d": "Force 'd' response",
                    "protected": "Protected",
                    "allow_hosts": "Allowed hosts",
                    "restore_on_restart": "Restore outs on restart",
                    "poll_outs": "Poll outs"
                }
            }
        }
@@ -29,7 +39,15 @@
                "data": {
                  "scan_interval": "Scan interval (sec), 0 - don't update",
                  "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
-                  "reload": "Reload objects"
+                  "reload": "Reload objects",
                  "mqtt_inputs": "Use MQTT (Deprecated)",
                  "update_all": "Update all outs when input",
                  "fake_response": "Fake response",
                  "force_d": "Force 'd' response",
                  "protected": "Protected",
                  "allow_hosts": "Allowed hosts",
                  "restore_on_restart": "Restore outs on restart",
                  "poll_outs": "Poll outs"
                }
            }
        }
--- a/custom_components/mega/translations/ru.json
+++ b/custom_components/mega/translations/ru.json
@@ -18,7 +18,16 @@
                    "id": "ID",
                    "mqtt_id": "MQTT id",
                    "scan_interval": "Периодичность обновлений (сек.), 0 - не обновлять",
-                    "port_to_scan": "Порт, который сканируется когда нет датчиков"
+                    "port_to_scan": "Порт, который сканируется когда нет датчиков",
                    "mqtt_inputs": "Использовать MQTT (Не рекомендуется)",
                    "nports": "Кол-во портов",
                    "update_all": "Обновить все выходы когда срабатывает вход",
                    "fake_response": "Имитация http-ответа",
                    "force_d": "Ответ 'd' по умолчанию",
                    "protected": "Блокировать неразрешенные соединения",
                    "restore_on_restart": "Восстанавливать выходы при перезагрузке",
                    "allow_hosts": "Разрешенные ip (через ;)",
                    "poll_outs": "Обновлять выходы (регулярно)"
                }
            }
        }
@@ -30,7 +39,16 @@
                  "scan_interval": "Периодичность обновлений (сек.), 0 - не обновлять",
                  "port_to_scan": "Порт, который сканируется когда нет датчиков",
                  "reload": "Обновить объекты",
-                  "invert": "Список портов (через ,) с инвертированной логикой"
+                  "invert": "Список портов (через ,) с инвертированной логикой",
                  "mqtt_inputs": "Использовать MQTT (Не рекомендуется)",
                  "fake_response": "Имитация http-ответа",
                  "force_d": "Ответ 'd' по умолчанию",
                  "nports": "Кол-во портов",
                  "update_all": "Обновить все выходы когда срабатывает вход",
                  "protected": "Блокировать неразрешенные соединения",
                  "allow_hosts": "Разрешенные ip (через ;)",
                  "restore_on_restart": "Восстанавливать выходы при перезагрузке",
                  "poll_outs": "Обновлять выходы (регулярно)"
                }
            }
        }
--- a/custom_components/mega/translations/uk.json
+++ b/custom_components/mega/translations/uk.json
@@ -17,8 +17,17 @@
                    "username": "Користувач",
                    "id": "ID",
                    "mqtt_id": "MQTT id",
-                    "scan_interval": "Період оновлення (сек.)",
+                    "scan_interval": "Період оновлення (сек.), 0 - не оновлювати",
-                    "port_to_scan": "Порт для сканування при відсутності датчиків"
+                    "port_to_scan": "Порт для сканування при відсутності датчиків",
                    "mqtt_inputs": "Використовувати MQTT (Deprecated)",
                    "nports": "Кількість портів",
                    "update_all": "Оновити всі виходи коли спрацьовує вхід",
                    "fake_response": "Імітація http-відповіді",
                    "force_d": "Неявно відповідати 'd'",
                    "protected": "Блокувати недозволені з'єднання",
                    "allow_hosts": "Дозволені ip (через ;)",
                    "restore_on_restart": "Відновлювати виходи при перезавантаженні",
                    "poll_outs": "Оновити виходи"
                }
            }
        }
@@ -27,10 +36,19 @@
        "step": {
            "init": {
                "data": {
-                  "scan_interval": "Період оновлення (сек.)",
+                    "scan_interval": "Період оновлення (сек.)",
-                  "port_to_scan": "Порт для сканування при відсутності датчиків",
+                    "port_to_scan": "Порт для сканування при відсутності датчиків",
-                  "reload": "Оновити об'єкти",
+                    "reload": "Оновити об'єкти",
-                  "invert": "Список портів з інвертованою логікою (через ,)"
+                    "invert": "Список портів з інвертованою логікою (через ,)",
                    "mqtt_inputs": "Використовувати MQTT (Deprecated)",
                    "nports": "Кількість портів",
                    "fake_response": "Імітація http-відповіді",
                    "force_d": "Неявно відповідати 'd'",
                    "update_all": "Оновити всі виходи коли спрацьовує вхід",
                    "protected": "Блокувати недозволені з'єднання",
                    "allow_hosts": "Дозволені ip (через ;)",
                    "restore_on_restart": "Відновлювати виходи при перезавантаженні",
                    "poll_outs": "Оновити виходи"
                }
            }
        }
--- a/readme.md
+++ b/readme.md
@@ -1,31 +1,46 @@
 # 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](https://www.ab-log.ru/smart-house/ethernet/megad-2561)
+Интеграция с [MegaD-2561, MegaD-328](https://www.ab-log.ru/smart-house/ethernet/megad-2561)
 Если вам понравилась интеграция, не забудьте поставить звезду на гитхабе - вам не сложно, а мне приятно ) А если
 интеграция очень понравилась - еще приятнее, если вы воспользуетесь кнопкой доната )
 Обновление прошивки MegaD можно делать прямо из HA с помощью [аддона](https://github.com/andvikt/mega_addon.git)
 Подробная документация по [ссылке](https://github.com/andvikt/mega_hacs/wiki)
 Предложения по доработкам просьба писать в [discussions](https://github.com/andvikt/mega_hacs/discussions), о проблемах
 создавать [issue](https://github.com/andvikt/mega_hacs/issues/new/choose)
 ## Основные особенности:
- Настройка в веб-интерфейсе + yaml
+- Настройка в веб-интерфейсе + [yaml](https://github.com/andvikt/mega_hacs/wiki/Кастомизация)
 - Все порты автоматически добавляются как устройства (для обычных релейных выходов создается 
  `light`, для шим - `light` с поддержкой яркости, для цифровых входов `binary_sensor`, для датчиков
  `sensor`)
 - Возможность работы с несколькими megad
- Обратная связь по mqtt
+- Обратная связь по [http](https://github.com/andvikt/mega_hacs/wiki/http) или mqtt (`deprecated`, поддержка mqtt 
- События на двойные/долгие нажатия
+  будет выключена в версиях >= 1.0.0, тк в нем нет необходимости)
 - [События](https://github.com/andvikt/mega_hacs/wiki/События) на двойные/долгие нажатия
 - Команды выполняются друг за другом без конкурентного доступа к ресурсам megad, это дает гарантии надежного исполнения
  большого кол-ва команд (например в сценах). Каждая следующая команда отправляется только после получения ответа о
  выполнении предыдущей.
-
+- поддержка [ds2413](https://www.ab-log.ru/smart-house/ethernet/megad-2w) (начиная с версии 0.4.1)
 ## Зависимости
 **Важно!!** Перед использованием необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
 в HomeAssistant
 Для максимальной совместимости необходимо обновить ваш контроллер до последней версии, тк были важные обновления в части
 mqtt
 ## Установка
 Рекомендованный способ с поддержкой обновлений - [HACS](https://hacs.xyz/docs/installation/installation):
 HACS - Integrations - Explore, в поиске ищем MegaD. 
 Чтобы включить возможность использования бета-версий, зайдите в HACS, найдите интеграцию MegaD, нажмите три точки, 
 там кнопка "переустановить" или reinstall, дальше нужно нажать галку "показывать бета-версии"
 Обновления выполняются так же в меню HACS. 
 Информация об обновлениях приходит с некоторым интервалом, чтобы вручную проверить наличие обновлений
 нажмите три точки возле интеграции в меню HACS и нажмите `обновить информацию`
 Альтернативный способ установки:
 ```shell
 # из папки с конфигом
@@ -38,107 +53,23 @@ wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.
 Все имеющиеся у вас порты будут настроены автоматически. Вы можете менять названия, иконки и entity_id так же из интерфейса.
-#### Кастомизация устройств с помощью yaml:
+В самой меге необходимо прописать настройки:
 ```yaml
-# configuration.yaml
+srv: "192.168.1.4:8123" # ip:port вашего HA
-
+script: "mega" # это api интеграции, к которому будет обращаться контроллер
 mega:
  hello: # ID меги, как в UI 
    7: # номер порта
      domain: switch # тип устройства (switch или light, по умолчанию для цифровых выходов используется light)
      invert: true # инвертировать или нет (по умолчанию false)
      name: Насос # имя устройства
    8:
      # исключить из сканирования
      skip: true
    33:
      # для датчиков можно кастомизировать только имя и unit_of_measurement
      # для температуры и влажность unit определяется автоматически, для остальных юнита нет 
      name: какой-то датчик
      unit_of_measurement:
        hum: "%" # если датчиков несколько, то можно указывать юниты по их ключам
        temp: "°C"
    14:
      name: какой-то датчик
      unit_of_measurement: "°C" # если датчик один, то просто строчкой
 ```
 Так же необходимо настроить Mega-ID в настройках контроллера, для каждой меги id должен быть разным.
-## События
+При любых изменениях настроек контроллера (типы входов, id и тд) необходимо в настройках интеграции нажать `Обновить 
-`binary_sensor` срабатывает когда цифровой выход принимает значение 'ON', вместе с этим
+объекты`
 он сохраняет полученные параметры от меги в аттрибутах. Атрибутами можно пользоваться так:
 ```yaml
 - alias: some double click
  trigger:
    - platform: state
      entity_id: binary_sensor.mega_1
      attribute: cnt
      to: 2
  action:
    - service: light.toggle
      entity_id: light.some_light
 ```
 Однако, особенность state-триггера в атоматизациях HA в том, что он срабатывает только когда state меняется. Это может 
 мешать, тк если вы повторно совершите двойной клик, стейт уже не поменяется, поэтому рекомендуется
 пользоваться event-триггером.
-При каждом срабатывании `binary_sensor` так же сообщает о событии типа `mega.sensor`.
+## Зависимости
-События можно использовать в автоматизациях, например так:
+Для максимальной скорости реакции на команды сервера, рекомендуется выключить `имитацию http-ответа` в 
-```yaml
+настройках интеграции и настроить proxy_pass к HA, самый простой способ сделать это - воспользоваться 
- alias: some double click
+[специальным аддоном](https://github.com/andvikt/mega_addon/tree/master/mega-proxy)
  trigger:
    - platform: event
      event_type: mega.sensor
      event_data:
        entity_id: binary_sensor.mega_1
        cnt: 2
  action:
    - service: light.toggle
      entity_id: light.some_light
 ```
 Чтобы понять, какие события происходят, лучше всего воспользоваться панелью разработчика и подписаться
 на вкладке события на событие `mega.sensor`, понажимать кнопки.
-## Сервисы
+Обновить ваш контроллер до последней версии, обновление прошивки MegaD можно делать 
-Все сервисы доступны в меню разработчика с описанием и примерами использования
+из HA с помощью [аддона](https://github.com/andvikt/mega_addon.git)
 ```yaml
 mega.save:
  description: Сохраняет текущее состояние портов (?cmd=s)
  fields:
    mega_id:
      description: ID меги, можно оставить пустым, тогда будут сохранены все зарегистрированные меги
      example: "mega"
 mega.get_port:
  description: Запросить текущий статус порта (или всех)
  fields:
    mega_id:
      description: ID меги, можно оставить пустым, тогда будут порты всех зарегистрированных мег
      example: "mega"
    port:
      description: Номер порта (если не заполнять, будут запрошены все порты сразу)
      example: 1
-mega.run_cmd:
+Подробная документация по [ссылке](https://github.com/andvikt/mega_hacs/wiki)
  description: Выполнить любую произвольную команду
  fields:
    mega_id:
      description: ID меги
      example: "mega"
    port:
      description: Номер порта (это не порт, которым мы управляем, а порт с которого шлем команду)
      example: 1
    cmd:
      description: Любая поддерживаемая мегой команда
      example: "1:0"
 ```
 ## Отладка
 Интеграция находится в активной разработке, при возникновении проблем [заводите issue](https://github.com/andvikt/mega_hacs/issues/new/choose)
 Просьба прикладывать детальный лог, который можно включить в конфиге так:
 ```yaml
 logger:
  default: info
  logs:
    custom_components.mega: debug
 ```
Author	SHA1	Message	Date
Andrey	2c0894356c	добавлена возможность восстановления состояний выходов после перезагрузки меги	2021-02-24 10:56:11 +03:00
andvikt	cdc38f2200	Merge pull request #16 from Foroxon/master UA translation update	2021-02-22 16:15:16 +03:00
Vladyslav Heneraliuk	bab1eab64a	updated UA translation	2021-02-22 10:28:17 +02:00
Vladyslav Heneraliuk	c5d8ece77f	Repo Sync (#2 ) Repo Sync	2021-02-22 10:18:26 +02:00
Andrey	e4c5a4a712	find mega by mdid	2021-02-22 09:53:58 +03:00
Andrey	c60c088795	add allow hosts to web-ui	2021-02-20 18:10:36 +03:00
Andrey	eb3813843c	edit readme	2021-02-19 12:46:10 +03:00
Andrey	804a6ad333	add proxy support	2021-02-19 11:10:34 +03:00
Andrey	a3398d0f2a	add proxy support	2021-02-19 10:47:08 +03:00
Andrey	1e8777ca6d	add proxy support	2021-02-19 10:39:15 +03:00
Andrey	ad2501ca8c	add proxy support	2021-02-19 10:32:28 +03:00
Andrey	5681f7315c	add proxy support	2021-02-19 10:06:56 +03:00
Andrey	da87c24db9	add proxy support	2021-02-19 09:50:31 +03:00
Andrey	a0dcfa4b9c	fix force_d	2021-02-18 20:09:45 +03:00
Andrey	80e43888b9	fix force_d	2021-02-18 15:45:13 +03:00
Andrey	ba41cbb100	fix 1wire bus	2021-02-18 15:41:12 +03:00
Andrey	0b5b9744ba	fix 1wire bus	2021-02-18 15:40:59 +03:00
Andrey	9746311f38	fix 1wire bus	2021-02-18 15:40:31 +03:00
Andrey	38a525f2f5	fix	2021-02-18 15:16:43 +03:00
Andrey	6503d6bddd	fix 1wire	2021-02-18 15:02:21 +03:00
Andrey	4af40c29a7	fix d	2021-02-18 14:10:04 +03:00
Andrey	75a41c9667	fix i2c	2021-02-18 12:36:43 +03:00
Andrey	4f8f38fde6	fix http response and ds2413 bugs	2021-02-18 12:07:55 +03:00
Andrey	7e02797be8	fix http response	2021-02-18 11:58:33 +03:00
Andrey	035bdebf64	fix ds2413	2021-02-18 11:42:23 +03:00
Andrey	8d92bbdfb3	ad more logging	2021-02-18 11:23:44 +03:00
Andrey	0c43e61c59	make fake http response	2021-02-18 11:11:30 +03:00
Andrey	0a71be693e	fix bugs	2021-02-18 11:00:41 +03:00
Andrey	8146148d0c	fix bugs	2021-02-18 10:46:17 +03:00
Andrey	e0eaafd0fa	fix bugs	2021-02-18 10:40:09 +03:00
Andrey	51f3eb3b19	fix bugs	2021-02-18 10:23:27 +03:00
Andrey	1716651497	fix bugs	2021-02-18 10:12:01 +03:00
Andrey	a87e8139a7	fix bugs	2021-02-18 09:53:30 +03:00
Andrey	358d29f8fd	fix bugs	2021-02-18 09:27:40 +03:00
Andrey	fcce9dcfc1	fix bugs	2021-02-17 22:01:33 +03:00
Andrey	4fe2469a01	fix bugs	2021-02-17 19:10:58 +03:00
Andrey	9fab4fce62	fix config scan for ds2413	2021-02-17 18:08:53 +03:00
Andrey	3c28cf4598	Merge remote-tracking branch 'origin/master'	2021-02-17 18:04:53 +03:00
Andrey	af2360b0a0	edit	2021-02-17 18:04:09 +03:00
andvikt	8f7604c9f6	Update bug-report.md	2021-02-17 17:44:56 +03:00
andvikt	f70d72bf39	Update bug-report.md	2021-02-17 17:44:37 +03:00
Andrey	896e02a457	edit readme	2021-02-17 17:40:26 +03:00
Andrey	bb95c9d312	edit readme	2021-02-17 17:23:23 +03:00
Andrey	7ba1562f12	fix assumed state	2021-02-17 17:11:00 +03:00
Andrey	ec505ac2ef	edit readme	2021-02-17 16:50:00 +03:00
Andrey	9544f562ba	do not update all if "v" parametr	2021-02-15 21:54:21 +03:00
Andrey	c2422cac9c	fix manifest	2021-02-15 21:51:31 +03:00
Andrey	0adba7fc0f	add http v parsing	2021-02-15 21:50:49 +03:00
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