Merge remote-tracking branch 'origin/main'

.gitmodules

@@ -307,3 +307,6 @@
 [submodule "frozen/circuitpython_picoed"]
 	path = frozen/circuitpython_picoed
 	url = https://github.com/elecfreaks/circuitpython_picoed.git
+[submodule "ports/espressif/esp32-camera"]
+	path = ports/espressif/esp32-camera
+	url = https://github.com/adafruit/esp32-camera/

conf.py

@@ -199,6 +199,7 @@ exclude_patterns = ["**/build*",
                     "ports/cxd56/spresense-exported-sdk",
                     "ports/espressif/certificates",
                     "ports/espressif/esp-idf",
+                    "ports/espressif/esp32-camera",
                     "ports/espressif/.idf_tools",
                     "ports/espressif/peripherals",
                     "ports/litex/hw",

locale/circuitpython.pot

@@ -3254,6 +3254,10 @@ msgstr ""
 msgid "invalid micropython decorator"
 msgstr ""
 
+#: ports/espressif/common-hal/esp32_camera/Camera.c
+msgid "invalid setting"
+msgstr ""
+
 #: shared-bindings/random/__init__.c
 msgid "invalid step"
 msgstr ""
@@ -3509,7 +3513,7 @@ msgstr ""
 msgid "no response from SD card"
 msgstr ""
 
-#: py/objobject.c py/runtime.c
+#: ports/espressif/common-hal/esp32_camera/Camera.c py/objobject.c py/runtime.c
 msgid "no such attribute"
 msgstr ""
 

ports/espressif/CMakeLists.txt

@@ -8,6 +8,13 @@ set(ENV{IDF_PATH} ${CMAKE_SOURCE_DIR}/esp-idf)
 # can build.
 set(COMPONENTS esptool_py soc driver log main esp-tls mbedtls mdns esp_event esp_adc_cal esp_netif esp_wifi lwip wpa_supplicant freertos bt usb)
 
+if("${CIRCUITPY_ESP32_CAMERA}")
+message("Including esp32-camera")
+set(EXTRA_COMPONENT_DIRS "esp32-camera")
+list(APPEND COMPONENTS "esp32-camera")
+message("COMPONENTS = ${COMPONENTS}")
+endif()
+
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
 project(circuitpython)
 

ports/espressif/Makefile

@@ -261,7 +261,6 @@ SRC_C += \
 	peripherals/touch.c
 ifeq ($(IDF_TARGET),esp32s2)
 SRC_C += \
-	cam.c \
 	i2s_lcd_esp32s2_driver.c
 endif
 endif
@@ -283,6 +282,15 @@ endif
 
 SRC_C += $(wildcard common-hal/espidf/*.c)
 
+ifneq ($(CIRCUITPY_ESP32_CAMERA),0)
+SRC_CAMERA := \
+	$(wildcard common-hal/esp32_camera/*.c) \
+	$(wildcard bindings/esp32_camera/*.c)
+SRC_C += $(SRC_CAMERA)
+CFLAGS += -isystem esp32-camera/driver/include
+CFLAGS += -isystem esp32-camera/conversions/include
+endif
+
 SRC_COMMON_HAL_EXPANDED = \
 	$(addprefix shared-bindings/, $(SRC_COMMON_HAL)) \
 	$(addprefix shared-bindings/, $(SRC_BINDINGS_ENUMS)) \
@@ -341,8 +349,10 @@ ifneq ($(CIRCUITPY_BLEIO),0)
 	SDKCONFIGS := esp-idf-config/sdkconfig-ble.defaults;$(SDKCONFIGS)
 endif
 # create the config headers
-$(BUILD)/esp-idf/config/sdkconfig.h: boards/$(BOARD)/sdkconfig | $(BUILD)/esp-idf
+.PHONY: do-sdkconfig
-	IDF_PATH=$(IDF_PATH) cmake -S . -B $(BUILD)/esp-idf -DSDKCONFIG=$(BUILD)/esp-idf/sdkconfig -DSDKCONFIG_DEFAULTS="$(SDKCONFIGS)" -DCMAKE_TOOLCHAIN_FILE=$(IDF_PATH)/tools/cmake/toolchain-$(IDF_TARGET).cmake -DIDF_TARGET=$(IDF_TARGET) -GNinja
+do-sdkconfig: $(BUILD)/esp-idf/config/sdkconfig.h
+$(BUILD)/esp-idf/config/sdkconfig.h: boards/$(BOARD)/sdkconfig CMakeLists.txt | $(BUILD)/esp-idf
+	IDF_PATH=$(IDF_PATH) cmake -S . -B $(BUILD)/esp-idf -DSDKCONFIG=$(BUILD)/esp-idf/sdkconfig -DSDKCONFIG_DEFAULTS="$(SDKCONFIGS)" -DCMAKE_TOOLCHAIN_FILE=$(IDF_PATH)/tools/cmake/toolchain-$(IDF_TARGET).cmake -DIDF_TARGET=$(IDF_TARGET) -GNinja -DCIRCUITPY_ESP32_CAMERA=$(CIRCUITPY_ESP32_CAMERA)
 
 # build a lib
 # Adding -d explain -j 1 -v to the ninja line will output debug info
@@ -391,6 +401,11 @@ BINARY_BLOBS += esp-idf/components/xtensa/$(IDF_TARGET)/libxt_hal.a
 ESP_IDF_COMPONENTS_EXPANDED += esp-idf/components/xtensa/$(IDF_TARGET)/libxt_hal.a
 endif
 
+ifneq ($(CIRCUITPY_ESP32_CAMERA),0)
+ESP_IDF_COMPONENTS_EXPANDED += $(BUILD)/esp-idf/esp-idf/esp32-camera/libesp32-camera.a
+#$(error $(ESP_IDF_COMPONENTS_EXPANDED))
+endif
+
 # BOOTLOADER_OFFSET is determined by chip type, based on the ROM bootloader, and is not changeable.
 ifeq ($(IDF_TARGET),esp32)
 BOOTLOADER_OFFSET = 0x1000

ports/espressif/bindings/esp32_camera/Camera.h

@@ -0,0 +1,116 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 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/enum.h"
+#include "py/obj.h"
+
+#include "esp_camera.h"
+
+#include "shared-bindings/busio/I2C.h"
+
+extern const mp_obj_type_t esp32_camera_camera_type;
+typedef struct esp32_camera_camera_obj esp32_camera_camera_obj_t;
+
+extern void common_hal_esp32_camera_camera_construct(
+    esp32_camera_camera_obj_t *self,
+    uint8_t data_pins[8],
+    const mcu_pin_obj_t *external_clock_pin,
+    const mcu_pin_obj_t *pixel_clock_pin,
+    const mcu_pin_obj_t *vsync_pin,
+    const mcu_pin_obj_t *href_pin,
+    const mcu_pin_obj_t *powerdown_pin,
+    const mcu_pin_obj_t *reset_pin,
+    const busio_i2c_obj_t *i2c,
+    mp_int_t external_clock_frequency,
+    pixformat_t pixel_format,
+    framesize_t frame_size,
+    mp_int_t jpeg_quality,
+    mp_int_t framebuffer_count,
+    camera_grab_mode_t grab_mode);
+
+extern void common_hal_esp32_camera_camera_deinit(esp32_camera_camera_obj_t *self);
+extern bool common_hal_esp32_camera_camera_deinited(esp32_camera_camera_obj_t *self);
+extern bool common_hal_esp32_camera_camera_available(esp32_camera_camera_obj_t *self);
+extern camera_fb_t *common_hal_esp32_camera_camera_take(esp32_camera_camera_obj_t *self, int timeout_ms);
+extern void common_hal_esp32_camera_camera_reconfigure(esp32_camera_camera_obj_t *self, framesize_t frame_size, pixformat_t pixel_format, camera_grab_mode_t grab_mode, mp_int_t framebuffer_count);
+
+#define DECLARE_SENSOR_GETSET(type, name, field_name, setter_function_name) \
+    DECLARE_SENSOR_GET(type, name, field_name, setter_function_name) \
+    DECLARE_SENSOR_SET(type, name, setter_function_name)
+
+#define DECLARE_SENSOR_STATUS_GETSET(type, name, status_field_name, setter_function_name) \
+    DECLARE_SENSOR_GETSET(type, name, status.status_field_name, setter_function_name)
+
+#define DECLARE_SENSOR_STATUS_GET(type, name, status_field_name, setter_function_name) \
+    DECLARE_SENSOR_GET(type, name, status.status_field_name, setter_function_name)
+
+#define DECLARE_SENSOR_GET(type, name, status_field_name, setter_function_name) \
+    extern type common_hal_esp32_camera_camera_get_##name(esp32_camera_camera_obj_t * self);
+
+#define DECLARE_SENSOR_SET(type, name, setter_function_name) \
+    extern void common_hal_esp32_camera_camera_set_##name(esp32_camera_camera_obj_t * self, type value);
+
+DECLARE_SENSOR_GET(pixformat_t, pixel_format, pixformat, set_pixformat)
+DECLARE_SENSOR_STATUS_GET(framesize_t, frame_size, framesize, set_framesize)
+DECLARE_SENSOR_STATUS_GETSET(int, contrast, contrast, set_contrast);
+DECLARE_SENSOR_STATUS_GETSET(int, brightness, brightness, set_brightness);
+DECLARE_SENSOR_STATUS_GETSET(int, saturation, saturation, set_saturation);
+DECLARE_SENSOR_STATUS_GETSET(int, sharpness, sharpness, set_sharpness);
+DECLARE_SENSOR_STATUS_GETSET(int, denoise, denoise, set_denoise);
+DECLARE_SENSOR_STATUS_GETSET(gainceiling_t, gainceiling, gainceiling, set_gainceiling);
+DECLARE_SENSOR_STATUS_GETSET(int, quality, quality, set_quality);
+DECLARE_SENSOR_STATUS_GETSET(bool, colorbar, colorbar, set_colorbar);
+DECLARE_SENSOR_STATUS_GETSET(bool, whitebal, whitebal, set_whitebal);
+DECLARE_SENSOR_STATUS_GETSET(bool, gain_ctrl, gain_ctrl, set_gain_ctrl);
+DECLARE_SENSOR_STATUS_GETSET(bool, exposure_ctrl, exposure_ctrl, set_exposure_ctrl);
+DECLARE_SENSOR_STATUS_GETSET(bool, hmirror, hmirror, set_hmirror);
+DECLARE_SENSOR_STATUS_GETSET(bool, vflip, vflip, set_vflip);
+DECLARE_SENSOR_STATUS_GETSET(bool, aec2, aec2, set_aec2);
+DECLARE_SENSOR_STATUS_GETSET(bool, awb_gain, awb_gain, set_awb_gain);
+DECLARE_SENSOR_STATUS_GETSET(int, agc_gain, agc_gain, set_agc_gain);
+DECLARE_SENSOR_STATUS_GETSET(int, aec_value, aec_value, set_aec_value);
+DECLARE_SENSOR_STATUS_GETSET(int, special_effect, special_effect, set_special_effect);
+DECLARE_SENSOR_STATUS_GETSET(int, wb_mode, wb_mode, set_wb_mode);
+DECLARE_SENSOR_STATUS_GETSET(int, ae_level, ae_level, set_ae_level);
+DECLARE_SENSOR_STATUS_GETSET(bool, dcw, dcw, set_dcw);
+DECLARE_SENSOR_STATUS_GETSET(bool, bpc, bpc, set_bpc);
+DECLARE_SENSOR_STATUS_GETSET(bool, wpc, wpc, set_wpc);
+DECLARE_SENSOR_STATUS_GETSET(bool, raw_gma, raw_gma, set_raw_gma);
+DECLARE_SENSOR_STATUS_GETSET(bool, lenc, lenc, set_lenc);
+
+// From settings
+extern camera_grab_mode_t common_hal_esp32_camera_camera_get_grab_mode(esp32_camera_camera_obj_t *self);
+extern int common_hal_esp32_camera_camera_get_framebuffer_count(esp32_camera_camera_obj_t *self);
+
+// From camera_sensor_info_t
+extern int common_hal_esp32_camera_camera_get_address(esp32_camera_camera_obj_t *self);
+extern const char *common_hal_esp32_camera_camera_get_sensor_name(esp32_camera_camera_obj_t *self);
+extern const bool common_hal_esp32_camera_camera_get_supports_jpeg(esp32_camera_camera_obj_t *self);
+extern framesize_t common_hal_esp32_camera_camera_get_max_frame_size(esp32_camera_camera_obj_t *self);
+extern int common_hal_esp32_camera_camera_get_width(esp32_camera_camera_obj_t *self);
+extern int common_hal_esp32_camera_camera_get_height(esp32_camera_camera_obj_t *self);

ports/espressif/bindings/esp32_camera/__init__.c

@@ -0,0 +1,287 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 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 "py/obj.h"
+#include "py/runtime.h"
+#include "py/mphal.h"
+
+#include "bindings/espidf/__init__.h"
+#include "bindings/esp32_camera/__init__.h"
+#include "bindings/esp32_camera/Camera.h"
+
+#include "esp_camera.h"
+#include "sensor.h"
+
+//| """Wrapper for the esp32_camera library
+//|
+//| This library enables access to any camera sensor supported by the library,
+//| including OV5640 and OV2640.
+//|
+//| .. seealso::
+//|
+//|     Non-Espressif microcontrollers use the `imagecapture` module together with wrapper libraries such as `adafruit_ov5640 <https://circuitpython.readthedocs.io/projects/ov5640/en/latest/>`_.
+//|
+//| """
+
+//| class GrabMode:
+//|     """Controls when a new frame is grabbed."""
+//|
+//|     WHEN_EMPTY: GrabMode
+//|     """Fills buffers when they are empty. Less resources but first ``fb_count`` frames might be old"""
+//|
+//|     LATEST: GrabMode
+//|     """Except when 1 frame buffer is used, queue will always contain the last ``fb_count`` frames"""
+//|
+
+MAKE_ENUM_VALUE(esp32_camera_grab_mode_type, grab_mode, WHEN_EMPTY, CAMERA_GRAB_WHEN_EMPTY);
+MAKE_ENUM_VALUE(esp32_camera_grab_mode_type, grab_mode, LATEST, CAMERA_GRAB_LATEST);
+
+MAKE_ENUM_MAP(esp32_camera_grab_mode) {
+    MAKE_ENUM_MAP_ENTRY(grab_mode, WHEN_EMPTY),
+    MAKE_ENUM_MAP_ENTRY(grab_mode, LATEST),
+};
+
+STATIC MP_DEFINE_CONST_DICT(esp32_camera_grab_mode_locals_dict, esp32_camera_grab_mode_locals_table);
+MAKE_PRINTER(esp32_camera, esp32_camera_grab_mode);
+MAKE_ENUM_TYPE(esp32_camera, GrabMode, esp32_camera_grab_mode);
+
+camera_grab_mode_t validate_grab_mode(mp_obj_t obj, qstr arg_name) {
+    return cp_enum_value(&esp32_camera_grab_mode_type, mp_arg_validate_type(obj, &esp32_camera_grab_mode_type, arg_name));
+}
+
+//| class PixelFormat:
+//|     """Format of data in the captured frames"""
+//|
+//|     RGB565: PixelFormat
+//|     """A 16-bit format with 5 bits of Red and Blue and 6 bits of Green"""
+//|
+//|     GRAYSCALE: PixelFormat
+//|     """An 8-bit format with 8-bits of luminance"""
+//|
+//|     JPEG: PixelFormat
+//|     """A compressed format"""
+//|
+
+MAKE_ENUM_VALUE(esp32_camera_pixel_format_type, pixel_format, RGB565, PIXFORMAT_RGB565);
+MAKE_ENUM_VALUE(esp32_camera_pixel_format_type, pixel_format, GRAYSCALE, PIXFORMAT_GRAYSCALE);
+MAKE_ENUM_VALUE(esp32_camera_pixel_format_type, pixel_format, JPEG, PIXFORMAT_JPEG);
+
+MAKE_ENUM_MAP(esp32_camera_pixel_format) {
+    MAKE_ENUM_MAP_ENTRY(pixel_format, RGB565),
+    MAKE_ENUM_MAP_ENTRY(pixel_format, GRAYSCALE),
+    MAKE_ENUM_MAP_ENTRY(pixel_format, JPEG),
+};
+
+STATIC MP_DEFINE_CONST_DICT(esp32_camera_pixel_format_locals_dict, esp32_camera_pixel_format_locals_table);
+MAKE_PRINTER(esp32_camera, esp32_camera_pixel_format);
+MAKE_ENUM_TYPE(esp32_camera, PixelFormat, esp32_camera_pixel_format);
+
+pixformat_t validate_pixel_format(mp_obj_t obj, qstr arg_name) {
+    return cp_enum_value(&esp32_camera_pixel_format_type, mp_arg_validate_type(obj, &esp32_camera_pixel_format_type, arg_name));
+}
+
+//| class FrameSize:
+//|     """The pixel size of the captured frames"""
+//|
+//|     R96X96: FrameSize
+//|     """96x96"""
+//|
+//|     QQVGA: FrameSize
+//|     """160x120"""
+//|
+//|     QCIF: FrameSize
+//|     """176x144"""
+//|
+//|     HQVGA: FrameSize
+//|     """240x176"""
+//|
+//|     R240X240: FrameSize
+//|     """240x240"""
+//|
+//|     QVGA: FrameSize
+//|     """320x240 """
+//|
+//|     CIF: FrameSize
+//|     """400x296"""
+//|
+//|     HVGA: FrameSize
+//|     """480x320"""
+//|
+//|     VGA: FrameSize
+//|     """640x480"""
+//|
+//|     SVGA: FrameSize
+//|     """800x600"""
+//|
+//|     XGA: FrameSize
+//|     """1024x768"""
+//|
+//|     HD: FrameSize
+//|     """1280x720"""
+//|
+//|     SXGA: FrameSize
+//|     """1280x1024"""
+//|
+//|     UXGA: FrameSize
+//|     """1600x1200"""
+//|
+//|     FHD: FrameSize
+//|     """1920x1080"""
+//|
+//|     P_HD: FrameSize
+//|     """ 720x1280"""
+//|
+//|     P_3MP: FrameSize
+//|     """ 864x1536"""
+//|
+//|     QXGA: FrameSize
+//|     """2048x1536"""
+//|
+//|     QHD: FrameSize
+//|     """2560x1440"""
+//|
+//|     WQXGA: FrameSize
+//|     """2560x1600"""
+//|
+//|     P_FHD: FrameSize
+//|     """1080x1920"""
+//|
+//|     QSXGA: FrameSize
+//|     """2560x1920"""
+//|
+
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, R96X96, FRAMESIZE_96X96);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, R240X240, FRAMESIZE_240X240);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, QQVGA, FRAMESIZE_QQVGA);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, QCIF, FRAMESIZE_QCIF);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, HQVGA, FRAMESIZE_HQVGA);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, QVGA, FRAMESIZE_QVGA);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, CIF, FRAMESIZE_CIF);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, HVGA, FRAMESIZE_HVGA);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, VGA, FRAMESIZE_VGA);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, SVGA, FRAMESIZE_SVGA);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, XGA, FRAMESIZE_XGA);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, HD, FRAMESIZE_HD);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, SXGA, FRAMESIZE_SXGA);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, UXGA, FRAMESIZE_UXGA);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, FHD, FRAMESIZE_FHD);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, P_HD, FRAMESIZE_P_HD);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, P_3MP, FRAMESIZE_P_3MP);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, QXGA, FRAMESIZE_QXGA);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, QHD, FRAMESIZE_QHD);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, WQXGA, FRAMESIZE_WQXGA);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, P_FHD, FRAMESIZE_P_FHD);
+MAKE_ENUM_VALUE(esp32_camera_frame_size_type, frame_size, QSXGA, FRAMESIZE_QSXGA);
+MAKE_ENUM_MAP(esp32_camera_frame_size) {
+    MAKE_ENUM_MAP_ENTRY(frame_size, R96X96),
+    MAKE_ENUM_MAP_ENTRY(frame_size, R240X240),
+    MAKE_ENUM_MAP_ENTRY(frame_size, QQVGA),
+    MAKE_ENUM_MAP_ENTRY(frame_size, QCIF),
+    MAKE_ENUM_MAP_ENTRY(frame_size, HQVGA),
+    MAKE_ENUM_MAP_ENTRY(frame_size, QVGA),
+    MAKE_ENUM_MAP_ENTRY(frame_size, CIF),
+    MAKE_ENUM_MAP_ENTRY(frame_size, HVGA),
+    MAKE_ENUM_MAP_ENTRY(frame_size, VGA),
+    MAKE_ENUM_MAP_ENTRY(frame_size, SVGA),
+    MAKE_ENUM_MAP_ENTRY(frame_size, XGA),
+    MAKE_ENUM_MAP_ENTRY(frame_size, HD),
+    MAKE_ENUM_MAP_ENTRY(frame_size, SXGA),
+    MAKE_ENUM_MAP_ENTRY(frame_size, UXGA),
+    MAKE_ENUM_MAP_ENTRY(frame_size, FHD),
+    MAKE_ENUM_MAP_ENTRY(frame_size, P_HD),
+    MAKE_ENUM_MAP_ENTRY(frame_size, P_3MP),
+    MAKE_ENUM_MAP_ENTRY(frame_size, QXGA),
+    MAKE_ENUM_MAP_ENTRY(frame_size, QHD),
+    MAKE_ENUM_MAP_ENTRY(frame_size, WQXGA),
+    MAKE_ENUM_MAP_ENTRY(frame_size, P_FHD),
+    MAKE_ENUM_MAP_ENTRY(frame_size, QSXGA),
+};
+
+STATIC MP_DEFINE_CONST_DICT(esp32_camera_frame_size_locals_dict, esp32_camera_frame_size_locals_table);
+MAKE_PRINTER(esp32_camera, esp32_camera_frame_size);
+MAKE_ENUM_TYPE(esp32_camera, FrameSize, esp32_camera_frame_size);
+
+framesize_t validate_frame_size(mp_obj_t obj, qstr arg_name) {
+    return cp_enum_value(&esp32_camera_frame_size_type, mp_arg_validate_type(obj, &esp32_camera_frame_size_type, arg_name));
+}
+
+//| class GainCeiling:
+//|     """The maximum amount of gain applied to raw sensor data.
+//|
+//|     Higher values are useful in darker conditions, but increase image noise."""
+//|
+//|     GAIN_2X: GainCeiling
+//|     GAIN_4X: GainCeiling
+//|     GAIN_8X: GainCeiling
+//|     GAIN_16X: GainCeiling
+//|     GAIN_32X: GainCeiling
+//|     GAIN_64X: GainCeiling
+//|     GAIN_128X: GainCeiling
+//|
+
+MAKE_ENUM_VALUE(esp32_camera_gain_ceiling_type, gain_ceiling, GAIN_2X, GAINCEILING_2X);
+MAKE_ENUM_VALUE(esp32_camera_gain_ceiling_type, gain_ceiling, GAIN_4X, GAINCEILING_4X);
+MAKE_ENUM_VALUE(esp32_camera_gain_ceiling_type, gain_ceiling, GAIN_8X, GAINCEILING_8X);
+MAKE_ENUM_VALUE(esp32_camera_gain_ceiling_type, gain_ceiling, GAIN_16X, GAINCEILING_16X);
+MAKE_ENUM_VALUE(esp32_camera_gain_ceiling_type, gain_ceiling, GAIN_32X, GAINCEILING_32X);
+MAKE_ENUM_VALUE(esp32_camera_gain_ceiling_type, gain_ceiling, GAIN_64X, GAINCEILING_64X);
+MAKE_ENUM_VALUE(esp32_camera_gain_ceiling_type, gain_ceiling, GAIN_128X, GAINCEILING_128X);
+
+MAKE_ENUM_MAP(esp32_camera_gain_ceiling) {
+    MAKE_ENUM_MAP_ENTRY(gain_ceiling, GAIN_2X),
+    MAKE_ENUM_MAP_ENTRY(gain_ceiling, GAIN_4X),
+    MAKE_ENUM_MAP_ENTRY(gain_ceiling, GAIN_8X),
+    MAKE_ENUM_MAP_ENTRY(gain_ceiling, GAIN_16X),
+    MAKE_ENUM_MAP_ENTRY(gain_ceiling, GAIN_32X),
+    MAKE_ENUM_MAP_ENTRY(gain_ceiling, GAIN_64X),
+    MAKE_ENUM_MAP_ENTRY(gain_ceiling, GAIN_128X)
+};
+
+STATIC MP_DEFINE_CONST_DICT(esp32_camera_gain_ceiling_locals_dict, esp32_camera_gain_ceiling_locals_table);
+MAKE_PRINTER(esp32_camera, esp32_camera_gain_ceiling);
+MAKE_ENUM_TYPE(esp32_camera, GainCeiling, esp32_camera_gain_ceiling);
+
+gainceiling_t validate_gain_ceiling(mp_obj_t obj, qstr arg_name) {
+    return cp_enum_value(&esp32_camera_gain_ceiling_type, mp_arg_validate_type(obj, &esp32_camera_gain_ceiling_type, arg_name));
+}
+
+STATIC const mp_rom_map_elem_t esp32_camera_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_esp32_camera) },
+    { MP_ROM_QSTR(MP_QSTR_Camera), MP_ROM_PTR(&esp32_camera_camera_type), },
+    { MP_ROM_QSTR(MP_QSTR_FrameSize), &esp32_camera_frame_size_type },
+    { MP_ROM_QSTR(MP_QSTR_GainCeiling), &esp32_camera_gain_ceiling_type },
+    { MP_ROM_QSTR(MP_QSTR_GrabMode), &esp32_camera_grab_mode_type },
+    { MP_ROM_QSTR(MP_QSTR_PixelFormat), &esp32_camera_pixel_format_type },
+};
+
+STATIC MP_DEFINE_CONST_DICT(esp32_camera_module_globals, esp32_camera_module_globals_table);
+
+const mp_obj_module_t esp32_camera_module = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&esp32_camera_module_globals,
+};
+
+MP_REGISTER_MODULE(MP_QSTR_esp32_camera, esp32_camera_module, CIRCUITPY_ESP32_CAMERA);

ports/espressif/bindings/esp32_camera/__init__.h

@@ -0,0 +1,45 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 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/enum.h"
+#include "py/obj.h"
+
+#include "esp_camera.h"
+
+extern const mp_obj_type_t esp32_camera_grab_mode_type;
+extern const cp_enum_obj_t grab_mode_WHEN_EMPTY_obj;
+extern const mp_obj_type_t esp32_camera_pixel_format_type;
+extern const cp_enum_obj_t pixel_format_RGB565_obj;
+extern const mp_obj_type_t esp32_camera_frame_size_type;
+extern const cp_enum_obj_t frame_size_QQVGA_obj;
+extern const mp_obj_type_t esp32_camera_gain_ceiling_type;
+
+extern camera_grab_mode_t validate_grab_mode(mp_obj_t obj, qstr arg_name);
+extern pixformat_t validate_pixel_format(mp_obj_t obj, qstr arg_name);
+extern framesize_t validate_frame_size(mp_obj_t obj, qstr arg_name);
+extern gainceiling_t validate_gain_ceiling(mp_obj_t obj, qstr arg_name);

ports/espressif/boards/adafruit_feather_esp32s3_4mbflash_2mbpsram/mpconfigboard.mk

@@ -17,3 +17,4 @@ CIRCUITPY_ESP_FLASH_FREQ = 40m
 CIRCUITPY_ESP_FLASH_SIZE = 4MB
 
 OPTIMIZATION_FLAGS = -Os
+CIRCUITPY_ESP32_CAMERA = 0

ports/espressif/boards/adafruit_feather_esp32s3_tft/mpconfigboard.mk

@@ -18,3 +18,4 @@ CIRCUITPY_ESP_FLASH_FREQ = 40m
 CIRCUITPY_ESP_FLASH_SIZE = 4MB
 
 OPTIMIZATION_FLAGS = -Os
+CIRCUITPY_ESP32_CAMERA = 0

ports/espressif/boards/adafruit_funhouse/mpconfigboard.mk

@@ -16,6 +16,8 @@ CIRCUITPY_ESP_FLASH_MODE = dio
 CIRCUITPY_ESP_FLASH_FREQ = 40m
 CIRCUITPY_ESP_FLASH_SIZE = 4MB
 
+CIRCUITPY_ESP32_CAMERA = 0
+
 # Include these Python libraries in firmware.
 FROZEN_MPY_DIRS += $(TOP)/frozen/Adafruit_CircuitPython_PortalBase
 FROZEN_MPY_DIRS += $(TOP)/frozen/Adafruit_CircuitPython_FakeRequests

ports/espressif/boards/adafruit_magtag_2.9_grayscale/mpconfigboard.mk

@@ -16,6 +16,8 @@ CIRCUITPY_ESP_FLASH_MODE = dio
 CIRCUITPY_ESP_FLASH_FREQ = 40m
 CIRCUITPY_ESP_FLASH_SIZE = 4MB
 
+CIRCUITPY_ESP32_CAMERA = 0
+
 # Include these Python libraries in firmware.
 FROZEN_MPY_DIRS += $(TOP)/frozen/Adafruit_CircuitPython_PortalBase
 FROZEN_MPY_DIRS += $(TOP)/frozen/Adafruit_CircuitPython_FakeRequests

ports/espressif/boards/espressif_esp32_eye/board.c

@@ -0,0 +1,46 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft 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 "supervisor/board.h"
+#include "mpconfigboard.h"
+#include "shared-bindings/microcontroller/Pin.h"
+#include "components/driver/include/driver/gpio.h"
+#include "components/hal/include/hal/gpio_hal.h"
+#include "common-hal/microcontroller/Pin.h"
+
+void board_init(void) {
+    reset_board();
+}
+
+bool board_requests_safe_mode(void) {
+    return false;
+}
+
+void reset_board(void) {
+}
+
+void board_deinit(void) {
+}

ports/espressif/boards/espressif_esp32_eye/mpconfigboard.h

@@ -0,0 +1,39 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 Dan Halbert 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.
+ */
+
+// Micropython setup
+
+#define MICROPY_HW_BOARD_NAME       "Espressif ESP32-EYE"
+#define MICROPY_HW_MCU_NAME         "ESP32"
+
+#define CIRCUITPY_BOARD_I2C         (1)
+#define CIRCUITPY_BOARD_I2C_PIN     {{.scl = &pin_GPIO23, .sda = &pin_GPIO18}}
+
+// UART pins attached to the USB-serial converter chip
+#define CIRCUITPY_CONSOLE_UART_TX (&pin_GPIO1)
+#define CIRCUITPY_CONSOLE_UART_RX (&pin_GPIO3)
+
+#define DEFAULT_RESERVED_PSRAM      (1048576)

ports/espressif/boards/espressif_esp32_eye/mpconfigboard.mk

@@ -0,0 +1,11 @@
+CIRCUITPY_CREATOR_ID =  0x000C303A
+CIRCUITPY_CREATION_ID = 0x00320001
+
+IDF_TARGET = esp32
+
+INTERNAL_FLASH_FILESYSTEM = 1
+LONGINT_IMPL = MPZ
+
+CIRCUITPY_ESP_FLASH_MODE = dio
+CIRCUITPY_ESP_FLASH_FREQ = 40m
+CIRCUITPY_ESP_FLASH_SIZE = 4MB

ports/espressif/boards/espressif_esp32_eye/pins.c

@@ -0,0 +1,40 @@
+#include "py/objtuple.h"
+#include "shared-bindings/board/__init__.h"
+
+STATIC const mp_rom_obj_tuple_t camera_data_tuple = {
+    {&mp_type_tuple},
+    8,
+    {
+        MP_ROM_PTR(&pin_GPIO34),
+        MP_ROM_PTR(&pin_GPIO13),
+        MP_ROM_PTR(&pin_GPIO14),
+        MP_ROM_PTR(&pin_GPIO35),
+        MP_ROM_PTR(&pin_GPIO39), // "S_VN"
+        MP_ROM_PTR(&pin_GPIO38),
+        MP_ROM_PTR(&pin_GPIO37),
+        MP_ROM_PTR(&pin_GPIO36), // "S_VP"
+    }
+};
+
+STATIC const mp_rom_map_elem_t board_module_globals_table[] = {
+    CIRCUITPYTHON_BOARD_DICT_STANDARD_ITEMS
+
+    { MP_ROM_QSTR(MP_QSTR_I2S_SCK), MP_ROM_PTR(&pin_GPIO26) },
+    { MP_ROM_QSTR(MP_QSTR_I2S_WS), MP_ROM_PTR(&pin_GPIO32) },
+    { MP_ROM_QSTR(MP_QSTR_I2S_SDO), MP_ROM_PTR(&pin_GPIO32) },
+
+    { MP_ROM_QSTR(MP_QSTR_BOOT), MP_ROM_PTR(&pin_GPIO0) },
+    { MP_ROM_QSTR(MP_QSTR_BUTTON), MP_ROM_PTR(&pin_GPIO15) },
+
+    { MP_ROM_QSTR(MP_QSTR_LED_RED), MP_ROM_PTR(&pin_GPIO21) },
+    { MP_ROM_QSTR(MP_QSTR_LED_WHITE), MP_ROM_PTR(&pin_GPIO22) },
+
+    { MP_ROM_QSTR(MP_QSTR_I2C), MP_ROM_PTR(&board_i2c_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_CAMERA_DATA), MP_ROM_PTR(&camera_data_tuple) },
+    { MP_ROM_QSTR(MP_QSTR_CAMERA_VSYNC), MP_ROM_PTR(&pin_GPIO5) },
+    { MP_ROM_QSTR(MP_QSTR_CAMERA_HREF), MP_ROM_PTR(&pin_GPIO27) },
+    { MP_ROM_QSTR(MP_QSTR_CAMERA_PCLK), MP_ROM_PTR(&pin_GPIO25) },
+    { MP_ROM_QSTR(MP_QSTR_CAMERA_XCLK), MP_ROM_PTR(&pin_GPIO4) },
+};
+MP_DEFINE_CONST_DICT(board_module_globals, board_module_globals_table);

ports/espressif/boards/espressif_esp32_eye/sdkconfig

@@ -0,0 +1,72 @@
+# Automatically generated file. DO NOT EDIT.
+# Espressif IoT Development Framework (ESP-IDF) Project Configuration
+#
+#
+# Component config
+#
+#
+# ESP32-specific
+#
+CONFIG_ESP32_SPIRAM_SUPPORT=y
+#
+# SPI RAM config
+#
+CONFIG_SPIRAM_TYPE_AUTO=y
+# CONFIG_SPIRAM_TYPE_ESPPSRAM16 is not set
+# CONFIG_SPIRAM_TYPE_ESPPSRAM32 is not set
+# CONFIG_SPIRAM_TYPE_ESPPSRAM64 is not set
+CONFIG_SPIRAM_SIZE=-1
+CONFIG_SPIRAM_SPEED_40M=y
+CONFIG_SPIRAM=y
+CONFIG_SPIRAM_BOOT_INIT=y
+CONFIG_SPIRAM_IGNORE_NOTFOUND=y
+CONFIG_SPIRAM_USE_MEMMAP=y
+# CONFIG_SPIRAM_USE_CAPS_ALLOC is not set
+# CONFIG_SPIRAM_USE_MALLOC is not set
+CONFIG_SPIRAM_MEMTEST=y
+# CONFIG_SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY is not set
+# CONFIG_SPIRAM_ALLOW_NOINIT_SEG_EXTERNAL_MEMORY is not set
+CONFIG_SPIRAM_CACHE_WORKAROUND=y
+# CONFIG_SPIRAM_BANKSWITCH_ENABLE is not set
+# end of SPI RAM config
+
+# end of ESP32-specific
+
+#
+# NVS
+#
+# CONFIG_NVS_ASSERT_ERROR_CHECK is not set
+# end of NVS
+
+#
+# Camera configuration
+#
+CONFIG_OV7670_SUPPORT=y
+CONFIG_OV7725_SUPPORT=y
+CONFIG_NT99141_SUPPORT=y
+CONFIG_OV2640_SUPPORT=y
+CONFIG_OV3660_SUPPORT=y
+CONFIG_OV5640_SUPPORT=y
+CONFIG_GC2145_SUPPORT=y
+CONFIG_GC032A_SUPPORT=y
+CONFIG_GC0308_SUPPORT=y
+CONFIG_BF3005_SUPPORT=y
+CONFIG_BF20A6_SUPPORT=y
+# CONFIG_SC101IOT_SUPPORT is not set
+CONFIG_SC030IOT_SUPPORT=y
+# CONFIG_SCCB_HARDWARE_I2C_PORT0 is not set
+CONFIG_SCCB_HARDWARE_I2C_PORT1=y
+CONFIG_SCCB_CLK_FREQ=100000
+# CONFIG_GC_SENSOR_WINDOWING_MODE is not set
+CONFIG_GC_SENSOR_SUBSAMPLE_MODE=y
+CONFIG_CAMERA_CORE0=y
+# CONFIG_CAMERA_CORE1 is not set
+# CONFIG_CAMERA_NO_AFFINITY is not set
+CONFIG_CAMERA_DMA_BUFFER_SIZE_MAX=32768
+# end of Camera configuration
+
+# end of Component config
+#
+CONFIG_ESP_CONSOLE_UART_TX_GPIO=1
+CONFIG_ESP_CONSOLE_UART_RX_GPIO=3
+

ports/espressif/boards/espressif_esp32s3_eye/board.c

@@ -0,0 +1,138 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft 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 "supervisor/board.h"
+#include "mpconfigboard.h"
+#include "shared-bindings/busio/SPI.h"
+#include "shared-bindings/displayio/FourWire.h"
+#include "shared-bindings/microcontroller/Pin.h"
+#include "shared-module/displayio/__init__.h"
+#include "shared-module/displayio/mipi_constants.h"
+#include "shared-bindings/board/__init__.h"
+
+displayio_fourwire_obj_t board_display_obj;
+
+#define DELAY 0x80
+
+// display init sequence according to LilyGO example app
+uint8_t display_init_sequence[] = {
+    // sw reset
+    0x01, 0 | DELAY, 150,
+    // sleep out
+    0x11, 0 | DELAY, 255,
+    // normal display mode on
+    0x13, 0,
+    // display and color format settings
+    0x36, 1, 0x08,
+    0xB6, 2, 0x0A, 0x82,
+    0x3A, 1 | DELAY,  0x55, 10,
+    // ST7789V frame rate setting
+    0xB2, 5, 0x0C, 0x0C, 0x00, 0x33, 0x33,
+    // voltages: VGH / VGL
+    0xB7, 1, 0x35,
+    // ST7789V power setting
+    0xBB, 1, 0x28,
+    0xC0, 1, 0x0C,
+    0xC2, 2, 0x01, 0xFF,
+    0xC3, 1, 0x10,
+    0xC4, 1, 0x20,
+    0xC6, 1, 0x0F,
+    0xD0, 2, 0xA4, 0xA1,
+    // ST7789V gamma setting
+    0xE0, 14, 0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x32, 0x44, 0x42, 0x06, 0x0E, 0x12, 0x14, 0x17,
+    0xE1, 14, 0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x31, 0x54, 0x47, 0x0E, 0x1C, 0x17, 0x1B, 0x1E,
+    0x21, 0,
+    // display on
+    0x29, 0 | DELAY, 255,
+};
+
+void board_init(void) {
+    busio_spi_obj_t *spi = common_hal_board_create_spi(0);
+    displayio_fourwire_obj_t *bus = &displays[0].fourwire_bus;
+    bus->base.type = &displayio_fourwire_type;
+
+    common_hal_displayio_fourwire_construct(
+        bus,
+        spi,
+        &pin_GPIO43,    // DC
+        &pin_GPIO44,    // CS
+        NULL,           // no reset pin
+        40000000,       // baudrate
+        0,              // polarity
+        0               // phase
+        );
+    displayio_display_obj_t *display = &displays[0].display;
+    display->base.type = &displayio_display_type;
+
+    // workaround as board_init() is called before reset_port() in main.c
+    pwmout_reset();
+
+    common_hal_displayio_display_construct(
+        display,
+        bus,
+        240,            // width (after rotation)
+        240,            // height (after rotation)
+        0,              // column start
+        0,              // row start
+        0,              // rotation
+        16,             // color depth
+        false,          // grayscale
+        false,          // pixels in a byte share a row. Only valid for depths < 8
+        1,              // bytes per cell. Only valid for depths < 8
+        false,          // reverse_pixels_in_byte. Only valid for depths < 8
+        true,           // reverse_pixels_in_word
+        MIPI_COMMAND_SET_COLUMN_ADDRESS, // set column command
+        MIPI_COMMAND_SET_PAGE_ADDRESS,   // set row command
+        MIPI_COMMAND_WRITE_MEMORY_START, // write memory command
+        display_init_sequence,
+        sizeof(display_init_sequence),
+        &pin_GPIO48,    // backlight pin
+        NO_BRIGHTNESS_COMMAND,
+        1.0f,           // brightness (ignored)
+        false,          // auto_brightness
+        false,          // single_byte_bounds
+        false,          // data_as_commands
+        true,           // auto_refresh
+        60,             // native_frames_per_second
+        false,          // backlight_on_high
+        false,          // SH1107_addressing
+        50000           // backlight pwm frequency
+        );
+
+    common_hal_never_reset_pin(&pin_GPIO48); // backlight pin
+    // Debug UART
+}
+
+bool board_requests_safe_mode(void) {
+    return false;
+}
+
+void reset_board(void) {
+
+}
+
+void board_deinit(void) {
+}

ports/espressif/boards/espressif_esp32s3_eye/mpconfigboard.h

@@ -0,0 +1,47 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Scott Shawcroft 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.
+ */
+
+// Micropython setup
+
+#define MICROPY_HW_BOARD_NAME       "ESP32-S3-EYE"
+#define MICROPY_HW_MCU_NAME         "ESP32S3"
+
+// Shared by the camera and accelerometer
+#define DEFAULT_I2C_BUS_SDA         (&pin_GPIO4)
+#define DEFAULT_I2C_BUS_SCL         (&pin_GPIO5)
+
+// This is the SD card connection, not the LCD
+#define DEFAULT_SPI_BUS_SCK         (&pin_GPIO39)
+#define DEFAULT_SPI_BUS_MISO        (&pin_GPIO40)
+#define DEFAULT_SPI_BUS_MOSI        (&pin_GPIO38)
+
+#define CIRCUITPY_BOARD_SPI         (2)
+#define CIRCUITPY_BOARD_SPI_PIN     { \
+        {.clock = &pin_GPIO21, .mosi = &pin_GPIO47, .miso = NULL}, \
+        {.clock = &pin_GPIO39, .mosi = &pin_GPIO40, .miso = &pin_GPIO38}, \
+}
+
+#define DEFAULT_RESERVED_PSRAM      (1048576)

ports/espressif/boards/espressif_esp32s3_eye/mpconfigboard.mk

@@ -0,0 +1,17 @@
+USB_VID = 0x303A
+USB_PID = 0x700F
+USB_PRODUCT = "ESP32-S3-EYE"
+USB_MANUFACTURER = "Espressif"
+
+IDF_TARGET = esp32s3
+
+INTERNAL_FLASH_FILESYSTEM = 1
+LONGINT_IMPL = MPZ
+
+# The default queue depth of 16 overflows on release builds,
+# so increase it to 32.
+CFLAGS += -DCFG_TUD_TASK_QUEUE_SZ=32
+
+CIRCUITPY_ESP_FLASH_MODE = dio
+CIRCUITPY_ESP_FLASH_FREQ = 80m
+CIRCUITPY_ESP_FLASH_SIZE = 8MB

ports/espressif/boards/espressif_esp32s3_eye/pins.c

@@ -0,0 +1,56 @@
+#include "py/objtuple.h"
+#include "shared-bindings/board/__init__.h"
+#include "shared-module/displayio/__init__.h"
+
+STATIC const mp_rom_obj_tuple_t camera_data_tuple = {
+    {&mp_type_tuple},
+    8,
+    {
+        MP_ROM_PTR(&pin_GPIO11),
+        MP_ROM_PTR(&pin_GPIO9),
+        MP_ROM_PTR(&pin_GPIO8),
+        MP_ROM_PTR(&pin_GPIO10),
+        MP_ROM_PTR(&pin_GPIO12),
+        MP_ROM_PTR(&pin_GPIO18),
+        MP_ROM_PTR(&pin_GPIO17),
+        MP_ROM_PTR(&pin_GPIO16),
+    }
+};
+
+
+STATIC const mp_rom_map_elem_t board_module_globals_table[] = {
+    CIRCUITPYTHON_BOARD_DICT_STANDARD_ITEMS
+
+    { MP_ROM_QSTR(MP_QSTR_BOOT), MP_ROM_PTR(&pin_GPIO0) },
+    { MP_ROM_QSTR(MP_QSTR_BUTTONS), MP_ROM_PTR(&pin_GPIO1) },
+    { MP_ROM_QSTR(MP_QSTR_MIC_SDO), MP_ROM_PTR(&pin_GPIO2) },
+    { MP_ROM_QSTR(MP_QSTR_IO3), MP_ROM_PTR(&pin_GPIO3) }, // LCD
+    { MP_ROM_QSTR(MP_QSTR_SDA), MP_ROM_PTR(&pin_GPIO4) },
+    { MP_ROM_QSTR(MP_QSTR_SCL), MP_ROM_PTR(&pin_GPIO5) },
+    { MP_ROM_QSTR(MP_QSTR_CAMERA_DATA), MP_ROM_PTR(&camera_data_tuple) },
+    { MP_ROM_QSTR(MP_QSTR_CAMERA_VSYNC), MP_ROM_PTR(&pin_GPIO6) },
+    { MP_ROM_QSTR(MP_QSTR_CAMERA_HREF), MP_ROM_PTR(&pin_GPIO7) },
+    { MP_ROM_QSTR(MP_QSTR_CAMERA_PCLK), MP_ROM_PTR(&pin_GPIO13) },
+    { MP_ROM_QSTR(MP_QSTR_BATTERY), MP_ROM_PTR(&pin_GPIO14) },
+    { MP_ROM_QSTR(MP_QSTR_CAMERA_XCLK), MP_ROM_PTR(&pin_GPIO15) },
+
+    { MP_ROM_QSTR(MP_QSTR_MOSI), MP_ROM_PTR(&pin_GPIO47) },
+    { MP_ROM_QSTR(MP_QSTR_SCK), MP_ROM_PTR(&pin_GPIO21) },
+
+    { MP_ROM_QSTR(MP_QSTR_MISO1), MP_ROM_PTR(&pin_GPIO40) },
+    { MP_ROM_QSTR(MP_QSTR_MOSI1), MP_ROM_PTR(&pin_GPIO38) },
+    { MP_ROM_QSTR(MP_QSTR_SCK1), MP_ROM_PTR(&pin_GPIO39) },
+
+    { MP_ROM_QSTR(MP_QSTR_MIC_SCK), MP_ROM_PTR(&pin_GPIO41) },
+    { MP_ROM_QSTR(MP_QSTR_MIC_WS), MP_ROM_PTR(&pin_GPIO42) },
+    { MP_ROM_QSTR(MP_QSTR_LCD_DC), MP_ROM_PTR(&pin_GPIO43) },
+    { MP_ROM_QSTR(MP_QSTR_LCD_CS), MP_ROM_PTR(&pin_GPIO44) },
+    { MP_ROM_QSTR(MP_QSTR_BACKLIGHT), MP_ROM_PTR(&pin_GPIO48) },
+    { MP_ROM_QSTR(MP_QSTR_NEOPIXEL), MP_ROM_PTR(&pin_GPIO48) },
+
+    { MP_ROM_QSTR(MP_QSTR_I2C), MP_ROM_PTR(&board_i2c_obj) },
+    { MP_ROM_QSTR(MP_QSTR_SPI), MP_ROM_PTR(&board_spi_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_DISPLAY), MP_ROM_PTR(&displays[0].display)},
+};
+MP_DEFINE_CONST_DICT(board_module_globals, board_module_globals_table);

ports/espressif/boards/espressif_esp32s3_eye/sdkconfig

@@ -0,0 +1,34 @@
+CONFIG_ESP32S3_SPIRAM_SUPPORT=y
+#
+# SPI RAM config
+#
+# CONFIG_SPIRAM_MODE_QUAD is not set
+CONFIG_SPIRAM_MODE_OCT=y
+# CONFIG_SPIRAM_TYPE_AUTO is not set
+CONFIG_SPIRAM_TYPE_ESPPSRAM64=y
+CONFIG_SPIRAM_SIZE=8388608
+# end of SPI RAM config
+
+CONFIG_DEFAULT_PSRAM_CLK_IO=30
+#
+# PSRAM Clock and CS IO for ESP32S3
+#
+CONFIG_DEFAULT_PSRAM_CS_IO=26
+# end of PSRAM Clock and CS IO for ESP32S3
+
+# CONFIG_SPIRAM_FETCH_INSTRUCTIONS is not set
+# CONFIG_SPIRAM_RODATA is not set
+CONFIG_SPIRAM_SPEED_80M=y
+# CONFIG_SPIRAM_SPEED_40M is not set
+CONFIG_SPIRAM=y
+CONFIG_SPIRAM_BOOT_INIT=y
+# CONFIG_SPIRAM_IGNORE_NOTFOUND is not set
+CONFIG_SPIRAM_USE_MEMMAP=y
+# CONFIG_SPIRAM_USE_CAPS_ALLOC is not set
+# CONFIG_SPIRAM_USE_MALLOC is not set
+CONFIG_SPIRAM_MEMTEST=y
+#
+# LWIP
+#
+CONFIG_LWIP_LOCAL_HOSTNAME="espressif-esp32s3-eye"
+# end of LWIP

ports/espressif/boards/espressif_kaluga_1.3/mpconfigboard.h

@@ -30,3 +30,6 @@
 #define MICROPY_HW_MCU_NAME         "ESP32S2"
 
 #define MICROPY_HW_NEOPIXEL (&pin_GPIO45)
+
+#define DEFAULT_I2C_BUS_SCL (&pin_GPIO7)
+#define DEFAULT_I2C_BUS_SDA (&pin_GPIO8)

ports/espressif/boards/espressif_kaluga_1.3/pins.c

@@ -140,5 +140,7 @@ STATIC const mp_rom_map_elem_t board_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_AUDIO_I2S1_LRCK_DAC1), MP_ROM_PTR(&pin_GPIO17) },
     { MP_ROM_QSTR(MP_QSTR_AUDIO_I2S1_BCLK_DAC2), MP_ROM_PTR(&pin_GPIO18) },
 
