enhance examples

Works in conjunction with adafruit/circuitpython#6360

 * get rid of the need for 'filler' in morse demo
 * make neopixels work super fast without explicit byteswapping

Author: jepler

examples/pioasm_background_morse.py

@@ -17,8 +17,8 @@
 https://en.wikipedia.org/wiki/Morse_code
 """
 
-import time
 import array
+import time
 from board import LED
 from rp2pio import StateMachine
 from adafruit_pioasm import Program
@@ -62,13 +62,6 @@
 SOS = S + O + S + WORD_SPACE
 TEST = T + E + S + T + WORD_SPACE
 
-# 8 slots of the shortest possible led-off time
-# A background write is 'complete' as soon as all data has been placed
-# in the StateMachine's FIFO.  This FIFO has either 4 or 8 entries.
-# By adding 8 very short "led off" times, we can have our 'sm.writing' test
-# tell us when the actual letter data has all been
-FILLER = array.array("H", [LED_OFF | 1]) * 8
-
 sm = StateMachine(
     pio_code.assembled,
     frequency=1_000_000,
@@ -94,11 +87,11 @@
         ("TEST", TEST),
     ):
         print(f"Sending out {plain}", end="")
-        sm.background_write(morse + FILLER)
-        while sm.writing:
+        sm.background_write(morse)
+        sm.clear_txstall()
+        while not sm.txstall:
             print(end=".")
             time.sleep(0.1)
         print()
-        print("Message all sent to StateMachine")
-        time.sleep(1)
+        print("Message all sent to StateMachine (including emptying FIFO)")
         print()

examples/pioasm_neopixel_bg.py

@@ -12,14 +12,17 @@
 Python code to run, so it may be possible to slightly increase the refresh
 rate of your LEDs or do more complicated processing.
 
+Because the pixelbuf storage is also being written out 'live', it is possible
+(even with auto-show 'false') to experience tearing, where the LEDs are a
+combination of old and new values at the same time.
+
 The demonstration code, under ``if __name__ == '__main__':`` is intended
 for the Adafruit MacroPad, with 12 NeoPixel LEDs. It shows a cycling rainbow
 pattern across all the LEDs.
 """
 
 import struct
 import adafruit_pixelbuf
-from ulab import numpy as np
 from rp2pio import StateMachine
 from adafruit_pioasm import Program
 
@@ -95,28 +98,51 @@ def __init__(
             **_program.pio_kwargs,
         )
 
+        self._first = True
         super().__init__(
             n,
             brightness=brightness,
             byteorder=pixel_order,
-            auto_write=auto_write,
+            auto_write=False,
             header=header,
             trailer=trailer,
         )
 
+        self._auto_write = False
+        self._auto_writing = False
+        self.auto_write = auto_write
+
+    @property
+    def auto_write(self):
+        return self._auto_write
+
+    @auto_write.setter
+    def auto_write(self, value):
+        self._auto_write = bool(value)
+        if not value and self._auto_writing:
+            self._sm.background_write()
+            self._auto_writing = False
+        elif value:
+            self.show()
+
     def _transmit(self, buf):
-        self._sm.background_write(np.frombuffer(buf, dtype=np.uint16).byteswap())
+        if self._auto_write:
+            if not self._auto_writing:
+                self._sm.background_write(loop=memoryview(buf).cast("H"), swap=True)
+                self._auto_writing = True
+        else:
+            self._sm.background_write(memoryview(buf).cast("H"), swap=True)
 
 
 if __name__ == "__main__":
     import board
     import rainbowio
-    import time
+    import supervisor
 
     NEOPIXEL = board.NEOPIXEL
     NUM_PIXELS = 12
     pixels = NeoPixelBackground(NEOPIXEL, NUM_PIXELS)
     i = 0
     while True:
-        pixels.fill(rainbowio.colorwheel(i := (i + 1) % 256))
-        time.sleep(0.01)
+        # Around 1 cycle per second
+        pixels.fill(rainbowio.colorwheel(supervisor.ticks_ms() // 4))