add i2c sensors

fix errors
2025-12-12 01:24:29 +05:00 · 2021-03-03 12:01:02 +03:00 · 2021-02-28 22:27:57 +03:00 · 2021-02-28 22:22:17 +03:00 · 2021-02-28 22:06:36 +03:00 · 2021-02-28 22:02:22 +03:00
20 changed files with 863 additions and 193 deletions
--- a/.experiment.py
+++ b/.experiment.py
@@ -1,35 +1,121 @@
-import asyncio
+from urllib.parse import urlparse, parse_qsl
-from asyncio import Event, FIRST_COMPLETED
+
-import signal
+from bs4 import BeautifulSoup
 page = '''
 <html><head></head><body><a href="/sec/?pt=33">Back</a><br>0x15 - <a href="/sec/?pt=33&amp;scl=32&amp;i2c_dev=t67xx">T67XX</a><br>0x40 - <a href="/sec/?pt=33&amp;scl=32&amp;i2c_dev=htu21d">HTU21D</a>/PCA9685/HM3301<br>0x4a - <a href="/sec/?pt=33&amp;scl=32&amp;i2c_dev=max44009">MAX44009</a><br>
 </body></html>
 '''
 from urllib.parse import parse_qsl, urlparse
 from bs4 import BeautifulSoup
 from homeassistant.const import (
    DEVICE_CLASS_HUMIDITY,
    DEVICE_CLASS_TEMPERATURE,
    DEVICE_CLASS_ILLUMINANCE,
    DEVICE_CLASS_PRESSURE,
 )
-stop = Event()
+def parse_scan_page(page: str):
-loop = asyncio.get_event_loop()
+    ret = []
    req = []
    page = BeautifulSoup(page, features="lxml")
    for x in page.find_all('a'):
        params = x.get('href')
        if params is None:
            continue
        params = dict(parse_qsl(urlparse(params).query))
        if 'i2c_dev' in params:
            dev = params['i2c_dev']
            classes = i2c_classes.get(dev, [])
            for i, c in enumerate(classes):
                if c is Skip:
                    continue
                elif c is Request:
                    req.append(params)
                    continue
                elif isinstance(c, tuple):
                    suffix, c = c
                elif isinstance(c, str):
                    suffix = c
                else:
                    suffix = ''
                if 'addr' in params:
                    suffix += f"_{params['addr']}" if suffix else str(params['addr'])
                if suffix:
                    _dev = f'{dev}_{suffix}'
                else:
                    _dev = dev
                params = params.copy()
                if i > 0:
                    params['i2c_par'] = i
                ret.append({
                    'id_suffix': _dev,
                    'device_class': c,
                    'params': params,
                })
                req.append(params)
    return req, ret
