I2CPeripheral: Rename class and its module

This is an incompatible change.

3 files changed, 134 insertions, 133 deletions

diff --git a/shared-bindings/i2cslave/I2CSlave.c b/shared-bindings/i2cperipheral/I2CPeripheral.c
index 9f051a125..4a3900174 100644
--- a/shared-bindings/i2cslave/I2CSlave.c
+++ b/shared-bindings/i2cperipheral/I2CPeripheral.c
@@ -25,7 +25,7 @@
  */
 
 #include "shared-bindings/microcontroller/Pin.h"
-#include "shared-bindings/i2cslave/I2CSlave.h"
+#include "shared-bindings/i2cperipheral/I2CPeripheral.h"
 #include "shared-bindings/time/__init__.h"
 #include "shared-bindings/util.h"
 
@@ -39,22 +39,22 @@
 #include "py/objproperty.h"
 #include "py/runtime.h"
 
-STATIC mp_obj_t mp_obj_new_i2cslave_i2c_slave_request(i2cslave_i2c_slave_obj_t *slave, uint8_t address, bool is_read, bool is_restart) {
-    i2cslave_i2c_slave_request_obj_t *self = m_new_obj(i2cslave_i2c_slave_request_obj_t);
-    self->base.type = &i2cslave_i2c_slave_request_type;
-    self->slave = slave;
+STATIC mp_obj_t mp_obj_new_i2cperipheral_i2c_peripheral_request(i2cperipheral_i2c_peripheral_obj_t *peripheral, uint8_t address, bool is_read, bool is_restart) {
+    i2cperipheral_i2c_peripheral_request_obj_t *self = m_new_obj(i2cperipheral_i2c_peripheral_request_obj_t);
+    self->base.type = &i2cperipheral_i2c_peripheral_request_type;
+    self->peripheral = peripheral;
     self->address = address;
     self->is_read = is_read;
     self->is_restart = is_restart;
     return (mp_obj_t)self;
 }
 
-//| class I2CSlave:
-//|     """Two wire serial protocol slave"""
+//| class I2CPeripheral:
+//|     """Two wire serial protocol peripheral"""
 //|
 //|     def __init__(self, scl: microcontroller.Pin, sda: microcontroller.Pin, addresses: tuple, smbus: bool = False):
 //|         """I2C is a two-wire protocol for communicating between devices.
-//|         This implements the slave side.
+//|         This implements the peripheral (sensor, secondary) side.
 //|
 //|         :param ~microcontroller.Pin scl: The clock pin
 //|         :param ~microcontroller.Pin sda: The data pin
@@ -62,9 +62,9 @@ STATIC mp_obj_t mp_obj_new_i2cslave_i2c_slave_request(i2cslave_i2c_slave_obj_t *
 //|         :param bool smbus: Use SMBUS timings if the hardware supports it"""
 //|         ...
 //|
-STATIC mp_obj_t i2cslave_i2c_slave_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    i2cslave_i2c_slave_obj_t *self = m_new_obj(i2cslave_i2c_slave_obj_t);
-    self->base.type = &i2cslave_i2c_slave_type;
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    i2cperipheral_i2c_peripheral_obj_t *self = m_new_obj(i2cperipheral_i2c_peripheral_obj_t);
+    self->base.type = &i2cperipheral_i2c_peripheral_type;
     enum { ARG_scl, ARG_sda, ARG_addresses, ARG_smbus };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_scl, MP_ARG_REQUIRED | MP_ARG_OBJ },
@@ -98,7 +98,7 @@ STATIC mp_obj_t i2cslave_i2c_slave_make_new(const mp_obj_type_t *type, size_t n_
         mp_raise_ValueError(translate("addresses is empty"));
     }
 
-    common_hal_i2cslave_i2c_slave_construct(self, scl, sda, addresses, i, args[ARG_smbus].u_bool);
+    common_hal_i2cperipheral_i2c_peripheral_construct(self, scl, sda, addresses, i, args[ARG_smbus].u_bool);
     return (mp_obj_t)self;
 }
 
