aswitch.py: fix bug where Delay_ms spawned needless coros.

Author: peterhinch

DRIVERS.md

@@ -156,6 +156,9 @@ loop = asyncio.get_event_loop()
 loop.run_until_complete(my_app())  # Run main application code
 ```
 
+An alternative Pushbutton class with lower RAM usage is available
+[here](https://github.com/kevinkk525/pysmartnode/blob/dev/pysmartnode/utils/abutton.py).
+
 ### 3.2.1 The suppress constructor argument
 
 When the button is pressed `press_func` runs immediately. This minimal latency
@@ -207,12 +210,18 @@ Methods:
 
  1. `trigger` optional argument `duration=0`. A timeout will occur after
  `duration` ms unless retriggered. If no arg is passed the period will be that
- of the `duration` passed to the constructor.
+ of the `duration` passed to the constructor. See Class variable below.
  2. `stop` No argument. Cancels the timeout, setting the `running` status
  `False`. The timer can be restarted by issuing `trigger` again.
  3. `running` No argument. Returns the running status of the object.
  4. `__call__` Alias for running.
 
+Class variable:
+
+ 1. `verbose=False` If `True` a warning will be printed if a running timer is
+ retriggered with a time value shorter than the time currently outstanding.
+ Such an operation has no effect owing to the design of `uasyncio`.
+
 If the `trigger` method is to be called from an interrupt service routine the
 `can_alloc` constructor arg should be `False`. This causes the delay object
 to use a slightly less efficient mode which avoids RAM allocation when
@@ -229,7 +238,7 @@ import uasyncio as asyncio
 from aswitch import Pushbutton, Delay_ms
 
 async def my_app():
-    await asyncio.sleep(60)  # Dummy
+    await asyncio.sleep(60)  # Run for 1 minute
 
 pin = Pin('X1', Pin.IN, Pin.PULL_UP)  # Pushbutton to gnd
 red = LED(1)

astests.py

@@ -13,7 +13,16 @@
 Test using switch or pushbutton between X1 and gnd.
 Ground pin X2 to terminate test.
 Soft reset (ctrl-D) after each test.
+
+'''
+tests = '''
+Available tests:
+test_sw Switch test
+test_swcb Switch with callback
+test_btn Pushutton launching coros
+test_btncb Pushbutton launching callbacks
 '''
+print(tests)
 
 # Pulse an LED (coroutine)
 async def pulse(led, ms):
@@ -33,8 +42,13 @@ async def killer():
 
 # Test for the Switch class passing coros
 def test_sw():
+    s = '''
+close pulses green
+open pulses red
+'''
     print('Test of switch scheduling coroutines.')
     print(helptext)
+    print(s)
     pin = Pin('X1', Pin.IN, Pin.PULL_UP)
     red = LED(1)
     green = LED(2)
@@ -47,8 +61,13 @@ def test_sw():
 
 # Test for the switch class with a callback
 def test_swcb():
+    s = '''
+close toggles red
+open toggles green
+'''
     print('Test of switch executing callbacks.')
     print(helptext)
+    print(s)
     pin = Pin('X1', Pin.IN, Pin.PULL_UP)
     red = LED(1)
     green = LED(2)
@@ -62,8 +81,15 @@ def test_swcb():
 # Test for the Pushbutton class (coroutines)
 # Pass True to test suppress
 def test_btn(suppress=False, lf=True, df=True):
+    s = '''
+press pulses red
+release pulses green
+double click pulses yellow
+long press pulses blue
+'''
     print('Test of pushbutton scheduling coroutines.')
     print(helptext)
+    print(s)
     pin = Pin('X1', Pin.IN, Pin.PULL_UP)
     red = LED(1)
     green = LED(2)
@@ -83,8 +109,15 @@ def test_btn(suppress=False, lf=True, df=True):
 
 # Test for the Pushbutton class (callbacks)
 def test_btncb():
+    s = '''
+press toggles red
+release toggles green
+double click toggles yellow
+long press toggles blue
+'''
     print('Test of pushbutton executing callbacks.')
     print(helptext)
+    print(s)
     pin = Pin('X1', Pin.IN, Pin.PULL_UP)
     red = LED(1)
     green = LED(2)

aswitch.py

@@ -46,53 +46,63 @@ def launch(func, tup_args):
         loop.create_task(res)
 
 
-class Delay_ms(object):
+class Delay_ms:
+    verbose = False
     def __init__(self, func=None, args=(), can_alloc=True, duration=1000):
         self.func = func
         self.args = args
         self.can_alloc = can_alloc
         self.duration = duration  # Default duration
-        self.tstop = None  # Not running
+        self._tstop = None  # Killer not running
+        self._running = False  # Timer not running
         self.loop = asyncio.get_event_loop()
         if not can_alloc:
             self.loop.create_task(self._run())
 
     async def _run(self):
         while True:
-            if self.tstop is None:  # Not running
+            if not self._running:  # timer not running
                 await asyncio.sleep_ms(0)
             else:
-                await self.killer()
+                await self._killer()
 
     def stop(self):
-        self.tstop = None
+        self._running = False
+        # If uasyncio is ever fixed we should cancel .killer
 
     def trigger(self, duration=0):  # Update end time
+        self._running = True
         if duration <= 0:
             duration = self.duration
-        if self.can_alloc and self.tstop is None:  # No killer task is running
-            self.tstop = time.ticks_add(time.ticks_ms(), duration)
-            # Start a task which stops the delay after its period has elapsed
-            self.loop.create_task(self.killer())
-        self.tstop = time.ticks_add(time.ticks_ms(), duration)
+        tn = time.ticks_add(time.ticks_ms(), duration)  # new end time
+        self.verbose and self._tstop is not None and self._tstop > tn \
+            and print("Warning: can't reduce Delay_ms time.")
+        # Start killer if can allocate and killer is not running
+        sk = self.can_alloc and self._tstop is None
+        # The following indicates ._killer is running: it will be
+        # started either here or in ._run
+        self._tstop = tn
+        if sk:  # ._killer stops the delay when its period has elapsed
+            self.loop.create_task(self._killer())
 
     def running(self):
-        return self.tstop is not None
+        return self._running
 
     __call__ = running
 
-    async def killer(self):
-        twait = time.ticks_diff(self.tstop, time.ticks_ms())
+    async def _killer(self):
+        twait = time.ticks_diff(self._tstop, time.ticks_ms())
         while twait > 0:  # Must loop here: might be retriggered
             await asyncio.sleep_ms(twait)
-            if self.tstop is None:
+            if self._tstop is None:
                 break  # Return if stop() called during wait
-            twait = time.ticks_diff(self.tstop, time.ticks_ms())
-        if self.tstop is not None and self.func is not None:
+            twait = time.ticks_diff(self._tstop, time.ticks_ms())
+        if self._running and self.func is not None:
             launch(self.func, self.args)  # Timed out: execute callback
-        self.tstop = None  # Not running
+        self._tstop = None  # killer not running
+        self._running = False  # timer is stopped
 
-class Switch(object):
+class Switch:
     debounce_ms = 50
     def __init__(self, pin):
         self.pin = pin # Should be initialised for input with pullup
@@ -127,7 +137,9 @@ async def switchcheck(self):
             # Ignore further state changes until switch has settled
             await asyncio.sleep_ms(Switch.debounce_ms)
 
-class Pushbutton(object):
+# An alternative Pushbutton solution with lower RAM use is available here
+# https://github.com/kevinkk525/pysmartnode/blob/dev/pysmartnode/utils/abutton.py
+class Pushbutton:
     debounce_ms = 50
     long_press_ms = 1000
     double_click_ms = 400