fix old mega out type 0

.github/ISSUE_TEMPLATE/bug-report.md

@@ -0,0 +1,26 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Описание**
+A clear and concise description of what the bug is.
+
+**Версии систем**
+Enviroment: raspberry/linux/windows/macos/docker
+HA version: 
+mega_hacs version:
+megad firmware version:
+
+**Ожидаемое поведение**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**LOG**
+Прочитайте в документации как включить подробный лог интеграции и приложите его здесь

custom_components/mega/__init__.py

@@ -4,24 +4,29 @@ import logging
 from functools import partial
 
 import voluptuous as vol
+
 from homeassistant.const import (
     CONF_SCAN_INTERVAL, CONF_ID, CONF_NAME, CONF_DOMAIN,
-    CONF_UNIT_OF_MEASUREMENT,
+    CONF_UNIT_OF_MEASUREMENT, CONF_HOST
 )
 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
+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
 from .hub import MegaD
 from .config_flow import ConfigFlow
-
+from .http import MegaView
 
 _LOGGER = logging.getLogger(__name__)
 
 CONFIG_SCHEMA = vol.Schema(
     {
         DOMAIN: {
+            vol.Optional(CONF_ALLOW_HOSTS): [str],
             vol.Required(str, description='id меги из веб-интерфейса'): {
                 vol.Optional(int, description='номер порта'): {
                     vol.Optional(CONF_SKIP, description='исключить порт из сканирования', default=False): bool,
@@ -34,6 +39,12 @@ CONFIG_SCHEMA = vol.Schema(
                         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,
                 }
             }
         }
@@ -51,7 +62,9 @@ _subs = {}
 async def async_setup(hass: HomeAssistant, config: dict):
     """YAML-конфигурация содержит только кастомизации портов"""
     hass.data[DOMAIN] = {CONF_CUSTOM: config.get(DOMAIN, {})}
-
+    hass.data[DOMAIN][CONF_HTTP] = view = MegaView(cfg=config.get(DOMAIN, {}))
+    view.allowed_hosts |= set(config.get(DOMAIN, {}).get(CONF_ALLOW_HOSTS, []))
+    hass.http.register_view(view)
     hass.services.async_register(
         DOMAIN, 'save', partial(_save_service, hass), schema=vol.Schema({
             vol.Optional('mega_id'): str
@@ -70,6 +83,7 @@ async def async_setup(hass: HomeAssistant, config: dict):
             vol.Optional('mega_id'): str,
         })
     )
+
     return True
 
 
@@ -78,9 +92,17 @@ async def get_hub(hass, entry):
     data = dict(entry.data)
     data.update(entry.options or {})
     data.update(id=id)
-    _mqtt = hass.data.get(mqtt.DOMAIN)
+    use_mqtt = data.get(CONF_MQTT_INPUTS, True)
-    if _mqtt is None:
+
-        raise Exception('mqtt not configured, please configure mqtt first')
+    _mqtt = hass.data.get(mqtt.DOMAIN) if use_mqtt else None
+    if _mqtt is None and use_mqtt:
+        for x in range(5):
+            await asyncio.sleep(5)
+            _mqtt = hass.data.get(mqtt.DOMAIN)
+            if _mqtt is not None:
+                break
+        if _mqtt is None:
+            raise Exception('mqtt not configured, please configure mqtt first')
     hub = MegaD(hass, **data, mqtt=_mqtt, lg=_LOGGER, loop=asyncio.get_event_loop())
     hub.mqtt_id = await hub.get_mqtt_id()
     return hub
@@ -89,7 +111,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] = hub
+    hass.data[DOMAIN][id] = hass.data[DOMAIN]['__def'] = hub
+    hass.data[DOMAIN][entry.data.get(CONF_HOST)] = hub
     if not await hub.authenticate():
         raise Exception("not authentificated")
     mid = await hub.get_mqtt_id()

custom_components/mega/binary_sensor.py

@@ -73,20 +73,13 @@ class MegaBinarySensor(BinarySensorEntity, MegaPushEntity):
 
     @property
     def is_on(self) -> bool:
-        if self._is_on is not None:
+        val = self.mega.values.get(self.port, {}).get("value") \
-            return self._is_on
+              or self.mega.values.get(self.port, {}).get('m')
-        return self._state == 'ON'
+        if val is None and self._state is not None:
+            return self._state == 'ON'
+        elif val is not None:
+            return val == 'ON' or val == 1
 
     def _update(self, payload: dict):
-        data = {CONF_ENTITY_ID: self.entity_id}
+        self.mega.values[self.port] = payload
-        payload = payload.copy()
+
-        payload.pop(CONF_PORT)
-        data.update(payload)
-        if not self.is_first_update:
-            self.hass.bus.async_fire(
-                EVENT_BINARY_SENSOR,
-                data,
-            )
-        val = payload.get("value")
-        self._is_on = val == 'ON'
-        self._attrs = data

custom_components/mega/config_flow.py

@@ -9,7 +9,8 @@ from homeassistant.components import mqtt
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_ID, CONF_PASSWORD, CONF_SCAN_INTERVAL
 from homeassistant.core import callback, HomeAssistant
-from .const import DOMAIN, CONF_PORT_TO_SCAN, CONF_RELOAD, PLATFORMS  # pylint:disable=unused-import
+from .const import DOMAIN, CONF_PORT_TO_SCAN, CONF_RELOAD, PLATFORMS, CONF_MQTT_INPUTS, \
+    CONF_NPORTS, CONF_UPDATE_ALL  # pylint:disable=unused-import
 from .hub import MegaD
 from . import exceptions
 
@@ -22,14 +23,17 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         vol.Required(CONF_PASSWORD, default="sec"): str,
         vol.Optional(CONF_SCAN_INTERVAL, default=0): int,
         vol.Optional(CONF_PORT_TO_SCAN, default=0): int,
+        vol.Optional(CONF_MQTT_INPUTS, default=True): bool,
+        vol.Optional(CONF_NPORTS, default=37): int,
+        # vol.Optional(CONF_UPDATE_ALL, default=True): bool,
     },
 )
 
 
 async def get_hub(hass: HomeAssistant, data):
     _mqtt = hass.data.get(mqtt.DOMAIN)
