lowpower Latency is functor.

Author: peterhinch

lowpower/README.md

@@ -1,10 +1,10 @@
 # A low power usayncio adaptation
 
-Release 0.11 11th April 2019
+Release 0.12 15th April 2019
 
 API changes: low power applications must now import `rtc_time_cfg` and set its
 `enabled` flag.  
-`Latency` class: Constructor requires event loop arg.  
+`Latency` is now a functor rather than a class.  
 
 This module is specific to Pyboards including the D series.
 
@@ -129,10 +129,10 @@ try:
         raise AttributeError
 except AttributeError:
     raise OSError('This requires fast_io fork of uasyncio.')
-import rtc_time
+from rtc_time import Latency
  # Instantiate event loop with any args before running code that uses it
 loop = asyncio.get_event_loop()
-rtc_time.Latency(100)  # Define latency in ms
+Latency(100)  # Define latency in ms
 ```
 
 The `Latency` class has a continuously running loop that executes `pyb.stop`
@@ -300,7 +300,7 @@ The class is a singleton consequently there is no need to pass an instance
 around or to make it global. Once instantiated, latency may be changed by
 
 ```python
-rtc_time.Latency(t)
+Latency(t)
 ```
 
 ###### [Contents](./README.md#a-low-power-usayncio-adaptation)
@@ -321,10 +321,10 @@ try:
 except AttributeError:
     raise OSError('This requires fast_io fork of uasyncio.')
  # Do this import before configuring any pins or I/O:
-import rtc_time
+from rtc_time import Latency
  # Instantiate event loop with any args before running code that uses it:
 loop = asyncio.get_event_loop()
-lp = rtc_time.Latency(100)  # Define latency in ms
+Latency(100)  # Define latency in ms
  # Run application code
 ```
 

lowpower/lp_uart.py

@@ -17,7 +17,7 @@
         raise AttributeError
 except AttributeError:
     raise OSError('This requires fast_io fork of uasyncio.')
-import rtc_time
+from rtc_time import Latency, use_utime
 
 # Stop the test after a period
 async def killer(duration):
@@ -39,13 +39,13 @@ async def receiver(uart_in, uart_out):
         await swriter.awrite(res)
 
 def test(duration):
-    if rtc_time.use_utime:  # Not running in low power mode
+    if use_utime:  # Not running in low power mode
         pyb.LED(3).on()
     uart2 = pyb.UART(1, 115200)
     uart4 = pyb.UART(4, 9600)
     # Instantiate event loop before using it in Latency class
     loop = asyncio.get_event_loop()
-    lp = rtc_time.Latency(50)  # ms
+    lp = Latency(50)  # ms
     loop.create_task(sender(uart4))
     loop.create_task(receiver(uart4, uart2))
     loop.run_until_complete(killer(duration))

lowpower/lpdemo.py

@@ -13,7 +13,7 @@
         raise AttributeError
 except AttributeError:
     raise OSError('This requires fast_io fork of uasyncio.')
-import rtc_time
+from rtc_time import Latency
 
 class Button(aswitch.Switch):
     def __init__(self, pin):
@@ -35,7 +35,7 @@ def start(loop, leds, tims):
     running = True
     coros = []
     # Demo: assume app requires higher speed (not true in this instance)
-    rtc_time.Latency().value(50)
+    Latency(50)
     # Here you might apply power to external hardware
     for x, led in enumerate(leds):  # Create a coroutine for each LED
         coros.append(toggle(led, tims[x]))
@@ -50,7 +50,7 @@ def stop(leds, coros):
     # Remove power from external hardware
     for led in leds:
         led.off()
-    rtc_time.Latency().value(200)  # Slow down scheduler to conserve power
+    Latency(200)  # Slow down scheduler to conserve power
 
 async def monitor(loop, button):
     leds = [LED(x) for x in (1, 2, 3)]  # Create list of LED's and times

lowpower/rtc_time.py

@@ -115,23 +115,24 @@ def ticks_diff(end, start):
 
 import uasyncio as asyncio
 
-def singleton(cls):
+def functor(cls):
     instance = None
     def getinstance(*args, **kwargs):
         nonlocal instance
         if instance is None:
             instance = cls(*args, **kwargs)
-        return instance
+            return instance
+        return instance(*args, **kwargs)
     return getinstance
 
-@singleton
-class Latency():
+@functor
+class Latency:
     def __init__(self, t_ms=100):
         if use_utime:  # Not in low power mode: t_ms stays zero
             self._t_ms = 0
         else:
             if asyncio.got_event_loop():
-                self._t_ms = t_ms
+                self._t_ms = max(t_ms, 0)
                 loop = asyncio.get_event_loop()
                 loop.create_task(self._run())
             else:
@@ -145,16 +146,17 @@ def _run(self):
         while True:
             if t_ms > 0:
                 pyb.stop()
+            # Pending tasks run once, may change self._t_ms
             yield
-            if t_ms != self._t_ms:
+            if t_ms != self._t_ms:  # Has changed: update wakeup
                 t_ms = self._t_ms
                 if t_ms > 0:
                     rtc.wakeup(t_ms)
                 else:
                     rtc.wakeup(None)
 
-    def value(self, val=None):
+    def __call__(self, t_ms=None):
         v = self._t_ms
-        if val is not None:
-            self._t_ms = max(val, 0)
+        if t_ms is not None:
+            self._t_ms = max(t_ms, 0)
         return v