Move hardware initialization out of boot.py

There are potential downsides to requiring use of boot.py:
* It's a bit obscure
* Not all IDEs (eg. XRPCode) properly support boot.py
* It's possible to brick a device with a bad boot.py
Now all hardware initialization is in an example module, which all examples import
Users can still move the contents to a boot.py file if they desire

Author: sfe-SparkFro

examples/boot.py

@@ -0,0 +1,40 @@
+# Initializes various hardware components for OpenCV in MicroPython. The
+# examples import this module, but you could instead create/edit a `boot.py`
+# script to automatically initialize the hardware when the board boots up. See:
+# https://micropython.org/resources/docs/en/latest/reference/reset_boot.html#id4
+
+try:
+    from .display import display
+except:
+    print("Display initialization failed, skipping...")
+
+try:
+    from .camera import camera
+except:
+    print("Camera initialization failed, skipping...")
+
+try:
+    from .touch_screen import touch_screen
+except:
+    print("Touch screen initialization failed, skipping...")
+
+try:
+    # We don't actually need to import anything here, just want to run the
+    # sd_card module so the SD card gets mounted to the filesystem. So just
+    # import something then delete it to avoid clutter
+    from .sd_card import sdcard
+    del sdcard
+except:
+    print("SD card initialization failed, skipping...")
+
+# Optional - show a splash image on the display if one is available, or clear
+# the display of any previous content
+try:
+    # Load and display a splash image, if one is available
+    import cv2
+    splash_image = cv2.imread("splash.png")
+    cv2.imshow(display, splash_image)
+except Exception:    
+    # No splash image, instead clear the display if the driver supports it
+    if hasattr(display, 'clear'):
+        display.clear()

examples/cv2_hardware_init/__init__.py

@@ -0,0 +1,11 @@
+# Import the machine.I2C class
+from machine import I2C
+
+# Initialize default I2C bus. You may need to adjust the arguments based on your
+# specific board and configuration
+i2c = I2C(
+    # id = 0,
+    # sda = machine.Pin(0),
+    # scl = machine.Pin(1),
+    # freq = 400_000
+)

examples/cv2_hardware_init/bus_i2c.py

@@ -0,0 +1,13 @@
+# Import the machine.SPI class
+from machine import SPI
+
+# Initialize default SPI bus. You may need to adjust the arguments based on your
+# specific board and configuration
+spi = SPI(
+    # id = 0,
+    baudrate = 24_000_000, # Use the fastest baudrate you can for best performance!
+    # sck = machine.Pin(2),
+    # mosi = machine.Pin(3),
+    # miso = machine.Pin(4),
+    # freq = 100_000
+)

examples/cv2_hardware_init/bus_spi.py

@@ -0,0 +1,38 @@
+# Initializes a camera object. Multiple options are provided below, so you can
+# choose one that best fits your needs. You may need to adjust the arguments
+# based on your specific camera and board configuration
+
+# Import the OpenCV camera drivers
+from cv2_drivers.cameras import *
+
+# Import the I2C bus
+from .bus_i2c import i2c
+
+################################################################################
+# HM01B0
+################################################################################
+
+# PIO interface, only available on Raspberry Pi RP2 processors
+camera = hm01b0_pio.HM01B0_PIO(
+    i2c,
+    pin_d0 = 12,
+    pin_vsync = 13,
+    pin_hsync = 14,
+    pin_pclk = 15,
+    pin_xclk = None, # Optional xclock pin, specify if needed
+    num_data_pins = 1 # Number of data pins used by the camera (1, 4, or 8)
+)
+
+################################################################################
+# OV5640
+################################################################################
+
+# PIO interface, only available on Raspberry Pi RP2 processors
+# camera = ov5640_pio.OV5640_PIO(
+#     i2c,
+#     pin_d0 = 8,
+#     pin_vsync = 22,
+#     pin_hsync = 21,
+#     pin_pclk = 20,
+#     pin_xclk = None # Optional xclock pin, specify if needed
+# )

examples/cv2_hardware_init/camera.py

