add optional aditional I2C singletons

define DEFAULT_I2C_BUS for the number of I2C busses
list the pins in a list DEFAULT_I2C_PINS
macro to create a new I2C object singleton ADD_SINGLETON_I2C_OBJ
check for I2C singleton in displayio

Author: Neradoc

ports/raspberrypi/boards/adafruit_qtpy_rp2040/mpconfigboard.h

@@ -4,8 +4,9 @@
 #define MICROPY_HW_NEOPIXEL (&pin_GPIO12)
 #define CIRCUITPY_STATUS_LED_POWER (&pin_GPIO11)
 
-#define DEFAULT_I2C_BUS_SCL (&pin_GPIO25)
-#define DEFAULT_I2C_BUS_SDA (&pin_GPIO24)
+#define DEFAULT_I2C_BUS (2)
+// SCL, SDA, SCL1, SDA1
+#define DEFAULT_I2C_PINS { &pin_GPIO25, &pin_GPIO24, &pin_GPIO23, &pin_GPIO22 }
 
 #define DEFAULT_SPI_BUS_SCK (&pin_GPIO6)
 #define DEFAULT_SPI_BUS_MOSI (&pin_GPIO3)

ports/raspberrypi/boards/adafruit_qtpy_rp2040/pins.c

@@ -1,5 +1,7 @@
 #include "shared-bindings/board/__init__.h"
 
+ADD_SINGLETON_I2C_OBJ(board_stemma_i2c_obj, 1)
+
 STATIC const mp_rom_map_elem_t board_module_globals_table[] = {
     CIRCUITPYTHON_BOARD_DICT_STANDARD_ITEMS
 
@@ -45,6 +47,7 @@ STATIC const mp_rom_map_elem_t board_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_SCL1), MP_ROM_PTR(&pin_GPIO23) },
 
     { MP_ROM_QSTR(MP_QSTR_I2C), MP_ROM_PTR(&board_i2c_obj) },
+    { MP_ROM_QSTR(MP_QSTR_STEMMA_I2C), MP_ROM_PTR(&board_stemma_i2c_obj) },
     { MP_ROM_QSTR(MP_QSTR_SPI), MP_ROM_PTR(&board_spi_obj) },
     { MP_ROM_QSTR(MP_QSTR_UART), MP_ROM_PTR(&board_uart_obj) },
 };

py/circuitpy_mpconfig.h

@@ -247,10 +247,19 @@ typedef long mp_off_t;
 // So if any are not defined in *.mk, they'll throw an error here.
 
 #if CIRCUITPY_BOARD
-#define BOARD_I2C (defined(DEFAULT_I2C_BUS_SDA) && defined(DEFAULT_I2C_BUS_SCL))
+
+// support defining default I2C the old way without DEFAULT_I2C_BUS
+#if defined(DEFAULT_I2C_BUS_SDA) && defined(DEFAULT_I2C_BUS_SCL) \
+    && !defined(DEFAULT_I2C_BUS)
+#define DEFAULT_I2C_BUS (1)
+#define DEFAULT_I2C_PINS { DEFAULT_I2C_BUS_SCL, DEFAULT_I2C_BUS_SDA }
+#endif
+#define BOARD_I2C (defined(DEFAULT_I2C_BUS))
+
 #define BOARD_SPI (defined(DEFAULT_SPI_BUS_SCK) && defined(DEFAULT_SPI_BUS_MISO) && defined(DEFAULT_SPI_BUS_MOSI))
 #define BOARD_UART (defined(DEFAULT_UART_BUS_RX) && defined(DEFAULT_UART_BUS_TX))
 // I2C and SPI are always allocated off the heap.
+
 #if BOARD_UART
 #define BOARD_UART_ROOT_POINTER mp_obj_t shared_uart_bus;
 #else

shared-bindings/board/__init__.c

@@ -54,15 +54,27 @@
 //|     ...
 //|
 
+//| def STEMMA_I2C() -> busio.I2C:
+//|     """Returns the `busio.I2C` object for the STEMMA or STEMMA QT connector.
+//|     Present only if the STEMMA connector provides a second, additional I2C bus that is not the same as `board.I2C()`.
+//|     It is a singleton."""
+//|     ...
+//|
+
 #if BOARD_I2C
