Bump version: 1.0.10b13 → 1.0.10b14

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.0.10b3
+current_version = 1.0.10b14
 parse = (?P<major>\d+)(\.(?P<minor>\d+))(\.(?P<patch>\d+))(?P<release>[bf]*)(?P<build>\d*)
 commit = True
 tag = True

custom_components/mega/__init__.py

@@ -16,7 +16,8 @@ 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_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
+    RGB_COMBINATIONS, CONF_WS28XX, CONF_ORDER, CONF_SMOOTH, CONF_LED, CONF_WHITE_SEP, CONF_CHIP, CONF_RANGE, \
+    CONF_FILTER_VALUES, CONF_FILTER_SCALE, CONF_FILTER_LOW, CONF_FILTER_HIGH
 from .hub import MegaD
 from .config_flow import ConfigFlow
 from .http import MegaView
@@ -74,6 +75,10 @@ CUSTOMIZE_PORT = {
     vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
     vol.Optional(CONF_FORCE_I2C_SCAN): bool,
     vol.Optional(CONF_HEX_TO_FLOAT): bool,
+    vol.Optional(CONF_FILTER_VALUES): [cv.positive_float],
+    vol.Optional(CONF_FILTER_SCALE): cv.positive_float,
+    vol.Optional(CONF_FILTER_LOW): cv.positive_float,
+    vol.Optional(CONF_FILTER_HIGH): cv.positive_float,
     vol.Optional(CONF_SMOOTH): cv.time_period_seconds,
     # vol.Optional(CONF_RANGE): vol.ExactSequence([int, int]), TODO: сделать отбрасывание "плохих" значений
     vol.Optional(str): {
@@ -99,6 +104,11 @@ CONFIG_SCHEMA = vol.Schema(
     {
         DOMAIN: {
             vol.Optional(CONF_ALLOW_HOSTS): [str],
+            vol.Optional('entities'): {
+                vol.Optional(str): vol.Any(
+                CUSTOMIZE_PORT,
+                CUSTOMIZE_DS2413
+            )},
             vol.Optional(vol.Any(str, int), description='id меги из веб-интерфейса'): {
                 vol.Optional(CONF_FORCE_D, description='Принудительно слать d после срабатывания входа', default=False): bool,
                 vol.Optional(
@@ -111,6 +121,10 @@ CONFIG_SCHEMA = vol.Schema(
                     CUSTOMIZE_PORT,
                     CUSTOMIZE_DS2413,
                 ),
+                vol.Optional(CONF_FILTER_VALUES): [cv.positive_float],
+                vol.Optional(CONF_FILTER_SCALE): cv.positive_float,
+                vol.Optional(CONF_FILTER_LOW): cv.positive_float,
+                vol.Optional(CONF_FILTER_HIGH): cv.positive_float,
             }
         }
     },

custom_components/mega/binary_sensor.py

@@ -67,6 +67,7 @@ class MegaBinarySensor(BinarySensorEntity, MegaPushEntity):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
+        self.mega.binary_sensors.append(self.port)
         self._is_on = None
         self._attrs = None
         self._click_task = None

custom_components/mega/const.py

@@ -45,6 +45,10 @@ CONF_SMOOTH = 'smooth'
 CONF_WHITE_SEP = 'white_sep'
 CONF_CHIP = 'chip'
 CONF_RANGE = 'range'
+CONF_FILTER_VALUES = 'filter_values'
+CONF_FILTER_SCALE = 'filter_scale'
+CONF_FILTER_LOW = 'filter_low'
+CONF_FILTER_HIGH = 'filter_high'
 PLATFORMS = [
     "light",
     "switch",

custom_components/mega/entities.py

@@ -54,7 +54,6 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
             smooth=None,
             **kwargs,
     ):
-        super().__init__(mega.updater)
         self._smooth = smooth
         self.http_cmd = http_cmd
         self._state: State = None
@@ -85,6 +84,8 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
         self._can_smooth_hard = None
         if self.http_cmd == 'ds2413':
             self.mega.ds2413_ports |= {self.port}
+        super().__init__(coordinator=mega.updater)
+
 
     @property
     def is_ws(self):
@@ -126,15 +127,21 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
     def customize(self):
         if self._customize is not None:
             return self._customize
-        if self.hass is None:
+        if self.hass is None or self.entity_id is None:
             return {}
         if self._customize is None:
+
+            c_entity_id = self.hass.data.get(DOMAIN, {}).get(CONF_CUSTOM).get('entities', {}).get(self.entity_id, {})
+            self.lg.debug(
+                'customize %s with %s', self.entity_id, c_entity_id
+            )
             c = self.hass.data.get(DOMAIN, {}).get(CONF_CUSTOM) or {}
             c = c.get(self._mega_id) or {}
             c = c.get(self.port) or {}
             if self.addr is not None and self.index is not None and isinstance(c, dict):
                 idx = self.addr.lower() + f'_a' if self.index == 0 else '_b'
                 c = c.get(idx, {})
+            c.update(c_entity_id)
             self._customize = c
 
         return self._customize
@@ -166,9 +173,9 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
 
     @property
     def lg(self) -> logging.Logger:
-        if self._lg is None:
-            self._lg = self.mega.lg.getChild(self._name or self.unique_id)
-        return self._lg
+        # if self._lg is None:
+        #     self._lg = self.mega.lg.getChild(self._name or self.unique_id)
+        return _LOGGER
 
     @property
     def available(self) -> bool:

custom_components/mega/http.py

@@ -134,7 +134,7 @@ class MegaView(HomeAssistantView):
                         if ret == 'd' and act:
                             await hub.request(cmd=act.replace(':3', f':{v}'))
                         ret = 'd' if hub.force_d else ''
-            else:
+            elif port in hub.binary_sensors:
                 hub.values[port] = data
                 for cb in self.callbacks[hub.id][port]:
                     cb(data)
@@ -147,7 +147,7 @@ class MegaView(HomeAssistantView):
         _LOGGER.debug('response %s', ret)
         Response(body='' if hub.fake_response else ret, content_type='text/plain')
 
-        if hub.fake_response and 'value' not in data and 'pt' in data:
+        if hub.fake_response and 'value' not in data and 'pt' in data and port in hub.binary_sensors:
             if 'd' in ret:
                 await hub.request(pt=port, cmd=ret)
             else:

custom_components/mega/hub.py

@@ -164,6 +164,7 @@ class MegaD:
             hass.data[DOMAIN][CONF_HTTP].protected = protected
         except Exception:
             self.lg.exception('while setting allowed hosts')
+        self.binary_sensors = []
 
     async def start(self):
         pass
@@ -309,8 +310,8 @@ class MegaD:
                             return ret
                 except asyncio.TimeoutError:
                     self.lg.warning(f'timeout while requesting {url}')
-                    raise
-                    # await asyncio.sleep(1)
+                    # raise
+                    await asyncio.sleep(1)
             raise asyncio.TimeoutError('after 3 tries')
 
     async def save(self):
@@ -426,7 +427,7 @@ class MegaD:
     def subscribe(self, port, callback):
         port = int_ignore(port)
         self.lg.debug(
-            f'subscribe %s %s', port, callback
+            f'subscribe %s %s', port, str(callback)
         )
         self.http.callbacks[self.id][port].append(callback)
 

custom_components/mega/manifest.json

@@ -15,5 +15,5 @@
     "@andvikt"
   ],
   "issue_tracker": "https://github.com/andvikt/mega_hacs/issues",
-  "version": "v1.0.10b3"
+  "version": "v1.0.10b14"
 }

custom_components/mega/sensor.py

@@ -20,7 +20,8 @@ from homeassistant.const import (
 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, CONF_HEX_TO_FLOAT, DOMAIN, CONF_CUSTOM, CONF_SKIP
+from .const import CONF_KEY, TEMP, HUM, W1, W1BUS, CONF_CONV_TEMPLATE, CONF_HEX_TO_FLOAT, DOMAIN, CONF_CUSTOM, \
+    CONF_SKIP, CONF_FILTER_VALUES, CONF_FILTER_SCALE, CONF_FILTER_LOW, CONF_FILTER_HIGH
 from .hub import MegaD
 import re
 
@@ -93,7 +94,7 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
                 hub.skip_ports |= {port}
                 continue
             for data in cfg:
-                hub.lg.debug(f'add sensor on port %s with data %s', port, data)
+                hub.lg.debug(f'add sensor on port %s with data %s, constructor: %s', port, data, _constructors[tp])
                 sensor = _constructors[tp](
                     mega=hub,
                     port=port,
@@ -107,7 +108,51 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, asyn
     async_add_devices(devices)
 
 
-class MegaI2C(MegaPushEntity):
+class FilterBadValues(MegaPushEntity):
+
+    def __init__(self, *args, **kwargs):
+        self._prev_value = None
+        super().__init__(*args, **kwargs)
+
+    def filter_value(self, value):
+        self.lg.debug(
+            'value=%s filter_low=%s filter_high=%s filter_scale=%s prev_value=%s filter_values=%s',
+            value, self.filter_low, self.filter_high, self.filter_scale, self._prev_value, self.filter_values
+        )
+        self.lg.debug(f'{self.customize} {self.entity_id}')
+        if value \
+                in self.filter_values \
+           or (self.filter_low is not None and value < self.filter_low) \
+           or (self.filter_high is not None and value > self.filter_high) \
+           or (
+                self._prev_value is not None
+                and self.filter_scale is not None
+                and (
+                        abs(value - self._prev_value) / self._prev_value > self.filter_scale
+                )
+            ):
+            value = self._prev_value
+        self._prev_value = value
+        return value
+
+    @property
+    def filter_values(self):
+        return self.customize.get(CONF_FILTER_VALUES, self.mega.customize.get(CONF_FILTER_VALUES, []))
+
+    @property
+    def filter_scale(self):
+        return self.customize.get(CONF_FILTER_SCALE, self.mega.customize.get(CONF_FILTER_SCALE, None))
+
+    @property
+    def filter_low(self):
+        return self.customize.get(CONF_FILTER_LOW, self.mega.customize.get(CONF_FILTER_LOW, None))
+
+    @property
+    def filter_high(self):
+        return self.customize.get(CONF_FILTER_HIGH, self.mega.customize.get(CONF_FILTER_HIGH, None))
+
+
+class MegaI2C(FilterBadValues):
 
     def __init__(
             self,
@@ -126,6 +171,14 @@ class MegaI2C(MegaPushEntity):
     def customize(self):
         return super().customize.get(self.id_suffix, {}) or {}
 
+    @property
+    def extra_state_attributes(self):
+        attrs = super().extra_state_attributes or {}
+        attrs.update({
+            'i2c_id': self.id_suffix,
+        })
+        return attrs
+
     @property
     def device_class(self):
         return self._device_class
@@ -140,7 +193,7 @@ class MegaI2C(MegaPushEntity):
         ret = self.mega.values.get(self._params)
         if self.customize.get(CONF_HEX_TO_FLOAT):
             try:
-                ret = struct.unpack('!f', bytes.fromhex('41973333'))[0]
+                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))
@@ -151,6 +204,7 @@ class MegaI2C(MegaPushEntity):
                 ret = tmpl.async_render({'value': ret})
         except:
             ret = ret
+        ret = self.filter_value(ret)
         return str(ret)
 
     @property
@@ -158,7 +212,7 @@ class MegaI2C(MegaPushEntity):
         return self._device_class
 
 
-class Mega1WSensor(MegaPushEntity):
+class Mega1WSensor(FilterBadValues):
 
     def __init__(
             self,
@@ -175,11 +229,13 @@ 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._value = None
         self.key = key
+        lg.debug(f'my key: {key}')
+        self._value = None
         self._device_class = device_class
         self._unit_of_measurement = unit_of_measurement
         self.mega.sensors.append(self)
+        self.prev_value = None
 
     @property
     def unit_of_measurement(self):
@@ -198,7 +254,7 @@ class Mega1WSensor(MegaPushEntity):
         if self.key:
             return super().unique_id + f'_{self.key}'
         else:
-            return super(Mega1WSensor, self).unique_id
+            return super().unique_id
 
     @property
     def device_class(self):
@@ -215,6 +271,8 @@ class Mega1WSensor(MegaPushEntity):
     @property
     def state(self):
         ret = None
+        if not hasattr(self, 'key'):
+            return None
         if self.key:
             try:
                 ret = self.mega.values.get(self.port, {})
@@ -233,7 +291,8 @@ class Mega1WSensor(MegaPushEntity):
             ret = float(ret)
             ret = str(ret)
         except:
-            ret = None
+            self.lg.warning(f'could not convert to float "{ret}"')
+            ret = self.prev_value
         if self.customize.get(CONF_HEX_TO_FLOAT):
             try:
                 ret = struct.unpack('!f', bytes.fromhex(ret))[0]
@@ -247,6 +306,8 @@ class Mega1WSensor(MegaPushEntity):
                 ret = tmpl.async_render({'value': ret})
         except:
             pass
+        ret = self.filter_value(ret)
+        self.prev_value = ret
         return str(ret)
 
     @property
@@ -254,7 +315,10 @@ class Mega1WSensor(MegaPushEntity):
         n = super().name
         c = self.customize.get(CONF_NAME, {})
         if isinstance(c, dict):
-            c = c.get(self.key)
+            try:
+                c = c.get(self.key)
+            except AttributeError:
+                lg.debug(dir(self))
         return c or n
 
 

docs/yaml.md

@@ -159,6 +159,12 @@ some_led2:
     - **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, интеграция его распакует (перед применением темплейта)
+    - **filter_high** (float, none): верхняя граница значений, выше нее значения будут считаться ошибочными и отбрасываться. [Доступно так же глобальное значение](#filter_high)
+    - **filter_low** (float, none): нижняя граница значений, ниже нее значения будут считаться ошибочными и отбрасываться. [Доступно так же глобальное значение](#filter_low)
+    - **filter_values** ([float], none): список значений, которые считаются ошибочными. [Доступно так же глобальное значение](#filter_values)
+    - **filter_scale** (float, none): значение отклонения от текущего значения, которое будет считаться выбросом и отфильтруется, например если
+    установить 1, то это означает, что при росте показателя сенсора на 100% и больше или падении на 100% и больше, такое значение не будет отображаться.
+    [Доступно так же глобальное значение](#filter_scale)
 При этом есть так же особенности адресации, так для сенсора на одном порте с одним значением:
 ```yaml
 36:
@@ -183,10 +189,10 @@ some_led2:
     # конфиг
 ```
 #### i2c {: #i2c}
-Для сенсоров i2c адресация конфига такая:
+Для сенсоров i2c нужно так же указать id сенсора, который можно посмотреть в атрибутах объекта на [странице разработчика](https://my.home-assistant.io/redirect/developer_states/).
 ```yaml
 36:
-  htu21d_humidity:  # entity_id сенсора без приставки sensor., видно в интерфейсе HA
+  htu21d_humidity:  # i2c_id
     # конфиг
 ```
 [Подробнее про i2c](i2c.md)
@@ -213,5 +219,27 @@ mega:
 ```yaml
 mega:
   allow_hosts:
-    - 192.168.1.20 
+    - 192.168.1.20
 ```
+
+### filter_high {: #filter_high}
+Верхняя граница значений датчиков по-умолчанию, выше нее значения будут считаться ошибочными и отбрасываться
+
+### filter_low {: #filter_low}
+Нижняя граница значений датчиков по-умолчанию, ниже нее значения будут считаться ошибочными и отбрасываться
+
+### filter_values {: #filter_values }
+Список значений, которые считаются ошибочными, настройка по-умолчанию для всех датчиков. Удобно, если у вас много 
+  однотипных датчиков
+
+```yaml
+mega:
+  filter_values: [-82, - 150]
+```
+### filter_scale {: #filter_scale }
+Значение отклонения от текущего значения, которое будет считаться выбросом и отфильтруется, например если
+установить 1, то это означает, что при росте показателя сенсора на 100% и больше или падении на 100% и больше, такое значение не будет отображаться.
+```yaml
+mega:
+  filter_scale: 1  # 100%
+```