1st pass at Pyboard D port.

Author: peterhinch

lowpower/README.md

@@ -1,6 +1,10 @@
 # A low power usayncio adaptation
 
-Release 0.1 25th July 2018
+Release 0.11 8th April 2019
+
+API change: low power applications must now import `rtc_time_cfg` and set its
+`enabled` flag.  
+Now supports Pyboard D.
 
  1. [Introduction](./README.md#1-introduction)  
  2. [Installation](./README.md#2-installation)  
@@ -62,16 +66,17 @@ tested. Copy the file `rtc_time.py` to the device so that it is on `sys.path`.
 ## 2.1 Files
 
  * `rtc_time.py` Low power library.
+ * `rtc_time_cfg` Configuration file to enable `uasyncio` to use above.
  * `lpdemo.py` A basic application which waits for a pushbutton to be pressed
  before running. A second button press terminates it. While "off" and waiting
  very low power is consumed. A normally open pushbutton should be connected
  between `X1` and `Gnd`. This program is intended as a basic template for
  similar applications.
- * `lowpower.py` Send and receive messages on UART4, echoing received messages
- to UART2 at a different baudrate. This consumes about 1.4mA and serves to
+ * `lp_uart.py` Send and receive messages on UART4, echoing received messages
+ to UART1 at a different baudrate. This consumes about 1.4mA and serves to
  demonstrate that interrupt-driven devices operate correctly.
 
-The test program `lowpower.py` requires a link between pins X1 and X2 to enable
+The test program `lp_uart.py` requires a link between pins X1 and X2 to enable
 UART 4 to receive data via a loopback.
 
 ###### [Contents](./README.md#a-low-power-usayncio-adaptation)
@@ -112,6 +117,10 @@ To avoid the power drain caused by `select.poll` the user code must issue the
 following:
 
 ```python
+import rtc_time_cfg
+rtc_time_cfg.enabled = True  # Must be done before importing uasyncio
+
+import uasyncio as asyncio
 try:
     if asyncio.version[0] != 'fast_io':
         raise AttributeError
@@ -160,6 +169,10 @@ from a separate power source for power measurements.
 Applications can detect which timebase is in use by issuing:
 
 ```python
+import rtc_time_cfg
+rtc_time_cfg.enabled = True  # Must be done before importing uasyncio
+
+import uasyncio as asyncio
 try:
     if asyncio.version[0] != 'fast_io':
         raise AttributeError
@@ -271,6 +284,10 @@ Attention to detail is required to minimise power consumption, both in terms of
 hardware and code. The only *required* change to application code is to add
 
 ```python
+import rtc_time_cfg
+rtc_time_cfg.enabled = True  # Must be done before importing uasyncio
+
+import uasyncio as asyncio
 try:
     if asyncio.version[0] != 'fast_io':
         raise AttributeError
@@ -377,9 +394,16 @@ the design of the scheduler beyond the use of a different timebase. It does,
 however, rely on the fact that the scheduler algorithm behaves as described
 above.
 
+`rtc_time` imports `rtc_time_cfg` and quits if `rtc_time_cfg.enabled` is
+`False`. This ensures that `uasyncio` will only be affected by the `rtc_time`
+module if `rtc_time` has specifically been enabled by application code.
+
 The `rtc_time` module ensures that `uasyncio` uses `utime` for timing if the
 module is present in the path but is unused. This can occur because of an
-active USB connection or if running on an an incompatible platform. This
-ensures that under such conditions performance is unaffected.
+active USB connection or if running on an an incompatible platform.
+
+The above precautions ensures that application behaviour and performance are
+unaffected unless `rtc_time` has been enabled, a USB connection is absent, and
+the hardware is a Pyboard 1.x or Pyboard D.
 
 ###### [Contents](./README.md#a-low-power-usayncio-adaptation)

lowpower/lowpower.py renamed to lowpower/lp_uart.py

@@ -1,13 +1,16 @@
-# lowpower.py Demo of using uasyncio to reduce Pyboard power consumption
+# lp_uart.py Demo of using uasyncio to reduce Pyboard power consumption
 # Author: Peter Hinch
 # Copyright Peter Hinch 2018 Released under the MIT license
 
-# The file rtc_time.py must be on the path.
+# The files rtc_time.py and rtc_time_cfg.py must be on the path.
 # Requires a link between X1 and X2.
-# Periodically sends a line on UART4 at 115200 baud.
-# This is received on UART4 and re-sent on UART2 (pin X3) at 9600 baud.
+# Periodically sends a line on UART4 at 9600 baud.
+# This is received on UART4 and re-sent on UART1 (pin Y1) at 115200 baud.
 
 import pyb
+import rtc_time_cfg
+rtc_time_cfg.enabled = True  # Must be done before importing uasyncio
+
 import uasyncio as asyncio
 try:
     if asyncio.version != 'fast_io':
@@ -38,8 +41,8 @@ async def receiver(uart_in, uart_out):
 def test(duration):
     if rtc_time.use_utime:  # Not running in low power mode
         pyb.LED(3).on()
-    uart2 = pyb.UART(2, 9600)
-    uart4 = pyb.UART(4, 115200)
+    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

lowpower/lpdemo.py

@@ -0,0 +1,75 @@
+# lpdemo.py Demo/test program for MicroPython asyncio low power operation
+# Author: Peter Hinch
+# Copyright Peter Hinch 2018-2019 Released under the MIT license
+
+import rtc_time_cfg
+rtc_time_cfg.enabled = True
+
+from pyb import LED, Pin
+import aswitch
+import uasyncio as asyncio
+try:
+    if asyncio.version[0] != 'fast_io':
+        raise AttributeError
+except AttributeError:
+    raise OSError('This requires fast_io fork of uasyncio.')
+import rtc_time
+
+class Button(aswitch.Switch):
+    def __init__(self, pin):
+        super().__init__(pin)
+        self.close_func(self._sw_close)
+        self._flag = False
+
+    def pressed(self):
+        f = self._flag
+        self._flag = False
+        return f
+
+    def _sw_close(self):
+        self._flag = True
+
+running = False
+def start(loop, leds, tims):
+    global running
+    running = True
+    coros = []
+    # Demo: assume app requires higher speed (not true in this instance)
+    rtc_time.Latency().value(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]))
+        loop.create_task(coros[-1])
+    return coros
+
+def stop(leds, coros):
+    global running
+    running = False
+    while coros:
+        asyncio.cancel(coros.pop())
+    # Remove power from external hardware
+    for led in leds:
+        led.off()
+    rtc_time.Latency().value(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
+    tims = [200, 700, 1200]
+    coros = start(loop, leds, tims)
+    while True:
+        if button.pressed():
+            if running:
+                stop(leds, coros)
+            else:
+                coros = start(loop, leds, tims)
+        await asyncio.sleep_ms(0)
+
+async def toggle(objLED, time_ms):
+    while True:
+        await asyncio.sleep_ms(time_ms)
+        objLED.toggle()
+
+loop = asyncio.get_event_loop()
+button = Button(Pin('X1', Pin.IN, Pin.PULL_UP))
+loop.create_task(monitor(loop, button))
+loop.run_forever()

lowpower/rtc_time.py

@@ -11,23 +11,28 @@
 
 import sys
 import utime
+from os import uname
+from rtc_time_cfg import enabled
+if not enabled:
+    print('rtc_time module has not been enabled.')
+    sys.exit(0)
 
 _PERIOD = const(604800000)  # ms in 7 days
 _PERIOD_2 = const(302400000)  # half period
 _SS_TO_MS = 1000/256  # Subsecs to ms
-
+d_series = uname().machine[:5] == 'PYBD_'
 use_utime = True  # Assume the normal utime timebase
+
 if sys.platform == 'pyboard':
     import pyb
     mode = pyb.usb_mode()
     if mode is None:  # USB is disabled
         use_utime = False  # use RTC timebase
     elif 'VCP' in mode:  # User has enabled VCP in boot.py
-        usb_conn = pyb.Pin.board.USB_VBUS.value()  # USB physically connected to pyb V1.x
-        if not usb_conn:
-            usb_conn = hasattr(pyb.Pin.board, 'USB_HS_DP') and pyb.Pin.board.USB_HS_DP.value()
-        if not usb_conn:
-            usb_conn = hasattr(pyb.Pin.board, 'USB_DP') and pyb.Pin.board.USB_DP.value()
+        if d_series:  # Detect an active connection to the PC
+            usb_conn = pyb.USB_VCP().isconnected()
+        else:
+            usb_conn = pyb.Pin.board.USB_VBUS.value()  # USB physically connected to pyb V1.x
         if usb_conn:
             print('USB connection: rtc_time disabled.')
         else:
@@ -38,10 +43,44 @@
 
 # For lowest power consumption set unused pins as inputs with pullups.
 # Note the 4K7 I2C pullups on X9 X10 Y9 Y10.
-for pin in [p for p in dir(pyb.Pin.board) if p[0] in 'XY']:
-    pin_x = pyb.Pin(pin, pyb.Pin.IN, pyb.Pin.PULL_UP)
+if d_series:
+    print('Running on Pyboard D')  # Investigate which pins we can do this to TODO
+else:
+    print('Running on Pyboard 1.x')
+    for pin in [p for p in dir(pyb.Pin.board) if p[0] in 'XY']:
+        pin_x = pyb.Pin(pin, pyb.Pin.IN, pyb.Pin.PULL_UP)
 # User code redefines any pins in use
 
+# sleep_ms is defined to stop things breaking if someone imports uasyncio.core
+# Power won't be saved if this is done.
+sleep_ms = utime.sleep_ms
+if use_utime:  # Run utime: Pyboard connected to PC via USB or alien platform
+    ticks_ms = utime.ticks_ms
+    ticks_add = utime.ticks_add
+    ticks_diff = utime.ticks_diff
+else:
+    rtc = pyb.RTC()
+    # dt: (year, month, day, weekday, hours, minutes, seconds, subseconds)
+    # weekday is 1-7 for Monday through Sunday.
+    if d_series:
+        # Subseconds are μs
+        def ticks_ms():
+            dt = rtc.datetime()
+            return ((dt[3] - 1)*86400000 + dt[4]*3600000 + dt[5]*60000 + dt[6]*1000 +
+                    int(dt[7] / 1000))
+    else:
+        # subseconds counts down from 255 to 0
+        def ticks_ms():
+            dt = rtc.datetime()
+            return ((dt[3] - 1)*86400000 + dt[4]*3600000 + dt[5]*60000 + dt[6]*1000 +
+                    int(_SS_TO_MS * (255 - dt[7])))
+
+    def ticks_add(a, b):
+        return (a + b) % _PERIOD
+
+    def ticks_diff(end, start):
+        return ((end - start + _PERIOD_2) % _PERIOD) - _PERIOD_2
+
 import uasyncio as asyncio
 
 # Common version has a needless dict: https://www.python.org/dev/peps/pep-0318/#examples
@@ -70,6 +109,7 @@ def __init__(self, t_ms=100):
                 raise OSError('Event loop not instantiated.')
 
     def _run(self):
+        print('Low power mode is ON.')
         rtc = pyb.RTC()
         rtc.wakeup(self._t_ms)
         t_ms = self._t_ms
@@ -88,26 +128,3 @@ def value(self, val=None):
         if val is not None and not use_utime:
             self._t_ms = max(val, 0)
         return self._t_ms
-
-# sleep_ms is defined to stop things breaking if someone imports uasyncio.core
-# Power won't be saved if this is done.
-sleep_ms = utime.sleep_ms
-if use_utime:  # Run utime: Pyboard connected to PC via USB or alien platform
-    ticks_ms = utime.ticks_ms
-    ticks_add = utime.ticks_add
-    ticks_diff = utime.ticks_diff
-else:
-    rtc = pyb.RTC()
-    # dt: (year, month, day, weekday, hours, minutes, seconds, subseconds)
-    # weekday is 1-7 for Monday through Sunday.
-    # subseconds counts down from 255 to 0
-    def ticks_ms():
-        dt = rtc.datetime()
-        return ((dt[3] - 1)*86400000 + dt[4]*3600000 + dt[5]*60000 + dt[6]*1000 +
-                int(_SS_TO_MS * (255 - dt[7])))
-
-    def ticks_add(a, b):
-        return (a + b) % _PERIOD
-
-    def ticks_diff(end, start):
-        return ((end - start + _PERIOD_2) % _PERIOD) - _PERIOD_2

lowpower/rtc_time_cfg.py

@@ -0,0 +1,2 @@
+# rtc_time_cfg.py
+enabled = False