Merge branch 'main' into New_quirk_for_SH1107

13 files changed, 1292 insertions, 3 deletions

diff --git a/shared-bindings/busio/I2C.c b/shared-bindings/busio/I2C.c
index 157e779fd..8b456dbd3 100644
--- a/shared-bindings/busio/I2C.c
+++ b/shared-bindings/busio/I2C.c
@@ -39,7 +39,7 @@
 //| class I2C:
 //|     """Two wire serial protocol"""
 //|
-//|     def __init__(self, scl: microcontroller.Pin, sda: microcontroller.Pin, *, frequency: int = 400000, timeout: int = 255) -> None:
+//|     def __init__(self, scl: microcontroller.Pin, sda: microcontroller.Pin, *, frequency: int = 100000, timeout: int = 255) -> None:
 //|
 //|         """I2C is a two-wire protocol for communicating between devices.  At the
 //|         physical level it consists of 2 wires: SCL and SDA, the clock and data
@@ -70,7 +70,7 @@ STATIC mp_obj_t busio_i2c_make_new(const mp_obj_type_t *type, size_t n_args, con
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_scl, MP_ARG_REQUIRED | MP_ARG_OBJ },
         { MP_QSTR_sda, MP_ARG_REQUIRED | MP_ARG_OBJ },
-        { MP_QSTR_frequency, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 400000} },
+        { MP_QSTR_frequency, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 100000} },
         { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 255} },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
diff --git a/shared-bindings/busio/SPI.c b/shared-bindings/busio/SPI.c
index aefe4f5a7..e47564c8c 100644
--- a/shared-bindings/busio/SPI.c
+++ b/shared-bindings/busio/SPI.c
@@ -96,6 +96,10 @@ STATIC mp_obj_t busio_spi_make_new(const mp_obj_type_t *type, size_t n_args, con
     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);
 
+    if (!miso && !mosi) {
+        mp_raise_ValueError(translate("Must provide MISO or MOSI pin"));
+    }
+
     common_hal_busio_spi_construct(self, clock, mosi, miso);
     return MP_OBJ_FROM_PTR(self);
 }
