Bump version: 1.0.10b1 → 1.0.10b2

add DEVICE_CLASS_CO2

.bumpversion.cfg

@@ -0,0 +1,21 @@
+[bumpversion]
+current_version = 1.0.10b2
+parse = (?P<major>\d+)(\.(?P<minor>\d+))(\.(?P<patch>\d+))(?P<release>[bf]*)(?P<build>\d*)
+commit = True
+tag = True
+serialize = 
+	{major}.{minor}.{patch}{release}{build}
+	{major}.{minor}.{patch}
+
+[bumpversion:part:release]
+optional_value = f
+values = 
+	b
+	f
+
+[bumpversion:part:build]
+first_value = 0
+
+[bumpversion:file:custom_components/mega/manifest.json]
+search = "version": "v{current_version}"
+replace = "version": "v{new_version}"

.experiment.py

@@ -1,61 +1,15 @@
-import asyncio
-from urllib.parse import urlparse, parse_qsl
-from asyncio import Event, FIRST_COMPLETED
-import signal
-import typing
-from logging import getLogger, DEBUG
+order ='brg'
+rgb = 'rgb'
+
+map_to_order = [rgb.index(x) for x in order]
+map_from_order = [order.index(x) for x in rgb]
 
 
-stop = Event()
-loop = asyncio.get_event_loop()
-lg = getLogger(__name__)
-lg.setLevel(DEBUG)
+_rgb = [
+        rgb[x] for x in map_to_order
+    ]
+_order = [
+        _rgb[x] for x in map_from_order
+    ]
 
-
-def make_handler(get_ans: typing.Callable[[dict], str]):
-
-    async def handler(
-            reader: asyncio.StreamReader,
-            writer: asyncio.StreamWriter,
-    ):
-        data = await reader.read(200)
-        print(data)
-        message = data.decode()
-        addr = writer.get_extra_info('peername')
-        lg.debug('process msg "%s" from %s', message, addr)
-        try:
-            (_, p, *_) = message.split(' ')
-            p = dict(parse_qsl(urlparse(p).query))
-            lg.debug('query %s', p)
-            ans = get_ans(p)
-            ans = f'''HTTP/1.1 200 OK\nContent-Length: {len(ans)}\n\n{ans}'''.encode()  # \nContent-Length: 6
-            ans = b'HTTP/1.1 200 OK\r\n\r\n7:2'
-            print(ans)
-        except Exception as exc:
-            print(exc)
-            lg.exception('process msg "%s" from %s', message, addr)
-            ans = '''HTTP/1.1 500\n\n'''.encode()
-        writer.write(ans)
-        await writer.drain()
-        # writer.transport.close()
-        writer.close()
-        await writer.wait_closed()
-    return handler
-
-
-async def serve():
-    server = await asyncio.start_server(
-        make_handler(lambda x: '7:2'),
-        host='0.0.0.0',
-        port=1111,
-    )
-    addr = server.sockets[0].getsockname()
-    print(f'Serving on {addr}')
-    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())
+print(_rgb, _order)

.github/ISSUE_TEMPLATE/bug-report.md

@@ -1,6 +1,6 @@
 ---
-name: Bug report
-about: Create a report to help us improve
+name: Проблема
+about: Обнаружен баг/проблема
 title: ''
 labels: ''
 assignees: ''
@@ -24,4 +24,4 @@ megad firmware version:
 If applicable, add screenshots to help explain your problem.
 
 **LOG**
-Просьба прикладывать детальный лог, подробная инструкция как включать отладку по [ссылке](https://github.com/andvikt/mega_hacs/wiki/Отладка)
+Просьба прикладывать детальный лог, подробная инструкция как включать отладку по [ссылке](https://andvikt.github.io/mega_hacs/debug/)

.github/ISSUE_TEMPLATE/enhance.md

@@ -0,0 +1,9 @@
+---
+name: Улучшение
+about: Идея на улучшение интеграции
+title: ''
+labels: 'enhancement'
+assignees: ''
+
+---
+**Описание**

.github/workflows/main.yml

@@ -0,0 +1,17 @@
+name: Publish docs via GitHub Pages
+on:
+  push:
+
+jobs:
+  build:
+    name: Deploy docs
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout main
+        uses: actions/checkout@v2
+
+      - name: Deploy docs
+        uses: mhausenblas/mkdocs-deploy-gh-pages@master
+        # Or use mhausenblas/mkdocs-deploy-gh-pages@nomaterial to build without the mkdocs-material theme
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

custom_components/mega/__init__.py

@@ -6,24 +6,49 @@ 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_HOST
+    CONF_NAME, CONF_DOMAIN,
+    CONF_UNIT_OF_MEASUREMENT, CONF_VALUE_TEMPLATE, CONF_DEVICE_CLASS, CONF_PORT
 )
 from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers.service import bind_hass
-from homeassistant.helpers.template import Template
 from homeassistant.helpers import config_validation as cv
-from homeassistant.components import mqtt
 from homeassistant.config_entries import ConfigEntry
 from .const import DOMAIN, CONF_INVERT, CONF_RELOAD, PLATFORMS, CONF_PORTS, CONF_CUSTOM, CONF_SKIP, CONF_PORT_TO_SCAN, \
     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_CONV_TEMPLATE, CONF_ALL, CONF_FORCE_D, CONF_DEF_RESPONSE, CONF_FORCE_I2C_SCAN, CONF_HEX_TO_FLOAT, \
+    RGB_COMBINATIONS, CONF_WS28XX, CONF_ORDER, CONF_SMOOTH, CONF_LED, CONF_WHITE_SEP, CONF_CHIP, CONF_RANGE
 from .hub import MegaD
 from .config_flow import ConfigFlow
 from .http import MegaView
 
 _LOGGER = logging.getLogger(__name__)
 
+_port_n = vol.Any(int, str)
+
+LED_LIGHT = \
+    {
+        str: vol.Any(
+            {
+                vol.Required(CONF_PORTS): vol.Any(
+                    vol.ExactSequence([_port_n, _port_n, _port_n]),
+                    vol.ExactSequence([_port_n, _port_n, _port_n, _port_n]),
+                    msg='ports must be [R, G, B] or [R, G, B, W] of integers 0..255'
+                ),
+                vol.Optional(CONF_NAME): str,
+                vol.Optional(CONF_WHITE_SEP, default=True): bool,
+                vol.Optional(CONF_SMOOTH, default=1): cv.time_period_seconds,
+            },
+            {
+                vol.Required(CONF_PORT): int,
+                vol.Required(CONF_WS28XX): True,
+                vol.Optional(CONF_CHIP, default=100): int,
+                vol.Optional(CONF_ORDER, default='rgb'): vol.Any(*RGB_COMBINATIONS, msg=f'order must be one of {RGB_COMBINATIONS}'),
+                vol.Optional(CONF_SMOOTH, default=1): cv.time_period_seconds,
+                vol.Optional(CONF_NAME): str,
+            },
+        )
+    }
+
 CUSTOMIZE_PORT = {
     vol.Optional(CONF_SKIP, description='исключить порт из сканирования', default=False): bool,
     vol.Optional(CONF_INVERT, default=False): bool,
@@ -35,28 +60,57 @@ 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='шаблон ответа когда на этот порт приходит'
                     'сообщение из меги '): 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_CONV_TEMPLATE): cv.template,
+    vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
+    vol.Optional(CONF_FORCE_I2C_SCAN): bool,
+    vol.Optional(CONF_HEX_TO_FLOAT): bool,
+    vol.Optional(CONF_SMOOTH): cv.time_period_seconds,
+    # vol.Optional(CONF_RANGE): vol.ExactSequence([int, int]), TODO: сделать отбрасывание "плохих" значений
+    vol.Optional(str): {
+        vol.Optional(CONF_NAME): str,
+        vol.Optional(CONF_DEVICE_CLASS): str,
+        vol.Optional(CONF_UNIT_OF_MEASUREMENT): str,
+        vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
+    }
 }
 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: {
             vol.Optional(CONF_ALLOW_HOSTS): [str],
-            vol.Required(str, description='id меги из веб-интерфейса'): {
+            vol.Optional(vol.Any(str, int), description='id меги из веб-интерфейса'): {
                 vol.Optional(CONF_FORCE_D, description='Принудительно слать d после срабатывания входа', default=False): bool,
-                vol.Optional(int, description='номер порта'): vol.Any(
+                vol.Optional(
+                    CONF_DEF_RESPONSE,
+                    description='Ответ по умолчанию',
+                    default=None
+                ): vol.Any(cv.template, None),
+                vol.Optional(CONF_LED): LED_LIGHT,
+                vol.Optional(vol.Any(int, extender), description='номер порта'): vol.Any(
                     CUSTOMIZE_PORT,
                     CUSTOMIZE_DS2413,
-                )
+                ),
             }
         }
     },
@@ -104,18 +158,7 @@ async def get_hub(hass, entry):
     data = dict(entry.data)
     data.update(entry.options or {})
     data.update(id=id)
-    use_mqtt = data.get(CONF_MQTT_INPUTS, True)
-
-    _mqtt = hass.data.get(mqtt.DOMAIN) if use_mqtt else None
-    if _mqtt is None and use_mqtt:
-        for x in range(5):
-            await asyncio.sleep(5)
-            _mqtt = hass.data.get(mqtt.DOMAIN)
-            if _mqtt is not None:
-                break
-        if _mqtt is None:
-            raise Exception('mqtt not configured, please configure mqtt first')
-    hub = MegaD(hass, **data, mqtt=_mqtt, lg=_LOGGER, loop=asyncio.get_event_loop())
+    hub = MegaD(hass, config=entry, **data, lg=_LOGGER, loop=asyncio.get_event_loop())
     hub.mqtt_id = await hub.get_mqtt_id()
     return hub
 
@@ -123,8 +166,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
-    hass.data[DOMAIN][entry.data.get(CONF_HOST)] = hub
+    hub.fw = await hub.get_fw()
+    hass.data[DOMAIN][id] = hub
     hass.data[DOMAIN][CONF_ALL][id] = hub
     if not await hub.authenticate():
         raise Exception("not authentificated")
