Factor out a PyCameraBase class

This gives the coder control over what is initialized. For the image
review app, for instance, the camera & autofocus would not be initialized.

Support for the display backlight is also added.

Author: jepler

adafruit_pycamera/__init__.py

@@ -71,8 +71,10 @@
 _NVM_MODE = const(3)
 
 
-class PyCamera:  # pylint: disable=too-many-instance-attributes,too-many-public-methods
-    """Wrapper class for the PyCamera hardware"""
+class PyCameraBase:  # pylint: disable=too-many-instance-attributes,too-many-public-methods
+    """Base class for PyCamera hardware"""
+
+    """Wrapper class for the PyCamera hardware with lots of smarts"""
 
     _finalize_firmware_load = (
         0x3022,
@@ -176,59 +178,41 @@ class PyCamera:  # pylint: disable=too-many-instance-attributes,too-many-public-
         b"\x29\x80\x05"  # _DISPON and Delay 5ms
     )
 
-    def i2c_scan(self):
-        """Print an I2C bus scan"""
-        while not self._i2c.try_lock():
-            pass
-
-        try:
-            print(
-                "I2C addresses found:",
-                [hex(device_address) for device_address in self._i2c.scan()],
-            )
-        finally:  # unlock the i2c bus when ctrl-c'ing out of the loop
-            self._i2c.unlock()
-
     def __init__(self) -> None:  # pylint: disable=too-many-statements
-        self._timestamp = time.monotonic()
+        displayio.release_displays()
         self._i2c = board.I2C()
         self._spi = board.SPI()
-        self.deinit_display()
-
-        self.splash = displayio.Group()
-        self._sd_label = label.Label(
-            terminalio.FONT, text="SD ??", color=0x0, x=150, y=10, scale=2
-        )
-        self._effect_label = label.Label(
-            terminalio.FONT, text="EFFECT", color=0xFFFFFF, x=4, y=10, scale=2
-        )
-        self._mode_label = label.Label(
-            terminalio.FONT, text="MODE", color=0xFFFFFF, x=150, y=10, scale=2
-        )
+        self._timestamp = time.monotonic()
+        self._bigbuf = None
+        self._botbar = None
+        self._camera_device = None
+        self._display_bus = None
+        self._effect_label = None
+        self._image_counter = 0
+        self._mode_label = None
+        self._res_label = None
+        self._sd_label = None
+        self._topbar = None
+        self.accel = None
+        self.camera = None
+        self.display = None
+        self.pixels = None
+        self.sdcard = None
+        self.splash = None
 
-        # turn on the display first, its reset line may be shared with the IO expander(?)
-        if not self.display:
-            self.init_display()
+        # Reset display and I/O expander
+        self._tft_aw_reset = DigitalInOut(board.TFT_RESET)
+        self._tft_aw_reset.switch_to_output(False)
+        time.sleep(0.05)
+        self._tft_aw_reset.switch_to_output(True)
 
         self.shutter_button = DigitalInOut(board.BUTTON)
         self.shutter_button.switch_to_input(Pull.UP)
         self.shutter = Button(self.shutter_button)
 
-        print("reset camera")
         self._cam_reset = DigitalInOut(board.CAMERA_RESET)
         self._cam_pwdn = DigitalInOut(board.CAMERA_PWDN)
 
-        self._cam_reset.switch_to_output(False)
-        self._cam_pwdn.switch_to_output(True)
-        time.sleep(0.01)
-        self._cam_pwdn.switch_to_output(False)
-        time.sleep(0.01)
-        self._cam_reset.switch_to_output(True)
-        time.sleep(0.01)
-
-        print("pre cam @", time.monotonic() - self._timestamp)
-        self.i2c_scan()
-
         # AW9523 GPIO expander
         self._aw = adafruit_aw9523.AW9523(self._i2c, address=0x58)
         print("Found AW9523")
@@ -260,17 +244,40 @@ def make_debounced_expander_pin(pin_no):
 
         self.mute = make_expander_output(_AW_MUTE, False)
 