@@ -106,13 +106,13 @@ STATIC mp_obj_t i2cslave_i2c_slave_make_new(const mp_obj_type_t *type, size_t n_
 //|         """Releases control of the underlying hardware so other classes can use it."""
 //|         ...
 //|
-STATIC mp_obj_t i2cslave_i2c_slave_obj_deinit(mp_obj_t self_in) {
-    mp_check_self(MP_OBJ_IS_TYPE(self_in, &i2cslave_i2c_slave_type));
-    i2cslave_i2c_slave_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    common_hal_i2cslave_i2c_slave_deinit(self);
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_obj_deinit(mp_obj_t self_in) {
+    mp_check_self(MP_OBJ_IS_TYPE(self_in, &i2cperipheral_i2c_peripheral_type));
+    i2cperipheral_i2c_peripheral_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_i2cperipheral_i2c_peripheral_deinit(self);
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_1(i2cslave_i2c_slave_deinit_obj, i2cslave_i2c_slave_obj_deinit);
+MP_DEFINE_CONST_FUN_OBJ_1(i2cperipheral_i2c_peripheral_deinit_obj, i2cperipheral_i2c_peripheral_obj_deinit);
 
 //|     def __enter__(self, ) -> Any:
 //|         """No-op used in Context Managers."""
@@ -125,25 +125,25 @@ MP_DEFINE_CONST_FUN_OBJ_1(i2cslave_i2c_slave_deinit_obj, i2cslave_i2c_slave_obj_
 //|         :ref:`lifetime-and-contextmanagers` for more info."""
 //|         ...
 //|
-STATIC mp_obj_t i2cslave_i2c_slave_obj___exit__(size_t n_args, const mp_obj_t *args) {
-    mp_check_self(MP_OBJ_IS_TYPE(args[0], &i2cslave_i2c_slave_type));
-    i2cslave_i2c_slave_obj_t *self = MP_OBJ_TO_PTR(args[0]);
-    common_hal_i2cslave_i2c_slave_deinit(self);
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_obj___exit__(size_t n_args, const mp_obj_t *args) {
+    mp_check_self(MP_OBJ_IS_TYPE(args[0], &i2cperipheral_i2c_peripheral_type));
+    i2cperipheral_i2c_peripheral_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    common_hal_i2cperipheral_i2c_peripheral_deinit(self);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2cslave_i2c_slave___exit___obj, 4, 4, i2cslave_i2c_slave_obj___exit__);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2cperipheral_i2c_peripheral___exit___obj, 4, 4, i2cperipheral_i2c_peripheral_obj___exit__);
 
 //|     def request(self, timeout: float = -1) -> Any:
 //|         """Wait for an I2C request.
 //|
 //|         :param float timeout: Timeout in seconds. Zero means wait forever, a negative value means check once
 //|         :return: I2C Slave Request or None if timeout=-1 and there's no request
-//|         :rtype: ~i2cslave.I2CSlaveRequest"""
+//|         :rtype: ~i2cperipheral.I2CPeripheralRequest"""
 //|
-STATIC mp_obj_t i2cslave_i2c_slave_request(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    mp_check_self(MP_OBJ_IS_TYPE(pos_args[0], &i2cslave_i2c_slave_type));
-    i2cslave_i2c_slave_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
-    if(common_hal_i2cslave_i2c_slave_deinited(self)) {
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_request(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    mp_check_self(MP_OBJ_IS_TYPE(pos_args[0], &i2cperipheral_i2c_peripheral_type));
+    i2cperipheral_i2c_peripheral_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    if(common_hal_i2cperipheral_i2c_peripheral_deinited(self)) {
         raise_deinited_error();
     }
     enum { ARG_timeout };
@@ -180,7 +180,7 @@ STATIC mp_obj_t i2cslave_i2c_slave_request(size_t n_args, const mp_obj_t *pos_ar
             return mp_const_none;
         }
 
-        int status = common_hal_i2cslave_i2c_slave_is_addressed(self, &address, &is_read, &is_restart);
+        int status = common_hal_i2cperipheral_i2c_peripheral_is_addressed(self, &address, &is_read, &is_restart);
         if (status < 0) {
             // On error try one more time before bailing out
             if (last_error) {
@@ -198,7 +198,7 @@ STATIC mp_obj_t i2cslave_i2c_slave_request(size_t n_args, const mp_obj_t *pos_ar
             continue;
         }
 
-        return mp_obj_new_i2cslave_i2c_slave_request(self, address, is_read, is_restart);
+        return mp_obj_new_i2cperipheral_i2c_peripheral_request(self, address, is_read, is_restart);
     } while (forever || common_hal_time_monotonic() < timeout_end);
 
     if (timeout_ms > 0) {
@@ -206,39 +206,39 @@ STATIC mp_obj_t i2cslave_i2c_slave_request(size_t n_args, const mp_obj_t *pos_ar
     }
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(i2cslave_i2c_slave_request_obj, 1, i2cslave_i2c_slave_request);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(i2cperipheral_i2c_peripheral_request_obj, 1, i2cperipheral_i2c_peripheral_request);
 
-STATIC const mp_rom_map_elem_t i2cslave_i2c_slave_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&i2cslave_i2c_slave_deinit_obj) },
+STATIC const mp_rom_map_elem_t i2cperipheral_i2c_peripheral_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_deinit_obj) },
     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&default___enter___obj) },
-    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&i2cslave_i2c_slave___exit___obj) },
-    { MP_ROM_QSTR(MP_QSTR_request), MP_ROM_PTR(&i2cslave_i2c_slave_request_obj) },
+    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&i2cperipheral_i2c_peripheral___exit___obj) },
+    { MP_ROM_QSTR(MP_QSTR_request), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_obj) },
 
 };
 