@@ -155,33 +198,34 @@ async def updater(hass: HomeAssistant, entry: ConfigEntry):
     :param entry:
     :return:
     """
-    hub: MegaD = hass.data[DOMAIN][entry.data[CONF_ID]]
-    hub.poll_interval = entry.options[CONF_SCAN_INTERVAL]
-    hub.port_to_scan = entry.options.get(CONF_PORT_TO_SCAN, 0)
-    entry.data = entry.options
-    for platform in PLATFORMS:
-        await hass.config_entries.async_forward_entry_unload(entry, platform)
-    await async_remove_entry(hass, entry)
-    await async_setup_entry(hass, entry)
+    # hub: MegaD = hass.data[DOMAIN][entry.data[CONF_ID]]
+    # hub.poll_interval = entry.options[CONF_SCAN_INTERVAL]
+    # hub.port_to_scan = entry.options.get(CONF_PORT_TO_SCAN, 0)
+    await hass.config_entries.async_reload(entry.entry_id)
     return True
 
 
-async def async_remove_entry(hass, entry) -> None:
+async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> 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}')
     _hubs.pop(id, None)
     hass.data[DOMAIN].pop(id, None)
     hass.data[DOMAIN][CONF_ALL].pop(id, None)
+    for platform in PLATFORMS:
+        await hass.config_entries.async_forward_entry_unload(entry, platform)
     task: asyncio.Task = _POLL_TASKS.pop(id, None)
     if task is not None:
         task.cancel()
     if hub is None:
         return
     await hub.stop()
+    return True
+
+async_unload_entry = async_remove_entry
 
 
 async def async_migrate_entry(hass, config_entry: ConfigEntry):

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,12 +51,14 @@ 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
         hub.lg.debug(f'add binary_sensor on port %s', port)
         sensor = MegaBinarySensor(mega=hub, port=port, config_entry=config_entry)
+        if '<' in sensor.name:
+            continue
         devices.append(sensor)
     async_add_devices(devices)
 
@@ -67,6 +69,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,32 +84,17 @@ class MegaBinarySensor(BinarySensorEntity, MegaPushEntity):
 
     @property
     def is_on(self) -> bool:
-        val = self.mega.values.get(self.port, {}).get("value") \
-              or self.mega.values.get(self.port, {}).get('m')
+        val = self.mega.values.get(self.port, {})
+        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']:
-                return val == 'ON' if not self.invert else val == 'OFF'
-            else:
+            if val in ['ON', 'OFF', '1', '0']:
+                return val in ['ON', '1'] if not self.invert else val in ['OFF', '0']
+            elif isinstance(val, int):
                 return val != 1 if not self.invert else val == 1
 
     def _update(self, payload: dict):
         self.mega.values[self.port] = payload
-        if not self.mega.mqtt_inputs:
-            return
-
-        template: Template = self.customize.get(CONF_RESPONSE_TEMPLATE, None)
-        if template is not None:
-            template.hass = self.hass
-            ret = template.async_render(payload)
-            self.mega.lg.debug(f'response: %s', ret)
-            self.hass.async_create_task(
-                self.mega.request(pt=self.port, cmd=ret)
-            )
-        elif self.mega.force_d:
-            self.mega.lg.debug(f'response d')
-            self.hass.async_create_task(
-                self.mega.request(pt=self.port, cmd='d')
-            )
 

custom_components/mega/config_flow.py

@@ -5,12 +5,12 @@ import logging
 import voluptuous as vol
 
 from homeassistant import config_entries, core
-from homeassistant.components import mqtt
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_ID, CONF_PASSWORD, CONF_SCAN_INTERVAL
 from homeassistant.core import callback, HomeAssistant
-from .const import DOMAIN, CONF_PORT_TO_SCAN, CONF_RELOAD, PLATFORMS, CONF_MQTT_INPUTS, \
-    CONF_NPORTS, CONF_UPDATE_ALL, CONF_POLL_OUTS  # pylint:disable=unused-import
+from .const import DOMAIN, CONF_RELOAD, \
+    CONF_NPORTS, CONF_UPDATE_ALL, CONF_POLL_OUTS, CONF_FAKE_RESPONSE, CONF_FORCE_D, \
+    CONF_ALLOW_HOSTS, CONF_PROTECTED, CONF_RESTORE_ON_RESTART, CONF_UPDATE_TIME
 from .hub import MegaD
 from . import exceptions
 
@@ -21,21 +21,27 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         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_SCAN_INTERVAL, default=30): int,
         vol.Optional(CONF_POLL_OUTS, default=False): bool,
-        vol.Optional(CONF_PORT_TO_SCAN, default=0): int,
-        vol.Optional(CONF_MQTT_INPUTS, default=True): bool,
+        # vol.Optional(CONF_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,
+        vol.Optional(CONF_UPDATE_TIME, default=True): bool,
     },
 )
 
 
 async def get_hub(hass: HomeAssistant, data):
-    _mqtt = hass.data.get(mqtt.DOMAIN)
+    # _mqtt = hass.data.get(mqtt.DOMAIN)
     # if not isinstance(_mqtt, mqtt.MQTT):
     #     raise exceptions.MqttNotConfigured("mqtt must be configured first")
-    hub = MegaD(hass, **data, lg=_LOGGER, mqtt=_mqtt, loop=asyncio.get_event_loop())
+    hub = MegaD(hass, **data, lg=_LOGGER, loop=asyncio.get_event_loop()) #mqtt=_mqtt,
     hub.mqtt_id = await hub.get_mqtt_id()
     if not await hub.authenticate():
         raise exceptions.InvalidAuth
@@ -57,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 = 6
+    VERSION = 25
     CONNECTION_CLASS = config_entries.CONN_CLASS_ASSUMED
 
     async def async_step_user(self, user_input=None):
@@ -72,10 +78,12 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
         try:
             hub = await validate_input(self.hass, user_input)
             await hub.start()
+            hub.new_naming=True
             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)
+            config['new_naming'] = True
             return self.async_create_entry(
                 title=user_input.get(CONF_ID, user_input[CONF_HOST]),
                 data=config,
@@ -107,22 +115,20 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
 
     async def async_step_init(self, user_input=None):
         """Manage the options."""
-
+        new_naming = self.config_entry.data.get('new_naming', False)
         if user_input is not None:
             reload = user_input.pop(CONF_RELOAD)
             cfg = dict(self.config_entry.data)
             cfg.update(user_input)
-            hub = await get_hub(self.hass, self.config_entry.data)
-            if reload:
-                await hub.start()
-                new = await hub.get_config(nports=user_input.get(CONF_NPORTS, 37))
-                await hub.stop()
+            cfg['new_naming'] = new_naming
+            self.config_entry.data = cfg
+            await get_hub(self.hass, cfg)
+
+            if reload:
+                id = self.config_entry.data.get('id', self.config_entry.entry_id)
+                hub: MegaD = self.hass.data[DOMAIN].get(id)
+                cfg = await hub.reload(reload_entry=False)
 
-                _LOGGER.debug(f'new config: %s', new)
-                cfg = dict(self.config_entry.data)
-                for x in PLATFORMS:
-                    cfg.pop(x, None)
-                cfg.update(new)
             return self.async_create_entry(
                 title='',
                 data=cfg,
@@ -133,11 +139,17 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
             data_schema=vol.Schema({
                 vol.Optional(CONF_SCAN_INTERVAL, default=e.get(CONF_SCAN_INTERVAL, 0)): int,
                 vol.Optional(CONF_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_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_UPDATE_TIME, default=e.get(CONF_UPDATE_TIME, False)): bool,
                 # vol.Optional(CONF_INVERT, default=''): str,
             }),
         )

custom_components/mega/config_parser.py

@@ -0,0 +1,62 @@
+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']
+    smooth = page.find('input', attrs={'name': 'misc'})
+    if smooth is None or smooth.get('checked') is None:
+        ret['misc'] = None
+    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")
+

custom_components/mega/const.py

@@ -1,5 +1,6 @@
 """Constants for the mega integration."""
 import re
+from itertools import permutations
 
 DOMAIN = "mega"
 CONF_MEGA_ID = "mega_id"
@@ -23,11 +24,27 @@ 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'
+CONF_CLICK_TIME = 'click_time'
+CONF_LONG_TIME = 'long_time'
+CONF_FORCE_I2C_SCAN = 'force_i2c_scan'
+CONF_UPDATE_TIME = 'update_time'
+CONF_HEX_TO_FLOAT = 'hex_to_float'
+CONF_LED = 'led'
+CONF_WS28XX = 'ws28xx'
+CONF_ORDER = 'order'
+CONF_SMOOTH = 'smooth'
+CONF_WHITE_SEP = 'white_sep'
+CONF_CHIP = 'chip'
+CONF_RANGE = 'range'
 PLATFORMS = [
     "light",
     "switch",
@@ -46,3 +63,19 @@ PRESS = 'press'
 LUX = 'lux'
 SINGLE_CLICK = 'single'
 DOUBLE_CLICK = 'double'
+
+PATT_FW = re.compile(r'fw:\s(.+?)\)')
+
+REMOVE_CONFIG = [
+    'extenders',
+    'ext_in',
+    'ext_acts',
+    'i2c_sensors',
+    'binary_sensor',
+    'light',
+    'i2c',
+    'sensor',
+    'smooth',
+]
+RGB_COMBINATIONS = [''.join(x) for x in permutations('rgb')]
+RGB = 'rgb'

custom_components/mega/entities.py

@@ -1,5 +1,9 @@
 import logging
 import asyncio
+import time
+import typing
+from datetime import timedelta
+from functools import partial
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_NAME
@@ -8,7 +12,7 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from homeassistant.helpers.restore_state import RestoreEntity
 from . import hub as h
 from .const import DOMAIN, CONF_CUSTOM, CONF_INVERT, EVENT_BINARY_SENSOR, LONG, \
-    LONG_RELEASE, RELEASE, PRESS, SINGLE_CLICK, DOUBLE_CLICK, EVENT_BINARY
+    LONG_RELEASE, RELEASE, PRESS, SINGLE_CLICK, DOUBLE_CLICK, EVENT_BINARY, CONF_SMOOTH
 
 _events_on = False
 _LOGGER = logging.getLogger(__name__)
@@ -38,7 +42,7 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
     def __init__(
             self,
             mega: 'h.MegaD',
-            port: int,
+            port: typing.Union[int, str, typing.List[int]],
             config_entry: ConfigEntry = None,
             id_suffix=None,
             name=None,
@@ -46,8 +50,13 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
             http_cmd='get',
             addr: str=None,
             index=None,
+            customize=None,
+            smooth=None,
+            **kwargs,
     ):
         super().__init__(mega.updater)
+        self._smooth = smooth
+        self.http_cmd = http_cmd
         self._state: State = None
         self.port = port
         self.config_entry = config_entry
@@ -55,17 +64,68 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
         mega.entities.append(self)
         self._mega_id = mega.id
         self._lg = None
+        if not isinstance(port, list):
             self._unique_id = unique_id or f"mega_{mega.id}_{port}" + \
                                            (f"_{id_suffix}" if id_suffix else "")
-        self._name = name or f"{mega.id}_{port}" + \
+            _pt = port if not mega.new_naming else f'{port:02}' if isinstance(port, int) else port
+            self._name = name or f"{mega.id}_{_pt}" + \
                          (f"_{id_suffix}" if id_suffix else "")
             self._customize: dict = None
-        self.http_cmd = http_cmd
+        else:
+            assert id_suffix is not None
+            assert name is not None
+            assert isinstance(customize, dict)
+            self._unique_id = unique_id or f"mega_{mega.id}_{id_suffix}"
+            self._name = name
+            self._customize = customize
+
         self.index = index
         self.addr = addr
+        self.id_suffix = id_suffix
+        self._can_smooth_hard = None
+        if self.http_cmd == 'ds2413':
+            self.mega.ds2413_ports |= {self.port}
+
+    @property
+    def is_ws(self):
+        return False
+
+    def get_attribute(self, name, default=None):
+        attr = getattr(self, f'_{name}', None)
+        if attr is None and self._state is not None:
+            if name == 'is_on':
+                attr = self._state.state
+            else:
+                attr = self._state.attributes.get(f'{name}', default)
+        return attr if attr is not None else default
+
+    @property
+    def can_smooth_hardware(self):
+        if self._can_smooth_hard is None:
+            if self.is_ws:
+                self._can_smooth_hard = False
+            if not isinstance(self.port, list):
+                self._can_smooth_hard = self.port in self.mega.smooth
+            else:
+                for x in self.port:
+                    if isinstance(x, str):
+                        self._can_smooth_hard = False
+                        break
+                    else:
+                        self._can_smooth_hard = self.port in self.mega.smooth
+        return self._can_smooth_hard
+
+    @property
+    def enabled(self):
+        if '<' in self.name:
+            return False
+        else:
+            return super().enabled
 
     @property
     def customize(self):
+        if self._customize is not None:
+            return self._customize
         if self.hass is None:
             return {}
         if self._customize is None:
@@ -81,18 +141,26 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
 
     @property
     def device_info(self):
+        if isinstance(self.port, list):
+            pt_idx = self.id_suffix
+        else:
+            _pt = self.port if not self.mega.new_naming else f'{self.port:02}' if isinstance(self.port, int) else self.port
+            if isinstance(_pt, str) and 'e' in _pt:
+                pt_idx, _ = _pt.split('e')
+            else:
+                pt_idx = _pt
         return {
             "identifiers": {
                 # Serial numbers are unique identifiers within a specific domain
-                (DOMAIN, f'{self._mega_id}', self.port),
+                (DOMAIN, f'{self._mega_id}', pt_idx),
             },
             "config_entries": [
                 self.config_entry,
             ],
-            "name": f'{self._mega_id} port {self.port}',
+            "name": f'{self._mega_id} port {pt_idx}' if not isinstance(self.port, list) else f'{self._mega_id} {pt_idx}',
             "manufacturer": 'ab-log.ru',
             # "model": self.light.productname,
-            # "sw_version": self.light.swversion,
+            "sw_version": self.mega.fw,
             "via_device": (DOMAIN, self._mega_id),
         }
 
@@ -110,7 +178,11 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
     def name(self):
         c = self.customize.get(CONF_NAME)
         if not isinstance(c, str):
-            c = self._name or f"{self.mega.id}_p{self.port}"
+            if not isinstance(self.port, list):
+                _pt = self.port if not self.mega.new_naming else f'{self.port:02}' if isinstance(self.port, int) else self.port
+                c = self._name or f"{self.mega.id}_p{_pt}"
+            else:
+                c = self.id_suffix
         return c
 
     @property
@@ -121,12 +193,9 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
         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()
 
 
@@ -143,11 +212,10 @@ class MegaPushEntity(BaseMegaEntity):
 
     def __update(self, value: dict):
         self._update(value)
+        if self.hass is None:
+            return
         self.async_write_ha_state()
         self.lg.debug(f'state after update %s', self.state)
-        if self.mega.mqtt_inputs and not _events_on:
-            _LOGGER.debug('skip event because events are off')
-            return
         if not self.entity_id.startswith('binary_sensor'):
             _LOGGER.debug('skip event because not a bnary sens')
             return
@@ -199,17 +267,13 @@ class MegaPushEntity(BaseMegaEntity):
     def _update(self, payload: dict):
         pass
 
-    async def async_added_to_hass(self) -> None:
-        await super().async_added_to_hass()
-        if self.mega.mqtt is not None:
-            asyncio.create_task(self.mega.get_port(self.port))
-
 
 class MegaOutPort(MegaPushEntity):
 
     def __init__(
             self,
             dimmer=False,
+            dimmer_scale=1,
             *args, **kwargs
     ):
         super().__init__(
@@ -218,11 +282,25 @@ class MegaOutPort(MegaPushEntity):
         self._brightness = None
         self._is_on = None
         self.dimmer = dimmer
+        self.dimmer_scale = dimmer_scale
+        self.is_extender = isinstance(self.port, str) and 'e' in self.port
+        self.task: asyncio.Task = None
+        self._restore_brightness = None
+        self._last_called: float = 0
 
     # @property
     # def assumed_state(self) -> bool:
     #     return True if self.index is not None or self.mega.mqtt is None else False
 
+    @property
+    def max_dim(self):
+        if self.dimmer_scale == 1:
+            return 255
+        elif self.dimmer_scale == 16:
+            return 4095
+        else:
+            return 255
+
     @property
     def invert(self):
         return self.customize.get(CONF_INVERT, False)
@@ -231,10 +309,22 @@ class MegaOutPort(MegaPushEntity):
     def brightness(self):
         if not self.dimmer:
             return
-        val = self.mega.values.get(self.port, {}).get("value")
-        if val is None and self._state is not None:
+        val = self.mega.values.get(self.port, {})
+        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
@@ -244,29 +334,38 @@ class MegaOutPort(MegaPushEntity):
     @property
     def is_on(self) -> bool:
         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 == '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 self.index and self.addr:
+            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} has wrong state: {val}')
+                    self.mega.lg.warning(f'{self.entity_id}: {val} is not a dict')
                     return
-                _val = val.get(self.addr)
-                if not isinstance(val, str):
-                    self.mega.lg.warning(f'{self.entity_id} has wrong state: {val}')
+                _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:
-                    val = val[self.index]
+                    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} has wrong state: {val}')
+                    self.mega.lg.warning(f'{self.entity_id}: {_val} has wrong length')
                     return
-            elif self.index and self.addr is None:
+            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:
@@ -279,19 +378,74 @@ class MegaOutPort(MegaPushEntity):
         else:
             return self.port
 
-    async def async_turn_on(self, brightness=None, **kwargs) -> None:
-        brightness = brightness or self.brightness or 255
+    @property
+    def smooth(self) -> timedelta:
+        ret = self.customize.get(CONF_SMOOTH)
+        if ret is None and self._smooth:
+            ret = timedelta(seconds=self._smooth)
+        return ret
 
+    @property
+    def smooth_dim(self):
+        if not self.dimmer:
+            return False
+        return self.smooth or self.can_smooth_hardware
+
+    def update_from_smooth(self, value, update_state=False):
+        if isinstance(self.port, str):
+            self.mega.values[self.port] = value[0]
+        else:
+            self.mega.values[self.port] = {
+                'value': value[0]
+            }
+        if update_state:
+            self.async_write_ha_state()
+
+    def _set_dim_brightness(self, from_, to_, transition):
+        pct = abs(to_ - from_) / (255 if self.dimmer_scale == 1 else 4095)
+        update_state = transition is not None and transition > 3
+        tm = (self.smooth.total_seconds() * pct) if transition is None else transition
+        if self.task is not None:
+            self.task.cancel()
+        self.task = asyncio.create_task(self.mega.smooth_dim(
+            (self.cmd_port, from_, to_),
+            time=tm,
+            can_smooth_hardware=self.can_smooth_hardware,
+            max_values=[255 if self.dimmer_scale == 1 else 4095],
+            updater=partial(self.update_from_smooth, update_state=update_state),
+        ))
+
+    async def async_turn_on(self, brightness=None, transition=None, **kwargs):
+        if (time.time() - self._last_called) < 0.1:
+            return
+        self._last_called = time.time()
+        if not self.dimmer:
+            transition = None
+        if not self.is_on and (brightness is None or brightness == 0):
+            brightness = self._restore_brightness
+        brightness = brightness or self.brightness or 255
+        _prev = safe_int(self.brightness) or 0
+        self._brightness = brightness
         if self.dimmer and brightness == 0:
-            cmd = 255
+            cmd = self.max_dim
         elif self.dimmer:
-            cmd = brightness
+            cmd = min((brightness * self.dimmer_scale, self.max_dim))
+            if self.smooth_dim or transition:
+                self._set_dim_brightness(from_=_prev, to_=cmd, transition=transition)
         else:
             cmd = 1 if not self.invert else 0
+        if transition is None:
             _cmd = {"cmd": f"{self.cmd_port}:{cmd}"}
+        else:
+            _cmd = {
+                "pt": f"{self.cmd_port}",
+                "pwm": cmd,
+                "cnt": round(transition / (abs(_prev - brightness) / 255)),
+            }
         if self.addr:
             _cmd['addr'] = self.addr
-        await self.mega.request(**_cmd)
+        if not (self.smooth_dim or transition):
+            await self.mega.request(**_cmd, priority=-1)
         if self.index is not None:
             # обновление текущего стейта для ds2413
             await self.mega.get_port(
@@ -300,17 +454,35 @@ 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()
 
-    async def async_turn_off(self, **kwargs) -> None:
-
+    async def async_turn_off(self, transition=None, **kwargs) -> None:
+        if (time.time() - self._last_called) < 0.1:
+            return
+        self._last_called = time.time()
+        self._restore_brightness = safe_int(self._brightness)
+        if not self.dimmer:
+            transition = None
         cmd = "0" if not self.invert else "1"
         _cmd = {"cmd": f"{self.cmd_port}:{cmd}"}
+        _prev = safe_int(self.brightness) or 0
         if self.addr:
             _cmd['addr'] = self.addr
-        await self.mega.request(**_cmd)
+        if not (self.smooth_dim or transition):
+            await self.mega.request(**_cmd, priority=-1)
+        else:
+            self._set_dim_brightness(
+                from_=_prev,
+                to_=0,
+                transition=transition,
+            )
         if self.index is not None:
             # обновление текущего стейта для ds2413
             await self.mega.get_port(
@@ -319,14 +491,23 @@ 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()
 
+    async def async_will_remove_from_hass(self) -> None:
+        if self.task is not None:
+            self.task.cancel()
+
+
 
 def safe_int(v):
-    if v in ['ON', 'OFF']:
-        return None
+    if v == 'ON':
+        return 1
+    elif v == 'OFF':
+        return 0
     try:
         return int(v)
     except (ValueError, TypeError):

custom_components/mega/exceptions.py

@@ -5,10 +5,6 @@ class CannotConnect(exceptions.HomeAssistantError):
     """Error to indicate we cannot connect."""
 
 
-class MqttNotConfigured(exceptions.HomeAssistantError):
-    """Error to indicate mqtt is not configured"""
-
-
 class DuplicateId(exceptions.HomeAssistantError):
     """Error to indicate duplicate id"""
 

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.allowed_hosts = {'::1'}
+        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,47 @@ 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)
+        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:
-            _LOGGER.warning(f'unauthorised attempt to connect from {request.remote}')
+                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)
 
-        hass: HomeAssistant = request.app['hass']
-        hub: 'h.MegaD' = hass.data.get(DOMAIN).get(request.remote)  # TODO: проверить какой remote
-        if hub is None and request.remote == '::1':
-            hub = hass.data.get(DOMAIN).get('__def')
+        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']:
+            try:
+                hub = list(self.hubs.values())[0]
+            except IndexError:
+                _LOGGER.warning(f'can not find mdid={request.query["mdid"]} in {list(self.hubs)}')
+                return Response(status=400)
+        elif hub is None:
             return Response(status=400)
         data = dict(request.query)
         hass.bus.async_fire(
@@ -59,6 +91,9 @@ class MegaView(HomeAssistantView):
         )
         _LOGGER.debug(f"Request: %s from '%s'", data, request.remote)
         make_ints(data)
+        if data.get('st') == '1':
+            hass.async_create_task(self.later_restore(hub))
+            return Response(status=200)
         port = data.get('pt')
         data = data.copy()
         update_all = True
@@ -66,23 +101,72 @@ class MegaView(HomeAssistantView):
             update_all = False
             data['value'] = data.pop('v')
         data['mega_id'] = hub.id
-        ret = 'd'
+        ret = 'd' if hub.force_d else ''
         if port is not None:
+            if is_ext(data):
+                # ret = ''  # пока ответ всегда пустой, неясно какая будет реакция на непустой ответ
+                if port in hub.extenders:
+                    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}' if not hub.new_naming else f'{int(pt_orig):02d}e{int(idx):02d}'
+                        _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)
-            if hub.update_all and update_all:
-                asyncio.create_task(self.later_update(hub))
+                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))
         _LOGGER.debug('response %s', ret)
-        ret = Response(body=ret or 'd', content_type='text/plain', headers={'Server': 's', 'Date': 'n'})
+        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_update(self, hub):
-        _LOGGER.debug('force update')
-        await asyncio.sleep(1)
-        await hub.updater.async_refresh()
+    async def later_restore(self, hub):
+        """
+        Восстановление всех выходов с небольшой задержкой. Задержка нужна чтобы ответ прошел успешно
 