diff --git a/shared-bindings/canio/CAN.c b/shared-bindings/canio/CAN.c
new file mode 100644
index 000000000..ff27bb204
--- /dev/null
+++ b/shared-bindings/canio/CAN.c
@@ -0,0 +1,422 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+ *
+ * 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 "py/enum.h"
+#include "common-hal/canio/CAN.h"
+#include "common-hal/canio/Listener.h"
+#include "shared-bindings/canio/__init__.h"
+#include "shared-bindings/canio/CAN.h"
+#include "shared-bindings/canio/Listener.h"
+#include "shared-bindings/canio/Match.h"
+#include "shared-bindings/canio/Message.h"
+#include "shared-bindings/microcontroller/Pin.h"
+
+#include "py/objproperty.h"
+#include "py/runtime.h"
+
+//|
+//| class CAN:
+//|     """CAN bus protocol"""
+//|
+//|     def __init__(self,
+//|             tx: microcontroller.Pin,
+//|             rx: microcontroller.Pin,
+//|             *,
+//|             baudrate: int = 250000,
+//|             loopback: bool = False,
+//|             silent: bool = False,
+//|             auto_restart: bool = False,
+//|         ):
+//|         """A common shared-bus protocol.  The rx and tx pins are generally
+//|         connected to a transceiver which controls the H and L pins on a
+//|         shared bus.
+//|
+//|         :param ~microcontroller.Pin rx: the pin to receive with
+//|         :param ~microcontroller.Pin tx: the pin to transmit with
+//|         :param int baudrate: The bit rate of the bus in Hz.  All devices on the bus must agree on this value.
+//|         :param bool loopback: When True  the ``rx`` pin's value is ignored, and the device receives the packets it sends.
+//|         :param bool silent: When True the ``tx`` pin is always driven to the high logic level.  This mode can be used to "sniff" a CAN bus without interfering.
+//|         :param bool auto_restart: If True, will restart communications after entering bus-off state
+//|         """
+//|         ...
+//|
+STATIC mp_obj_t canio_can_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_tx, ARG_rx, ARG_baudrate, ARG_loopback, ARG_silent, ARG_auto_restart, NUM_ARGS };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_tx, MP_ARG_OBJ | MP_ARG_REQUIRED },
+        { MP_QSTR_rx, MP_ARG_OBJ | MP_ARG_REQUIRED },
+        { MP_QSTR_baudrate, MP_ARG_INT, {.u_int = 250000} },
+        { MP_QSTR_loopback, MP_ARG_BOOL, {.u_bool = false} },
+        { MP_QSTR_silent, MP_ARG_BOOL, {.u_bool = false} },
+        { MP_QSTR_auto_restart, MP_ARG_BOOL, {.u_bool = false} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    MP_STATIC_ASSERT( MP_ARRAY_SIZE(allowed_args) == NUM_ARGS );
+
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    mcu_pin_obj_t *rx_pin = validate_obj_is_free_pin_or_none(args[ARG_rx].u_obj);
+    mcu_pin_obj_t *tx_pin = validate_obj_is_free_pin_or_none(args[ARG_tx].u_obj);
+    if (!rx_pin && !tx_pin) {
+        mp_raise_ValueError(translate("tx and rx cannot both be None"));
+    }
+
+    canio_can_obj_t *self = m_new_obj(canio_can_obj_t);
+    self->base.type = &canio_can_type;
+    common_hal_canio_can_construct(self, tx_pin, rx_pin, args[ARG_baudrate].u_int, args[ARG_loopback].u_bool, args[ARG_silent].u_bool);
+
+    common_hal_canio_can_auto_restart_set(self, args[ARG_auto_restart].u_bool);
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+
+//|     auto_restart: bool
+//|     """If True, will restart communications after entering bus-off state"""
+//|
+STATIC mp_obj_t canio_can_auto_restart_get(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    return mp_obj_new_bool(common_hal_canio_can_auto_restart_get(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_can_auto_restart_get_obj, canio_can_auto_restart_get);
+
+STATIC mp_obj_t canio_can_auto_restart_set(mp_obj_t self_in, mp_obj_t flag_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    common_hal_canio_can_auto_restart_set(self, mp_obj_is_true(flag_in));
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(canio_can_auto_restart_set_obj, canio_can_auto_restart_set);
+
+STATIC const mp_obj_property_t canio_can_auto_restart_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_can_auto_restart_get_obj,
+              (mp_obj_t)&canio_can_auto_restart_set_obj,
+              (mp_obj_t)mp_const_none},
+};
+
+
+//|     baudrate: int
+//|     """The baud rate (read-only)"""
+//|
+STATIC mp_obj_t canio_can_baudrate_get(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_can_baudrate_get(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_can_baudrate_get_obj, canio_can_baudrate_get);
+
+STATIC const mp_obj_property_t canio_can_baudrate_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_can_baudrate_get_obj,
+              (mp_obj_t)mp_const_none,
+              (mp_obj_t)mp_const_none},
+};
+
+//|     transmit_error_count: int
+//|     """The number of transmit errors (read-only).  Increased for a detected transmission error, decreased for successful transmission.  Limited to the range from 0 to 255 inclusive.  Also called TEC."""
+//|
+STATIC mp_obj_t canio_can_transmit_error_count_get(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_can_transmit_error_count_get(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_can_transmit_error_count_get_obj, canio_can_transmit_error_count_get);
+
+STATIC const mp_obj_property_t canio_can_transmit_error_count_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_can_transmit_error_count_get_obj,
+              (mp_obj_t)mp_const_none,
+              (mp_obj_t)mp_const_none},
+};
+
+//|     receive_error_count: int
+//|     """The number of receive errors (read-only).  Increased for a detected reception error, decreased for successful reception.  Limited to the range from 0 to 255 inclusive.  Also called REC."""
+//|
+STATIC mp_obj_t canio_can_receive_error_count_get(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_can_receive_error_count_get(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_can_receive_error_count_get_obj, canio_can_receive_error_count_get);
+
+STATIC const mp_obj_property_t canio_can_receive_error_count_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_can_receive_error_count_get_obj,
+              (mp_obj_t)mp_const_none,
+              (mp_obj_t)mp_const_none},
+};
+
+//|     error_warning_state_count: int
+//|     """The number of times the controller enterted the Error Warning state (read-only).  This number wraps around to 0 after an implementation-defined number of errors."""
+//|
+STATIC mp_obj_t canio_can_error_warning_state_count_get(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_can_error_warning_state_count_get(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_can_error_warning_state_count_get_obj, canio_can_error_warning_state_count_get);
+
+STATIC const mp_obj_property_t canio_can_error_warning_state_count_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_can_error_warning_state_count_get_obj,
+              (mp_obj_t)mp_const_none,
+              (mp_obj_t)mp_const_none},
+};
+
+//|     error_passive_state_count: int
+//|     """The number of times the controller enterted the Error Passive state (read-only).  This number wraps around to 0 after an implementation-defined number of errors."""
+//|
+STATIC mp_obj_t canio_can_error_passive_state_count_get(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_can_error_passive_state_count_get(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_can_error_passive_state_count_get_obj, canio_can_error_passive_state_count_get);
+
+STATIC const mp_obj_property_t canio_can_error_passive_state_count_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_can_error_passive_state_count_get_obj,
+              (mp_obj_t)mp_const_none,
+              (mp_obj_t)mp_const_none},
+};
+
+//|     bus_off_state_count: int
+//|     """The number of times the controller enterted the Bus Off state (read-only).  This number wraps around to 0 after an implementation-defined number of errors."""
+//|
+STATIC mp_obj_t canio_can_bus_off_state_count_get(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_can_bus_off_state_count_get(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_can_bus_off_state_count_get_obj, canio_can_bus_off_state_count_get);
+
+STATIC const mp_obj_property_t canio_can_bus_off_state_count_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_can_bus_off_state_count_get_obj,
+              (mp_obj_t)mp_const_none,
+              (mp_obj_t)mp_const_none},
+};
+
+//|     state: State
+//|     """The current state of the bus."""
+STATIC mp_obj_t canio_can_state_get(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    return cp_enum_find(&canio_bus_state_type, common_hal_canio_can_state_get(self));
+}
+
+MP_DEFINE_CONST_FUN_OBJ_1(canio_can_state_get_obj, canio_can_state_get);
+
+STATIC const mp_obj_property_t canio_can_state_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_can_state_get_obj,
+              (mp_obj_t)mp_const_none,
+              (mp_obj_t)mp_const_none},
+};
+
+
+//|     def restart(self) -> None:
+//|         """If the device is in the bus off state, restart it."""
+//|         ...
+//|
+STATIC mp_obj_t canio_can_restart(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    common_hal_canio_can_restart(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_can_restart_obj, canio_can_restart);
+
+//|     def listen(self, match: Optional[Sequence[Match]]=None, *, timeout: float=10) -> Listener:
+//|         """Start receiving messages that match any one of the filters.
+//|
+//|         Creating a listener is an expensive operation and can interfere with reception of messages by other listeners.
+//|
+//|         There is an implementation-defined maximum number of listeners and limit to the complexity of the filters.
+//|
+//|         If the hardware cannot support all the requested matches, a ValueError is raised.  Note that generally there are some number of hardware filters shared among all fifos.
+//|
+//|         A message can be received by at most one Listener.  If more than one listener matches a message, it is undefined which one actually receives it.
+//|
+//|         An empty filter list causes all messages to be accepted.
+//|
+//|         Timeout dictates how long readinto, read and next() will block."""
+//|         ...
+//|
+STATIC mp_obj_t canio_can_listen(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    common_hal_canio_can_check_for_deinit(self);
+
+    enum { ARG_match, ARG_timeout, NUM_ARGS };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_match, MP_ARG_OBJ, {.u_obj = 0} },
+        { MP_QSTR_timeout, MP_ARG_OBJ, {.u_obj = 0} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    MP_STATIC_ASSERT( MP_ARRAY_SIZE(allowed_args) == NUM_ARGS );
+
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    size_t nmatch = 0;
+    mp_obj_t *match_objects = NULL;
+
+    if (args[ARG_match].u_obj) {
+        mp_obj_get_array(args[ARG_match].u_obj, &nmatch, &match_objects);
+    }
+
+    canio_match_obj_t *matches[nmatch];
+    for (size_t i=0; i<nmatch; i++) {
+        mp_obj_type_t *type = mp_obj_get_type(match_objects[i]);
+        if (type != &canio_match_type) {
+            mp_raise_TypeError_varg(translate("expected '%q' but got '%q'"), MP_QSTR_Match, type->name);
+        }
+        matches[i] = MP_OBJ_TO_PTR(match_objects[i]);
+    }
+
+    float timeout = args[ARG_timeout].u_obj ? mp_obj_get_float(args[ARG_timeout].u_obj) : 10.0f;
+    canio_listener_obj_t *listener = m_new_obj(canio_listener_obj_t);
+    listener->base.type = &canio_listener_type;
+    common_hal_canio_listener_construct(listener, self, nmatch, matches, timeout);
+    return listener;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(canio_can_listen_obj, 1, canio_can_listen);
+
+//|     loopback: bool
+//|     """True if the device was created in loopback mode, False otherwise"""
+//|
+STATIC mp_obj_t canio_can_loopback_get(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    return mp_obj_new_bool(common_hal_canio_can_loopback_get(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_can_loopback_get_obj, canio_can_loopback_get);
+
+STATIC const mp_obj_property_t canio_can_loopback_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_can_loopback_get_obj,
+              (mp_obj_t)mp_const_none,
+              (mp_obj_t)mp_const_none},
+};
+
+
+//|     def send(message: Message) -> None:
+//|         """Send a message on the bus with the given data and id.
+//|         If the message could not be sent due to a full fifo or a bus error condition, RuntimeError is raised.
+//|         """
+//|         ...
+//|
+STATIC mp_obj_t canio_can_send(mp_obj_t self_in, mp_obj_t message_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    mp_obj_type_t *message_type = mp_obj_get_type(message_in);
+    if (message_type != &canio_message_type) {
+        mp_raise_TypeError_varg(translate("expected '%q' but got '%q'"), MP_QSTR_Message, message_type->name);
+    }
+
+    canio_message_obj_t *message = message_in;
+    common_hal_canio_can_send(self, message);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(canio_can_send_obj, canio_can_send);
+
+//|     silent: bool
+//|     """True if the device was created in silent mode, False otherwise"""
+//|
+STATIC mp_obj_t canio_can_silent_get(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    return mp_obj_new_bool(common_hal_canio_can_silent_get(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_can_silent_get_obj, canio_can_silent_get);
+
+STATIC const mp_obj_property_t canio_can_silent_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_can_silent_get_obj,
+              (mp_obj_t)mp_const_none,
+              (mp_obj_t)mp_const_none},
+};
+
+
+//|     def deinit(self) -> None:
+//|         """Deinitialize this object, freeing its hardware resources"""
+//|         ...
+//|
+STATIC mp_obj_t canio_can_deinit(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_deinit(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_can_deinit_obj, canio_can_deinit);
+
+//|     def __enter__(self) -> CAN:
+//|         """Returns self, to allow the object to be used in a `with` statement for resource control"""
+//|         ...
+//|
+STATIC mp_obj_t canio_can_enter(mp_obj_t self_in) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_can_check_for_deinit(self);
+    return self_in;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_can_enter_obj, canio_can_enter);
+
+//|     def __exit__(self, unused1, unused2, unused3) -> None:
+//|         """Calls deinit()"""
+//|         ...
+STATIC mp_obj_t canio_can_exit(size_t num_args, const mp_obj_t args[]) {
+    canio_can_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    common_hal_canio_can_deinit(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(canio_can_exit_obj, 4, 4, canio_can_exit);
+
+STATIC const mp_rom_map_elem_t canio_can_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&canio_can_enter_obj) },
+    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&canio_can_exit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_auto_restart), MP_ROM_PTR(&canio_can_auto_restart_obj) },
+    { MP_ROM_QSTR(MP_QSTR_baudrate), MP_ROM_PTR(&canio_can_baudrate_obj) },
+    { MP_ROM_QSTR(MP_QSTR_bus_off_state_count), MP_ROM_PTR(&canio_can_bus_off_state_count_obj) },
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&canio_can_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_error_passive_state_count), MP_ROM_PTR(&canio_can_error_passive_state_count_obj) },
+    { MP_ROM_QSTR(MP_QSTR_error_warning_state_count), MP_ROM_PTR(&canio_can_error_warning_state_count_obj) },
+    { MP_ROM_QSTR(MP_QSTR_listen), MP_ROM_PTR(&canio_can_listen_obj) },
+    { MP_ROM_QSTR(MP_QSTR_loopback), MP_ROM_PTR(&canio_can_loopback_obj) },
+    { MP_ROM_QSTR(MP_QSTR_receive_error_count), MP_ROM_PTR(&canio_can_receive_error_count_obj) },
+    { MP_ROM_QSTR(MP_QSTR_restart), MP_ROM_PTR(&canio_can_restart_obj) },
+    { MP_ROM_QSTR(MP_QSTR_send), MP_ROM_PTR(&canio_can_send_obj) },
+    { MP_ROM_QSTR(MP_QSTR_silent), MP_ROM_PTR(&canio_can_silent_obj) },
+    { MP_ROM_QSTR(MP_QSTR_state), MP_ROM_PTR(&canio_can_state_obj) },
+    { MP_ROM_QSTR(MP_QSTR_transmit_error_count), MP_ROM_PTR(&canio_can_transmit_error_count_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(canio_can_locals_dict, canio_can_locals_dict_table);
+
+const mp_obj_type_t canio_can_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_CAN,
+    .make_new = canio_can_make_new,
+    .locals_dict = (mp_obj_t)&canio_can_locals_dict,
+};
diff --git a/shared-bindings/canio/CAN.h b/shared-bindings/canio/CAN.h
new file mode 100644
index 000000000..66c972c28
--- /dev/null
+++ b/shared-bindings/canio/CAN.h
@@ -0,0 +1,54 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include "py/obj.h"
+#include "shared-bindings/microcontroller/Pin.h"
+#include "shared-bindings/canio/Message.h"
+
+extern const mp_obj_type_t canio_can_type;
+
+typedef struct canio_can_obj canio_can_obj_t;
+
+void common_hal_canio_can_construct(canio_can_obj_t *self, mcu_pin_obj_t *tx, mcu_pin_obj_t *rx, int baudrate, bool loopback, bool silent);
+bool common_hal_canio_can_auto_restart_get(canio_can_obj_t *self);
+bool common_hal_canio_can_deinited(canio_can_obj_t *self);
+int common_hal_canio_can_baudrate_get(canio_can_obj_t *self);
+int common_hal_canio_can_bus_off_state_count_get(canio_can_obj_t *self);
+int common_hal_canio_can_error_passive_state_count_get(canio_can_obj_t *self);
+int common_hal_canio_can_error_warning_state_count_get(canio_can_obj_t *self);
+bool common_hal_canio_can_loopback_get(canio_can_obj_t *self);
+int common_hal_canio_can_receive_error_count_get(canio_can_obj_t *self);
+canio_bus_state_t common_hal_canio_can_state_get(canio_can_obj_t *self);
+bool common_hal_canio_can_silent_get(canio_can_obj_t *self);
+int common_hal_canio_can_transmit_error_count_get(canio_can_obj_t *self);
+void common_hal_canio_can_auto_restart_set(canio_can_obj_t *self, bool auto_restart);
+void common_hal_canio_can_check_for_deinit(canio_can_obj_t *self);
+void common_hal_canio_can_deinit(canio_can_obj_t *self);
+void common_hal_canio_can_restart(canio_can_obj_t *self);
+void common_hal_canio_can_send(canio_can_obj_t *self, canio_message_obj_t *message);
+void common_hal_canio_reset(void);
diff --git a/shared-bindings/canio/Listener.c b/shared-bindings/canio/Listener.c
new file mode 100644
index 000000000..1f4176f0c
--- /dev/null
+++ b/shared-bindings/canio/Listener.c
@@ -0,0 +1,185 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+ *
+ * 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 "shared-bindings/canio/Listener.h"
+#include "shared-bindings/canio/Message.h"
+#include "common-hal/canio/Listener.h"
+
+#include "py/runtime.h"
+#include "py/objproperty.h"
+
+//| class Listener:
+//|     """Listens for CAN message
+//|
+//|     canio.Listener is not constructed directly, but instead by calling the
+//|     Listen method of a canio.CAN object."""
+//|
+
+//|     def read(self) -> Optional[Message]:
+//|         """Reads a message, after waiting up to self.timeout seconds
+//|
+//|         If no message is received in time, None is returned.  Otherwise,
+//|         a Message is returned."""
+//|         ...
+//|
+STATIC mp_obj_t canio_listener_read(mp_obj_t self_in) {
+    canio_listener_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_listener_check_for_deinit(self);
+
+    canio_message_obj_t *message = m_new_obj(canio_message_obj_t);
+    message->base.type = &canio_message_type;
+
+    if (common_hal_canio_listener_readinto(self, message)) {
+        return message;
+    } else {
+        m_free(message); // message did not escape into vm
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_listener_read_obj, canio_listener_read);
+
+//|     def readinto(self, message: Message) -> bool:
+//|         """Returns True (and modifies message) if a message was received
+//|         before ``timeout`` seconds elapsed, False otherwise."""
+//|         ...
+//|
+STATIC mp_obj_t canio_listener_readinto(mp_obj_t self_in, mp_obj_t message) {
+    canio_listener_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_obj_type_t *type = mp_obj_get_type(message);
+    if (type != &canio_message_type) {
+        mp_raise_TypeError_varg(translate("expected '%q' but got '%q'"), MP_QSTR_Message, type->name);
+    }
+    common_hal_canio_listener_check_for_deinit(self);
+    return mp_obj_new_bool(common_hal_canio_listener_readinto(self, message));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(canio_listener_readinto_obj, canio_listener_readinto);
+
+//|     def in_waiting(self) -> int:
+//|         """Returns the number of messages waiting"""
+//|         ...
+//|
+STATIC mp_obj_t canio_listener_in_waiting(mp_obj_t self_in) {
+    canio_listener_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_listener_check_for_deinit(self);
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_listener_in_waiting(self));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_listener_in_waiting_obj, canio_listener_in_waiting);
+
+//|     def __iter__(self):
+//|         """Returns self, unless the object is deinitialized"""
+//|         ...
+//|
+//|     def __next__(self):
+//|         """Reads a message, after waiting up to self.timeout seconds
+//|
+//|         If no message is received in time, raises StopIteration.  Otherwise,
+//|         a Message is returned."""
+//|         ...
+//|
+STATIC mp_obj_t canio_iternext(mp_obj_t self_in) {
+    mp_obj_t result = canio_listener_read(self_in);
+    if (result == mp_const_none) {
+        return MP_OBJ_STOP_ITERATION;
+    }
+    return result;
+}
+
+//|     def deinit(self) -> None:
+//|         """Deinitialize this object, freeing its hardware resources"""
+//|         ...
+//|
+STATIC mp_obj_t canio_listener_deinit(mp_obj_t self_in) {
+    canio_listener_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_listener_deinit(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_listener_deinit_obj, canio_listener_deinit);
+
+//|     def __enter__(self) -> CAN:
+//|         """Returns self, to allow the object to be used in a `with` statement for resource control"""
+//|         ...
+//|
+STATIC mp_obj_t canio_listener_enter(mp_obj_t self_in) {
+    canio_listener_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_listener_check_for_deinit(self);
+    return self_in;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_listener_enter_obj, canio_listener_enter);
+
+//|     def __exit__(self, unused1, unused2, unused3) -> None:
+//|         """Calls deinit()"""
+//|         ...
+STATIC mp_obj_t canio_listener_exit(size_t num_args, const mp_obj_t args[]) {
+    canio_listener_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    common_hal_canio_listener_deinit(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(canio_listener_exit_obj, 4, 4, canio_listener_exit);
+
+
+//|     timeout : float
+STATIC mp_obj_t canio_listener_timeout_get(mp_obj_t self_in) {
+    canio_listener_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_listener_check_for_deinit(self);
+    return mp_obj_new_float(common_hal_canio_listener_get_timeout(self));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_listener_timeout_get_obj, canio_listener_timeout_get);
+
+STATIC mp_obj_t canio_listener_timeout_set(mp_obj_t self_in, mp_obj_t timeout_in) {
+    canio_listener_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_canio_listener_check_for_deinit(self);
+    common_hal_canio_listener_set_timeout(self, mp_obj_get_float(timeout_in));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(canio_listener_timeout_set_obj, canio_listener_timeout_set);
+
+STATIC const mp_obj_property_t canio_listener_timeout_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_listener_timeout_get_obj,
+              (mp_obj_t)&canio_listener_timeout_set_obj,
+              (mp_obj_t)mp_const_none},
+};
+
+
+
+STATIC const mp_rom_map_elem_t canio_listener_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&canio_listener_enter_obj) },
+    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&canio_listener_exit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&canio_listener_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_in_waiting), MP_ROM_PTR(&canio_listener_in_waiting_obj) },
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&canio_listener_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&canio_listener_readinto_obj) },
+    { MP_ROM_QSTR(MP_QSTR_timeout), MP_ROM_PTR(&canio_listener_timeout_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(canio_listener_locals_dict, canio_listener_locals_dict_table);
+
+const mp_obj_type_t canio_listener_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Listener,
+    .getiter = mp_identity_getiter,
+    .iternext = canio_iternext,
+    .locals_dict = (mp_obj_dict_t*)&canio_listener_locals_dict,
+};
diff --git a/shared-bindings/canio/Listener.h b/shared-bindings/canio/Listener.h
new file mode 100644
index 000000000..eaa3490df
--- /dev/null
+++ b/shared-bindings/canio/Listener.h
@@ -0,0 +1,31 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include "py/obj.h"
+
+extern const mp_obj_type_t canio_listener_type;
diff --git a/shared-bindings/canio/Match.c b/shared-bindings/canio/Match.c
new file mode 100644
index 000000000..ff5d028fa
--- /dev/null
+++ b/shared-bindings/canio/Match.c
@@ -0,0 +1,139 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+ *
+ * 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 "shared-bindings/canio/Match.h"
+
+#include "py/objproperty.h"
+#include "py/runtime.h"
+
+//| class Match:
+//|     """Describe CAN bus messages to match"""
+//|
+//|
+//|     def __init__(self, address: int, *, mask: int = 0, extended: bool = False):
+//|         """Construct a Match with the given properties.
+//|
+//|         If mask is nonzero, then the filter is for any sender which matches all
+//|         the nonzero bits in mask. Otherwise, it matches exactly the given address.
+//|         If extended is true then only extended addresses are matched, otherwise
+//|         only standard addresses are matched."""
+//|
+
+STATIC mp_obj_t canio_match_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_address, ARG_mask, ARG_extended, NUM_ARGS };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_address, MP_ARG_INT | MP_ARG_REQUIRED },
+        { MP_QSTR_mask, MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_extended, MP_ARG_BOOL, {.u_bool = false} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    MP_STATIC_ASSERT( MP_ARRAY_SIZE(allowed_args) == NUM_ARGS );
+
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    int address_bits = args[ARG_extended].u_bool ? 0x1fffffff : 0x7ff;
+    int address = args[ARG_address].u_int;
+    int mask = args[ARG_mask].u_int;
+
+    if (address & ~address_bits) {
+        mp_raise_ValueError_varg(translate("%q out of range"), MP_QSTR_address);
+    }
+
+    if (mask & ~address_bits) {
+        mp_raise_ValueError_varg(translate("%q out of range"), MP_QSTR_mask);
+    }
+
+    canio_match_obj_t *self = m_new_obj(canio_match_obj_t);
+    self->base.type = &canio_match_type;
+    common_hal_canio_match_construct(self, args[ARG_address].u_int, args[ARG_mask].u_int, args[ARG_extended].u_bool);
+    return self;
+}
+
+//|     address: int
+//|     """The address to match"""
+//|
+
+STATIC mp_obj_t canio_match_address_get(mp_obj_t self_in) {
+    canio_match_obj_t *self = self_in;
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_match_get_address(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_match_address_get_obj, canio_match_address_get);
+
+const mp_obj_property_t canio_match_address_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_match_address_get_obj,
+              (mp_obj_t)&mp_const_none_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
+//|
+//|     mask: int
+//|     """The optional mask of addresses to match"""
+//|
+
+STATIC mp_obj_t canio_match_mask_get(mp_obj_t self_in) {
+    canio_match_obj_t *self = self_in;
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_match_get_mask(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_match_mask_get_obj, canio_match_mask_get);
+
+const mp_obj_property_t canio_match_mask_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_match_mask_get_obj,
+              (mp_obj_t)&mp_const_none_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
+//|     extended: bool
+//|     """True to match extended addresses, False to match standard addresses"""
+//|
+
+STATIC mp_obj_t canio_match_extended_get(mp_obj_t self_in) {
+    canio_match_obj_t *self = self_in;
+    return mp_obj_new_bool(common_hal_canio_match_get_extended(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_match_extended_get_obj, canio_match_extended_get);
+
+const mp_obj_property_t canio_match_extended_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_match_extended_get_obj,
+              (mp_obj_t)&mp_const_none_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
+STATIC const mp_rom_map_elem_t canio_match_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_address), MP_ROM_PTR(&canio_match_address_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mask), MP_ROM_PTR(&canio_match_mask_obj) },
+    { MP_ROM_QSTR(MP_QSTR_extended), MP_ROM_PTR(&canio_match_extended_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(canio_match_locals_dict, canio_match_locals_dict_table);
+
+const mp_obj_type_t canio_match_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Match,
+    .make_new = canio_match_make_new,
+    .locals_dict = (mp_obj_dict_t*)&canio_match_locals_dict,
+};
diff --git a/shared-bindings/canio/Match.h b/shared-bindings/canio/Match.h
new file mode 100644
index 000000000..88996d730
--- /dev/null
+++ b/shared-bindings/canio/Match.h
@@ -0,0 +1,37 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include "py/obj.h"
+#include "shared-module/canio/Match.h"
+
+extern const mp_obj_type_t canio_match_type;
+
+void common_hal_canio_match_construct(canio_match_obj_t *self, int address, int mask, bool extended);
+int common_hal_canio_match_get_address(const canio_match_obj_t *self);
+int common_hal_canio_match_get_mask(const canio_match_obj_t *self);
+bool common_hal_canio_match_get_extended(const canio_match_obj_t *self);
diff --git a/shared-bindings/canio/Message.c b/shared-bindings/canio/Message.c
new file mode 100644
index 000000000..23645d2e5
--- /dev/null
+++ b/shared-bindings/canio/Message.c
@@ -0,0 +1,212 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+ *
+ * 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 "shared-bindings/canio/Message.h"
+
+#include "py/obj.h"
+#include "py/objproperty.h"
+#include "py/runtime.h"
+
+//| class Message:
+//|     def __init__(self, id: int=0, data: Optional[bytes] = None, *, size: Optional[int] = None, rtr: bool = False, extended: bool = False):
+//|         """Construct a Message to use with a CAN bus.  Provide arguments to create a message to send.  Otherwise, use Listener.readinto() to read a message.
+//|
+//|         :param int id: The numeric ID of the message
+//|         :param bytes data: The content of the message
+//|         :param int size: The amount of data requested, for an rtr
+//|         :param bool rtr: True if the message represents an rtr (Remote Transmission Request)
+//|         :param bool extended: True if the message has an extended identifier, False if it has a standard identifier
+//|
+//|         In CAN, messages can have a size from 0 to 8 bytes.
+//|
+//|         For a non-rtr message, specify ``data``.  For an rtr-message, specify either ``data`` (a dummy buffer of the requested size) or ``size``.
+//|         """
+//|         ...
+//|
+STATIC mp_obj_t canio_message_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_id, ARG_data, ARG_size, ARG_rtr, ARG_extended, NUM_ARGS };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_id, MP_ARG_INT, {.u_obj = 0} },
+        { MP_QSTR_data, MP_ARG_OBJ, {.u_obj = 0} },
+        { MP_QSTR_size, MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_rtr, MP_ARG_BOOL, {.u_bool = false} },
+        { MP_QSTR_extended, MP_ARG_BOOL, {.u_bool = false} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    MP_STATIC_ASSERT( MP_ARRAY_SIZE(allowed_args) == NUM_ARGS );
+
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    bool rtr = args[ARG_rtr].u_bool;
+    bool extended = args[ARG_extended].u_bool;
+    size_t size = (size_t)args[ARG_size].u_int;
+    bool specified_size = (size != (size_t)-1);
+    bool specified_data = (args[ARG_data].u_obj != NULL);
+
+    if (specified_size && specified_data) {
+        mp_raise_TypeError(translate("specify size or data, but not both"));
+    }
+
+    mp_buffer_info_t data;
+    if (specified_data) {
+        mp_get_buffer_raise(args[ARG_data].u_obj, &data, MP_BUFFER_READ);
+    } else if (specified_size) {
+        data.buf = 0;
+        data.len = size;
+    } else {
+        data.buf = 0;
+        data.len = 0;
+    }
+
+    if (data.len > 8) {
+        mp_raise_ValueError(translate("Messages limited to 8 bytes"));
+    }
+
+    canio_message_obj_t *self = m_new_obj(canio_message_obj_t);
+    self->base.type = &canio_message_type;
+    common_hal_canio_message_construct(self, args[ARG_id].u_int, data.buf, data.len, rtr, extended);
+    return self;
+}
+
+//|     id: int
+//|     """The numeric ID of the message"""
+//|
+STATIC mp_obj_t canio_message_id_get(const mp_obj_t self_in) {
+    canio_message_obj_t *self = self_in;
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_message_get_id(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_message_id_get_obj, canio_message_id_get);
+
+STATIC mp_obj_t canio_message_id_set(const mp_obj_t self_in, const mp_obj_t id) {
+    canio_message_obj_t *self = self_in;
+    common_hal_canio_message_set_id(self, mp_obj_get_int(id));
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(canio_message_id_set_obj, canio_message_id_set);
+
+STATIC const mp_obj_property_t canio_message_id_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_message_id_get_obj,
+              (mp_obj_t)&canio_message_id_set_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
+//|     data: bytes
+//|     """The content of the message, or dummy content in the case of an rtr.
+//|
+//|     Assigning to data also sets the length and clears the rtr flag."""
+//|
+STATIC mp_obj_t canio_message_data_get(const mp_obj_t self_in) {
+    canio_message_obj_t *self = self_in;
+    return mp_obj_new_bytes((const byte*)common_hal_canio_message_get_data(self), common_hal_canio_message_get_size(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_message_data_get_obj, canio_message_data_get);
+
+STATIC mp_obj_t canio_message_data_set(const mp_obj_t self_in, const mp_obj_t data_in) {
+    canio_message_obj_t *self = self_in;
+    mp_buffer_info_t data;
+    mp_get_buffer_raise(data_in, &data, MP_BUFFER_READ);
+    if (data.len > 8) {
+        mp_raise_ValueError(translate("Messages limited to 8 bytes"));
+    }
+    common_hal_canio_message_set_data(self, data.buf, data.len);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(canio_message_data_set_obj, canio_message_data_set);
+
+
+STATIC const mp_obj_property_t canio_message_data_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_message_data_get_obj,
+              (mp_obj_t)&canio_message_data_set_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
+
+//|     extended: bool
+//|     """True if the message represents a remote transmission request (RTR)"""
+//|
+STATIC mp_obj_t canio_message_extended_get(const mp_obj_t self_in) {
+    canio_message_obj_t *self = self_in;
+    return mp_obj_new_bool(common_hal_canio_message_get_extended(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_message_extended_get_obj, canio_message_extended_get);
+
+STATIC mp_obj_t canio_message_extended_set(const mp_obj_t self_in, const mp_obj_t extended) {
+    canio_message_obj_t *self = self_in;
+    common_hal_canio_message_set_extended(self, mp_obj_is_true(extended));
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(canio_message_extended_set_obj, canio_message_extended_set);
+
+
+STATIC const mp_obj_property_t canio_message_extended_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_message_extended_get_obj,
+              (mp_obj_t)&canio_message_extended_set_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
+
+//|     rtr: bool
+//|     """True if the message represents a remote transmission request (RTR).  Setting rtr to true zeros out data"""
+//|
+STATIC mp_obj_t canio_message_rtr_get(const mp_obj_t self_in) {
+    canio_message_obj_t *self = self_in;
+    return mp_obj_new_bool(common_hal_canio_message_get_rtr(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_message_rtr_get_obj, canio_message_rtr_get);
+
+STATIC mp_obj_t canio_message_rtr_set(const mp_obj_t self_in, const mp_obj_t rtr) {
+    canio_message_obj_t *self = self_in;
+    common_hal_canio_message_set_rtr(self, mp_obj_is_true(rtr));
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(canio_message_rtr_set_obj, canio_message_rtr_set);
+
+
+STATIC const mp_obj_property_t canio_message_rtr_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_message_rtr_get_obj,
+              (mp_obj_t)&canio_message_rtr_set_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
+
+STATIC const mp_rom_map_elem_t canio_message_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_id), MP_ROM_PTR(&canio_message_id_obj) },
+    { MP_ROM_QSTR(MP_QSTR_data), MP_ROM_PTR(&canio_message_data_obj) },
+    { MP_ROM_QSTR(MP_QSTR_rtr), MP_ROM_PTR(&canio_message_rtr_obj) },
+    { MP_ROM_QSTR(MP_QSTR_extended), MP_ROM_PTR(&canio_message_extended_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(canio_message_locals_dict, canio_message_locals_dict_table);
+
+const mp_obj_type_t canio_message_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Message,
+    .make_new = canio_message_make_new,
+    .locals_dict = (mp_obj_t)&canio_message_locals_dict,
+};
diff --git a/shared-bindings/canio/Message.h b/shared-bindings/canio/Message.h
new file mode 100644
index 000000000..34b632e84
--- /dev/null
+++ b/shared-bindings/canio/Message.h
@@ -0,0 +1,44 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include "py/obj.h"
+#include "shared-module/canio/Message.h"
+
+extern const mp_obj_type_t canio_message_type;
+
+void common_hal_canio_message_construct(canio_message_obj_t *self, int id, void *data, size_t size, bool rtr, bool extended);
+const void *common_hal_canio_message_get_data(const canio_message_obj_t *self);
+void common_hal_canio_message_set_data(canio_message_obj_t *self, const void *data, size_t size);
+bool common_hal_canio_message_get_extended(const canio_message_obj_t *self);
+void common_hal_canio_message_set_extended(canio_message_obj_t *self, bool extended);
+int common_hal_canio_message_get_id(const canio_message_obj_t *self);
+void common_hal_canio_message_set_id(canio_message_obj_t *self, int id);
+bool common_hal_canio_message_get_rtr(const canio_message_obj_t *self);
+void common_hal_canio_message_set_rtr(canio_message_obj_t *self, bool rtr);
+size_t common_hal_canio_message_get_size(const canio_message_obj_t *self);
+void common_hal_canio_message_set_size(canio_message_obj_t *self, size_t size);
diff --git a/shared-bindings/canio/__init__.c b/shared-bindings/canio/__init__.c
new file mode 100644
index 000000000..b0b982c95
--- /dev/null
+++ b/shared-bindings/canio/__init__.c
@@ -0,0 +1,124 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+ *
+ * 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.
+ */
+
+//| """CAN bus access
+//|
+//| The `canio` module contains low level classes to support the CAN bus
+//| protocol.
+//|
+//| CAN and Listener classes change hardware state and should be deinitialized when they
+//| are no longer needed if the program continues after use. To do so, either
+//| call :py:meth:`!deinit` or use a context manager. See
+//| :ref:`lifetime-and-contextmanagers` for more info.
+//|
+//| For example::
+//|
+//|   import canio
+//|   from board import *
+//|
+//|   can = canio.CAN(board.CAN_RX, board.CAN_TX, baudrate=1000000)
+//|   message = canio.Message(id=0x0408, data="adafruit"
+//|   can.write(message))
+//|   can.deinit()
+//|
+//| This example will write the data 'adafruit' onto the CAN bus to any
+//| device listening for message id 0x0408.
+//|
+//| A CAN bus involves a transceiver, which is often a separate chip with a "standby" pin.
+//| If your board has a CAN_STANDBY pin, ensure to set it to an output with the value False
+//| to enable the transceiver.
+//|
+//| Other implementations of the CAN device may exist (for instance, attached
+//| via an SPI bus).  If so their constructor arguments may differ, but
+//| otherwise we encourage implementors to follow the API that the core uses.
+//| """
+//|
+
+#include "py/obj.h"
+#include "py/enum.h"
+
+#include "shared-bindings/canio/__init__.h"
+#include "shared-bindings/canio/CAN.h"
+#include "shared-bindings/canio/Match.h"
+#include "shared-bindings/canio/Message.h"
+#include "shared-bindings/canio/Listener.h"
+
+MAKE_ENUM_VALUE(canio_bus_state_type, bus_state, ERROR_ACTIVE, BUS_STATE_ERROR_ACTIVE);
+MAKE_ENUM_VALUE(canio_bus_state_type, bus_state, ERROR_PASSIVE, BUS_STATE_ERROR_PASSIVE);
+MAKE_ENUM_VALUE(canio_bus_state_type, bus_state, ERROR_WARNING, BUS_STATE_ERROR_WARNING);
+MAKE_ENUM_VALUE(canio_bus_state_type, bus_state, BUS_OFF, BUS_STATE_OFF);
+
+//| class BusState:
+//|     """The state of the CAN bus"""
+//|
+//|     ERROR_ACTIVE: object
+//|     """The bus is in the normal (active) state"""
+//|
+//|     ERROR_WARNING: object
+//|     """The bus is in the normal (active) state, but a moderate number of errors have occurred recently.
+//|
+//|     NOTE: Not all implementations may use ERROR_WARNING.  Do not rely on seeing ERROR_WARNING before ERROR_PASSIVE."""
+//|
+//|     ERROR_PASSIVE: object
+//|     """The bus is in the passive state due to the number of errors that have occurred recently.
+//|
+//|     This device will acknowledge packets it receives, but cannot transmit messages.
+//|     If additional errors occur, this device may progress to BUS_OFF.
+//|     If it successfully acknowledges other packets on the bus, it can return to ERROR_WARNING or ERROR_ACTIVE and transmit packets.
+//|     """
+//|
+//|     BUS_OFF: object
+//|     """The bus has turned off due to the number of errors that have
+//|     occurred recently.  It must be restarted before it will send or receive
+//|     packets.  This device will neither send or acknowledge packets on the bus."""
+//|
+MAKE_ENUM_MAP(canio_bus_state) {
+    MAKE_ENUM_MAP_ENTRY(bus_state, ERROR_ACTIVE),
+    MAKE_ENUM_MAP_ENTRY(bus_state, ERROR_PASSIVE),
+    MAKE_ENUM_MAP_ENTRY(bus_state, ERROR_WARNING),
+    MAKE_ENUM_MAP_ENTRY(bus_state, BUS_OFF),
+};
+STATIC MP_DEFINE_CONST_DICT(canio_bus_state_locals_dict, canio_bus_state_locals_table);
+
+MAKE_PRINTER(canio, canio_bus_state);
+
+MAKE_ENUM_TYPE(canio, BusState, canio_bus_state);
+
+STATIC const mp_rom_map_elem_t canio_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_BusState), MP_ROM_PTR(&canio_bus_state_type) },
+    { MP_ROM_QSTR(MP_QSTR_CAN), MP_ROM_PTR(&canio_can_type) },
+    { MP_ROM_QSTR(MP_QSTR_Listener), MP_ROM_PTR(&canio_listener_type) },
+    { MP_ROM_QSTR(MP_QSTR_Match), MP_ROM_PTR(&canio_match_type) },
+    { MP_ROM_QSTR(MP_QSTR_Message), MP_ROM_PTR(&canio_message_type) },
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__canio) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(canio_module_globals, canio_module_globals_table);
+
+const mp_obj_module_t canio_module = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t*)&canio_module_globals,
+};
diff --git a/shared-bindings/canio/__init__.h b/shared-bindings/canio/__init__.h
new file mode 100644
index 000000000..e24eba92c
--- /dev/null
+++ b/shared-bindings/canio/__init__.h
@@ -0,0 +1,33 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jeff Epler for Adafruit Industries
+ *
+ * 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.
+ */
+
+#pragma once
+
+typedef enum {
+    BUS_STATE_ERROR_ACTIVE, BUS_STATE_ERROR_PASSIVE, BUS_STATE_ERROR_WARNING, BUS_STATE_OFF
+} canio_bus_state_t;
+
+extern const mp_obj_type_t canio_bus_state_type;
diff --git a/shared-bindings/microcontroller/Pin.c b/shared-bindings/microcontroller/Pin.c
index 1294b78f0..6ba02a0e7 100644
--- a/shared-bindings/microcontroller/Pin.c
+++ b/shared-bindings/microcontroller/Pin.c
@@ -71,7 +71,11 @@ STATIC void mcu_pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_ki
     qstr name;
 
     get_pin_name(self, &package, &module, &name);
-    mp_printf(print, "%q.%q.%q", MP_QSTR_microcontroller, MP_QSTR_pin, name);
+    if (package){
+        mp_printf(print, "%q.%q.%q", package, module, name);
+    } else {
+        mp_printf(print, "%q.%q", module , name);
+    }
 }
 
 const mp_obj_type_t mcu_pin_type = {