-        self.sdcard = None
-        try:
-            self.mount_sd_card()
-        except RuntimeError:
-            pass  # no card found, its ok!
-        print("sdcard done @", time.monotonic() - self._timestamp)
+    def make_camera_ui(self):
+        """Create displayio widgets for the standard camera UI"""
+        self.splash = displayio.Group()
+        self._sd_label = label.Label(
+            terminalio.FONT, text="SD ??", color=0x0, x=150, y=10, scale=2
+        )
+        self._effect_label = label.Label(
+            terminalio.FONT, text="EFFECT", color=0xFFFFFF, x=4, y=10, scale=2
+        )
+        self._mode_label = label.Label(
+            terminalio.FONT, text="MODE", color=0xFFFFFF, x=150, y=10, scale=2
+        )
+        self._topbar = displayio.Group()
+        self._res_label = label.Label(
+            terminalio.FONT, text="", color=0xFFFFFF, x=0, y=10, scale=2
+        )
+        self._topbar.append(self._res_label)
+        self._topbar.append(self._sd_label)
+
+        self._botbar = displayio.Group(x=0, y=210)
+        self._botbar.append(self._effect_label)
+        self._botbar.append(self._mode_label)
+
+        self.splash.append(self._topbar)
+        self.splash.append(self._botbar)
 
+    def init_accelerometer(self):
+        """Initialize the accelerometer"""
         # lis3dh accelerometer
         self.accel = adafruit_lis3dh.LIS3DH_I2C(self._i2c, address=0x19)
         self.accel.range = adafruit_lis3dh.RANGE_2_G
 
+    def init_neopixel(self):
+        """Initialize the neopixels (onboard & ring)"""
         # main board neopixel
         neopix = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.1)
         neopix.fill(0)
@@ -282,6 +289,17 @@ def make_debounced_expander_pin(pin_no):
         )
         self.pixels.fill(0)
 
+    def init_camera(self, init_autofocus=True) -> None:
+        """Initialize the camera, by default including autofocus"""
+        print("reset camera")
+        self._cam_reset.switch_to_output(False)
+        self._cam_pwdn.switch_to_output(True)
+        time.sleep(0.01)
+        self._cam_pwdn.switch_to_output(False)
+        time.sleep(0.01)
+        self._cam_reset.switch_to_output(True)
+        time.sleep(0.01)
+
         print("Initializing camera")
         self.camera = espcamera.Camera(
             data_pins=board.CAMERA_DATA,
@@ -305,33 +323,12 @@ def make_debounced_expander_pin(pin_no):
                 self.camera.address,
             )
         )
-        print("camera done @", time.monotonic() - self._timestamp)
-        print(dir(self.camera))
 
         self._camera_device = I2CDevice(self._i2c, self.camera.address)
-        # display.auto_refresh = False
 
         self.camera.hmirror = False
         self.camera.vflip = True
 
-        self._bigbuf = None
-
-        self._topbar = displayio.Group()
-        self._res_label = label.Label(
-            terminalio.FONT, text="", color=0xFFFFFF, x=0, y=10, scale=2
-        )
-        self._topbar.append(self._res_label)
-        self._topbar.append(self._sd_label)
-
-        self._botbar = displayio.Group(x=0, y=210)
-        self._botbar.append(self._effect_label)
-        self._botbar.append(self._mode_label)
-
-        self.splash.append(self._topbar)
-        self.splash.append(self._botbar)
-        self.display.root_group = self.splash
-        self.display.refresh()
-
         self.led_color = 0
         self.led_level = 0
 
@@ -340,6 +337,10 @@ def make_debounced_expander_pin(pin_no):
         self.camera.saturation = 3
         self.resolution = microcontroller.nvm[_NVM_RESOLUTION]
         self.mode = microcontroller.nvm[_NVM_MODE]
+
+        if init_autofocus:
+            self.autofocus_init()
+
         print("init done @", time.monotonic() - self._timestamp)
 
     def autofocus_init_from_file(self, filename):
@@ -526,15 +527,15 @@ def resolution(self, res):
             self._res_label.text = self.resolutions[res]
         self.display.refresh()
 
-    def init_display(self, reset=True):
+    def init_display(self):
         """Initialize the TFT display"""
         # construct displayio by hand
         displayio.release_displays()
         self._display_bus = displayio.FourWire(
             self._spi,
             command=board.TFT_DC,
             chip_select=board.TFT_CS,
-            reset=board.TFT_RESET if reset else None,
+            reset=None,
             baudrate=60_000_000,
         )
         self.display = board.DISPLAY
@@ -546,6 +547,7 @@ def init_display(self, reset=True):
             height=240,
             colstart=80,
             auto_refresh=False,