-STATIC MP_DEFINE_CONST_DICT(i2cslave_i2c_slave_locals_dict, i2cslave_i2c_slave_locals_dict_table);
+STATIC MP_DEFINE_CONST_DICT(i2cperipheral_i2c_peripheral_locals_dict, i2cperipheral_i2c_peripheral_locals_dict_table);
 
-const mp_obj_type_t i2cslave_i2c_slave_type = {
+const mp_obj_type_t i2cperipheral_i2c_peripheral_type = {
    { &mp_type_type },
-   .name = MP_QSTR_I2CSlave,
-   .make_new = i2cslave_i2c_slave_make_new,
-   .locals_dict = (mp_obj_dict_t*)&i2cslave_i2c_slave_locals_dict,
+   .name = MP_QSTR_I2CPeripheral,
+   .make_new = i2cperipheral_i2c_peripheral_make_new,
+   .locals_dict = (mp_obj_dict_t*)&i2cperipheral_i2c_peripheral_locals_dict,
 };
 
-//| class I2CSlaveRequest:
+//| class I2CPeripheralRequest:
 //|
-//|     def __init__(self, slave: i2cslave.I2CSlave, address: int, is_read: bool, is_restart: bool):
+//|     def __init__(self, peripheral: i2cperipheral.I2CPeripheral, address: int, is_read: bool, is_restart: bool):
 //|         """Information about an I2C transfer request
-//|         This cannot be instantiated directly, but is returned by :py:meth:`I2CSlave.request`.
+//|         This cannot be instantiated directly, but is returned by :py:meth:`I2CPeripheral.request`.
 //|
-//|         :param slave: The I2C Slave receiving this request
+//|         :param peripheral: The I2CPeripheral object receiving this request
 //|         :param address: I2C address
-//|         :param is_read: True if the main device is requesting data
+//|         :param is_read: True if the main peripheral is requesting data
 //|         :param is_restart: Repeated Start Condition"""
 //|
-STATIC mp_obj_t i2cslave_i2c_slave_request_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
     mp_arg_check_num(n_args, kw_args, 4, 4, false);
-    return mp_obj_new_i2cslave_i2c_slave_request(args[0], mp_obj_get_int(args[1]), mp_obj_is_true(args[2]), mp_obj_is_true(args[3]));
+    return mp_obj_new_i2cperipheral_i2c_peripheral_request(args[0], mp_obj_get_int(args[1]), mp_obj_is_true(args[2]), mp_obj_is_true(args[3]));
 }
 
 //|     def __enter__(self, ) -> Any:
