Remote Shutter Button for MEMENTO

by Ruiz Brothers and

published January 23, 2024, last updated January 23, 2024

posted in

Save Download

Updated

Beginner

Project guide

Overview

Minimize camera shake

You can build a remote shutter button for the Adafruit MEMENTO camera for taking still photos without having to manually press the onboard shutter switch!

This simple project uses a momentary push button to create an external remote for triggering the shutter button on the MEMENTO camera.

Focus and capture

Our 3D printed snap fit enclosure houses the button PCB and doubles as a handle so you can take photos without any camera shake.

This button PCB features an on-board JST PH connector making it easy to connect to the MEMENTO camera board.

Stomp button

The MEMENTO camera code in CircuitPython allows for easy customization allowing you to trigger the shutter in any number of ways.

We can use copper tape on cardboard to create a stomp button!

Prerequisite Guides

Take a moment to review the following guides to learn how to setup the MEMENTO.

Primary Guide: Adafruit MEMENTO Camera Board

Parts

MEMENTO - Python Programmable DIY Camera - Bare Board

Make memories, or just a cool camera-based project, with Adafruit's MEMENTO Camera Board. It's a development board with everything you need to create...

guides with product

$34.95

In Stock

Add to Cart

STEMMA Wired Tactile Push-Buttons connected to a half sized white breadboard

STEMMA Wired Tactile Push-Button Pack - 5 Color Pack

Little clicky switches are standard input "buttons" on electronic projects. These are just like our Colorful Round...

$7.50

In Stock

Add to Cart

Lithium Ion Polymer Battery 3.7v 420mAh with JST 2-PH connector and short cable

Lithium Ion Polymer Battery with Short Cable - 3.7V 420mAh

Lithium-ion polymer (also known as 'lipo' or 'lipoly') batteries are thin, light, and powerful. The output ranges from 4.2V when completely charged to 3.7V. This...

$6.95

In Stock

Add to Cart

Camera and Tripod 3/8" to 1/4" Adapter Screw

Whaddya got a screw loose or something?This 3/8" to 1/4" Adapter Screw is super handy if you're building projects that...

Out of Stock

256MB Micro SD Memory Card

Add storage in a jiffy using this 256MB microSD card. Preformatted to FAT32, so it works out of the packaging with our projects. Works great with any device in the...

$4.50

In Stock

Add to Cart

Angled shot of STEMMA JST PH 3-Pin to Male Header Cable - 200mm.

STEMMA JST PH 2mm 3-Pin to Male Header Cable - 200mm

This cable will let you turn a JST PH 3-pin cable port into 3 individual wires with high-quality 0.1" male header plugs on the end. We're carrying these to match up with our...

$1.25

In Stock

Add to Cart

1 x STEMMA JST PH 2mm 3-Pin to Female Socket Cable - 200mm

STEMMA JST PH 2mm 3-Pin to Female Socket Cable - 200mm

Add to Cart

1 x JST PH 2mm 3-pin Plug to Color Coded Alligator Clips Cable

JST PH 2mm 3-pin Plug to Color Coded Alligator Clips Cable

Add to Cart

1 x Copper Foil Tape with Conductive Adhesive - 6mm x 15 meter roll

Copper Foil Tape with Conductive Adhesive - 6mm x 15 meter roll

Add to Cart

1 x 28 AWG 3 Conductor Wire

Long cable - 28 AWG 3 Conductor Wire

Buy Now

1 x Pink and Purple Woven USB A to USB C Cable - 1 meter long

Pink and Purple Woven USB A to USB C Cable - 1 meter long

Add to Cart

Text editor powered by tinymce.

Install CircuitPython

CircuitPython is a derivative of MicroPython designed to simplify experimentation and education on low-cost microcontrollers. It makes it easier than ever to get prototyping by requiring no upfront desktop software downloads. Simply copy and edit files on the CIRCUITPY drive to iterate.

CircuitPython Quickstart

Follow this step-by-step to quickly get CircuitPython running on your board.

Make sure you use CircuitPython 9.0.0 final or later. CircuitPython 9.0.0-beta.1 and earlier have a bug that can corrupt the fileystem.

Download File

Copy Code

import storage
storage.erase_filesystem()

import storage
storage.erase_filesystem()

Your board will reboot after running this.

Download the latest version of CircuitPython for this board via circuitpython.org

As of CircuitPython 9, you'll need to create a folder called "sd" on your CIRCUITPY drive to mount the microSD card, if it's not already there.

Follow these steps to create the /sd directory

install_circuitpython_on_most_boards_CircuitPython_downloaded.jpg

Click the link above to download the latest CircuitPython UF2 file.