+            backlight_pin=board.TFT_BACKLIGHT,
         )
         self.display.root_group = self.splash
         self.display.refresh()
@@ -562,7 +564,7 @@ def display_message(self, message, color=0xFF0000, scale=3):
         text_area = label.Label(terminalio.FONT, text=message, color=color, scale=scale)
         text_area.anchor_point = (0.5, 0.5)
         if not self.display:
-            self.init_display(None)
+            self.init_display()
         text_area.anchored_position = (self.display.width / 2, self.display.height / 2)
 
         # Show it
@@ -572,10 +574,11 @@ def display_message(self, message, color=0xFF0000, scale=3):
 
     def mount_sd_card(self):
         """Attempt to mount the SD card"""
-        self._sd_label.text = "NO SD"
-        self._sd_label.color = 0xFF0000
+        if self._sd_label is not None:
+            self._sd_label.text = "NO SD"
+            self._sd_label.color = 0xFF0000
         if not self.card_detect.value:
-            raise RuntimeError("SD card detection failed")
+            raise RuntimeError("No SD card inserted")
         if self.sdcard:
             self.sdcard.deinit()
         # depower SD card
@@ -585,6 +588,7 @@ def mount_sd_card(self):
         # deinit display and SPI bus because we need to drive all SD pins LOW
         # to ensure nothing, not even an I/O pin, could possibly power the SD
         # card
+        had_display = self.display is not None
         self.deinit_display()
         self._spi.deinit()
         sckpin = DigitalInOut(board.SCK)
@@ -604,23 +608,28 @@ def mount_sd_card(self):
         self._card_power.value = False
         card_cs.deinit()
         print("sdcard init @", time.monotonic() - self._timestamp)
-        self.sdcard = sdcardio.SDCard(self._spi, board.CARD_CS, baudrate=20_000_000)
-        vfs = storage.VfsFat(self.sdcard)
-        print("mount vfs @", time.monotonic() - self._timestamp)
-        storage.mount(vfs, "/sd")
-        self.init_display(None)
-        self._image_counter = 0
-        self._sd_label.text = "SD OK"
-        self._sd_label.color = 0x00FF00
+        try:
+            self.sdcard = sdcardio.SDCard(self._spi, board.CARD_CS, baudrate=20_000_000)
+            vfs = storage.VfsFat(self.sdcard)
+            print("mount vfs @", time.monotonic() - self._timestamp)
+            storage.mount(vfs, "/sd")
+            self._image_counter = 0
+            if self._sd_label is not None:
+                self._sd_label.text = "SD OK"
+                self._sd_label.color = 0x00FF00
+        finally:
+            if had_display:
+                self.init_display()
 
     def unmount_sd_card(self):
         """Unmount the SD card, if mounted"""
         try:
             storage.umount("/sd")
         except OSError:
             pass
-        self._sd_label.text = "NO SD"
-        self._sd_label.color = 0xFF0000
+        if self._sd_label is not None:
+            self._sd_label.text = "NO SD"
+            self._sd_label.color = 0xFF0000
 
     def keys_debounce(self):
         """Debounce all keys.
@@ -775,3 +784,21 @@ def led_color(self, new_color):
             self.pixels.fill(colors)
         else:
             self.pixels[:] = colors
+
+
+class PyCamera(PyCameraBase):
+    """Wrapper class for the PyCamera hardware"""
+
+    def __init__(self, init_autofocus=True):
+        super().__init__()
+
+        self.make_camera_ui()
+        self.init_accelerometer()
+        self.init_neopixel()
+        self.init_display()
+        self.init_camera(init_autofocus)
+        try:
+            self.mount_sd_card()
+        except Exception as exc:  # pylint: disable=broad-exception-caught
+            # No SD card inserted, it's OK
+            print(exc)

examples/camera/code.py

@@ -12,7 +12,6 @@
 import adafruit_pycamera
 
 pycam = adafruit_pycamera.PyCamera()
-pycam.autofocus_init()
 # pycam.live_preview_mode()
 
 settings = (None, "resolution", "effect", "mode", "led_level", "led_color")

examples/ipcam2/code.py

@@ -29,7 +29,6 @@
 supervisor.runtime.autoreload = False
 
 pycam = adafruit_pycamera.PyCamera()
-pycam.autofocus_init()
 
 if wifi.radio.ipv4_address:
     # use alt port if web workflow enabled