-    if not isinstance(_mqtt, mqtt.MQTT):
+    # if not isinstance(_mqtt, mqtt.MQTT):
-        raise exceptions.MqttNotConfigured("mqtt must be configured first")
+    #     raise exceptions.MqttNotConfigured("mqtt must be configured first")
     hub = MegaD(hass, **data, lg=_LOGGER, mqtt=_mqtt, loop=asyncio.get_event_loop())
     hub.mqtt_id = await hub.get_mqtt_id()
     if not await hub.authenticate():
@@ -52,7 +56,7 @@ async def validate_input(hass: core.HomeAssistant, data):
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for mega."""
 
-    VERSION = 3
+    VERSION = 4
     CONNECTION_CLASS = config_entries.CONN_CLASS_ASSUMED
 
     async def async_step_user(self, user_input=None):
@@ -67,7 +71,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
         try:
             hub = await validate_input(self.hass, user_input)
             await hub.start()
-            config = await hub.get_config()
+            config = await hub.get_config(nports=user_input.get(CONF_NPORTS, 37))
             await hub.stop()
             hub.lg.debug(f'config loaded: %s', config)
             config.update(user_input)
@@ -110,7 +114,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
             hub = await get_hub(self.hass, self.config_entry.data)
             if reload:
                 await hub.start()
-                new = await hub.get_config()
+                new = await hub.get_config(nports=user_input.get(CONF_NPORTS, 37))
                 await hub.stop()
 
                 _LOGGER.debug(f'new config: %s', new)
@@ -128,7 +132,10 @@ 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_PORT_TO_SCAN, default=e.get(CONF_PORT_TO_SCAN, 0)): int,
+                vol.Optional(CONF_MQTT_INPUTS, default=e.get(CONF_MQTT_INPUTS, True)): bool,
+                vol.Optional(CONF_NPORTS, default=e.get(CONF_NPORTS, 37)): int,
                 vol.Optional(CONF_RELOAD, default=False): bool,
+                # vol.Optional(CONF_UPDATE_ALL, default=e.get(CONF_UPDATE_ALL, True)): bool,
                 # vol.Optional(CONF_INVERT, default=''): str,
             }),
         )

custom_components/mega/const.py

@@ -1,4 +1,5 @@
 """Constants for the mega integration."""
+import re
 
 DOMAIN = "mega"
 CONF_MEGA_ID = "mega_id"
@@ -14,11 +15,20 @@ CONF_RELOAD = 'reload'
 CONF_INVERT = 'invert'
 CONF_PORTS = 'ports'
 CONF_CUSTOM = '__custom'
+CONF_HTTP = '__http'
 CONF_SKIP = 'skip'
+CONF_MQTT_INPUTS = 'mqtt_inputs'
+CONF_NPORTS = 'nports'
+CONF_RESPONSE_TEMPLATE = 'response_template'
+CONF_ACTION = 'action'
+CONF_UPDATE_ALL = 'update_all'
+CONF_GET_VALUE = 'get_value'
+CONF_ALLOW_HOSTS = 'allow_hosts'
 PLATFORMS = [
     "light",
     "switch",
     "binary_sensor",
     "sensor",
 ]
-EVENT_BINARY_SENSOR = f'{DOMAIN}.sensor'
+EVENT_BINARY_SENSOR = f'{DOMAIN}.sensor'
+PATT_SPLIT = re.compile('[;/]')

custom_components/mega/entities.py

@@ -1,4 +1,5 @@
 import logging
+import asyncio
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_NAME
 from homeassistant.core import State
@@ -28,6 +29,7 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
         self.port = port
         self.config_entry = config_entry
         self.mega = mega
+        mega.entities.append(self)
         self._mega_id = mega.id
         self._lg = None
         self._unique_id = unique_id or f"mega_{mega.id}_{port}" + \
@@ -89,6 +91,10 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
         await super().async_added_to_hass()
         self._state = await self.async_get_last_state()
 
+    async def get_state(self):
+        if self.mega.mqtt is None:
+            self.async_write_ha_state()
+
 
 class MegaPushEntity(BaseMegaEntity):
 
@@ -113,7 +119,8 @@ class MegaPushEntity(BaseMegaEntity):
 
     async def async_added_to_hass(self) -> None:
         await super().async_added_to_hass()
-        self.hass.async_create_task(self.mega.get_port(self.port))
+        if self.mega.mqtt is not None:
+            asyncio.create_task(self.mega.get_port(self.port))
 
 
 class MegaOutPort(MegaPushEntity):
@@ -136,16 +143,26 @@ class MegaOutPort(MegaPushEntity):
 
     @property
     def brightness(self):
-        if self._brightness is not None:
+        val = self.mega.values.get(self.port, {}).get("value")
-            return self._brightness
+        if val is None and self._state is not None:
-        if self._state:
             return self._state.attributes.get("brightness")
+        elif val is not None:
+            try:
+                val = int(val)
+                return val
+            except Exception:
+                pass
 
     @property
     def is_on(self) -> bool:
-        if self._is_on is not None:
+        val = self.mega.values.get(self.port, {}).get("value")
-            return self._is_on
+        if val is None and self._state is not None:
-        return self._state == 'ON'
+            return self._state == 'ON'
+        elif val is not None:
+            if not self.invert:
+                return val == 'ON' or str(val) == '1' or (safe_int(val) is not None and safe_int(val) > 0)
+            else:
+                return val == 'OFF' or str(val) == '0' or (safe_int(val) is not None and safe_int(val) == 0)
 
     async def async_turn_on(self, brightness=None, **kwargs) -> None:
         brightness = brightness or self.brightness or 255
@@ -156,31 +173,23 @@ class MegaOutPort(MegaPushEntity):
             cmd = brightness
         else:
             cmd = 1 if not self.invert else 0
-        if await self.mega.send_command(self.port, f"{self.port}:{cmd}"):
+        await self.mega.send_command(self.port, f"{self.port}:{cmd}")
-            self._is_on = True
+        self.mega.values[self.port] = {'value': cmd}
-            self._brightness = brightness
+        await self.get_state()
-        await self.async_update_ha_state()
+
 
     async def async_turn_off(self, **kwargs) -> None:
 
         cmd = "0" if not self.invert else "1"
 
-        if await self.mega.send_command(self.port, f"{self.port}:{cmd}"):
+        await self.mega.send_command(self.port, f"{self.port}:{cmd}")
-            self._is_on = False
+        self.mega.values[self.port] = {'value': cmd}
-        await self.async_update_ha_state()
+        await self.get_state()
 
-    def _update(self, payload: dict):
+def safe_int(v):
-        val = payload.get("value")
+    if v in ['ON', 'OFF']:
-        try:
+        return None
-            val = int(val)
+    try:
-        except Exception:
+        return int(v)
-            pass
+    except ValueError:
-        if isinstance(val, int):
+        return None
-            self._is_on = val
-            if val > 0:
-                self._brightness = val
-        else:
-            if not self.invert:
-                self._is_on = val == 'ON'
-            else:
-                self._is_on = val == 'OFF'

custom_components/mega/http.py

@@ -0,0 +1,95 @@
+import asyncio
+import logging
+
+import typing
+from collections import defaultdict
+
+from aiohttp.web_request import Request
+from aiohttp.web_response import Response
+
+from homeassistant.helpers.template import Template
+from .const import EVENT_BINARY_SENSOR, CONF_HTTP, DOMAIN, CONF_CUSTOM, CONF_RESPONSE_TEMPLATE
+from homeassistant.components.http import HomeAssistantView
+from homeassistant.core import callback, HomeAssistant
+from . import hub
+
+_LOGGER = logging.getLogger(__name__).getChild('http')
+
+
+class MegaView(HomeAssistantView):
+    """Handle Yandex Smart Home unauthorized requests."""
+
+    url = '/mega'
+    name = 'mega'
+    requires_auth = False
+
+    def __init__(self, cfg: dict):
+        self._try = 0
+        self.allowed_hosts = {'::1'}
+        self.callbacks: typing.DefaultDict[int, typing.List[typing.Callable[[dict], typing.Coroutine]]] \
+            = defaultdict(list)
+        self.templates: typing.Dict[str, typing.Dict[str, Template]] = {
+            mid: {
+                pt: cfg[mid][pt][CONF_RESPONSE_TEMPLATE]
+                for pt in cfg[mid]
+                if CONF_RESPONSE_TEMPLATE in cfg[mid][pt]
+            } for mid in cfg
+        }
+        _LOGGER.debug('templates: %s', self.templates)
+
+    async def get(self, request: Request) -> Response:
+        auth = False
+        for x in self.allowed_hosts:
+            if request.remote.startswith(x):
+                auth = True
+                break
+        if not auth:
+            _LOGGER.warning(f'unauthorised attempt to connect from {request.remote}')
+            return Response(status=401)
+
+        hass: HomeAssistant = request.app['hass']
+        hub: 'hub.MegaD' = hass.data.get(DOMAIN).get(request.remote)  # TODO: проверить какой remote
+        if hub is None and request.remote == '::1':
+            hub = hass.data.get(DOMAIN).get('__def')
+        if hub is None:
+            return Response(status=400)
+        data = dict(request.query)
+        hass.bus.async_fire(
+            EVENT_BINARY_SENSOR,
+            data,
+        )
+        _LOGGER.debug(f"Request: %s from '%s'", data, request.remote)
+        make_ints(data)
+        port = data.get('pt')
+        data = data.copy()
+        ret = 'd'
+        if port is not None:
+            for cb in self.callbacks[port]:
+                cb(data)
+            template: Template = self.templates.get(hub.id, {}).get(port)
+            if hub.update_all:
+                asyncio.create_task(self.later_update(hub))
+            if template is not None:
+                template.hass = hass
+                ret = template.async_render(data)
+        _LOGGER.debug('response %s', ret)
+        ret = Response(body=ret or 'd', content_type='text/plain', headers={})
+        ret.headers.clear()
+        return ret
+
+    async def later_update(self, hub):
+        _LOGGER.debug('force update')
+        await asyncio.sleep(1)
+        await hub.updater.async_refresh()
+
+
+def make_ints(d: dict):
+    for x in d:
+        try:
+            d[x] = float(d[x])
+        except ValueError:
+            pass
+    if 'm' not in d:
+        d['m'] = 0
+    if 'click' not in d:
+        d['click'] = 0

custom_components/mega/hub.py

@@ -14,8 +14,9 @@ from homeassistant.const import DEVICE_CLASS_TEMPERATURE, DEVICE_CLASS_HUMIDITY
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
-from .const import TEMP, HUM
+from .const import TEMP, HUM, PATT_SPLIT, DOMAIN, CONF_HTTP
-from .exceptions import CannotConnect
+from .exceptions import CannotConnect, MqttNotConfigured
+from .http import MegaView
 
 TEMP_PATT = re.compile(r'temp:([01234567890\.]+)')
 HUM_PATT = re.compile(r'hum:([01234567890\.]+)')
@@ -32,6 +33,10 @@ CLASSES = {
     HUM: DEVICE_CLASS_HUMIDITY
 }
 
+class NoPort(Exception):
+    pass
+
+
 class MegaD:
     """MegaD Hub"""
 
@@ -44,13 +49,25 @@ class MegaD:
             mqtt: mqtt.MQTT,
             lg: logging.Logger,
             id: str,
+            mqtt_inputs: bool = True,
             mqtt_id: str = None,
             scan_interval=60,
             port_to_scan=0,
+            nports=38,
             inverted: typing.List[int] = None,
+            update_all=True,
             **kwargs,
     ):
         """Initialize."""
+        if mqtt_inputs is None or mqtt_inputs == 'None' or mqtt_inputs is False:
+            self.http = hass.data.get(DOMAIN, {}).get(CONF_HTTP)
+            if not self.http is None:
+                self.http.allowed_hosts |= {host}
+        else:
+            self.http = None
+        self.update_all = update_all if update_all is not None else True
+        self.nports = nports
+        self.mqtt_inputs = mqtt_inputs
         self.loop: asyncio.AbstractEventLoop = None
         self.hass = hass
         self.host = host
@@ -58,6 +75,8 @@ class MegaD:
         self.mqtt = mqtt
         self.id = id
         self.lck = asyncio.Lock()
+        self._http_lck = asyncio.Lock()
+        self._notif_lck = asyncio.Lock()
         self.cnd = asyncio.Condition()
         self.online = True
         self.entities: typing.List[Entity] = []
@@ -79,6 +98,7 @@ class MegaD:
             update_method=self.poll,
             update_interval=timedelta(seconds=self.poll_interval) if self.poll_interval else None,
         )
+        self.notifiers = defaultdict(asyncio.Condition)
         if not mqtt_id:
             _id = host.split(".")[-1]
             self.mqtt_id = f"megad/{_id}"
@@ -87,14 +107,16 @@ class MegaD:
 
     async def start(self):
         self.loop = asyncio.get_event_loop()
-        self.subs = await self.mqtt.async_subscribe(
+        if self.mqtt is not None:
-            topic=f"{self.mqtt_id}/+",
+            self.subs = await self.mqtt.async_subscribe(
-            msg_callback=self._process_msg,
+                topic=f"{self.mqtt_id}/+",
-            qos=0,
+                msg_callback=self._process_msg,
-        )
+                qos=0,
+            )
 
     async def stop(self):
-        self.subs()
+        if self.subs is not None:
+            self.subs()
         for x in self._callbacks.values():
             x.clear()
 
@@ -102,10 +124,16 @@ class MegaD:
         async with self.lck:
             self.entities.append(ent)
 
-    async def get_sensors(self):
+    async def get_sensors(self, only_list=False):
         self.lg.debug(self.sensors)
+        ports = []
         for x in self.sensors:
-            await self.get_port(x)
+            if only_list and x.http_cmd != 'list':
+                continue
+            if x.port in ports:
+                continue
+            await self.get_port(x.port, force_http=True, http_cmd=x.http_cmd)
+            ports.append(x.port)
 
     @property
     def is_online(self):
@@ -134,6 +162,10 @@ class MegaD:
         offline
         """
         self.lg.debug('poll')
