edit readme

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