use the timestamp from the event to determine clicks

This avoids problems with a) clicks happening during other longer running coroutines and b) gradual loss of accuracy of `time.monotonic` over longer periods.

The implementation of keypad in Blinka does not use this field, so it will default to using the ticks library, and lose the benefit of a), but retain b). This is a requirement of the asyncio library anyway,

Author: furbrain

async_button.py

@@ -21,17 +21,19 @@
 
 * CircuitPython asyncio module:
   https://github.com/adafruit/Adafruit_CircuitPython_asyncio
+
+* CircuitPython ticks module:
+  https://github.com/adafruit/Adafruit_CircuitPython_Ticks
 """
 
-# imports
 
 __version__ = "0.0.0+auto.0"
 __repo__ = "https://github.com/furbrain/CircuitPython_async_button.git"
 
-import time
-
 import asyncio
 
+from adafruit_ticks import ticks_add, ticks_less, ticks_ms
+
 try:
     from typing import Dict, Sequence, Awaitable
 except ImportError:
@@ -92,7 +94,6 @@ async def released(self):
 
 
 class Button:
-    # pylint: disable
     """
     This object will monitor the specified pin for changes and will report
     single, double, triple and long_clicks. It creates a background `asyncio` process
@@ -191,20 +192,27 @@ async def _monitor(self):
         This is the main background task that monitors key presses and releases
         """
         evt = keypad.Event(0, False)
-        last_click_tm = -100000
-        long_click_due = None
+        now = ticks_ms()
+        long_click_due = ticks_add(now, int(self.long_click_min_duration * 1000))
+        dbl_clk_expires = ticks_add(now, -100)
         while True:
             if self.keys.events.get_into(evt):
                 if evt.pressed:
                     self._trigger(self.PRESSED)
-                    now = time.monotonic()
+                    now = getattr(
+                        evt, "timestamp", ticks_ms()
+                    )  # use now if timestamp not there
                     # print(now, self.last_click_tm, self.double_click_max_duration)
-                    if now - last_click_tm < self.double_click_max_duration:
+                    if ticks_less(now, dbl_clk_expires):
                         self._increase_clicks()
                     else:
                         self.last_click = self.SINGLE
-                    last_click_tm = now
-                    long_click_due = now + self.long_click_min_duration
+                    long_click_due = ticks_add(
+                        now, int(self.long_click_min_duration * 1000)
+                    )
+                    dbl_clk_expires = ticks_add(
+                        now, int(self.double_click_max_duration * 1000)
+                    )
                     self.pressed = True
                 else:
                     self._trigger(self.RELEASED)
@@ -216,7 +224,7 @@ async def _monitor(self):
             else:
                 if self.pressed and self.click_enabled[self.LONG]:
                     if (
-                        time.monotonic() > long_click_due
+                        ticks_less(long_click_due, ticks_ms())
                         and self.last_click != self.LONG
                     ):
                         self.last_click = self.LONG

docs/conf.py

@@ -25,7 +25,13 @@
 
 wavedrom_html_jsinline = False
 render_using_wavedrompy = True
-autodoc_mock_imports = ["microcontroller", "countio", "keypad", "asyncio"]
+autodoc_mock_imports = [
+    "microcontroller",
+    "countio",
+    "keypad",
+    "asyncio",
+    "adafruit_ticks",
+]
 
 autodoc_preserve_defaults = True
 

requirements.txt

@@ -5,3 +5,4 @@
 
 Adafruit-Blinka
 adafruit-circuitpython-asyncio
+adafruit-circuitpython-ticks

tests/test_async_button.py

@@ -11,8 +11,8 @@
 
 sys.modules["countio"] = MagicMock()
 
-# pylint: disable=wrong-import-position
-import async_button
+import async_button  # pylint: disable=wrong-import-position
+
 
 # this class sets the sleep interval in the monitor task to zero so tests finish quickly
 class FastButton(async_button.Button):
@@ -25,10 +25,8 @@ def __init__(self, pin, value_when_pressed, *, interval=0, **kwargs):
 class TestButton(IsolatedAsyncioTestCase):
     # pylint: disable=invalid-name, too-many-public-methods
     def setUp(self) -> None:
-        self.time = MagicMock()
-        self.patch1 = patch("async_button.time", new=self.time)
+        self.patch1 = patch("async_button.ticks_ms", new=self.new_ticks_ms)
         self.patch1.start()
-        self.time.monotonic.side_effect = self.new_monotonic
         self.keypad_keys = MagicMock()
         self.patch2 = patch("async_button.keypad.Keys", new=self.keypad_keys)
         self.patch2.start()
@@ -50,8 +48,8 @@ async def asyncTearDown(self) -> None:
             self.button.deinit()
             await asyncio.sleep(0)
 
-    def new_monotonic(self) -> float:
-        return self.time_count
+    def new_ticks_ms(self) -> float:
+        return int(self.time_count * 1000)
 
     def new_key_get(self, event: keypad.Event) -> bool:
         self.time_count += self.interval
@@ -256,3 +254,15 @@ async def test_wait_all(self):
             await self.button.wait(), (self.button.RELEASED, self.button.TRIPLE)
         )
         self.assertAlmostEqual(self.time_count, 1.10, delta=0.1)
+
+
+class TestButtonWithTimestamp(TestButton):
+    """
+    This one adds a timestamp to the event
+    """
+
+    def new_key_get(self, event: keypad.Event) -> bool:
+        result = super().new_key_get(event)
+        if result:
+            event.timestamp = self.new_ticks_ms()
+        return result