+        if self.mqtt is None:
+            await self.get_all_ports()
+            await self.get_sensors(only_list=True)
+            return
         if len(self.sensors) > 0:
             await self.get_sensors()
         else:
@@ -152,46 +184,90 @@ class MegaD:
             return _id or 'megad/' + self.host.split('.')[-1]
 
     async def send_command(self, port=None, cmd=None):
-        if port:
+        return await self.request(pt=port, cmd=cmd)
-            url = f"http://{self.host}/{self.sec}/?pt={port}&cmd={cmd}"
+
-        else:
+    async def request(self, **kwargs):
-            url = f"http://{self.host}/{self.sec}/?cmd={cmd}"
+        cmd = '&'.join([f'{k}={v}' for k, v in kwargs.items() if v is not None])
-        self.lg.debug('run command: %s', url)
+        url = f"http://{self.host}/{self.sec}/?{cmd}"
-        async with self.lck:
+        self.lg.debug('request: %s', url)
+        async with self._http_lck:
             async with aiohttp.request("get", url=url) as req:
                 if req.status != 200:
                     self.lg.warning('%s returned %s (%s)', url, req.status, await req.text())
-                    return False
+                    return None
                 else:
-                    return True
+                    ret = await req.text()
+                    self.lg.debug('response %s', ret)
+                    return ret
 
     async def save(self):
         await self.send_command(cmd='s')
 
