MicroPython, CircuitPython and other ports

ports/run_both.py

"""The same application on the MicroPython layer and the CircuitPython layer, run on stand-ins of both platforms."""
import app
import bench
import hw_circuitpython
import hw_micropython

TIMES = range(0, 2000, 250)
print("ms            " + "".join("%5d" % t for t in TIMES))
for name, layer in (("MicroPython  ", hw_micropython), ("CircuitPython", hw_circuitpython)):
    bench.reset()
    board = layer.Board(clock=bench.clock)
    seen = []
    for t in TIMES:
        bench.press(1200 <= t < 1700)  # the button is held from 1,200 to 1,700 ms
        app.step(board)
        seen.append(bench.led().strip())
        bench.advance(250)
    print(name + " " + "".join("%5s" % s for s in seen))

ms                0  250  500  750 1000 1250 1500 1750
MicroPython      on   on  off  off   on   on   on  off
CircuitPython    on   on  off  off   on   on   on  off

ports/app.py

"""The application: blink once a second while idle, stay lit while the button is held.
It talks only to a board object, never to machine or digitalio, so it runs on either platform."""


def step(board):
    if board.button_pressed():
        board.led(True)
    else:
        board.led(board.now_ms() // 500 % 2 == 0)

ports/hw_micropython.py

"""The board layer for MicroPython: machine.Pin and Signal, with ticks that survive the wrap-around."""
import time

from machine import Pin, Signal


class Board:
    def __init__(self, led_pin="LED", button_pin=14, clock=None):
        self._led = Signal(Pin(led_pin, Pin.OUT, value=0))
        self._button = Signal(Pin(button_pin, Pin.IN, Pin.PULL_UP), invert=True)  # pressed pulls low
        if clock is None:
            t0 = time.ticks_ms()

            def clock():
                return time.ticks_diff(time.ticks_ms(), t0)

        self.now_ms = clock  # milliseconds since start; a test passes its own clock

    def led(self, on):
        self._led.value(1 if on else 0)

    def button_pressed(self):
        return bool(self._button.value())

ports/hw_circuitpython.py

"""The board layer for CircuitPython: board pin names and digitalio, with time.monotonic_ns()."""
import time

import board
import digitalio


class Board:
    def __init__(self, led_pin=board.LED, button_pin=board.GP14, clock=None):
        self._led = digitalio.DigitalInOut(led_pin)
        self._led.switch_to_output(value=False)
        self._button = digitalio.DigitalInOut(button_pin)
        self._button.switch_to_input(pull=digitalio.Pull.UP)
        if clock is None:
            t0 = time.monotonic_ns()

            def clock():
                return (time.monotonic_ns() - t0) // 1_000_000

        self.now_ms = clock  # milliseconds since start; a test passes its own clock

    def led(self, on):
        self._led.value = bool(on)

    def button_pressed(self):
        return not self._button.value  # pressed pulls low

machine.py (stand-in) · ports/machine.py

"""A stand-in for machine.Pin and machine.Signal, enough for the board layer beside it. Never copy it to a board."""
import bench

FAKE = True


class Pin:
    IN, OUT, PULL_UP = 0, 1, 1

    def __init__(self, id, mode=-1, pull=None, value=None):
        self.id = id
        if value is not None:
            bench.write(id, value)

    def value(self, v=None):
        if v is None:
            return bench.read(self.id)
        bench.write(self.id, v)


class Signal:
    def __init__(self, pin, invert=False):
        self.pin, self.invert = pin, invert

    def value(self, v=None):
        if v is None:
            return self.pin.value() ^ self.invert
        self.pin.value(v ^ self.invert)


class I2C:
    """machine.I2C with MSC-ENV1 (made up) at 0x41: TEMP in registers 3 and 4, 21.5 °C."""

    def __init__(self, id=0, *, scl=None, sda=None, freq=400_000):
        self.regs = bytes([0xE1, 0, 0, 0x0A, 0xC0])

    def readfrom_mem_into(self, addr, memaddr, buf):
        buf[:] = self.regs[memaddr:memaddr + len(buf)]

board.py (stand-in) · ports/board.py

"""A stand-in for CircuitPython's board module on a Pico: pin names as objects. Never copy it to a board."""
FAKE = True


class _Pin:
    def __init__(self, name):
        self.name = name


LED = _Pin("LED")
GP14 = _Pin("GP14")
GP4 = _Pin("GP4")
GP5 = _Pin("GP5")

digitalio.py (stand-in) · ports/digitalio.py

"""A stand-in for CircuitPython's digitalio, enough for the board layer beside it. Never copy it to a board."""
import bench

FAKE = True
_IDS = {"LED": "LED", "GP14": 14}  # the names the bench uses


class Pull:
    UP, DOWN = "UP", "DOWN"


class DigitalInOut:
    def __init__(self, pin):
        self._id = _IDS[pin.name]

    def switch_to_output(self, value=False, drive_mode=None):
        bench.write(self._id, int(value))

    def switch_to_input(self, pull=None):
        pass

    @property
    def value(self):
        return bool(bench.read(self._id))

    @value.setter
    def value(self, v):
        bench.write(self._id, int(v))

ports/bench.py

"""The test bench for both board layers: a clock you move, a button you press, and the LED's level."""
_levels = {14: 1}  # GP14 idles high through its pull-up
_now = [0]


def reset():
    _levels.clear()
    _levels[14] = 1
    _now[0] = 0


def clock():
    return _now[0]


def advance(ms):
    _now[0] += ms


def press(down):
    _levels[14] = 0 if down else 1


def read(pin):
    return _levels.get(pin, 0)


def write(pin, value):
    if pin != 14:  # the button is an input; writes to it change nothing
        _levels[pin] = 1 if value else 0


def led():
    return "on " if _levels.get("LED") else "off"