@@ -251,56 +251,56 @@ STATIC mp_obj_t i2cslave_i2c_slave_request_make_new(const mp_obj_type_t *type, s
 //|         """Close the request."""
 //|         ...
 //|
-STATIC mp_obj_t i2cslave_i2c_slave_request_obj___exit__(size_t n_args, const mp_obj_t *args) {
-    mp_check_self(MP_OBJ_IS_TYPE(args[0], &i2cslave_i2c_slave_request_type));
-    i2cslave_i2c_slave_request_obj_t *self = MP_OBJ_TO_PTR(args[0]);
-    common_hal_i2cslave_i2c_slave_close(self->slave);
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_obj___exit__(size_t n_args, const mp_obj_t *args) {
+    mp_check_self(MP_OBJ_IS_TYPE(args[0], &i2cperipheral_i2c_peripheral_request_type));
+    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    common_hal_i2cperipheral_i2c_peripheral_close(self->peripheral);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2cslave_i2c_slave_request___exit___obj, 4, 4, i2cslave_i2c_slave_request_obj___exit__);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2cperipheral_i2c_peripheral_request___exit___obj, 4, 4, i2cperipheral_i2c_peripheral_request_obj___exit__);
 
 //|     address: int = ...
 //|     """The I2C address of the request."""
 //|
-STATIC mp_obj_t i2cslave_i2c_slave_request_get_address(mp_obj_t self_in) {
-    mp_check_self(MP_OBJ_IS_TYPE(self_in, &i2cslave_i2c_slave_request_type));
-    i2cslave_i2c_slave_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_get_address(mp_obj_t self_in) {
+    mp_check_self(MP_OBJ_IS_TYPE(self_in, &i2cperipheral_i2c_peripheral_request_type));
+    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
     return mp_obj_new_int(self->address);
 }
-MP_DEFINE_CONST_PROP_GET(i2cslave_i2c_slave_request_address_obj, i2cslave_i2c_slave_request_get_address);
+MP_DEFINE_CONST_PROP_GET(i2cperipheral_i2c_peripheral_request_address_obj, i2cperipheral_i2c_peripheral_request_get_address);
 
 //|     is_read: bool = ...
-//|     """The I2C main controller is reading from this device."""
+//|     """The I2C main controller is reading from this peripheral."""
 //|
-STATIC mp_obj_t i2cslave_i2c_slave_request_get_is_read(mp_obj_t self_in) {
-    mp_check_self(MP_OBJ_IS_TYPE(self_in, &i2cslave_i2c_slave_request_type));
-    i2cslave_i2c_slave_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_get_is_read(mp_obj_t self_in) {
+    mp_check_self(MP_OBJ_IS_TYPE(self_in, &i2cperipheral_i2c_peripheral_request_type));
+    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
     return mp_obj_new_bool(self->is_read);
 }
-MP_DEFINE_CONST_PROP_GET(i2cslave_i2c_slave_request_is_read_obj, i2cslave_i2c_slave_request_get_is_read);
+MP_DEFINE_CONST_PROP_GET(i2cperipheral_i2c_peripheral_request_is_read_obj, i2cperipheral_i2c_peripheral_request_get_is_read);
 
 //|     is_restart: bool = ...
 //|     """Is Repeated Start Condition."""
 //|
-STATIC mp_obj_t i2cslave_i2c_slave_request_get_is_restart(mp_obj_t self_in) {
-    mp_check_self(MP_OBJ_IS_TYPE(self_in, &i2cslave_i2c_slave_request_type));
-    i2cslave_i2c_slave_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_get_is_restart(mp_obj_t self_in) {
+    mp_check_self(MP_OBJ_IS_TYPE(self_in, &i2cperipheral_i2c_peripheral_request_type));
+    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
     return mp_obj_new_bool(self->is_restart);
 }
-MP_DEFINE_CONST_PROP_GET(i2cslave_i2c_slave_request_is_restart_obj, i2cslave_i2c_slave_request_get_is_restart);
+MP_DEFINE_CONST_PROP_GET(i2cperipheral_i2c_peripheral_request_is_restart_obj, i2cperipheral_i2c_peripheral_request_get_is_restart);
 
 //|     def read(self, n: int = -1, ack: bool = True) -> bytearray:
 //|         """Read data.
-//|         If ack=False, the caller is responsible for calling :py:meth:`I2CSlaveRequest.ack`.
+//|         If ack=False, the caller is responsible for calling :py:meth:`I2CPeripheralRequest.ack`.
 //|
 //|         :param n: Number of bytes to read (negative means all)
 //|         :param ack: Whether or not to send an ACK after the n'th byte
 //|         :return: Bytes read"""
 //|         ...
 //|
-STATIC mp_obj_t i2cslave_i2c_slave_request_read(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    mp_check_self(MP_OBJ_IS_TYPE(pos_args[0], &i2cslave_i2c_slave_request_type));
-    i2cslave_i2c_slave_request_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_read(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    mp_check_self(MP_OBJ_IS_TYPE(pos_args[0], &i2cperipheral_i2c_peripheral_request_type));
+    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
     enum { ARG_n, ARG_ack };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_n,          MP_ARG_INT, {.u_int = -1} },
@@ -329,7 +329,7 @@ STATIC mp_obj_t i2cslave_i2c_slave_request_read(size_t n_args, const mp_obj_t *p
         }
 
         uint8_t data;
-        int num = common_hal_i2cslave_i2c_slave_read_byte(self->slave, &data);
+        int num = common_hal_i2cperipheral_i2c_peripheral_read_byte(self->peripheral, &data);
         if (num == 0) {
             break;
         }
@@ -338,16 +338,16 @@ STATIC mp_obj_t i2cslave_i2c_slave_request_read(size_t n_args, const mp_obj_t *p
         buffer[i++] = data;
         if (i == n) {
             if (ack) {
-                common_hal_i2cslave_i2c_slave_ack(self->slave, true);
+                common_hal_i2cperipheral_i2c_peripheral_ack(self->peripheral, true);
             }
             break;
         }
-        common_hal_i2cslave_i2c_slave_ack(self->slave, true);
+        common_hal_i2cperipheral_i2c_peripheral_ack(self->peripheral, true);
     }
 
     return mp_obj_new_bytearray(i, buffer);
 }
-MP_DEFINE_CONST_FUN_OBJ_KW(i2cslave_i2c_slave_request_read_obj, 1, i2cslave_i2c_slave_request_read);
+MP_DEFINE_CONST_FUN_OBJ_KW(i2cperipheral_i2c_peripheral_request_read_obj, 1, i2cperipheral_i2c_peripheral_request_read);
 
 //|     def write(self, buffer: bytearray) -> int:
 //|         """Write the data contained in buffer.
@@ -356,9 +356,9 @@ MP_DEFINE_CONST_FUN_OBJ_KW(i2cslave_i2c_slave_request_read_obj, 1, i2cslave_i2c_
 //|         :return: Number of bytes written"""
 //|         ...
 //|
-STATIC mp_obj_t i2cslave_i2c_slave_request_write(mp_obj_t self_in, mp_obj_t buf_in) {
-    mp_check_self(MP_OBJ_IS_TYPE(self_in, &i2cslave_i2c_slave_request_type));
-    i2cslave_i2c_slave_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_write(mp_obj_t self_in, mp_obj_t buf_in) {
+    mp_check_self(MP_OBJ_IS_TYPE(self_in, &i2cperipheral_i2c_peripheral_request_type));
+    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
     if (!self->is_read) {
         mp_raise_OSError(MP_EACCES);
@@ -373,7 +373,7 @@ STATIC mp_obj_t i2cslave_i2c_slave_request_write(mp_obj_t self_in, mp_obj_t buf_
             break;
         }
 
-        int num = common_hal_i2cslave_i2c_slave_write_byte(self->slave, ((uint8_t *)(bufinfo.buf))[i]);
+        int num = common_hal_i2cperipheral_i2c_peripheral_write_byte(self->peripheral, ((uint8_t *)(bufinfo.buf))[i]);
         if (num == 0) {
             return mp_obj_new_int(i);
         }
@@ -381,55 +381,55 @@ STATIC mp_obj_t i2cslave_i2c_slave_request_write(mp_obj_t self_in, mp_obj_t buf_
 
     return mp_obj_new_int(bufinfo.len);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(i2cslave_i2c_slave_request_write_obj, i2cslave_i2c_slave_request_write);
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(i2cperipheral_i2c_peripheral_request_write_obj, i2cperipheral_i2c_peripheral_request_write);
 
 //|     def ack(self, ack: bool = True) -> Any:
 //|         """Acknowledge or Not Acknowledge last byte received.
-//|         Use together with :py:meth:`I2CSlaveRequest.read` ack=False.
+//|         Use together with :py:meth:`I2CPeripheralRequest.read` ack=False.
 //|
 //|         :param ack: Whether to send an ACK or NACK"""
 //|         ...
 //|
-STATIC mp_obj_t i2cslave_i2c_slave_request_ack(uint n_args, const mp_obj_t *args) {
-    mp_check_self(MP_OBJ_IS_TYPE(args[0], &i2cslave_i2c_slave_request_type));
-    i2cslave_i2c_slave_request_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_ack(uint n_args, const mp_obj_t *args) {
+    mp_check_self(MP_OBJ_IS_TYPE(args[0], &i2cperipheral_i2c_peripheral_request_type));
+    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(args[0]);
     bool ack = (n_args == 1) ? true : mp_obj_is_true(args[1]);
 
     if (self->is_read) {
         mp_raise_OSError(MP_EACCES);
     }
 
-    common_hal_i2cslave_i2c_slave_ack(self->slave, ack);
+    common_hal_i2cperipheral_i2c_peripheral_ack(self->peripheral, ack);
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2cslave_i2c_slave_request_ack_obj, 1, 2, i2cslave_i2c_slave_request_ack);
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2cperipheral_i2c_peripheral_request_ack_obj, 1, 2, i2cperipheral_i2c_peripheral_request_ack);
 
-STATIC mp_obj_t i2cslave_i2c_slave_request_close(mp_obj_t self_in) {
-    mp_check_self(MP_OBJ_IS_TYPE(self_in, &i2cslave_i2c_slave_request_type));
-    i2cslave_i2c_slave_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t i2cperipheral_i2c_peripheral_request_close(mp_obj_t self_in) {
+    mp_check_self(MP_OBJ_IS_TYPE(self_in, &i2cperipheral_i2c_peripheral_request_type));
+    i2cperipheral_i2c_peripheral_request_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
-    common_hal_i2cslave_i2c_slave_close(self->slave);
+    common_hal_i2cperipheral_i2c_peripheral_close(self->peripheral);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(i2cslave_i2c_slave_request_close_obj, i2cslave_i2c_slave_request_close);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(i2cperipheral_i2c_peripheral_request_close_obj, i2cperipheral_i2c_peripheral_request_close);
 
-STATIC const mp_rom_map_elem_t i2cslave_i2c_slave_request_locals_dict_table[] = {
+STATIC const mp_rom_map_elem_t i2cperipheral_i2c_peripheral_request_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&default___enter___obj) },
-    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&i2cslave_i2c_slave_request___exit___obj) },
-    { MP_ROM_QSTR(MP_QSTR_address), MP_ROM_PTR(&i2cslave_i2c_slave_request_address_obj) },
-    { MP_ROM_QSTR(MP_QSTR_is_read), MP_ROM_PTR(&i2cslave_i2c_slave_request_is_read_obj) },
-    { MP_ROM_QSTR(MP_QSTR_is_restart), MP_ROM_PTR(&i2cslave_i2c_slave_request_is_restart_obj) },
-    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&i2cslave_i2c_slave_request_read_obj) },
-    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&i2cslave_i2c_slave_request_write_obj) },
-    { MP_ROM_QSTR(MP_QSTR_ack), MP_ROM_PTR(&i2cslave_i2c_slave_request_ack_obj) },
-    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&i2cslave_i2c_slave_request_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request___exit___obj) },
+    { MP_ROM_QSTR(MP_QSTR_address), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_address_obj) },
+    { MP_ROM_QSTR(MP_QSTR_is_read), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_is_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_is_restart), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_is_restart_obj) },
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_write_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ack), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_ack_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_request_close_obj) },
 };
 
