monitor: Reduce latency, adapt for future SPI option.

peterhinch · peterhinch · commit e44472579834 · 2021-09-24T14:56:01.000+01:00
diff --git a/v3/as_demos/monitor/README.md b/v3/as_demos/monitor/README.md
@@ -187,6 +187,7 @@ of 100ms - pin 28 will pulse if ident 0 is inactive for over 100ms. These
 behaviours can be modified by the following `run` args:
  1. `period=100` Define the timer period in ms.
  2. `verbose=()` Determines which `ident` values should produce console output.
+ 3. `device="uart"` Provides for future use of other interfaces.
 
 Thus to run such that idents 4 and 7 produce console output, with hogging
 reported if blocking is for more than 60ms, issue
@@ -195,7 +196,12 @@ from monitor_pico import run
 run(60, (4, 7))
 ```
 
-# 5. Design notes
+# 5. Performance and design notes
+
+The latency between a monitored coroutine starting to run and the Pico pin
+going high is about 20μs. This isn't as absurd as it sounds: theoretically the
+latency could be negative as the effect of the decorator is to send the
+character before the coroutine starts.
 
 The use of decorators is intended to ease debugging: they are readily turned on
 and off by commenting out.
@@ -213,3 +219,11 @@ which can be scheduled at a high rate, can't overflow the UART buffer. The
 
 This project was inspired by
 [this GitHub thread](https://github.com/micropython/micropython/issues/7456).
+
+# 6. Work in progress
+
+It is intended to add an option for SPI communication; `monitor.py` has a
+`set_device` method which can be passed an instance of an initialised SPI
+object. The Pico `run` method will be able to take a `device="spi"` arg which
+will expect an SPI connection on pins 0 (sck) and 1 (data). This requires a
+limited implementation of an SPI slave using the PIO, which I will do soon.
diff --git a/v3/as_demos/monitor/monitor.py b/v3/as_demos/monitor/monitor.py
@@ -7,10 +7,16 @@
 import uasyncio as asyncio
 from machine import UART
 
-uart = None
+device = None
 def set_uart(n):  # Monitored app defines interface
-    global uart
-    uart = UART(n, 1_000_000)
+    global device
+    device = UART(n, 1_000_000)
+
+# For future use with SPI
+# Pass initialised instance of some device
+def set_device(dev):
+    global device
+    device = dev
 
 _available = set(range(0, 23))  # Valid idents are 0..22
 
@@ -38,22 +44,22 @@ async def wrapped_coro(*args, **kwargs):
             instance += 1
             if instance > max_instances:
                 print(f'Monitor {n:02} max_instances reached')
-            uart.write(v)
+            device.write(v)
             try:
                 res = await coro(*args, **kwargs)
             except asyncio.CancelledError:
                 raise
             finally:
                 d |= 0x20
                 v = bytes(chr(d), 'utf8')
-                uart.write(v)
+                device.write(v)
                 instance -= 1
             return res
         return wrapped_coro
     return decorator
 
 def monitor_init():
-    uart.write(b'z')
+    device.write(b'z')
 
 # Optionally run this to show up periods of blocking behaviour
 @monitor(0)
@@ -73,9 +79,9 @@ def decorator(func):
         dend = 0x60 + n
         vend = bytes(chr(dend), 'utf8')
         def wrapped_func(*args, **kwargs):
-            uart.write(vstart)
+            device.write(vstart)
             res = func(*args, **kwargs)
-            uart.write(vend)
+            device.write(vend)
             return res
         return wrapped_func
     return decorator
@@ -92,9 +98,9 @@ def __init__(self, n):
         self.vend = bytes(chr(self.dend), 'utf8')
 
     def __enter__(self):
-        uart.write(self.vstart)
+        device.write(self.vstart)
         return self
 
     def __exit__(self, type, value, traceback):
-        uart.write(self.vend)
+        device.write(self.vend)
         return False  # Don't silence exceptions
diff --git a/v3/as_demos/monitor/monitor_pico.py b/v3/as_demos/monitor/monitor_pico.py
@@ -9,12 +9,13 @@
 # Pin goes high if use count > 0 else low.
 # incoming numbers are 0..22 which map onto 23 GPIO pins
 
-from machine import UART, Pin, Timer
+from machine import UART, Pin, Timer, freq
+
+freq(250_000_000)
 
 # Valid GPIO pins
 # GP0,1 are UART 0 so pins are 2..22, 26..27
 PIN_NOS = list(range(2,23)) + list(range(26, 28))
-uart = UART(0, 1_000_000)  # rx on GP1
 
 pin_t = Pin(28, Pin.OUT)
 def _cb(_):
@@ -30,29 +31,37 @@ def _cb(_):
 for pin_no in PIN_NOS:
     pins.append([Pin(pin_no, Pin.OUT), 0, False])
 
-def run(period=100, verbose=[]):
+# native reduced latency to 10μs but killed the hog detector: timer never timed out.
+# Also locked up Pico so ctrl-c did not interrupt.
+#@micropython.native
+def run(period=100, verbose=[], device="uart"):
     global t_ms
     t_ms = period
     for x in verbose:
         pins[x][2] = True
+    # Provide for future devices. Must support a blocking read.
+    if device == "uart":
+        uart = UART(0, 1_000_000)  # rx on GPIO 1
+        def read():
+            while not uart.any():
+                pass
+            return ord(uart.read(1))
+
     while True:
-        while not uart.any():
-            pass
-        x = ord(uart.read(1))
-        if not 0x40 <= x <= 0x7f:  # Get an initial 0
-            continue
-        if x == 0x7a:  # Init: program under test has restarted
-            for w in range(len(pins)):
-                pins[w][1] = 0
-            continue
-        if x == 0x40:
-            tim.init(period=t_ms, mode=Timer.ONE_SHOT, callback=_cb)
-        i = x & 0x1f  # Key: 0x40 (ord('@')) is pin ID 0
-        d = -1 if x & 0x20 else 1
-        pins[i][1] += d
-        if pins[i][1]:  # Count > 0 turn pin on
-            pins[i][0](1)
-        else:
-            pins[i][0](0)
-        if pins[i][2]:
-            print(f'ident {i} count {pins[i][1]}')
+        if x := read():  # Get an initial 0 on UART
+            if x == 0x7a:  # Init: program under test has restarted
+                for pin in pins:
+                    pin[1] = 0
+                continue
+            if x == 0x40:  # Retrigger hog detector.
+                tim.init(period=t_ms, mode=Timer.ONE_SHOT, callback=_cb)
+            p = pins[x & 0x1f]  # Key: 0x40 (ord('@')) is pin ID 0
+            if x & 0x20:  # Going down
+                p[1] -= 1
+                if not p[1]:  # Instance count is zero
+                    p[0](0)
+            else:
+                p[0](1)
+                p[1] += 1
+            if p[2]:
+                print(f'ident {i} count {p[1]}')
diff --git a/v3/as_demos/monitor/quick_test.py b/v3/as_demos/monitor/quick_test.py
@@ -2,12 +2,15 @@
 
 import uasyncio as asyncio
 import time
+from machine import Pin
 from monitor import monitor, monitor_init, hog_detect, set_uart
 
 set_uart(2)  # Define interface to use
 
 @monitor(1)
-async def foo(t):
+async def foo(t, pin):
+    pin(1)  # Measure latency
+    pin(0)
     await asyncio.sleep_ms(t)
 
 @monitor(2)
@@ -22,10 +25,11 @@ async def bar(t):
 
 async def main():
     monitor_init()
+    test_pin = Pin('X6', Pin.OUT)
     asyncio.create_task(hog_detect())
     asyncio.create_task(hog())  # Will hog for 500ms after 5 secs
     while True:
-        ft = asyncio.create_task(foo(100))
+        asyncio.create_task(foo(100, test_pin))
         await bar(150)
         await asyncio.sleep_ms(50)
 
