Ported to Raspberry Pi Pico.

Author: peterhinch

README.md

@@ -8,12 +8,15 @@ electrical equipment.
 They are cheap, reliable and consume negligible power. However they lack
 flexibility: they can only be controlled by the matching remote. This library
 provides a means of incorporating them into an IOT (internet of things)
-solution, or simply enabling the construction of a remote with a better antenna
-and longer range than the stock item.
+solution, or building a remote capable of controlling more devices with a
+better antenna and longer range than the stock item.
+
+For the constructor a key benefit is that no high voltage wiring is required.
 
 The approach relies on the fact that most units use a common frequency of
 433.92MHz. Transmitter and receiver modules are available for this frequency at
 low cost, e.g. [from Seeed](https://www.seeedstudio.com/433Mhz-RF-link-kit-p-127.html).
+The Seeed units:
 
 ![Image](images/seeed.png)
 
@@ -25,15 +28,15 @@ requiring the remote to be held very close to it to achieve results.
 The signal from the supplied remote is captured by a simple utility and stored
 in a file. Multiple signals - optionally from multiple remotes - may be stored
 in a file. The utility is used interactively at the REPL. Supported targets are
-Pyboard D, Pyboard 1.x, Pyboard Lite and ESP32.
+Pyboard D, Pyboard 1.x, Pyboard Lite, ESP32 and Raspberry Pi Pico.
 
 #### Transmitter
 
 This module is intended to be used by applications. The application loads the
 file created by the receiver and transmits captured codes on demand.
-Transmission is nonblocking. Supported targets are Pyboard D, Pyboard 1.x and
-ESP32. Pyboard Lite works in my testing, but only in blocking mode. The module
-does not use `uasyncio` but is compatible with it.
+Transmission is nonblocking. Supported targets are Pyboard D, Pyboard 1.x,
+ESP32 and Raspberry Pi Pico. Pyboard Lite works in my testing, but only in
+blocking mode. The module does not use `uasyncio` but is compatible with it.
 
 #### Warning
 
@@ -45,6 +48,14 @@ to improve accuracy.
 
 See [section 6](./README.md#6-background) for the reasons for this approach.
 
+#### Raspberry Pi Pico note
+
+Early firmware has [this issue](https://github.com/micropython/micropython/issues/6866)
+affecting USB communication with some PC's. It particularly affects code which
+issues `print()` only occasionally: the application appears to have failed. The
+missing messages appear when you press a key. Hopefully this will be fixed soon
+(note dated 8th March 2021).
+
 # 1. Installation
 
 ## 1.1 Code
@@ -53,8 +64,8 @@ Receiver: copy the `rx` directory and contents to the target's filesystem.
 Transmitter: copy the `tx` directory and contents to the target's filesystem.
 
 In each directory there is a file `get_pin.py`. This provides a convenient way
-to instantiate a `Pin` on Pyboard or ESP32. This may be modified for your own
-needs or ignored and replaced with your own code.
+to instantiate a `Pin` on Pyboard, ESP32 or Raspberry Pi Pico. This may be
+modified for your own needs or ignored and replaced with your own code.
 
 There are no dependencies.
 
@@ -64,26 +75,33 @@ It is difficult to generalise as there are multiple sources for 433MHz
 transceivers. Check the data for your modules.
 
 My transmitter and receiver need a 5V supply. The receiver produces a 0-5V
-signal: this is compatible with Pyboards but the ESP32 requires a circuit to
-ensure 0-3.3V levels. The receiver code is polarity agnostic so an inverting
-buffer as shown below will suffice.
+signal: this is compatible with Pyboards but the ESP32 and Raspberry Pi Pico
+require a circuit to ensure 0-3.3V levels. The receiver code is polarity
+agnostic so an inverting buffer as shown below will suffice.
 
-By default pin X3 is used on the Pyboard and pin 27 on ESP32, but any pins may
-be used.
+Receiver defaults are pin X3 on Pyboard, pin 27 on ESP32 and pin 17 on Pico,
+but any pins may be used.
 
 ![Image](images/buffer.png)
 
 The transmitter can be directly connected as 5V devices are normally compatible
-with 3.3V logic levels. Default pins are X3 on Pyboard, 23 on ESP32. Any pins
-may be substituted. The 
+with 3.3V logic levels. Transmitter defaults are X3 on Pyboard, 23 on ESP32 and
+16 on the Pico. Any pins may be substituted. The 
 [data for the Seeed transmitter](https://www.seeedstudio.com/433Mhz-RF-link-kit-p-127.html)
 states that a supply of up to 12V may be used to increase power. Whether this
 applies to other versions is moot: try at your own risk. I haven't.
 
 ## 1.3 Hardware usage
 
 Pyboards: Timer 5.  
-ESP32: RMT channel 0.
+ESP32: RMT channel 0.  
+Pico: PIO state machine 0, IRQ 0, PIO 0.  
+
+The Pico uses `tx/rp2_rmt.py` which uses the PIO for nonblocking modulation in
+a similar way to the ESP32 RMT device. To use this library there is no need to
+study the code, but documentation is available
+[here](https://github.com/peterhinch/micropython_ir/blob/master/RP2_RMT.md) for
+those interested.
 
 # 2. Acquiring data
 
@@ -165,9 +183,10 @@ from tx.get_pin import pin
 transmit = TX(pin(), 'remotes')
 transmit('TV on')  # Immediate return
 ```
-The transmit method is nonblocking, both on Pyboard and on ESP32. There is an
-alternative blocking method for use on Pyboard only. This offers more precise
-timing, and I found it necessary on the Pyboard Lite only. This is accessed as:
+The transmit method is nonblocking, on Pyboard, ESP32 and Raspberry Pi Pico.
+There is an alternative blocking method for use on Pyboard only. This offers
+more precise timing, and I found it necessary on the Pyboard Lite only. This is
+accessed as:
 ```python
 transmit.send('TV on')  # Blocks
 ```
@@ -230,6 +249,8 @@ async def send_queued():
         transmit(to_send)
         await asyncio.sleep_ms(delay)
 ```
+In the absence of an official `Queue` class, an unofficial version is available
+documented [here](https://github.com/peterhinch/micropython-async/blob/master/v3/docs/TUTORIAL.md#35-queue).
 
 # 4. File maintenance
 

rx/get_pin.py

@@ -16,4 +16,6 @@ def pin():
         #pin = Pin(13, Pin.IN)
     elif platform == 'esp32' or platform == 'esp32_LoBo':
         pin = Pin(27, Pin.IN)
+    elif platform == 'rp2':  # Raspberry Pi Pico
+        pin = Pin(17, Pin.IN)
     return pin

tx/__init__.py

@@ -1,12 +1,16 @@
 # __init__.py Nonblocking 433MHz transmitter
-# Runs on Pyboard D, Pyboard 1.x, Pyboard Lite and ESP32
+# Runs on Pyboard D, Pyboard 1.x, Pyboard Lite, ESP32 and Raspberry Pi Pico
 
 # Released under the MIT License (MIT). See LICENSE.
-# Copyright (c) 2020 Peter Hinch
+# Copyright (c) 2020-2021 Peter Hinch
+
 from sys import platform
 ESP32 = platform == 'esp32'  # Loboris not supported owing to RMT
+RP2 = platform == 'rp2'
 if ESP32:
     from esp32 import RMT
+elif RP2:
+    from .rp2_rmt import RP2_RMT
 else:
     from pyb import Timer
 
@@ -40,6 +44,11 @@ def __init__(self, pin, fname, reps=5):
         gc.collect()
         if ESP32:
             self._rmt = RMT(0, pin=pin, clock_div=80)  # 1μs resolution
+        elif RP2:  # PIO-based RMT-like device
+            self._rmt = RP2_RMT(pin_pulse=pin)  # 1μs resolution
+            # Array size: length of longest entry + 1 for STOP
+            asize = max([len(x) for x in self._data.values()]) + 1
+            self._arr = array('H', (0 for _ in range(asize)))  # on/off times (μs)
         else:  # Pyboard
             self._tim = Timer(5)  # Timer 5 controls carrier on/off times
             self._tcb = self._cb  # Pre-allocate
@@ -83,6 +92,11 @@ def __call__(self, key):
                 # This would save RAM. RMT.loop() is currently broken:
                 # https://github.com/micropython/micropython/issues/5787
                 self._rmt.write_pulses(lst * self._reps, start = 1)  # Active high
+            elif RP2:
+                for x, t in enumerate(lst):
+                    self._arr[x] = t
+                self._arr[x + 1] = STOP
+                self._rmt.send(self._arr, self._reps)
             else:
                 x = 0
                 for _ in range(self._reps):

tx/get_pin.py

@@ -12,6 +12,8 @@ def pin(state=0):
         pin = Pin('X3', Pin.OUT)
     elif platform == 'esp32':
         pin = Pin(23, Pin.OUT)
+    elif platform == 'rp2':  # Raspberry Pi Pico
+        pin = Pin(16, Pin.OUT)
     elif platform == 'esp8266':
         raise OSError('Transmitter does not support ESP8266')
     elif platform == 'esp32_LoBo':

tx/rp2_rmt.py

@@ -0,0 +1,104 @@
+# rp2_rmt.py A RMT-like class for the RP2.
+
+# Released under the MIT License (MIT). See LICENSE.
+
+# Copyright (c) 2021 Peter Hinch
+
+from machine import Pin, PWM
+import rp2
+
+@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW, autopull=True, pull_thresh=32)
+def pulsetrain():
+    wrap_target()
+    out(x, 32)  # No of 1MHz ticks. Block if FIFO MT at end.
+    irq(rel(0))
+    set(pins, 1)  # Set pin high
+    label('loop')
+    jmp(x_dec,'loop')
+    irq(rel(0))
+    set(pins, 0)  # Set pin low
+    out(y, 32)  # Low time.
+    label('loop_lo')
+    jmp(y_dec,'loop_lo')
+    wrap()
+
+@rp2.asm_pio(autopull=True, pull_thresh=32)
+def irqtrain():
+    wrap_target()
+    out(x, 32)  # No of 1MHz ticks. Block if FIFO MT at end.
+    irq(rel(0))
+    label('loop')
+    jmp(x_dec,'loop')
+    wrap()
+
+class DummyPWM:
+    def duty_u16(self, _):
+        pass
+
+class RP2_RMT:
+
+    def __init__(self, pin_pulse=None, carrier=None, sm_no=0, sm_freq=1_000_000):
+        if carrier is None:
+            self.pwm = DummyPWM()
+            self.duty = (0, 0)
+        else:
+            pin_car, freq, duty = carrier
+            self.pwm = PWM(pin_car)  # Set up PWM with carrier off.
+            self.pwm.freq(freq)
+            self.pwm.duty_u16(0)
+            self.duty = (int(0xffff * duty // 100), 0)
+        if pin_pulse is None:
+            self.sm = rp2.StateMachine(sm_no, irqtrain, freq=sm_freq)
+        else:
+            self.sm = rp2.StateMachine(sm_no, pulsetrain, freq=sm_freq, set_base=pin_pulse)
+        self.apt = 0  # Array index
+        self.arr = None  # Array
+        self.ict = None  # Current IRQ count
+        self.icm = 0  # End IRQ count
+        self.reps = 0  # 0 == forever n == no. of reps
+        rp2.PIO(0).irq(self._cb)
+
+    # IRQ callback. Because of FIFO IRQ's keep arriving after STOP.
+    def _cb(self, pio):
+        self.pwm.duty_u16(self.duty[self.ict & 1])
+        self.ict += 1
+        if d := self.arr[self.apt]:  # If data available feed FIFO
+            self.sm.put(d)
+            self.apt += 1
+        else:
+            if r := self.reps != 1:  # All done if reps == 1
+                if r:  # 0 == run forever
+                    self.reps -= 1
+                self.sm.put(self.arr[0])
+                self.apt = 1  # Set pointer and count to state
+                self.ict = 1  # after 1st IRQ
+
+    # Arg is an array of times in μs terminated by 0. 
+    def send(self, ar, reps=1, check=True):
+        self.sm.active(0)
+        self.reps = reps
+        ar[-1] = 0  # Ensure at least one STOP
+        for x, d in enumerate(ar):  # Find 1st STOP
+            if d == 0:
+                break
+        if check:
+            # Discard any trailing mark which would leave carrier on.
+            if (x & 1):
+                x -= 1
+                ar[x] = 0
+        self.icm = x  # index of 1st STOP
+        mv = memoryview(ar)
+        n = min(x, 4)  # Fill FIFO if there are enough data points.
+        self.sm.put(mv[0 : n])
+        self.arr = ar  # Initial conditions for ISR
+        self.apt = n  # Point to next data value
+        self.ict = 0  # IRQ count
+        self.sm.active(1)
+
+    def busy(self):
+        if self.ict is None:
+            return False  # Just instantiated
+        return self.ict < self.icm
+
+    def cancel(self):
+        self.reps = 1