+    { MP_ROM_QSTR(MP_QSTR_I2C), MP_ROM_PTR(&board_i2c_obj) },
+
 };
 MP_DEFINE_CONST_DICT(board_module_globals, board_module_globals_table);

ports/espressif/boards/mixgo_ce_serial/mpconfigboard.mk

@@ -16,6 +16,8 @@ CIRCUITPY_ESP_FLASH_MODE = dio
 CIRCUITPY_ESP_FLASH_FREQ = 40m
 CIRCUITPY_ESP_FLASH_SIZE = 4MB
 
+CIRCUITPY_ESP32_CAMERA = 0
+
 FROZEN_MPY_DIRS += $(TOP)/frozen/Adafruit_CircuitPython_Requests
 FROZEN_MPY_DIRS += $(TOP)/frozen/Adafruit_CircuitPython_NeoPixel
 FROZEN_MPY_DIRS += $(TOP)/frozen/mixgo_cp_lib/mixgoce_lib

ports/espressif/boards/mixgo_ce_udisk/mpconfigboard.mk

@@ -16,6 +16,8 @@ CIRCUITPY_ESP_FLASH_MODE = dio
 CIRCUITPY_ESP_FLASH_FREQ = 40m
 CIRCUITPY_ESP_FLASH_SIZE = 4MB
 
