Merge pull request #15 from adafruit/enhancements

Various enhancements

Author: jepler

adafruit_pycamera/__init__.py

@@ -17,6 +17,8 @@
 import bitmaptools
 import board
 import displayio
+import fourwire
+import busdisplay
 import espcamera
 import microcontroller
 import neopixel
@@ -71,8 +73,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 +180,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._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 = 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
-        )
 
-        # 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 +246,39 @@ 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._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 +290,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 +324,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 +338,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):
@@ -383,9 +385,19 @@ def autofocus_init_from_bitstream(self, firmware: bytes):
             raise RuntimeError(f"Autofocus not supported on {self.camera.sensor_name}")
 
         self.write_camera_register(0x3000, 0x20)  # reset autofocus coprocessor
+        time.sleep(0.01)
 
-        for addr, val in enumerate(firmware):
-            self.write_camera_register(0x8000 + addr, val)
+        arr = bytearray(256)
+        with self._camera_device as i2c:
+            for offset in range(0, len(firmware), 254):
+                num_firmware_bytes = min(254, len(firmware) - offset)
+                reg = offset + 0x8000
+                arr[0] = reg >> 8
+                arr[1] = reg & 0xFF
+                arr[2 : 2 + num_firmware_bytes] = firmware[
+                    offset : offset + num_firmware_bytes
+                ]
+                i2c.write(arr, end=2 + num_firmware_bytes)
 
         self.write_camera_list(self._finalize_firmware_load)
         for _ in range(100):
@@ -526,26 +538,26 @@ 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._display_bus = fourwire.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
         # init specially since we are going to write directly below
-        self.display = displayio.Display(
+        self.display = busdisplay.BusDisplay(
             self._display_bus,
             self._INIT_SEQUENCE,
             width=240,
             height=240,
             colstart=80,
             auto_refresh=False,
+            backlight_pin=board.TFT_BACKLIGHT,
         )
         self.display.root_group = self.splash
         self.display.refresh()
@@ -562,7 +574,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 +584,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 +598,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 +618,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.
@@ -733,7 +752,7 @@ def continuous_capture(self):
         or the camera's capture mode is changed"""
         return self.camera.take(1)
 
-    def blit(self, bitmap):
+    def blit(self, bitmap, x_offset=0, y_offset=32):
         """Display a bitmap direct to the LCD, bypassing displayio
 
         This can be more efficient than displaying a bitmap as a displayio
@@ -744,8 +763,12 @@ def blit(self, bitmap):
         for status information.
         """
 
-        self._display_bus.send(42, struct.pack(">hh", 80, 80 + bitmap.width - 1))
-        self._display_bus.send(43, struct.pack(">hh", 32, 32 + bitmap.height - 1))
+        self._display_bus.send(
+            42, struct.pack(">hh", 80 + x_offset, 80 + x_offset + bitmap.width - 1)
+        )
+        self._display_bus.send(
+            43, struct.pack(">hh", y_offset, y_offset + bitmap.height - 1)
+        )
         self._display_bus.send(44, bitmap)
 
     @property
@@ -775,3 +798,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)