Merge branch 'main' into esp32-analogin

14 files changed, 324 insertions, 209 deletions

diff --git a/shared-bindings/canio/CAN.c b/shared-bindings/canio/CAN.c
index ff27bb204..6dae36943 100644
--- a/shared-bindings/canio/CAN.c
+++ b/shared-bindings/canio/CAN.c
@@ -171,59 +171,8 @@ STATIC const mp_obj_property_t canio_can_receive_error_count_obj = {
               (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."""
+//|     """The current state of the bus. (read-only)"""
 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);
@@ -252,7 +201,7 @@ STATIC mp_obj_t canio_can_restart(mp_obj_t self_in) {
 }
 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:
+//|     def listen(self, matches: 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.
@@ -265,16 +214,16 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_can_restart_obj, canio_can_restart);
 //|
 //|         An empty filter list causes all messages to be accepted.
 //|
-//|         Timeout dictates how long readinto, read and next() will block."""
+//|         Timeout dictates how long receive() 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 };
+    enum { ARG_matches, ARG_timeout, NUM_ARGS };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_match, MP_ARG_OBJ, {.u_obj = 0} },
+        { MP_QSTR_matches, 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)];
@@ -285,8 +234,8 @@ STATIC mp_obj_t canio_can_listen(size_t n_args, const mp_obj_t *pos_args, mp_map
     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);
+    if (args[ARG_matches].u_obj) {
+        mp_obj_get_array(args[ARG_matches].u_obj, &nmatch, &match_objects);
     }
 
     canio_match_obj_t *matches[nmatch];