+CIRCUITPY_ESP32_CAMERA = 0
+
 FROZEN_MPY_DIRS += $(TOP)/frozen/Adafruit_CircuitPython_Requests
 FROZEN_MPY_DIRS += $(TOP)/frozen/Adafruit_CircuitPython_NeoPixel
 FROZEN_MPY_DIRS += $(TOP)/frozen/mixgo_cp_lib/mixgoce_lib

ports/espressif/common-hal/esp32_camera/Camera.c

@@ -0,0 +1,279 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 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 "py/runtime.h"
+
+#include "bindings/esp32_camera/Camera.h"
+#include "bindings/espidf/__init__.h"
+#include "common-hal/esp32_camera/Camera.h"
+#include "shared-bindings/microcontroller/Pin.h"
+#include "common-hal/microcontroller/Pin.h"
+
+#include "esp32-camera/driver/private_include/cam_hal.h"
+
+static void maybe_claim_pin(const mcu_pin_obj_t *pin) {
+    if (pin) {
+        claim_pin(pin);
+    }
+}
+
+void common_hal_esp32_camera_camera_construct(
+    esp32_camera_camera_obj_t *self,
+    uint8_t data_pins[8],
+    const mcu_pin_obj_t *external_clock_pin,
+    const mcu_pin_obj_t *pixel_clock_pin,
+    const mcu_pin_obj_t *vsync_pin,
+    const mcu_pin_obj_t *href_pin,
+    const mcu_pin_obj_t *powerdown_pin,
+    const mcu_pin_obj_t *reset_pin,
+    const busio_i2c_obj_t *i2c,
+    mp_int_t external_clock_frequency,
+    pixformat_t pixel_format,
+    framesize_t frame_size,
+    mp_int_t jpeg_quality,
+    mp_int_t framebuffer_count,
+    camera_grab_mode_t grab_mode) {
+
+    for (int i = 0; i < 8; i++) {
+        claim_pin_number(data_pins[i]);
+    }
+    claim_pin(external_clock_pin);
+    claim_pin(pixel_clock_pin);
+    claim_pin(vsync_pin);
+    claim_pin(href_pin);
+    maybe_claim_pin(powerdown_pin);
+    maybe_claim_pin(reset_pin);
+
+    common_hal_pwmio_pwmout_construct(&self->pwm, external_clock_pin, 1, external_clock_frequency, true);
+
+    self->camera_config.pin_pwdn = common_hal_mcu_pin_number(powerdown_pin);
+    self->camera_config.pin_reset = common_hal_mcu_pin_number(reset_pin);
+    self->camera_config.pin_xclk = common_hal_mcu_pin_number(external_clock_pin);
+
+    self->camera_config.pin_sccb_sda = NO_PIN;
+    self->camera_config.pin_sccb_scl = NO_PIN;
+    /* sccb i2c port set below */
+
+    self->camera_config.pin_d7 = data_pins[7];
+    self->camera_config.pin_d6 = data_pins[6];
+    self->camera_config.pin_d5 = data_pins[5];
+    self->camera_config.pin_d4 = data_pins[4];
+    self->camera_config.pin_d3 = data_pins[3];
+    self->camera_config.pin_d2 = data_pins[2];
+    self->camera_config.pin_d1 = data_pins[1];
+    self->camera_config.pin_d0 = data_pins[0];
+
+    self->camera_config.pin_vsync = common_hal_mcu_pin_number(vsync_pin);
+    self->camera_config.pin_href = common_hal_mcu_pin_number(href_pin);
+    self->camera_config.pin_pclk = common_hal_mcu_pin_number(pixel_clock_pin);
+
+    self->camera_config.xclk_freq_hz = external_clock_frequency;
+
+    self->camera_config.ledc_timer = self->pwm.tim_handle.timer_num;
+    self->camera_config.ledc_channel = self->pwm.chan_handle.channel;
+
+    self->camera_config.pixel_format = pixel_format;
+    self->camera_config.frame_size = frame_size;
+    self->camera_config.jpeg_quality = jpeg_quality;
+    self->camera_config.fb_count = framebuffer_count;
+    self->camera_config.grab_mode = grab_mode;
+
+    self->camera_config.sccb_i2c_port = i2c->i2c_num;
+
+    CHECK_ESP_RESULT(esp_camera_init(&self->camera_config));
+}
+
+extern void common_hal_esp32_camera_camera_deinit(esp32_camera_camera_obj_t *self) {
+    if (common_hal_esp32_camera_camera_deinited(self)) {
+        return;
+    }
+
+    common_hal_pwmio_pwmout_deinit(&self->pwm);
+
+    reset_pin_number(self->camera_config.pin_pwdn);
+    reset_pin_number(self->camera_config.pin_reset);
+    reset_pin_number(self->camera_config.pin_xclk);
+
+    reset_pin_number(self->camera_config.pin_d7);
+    reset_pin_number(self->camera_config.pin_d6);
+    reset_pin_number(self->camera_config.pin_d5);
+    reset_pin_number(self->camera_config.pin_d4);
+    reset_pin_number(self->camera_config.pin_d3);
+    reset_pin_number(self->camera_config.pin_d2);
+    reset_pin_number(self->camera_config.pin_d1);
+    reset_pin_number(self->camera_config.pin_d0);
+
+    esp_camera_deinit();
+
+    self->camera_config.xclk_freq_hz = 0;
+}
+
+bool common_hal_esp32_camera_camera_deinited(esp32_camera_camera_obj_t *self) {
+    return !self->camera_config.xclk_freq_hz;
+}
+
+bool common_hal_esp32_camera_camera_available(esp32_camera_camera_obj_t *self) {
+    return esp_camera_fb_available();
+}
+
+camera_fb_t *common_hal_esp32_camera_camera_take(esp32_camera_camera_obj_t *self, int timeout_ms) {
+    if (self->buffer_to_return) {
+        esp_camera_fb_return(self->buffer_to_return);
+        self->buffer_to_return = NULL;
+    }
+    return self->buffer_to_return = esp_camera_fb_get_timeout(timeout_ms);
+}
+
+#define SENSOR_GETSET(type, name, field_name, setter_function_name) \
+    SENSOR_GET(type, name, field_name, setter_function_name) \
+    SENSOR_SET(type, name, setter_function_name)
+
+#define SENSOR_STATUS_GETSET(type, name, status_field_name, setter_function_name) \
+    SENSOR_GETSET(type, name, status.status_field_name, setter_function_name)
+
+#define SENSOR_GET(type, name, status_field_name, setter_function_name) \
+    type common_hal_esp32_camera_camera_get_##name(esp32_camera_camera_obj_t * self) { \
+        sensor_t *sensor = esp_camera_sensor_get(); \
+        if (!sensor->setter_function_name) { \
+            mp_raise_AttributeError(translate("no such attribute")); \
+        } \
+        return sensor->status_field_name; \
+    }
+
+#define SENSOR_SET(type, name, setter_function_name) \
+    void common_hal_esp32_camera_camera_set_##name(esp32_camera_camera_obj_t * self, type value) { \
+        sensor_t *sensor = esp_camera_sensor_get(); \
+        if (!sensor->setter_function_name) { \
+            mp_raise_AttributeError(translate("no such attribute")); \
+        } \
+        if (sensor->setter_function_name(sensor, value) < 0) { \
+            mp_raise_ValueError(translate("invalid setting")); \
+        } \
+    }
+
+pixformat_t common_hal_esp32_camera_camera_get_pixel_format(esp32_camera_camera_obj_t *self) {
+    return self->camera_config.pixel_format;
+}
+
+framesize_t common_hal_esp32_camera_camera_get_frame_size(esp32_camera_camera_obj_t *self) {
+    return self->camera_config.frame_size;
+}
+
+#include "esp_log.h"
+
+void common_hal_esp32_camera_camera_reconfigure(esp32_camera_camera_obj_t *self, framesize_t frame_size, pixformat_t pixel_format, camera_grab_mode_t grab_mode, mp_int_t framebuffer_count) {
+    sensor_t *sensor = esp_camera_sensor_get();
+    camera_sensor_info_t *sensor_info = esp_camera_sensor_get_info(&sensor->id);
+
+    if (PIXFORMAT_JPEG == pixel_format && (!sensor_info->support_jpeg)) {
+        raise_esp_error(ESP_ERR_NOT_SUPPORTED);
+    }
+
+    if (frame_size > sensor_info->max_size) {
+        frame_size = sensor_info->max_size;
+    }
+
+    cam_deinit();
+    self->camera_config.pixel_format = pixel_format;
+    self->camera_config.frame_size = frame_size;
+    self->camera_config.grab_mode = grab_mode;
+    self->camera_config.fb_count = framebuffer_count;
+    sensor->set_pixformat(sensor, self->camera_config.pixel_format);
+    sensor->set_framesize(sensor, self->camera_config.frame_size);
+    cam_init(&self->camera_config);
+    cam_config(&self->camera_config, frame_size, sensor_info->pid);
+    cam_start();
+}
+
+SENSOR_STATUS_GETSET(int, contrast, contrast, set_contrast);
+SENSOR_STATUS_GETSET(int, brightness, brightness, set_brightness);
+SENSOR_STATUS_GETSET(int, saturation, saturation, set_saturation);
+SENSOR_STATUS_GETSET(int, sharpness, sharpness, set_sharpness);
+SENSOR_STATUS_GETSET(int, denoise, denoise, set_denoise);
+SENSOR_STATUS_GETSET(gainceiling_t, gainceiling, gainceiling, set_gainceiling);
+SENSOR_STATUS_GETSET(int, quality, quality, set_quality);
+SENSOR_STATUS_GETSET(bool, colorbar, colorbar, set_colorbar);
+SENSOR_STATUS_GETSET(bool, whitebal, awb, set_whitebal);
+SENSOR_STATUS_GETSET(bool, gain_ctrl, agc, set_gain_ctrl);
+SENSOR_STATUS_GETSET(bool, exposure_ctrl, aec, set_exposure_ctrl);
+SENSOR_STATUS_GETSET(bool, hmirror, hmirror, set_hmirror);
+SENSOR_STATUS_GETSET(bool, vflip, vflip, set_vflip);
+SENSOR_STATUS_GETSET(bool, aec2, aec2, set_aec2);
+SENSOR_STATUS_GETSET(bool, awb_gain, awb_gain, set_awb_gain);
+SENSOR_STATUS_GETSET(int, agc_gain, agc_gain, set_agc_gain);
+SENSOR_STATUS_GETSET(int, aec_value, aec_value, set_aec_value);
+SENSOR_STATUS_GETSET(int, special_effect, special_effect, set_special_effect);
+SENSOR_STATUS_GETSET(int, wb_mode, wb_mode, set_wb_mode);
+SENSOR_STATUS_GETSET(int, ae_level, ae_level, set_ae_level);
+SENSOR_STATUS_GETSET(bool, dcw, dcw, set_dcw);
+SENSOR_STATUS_GETSET(bool, bpc, bpc, set_bpc);
+SENSOR_STATUS_GETSET(bool, wpc, wpc, set_wpc);
+SENSOR_STATUS_GETSET(bool, raw_gma, raw_gma, set_raw_gma);
+SENSOR_STATUS_GETSET(bool, lenc, lenc, set_lenc);
+
+const char *common_hal_esp32_camera_camera_get_sensor_name(esp32_camera_camera_obj_t *self) {
+    sensor_t *sensor = esp_camera_sensor_get();
+    camera_sensor_info_t *sensor_info = esp_camera_sensor_get_info(&sensor->id);
+    return sensor_info->name;
+}
+
+const bool common_hal_esp32_camera_camera_get_supports_jpeg(esp32_camera_camera_obj_t *self) {
+    sensor_t *sensor = esp_camera_sensor_get();
+    camera_sensor_info_t *sensor_info = esp_camera_sensor_get_info(&sensor->id);
+    return sensor_info->support_jpeg;
+}
+
+const framesize_t common_hal_esp32_camera_camera_get_max_frame_size(esp32_camera_camera_obj_t *self) {
+    sensor_t *sensor = esp_camera_sensor_get();
+    camera_sensor_info_t *sensor_info = esp_camera_sensor_get_info(&sensor->id);
+    return sensor_info->max_size;
+}
+
+const int common_hal_esp32_camera_camera_get_address(esp32_camera_camera_obj_t *self) {
+    sensor_t *sensor = esp_camera_sensor_get();
+    camera_sensor_info_t *sensor_info = esp_camera_sensor_get_info(&sensor->id);
+    return sensor_info->sccb_addr;
+}
+
+const int common_hal_esp32_camera_camera_get_width(esp32_camera_camera_obj_t *self) {
+    sensor_t *sensor = esp_camera_sensor_get();
+    framesize_t framesize = sensor->status.framesize;
+    return resolution[framesize].width;
+}
+
+const int common_hal_esp32_camera_camera_get_height(esp32_camera_camera_obj_t *self) {
+    sensor_t *sensor = esp_camera_sensor_get();
+    framesize_t framesize = sensor->status.framesize;
+    return resolution[framesize].height;
+}
+
+const camera_grab_mode_t common_hal_esp32_camera_camera_get_grab_mode(esp32_camera_camera_obj_t *self) {
+    return self->camera_config.grab_mode;
+}
+
+const int common_hal_esp32_camera_camera_get_framebuffer_count(esp32_camera_camera_obj_t *self) {
+    return self->camera_config.fb_count;
+}