Save it wherever is convenient for you.

Plug your board into your computer, using a known-good data-sync cable, directly, or via an adapter if needed.

Double-click the reset button (highlighted in red above), and you will see the RGB status LED(s) turn green (highlighted in green above). If you see red, try another port, or if you're using an adapter or hub, try without the hub, or different adapter or hub.

For this board, tap reset and wait for the LED to turn purple, and as soon as it turns purple, tap reset again. The second tap needs to happen while the LED is still purple.

If you do not see the LED turning purple, you will need to reinstall the UF2 bootloader. See the Factory Reset page in this guide for details.

If double-clicking doesn't work the first time, try again. Sometimes it can take a few tries to get the rhythm right!

A lot of people end up using charge-only USB cables and it is very frustrating! Make sure you have a USB cable you know is good for data sync.

You will see a new disk drive appear called CAMERABOOT. Drag the adafruit-circuitpython-adafruit_esp32s3_camera-etc.uf2 file to CAMERABOOT.

The BOOT drive will disappear and a new disk drive called CIRCUITPY will appear.

That's it!

Text editor powered by tinymce.

Code

Once you've finished setting up your MEMENTO with CircuitPython, you can access the code and necessary libraries by downloading the Project Bundle.

To do this, click on the Download Project Bundle button in the window below. It will download to your computer as a zipped folder.

Download Project Bundle

Copy Code

# SPDX-FileCopyrightText: 2023 Jeff Epler for Adafruit Industries
#
# SPDX-License-Identifier: Unlicense

import time
import board
import bitmaptools
import displayio
import gifio
import ulab.numpy as np
from adafruit_debouncer import Button
import adafruit_pycamera
from digitalio import DigitalInOut, Direction, Pull

pycam = adafruit_pycamera.PyCamera()
# pycam.live_preview_mode()

settings = (None, "resolution", "effect", "mode", "led_level", "led_color")
curr_setting = 0

pin = DigitalInOut(board.A0)
pin.direction = Direction.INPUT
pin.pull = Pull.UP
ext_button = Button(pin, long_duration_ms=1000)

