boneIO 0.6.0dev2__py3-none-any.whl → 0.6.0dev4__py3-none-any.whl

{boneIO-0.6.0.dev2.dist-info → boneIO-0.6.0.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: boneIO
-Version: 0.6.0dev2
+Version: 0.6.0dev4
 Summary: Python App for BoneIO
 License: GNU General Public License v3.0
 Author-email: Paweł Szafer <pszafer@gmail.com>
@@ -12,7 +12,7 @@ Requires-Dist: PyYAML>=6.0
 Requires-Dist: adafruit-circuitpython-ds18x20>=1.3.12
 Requires-Dist: adafruit-circuitpython-mcp230xx>=2.5.5
 Requires-Dist: adafruit-circuitpython-mcp9808>=3.3.14
-Requires-Dist: adafruit-circuitpython-onewire>=2.0.1
+Requires-Dist: adafruit-circuitpython-onewire>=2.0.4
 Requires-Dist: adafruit-circuitpython-pca9685>=3.4.6
 Requires-Dist: adafruit-circuitpython-pct2075>=1.1.14
 Requires-Dist: asyncio-mqtt>=0.12.1

{boneIO-0.6.0.dev2.dist-info → boneIO-0.6.0.dev4.dist-info}/RECORD

@@ -1,6 +1,6 @@
 boneio/__init__.py,sha256=hoLKnu6h1uEsiCHA9Ql2MMDC7VQS0E-s_2cxBS-CTOg,147
 boneio/bonecli.py,sha256=Wg3Wc2xZ9FjF_23PK6Ja3YzXUkYanzYyQ_QdtQbKESw,3155
-boneio/const.py,sha256=9_bmHoetk6TE53KHBXjHRSBbD4gOqaUM_z8PYR1Qx2o,2908
+boneio/const.py,sha256=jowaP49OLdHOK2Bop2KDVPVKRVbqjBPHl_Fgl5aRzIg,2924
 boneio/cover.py,sha256=nr76ft5smAPdBB8Jytk-uFd6RWuqtcZiG6EE129OUjw,8454
 boneio/example_config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 boneio/example_config/adc.yaml,sha256=KaNfPuZmrhpiKJVUKC6uQXQ0YRCp0DoXVxYtqsbiSGI,168
@@ -11,13 +11,14 @@ boneio/example_config/led32x4A.yaml,sha256=YkcZ5XH2JF9Oa3pAmrYM5wsE8qQODCHcjYH47
 boneio/example_config/output24x16A.yaml,sha256=BTtHToRgz-U_rMMDbmHkM4wQxHakdzInb3zKMkOkj4w,1691
 boneio/example_config/output32x5A.yaml,sha256=G2Pb6qL8mXs6MliIM1roAanPag9ozRe3McYYuFsiBc0,2403
 boneio/fonts/danube__.ttf,sha256=KBRPUcGvmroCjrWC8zK4MulUb9lV8R0lXkOY7lNnQWc,19372
-boneio/helper/__init__.py,sha256=IRuXwAcbpV8jNJ_wuBF0rm5uFn9qP43naEmRiE8dRGs,1972
+boneio/helper/__init__.py,sha256=r-9dubCtDlrs_HFF2OGPQEPmw1XREgb4qQF6I486Li4,2039
 boneio/helper/async_updater.py,sha256=BVh5mXFxgaZqoekjQbQSCTssfyVIdCQ80LCJny-rOo4,985
+boneio/helper/click_timer.py,sha256=blWofzFIwuYcF_yFfCGDtI8nGSMpSdXdl9qMLXlKdXc,1169
 boneio/helper/config.py,sha256=XeHG7OSMCMmEL43rCbWy6Ij0RcTNlrIpevWZ0UJyrlo,1311
-boneio/helper/events.py,sha256=63FEM5bKIDmMHncJG0NLcVHJZ7gIZBEb0TP7xtfyKvs,5579
+boneio/helper/events.py,sha256=EHYJy507RF1LikWQ2s4r990JRvR9rO4z7FkaJqt1Mrk,7494
 boneio/helper/exceptions.py,sha256=Tll3ZZPOo0JZskN67hkoAxxGJ4I5ZY4IjeXtKyveziI,637
 boneio/helper/filter.py,sha256=UcjifjaC5wHDW2He7wmwCX2IjSSeLVhXyhrXHeT8RmA,885
-boneio/helper/gpio.py,sha256=Z-P76CcvFL7msoSopXooaTUi3Lx0WQYeWoRXeO64K7Y,2710
+boneio/helper/gpio.py,sha256=v4QrJfwlhIOqRCcD1SCpwPVcY6zsTlm1tens0eLbazM,2718
 boneio/helper/ha_discovery.py,sha256=e2xjArXixpbVru3oD_8L8UKMgEkpbL5OV2ybZaNi-f0,6129
 boneio/helper/loader.py,sha256=8lWjNVLcV-uqIGGgD7bY3lGEK9dhEDB0wQppxFb_Vys,13488
 boneio/helper/logger.py,sha256=zyF_Vk3o2eSHuXypJhNzK99eZgkWDWybuB5KcJgurDs,1801
@@ -32,10 +33,10 @@ boneio/helper/state_manager.py,sha256=LsMQRrD7WXu5jXFoltYXvzHDeiNDDEx6UWYebFw18g
 boneio/helper/stats.py,sha256=eLz3-g6cyaClZ7N1YVEuKVg-P6MAhuKX8D-cm5Nj-k8,5693
 boneio/helper/timeperiod.py,sha256=xpg9oe30Z5WiLDQPq3EBKKScejOnN47NhcpeFvDd3bY,5806
 boneio/helper/util.py,sha256=QfSoT3H3WnOQAKO5bFRIBCy62HT5NMa9Ek-FmfTW_rw,508
-boneio/helper/yaml_util.py,sha256=3VL0KMh9mRZ2O-6iO8xoMx46IaQ8xV1AAFt2RRktKFM,11304
+boneio/helper/yaml_util.py,sha256=gAX7hCaHUlPgkhGCIQ4zjv0Vj9JmLzQsSyF51ZmSb9g,11304
 boneio/input/__init__.py,sha256=u9wuehuC_TNizL4tyn7EygZW5LaTFjSnFaZeZr3zZ1U,99
-boneio/input/gpio.py,sha256=2WK3DR3kGAxHvmsNHZhN-oq8dF75oROxwm_mOZzYYh8,4391
-boneio/manager.py,sha256=vg4Kzxj8F_Kz2SujBPn2-OyGENPmSSLqrkdc3BUK_sU,20179
+boneio/input/gpio.py,sha256=oCJNJ7FYvznsNt2xwtmEGMOOeXCJj-3Ssh-xMYVXOfQ,2583
+boneio/manager.py,sha256=D_VT_VpGAZo3CVjoxDecYPlQwIbdEA-2rkABXUIDxW4,20273
 boneio/modbus.py,sha256=eA_sGnmdcIneXX75ZcXOI223-UkKN1UYmWFqiJBAhJo,4176
 boneio/mqtt_client.py,sha256=ioOBEmnbjpZjYrD5u8W5CrVsrNFRHDJ93fyk6XcWkeE,6983
 boneio/oled.py,sha256=d_ofDQHc7zr3j0qOR0B_L3C8TJhvRH85nnb9Le-88nk,5244
@@ -45,7 +46,7 @@ boneio/relay/gpio.py,sha256=s64FBf6zlxciF57xJ6nrvy0t5Rie0uiXlwos0HL3RKM,1163
 boneio/relay/mcp.py,sha256=DhgqZbFHB6TucL9hJaJiqdVAbkw4Rv5VPHm_khSBIFo,2669
 boneio/relay/pca.py,sha256=tCwXvMJcsxzFj48ZO2tPYyvElZfyIRTFmEMp7ENKvtk,4873
 boneio/runner.py,sha256=geT_ps_vo1SLoBszmhtcpkzk_LwWpG8OZYgUcQg3nKU,2287
-boneio/schema/actions.yaml,sha256=0QJlzZGVj4yyv1LMr1p7mc2oy58XscCPahuwcPTs8P8,1009
+boneio/schema/actions.yaml,sha256=WD0LR9SxVPgwU12x10RvFaTeyDiCjdRiicfkrCGLNvc,1030
 boneio/schema/actions_sensor.yaml,sha256=LhXEsYsg6qs7iHqgQE6n-2jj-o-ZZRusDW_9nWIiZAY,129
 boneio/schema/actions_switch.yaml,sha256=qyooX0izkgl4wBEh8xUsYFEKMrvhbIAQYxOGTB5AROY,124
 boneio/schema/filters.yaml,sha256=WopX1SmCZsSZXNiGccLoi7uMCsUpdbs0eVfsAjmbay4,286
@@ -65,12 +66,12 @@ boneio/sensor/modbus/sdm120.json,sha256=4sueFfSw7G6a77gdIUhbfJvE-MNVJFOeVbRvHDw5
 boneio/sensor/modbus/sdm630.json,sha256=6LbIfXWk_PVRW-OuJwrsFEnRGLVEmEqqGIbj-1FDaiI,10969
 boneio/sensor/modbus/sofar.json,sha256=A_YztQN_ctyItIm2LH1tfcs-pSyG18I530qleLd2tOw,5592
 boneio/sensor/temp/__init__.py,sha256=h5rGbkC8K6y2GJSNHtm9f8EmoBS3wFlSNIFjcrRj470,1659
-boneio/sensor/temp/dallas.py,sha256=LqGjH5qCSOMZO7N4PmLRjvoZvtBWmXSUBdIIYzvhvMM,2355
+boneio/sensor/temp/dallas.py,sha256=xrvd1LNBh1fRcjz_yd_9S29Lv26ItVtLCmhZgVQWJos,2485
 boneio/sensor/temp/lm75.py,sha256=-mpOv78429plRPBp9s09Ljz1x2Bdxuagalqz40vlAKE,243
 boneio/sensor/temp/mcp9808.py,sha256=yAh5yJzZLGTqa39xV4fyqsruj7oy3niOZAUV2W6eyCM,271
-boneio/version.py,sha256=n0K_D5qFEGdPK43G_weoquIzwPuwhNbYwDFFsFbj0js,41
-boneIO-0.6.0.dev2.dist-info/entry_points.txt,sha256=Igl1SMDEWwMg144bwRz28UOCb80hdxomC99QJ3u6qC0,46
-boneIO-0.6.0.dev2.dist-info/WHEEL,sha256=_LDBqpgIVFNHZvvFOGbg2pvJOENq6RHAyT5px-HeX0U,87
-boneIO-0.6.0.dev2.dist-info/METADATA,sha256=-vGHlXwsVkb7Bb2cWkcLJimskk3pt5QugjOMP8pBljY,1696
-boneIO-0.6.0.dev2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-boneIO-0.6.0.dev2.dist-info/RECORD,,
+boneio/version.py,sha256=c4Y90PQyvZ4QIDtX6BiDOphICDX-64mrmDrLk75FXoU,41
+boneIO-0.6.0.dev4.dist-info/entry_points.txt,sha256=Igl1SMDEWwMg144bwRz28UOCb80hdxomC99QJ3u6qC0,46
+boneIO-0.6.0.dev4.dist-info/WHEEL,sha256=lsei1NEk3eJVaxXEuOSSqU002B_yCocFbsEPxBs2x2s,87
+boneIO-0.6.0.dev4.dist-info/METADATA,sha256=S4FUlkbD_kjqB7DboCk17eVjdIYKWoLk_8aSxXLVvTI,1696
+boneIO-0.6.0.dev4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+boneIO-0.6.0.dev4.dist-info/RECORD,,

{boneIO-0.6.0.dev2.dist-info → boneIO-0.6.0.dev4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-pep517 1.0.6
+Generator: pdm-pep517 1.1.3
 Root-Is-Purelib: True
 Tag: py3-none-any

boneio/const.py

@@ -18,6 +18,7 @@ RELAY = "relay"
 LED = "led"
 ON = "ON"
 OFF = "OFF"
+TOGGLE = "TOGGLE"
 STATE = "state"
 BRIGHTNESS = "brightness"
 SET_BRIGHTNESS = "set_brightness"
@@ -55,7 +56,7 @@ UARTS = {
     "uart5": {ID: "/dev/ttyS5", TX: "P8.37", RX: "P8.38"},
 }
 
-relay_actions = {ON: "turn_on", OFF: "turn_off", "TOGGLE": "toggle"}
+relay_actions = {ON: "turn_on", OFF: "turn_off", TOGGLE: "toggle"}
 
 # HA CONSTS
 HOMEASSISTANT = "homeassistant"

boneio/helper/__init__.py

@@ -1,6 +1,7 @@
 """Helper dir for BoneIO."""
 
 from boneio.helper.exceptions import GPIOInputException, GPIOOutputException, I2CError
+from boneio.helper.click_timer import ClickTimer
 from boneio.helper.gpio import (
     GpioBaseClass,
     configure_pin,
@@ -70,4 +71,5 @@ __all__ = [
     "TimePeriod",
     "callback",
     "is_callback",
+    "ClickTimer",
 ]

boneio/helper/click_timer.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+import asyncio
+from boneio.helper.events import async_call_later_miliseconds
+
+
+class ClickTimer:
+    """Represent async call later function with variable to check if timing is ON."""
+
+    def __init__(self, delay: float, action) -> None:
+        """Initialize Click timer."""
+        self._loop = asyncio.get_running_loop()
+        self._remove_listener = None
+        self._delay = delay
+        self._action = action
+
+    def is_waiting(self) -> bool:
+        """If variable is set then timer is ON, if None is Off."""
+        return self._remove_listener is not None
+
+    def action(self, x: float) -> None:
+        """Reset Call later variable and call action."""
+        self.reset()
+        self._action(x)
+
+    def reset(self) -> None:
+        """Uninitialize variable remove_listener."""
+        if self._remove_listener:
+            self._remove_listener()
+            self._remove_listener = None
+
+    def start_timer(self) -> None:
+        """Start timer."""
+        self._remove_listener = async_call_later_miliseconds(
+            loop=self._loop,
+            action=self.action,
+            delay=self._delay,
+        )

boneio/helper/events.py

@@ -21,7 +21,9 @@ def utcnow() -> dt.datetime:
 time_tracker_utcnow = utcnow
 
 
-def _async_create_timer(loop: asyncio.AbstractEventLoop, event_callback) -> None:
+def _async_create_timer(
+    loop: asyncio.AbstractEventLoop, event_callback
+) -> CALLBACK_TYPE:
     """Create a timer that will start on BoneIO start."""
     handle = None
 
@@ -149,6 +151,7 @@ def async_track_point_in_time(
     """Add a listener that fires once after a specific point in UTC time."""
     # Ensure point_in_time is UTC
     utc_point_in_time = as_utc(point_in_time)
+    expected_fire_timestamp = utc_point_in_time.timestamp()
 
     # Since this is called once, we accept a so we can avoid
     # having to figure out how to call the action every time its called.
@@ -159,14 +162,12 @@ def async_track_point_in_time(
         """Call the action."""
         nonlocal cancel_callback
 
-        now = time_tracker_utcnow()
-
         # Depending on the available clock support (including timer hardware
         # and the OS kernel) it can happen that we fire a little bit too early
         # as measured by utcnow(). That is bad when callbacks have assumptions
         # about the current time. Thus, we rearm the timer for the remaining
         # time.
-        delta = (utc_point_in_time - now).total_seconds()
+        delta = expected_fire_timestamp - time.time()
         if delta > 0:
             _LOGGER.debug("Called %f seconds too early, rearming", delta)
 
@@ -175,7 +176,52 @@ def async_track_point_in_time(
 
         loop.call_soon(job, utc_point_in_time)
 
-    delta = utc_point_in_time.timestamp() - time.time()
+    delta = expected_fire_timestamp - time.time()
+    cancel_callback = loop.call_later(delta, run_action, action)
+
+    @callback
+    def unsub_point_in_time_listener() -> None:
+        """Cancel the call_later."""
+        assert cancel_callback is not None
+        cancel_callback.cancel()
+
+    return unsub_point_in_time_listener
+
+
+@callback
+def async_track_point_in_timestamp(
+    loop: asyncio.AbstractEventLoop,
+    action,
+    timestamp: float,
+) -> CALLBACK_TYPE:
+    """Add a listener that fires once after a specific point in UTC time."""
+    # Since this is called once, we accept a so we can avoid
+    # having to figure out how to call the action every time its called.
+    cancel_callback: Optional[asyncio.TimerHandle] = None
+
+    @callback
+    def run_action(job) -> None:
+        """Call the action."""
+        nonlocal cancel_callback
+
+        now = time.time()
+
+        # Depending on the available clock support (including timer hardware
+        # and the OS kernel) it can happen that we fire a little bit too early
+        # as measured by utcnow(). That is bad when callbacks have assumptions
+        # about the current time. Thus, we rearm the timer for the remaining
+        # time.
+        delta = timestamp - now
+        if delta > 0:
+            _LOGGER.debug("Called %f seconds too early, rearming", delta)
+
+            cancel_callback = loop.call_later(delta, run_action, job)
+            return
+
+        loop.call_soon(job, timestamp)
+
+    now = time.time()
+    delta = timestamp - now
     cancel_callback = loop.call_later(delta, run_action, action)
 
     @callback
@@ -185,3 +231,17 @@ def async_track_point_in_time(
         cancel_callback.cancel()
 
     return unsub_point_in_time_listener
+
+
+@callback
+def async_call_later_miliseconds(
+    loop: asyncio.AbstractEventLoop,
+    action,
+    delay: float,
+) -> CALLBACK_TYPE:
+    """Add a listener that fires once after a specific point in UTC time."""
+    # Ensure point_in_time is UTC
+    expected_fire_timestamp = time.time() + (delay / 1000)
+    return async_track_point_in_timestamp(
+        loop=loop, action=action, timestamp=expected_fire_timestamp
+    )

boneio/helper/gpio.py

@@ -67,7 +67,7 @@ def write_output(pin: str, value: str) -> None:
     GPIO.output(pin, value)
 
 
-def read_input(pin: str, on_state: Gpio_States = LOW) -> None:
+def read_input(pin: str, on_state: Gpio_States = LOW) -> bool:
     """Read a value from a GPIO."""
     return GPIO.input(pin) is on_state
 
@@ -97,6 +97,6 @@ class GpioBaseClass:
         setup_input(pin=self._pin, pull_mode=gpio_mode)
 
     @property
-    def is_pressed(self):
+    def is_pressed(self) -> bool:
         """Is button pressed."""
         return read_input(self._pin)

boneio/helper/yaml_util.py

@@ -8,7 +8,7 @@ from typing import Any, Tuple
 from cerberus import TypeDefinition, Validator
 from yaml import MarkedYAMLError, SafeLoader, YAMLError, load
 
-from boneio.const import COVER, ID, OUTPUT
+from boneio.const import COVER, ID, OUTPUT, TOGGLE
 from boneio.helper.exceptions import ConfigurationException
 from boneio.helper.timeperiod import TimePeriod
 
@@ -103,9 +103,7 @@ BoneIOLoader.add_constructor(
 BoneIOLoader.add_constructor(
     "!include_dir_merge_named", BoneIOLoader.construct_include_dir_merge_named
 )
-BoneIOLoader.add_constructor(
-    "!include_files", BoneIOLoader.construct_include_files
-)
+BoneIOLoader.add_constructor("!include_files", BoneIOLoader.construct_include_files)
 
 
 def filter_yaml_files(files):
@@ -246,7 +244,7 @@ class CustomValidator(Validator):
         return str(value).upper()
 
     def _normalize_coerce_actions_output(self, value):
-        return str(value).lower()
+        return str(value).upper()
 
     def _normalize_coerce_str(self, value):
         return str(value)
@@ -324,4 +322,4 @@ class CustomValidator(Validator):
 
         parent = get_parent()
         if parent["action"] == COVER:
-            return "toggle"
+            return TOGGLE

boneio/input/gpio.py

@@ -1,16 +1,18 @@
 """GPIOInputButton to receive signals."""
+from __future__ import annotations
 import logging
-from datetime import datetime, timedelta
+import asyncio
+from datetime import timedelta
 from functools import partial
+from boneio.const import DOUBLE, LONG, SINGLE, ClickTypes
+from boneio.helper import GpioBaseClass, ClickTimer
 
-from boneio.const import DOUBLE, LONG, SINGLE
-from boneio.helper import GpioBaseClass, edge_detect
 
 # TIMINGS FOR BUTTONS
+
 DEBOUNCE_DURATION = timedelta(microseconds=150000)
-LONG_PRESS_DURATION = timedelta(microseconds=700000)
-DELAY_DURATION = 0.08
-SECOND_DELAY_DURATION = 0.14
+DOUBLE_CLICK_DURATION_MS = 350
+LONG_PRESS_DURATION_MS = 700
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -21,103 +23,53 @@ class GpioInputButton(GpioBaseClass):
     def __init__(self, **kwargs) -> None:
         """Setup GPIO Input Button"""
         super().__init__(**kwargs)
-        edge_detect(
-            self._pin,
-            callback=self._handle_press,
-            bounce=self._bounce_time.total_milliseconds,
-        )
-        self._first_press_timestamp = None
-        self._is_long_press = False
-        self._second_press_timestamp = None
-        self._second_check = False
+        self._state = self.is_pressed
         _LOGGER.debug("Configured listening for input pin %s", self._pin)
+        self._timer_double = ClickTimer(
+            delay=DOUBLE_CLICK_DURATION_MS,
+            action=lambda x: self.double_click_press_callback(),
+        )
+        self._timer_long = ClickTimer(
+            delay=LONG_PRESS_DURATION_MS,
+            action=lambda x: self.press_callback(click_type=LONG),
+        )
+        self._double_click_ran = False
+        self._is_waiting_for_second_click = False
+        self._long_press_ran = False
+        asyncio.create_task(self._run())
 
-    def _handle_press(self, pin: str) -> None:
-        """Handle the button press callback"""
-        # Ignore if we are in a long press
-        if self._is_long_press:
-            return
-        now = datetime.now()
-
-        # Debounce button
-        if (
-            self._first_press_timestamp is not None
-            and now - self._first_press_timestamp < DEBOUNCE_DURATION
-        ):
-            return
-
-        # Second click debounce. Just in case.
-        if (
-            self._second_press_timestamp is not None
-            and now - self._second_press_timestamp < DEBOUNCE_DURATION
-        ):
-            return
-        if not self._first_press_timestamp:
-            self._first_press_timestamp = now
-        elif not self._second_press_timestamp:
-            self._second_press_timestamp = now
-
+    def press_callback(self, click_type: ClickTypes):
         self._loop.call_soon_threadsafe(
-            self._loop.call_later,
-            DELAY_DURATION,
-            self.check_press_length,
+            partial(self._press_callback, click_type, self._pin)
         )
 
-    def check_press_length(self) -> None:
-        """Check if it's a single, double or long press"""
-        # Check if button is still pressed
-        if self.is_pressed:
-            # Schedule a new check
-            self._loop.call_soon_threadsafe(
-                self._loop.call_later,
-                DELAY_DURATION,
-                self.check_press_length,
-            )
+    def double_click_press_callback(self):
+        self._is_waiting_for_second_click = False
+        if not self._state and not self._timer_long.is_waiting():
+            self.press_callback(click_type=SINGLE)
 
-            # Handle edge case due to multiple clicks
-            if self._first_press_timestamp is None:
-                return
+    async def _run(self) -> None:
+        while True:
+            self.check_state(state=self.is_pressed)
+            await asyncio.sleep(self._bounce_time.total_in_seconds)
 
-            # Check if we reached a long press
-            diff = datetime.now() - self._first_press_timestamp
-            if not self._is_long_press and diff > LONG_PRESS_DURATION:
-                self._is_long_press = True
-                _LOGGER.debug("Long button press on pin %s, call callback", self._pin)
-                self._loop.call_soon_threadsafe(
-                    partial(self._press_callback, LONG, self._pin)
-                )
+    def check_state(self, state):
+        if state == self._state:
             return
-
-        # Handle short press
-        if not self._is_long_press:
-            if not self._second_press_timestamp and not self._second_check:
-                # let's try to check if second click will atempt
-                self._second_check = True
-                self._loop.call_soon_threadsafe(
-                    self._loop.call_later,
-                    SECOND_DELAY_DURATION,
-                    self.check_press_length,
-                )
-                return
-            if self._second_check:
-                if self._second_press_timestamp:
-                    _LOGGER.debug(
-                        "Double click event on pin %s, diff %s",
-                        self._pin,
-                        self._second_press_timestamp - self._first_press_timestamp,
-                    )
-                    self._loop.call_soon_threadsafe(
-                        partial(self._press_callback, DOUBLE, self._pin)
-                    )
-
-                elif self._first_press_timestamp:
-                    _LOGGER.debug("One click event on pin %s, call callback", self._pin)
-                    self._loop.call_soon_threadsafe(
-                        partial(self._press_callback, SINGLE, self._pin)
-                    )
-
-        # Clean state on button released
-        self._first_press_timestamp = None
-        self._second_press_timestamp = None
-        self._second_check = False
-        self._is_long_press = False
+        self._state = state
+        if state:
+            self._timer_long.start_timer()
+            if self._timer_double.is_waiting():
+                self._timer_double.reset()
+                self._double_click_ran = True
+                self.press_callback(click_type=DOUBLE)
+            else:
+                self._timer_double.start_timer()
+                self._is_waiting_for_second_click = True
+
+        else:
+            if not self._is_waiting_for_second_click and not self._double_click_ran:
+                if self._timer_long.is_waiting():
+                    self.press_callback(click_type=SINGLE)
+            self._timer_long.reset()
+            self._double_click_ran = False

boneio/manager.py

@@ -442,6 +442,8 @@ class Manager:
                 action = relay_actions.get(action_definition["action_output"])
                 if relay and action:
                     getattr(relay, action)()
+                else:
+                    _LOGGER.warn("PIN %s for action not found", device)
             elif action_definition[ACTION] == MQTT:
                 action_topic = action_definition.get(TOPIC)
                 action_payload = action_definition.get("action_mqtt_msg")

boneio/schema/actions.yaml

@@ -23,6 +23,8 @@ schema:
     default_setter: toggle_cover
     dependencies:
       action: ['cover']
+    coerce:
+      - actions_output
     meta:
       label: If cover action chosen then what action to perform.
   action_output:
@@ -32,7 +34,6 @@ schema:
     dependencies:
       action: ['output']
     coerce:
-      - lower
       - actions_output
     meta:
       label: If output action chosen then what action to perform.

boneio/sensor/temp/dallas.py

@@ -5,7 +5,7 @@ import logging
 from datetime import datetime
 
 from adafruit_ds18x20 import DS18X20
-from w1thermsensor import SensorNotReadyError
+from w1thermsensor import SensorNotReadyError, NoSensorFoundError
 
 from boneio.const import SENSOR, STATE, TEMPERATURE
 from boneio.helper import AsyncUpdater, BasicMqtt
@@ -74,3 +74,5 @@ class DallasSensorW1(TempSensor, AsyncUpdater):
             )
         except SensorNotReadyError as err:
             _LOGGER.error("Sensor not ready, can't update %s", err)
+        except NoSensorFoundError as err:
+            _LOGGER.error("Sensor not found, can't update %s", err)

boneio/version.py

@@ -1,2 +1,2 @@
 # flake8: noqa
-__version__ = "0.6.0dev2"
+__version__ = "0.6.0dev4"