-    async def get_port(self, port):
+    def parse_response(self, ret):
-        """Запрос состояния порта. Блокируется пока не придет какое-нибудь сообщение от меги или таймаут"""
+        if ret is None:
-        async with self.cnd:
+            raise NoPort()
-            await self.mqtt.async_publish(
+        if ':' in ret:
-                topic=f'{self.mqtt_id}/cmd',
+            ret = PATT_SPLIT.split(ret)
-                payload=f'get:{port}',
+            ret = dict([
-                qos=2,
+                x.split(':') for x in ret if x.count(':') == 1
-                retain=False,
+            ])
-            )
+        elif 'ON' in ret:
-            await asyncio.wait_for(self.cnd.wait_for(lambda: self.last_port == port), timeout=15)
+            ret = {'value': 'ON'}
+        elif 'OFF' in ret:
+            ret = {'value': 'OFF'}
+        else:
+            ret = {'value': ret}
+        return ret
+
+    async def get_port(self, port, force_http=False, http_cmd='get'):
+        """
+        Запрос состояния порта. Состояние всегда возвращается в виде объекта, всегда сохраняется в центральное
+        хранилище values
+        """
+        self.lg.debug(f'get port %s', port)
+        if self.mqtt is None or force_http:
+            ret = await self.request(pt=port, cmd=http_cmd)
+            ret = self.parse_response(ret)
+            self.lg.debug('parsed: %s', ret)
+            if http_cmd == 'list' and isinstance(ret, dict) and 'value' in ret:
+                await asyncio.sleep(1)
+                ret = await self.request(pt=port, http_cmd=http_cmd)
+                ret = self.parse_response(ret)
+            self.values[port] = ret
+            return ret
+
+        async with self._notif_lck:
+            async with self.notifiers[port]:
+                cnd = self.notifiers[port]
+                await self.mqtt.async_publish(
+                    topic=f'{self.mqtt_id}/cmd',
+                    payload=f'get:{port}',
+                    qos=2,
+                    retain=False,
+                )
+                try:
+                    await asyncio.wait_for(cnd.wait(), timeout=10)
+                    return self.values.get(port)
+                except asyncio.TimeoutError:
+                    self.lg.error(f'timeout when getting port {port}')
 
     async def get_all_ports(self):