-async def handler(
+class Skip:
-        reader: asyncio.StreamReader,
+    pass
        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():
+class Request:
-    server = await asyncio.start_server(
+    pass
        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(
+i2c_classes = {
-        signal.SIGINT, stop.set
+    'htu21d': [
-    )
+        DEVICE_CLASS_HUMIDITY,
-    loop.run_until_complete(serve())
+        DEVICE_CLASS_TEMPERATURE,
    ],
    'sht31': [
        DEVICE_CLASS_HUMIDITY,
        DEVICE_CLASS_TEMPERATURE,
    ],
    'max44009': [
        DEVICE_CLASS_ILLUMINANCE
    ],
    'bh1750': [
        DEVICE_CLASS_ILLUMINANCE
    ],
    'tsl2591': [
        DEVICE_CLASS_ILLUMINANCE
    ],
    'bmp180': [
        DEVICE_CLASS_PRESSURE,
        DEVICE_CLASS_TEMPERATURE,
    ],
    'bmx280': [
        DEVICE_CLASS_PRESSURE,
        DEVICE_CLASS_TEMPERATURE,
        DEVICE_CLASS_HUMIDITY
    ],
    'mlx90614': [
        Skip,
        ('temp', DEVICE_CLASS_TEMPERATURE),
        ('object', DEVICE_CLASS_TEMPERATURE),
    ],
    'ptsensor': [
        Request,  # запрос на измерение
        DEVICE_CLASS_PRESSURE,
        DEVICE_CLASS_TEMPERATURE,
    ],
    'mcp9600': [
        DEVICE_CLASS_TEMPERATURE,  # термопара
        DEVICE_CLASS_TEMPERATURE,  # сенсор встроенный в микросхему
    ],
    't67xx': [
        None  # для co2 нет класса в HA
    ],
    'tmp117': [
        DEVICE_CLASS_TEMPERATURE,
    ]
 }
 print(parse_scan_page(page))
--- a/custom_components/mega/init.py
+++ b/custom_components/mega/init.py
@@ -7,7 +7,7 @@ import voluptuous as vol
 from homeassistant.const import (
    CONF_SCAN_INTERVAL, CONF_ID, CONF_NAME, CONF_DOMAIN,
-    CONF_UNIT_OF_MEASUREMENT, CONF_HOST, CONF_VALUE_TEMPLATE
+    CONF_UNIT_OF_MEASUREMENT, CONF_HOST, CONF_VALUE_TEMPLATE, CONF_DEVICE_CLASS
 )
 from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers.service import bind_hass
@@ -34,6 +34,10 @@ CUSTOMIZE_PORT = {
        vol.Any(str, {
            vol.Required(str): str
        }),
    vol.Optional(CONF_DEVICE_CLASS):
        vol.Any(str, {
            vol.Required(str): str
        }),
    vol.Optional(
        CONF_RESPONSE_TEMPLATE,
        description='шаблон ответа когда на этот порт приходит'
@@ -47,6 +51,14 @@ CUSTOMIZE_DS2413 = {
    vol.Optional(str.lower, description='адрес и индекс устройства'): CUSTOMIZE_PORT
 }
 def extender(x):
    if isinstance(x, str) and 'e' in x:
        return x
    else:
        raise ValueError('must has "e" in port name')
 CONFIG_SCHEMA = vol.Schema(
    {
        DOMAIN: {
@@ -58,7 +70,7 @@ CONFIG_SCHEMA = vol.Schema(
                    description='Ответ по умолчанию',
                    default=None
                ): vol.Any(cv.template, None),
-                vol.Optional(int, description='номер порта'): vol.Any(
+                vol.Optional(vol.Any(int, extender), description='номер порта'): vol.Any(
                    CUSTOMIZE_PORT,
                    CUSTOMIZE_DS2413,
                )
@@ -128,8 +140,8 @@ async def get_hub(hass, entry):
 async def _add_mega(hass: HomeAssistant, entry: ConfigEntry):
    id = entry.data.get('id', entry.entry_id)
    hub = await get_hub(hass, entry)
-    hass.data[DOMAIN][id] = hass.data[DOMAIN]['__def'] = hub
+    hub.fw = await hub.get_fw()
-    hass.data[DOMAIN][entry.data.get(CONF_HOST)] = hub
+    hass.data[DOMAIN][id] = hub
    hass.data[DOMAIN][CONF_ALL][id] = hub
    if not await hub.authenticate():
        raise Exception("not authentificated")
@@ -174,7 +186,7 @@ async def updater(hass: HomeAssistant, entry: ConfigEntry):
 async def async_remove_entry(hass, entry) -> None:
    """Handle removal of an entry."""
    id = entry.data.get('id', entry.entry_id)
-    hub: MegaD = hass.data[DOMAIN][id]
+    hub: MegaD = hass.data[DOMAIN].get(id)
    if hub is None:
        return
    _LOGGER.debug(f'remove {id}')
--- a/custom_components/mega/binary_sensor.py
+++ b/custom_components/mega/binary_sensor.py
@@ -20,7 +20,7 @@ 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
-
+from .tools import int_ignore
 lg = logging.getLogger(__name__)
@@ -51,7 +51,7 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
    devices = []
    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {})
    for port, cfg in config_entry.data.get('binary_sensor', {}).items():
-        port = int(port)
+        port = int_ignore(port)
        c = customize.get(mid, {}).get(port, {})
        if c.get(CONF_SKIP, False):
            continue
@@ -67,6 +67,10 @@ class MegaBinarySensor(BinarySensorEntity, MegaPushEntity):
        super().__init__(*args, **kwargs)
        self._is_on = None
        self._attrs = None
        self._click_task = None
    async def _click(self):
        await self.customize.get
    @property
    def state_attributes(self):
@@ -78,14 +82,15 @@ class MegaBinarySensor(BinarySensorEntity, MegaPushEntity):
    @property
    def is_on(self) -> bool:
-        val = self.mega.values.get(self.port, {}).get("value") \
+        val = self.mega.values.get(self.port, {})
-              or self.mega.values.get(self.port, {}).get('m')
+        if isinstance(val, dict):
            val = val.get("value", val.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']:
+            if val in ['ON', 'OFF', '1', '0']:
-                return val == 'ON' if not self.invert else val == 'OFF'
+                return val in ['ON', '1'] if not self.invert else val in ['OFF', '0']
-            else:
+            elif isinstance(val, int):
                return val != 1 if not self.invert else val == 1
    def _update(self, payload: dict):
--- a/custom_components/mega/config_flow.py
+++ b/custom_components/mega/config_flow.py
@@ -10,7 +10,8 @@ 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, CONF_MQTT_INPUTS, \
-    CONF_NPORTS, CONF_UPDATE_ALL, CONF_POLL_OUTS, CONF_FAKE_RESPONSE, CONF_FORCE_D  # pylint:disable=unused-import
+    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
@@ -29,6 +30,9 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
        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,
    },
 )
@@ -59,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 = 10
+    VERSION = 18
    CONNECTION_CLASS = config_entries.CONN_CLASS_ASSUMED
    async def async_step_user(self, user_input=None):
@@ -109,12 +113,12 @@ 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)
            cfg.update(user_input)
-            hub = await get_hub(self.hass, self.config_entry.data)
+            hub = await get_hub(self.hass, cfg)
            if reload:
                await hub.start()
                new = await hub.get_config(nports=user_input.get(CONF_NPORTS, 37))
@@ -142,6 +146,9 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
                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/config_parser.py
+++ b/custom_components/mega/config_parser.py
@@ -0,0 +1,59 @@
 from dataclasses import dataclass, field
 from bs4 import BeautifulSoup
 inputs = [
    'eact',
    'inta',
    'misc',
 ]
 selectors = [
    'pty',
    'm',
    'gr',
    'd',
    'ety',
 ]
@dataclass(frozen=True, eq=True)
 class Config:
    pty: str = None
    m: str = None
    gr: str = None
    d: str = None
    ety: str = None
    inta: str = field(compare=False, hash=False, default=None)
    misc: str = field(compare=False, hash=False, default=None)
    eact: str = field(compare=False, hash=False, default=None)
    src: BeautifulSoup = field(compare=False, hash=False, default=None)
 def parse_config(page: str):
    page = BeautifulSoup(page, features="lxml")
    ret = {}
    for x in selectors:
        v = page.find('select', attrs={'name': x})
        if v is None:
            continue
        else:
            v = v.find(selected=True)
            if v:
                v = v['value']
                ret[x] = v
    for x in inputs:
        v = page.find('input', attrs={'name': x})
        if v:
            ret[x] = v['value']
    return Config(**ret, src=page)
 DIGITAL_IN = Config(pty="0")
 RELAY_OUT = Config(pty="1", m="0")
 PWM_OUT = Config(pty="1", m="1")
 DS2413 = Config(pty="1", m="2")
 MCP230 = Config(pty="4", m="1", gr="3", d="20")
 MCP230_OUT = Config(ety="1")
 MCP230_IN = Config(ety="0")
 PCA9685 = Config(pty="4", m="1", gr="3", d="21")
 OWIRE_BUS = Config(pty="3", d="5")
--- a/custom_components/mega/const.py
+++ b/custom_components/mega/const.py
@@ -26,10 +26,14 @@ 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'
 CONF_CLICK_TIME = 'click_time'
 CONF_LONG_TIME = 'long_time'
 PLATFORMS = [
    "light",
    "switch",
@@ -48,3 +52,5 @@ PRESS = 'press'
 LUX = 'lux'
 SINGLE_CLICK = 'single'
 DOUBLE_CLICK = 'double'
 PATT_FW = re.compile(r'fw:\s(.+)\)')
--- a/custom_components/mega/entities.py
+++ b/custom_components/mega/entities.py
@@ -96,7 +96,7 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
            "name": f'{self._mega_id} port {self.port}',
            "manufacturer": 'ab-log.ru',
            # "model": self.light.productname,
-            # "sw_version": self.light.swversion,
+            "sw_version": self.mega.fw,
            "via_device": (DOMAIN, self._mega_id),
        }
@@ -214,6 +214,7 @@ class MegaOutPort(MegaPushEntity):
    def __init__(
            self,
            dimmer=False,
            dimmer_scale=1,
            *args, **kwargs
    ):
        super().__init__(
@@ -222,6 +223,7 @@ class MegaOutPort(MegaPushEntity):
        self._brightness = None
        self._is_on = None
        self.dimmer = dimmer
        self.dimmer_scale = dimmer_scale
    # @property
    # def assumed_state(self) -> bool:
@@ -235,10 +237,22 @@ class MegaOutPort(MegaPushEntity):
    def brightness(self):
        if not self.dimmer:
            return
-        val = self.mega.values.get(self.port, {}).get("value")
+        val = self.mega.values.get(self.port, {})
-        if val is None and self._state is not None:
+        if isinstance(val, dict) and len(val) == 0 and self._state is not None:
            return self._state.attributes.get("brightness")
        elif isinstance(self.port, str) and 'e' in self.port:
            if isinstance(val, str):
                val = safe_int(val)
            else:
                val = 0
            if val == 0:
                return self._brightness
            elif isinstance(val, (int, float)):
                return int(val / self.dimmer_scale)
        elif val is not None:
            val = val.get("value")
            if val is None:
                return
            try:
                val = int(val)
                return val
@@ -248,9 +262,17 @@ class MegaOutPort(MegaPushEntity):
    @property
    def is_on(self) -> bool:
        val = self.mega.values.get(self.port, {})
-
+        if isinstance(val, dict) and len(val) == 0 and self._state is not None:
        if val is None and self._state is not None:
            return self._state == 'ON'
        elif isinstance(self.port, str) and 'e' in self.port and val:
            if val is None:
                return
            if self.dimmer:
                val = safe_int(val)
                if val is not None:
                    return val > 0 if not self.invert else val == 0
            else:
                return val == 'ON' if not self.invert else val == 'OFF'
        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:
@@ -286,17 +308,17 @@ class MegaOutPort(MegaPushEntity):
    async def async_turn_on(self, brightness=None, **kwargs) -> None:
        brightness = brightness or self.brightness or 255
-
+        self._brightness = brightness
        if self.dimmer and brightness == 0:
-            cmd = 255
+            cmd = 255 * self.dimmer_scale
        elif self.dimmer:
-            cmd = brightness
+            cmd = brightness * self.dimmer_scale
        else:
            cmd = 1 if not self.invert else 0
        _cmd = {"cmd": f"{self.cmd_port}:{cmd}"}
        if self.addr:
            _cmd['addr'] = self.addr
-        await self.mega.request(**_cmd)
+        await self.mega.request(**_cmd, priority=-1)
        if self.index is not None:
            # обновление текущего стейта для ds2413
            await self.mega.get_port(
@@ -305,6 +327,11 @@ class MegaOutPort(MegaPushEntity):
                conv=False,
                http_cmd='list',
            )
        elif isinstance(self.port, str) and 'e' in self.port:
            if not self.dimmer:
                self.mega.values[self.port] = 'ON' if not self.invert else 'OFF'
            else:
                self.mega.values[self.port] = cmd
        else:
            self.mega.values[self.port] = {'value': cmd}
        await self.get_state()
@@ -315,7 +342,7 @@ class MegaOutPort(MegaPushEntity):
        _cmd = {"cmd": f"{self.cmd_port}:{cmd}"}
        if self.addr:
            _cmd['addr'] = self.addr
-        await self.mega.request(**_cmd)
+        await self.mega.request(**_cmd, priority=-1)
        if self.index is not None:
            # обновление текущего стейта для ds2413
            await self.mega.get_port(
@@ -324,14 +351,18 @@ class MegaOutPort(MegaPushEntity):
                conv=False,
                http_cmd='list',
            )
        elif isinstance(self.port, str) and 'e' in self.port:
            self.mega.values[self.port] = 'OFF' if not self.invert else 'ON'
        else:
            self.mega.values[self.port] = {'value': cmd}
        await self.get_state()
 def safe_int(v):
-    if v in ['ON', 'OFF']:
+    if v == 'ON':
-        return None
+        return 1
    elif v == 'OFF':
        return 0
    try:
        return int(v)
    except (ValueError, TypeError):
--- a/custom_components/mega/http.py
+++ b/custom_components/mega/http.py
@@ -16,6 +16,12 @@ from . import hub as h
 _LOGGER = logging.getLogger(__name__).getChild('http')
 def is_ext(data: typing.Dict[str, typing.Any]):
    for x in data:
        if x.startswith('ext'):
            return True
 class MegaView(HomeAssistantView):
    url = '/mega'
@@ -24,7 +30,9 @@ class MegaView(HomeAssistantView):
    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: {
@@ -34,23 +42,43 @@ class MegaView(HomeAssistantView):
            } 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)
        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 self.protected:
-        if hub is None and request.remote == '::1':
+            auth = False
-            hub = hass.data.get(DOMAIN).get('__def')
+            for x in self.allowed_hosts:
-        if hub is None:
+                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(
@@ -59,6 +87,9 @@ class MegaView(HomeAssistantView):
        )
        _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
@@ -68,25 +99,67 @@ class MegaView(HomeAssistantView):
        data['mega_id'] = hub.id
        ret = 'd' if hub.force_d else ''
        if port is not None:
-            hub.values[port] = data
+            if is_ext(data):
-            for cb in self.callbacks[hub.id][port]:
+                # ret = ''  # пока ответ всегда пустой, неясно какая будет реакция на непустой ответ
-                cb(data)
+                if port in hub.extenders:
-            template: Template = self.templates.get(hub.id, {}).get(port, hub.def_response)
+                    pt_orig = port
                else:
                    pt_orig = hub.ext_in.get(port, hub.ext_in.get(str(port)))
                if pt_orig is None:
                    hub.lg.warning(f'can not find extender for int port {port}, '
                                   f'have ext_int: {hub.ext_in}, ext: {hub.extenders}')
                    return Response(status=200)
                for e, v in data.items():
                    _data = data.copy()
                    if e.startswith('ext'):
                        idx = e[3:]
                        pt = f'{pt_orig}e{idx}'
                        _data['pt_orig'] = pt_orig
                        _data['value'] = 'ON' if v == '1' else 'OFF'
                        _data['m'] = 1 if _data[e] == '0' else 0  # имитация поведения обычного входа, чтобы события обрабатывались аналогично
                        hub.values[pt] = _data
                        for cb in self.callbacks[hub.id][pt]:
                            cb(_data)
                        act = hub.ext_act.get(pt)
                        hub.lg.debug(f'act on port {pt}: {act}, all acts are: {hub.ext_act}')
                        template: Template = self.templates.get(hub.id, {}).get(port, hub.def_response)
                        if template is not None:
                            template.hass = hass
                            ret = template.async_render(_data)
                        hub.lg.debug(f'response={ret}, template={template}')
                        if ret == 'd' and act:
                            await hub.request(cmd=act.replace(':3', f':{v}'))
                        ret = 'd' if hub.force_d else ''
            else:
                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 template is not None:
                    template.hass = hass
                    ret = template.async_render(data)
            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:
+        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')
--- a/custom_components/mega/hub.py
+++ b/custom_components/mega/hub.py
@@ -16,14 +16,16 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from .config_parser import parse_config, DS2413, MCP230, MCP230_OUT, MCP230_IN, PCA9685
 from .const import (
    TEMP, HUM, PRESS,
    LUX, PATT_SPLIT, DOMAIN,
-    CONF_HTTP, EVENT_BINARY_SENSOR, CONF_CUSTOM, CONF_FORCE_D, CONF_DEF_RESPONSE
+    CONF_HTTP, EVENT_BINARY_SENSOR, CONF_CUSTOM, CONF_FORCE_D, CONF_DEF_RESPONSE, PATT_FW
 )
-from .entities import set_events_off, BaseMegaEntity
+from .entities import set_events_off, BaseMegaEntity, MegaOutPort
 from .exceptions import CannotConnect, NoPort
-from .tools import make_ints
+from .i2c import parse_scan_page
 from .tools import make_ints, int_ignore, PriorityLock
 TEMP_PATT = re.compile(r'temp:([01234567890\.]+)')
 HUM_PATT = re.compile(r'hum:([01234567890\.]+)')
@@ -72,11 +74,17 @@ class MegaD:
            scan_interval=60,
            port_to_scan=0,
            nports=38,
-            inverted: typing.List[int] = None,
+            update_all: bool=True,
-            update_all=True,
+            poll_outs: bool=False,
-            poll_outs=False,
+            fake_response: bool=True,
-            fake_response=True,
+            force_d: bool=None,
-            force_d=None,
+            allow_hosts: str=None,
            protected=True,
            restore_on_restart=False,
            extenders=None,
            ext_in=None,
            ext_acts=None,
            i2c_sensors=None,
            **kwargs,
    ):
        """Initialize."""
@@ -84,8 +92,17 @@ class MegaD:
            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.extenders = extenders or []
        self.ext_in = ext_in or {}
        self.ext_act = ext_acts or {}
        self.i2c_sensors = i2c_sensors or []
        self.poll_outs = poll_outs
        self.update_all = update_all if update_all is not None else True
        self.nports = nports
@@ -99,7 +116,7 @@ class MegaD:
        self.id = id
        self.lck = asyncio.Lock()
        self.last_long = {}
-        self._http_lck = asyncio.Lock()
+        self._http_lck = PriorityLock()
        self._notif_lck = asyncio.Lock()
        self.cnd = asyncio.Condition()
        self.online = True
@@ -120,19 +137,29 @@ class MegaD:
        self.updater = DataUpdateCoordinator(
            hass,
            self.lg,
-            name="sensors",
+            name="megad",
            update_method=self.poll,
            update_interval=timedelta(seconds=self.poll_interval) if self.poll_interval else None,
        )
        self.updaters = []
        self.fw = ''
        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()
@@ -221,6 +248,18 @@ class MegaD:
        Polling ports
        """
        self.lg.debug('poll')
        for x in self.i2c_sensors:
            if not isinstance(x, dict):
                continue
            ret = await self._update_i2c(x)
            if isinstance(ret, dict):
                self.values.update(ret)
        for x in self.extenders:
            ret = await self._update_extender(x)
            if not isinstance(ret, dict):
                self.lg.warning(f'wrong updater result: {ret} from extender {x}')
                continue
            self.values.update(ret)
        if self.mqtt is None:
            await self.get_all_ports()
            await self.get_sensors(only_list=True)
@@ -244,14 +283,20 @@ class MegaD:
                _id = _id['value']
            return _id or 'megad/' + self.host.split('.')[-1]
    async def get_fw(self):
        data = await self.request()
        return PATT_FW.search(data).groups()[0]
    async def send_command(self, port=None, cmd=None):
        return await self.request(pt=port, cmd=cmd)
-    async def request(self, **kwargs):
+    async def request(self, priority=0, **kwargs):
        cmd = '&'.join([f'{k}={v}' for k, v in kwargs.items() if v is not None])
-        url = f"http://{self.host}/{self.sec}/?{cmd}"
+        url = f"http://{self.host}/{self.sec}"
        if cmd:
            url = f"{url}/?{cmd}"
        self.lg.debug('request: %s', url)
-        async with self._http_lck:
+        async with self._http_lck(priority):
            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())
@@ -362,7 +407,7 @@ class MegaD:
        if port == 'cmd':
            return
        try:
-            port = int(port)
+            port = int_ignore(port)
        except:
            self.lg.warning('can not process %s', msg)
            return
@@ -391,7 +436,7 @@ class MegaD:
            asyncio.run_coroutine_threadsafe(self._notify(port, value), self.loop)
    def subscribe(self, port, callback):
-        port = int(port)
+        port = int_ignore(port)
        self.lg.debug(
            f'subscribe %s %s', port, callback
        )
@@ -417,61 +462,91 @@ class MegaD:
            return await req.text()
    async def scan_port(self, port):
-        async with self.lck:
+        data = await self.request(pt=port)
-            if port in self._scanned:
+        return parse_config(data)
-                return self._scanned[port]
+        # async with self.lck:
-            url = f'http://{self.host}/{self.sec}/?pt={port}'
+        #     if port in self._scanned:
-            self.lg.debug(
+        #         return self._scanned[port]
-                f'scan port %s: %s', port, url
+        #     url = f'http://{self.host}/{self.sec}/?pt={port}'
-            )
+        #     self.lg.debug(
-            async with aiohttp.request('get', url) as req:
+        #         f'scan port %s: %s', port, url
-                html = await req.text()
+        #     )
-                if req.status != 200:
+        #     async with aiohttp.request('get', url) as req:
-                    return
+        #         html = await req.text()
-            tree = BeautifulSoup(html, features="lxml")
+        #         if req.status != 200:
-            pty = tree.find('select', attrs={'name': 'pty'})
+        #             return
-            if pty is None:
+        #     tree = BeautifulSoup(html, features="lxml")
-                return
+        #     pty = tree.find('select', attrs={'name': 'pty'})
-            else:
+        #     if pty is None:
-                pty = pty.find(selected=True)
+        #         return
-                if pty:
+        #     else:
-                    pty = pty['value']
+        #         pty = pty.find(selected=True)
-                else:
+        #         if pty:
-                    return
+        #             pty = pty['value']
-            if pty in ['0', '1']:
+        #         else:
-                m = tree.find('select', attrs={'name': 'm'})
+        #             return
-                if m:
+        #     if pty in ['0', '1']:
-                    m = m.find(selected=True)['value']
+        #         m = tree.find('select', attrs={'name': 'm'})
-                self._scanned[port] = (pty, m)
+        #         if m:
-                return pty, m
+        #             m = m.find(selected=True)['value']
-            elif pty == '3':
+        #         self._scanned[port] = (pty, m)
-                m = tree.find('select', attrs={'name': 'd'})
+        #         return pty, m
-                if m:
+        #     elif pty == '3':
-                    m = m.find(selected=True)['value']
+        #         m = tree.find('select', attrs={'name': 'd'})
-                self._scanned[port] = (pty, m)
+        #         if m:
-                return pty, m
+        #             m = m.find(selected=True)['value']
-            elif pty in ('2', '4'):  # эта часть не очень проработана, тут есть i2c который может работать неправильно
+        #         self._scanned[port] = (pty, m)
-                m = tree.find('select', attrs={'name': 'd'})
+        #         return pty, m
-                if m:
+        #     elif pty in ('2', '4'):  # эта часть не очень проработана, тут есть i2c который может работать неправильно
-                    m = m.find(selected=True)['value']
+        #         m = tree.find('select', attrs={'name': 'd'})
-                self._scanned[port] = (pty, m or '0')
+        #         if m:
-                return pty, m or '0'
+        #             m = m.find(selected=True)['value']
        #         self._scanned[port] = (pty, m or '0')
        #         return pty, m or '0'
    async def scan_ports(self, nports=37):
        for x in range(0, nports+1):
            ret = await self.scan_port(x)
            if ret:
-                yield [x, *ret]
+                yield x, ret
        self.nports = nports+1
    async def _update_extender(self, port):
        """
        Обновление mcp230, так же подходит для PCA9685
        :param port:
        :return:
        """
        values = await self.request(pt=port, cmd='get')
        ret = {}
        for i, x in enumerate(values.split(';')):
            ret[f'{port}e{i}'] = x
        return ret
    async def _update_i2c(self, params):
        """
        Обновление портов i2c
        :param params: параметры url
        :return:
        """
        _params = tuple(params.items())
        return {
            _params: await self.request(**params)
        }
    async def get_config(self, nports=37):
        ret = defaultdict(lambda: defaultdict(list))
-        async for port, pty, m in self.scan_ports(nports):
+        ret['mqtt_id'] = await self.get_mqtt_id()
-            if pty == "0":
+        ret['extenders'] = extenders = []
        ret['ext_in'] = ext_int = {}
        ret['ext_acts'] = ext_acts = {}
        ret['i2c_sensors'] = i2c_sensors = []
        async for port, cfg in self.scan_ports(nports):
            if cfg.pty == "0":
                ret['binary_sensor'][port].append({})
-            elif pty == "1" and (m in ['0', '1', '3'] or m is None):
+            elif cfg.pty == "1" and (cfg.m in ['0', '1', '3'] or cfg.m is None):
-                ret['light'][port].append({'dimmer': m == '1'})
+                ret['light'][port].append({'dimmer': cfg.m == '1'})
-            elif pty == "1" and m == "2":
+            elif cfg == DS2413:
                # ds2413
                _data = await self.get_port(port=port, force_http=True, http_cmd='list', conv=False)
                data = _data.get('value', {})
@@ -483,21 +558,49 @@ class MegaD:
                        {"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'):
+            elif cfg == MCP230:
-                try:
+                extenders.append(port)
-                    http_cmd = 'get'
+                if cfg.inta:
-                    if m == '5' and pty == '3':
+                    ext_int[int_ignore(cfg.inta)] = port
-                        # 1-wire bus
+                values = await self.request(pt=port, cmd='get')
                values = values.split(';')
                for n in range(len(values)):
                    ext_page = await self.request(pt=port, ext=n)
                    ext_cfg = parse_config(ext_page)
                    pt = f'{port}e{n}'
                    if ext_cfg.ety == '1':
                        ret['light'][pt].append({})
                    elif ext_cfg.ety == '0':
                        if ext_cfg.eact:
                            ext_acts[pt] = ext_cfg.eact
                        ret['binary_sensor'][pt].append({})
            elif cfg == PCA9685:
                extenders.append(port)
                values = await self.request(pt=port, cmd='get')
                values = values.split(';')
                for n in range(len(values)):
                    ret['light'][f'{port}e{n}'].append({'dimmer': True, 'dimmer_scale': 16})
            elif cfg.pty == '4' and cfg.gr == '0':
                # i2c в режиме ANY
                scan = cfg.src.find('a', text='I2C Scan')
                self.lg.debug(f'find scan link: %s', scan)
                if scan is not None:
                    page = await self.request(pt=port, cmd='scan')
                    req, parsed = parse_scan_page(page)
                    self.lg.debug(f'scan results: %s', (req, parsed))
                    ret['i2c'][port].append(parsed)
                    i2c_sensors.extend(req)
            elif cfg.pty in ('3', '2', '4'):
                http_cmd = 'get'
                if cfg.d == '5' and cfg.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'
                    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
                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')
@@ -507,8 +610,8 @@ class MegaD:
                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:
+                    if cfg.pty == '4' and cfg.d in I2C_DEVICE_TYPES:
-                        values = {I2C_DEVICE_TYPES[m]: values}
+                        values = {I2C_DEVICE_TYPES.get(cfg.m): values}
                    else:
                        values = {None: values}
                for key in values:
@@ -522,4 +625,12 @@ class MegaD:
                    ))
        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/i2c.py
+++ b/custom_components/mega/i2c.py
@@ -0,0 +1,108 @@
 from urllib.parse import parse_qsl, urlparse
 from bs4 import BeautifulSoup
 from homeassistant.const import (
    DEVICE_CLASS_HUMIDITY,
    DEVICE_CLASS_TEMPERATURE,
    DEVICE_CLASS_ILLUMINANCE,
    DEVICE_CLASS_PRESSURE,
 )
 def parse_scan_page(page: str):
    ret = []
    req = []
    page = BeautifulSoup(page, features="lxml")
    for x in page.find_all('a'):
        params = x.get('href')
        if params is None:
            continue
        params = dict(parse_qsl(urlparse(params).query))
        if 'i2c_dev' in params:
            dev = params['i2c_dev']
            classes = i2c_classes.get(dev, [])
            for i, c in enumerate(classes):
                if c is Skip:
                    continue
                elif c is Request:
                    req.append(params)
                    continue
                elif isinstance(c, tuple):
                    suffix, c = c
                elif isinstance(c, str):
                    suffix = c
                else:
                    suffix = ''
                if 'addr' in params:
                    suffix += f"_{params['addr']}" if suffix else str(params['addr'])
                if suffix:
                    _dev = f'{dev}_{suffix}'
                else:
                    _dev = dev
                params = params.copy()
                if i > 0:
                    params['i2c_par'] = i
                ret.append({
                    'id_suffix': _dev,
                    'device_class': c,
                    'params': params,
                })
                req.append(params)
    return req, ret
 class Skip:
    pass
 class Request:
    pass
 i2c_classes = {
    'htu21d': [
        DEVICE_CLASS_HUMIDITY,
        DEVICE_CLASS_TEMPERATURE,
    ],
    'sht31': [
        DEVICE_CLASS_HUMIDITY,
        DEVICE_CLASS_TEMPERATURE,
    ],
    'max44009': [
        DEVICE_CLASS_ILLUMINANCE
    ],
    'bh1750': [
        DEVICE_CLASS_ILLUMINANCE
    ],
    'tsl2591': [
        DEVICE_CLASS_ILLUMINANCE
    ],
    'bmp180': [
        DEVICE_CLASS_PRESSURE,
        DEVICE_CLASS_TEMPERATURE,
    ],
    'bmx280': [
        DEVICE_CLASS_PRESSURE,
        DEVICE_CLASS_TEMPERATURE,
        DEVICE_CLASS_HUMIDITY
    ],
    'mlx90614': [
        Skip,
        ('temp', DEVICE_CLASS_TEMPERATURE),
        ('object', DEVICE_CLASS_TEMPERATURE),
    ],
    'ptsensor': [
        Request,  # запрос на измерение
        DEVICE_CLASS_PRESSURE,
        DEVICE_CLASS_TEMPERATURE,
    ],
    'mcp9600': [
        DEVICE_CLASS_TEMPERATURE,  # термопара
        DEVICE_CLASS_TEMPERATURE,  # сенсор встроенный в микросхему
    ],
    't67xx': [
        None  # для co2 нет класса в HA
    ],
    'tmp117': [
        DEVICE_CLASS_TEMPERATURE,
    ]
 }
--- a/custom_components/mega/light.py
+++ b/custom_components/mega/light.py
@@ -26,6 +26,7 @@ from .const import (
    CONF_CUSTOM,
    CONF_SKIP,
 )
 from .tools import int_ignore
 lg = logging.getLogger(__name__)
@@ -61,7 +62,7 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
    devices = []
    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {})
    for port, cfg in config_entry.data.get('light', {}).items():
-        port = int(port)
+        port = int_ignore(port)
        c = customize.get(mid, {}).get(port, {})
        if c.get(CONF_SKIP, False) or c.get(CONF_DOMAIN, 'light') != 'light':
            continue
--- a/custom_components/mega/manifest.json
+++ b/custom_components/mega/manifest.json
@@ -15,5 +15,5 @@
    "@andvikt"
  ],
  "issue_tracker": "https://github.com/andvikt/mega_hacs/issues",
-  "version": "v0.4.2b1"
+  "version": "v0.6.1b1"
 }
--- a/custom_components/mega/sensor.py
+++ b/custom_components/mega/sensor.py
@@ -14,6 +14,7 @@ from homeassistant.const import (
    CONF_UNIQUE_ID,
    CONF_ID,
    CONF_TYPE, CONF_UNIT_OF_MEASUREMENT, CONF_VALUE_TEMPLATE,
    CONF_DEVICE_CLASS,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.template import Template
@@ -22,6 +23,8 @@ from .const import CONF_KEY, TEMP, HUM, W1, W1BUS, CONF_CONV_TEMPLATE
 from .hub import MegaD
 import re
 from .tools import int_ignore
 lg = logging.getLogger(__name__)
 TEMP_PATT = re.compile(r'temp:([01234567890\.]+)')
 HUM_PATT = re.compile(r'hum:([01234567890\.]+)')
@@ -80,21 +83,40 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
    mid = config_entry.data[CONF_ID]
    hub: MegaD = hass.data['mega'][mid]
    devices = []
-    for port, cfg in config_entry.data.get('sensor', {}).items():
+    for tp in ['sensor', 'i2c']:
-        port = int(port)
+        for port, cfg in config_entry.data.get(tp, {}).items():
-        for data in cfg:
+            port = int_ignore(port)
-            hub.lg.debug(f'add sensor on port %s with data %s', port, data)
+            for data in cfg:
-            sensor = Mega1WSensor(
+                hub.lg.debug(f'add sensor on port %s with data %s', port, data)
-                mega=hub,
+                sensor = _constructors[tp](
-                port=port,
+                    mega=hub,
-                config_entry=config_entry,
+                    port=port,
-                **data,
+                    config_entry=config_entry,
-            )
+                    **data,
-            devices.append(sensor)
+                )
                devices.append(sensor)
    async_add_devices(devices)
 class MegaI2C(MegaPushEntity):
    def __init__(self, *args, device_class: str, params: dict, **kwargs):
        self._device_class = device_class
        self._params = tuple(params.items())
        super().__init__(*args, **kwargs)
    def device_class(self):
        return self._device_class
    def state(self):
        return self.mega.values[self._params]
    @property
    def device_class(self):
        return self._device_class
 class Mega1WSensor(MegaPushEntity):
    def __init__(
@@ -139,7 +161,15 @@ class Mega1WSensor(MegaPushEntity):
    @property
    def device_class(self):
-        return self._device_class
+        _u = self.customize.get(CONF_DEVICE_CLASS, None)
        if _u is None:
            return self._device_class
        elif isinstance(_u, str):
            return _u
        elif isinstance(_u, dict) and self.key in _u:
            return _u[self.key]
        else:
            return self._device_class
    @property
    def state(self):
@@ -175,4 +205,10 @@ class Mega1WSensor(MegaPushEntity):
        c = self.customize.get(CONF_NAME, {})
        if isinstance(c, dict):
            c = c.get(self.key)
-        return c or n
+        return c or n
 _constructors = {
    'sensor': Mega1WSensor,
    'i2c': MegaI2C,
 }
--- a/custom_components/mega/strings.json
+++ b/custom_components/mega/strings.json
@@ -17,6 +17,9 @@
          "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%]"
        }
      }
--- a/custom_components/mega/switch.py
+++ b/custom_components/mega/switch.py
@@ -18,6 +18,7 @@ from homeassistant.core import HomeAssistant
 from . import hub as h
 from .entities import MegaOutPort
 from .const import CONF_DIMMER, CONF_SWITCH, DOMAIN, CONF_CUSTOM, CONF_SKIP
 from .tools import int_ignore
 _LOGGER = lg = logging.getLogger(__name__)
@@ -50,7 +51,7 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {})
    for port, cfg in config_entry.data.get('light', {}).items():
-        port = int(port)
+        port = int_ignore(port)
        c = customize.get(mid, {}).get(port, {})
        if c.get(CONF_SKIP, False) or c.get(CONF_DOMAIN, 'light') != 'switch':
            continue
--- a/custom_components/mega/tools.py
+++ b/custom_components/mega/tools.py
@@ -1,5 +1,12 @@
 import asyncio
 import itertools
 from heapq import heappush
 from contextlib import asynccontextmanager
 _params = ['m', 'click', 'cnt', 'pt']
 def make_ints(d: dict):
    for x in _params:
        try:
@@ -9,4 +16,102 @@ def make_ints(d: dict):
    if 'm' not in d:
        d['m'] = 0
    if 'click' not in d:
-        d['click'] = 0
+        d['click'] = 0
 def int_ignore(x):
    try:
        return int(x)
    except (TypeError, ValueError):
        return x
 class PriorityLock(asyncio.Lock):
    """
    You can acquire lock with some kind of priority in mind, so that locks with higher priority will be released first.
    priority can be set with lck.acquire(1)
    or by using context manager:
    >>> lck = PriorityLock()
    ... async with lck(1):
    ...     # do something
    """
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._cnt = itertools.count()
    def __call__(self, priority=0):
        return self._with_priority(priority)
    @asynccontextmanager
    async def _with_priority(self, p):
        await self.acquire(p)
        try:
            yield
        finally:
            self.release()
    async def acquire(self, priority=0) -> bool:
        """Acquire a lock.
                This method blocks until the lock is unlocked, then sets it to
                locked and returns True.
                """
        if (not self._locked and (self._waiters is None or
                                  all(w.cancelled() for _, w in self._waiters))):
            self._locked = True
            return True
        if self._waiters is None:
            self._waiters = []
        fut = self._loop.create_future()
        cnt = next(self._cnt)
        heappush(self._waiters, (priority, cnt, fut))
        # Finally block should be called before the CancelledError
        # handling as we don't want CancelledError to call
        # _wake_up_first() and attempt to wake up itself.
        try:
            try:
                await fut
            finally:
                self._waiters.remove((priority, cnt, fut))
        except asyncio.exceptions.CancelledError:
            if not self._locked:
                self._wake_up_first()
            raise
        self._locked = True
        return True
    def release(self):
        """Release a lock.
        When the lock is locked, reset it to unlocked, and return.
        If any other coroutines are blocked waiting for the lock to become
        unlocked, allow exactly one of them to proceed.
        When invoked on an unlocked lock, a RuntimeError is raised.
        There is no return value.
        """
        if self._locked:
            self._locked = False
            self._wake_up_first()
        else:
            raise RuntimeError('Lock is not acquired.')
    def _wake_up_first(self):
        """Wake up the first waiter if it isn't done."""
        if not self._waiters:
            return
        try:
            _, _, fut = self._waiters[0]
        except IndexError:
            return
        # .done() necessarily means that a waiter will wake up later on and
        # either take the lock, or, if it was cancelled and lock wasn't
        # taken already, will hit this again and wake up a new waiter.
        if not fut.done():
            fut.set_result(True)
--- a/custom_components/mega/translations/en.json
+++ b/custom_components/mega/translations/en.json
@@ -25,6 +25,9 @@
                    "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"
                }
            }
@@ -41,6 +44,9 @@
                  "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
@@ -24,6 +24,9 @@
                    "update_all": "Обновить все выходы когда срабатывает вход",
                    "fake_response": "Имитация http-ответа",
                    "force_d": "Ответ 'd' по умолчанию",
                    "protected": "Блокировать неразрешенные соединения",
                    "restore_on_restart": "Восстанавливать выходы при перезагрузке",
                    "allow_hosts": "Разрешенные ip (через ;)",
                    "poll_outs": "Обновлять выходы (регулярно)"
                }
            }