@@ -307,7 +256,8 @@ STATIC mp_obj_t canio_can_listen(size_t n_args, const mp_obj_t *pos_args, mp_map
 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"""
+//|     """True if the device was created in loopback mode, False
+//|     otherwise (read-only)"""
 //|
 STATIC mp_obj_t canio_can_loopback_get(mp_obj_t self_in) {
     canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
@@ -324,7 +274,7 @@ STATIC const mp_obj_property_t canio_can_loopback_obj = {
 };
 
 
-//|     def send(message: Message) -> None:
+//|     def send(message: Union[RemoteTransmissionRequest, 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.
 //|         """
@@ -334,8 +284,8 @@ 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);
+    if (message_type != &canio_message_type && message_type != &canio_remote_transmission_request_type) {
+        mp_raise_TypeError_varg(translate("expected '%q' or '%q' but got '%q'"), MP_QSTR_Message, MP_QSTR_RemoteTransmissionRequest, message_type->name);
     }
 
     canio_message_obj_t *message = message_in;
@@ -345,7 +295,8 @@ STATIC mp_obj_t canio_can_send(mp_obj_t self_in, mp_obj_t message_in) {
 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"""
+//|     """True if the device was created in silent mode, False
+//|     otherwise (read-only)"""
 //|
 STATIC mp_obj_t canio_can_silent_get(mp_obj_t self_in) {
     canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
@@ -399,10 +350,7 @@ STATIC const mp_rom_map_elem_t canio_can_locals_dict_table[] = {
     { 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) },
diff --git a/shared-bindings/canio/CAN.h b/shared-bindings/canio/CAN.h
index 66c972c28..968b71f14 100644
--- a/shared-bindings/canio/CAN.h
+++ b/shared-bindings/canio/CAN.h
@@ -28,6 +28,7 @@
 
 #include "py/obj.h"
 #include "shared-bindings/microcontroller/Pin.h"
+#include "shared-bindings/canio/__init__.h"
 #include "shared-bindings/canio/Message.h"
 
 extern const mp_obj_type_t canio_can_type;
@@ -38,9 +39,6 @@ void common_hal_canio_can_construct(canio_can_obj_t *self, mcu_pin_obj_t *tx, mc
 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);
@@ -50,5 +48,5 @@ void common_hal_canio_can_auto_restart_set(canio_can_obj_t *self, bool auto_rest
 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_can_send(canio_can_obj_t *self, mp_obj_t message);
 void common_hal_canio_reset(void);
diff --git a/shared-bindings/canio/Listener.c b/shared-bindings/canio/Listener.c
index 1f4176f0c..93552af81 100644
--- a/shared-bindings/canio/Listener.c
+++ b/shared-bindings/canio/Listener.c
@@ -34,51 +34,39 @@
 //| class Listener:
 //|     """Listens for CAN message
 //|
-//|     canio.Listener is not constructed directly, but instead by calling the
-//|     Listen method of a canio.CAN object."""
+//|     `canio.Listener` is not constructed directly, but instead by calling
+//|     `canio.CAN.listen`.
+//|
+//|     In addition to using the `receive` method to retrieve a message or
+//|     the `in_waiting` method to check for an available message, a
+//|     listener can be used as an iterable, yielding messages until no
+//|     message arrives within ``self.timeout`` seconds."""
 //|
 
-//|     def read(self) -> Optional[Message]:
-//|         """Reads a message, after waiting up to self.timeout seconds
+//|     def receive(self) -> Optional[Union[RemoteTransmissionRequest,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."""
+//|         If no message is received in time, `None` is returned.  Otherwise,
+//|         a `Message` or `RemoteTransmissionRequest` is returned."""
 //|         ...
 //|
-STATIC mp_obj_t canio_listener_read(mp_obj_t self_in) {
+STATIC mp_obj_t canio_listener_receive(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;
+    mp_obj_t message = common_hal_canio_listener_receive(self);
+    // note: receive fills out the type field of the message
 
-    if (common_hal_canio_listener_readinto(self, message)) {
+    if (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);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_listener_receive_obj, canio_listener_receive);
 
 //|     def in_waiting(self) -> int:
-//|         """Returns the number of messages waiting"""
+//|         """Returns the number of messages (including remote
+//|         transmission requests) waiting"""
 //|         ...
 //|
 STATIC mp_obj_t canio_listener_in_waiting(mp_obj_t self_in) {
@@ -88,19 +76,25 @@ STATIC mp_obj_t canio_listener_in_waiting(mp_obj_t self_in) {
 }
 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 __iter__(self) -> Listener:
+//|         """Returns self
+//|
+//|         This method exists so that `Listener` can be used as an
+//|         iterable"""
 //|         ...
 //|
-//|     def __next__(self):
+//|     def __next__(self) -> Union[RemoteTransmissionRequest,Message]:
 //|         """Reads a message, after waiting up to self.timeout seconds
 //|
 //|         If no message is received in time, raises StopIteration.  Otherwise,
-//|         a Message is returned."""
+//|         a Message or  is returned.
+//|
+//|         This method enables the `Listener` to be used as an
+//|         iterable, for instance in a for-loop."""
 //|         ...
 //|
 STATIC mp_obj_t canio_iternext(mp_obj_t self_in) {
-    mp_obj_t result = canio_listener_read(self_in);
+    mp_obj_t result = canio_listener_receive(self_in);
     if (result == mp_const_none) {
         return MP_OBJ_STOP_ITERATION;
     }
@@ -170,8 +164,7 @@ STATIC const mp_rom_map_elem_t canio_listener_locals_dict_table[] = {
     { 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_receive), MP_ROM_PTR(&canio_listener_receive_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);
diff --git a/shared-bindings/canio/Listener.h b/shared-bindings/canio/Listener.h
index eaa3490df..527ffe4cb 100644
--- a/shared-bindings/canio/Listener.h
+++ b/shared-bindings/canio/Listener.h
@@ -27,5 +27,17 @@
 #pragma once
 
 #include "py/obj.h"
+#include "shared-bindings/canio/CAN.h"
+#include "shared-bindings/canio/Match.h"
 
 extern const mp_obj_type_t canio_listener_type;
+
+typedef struct canio_listener_obj canio_listener_obj_t;
+
+void common_hal_canio_listener_construct(canio_listener_obj_t *self, canio_can_obj_t *can, size_t nmatch, canio_match_obj_t **matches, float timeout);
+void common_hal_canio_listener_check_for_deinit(canio_listener_obj_t *self);
+void common_hal_canio_listener_deinit(canio_listener_obj_t *self);
+mp_obj_t common_hal_canio_listener_receive(canio_listener_obj_t *self);
+int common_hal_canio_listener_in_waiting(canio_listener_obj_t *self);
+float common_hal_canio_listener_get_timeout(canio_listener_obj_t *self);
+void common_hal_canio_listener_set_timeout(canio_listener_obj_t *self, float timeout);
diff --git a/shared-bindings/canio/Match.c b/shared-bindings/canio/Match.c
index ff5d028fa..3fbc1773e 100644
--- a/shared-bindings/canio/Match.c
+++ b/shared-bindings/canio/Match.c
@@ -33,20 +33,20 @@
 //|     """Describe CAN bus messages to match"""
 //|
 //|
-//|     def __init__(self, address: int, *, mask: int = 0, extended: bool = False):
+//|     def __init__(self, id: int, *, mask: Optional[int] = None, 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."""
+//|         If mask is not None, then the filter is for any id which matches all
+//|         the nonzero bits in mask. Otherwise, it matches exactly the given id.
+//|         If extended is true then only extended ids are matched, otherwise
+//|         only standard ids 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 };
+    enum { ARG_id, 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_id, MP_ARG_INT | MP_ARG_REQUIRED },
+        { MP_QSTR_mask, MP_ARG_OBJ, {.u_obj = mp_const_none } },
         { MP_QSTR_extended, MP_ARG_BOOL, {.u_bool = false} },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
@@ -54,44 +54,44 @@ STATIC mp_obj_t canio_match_make_new(const mp_obj_type_t *type, size_t n_args, c
 
     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;
+    int id_bits = args[ARG_extended].u_bool ? 0x1fffffff : 0x7ff;
+    int id = args[ARG_id].u_int;
+    int mask = args[ARG_mask].u_obj == mp_const_none ?  id_bits : mp_obj_get_int(args[ARG_mask].u_obj);
 
-    if (address & ~address_bits) {
-        mp_raise_ValueError_varg(translate("%q out of range"), MP_QSTR_address);
+    if (id & ~id_bits) {
+        mp_raise_ValueError_varg(translate("%q out of range"), MP_QSTR_id);
     }
 
-    if (mask & ~address_bits) {
+    if (mask & ~id_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);
+    common_hal_canio_match_construct(self, id, mask, args[ARG_extended].u_bool);
     return self;
 }
 
-//|     address: int
-//|     """The address to match"""
+//|     id: int
+//|     """The id to match"""
 //|
 
-STATIC mp_obj_t canio_match_address_get(mp_obj_t self_in) {
+STATIC mp_obj_t canio_match_id_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));
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_match_get_id(self));
 }
-MP_DEFINE_CONST_FUN_OBJ_1(canio_match_address_get_obj, canio_match_address_get);
+MP_DEFINE_CONST_FUN_OBJ_1(canio_match_id_get_obj, canio_match_id_get);
 
-const mp_obj_property_t canio_match_address_obj = {
+const mp_obj_property_t canio_match_id_obj = {
     .base.type = &mp_type_property,
-    .proxy = {(mp_obj_t)&canio_match_address_get_obj,
+    .proxy = {(mp_obj_t)&canio_match_id_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"""
+//|     """The optional mask of ids to match"""
 //|
 
 STATIC mp_obj_t canio_match_mask_get(mp_obj_t self_in) {
@@ -108,7 +108,7 @@ const mp_obj_property_t canio_match_mask_obj = {
 };
 
 //|     extended: bool
-//|     """True to match extended addresses, False to match standard addresses"""
+//|     """True to match extended ids, False to match standard ides"""
 //|
 
 STATIC mp_obj_t canio_match_extended_get(mp_obj_t self_in) {
@@ -125,7 +125,7 @@ const mp_obj_property_t canio_match_extended_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_id), MP_ROM_PTR(&canio_match_id_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) },
 };
diff --git a/shared-bindings/canio/Match.h b/shared-bindings/canio/Match.h
index 88996d730..01a75fd1c 100644
--- a/shared-bindings/canio/Match.h
+++ b/shared-bindings/canio/Match.h
@@ -31,7 +31,7 @@
 
 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);
+void common_hal_canio_match_construct(canio_match_obj_t *self, int id, int mask, bool extended);
+int common_hal_canio_match_get_id(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
index 23645d2e5..e47e997c7 100644
--- a/shared-bindings/canio/Message.c
+++ b/shared-bindings/canio/Message.c
@@ -31,28 +31,22 @@
 #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.
+//|     def __init__(self, id: int, data: bytes, *, extended: bool = False):
+//|         """Construct a Message to send on a CAN bus.
 //|
 //|         :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``.
+//|         In CAN, messages can have a length from 0 to 8 bytes.
 //|         """
 //|         ...
 //|
 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 };
+    enum { ARG_id, ARG_data, 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_id, MP_ARG_INT | MP_ARG_REQUIRED },
+        { MP_QSTR_data, MP_ARG_OBJ | MP_ARG_REQUIRED },
         { MP_QSTR_extended, MP_ARG_BOOL, {.u_bool = false} },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
@@ -60,26 +54,8 @@ STATIC mp_obj_t canio_message_make_new(const mp_obj_type_t *type, size_t n_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;
-    }
+    mp_get_buffer_raise(args[ARG_data].u_obj, &data, MP_BUFFER_READ);
 
     if (data.len > 8) {
         mp_raise_ValueError(translate("Messages limited to 8 bytes"));
@@ -87,7 +63,7 @@ STATIC mp_obj_t canio_message_make_new(const mp_obj_type_t *type, size_t n_args,
 
     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);
+    common_hal_canio_message_construct(self, args[ARG_id].u_int, data.buf, data.len, args[ARG_extended].u_bool);
     return self;
 }
 
@@ -115,13 +91,11 @@ STATIC const mp_obj_property_t canio_message_id_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."""
+//|     """The content of the message"""
 //|
 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));
+    return mp_obj_new_bytes((const byte*)common_hal_canio_message_get_data(self), common_hal_canio_message_get_length(self));
 }
 MP_DEFINE_CONST_FUN_OBJ_1(canio_message_data_get_obj, canio_message_data_get);
 
@@ -147,7 +121,7 @@ STATIC const mp_obj_property_t canio_message_data_obj = {
 
 
 //|     extended: bool
-//|     """True if the message represents a remote transmission request (RTR)"""
+//|     """True if the message's id is an extended id"""
 //|
 STATIC mp_obj_t canio_message_extended_get(const mp_obj_t self_in) {
     canio_message_obj_t *self = self_in;
@@ -170,36 +144,9 @@ STATIC const mp_obj_property_t canio_message_extended_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);
diff --git a/shared-bindings/canio/Message.h b/shared-bindings/canio/Message.h
index 34b632e84..b76535939 100644
--- a/shared-bindings/canio/Message.h
+++ b/shared-bindings/canio/Message.h
@@ -30,15 +30,13 @@
 #include "shared-module/canio/Message.h"
 
 extern const mp_obj_type_t canio_message_type;
+extern const mp_obj_type_t canio_remote_transmission_request_type;
 
-void common_hal_canio_message_construct(canio_message_obj_t *self, int id, void *data, size_t size, bool rtr, bool extended);
+void common_hal_canio_message_construct(canio_message_obj_t *self, int id, void *data, size_t size, 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);
+size_t common_hal_canio_message_get_length(const canio_message_obj_t *self);
diff --git a/shared-bindings/canio/RemoteTransmissionRequest.c b/shared-bindings/canio/RemoteTransmissionRequest.c
new file mode 100644
index 000000000..d762787b1
--- /dev/null
+++ b/shared-bindings/canio/RemoteTransmissionRequest.c
@@ -0,0 +1,156 @@
+/*
+ * 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/RemoteTransmissionRequest.h"
+
+#include "py/obj.h"
+#include "py/objproperty.h"
+#include "py/runtime.h"
+
+//| class RemoteTransmissionRequest:
+//|     def __init__(self, id: int, length: int, *, extended: bool = False):
+//|         """Construct a RemoteTransmissionRequest to send on a CAN bus.
+//|
+//|         :param int id: The numeric ID of the requested message
+//|         :param int length: The length of the requested message
+//|         :param bool extended: True if the message has an extended identifier, False if it has a standard identifier
+//|
+//|         In CAN, messages can have a length from 0 to 8 bytes.
+//|         """
+//|         ...
+//|
+STATIC mp_obj_t canio_remote_transmission_request_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_length, ARG_extended, NUM_ARGS };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_id, MP_ARG_INT | MP_ARG_REQUIRED },
+        { MP_QSTR_length, MP_ARG_INT | MP_ARG_REQUIRED },
+        { 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 length = args[ARG_length].u_int;
+    if (length < 0 || length > 8) {
+        mp_raise_ValueError(translate("RemoteTransmissionRequests limited to 8 bytes"));
+    }
+
+    canio_remote_transmission_request_obj_t *self = m_new_obj(canio_remote_transmission_request_obj_t);
+    self->base.type = &canio_remote_transmission_request_type;
+    common_hal_canio_remote_transmission_request_construct(self, args[ARG_id].u_int, length, args[ARG_extended].u_bool);
+    return self;
+}
+
+
+//|     id: int
+//|     """The numeric ID of the message"""
+//|
+STATIC mp_obj_t canio_remote_transmission_request_id_get(const mp_obj_t self_in) {
+    canio_remote_transmission_request_obj_t *self = self_in;
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_remote_transmission_request_get_id(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_remote_transmission_request_id_get_obj, canio_remote_transmission_request_id_get);
+
+STATIC mp_obj_t canio_remote_transmission_request_id_set(const mp_obj_t self_in, const mp_obj_t id) {
+    canio_remote_transmission_request_obj_t *self = self_in;
+    common_hal_canio_remote_transmission_request_set_id(self, mp_obj_get_int(id));
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(canio_remote_transmission_request_id_set_obj, canio_remote_transmission_request_id_set);
+
+STATIC const mp_obj_property_t canio_remote_transmission_request_id_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_remote_transmission_request_id_get_obj,
+              (mp_obj_t)&canio_remote_transmission_request_id_set_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
+//|     extended: bool
+//|     """True if the message's id is an extended id"""
+//|
+STATIC mp_obj_t canio_remote_transmission_request_extended_get(const mp_obj_t self_in) {
+    canio_remote_transmission_request_obj_t *self = self_in;
+    return mp_obj_new_bool(common_hal_canio_remote_transmission_request_get_extended(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_remote_transmission_request_extended_get_obj, canio_remote_transmission_request_extended_get);
+
+STATIC mp_obj_t canio_remote_transmission_request_extended_set(const mp_obj_t self_in, const mp_obj_t extended) {
+    canio_remote_transmission_request_obj_t *self = self_in;
+    common_hal_canio_remote_transmission_request_set_extended(self, mp_obj_is_true(extended));
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(canio_remote_transmission_request_extended_set_obj, canio_remote_transmission_request_extended_set);
+
+
+STATIC const mp_obj_property_t canio_remote_transmission_request_extended_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_remote_transmission_request_extended_get_obj,
+              (mp_obj_t)&canio_remote_transmission_request_extended_set_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
+//|     length: int
+//|     """The length of the requested message."""
+//|
+STATIC mp_obj_t canio_remote_transmission_request_length_get(const mp_obj_t self_in) {
+    canio_remote_transmission_request_obj_t *self = self_in;
+    return MP_OBJ_NEW_SMALL_INT(common_hal_canio_remote_transmission_request_get_length(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(canio_remote_transmission_request_length_get_obj, canio_remote_transmission_request_length_get);
+
+STATIC mp_obj_t canio_remote_transmission_request_length_set(const mp_obj_t self_in, const mp_obj_t length_in) {
+    canio_remote_transmission_request_obj_t *self = self_in;
+    int length = mp_obj_get_int(length_in);
+    if (length < 0 || length > 8) {
+        mp_raise_ValueError(translate("RemoteTransmissionRequests limited to 8 bytes"));
+    }
+    common_hal_canio_remote_transmission_request_set_length(self, length);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(canio_remote_transmission_request_length_set_obj, canio_remote_transmission_request_length_set);
+
+
+STATIC const mp_obj_property_t canio_remote_transmission_request_length_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&canio_remote_transmission_request_length_get_obj,
+              (mp_obj_t)&canio_remote_transmission_request_length_set_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
+STATIC const mp_rom_map_elem_t canio_remote_transmission_request_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_id), MP_ROM_PTR(&canio_remote_transmission_request_id_obj) },
+    { MP_ROM_QSTR(MP_QSTR_length), MP_ROM_PTR(&canio_remote_transmission_request_length_obj) },
+    { MP_ROM_QSTR(MP_QSTR_extended), MP_ROM_PTR(&canio_remote_transmission_request_extended_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(canio_remote_transmission_request_locals_dict, canio_remote_transmission_request_locals_dict_table);
+
+const mp_obj_type_t canio_remote_transmission_request_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_RemoteTransmissionRequest,
+    .make_new = canio_remote_transmission_request_make_new,
+    .locals_dict = (mp_obj_t)&canio_remote_transmission_request_locals_dict,
+};
diff --git a/shared-bindings/canio/RemoteTransmissionRequest.h b/shared-bindings/canio/RemoteTransmissionRequest.h
new file mode 100644
index 000000000..8956587b3
--- /dev/null
+++ b/shared-bindings/canio/RemoteTransmissionRequest.h
@@ -0,0 +1,42 @@
+/*
+ * 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/RemoteTransmissionRequest.h"
+
+extern const mp_obj_type_t canio_remote_transmission_request_type;
+
+void common_hal_canio_remote_transmission_request_construct(canio_remote_transmission_request_obj_t *self, int id, size_t size, bool extended);
+const void *common_hal_canio_remote_transmission_request_get_data(const canio_remote_transmission_request_obj_t *self);
+void common_hal_canio_remote_transmission_request_set_data(canio_remote_transmission_request_obj_t *self, const void *data, size_t size);
+bool common_hal_canio_remote_transmission_request_get_extended(const canio_remote_transmission_request_obj_t *self);
+void common_hal_canio_remote_transmission_request_set_extended(canio_remote_transmission_request_obj_t *self, bool extended);
+int common_hal_canio_remote_transmission_request_get_id(const canio_remote_transmission_request_obj_t *self);
+void common_hal_canio_remote_transmission_request_set_id(canio_remote_transmission_request_obj_t *self, int id);
+size_t common_hal_canio_remote_transmission_request_get_length(const canio_remote_transmission_request_obj_t *self);
+void common_hal_canio_remote_transmission_request_set_length(canio_remote_transmission_request_obj_t *self, size_t length);
diff --git a/shared-bindings/canio/__init__.c b/shared-bindings/canio/__init__.c
index b0b982c95..f29d3ab8a 100644
--- a/shared-bindings/canio/__init__.c
+++ b/shared-bindings/canio/__init__.c
@@ -40,8 +40,8 @@
 //|   from board import *
 //|
 //|   can = canio.CAN(board.CAN_RX, board.CAN_TX, baudrate=1000000)
-//|   message = canio.Message(id=0x0408, data="adafruit"
-//|   can.write(message))
+//|   message = canio.Message(id=0x0408, data=b"adafruit")
+//|   can.send(message)
 //|   can.deinit()
 //|
 //| This example will write the data 'adafruit' onto the CAN bus to any
@@ -113,6 +113,7 @@ STATIC const mp_rom_map_elem_t canio_module_globals_table[] = {
     { 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_RemoteTransmissionRequest), MP_ROM_PTR(&canio_remote_transmission_request_type) },
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__canio) },
 };
 
diff --git a/shared-bindings/displayio/Display.c b/shared-bindings/displayio/Display.c
index f36aeed18..e78a893b0 100644
--- a/shared-bindings/displayio/Display.c
+++ b/shared-bindings/displayio/Display.c
@@ -105,13 +105,22 @@
 //|         :param bool auto_brightness: If True, brightness is controlled via an ambient light sensor or other mechanism.
 //|         :param bool single_byte_bounds: Display column and row commands use single bytes
 //|         :param bool data_as_commands: Treat all init and boundary data as SPI commands. Certain displays require this.
+//|         :param bool SH1107_addressing: Special quirk for SH1107, use upper/lower column set and page set
 //|         :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_reverse_bytes_in_word, 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 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_reverse_bytes_in_word,
+                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,
+                ARG_SH1107_addressing };
     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 },
@@ -139,6 +148,7 @@ STATIC mp_obj_t displayio_display_make_new(const mp_obj_type_t *type, size_t n_a
         { 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_QSTR_SH1107_addressing, MP_ARG_BOOL | MP_ARG_KW_ONLY, {.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);
@@ -180,7 +190,8 @@ STATIC mp_obj_t displayio_display_make_new(const mp_obj_type_t *type, size_t n_a
         args[ARG_data_as_commands].u_bool,
         args[ARG_auto_refresh].u_bool,
         args[ARG_native_frames_per_second].u_int,
-        args[ARG_backlight_on_high].u_bool
+        args[ARG_backlight_on_high].u_bool,
+        args[ARG_SH1107_addressing].u_bool
         );
 
     return self;
diff --git a/shared-bindings/displayio/Display.h b/shared-bindings/displayio/Display.h
index e69c5b6b5..f9fbc157c 100644
--- a/shared-bindings/displayio/Display.h
+++ b/shared-bindings/displayio/Display.h
@@ -45,7 +45,8 @@ 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 backlight_on_high);
+    bool single_byte_bounds, bool data_as_commands, bool auto_refresh, uint16_t native_frames_per_second,
+    bool backlight_on_high, bool SH1107_addressing);
 
 bool common_hal_displayio_display_show(displayio_display_obj_t* self,
                                        displayio_group_t* root_group);
diff --git a/shared-bindings/rgbmatrix/RGBMatrix.c b/shared-bindings/rgbmatrix/RGBMatrix.c
index e4683af92..753c1c920 100644
--- a/shared-bindings/rgbmatrix/RGBMatrix.c
+++ b/shared-bindings/rgbmatrix/RGBMatrix.c
@@ -73,6 +73,10 @@ STATIC void preflight_pins_or_throw(uint8_t clock_pin, uint8_t *rgb_pins, uint8_
     uint32_t port = clock_pin / 32;
     uint32_t bit_mask = 1 << (clock_pin % 32);
 
+    if (rgb_pin_count <= 0 || rgb_pin_count % 6 != 0 || rgb_pin_count > 30) {
+        mp_raise_ValueError_varg(translate("The length of rgb_pins must be 6, 12, 18, 24, or 30"));
+    }
+
     for (uint8_t i = 0; i < rgb_pin_count; i++) {
         uint32_t pin_port = rgb_pins[i] / 32;
 
@@ -210,6 +214,10 @@ STATIC mp_obj_t rgbmatrix_rgbmatrix_make_new(const mp_obj_type_t *type, size_t n
         }
     }
 
+    if (args[ARG_width].u_int <= 0) {
+        mp_raise_ValueError(translate("width must be greater than zero"));
+    }
+
     preflight_pins_or_throw(clock_pin, rgb_pins, rgb_count, true);
 
     mp_obj_t framebuffer = args[ARG_framebuffer].u_obj;