print("Starting!")
# pycam.tone(200, 0.1)
last_frame = displayio.Bitmap(pycam.camera.width, pycam.camera.height, 65535)
onionskin = displayio.Bitmap(pycam.camera.width, pycam.camera.height, 65535)
while True:
    if pycam.mode_text == "STOP" and pycam.stop_motion_frame != 0:
        # alpha blend
        new_frame = pycam.continuous_capture()
        bitmaptools.alphablend(
            onionskin, last_frame, new_frame, displayio.Colorspace.RGB565_SWAPPED
        )
        pycam.blit(onionskin)
    elif pycam.mode_text == "GBOY":
        bitmaptools.dither(
            last_frame, pycam.continuous_capture(), displayio.Colorspace.RGB565_SWAPPED
        )
        pycam.blit(last_frame)
    else:
        pycam.blit(pycam.continuous_capture())
    # print("\t\t", capture_time, blit_time)

    pycam.keys_debounce()
    ext_button.update()
    # test shutter button
    if pycam.shutter.long_press or ext_button.long_press:
        print("FOCUS")
        print(pycam.autofocus_status)
        pycam.autofocus()
        print(pycam.autofocus_status)
    if pycam.shutter.short_count or ext_button.short_count:
        print("Shutter released")
        if pycam.mode_text == "STOP":
            pycam.capture_into_bitmap(last_frame)
            pycam.stop_motion_frame += 1
            try:
                pycam.display_message("Snap!", color=0x0000FF)
                pycam.capture_jpeg()
            except TypeError as e:
                pycam.display_message("Failed", color=0xFF0000)
                time.sleep(0.5)
            except RuntimeError as e:
                pycam.display_message("Error\nNo SD Card", color=0xFF0000)
                time.sleep(0.5)
            pycam.live_preview_mode()

        if pycam.mode_text == "GBOY":
            try:
                f = pycam.open_next_image("gif")
            except RuntimeError as e:
                pycam.display_message("Error\nNo SD Card", color=0xFF0000)
                time.sleep(0.5)
                continue

            with gifio.GifWriter(
                f,
                pycam.camera.width,
                pycam.camera.height,
                displayio.Colorspace.RGB565_SWAPPED,
                dither=True,
            ) as g:
                g.add_frame(last_frame, 1)

        if pycam.mode_text == "GIF":
            try:
                f = pycam.open_next_image("gif")
            except RuntimeError as e:
                pycam.display_message("Error\nNo SD Card", color=0xFF0000)
                time.sleep(0.5)
                continue
            i = 0
            ft = []
            pycam._mode_label.text = "RECORDING"  # pylint: disable=protected-access

            pycam.display.refresh()
            with gifio.GifWriter(
                f,
                pycam.camera.width,
                pycam.camera.height,
                displayio.Colorspace.RGB565_SWAPPED,
                dither=True,
            ) as g:
                t00 = t0 = time.monotonic()
                while (i < 15) or not pycam.shutter_button.value:
                    i += 1
                    _gifframe = pycam.continuous_capture()
                    g.add_frame(_gifframe, 0.12)
                    pycam.blit(_gifframe)
                    t1 = time.monotonic()
                    ft.append(1 / (t1 - t0))
                    print(end=".")
                    t0 = t1
            pycam._mode_label.text = "GIF"  # pylint: disable=protected-access
            print(f"\nfinal size {f.tell()} for {i} frames")
            print(f"average framerate {i/(t1-t00)}fps")
            print(f"best {max(ft)} worst {min(ft)} std. deviation {np.std(ft)}")
            f.close()
            pycam.display.refresh()

        if pycam.mode_text == "JPEG":
            pycam.tone(200, 0.1)
            try:
                pycam.display_message("Snap!", color=0x0000FF)
                pycam.capture_jpeg()
                pycam.live_preview_mode()
            except TypeError as e:
                pycam.display_message("Failed", color=0xFF0000)
                time.sleep(0.5)
                pycam.live_preview_mode()
            except RuntimeError as e:
                pycam.display_message("Error\nNo SD Card", color=0xFF0000)
                time.sleep(0.5)
    if pycam.card_detect.fell:
        print("SD card removed")
        pycam.unmount_sd_card()
        pycam.display.refresh()
    if pycam.card_detect.rose:
        print("SD card inserted")
        pycam.display_message("Mounting\nSD Card", color=0xFFFFFF)
        for _ in range(3):
            try:
                print("Mounting card")
                pycam.mount_sd_card()
                print("Success!")
                break
            except OSError as e:
                print("Retrying!", e)
                time.sleep(0.5)
        else:
            pycam.display_message("SD Card\nFailed!", color=0xFF0000)
            time.sleep(0.5)
        pycam.display.refresh()

    if pycam.up.fell:
        print("UP")
        key = settings[curr_setting]
        if key:
            setattr(pycam, key, getattr(pycam, key) + 1)
    if pycam.down.fell:
        print("DN")
        key = settings[curr_setting]
        if key:
            setattr(pycam, key, getattr(pycam, key) - 1)
    if pycam.left.fell:
        print("LF")
        curr_setting = (curr_setting + 1) % len(settings)
        print(settings[curr_setting])
        # new_res = min(len(pycam.resolutions)-1, pycam.get_resolution()+1)
        # pycam.set_resolution(pycam.resolutions[new_res])
        pycam.select_setting(settings[curr_setting])
    if pycam.right.fell:
        print("RT")
        curr_setting = (curr_setting - 1 + len(settings)) % len(settings)
        print(settings[curr_setting])
        pycam.select_setting(settings[curr_setting])
        # new_res = max(1, pycam.get_resolution()-1)
        # pycam.set_resolution(pycam.resolutions[new_res])
    if pycam.select.fell:
        print("SEL")
    if pycam.ok.fell:
        print("OK")

# SPDX-FileCopyrightText: 2023 Jeff Epler for Adafruit Industries
#
# SPDX-License-Identifier: Unlicense

import time
import board
import bitmaptools
import displayio
import gifio
import ulab.numpy as np
from adafruit_debouncer import Button
import adafruit_pycamera
from digitalio import DigitalInOut, Direction, Pull

pycam = adafruit_pycamera.PyCamera()
# pycam.live_preview_mode()

settings = (None, "resolution", "effect", "mode", "led_level", "led_color")
curr_setting = 0

pin = DigitalInOut(board.A0)
pin.direction = Direction.INPUT
pin.pull = Pull.UP
ext_button = Button(pin, long_duration_ms=1000)