@@ -0,0 +1,37 @@
+# Initializes a display object. Multiple options are provided below, so you can
+# choose one that best fits your needs. You may need to adjust the arguments
+# based on your specific display and board configuration
+
+# Import the OpenCV display drivers
+from cv2_drivers.displays import *
+
+# Import the SPI bus
+from .bus_spi import spi
+
+################################################################################
+# ST7789
+################################################################################
+
+# SPI interface. This should work on any platform, but it's not always the
+# fastest option (24Mbps on RP2350)
+display = st7789_spi.ST7789_SPI(
+    width = 240,
+    height = 320,
+    spi = spi,
+    pin_dc = 16,
+    pin_cs = 17,
+    rotation = 1
+)
+
+# PIO interface. This is only available on Raspberry Pi RP2 processors,
+# but is much faster than the SPI interface (75Mbps on RP2350)
+# display = st7789_pio.ST7789_PIO(
+#     width = 240,
+#     height = 320,
+#     sm_id = 1,
+#     pin_clk = 18,
+#     pin_tx = 19,
+#     pin_dc = 16,
+#     pin_cs = 17,
+#     rotation = 1
+# )

examples/cv2_hardware_init/display.py

@@ -0,0 +1,50 @@
+# Initializes SD card and mounts it to the filesystem. This assumes the SD card
+# is on the same SPI bus as the display with a different chip select pin. You
+# may need to adjust this based on your specific board and configuration
+
+# Import the Pin class for the chip select pin
+from machine import Pin
+
+# Import the SPI bus
+from .bus_spi import spi
+
+# When the SD card is initialized, it changes the SPI bus baudrate. We'll
+# want to revert it, so we need to know the original baudrate. There's no
+# way to get it directly, so we convert the bus to a string and parse it.
+# Example format:
+# "SPI(0, baudrate=24000000, sck=Pin(2), mosi=Pin(3), miso=Pin(4))"
+spi_str = str(spi)
+baudrate = int(spi_str[spi_str.index("baudrate=") + 9:].partition(",")[0])
+
+# Set the chip select pin for the SD card
+sd_cs = Pin(7, Pin.OUT)
+
+try:
+    # Import the SD card module. This is often not installed by default in
+    # MicroPython, so you may need to install it manually. For example, you can
+    # use `mpremote mip install sdcard`
+    import sdcard
+
+    # Initialize the SD card, then restore the original SPI bus baudrate. This
+    # is wrapped in a try/finally block to ensure the baudrate is restored even if
+    # the SD card initialization fails
+    try:
+        sd_card = sdcard.SDCard(spi, sd_cs)
+    finally:
+        spi.init(baudrate = baudrate)
+
+    # Mount the SD card to the filesystem under the "/sd" directory, which makes
+    # it accessible just like the normal MicroPython filesystem
+    import uos
+    vfs = uos.VfsFat(sd_card)
+    uos.mount(vfs, "/sd")
+except ImportError:
+    print("sdcard module not found, skipping SD card initialization...")
+except OSError as e:
+    eStr = str(e)
+    if "no SD card" in eStr:
+        print("no SD card found, skipping SD card initialization...")
+    elif "Errno 1" in eStr:
+        print("SD card already mounted, skipping SD card initialization...")
+    else:
+        print("Failed to mount SD card, skipping SD card initialization...")

examples/cv2_hardware_init/sd_card.py

@@ -0,0 +1,16 @@
+# Import the machine module to access hardware features
+from .bus_i2c import i2c
+
+# Import the OpenCV touch screen drivers
+from cv2_drivers.touch_screens import *
+
+# Create a touch screen object. Multiple options are provided below, so you can choose
+# one that best fits your needs. You may need to adjust the arguments based on
+# your specific touch screen and board configuration
+
+################################################################################
+# CST816
+################################################################################
+
+# I2C interface
+touch_screen = cst816.CST816(i2c)

examples/cv2_hardware_init/touch_screen.py

@@ -1,6 +1,14 @@
 # Import OpenCV, just as you would in any other Python environment!
 import cv2
 
+# Standard OpenCV leverages the host operating system to access hardware, but we
+# don't have that luxury in MicroPython. Instead, drivers are provided for
+# various hardware components, which need to be initialized before using them.
+# The exmples import a module called `cv2_hardware_init`, which initializes the
+# drivers. You may need to edit the contents of the `cv2_hardware_init` module
+# based on your specific board and hardware configuration
+from cv2_hardware_init import *
+
 # Import NumPy, almost like any other Python environment! The only difference is
 # the addition of `from ulab` since MicroPython does not have a full NumPy
 # implementation; ulab NumPy is a lightweight version of standard NumPy

examples/ex01_hello_opencv.py

@@ -1,5 +1,6 @@
-# Import OpenCV
+# Import OpenCV and hardware initialization module
 import cv2
+from cv2_hardware_init import *
 
 # Call `cv2.imread()` to read an image from the MicroPython filesystem, just
 # like in any other Python environment! Make sure to copy the image to the