-mp_obj_t board_i2c(void) {
-    mp_obj_t singleton = common_hal_board_get_i2c();
+extern mcu_pin_obj_t *i2c_default_pins[];
+
+mp_obj_t board_i2c_n(int busnum) {
+    mp_obj_t singleton = common_hal_board_get_i2c(busnum);
     if (singleton != NULL && !common_hal_busio_i2c_deinited(singleton)) {
         return singleton;
     }
-    assert_pin_free(DEFAULT_I2C_BUS_SDA);
-    assert_pin_free(DEFAULT_I2C_BUS_SCL);
-    return common_hal_board_create_i2c();
+    assert_pin_free(i2c_default_pins[busnum * 2]);
+    assert_pin_free(i2c_default_pins[busnum * 2 + 1]);
+    return common_hal_board_create_i2c(busnum);
+}
+mp_obj_t board_i2c(void) {
+    return board_i2c_n(0);
 }
 #else
 mp_obj_t board_i2c(void) {

shared-bindings/board/__init__.h

@@ -35,9 +35,18 @@
 extern const mp_obj_dict_t board_module_globals;
 STATIC const MP_DEFINE_STR_OBJ(board_module_id_obj, CIRCUITPY_BOARD_ID);
 
-mp_obj_t common_hal_board_get_i2c(void);
-mp_obj_t common_hal_board_create_i2c(void);
+mp_obj_t common_hal_board_get_i2c(int);
+mp_obj_t common_hal_board_create_i2c(int);
 MP_DECLARE_CONST_FUN_OBJ_0(board_i2c_obj);
+bool common_hal_board_is_i2c_singleton(mp_obj_t compare_i2c);
+
+#if BOARD_I2C
+extern mp_obj_t board_i2c_n(int busnum);
+#define ADD_SINGLETON_I2C_OBJ(name, n) mp_obj_t board_i2c_bus_##n(void) { \
+        return board_i2c_n(n); \
+} \
+    MP_DEFINE_CONST_FUN_OBJ_0(name, board_i2c_bus_##n);
+#endif
 
 mp_obj_t common_hal_board_get_spi(void);
 mp_obj_t common_hal_board_create_spi(void);

shared-module/board/__init__.c

@@ -47,25 +47,35 @@
 #if BOARD_I2C
 // Statically allocate the I2C object so it can live past the end of the heap and into the next VM.
 // That way it can be used by built-in I2CDisplay displays and be accessible through board.I2C().
-STATIC busio_i2c_obj_t i2c_obj;
-STATIC mp_obj_t i2c_singleton = NULL;
+STATIC busio_i2c_obj_t i2c_obj[DEFAULT_I2C_BUS];
+STATIC mp_obj_t i2c_singleton[DEFAULT_I2C_BUS];
+const mcu_pin_obj_t *i2c_default_pins[DEFAULT_I2C_BUS * 2] = DEFAULT_I2C_PINS;
 
-mp_obj_t common_hal_board_get_i2c(void) {
-    return i2c_singleton;
+mp_obj_t common_hal_board_get_i2c(int busnum) {
+    return i2c_singleton[busnum];
 }
 
-mp_obj_t common_hal_board_create_i2c(void) {
+mp_obj_t common_hal_board_create_i2c(int busnum) {
     // All callers have either already verified this or come so early that it can't be otherwise.
-    assert(i2c_singleton == NULL || common_hal_busio_i2c_deinited(i2c_singleton));
-    busio_i2c_obj_t *self = &i2c_obj;
+    assert(i2c_singleton[busnum] == NULL || common_hal_busio_i2c_deinited(i2c_singleton[busnum]));
+    busio_i2c_obj_t *self = &i2c_obj[busnum];
     self->base.type = &busio_i2c_type;
 
-    common_hal_busio_i2c_construct(self, DEFAULT_I2C_BUS_SCL, DEFAULT_I2C_BUS_SDA, 100000, 255);
-    i2c_singleton = (mp_obj_t)self;
-    return i2c_singleton;
+    common_hal_busio_i2c_construct(self, i2c_default_pins[busnum * 2], i2c_default_pins[busnum * 2 + 1], 100000, 255);
+    i2c_singleton[busnum] = (mp_obj_t)self;
+    return i2c_singleton[busnum];
 }
-#endif
 
+bool common_hal_board_is_i2c_singleton(mp_obj_t compare_i2c) {
+    // check that this object is one of the singletons (for displayio)
+    for (int i2ci = 0; i2ci < DEFAULT_I2C_BUS; ++i2ci) {
+        if (compare_i2c == i2c_singleton[i2ci]) {
+            return true;
+        }
+    }
+    return false;
+}
+#endif
 
 #if BOARD_SPI
 // Statically allocate the SPI object so it can live past the end of the heap and into the next VM.
@@ -134,21 +144,23 @@ mp_obj_t common_hal_board_create_uart(void) {
 
 void reset_board_busses(void) {
     #if BOARD_I2C
-    bool display_using_i2c = false;
-    #if CIRCUITPY_DISPLAYIO
-    for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
-        if (displays[i].bus_base.type == &displayio_i2cdisplay_type && displays[i].i2cdisplay_bus.bus == i2c_singleton) {
-            display_using_i2c = true;
-            break;
+    for (int i2ci = 0; i2ci < DEFAULT_I2C_BUS; ++i2ci) {
+        bool display_using_i2c = false;
+        #if CIRCUITPY_DISPLAYIO
+        for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
+            if (displays[i].bus_base.type == &displayio_i2cdisplay_type && displays[i].i2cdisplay_bus.bus == i2c_singleton[i2ci]) {
+                display_using_i2c = true;
+                break;
+            }
         }
-    }
-    #endif
-    // make sure I2C lock is not held over a soft reset
-    if (i2c_singleton != NULL) {
-        common_hal_busio_i2c_unlock(i2c_singleton);
-        if (!display_using_i2c) {
-            common_hal_busio_i2c_deinit(i2c_singleton);
-            i2c_singleton = NULL;
+        #endif
+        // make sure I2C lock is not held over a soft reset
+        if (i2c_singleton[i2ci] != NULL) {
+            common_hal_busio_i2c_unlock(i2c_singleton[i2ci]);
+            if (!display_using_i2c) {
+                common_hal_busio_i2c_deinit(i2c_singleton[i2ci]);
+                i2c_singleton[i2ci] = NULL;
+            }
         }
     }
     #endif

shared-module/displayio/__init__.c

@@ -165,10 +165,10 @@ void reset_displays(void) {
                 ((uint32_t)i2c->bus) > ((uint32_t)&displays + CIRCUITPY_DISPLAY_LIMIT)) {
                 busio_i2c_obj_t *original_i2c = i2c->bus;
                 #if BOARD_I2C
-                // We don't need to move original_i2c if it is the board.I2C object because it is
+                // We don't need to move original_i2c if it is a board.I2C singletion because it is
                 // statically allocated already. (Doing so would also make it impossible to reference in
                 // a subsequent VM run.)
-                if (original_i2c == common_hal_board_get_i2c()) {
+                if (common_hal_board_is_i2c_singleton(original_i2c)) {
                     continue;
                 }
                 #endif