print("Starting!")
# pycam.tone(200, 0.1)
last_frame = displayio.Bitmap(pycam.camera.width, pycam.camera.height, 65535)
onionskin = displayio.Bitmap(pycam.camera.width, pycam.camera.height, 65535)
while True:
    if pycam.mode_text == "STOP" and pycam.stop_motion_frame != 0:
        # alpha blend
        new_frame = pycam.continuous_capture()
        bitmaptools.alphablend(
            onionskin, last_frame, new_frame, displayio.Colorspace.RGB565_SWAPPED
        )
        pycam.blit(onionskin)
    elif pycam.mode_text == "GBOY":
        bitmaptools.dither(
            last_frame, pycam.continuous_capture(), displayio.Colorspace.RGB565_SWAPPED
        )
        pycam.blit(last_frame)
    else:
        pycam.blit(pycam.continuous_capture())
    # print("\t\t", capture_time, blit_time)

    pycam.keys_debounce()
    ext_button.update()
    # test shutter button
    if pycam.shutter.long_press or ext_button.long_press:
        print("FOCUS")
        print(pycam.autofocus_status)
        pycam.autofocus()
        print(pycam.autofocus_status)
    if pycam.shutter.short_count or ext_button.short_count:
        print("Shutter released")
        if pycam.mode_text == "STOP":
            pycam.capture_into_bitmap(last_frame)
            pycam.stop_motion_frame += 1
            try:
                pycam.display_message("Snap!", color=0x0000FF)
                pycam.capture_jpeg()
            except TypeError as e:
                pycam.display_message("Failed", color=0xFF0000)
                time.sleep(0.5)
            except RuntimeError as e:
                pycam.display_message("Error\nNo SD Card", color=0xFF0000)
                time.sleep(0.5)
            pycam.live_preview_mode()

        if pycam.mode_text == "GBOY":
            try:
                f = pycam.open_next_image("gif")
            except RuntimeError as e:
                pycam.display_message("Error\nNo SD Card", color=0xFF0000)
                time.sleep(0.5)
                continue

            with gifio.GifWriter(
                f,
                pycam.camera.width,
                pycam.camera.height,
                displayio.Colorspace.RGB565_SWAPPED,
                dither=True,
            ) as g:
                g.add_frame(last_frame, 1)

        if pycam.mode_text == "GIF":
            try:
                f = pycam.open_next_image("gif")
            except RuntimeError as e:
                pycam.display_message("Error\nNo SD Card", color=0xFF0000)
                time.sleep(0.5)
                continue
            i = 0
            ft = []
            pycam._mode_label.text = "RECORDING"  # pylint: disable=protected-access

            pycam.display.refresh()
            with gifio.GifWriter(
                f,
                pycam.camera.width,
                pycam.camera.height,
                displayio.Colorspace.RGB565_SWAPPED,
                dither=True,
            ) as g:
                t00 = t0 = time.monotonic()
                while (i < 15) or not pycam.shutter_button.value:
                    i += 1
                    _gifframe = pycam.continuous_capture()
                    g.add_frame(_gifframe, 0.12)
                    pycam.blit(_gifframe)
                    t1 = time.monotonic()
                    ft.append(1 / (t1 - t0))
                    print(end=".")
                    t0 = t1
            pycam._mode_label.text = "GIF"  # pylint: disable=protected-access
            print(f"\nfinal size {f.tell()} for {i} frames")
            print(f"average framerate {i/(t1-t00)}fps")
            print(f"best {max(ft)} worst {min(ft)} std. deviation {np.std(ft)}")
            f.close()
            pycam.display.refresh()

        if pycam.mode_text == "JPEG":
            pycam.tone(200, 0.1)
            try:
                pycam.display_message("Snap!", color=0x0000FF)
                pycam.capture_jpeg()
                pycam.live_preview_mode()
            except TypeError as e:
                pycam.display_message("Failed", color=0xFF0000)
                time.sleep(0.5)
                pycam.live_preview_mode()
            except RuntimeError as e:
                pycam.display_message("Error\nNo SD Card", color=0xFF0000)
                time.sleep(0.5)
    if pycam.card_detect.fell:
        print("SD card removed")
        pycam.unmount_sd_card()
        pycam.display.refresh()
    if pycam.card_detect.rose:
        print("SD card inserted")
        pycam.display_message("Mounting\nSD Card", color=0xFFFFFF)
        for _ in range(3):
            try:
                print("Mounting card")
                pycam.mount_sd_card()
                print("Success!")
                break
            except OSError as e:
                print("Retrying!", e)
                time.sleep(0.5)
        else:
            pycam.display_message("SD Card\nFailed!", color=0xFF0000)
            time.sleep(0.5)
        pycam.display.refresh()

    if pycam.up.fell:
        print("UP")
        key = settings[curr_setting]
        if key:
            setattr(pycam, key, getattr(pycam, key) + 1)
    if pycam.down.fell:
        print("DN")
        key = settings[curr_setting]
        if key:
            setattr(pycam, key, getattr(pycam, key) - 1)
    if pycam.left.fell:
        print("LF")
        curr_setting = (curr_setting + 1) % len(settings)
        print(settings[curr_setting])
        # new_res = min(len(pycam.resolutions)-1, pycam.get_resolution()+1)
        # pycam.set_resolution(pycam.resolutions[new_res])
        pycam.select_setting(settings[curr_setting])
    if pycam.right.fell:
        print("RT")
        curr_setting = (curr_setting - 1 + len(settings)) % len(settings)
        print(settings[curr_setting])
        pycam.select_setting(settings[curr_setting])
        # new_res = max(1, pycam.get_resolution()-1)
        # pycam.set_resolution(pycam.resolutions[new_res])
    if pycam.select.fell:
        print("SEL")
    if pycam.ok.fell:
        print("OK")