-STATIC MP_DEFINE_CONST_DICT(i2cslave_i2c_slave_request_locals_dict, i2cslave_i2c_slave_request_locals_dict_table);
+STATIC MP_DEFINE_CONST_DICT(i2cperipheral_i2c_peripheral_request_locals_dict, i2cperipheral_i2c_peripheral_request_locals_dict_table);
 
-const mp_obj_type_t i2cslave_i2c_slave_request_type = {
+const mp_obj_type_t i2cperipheral_i2c_peripheral_request_type = {
    { &mp_type_type },
-   .name = MP_QSTR_I2CSlaveRequest,
-   .make_new = i2cslave_i2c_slave_request_make_new,
-   .locals_dict = (mp_obj_dict_t*)&i2cslave_i2c_slave_request_locals_dict,
+   .name = MP_QSTR_I2CPeripheralRequest,
+   .make_new = i2cperipheral_i2c_peripheral_request_make_new,
+   .locals_dict = (mp_obj_dict_t*)&i2cperipheral_i2c_peripheral_request_locals_dict,
 };
diff --git a/shared-bindings/i2cslave/I2CSlave.h b/shared-bindings/i2cperipheral/I2CPeripheral.h
index abb761416..3035cfbfe 100644
--- a/shared-bindings/i2cslave/I2CSlave.h
+++ b/shared-bindings/i2cperipheral/I2CPeripheral.h
@@ -30,31 +30,31 @@
 #include "py/obj.h"
 
 #include "common-hal/microcontroller/Pin.h"
-#include "common-hal/i2cslave/I2CSlave.h"
+#include "common-hal/i2cperipheral/I2CPeripheral.h"
 
 typedef struct {
     mp_obj_base_t base;
-    i2cslave_i2c_slave_obj_t *slave;
+    i2cperipheral_i2c_peripheral_obj_t *peripheral;
     uint16_t address;
     bool is_read;
     bool is_restart;
-} i2cslave_i2c_slave_request_obj_t;
+} i2cperipheral_i2c_peripheral_request_obj_t;
 