@@ -38,11 +41,14 @@
                  "reload": "Обновить объекты",
                  "invert": "Список портов (через ,) с инвертированной логикой",
                  "mqtt_inputs": "Использовать MQTT (Не рекомендуется)",
-                    "fake_response": "Имитация http-ответа",
+                  "fake_response": "Имитация http-ответа",
-                    "force_d": "Ответ 'd' по умолчанию",
+                  "force_d": "Ответ 'd' по умолчанию",
-                    "nports": "Кол-во портов",
+                  "nports": "Кол-во портов",
-                    "update_all": "Обновить все выходы когда срабатывает вход",
+                  "update_all": "Обновить все выходы когда срабатывает вход",
-                    "poll_outs": "Обновлять выходы (регулярно)"
+                  "protected": "Блокировать неразрешенные соединения",
                  "allow_hosts": "Разрешенные ip (через ;)",
                  "restore_on_restart": "Восстанавливать выходы при перезагрузке",
                  "poll_outs": "Обновлять выходы (регулярно)"
                }
            }
        }
--- a/custom_components/mega/translations/uk.json
+++ b/custom_components/mega/translations/uk.json
@@ -22,8 +22,11 @@
                    "mqtt_inputs": "Використовувати MQTT (Deprecated)",
                    "nports": "Кількість портів",
                    "update_all": "Оновити всі виходи коли спрацьовує вхід",
