Add boot.py example to initialize display and mount SD card

Also update Example 1 to remove display driver dependency, now requires hardware to be initialized by boot.py

Author: sfe-SparkFro

examples/boot.py

@@ -0,0 +1,60 @@
+# Import the machine module to access hardware features
+import machine
+
+# Initialize SPI bus, assuming default pins on bus 0. You may need to adjust
+# this based on your specific board and configuration
+spi = machine.SPI(0)
+
+# Initialize display, if available
+try:
+    # Import a display driver module. This example assumes the ST7789, which is
+    # a very popular display driver for embedded systems. Moreover, this example
+    # uses an SPI-based driver, so it should work on any platform, but it's not
+    # always the fastest option
+    import st7789_spi
+
+    # Create a display object. This will depend on the display driver you are
+    # using, and you may need to adjust the parameters based on your specific
+    # display and board configuration
+    display = st7789_spi.ST7789_SPI(width=240,
+                                    height=320,
+                                    spi=spi,
+                                    pin_dc=16,
+                                    pin_cs=17,
+                                    rotation=1)
+except ImportError:
+    print("boot.py - Display driver module not found, skipping display initialization.")
+
+# Initialize SD card, if available
+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
+
+    # This example 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
+    sd_cs = machine.Pin(7, machine.Pin.OUT)
+    sd = sdcard.SDCard(spi, sd_cs)
+    
+    # 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)
+    uos.mount(vfs, "/sd")
+except ImportError:
+    print("boot.py - sdcard module not found, skipping SD card initialization.")
+except OSError:
+    print("boot.py - Failed to mount SD card, skipping SD card initialization.")
+
+# Set the SPI bus baudrate (note - the sdcard module overrides the baudrate upon
+# initialization, so the baudrate should be set after that). It is recommended
+# to use the fastest baudrate supported by your board, display, and SD card to
+# minimize latency
+spi.init(baudrate=24_000_000)
+
+# Clear the display to wipe any previous content. This is optional, but it's
+# recommended to ensure a clean slate
+if hasattr(display, 'clear'):
+    display.clear()

examples/ex01_hello_opencv.py

@@ -6,22 +6,6 @@
 # implementation; ulab NumPy is a lightweight version of standard NumPy
 from ulab import numpy as np
 
-# Standard OpenCV leverages the host operating system to display images, but we
-# don't have that luxury in MicroPython. Instead, we need to import a display
-# driver. Any display driver can be used, as long as it implements an `imshow()`
-# method that takes an NumPy array as input
-from st7789_spi import ST7789_SPI
-
-# Create a display object. This will depend on the display driver you are using,
-# and you may need to adjust the parameters based on your specific display and
-# board configuration
-display = ST7789_SPI(width=240,
-                    height=320,
-                    spi_id=0,
-                    pin_cs=17,
-                    pin_dc=16,
-                    rotation=1)
-
 # Initialize an image (NumPy array) to be displayed, just like in any other
 # Python environment! Here we create a 240x320 pixel image with 3 color channels
 # (BGR order, like standard OpenCV) and a data type of `uint8` (you should
@@ -39,17 +23,25 @@
 # Note - Most OpenCV functions return the resulting image. It's redundant for
 # the drawing functions and often ignored, but if you call those functions from
 # the REPL without assigning it to a variable, the entire array will be printed.
-# To avoid this, you can simply re-assign the image, which has no effect other
-# than preventing the output from being printed
+# To avoid this, you can simply re-assign the image variable (for example,
+# `img = cv2.function(...)`)
 
 # And the obligatory "Hello OpenCV" text! This time in red
 img = cv2.putText(img, "Hello OpenCV!", (50, 200), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
 
 # Once we have an image ready to show, just call `cv2.imshow()`, almost like any
-# other Python environment! The only difference is that we need to pass the
-# display object we created earlier as the first argument, instead of a window
-# name string. Alternatively, you can call `display.imshow(img)` directly
-cv2.imshow(display, img)
+# other Python environment! However, there is one important difference:
+# 
+# Standard OpenCV leverages the host operating system to display images in
+# windows, but we don't have that luxury in MicroPython. So there is an API
+# change to `cv2.imshow()` to accommodate this: instead of passing a window name
+# string as the first argument to `cv2.imshow()`, we pass a display driver. Any
+# display driver can be used, as long as it implements an `imshow()` method that
+# takes a NumPy array as input
+# 
+# This example assumes a display driver called `display` has been initialized by
+# a `boot.py` script. See the example `boot.py` script for more details
+cv2.imshow(display, img) # Can alternatively call `display.imshow(img)`
 
 # Standard OpenCV requires a call to `cv2.waitKey()` to process events and
 # actually display the image. However the display driver shows the image
@@ -61,4 +53,4 @@
 # 
 # Note - Some MicroPython IDEs (like Thonny) don't actually send any key presses
 # until you hit Enter on your keyboard
-key = cv2.waitKey(1) # Not necessary to display image, can remove if desired
+key = cv2.waitKey(0) # Not necessary to display image, can remove if desired