-        for x in range(37):
+        if not self.mqtt_inputs:
-            await self.get_port(x)
+            ret = await self.request(cmd='all')
+            for port, x in enumerate(ret.split(';')):
+                ret = self.parse_response(x)
+                self.values[port] = ret
+        else:
+            for x in range(self.nports + 1):
+                await self.get_port(x)
 
     async def reboot(self, save=True):
         await self.save()
 
     async def _notify(self, port, value):
-        async with self.cnd:
+        async with self.notifiers[port]:
-            self.last_update = datetime.now()
+            cnd = self.notifiers[port]
-            self.values[port] = value
+            cnd.notify_all()
-            self.last_port = port
-            self.cnd.notify_all()
 
     def _process_msg(self, msg):
         try:
@@ -214,6 +290,7 @@ class MegaD:
         value = None
         try:
             value = json.loads(msg.payload)
+            self.values[port] = value
             for cb in self._callbacks[port]:
                 cb(value)
         except Exception as exc:
@@ -227,7 +304,10 @@ class MegaD:
         self.lg.debug(
             f'subscribe %s %s', port, callback
         )
-        self._callbacks[port].append(callback)
+        if self.mqtt_inputs:
+            self._callbacks[port].append(callback)
+        else:
+            self.http.callbacks[port].append(callback)
 
     async def authenticate(self) -> bool:
         """Test if we can authenticate with the host."""