+        :param hub:
+        :return:
+        """
+        await asyncio.sleep(0.2)
+        if hub.restore_on_restart:
+            await hub.restore_states()
+        await hub.reload()
+
+    async def later_update(self, hub):
+        await asyncio.sleep(1)
+        _LOGGER.debug('force update')
+        await hub.updater.async_refresh()

custom_components/mega/hub.py

@@ -9,21 +9,24 @@ import re
 import json
 
 from bs4 import BeautifulSoup
-from homeassistant.components import mqtt
+from homeassistant.config_entries import ConfigEntry
 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.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_HTTP, EVENT_BINARY_SENSOR, CONF_CUSTOM, CONF_FORCE_D, CONF_DEF_RESPONSE, PATT_FW, CONF_FORCE_I2C_SCAN,
+    REMOVE_CONFIG
 )
-from .entities import set_events_off, BaseMegaEntity
+from .entities import set_events_off, BaseMegaEntity, MegaOutPort, safe_int
 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\.]+)')
@@ -64,43 +67,66 @@ class MegaD:
             loop: asyncio.AbstractEventLoop,
             host: str,
             password: str,
-            mqtt: mqtt.MQTT,
             lg: logging.Logger,
             id: str,
-            mqtt_inputs: bool = True,
+            config: ConfigEntry = None,
             mqtt_id: str = None,
             scan_interval=60,
             port_to_scan=0,
             nports=38,
-            inverted: typing.List[int] = None,
-            update_all=True,
-            poll_outs=False,
+            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,
+            extenders=None,
+            ext_in=None,
+            ext_acts=None,
+            i2c_sensors=None,
+            new_naming=False,
+            update_time=False,
+            smooth: list=None,
             **kwargs,
     ):
         """Initialize."""
-        if mqtt_inputs is None or mqtt_inputs == 'None' or mqtt_inputs is False:
+        self.skip_ports = set()
+        if config is not None:
+            lg.debug(f'load config: %s', config.data)
+        self.config = config
         self.http = hass.data.get(DOMAIN, {}).get(CONF_HTTP)
         if not self.http is None:
             self.http.allowed_hosts |= {host}
-        else:
-            self.http = None
+            self.http.hubs[host] = self
+            if len(self.http.hubs) == 1:
+                self.http.hubs['__def'] = self
+            if mqtt_id:
+                self.http.hubs[mqtt_id] = self
+        self.smooth = smooth or []
+        self.new_naming = new_naming
+        self.extenders = extenders or []
+        self.ext_in = ext_in or {}
+        self.ext_act = ext_acts or {}
+        self.i2c_sensors = i2c_sensors or []
+        self._update_time = update_time
         self.poll_outs = poll_outs
         self.update_all = update_all if update_all is not None else True
         self.nports = nports
-        self.mqtt_inputs = mqtt_inputs
+        self.fake_response = fake_response
         self.loop: asyncio.AbstractEventLoop = None
         self.hass = hass
         self.host = host
         self.sec = password
-        self.mqtt = mqtt
         self.id = id
         self.lck = asyncio.Lock()
         self.last_long = {}
-        self._http_lck = asyncio.Lock()
+        self._http_lck = PriorityLock()
         self._notif_lck = asyncio.Lock()
         self.cnd = asyncio.Condition()
         self.online = True
         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)
@@ -116,26 +142,31 @@ 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 and DOMAIN in hass.data:
+                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()
-        if self.mqtt is not None:
-            set_events_off()
-            self.subs = await self.mqtt.async_subscribe(
-                topic=f"{self.mqtt_id}/+",
-                msg_callback=self._process_msg,
-                qos=0,
-            )
+        pass
 
     async def stop(self):
         if self.subs is not None:
@@ -155,7 +186,10 @@ class MegaD:
                 continue
             if x.port in ports:
                 continue
+            try:
                 await self.get_port(x.port, force_http=True, http_cmd=x.http_cmd)
+            except asyncio.TimeoutError:
+                continue
             ports.append(x.port)
 
     @property
@@ -170,6 +204,10 @@ class MegaD:
     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):
         return (datetime.now() - self.last_update).total_seconds() < (self.poll_interval + 10)
@@ -191,34 +229,47 @@ 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)
+            try:
+                await self.get_port(
+                    port=x,
+                    force_http=True,
+                    http_cmd='list',
+                    conv=False
+                )
+            except asyncio.TimeoutError:
+                continue
+
     async def poll(self):
         """
         Polling ports
         """
         self.lg.debug('poll')
-        ds2413_polled = []
-        for x in self.entities:
-            # обновление ds2413 устройств
-            if x.http_cmd == 'ds2413':
-                self.lg.debug(f'poll ds2413 for {x.entity_id}')
-                if x.port in ds2413_polled:
+        if self._update_time:
+            await self.update_time()
+        for x in self.i2c_sensors:
+            if not isinstance(x, dict):
                 continue
-                await self.get_port(
-                    port=x.port,
-                    force_http=True,
-                    http_cmd='list',
-                    conv=False
-                )
-                ds2413_polled.append(x.port)
-        if self.mqtt is None:
+            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)
+
         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):
@@ -232,15 +283,23 @@ 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 aiohttp.request("get", url=url) as req:
+        async with self._http_lck(priority):
+            for _ntry in range(3):
+                try:
+                    async with aiohttp.request("get", url=url, timeout=aiohttp.ClientTimeout(total=5)) as req:
                         if req.status != 200:
                             self.lg.warning('%s returned %s (%s)', url, req.status, await req.text())
                             return None
@@ -248,17 +307,27 @@ class MegaD:
                             ret = await req.text()
                             self.lg.debug('response %s', ret)
                             return ret
+                except asyncio.TimeoutError:
+                    self.lg.warning(f'timeout while requesting {url}')
+                    raise
+                    # await asyncio.sleep(1)
+            raise asyncio.TimeoutError('after 3 tries')
 
     async def save(self):
         await self.send_command(cmd='s')
 
-    def parse_response(self, ret):
+    def parse_response(self, ret, cmd='get'):
         if ret is None:
             raise NoPort()
         if 'busy' in ret:
             return None
         if ':' in ret:
+            if ';' in ret:
                 ret = ret.split(';')
+            elif '/' in ret and not cmd == 'list':
+                ret = ret.split('/')
+            else:
+                ret = [ret]
             ret = {'value': dict([
                 x.split(':') for x in ret if x.count(':') == 1
             ])}
@@ -276,11 +345,10 @@ class MegaD:
         хранилище 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))
+        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)
@@ -290,39 +358,23 @@ class MegaD:
         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:
+        try:
             ret = await self.request(cmd='all')
+        except asyncio.TimeoutError:
+            return
         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()
@@ -343,7 +395,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
@@ -372,13 +424,10 @@ 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
         )
-        if self.mqtt_inputs:
-            self._callbacks[port].append(callback)
-        else:
         self.http.callbacks[self.id][port].append(callback)
 
     async def authenticate(self) -> bool:
@@ -398,61 +447,77 @@ class MegaD:
             return await req.text()
 
     async def scan_port(self, port):
-        async with self.lck:
-            if port in self._scanned:
-                return self._scanned[port]
-            url = f'http://{self.host}/{self.sec}/?pt={port}'
-            self.lg.debug(
-                f'scan port %s: %s', port, url
-            )
-            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:
-                return
-            else:
-                pty = pty.find(selected=True)
-                if pty:
-                    pty = pty['value']
-                else:
-                    return
-            if pty in ['0', '1']:
-                m = tree.find('select', attrs={'name': 'm'})
-                if m:
-                    m = m.find(selected=True)['value']
-                self._scanned[port] = (pty, m)
-                return pty, m
-            elif pty == '3':
-                m = tree.find('select', attrs={'name': 'd'})
-                if m:
-                    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'
+        data = await self.request(pt=port)
+        return parse_config(data)
 
     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:
+        """
+        try:
+            values = await self.request(pt=port, cmd='get')
+        except asyncio.TimeoutError:
+            return
+        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:
+        """
+        pt = params.get('pt')
+        if pt in self.skip_ports:
+            return
+        if pt is not None:
+            pass
+        _params = tuple(params.items())
+        delay = None
+        if 'delay' in params:
+            delay = params.pop('delay')
+        try:
+            ret = {
+                _params: await self.request(**params)
+            }
+        except asyncio.TimeoutError:
+            return
+        self.lg.debug('i2c response: %s', ret)
+        if delay:
+            self.lg.debug('delay %s', delay)
+            await asyncio.sleep(delay)
+        return ret
+
     async def get_config(self, nports=37):
         ret = defaultdict(lambda: defaultdict(list))
-        async for port, pty, m in self.scan_ports(nports):
-            if pty == "0":
+        ret['mqtt_id'] = await self.get_mqtt_id()
+        ret['extenders'] = extenders = []
+        ret['ext_in'] = ext_int = {}
+        ret['ext_acts'] = ext_acts = {}
+        ret['i2c_sensors'] = i2c_sensors = []
+        ret['smooth'] = smooth = []
+        async for port, cfg in self.scan_ports(nports):
+            _cust = self.customize.get(port)
+            if not isinstance(_cust, dict):
+                _cust = {}
+            if cfg.pty == "0":
                 ret['binary_sensor'][port].append({})
-            elif pty == "1" and (m in ['0', '1', '3'] or m is None):
-                ret['light'][port].append({'dimmer': m == '1'})
-            elif pty == "1" and m == "2":
+            elif cfg.pty == "1" and (cfg.m in ['0', '1', '3'] or cfg.m is None):
+                if cfg.misc is not None:
+                    smooth.append(port)
+                ret['light'][port].append({'dimmer': cfg.m == '1', 'smooth': safe_int(cfg.misc)})
+            elif cfg == DS2413:
                 # ds2413
                 _data = await self.get_port(port=port, force_http=True, http_cmd='list', conv=False)
                 data = _data.get('value', {})
@@ -464,16 +529,57 @@ 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'):
-                try:
+            elif cfg == MCP230:
+                extenders.append(port)
+                if cfg.inta:
+                    ext_int[int_ignore(cfg.inta)] = port
+                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 not self.new_naming else f'{port:02d}e{n:02d}'
+                    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)):
+                    pt = f'{port}e{n}'
+                    name = pt if not self.new_naming else f'{port:02}e{n:02}'
+                    ret['light'][pt].append({'dimmer': True, 'dimmer_scale': 16, 'name': f'{self.id}_{name}'})
+            if cfg.pty == '4':  # and (cfg.gr == '0' or _cust.get(CONF_FORCE_I2C_SCAN))
+                # 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].extend(parsed)
+                    i2c_sensors.extend(req)
+            elif cfg.pty == '4' and cfg.m == '2':
+                # scl исключаем из сканирования
+                continue
+            elif cfg.pty is None and nports < 30:
+                # вроде как это ADC на 328 меге
+                ret['sensor'][port].append(dict())
+            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'
-                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')
@@ -483,8 +589,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:
-                        values = {I2C_DEVICE_TYPES[m]: values}
+                    if cfg.pty == '4' and cfg.d in I2C_DEVICE_TYPES:
+                        values = {I2C_DEVICE_TYPES.get(cfg.m): values}
                     else:
                         values = {None: values}
                 for key in values:
@@ -498,4 +604,110 @@ 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()
 
+    async def update_time(self):
+        await self.request(
+            cf=7,
+            stime=datetime.now().strftime('%H:%M:%S')
+        )
+
+    async def reload(self, reload_entry=True):
+        new = await self.get_config(nports=self.nports)
+        cfg = dict(self.config.data)
+        for x in REMOVE_CONFIG:
+            cfg.pop(x, None)
+        cfg.update(new)
+        self.lg.debug(f'new config: %s', cfg)
+        self.config.data = cfg
+        if reload_entry:
+            await self.hass.config_entries.async_reload(self.config.entry_id)
+        return cfg
+
+    def _wrap_port_smooth(self, from_, to_, time):
+        self.lg.debug('dim from %s to %s for %s seconds', from_, to_, time)
+        if time <= 0:
+            return
+        beg = datetime.now()
+        diff = to_ - from_
+        while True:
+            _pct = (datetime.now() - beg).total_seconds() / time
+            if _pct > 1:
+                return
+            val = from_ + round(diff * _pct)
+            yield val
+
+    async def smooth_dim(
+            self,
+            *config: typing.Tuple[typing.Any, int, int],
+            time: float,
+            jitter: int = 50,
+            ws=False,
+            updater=None,
+            can_smooth_hardware=False,
+            max_values=None,
+            chip=None,
+    ):
+        """
+        Плавное диммирование силами сервера, сразу нескольких портов (одной командой)
+
+        :param config: [(port, from, to), (port, from, to)]
+        :param time: время на диммирование
+        :param jitter: дополнительное замедление между командами в милисекундах
+        :param ws: если True, используется режим ws21xx
+        :param updater: функция, в которую передается текущее состояние
+        :param can_smooth_hardware: если True, используется аппаратная реализация smooth
+        :param max_values: максимальные значения (необходимы для расчета тайминга аппаратного smooth)
+        :param chip: кол-во чипов для ws-лент
+        :return:
+        """
+        if can_smooth_hardware:
+            for i, (pt, from_, to_) in enumerate(config):
+                pct = abs(from_ - to_) / max_values[i]
+                tm = max([round(time / pct), 1])
+                await self.request(pt=pt, pwm=to_, cnt=tm)
+
+        last_step = tuple([to_ for (_, _, to_) in config])
+        gen = [self._wrap_port_smooth(f, t, time) for (_, f, t) in config]
+        c = None
+        stop = False
+        while True:
+            if stop:
+                return
+            await asyncio.sleep(jitter / 1000)
+            try:
+                _next_val = tuple([next(x) for x in gen])
+            except StopIteration:
+                _next_val = last_step
+                stop = True
+            if _next_val == c:
+                continue
+            if updater is not None:
+                updater(_next_val)
+            if can_smooth_hardware:
+                if _next_val == last_step:
+                    return
+                continue
+            if not ws:
+                cmd = dict(
+                    cmd=';'.join([f'{pt}:{_next_val[i]}' for i, (pt, _, _) in enumerate(config)])
+                )
+                await self.request(**cmd)
+            else:
+                # для адресных лент
+                cmd = dict(
+                    pt=config[0][0],
+                    chip=chip,
+                    ws=''.join([hex(x).split('x')[1].rjust(2, '0').upper() for x in _next_val])
+                )
+                await self.request(**cmd)
+
+            if _next_val == last_step:
+                return
+            c = _next_val

custom_components/mega/i2c.py

@@ -0,0 +1,144 @@
+from dataclasses import dataclass, field
+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,
+    DEVICE_CLASS_CO2,
+    PERCENTAGE,
+    LIGHT_LUX,
+    TEMP_CELSIUS,
+    CONCENTRATION_PARTS_PER_MILLION,
+    PRESSURE_BAR,
+)
+from collections import namedtuple
+
+DeviceType = namedtuple('DeviceType', 'device_class,unit_of_measurement,suffix')
+
+
+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))
+        dev = params.get('i2c_dev')
+        if dev is None:
+            continue
+        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, Request):
+                if c.delay:
+                    params = params.copy()
+                    params['delay'] = c.delay
+                req.append(params)
+                continue
+            elif isinstance(c, DeviceType):
+                c, m, suffix = c
+            else:
+                continue
+            suffix = suffix or c
+            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,
+                'unit_of_measurement': m,
+            })
+            req.append(params)
+    return req, ret
+
+
+class Skip:
+    pass
+
+
+@dataclass
+class Request:
+    delay: float = None
+
+
+i2c_classes = {
+    'htu21d': [
+        DeviceType(DEVICE_CLASS_HUMIDITY, PERCENTAGE, None),
+        DeviceType(DEVICE_CLASS_TEMPERATURE, TEMP_CELSIUS, None),
+    ],
+    'sht31': [
+        DeviceType(DEVICE_CLASS_HUMIDITY, PERCENTAGE, None),
+        DeviceType(DEVICE_CLASS_TEMPERATURE, TEMP_CELSIUS, None),
+    ],
+    'max44009': [
+        DeviceType(DEVICE_CLASS_ILLUMINANCE, LIGHT_LUX, None)
+    ],
+    'bh1750': [
+        DeviceType(DEVICE_CLASS_ILLUMINANCE, LIGHT_LUX, None)
+    ],
+    'tsl2591': [
+        DeviceType(DEVICE_CLASS_ILLUMINANCE, LIGHT_LUX, None)
+    ],
+    'bmp180': [
+        DeviceType(DEVICE_CLASS_PRESSURE, PRESSURE_BAR, None),
+        DeviceType(DEVICE_CLASS_TEMPERATURE, TEMP_CELSIUS, None),
+    ],
+    'bmx280': [
+        DeviceType(DEVICE_CLASS_PRESSURE, PRESSURE_BAR, None),
+        DeviceType(DEVICE_CLASS_TEMPERATURE, TEMP_CELSIUS, None),
+        DeviceType(DEVICE_CLASS_HUMIDITY, PERCENTAGE, None)
+    ],
+    'dps368': [
+        DeviceType(DEVICE_CLASS_PRESSURE, PRESSURE_BAR, None),
+        DeviceType(DEVICE_CLASS_TEMPERATURE, TEMP_CELSIUS, None),
+    ],
+    'mlx90614': [
+        Skip,
+        DeviceType(DEVICE_CLASS_TEMPERATURE, TEMP_CELSIUS, 'temp'),
+        DeviceType(DEVICE_CLASS_TEMPERATURE, TEMP_CELSIUS, 'object'),
+    ],
+    'ptsensor': [
+        Skip,
+        Request(delay=1),  # запрос на измерение
+        DeviceType(DEVICE_CLASS_PRESSURE, PRESSURE_BAR, None),
+        DeviceType(DEVICE_CLASS_TEMPERATURE, TEMP_CELSIUS, None),
+    ],
+    'mcp9600': [
+        DeviceType(DEVICE_CLASS_TEMPERATURE, TEMP_CELSIUS, None),  # термопара
+        DeviceType(DEVICE_CLASS_TEMPERATURE, TEMP_CELSIUS, None),  # сенсор встроенный в микросхему
+    ],
+    't67xx': [
+        DeviceType(DEVICE_CLASS_CO2, CONCENTRATION_PARTS_PER_MILLION, None)
+    ],
+    'tmp117': [
+        DeviceType(DEVICE_CLASS_TEMPERATURE, TEMP_CELSIUS, None),
+    ],
+    'ads1115': [
+        DeviceType(None, None, 'ch0'),
+        DeviceType(None, None, 'ch1'),
+        DeviceType(None, None, 'ch2'),
+        DeviceType(None, None, 'ch3'),
+    ],
+    'ads1015': [
+        DeviceType(None, None, 'ch0'),
+        DeviceType(None, None, 'ch1'),
+        DeviceType(None, None, 'ch2'),
+        DeviceType(None, None, 'ch3'),
+    ],
+}

custom_components/mega/light.py

@@ -1,11 +1,20 @@
 """Platform for light integration."""
+import asyncio
 import logging
+from datetime import timedelta, datetime
+from functools import partial
+
 import voluptuous as vol
+import colorsys
+import time
 
 from homeassistant.components.light import (
     PLATFORM_SCHEMA as LIGHT_SCHEMA,
     SUPPORT_BRIGHTNESS,
     LightEntity,
+    SUPPORT_TRANSITION,
+    SUPPORT_COLOR,
+    SUPPORT_WHITE_VALUE
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -16,7 +25,7 @@ from homeassistant.const import (
     CONF_DOMAIN,
 )
 from homeassistant.core import HomeAssistant
-from .entities import MegaOutPort
+from .entities import MegaOutPort, BaseMegaEntity, safe_int
 
 from .hub import MegaD
 from .const import (
@@ -24,11 +33,12 @@ from .const import (
     CONF_SWITCH,
     DOMAIN,
     CONF_CUSTOM,
-    CONF_SKIP,
+    CONF_SKIP, CONF_LED, CONF_WS28XX, CONF_PORTS, CONF_WHITE_SEP, CONF_SMOOTH, CONF_ORDER, CONF_CHIP, RGB,
 )
+from .tools import int_ignore, map_reorder_rgb
 
 lg = logging.getLogger(__name__)
-
+SCAN_INTERVAL = timedelta(seconds=5)
 
 # Validation of the user's configuration
 _EXTENDED = {
@@ -59,16 +69,32 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
     mid = config_entry.data[CONF_ID]
     hub: MegaD = hass.data['mega'][mid]
     devices = []
-    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {})
+    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {}).get(mid, {})
+    skip = []
+    if CONF_LED in customize:
+        for entity_id, conf in customize[CONF_LED].items():
+            ports = conf.get(CONF_PORTS) or [conf.get(CONF_PORT)]
+            skip.extend(ports)
+            devices.append(MegaRGBW(
+                mega=hub,
+                port=ports,
+                name=entity_id,
+                customize=conf,
+                id_suffix=entity_id,
+                config_entry=config_entry
+            ))
     for port, cfg in config_entry.data.get('light', {}).items():
-        port = int(port)
-        c = customize.get(mid, {}).get(port, {})
-        if c.get(CONF_SKIP, False) or c.get(CONF_DOMAIN, 'light') != 'light':
+        port = int_ignore(port)
+        c = customize.get(port, {})
+        if c.get(CONF_SKIP, False) or port in skip or c.get(CONF_DOMAIN, 'light') != 'light':
             continue
         for data in cfg:
             hub.lg.debug(f'add light on port %s with data %s', port, data)
             light = MegaLight(mega=hub, port=port, config_entry=config_entry, **data)
+            if '<' in light.name:
+                continue
             devices.append(light)
+
     async_add_devices(devices)
 
 
@@ -76,5 +102,216 @@ class MegaLight(MegaOutPort, LightEntity):
 
     @property
     def supported_features(self):
-        return SUPPORT_BRIGHTNESS if self.dimmer else 0
+        return (
+            (SUPPORT_BRIGHTNESS if self.dimmer else 0) |
+            (SUPPORT_TRANSITION if self.dimmer else 0)
+        )
 
+
+class MegaRGBW(LightEntity, BaseMegaEntity):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._is_on = None
+        self._brightness = None
+        self._hs_color = None
+        self._white_value = None
+        self._task: asyncio.Task = None
+        self._restore = None
+        self.smooth: timedelta = self.customize[CONF_SMOOTH]
+        self._color_order = self.customize.get(CONF_ORDER, 'rgb')
+        self._last_called: float = 0
+        self._max_values = None
+
+    @property
+    def max_values(self) -> list:
+        if self._max_values is None:
+            if self.is_ws:
+                self._max_values = [255] * 3
+            else:
+                self._max_values = [
+                    255 if isinstance(x, int) else 4095 for x in self.port
+                ]
+        return self._max_values
+
+    @property
+    def chip(self) -> int:
+        return self.customize.get(CONF_CHIP, 100)
+
+    @property
+    def is_ws(self):
+        return self.customize.get(CONF_WS28XX)
+
+    @property
+    def white_value(self):
+        if self.supported_features & SUPPORT_WHITE_VALUE:
+            return float(self.get_attribute('white_value', 0))
+
+    @property
+    def brightness(self):
+        return float(self.get_attribute('brightness', 0))
+
+    @property
+    def hs_color(self):
+        return self.get_attribute('hs_color', [0, 0])
+
+    @property
+    def is_on(self):
+        return self.get_attribute('is_on', False)
+
+    @property
+    def supported_features(self):
+        return (
+            SUPPORT_BRIGHTNESS |
+            SUPPORT_TRANSITION |
+            SUPPORT_COLOR |
+            (SUPPORT_WHITE_VALUE if len(self.port) == 4 else 0)
+        )
+
+    def get_rgbw(self):
+        if not self.is_on:
+            return [0 for x in range(len(self.port))] if not self.is_ws else [0] * 3
+        rgb = colorsys.hsv_to_rgb(
+            self.hs_color[0]/360, self.hs_color[1]/100, self.brightness / 255
+        )
+        rgb = [x for x in rgb]
+        if self.white_value is not None:
+            white = self.white_value
+            if not self.customize.get(CONF_WHITE_SEP):
+                white = white * (self.brightness / 255)
+            rgb.append(white / 255)
+        rgb = [
+            round(x * self.max_values[i]) for i, x in enumerate(rgb)
+        ]
+        if self.is_ws:
+            # восстанавливаем мэпинг
+            rgb = map_reorder_rgb(rgb, RGB, self._color_order)
+        return rgb
+
+    async def async_turn_on(self, **kwargs):
+        if (time.time() - self._last_called) < 0.1:
+            return
+        self._last_called = time.time()
+        self.lg.debug(f'turn on %s with kwargs %s', self.entity_id, kwargs)
+        if self._restore is not None:
+            self._restore.update(kwargs)
+            kwargs = self._restore
+            self._restore = None
+        _before = self.get_rgbw()
+        self._is_on = True
+        if self._task is not None:
+            self._task.cancel()
+        self._task = asyncio.create_task(self.set_color(_before, **kwargs))
+
+    async def async_turn_off(self, **kwargs):
+        if (time.time() - self._last_called) < 0.1:
+            return
+        self._last_called = time.time()
+        self._restore = {
+            'hs_color': self.hs_color,
+            'brightness': self.brightness,
+            'white_value': self.white_value,
+        }
+        _before = self.get_rgbw()
+        self._is_on = False
+        if self._task is not None:
+            self._task.cancel()
+        self._task = asyncio.create_task(self.set_color(_before, **kwargs))
+
+    async def set_color(self, _before, **kwargs):
+        transition = kwargs.get('transition')
+        update_state = transition is not None and transition > 3
+        for item, value in kwargs.items():
+            setattr(self, f'_{item}', value)
+        _after = self.get_rgbw()
+        if transition is None:
+            transition = self.smooth.total_seconds()
+            ratio = self.calc_speed_ratio(_before, _after)
+            transition = transition * ratio
+        self.async_write_ha_state()
+        ports = self.port if not self.is_ws else self.port*3
+        config = [(port, _before[i], _after[i]) for i, port in enumerate(ports)]
+        try:
+            await self.mega.smooth_dim(
+                *config,
+                time=transition,
+                ws=self.is_ws,
+                jitter=50,
+                updater=partial(self._update_from_rgb, update_state=update_state),
+                can_smooth_hardware=self.can_smooth_hardware,
+                max_values=self.max_values,
+                chip=self.chip,
+            )
+        except asyncio.CancelledError:
+            return
+        except:
+            self.lg.exception('while dimming')
+
+    async def async_will_remove_from_hass(self) -> None:
+        await super().async_will_remove_from_hass()
+        if self._task is not None:
+            self._task.cancel()
+
+    def _update_from_rgb(self, rgbw, update_state=False):
+        if len(self.port) == 4:
+            w = rgbw[-1]
+            rgb = rgbw[:3]
+        else:
+            w = None
+            rgb = rgbw
+        if self.is_ws:
+            rgb = map_reorder_rgb(
+                rgb, self._color_order, RGB
+            )
+        h, s, v = colorsys.rgb_to_hsv(*[x/self.max_values[i] for i, x in enumerate(rgb)])
+        h *= 360
+        s *= 100
+        v *= 255
+        self._hs_color = [h, s]
+        if self.is_on:
+            self._brightness = v
+        if w is not None:
+            if not self.customize.get(CONF_WHITE_SEP):
+                w = w/(self._brightness / 255)
+            else:
+                w = w
+            w = w / (self.max_values[-1] / 255)
+            self._white_value = w
+        # print(f'updated state {self.hs_color=} {self.brightness=}')
+        if update_state:
+            self.async_write_ha_state()
+
+    async def async_update(self):
+        """
+        Эта штука нужна для синхронизации статуса вкл/выкл с реальностью. Если все цвета сброшены в ноль, значит мега
+        рестартнулась и не запомнила настройки, поэтому извещаем HA о выключении
+        Если вручную править цвет на стороне меги, тут изменения отражаться не будут
+        :return:
+        """
+        if not self.enabled:
+            return
+        rgbw = []
+        for x in self.port:
+            data = self.coordinator.data
+            if not isinstance(data, dict):
+                return
+            data = data.get(x, None)
+            if isinstance(data, dict):
+                data = data.get('value')
+            data = safe_int(data)
+            if data is None:
+                return
+            rgbw.append(data)
+        if sum(rgbw) == 0:
+            self._is_on = False
+        self.async_write_ha_state()
+
+    def calc_speed_ratio(self, _before, _after):
+        ret = None
+        for i, x in enumerate(_before):
+            r = abs(x - _after[i]) / self.max_values[i]
+            if ret is None:
+                ret = r
+            else:
+                ret = max([r, ret])
+        return ret

custom_components/mega/manifest.json

@@ -2,7 +2,7 @@
   "domain": "mega",
   "name": "mega",
   "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/mega_hacs",
+  "documentation": "https://github.com/andvikt/mega_hacs",
   "requirements": [
     "beautifulsoup4",
     "lxml"
@@ -15,5 +15,5 @@
     "@andvikt"
   ],
   "issue_tracker": "https://github.com/andvikt/mega_hacs/issues",
-  "version": "v0.4.1b3"
+  "version": "v1.0.10b2"
 }

custom_components/mega/sensor.py

@@ -1,6 +1,7 @@
 """Platform for light integration."""
 import logging
 import voluptuous as vol
+import struct
 
 from homeassistant.components.sensor import (
     PLATFORM_SCHEMA as SENSOR_SCHEMA,
@@ -13,15 +14,18 @@ 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,
+    CONF_DEVICE_CLASS,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.template import Template
 from .entities import MegaPushEntity
-from .const import CONF_KEY, TEMP, HUM, W1, W1BUS, CONF_CONV_TEMPLATE
+from .const import CONF_KEY, TEMP, HUM, W1, W1BUS, CONF_CONV_TEMPLATE, CONF_HEX_TO_FLOAT, DOMAIN, CONF_CUSTOM, CONF_SKIP
 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 +84,80 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
     mid = config_entry.data[CONF_ID]
     hub: MegaD = hass.data['mega'][mid]
     devices = []
-    for port, cfg in config_entry.data.get('sensor', {}).items():
-        port = int(port)
+    customize = hass.data.get(DOMAIN, {}).get(CONF_CUSTOM, {}).get(mid, {})
+    for tp in ['sensor', 'i2c']:
+        for port, cfg in config_entry.data.get(tp, {}).items():
+            port = int_ignore(port)
+            c = customize.get(port, {})
+            if c.get(CONF_SKIP):
+                hub.skip_ports |= {port}
+                continue
             for data in cfg:
                 hub.lg.debug(f'add sensor on port %s with data %s', port, data)
-            sensor = Mega1WSensor(
+                sensor = _constructors[tp](
                     mega=hub,
                     port=port,
                     config_entry=config_entry,
                     **data,
                 )
+                if '<' in sensor.name:
+                    continue
                 devices.append(sensor)
 
     async_add_devices(devices)
 
 
+class MegaI2C(MegaPushEntity):
+
+    def __init__(
+            self,
+            *args,
+            device_class: str,
+            params: dict,
+            unit_of_measurement: str = None,
+            **kwargs
+    ):
+        self._device_class = device_class
+        self._params = tuple(params.items())
+        self._unit_of_measurement = unit_of_measurement
+        super().__init__(*args, **kwargs)
+
+    @property
+    def customize(self):
+        return super().customize.get(self.id_suffix, {}) or {}
+
+    @property
+    def device_class(self):
+        return self._device_class
+
+    @property
+    def unit_of_measurement(self):
+        return self._unit_of_measurement
+
+    @property
+    def state(self):
+        # self.lg.debug(f'get % all states: %', self._params, self.mega.values)
+        ret = self.mega.values.get(self._params)
+        if self.customize.get(CONF_HEX_TO_FLOAT):
+            try:
+                ret = struct.unpack('!f', bytes.fromhex('41973333'))[0]
+            except:
+                self.lg.warning(f'could not convert {ret} form hex to float')
+        tmpl: Template = self.customize.get(CONF_CONV_TEMPLATE, self.customize.get(CONF_VALUE_TEMPLATE))
+        try:
+            ret = float(ret)
+            if tmpl is not None and self.hass is not None:
+                tmpl.hass = self.hass
+                ret = tmpl.async_render({'value': ret})
+        except:
+            ret = ret
+        return str(ret)
+
+    @property
+    def device_class(self):
+        return self._device_class
+
+
 class Mega1WSensor(MegaPushEntity):
 
     def __init__(
@@ -139,6 +202,14 @@ class Mega1WSensor(MegaPushEntity):
 
     @property
     def device_class(self):
+        _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
@@ -163,11 +234,20 @@ class Mega1WSensor(MegaPushEntity):
             ret = str(ret)
         except:
             ret = None
-        tmpl: Template = self.customize.get(CONF_CONV_TEMPLATE)
+        if self.customize.get(CONF_HEX_TO_FLOAT):
+            try:
+                ret = struct.unpack('!f', bytes.fromhex(ret))[0]
+            except:
+                self.lg.warning(f'could not convert {ret} form hex to float')
+        tmpl: Template = self.customize.get(CONF_CONV_TEMPLATE, self.customize.get(CONF_VALUE_TEMPLATE))
+        try:
+            ret = float(ret)
             if tmpl is not None and self.hass is not None:
                 tmpl.hass = self.hass
                 ret = tmpl.async_render({'value': ret})
-        return ret
+        except:
+            pass
+        return str(ret)
 
     @property
     def name(self):
@@ -176,3 +256,9 @@ class Mega1WSensor(MegaPushEntity):
         if isinstance(c, dict):
             c = c.get(self.key)
         return c or n
+
+
+_constructors = {
+    'sensor': Mega1WSensor,
+    'i2c': MegaI2C,
+}

custom_components/mega/strings.json

@@ -15,7 +15,14 @@
           "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%]"
+          "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%]",
+          "update_time": "[%key:common::config_flow::data::update_time%]"
+
         }
       }
     },

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,13 +51,15 @@ 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
         for data in cfg:
             hub.lg.debug(f'add switch on port %s with data %s', port, data)
             light = MegaSwitch(mega=hub, port=port, config_entry=config_entry, **data)
+            if '<' in light.name:
+                continue
             devices.append(light)
     async_add_devices(devices)
 

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:
@@ -10,3 +17,108 @@ def make_ints(d: dict):
         d['m'] = 0
     if 'click' not in d:
         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)
+
+
+def map_reorder_rgb(rgb: list, from_: str, to_: str):
+    if from_ == to_:
+        return rgb
+    mapping = [from_.index(x) for x in to_]
+    return [rgb[x] for x in mapping]

custom_components/mega/translations/en.json

@@ -22,8 +22,14 @@
                     "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
                     "nports": "Number of ports",
                     "update_all": "Update all outs when input",
-                    "mqtt_inputs": "Use MQTT",
-                    "poll_outs": "Poll outs"
+                    "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",
+                    "update_time": "Sync time"
                 }
             }
         }
@@ -35,9 +41,15 @@
                   "scan_interval": "Scan interval (sec), 0 - don't update",
                   "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
                   "reload": "Reload objects",
-                  "mqtt_inputs": "Use MQTT",
+                  "mqtt_inputs": "Use MQTT (Deprecated)",
                   "update_all": "Update all outs when input",
-                  "poll_outs": "Poll outs"
+                  "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",
+                  "update_time": "Sync time"
                 }
             }
         }

custom_components/mega/translations/ru.json

@@ -19,10 +19,16 @@
                     "mqtt_id": "MQTT id",
                     "scan_interval": "Периодичность обновлений (сек.), 0 - не обновлять",
                     "port_to_scan": "Порт, который сканируется когда нет датчиков",
-                    "mqtt_inputs": "Использовать MQTT",
+                    "mqtt_inputs": "Использовать MQTT (Не рекомендуется)",
                     "nports": "Кол-во портов",
                     "update_all": "Обновить все выходы когда срабатывает вход",
-                    "poll_outs": "Обновлять выходы (регулярно)"
+                    "fake_response": "Имитация http-ответа",
+                    "force_d": "Ответ 'd' по умолчанию",
+                    "protected": "Блокировать неразрешенные соединения",
+                    "restore_on_restart": "Восстанавливать выходы при перезагрузке",
+                    "allow_hosts": "Разрешенные ip (через ;)",
+                    "poll_outs": "Обновлять выходы (регулярно)",
+                    "update_time": "Синхронизировать время"
                 }
             }
         }
@@ -35,10 +41,16 @@
                   "port_to_scan": "Порт, который сканируется когда нет датчиков",
                   "reload": "Обновить объекты",
                   "invert": "Список портов (через ,) с инвертированной логикой",
-                  "mqtt_inputs": "Использовать MQTT",
+                  "mqtt_inputs": "Использовать MQTT (Не рекомендуется)",
+                  "fake_response": "Имитация http-ответа",
+                  "force_d": "Ответ 'd' по умолчанию",
                   "nports": "Кол-во портов",
                   "update_all": "Обновить все выходы когда срабатывает вход",
-                    "poll_outs": "Обновлять выходы (регулярно)"
+                  "protected": "Блокировать неразрешенные соединения",
+                  "allow_hosts": "Разрешенные ip (через ;)",
+                  "restore_on_restart": "Восстанавливать выходы при перезагрузке",
+                  "poll_outs": "Обновлять выходы (регулярно)",
+                  "update_time": "Синхронизировать время"
                 }
             }
         }

custom_components/mega/translations/uk.json

@@ -19,10 +19,16 @@
                     "mqtt_id": "MQTT id",
                     "scan_interval": "Період оновлення (сек.), 0 - не оновлювати",
                     "port_to_scan": "Порт для сканування при відсутності датчиків",
-                    "mqtt_inputs": "Використовувати MQTT",
+                    "mqtt_inputs": "Використовувати MQTT (Deprecated)",
                     "nports": "Кількість портів",
                     "update_all": "Оновити всі виходи коли спрацьовує вхід",
-                    "poll_outs": "Оновити виходи"
+                    "fake_response": "Імітація http-відповіді",
+                    "force_d": "Неявно відповідати 'd'",
+                    "protected": "Блокувати недозволені з'єднання",
+                    "allow_hosts": "Дозволені ip (через ;)",
+                    "restore_on_restart": "Відновлювати виходи при перезавантаженні",
+                    "poll_outs": "Оновити виходи",
+                    "update_time": "Осинхронізувати час"
                 }
             }
         }
@@ -35,9 +41,14 @@
                     "port_to_scan": "Порт для сканування при відсутності датчиків",
                     "reload": "Оновити об'єкти",
                     "invert": "Список портів з інвертованою логікою (через ,)",
-                  "mqtt_inputs": "Використовувати MQTT",
+                    "mqtt_inputs": "Використовувати MQTT (Deprecated)",
                     "nports": "Кількість портів",
+                    "fake_response": "Імітація http-відповіді",
+                    "force_d": "Неявно відповідати 'd'",
                     "update_all": "Оновити всі виходи коли спрацьовує вхід",
+                    "protected": "Блокувати недозволені з'єднання",
+                    "allow_hosts": "Дозволені ip (через ;)",
+                    "restore_on_restart": "Відновлювати виходи при перезавантаженні",
                     "poll_outs": "Оновити виходи"
                 }
             }

docs/blueprints.md

@@ -0,0 +1,58 @@
+**blueprints** - это удобные шаблоны автоматизаций, которые помогают строить автоматизацию из
+интерфейса и ими легко делиться. Все ваши шаблоны доступны из специального меню. 
+
+[![Open your Home Assistant instance and show your blueprints.](https://my.home-assistant.io/badges/blueprints.svg)](https://my.home-assistant.io/redirect/blueprints/)
+
+[Официальная документация по blueprints](https://www.home-assistant.io/docs/blueprint/)
+
+## Общее
+Здесь я делюсь шаблонами, в которых используются события из моей интеграции. 
+
+Если вы хотите сделать что-то подобное своими руками, то можно использовать мои шаблоны как отправную точку.
+
+Во всех шаблонах в качестве триггера используется событие **mega.binary** и доступен выбор типа, 
+[подробное описание типов здесь](events.md#binary).
+
+## Включить что-то
+Этот шаблон лучше всего подходит для включения сценариев/сцен или любых других объектов по нажатию какой-то кнопки или 
+обнаружению движения.
+
+!!! note "Движение"
+    Датчики движения - это такие же *binary_sensor* как и обычные выключатели. В зависимости от настроек контроллера
+    будут приходить события либо типа **single** (если настроен режим click), либо **press**
+
+Опционально так же доступна настройка автоматического выключения по таймеру, если указан 0 (по умолчанию), таймер не 
+будет использован.
+
+Опционально доступен так же *блокирующий объект* и *период блокировки*. Например, если в одной комнате с датчиком 
+движения есть выключатель, тогда его можно указать как *блокирующий объект* и в течении *периода блокировки* 
+после нажатия выключателя события с датчика движения будут игнорироваться.
+
+[![Open your Home Assistant instance and show the blueprint import dialog with a specific blueprint pre-filled.](https://my.home-assistant.io/badges/blueprint_import.svg)](https://my.home-assistant.io/redirect/blueprint_import/?blueprint_url=https%3A%2F%2Fgist.github.com%2Fandvikt%2Fb78459f4f43862d04c7fbba20d6893c7)
+
+[Исходный код](https://gist.github.com/andvikt/b78459f4f43862d04c7fbba20d6893c7)
+## Переключить состояние
+Классическое управление светом с кнопки без фиксации: нажали кнопку - свет выключился, если он сейчас включен, и наоборот. 
+Если вам нужно управлять несколькими светильниками, то необходимо будет 
+[создать группу света](https://www.home-assistant.io/integrations/light.group/)
+
+[![Open your Home Assistant instance and show the blueprint import dialog with a specific blueprint pre-filled.](https://my.home-assistant.io/badges/blueprint_import.svg)](https://my.home-assistant.io/redirect/blueprint_import/?blueprint_url=https%3A%2F%2Fgist.github.com%2Fandvikt%2Fefb48535b1b9d998fe3dbe9a3efcea2c)
+
+[Исходный код](https://gist.github.com/andvikt/efb48535b1b9d998fe3dbe9a3efcea2c)
+## Выключатель с фиксацией
+Если выбран тип "нестрогий", то при каждом переключении состояния выключателя состоянии целевого объекта так же будет 
+меняться. Этот режим рекомендуется, тк в случае переключения состояния с сервера, в случае со строгим типом будет
+"рассинхрон" - вам придется сначала выключатель привести в соответствие с текущим состоянием света. 
+
+Если выбран тип "строгий", то будет строгое соответсвие состояний, те выкл==выкл и наоборот.
+
+[![Open your Home Assistant instance and show the blueprint import dialog with a specific blueprint pre-filled.](https://my.home-assistant.io/badges/blueprint_import.svg)](https://my.home-assistant.io/redirect/blueprint_import/?blueprint_url=https%3A%2F%2Fgist.github.com%2Fandvikt%2F9addf966db75d0964143177963f40bb9)
+
+[Исходный код](https://gist.github.com/andvikt/9addf966db75d0964143177963f40bb9)
+## Универсальный шаблон
+Универсальный шаблон, с помощью которого можно выбрать любое событие меги, привязать
+к нему набор произвольных действий
+
+[![Open your Home Assistant instance and show the blueprint import dialog with a specific blueprint pre-filled.](https://my.home-assistant.io/badges/blueprint_import.svg)](https://my.home-assistant.io/redirect/blueprint_import/?blueprint_url=https%3A%2F%2Fgist.github.com%2Fandvikt%2Fbe1f683d308050b8972f9efa8aec465f)
+
+[Исходный код](https://gist.github.com/andvikt/be1f683d308050b8972f9efa8aec465f)

docs/debug.md

@@ -0,0 +1,15 @@
+[Сообщить о проблеме](https://github.com/andvikt/mega_hacs/issues/new?assignees=&labels=&template=bug-report.md&title=){ .md-button .md-button--primary }
+
+В первую очередь проверьте лог на наличие ошибок, доступ к логу возможен по кнопке ниже.
+
+[![Open your Home Assistant instance and show your Home Assistant logs.](https://my.home-assistant.io/badges/logs.svg)](https://my.home-assistant.io/redirect/logs/)
+
+Так же будет очень полезно прикладывать детальный лог, который можно включить в конфиге так:
+```yaml
+logger:
+  default: info
+  logs:
+    custom_components.mega: debug
+```
+Для просмотра логов рекомендуется использовать [logviewer](https://github.com/hassio-addons/addon-log-viewer)
+

docs/events.md

@@ -0,0 +1,66 @@
+Для быстрого старта рекомендую попробовать [мои шаблоны автоматизаций](blueprints.md)
+
+## mega.binary {: #binary}
+События можно использовать только в автоматизациях как триггер типа *event*
+```yaml
+- alias: some long click
+  trigger:
+    - platform: event
+      event_type: mega.binary
+      event_data:
+        entity_id: binary_sensor.some_id
+        type: long
+  action:
+    - service: light.toggle
+      entity_id: light.some_light
+```
+!!! note "Возможные варианты поля type"
+        - **press**: замыкание
+        - **release**: размыкание (с гарантией, что не было долгого нажатия)
+        
+        *Эти типы доступны только в режиме click (настраивается на контроллере):*
+        
+        - **long**: долгое нажатие
+        - **long_release**: размыкание после долгого нажатия
+        - **single**: одинарный клик (в режиме кликов)
+        - **double**: двойной клик
+
+## mega.sensor
+Этот вид событий более "технический", им имеет смысл пользоваться только если функциональности *mega.binary* не 
+достаточно.
+```yaml
+# событие при перезагрузке меги
+- alias: mega restart
+  trigger:
+    - platform: event
+      event_type: mega.sensor
+      event_data:
+        st: 1
+  action:
+    # какой-то экшн
+# Пример события с полями как есть прямо из меги
+- alias: some double click
+  trigger:
+    - platform: event
+      event_type: mega.sensor
+      event_data:
+        pt: 1
+        click: 2
+  action:
+    - service: light.toggle
+      entity_id: light.some_light
+```
+!!! note "События могут содержать следующие поля в event_data" 
+    - **mega_id**: id как в конфиге HA
+    - **pt**: номер порта
+    - **cnt**: счетчик срабатываний
+    - **mdid**: id как в конфиге контроллера
+    - **click**: клик (подробнее в документации меги)
+    - **port**: номер порта
+
+
+## Отладка
+Чтобы понять, какие события приходят, лучше всего воспользоваться панелью разработчика (кнопка ниже) и подписаться
+на вкладке события на событие `mega.binary` или `mega.sensor`, понажимать физические кнопки на меге.
+
+[![Open your Home Assistant instance and show your event developer tools.](https://my.home-assistant.io/badges/developer_events.svg)](https://my.home-assistant.io/redirect/developer_events/)

docs/http.md

@@ -0,0 +1,64 @@
+Контроллер оповещает сервер о своих событиях, например, нажали кнопку выключателя или сработал датчик движения,
+для этого в интеграции реализован http-сервер, для его работы необходимо прописать
+в настройках меги следующие параметры:
+
+```yaml
+srv: "192.168.1.4:8123" # ip:port вашего HA
+script: "mega" # это api интеграции, к которому будет обращаться контроллер
+```
+
+!!! note "Внимание!" 
+    Не используйте **srv loop** на контроллере - это может приводить к ложным срабатываниям входов. Вместо srv loop 
+    интеграция будет сама обновлять все состояния портов с заданным интервалом
+
+За события будут отвечать объекты типа *binary_sensor* - их статус будет меняться на **on** при замыкании
+контакта, на **off** при размыкании, а так же для более сложного контроля (двойные, долгие нажатия) предусмотрены
+события с типом *mega.binary*, [об этом подробнее в разделе события](events.md)
+
+Так же вы можете [воспользоваться моими шаблонами автоматизаций](blueprints.md) для быстрого понимания, как всем этим 
+пользоваться.
+
+## Ответ на входящие события от контроллера
+
+Контроллер ожидает ответ от сервера, который может быть сценарием (по умолчанию интеграция отвечает `d`, что означает 
+запустить то что прописано в поле act в настройках порта).
+
+*Внимание!* По умолчанию в настройках интеграции стоит опция `имитация ответа` - это означает, что сервер вместо ответа
+делает запрос к меге с необходимой командой - это вынужденная мера, тк встроенный в HA сервер разбивает пакет на части,
+а контроллер не работает с такими пакетами. В целом, `имитация ответа` полностью закрывает эту проблему, единственный
+недостаток - это небольшая задержка в ответе.
+
+Для максимальной скорости реакции, можно воспользоваться 
+[аддоном](https://github.com/andvikt/mega_addon/tree/master/mega-proxy), подробности в документации аддона.
+
+[Поддерживаются шаблоны HA.](yaml.md#binary) Это может быть использовано, например, для запоминания яркости (тк сам контроллер этого не 
+умеет).
+
+## Отладка шаблонов {: #temp-debug }
+Отладку шаблонов рекомендуется проводить в специальном меню HA, которое находится в `Панель разработчика` - `Шаблоны`
+
+Вот пример, с которого можно начать:
+```yaml
+{## Переменные, которые передает контроллер, указываются только в тесте ##}
+{% set m = 1%}
+{% set pt = 2%}
+{% set mdid = 'mega'%}
+{## Шаблон ответа ##}
+{% if m in [0, 1] %}d{% endif %}
+```
+
+## Отладка ответов http-сервера {: #http-response }
+Для отладки ответов сервера можно самим имитировать запросы контроллера, если у вас есть доступ к консоли HA:
+```shell
+curl -v -X GET 'http://localhost:8123/mega?pt=5&m=1&mdid=mymega1'
+```
+Где mymega1 - id устройства mega, который нужно узнать по url `http://192.168.1.14/sec/?cf=2`
+
+При этом необходимо так же в настройках интеграции прописать хост, с которого вы будете обращаться,
+[подробнее](yaml.md#allow_hosts)
+
+И тогда можно с локальной машины делать запросы на ваш сервер HA:
+```shell
+curl -v -X GET 'http://192.168.88.1.4:8123/mega?pt=5&m=1&mdid=mymega1'
+```
+В ответ будет приходить либо d, либо скрипт, который вы настроили

docs/i2c.md

@@ -0,0 +1,29 @@
+I2C-датчики будут добавлены автоматически в HA с названием, соответствующим порту, типу и адресу 
+(если необходим), название и entity_id вы всегда можете поменять из интерфейса HA, [а также дополнительно их
+кастомизировать с помощью yaml](yaml.md#sensors).
+
+Как и все остальные датчики, i2c подчиняется единому интервалу обновления, который указывается в меню интеграции.
+
+## Список i2c-датчиков, поддерживаемых интеграцией: {: #list}
+!!! note ""
+    Под поддерживаемыми подразумеваются те датчики, у которых учтены все возможные
+    дополнительные значения, а так же корректно определены типы
+    
+    Неподдерживаемые датчики все равно будут работать, но будет отображаться только основное значение (i2c_par=0),
+    а тип будет определен как общий, универсальный для всех датчиков.
+
+- HTU21D/Si7021
+- SHT31
+- MAX44009
+- BH1750
+- TSL2591
+- BMP180
+- BME280
+- T6703/T67xx
+- MLX90614
+- PTsensor
+- MCP9600
+- DPS368
+- ADS1115/ADS1015
+  
+Так же заводите issue если какой-то датчик отсутсвует в этом списке, но поддерживается контроллером.

docs/index.md

@@ -0,0 +1,69 @@
+# 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)
+<a class="github-button" href="https://github.com/andvikt/mega_hacs" data-icon="octicon-star" data-show-count="true" aria-label="Star andvikt/mega_hacs on GitHub">Star</a>
+
+[Сообщить о проблеме](https://github.com/andvikt/mega_hacs/issues/new?assignees=&labels=&template=bug-report.md&title=){ .md-button .md-button--primary }
+[Предложение об улучшении](https://github.com/andvikt/mega_hacs/issues/new?assignees=&labels=enhancement&template=enhance.md&title=){ .md-button .md-button--primary }
+
+Интеграция с [MegaD-2561, MegaD-328](https://www.ab-log.ru/smart-house/ethernet/megad-2561)
+
+
+Если вам понравилась интеграция, не забудьте поставить звезду на гитхабе - вам не сложно, а мне приятно ) А если
+интеграция очень понравилась - еще приятнее, если вы воспользуетесь кнопкой доната )
+
+Обновление прошивки MegaD можно делать прямо из HA с помощью [аддона](https://github.com/andvikt/mega_addon.git)
+
+## Основные особенности {: #mains }
+- Настройка в [веб-интерфейсе](settings.md) + [yaml](yaml.md)
+- Все порты автоматически добавляются как устройства (для обычных релейных выходов создается 
+  `light`, для шим - `light` с поддержкой яркости, для цифровых входов `binary_sensor`, для датчиков
+  `sensor`)
+- Поддержка rgb+w лент как с использованием диммеров, так и адресных лент на чипах ws28xx и подобных, 
+  [подробнее про rgbw](yaml.md#rgb)
+- Плавное диммирование для любых диммируемых объектов (в том числе с аппаратной поддержкой и без),
+  [подробнее про smooth](smooth.md)
+- Возможность работы с несколькими megad
+- Обратная связь по [http](http.md)
+- Автоматическое восстановление состояний выходов после перезагрузки контроллера
+- Автоматическое добавление/изменение объектов после перезагрузки контроллера
+- [События](events.md) на двойные/долгие нажатия
+- Команды выполняются друг за другом без конкурентного доступа к ресурсам megad, это дает гарантии надежного исполнения
+  большого кол-ва команд (например в сценах). Каждая следующая команда отправляется только после получения ответа о
+  выполнении предыдущей.
+- поддержка [ds2413](https://www.ab-log.ru/smart-house/ethernet/megad-2w) в том числе несколько шиной (начиная с версии 0.4.1)
+- поддержка расширителей MegaD-16I-XT, MegaD-16R-XT, MegaD-16PWM (начиная с версии 0.5.1)
+- поддержка всех возможных датчиков в режиме I2C-ANY, полный список поддерживаемых датчиков 
+  [по ссылке](i2c.md) (начиная с версии 0.6.1)
+
+## Установка {: #install}
+Если вы уже раньше устанавливали HACS, то просто поищите в списке интеграций HACS MegaD, если нет, то сначла необходимо
+установить HACS - это витрина сторонних интеграций. [Инструкция по установке](https://hacs.xyz/docs/installation/installation)
+
+Далее внутри интерфейса HACS ищем MegaD: `HACS - Integrations - Explore`, в поиске ищем MegaD. 
+
+На этом установка не закончена, вам потребуется прописать настройки каждого контроллера, [подробнее](settings.md)
+
+!!! note "Альтернативный способ установки"
+    Откройте терминал (стандартный аддон Terminal & SSH, если у вас есть supervisor, если нет то терминал вашей системы)
+    ```shell
+    # из папки с конфигом
+    wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.sh | bash -
+    ```
+    Не забываем перезагрузить HA
+
+## Обновления
+Обновления выполняются так же в меню HACS. 
+Информация об обновлениях приходит с некоторым интервалом, чтобы вручную проверить наличие обновлений
+нажмите три точки возле интеграции в меню HACS и нажмите `обновить информацию`
+
+Чтобы включить возможность использования бета-версий, зайдите в HACS, найдите интеграцию MegaD, нажмите три точки, 
+там кнопка "переустановить" или reinstall, дальше нужно нажать галку "показывать бета-версии"
+
+## Зависимости {: #deps }
+Для максимальной скорости реакции на команды сервера, рекомендуется выключить `имитацию http-ответа` в 
+настройках интеграции и настроить proxy_pass к HA, самый простой способ сделать это - воспользоваться 
+[специальным аддоном](https://github.com/andvikt/mega_addon/tree/master/mega-proxy)
+
+Обновить ваш контроллер до последней версии, обновление прошивки MegaD можно делать 
+из HA с помощью [аддона](https://github.com/andvikt/mega_addon.git)

docs/services.md

@@ -0,0 +1,32 @@
+Все сервисы доступны в меню разработчика с описанием и примерами использования
+```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:
+  description: Выполнить любую произвольную команду
+  fields:
+    mega_id:
+      description: ID меги
+      example: "mega"
+    port:
+      description: Номер порта (это не порт, которым мы управляем, а порт с которого шлем команду)
+      example: 1
+    cmd:
+      description: Любая поддерживаемая мегой команда
+      example: "1:0"
+```

docs/settings.md

@@ -0,0 +1,16 @@
+[После успешной установки интеграции в HACS](index.md#install), необходимо настроить
+каждый контроллер, проще всего сделать это по этой кнопке:
+
+[![Добавить интеграцию](https://my.home-assistant.io/badges/config_flow_start.svg)](https://my.home-assistant.io/redirect/config_flow_start/?domain=mega)
+
+Все имеющиеся у вас порты будут настроены автоматически. Вы можете менять названия, иконки и entity_id так же из интерфейса.
+
+В самой меге необходимо прописать настройки:
+```yaml
+srv: "192.168.1.4:8123" # ip:port вашего HA
+script: "mega" # это api интеграции, к которому будет обращаться контроллер
+```
+Так же необходимо настроить Mega-ID в настройках контроллера, для каждой меги id должен быть разным.
+
+При любых изменениях настроек контроллера (типы входов, id и тд) необходимо в настройках интеграции нажать `Обновить 
+объекты`

docs/smooth.md

@@ -0,0 +1,50 @@
+Начиная с версии `1.0.0` интеграция поддерживает плавные переходы. Функция реализована
+как на аппаратном уровне, так и на программном.
+
+Для аппаратной поддержки в настройках контроллера диммируемого порта необходимо включить опцию smooth.
+
+В чем разница между аппаратной и программной реализацией? Контроллер на аппаратном уровне умеет медленно
+менять значение pwm-порта, рекомендуется для всех портов с поддержкой этого режима использовать именно его,
+тк будет обеспечена максимальная плавность для любого числа устройств одновременно.
+Плавность программного диммирования ограничена ресурсами вашего сервера и скоростью ответа контроллера,
+если вы будете довольно быстро (за пару секунд) диммировать сразу группу
+света из нескольких светильков, то в программной реализации возможно увидеть скачки.
+
+Тем не менее, pwm-расширитель не умеет аппаратно сглаживать диммирование, поэтому для него есть смысл воспользоваться 
+программной реализацией
+
+Для запуска плавного перехода можно воспользоваться штатными сервисами, например:
+```yaml
+action:
+  service: light.turn_on
+  entity_id: light.some_light
+  data:
+    # свет будет плавно включаться в течении 30 секунд    
+    brightness_pct: 50
+    transition: 10 # кол-во секунд на переход
+```
+Так же любые диммируемые каналы могут участвовать в сценах, а эти сцены в свою очередь будут поддерживать опцию transition:
+```yaml
+action:
+  service: scene.turn_on
+  target:
+    entity_id: scene.romantic
+  data:
+    transition: 2.5
+```
+
+Плавность реализована в любых диммируемых объектах: свет, rgb-ленты. 
+
+Кроме того, возможно установить плавность по-умолчанию (имеет смысл использовать на pwm-расширителе), для этого в yaml-конфиге
+следует добавить опцию smooth:
+```yaml
+mega:
+  mega1:
+    10e1:    
+      smooth: 1 # если указать, то порт будет диммироваться плавно (от 0 до 100% за <smooth> секунд)
+        # опцию smooth можно использовать и на обычном pwm-порте, но в этом мало необходимости, лучше использовать 
+        # встроенный в контроллер механизм smooth
+```
+
+Для светодиодных лент smooth по умолчанию установлен в 1 секунду, 
+подробнее [тут](yaml.md#rgb)

docs/yaml.md

@@ -0,0 +1,217 @@
+С помощью yaml-конфигурации можно кастомизировать ваши устройства.
+
+## Основное
+Конфиг записывается стандартным образом в файл `configuration.yaml`, начинаем с 
+указания названия интеграции:
+```yaml hl_lines="1"
+mega:
+  megaid1:
+    10:
+      domain: switch
+      invert: true
+  megaid2:
+    14:
+      hex_to_float: true
+```
+Далее каждый новый контроллер добавляется с помощью указания его id, который вы
+придумали при установке интеграции
+```yaml hl_lines="2 6"
+mega:
+  megaid1:
+    10:
+      domain: switch
+      invert: true
+  megaid2:
+    14:
+      hex_to_float: true
+```
+
+Далее конфигурируются порты:
+```yaml hl_lines="3 4 5 7 8"
+mega:
+  megaid1:
+    10:
+      domain: switch
+      invert: true
+  megaid2:
+    14:
+      hex_to_float: true
+```
+
+## Параметры устройств
+В зависимости от типа порта доступны разные параметры. Все параметры опциональные, в скобках приведены типы и дефолтные 
+значения.
+### Стандартный набор параметров
+Все устройства вне зависимости от типа
+!!! note ""
+    - **skip** (bool, false): пропустить или нет. Если true - устройство будет исключено из списка
+    - **name** (str): имя, используется в интерфейсе
+### Реле
+!!! note ""
+    - **domain** (str, light): тип устройства. Можно выбрать light или switch
+    - **invert** (bool, false): инвертировать или нет.
+### ds2413
+Те же параметры, что у реле, но записываются иначе:
+```yaml
+10:
+  c6c439000000_a:  #c6c439000000 - это адрес ds2413, a-первый канал
+    # параметры
+  c6c439000000_b:  #b-второй канал
+```
+### Диммеры
+!!! note ""
+    - **smooth** (float, 0): программное плавное диммирование. Это поле отвечает за кол-во секунд, за которое яркость
+    диммера набирает от 0 до 100%
+    - **limits** (list[int, int], [0, 255]), *начиная с версии 1.1.0*: границы диммирования в абсолютных единицах контроллера. При диммировании 1%
+    будет равен левой границе, 100% - правой.
+[Подробнее про плавное диммирование](smooth.md)
+### MegaD-16R-XT, MegaD-16PWM
+Порты расширителей MegaD-16R-XT, MegaD-16PWM конфигурируются аналогично обычным реле и диммерам, но адресация порта 
+выглядит так:
+```yaml
+33e1:  # 33-основной порт, на котором сидит расширитель, e1-дополнительный порт расширителя
+  # стандартный конфиг порта
+33e2:
+```
+### RGB+W {: #rgb}
+Для настройки rgb(w) лент существует специальный раздел `led` в настройках каждого контроллера:
+```yaml hl_lines="3"
+mega:
+  megaid1:
+    led:
+      ledid1:  # id, который вы придумываете сами
+        # конфиг
+```
+Далее интеграция имеет поддержку двух типов лент
+#### На диммерах
+Интеграция может превратить любые 3 (или 4) диммера (актуально для мосфетов на pwm-расширителе или моноблоке)
+в rgb(w) контроллер с интерфейсом выбора цвета. Конфиг для такого типа ленты будет выглядеть так:
+!!! note ""
+    - **ports** (list\[str\]): список номеров портов, из которых составлять ленту, все порты должны быть типа PWM.
+    Порядок цветов строго \[R, G, B, W\]. W указывается опционально
+    - **white_sep** (bool, true): яркостью белого можно управлять в двух режимах - синхронно с яркостью RGB, либо 
+    отдельно, по умолчанию стоит отдельно (true)
+    - **smooth** (float, 1): скорость диммирования, от 0 до 100% за <smooth> секунд.
+Пример:
+```yaml
+some_led1:
+  ports: [10, 12, 15, 16]
+  white_sep: true
+  smooth: 2
+```
+#### Адресные ленты на WS281X
+Подробно про поддержку контроллера таких лент рассказано в [инструкции](https://www.ab-log.ru/smart-house/ethernet/megad-2561#ws).
+Интеграция не привносит ничего нового - только помогает "пробросить" такие ленты в интерфейс HA.
+Конфиг таких лент выглядит так:
+!!! note ""
+    - **ws28xx** (bool, false): обязательное поле, необходимо установить true.
+    - **port** (int): номер порта, на котором настроена лента.
+    - **order** (str, "rgb"): последовательность каналов, допускаются любые комбинации букв r,g,b: rbg, bgr и тд
+    - **chip** (int, 100): кол-во чипов в ленте, по умолчанию 100, если их меньше емеет смысл указать правильное кол-во 
+    для увеличения скорости плавного диммирования
+    - **smooth** (float, 1): скорость диммирования, от 0 до 100% за <smooth> секунд.
+Пример:
+```yaml
+some_led2:
+  ws28xx: true
+  port: 36
+  order: bgr
+  smooth: 2
+```
+### Бинарные сенсоры {: #binary}
+Или по-другому цифровые входы. Как правило используются для выключателей, кнопок, датчиков движения и тд.
+!!! note ""
+    - **response_template** (str): шаблон ответа на команды сервера. По-умолчанию d. 
+    Про формат ответа подробно описано [тут](https://www.ab-log.ru/smart-house/ethernet/megad-2561#conf-in-act). 
+    В шаблоне можно использовать параметры, которые передает контроллер (m, click, pt, mdid, mega_id).
+    Про отладку шаблонов подробнее [тут](http.md#temp-debug)
+
+!!! note "на меге"
+    Для корректной работы binary_sensor имеет смысл использовать режим P&R в настройках порта меги
+Бинарные сенсоры так же отвечают за события типа *mega.binary*, [об этом подробнее в разделе события](events.md)
+
+Примеры шаблонов ответа:
+```yaml
+4:
+  response_template: "5:2" # простейший пример без шаблона. Каждый раз когда будет приходить сообщение на этот порт, 
+                         # будем менять состояние на противоположное
+5:
+  # пример с использованием шаблона, порт 1 будет выключен если он сейчас включен и включен с последней сохраненной 
+  # яркостью если он сейчас выключен     
+  response_template: >-
+    {% if is_state('light.some_port_1', 'on') %}
+    1:0
+    {% else %}
+    1:{{state_attr('light.some_port_1', 'brightness')}}
+    {% endif %}
+6:
+  # в шаблон так же передаются все параметры, которые передает контроллер (pt, cnt, m, click)
+  # эти параметры можно использовать в условиях или непосредственно в шаблоне в виде {{pt}}
+  response_template: >-
+    {% if m==2 %}1:0{% else %}d{% endif %}
+```
+
+
+### Датчики  {: #sensors }
+Любой датчик будь то i2c или аналоговый или 1-wire
+!!! note ""
+    - **unit_of_measurement** (str): единицы измерения, [список доступных](https://developers.home-assistant.io/docs/core/entity/sensor#available-device-classes)
+    - **value_template** (str): шаблон для конвертации, например `{{(value|float)/100}}`
+    - **device_class** (str): класс устройства, [список доступных](https://developers.home-assistant.io/docs/core/entity/sensor#available-device-classes)
+    - **hex_to_float** (bool, false): если ваш датчик возвращает float запакованный в HEX, интеграция его распакует (перед применением темплейта)
+При этом есть так же особенности адресации, так для сенсора на одном порте с одним значением:
+```yaml
+36:
+  # конфиг
+```
+#### DHT11/22
+На этих сенсорах два значения, одно для температуры, второе для влажности, поэтому для них применяется
+особый вид адресации:
+```yaml
+35:
+  name:
+    hum: "влажность"
+    temp: "температура"
+  # и так далее для любого параметра сенсоров
+```
+Логика так себе ) Но так повелось в первых версиях.
+#### 1W-BUS
+Для датчиков установленных в шину 1-wire адресация кастомизации такая:
+```yaml
+35:
+  addr:  # адрес датчика, по-умолчанию entity_id будет состоять из адреса и типа
+    # конфиг
+```
+#### i2c {: #i2c}
+Для сенсоров i2c адресация конфига такая:
+```yaml
+36:
+  htu21d_humidity:  # entity_id сенсора без приставки sensor., видно в интерфейсе HA
+    # конфиг
+```
+[Подробнее про i2c](i2c.md)
+## Параметры контроллера
+Некоторые параметры применяются для всего контроллера (одна мега)
+### def_response
+Шаблон ответа сервера по умолчанию. Если этот параметр указан, то настройка "d по умолчанию" 
+в UI игнорируется.
+
+Пример:
+```yaml
+mega:
+  megaid1:
+    def_response: >-
+      {% if m in [0, 1] %}d{% endif %}
+```
+
+## Параметры интеграции
+### allow_hosts {: #allow_hosts }
+Отвечает за список хостов, с которых интеграция "слушает" сообщения. По умолчанию, в этот список
+входят все настроенные меги, а так же все запросы с локального хоста.
+
+Иногда, в целях отладки, требуется расширить этот список, что можно сделать следующим оьразом:
+```yaml
+mega:
+  allow_hosts:
+    - 192.168.1.20 
+```

mkdocs.yml

@@ -0,0 +1,34 @@
+site_name: MegaD HomeAssistant integration
+repo_url: https://github.com/andvikt/mega_hacs
+site_url: http://127.0.0.1:8000
+extra:
+  disqus: mega-hacs
+  analytics:
+    provider: google
+    property: G-E3LX9D6959
+theme:
+  name: material
+markdown_extensions:
+  - toc:
+      permalink: "#"
+  - attr_list:
+  - pymdownx.highlight
+  - pymdownx.superfences
+  - admonition
+plugins:
+  - search
+nav:
+  - Главное: index.md
+  - Конфигурация:
+    - В интерфейсе: settings.md
+    - Настройка обратной связи: http.md
+    - YAML-конфиг: yaml.md
+    - i2c: i2c.md
+    - Плавные переходы: smooth.md
+  - Автоматизация:
+    - Шаблоны (Blueprints): blueprints.md
+    - События: events.md
+    - Сервисы: services.md
+  - Неполадки: debug.md
+extra_javascript:
+  - "https://buttons.github.io/buttons.js"

readme.md

@@ -9,47 +9,4 @@
 Если вам понравилась интеграция, не забудьте поставить звезду на гитхабе - вам не сложно, а мне приятно ) А если
 интеграция очень понравилась - еще приятнее, если вы воспользуетесь кнопкой доната )
 
-Обновление прошивки MegaD можно делать прямо из HA с помощью [аддона](https://github.com/andvikt/mega_addon.git)
-
-Подробная документация по [ссылке](https://github.com/andvikt/mega_hacs/wiki)
-## Основные особенности:
-- Настройка в веб-интерфейсе + yaml
-- Все порты автоматически добавляются как устройства (для обычных релейных выходов создается 
-  `light`, для шим - `light` с поддержкой яркости, для цифровых входов `binary_sensor`, для датчиков
-  `sensor`)
-- Возможность работы с несколькими megad
-- Обратная связь по mqtt или http (на выбор)
-- События на двойные/долгие нажатия
-- Команды выполняются друг за другом без конкурентного доступа к ресурсам megad, это дает гарантии надежного исполнения
-  большого кол-ва команд (например в сценах). Каждая следующая команда отправляется только после получения ответа о
-  выполнении предыдущей.
-- поддержка ds2413 (начиная с версии 0.4.1)
-
-## Установка
-Рекомендованный способ с поддержкой обновлений - [HACS](https://hacs.xyz/docs/installation/installation):
-
-HACS - Integrations - Explore, в поиске ищем MegaD. 
-
-Чтобы включить возможность использования бета-версий, зайдите в HACS, найдите интеграцию MegaD, нажмите три точки, 
-там кнопка "переустановить" или reinstall, дальше нужно нажать галку "показывать бета-версии"
-
-Обновления выполняются так же в меню HACS. 
-Информация об обновлениях приходит с некоторым интервалом, чтобы вручную проверить наличие обновлений
-нажмите три точки возле интеграции в меню HACS и нажмите `обновить информацию`
-
-Альтернативный способ установки:
-```shell
-# из папки с конфигом
-wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.sh | bash -
-```
-Не забываем перезагрузить HA
-
-## Настройка
-`Настройки` -> `Интеграции` -> `Добавить интеграцию` в поиске ищем mega
-
-Все имеющиеся у вас порты будут настроены автоматически. Вы можете менять названия, иконки и entity_id так же из интерфейса.
-
-## Зависимости
-Для совместимости c mqtt необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
-в HomeAssistant, а так же обновить ваш контроллер до последней версии, обновление прошивки MegaD можно делать прямо 
-из HA с помощью [аддона](https://github.com/andvikt/mega_addon.git)
+[Подробная документация](https://andvikt.github.io/mega_hacs/)