ports/espressif/common-hal/esp32_camera/Camera.h

@@ -0,0 +1,38 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 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 "esp_camera.h"
+#include "shared-bindings/pwmio/PWMOut.h"
+
+typedef struct esp32_camera_camera_obj {
+    mp_obj_base_t base;
+    camera_config_t camera_config;
+    camera_fb_t *buffer_to_return;
+    pwmio_pwmout_obj_t pwm;
+} esp32_camera_obj_t;

ports/espressif/common-hal/microcontroller/Pin.c

@@ -100,7 +100,9 @@ static const uint64_t pin_mask_reset_forbidden =
 
 
 void never_reset_pin_number(gpio_num_t pin_number) {
-    if (pin_number == NO_PIN) {
+    // Some CircuitPython APIs deal in uint8_t pin numbers, but NO_PIN is -1.
+    // Also allow pin 255 to be treated as NO_PIN to avoid crashes
+    if (pin_number == NO_PIN || pin_number == (uint8_t)NO_PIN) {
         return;
     }
     never_reset_pins |= PIN_BIT(pin_number);
@@ -141,7 +143,9 @@ STATIC void _reset_pin(gpio_num_t pin_number) {
 
 // Mark pin as free and return it to a quiescent state.
 void reset_pin_number(gpio_num_t pin_number) {
-    if (pin_number == NO_PIN) {
+    // Some CircuitPython APIs deal in uint8_t pin numbers, but NO_PIN is -1.
+    // Also allow pin 255 to be treated as NO_PIN to avoid crashes
+    if (pin_number == NO_PIN || pin_number == (uint8_t)NO_PIN) {
         return;
     }
     never_reset_pins &= ~PIN_BIT(pin_number);
@@ -174,7 +178,9 @@ void reset_all_pins(void) {
 }
 
 void claim_pin_number(gpio_num_t pin_number) {
-    if (pin_number == NO_PIN) {
+    // Some CircuitPython APIs deal in uint8_t pin numbers, but NO_PIN is -1.
+    // Also allow pin 255 to be treated as NO_PIN to avoid crashes
+    if (pin_number == NO_PIN || pin_number == (uint8_t)NO_PIN) {
         return;
     }
     in_use |= PIN_BIT(pin_number);

ports/espressif/esp-idf-config/sdkconfig-esp32s3.defaults

@@ -191,3 +191,31 @@ CONFIG_ESP32_DEFAULT_PTHREAD_CORE_NO_AFFINITY=y
 CONFIG_ESP32_PTHREAD_TASK_CORE_DEFAULT=-1
 CONFIG_ESP32_PTHREAD_TASK_NAME_DEFAULT="pthread"
 # end of Deprecated options for backward compatibility
+
+#
+# Camera configuration
+#
+CONFIG_OV7670_SUPPORT=y
+# CONFIG_OV7725_SUPPORT is not set
+# CONFIG_NT99141_SUPPORT is not set
+CONFIG_OV2640_SUPPORT=y
+CONFIG_OV3660_SUPPORT=y
+CONFIG_OV5640_SUPPORT=y
+# CONFIG_GC2145_SUPPORT is not set
+# CONFIG_GC032A_SUPPORT is not set
+# CONFIG_GC0308_SUPPORT is not set
+# CONFIG_BF3005_SUPPORT is not set
+# CONFIG_BF20A6_SUPPORT is not set
+# CONFIG_SC101IOT_SUPPORT is not set
+# CONFIG_SC030IOT_SUPPORT is not set
+# CONFIG_SCCB_HARDWARE_I2C_PORT0 is not set
+CONFIG_SCCB_HARDWARE_I2C_PORT1=y
+CONFIG_SCCB_CLK_FREQ=100000
+CONFIG_CAMERA_CORE0=y
+# CONFIG_CAMERA_CORE1 is not set
+# CONFIG_CAMERA_NO_AFFINITY is not set
+CONFIG_CAMERA_DMA_BUFFER_SIZE_MAX=32768
+# CONFIG_CAMERA_CONVERTER_ENABLED is not set
+# end of Camera configuration
+# end of Component config
+

ports/espressif/esp32-camera

@@ -0,0 +1 @@
+Subproject commit 28804391c002f6a3ea5ce6a55aee3b191be3ecde

ports/espressif/mpconfigport.mk

@@ -20,7 +20,7 @@ CIRCUITPY_DUALBANK ?= 1
 CIRCUITPY_FRAMEBUFFERIO ?= 1
 CIRCUITPY_FREQUENCYIO ?= 1
 CIRCUITPY_HASHLIB ?= 1
-CIRCUITPY_IMAGECAPTURE ?= 1
+CIRCUITPY_IMAGECAPTURE ?= 0
 CIRCUITPY_I2CTARGET ?= 1
 CIRCUITPY_RGBMATRIX ?= 1
 CIRCUITPY_ROTARYIO ?= 1
@@ -35,12 +35,12 @@ CIRCUITPY_ESPIDF ?= 1
 ifeq ($(IDF_TARGET),esp32)
 CIRCUITPY_BLEIO = 0
 CIRCUITPY_BLEIO_HCI = 0
-CIRCUITPY_IMAGECAPTURE = 0
 CIRCUITPY_PARALLELDISPLAY = 0
 # Protomatter needs to support ESP32.
 CIRCUITPY_RGBMATRIX = 0
 CIRCUITPY_USB = 0
 CIRCUITPY_BUILD_EXTENSIONS ?= bin
+CIRCUITPY_ESP32_CAMERA ?= 1
 
 else ifeq ($(IDF_TARGET),esp32c3)
 CIRCUITPY_AESIO = 0
@@ -51,7 +51,6 @@ CIRCUITPY_BLEIO_HCI = 0
 CIRCUITPY_COUNTIO = 0
 CIRCUITPY_DUALBANK = 0
 CIRCUITPY_FREQUENCYIO = 0
-CIRCUITPY_IMAGECAPTURE = 0
 CIRCUITPY_PARALLELDISPLAY = 0
 CIRCUITPY_PS2IO = 0
 CIRCUITPY_ROTARYIO = 0
@@ -63,15 +62,16 @@ CIRCUITPY_BUILD_EXTENSIONS ?= bin
 else ifeq ($(IDF_TARGET),esp32s3)
 CIRCUITPY_BLEIO = 1
 CIRCUITPY_BLEIO_HCI = 0
-CIRCUITPY_IMAGECAPTURE = 0
 CIRCUITPY_PARALLELDISPLAY = 0
 CIRCUITPY_BUILD_EXTENSIONS ?= bin,uf2
+CIRCUITPY_ESP32_CAMERA ?= 1
 
 else ifeq ($(IDF_TARGET),esp32s2)
 # No BLE on S2
 CIRCUITPY_BLEIO = 0
 CIRCUITPY_BLEIO_HCI = 0
 CIRCUITPY_BUILD_EXTENSIONS ?= bin,uf2
+CIRCUITPY_ESP32_CAMERA ?= 1
 endif
 
 # From ESP32-S2/S3 Technical Reference Manual:
@@ -85,3 +85,7 @@ endif
 # only if something else is turned off, such as HID.
 USB_NUM_ENDPOINT_PAIRS = 7
 USB_NUM_IN_ENDPOINTS = 5
+
+CIRCUITPY_ESP32_CAMERA ?= 0
+CIRCUITPY_GIFIO ?= $(CIRCUITPY_ESP32_CAMERA)
+CIRCUITPY_QRIO ?= $(CIRCUITPY_ESP32_CAMERA)

ports/espressif/supervisor/port.c

@@ -76,8 +76,8 @@
 #include "shared-bindings/_bleio/__init__.h"
 #endif
 
-#if CIRCUITPY_IMAGECAPTURE
+#if CIRCUITPY_ESP32_CAMERA
-#include "cam.h"
+#include "esp_camera.h"
 #endif
 
 #ifndef CONFIG_IDF_TARGET_ESP32
@@ -338,8 +338,9 @@ safe_mode_t port_init(void) {
 }
 
 void reset_port(void) {
-    #if CIRCUITPY_IMAGECAPTURE
+    // TODO deinit for esp32-camera
-    cam_deinit();
+    #if CIRCUITPY_ESP32_CAMERA
+    esp_camera_deinit();
     #endif
 
     reset_all_pins();

py/circuitpy_mpconfig.mk

@@ -214,6 +214,9 @@ CFLAGS += -DCIRCUITPY_ERRNO=$(CIRCUITPY_ERRNO)
 CIRCUITPY_ESPIDF ?= 0
 CFLAGS += -DCIRCUITPY_ESPIDF=$(CIRCUITPY_ESPIDF)
 
+CIRCUITPY_ESP32_CAMERA ?= 0
+CFLAGS += -DCIRCUITPY_ESP32_CAMERA=$(CIRCUITPY_ESP32_CAMERA)
+
 CIRCUITPY__EVE ?= 0
 CFLAGS += -DCIRCUITPY__EVE=$(CIRCUITPY__EVE)
 

requirements-doc.txt

@@ -5,7 +5,7 @@ isort
 twine
 wheel
 astroid
-setuptools
+setuptools>=45
 setuptools_scm
 
 # For sphinx

shared-bindings/countio/Edge.h

@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2021 an Halbertfor Adafruit Industries
+ * Copyright (c) 2021 Dan Halbert 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

shared-bindings/displayio/Bitmap.h

@@ -33,6 +33,8 @@ extern const mp_obj_type_t displayio_bitmap_type;
 
 void common_hal_displayio_bitmap_construct(displayio_bitmap_t *self, uint32_t width,
     uint32_t height, uint32_t bits_per_value);
+void common_hal_displayio_bitmap_construct_from_buffer(displayio_bitmap_t *self, uint32_t width,
+    uint32_t height, uint32_t bits_per_value, uint32_t *data, bool read_only);
 
 void common_hal_displayio_bitmap_load_row(displayio_bitmap_t *self, uint16_t y, uint8_t *data,
     uint16_t len);

shared-bindings/floppyio/__init__.c

@@ -31,7 +31,6 @@
 #include <stdint.h>
 
 #include "py/binary.h"
-#include "py/enum.h"
 #include "py/obj.h"
 #include "py/runtime.h"
 

shared-bindings/imagecapture/ParallelImageCapture.c

@@ -47,6 +47,8 @@
 //|     ) -> None:
 //|         """Create a parallel image capture object
 //|
+//|         This object is usually used with a camera-specific wrapper library such as `adafruit_ov5640 <https://circuitpython.readthedocs.io/projects/ov5640/en/latest/>`_.
+//|
 //|         :param List[microcontroller.Pin] data_pins: The data pins.
 //|         :param microcontroller.Pin clock: The pixel clock input.
 //|         :param microcontroller.Pin vsync: The vertical sync input, which has a negative-going pulse at the beginning of each frame.

shared-bindings/imagecapture/__init__.c

@@ -31,9 +31,13 @@
 
 #include "shared-bindings/imagecapture/ParallelImageCapture.h"
 
-//| """Support for "Parallel capture" interfaces"""
+//| """Support for "Parallel capture" interfaces
 //|
-
+//| .. seealso::
+//|
+//|     Espressif microcontrollers use the `esp32_camera` module together.
+//|
+//| """
 STATIC const mp_rom_map_elem_t imagecapture_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_imagecapture) },
     { MP_ROM_QSTR(MP_QSTR_ParallelImageCapture), MP_ROM_PTR(&imagecapture_parallelimagecapture_type) },

shared-module/displayio/Bitmap.c

@@ -30,20 +30,29 @@
 
 #include "py/runtime.h"
 
-void common_hal_displayio_bitmap_construct(displayio_bitmap_t *self, uint32_t width,
+enum { align_bits = 8 * sizeof(uint32_t) };
-    uint32_t height, uint32_t bits_per_value) {
+
+static int stride(uint32_t width, uint32_t bits_per_value) {
     uint32_t row_width = width * bits_per_value;
     // align to uint32_t
-    uint8_t align_bits = 8 * sizeof(uint32_t);
+    return (row_width + align_bits - 1) / align_bits;
-    if (row_width % align_bits != 0) {
+}
-        self->stride = (row_width / align_bits + 1);
+
-    } else {
+void common_hal_displayio_bitmap_construct(displayio_bitmap_t *self, uint32_t width,
-        self->stride = row_width / align_bits;
+    uint32_t height, uint32_t bits_per_value) {
-    }
+    common_hal_displayio_bitmap_construct_from_buffer(self, width, height, bits_per_value, NULL, false);
+}
+
+void common_hal_displayio_bitmap_construct_from_buffer(displayio_bitmap_t *self, uint32_t width,
+    uint32_t height, uint32_t bits_per_value, uint32_t *data, bool read_only) {
     self->width = width;
     self->height = height;
-    self->data = m_malloc(self->stride * height * sizeof(uint32_t), false);
+    self->stride = stride(width, bits_per_value);
-    self->read_only = false;
+    if (!data) {
+        data = m_malloc(self->stride * height * sizeof(uint32_t), false);
+    }
+    self->data = data;
+    self->read_only = read_only;
     self->bits_per_value = bits_per_value;
 
     if (bits_per_value > 8 && bits_per_value != 16 && bits_per_value != 32) {
@@ -70,6 +79,7 @@ void common_hal_displayio_bitmap_construct(displayio_bitmap_t *self, uint32_t wi
     self->dirty_area.y2 = height;
 }
 
+
 uint16_t common_hal_displayio_bitmap_get_height(displayio_bitmap_t *self) {
     return self->height;
 }