Upload the Code and Libraries to the MEMENTO

After downloading the Project Bundle, plug your MEMENTO into the computer's USB port with a known good USB data+power cable. You should see a new flash drive appear in the computer's File Explorer or Finder (depending on your operating system) called CIRCUITPY. Unzip the folder and copy the following items to the MEMENTO's CIRCUITPY drive.

lib folder
code.py

Your MEMENTO CIRCUITPY drive should look like this after copying the lib folder and the code.py file.

How the CircuitPython Code Works

The code consists of the Fancy Camera example from the PyCamera library written by Jeff Epler with some minor modifications to add in the external shutter button. The A0 pin is instantiated as an input and passed as a Button object with a long_press interval of one second.

Download File

Copy Code

pin = DigitalInOut(board.A0)
pin.direction = Direction.INPUT
pin.pull = Pull.UP
ext_button = Button(pin, long_duration_ms=1000)

pin = DigitalInOut(board.A0)
pin.direction = Direction.INPUT
pin.pull = Pull.UP
ext_button = Button(pin, long_duration_ms=1000)

In the loop, the ext_button is checked for either a long or short press alongside the shutter button on the MEMENTO. A short press takes a photo and a long press focuses.

Download File

Copy Code

pycam.keys_debounce()
ext_button.update()
# test shutter button
if pycam.shutter.long_press or ext_button.long_press:
  print("FOCUS")
  print(pycam.autofocus_status)
  pycam.autofocus()
  print(pycam.autofocus_status)
if pycam.shutter.short_count or ext_button.short_count:

pycam.keys_debounce()
ext_button.update()
# test shutter button
if pycam.shutter.long_press or ext_button.long_press:
  print("FOCUS")
  print(pycam.autofocus_status)
  pycam.autofocus()
  print(pycam.autofocus_status)
if pycam.shutter.short_count or ext_button.short_count:

Otherwise, the code is identical to the Fancy Camera example, leaving all of the excellent functionality in place.

Text editor powered by tinymce.

Circuit Diagram

The diagram below provides a general visual reference for wiring of the components once you get to the Assembly page. This diagram was created using the software package Fritzing.

Adafruit Library for Fritzing

Adafruit uses the Adafruit's Fritzing parts library to create circuit diagrams for projects. You can download the library or just grab individual parts. Get the library and parts from GitHub - Adafruit Fritzing Parts.

Text editor powered by tinymce.

3D Printing

3D Printed Parts

STL files for 3D printing are oriented to print "as-is" on FDM style machines.

Parts are designed to 3D print without any support material using PLA filament.

Original design source files may be downloaded using the links below.

Shutter Button Case

MEMENTO Case Ports

Download STLs

Slice with Settings for PLA material

The parts were sliced using CURA using the slice settings below.

PLA filament 200c extruder
0.2 layer height
10% gyroid infill
60mm/s print speed
60c heated bed

Text editor powered by tinymce.

Assemble

Two button types

Build the remote case version or this alternate cardboard stomp switch. This demonstrates you can craft your own shutter remote with copper tape and a piece of cardboard.

Remote Case

Use 3 Pin JST wires to plug into the MEMENTO.

Measure and cut wires. Add heat shrink tubing to help bundle the wires before soldering cables together.

Camera Case

Align the MEMENTO board to the cutouts on the printed case.

The camera case exposes the ports so you can plug in external components and additional sensors.

Tactile Button

Align the nubs on the printed case to the screw holes on the Tactile push button PCB.

Place the printed lid over the case and press fit to the case.

Tripod screw

An optional 3/8 to 25/20 thread screw fits to attach a tripod.

Use a flat head or the end of tweezers to thread the adapter.

Cardboard stomp button

Use strips on copper table on a folded cardboard to create a stomp button of any size.

Use Alligator Clips Cables to "connect" to the copper strips.

Plug the other ends of the cables into into the outer two pins of the MEMENTO A0 port. (Polarity doesn't matter here, either cable can plug into either pin).

Then, to trigger the camera shutter, simple "stomp" on the cardboard so the two copper strips make contact with each other.