Use primary/secondary terminology in docstrings

Author: jepler

shared-bindings/bitbangio/I2C.c

@@ -158,7 +158,7 @@ STATIC mp_obj_t bitbangio_i2c_obj_unlock(mp_obj_t self_in) {
 MP_DEFINE_CONST_FUN_OBJ_1(bitbangio_i2c_unlock_obj, bitbangio_i2c_obj_unlock);
 
 //|     def readfrom_into(self, address: int, buffer: bytearray, *, start: int = 0, end: int = None) -> Any:
-//|         """Read into ``buffer`` from the slave specified by ``address``.
+//|         """Read into ``buffer`` from the secondary specified by ``address``.
 //|         The number of bytes read will be the length of ``buffer``.
 //|         At least one byte must be read.
 //|
@@ -210,7 +210,7 @@ STATIC mp_obj_t bitbangio_i2c_readfrom_into(size_t n_args, const mp_obj_t *pos_a
 MP_DEFINE_CONST_FUN_OBJ_KW(bitbangio_i2c_readfrom_into_obj, 3, bitbangio_i2c_readfrom_into);
 
 //|     def writeto(self, address: int, buffer: bytearray, *, start: int = 0, end: int = None, stop: bool = True) -> Any:
-//|         """Write the bytes from ``buffer`` to the slave specified by ``address`` and then transmits a
+//|         """Write the bytes from ``buffer`` to the secondary specified by ``address`` and then transmits a
 //|         stop bit. Use `writeto_then_readfrom` when needing a write, no stop and repeated start
 //|         before a read.
 //|
@@ -270,7 +270,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bitbangio_i2c_writeto_obj, 1, bitbangio_i2c_wr
 
 
 //|     def writeto_then_readfrom(self, address: int, out_buffer: bytearray, in_buffer: bytearray, *, out_start: int = 0, out_end: int = None, in_start: int = 0, in_end: int = None) -> Any:
-//|         """Write the bytes from ``out_buffer`` to the slave specified by ``address``, generate no stop
+//|         """Write the bytes from ``out_buffer`` to the secondary specified by ``address``, generate no stop
 //|         bit, generate a repeated start and read into ``in_buffer``. ``out_buffer`` and
 //|         ``in_buffer`` can be the same buffer because they are used sequentially.
 //|

shared-bindings/bitbangio/SPI.c

@@ -43,19 +43,19 @@
 //|     """A 3-4 wire serial protocol
 //|
 //|     SPI is a serial protocol that has exclusive pins for data in and out of the
-//|     master.  It is typically faster than :py:class:`~bitbangio.I2C` because a
-//|     separate pin is used to control the active slave rather than a transmitted
+//|     microcontroller.  It is typically faster than :py:class:`~bitbangio.I2C` because a
+//|     separate pin is used to control the active secondary rather than a transmitted
 //|     address. This class only manages three of the four SPI lines: `!clock`,
-//|     `!MOSI`, `!MISO`. Its up to the client to manage the appropriate slave
-//|     select line. (This is common because multiple slaves can share the `!clock`,
+//|     `!MOSI`, `!MISO`. Its up to the client to manage the appropriate secondary
+//|     select line. (This is common because multiple secondaries can share the `!clock`,
 //|     `!MOSI` and `!MISO` lines and therefore the hardware.)"""
 //|
 //|     def __init__(self, clock: microcontroller.Pin, MOSI: microcontroller.Pin = None, MISO: microcontroller.Pin = None):
 //|         """Construct an SPI object on the given pins.
 //|
 //|         :param ~microcontroller.Pin clock: the pin to use for the clock.
-//|         :param ~microcontroller.Pin MOSI: the Master Out Slave In pin.
-//|         :param ~microcontroller.Pin MISO: the Master In Slave Out pin."""
+//|         :param ~microcontroller.Pin MOSI: the Microcontroller Out Secondary In pin.
+//|         :param ~microcontroller.Pin MISO: the Microcontroller In Secondary Out pin."""
 //|         ...
 //|
 

shared-bindings/busio/I2C.c

@@ -177,7 +177,7 @@ STATIC mp_obj_t busio_i2c_obj_unlock(mp_obj_t self_in) {
 MP_DEFINE_CONST_FUN_OBJ_1(busio_i2c_unlock_obj, busio_i2c_obj_unlock);
 
 //|     def readfrom_into(self, address: int, buffer: bytearray, *, start: int = 0, end: int = None) -> Any:
-//|          """Read into ``buffer`` from the slave specified by ``address``.
+//|          """Read into ``buffer`` from the secondary specified by ``address``.
 //|          The number of bytes read will be the length of ``buffer``.
 //|          At least one byte must be read.
 //|
@@ -229,7 +229,7 @@ STATIC mp_obj_t busio_i2c_readfrom_into(size_t n_args, const mp_obj_t *pos_args,
 MP_DEFINE_CONST_FUN_OBJ_KW(busio_i2c_readfrom_into_obj, 3, busio_i2c_readfrom_into);
 
 //|     def writeto(self, address: int, buffer: bytearray, *, start: int = 0, end: int = None, stop: bool = True) -> Any:
-//|          """Write the bytes from ``buffer`` to the slave specified by ``address``.
+//|          """Write the bytes from ``buffer`` to the secondary specified by ``address``.
 //|          Transmits a stop bit when stop is True. Setting stop=False is deprecated and stop will be
 //|          removed in CircuitPython 6.x. Use `writeto_then_readfrom` when needing a write, no stop and
 //|          repeated start before a read.
@@ -288,7 +288,7 @@ STATIC mp_obj_t busio_i2c_writeto(size_t n_args, const mp_obj_t *pos_args, mp_ma
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(busio_i2c_writeto_obj, 1, busio_i2c_writeto);
 
 //|     def writeto_then_readfrom(self, address: int, out_buffer: bytearray, in_buffer: bytearray, *, out_start: int = 0, out_end: int = None, in_start: int = 0, in_end: int = None) -> Any:
-//|          """Write the bytes from ``out_buffer`` to the slave specified by ``address``, generate no stop
+//|          """Write the bytes from ``out_buffer`` to the secondary specified by ``address``, generate no stop
 //|          bit, generate a repeated start and read into ``in_buffer``. ``out_buffer`` and
 //|          ``in_buffer`` can be the same buffer because they are used sequentially.
 //|

shared-bindings/busio/SPI.c

@@ -45,11 +45,11 @@
 //|     """A 3-4 wire serial protocol
 //|
 //|     SPI is a serial protocol that has exclusive pins for data in and out of the
-//|     master.  It is typically faster than :py:class:`~busio.I2C` because a
-//|     separate pin is used to control the active slave rather than a transitted
+//|     microcontroller.  It is typically faster than :py:class:`~busio.I2C` because a
+//|     separate pin is used to control the active secondary rather than a transitted
 //|     address. This class only manages three of the four SPI lines: `!clock`,
-//|     `!MOSI`, `!MISO`. Its up to the client to manage the appropriate slave
-//|     select line. (This is common because multiple slaves can share the `!clock`,
+//|     `!MOSI`, `!MISO`. Its up to the client to manage the appropriate secondary
+//|     select line. (This is common because multiple secondaries can share the `!clock`,
 //|     `!MOSI` and `!MISO` lines and therefore the hardware.)"""
 //|
 //|     def __init__(self, clock: microcontroller.Pin, MOSI: microcontroller.Pin = None, MISO: microcontroller.Pin = None):
@@ -72,8 +72,8 @@
 //|             :ref:`Register <register-module-reference>` data descriptors.
 //|
 //|         :param ~microcontroller.Pin clock: the pin to use for the clock.
-//|         :param ~microcontroller.Pin MOSI: the Master Out Slave In pin.
-//|         :param ~microcontroller.Pin MISO: the Master In Slave Out pin."""
+//|         :param ~microcontroller.Pin MOSI: the Microcontroller Out Secondary In pin.
+//|         :param ~microcontroller.Pin MISO: the Microcontroller In Secondary Out pin."""
 //|         ...
 //|
 

shared-bindings/i2cslave/I2CSlave.c

@@ -134,7 +134,7 @@ STATIC mp_obj_t i2cslave_i2c_slave_obj___exit__(size_t n_args, const mp_obj_t *a
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(i2cslave_i2c_slave___exit___obj, 4, 4, i2cslave_i2c_slave_obj___exit__);
 
 //|     def request(self, timeout: float = -1) -> Any:
-//|         """Wait for an I2C request from a master.
+//|         """Wait for an I2C request from a microcontroller.
 //|
 //|         :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
@@ -228,12 +228,12 @@ const mp_obj_type_t i2cslave_i2c_slave_type = {
 //| class I2CSlaveRequest:
 //|
 //|     def __init__(self, slave: i2cslave.I2CSlave, address: int, is_read: bool, is_restart: bool):
-//|         """I2C transfer request from a master.
+//|         """I2C transfer request from a microcontroller
 //|         This cannot be instantiated directly, but is returned by :py:meth:`I2CSlave.request`.
 //|
 //|         :param slave: The I2C Slave receiving this request
 //|         :param address: I2C address
-//|         :param is_read: I2C Master read request
+//|         :param is_read: True if The I2C Microcontroller is reading from the device
 //|         :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) {
@@ -270,7 +270,7 @@ STATIC mp_obj_t i2cslave_i2c_slave_request_get_address(mp_obj_t self_in) {
 MP_DEFINE_CONST_PROP_GET(i2cslave_i2c_slave_request_address_obj, i2cslave_i2c_slave_request_get_address);
 
 //|     is_read: bool = ...
-//|     """The I2C master is reading from the device."""
+//|     """The I2C Microcontroller is reading from the device."""
 //|
 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));

shared-bindings/i2cslave/__init__.c

@@ -53,9 +53,9 @@
 //|           if not r:
 //|               # Maybe do some housekeeping
 //|               continue
-//|           with r:  # Closes the transfer if necessary by sending a NACK or feeding the master dummy bytes
+//|           with r:  # Closes the transfer if necessary by sending a NACK or feeding the microcontroller dummy bytes
 //|               if r.address == 0x40:
-//|                   if not r.is_read:  # Master write which is Slave read
+//|                   if not r.is_read:  # Microcontroller write which is Secondary read
 //|                       b = r.read(1)
 //|                       if not b or b[0] > 15:
 //|                           break