@@ -255,6 +335,8 @@ class MegaD:
             )
             async with aiohttp.request('get', url) as req:
                 html = await req.text()
+                if req.status != 200:
+                    return
             tree = BeautifulSoup(html, features="lxml")
             pty = tree.find('select', attrs={'name': 'pty'})
             if pty is None:
@@ -278,23 +360,27 @@ class MegaD:
                 self._scanned[port] = (pty, m)
                 return pty, m
 
-    async def scan_ports(self,):
+    async def scan_ports(self, nports=37):
-        for x in range(38):
+        for x in range(0, nports+1):
             ret = await self.scan_port(x)
             if ret:
                 yield [x, *ret]
+        self.nports = nports+1
 
-    async def get_config(self):
+    async def get_config(self, nports=37):
         ret = defaultdict(lambda: defaultdict(list))
-        async for port, pty, m in self.scan_ports():
+        async for port, pty, m in self.scan_ports(nports):
             if pty == "0":
                 ret['binary_sensor'][port].append({})
-            elif pty == "1" and m in ['0', '1']:
+            elif pty == "1" and (m in ['0', '1', '3'] or m is None):
                 ret['light'][port].append({'dimmer': m == '1'})
             elif pty == '3':
                 try:
-                    await self.get_port(port)
+                    http_cmd = 'get'
-                    values = self.values.get(port)
+                    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
@@ -315,6 +401,7 @@ class MegaD:
                         unit_of_measurement=UNITS.get(key, UNITS[TEMP]),
                         device_class=CLASSES.get(key, CLASSES[TEMP]),
                         id_suffix=key,
+                        http_cmd=http_cmd,
                     ))
         return ret
 

custom_components/mega/manifest.json

@@ -10,9 +10,7 @@
   "ssdp": [],
   "zeroconf": [],
   "homekit": {},
-  "dependencies": [
+  "after_dependencies": ["mqtt"],
-    "mqtt"
-  ],
   "codeowners": [
     "@andvikt"
   ],

custom_components/mega/sensor.py

@@ -101,6 +101,7 @@ class Mega1WSensor(MegaPushEntity):
             unit_of_measurement,
             device_class,
             key=None,
+            http_cmd='get',
             *args,
             **kwargs
     ):
