Merge branch 'master' into nfc_copy

51 files changed, 2027 insertions, 500 deletions

diff --git a/shared-bindings/_bleio/Adapter.c b/shared-bindings/_bleio/Adapter.c
index 500055cf3..921667f0f 100644
--- a/shared-bindings/_bleio/Adapter.c
+++ b/shared-bindings/_bleio/Adapter.c
@@ -117,7 +117,7 @@ const mp_obj_property_t bleio_adapter_address_obj = {
 
 //|   .. attribute:: name
 //|
-//|       name of the BLE adapter used once connected. Not used in advertisements.
+//|       name of the BLE adapter used once connected.
 //|       The name is "CIRCUITPY" + the last four hex digits of ``adapter.address``,
 //|       to make it easy to distinguish multiple CircuitPython boards.
 //|
diff --git a/shared-bindings/_bleio/Characteristic.c b/shared-bindings/_bleio/Characteristic.c
index 2b1dc1f78..e55191f7c 100644
--- a/shared-bindings/_bleio/Characteristic.c
+++ b/shared-bindings/_bleio/Characteristic.c
@@ -49,7 +49,7 @@
 //|   as part of remote Services.
 //|
 
-//|   .. method:: add_to_service(service, uuid, *, properties=0, read_perm=`Attribute.OPEN`, write_perm=`Attribute.OPEN`, max_length=20, fixed_length=False, initial_value=None)
+//|   .. method:: add_to_service(service, uuid, *, properties=0, read_perm=Attribute.OPEN, write_perm=Attribute.OPEN, max_length=20, fixed_length=False, initial_value=None)
 //|
 //|     Create a new Characteristic object, and add it to this Service.
 //|
diff --git a/shared-bindings/_bleio/PacketBuffer.c b/shared-bindings/_bleio/PacketBuffer.c
index f9f171870..9e3666044 100644
--- a/shared-bindings/_bleio/PacketBuffer.c
+++ b/shared-bindings/_bleio/PacketBuffer.c
@@ -109,7 +109,12 @@ STATIC mp_obj_t bleio_packet_buffer_readinto(mp_obj_t self_in, mp_obj_t buffer_o
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(buffer_obj, &bufinfo, MP_BUFFER_WRITE);
 
-    return MP_OBJ_NEW_SMALL_INT(common_hal_bleio_packet_buffer_readinto(self, bufinfo.buf, bufinfo.len));
+    int size = common_hal_bleio_packet_buffer_readinto(self, bufinfo.buf, bufinfo.len);
+    if (size < 0) {
+        mp_raise_ValueError_varg(translate("Buffer too short by %d bytes"), size * -1);
+    }
+
+    return MP_OBJ_NEW_SMALL_INT(size);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(bleio_packet_buffer_readinto_obj, bleio_packet_buffer_readinto);
 
@@ -163,13 +168,13 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(bleio_packet_buffer_deinit_obj, bleio_packet_bu
 
 //|   .. attribute:: packet_size
 //|
-//|     Maximum size of each packet in bytes. This is the minimum of the Characterstic length and
+//|     Maximum size of each packet in bytes. This is the minimum of the Characteristic length and
 //|     the negotiated Maximum Transfer Unit (MTU).
 //|
 STATIC mp_obj_t bleio_packet_buffer_get_packet_size(mp_obj_t self_in) {
     bleio_packet_buffer_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
-    return mp_obj_new_bool(common_hal_bleio_packet_buffer_get_packet_size(self));
+    return MP_OBJ_NEW_SMALL_INT(common_hal_bleio_packet_buffer_get_packet_size(self));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(bleio_packet_buffer_get_packet_size_obj, bleio_packet_buffer_get_packet_size);
 
diff --git a/shared-bindings/_bleio/__init__.c b/shared-bindings/_bleio/__init__.c
index 5d26862a6..dd401398c 100644
--- a/shared-bindings/_bleio/__init__.c
+++ b/shared-bindings/_bleio/__init__.c
@@ -132,6 +132,14 @@ NORETURN void mp_raise_bleio_SecurityError(const compressed_string_t* fmt, ...)
     nlr_raise(exception);
 }
 
+// Called when _bleio is imported.
+STATIC mp_obj_t bleio___init__(void) {
+    common_hal_bleio_adapter_set_enabled(&common_hal_bleio_adapter_obj, true);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(bleio___init___obj, bleio___init__);
+
+
 STATIC const mp_rom_map_elem_t bleio_module_globals_table[] = {
     // Name must be the first entry so that the exception printing below is correct.
     { MP_ROM_QSTR(MP_QSTR___name__),             MP_ROM_QSTR(MP_QSTR__bleio) },
@@ -156,6 +164,10 @@ STATIC const mp_rom_map_elem_t bleio_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_ConnectionError),     MP_ROM_PTR(&mp_type_bleio_ConnectionError) },
     { MP_ROM_QSTR(MP_QSTR_RoleError),           MP_ROM_PTR(&mp_type_bleio_RoleError) },
     { MP_ROM_QSTR(MP_QSTR_SecurityError),       MP_ROM_PTR(&mp_type_bleio_SecurityError) },
+
+    // Initialization
+    { MP_ROM_QSTR(MP_QSTR___init__),            MP_ROM_PTR(&bleio___init___obj) },
+
 };
 
 STATIC MP_DEFINE_CONST_DICT(bleio_module_globals, bleio_module_globals_table);
diff --git a/shared-bindings/_eve/__init__.c b/shared-bindings/_eve/__init__.c
new file mode 100644
index 000000000..9bc790f5d
--- /dev/null
+++ b/shared-bindings/_eve/__init__.c
@@ -0,0 +1,1105 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 James Bowman for Excamera Labs
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+
+#include "py/runtime.h"
+#include "py/binary.h"
+
+#include "shared-module/_eve/__init__.h"
+#include "shared-bindings/_eve/__init__.h"
+
+//| :mod:`_eve` --- low-level BridgeTek EVE bindings
+//| ================================================
+//|
+//| .. module:: _eve
+//|   :synopsis: low-level BridgeTek EVE bindings
+//|   :platform: SAMD21/SAMD51
+//|
+//| The `_eve` module provides a class _EVE which
+//| contains methods for constructing EVE command 
+//| buffers and appending basic graphics commands.
+//|
+
+typedef struct _mp_obj__EVE_t {
+    mp_obj_base_t base;
+    common_hal__eve_t _eve;
+} mp_obj__EVE_t;
+
+STATIC const mp_obj_type_t _EVE_type;
+
+#define EVEHAL(s) \
+  (&((mp_obj__EVE_t*)mp_instance_cast_to_native_base((s), &_EVE_type))->_eve)
+
+STATIC mp_obj_t _register(mp_obj_t self, mp_obj_t o) {
+    common_hal__eve_t *eve = EVEHAL(self);
+    mp_load_method(o, MP_QSTR_write, eve->dest);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(register_obj, _register);
+
+//|   .. method:: flush()
+//| 
+//|     Send any queued drawing commands directly to the hardware.
+//|
+//|     :param int width: The width of the grid in tiles, or 1 for sprites.
+//|
+STATIC mp_obj_t _flush(mp_obj_t self) {
+    common_hal__eve_flush(EVEHAL(self));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(flush_obj, _flush);
+
+//|   .. method:: cc(b)
+//| 
+//|     Append bytes to the command FIFO.
+//|
+//|     :param bytes b: The bytes to add
+//|
+STATIC mp_obj_t _cc(mp_obj_t self, mp_obj_t b) {
+    mp_buffer_info_t buffer_info;
+    mp_get_buffer_raise(b, &buffer_info, MP_BUFFER_READ);
+    common_hal__eve_add(EVEHAL(self), buffer_info.len, buffer_info.buf);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(cc_obj, _cc);
+
+//{
+
+//|   .. method:: AlphaFunc(func, ref)
+//|
+//|     Set the alpha test function
+//|
+//|     :param int func: specifies the test function, one of ``NEVER``, ``LESS``, ``LEQUAL``, ``GREATER``, ``GEQUAL``, ``EQUAL``, ``NOTEQUAL``, or ``ALWAYS``. Range 0-7. The initial value is ALWAYS(7)
+//|     :param int ref: specifies the reference value for the alpha test. Range 0-255. The initial value is 0
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _alphafunc(mp_obj_t self, mp_obj_t a0, mp_obj_t a1) {
+    uint32_t func   = mp_obj_get_int_truncated(a0);
+    uint32_t ref    = mp_obj_get_int_truncated(a1);
+    common_hal__eve_AlphaFunc(EVEHAL(self), func, ref);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(alphafunc_obj, _alphafunc);
+
+//|   .. method:: Begin(prim)
+//|
+//|     Begin drawing a graphics primitive
+//|
+//|     :param int prim: graphics primitive.
+//|
+//|     Valid primitives are ``BITMAPS``, ``POINTS``, ``LINES``, ``LINE_STRIP``, ``EDGE_STRIP_R``, ``EDGE_STRIP_L``, ``EDGE_STRIP_A``, ``EDGE_STRIP_B`` and ``RECTS``.
+//| 
+
+STATIC mp_obj_t _begin(mp_obj_t self, mp_obj_t a0) {
+    uint32_t prim   = mp_obj_get_int_truncated(a0);
+    common_hal__eve_Begin(EVEHAL(self), prim);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(begin_obj, _begin);
+
+//|   .. method:: BitmapExtFormat(format)
+//|
+//|     Set the bitmap format
+//|
+//|     :param int format: bitmap pixel format.
+//|
+
+STATIC mp_obj_t _bitmapextformat(mp_obj_t self, mp_obj_t a0) {
+    uint32_t fmt    = mp_obj_get_int_truncated(a0);
+    common_hal__eve_BitmapExtFormat(EVEHAL(self), fmt);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(bitmapextformat_obj, _bitmapextformat);
+
+//|   .. method:: BitmapHandle(handle)
+//|
+//|     Set the bitmap handle
+//|
+//|     :param int handle: bitmap handle. Range 0-31. The initial value is 0
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _bitmaphandle(mp_obj_t self, mp_obj_t a0) {
+    uint32_t handle = mp_obj_get_int_truncated(a0);
+    common_hal__eve_BitmapHandle(EVEHAL(self), handle);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(bitmaphandle_obj, _bitmaphandle);
+
+//|   .. method:: BitmapLayoutH(linestride, height)
+//|
+//|     Set the source bitmap memory format and layout for the current handle. high bits for large bitmaps
+//|
+//|     :param int linestride: high part of bitmap line stride, in bytes. Range 0-7
+//|     :param int height: high part of bitmap height, in lines. Range 0-3
+//|
+
+STATIC mp_obj_t _bitmaplayouth(mp_obj_t self, mp_obj_t a0, mp_obj_t a1) {
+    uint32_t linestride = mp_obj_get_int_truncated(a0);
+    uint32_t height = mp_obj_get_int_truncated(a1);
+    common_hal__eve_BitmapLayoutH(EVEHAL(self), linestride, height);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(bitmaplayouth_obj, _bitmaplayouth);
+
+//|   .. method:: BitmapLayout(format, linestride, height)
+//|
+//|     Set the source bitmap memory format and layout for the current handle
+//|
+//|     :param int format: bitmap pixel format, or GLFORMAT to use BITMAP_EXT_FORMAT instead. Range 0-31
+//|     :param int linestride: bitmap line stride, in bytes. Range 0-1023
+//|     :param int height: bitmap height, in lines. Range 0-511
+//|
+
+STATIC mp_obj_t _bitmaplayout(size_t n_args, const mp_obj_t *args) {
+    uint32_t format = mp_obj_get_int_truncated(args[1]);
+    uint32_t linestride = mp_obj_get_int_truncated(args[2]);
+    uint32_t height = mp_obj_get_int_truncated(args[3]);
+    common_hal__eve_BitmapLayout(EVEHAL(args[0]), format, linestride, height);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bitmaplayout_obj, 4, 4, _bitmaplayout);
+
+//|   .. method:: BitmapSizeH(width, height)
+//|
+//|     Set the screen drawing of bitmaps for the current handle. high bits for large bitmaps
+//|
+//|     :param int width: high part of drawn bitmap width, in pixels. Range 0-3
+//|     :param int height: high part of drawn bitmap height, in pixels. Range 0-3
+//|
+
+STATIC mp_obj_t _bitmapsizeh(mp_obj_t self, mp_obj_t a0, mp_obj_t a1) {
+    uint32_t width  = mp_obj_get_int_truncated(a0);
+    uint32_t height = mp_obj_get_int_truncated(a1);
+    common_hal__eve_BitmapSizeH(EVEHAL(self), width, height);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(bitmapsizeh_obj, _bitmapsizeh);
+
+//|   .. method:: BitmapSize(filter, wrapx, wrapy, width, height)
+//|
+//|     Set the screen drawing of bitmaps for the current handle
+//|
+//|     :param int filter: bitmap filtering mode, one of ``NEAREST`` or ``BILINEAR``. Range 0-1
+//|     :param int wrapx: bitmap :math:`x` wrap mode, one of ``REPEAT`` or ``BORDER``. Range 0-1
+//|     :param int wrapy: bitmap :math:`y` wrap mode, one of ``REPEAT`` or ``BORDER``. Range 0-1
+//|     :param int width: drawn bitmap width, in pixels. Range 0-511
+//|     :param int height: drawn bitmap height, in pixels. Range 0-511
+//|
+
+STATIC mp_obj_t _bitmapsize(size_t n_args, const mp_obj_t *args) {
+    uint32_t filter = mp_obj_get_int_truncated(args[1]);
+    uint32_t wrapx  = mp_obj_get_int_truncated(args[2]);
+    uint32_t wrapy  = mp_obj_get_int_truncated(args[3]);
+    uint32_t width  = mp_obj_get_int_truncated(args[4]);
+    uint32_t height = mp_obj_get_int_truncated(args[5]);
+    common_hal__eve_BitmapSize(EVEHAL(args[0]), filter, wrapx, wrapy, width, height);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bitmapsize_obj, 6, 6, _bitmapsize);
+
+//|   .. method:: BitmapSource(addr)
+//|
+//|     Set the source address for bitmap graphics
+//|
+//|     :param int addr: Bitmap start address, pixel-aligned. May be in SRAM or flash. Range 0-16777215
+//|
+
+STATIC mp_obj_t _bitmapsource(mp_obj_t self, mp_obj_t a0) {
+    uint32_t addr   = mp_obj_get_int_truncated(a0);
+    common_hal__eve_BitmapSource(EVEHAL(self), addr);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(bitmapsource_obj, _bitmapsource);
+
+//|   .. method:: BitmapSwizzle(r, g, b, a)
+//|
+//|     Set the source for the r,g,b and a channels of a bitmap
+//|
+//|     :param int r: red component source channel. Range 0-7
+//|     :param int g: green component source channel. Range 0-7
+//|     :param int b: blue component source channel. Range 0-7
+//|     :param int a: alpha component source channel. Range 0-7
+//|
+
+STATIC mp_obj_t _bitmapswizzle(size_t n_args, const mp_obj_t *args) {
+    uint32_t r      = mp_obj_get_int_truncated(args[1]);
+    uint32_t g      = mp_obj_get_int_truncated(args[2]);
+    uint32_t b      = mp_obj_get_int_truncated(args[3]);
+    uint32_t a      = mp_obj_get_int_truncated(args[4]);
+    common_hal__eve_BitmapSwizzle(EVEHAL(args[0]), r, g, b, a);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bitmapswizzle_obj, 5, 5, _bitmapswizzle);
+
+//|   .. method:: BitmapTransformA(p, v)
+//|
+//|     Set the :math:`a` component of the bitmap transform matrix
+//|
+//|     :param int p: precision control: 0 is 8.8, 1 is 1.15. Range 0-1. The initial value is 0
+//|     :param int v: The :math:`a` component of the bitmap transform matrix, in signed 8.8 or 1.15 bit fixed-point form. Range 0-131071. The initial value is 256
+//|
+//|     The initial value is **p** = 0, **v** = 256. This represents the value 1.0.
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _bitmaptransforma(mp_obj_t self, mp_obj_t a0, mp_obj_t a1) {
+    uint32_t p      = mp_obj_get_int_truncated(a0);
+    uint32_t v      = mp_obj_get_int_truncated(a1);
+    common_hal__eve_BitmapTransformA(EVEHAL(self), p, v);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(bitmaptransforma_obj, _bitmaptransforma);
+
+//|   .. method:: BitmapTransformB(p, v)
+//|
+//|     Set the :math:`b` component of the bitmap transform matrix
+//|
+//|     :param int p: precision control: 0 is 8.8, 1 is 1.15. Range 0-1. The initial value is 0
+//|     :param int v: The :math:`b` component of the bitmap transform matrix, in signed 8.8 or 1.15 bit fixed-point form. Range 0-131071. The initial value is 0
+//|
+//|     The initial value is **p** = 0, **v** = 0. This represents the value 0.0.
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _bitmaptransformb(mp_obj_t self, mp_obj_t a0, mp_obj_t a1) {
+    uint32_t p      = mp_obj_get_int_truncated(a0);
+    uint32_t v      = mp_obj_get_int_truncated(a1);
+    common_hal__eve_BitmapTransformB(EVEHAL(self), p, v);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(bitmaptransformb_obj, _bitmaptransformb);
+
+//|   .. method:: BitmapTransformC(v)
+//|
+//|     Set the :math:`c` component of the bitmap transform matrix
+//|
+//|     :param int v: The :math:`c` component of the bitmap transform matrix, in signed 15.8 bit fixed-point form. Range 0-16777215. The initial value is 0
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _bitmaptransformc(mp_obj_t self, mp_obj_t a0) {
+    uint32_t v      = mp_obj_get_int_truncated(a0);
+    common_hal__eve_BitmapTransformC(EVEHAL(self), v);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(bitmaptransformc_obj, _bitmaptransformc);
+
+//|   .. method:: BitmapTransformD(p, v)
+//|
+//|     Set the :math:`d` component of the bitmap transform matrix
+//|
+//|     :param int p: precision control: 0 is 8.8, 1 is 1.15. Range 0-1. The initial value is 0
+//|     :param int v: The :math:`d` component of the bitmap transform matrix, in signed 8.8 or 1.15 bit fixed-point form. Range 0-131071. The initial value is 0
+//|
+//|     The initial value is **p** = 0, **v** = 0. This represents the value 0.0.
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _bitmaptransformd(mp_obj_t self, mp_obj_t a0, mp_obj_t a1) {
+    uint32_t p      = mp_obj_get_int_truncated(a0);
+    uint32_t v      = mp_obj_get_int_truncated(a1);
+    common_hal__eve_BitmapTransformD(EVEHAL(self), p, v);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(bitmaptransformd_obj, _bitmaptransformd);
+
+//|   .. method:: BitmapTransformE(p, v)
+//|
+//|     Set the :math:`e` component of the bitmap transform matrix
+//|
+//|     :param int p: precision control: 0 is 8.8, 1 is 1.15. Range 0-1. The initial value is 0
+//|     :param int v: The :math:`e` component of the bitmap transform matrix, in signed 8.8 or 1.15 bit fixed-point form. Range 0-131071. The initial value is 256
+//|
+//|     The initial value is **p** = 0, **v** = 256. This represents the value 1.0.
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _bitmaptransforme(mp_obj_t self, mp_obj_t a0, mp_obj_t a1) {
+    uint32_t p      = mp_obj_get_int_truncated(a0);
+    uint32_t v      = mp_obj_get_int_truncated(a1);
+    common_hal__eve_BitmapTransformE(EVEHAL(self), p, v);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(bitmaptransforme_obj, _bitmaptransforme);
+
+//|   .. method:: BitmapTransformF(v)
+//|
+//|     Set the :math:`f` component of the bitmap transform matrix
+//|
+//|     :param int v: The :math:`f` component of the bitmap transform matrix, in signed 15.8 bit fixed-point form. Range 0-16777215. The initial value is 0
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _bitmaptransformf(mp_obj_t self, mp_obj_t a0) {
+    uint32_t v      = mp_obj_get_int_truncated(a0);
+    common_hal__eve_BitmapTransformF(EVEHAL(self), v);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(bitmaptransformf_obj, _bitmaptransformf);
+
+//|   .. method:: BlendFunc(src, dst)
+//|
+//|     Set pixel arithmetic
+//|
+//|     :param int src: specifies how the source blending factor is computed.  One of ``ZERO``, ``ONE``, ``SRC_ALPHA``, ``DST_ALPHA``, ``ONE_MINUS_SRC_ALPHA`` or ``ONE_MINUS_DST_ALPHA``. Range 0-7. The initial value is SRC_ALPHA(2)
+//|     :param int dst: specifies how the destination blending factor is computed, one of the same constants as **src**. Range 0-7. The initial value is ONE_MINUS_SRC_ALPHA(4)
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _blendfunc(mp_obj_t self, mp_obj_t a0, mp_obj_t a1) {
+    uint32_t src    = mp_obj_get_int_truncated(a0);
+    uint32_t dst    = mp_obj_get_int_truncated(a1);
+    common_hal__eve_BlendFunc(EVEHAL(self), src, dst);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(blendfunc_obj, _blendfunc);
+
+//|   .. method:: Call(dest)
+//|
+//|     Execute a sequence of commands at another location in the display list
+//|
+//|     :param int dest: display list address. Range 0-65535
+//|
+
+STATIC mp_obj_t _call(mp_obj_t self, mp_obj_t a0) {
+    uint32_t dest   = mp_obj_get_int_truncated(a0);
+    common_hal__eve_Call(EVEHAL(self), dest);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(call_obj, _call);
+
+//|   .. method:: Cell(cell)
+//|
+//|     Set the bitmap cell number for the vertex2f command
+//|
+//|     :param int cell: bitmap cell number. Range 0-127. The initial value is 0
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _cell(mp_obj_t self, mp_obj_t a0) {
+    uint32_t cell   = mp_obj_get_int_truncated(a0);
+    common_hal__eve_Cell(EVEHAL(self), cell);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(cell_obj, _cell);
+
+//|   .. method:: ClearColorA(alpha)
+//|
+//|     Set clear value for the alpha channel
+//|
+//|     :param int alpha: alpha value used when the color buffer is cleared. Range 0-255. The initial value is 0
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _clearcolora(mp_obj_t self, mp_obj_t a0) {
+    uint32_t alpha  = mp_obj_get_int_truncated(a0);
+    common_hal__eve_ClearColorA(EVEHAL(self), alpha);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(clearcolora_obj, _clearcolora);
+
+//|   .. method:: ClearColorRGB(red, green, blue)
+//|
+//|     Set clear values for red, green and blue channels
+//|
+//|     :param int red: red value used when the color buffer is cleared. Range 0-255. The initial value is 0
+//|     :param int green: green value used when the color buffer is cleared. Range 0-255. The initial value is 0
+//|     :param int blue: blue value used when the color buffer is cleared. Range 0-255. The initial value is 0
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _clearcolorrgb(size_t n_args, const mp_obj_t *args) {
+    uint32_t red    = mp_obj_get_int_truncated(args[1]);
+    uint32_t green  = mp_obj_get_int_truncated(args[2]);
+    uint32_t blue   = mp_obj_get_int_truncated(args[3]);
+    common_hal__eve_ClearColorRGB(EVEHAL(args[0]), red, green, blue);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(clearcolorrgb_obj, 4, 4, _clearcolorrgb);
+
+//|   .. method:: Clear(c, s, t)
+//|
+//|     Clear buffers to preset values
+//|
+//|     :param int c: clear color buffer. Range 0-1
+//|     :param int s: clear stencil buffer. Range 0-1
+//|     :param int t: clear tag buffer. Range 0-1
+//|
+
+STATIC mp_obj_t _clear(size_t n_args, const mp_obj_t *args) {
+    uint32_t c      = (n_args > 1) ? mp_obj_get_int_truncated(args[1]) : 1;
+    uint32_t s      = (n_args > 2) ? mp_obj_get_int_truncated(args[2]) : 1;
+    uint32_t t      = (n_args > 3) ? mp_obj_get_int_truncated(args[3]) : 1;
+    common_hal__eve_Clear(EVEHAL(args[0]), c, s, t);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(clear_obj, 1, 4, _clear);
+
+//|   .. method:: ClearStencil(s)
+//|
+//|     Set clear value for the stencil buffer
+//|
+//|     :param int s: value used when the stencil buffer is cleared. Range 0-255. The initial value is 0
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _clearstencil(mp_obj_t self, mp_obj_t a0) {
+    uint32_t s      = mp_obj_get_int_truncated(a0);
+    common_hal__eve_ClearStencil(EVEHAL(self), s);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(clearstencil_obj, _clearstencil);
+
+//|   .. method:: ClearTag(s)
+//|
+//|     Set clear value for the tag buffer
+//|
+//|     :param int s: value used when the tag buffer is cleared. Range 0-255. The initial value is 0
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _cleartag(mp_obj_t self, mp_obj_t a0) {
+    uint32_t s      = mp_obj_get_int_truncated(a0);
+    common_hal__eve_ClearTag(EVEHAL(self), s);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(cleartag_obj, _cleartag);
+
+//|   .. method:: ColorA(alpha)
+//|
+//|     Set the current color alpha
+//|
+//|     :param int alpha: alpha for the current color. Range 0-255. The initial value is 255
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _colora(mp_obj_t self, mp_obj_t a0) {
+    uint32_t alpha  = mp_obj_get_int_truncated(a0);
+    common_hal__eve_ColorA(EVEHAL(self), alpha);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(colora_obj, _colora);
+
+//|   .. method:: ColorMask(r, g, b, a)
+//|
+//|     Enable and disable writing of frame buffer color components
+//|
+//|     :param int r: allow updates to the frame buffer red component. Range 0-1. The initial value is 1
+//|     :param int g: allow updates to the frame buffer green component. Range 0-1. The initial value is 1
+//|     :param int b: allow updates to the frame buffer blue component. Range 0-1. The initial value is 1
+//|     :param int a: allow updates to the frame buffer alpha component. Range 0-1. The initial value is 1
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _colormask(size_t n_args, const mp_obj_t *args) {
+    uint32_t r      = mp_obj_get_int_truncated(args[1]);
+    uint32_t g      = mp_obj_get_int_truncated(args[2]);
+    uint32_t b      = mp_obj_get_int_truncated(args[3]);
+    uint32_t a      = mp_obj_get_int_truncated(args[4]);
+    common_hal__eve_ColorMask(EVEHAL(args[0]), r, g, b, a);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(colormask_obj, 5, 5, _colormask);
+
+//|   .. method:: ColorRGB(red, green, blue)
+//|
+//|     Set the drawing color
+//|
+//|     :param int red: red value for the current color. Range 0-255. The initial value is 255
+//|     :param int green: green for the current color. Range 0-255. The initial value is 255
+//|     :param int blue: blue for the current color. Range 0-255. The initial value is 255
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _colorrgb(size_t n_args, const mp_obj_t *args) {
+    uint32_t red    = mp_obj_get_int_truncated(args[1]);
+    uint32_t green  = mp_obj_get_int_truncated(args[2]);
+    uint32_t blue   = mp_obj_get_int_truncated(args[3]);
+    common_hal__eve_ColorRGB(EVEHAL(args[0]), red, green, blue);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(colorrgb_obj, 4, 4, _colorrgb);
+
+//|   .. method:: Display()
+//|
+//|     End the display list
+//|
+
+STATIC mp_obj_t _display(mp_obj_t self) {
+
+    common_hal__eve_Display(EVEHAL(self));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(display_obj, _display);
+
+//|   .. method:: End()
+//|
+//|     End drawing a graphics primitive
+//|
+//|     :meth:`Vertex2ii` and :meth:`Vertex2f` calls are ignored until the next :meth:`Begin`.
+//| 
+
+STATIC mp_obj_t _end(mp_obj_t self) {
+
+    common_hal__eve_End(EVEHAL(self));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(end_obj, _end);
+
+//|   .. method:: Jump(dest)
+//|
+//|     Execute commands at another location in the display list
+//|
+//|     :param int dest: display list address. Range 0-65535
+//|
+
+STATIC mp_obj_t _jump(mp_obj_t self, mp_obj_t a0) {
+    uint32_t dest   = mp_obj_get_int_truncated(a0);
+    common_hal__eve_Jump(EVEHAL(self), dest);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(jump_obj, _jump);
+
+//|   .. method:: LineWidth(width)
+//|
+//|     Set the width of rasterized lines
+//|
+//|     :param int width: line width in :math:`1/16` pixel. Range 0-4095. The initial value is 16
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _linewidth(mp_obj_t self, mp_obj_t a0) {
+    uint32_t width  = mp_obj_get_int_truncated(a0);
+    common_hal__eve_LineWidth(EVEHAL(self), width);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(linewidth_obj, _linewidth);
+
+//|   .. method:: Macro(m)
+//|
+//|     Execute a single command from a macro register
+//|
+//|     :param int m: macro register to read. Range 0-1
+//|
+
+STATIC mp_obj_t _macro(mp_obj_t self, mp_obj_t a0) {
+    uint32_t m      = mp_obj_get_int_truncated(a0);
+    common_hal__eve_Macro(EVEHAL(self), m);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(macro_obj, _macro);
+
+//|   .. method:: Nop()
+//|
+//|     No operation
+//|
+
+STATIC mp_obj_t _nop(mp_obj_t self) {
+
+    common_hal__eve_Nop(EVEHAL(self));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(nop_obj, _nop);
+
+//|   .. method:: PaletteSource(addr)
+//|
+//|     Set the base address of the palette
+//|
+//|     :param int addr: Address in graphics SRAM, 2-byte aligned. Range 0-4194303. The initial value is 0
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _palettesource(mp_obj_t self, mp_obj_t a0) {
+    uint32_t addr   = mp_obj_get_int_truncated(a0);
+    common_hal__eve_PaletteSource(EVEHAL(self), addr);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(palettesource_obj, _palettesource);
+
+//|   .. method:: PointSize(size)
+//|
+//|     Set the radius of rasterized points
+//|
+//|     :param int size: point radius in :math:`1/16` pixel. Range 0-8191. The initial value is 16
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _pointsize(mp_obj_t self, mp_obj_t a0) {
+    uint32_t size   = mp_obj_get_int_truncated(a0);
+    common_hal__eve_PointSize(EVEHAL(self), size);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(pointsize_obj, _pointsize);
+
+//|   .. method:: RestoreContext()
+//|
+//|     Restore the current graphics context from the context stack
+//|
+
+STATIC mp_obj_t _restorecontext(mp_obj_t self) {
+
+    common_hal__eve_RestoreContext(EVEHAL(self));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(restorecontext_obj, _restorecontext);
+
+//|   .. method:: Return()
+//|
+//|     Return from a previous call command
+//|
+
+STATIC mp_obj_t _return(mp_obj_t self) {
+
+    common_hal__eve_Return(EVEHAL(self));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(return_obj, _return);
+
+//|   .. method:: SaveContext()
+//|
+//|     Push the current graphics context on the context stack
+//|
+
+STATIC mp_obj_t _savecontext(mp_obj_t self) {
+
+    common_hal__eve_SaveContext(EVEHAL(self));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(savecontext_obj, _savecontext);
+
+//|   .. method:: ScissorSize(width, height)
+//|
+//|     Set the size of the scissor clip rectangle
+//|
+//|     :param int width: The width of the scissor clip rectangle, in pixels. Range 0-4095. The initial value is hsize
+//|     :param int height: The height of the scissor clip rectangle, in pixels. Range 0-4095. The initial value is 2048
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _scissorsize(mp_obj_t self, mp_obj_t a0, mp_obj_t a1) {
+    uint32_t width  = mp_obj_get_int_truncated(a0);
+    uint32_t height = mp_obj_get_int_truncated(a1);
+    common_hal__eve_ScissorSize(EVEHAL(self), width, height);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(scissorsize_obj, _scissorsize);
+
+//|   .. method:: ScissorXY(x, y)
+//|
+//|     Set the top left corner of the scissor clip rectangle
+//|
+//|     :param int x: The :math:`x` coordinate of the scissor clip rectangle, in pixels. Range 0-2047. The initial value is 0
+//|     :param int y: The :math:`y` coordinate of the scissor clip rectangle, in pixels. Range 0-2047. The initial value is 0
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _scissorxy(mp_obj_t self, mp_obj_t a0, mp_obj_t a1) {
+    uint32_t x      = mp_obj_get_int_truncated(a0);
+    uint32_t y      = mp_obj_get_int_truncated(a1);
+    common_hal__eve_ScissorXY(EVEHAL(self), x, y);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(scissorxy_obj, _scissorxy);
+
+//|   .. method:: StencilFunc(func, ref, mask)
+//|
+//|     Set function and reference value for stencil testing
+//|
+//|     :param int func: specifies the test function, one of ``NEVER``, ``LESS``, ``LEQUAL``, ``GREATER``, ``GEQUAL``, ``EQUAL``, ``NOTEQUAL``, or ``ALWAYS``. Range 0-7. The initial value is ALWAYS(7)
+//|     :param int ref: specifies the reference value for the stencil test. Range 0-255. The initial value is 0
+//|     :param int mask: specifies a mask that is ANDed with the reference value and the stored stencil value. Range 0-255. The initial value is 255
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _stencilfunc(size_t n_args, const mp_obj_t *args) {
+    uint32_t func   = mp_obj_get_int_truncated(args[1]);
+    uint32_t ref    = mp_obj_get_int_truncated(args[2]);
+    uint32_t mask   = mp_obj_get_int_truncated(args[3]);
+    common_hal__eve_StencilFunc(EVEHAL(args[0]), func, ref, mask);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(stencilfunc_obj, 4, 4, _stencilfunc);
+
+//|   .. method:: StencilMask(mask)
+//|
+//|     Control the writing of individual bits in the stencil planes
+//|
+//|     :param int mask: the mask used to enable writing stencil bits. Range 0-255. The initial value is 255
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _stencilmask(mp_obj_t self, mp_obj_t a0) {
+    uint32_t mask   = mp_obj_get_int_truncated(a0);
+    common_hal__eve_StencilMask(EVEHAL(self), mask);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(stencilmask_obj, _stencilmask);
+
+//|   .. method:: StencilOp(sfail, spass)
+//|
+//|     Set stencil test actions
+//|
+//|     :param int sfail: specifies the action to take when the stencil test fails, one of ``KEEP``, ``ZERO``, ``REPLACE``, ``INCR``, ``INCR_WRAP``, ``DECR``, ``DECR_WRAP``, and ``INVERT``. Range 0-7. The initial value is KEEP(1)
+//|     :param int spass: specifies the action to take when the stencil test passes, one of the same constants as **sfail**. Range 0-7. The initial value is KEEP(1)
+//|
+//|     These values are part of the graphics context and are saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _stencilop(mp_obj_t self, mp_obj_t a0, mp_obj_t a1) {
+    uint32_t sfail  = mp_obj_get_int_truncated(a0);
+    uint32_t spass  = mp_obj_get_int_truncated(a1);
+    common_hal__eve_StencilOp(EVEHAL(self), sfail, spass);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(stencilop_obj, _stencilop);
+
+//|   .. method:: TagMask(mask)
+//|
+//|     Control the writing of the tag buffer
+//|
+//|     :param int mask: allow updates to the tag buffer. Range 0-1. The initial value is 1
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _tagmask(mp_obj_t self, mp_obj_t a0) {
+    uint32_t mask   = mp_obj_get_int_truncated(a0);
+    common_hal__eve_TagMask(EVEHAL(self), mask);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(tagmask_obj, _tagmask);
+
+//|   .. method:: Tag(s)
+//|
+//|     Set the current tag value
+//|
+//|     :param int s: tag value. Range 0-255. The initial value is 255
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _tag(mp_obj_t self, mp_obj_t a0) {
+    uint32_t s      = mp_obj_get_int_truncated(a0);
+    common_hal__eve_Tag(EVEHAL(self), s);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(tag_obj, _tag);
+
+//|   .. method:: VertexTranslateX(x)
+//|
+//|     Set the vertex transformation's x translation component
+//|
+//|     :param int x: signed x-coordinate in :math:`1/16` pixel. Range 0-131071. The initial value is 0
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _vertextranslatex(mp_obj_t self, mp_obj_t a0) {
+    uint32_t x      = mp_obj_get_int_truncated(a0);
+    common_hal__eve_VertexTranslateX(EVEHAL(self), x);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vertextranslatex_obj, _vertextranslatex);
+
+//|   .. method:: VertexTranslateY(y)
+//|
+//|     Set the vertex transformation's y translation component
+//|
+//|     :param int y: signed y-coordinate in :math:`1/16` pixel. Range 0-131071. The initial value is 0
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+
+STATIC mp_obj_t _vertextranslatey(mp_obj_t self, mp_obj_t a0) {
+    uint32_t y      = mp_obj_get_int_truncated(a0);
+    common_hal__eve_VertexTranslateY(EVEHAL(self), y);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vertextranslatey_obj, _vertextranslatey);
+
+//|   .. method:: VertexFormat(frac)
+//|
+//|     Set the precision of vertex2f coordinates
+//|
+//|     :param int frac: Number of fractional bits in X,Y coordinates, 0-4. Range 0-7. The initial value is 4
+//|
+//|     This value is part of the graphics context and is saved and restored by :meth:`SaveContext` and :meth:`RestoreContext`.
+//|
+
+STATIC mp_obj_t _vertexformat(mp_obj_t self, mp_obj_t a0) {
+    uint32_t frac   = mp_obj_get_int_truncated(a0);
+    common_hal__eve_VertexFormat(EVEHAL(self), frac);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(vertexformat_obj, _vertexformat);
+
+//|   .. method:: Vertex2ii(x, y, handle, cell)
+//|
+//|     :param int x: x-coordinate in pixels. Range 0-511
+//|     :param int y: y-coordinate in pixels. Range 0-511
+//|     :param int handle: bitmap handle. Range 0-31
+//|     :param int cell: cell number. Range 0-127
+//|
+//|     This method is an alternative to :meth:`Vertex2f`.
+//| 
+
+STATIC mp_obj_t _vertex2ii(size_t n_args, const mp_obj_t *args) {
+    uint32_t x      = mp_obj_get_int_truncated(args[1]);
+    uint32_t y      = mp_obj_get_int_truncated(args[2]);
+    uint32_t handle = (n_args > 3) ? mp_obj_get_int_truncated(args[3]) : 0;
+    uint32_t cell   = (n_args > 4) ? mp_obj_get_int_truncated(args[4]) : 0;
+    common_hal__eve_Vertex2ii(EVEHAL(args[0]), x, y, handle, cell);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(vertex2ii_obj, 3, 5, _vertex2ii);
+
+#define ROM_DECLS \
+    { MP_ROM_QSTR(MP_QSTR_AlphaFunc), MP_ROM_PTR(&alphafunc_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_Begin), MP_ROM_PTR(&begin_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapExtFormat), MP_ROM_PTR(&bitmapextformat_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapHandle), MP_ROM_PTR(&bitmaphandle_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapLayoutH), MP_ROM_PTR(&bitmaplayouth_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapLayout), MP_ROM_PTR(&bitmaplayout_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapSizeH), MP_ROM_PTR(&bitmapsizeh_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapSize), MP_ROM_PTR(&bitmapsize_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapSource), MP_ROM_PTR(&bitmapsource_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapSwizzle), MP_ROM_PTR(&bitmapswizzle_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapTransformA), MP_ROM_PTR(&bitmaptransforma_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapTransformB), MP_ROM_PTR(&bitmaptransformb_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapTransformC), MP_ROM_PTR(&bitmaptransformc_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapTransformD), MP_ROM_PTR(&bitmaptransformd_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapTransformE), MP_ROM_PTR(&bitmaptransforme_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BitmapTransformF), MP_ROM_PTR(&bitmaptransformf_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_BlendFunc), MP_ROM_PTR(&blendfunc_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_Call), MP_ROM_PTR(&call_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_Cell), MP_ROM_PTR(&cell_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_ClearColorA), MP_ROM_PTR(&clearcolora_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_ClearColorRGB), MP_ROM_PTR(&clearcolorrgb_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_Clear), MP_ROM_PTR(&clear_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_ClearStencil), MP_ROM_PTR(&clearstencil_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_ClearTag), MP_ROM_PTR(&cleartag_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_ColorA), MP_ROM_PTR(&colora_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_ColorMask), MP_ROM_PTR(&colormask_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_ColorRGB), MP_ROM_PTR(&colorrgb_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_Display), MP_ROM_PTR(&display_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_End), MP_ROM_PTR(&end_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_Jump), MP_ROM_PTR(&jump_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_LineWidth), MP_ROM_PTR(&linewidth_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_Macro), MP_ROM_PTR(&macro_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_Nop), MP_ROM_PTR(&nop_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_PaletteSource), MP_ROM_PTR(&palettesource_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_PointSize), MP_ROM_PTR(&pointsize_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_RestoreContext), MP_ROM_PTR(&restorecontext_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_Return), MP_ROM_PTR(&return_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_SaveContext), MP_ROM_PTR(&savecontext_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_ScissorSize), MP_ROM_PTR(&scissorsize_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_ScissorXY), MP_ROM_PTR(&scissorxy_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_StencilFunc), MP_ROM_PTR(&stencilfunc_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_StencilMask), MP_ROM_PTR(&stencilmask_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_StencilOp), MP_ROM_PTR(&stencilop_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_TagMask), MP_ROM_PTR(&tagmask_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_Tag), MP_ROM_PTR(&tag_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_VertexTranslateX), MP_ROM_PTR(&vertextranslatex_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_VertexTranslateY), MP_ROM_PTR(&vertextranslatey_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_VertexFormat), MP_ROM_PTR(&vertexformat_obj) }, \
+    { MP_ROM_QSTR(MP_QSTR_Vertex2ii), MP_ROM_PTR(&vertex2ii_obj) }
+
+//}
+
+// Hand-written functions {
+
+//|   .. method:: Vertex2f(b)
+//| 
+//|     Draw a point.
+//|
+//|     :param float x: pixel x-coordinate
+//|     :param float y: pixel y-coordinate
+//|
+STATIC mp_obj_t _vertex2f(mp_obj_t self, mp_obj_t a0, mp_obj_t a1) {
+    mp_float_t x = mp_obj_get_float(a0);
+    mp_float_t y = mp_obj_get_float(a1);
+    common_hal__eve_Vertex2f(EVEHAL(self), x, y);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(vertex2f_obj, _vertex2f);
+
+// Append an object x to the FIFO
+#define ADD_X(self, x) \
+    common_hal__eve_add(EVEHAL(self), sizeof(x), &(x));
+
+//|   .. method:: cmd0(n)
+//| 
+//|     Append the command word n to the FIFO
+//|
+//|     :param int n: The command code
+//|
+//|     This method is used by the ``eve`` module to efficiently add
+//|     commands to the FIFO.
+//|
+
+STATIC mp_obj_t _cmd0(mp_obj_t self, mp_obj_t n) {
+    uint32_t code = 0xffffff00 | mp_obj_get_int_truncated(n);
+    ADD_X(self, code);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(cmd0_obj, _cmd0);
+
+//|   .. method:: cmd(n, fmt, args)
+//| 
+//|     Append a command packet to the FIFO.
+//|
+//|     :param int n: The command code
+//|     :param str fmt: The command format `struct` layout
+//|     :param tuple args: The command's arguments
+//|
+//|     Supported format codes: h, H, i, I.
+//|
+//|     This method is used by the ``eve`` module to efficiently add
+//|     commands to the FIFO.
+//|
+STATIC mp_obj_t _cmd(size_t n_args, const mp_obj_t *args) {
+    mp_obj_t self = args[0];
+    mp_obj_t num = args[1];
+    mp_buffer_info_t fmt;
+    mp_get_buffer_raise(args[2], &fmt, MP_BUFFER_READ);
+    size_t len;
+    mp_obj_t *items;
+    mp_obj_tuple_get(args[3], &len, &items);
+
+    // Count how many 32-bit words required
+    size_t n = 0;
+    for (size_t i = 0; i < fmt.len; n++) {
+        switch (((char*)fmt.buf)[i]) {
+            case 'I':
+            case 'i':
+                i += 1;
+                break;
+            case 'H':
+            case 'h':
+                i += 2;
+                break;
+            default:
+                break;
+        }
+    }
+
+    uint32_t buf[16];
+    uint32_t *p = buf;
+    *p++ = 0xffffff00 | mp_obj_get_int_truncated(num);
+    mp_obj_t *a = items;
+    uint32_t lo;
+
+    for (size_t i = 0; i < fmt.len; ) {
+        switch (((char*)fmt.buf)[i]) {
+            case 'I':
+            case 'i':
+                *p++ = mp_obj_get_int_truncated(*a++);
+                i += 1;
+                break;
+            case 'H':
+            case 'h':
+                lo = mp_obj_get_int_truncated(*a++) & 0xffff;
+                *p++ = lo | (mp_obj_get_int_truncated(*a++) << 16);
+                i += 2;
+                break;
+            default:
+                break;
+        }
+    }
+
+    common_hal__eve_add(EVEHAL(self), sizeof(uint32_t) * (1 + n), buf);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(cmd_obj, 4, 4, _cmd);
+
+STATIC const mp_rom_map_elem_t _EVE_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_register), MP_ROM_PTR(&register_obj) },
+    { MP_ROM_QSTR(MP_QSTR_cc), MP_ROM_PTR(&cc_obj) },
+    { MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&flush_obj) },
+    { MP_ROM_QSTR(MP_QSTR_Vertex2f), MP_ROM_PTR(&vertex2f_obj) },
+    { MP_ROM_QSTR(MP_QSTR_cmd), MP_ROM_PTR(&cmd_obj) },
+    { MP_ROM_QSTR(MP_QSTR_cmd0), MP_ROM_PTR(&cmd0_obj) },
+    ROM_DECLS
+};
+STATIC MP_DEFINE_CONST_DICT(_EVE_locals_dict, _EVE_locals_dict_table);
+
+STATIC mp_obj_t _EVE_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    // mp_arg_check_num(n_args, kw_args, 1, 1, false);
+    mp_obj__EVE_t *o = m_new_obj(mp_obj__EVE_t);
+    o->base.type = &_EVE_type;
+    o->_eve.n = 0;
+    o->_eve.vscale = 16;
+    return MP_OBJ_FROM_PTR(o);
+}
+
+STATIC const mp_obj_type_t _EVE_type = {
+    { &mp_type_type },
+    .name = MP_QSTR__EVE,
+    .make_new = _EVE_make_new,
+    .locals_dict = (void*)&_EVE_locals_dict,
+};
+
+STATIC const mp_rom_map_elem_t mp_module__eve_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__eve) },
+    { MP_ROM_QSTR(MP_QSTR__EVE), MP_OBJ_FROM_PTR(&_EVE_type) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(mp_module__eve_globals, mp_module__eve_globals_table);
+
+const mp_obj_module_t _eve_module = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t*)&mp_module__eve_globals,
+};
diff --git a/shared-bindings/_eve/__init__.h b/shared-bindings/_eve/__init__.h
new file mode 100644
index 000000000..759a629bb
--- /dev/null
+++ b/shared-bindings/_eve/__init__.h
@@ -0,0 +1,84 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 James Bowman for Excamera Labs
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS__EVE___INIT___H
+#define MICROPY_INCLUDED_SHARED_BINDINGS__EVE___INIT___H
+
+void common_hal__eve_flush(common_hal__eve_t *eve);
+void common_hal__eve_add(common_hal__eve_t *eve, size_t len, void *buf);
+void common_hal__eve_Vertex2f(common_hal__eve_t *eve, mp_float_t x, mp_float_t y);
+
+void common_hal__eve_AlphaFunc(common_hal__eve_t *eve, uint32_t func, uint32_t ref);
+void common_hal__eve_Begin(common_hal__eve_t *eve, uint32_t prim);
+void common_hal__eve_BitmapExtFormat(common_hal__eve_t *eve, uint32_t fmt);
+void common_hal__eve_BitmapHandle(common_hal__eve_t *eve, uint32_t handle);
+void common_hal__eve_BitmapLayoutH(common_hal__eve_t *eve, uint32_t linestride, uint32_t height);
+void common_hal__eve_BitmapLayout(common_hal__eve_t *eve, uint32_t format, uint32_t linestride, uint32_t height);
+void common_hal__eve_BitmapSizeH(common_hal__eve_t *eve, uint32_t width, uint32_t height);
+void common_hal__eve_BitmapSize(common_hal__eve_t *eve, uint32_t filter, uint32_t wrapx, uint32_t wrapy, uint32_t width, uint32_t height);
+void common_hal__eve_BitmapSource(common_hal__eve_t *eve, uint32_t addr);
+void common_hal__eve_BitmapSwizzle(common_hal__eve_t *eve, uint32_t r, uint32_t g, uint32_t b, uint32_t a);
+void common_hal__eve_BitmapTransformA(common_hal__eve_t *eve, uint32_t p, uint32_t v);
+void common_hal__eve_BitmapTransformB(common_hal__eve_t *eve, uint32_t p, uint32_t v);
+void common_hal__eve_BitmapTransformC(common_hal__eve_t *eve, uint32_t v);
+void common_hal__eve_BitmapTransformD(common_hal__eve_t *eve, uint32_t p, uint32_t v);
+void common_hal__eve_BitmapTransformE(common_hal__eve_t *eve, uint32_t p, uint32_t v);
+void common_hal__eve_BitmapTransformF(common_hal__eve_t *eve, uint32_t v);
+void common_hal__eve_BlendFunc(common_hal__eve_t *eve, uint32_t src, uint32_t dst);
+void common_hal__eve_Call(common_hal__eve_t *eve, uint32_t dest);
+void common_hal__eve_Cell(common_hal__eve_t *eve, uint32_t cell);
+void common_hal__eve_ClearColorA(common_hal__eve_t *eve, uint32_t alpha);
+void common_hal__eve_ClearColorRGB(common_hal__eve_t *eve, uint32_t red, uint32_t green, uint32_t blue);
+void common_hal__eve_Clear(common_hal__eve_t *eve, uint32_t c, uint32_t s, uint32_t t);
+void common_hal__eve_ClearStencil(common_hal__eve_t *eve, uint32_t s);
+void common_hal__eve_ClearTag(common_hal__eve_t *eve, uint32_t s);
+void common_hal__eve_ColorA(common_hal__eve_t *eve, uint32_t alpha);
+void common_hal__eve_ColorMask(common_hal__eve_t *eve, uint32_t r, uint32_t g, uint32_t b, uint32_t a);
+void common_hal__eve_ColorRGB(common_hal__eve_t *eve, uint32_t red, uint32_t green, uint32_t blue);
+void common_hal__eve_Display(common_hal__eve_t *eve);
+void common_hal__eve_End(common_hal__eve_t *eve);
+void common_hal__eve_Jump(common_hal__eve_t *eve, uint32_t dest);
+void common_hal__eve_LineWidth(common_hal__eve_t *eve, uint32_t width);
+void common_hal__eve_Macro(common_hal__eve_t *eve, uint32_t m);
+void common_hal__eve_Nop(common_hal__eve_t *eve);
+void common_hal__eve_PaletteSource(common_hal__eve_t *eve, uint32_t addr);
+void common_hal__eve_PointSize(common_hal__eve_t *eve, uint32_t size);
+void common_hal__eve_RestoreContext(common_hal__eve_t *eve);
+void common_hal__eve_Return(common_hal__eve_t *eve);
+void common_hal__eve_SaveContext(common_hal__eve_t *eve);
+void common_hal__eve_ScissorSize(common_hal__eve_t *eve, uint32_t width, uint32_t height);
+void common_hal__eve_ScissorXY(common_hal__eve_t *eve, uint32_t x, uint32_t y);
+void common_hal__eve_StencilFunc(common_hal__eve_t *eve, uint32_t func, uint32_t ref, uint32_t mask);
+void common_hal__eve_StencilMask(common_hal__eve_t *eve, uint32_t mask);
+void common_hal__eve_StencilOp(common_hal__eve_t *eve, uint32_t sfail, uint32_t spass);
+void common_hal__eve_TagMask(common_hal__eve_t *eve, uint32_t mask);
+void common_hal__eve_Tag(common_hal__eve_t *eve, uint32_t s);
+void common_hal__eve_VertexTranslateX(common_hal__eve_t *eve, uint32_t x);
+void common_hal__eve_VertexTranslateY(common_hal__eve_t *eve, uint32_t y);
+void common_hal__eve_VertexFormat(common_hal__eve_t *eve, uint32_t frac);
+void common_hal__eve_Vertex2ii(common_hal__eve_t *eve, uint32_t x, uint32_t y, uint32_t handle, uint32_t cell);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS__EVE___INIT___H
diff --git a/shared-bindings/_pixelbuf/PixelBuf.c b/shared-bindings/_pixelbuf/PixelBuf.c
index 3e9319047..61b4c9ae0 100644
--- a/shared-bindings/_pixelbuf/PixelBuf.c
+++ b/shared-bindings/_pixelbuf/PixelBuf.c
@@ -36,13 +36,14 @@
 
 #include <string.h>
 
-#include "PixelBuf.h"
-#include "shared-bindings/_pixelbuf/types.h"
-#include "../../shared-module/_pixelbuf/PixelBuf.h"
+#include "shared-bindings/_pixelbuf/PixelBuf.h"
+#include "shared-module/_pixelbuf/PixelBuf.h"
 #include "shared-bindings/digitalio/DigitalInOut.h"
 
 extern const int32_t colorwheel(float pos);
 
+static void parse_byteorder(mp_obj_t byteorder_obj, pixelbuf_byteorder_details_t* parsed);
+
 //| .. currentmodule:: pixelbuf
 //|
 //| :class:`PixelBuf` -- A fast RGB[W] pixel buffer for LED and similar devices
@@ -50,140 +51,109 @@ extern const int32_t colorwheel(float pos);
 //|
 //| :class:`~_pixelbuf.PixelBuf` implements an RGB[W] bytearray abstraction.
 //|
-//| .. class:: PixelBuf(size, buf, byteorder="BGR", brightness=0, rawbuf=None, offset=0, auto_write=False)
+//| .. class:: PixelBuf(size, *, byteorder="BGR", brightness=0, auto_write=False, header=b"", trailer=b"")
 //|
 //|   Create a PixelBuf object of the specified size, byteorder, and bits per pixel.
 //|
-//|   When given a second bytearray (``rawbuf``), changing brightness adjusts the
-//|   brightness of all members of ``buf``.
-//|
-//|   When only given ``buf``, ``brightness`` applies to the next pixel assignment.
+//|   When brightness is less than 1.0, a second buffer will be used to store the color values
+//|   before they are adjusted for brightness.
 //|
-//|   When ``P`` (pwm duration) is present as the 4th character of the byteorder 
-//|   string, the 4th value in the tuple/list for a pixel is the individual pixel 
+//|   When ``P`` (pwm duration) is present as the 4th character of the byteorder
+//|   string, the 4th value in the tuple/list for a pixel is the individual pixel
 //|   brightness (0.0-1.0) and will enable a Dotstar compatible 1st byte in the
 //|   output buffer (``buf``).
 //|
 //|   :param ~int size: Number of pixelsx
-//|   :param ~bytearray buf: Bytearray in which to store pixel data
 //|   :param ~str byteorder: Byte order string (such as "BGR" or "PBGR")
 //|   :param ~float brightness: Brightness (0 to 1.0, default 1.0)
-//|   :param ~bytearray rawbuf: Bytearray in which to store raw pixel data (before brightness adjustment)
-//|   :param ~int offset: Offset from start of buffer (default 0)
 //|   :param ~bool auto_write: Whether to automatically write pixels (Default False)
+//|   :param bytes header: Sequence of bytes to always send before pixel values.
+//|   :param bytes trailer: Sequence of bytes to always send after pixel values.
 //|
 STATIC mp_obj_t pixelbuf_pixelbuf_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    mp_arg_check_num(n_args, kw_args, 2, MP_OBJ_FUN_ARGS_MAX, true);
-    enum { ARG_size, ARG_buf, ARG_byteorder, ARG_brightness, ARG_rawbuf, ARG_offset,
-           ARG_auto_write };
+    mp_arg_check_num(n_args, kw_args, 1, MP_OBJ_FUN_ARGS_MAX, true);
+    enum { ARG_size, ARG_byteorder, ARG_brightness, ARG_auto_write, ARG_header, ARG_trailer };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_size, MP_ARG_REQUIRED | MP_ARG_INT },
-        { MP_QSTR_buf, MP_ARG_REQUIRED | MP_ARG_OBJ },
-        { MP_QSTR_byteorder, MP_ARG_OBJ, { .u_obj = MP_OBJ_NEW_QSTR(MP_QSTR_BGR) } },
-        { MP_QSTR_brightness, MP_ARG_OBJ, { .u_obj = mp_const_none } },
-        { MP_QSTR_rawbuf, MP_ARG_OBJ, { .u_obj = mp_const_none } },
-        { MP_QSTR_offset, MP_ARG_INT, { .u_int = 0 } },
-        { MP_QSTR_auto_write, MP_ARG_BOOL, {.u_bool = false} },
+        { MP_QSTR_byteorder, MP_ARG_KW_ONLY | MP_ARG_OBJ, { .u_obj = MP_OBJ_NEW_QSTR(MP_QSTR_BGR) } },
+        { MP_QSTR_brightness, MP_ARG_KW_ONLY | MP_ARG_OBJ, { .u_obj = mp_const_none } },
+        { MP_QSTR_auto_write, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
+        { MP_QSTR_header, MP_ARG_KW_ONLY | MP_ARG_OBJ, { .u_obj = mp_const_none } },
+        { MP_QSTR_trailer, MP_ARG_KW_ONLY | MP_ARG_OBJ, { .u_obj = mp_const_none } },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-    const char *byteorder = NULL;
     pixelbuf_byteorder_details_t byteorder_details;
-    size_t bo_len;
 
-    if (!MP_OBJ_IS_STR(args[ARG_byteorder].u_obj))
+    parse_byteorder(args[ARG_byteorder].u_obj, &byteorder_details);
+
+    mp_buffer_info_t header_bufinfo;
+    mp_buffer_info_t trailer_bufinfo;
+
+    if (!mp_get_buffer(args[ARG_header].u_obj, &header_bufinfo, MP_BUFFER_READ)) {
+        header_bufinfo.buf = NULL;
+        header_bufinfo.len = 0;
+    }
+    if (!mp_get_buffer(args[ARG_trailer].u_obj, &trailer_bufinfo, MP_BUFFER_READ)) {
+        trailer_bufinfo.buf = NULL;
+        trailer_bufinfo.len = 0;
+    }
+
+    float brightness = 1.0;
+    if (args[ARG_brightness].u_obj != mp_const_none) {
+        brightness = mp_obj_get_float(args[ARG_brightness].u_obj);
+        if (brightness < 0) {
+            brightness = 0;
+        } else if (brightness > 1) {
+            brightness = 1;
+        }
+    }
+
+    // Validation complete, allocate and populate object.
+    pixelbuf_pixelbuf_obj_t *self = m_new_obj(pixelbuf_pixelbuf_obj_t);
+    self->base.type = &pixelbuf_pixelbuf_type;
+    common_hal__pixelbuf_pixelbuf_construct(self, args[ARG_size].u_int,
+    &byteorder_details, brightness, args[ARG_auto_write].u_bool, header_bufinfo.buf,
+    header_bufinfo.len, trailer_bufinfo.buf, trailer_bufinfo.len);
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+static void parse_byteorder(mp_obj_t byteorder_obj, pixelbuf_byteorder_details_t* parsed) {
+    if (!MP_OBJ_IS_STR(byteorder_obj)) {
         mp_raise_TypeError(translate("byteorder is not a string"));
+    }
 
-    byteorder = mp_obj_str_get_data(args[ARG_byteorder].u_obj, &bo_len);
-    if (bo_len < 3 || bo_len > 4)
+    size_t bo_len;
+    const char *byteorder = mp_obj_str_get_data(byteorder_obj, &bo_len);
+    if (bo_len < 3 || bo_len > 4) {
         mp_raise_ValueError(translate("Invalid byteorder string"));
-    byteorder_details.order = args[ARG_byteorder].u_obj;
+    }
+    parsed->order_string = byteorder_obj;
 
-    byteorder_details.bpp = bo_len;
+    parsed->bpp = bo_len;
     char *dotstar = strchr(byteorder, 'P');
     char *r = strchr(byteorder, 'R');
     char *g = strchr(byteorder, 'G');
     char *b = strchr(byteorder, 'B');
     char *w = strchr(byteorder, 'W');
     int num_chars = (dotstar ? 1 : 0) + (w ? 1 : 0) + (r ? 1 : 0) + (g ? 1 : 0) + (b ? 1 : 0);
-    if ((num_chars < byteorder_details.bpp) || !(r && b && g))
+    if ((num_chars < parsed->bpp) || !(r && b && g)) {
         mp_raise_ValueError(translate("Invalid byteorder string"));
-    byteorder_details.is_dotstar = dotstar ? true : false;
-    byteorder_details.has_white = w ? true : false;
-    byteorder_details.byteorder.r = r - byteorder;
-    byteorder_details.byteorder.g = g - byteorder;
-    byteorder_details.byteorder.b = b - byteorder;
-    byteorder_details.byteorder.w = w ? w - byteorder : 0;
+    }
+    parsed->is_dotstar = dotstar ? true : false;
+    parsed->has_white = w ? true : false;
+    parsed->byteorder.r = r - byteorder;
+    parsed->byteorder.g = g - byteorder;
+    parsed->byteorder.b = b - byteorder;
+    parsed->byteorder.w = w ? w - byteorder : 0;
     // The dotstar brightness byte is always first (as it goes with the pixel start bits)
     if (dotstar && byteorder[0] != 'P') {
         mp_raise_ValueError(translate("Invalid byteorder string"));
     }
-    if (byteorder_details.has_white && byteorder_details.is_dotstar)
+    if (parsed->has_white && parsed->is_dotstar) {
         mp_raise_ValueError(translate("Invalid byteorder string"));
-
-    size_t effective_bpp = byteorder_details.is_dotstar ? 4 : byteorder_details.bpp; // Always 4 for DotStar
-    size_t bytes = args[ARG_size].u_int * effective_bpp;
-    size_t offset = args[ARG_offset].u_int;
-    mp_buffer_info_t bufinfo, rawbufinfo;
-
-    mp_get_buffer_raise(args[ARG_buf].u_obj, &bufinfo, MP_BUFFER_READ | MP_BUFFER_WRITE);
-    bool two_buffers = args[ARG_rawbuf].u_obj != mp_const_none;
-    if (two_buffers) {
-        mp_get_buffer_raise(args[ARG_rawbuf].u_obj, &rawbufinfo, MP_BUFFER_READ | MP_BUFFER_WRITE);
-        if (rawbufinfo.len != bufinfo.len) {
-            mp_raise_ValueError(translate("rawbuf is not the same size as buf"));
-        }
-    }
-
-    if (bytes + offset > bufinfo.len)
-        mp_raise_ValueError_varg(translate("buf is too small. need %d bytes"), bytes + offset);
-
-    // Validation complete, allocate and populate object.
-    pixelbuf_pixelbuf_obj_t *self = m_new_obj(pixelbuf_pixelbuf_obj_t);
-
-    self->base.type = &pixelbuf_pixelbuf_type;
-    self->pixels = args[ARG_size].u_int;
-    self->bytes = bytes;
-    self->byteorder = byteorder_details;  // Copied because we modify for dotstar
-    self->bytearray = args[ARG_buf].u_obj;
-    self->two_buffers = two_buffers;
-    self->rawbytearray = two_buffers ? args[ARG_rawbuf].u_obj : NULL;
-    self->offset = offset;
-    self->buf = (uint8_t *)bufinfo.buf + offset;
-    self->rawbuf = two_buffers ? (uint8_t *)rawbufinfo.buf + offset : NULL;
-    self->pixel_step = effective_bpp;
-    self->auto_write = args[ARG_auto_write].u_bool;
-
-    if (args[ARG_brightness].u_obj == mp_const_none) {
-        self->brightness = 1.0;
-    } else {
-        self->brightness = mp_obj_get_float(args[ARG_brightness].u_obj);
-        if (self->brightness < 0)
-            self->brightness = 0;
-        else if (self->brightness > 1)
-            self->brightness = 1;
     }
-
-    if (self->byteorder.is_dotstar) {
-        // Initialize the buffer with the dotstar start bytes.
-        // Note: Header and end must be setup by caller
-        for (uint i = 0; i < self->pixels * 4; i += 4) {
-            self->buf[i] = DOTSTAR_LED_START_FULL_BRIGHT;
-            if (two_buffers) {
-                self->rawbuf[i] = DOTSTAR_LED_START_FULL_BRIGHT;
-            }
-        }
-    }
-
-    return MP_OBJ_FROM_PTR(self);
-}
-
-
-// Helper to ensure we have the native super class instead of a subclass.
-static pixelbuf_pixelbuf_obj_t* native_pixelbuf(mp_obj_t pixelbuf_obj) {
-    mp_obj_t native_pixelbuf = mp_instance_cast_to_native_base(pixelbuf_obj, &pixelbuf_pixelbuf_type);
-    mp_obj_assert_native_inited(native_pixelbuf);
-    return MP_OBJ_TO_PTR(native_pixelbuf);
 }
 
 //|   .. attribute:: bpp
@@ -191,8 +161,7 @@ static pixelbuf_pixelbuf_obj_t* native_pixelbuf(mp_obj_t pixelbuf_obj) {
 //|     The number of bytes per pixel in the buffer (read-only)
 //|
 STATIC mp_obj_t pixelbuf_pixelbuf_obj_get_bpp(mp_obj_t self_in) {
-    pixelbuf_pixelbuf_obj_t *self = native_pixelbuf(self_in);
-    return mp_obj_new_int_from_uint(self->byteorder.bpp);
+    return MP_OBJ_NEW_SMALL_INT(common_hal__pixelbuf_pixelbuf_get_bpp(self_in));
 }
 MP_DEFINE_CONST_FUN_OBJ_1(pixelbuf_pixelbuf_get_bpp_obj, pixelbuf_pixelbuf_obj_get_bpp);
 
@@ -207,30 +176,24 @@ const mp_obj_property_t pixelbuf_pixelbuf_bpp_obj = {
 //|   .. attribute:: brightness
 //|
 //|     Float value between 0 and 1.  Output brightness.
-//|     If the PixelBuf was allocated with two both a buf and a rawbuf,
-//|     setting this value causes a recomputation of the values in buf.
-//|     If only a buf was provided, then the brightness only applies to
-//|     future pixel changes.
-//|     In DotStar mode
+//|
+//|     When brightness is less than 1.0, a second buffer will be used to store the color values
+//|     before they are adjusted for brightness.
 //|
 STATIC mp_obj_t pixelbuf_pixelbuf_obj_get_brightness(mp_obj_t self_in) {
-    pixelbuf_pixelbuf_obj_t *self = native_pixelbuf(self_in);
-    return mp_obj_new_float(self->brightness);
+    return mp_obj_new_float(common_hal__pixelbuf_pixelbuf_get_brightness(self_in));
 }
 MP_DEFINE_CONST_FUN_OBJ_1(pixelbuf_pixelbuf_get_brightness_obj, pixelbuf_pixelbuf_obj_get_brightness);
 
 
 STATIC mp_obj_t pixelbuf_pixelbuf_obj_set_brightness(mp_obj_t self_in, mp_obj_t value) {
-    pixelbuf_pixelbuf_obj_t *self = native_pixelbuf(self_in);
-    self->brightness = mp_obj_float_get(value);
-    if (self->brightness > 1)
-        self->brightness = 1;
-    else if (self->brightness < 0)
-        self->brightness = 0;
-    if (self->two_buffers)
-        pixelbuf_recalculate_brightness(self);
-    if (self->auto_write)
-        pixelbuf_call_show(self_in);
+    mp_float_t brightness = mp_obj_float_get(value);
+    if (brightness > 1) {
+        brightness = 1;
+    } else if (brightness < 0) {
+        brightness = 0;
+    }
+    common_hal__pixelbuf_pixelbuf_set_brightness(self_in, brightness);
     return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_2(pixelbuf_pixelbuf_set_brightness_obj, pixelbuf_pixelbuf_obj_set_brightness);
@@ -242,37 +205,18 @@ const mp_obj_property_t pixelbuf_pixelbuf_brightness_obj = {
               (mp_obj_t)&mp_const_none_obj},
 };
 
-void pixelbuf_recalculate_brightness(pixelbuf_pixelbuf_obj_t *self) {
-    uint8_t *buf = (uint8_t *)self->buf;
-    uint8_t *rawbuf = (uint8_t *)self->rawbuf;
-    // Compensate for shifted buffer (bpp=3 dotstar)
-    for (uint i = 0; i < self->bytes; i++) {
-        // Don't adjust per-pixel luminance bytes in dotstar mode
-        if (!self->byteorder.is_dotstar || (i % 4 != 0))
-            buf[i] = rawbuf[i] * self->brightness;
-    }
-}
-
-mp_obj_t pixelbuf_call_show(mp_obj_t self_in) {
-    mp_obj_t dest[2];
-    mp_load_method(self_in, MP_QSTR_show, dest);
-    return mp_call_method_n_kw(0, 0, dest);
-}
-
 //|   .. attribute:: auto_write
 //|
 //|     Whether to automatically write the pixels after each update.
 //|
 STATIC mp_obj_t pixelbuf_pixelbuf_obj_get_auto_write(mp_obj_t self_in) {
-    pixelbuf_pixelbuf_obj_t *self = native_pixelbuf(self_in);
-    return mp_obj_new_bool(self->auto_write);
+    return mp_obj_new_bool(common_hal__pixelbuf_pixelbuf_get_auto_write(self_in));
 }
 MP_DEFINE_CONST_FUN_OBJ_1(pixelbuf_pixelbuf_get_auto_write_obj, pixelbuf_pixelbuf_obj_get_auto_write);
 
 
 STATIC mp_obj_t pixelbuf_pixelbuf_obj_set_auto_write(mp_obj_t self_in, mp_obj_t value) {
-    pixelbuf_pixelbuf_obj_t *self = native_pixelbuf(self_in);
-    self->auto_write = mp_obj_is_true(value);
+    common_hal__pixelbuf_pixelbuf_set_auto_write(self_in, mp_obj_is_true(value));
     return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_2(pixelbuf_pixelbuf_set_auto_write_obj, pixelbuf_pixelbuf_obj_set_auto_write);
@@ -284,33 +228,12 @@ const mp_obj_property_t pixelbuf_pixelbuf_auto_write_obj = {
               (mp_obj_t)&mp_const_none_obj},
 };
 
-
-//|   .. attribute:: buf
-//|
-//|     (read-only) bytearray of pixel data after brightness adjustment.  If an offset was provided
-//|     then this bytearray is the subset of the bytearray passed in that represents the
-//|     actual pixels.
-//|
-STATIC mp_obj_t pixelbuf_pixelbuf_obj_get_buf(mp_obj_t self_in) {
-    pixelbuf_pixelbuf_obj_t *self = native_pixelbuf(self_in);
-    return mp_obj_new_bytearray_by_ref(self->bytes, self->buf);
-}
-MP_DEFINE_CONST_FUN_OBJ_1(pixelbuf_pixelbuf_get_buf_obj, pixelbuf_pixelbuf_obj_get_buf);
-
-const mp_obj_property_t pixelbuf_pixelbuf_buf_obj = {
-    .base.type = &mp_type_property,
-    .proxy = {(mp_obj_t)&pixelbuf_pixelbuf_get_buf_obj,
-              (mp_obj_t)&mp_const_none_obj,
-              (mp_obj_t)&mp_const_none_obj},
-};
-
 //|   .. attribute:: byteorder
 //|
 //|     byteorder string for the buffer (read-only)
 //|
 STATIC mp_obj_t pixelbuf_pixelbuf_obj_get_byteorder(mp_obj_t self_in) {
-    pixelbuf_pixelbuf_obj_t *self = native_pixelbuf(self_in);
-    return self->byteorder.order;
+    return common_hal__pixelbuf_pixelbuf_get_byteorder_string(self_in);
 }
 MP_DEFINE_CONST_FUN_OBJ_1(pixelbuf_pixelbuf_get_byteorder_str, pixelbuf_pixelbuf_obj_get_byteorder);
 
@@ -322,32 +245,49 @@ const mp_obj_property_t pixelbuf_pixelbuf_byteorder_str = {
 };
 
 STATIC mp_obj_t pixelbuf_pixelbuf_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
-    pixelbuf_pixelbuf_obj_t *self = native_pixelbuf(self_in);
     switch (op) {
         case MP_UNARY_OP_BOOL: return mp_const_true;
-        case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->pixels);
+        case MP_UNARY_OP_LEN:
+            return MP_OBJ_NEW_SMALL_INT(common_hal__pixelbuf_pixelbuf_get_len(self_in));
         default: return MP_OBJ_NULL; // op not supported
     }
 }
 
 //|   .. method:: show()
 //|
-//|     Must be implemented in subclasses.
+//|     Transmits the color data to the pixels so that they are shown. This is done automatically
+//|     when `auto_write` is True.
 //|
 
 STATIC mp_obj_t pixelbuf_pixelbuf_show(mp_obj_t self_in) {
-    mp_raise_NotImplementedError(NULL);
+    common_hal__pixelbuf_pixelbuf_show(self_in);
+    return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pixelbuf_pixelbuf_show_obj, pixelbuf_pixelbuf_show);
 
+//| .. function:: fill(color)
+//|
+//|   Fills the given pixelbuf with the given color.
+//|
+
+STATIC mp_obj_t pixelbuf_pixelbuf_fill(mp_obj_t self_in, mp_obj_t value) {
+    common_hal__pixelbuf_pixelbuf_fill(self_in, value);
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(pixelbuf_pixelbuf_fill_obj, pixelbuf_pixelbuf_fill);
+
 
 //|   .. method:: __getitem__(index)
 //|
-//|     Returns the pixel value at the given index.
+//|     Returns the pixel value at the given index as a tuple of (Red, Green, Blue[, White]) values
+//|     between 0 and 255.
 //|
 //|   .. method:: __setitem__(index, value)
 //|
-//|     Sets the pixel value at the given index.
+//|     Sets the pixel value at the given index. Value can either be a tuple of (Red, Green, Blue
+//|     [, White]) values between 0 and 255 or an integer where the red, green and blue values are
+//|     packed into the lower three bytes (0xRRGGBB).
 //|
 STATIC mp_obj_t pixelbuf_pixelbuf_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value) {
     if (value == MP_OBJ_NULL) {
@@ -356,32 +296,34 @@ STATIC mp_obj_t pixelbuf_pixelbuf_subscr(mp_obj_t self_in, mp_obj_t index_in, mp
         return MP_OBJ_NULL; // op not supported
     }
 
-    pixelbuf_pixelbuf_obj_t *self = native_pixelbuf(self_in);
-
     if (0) {
 #if MICROPY_PY_BUILTINS_SLICE
     } else if (MP_OBJ_IS_TYPE(index_in, &mp_type_slice)) {
         mp_bound_slice_t slice;
 
-        mp_seq_get_fast_slice_indexes(self->pixels, index_in, &slice);
+        size_t length = common_hal__pixelbuf_pixelbuf_get_len(self_in);
+        mp_seq_get_fast_slice_indexes(length, index_in, &slice);
 
-        if ((slice.stop * self->pixel_step) > self->bytes)
-            mp_raise_IndexError(translate("Range out of bounds"));
-        if (slice.step < 0)
+        if (slice.step < 0) {
             mp_raise_IndexError(translate("Negative step not supported"));
+        }
 
         if (value == MP_OBJ_SENTINEL) { // Get
             size_t len = slice.stop - slice.start;
             if (slice.step > 1) {
                 len = (len / slice.step) + (len % slice.step ? 1 : 0);
             }
-            uint8_t *readbuf = self->two_buffers ? self->rawbuf : self->buf;
-            return pixelbuf_get_pixel_array(readbuf + slice.start, len, &self->byteorder, self->pixel_step, slice.step, self->byteorder.is_dotstar);
+            mp_obj_tuple_t* t = MP_OBJ_TO_PTR(mp_obj_new_tuple(len, NULL));
+            for (uint i = 0; i < len; i++) {
+                t->items[i] = common_hal__pixelbuf_pixelbuf_get_pixel(self_in, i * slice.step);
+            }
+            return MP_OBJ_FROM_PTR(t);
         } else { // Set
             #if MICROPY_PY_ARRAY_SLICE_ASSIGN
 
-            if (!(MP_OBJ_IS_TYPE(value, &mp_type_list) || MP_OBJ_IS_TYPE(value, &mp_type_tuple)))
+            if (!(MP_OBJ_IS_TYPE(value, &mp_type_list) || MP_OBJ_IS_TYPE(value, &mp_type_tuple))) {
                 mp_raise_ValueError(translate("tuple/list required on RHS"));
+            }
 
             size_t dst_len = (slice.stop - slice.start);
             if (slice.step > 1) {
@@ -398,21 +340,12 @@ STATIC mp_obj_t pixelbuf_pixelbuf_subscr(mp_obj_t self_in, mp_obj_t index_in, mp
                 num_items = l->len;
                 src_objs = l->items;
             }
-            if (num_items != dst_len)
+            if (num_items != dst_len) {
                 mp_raise_ValueError_varg(translate("Unmatched number of items on RHS (expected %d, got %d)."),
                                                    dst_len, num_items);
-
-            size_t target_i = slice.start;
-            for (size_t i = slice.start; target_i < slice.stop; i++, target_i += slice.step) {
-                mp_obj_t *item = src_objs[i-slice.start];
-                if (MP_OBJ_IS_TYPE(value, &mp_type_list) || MP_OBJ_IS_TYPE(value, &mp_type_tuple) || MP_OBJ_IS_INT(value)) {
-                    pixelbuf_set_pixel(self->buf + (target_i * self->pixel_step),
-                        self->two_buffers ? self->rawbuf + (i * self->pixel_step) : NULL,
-                        self->brightness, item, &self->byteorder, self->byteorder.is_dotstar);
-                }
             }
-            if (self->auto_write)
-                pixelbuf_call_show(self_in);
+
+            common_hal__pixelbuf_pixelbuf_set_pixels(self_in, slice.start, slice.stop, slice.step, src_objs);
             return mp_const_none;
             #else
             return MP_OBJ_NULL; // op not supported
@@ -420,19 +353,13 @@ STATIC mp_obj_t pixelbuf_pixelbuf_subscr(mp_obj_t self_in, mp_obj_t index_in, mp
         }
 #endif
     } else { // Single index rather than slice.
-        size_t index = mp_get_index(self->base.type, self->pixels, index_in, false);
-        size_t offset = (index * self->pixel_step);
-        if (offset > self->bytes)
-            mp_raise_IndexError(translate("Pixel beyond bounds of buffer"));
+        size_t length = common_hal__pixelbuf_pixelbuf_get_len(self_in);
+        size_t index = mp_get_index(mp_obj_get_type(self_in), length, index_in, false);
 
         if (value == MP_OBJ_SENTINEL) { // Get
-            uint8_t *pixelstart = (uint8_t *)(self->two_buffers ? self->rawbuf : self->buf) + offset;
-            return pixelbuf_get_pixel(pixelstart, &self->byteorder, self->byteorder.is_dotstar);
+            return common_hal__pixelbuf_pixelbuf_get_pixel(self_in, index);
         } else { // Store
-            pixelbuf_set_pixel(self->buf + offset, self->two_buffers ? self->rawbuf + offset : NULL,
-                self->brightness, value, &self->byteorder, self->byteorder.is_dotstar);
-            if (self->auto_write)
-                pixelbuf_call_show(self_in);
+            common_hal__pixelbuf_pixelbuf_set_pixel(self_in, index, value);
             return mp_const_none;
         }
     }
@@ -442,9 +369,9 @@ STATIC const mp_rom_map_elem_t pixelbuf_pixelbuf_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_auto_write), MP_ROM_PTR(&pixelbuf_pixelbuf_auto_write_obj)},
     { MP_ROM_QSTR(MP_QSTR_bpp), MP_ROM_PTR(&pixelbuf_pixelbuf_bpp_obj)},
     { MP_ROM_QSTR(MP_QSTR_brightness), MP_ROM_PTR(&pixelbuf_pixelbuf_brightness_obj)},
-    { MP_ROM_QSTR(MP_QSTR_buf), MP_ROM_PTR(&pixelbuf_pixelbuf_buf_obj)},
     { MP_ROM_QSTR(MP_QSTR_byteorder), MP_ROM_PTR(&pixelbuf_pixelbuf_byteorder_str)},
     { MP_ROM_QSTR(MP_QSTR_show), MP_ROM_PTR(&pixelbuf_pixelbuf_show_obj)},
+    { MP_ROM_QSTR(MP_QSTR_fill), MP_ROM_PTR(&pixelbuf_pixelbuf_fill_obj)},
 };
 
 STATIC MP_DEFINE_CONST_DICT(pixelbuf_pixelbuf_locals_dict, pixelbuf_pixelbuf_locals_dict_table);
diff --git a/shared-bindings/_pixelbuf/PixelBuf.h b/shared-bindings/_pixelbuf/PixelBuf.h
index 691da3cd3..68d6d4eef 100644
--- a/shared-bindings/_pixelbuf/PixelBuf.h
+++ b/shared-bindings/_pixelbuf/PixelBuf.h
@@ -27,27 +27,26 @@
 #ifndef CP_SHARED_BINDINGS_PIXELBUF_PIXELBUF_H
 #define CP_SHARED_BINDINGS_PIXELBUF_PIXELBUF_H
 
-#include "shared-bindings/_pixelbuf/types.h"
+#include "shared-module/_pixelbuf/PixelBuf.h"
 
 const mp_obj_type_t pixelbuf_pixelbuf_type;
 
-typedef struct {
-    mp_obj_base_t base;
-    size_t pixels;
-    size_t bytes;
-    size_t pixel_step;
-    pixelbuf_byteorder_details_t byteorder;
-    mp_obj_t bytearray;
-    mp_obj_t rawbytearray;
-    mp_float_t brightness;
-    bool two_buffers;
-    size_t offset;
-    uint8_t *rawbuf;
-    uint8_t *buf;
-    bool auto_write;
-} pixelbuf_pixelbuf_obj_t;
+void common_hal__pixelbuf_pixelbuf_construct(pixelbuf_pixelbuf_obj_t *self, size_t n,
+    pixelbuf_byteorder_details_t* byteorder, mp_float_t brightness, bool auto_write, uint8_t* header,
+    size_t header_len, uint8_t* trailer, size_t trailer_len);
 
-void pixelbuf_recalculate_brightness(pixelbuf_pixelbuf_obj_t *self);
-mp_obj_t pixelbuf_call_show(mp_obj_t self_in);
+// These take mp_obj_t because they are called on subclasses of PixelBuf.
+uint8_t common_hal__pixelbuf_pixelbuf_get_bpp(mp_obj_t self);
+mp_float_t common_hal__pixelbuf_pixelbuf_get_brightness(mp_obj_t self);
+void common_hal__pixelbuf_pixelbuf_set_brightness(mp_obj_t self, mp_float_t brightness);
+bool common_hal__pixelbuf_pixelbuf_get_auto_write(mp_obj_t self);
+void common_hal__pixelbuf_pixelbuf_set_auto_write(mp_obj_t self, bool auto_write);
+size_t common_hal__pixelbuf_pixelbuf_get_len(mp_obj_t self_in);
+mp_obj_t common_hal__pixelbuf_pixelbuf_get_byteorder_string(mp_obj_t self);
+void common_hal__pixelbuf_pixelbuf_fill(mp_obj_t self, mp_obj_t item);
+void common_hal__pixelbuf_pixelbuf_show(mp_obj_t self);
+mp_obj_t common_hal__pixelbuf_pixelbuf_get_pixel(mp_obj_t self, size_t index);
+void common_hal__pixelbuf_pixelbuf_set_pixel(mp_obj_t self, size_t index, mp_obj_t item);
+void common_hal__pixelbuf_pixelbuf_set_pixels(mp_obj_t self_in, size_t start, size_t stop, size_t step, mp_obj_t* values);
 
 #endif  // CP_SHARED_BINDINGS_PIXELBUF_PIXELBUF_H
diff --git a/shared-bindings/_pixelbuf/__init__.c b/shared-bindings/_pixelbuf/__init__.c
index ed264f3bb..424ed23e4 100644
--- a/shared-bindings/_pixelbuf/__init__.c
+++ b/shared-bindings/_pixelbuf/__init__.c
@@ -29,11 +29,8 @@
 #include "py/runtime.h"
 #include "py/objproperty.h"
 
-#include "types.h"
-#include "__init__.h"
-
-#include "PixelBuf.h"
-#include "../../shared-module/_pixelbuf/PixelBuf.h"
+#include "shared-bindings/_pixelbuf/__init__.h"
+#include "shared-bindings/_pixelbuf/PixelBuf.h"
 
 
 //| :mod:`_pixelbuf` --- Fast RGB(W) pixel buffer and helpers
@@ -82,39 +79,15 @@ const int32_t colorwheel(float pos) {
     }
 }
 
-
-//| .. function:: fill(pixelbuf, color)
-//|
-//|   Fills the given pixelbuf with the given color.
-//|
-
-STATIC mp_obj_t pixelbuf_fill(mp_obj_t pixelbuf_in, mp_obj_t value) {
-    mp_obj_t obj = mp_instance_cast_to_native_base(pixelbuf_in, &pixelbuf_pixelbuf_type);
-    if (obj == MP_OBJ_NULL)
-        mp_raise_TypeError(translate("Expected a PixelBuf instance"));
-    pixelbuf_pixelbuf_obj_t *pixelbuf = MP_OBJ_TO_PTR(obj);
-
-    for (size_t offset = 0; offset < pixelbuf->bytes; offset+= pixelbuf->pixel_step) {
-        pixelbuf_set_pixel(pixelbuf->buf + offset, pixelbuf->two_buffers ? (pixelbuf->rawbuf + offset) : NULL,
-                           pixelbuf->brightness, value, &pixelbuf->byteorder, pixelbuf->byteorder.is_dotstar);
-    }
-    if (pixelbuf->auto_write)
-        pixelbuf_call_show(pixelbuf_in);
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(pixelbuf_fill_obj, pixelbuf_fill);
-
-
 STATIC const mp_rom_map_elem_t pixelbuf_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__pixelbuf) },
     { MP_ROM_QSTR(MP_QSTR_PixelBuf), MP_ROM_PTR(&pixelbuf_pixelbuf_type) },
     { MP_ROM_QSTR(MP_QSTR_wheel), MP_ROM_PTR(&pixelbuf_wheel_obj) },
-    { MP_ROM_QSTR(MP_QSTR_fill), MP_ROM_PTR(&pixelbuf_fill_obj) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(pixelbuf_module_globals, pixelbuf_module_globals_table);
 
 const mp_obj_module_t pixelbuf_module = {
-        .base = { &mp_type_module },
-        .globals = (mp_obj_dict_t*)&pixelbuf_module_globals,
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t*)&pixelbuf_module_globals,
 };
diff --git a/shared-bindings/_pixelbuf/__init__.h b/shared-bindings/_pixelbuf/__init__.h
index f70ffe508..0e8c4a37f 100644
--- a/shared-bindings/_pixelbuf/__init__.h
+++ b/shared-bindings/_pixelbuf/__init__.h
@@ -30,6 +30,5 @@
 #include "common-hal/digitalio/DigitalInOut.h"
 
 const int32_t colorwheel(float pos);
-extern void common_hal_neopixel_write(const digitalio_digitalinout_obj_t* gpio, uint8_t *pixels, uint32_t numBytes);
 
 #endif //CP_SHARED_BINDINGS_PIXELBUF_INIT_H
diff --git a/shared-bindings/_pixelbuf/types.h b/shared-bindings/_pixelbuf/types.h
deleted file mode 100644
index f7dc1a109..000000000
--- a/shared-bindings/_pixelbuf/types.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * This file is part of the Circuit Python project, https://github.com/adafruit/circuitpython
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2018 Roy Hooper
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#ifndef CIRCUITPYTHON_PIXELBUF_TYPES_H
-#define CIRCUITPYTHON_PIXELBUF_TYPES_H
-
-//| :orphan:
-
-typedef struct {
-    uint8_t r;
-    uint8_t g;
-    uint8_t b;
-    uint8_t w;
-} pixelbuf_rgbw_t;
-
-typedef struct {
-    uint8_t bpp;
-    pixelbuf_rgbw_t byteorder;
-    bool has_white;
-    bool is_dotstar;
-    mp_obj_t *order;
-} pixelbuf_byteorder_details_t;
-
-#endif // CIRCUITPYTHON_PIXELBUF_TYPES_H
diff --git a/shared-bindings/_stage/__init__.c b/shared-bindings/_stage/__init__.c
index 1154bbbf1..4bac280bf 100644
--- a/shared-bindings/_stage/__init__.c
+++ b/shared-bindings/_stage/__init__.c
@@ -51,7 +51,7 @@
 //|     Layer
 //|     Text
 //|
-//| .. function:: render(x0, y0, x1, y1, layers, buffer, display[, scale])
+//| .. function:: render(x0, y0, x1, y1, layers, buffer, display[, scale[, background]])
 //|
 //|     Render and send to the display a fragment of the screen.
 //|
@@ -63,6 +63,7 @@
 //|     :param bytearray buffer: A buffer to use for rendering.
 //|     :param ~displayio.Display display: The display to use.
 //|     :param int scale: How many times should the image be scaled up.
+//|     :param int background: What color to display when nothing is there.
 //|
 //|     There are also no sanity checks, outside of the basic overflow
 //|     checking. The caller is responsible for making the passed parameters
@@ -92,12 +93,16 @@ STATIC mp_obj_t stage_render(size_t n_args, const mp_obj_t *args) {
     }
     displayio_display_obj_t *display = MP_OBJ_TO_PTR(native_display);
     uint8_t scale = 1;
-    if (n_args >= 8) {
+    if (n_args > 7) {
         scale = mp_obj_get_int(args[7]);
     }
+    uint16_t background = 0;
+    if (n_args > 8) {
+        background = mp_obj_get_int(args[8]);
+    }
 
     render_stage(x0, y0, x1, y1, layers, layers_size, buffer, buffer_size,
-                 display, scale);
+                 display, scale, background);
 
     return mp_const_none;
 }
diff --git a/shared-bindings/analogio/AnalogIn.c b/shared-bindings/analogio/AnalogIn.c
index 9a9b525d8..b4eeb2af1 100644
--- a/shared-bindings/analogio/AnalogIn.c
+++ b/shared-bindings/analogio/AnalogIn.c
@@ -63,16 +63,13 @@ STATIC mp_obj_t analogio_analogin_make_new(const mp_obj_type_t *type,
     mp_arg_check_num(n_args, kw_args, 1, 1, false);
 
     // 1st argument is the pin
-    mp_obj_t pin_obj = args[0];
-    assert_pin(pin_obj, false);
+    const mcu_pin_obj_t *pin = validate_obj_is_free_pin(args[0]);
 
     analogio_analogin_obj_t *self = m_new_obj(analogio_analogin_obj_t);
     self->base.type = &analogio_analogin_type;
-    const mcu_pin_obj_t *pin = MP_OBJ_TO_PTR(pin_obj);
-    assert_pin_free(pin);
     common_hal_analogio_analogin_construct(self, pin);
 
-    return (mp_obj_t) self;
+    return MP_OBJ_FROM_PTR(self);
 }
 
 //|   .. method:: deinit()
@@ -141,7 +138,7 @@ STATIC mp_obj_t analogio_analogin_obj_get_reference_voltage(mp_obj_t self_in) {
 
     float reference_voltage = common_hal_analogio_analogin_get_reference_voltage(self);
     if (reference_voltage <= 0.0f) {
-        return mp_const_none; 
+        return mp_const_none;
     } else {
         return mp_obj_new_float(reference_voltage);
     }
diff --git a/shared-bindings/analogio/AnalogOut.c b/shared-bindings/analogio/AnalogOut.c
index 0816da465..89cf147b2 100644
--- a/shared-bindings/analogio/AnalogOut.c
+++ b/shared-bindings/analogio/AnalogOut.c
@@ -62,15 +62,13 @@ STATIC mp_obj_t analogio_analogout_make_new(const mp_obj_type_t *type, mp_uint_t
     // check arguments
     mp_arg_check_num(n_args, kw_args, 1, 1, false);
 
-    assert_pin(args[0], false);
-    const mcu_pin_obj_t *pin = MP_OBJ_TO_PTR(args[0]);
+    const mcu_pin_obj_t *pin = validate_obj_is_free_pin(args[0]);
 
     analogio_analogout_obj_t *self = m_new_obj(analogio_analogout_obj_t);
     self->base.type = &analogio_analogout_type;
-    assert_pin_free(pin);
     common_hal_analogio_analogout_construct(self, pin);
 
-    return self;
+    return MP_OBJ_FROM_PTR(self);
 }
 
 //|   .. method:: deinit()
diff --git a/shared-bindings/audiobusio/I2SOut.c b/shared-bindings/audiobusio/I2SOut.c
index 8f7382fde..cd662acb5 100644
--- a/shared-bindings/audiobusio/I2SOut.c
+++ b/shared-bindings/audiobusio/I2SOut.c
@@ -105,17 +105,9 @@ STATIC mp_obj_t audiobusio_i2sout_make_new(const mp_obj_type_t *type, size_t n_a
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    mp_obj_t bit_clock_obj = args[ARG_bit_clock].u_obj;
-    assert_pin(bit_clock_obj, false);
-    const mcu_pin_obj_t *bit_clock = MP_OBJ_TO_PTR(bit_clock_obj);
-
-    mp_obj_t word_select_obj = args[ARG_word_select].u_obj;
-    assert_pin(word_select_obj, false);
-    const mcu_pin_obj_t *word_select = MP_OBJ_TO_PTR(word_select_obj);
-
-    mp_obj_t data_obj = args[ARG_data].u_obj;
-    assert_pin(data_obj, false);
-    const mcu_pin_obj_t *data = MP_OBJ_TO_PTR(data_obj);
+    const mcu_pin_obj_t *bit_clock = validate_obj_is_free_pin(args[ARG_bit_clock].u_obj);
+    const mcu_pin_obj_t *word_select = validate_obj_is_free_pin(args[ARG_word_select].u_obj);
+    const mcu_pin_obj_t *data = validate_obj_is_free_pin(args[ARG_data].u_obj);
 
     audiobusio_i2sout_obj_t *self = m_new_obj_with_finaliser(audiobusio_i2sout_obj_t);
     self->base.type = &audiobusio_i2sout_type;
diff --git a/shared-bindings/audiobusio/PDMIn.c b/shared-bindings/audiobusio/PDMIn.c
index 0c92c2478..fce6cf7a2 100644
--- a/shared-bindings/audiobusio/PDMIn.c
+++ b/shared-bindings/audiobusio/PDMIn.c
@@ -104,15 +104,8 @@ STATIC mp_obj_t audiobusio_pdmin_make_new(const mp_obj_type_t *type, size_t n_ar
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    mp_obj_t clock_pin_obj = args[ARG_clock_pin].u_obj;
-    assert_pin(clock_pin_obj, false);
-    const mcu_pin_obj_t *clock_pin = MP_OBJ_TO_PTR(clock_pin_obj);
-    assert_pin_free(clock_pin);
-
-    mp_obj_t data_pin_obj = args[ARG_data_pin].u_obj;
-    assert_pin(data_pin_obj, false);
-    const mcu_pin_obj_t *data_pin = MP_OBJ_TO_PTR(data_pin_obj);
-    assert_pin_free(data_pin);
+    const mcu_pin_obj_t *clock_pin = validate_obj_is_free_pin(args[ARG_clock_pin].u_obj);
+    const mcu_pin_obj_t *data_pin = validate_obj_is_free_pin(args[ARG_data_pin].u_obj);
 
     // create PDMIn object from the given pin
     audiobusio_pdmin_obj_t *self = m_new_obj(audiobusio_pdmin_obj_t);
diff --git a/shared-bindings/audiocore/RawSample.c b/shared-bindings/audiocore/RawSample.c
index 87d410ea1..96af58a4f 100644
--- a/shared-bindings/audiocore/RawSample.c
+++ b/shared-bindings/audiocore/RawSample.c
@@ -49,7 +49,7 @@
 //|   first sample will be for channel 1, the second sample will be for channel two, the third for
 //|   channel 1 and so on.
 //|
-//|   :param array buffer: An `array.array` with samples
+//|   :param array.array buffer: An `array.array` with samples
 //|   :param int channel_count: The number of channels in the buffer
 //|   :param int sample_rate: The desired playback sample rate
 //|
diff --git a/shared-bindings/audioio/AudioOut.c b/shared-bindings/audioio/AudioOut.c
index eb4ef1fc6..ea1efcdff 100644
--- a/shared-bindings/audioio/AudioOut.c
+++ b/shared-bindings/audioio/AudioOut.c
@@ -104,16 +104,8 @@ STATIC mp_obj_t audioio_audioout_make_new(const mp_obj_type_t *type, size_t n_ar
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    mp_obj_t left_channel_obj = args[ARG_left_channel].u_obj;
-    assert_pin(left_channel_obj, false);
-    const mcu_pin_obj_t *left_channel_pin = MP_OBJ_TO_PTR(left_channel_obj);
-
-    mp_obj_t right_channel_obj = args[ARG_right_channel].u_obj;
-    const mcu_pin_obj_t *right_channel_pin = NULL;
-    if (right_channel_obj != mp_const_none) {
-        assert_pin(right_channel_obj, false);
-        right_channel_pin = MP_OBJ_TO_PTR(right_channel_obj);
-    }
+    const mcu_pin_obj_t *left_channel_pin = validate_obj_is_free_pin(args[ARG_left_channel].u_obj);
+    const mcu_pin_obj_t *right_channel_pin = validate_obj_is_free_pin_or_none(args[ARG_right_channel].u_obj);
 
     // create AudioOut object from the given pin
     audioio_audioout_obj_t *self = m_new_obj(audioio_audioout_obj_t);
diff --git a/shared-bindings/audiopwmio/PWMAudioOut.c b/shared-bindings/audiopwmio/PWMAudioOut.c
index 60bf08500..9fa2b1578 100644
--- a/shared-bindings/audiopwmio/PWMAudioOut.c
+++ b/shared-bindings/audiopwmio/PWMAudioOut.c
@@ -107,16 +107,8 @@ STATIC mp_obj_t audiopwmio_pwmaudioout_make_new(const mp_obj_type_t *type, size_
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    mp_obj_t left_channel_obj = args[ARG_left_channel].u_obj;
-    assert_pin(left_channel_obj, false);
-    const mcu_pin_obj_t *left_channel_pin = MP_OBJ_TO_PTR(left_channel_obj);
-
-    mp_obj_t right_channel_obj = args[ARG_right_channel].u_obj;
-    const mcu_pin_obj_t *right_channel_pin = NULL;
-    if (right_channel_obj != mp_const_none) {
-        assert_pin(right_channel_obj, false);
-        right_channel_pin = MP_OBJ_TO_PTR(right_channel_obj);
-    }
+    const mcu_pin_obj_t *left_channel_pin = validate_obj_is_free_pin(args[ARG_left_channel].u_obj);
+    const mcu_pin_obj_t *right_channel_pin = validate_obj_is_free_pin_or_none(args[ARG_right_channel].u_obj);
 
     // create AudioOut object from the given pin
     audiopwmio_pwmaudioout_obj_t *self = m_new_obj(audiopwmio_pwmaudioout_obj_t);
diff --git a/shared-bindings/bitbangio/I2C.c b/shared-bindings/bitbangio/I2C.c
index 01a128393..3c4f13777 100644
--- a/shared-bindings/bitbangio/I2C.c
+++ b/shared-bindings/bitbangio/I2C.c
@@ -63,10 +63,9 @@ STATIC mp_obj_t bitbangio_i2c_make_new(const mp_obj_type_t *type, size_t n_args,
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-    assert_pin(args[ARG_scl].u_obj, false);
-    assert_pin(args[ARG_sda].u_obj, false);
-    const mcu_pin_obj_t* scl = MP_OBJ_TO_PTR(args[ARG_scl].u_obj);
-    const mcu_pin_obj_t* sda = MP_OBJ_TO_PTR(args[ARG_sda].u_obj);
+
+    const mcu_pin_obj_t* scl = validate_obj_is_free_pin(args[ARG_scl].u_obj);
+    const mcu_pin_obj_t* sda = validate_obj_is_free_pin(args[ARG_sda].u_obj);
 
     bitbangio_i2c_obj_t *self = m_new_obj(bitbangio_i2c_obj_t);
     self->base.type = &bitbangio_i2c_type;
diff --git a/shared-bindings/bitbangio/OneWire.c b/shared-bindings/bitbangio/OneWire.c
index 73bedcd8d..95bbd0679 100644
--- a/shared-bindings/bitbangio/OneWire.c
+++ b/shared-bindings/bitbangio/OneWire.c
@@ -69,9 +69,8 @@ STATIC mp_obj_t bitbangio_onewire_make_new(const mp_obj_type_t *type, size_t n_a
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-    assert_pin(args[ARG_pin].u_obj, false);
-    const mcu_pin_obj_t* pin = MP_OBJ_TO_PTR(args[ARG_pin].u_obj);
-    assert_pin_free(pin);
+
+    const mcu_pin_obj_t* pin = validate_obj_is_free_pin(args[ARG_pin].u_obj);
 
     bitbangio_onewire_obj_t *self = m_new_obj(bitbangio_onewire_obj_t);
     self->base.type = &bitbangio_onewire_type;
diff --git a/shared-bindings/bitbangio/SPI.c b/shared-bindings/bitbangio/SPI.c
index 9a51bde66..b1a94c184 100644
--- a/shared-bindings/bitbangio/SPI.c
+++ b/shared-bindings/bitbangio/SPI.c
@@ -71,12 +71,10 @@ STATIC mp_obj_t bitbangio_spi_make_new(const mp_obj_type_t *type, size_t n_args,
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-    assert_pin(args[ARG_clock].u_obj, false);
-    assert_pin(args[ARG_MOSI].u_obj, true);
-    assert_pin(args[ARG_MISO].u_obj, true);
-    const mcu_pin_obj_t* clock = MP_OBJ_TO_PTR(args[ARG_clock].u_obj);
-    const mcu_pin_obj_t* mosi = MP_OBJ_TO_PTR(args[ARG_MOSI].u_obj);
-    const mcu_pin_obj_t* miso = MP_OBJ_TO_PTR(args[ARG_MISO].u_obj);
+
+    const mcu_pin_obj_t* clock = validate_obj_is_free_pin(args[ARG_clock].u_obj);
+    const mcu_pin_obj_t* mosi = validate_obj_is_free_pin_or_none(args[ARG_MOSI].u_obj);
+    const mcu_pin_obj_t* miso = validate_obj_is_free_pin_or_none(args[ARG_MISO].u_obj);
 
     bitbangio_spi_obj_t *self = m_new_obj(bitbangio_spi_obj_t);
     self->base.type = &bitbangio_spi_type;
diff --git a/shared-bindings/busio/I2C.c b/shared-bindings/busio/I2C.c
index 50a95beb2..c89215acd 100644
--- a/shared-bindings/busio/I2C.c
+++ b/shared-bindings/busio/I2C.c
@@ -76,12 +76,10 @@ STATIC mp_obj_t busio_i2c_make_new(const mp_obj_type_t *type, size_t n_args, con
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-    assert_pin(args[ARG_scl].u_obj, false);
-    assert_pin(args[ARG_sda].u_obj, false);
-    const mcu_pin_obj_t* scl = MP_OBJ_TO_PTR(args[ARG_scl].u_obj);
-    assert_pin_free(scl);
-    const mcu_pin_obj_t* sda = MP_OBJ_TO_PTR(args[ARG_sda].u_obj);
-    assert_pin_free(sda);
+
+    const mcu_pin_obj_t* scl = validate_obj_is_free_pin(args[ARG_scl].u_obj);
+    const mcu_pin_obj_t* sda = validate_obj_is_free_pin(args[ARG_sda].u_obj);
+
     common_hal_busio_i2c_construct(self, scl, sda, args[ARG_frequency].u_int, args[ARG_timeout].u_int);
     return (mp_obj_t)self;
 }
diff --git a/shared-bindings/busio/OneWire.c b/shared-bindings/busio/OneWire.c
index aca2a3ef2..022d6afcf 100644
--- a/shared-bindings/busio/OneWire.c
+++ b/shared-bindings/busio/OneWire.c
@@ -69,9 +69,7 @@ STATIC mp_obj_t busio_onewire_make_new(const mp_obj_type_t *type, size_t n_args,
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-    assert_pin(args[ARG_pin].u_obj, false);
-    const mcu_pin_obj_t* pin = MP_OBJ_TO_PTR(args[ARG_pin].u_obj);
-    assert_pin_free(pin);
+    const mcu_pin_obj_t* pin = validate_obj_is_free_pin(args[ARG_pin].u_obj);
 
     busio_onewire_obj_t *self = m_new_obj(busio_onewire_obj_t);
     self->base.type = &busio_onewire_type;
diff --git a/shared-bindings/busio/SPI.c b/shared-bindings/busio/SPI.c
index d1791bef3..043c1089d 100644
--- a/shared-bindings/busio/SPI.c
+++ b/shared-bindings/busio/SPI.c
@@ -57,6 +57,13 @@
 //|
 //|    Construct an SPI object on the given pins.
 //|
+//|   ..note:: The SPI peripherals allocated in order of desirability, if possible,
+//|      such as highest speed and not shared use first. For instance, on the nRF52840,
+//|      there is a single 32MHz SPI peripheral, and multiple 8MHz peripherals,
+//|      some of which may also be used for I2C. The 32MHz SPI peripheral is returned
+//|      first, then the exclusive 8MHz SPI peripheral, and finally the shared 8MHz
+//|      peripherals.
+//|
 //|   .. seealso:: Using this class directly requires careful lock management.
 //|       Instead, use :class:`~adafruit_bus_device.spi_device.SPIDevice` to
 //|       manage locks.
@@ -82,17 +89,13 @@ STATIC mp_obj_t busio_spi_make_new(const mp_obj_type_t *type, size_t n_args, con
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-    assert_pin(args[ARG_clock].u_obj, false);
-    assert_pin(args[ARG_MOSI].u_obj, true);
-    assert_pin(args[ARG_MISO].u_obj, true);
-    const mcu_pin_obj_t* clock = MP_OBJ_TO_PTR(args[ARG_clock].u_obj);
-    assert_pin_free(clock);
-    const mcu_pin_obj_t* mosi = MP_OBJ_TO_PTR(args[ARG_MOSI].u_obj);
-    assert_pin_free(mosi);
-    const mcu_pin_obj_t* miso = MP_OBJ_TO_PTR(args[ARG_MISO].u_obj);
-    assert_pin_free(miso);
+
+    const mcu_pin_obj_t* clock = validate_obj_is_free_pin(args[ARG_clock].u_obj);
+    const mcu_pin_obj_t* mosi = validate_obj_is_free_pin_or_none(args[ARG_MOSI].u_obj);
+    const mcu_pin_obj_t* miso = validate_obj_is_free_pin_or_none(args[ARG_MISO].u_obj);
+
     common_hal_busio_spi_construct(self, clock, mosi, miso);
-    return (mp_obj_t)self;
+    return MP_OBJ_FROM_PTR(self);
 }
 
 //|   .. method:: deinit()
diff --git a/shared-bindings/busio/UART.c b/shared-bindings/busio/UART.c
index 1fc81e78e..f231924d5 100644
--- a/shared-bindings/busio/UART.c
+++ b/shared-bindings/busio/UART.c
@@ -53,6 +53,10 @@
 //|
 //|   :param ~microcontroller.Pin tx: the pin to transmit with, or ``None`` if this ``UART`` is receive-only.
 //|   :param ~microcontroller.Pin rx: the pin to receive on, or ``None`` if this ``UART`` is transmit-only.
+//|   :param ~microcontroller.Pin rts: the pin for rts, or ``None`` if rts not in use.
+//|   :param ~microcontroller.Pin cts: the pin for cts, or ``None`` if cts not in use.
+//|   :param ~microcontroller.Pin rs485_dir: the pin for rs485 direction setting, or ``None`` if rs485 not in use.
+//|   :param bool rs485_invert: set to invert the sense of the rs485_dir pin.
 //|   :param int baudrate: the transmit and receive speed.
 //|   :param int bits:  the number of bits per byte, 7, 8 or 9.
 //|   :param Parity parity:  the parity used for error checking.
@@ -82,7 +86,8 @@ STATIC mp_obj_t busio_uart_make_new(const mp_obj_type_t *type, size_t n_args, co
     // https://github.com/adafruit/circuitpython/issues/1056)
     busio_uart_obj_t *self = m_new_ll_obj(busio_uart_obj_t);
     self->base.type = &busio_uart_type;
-    enum { ARG_tx, ARG_rx, ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_timeout, ARG_receiver_buffer_size};
+    enum { ARG_tx, ARG_rx, ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_timeout, ARG_receiver_buffer_size,
+           ARG_rts, ARG_cts, ARG_rs485_dir,ARG_rs485_invert};
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_tx, MP_ARG_REQUIRED | MP_ARG_OBJ },
         { MP_QSTR_rx, MP_ARG_REQUIRED | MP_ARG_OBJ },
@@ -92,17 +97,20 @@ STATIC mp_obj_t busio_uart_make_new(const mp_obj_type_t *type, size_t n_args, co
         { MP_QSTR_stop, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
         { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NEW_SMALL_INT(1)} },
         { MP_QSTR_receiver_buffer_size, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 64} },
+        { MP_QSTR_rts, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_cts, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_rs485_dir, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none } },
+        { MP_QSTR_rs485_invert, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false } },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    assert_pin(args[ARG_rx].u_obj, true);
-    const mcu_pin_obj_t* rx = MP_OBJ_TO_PTR(args[ARG_rx].u_obj);
-    assert_pin_free(rx);
+    const mcu_pin_obj_t* rx = validate_obj_is_free_pin_or_none(args[ARG_rx].u_obj);
+    const mcu_pin_obj_t* tx = validate_obj_is_free_pin_or_none(args[ARG_tx].u_obj);
 
-    assert_pin(args[ARG_tx].u_obj, true);
-    const mcu_pin_obj_t* tx = MP_OBJ_TO_PTR(args[ARG_tx].u_obj);
-    assert_pin_free(tx);
+    if ( (tx == NULL) && (rx == NULL) ) {
+        mp_raise_ValueError(translate("tx and rx cannot both be None"));
+    }
 
     uint8_t bits = args[ARG_bits].u_int;
     if (bits < 7 || bits > 9) {
@@ -124,7 +132,13 @@ STATIC mp_obj_t busio_uart_make_new(const mp_obj_type_t *type, size_t n_args, co
     mp_float_t timeout = mp_obj_get_float(args[ARG_timeout].u_obj);
     validate_timeout(timeout);
 
-    common_hal_busio_uart_construct(self, tx, rx,
+    const mcu_pin_obj_t* rts = validate_obj_is_free_pin_or_none(args[ARG_rts].u_obj);
+    const mcu_pin_obj_t* cts = validate_obj_is_free_pin_or_none(args[ARG_cts].u_obj);
+    const mcu_pin_obj_t* rs485_dir = validate_obj_is_free_pin_or_none(args[ARG_rs485_dir].u_obj);
+
+    const bool rs485_invert = args[ARG_rs485_invert].u_bool;
+
+    common_hal_busio_uart_construct(self, tx, rx, rts, cts, rs485_dir, rs485_invert,
                                     args[ARG_baudrate].u_int, bits, parity, stop, timeout,
                                     args[ARG_receiver_buffer_size].u_int);
     return (mp_obj_t)self;
diff --git a/shared-bindings/busio/UART.h b/shared-bindings/busio/UART.h
index cfd2c800c..fe71e8668 100644
--- a/shared-bindings/busio/UART.h
+++ b/shared-bindings/busio/UART.h
@@ -40,9 +40,11 @@ typedef enum {
 
 // Construct an underlying UART object.
 extern void common_hal_busio_uart_construct(busio_uart_obj_t *self,
-    const mcu_pin_obj_t * tx, const mcu_pin_obj_t * rx, uint32_t baudrate,
-    uint8_t bits, uart_parity_t parity, uint8_t stop, mp_float_t timeout,
-    uint16_t receiver_buffer_size);
+    const mcu_pin_obj_t * tx, const mcu_pin_obj_t * rx,
+    const mcu_pin_obj_t * rts, const mcu_pin_obj_t * cts,
+    const mcu_pin_obj_t * rs485_dir, bool rs485_invert,
+    uint32_t baudrate, uint8_t bits, uart_parity_t parity, uint8_t stop,
+    mp_float_t timeout, uint16_t receiver_buffer_size);
 
 extern void common_hal_busio_uart_deinit(busio_uart_obj_t *self);
 extern bool common_hal_busio_uart_deinited(busio_uart_obj_t *self);
diff --git a/shared-bindings/digitalio/DigitalInOut.c b/shared-bindings/digitalio/DigitalInOut.c
index 16472c12c..39da00cf7 100644
--- a/shared-bindings/digitalio/DigitalInOut.c
+++ b/shared-bindings/digitalio/DigitalInOut.c
@@ -68,12 +68,10 @@ STATIC mp_obj_t digitalio_digitalinout_make_new(const mp_obj_type_t *type,
     digitalio_digitalinout_obj_t *self = m_new_obj(digitalio_digitalinout_obj_t);
     self->base.type = &digitalio_digitalinout_type;
 
-    assert_pin(args[0], false);
-    mcu_pin_obj_t *pin = MP_OBJ_TO_PTR(args[0]);
-    assert_pin_free(pin);
+    mcu_pin_obj_t *pin = validate_obj_is_free_pin(args[0]);
     common_hal_digitalio_digitalinout_construct(self, pin);
 
-    return (mp_obj_t)self;
+    return MP_OBJ_FROM_PTR(self);
 }
 
 //|   .. method:: deinit()
diff --git a/shared-bindings/displayio/Display.c b/shared-bindings/displayio/Display.c
index 5759e8ad2..3ef7e74e9 100644
--- a/shared-bindings/displayio/Display.c
+++ b/shared-bindings/displayio/Display.c
@@ -104,9 +104,10 @@
 //|   :param bool data_as_commands: Treat all init and boundary data as SPI commands. Certain displays require this.
 //|   :param bool auto_refresh: Automatically refresh the screen
 //|   :param int native_frames_per_second: Number of display refreshes per second that occur with the given init_sequence.
+//|   :param bool backlight_on_high: If True, pulling the backlight pin high turns the backlight on.
 //|
 STATIC mp_obj_t displayio_display_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_display_bus, ARG_init_sequence, ARG_width, ARG_height, ARG_colstart, ARG_rowstart, ARG_rotation, ARG_color_depth, ARG_grayscale, ARG_pixels_in_byte_share_row, ARG_bytes_per_cell, ARG_reverse_pixels_in_byte, ARG_set_column_command, ARG_set_row_command, ARG_write_ram_command, ARG_set_vertical_scroll, ARG_backlight_pin, ARG_brightness_command, ARG_brightness, ARG_auto_brightness, ARG_single_byte_bounds, ARG_data_as_commands, ARG_auto_refresh, ARG_native_frames_per_second };
+    enum { ARG_display_bus, ARG_init_sequence, ARG_width, ARG_height, ARG_colstart, ARG_rowstart, ARG_rotation, ARG_color_depth, ARG_grayscale, ARG_pixels_in_byte_share_row, ARG_bytes_per_cell, ARG_reverse_pixels_in_byte, ARG_set_column_command, ARG_set_row_command, ARG_write_ram_command, ARG_set_vertical_scroll, ARG_backlight_pin, ARG_brightness_command, ARG_brightness, ARG_auto_brightness, ARG_single_byte_bounds, ARG_data_as_commands, ARG_auto_refresh, ARG_native_frames_per_second, ARG_backlight_on_high };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_display_bus, MP_ARG_REQUIRED | MP_ARG_OBJ },
         { MP_QSTR_init_sequence, MP_ARG_REQUIRED | MP_ARG_OBJ },
@@ -132,6 +133,7 @@ STATIC mp_obj_t displayio_display_make_new(const mp_obj_type_t *type, size_t n_a
         { MP_QSTR_data_as_commands, MP_ARG_BOOL | MP_ARG_KW_ONLY, {.u_bool = false} },
         { MP_QSTR_auto_refresh, MP_ARG_BOOL | MP_ARG_KW_ONLY, {.u_bool = true} },
         { MP_QSTR_native_frames_per_second, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 60} },
+        { MP_QSTR_backlight_on_high, MP_ARG_BOOL | MP_ARG_KW_ONLY, {.u_bool = true} },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
@@ -141,13 +143,7 @@ STATIC mp_obj_t displayio_display_make_new(const mp_obj_type_t *type, size_t n_a
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(args[ARG_init_sequence].u_obj, &bufinfo, MP_BUFFER_READ);
 
-    mp_obj_t backlight_pin_obj = args[ARG_backlight_pin].u_obj;
-    assert_pin(backlight_pin_obj, true);
-    const mcu_pin_obj_t* backlight_pin = NULL;
-    if (backlight_pin_obj != NULL && backlight_pin_obj != mp_const_none) {
-        backlight_pin = MP_OBJ_TO_PTR(backlight_pin_obj);
-        assert_pin_free(backlight_pin);
-    }
+    const mcu_pin_obj_t* backlight_pin = validate_obj_is_free_pin_or_none(args[ARG_backlight_pin].u_obj);
 
     mp_float_t brightness = mp_obj_get_float(args[ARG_brightness].u_obj);
 
@@ -184,7 +180,8 @@ STATIC mp_obj_t displayio_display_make_new(const mp_obj_type_t *type, size_t n_a
         args[ARG_single_byte_bounds].u_bool,
         args[ARG_data_as_commands].u_bool,
         args[ARG_auto_refresh].u_bool,
-        args[ARG_native_frames_per_second].u_int
+        args[ARG_native_frames_per_second].u_int,
+        args[ARG_backlight_on_high].u_bool
         );
 
     return self;
diff --git a/shared-bindings/displayio/Display.h b/shared-bindings/displayio/Display.h
index b82a68ebe..8c2e20262 100644
--- a/shared-bindings/displayio/Display.h
+++ b/shared-bindings/displayio/Display.h
@@ -45,7 +45,7 @@ void common_hal_displayio_display_construct(displayio_display_obj_t* self,
     uint8_t set_column_command, uint8_t set_row_command, uint8_t write_ram_command, uint8_t set_vertical_scroll,
     uint8_t* init_sequence, uint16_t init_sequence_len, const mcu_pin_obj_t* backlight_pin, uint16_t brightness_command,
     mp_float_t brightness, bool auto_brightness,
-    bool single_byte_bounds, bool data_as_commands, bool auto_refresh, uint16_t native_frames_per_second);
+    bool single_byte_bounds, bool data_as_commands, bool auto_refresh, uint16_t native_frames_per_second, bool backlight_on_high);
 
 bool common_hal_displayio_display_show(displayio_display_obj_t* self,
                                        displayio_group_t* root_group);
diff --git a/shared-bindings/displayio/EPaperDisplay.c b/shared-bindings/displayio/EPaperDisplay.c
index 81e06f82f..25a4a41e9 100644
--- a/shared-bindings/displayio/EPaperDisplay.c
+++ b/shared-bindings/displayio/EPaperDisplay.c
@@ -129,13 +129,7 @@ STATIC mp_obj_t displayio_epaperdisplay_make_new(const mp_obj_type_t *type, size
     mp_get_buffer_raise(args[ARG_stop_sequence].u_obj, &stop_bufinfo, MP_BUFFER_READ);
 
 
-    mp_obj_t busy_pin_obj = args[ARG_busy_pin].u_obj;
-    assert_pin(busy_pin_obj, true);
-    const mcu_pin_obj_t* busy_pin = NULL;
-    if (busy_pin_obj != NULL && busy_pin_obj != mp_const_none) {
-        busy_pin = MP_OBJ_TO_PTR(busy_pin_obj);
-        assert_pin_free(busy_pin);
-    }
+    const mcu_pin_obj_t* busy_pin = validate_obj_is_free_pin_or_none(args[ARG_busy_pin].u_obj);
 
     mp_int_t rotation = args[ARG_rotation].u_int;
     if (rotation % 90 != 0) {
diff --git a/shared-bindings/displayio/FourWire.c b/shared-bindings/displayio/FourWire.c
index 51203d460..77329578a 100644
--- a/shared-bindings/displayio/FourWire.c
+++ b/shared-bindings/displayio/FourWire.c
@@ -46,7 +46,7 @@
 //| Manage updating a display over SPI four wire protocol in the background while Python code runs.
 //| It doesn't handle display initialization.
 //|
-//| .. class:: FourWire(spi_bus, *, command, chip_select, reset=None, baudrate=24000000)
+//| .. class:: FourWire(spi_bus, *, command, chip_select, reset=None, baudrate=24000000, polarity=0, phase=0)
 //|
 //|   Create a FourWire object associated with the given pins.
 //|
@@ -60,29 +60,27 @@
 //|   :param microcontroller.Pin chip_select: Chip select pin
 //|   :param microcontroller.Pin reset: Reset pin. When None only software reset can be used
 //|   :param int baudrate: Maximum baudrate in Hz for the display on the bus
+//|   :param int polarity: the base state of the clock line (0 or 1)
+//|   :param int phase: the edge of the clock that data is captured. First (0)
+//|       or second (1). Rising or falling depends on clock polarity.
 //|
 STATIC mp_obj_t displayio_fourwire_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_spi_bus, ARG_command, ARG_chip_select, ARG_reset, ARG_baudrate };
+    enum { ARG_spi_bus, ARG_command, ARG_chip_select, ARG_reset, ARG_baudrate, ARG_polarity, ARG_phase };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_spi_bus, MP_ARG_REQUIRED | MP_ARG_OBJ },
         { MP_QSTR_command, MP_ARG_OBJ | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
         { MP_QSTR_chip_select, MP_ARG_OBJ | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
         { MP_QSTR_reset, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_obj = mp_const_none} },
         { MP_QSTR_baudrate, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 24000000} },
+        { MP_QSTR_polarity, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_phase, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    mp_obj_t command = args[ARG_command].u_obj;
-    mp_obj_t chip_select = args[ARG_chip_select].u_obj;
-    assert_pin_free(command);
-    assert_pin_free(chip_select);
-    mp_obj_t reset = args[ARG_reset].u_obj;
-    if (reset != mp_const_none) {
-        assert_pin_free(reset);
-    } else {
-        reset = NULL;
-    }
+    mcu_pin_obj_t *command = validate_obj_is_free_pin(args[ARG_command].u_obj);
+    mcu_pin_obj_t *chip_select = validate_obj_is_free_pin(args[ARG_chip_select].u_obj);
+    mcu_pin_obj_t *reset = validate_obj_is_free_pin_or_none(args[ARG_reset].u_obj);
 
     displayio_fourwire_obj_t* self = NULL;
     mp_obj_t spi = args[ARG_spi_bus].u_obj;
@@ -98,8 +96,17 @@ STATIC mp_obj_t displayio_fourwire_make_new(const mp_obj_type_t *type, size_t n_
         mp_raise_RuntimeError(translate("Too many display busses"));
     }
 
+    uint8_t polarity = args[ARG_polarity].u_int;
+    if (polarity != 0 && polarity != 1) {
+        mp_raise_ValueError(translate("Invalid polarity"));
+    }
+    uint8_t phase = args[ARG_phase].u_int;
+    if (phase != 0 && phase != 1) {
+        mp_raise_ValueError(translate("Invalid phase"));
+    }
+
     common_hal_displayio_fourwire_construct(self,
-        MP_OBJ_TO_PTR(spi), command, chip_select, reset, args[ARG_baudrate].u_int);
+        MP_OBJ_TO_PTR(spi), command, chip_select, reset, args[ARG_baudrate].u_int, polarity, phase);
     return self;
 }
 
diff --git a/shared-bindings/displayio/FourWire.h b/shared-bindings/displayio/FourWire.h
index d0935f063..ac186d2c3 100644
--- a/shared-bindings/displayio/FourWire.h
+++ b/shared-bindings/displayio/FourWire.h
@@ -38,7 +38,8 @@ extern const mp_obj_type_t displayio_fourwire_type;
 
 void common_hal_displayio_fourwire_construct(displayio_fourwire_obj_t* self,
     busio_spi_obj_t* spi, const mcu_pin_obj_t* command,
-    const mcu_pin_obj_t* chip_select, const mcu_pin_obj_t* reset, uint32_t baudrate);
+    const mcu_pin_obj_t* chip_select, const mcu_pin_obj_t* reset, uint32_t baudrate,
+    uint8_t polarity, uint8_t phase);
 
 void common_hal_displayio_fourwire_deinit(displayio_fourwire_obj_t* self);
 
diff --git a/shared-bindings/displayio/I2CDisplay.c b/shared-bindings/displayio/I2CDisplay.c
index 4339d182f..2e312aa14 100644
--- a/shared-bindings/displayio/I2CDisplay.c
+++ b/shared-bindings/displayio/I2CDisplay.c
@@ -69,12 +69,7 @@ STATIC mp_obj_t displayio_i2cdisplay_make_new(const mp_obj_type_t *type, size_t
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    mp_obj_t reset = args[ARG_reset].u_obj;
-    if (reset != mp_const_none) {
-        assert_pin_free(reset);
-    } else {
-        reset = NULL;
-    }
+    mcu_pin_obj_t *reset = validate_obj_is_free_pin_or_none(args[ARG_reset].u_obj);
 
     displayio_i2cdisplay_obj_t* self = NULL;
     mp_obj_t i2c = args[ARG_i2c_bus].u_obj;
@@ -118,7 +113,7 @@ MP_DEFINE_CONST_FUN_OBJ_1(displayio_i2cdisplay_reset_obj, displayio_i2cdisplay_o
 STATIC mp_obj_t displayio_i2cdisplay_obj_send(mp_obj_t self, mp_obj_t command_obj, mp_obj_t data_obj) {
     mp_int_t command_int = MP_OBJ_SMALL_INT_VALUE(command_obj);
     if (!MP_OBJ_IS_SMALL_INT(command_obj) || command_int > 255 || command_int < 0) {
-        mp_raise_ValueError(translate("Command must be 0-255"));
+        mp_raise_ValueError(translate("Command must be an int between 0 and 255"));
     }
     uint8_t command = command_int;
     mp_buffer_info_t bufinfo;
diff --git a/shared-bindings/displayio/OnDiskBitmap.c b/shared-bindings/displayio/OnDiskBitmap.c
index f7e2bf693..57179947e 100644
--- a/shared-bindings/displayio/OnDiskBitmap.c
+++ b/shared-bindings/displayio/OnDiskBitmap.c
@@ -62,7 +62,7 @@
 //|       face = displayio.TileGrid(odb, pixel_shader=displayio.ColorConverter())
 //|       splash.append(face)
 //|       # Wait for the image to load.
-//|       board.DISPLAY.wait_for_frame()
+//|       board.DISPLAY.refresh(target_frames_per_second=60)
 //|
 //|       # Fade up the backlight
 //|       for i in range(100):
diff --git a/shared-bindings/displayio/Palette.c b/shared-bindings/displayio/Palette.c
index dda58e3c5..67a7db85b 100644
--- a/shared-bindings/displayio/Palette.c
+++ b/shared-bindings/displayio/Palette.c
@@ -86,7 +86,8 @@ STATIC mp_obj_t group_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
 //|     Sets the pixel color at the given index. The index should be an integer in the range 0 to color_count-1.
 //|
 //|     The value argument represents a color, and can be from 0x000000 to 0xFFFFFF (to represent an RGB value).
-//|     Value can be an int, bytes (3 bytes (RGB) or 4 bytes (RGB + pad byte)), or bytearray.
+//|     Value can be an int, bytes (3 bytes (RGB) or 4 bytes (RGB + pad byte)), bytearray,
+//|     or a tuple or list of 3 integers.
 //|
 //|     This allows you to::
 //|
@@ -94,6 +95,7 @@ STATIC mp_obj_t group_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
 //|       palette[1] = b'\xff\xff\x00'              # set using 3 bytes
 //|       palette[2] = b'\xff\xff\x00\x00'          # set using 4 bytes
 //|       palette[3] = bytearray(b'\x00\x00\xFF')   # set using a bytearay of 3 or 4 bytes
+//|       palette[4] = (10, 20, 30)                 # set using a tuple of 3 integers
 //|
 STATIC mp_obj_t palette_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value) {
     if (value == MP_OBJ_NULL) {
@@ -111,6 +113,12 @@ STATIC mp_obj_t palette_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t val
         return MP_OBJ_NEW_SMALL_INT(common_hal_displayio_palette_get_color(self, index));
     }
 
+    // Convert a tuple or list to a bytearray.
+    if (MP_OBJ_IS_TYPE(value, &mp_type_tuple) ||
+        MP_OBJ_IS_TYPE(value, &mp_type_list)) {
+        value = mp_type_bytes.make_new(&mp_type_bytes, 1, &value, NULL);
+    }
+
     uint32_t color;
     mp_int_t int_value;
     mp_buffer_info_t bufinfo;
@@ -130,7 +138,7 @@ STATIC mp_obj_t palette_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t val
         }
         color = int_value;
     } else {
-        mp_raise_TypeError(translate("color buffer must be a buffer or int"));
+        mp_raise_TypeError(translate("color buffer must be a buffer, tuple, list, or int"));
     }
     common_hal_displayio_palette_set_color(self, index, color);
     return mp_const_none;
diff --git a/shared-bindings/displayio/ParallelBus.c b/shared-bindings/displayio/ParallelBus.c
index f7195b9cc..b3a876f90 100644
--- a/shared-bindings/displayio/ParallelBus.c
+++ b/shared-bindings/displayio/ParallelBus.c
@@ -71,23 +71,17 @@ STATIC mp_obj_t displayio_parallelbus_make_new(const mp_obj_type_t *type, size_t
         { MP_QSTR_chip_select, MP_ARG_OBJ | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
         { MP_QSTR_write, MP_ARG_OBJ | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
         { MP_QSTR_read, MP_ARG_OBJ | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
-        { MP_QSTR_reset, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_obj = mp_const_none} },
+        { MP_QSTR_reset, MP_ARG_OBJ | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    mp_obj_t data0 = args[ARG_data0].u_obj;
-    mp_obj_t command = args[ARG_command].u_obj;
-    mp_obj_t chip_select = args[ARG_chip_select].u_obj;
-    mp_obj_t write = args[ARG_write].u_obj;
-    mp_obj_t read = args[ARG_read].u_obj;
-    mp_obj_t reset = args[ARG_reset].u_obj;
-    assert_pin_free(data0);
-    assert_pin_free(command);
-    assert_pin_free(chip_select);
-    assert_pin_free(write);
-    assert_pin_free(read);
-    assert_pin_free(reset);
+    mcu_pin_obj_t *data0 = validate_obj_is_free_pin(args[ARG_data0].u_obj);
+    mcu_pin_obj_t *command = validate_obj_is_free_pin(args[ARG_command].u_obj);
+    mcu_pin_obj_t *chip_select = validate_obj_is_free_pin(args[ARG_chip_select].u_obj);
+    mcu_pin_obj_t *write = validate_obj_is_free_pin(args[ARG_write].u_obj);
+    mcu_pin_obj_t *read = validate_obj_is_free_pin(args[ARG_read].u_obj);
+    mcu_pin_obj_t *reset = validate_obj_is_free_pin(args[ARG_reset].u_obj);
 
     displayio_parallelbus_obj_t* self = NULL;
     for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
diff --git a/shared-bindings/frequencyio/FrequencyIn.c b/shared-bindings/frequencyio/FrequencyIn.c
index e2b924c07..6743f8706 100644
--- a/shared-bindings/frequencyio/FrequencyIn.c
+++ b/shared-bindings/frequencyio/FrequencyIn.c
@@ -87,9 +87,7 @@ STATIC mp_obj_t frequencyio_frequencyin_make_new(const mp_obj_type_t *type, size
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    assert_pin(args[ARG_pin].u_obj, false);
-    mcu_pin_obj_t* pin = MP_OBJ_TO_PTR(args[ARG_pin].u_obj);
-    assert_pin_free(pin);
+    mcu_pin_obj_t* pin = validate_obj_is_free_pin(args[ARG_pin].u_obj);
 
     const uint16_t capture_period = args[ARG_capture_period].u_int;
 
diff --git a/shared-bindings/i2cslave/I2CSlave.c b/shared-bindings/i2cslave/I2CSlave.c
index c98ea52e0..e28eb3f25 100644
--- a/shared-bindings/i2cslave/I2CSlave.c
+++ b/shared-bindings/i2cslave/I2CSlave.c
@@ -77,12 +77,8 @@ STATIC mp_obj_t i2cslave_i2c_slave_make_new(const mp_obj_type_t *type, size_t n_
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    assert_pin(args[ARG_scl].u_obj, false);
-    assert_pin(args[ARG_sda].u_obj, false);
-    const mcu_pin_obj_t* scl = MP_OBJ_TO_PTR(args[ARG_scl].u_obj);
-    assert_pin_free(scl);
-    const mcu_pin_obj_t* sda = MP_OBJ_TO_PTR(args[ARG_sda].u_obj);
-    assert_pin_free(sda);
+    const mcu_pin_obj_t* scl = validate_obj_is_free_pin(args[ARG_scl].u_obj);
+    const mcu_pin_obj_t* sda = validate_obj_is_free_pin(args[ARG_sda].u_obj);
 
     mp_obj_iter_buf_t iter_buf;
     mp_obj_t iterable = mp_getiter(args[ARG_addresses].u_obj, &iter_buf);
diff --git a/shared-bindings/microcontroller/Pin.c b/shared-bindings/microcontroller/Pin.c
index 3635f0afb..67aecaf66 100644
--- a/shared-bindings/microcontroller/Pin.c
+++ b/shared-bindings/microcontroller/Pin.c
@@ -84,10 +84,35 @@ const mp_obj_type_t mcu_pin_type = {
     .print = mcu_pin_print
 };
 
-void assert_pin(mp_obj_t obj, bool none_ok) {
-    if ((obj != mp_const_none || !none_ok) && !MP_OBJ_IS_TYPE(obj, &mcu_pin_type)) {
+mcu_pin_obj_t *validate_obj_is_pin(mp_obj_t obj) {
+    if (!MP_OBJ_IS_TYPE(obj, &mcu_pin_type)) {
         mp_raise_TypeError_varg(translate("Expected a %q"), mcu_pin_type.name);
     }
+    return MP_OBJ_TO_PTR(obj);
+}
+
+// Validate that the obj is a pin or None. Return an mcu_pin_obj_t* or NULL, correspondingly.
+mcu_pin_obj_t *validate_obj_is_pin_or_none(mp_obj_t obj) {
+    if (obj == mp_const_none) {
+        return NULL;
+    }
+    return validate_obj_is_pin(obj);
+}
+
+mcu_pin_obj_t *validate_obj_is_free_pin(mp_obj_t obj) {
+    mcu_pin_obj_t *pin = validate_obj_is_pin(obj);
+    assert_pin_free(pin);
+    return pin;
+}
+
+// Validate that the obj is a free pin or None. Return an mcu_pin_obj_t* or NULL, correspondingly.
+mcu_pin_obj_t *validate_obj_is_free_pin_or_none(mp_obj_t obj) {
+    if (obj == mp_const_none) {
+        return NULL;
+    }
+    mcu_pin_obj_t *pin = validate_obj_is_pin(obj);
+    assert_pin_free(pin);
+    return pin;
 }
 
 void assert_pin_free(const mcu_pin_obj_t* pin) {
diff --git a/shared-bindings/microcontroller/Pin.h b/shared-bindings/microcontroller/Pin.h
index 2d15dd5c5..4f29322a0 100644
--- a/shared-bindings/microcontroller/Pin.h
+++ b/shared-bindings/microcontroller/Pin.h
@@ -33,7 +33,11 @@
 // Type object used in Python. Should be shared between ports.
 extern const mp_obj_type_t mcu_pin_type;
 
-void assert_pin(mp_obj_t obj, bool none_ok);
+mcu_pin_obj_t *validate_obj_is_pin(mp_obj_t obj);
+mcu_pin_obj_t *validate_obj_is_pin_or_none(mp_obj_t obj);
+mcu_pin_obj_t *validate_obj_is_free_pin(mp_obj_t obj);
+mcu_pin_obj_t *validate_obj_is_free_pin_or_none(mp_obj_t obj);
+
 void assert_pin_free(const mcu_pin_obj_t* pin);
 
 bool common_hal_mcu_pin_is_free(const mcu_pin_obj_t* pin);
diff --git a/shared-bindings/os/__init__.c b/shared-bindings/os/__init__.c
index c2b63bbce..f3b745aef 100644
--- a/shared-bindings/os/__init__.c
+++ b/shared-bindings/os/__init__.c
@@ -143,6 +143,11 @@ MP_DEFINE_CONST_FUN_OBJ_1(os_rmdir_obj, os_rmdir);
 //|
 //|   Get the status of a file or directory.
 //|
+//|   .. note:: On builds without long integers, the number of seconds
+//|      for contemporary dates will not fit in a small integer.
+//|      So the time fields return 946684800,
+//|      which is the number of seconds corresponding to 1999-12-31.
+//|
 mp_obj_t os_stat(mp_obj_t path_in) {
     const char *path = mp_obj_str_get_str(path_in);
     return common_hal_os_stat(path);
diff --git a/shared-bindings/ps2io/Ps2.c b/shared-bindings/ps2io/Ps2.c
index fb5c24b85..89ed0a76c 100644
--- a/shared-bindings/ps2io/Ps2.c
+++ b/shared-bindings/ps2io/Ps2.c
@@ -77,12 +77,9 @@ STATIC mp_obj_t ps2io_ps2_make_new(const mp_obj_type_t *type, size_t n_args, con
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-    assert_pin(args[ARG_clkpin].u_obj, false);
-    assert_pin(args[ARG_datapin].u_obj, false);
-    const mcu_pin_obj_t* clkpin = MP_OBJ_TO_PTR(args[ARG_clkpin].u_obj);
-    assert_pin_free(clkpin);
-    const mcu_pin_obj_t* datapin = MP_OBJ_TO_PTR(args[ARG_datapin].u_obj);
-    assert_pin_free(datapin);
+
+    const mcu_pin_obj_t* clkpin = validate_obj_is_free_pin(args[ARG_clkpin].u_obj);
+    const mcu_pin_obj_t* datapin = validate_obj_is_free_pin(args[ARG_datapin].u_obj);
 
     ps2io_ps2_obj_t *self = m_new_obj(ps2io_ps2_obj_t);
     self->base.type = &ps2io_ps2_type;
diff --git a/shared-bindings/pulseio/PWMOut.c b/shared-bindings/pulseio/PWMOut.c
index 53b88c61a..2491a5c3f 100644
--- a/shared-bindings/pulseio/PWMOut.c
+++ b/shared-bindings/pulseio/PWMOut.c
@@ -96,10 +96,7 @@ STATIC mp_obj_t pulseio_pwmout_make_new(const mp_obj_type_t *type, size_t n_args
     mp_arg_val_t parsed_args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, parsed_args);
 
-    mp_obj_t pin_obj = parsed_args[ARG_pin].u_obj;
-    assert_pin(pin_obj, false);
-    const mcu_pin_obj_t *pin = MP_OBJ_TO_PTR(pin_obj);
-    assert_pin_free(pin);
+    const mcu_pin_obj_t *pin = validate_obj_is_free_pin(parsed_args[ARG_pin].u_obj);
 
     uint16_t duty_cycle = parsed_args[ARG_duty_cycle].u_int;
     uint32_t frequency = parsed_args[ARG_frequency].u_int;
diff --git a/shared-bindings/pulseio/PulseIn.c b/shared-bindings/pulseio/PulseIn.c
index 8b69109f0..6c01a4c17 100644
--- a/shared-bindings/pulseio/PulseIn.c
+++ b/shared-bindings/pulseio/PulseIn.c
@@ -90,9 +90,7 @@ STATIC mp_obj_t pulseio_pulsein_make_new(const mp_obj_type_t *type, size_t n_arg
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-    assert_pin(args[ARG_pin].u_obj, false);
-    const mcu_pin_obj_t* pin = MP_OBJ_TO_PTR(args[ARG_pin].u_obj);
-    assert_pin_free(pin);
+    const mcu_pin_obj_t* pin = validate_obj_is_free_pin(args[ARG_pin].u_obj);
 
     pulseio_pulsein_obj_t *self = m_new_obj(pulseio_pulsein_obj_t);
     self->base.type = &pulseio_pulsein_type;
diff --git a/shared-bindings/rotaryio/IncrementalEncoder.c b/shared-bindings/rotaryio/IncrementalEncoder.c
index f2f157847..058241d24 100644
--- a/shared-bindings/rotaryio/IncrementalEncoder.c
+++ b/shared-bindings/rotaryio/IncrementalEncoder.c
@@ -73,13 +73,8 @@ STATIC mp_obj_t rotaryio_incrementalencoder_make_new(const mp_obj_type_t *type,
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    assert_pin(args[ARG_pin_a].u_obj, false);
-    const mcu_pin_obj_t* pin_a = MP_OBJ_TO_PTR(args[ARG_pin_a].u_obj);
-    assert_pin_free(pin_a);
-
-    assert_pin(args[ARG_pin_b].u_obj, false);
-    const mcu_pin_obj_t* pin_b = MP_OBJ_TO_PTR(args[ARG_pin_b].u_obj);
-    assert_pin_free(pin_b);
+    const mcu_pin_obj_t* pin_a = validate_obj_is_free_pin(args[ARG_pin_a].u_obj);
+    const mcu_pin_obj_t* pin_b = validate_obj_is_free_pin(args[ARG_pin_b].u_obj);
 
     rotaryio_incrementalencoder_obj_t *self = m_new_obj(rotaryio_incrementalencoder_obj_t);
     self->base.type = &rotaryio_incrementalencoder_type;
diff --git a/shared-bindings/time/__init__.c b/shared-bindings/time/__init__.c
index b3e4604b5..8d7f2f3fd 100644
--- a/shared-bindings/time/__init__.c
+++ b/shared-bindings/time/__init__.c
@@ -70,14 +70,16 @@ MP_DEFINE_CONST_FUN_OBJ_0(time_monotonic_obj, time_monotonic);
 //|
 STATIC mp_obj_t time_sleep(mp_obj_t seconds_o) {
     #if MICROPY_PY_BUILTINS_FLOAT
-    float seconds = mp_obj_get_float(seconds_o);
+    mp_float_t seconds = mp_obj_get_float(seconds_o);
+    mp_float_t msecs = 1000.0f * seconds + 0.5f;
     #else
-    int seconds = mp_obj_get_int(seconds_o);
+    mp_int_t seconds = mp_obj_get_int(seconds_o);
+    mp_int_t msecs = 1000 * seconds;
     #endif
     if (seconds < 0) {
         mp_raise_ValueError(translate("sleep length must be non-negative"));
     }
-    common_hal_time_delay_ms(1000 * seconds);
+    common_hal_time_delay_ms(msecs);
     return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_1(time_sleep_obj, time_sleep);
@@ -216,7 +218,7 @@ MP_DEFINE_CONST_FUN_OBJ_0(time_time_obj, time_time);
 //|   :rtype: int
 //|
 STATIC mp_obj_t time_monotonic_ns(void) {
-    uint64_t time64 = common_hal_time_monotonic() * 1000000llu;
+    uint64_t time64 = common_hal_time_monotonic_ns();
     return mp_obj_new_int_from_ll((long long) time64);
 }
 MP_DEFINE_CONST_FUN_OBJ_0(time_monotonic_ns_obj, time_monotonic_ns);
diff --git a/shared-bindings/time/__init__.h b/shared-bindings/time/__init__.h
index c5a0b47fc..ec96aea24 100644
--- a/shared-bindings/time/__init__.h
+++ b/shared-bindings/time/__init__.h
@@ -36,6 +36,7 @@ extern mp_obj_t struct_time_from_tm(timeutils_struct_time_t *tm);
 extern void struct_time_to_tm(mp_obj_t t, timeutils_struct_time_t *tm);
 
 extern uint64_t common_hal_time_monotonic(void);
+extern uint64_t common_hal_time_monotonic_ns(void);
 extern void common_hal_time_delay_ms(uint32_t);
 
 #endif  // MICROPY_INCLUDED_SHARED_BINDINGS_TIME___INIT___H
diff --git a/shared-bindings/touchio/TouchIn.c b/shared-bindings/touchio/TouchIn.c
index 33d369c74..db53ec1bc 100644
--- a/shared-bindings/touchio/TouchIn.c
+++ b/shared-bindings/touchio/TouchIn.c
@@ -66,10 +66,7 @@ STATIC mp_obj_t touchio_touchin_make_new(const mp_obj_type_t *type,
     mp_arg_check_num(n_args, kw_args, 1, 1, false);
 
     // 1st argument is the pin
-    mp_obj_t pin_obj = args[0];
-    assert_pin(pin_obj, false);
-    const mcu_pin_obj_t *pin = MP_OBJ_TO_PTR(pin_obj);
-    assert_pin_free(pin);
+    const mcu_pin_obj_t *pin = validate_obj_is_free_pin(args[0]);
 
     touchio_touchin_obj_t *self = m_new_obj(touchio_touchin_obj_t);
     self->base.type = &touchio_touchin_type;
diff --git a/shared-bindings/ulab/__init__.rst b/shared-bindings/ulab/__init__.rst
new file mode 100644
index 000000000..1379e56f3
--- /dev/null
+++ b/shared-bindings/ulab/__init__.rst
@@ -0,0 +1,481 @@
+
+:mod:`ulab` --- Manipulate numeric data similar to numpy
+========================================================
+
+.. module:: ulab
+   :synopsis: Manipulate numeric data similar to numpy
+
+`ulab` is a numpy-like module for micropython, meant to simplify and
+speed up common mathematical operations on arrays. The primary goal was to
+implement a small subset of numpy that might be useful in the context of a
+microcontroller. This means low-level data processing of linear (array) and
+two-dimensional (matrix) data.
+
+`ulab` is adapted from micropython-ulab, and the original project's
+documentation can be found at
+https://micropython-ulab.readthedocs.io/en/latest/
+
+`ulab` is modeled after numpy, and aims to be a compatible subset where
+possible.  Numpy's documentation can be found at
+https://docs.scipy.org/doc/numpy/index.html
+
+.. contents::
+
+.. attribute:: __version__
+
+The closest corresponding version of micropython-ulab
+
+ulab.array -- 1- and 2- dimensional array
+-----------------------------------------
+
+.. class:: ulab.array(values, \*, dtype=float)
+
+  :param sequence values: Sequence giving the initial content of the array.
+  :param dtype: The type of array values, ``int8``, ``uint8``, ``int16``, ``uint16``, or ``float``
+
+  The `values` sequence can either be another ~ulab.array, sequence of numbers
+  (in which case a 1-dimensional array is created), or a sequence where each
+  subsequence has the same length (in which case a 2-dimensional array is
+  created).
+
+  Passing a ~ulab.array and a different dtype can be used to convert an array
+  from one dtype to another.
+
+  In many cases, it is more convenient to create an array from a function
+  like `zeros` or `linspace`.
+
+  `ulab.array` implements the buffer protocol, so it can be used in many
+  places an `array.array` can be used.
+
+   .. attribute:: shape
+
+      The size of the array, a tuple of length 1 or 2
+
+   .. attribute:: size
+
+      The number of elements in the array
+
+   .. attribute:: itemsize
+
+      The number of elements in the array
+
+   .. method:: flatten(\*, order='C')
+
+      :param order: Whether to flatten by rows ('C') or columns ('F')
+
+      Returns a new `ulab.array` object which is always 1 dimensional.
+      If order is 'C' (the default", then the data is ordered in rows;
+      If it is 'F', then the data is ordered in columns.  "C" and "F" refer
+      to the typical storage organization of the C and Fortran languages.
+
+   .. method:: sort(\*, axis=1)
+
+      :param axis: Whether to sort elements within rows (0), columns (1), or elements (None)
+
+   .. method:: transpose()
+
+      Swap the rows and columns of a 2-dimensional array
+
+   .. method:: __add__()
+
+      Adds corresponding elements of the two arrays, or adds a number to all
+      elements of the array.  A number must be on the right hand side.  If
+      both arguments are arrays, their sizes must match.
+
+   .. method:: __sub__()
+
+      Subtracts corresponding elements of the two arrays, or subtracts a
+      number from all elements of the array.  A number must be on the right
+      hand side.  If both arguments are arrays, their sizes must match.
+
+   .. method:: __mul__()
+
+      Multiplies corresponding elements of the two arrays, or multiplies
+      all elements of the array by a number.  A number must be on the right
+      hand side.  If both arguments are arrays, their sizes must match.
+
+   .. method:: __div__()
+
+      Multiplies corresponding elements of the two arrays, or divides
+      all elements of the array by a number.  A number must be on the right
+      hand side.  If both arguments are arrays, their sizes must match.
+
+   .. method:: __getitem__()
+
+      Retrieve an element of the array.
+
+   .. method:: __setitem__()
+
+      Set an element of the array.
+
+Array type codes
+----------------
+.. attribute:: int8
+
+   Type code for signed integers in the range -128 .. 127 inclusive, like the 'b' typecode of `array.array`
+
+.. attribute:: int16
+
+   Type code for signed integers in the range -32768 .. 32767 inclusive, like the 'h' typecode of `array.array`
+
+.. attribute:: float
+
+   Type code for floating point values, like the 'f' typecode of `array.array`
+
+.. attribute:: uint8
+
+   Type code for unsigned integers in the range 0 .. 255 inclusive, like the 'H' typecode of `array.array`
+
+.. attribute:: uint8
+
+   Type code for unsigned integers in the range 0 .. 65535 inclusive, like the 'h' typecode of `array.array`
+
+
+Basic Array defining functions
+------------------------------
+
+.. method:: ones(shape, \*, dtype=float)
+
+   .. param: shape
+      Shape of the array, either an integer (for a 1-D array) or a tuple of 2 integers (for a 2-D array)
+
+   .. param: dtype
+      Type of values in the array
+
+   Return a new array of the given shape with all elements set to 1.
+
+.. method:: zeros
+
+   .. param: shape
+      Shape of the array, either an integer (for a 1-D array) or a tuple of 2 integers (for a 2-D array)
+
+   .. param: dtype
+      Type of values in the array
+
+   Return a new array of the given shape with all elements set to 0.
+
+
+.. method:: eye(size, \*, dtype=float)
+
+   Return a new square array of size, with the diagonal elements set to 1
+   and the other elements set to 0.
+
+.. method:: linspace(start, stop, \*, dtype=float, num=50, endpoint=True)
+
+   .. param: start
+
+      First value in the array
+
+   .. param: stop
+
+      Final value in the array
+
+   .. param int: num
+
+      Count of values in the array
+
+   .. param: dtype
+
+      Type of values in the array
+
+   .. param bool: endpoint
+
+      Whether the ``stop`` value is included.  Note that even when
+      endpoint=True, the exact ``stop`` value may not be included due to the
+      inaccuracy of floating point arithmetic.
+
+   Return a new 1-D array with ``num`` elements ranging from ``start`` to ``stop`` linearly.
+
+
+
+:mod:`ulab.vector` --- Element-by-element functions
+===================================================
+
+.. module:: ulab.vector
+
+These functions can operate on numbers, 1-D arrays, or 2-D arrays by
+applying the function to every element in the array.  This is typically
+much more efficient than expressing the same operation as a Python loop.
+
+.. method:: acos
+
+   Computes the inverse cosine function
+
+.. method:: acosh
+
+   Computes the inverse hyperbolic cosine function
+
+.. method:: asin
+
+   Computes the inverse sine function
+
+.. method:: asinh
+
+   Computes the inverse hyperbolic sine function
+
+.. method:: around(a, \*, decimals)
+
+   Returns a new float array in which each element is rounded to
+   ``decimals`` places.
+
+.. method:: atan
+
+   Computes the inverse tangent function; the return values are in the
+   range [-pi/2,pi/2].
+
+.. method:: atan2(y,x)
+
+   Computes the inverse tangent function of y/x; the return values are in
+   the range [-pi, pi].
+
+.. method:: atanh
+
+   Computes the inverse hyperbolic tangent function
+
+.. method:: ceil
+
+   Rounds numbers up to the next whole number
+
+.. method:: cos
+
+   Computes the cosine function
+
+.. method:: erf
+
+   Computes the error function, which has applications in statistics
+
+.. method:: erfc
+
+   Computes the complementary error function, which has applications in statistics
+
+.. method:: exp
+
+   Computes the exponent function.
+
+.. method:: expm1
+
+   Computes $e^x-1$.  In certain applications, using this function preserves numeric accuracy better than the `exp` function.
+
+.. method:: floor
+
+   Rounds numbers up to the next whole number
+
+.. method:: gamma
+
+   Computes the gamma function
+
+.. method:: lgamma
+
+   Computes the natural log of the gamma function
+
+.. method:: log
+
+   Computes the natural log
+
+.. method:: log10
+
+   Computes the log base 10
+
+.. method:: log2
+
+   Computes the log base 2
+
+.. method:: sin
+
+   Computes the sine
+
+.. method:: sinh
+
+   Computes the hyperbolic sine
+
+.. method:: sqrt
+
+   Computes the square root
+
+.. method:: tan
+
+   Computes the tangent
+
+.. method:: tanh
+
+   Computes the hyperbolic tangent
+
+:mod:`ulab.linalg` - Linear algebra functions
+=============================================
+
+.. module:: ulab.linalg
+
+.. method:: cholesky(A)
+
+   :param ~ulab.array A: a positive definite, symmetric square matrix
+   :return ~ulab.array L: a square root matrix in the lower triangular form
+   :raises ValueError: If the input does not fulfill the necessary conditions
+
+   The returned matrix satisfies the equation m=LL*
+
+.. method:: det
+
+   :param: m, a square matrix
+   :return float: The determinant of the matrix
+
+   Computes the eigenvalues and eigenvectors of a square matrix
+
+.. method:: dot(m1, m2)
+
+   :param ~ulab.array m1: a matrix
+   :param ~ulab.array m2: a matrix
+
+   Computes the matrix product of two matrices
+
+   **WARNING:** Unlike ``numpy``, this function cannot be used to compute the dot product of two vectors
+
+.. method:: eig(m)
+
+   :param m: a square matrix
+   :return tuple (eigenvectors, eigenvalues):
+
+   Computes the eigenvalues and eigenvectors of a square matrix
+
+.. method:: inv(m)
+
+   :param ~ulab.array m: a square matrix
+   :return: The inverse of the matrix, if it exists
+   :raises ValueError: if the matrix is not invertible
+
+   Computes the inverse of a square matrix
+
+.. method:: size(array)
+
+   Return the total number of elements in the array, as an integer.
+
+:mod:`ulab.filter` --- Filtering functions
+==========================================
+
+.. module:: ulab.filter
+
+.. method:: convolve(r, c=None)
+
+   :param ulab.array a:
+   :param ulab.array v:
+
+   Returns the discrete, linear convolution of two one-dimensional sequences.
+   The result is always an array of float.  Only the ``full`` mode is supported,
+   and the ``mode`` named parameter of numpy is not accepted. Note that all other
+   modes can be had by slicing a ``full`` result.
+
+   Convolution filters can implement high pass, low pass, band pass, etc.,
+   filtering operations.  Convolution filters are typically constructed ahead
+   of time.  This can be done using desktop python with scipy, or on web pages
+   such as https://fiiir.com/
+
+   Convolution is most time-efficient when both inputs are of float type.
+
+:mod:`ulab.fft` --- Frequency-domain functions
+==============================================
+
+.. module:: ulab.fft
+
+.. method:: fft(r, c=None)
+
+   :param ulab.array r: A 1-dimension array of values whose size is a power of 2
+   :param ulab.array c: An optional 1-dimension array of values whose size is a power of 2, giving the complex part of the value
+   :return tuple (r, c): The real and complex parts of the FFT
+
+   Perform a Fast Fourier Transform from the time domain into the frequency domain
+
+    See also ~ulab.extras.spectrum, which computes the magnitude of the fft,
+    rather than separately returning its real and imaginary parts.
+
+.. method:: ifft(r, c=None)
+
+   :param ulab.array r: A 1-dimension array of values whose size is a power of 2
+   :param ulab.array c: An optional 1-dimension array of values whose size is a power of 2, giving the complex part of the value
+   :return tuple (r, c): The real and complex parts of the inverse FFT
+
+   Perform an Inverse Fast Fourier Transform from the frequeny domain into the time domain
+
+:mod:`ulab.numerical` --- Numerical and Statistical functions
+=============================================================
+
+.. module:: ulab.numerical
+
+Most of these functions take an "axis" argument, which indicates whether to
+operate over the flattened array (None), rows (0), or columns (1).
+
+.. method:: argmax(array, \*, axis=None)
+
+   Return the index of the maximum element of the 1D array, as an array with 1 element
+
+.. method:: argmin(array, \*, axis=None)
+
+   Return the index of the minimum element of the 1D array, as an array with 1 element
+
+.. method:: argsort(array, \*, axis=None)
+
+   Returns an array which gives indices into the input array from least to greatest.
+
+.. method:: diff(array, \*, axis=1)
+
+   Return the numerical derivative of successive elements of the array, as
+   an array.  axis=None is not supported.
+
+.. method:: flip(array, \*, axis=None)
+
+   Returns a new array that reverses the order of the elements along the
+   given axis, or along all axes if axis is None.
+
+.. method:: max(array, \*, axis=None)
+
+   Return the maximum element of the 1D array, as an array with 1 element
+
+.. method:: mean(array, \*, axis=None)
+
+   Return the mean element of the 1D array, as a number if axis is None, otherwise as an array.
+
+.. method:: min(array, \*, axis=None)
+
+   Return the minimum element of the 1D array, as an array with 1 element
+
+.. method:: roll(array, distance, \*, axis=None)
+
+   Shift the content of a vector by the positions given as the second
+   argument. If the ``axis`` keyword is supplied, the shift is applied to
+   the given axis.  The array is modified in place.
+
+.. method:: std(array, \*, axis=None)
+
+   Return the standard deviation of the array, as a number if axis is None, otherwise as an array.
+
+.. method:: sum(array, \*, axis=None)
+
+   Return the sum of the array, as a number if axis is None, otherwise as an array.
+
+.. method:: sort(array, \*, axis=0)
+
+   Sort the array along the given axis, or along all axes if axis is None.
+   The array is modified in place.
+
+:mod:`ulab.poly` --- Polynomial functions
+=========================================
+
+.. module:: ulab.poly
+
+.. method:: polyfit([x, ] y, degree)
+
+   Return a polynomial of given degree that approximates the function
+   f(x)=y.  If x is not supplied, it is the range(len(y)).
+
+.. method:: polyval(p, x)
+
+   Evaluate the polynomial p at the points x.  x must be an array.
+
+:mod:`ulab.extras` --- Additional functions not in numpy
+========================================================
+
+.. method:: spectrum(r):
+
+   :param ulab.array r: A 1-dimension array of values whose size is a power of 2
+
+   Computes the spectrum of the input signal.  This is the absolute value of the (complex-valued) fft of the signal.
+
+   This function is similar to scipy's ``scipy.signal.spectrogram``.
diff --git a/shared-bindings/wiznet/wiznet5k.c b/shared-bindings/wiznet/wiznet5k.c
index ac89cc691..786978bfe 100644
--- a/shared-bindings/wiznet/wiznet5k.c
+++ b/shared-bindings/wiznet/wiznet5k.c
@@ -78,10 +78,10 @@ STATIC mp_obj_t wiznet5k_make_new(const mp_obj_type_t *type, size_t n_args, cons
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
     // TODO check type of ARG_spi?
-    assert_pin(args[ARG_cs].u_obj, false);
-    assert_pin(args[ARG_rst].u_obj, true); // may be NULL
+    const mcu_pin_obj_t *cs = validate_obj_is_free_pin(args[ARG_cs].u_obj);
+    const mcu_pin_obj_t *rst = validate_obj_is_free_pin_or_none(args[ARG_rst].u_obj);
 
-    mp_obj_t ret = wiznet5k_create(args[ARG_spi].u_obj, args[ARG_cs].u_obj, args[ARG_rst].u_obj);
+    mp_obj_t ret = wiznet5k_create(args[ARG_spi].u_obj, cs, rst);
     if (args[ARG_dhcp].u_bool) wiznet5k_start_dhcp();
     return ret;
 }