-                    "fake_response": "Имитация http-ответа",
+                    "fake_response": "Імітація http-відповіді",
-                    "force_d": "Ответ 'd' по умолчанию",
+                    "force_d": "Неявно відповідати 'd'",
                    "protected": "Блокувати недозволені з'єднання",
                    "allow_hosts": "Дозволені ip (через ;)",
                    "restore_on_restart": "Відновлювати виходи при перезавантаженні",
                    "poll_outs": "Оновити виходи"
                }
            }
@@ -33,15 +36,18 @@
        "step": {
            "init": {
                "data": {
-                  "scan_interval": "Період оновлення (сек.)",
+                    "scan_interval": "Період оновлення (сек.)",
-                  "port_to_scan": "Порт для сканування при відсутності датчиків",
+                    "port_to_scan": "Порт для сканування при відсутності датчиків",
-                  "reload": "Оновити об'єкти",
+                    "reload": "Оновити об'єкти",
-                  "invert": "Список портів з інвертованою логікою (через ,)",
+                    "invert": "Список портів з інвертованою логікою (через ,)",
-                  "mqtt_inputs": "Використовувати MQTT (Deprecated)",
+                    "mqtt_inputs": "Використовувати MQTT (Deprecated)",
-                  "nports": "Кількість портів",
+                    "nports": "Кількість портів",
-                    "fake_response": "Имитация http-ответа",
+                    "fake_response": "Імітація http-відповіді",
-                    "force_d": "Ответ 'd' по умолчанию",
+                    "force_d": "Неявно відповідати 'd'",
-                  "update_all": "Оновити всі виходи коли спрацьовує вхід",
+                    "update_all": "Оновити всі виходи коли спрацьовує вхід",
                    "protected": "Блокувати недозволені з'єднання",
                    "allow_hosts": "Дозволені ip (через ;)",
                    "restore_on_restart": "Відновлювати виходи при перезавантаженні",
                    "poll_outs": "Оновити виходи"
                }
            }
--- a/readme.md
+++ b/readme.md
@@ -16,18 +16,22 @@
 Предложения по доработкам просьба писать в [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
- Обратная связь по http или mqtt (`deprecated`, поддержка mqtt будет выключена в версиях >= 1.0.0, тк в нем нет 
+- Автоматическое восстановление состояний выходов после перезагрузки контроллера
-  необходимости)
+- Обратная связь по [http](https://github.com/andvikt/mega_hacs/wiki/http) или mqtt (`deprecated`, поддержка mqtt 
- События на двойные/долгие нажатия
+  будет выключена в версиях >= 1.0.0, тк в нем нет необходимости)
 - [События](https://github.com/andvikt/mega_hacs/wiki/События) на двойные/долгие нажатия
 - Команды выполняются друг за другом без конкурентного доступа к ресурсам megad, это дает гарантии надежного исполнения
  большого кол-ва команд (например в сценах). Каждая следующая команда отправляется только после получения ответа о
  выполнении предыдущей.
- поддержка ds2413 (начиная с версии 0.4.1)
+- поддержка [ds2413](https://www.ab-log.ru/smart-house/ethernet/megad-2w) (начиная с версии 0.4.1)
 - поддержка MCP23008/MCP23017/PCA9685 (начиная с версии 0.5.1)
 - поддержка всех возможных датчиков в режиме I2C-ANY, полный список поддерживаемых датчиков датчиков 
  [по ссылке](https://github.com/andvikt/mega_hacs/wiki/ш2с)
 ## Установка
 Рекомендованный способ с поддержкой обновлений - [HACS](https://hacs.xyz/docs/installation/installation):
@@ -58,11 +62,15 @@ wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.
 srv: "192.168.1.4:8123" # ip:port вашего HA
 script: "mega" # это api интеграции, к которому будет обращаться контроллер
 ```
 Так же необходимо настроить Mega-ID в настройках контроллера, для каждой меги id должен быть разным.
 При любых изменениях настроек контроллера (типы входов, id и тд) необходимо в настройках интеграции нажать `Обновить 
 объекты`
 ## Зависимости
 Для максимальной скорости реакции на команды сервера, рекомендуется выключить `имитацию http-ответа` в 
 настройках интеграции и настроить proxy_pass к HA, самый простой способ сделать это - воспользоваться 
-[специальным аддоном](https://github.com/andvikt/mega_addon/tree/master/mega-updater)
+[специальным аддоном](https://github.com/andvikt/mega_addon/tree/master/mega-proxy)
 Обновить ваш контроллер до последней версии, обновление прошивки MegaD можно делать 
 из HA с помощью [аддона](https://github.com/andvikt/mega_addon.git)
Author	SHA1	Message	Date
Andrey	49fcf880d9	add i2c sensors	2021-03-03 12:01:02 +03:00
Andrey	289f52ef73	fix errors	2021-02-28 22:27:57 +03:00
Andrey	ce589c97b9	fix errors	2021-02-28 22:22:17 +03:00
Andrey	22a6f8f444	fix errors	2021-02-28 22:06:36 +03:00
Andrey	9a53de1d5d	fix errors	2021-02-28 22:02:22 +03:00
Andrey	bd8b07dd90	fix errors	2021-02-28 21:52:34 +03:00
Andrey	d9b6ba3a50	fix errors	2021-02-28 21:52:06 +03:00
Andrey	1042592a31	fix errors	2021-02-28 21:33:26 +03:00
Andrey	137eb8b6ba	fix errors	2021-02-28 21:15:48 +03:00
Andrey	a2f412b89e	fix errors	2021-02-28 20:16:04 +03:00
Andrey	8fa14cdbc5	fix errors	2021-02-28 20:15:47 +03:00
Andrey	fc17b82021	support response for extenders	2021-02-28 15:01:39 +03:00
Andrey	1aeaabfb3c	fix errors	2021-02-28 14:50:47 +03:00
Andrey	a0bd8acac0	fix errors	2021-02-28 14:49:38 +03:00
andvikt	c48a3632d2	Update http.py	2021-02-28 13:04:00 +03:00
Andrey	e06ba65ead	fix errors	2021-02-28 09:49:16 +03:00
Andrey	22720a27bd	fix errors	2021-02-28 09:46:06 +03:00
Andrey	d0769b5b02	fix errors	2021-02-27 17:39:54 +03:00
Andrey	9ae093dd91	fix errors	2021-02-27 14:44:20 +03:00
Andrey	f88109c3a6	fix int(port)	2021-02-26 16:18:05 +03:00
Andrey	8742bb975f	поддержка PCA9685 и MCP230	2021-02-25 12:11:05 +03:00
Andrey	97da209cf0	поддержка PCA9685 и MCP230	2021-02-25 11:52:11 +03:00
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