@@ -111,13 +112,12 @@ class Mega1WSensor(MegaPushEntity):
         :param patt: pattern to extract value, must have at least one group that will contain parsed value
         """
         super().__init__(*args, **kwargs)
-        self.mega.sensors.append(self)
         self._value = None
         self.key = key
         self._device_class = device_class
         self._unit_of_measurement = unit_of_measurement
-        if self.port not in self.mega.sensors:
+        self.mega.sensors.append(self)
-            self.mega.sensors.append(self.port)
+        self.http_cmd = http_cmd
 
     @property
     def unit_of_measurement(self):
@@ -144,19 +144,30 @@ class Mega1WSensor(MegaPushEntity):
 
     @property
     def state(self):
+        ret = None
         if self.key:
-            ret = self.mega.values.get(self.port, {}).get('value', {}).get(self.key)
+            try:
+                ret = self.mega.values.get(self.port, {})
+                if isinstance(ret, dict):
+                    ret = ret.get(self.key)
+            except:
+                self.lg.error(self.mega.values.get(self.port, {}).get('value', {}))
+                return
         else:
             ret = self.mega.values.get(self.port, {}).get('value')
         if ret is None and self._state is not None:
             ret = self._state.state
+        try:
+            ret = float(ret)
+            ret = str(ret)
+        except:
+            ret = None
         return ret
 
-    def _update(self, payload: dict):
-        self.mega.values[self.port] = payload
-
     @property
     def name(self):
         n = super().name
-        c = self.customize.get(CONF_NAME, {}).get(self.key)
+        c = self.customize.get(CONF_NAME, {})
+        if isinstance(c, dict):
+            c = c.get(self.key)
         return c or n

custom_components/mega/strings.json

@@ -11,7 +11,10 @@
           "mqtt_id": "[%key:common::config_flow::data::mqtt_id%]",
           "scan_interval": "[%key:common::config_flow::data::mqtt_id%]",
           "port_to_scan": "[%key:common::config_flow::data::port_to_scan%]",
-          "invert": "[%key:common::config_flow::data::invert%]"
+          "invert": "[%key:common::config_flow::data::invert%]",
+          "mqtt_inputs": "[%key:common::config_flow::data::mqtt_inputs%]",
+          "nports": "[%key:common::config_flow::data::nports%]",
+          "update_all": "[%key:common::config_flow::data::update_all%]"
         }
       }
     },
@@ -32,7 +35,10 @@
           "scan_interval": "[%key:common::config_flow::data::scan_interval%]",
           "port_to_scan": "[%key:common::config_flow::data::port_to_scan%]",
           "reload": "[%key:common::config_flow::data::reload%]",
-          "invert": "[%key:common::config_flow::data::invert%]"
+          "invert": "[%key:common::config_flow::data::invert%]",
+          "mqtt_inputs": "[%key:common::config_flow::data::mqtt_inputs%]",
+          "nports": "[%key:common::config_flow::data::nports%]",
+          "update_all": "[%key:common::config_flow::data::update_all%]"
         }
       }
     }

custom_components/mega/translations/en.json

@@ -7,7 +7,8 @@
             "cannot_connect": "Failed to connect",
             "invalid_auth": "Invalid authentication",
             "unknown": "Unexpected error",
-            "duplicate_id": "Duplicate ID"
+            "duplicate_id": "Duplicate ID",
+            "mqtt_inputs": "Use MQTT"
         },
         "step": {
             "user": {
@@ -18,7 +19,10 @@
                     "id": "ID",
                     "mqtt_id": "MQTT id",
                     "scan_interval": "Scan interval (sec), 0 - don't update",
-                    "port_to_scan": "Port to poll aliveness (needed only if no sensors used)"
+                    "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
+                    "nports": "Number of ports",
+                    "update_all": "Update all outs when input",
+                    "mqtt_inputs": "Use MQTT"
                 }
             }
         }
@@ -29,7 +33,9 @@
                 "data": {
                   "scan_interval": "Scan interval (sec), 0 - don't update",
                   "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
-                  "reload": "Reload objects"
+                  "reload": "Reload objects",
+                  "mqtt_inputs": "Use MQTT",
+                  "update_all": "Update all outs when input"
                 }
             }
         }

custom_components/mega/translations/ru.json

@@ -18,7 +18,10 @@
                     "id": "ID",
                     "mqtt_id": "MQTT id",
                     "scan_interval": "Периодичность обновлений (сек.), 0 - не обновлять",
-                    "port_to_scan": "Порт, который сканируется когда нет датчиков"
+                    "port_to_scan": "Порт, который сканируется когда нет датчиков",
+                    "mqtt_inputs": "Использовать MQTT",
+                    "nports": "Кол-во портов",
+                    "update_all": "Обновить все выходы когда срабатывает вход"
                 }
             }
         }
@@ -30,7 +33,10 @@
                   "scan_interval": "Периодичность обновлений (сек.), 0 - не обновлять",
                   "port_to_scan": "Порт, который сканируется когда нет датчиков",
                   "reload": "Обновить объекты",
-                  "invert": "Список портов (через ,) с инвертированной логикой"
+                  "invert": "Список портов (через ,) с инвертированной логикой",
+                  "mqtt_inputs": "Использовать MQTT",
+                    "nports": "Кол-во портов",
+                    "update_all": "Обновить все выходы когда срабатывает вход"
                 }
             }
         }

readme.md

@@ -8,19 +8,12 @@
   `light`, для шим - `light` с поддержкой яркости, для цифровых входов `binary_sensor`, для датчиков
   `sensor`)
 - Возможность работы с несколькими megad
-- Обратная связь по mqtt
+- Обратная связь по mqtt или http (на выбор)
 - События на двойные/долгие нажатия
 - Команды выполняются друг за другом без конкурентного доступа к ресурсам megad, это дает гарантии надежного исполнения
   большого кол-ва команд (например в сценах). Каждая следующая команда отправляется только после получения ответа о
   выполнении предыдущей.
 
-## Зависимости
-**Важно!!** Перед использованием необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
-в HomeAssistant
-
-Для максимальной совместимости необходимо обновить ваш контроллер до последней версии, тк были важные обновления в части
-mqtt
-
 ## Установка
 Рекомендованный способ с поддержкой обновлений - [HACS](https://hacs.xyz/docs/installation/installation):
 
@@ -65,23 +58,87 @@ mega:
       unit_of_measurement: "°C" # если датчик один, то просто строчкой
 ```
 
-## События
+## Зависимости
-`binary_sensor` срабатывает когда цифровой выход принимает значение 'ON', вместе с этим
+Для совместимости c mqtt необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
-он сохраняет полученные параметры от меги в аттрибутах. Атрибутами можно пользоваться так:
+в HomeAssistant, а так же обновить ваш контроллер до последней версии, тк были важные обновления в части mqtt
+
+## HTTP in
+Начиная с версии `0.3.1` интеграция стала поддерживать обратную связь без mqtt, используя http-сервер. Для этого в настройках
+интеграции необходимо снять галку с `использовать mqtt`
+
+В самой меге необходимо прописать настройки:
+```yaml
+srv: "192.168.1.4:8123" # ip:port вашего HA
+script: "mega" # это api интеграции, к которому будет обращаться контроллер
+```
+
+Входы будут доступны как binary_sensor, а так же в виде событий `mega.sensor`.
+События можно обрабатывать так:
 ```yaml
 - alias: some double click
   trigger:
-    - platform: state
+    - platform: event
-      entity_id: binary_sensor.mega_1
+      event_type: mega.sensor
-      attribute: cnt
+      event_data:
-      to: 2
+        pt: 1
   action:
     - service: light.toggle
       entity_id: light.some_light
 ```
-Однако, особенность state-триггера в атоматизациях HA в том, что он срабатывает только когда state меняется. Это может 
+Для binary_sensor имеет смысл использовать режим P&R, для остальных режимов - лучше пользоваться событиями.
-мешать, тк если вы повторно совершите двойной клик, стейт уже не поменяется, поэтому рекомендуется
+
-пользоваться event-триггером.
+## Ответ на входящие события от контроллера
+Контроллер ожидает ответ от сервера, который может быть сценарием (по умолчанию интеграция отвечает `d`, что означает 
+запустить то что прописано в поле act в настройках порта).
+
+Поддерживаеются шаблоны HA. Это может быть использовано, например, для запоминания яркости (тк сам контроллер этого не 
+умеет). В шаблоне можно использовать параметры, которые передает контроллер (m, click, pt, value)
+
+Примеры:
+```yaml
+mega:
+  mega1: # id меги, который вы сами придумываете в конфиге в UI
+    4: # номер порта, с которого ожидаются события
+      response_template: 5:2 # простейший пример без шаблона. Каждый раз когда будет приходить сообщение на этот порт, 
+                             # будем менять состояние на противоположное
+    5:
+      # пример с использованием шаблона, порт 1 будет выключен если он сейчас включен и включен с последней сохраненной 
+      # яркостью если он сейчас выключен     
+      response_template: >-
+        {% if is_state('light.some_port_1', 'on') %}
+        1:0
+        {% else %}
+        1:{{state_attr('light.some_port_1', 'brightness')}}
+        {% endif %}
+    6:
+      # в шаблон так же передаются все параметры, которые передает контроллер (pt, cnt, m, click)
+      # эти параметры можно использовать в условиях или непосредственно в шаблоне в виде {{pt}}
+      response_template: >-
+        {% if m==2 %}1:0{% else %}d{% endif %}
+    
+```
+## Отладка ответов
+Для отладки ответов сервера можно самим имитировать запросы контроллера, если у вас есть доступ к консоли
+HA:
+```shell
+curl -v -X GET 'http://localhost:8123/mega?pt=5&m=1'
+```
+Если доступа нет, нужно в файл конфигурации добавить ip компьюетра, с которого вы хотите делать запросы, например:
+```yaml
+mega:
+  allow_hosts:
+    - 192.168.1.1
+```
+И тогда можно с локальной машины делать запросы на ваш сервер HA:
+```shell
+curl -v -X GET 'http://192.168.88.1.4:8123/mega?pt=5&m=1'
+```
+В ответ будет приходить либо `d`, либо скрипт, который вы настроили
+
+
+## События
+`binary_sensor` срабатывает когда цифровой выход принимает значение 'ON'. `binary_sensor` имеет смысл использовать
+только с режимом входа P&R
 
 При каждом срабатывании `binary_sensor` так же сообщает о событии типа `mega.sensor`.
 События можно использовать в автоматизациях, например так:
@@ -91,7 +148,7 @@ mega:
     - platform: event
       event_type: mega.sensor
       event_data:
-        entity_id: binary_sensor.mega_1
+        pt: 1
         cnt: 2
   action:
     - service: light.toggle