-extern const mp_obj_type_t i2cslave_i2c_slave_request_type;
+extern const mp_obj_type_t i2cperipheral_i2c_peripheral_request_type;
 
-extern const mp_obj_type_t i2cslave_i2c_slave_type;
+extern const mp_obj_type_t i2cperipheral_i2c_peripheral_type;
 
-extern void common_hal_i2cslave_i2c_slave_construct(i2cslave_i2c_slave_obj_t *self,
+extern void common_hal_i2cperipheral_i2c_peripheral_construct(i2cperipheral_i2c_peripheral_obj_t *self,
         const mcu_pin_obj_t* scl, const mcu_pin_obj_t* sda,
         uint8_t *addresses, unsigned int num_addresses, bool smbus);
-extern void common_hal_i2cslave_i2c_slave_deinit(i2cslave_i2c_slave_obj_t *self);
-extern bool common_hal_i2cslave_i2c_slave_deinited(i2cslave_i2c_slave_obj_t *self);
+extern void common_hal_i2cperipheral_i2c_peripheral_deinit(i2cperipheral_i2c_peripheral_obj_t *self);
+extern bool common_hal_i2cperipheral_i2c_peripheral_deinited(i2cperipheral_i2c_peripheral_obj_t *self);
 
-extern int common_hal_i2cslave_i2c_slave_is_addressed(i2cslave_i2c_slave_obj_t *self,
+extern int common_hal_i2cperipheral_i2c_peripheral_is_addressed(i2cperipheral_i2c_peripheral_obj_t *self,
         uint8_t *address, bool *is_read, bool *is_restart);
-extern int common_hal_i2cslave_i2c_slave_read_byte(i2cslave_i2c_slave_obj_t *self, uint8_t *data);
-extern int common_hal_i2cslave_i2c_slave_write_byte(i2cslave_i2c_slave_obj_t *self, uint8_t data);
-extern void common_hal_i2cslave_i2c_slave_ack(i2cslave_i2c_slave_obj_t *self, bool ack);
-extern void common_hal_i2cslave_i2c_slave_close(i2cslave_i2c_slave_obj_t *self);
+extern int common_hal_i2cperipheral_i2c_peripheral_read_byte(i2cperipheral_i2c_peripheral_obj_t *self, uint8_t *data);
+extern int common_hal_i2cperipheral_i2c_peripheral_write_byte(i2cperipheral_i2c_peripheral_obj_t *self, uint8_t data);
+extern void common_hal_i2cperipheral_i2c_peripheral_ack(i2cperipheral_i2c_peripheral_obj_t *self, bool ack);
+extern void common_hal_i2cperipheral_i2c_peripheral_close(i2cperipheral_i2c_peripheral_obj_t *self);
 
 #endif // MICROPY_INCLUDED_SHARED_BINDINGS_BUSIO_I2C_SLAVE_H
diff --git a/shared-bindings/i2cslave/__init__.c b/shared-bindings/i2cperipheral/__init__.c
index 59674d5cb..e2cb8509d 100644
--- a/shared-bindings/i2cslave/__init__.c
+++ b/shared-bindings/i2cperipheral/__init__.c
@@ -30,26 +30,26 @@
 #include "py/runtime.h"
 
 #include "shared-bindings/microcontroller/Pin.h"
-//#include "shared-bindings/i2cslave/__init__.h"
-#include "shared-bindings/i2cslave/I2CSlave.h"
+//#include "shared-bindings/i2cperipheral/__init__.h"
+#include "shared-bindings/i2cperipheral/I2CPeripheral.h"
 
 #include "py/runtime.h"
 
-//| """Two wire serial protocol slave
+//| """Two wire serial protocol peripheral
 //|
-//| The `i2cslave` module contains classes to support a I2C slave.
+//| The `i2cperipheral` module contains classes to support an I2C peripheral.
 //|
-//| Example emulating 2 devices::
+//| Example emulating a peripheral with 2 addresses (read and write)::
 //|
 //|   import board
-//|   from i2cslave import I2CSlave
+//|   from i2cperipheral import I2CPeripheral
 //|
 //|   regs = [0] * 16
 //|   index = 0
 //|
-//|   with I2CSlave(board.SCL, board.SDA, (0x40, 0x41)) as slave:
+//|   with I2CPeripheral(board.SCL, board.SDA, (0x40, 0x41)) as device:
 //|       while True:
-//|           r = slave.request()
+//|           r = device.request()
 //|           if not r:
 //|               # Maybe do some housekeeping
 //|               continue
@@ -67,7 +67,7 @@
 //|                       n = r.write(bytes([regs[index]]))
 //|                   #else:
 //|                       # A read transfer is not supported in this example
-//|                       # If the Master tries, it will get 0xff byte(s) by the ctx manager (r.close())
+//|                       # If the microcontroller tries, it will get 0xff byte(s) by the ctx manager (r.close())
 //|               elif r.address == 0x41:
 //|                   if not r.is_read:
 //|                       b = r.read(1)
@@ -75,7 +75,7 @@
 //|                           # do something
 //|                           pass
 //|
-//| This example sets up an I2C slave that can be accessed from Linux like this::
+//| This example sets up an I2C device that can be accessed from Linux like this::
 //|
 //|   $ i2cget -y 1 0x40 0x01
 //|   0x00
@@ -84,22 +84,23 @@
 //|   0xaa
 //|
 //| .. warning::
-//|    I2CSlave makes use of clock stretching in order to slow down the master.
-//|    Make sure the I2C master supports this.
+//|    I2CPeripheral makes use of clock stretching in order to slow down
+//|    the host.
+//|    Make sure the I2C host supports this.
 //|
 //|    Raspberry Pi in particular does not support this with its I2C hw block.
 //|    This can be worked around by using the ``i2c-gpio`` bit banging driver.
 //|    Since the RPi firmware uses the hw i2c, it's not possible to emulate a HAT eeprom."""
 //|
 
-STATIC const mp_rom_map_elem_t i2cslave_module_globals_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_i2cslave) },
-    { MP_ROM_QSTR(MP_QSTR_I2CSlave), MP_ROM_PTR(&i2cslave_i2c_slave_type) },
+STATIC const mp_rom_map_elem_t i2cperipheral_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_i2cperipheral) },
+    { MP_ROM_QSTR(MP_QSTR_I2CPeripheral), MP_ROM_PTR(&i2cperipheral_i2c_peripheral_type) },
 };
 
-STATIC MP_DEFINE_CONST_DICT(i2cslave_module_globals, i2cslave_module_globals_table);
+STATIC MP_DEFINE_CONST_DICT(i2cperipheral_module_globals, i2cperipheral_module_globals_table);
 
-const mp_obj_module_t i2cslave_module = {
+const mp_obj_module_t i2cperipheral_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&i2cslave_module_globals,
+    .globals = (mp_obj_dict_t*)&i2cperipheral_module_globals,
 };