Add suport of i2c reusage (experimental)

Author: cnadler86

README.md

@@ -23,6 +23,7 @@ If you want to play arround with AI, take a look at the [micropython binding for
   - [Freeing the buffer](#freeing-the-buffer)
   - [Is a frame available](#is-frame-available)
   - [Additional methods](#additional-methods)
+  - [I2C Integration](#i2c-integration)
   - [Additional information](#additional-information)
 - [Build your custom firmware](#build-your-custom-firmware)
   - [Setting up the build environment (DIY method)](#setting-up-the-build-environment-diy-method)
@@ -209,6 +210,42 @@ import camera
 vers = camera.Version()
 ```
 
+### I2C Integration
+
+The camera uses I2C (SCCB protocol) to communicate with the camera sensor. You can share this I2C bus with other devices by passing an external I2C object to the camera:
+
+#### Sharing I2C with Camera
+
+```python
+import machine
+
+# Create your own I2C object first
+i2c = machine.I2C(0, scl=22, sda=21, freq=400000)
+
+# Pass it to the camera (no need for sda_pin/scl_pin)
+cam = camera.Camera(i2c=i2c, data_pins=..., pclk_pin=..., ...)
+
+# The same I2C object can be used for other devices on the same bus!
+devices = i2c.scan()
+print(f"I2C devices found: {devices}")
+
+# You can communicate with other I2C devices while camera is running
+i2c.writeto(0x42, b'\x00\x01')  # Write to another device
+
+# Camera sensor communication works too
+cam.set_saturation(1)  # Uses the shared I2C bus
+```
+
+#### Alternative: Camera Creates Its Own I2C (Default)
+
+```python
+# Camera creates and manages its own I2C internally
+cam = camera.Camera(sda_pin=21, scl_pin=22, ...)
+
+# In this mode, you cannot share I2C with other devices
+# Use the first method if you need to share I2C
+```
+
 ### Additional information
 
 The firmware images support the following cameras out of the box, but is therefore big: OV7670, OV7725, OV2640, OV3660, OV5640, NT99141, GC2145, GC032A, GC0308, BF3005, BF20A6, SC030IOT

src/modcamera.c

@@ -113,6 +113,7 @@ void mp_camera_hal_construct(
     int8_t reset_pin,
     int8_t sccb_sda_pin,
     int8_t sccb_scl_pin,
+    int8_t sccb_i2c_port,
     int32_t xclk_freq_hz,
     mp_camera_pixformat_t pixel_format,
     mp_camera_framesize_t frame_size,
@@ -134,9 +135,15 @@ void mp_camera_hal_construct(
         self->camera_config.pin_pwdn = powerdown_pin;
         self->camera_config.pin_reset = reset_pin;
         self->camera_config.pin_xclk = external_clock_pin;
-        self->camera_config.pin_sscb_sda = sccb_sda_pin;
-        self->camera_config.pin_sscb_scl = sccb_scl_pin;
-
+        if (sccb_i2c_port != -1) {
+            self->camera_config.sccb_i2c_port = sccb_i2c_port;
+            self->camera_config.pin_sscb_sda = -1;  // Set sda_pin = -1 to signal esp_camera_init to use SCCB_Use_Port()
+            self->camera_config.pin_sscb_scl = -1;
+        } else {
+            self->camera_config.pin_sscb_sda = sccb_sda_pin;
+            self->camera_config.pin_sscb_scl = sccb_scl_pin;
+            self->camera_config.sccb_i2c_port = sccb_i2c_port;
+        }
         self->camera_config.frame_size = frame_size;        
         self->camera_config.jpeg_quality = jpeg_quality;    //save value in here, but will be corrected (with map) before passing it to the esp32-driver
 

src/modcamera.h

@@ -119,8 +119,9 @@ typedef hal_camera_gainceiling_t mp_camera_gainceiling_t;
  * @param href_pin HREF pin.
  * @param powerdown_pin Power down pin.
  * @param reset_pin Reset pin.
- * @param sccb_sda_pin SCCB SDA pin.
+ * @param sccb_sda_pin SCCB SDA pin (set to -1 to use sccb_i2c_port instead).
  * @param sccb_scl_pin SCCB SCL pin.
+ * @param sccb_i2c_port I2C port number to use (only if sccb_sda_pin is -1).
  * @param xclk_freq_hz External clock frequency in Hz.
  * @param pixel_format Pixel format.
  * @param frame_size Frame size.
@@ -139,6 +140,7 @@ extern void mp_camera_hal_construct(
     int8_t reset_pin,
     int8_t sccb_sda_pin,
     int8_t sccb_scl_pin,
+    int8_t sccb_i2c_port,
     int32_t xclk_freq_hz,
     mp_camera_pixformat_t pixel_format,
     mp_camera_framesize_t frame_size,

src/modcamera_api.c

@@ -35,6 +35,13 @@
 
 #include "modcamera.h"
 
+#if MICROPY_HW_ESP_NEW_I2C_DRIVER
+#include "driver/i2c_master.h"
+#else
+#include "driver/i2c.h"
+#include "hal/i2c_ll.h"
+#endif
+
 typedef struct mp_camera_obj_t mp_camera_obj;
 const mp_obj_type_t camera_type;
 
@@ -43,7 +50,7 @@ static mp_camera_obj_t mp_camera_singleton = { .base = { NULL } };
 
 //Constructor
 static mp_obj_t mp_camera_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
-    enum { ARG_data_pins, ARG_pixel_clock_pin, ARG_vsync_pin, ARG_href_pin, ARG_sda_pin, ARG_scl_pin, ARG_xclock_pin, ARG_xclock_frequency, ARG_powerdown_pin, ARG_reset_pin, ARG_pixel_format, ARG_frame_size, ARG_jpeg_quality, ARG_fb_count, ARG_grab_mode, ARG_init, NUM_ARGS };
+    enum { ARG_data_pins, ARG_pixel_clock_pin, ARG_vsync_pin, ARG_href_pin, ARG_sda_pin, ARG_scl_pin, ARG_xclock_pin, ARG_i2c, ARG_xclock_frequency, ARG_powerdown_pin, ARG_reset_pin, ARG_pixel_format, ARG_frame_size, ARG_jpeg_quality, ARG_fb_count, ARG_grab_mode, ARG_init, NUM_ARGS };
     static const mp_arg_t allowed_args[] = {
         #ifdef MICROPY_CAMERA_ALL_REQ_PINS_DEFINED
             { MP_QSTR_data_pins, MP_ARG_OBJ | MP_ARG_KW_ONLY , { .u_obj = MP_ROM_NONE } },
@@ -58,10 +65,11 @@ static mp_obj_t mp_camera_make_new(const mp_obj_type_t *type, size_t n_args, siz
             { MP_QSTR_pclk_pin, MP_ARG_INT | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
             { MP_QSTR_vsync_pin, MP_ARG_INT | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
             { MP_QSTR_href_pin, MP_ARG_INT | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
-            { MP_QSTR_sda_pin, MP_ARG_INT | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
-            { MP_QSTR_scl_pin, MP_ARG_INT | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
+            { MP_QSTR_sda_pin, MP_ARG_INT | MP_ARG_KW_ONLY, { .u_int = -1 } },
+            { MP_QSTR_scl_pin, MP_ARG_INT | MP_ARG_KW_ONLY, { .u_int = -1 } },
             { MP_QSTR_xclk_pin, MP_ARG_INT | MP_ARG_KW_ONLY | MP_ARG_REQUIRED },
         #endif
+        { MP_QSTR_i2c, MP_ARG_OBJ | MP_ARG_KW_ONLY, { .u_obj = MP_ROM_NONE } },
         { MP_QSTR_xclk_freq, MP_ARG_INT | MP_ARG_KW_ONLY, { .u_int = MICROPY_CAMERA_XCLK_FREQ } },
         { MP_QSTR_powerdown_pin, MP_ARG_INT | MP_ARG_KW_ONLY, { .u_int = MICROPY_CAMERA_PIN_PWDN } },
         { MP_QSTR_reset_pin, MP_ARG_INT | MP_ARG_KW_ONLY, { .u_int = MICROPY_CAMERA_PIN_RESET } },
@@ -111,8 +119,48 @@ static mp_obj_t mp_camera_make_new(const mp_obj_type_t *type, size_t n_args, siz
     int8_t pixel_clock_pin = args[ARG_pixel_clock_pin].u_int;
     int8_t vsync_pin = args[ARG_vsync_pin].u_int;
     int8_t href_pin = args[ARG_href_pin].u_int;
-    int8_t sda_pin = args[ARG_sda_pin].u_int;
-    int8_t scl_pin = args[ARG_scl_pin].u_int;
+    
+    // Handle I2C configuration: either use I2C object or individual pins
+    int8_t sda_pin = -1;
+    int8_t scl_pin = -1;
+    int8_t i2c_port = -1;
+    mp_obj_t i2c_obj = args[ARG_i2c].u_obj;
+    
+    if (i2c_obj != MP_ROM_NONE) {
+        // External I2C object provided - extract port number from it
+        extern const mp_obj_type_t machine_i2c_type;
+        if (!mp_obj_is_type(i2c_obj, &machine_i2c_type)) {
+            mp_raise_TypeError(MP_ERROR_TEXT("i2c must be a machine.I2C object"));
+        }
+        
+        // Get the I2C port from the I2C object
+        // Structure matches machine_hw_i2c_obj_t from machine_i2c.c
+        typedef struct _machine_hw_i2c_obj_t {
+            mp_obj_base_t base;
+            i2c_port_t port : 8;
+            gpio_num_t scl : 8;
+            gpio_num_t sda : 8;
+            uint32_t freq;
+            uint32_t timeout_us;
+        } machine_hw_i2c_obj_t;
+
+        machine_hw_i2c_obj_t *i2c = (machine_hw_i2c_obj_t *)MP_OBJ_TO_PTR(i2c_obj);
+        i2c_port = (int8_t)i2c->port;
+        sda_pin = i2c->sda;
+        scl_pin = i2c->scl;
+    } else {
+        // Use individual pins
+        sda_pin = args[ARG_sda_pin].u_int;
+        scl_pin = args[ARG_scl_pin].u_int;
+        
+        // Validate that pins are provided (if no default pins defined)
+        #ifndef MICROPY_CAMERA_ALL_REQ_PINS_DEFINED
+            if (sda_pin == -1 || scl_pin == -1) {
+                mp_raise_ValueError(MP_ERROR_TEXT("Either i2c object or sda_pin/scl_pin must be specified"));
+            }
+        #endif
+    }
+    
     int8_t xclock_pin = args[ARG_xclock_pin].u_int;
     int32_t xclock_frequency = args[ARG_xclock_frequency].u_int;
     if (xclock_frequency < 1000) {
@@ -132,21 +180,17 @@ static mp_obj_t mp_camera_make_new(const mp_obj_type_t *type, size_t n_args, siz
     // Get static singleton object
     mp_camera_obj_t *self = &mp_camera_singleton;
 
-    // If camera was already initialized, deinit it first
-    bool first_init = false;
     if (self->base.type == NULL) {
-        // First time initialization
         self->base.type = &camera_type;
-        first_init = true;
     } else {
-        // Camera already exists, deinit it before reinitializing
-        mp_camera_hal_deinit(self);
+        mp_camera_hal_deinit(self);     // Camera already exists, deinit it before reinitializing
     }
 
     mp_camera_hal_construct(self, data_pins, xclock_pin, pixel_clock_pin, vsync_pin, href_pin, powerdown_pin, reset_pin, 
-        sda_pin, scl_pin, xclock_frequency, pixel_format, frame_size, jpeg_quality, fb_count, grab_mode);
+        sda_pin, scl_pin, i2c_port, xclock_frequency, pixel_format, frame_size, jpeg_quality, fb_count, grab_mode);
 
     mp_camera_hal_init(self);
+    mp_hal_delay_ms(10); // Small delay to ensure I2C/SCCB is fully initialized
     if (mp_camera_hal_capture(self) == mp_const_none){
         mp_camera_hal_deinit(self);
         mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Failed to capture initial frame. Construct a new object with appropriate configuration."));