MEMENTO Camera Quick Start Guide

by Anne Barela and

published March 18, 2024, last updated March 18, 2024

posted in Sensors/ Camera CircuitPython AdaBox

Save Download

Updated

Beginner

Project guide

Overview

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 programmable camera and vision projects: with a camera module, TFT preview screen, buttons, SD card slot and driven by a powerful ESP32-S3 processor with 2 MB of PSRAM for buffering 5 MegaPixel camera images.

This guide will focus on (pun intended) getting you familiar with using various functionality available with the MEMENTO camera.

It's time to get started by getting your MEMENTO assembled and powered on.

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

Overhead shot of two square-shaped PCB boards for a DIY camera above eight black plastic screws and four black plastic hex nuts with 3pin to 3pin JST PH cable and adhesive sticker.

Adafruit MEMENTO Camera Enclosure & Hardware Kit

Once you've picked up your MEMENTO Camera and you're ready to take it out into the world, here is a chic and minimalist enclosure that will look great on the...

guides with product

Out of Stock

USB Type A to Type C Cable - approx 1 meter / 3 ft long

As technology changes and adapts, so does Adafruit. This USB Type A to Type C cable will help you with the transition to USB C, even if you're still...

$4.95

In Stock

Add to Cart

Text editor powered by tinymce.

Parts, Assembly, and Power On

Your MEMENTO camera comes unassembled. Make sure you have all the pieces needed to assemble your camera.

Assemble MEMENTO per the guide page below.

AdaBox 021

By John Park

MEMENTO Assembly

View Guide

Inserting a microSD Card

The maximum size microSD card MEMENTO can use is 32GB. Smaller sizes are fine. Please do not use a card larger than 32GB.

If you see the MEMENTO powered on at this point (the screen is on), slide the switch marked ➡On to the left, towards the upper left corner of the camera. The display should go dark and the green LED next to the switch should not be lit.

Inserting or removing the microSD card should be done with the MEMENTO powered OFF. If the power is ON, it risks corrupting the microSD card. This would necessitate reformatting the card in a computer and losing the stored files.

With the MEMENTO powered off, take a microSD card with the non-straight edge to the right and printing on top (gold contacts on the bottom), insert the card into the slot where microSD is printed on the back of the camera.

It is below the connector used to provide power and signal to the lights on the front of the camera (if installed). On the rear of the camera its labeled microSD. It's a small slot so it may be a bit hard to see at first.

See the orientation of the card in relation to the slot.

Orient the micro SD card as shown and press it into the SD card reader slot -- you'll press it all the way in until it clicks and stops and then as you let off the pressure it'll click a second time.

If it seems to not seat, remove the card and try again.

Power On

With your MEMENTO fully assembled, look on the top left from the rear of the camera. There is a slide switch marked ➡On. Using your fingernail, slide the switch towards the right.

When you want to turn the camera off, slide the same switch towards the left and watch for the display to power off.

When the camera is off, it is safe to remove the microSD card by pressing on the edge, waiting for it to disengage, then gently pulling it out.

Text editor powered by tinymce.

Charging the Battery

During assembly, the battery was plugged into the MEMENTO main board before sandwiching on the rear cover.

The battery need not be removed under normal use. It is rechargeable.

To charge the battery, simply plug in a USB-C cable into the USB-C port on the left side of the camera. The back of the MEMENTO shows "USB-C" where the jack is located.

Plug the other end of the cable into either a USB charging block, a computer USB port, or a USB battery power bank (often called a "lipstick" battery, used to charge mobile phones).

While the camera battery is charging, the tiny yellow light near the USB-C port will be lit yellow. The camera does not need to be on to show the charging status light.

When the battery is fully charged, that yellow LED light will be off.

You can use your MEMENTO even while the battery is charging.

Battery Status

The default stock camera program loaded on MEMENTO from the factory displays the battery voltage. The battery sinking from the full charge 3.7 volts can provide indication of the battery needing a charge.

The CircuitPython Fancy Camera app does not currently have a battery indicator but one could be added by the user.

Text editor powered by tinymce.

The Stock Camera App

When you assemble the MEMENTO and turn it on, it will run a basic camera application from the factory. It is a perfectly functional basic camera.

More advanced functionality will be obtained when loading the camera with CircuitPython and CircuitPython apps.

This page documents the factory software for your information. It is recommended you use the alternative CircuitPython apps listed later in this guide to gain other capabilities.

The microSD Card

The images are stored on the inserted microSD card inserted into the slot in the lower right portion of the camera looking at the rear.

When inserting or removing a microSD card with MEMENTO, please ensure the camera is powered off to avoid any possibility of data corruption.

Note that the microSD card must be 32GB or less. Cards greater than 32GB will not work.

With the MEMENTO power off, take a microSD card with the non-straight edge to the right and printing on top (gold contacts on the bottom), insert the card into the slot where microSD is printed on the back of the camera. It is below the connector used to provide power and signal to the lights on the front of the camera (if installed).

Insert the card loosely, wiggle if it feels tight. Do not force it, if it will not go in, check for the correct orientation.

Press the card in until it clicks. Do not force it if it appears to not want to go in - in that case remove the card, check the orientation, and try again.

If Your microSD Card is Not Formatted Prior to Use

Refer to the page below on formatting the card you are not using a formatted microSD card. If you have a fresh microSD card from Adafruit, it should already be formatted (although suppliers can miss it and it may need formatting).

Adafruit MEMENTO Camera Board

By Liz Clark

microSD Card Formatting Notes

View Guide

Turning On Your Camera

With your MEMENTO camera fully assembled, look on the top left. There is a slide switch marked ➡On. Using your fingernail, slide the switch towards the right.

The display will then show what the camera sees. A small green LED next to the power switch will be on.

If the green LED isn't on, and the display is dark, see the previous page about charging the battery.

Taking a Picture

The LCD display on the rear frames the shot.

Press the shutter button to take a picture. It's located at the top of the camera to the right.

Images are numbered sequentially IMAGE0000.jpg, IMAGE0001.jpg, etc. on the microSD card.

To download the images, you'll need to remove the microSD card. How to do this is as follows:

Do not remove the microSD card while the camera is turned on. Turn MEMENTO off using the slide switch on the top left of the camera. The display will go dark, indicating it is off.

Turn your MEMENTO off by sliding the power switch to the left. The display and any LEDs seen from the top should go dark.

Once the camera is off, you can gently push on the microSD card and it will disengage and can be removed. You can insert the card in a USB card reader and connect that to your computer to view the picture files.

Be sure to put the microSD back in the MEMENTO before trying out the settings listed below.

Changing Settings

The four buttons in a diamond pattern on the rear of the camera allow you to make settings adjustments.

Image Resolution

The current resolution is shown overlaid near the bottom of the screen. Above, the circled in red text shows "Size: 1024x768".

The Up button changes the image resolution from the base 640x480 (default) to one of the following:

160x120
320x240
480x320
640x480
800x640
1024x768
1280x720
1280x1024
1600x1200
2048x1536
2560x1920 (highest)

For the best picture quality, select 2560x1920. 640x480 images are about 50k bytes, 160x120 images are about 6kb. 2560x1920 images are about 320kb. Actual sizes will vary depending on the subject and JPEG compression.

Filters

The filter has been changed in the image shown here to save images as yellow tinted (sepia).

The Left and Right buttons in the four button cluster control various filters. When the camera is powered on, there is no filter applied, it is a standard color image.

The Right button cycles through various filters: sepia (yellow), blue, green, red, greyscale, reverse image and back to normal. The Left button cycles through the same effects in the reverse direction.

The stock application has limited ways to change settings. If you want more advanced functions, continue reading this guide's subsequent pages for using the CircuitPython app.

Software to Revert to Factory Functionality

Customers often ask for the software to get a product back to the working state from the factory. Follow the guide page listed below.

Adafruit MEMENTO Camera Board

By Liz Clark

Factory Reset

View Guide

The source for the factory code is available on GitHub:

Factory Basic Camera Code (Arduino)

NOTE: the firmware that ships with your MEMENTO may not have LED ring functions enabled -- you can add this by updating to the Factory Reset UF2 in the MEMENTO main guide, or by switching to CircuitPython and the "fancy camera" example in the adafruit_pycamera library.

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.

Install the CircuitPython Fancy Camera App

This example from the Adafruit CircuitPython PyCamera library is similar to the Basic Camera, but adds autofocus and on-camera user interaction via the MEMENTO's buttons to give you more of a point-and-shoot camera experience.

You can use the buttons to adjust:

resolutions
effects
modes
optional NeoPixel LED colors

Format your SD card if necessary and insert it in the MEMENTO SD card reader as shown on the Basic Camera page.

CircuitPython

Be sure you've installed CircuitPython on your MEMENTO before proceeding.

Download the Project Bundle

Your project will use a specific set of CircuitPython libraries, and the code.py file. To get everything you need, click on the Download Project Bundle button below, and uncompress the .zip file.

Connect your computer to the board via a known good USB power+data cable. A new flash drive should show up as CIRCUITPY.

adafruit_products_Screenshot_2024-02-26_at_8.10.59_AM.jpg

Drag the contents of the uncompressed bundle directory for the version of CircuitPython you're running (e.g., /examples/camera/CircuitPython 9.x/) onto your board's CIRCUITPY drive, replacing any existing files or directories with the same names, and adding any new ones that are necessary.

Download Project Bundle

Copy Code

# SPDX-FileCopyrightText: 2023 Jeff Epler for Adafruit Industries
# SPDX-FileCopyrightText: 2023 Limor Fried for Adafruit Industries
#
# SPDX-License-Identifier: Unlicense
import ssl
import os
import time
import socketpool
import adafruit_requests
import rtc
import adafruit_ntp
import wifi
import bitmaptools
import displayio
import gifio
import ulab.numpy as np

import adafruit_pycamera

# Wifi details are in settings.toml file, also,
# timezone info should be included to allow local time and DST adjustments
# # UTC_OFFSET, if present, will override TZ and DST and no API query will be done
# UTC_OFFSET=-25200
# # TZ="America/Phoenix"

UTC_OFFSET = os.getenv("UTC_OFFSET")
TZ = os.getenv("TZ")

print(f"Connecting to {os.getenv('CIRCUITPY_WIFI_SSID')}")
SSID = os.getenv("CIRCUITPY_WIFI_SSID")
PASSWORD = os.getenv("CIRCUITPY_WIFI_PASSWORD")

if SSID and PASSWORD:
    wifi.radio.connect(
        os.getenv("CIRCUITPY_WIFI_SSID"), os.getenv("CIRCUITPY_WIFI_PASSWORD")
    )
    if wifi.radio.connected:
        print(f"Connected to {os.getenv('CIRCUITPY_WIFI_SSID')}!")
        print("My IP address is", wifi.radio.ipv4_address)
        pool = socketpool.SocketPool(wifi.radio)

        if UTC_OFFSET is None:
            requests = adafruit_requests.Session(pool, ssl.create_default_context())
            response = requests.get("http://worldtimeapi.org/api/timezone/" + TZ)
            response_as_json = response.json()
            UTC_OFFSET = response_as_json["raw_offset"] + response_as_json["dst_offset"]
            print(f"UTC_OFFSET: {UTC_OFFSET}")

        ntp = adafruit_ntp.NTP(
            pool, server="pool.ntp.org", tz_offset=UTC_OFFSET // 3600
        )

        print(f"ntp time: {ntp.datetime}")
        rtc.RTC().datetime = ntp.datetime
    else:
        print("Wifi failed to connect. Time not set.")
else:
    print("Wifi config not found in settintgs.toml. Time not set.")

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

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

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)
timelapse_remaining = None
timelapse_timestamp = None

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)
    elif pycam.mode_text == "LAPS":
        if timelapse_remaining is None:
            pycam.timelapsestatus_label.text = "STOP"
        else:
            timelapse_remaining = timelapse_timestamp - time.time()
            pycam.timelapsestatus_label.text = f"{timelapse_remaining}s /    "
        # Manually updating the label text a second time ensures that the label
        # is re-painted over the blitted preview.
        pycam.timelapse_rate_label.text = pycam.timelapse_rate_label.text
        pycam.timelapse_submode_label.text = pycam.timelapse_submode_label.text

        # only in high power mode do we continuously preview
        if (timelapse_remaining is None) or (
            pycam.timelapse_submode_label.text == "HiPwr"
        ):
            pycam.blit(pycam.continuous_capture())
        if pycam.timelapse_submode_label.text == "LowPwr" and (
            timelapse_remaining is not None
        ):
            pycam.display.brightness = 0.05
        else:
            pycam.display.brightness = 1
        pycam.display.refresh()

        if timelapse_remaining is not None and timelapse_remaining <= 0:
            # no matter what, show what was just on the camera
            pycam.blit(pycam.continuous_capture())
            # pycam.tone(200, 0.1) # uncomment to add a beep when a photo is taken
            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()
            pycam.display.refresh()
            pycam.blit(pycam.continuous_capture())
            timelapse_timestamp = (
                time.time() + pycam.timelapse_rates[pycam.timelapse_rate] + 1
            )
    else:
        pycam.blit(pycam.continuous_capture())
    # print("\t\t", capture_time, blit_time)

    pycam.keys_debounce()
    # test shutter button
    if pycam.shutter.long_press:
        print("FOCUS")
        print(pycam.autofocus_status)
        pycam.autofocus()
        print(pycam.autofocus_status)
    if pycam.shutter.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:
            print("getting", key, getattr(pycam, 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.right.fell:
        print("RT")
        curr_setting = (curr_setting + 1) % len(settings)
        if pycam.mode_text != "LAPS" and settings[curr_setting] == "timelapse_rate":
            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.left.fell:
        print("LF")
        curr_setting = (curr_setting - 1 + len(settings)) % len(settings)
        if pycam.mode_text != "LAPS" and settings[curr_setting] == "timelaps_rate":
            curr_setting = (curr_setting + 1) % 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.mode_text == "LAPS":
            pycam.timelapse_submode += 1
            pycam.display.refresh()
    if pycam.ok.fell:
        print("OK")
        if pycam.mode_text == "LAPS":
            if timelapse_remaining is None:  # stopped
                print("Starting timelapse")
                timelapse_remaining = pycam.timelapse_rates[pycam.timelapse_rate]
                timelapse_timestamp = time.time() + timelapse_remaining + 1
                # dont let the camera take over auto-settings
                saved_settings = pycam.get_camera_autosettings()
                # print(f"Current exposure {saved_settings=}")
                pycam.set_camera_exposure(saved_settings["exposure"])
                pycam.set_camera_gain(saved_settings["gain"])
                pycam.set_camera_wb(saved_settings["wb"])
            else:  # is running, turn off
                print("Stopping timelapse")

                timelapse_remaining = None
                pycam.camera.exposure_ctrl = True
                pycam.set_camera_gain(None)  # go back to autogain
                pycam.set_camera_wb(None)  # go back to autobalance
                pycam.set_camera_exposure(None)  # go back to auto shutter

# SPDX-FileCopyrightText: 2023 Jeff Epler for Adafruit Industries
# SPDX-FileCopyrightText: 2023 Limor Fried for Adafruit Industries
#
# SPDX-License-Identifier: Unlicense
import ssl
import os
import time
import socketpool
import adafruit_requests
import rtc
import adafruit_ntp
import wifi
import bitmaptools
import displayio
import gifio
import ulab.numpy as np

import adafruit_pycamera

# Wifi details are in settings.toml file, also,
# timezone info should be included to allow local time and DST adjustments
# # UTC_OFFSET, if present, will override TZ and DST and no API query will be done
# UTC_OFFSET=-25200
# # TZ="America/Phoenix"

UTC_OFFSET = os.getenv("UTC_OFFSET")
TZ = os.getenv("TZ")

print(f"Connecting to {os.getenv('CIRCUITPY_WIFI_SSID')}")
SSID = os.getenv("CIRCUITPY_WIFI_SSID")
PASSWORD = os.getenv("CIRCUITPY_WIFI_PASSWORD")

if SSID and PASSWORD:
    wifi.radio.connect(
        os.getenv("CIRCUITPY_WIFI_SSID"), os.getenv("CIRCUITPY_WIFI_PASSWORD")
    )
    if wifi.radio.connected:
        print(f"Connected to {os.getenv('CIRCUITPY_WIFI_SSID')}!")
        print("My IP address is", wifi.radio.ipv4_address)
        pool = socketpool.SocketPool(wifi.radio)

        if UTC_OFFSET is None:
            requests = adafruit_requests.Session(pool, ssl.create_default_context())
            response = requests.get("http://worldtimeapi.org/api/timezone/" + TZ)
            response_as_json = response.json()
            UTC_OFFSET = response_as_json["raw_offset"] + response_as_json["dst_offset"]
            print(f"UTC_OFFSET: {UTC_OFFSET}")

        ntp = adafruit_ntp.NTP(
            pool, server="pool.ntp.org", tz_offset=UTC_OFFSET // 3600
        )

        print(f"ntp time: {ntp.datetime}")
        rtc.RTC().datetime = ntp.datetime
    else:
        print("Wifi failed to connect. Time not set.")
else:
    print("Wifi config not found in settintgs.toml. Time not set.")

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

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

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)
timelapse_remaining = None
timelapse_timestamp = None

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)
    elif pycam.mode_text == "LAPS":
        if timelapse_remaining is None:
            pycam.timelapsestatus_label.text = "STOP"
        else:
            timelapse_remaining = timelapse_timestamp - time.time()
            pycam.timelapsestatus_label.text = f"{timelapse_remaining}s /    "
        # Manually updating the label text a second time ensures that the label
        # is re-painted over the blitted preview.
        pycam.timelapse_rate_label.text = pycam.timelapse_rate_label.text
        pycam.timelapse_submode_label.text = pycam.timelapse_submode_label.text

        # only in high power mode do we continuously preview
        if (timelapse_remaining is None) or (
            pycam.timelapse_submode_label.text == "HiPwr"
        ):
            pycam.blit(pycam.continuous_capture())
        if pycam.timelapse_submode_label.text == "LowPwr" and (
            timelapse_remaining is not None
        ):
            pycam.display.brightness = 0.05
        else:
            pycam.display.brightness = 1
        pycam.display.refresh()

        if timelapse_remaining is not None and timelapse_remaining <= 0:
            # no matter what, show what was just on the camera
            pycam.blit(pycam.continuous_capture())
            # pycam.tone(200, 0.1) # uncomment to add a beep when a photo is taken
            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()
            pycam.display.refresh()
            pycam.blit(pycam.continuous_capture())
            timelapse_timestamp = (
                time.time() + pycam.timelapse_rates[pycam.timelapse_rate] + 1
            )
    else:
        pycam.blit(pycam.continuous_capture())
    # print("\t\t", capture_time, blit_time)

    pycam.keys_debounce()
    # test shutter button
    if pycam.shutter.long_press:
        print("FOCUS")
        print(pycam.autofocus_status)
        pycam.autofocus()
        print(pycam.autofocus_status)
    if pycam.shutter.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:
            print("getting", key, getattr(pycam, 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.right.fell:
        print("RT")
        curr_setting = (curr_setting + 1) % len(settings)
        if pycam.mode_text != "LAPS" and settings[curr_setting] == "timelapse_rate":
            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.left.fell:
        print("LF")
        curr_setting = (curr_setting - 1 + len(settings)) % len(settings)
        if pycam.mode_text != "LAPS" and settings[curr_setting] == "timelaps_rate":
            curr_setting = (curr_setting + 1) % 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.mode_text == "LAPS":
            pycam.timelapse_submode += 1
            pycam.display.refresh()
    if pycam.ok.fell:
        print("OK")
        if pycam.mode_text == "LAPS":
            if timelapse_remaining is None:  # stopped
                print("Starting timelapse")
                timelapse_remaining = pycam.timelapse_rates[pycam.timelapse_rate]
                timelapse_timestamp = time.time() + timelapse_remaining + 1
                # dont let the camera take over auto-settings
                saved_settings = pycam.get_camera_autosettings()
                # print(f"Current exposure {saved_settings=}")
                pycam.set_camera_exposure(saved_settings["exposure"])
                pycam.set_camera_gain(saved_settings["gain"])
                pycam.set_camera_wb(saved_settings["wb"])
            else:  # is running, turn off
                print("Stopping timelapse")

                timelapse_remaining = None
                pycam.camera.exposure_ctrl = True
                pycam.set_camera_gain(None)  # go back to autogain
                pycam.set_camera_wb(None)  # go back to autobalance
                pycam.set_camera_exposure(None)  # go back to auto shutter

Use the Camera

Taking pictures is just as simple as with the Basic Camera -- you could say it's a snap -- simply follow these two steps:

point the MEMENTO at a subject while framing it in the display
press-and-release the shutter button fairly quickly

Autofocus

However, now you can use the autofocus feature to help keep closer subjects looking sharp:

point the MEMENTO at a subject while framing it in the display
press-and-hold the shutter button until you hear the beep (you should also see the focus change if there is a close subject in frame)
release the shutter button to finish enabling autofocus
press-and-release the shutter button to snap your pic!

I ate the banana. So now we have a can of Liquid Wrench to take its place. Which is great, because it is still yellow, but has a lot more detail on which to focus!

In the first photo, the MEMENTO's default distant focus is shown. Note how the Droid Builders patch is in focus but the mid and foreground objects aren't.

Default infinite focus

For this second shot I pointed the camera at the can of Liquid Wrench, held the shutter button to set the MEMENTO's autofocus, released it, then aimed it back at the patch and snapped the pic. Such nice close-up focus!

Autofocus on near subject

Settings

While the Basic Camera example settings could only be changed directly in code, in the Fancy Camera example you can use the MEMENTO's four directional buttons to change settings on the fly.

press Right button to pick a menu category Resolution, Effect, or Mode
the category will be highlighted
press Up or Down buttons to select the choices within the mode:
- Resolution will page through the different available resolutions
- Effect picks the different effects, such as Normal, Invert, B&W, Reddish, Sepia, Solarize, etc.
- Mode will flip between JPEG, GIF, GBOY, STOP, LAPS (we'll cover stop motion mode and timelapse modes elsewhere in this guide)

Text editor powered by tinymce.

Taking Your First Photo

Inserting a microSD Memory Card

If your MEMENTO is powered on, turn it off prior to removing the microSD card.

Inserting the microSD card into MEMENTO

Insert the card loosely, wiggle if it feels tight. Do not force it, if it will not go in, check for the correct orientation.

When it is in, press the edge of the card until you feel a click. The card is then seated.

Power On

With your MEMENTO camera fully assembled, look on the top left. There is a slide switch marked ➡On. Using your fingernail, slide the switch towards the right.

When you turn your camera on for the first time with the CircuitPython "Fancy Camera" program loaded, you'll see a screen similar to above.

The screen should look like this: “240x240”, “Normal”, “JPEG”, “SD OK”.

If the upper right text says "NO SD", turn the camera off using the power button on the top left of body. Insert (or reinsert) a microSD card. If you believe a card is in there, be sure it is seated properly with a click at the end.

If the card still is not registering, it might not be formatted. Power the MEMENTO off and remove the microSD card. Insert the card into a USB card reader to see if your computer recognizes it as formatted. If there are files on it, it should be formatted. If your computer cannot read the card, it may be unformatted.

If you determine the card is unformatted, you can follow the formatting instructions in the guide page below.

Formatting a microSD card will erase any files on it. If you believe you have files on the card, try to save them onto your computer prior to formatting (likely formatting is unnecessary if you can see files).

Adafruit MEMENTO Camera Board

By Liz Clark

microSD Card Formatting Notes

View Guide

With the MEMENTO still powered off, reinsert the (freshly formatted) microSD card and power the camera back on. The display in the upper right should now show "SD Ok" in green.

Taking a Picture

Taking pictures is similar to any camera -- simply follow these two steps:

Point the MEMENTO at a subject while framing it in the display

Press-and-release the shutter button fairly quickly

When the shutter engages, you will hear a sound from the speaker and on the screen you'll see the word Snap! appear in the center of the screen.

Congratulations, you've taken your first picture!

Focusing

Like commercial cameras, MEMENTO is capable of autofocusing on an object (using a tiny motor in the lens).

Press shutter button for a second (e.g., “long-press”) to focus on the object in the center of the frame.

Release the shutter button once it has focused

Press/release the shutter button to snap a photo (e.g., a “short-press").

Have Fun

Go ahead and take some pictures!

See the next page for detailed instructions on powering off your camera, removing the microSD card and looking at the pictures on your computer.

Subsequent pages go over how to set your MEMENTO for higher resolution images and how to use special effects.

Remember, once you would like to view the pictures on your computer, power off your camera. Then you can safely remove your microSD card.

Text editor powered by tinymce.

Getting Photos off the microSD Card

Where is my Picture?

Be sure the MEMENTO is powered off before removing the microSD card.

Turn off your camera using the power switch on the top left of the camera.

The display will go dark and any LEDs visible from the top of MEMENTO will be off.

Remove the microSD card by gently pressing in on the card and then letting it pop out. Grasp it once it's popped out.

Load the card into a USB card reader and connect it to your computer (Windows/Mac/Linux/Chromebook, etc.).

USB card readers some in many shapes and sizes. Use one that fits the USB ports in your computer.

Angled shot of a microSD card reader with a key chain plugged into a laptop port.

USB Type C microSD Card Reader/Writer

This is the cutest little USB C microSD Card Reader/Writer, but don't be fooled by its adorableness! Simply pop the card into the edge and plug it into your...

$6.95

In Stock

Add to Cart

The card reader should show up as a new flash disk in your File Explorer/Finder (which depends on your operating system). Below is a Windows File Explorer image of a microSD card showing two files: IMAGE0000.jpg and img0000.jpg.

IMAGE0000.jpg is from the factory demo program. img0000.jpg is the view taken below with the CircuitPython Fancy Camera code.py. Other operating systems would show the microSD files similarly.

Opening the file img0000.jpg, it shows the image just taken with the camera:

The resolution is only 240x240 pixels by default (rather low) and there is no lighting on the subject. Changing those will be demonstrated in upcoming Quick Start pages.

You'll notice that the text showing you the resolution and image type does not appear on the saved photo. The text only appears on the screen for your information.

Saving Your Pictures

It is a good practice to save your pictures on backup media. While the microSD card will likely be able to hold many files, if you were to lose the card (or camera!), your pictures would be lost.

While you have your card out of the camera and in a USB card reader, copy them either to your computer storage drive or an external drive. Use your File Explorer / Finder (operating system dependent) to copy the files.

You can also delete images you do not want. If you know you have a safe backup of your images, you can delete images on the card to make more space.

Putting your microSD Card Back in Your Camera

Use the Eject drive function of your computer to safely be able to remove the USB card reader from the USB port. On Windows, right click the drive and select Eject (see above).

Be sure your MEMENTO is powered off before inserting (or removing) the microSD card).

Remove the microSD card from the card reader.

Ensure the MEMENTO is powered off. The display should be dark and no led lights should be on looking down into the top of the camera.

How to insert a microSD card into MEMENTO

Take the microSD card and place it back in the camera by pushing it into the card slot until it clicks into place.

Now you can turn on your MEMENTO camera. The upper right corner of the screen should say in green "SD Ok". If it says "NO SD" in red, turn the power off and be sure the card is seated properly.

Now to look at take some better photos in the following pages.

Text editor powered by tinymce.

Adjusting Photo Resolution

You can use the MEMENTO's four directional buttons to change different camera settings on the fly.

Be sure the MEMENTO is powered off. The display should be dark and no LED lights visible from the top of the camera.

Place a microSD card into the microSD card slot. Power on the camera.

Changing the Resolution MEMENTO Uses to Take Pictures

Press the Right button to pick a menu category: Resolution, Effect, or Mode. When one of those is highlighted, re. black text on a white background (instead of white text on a black background), it is highlighted.

Hover over Resolution (black lettering on a white background in the upper left corner of the display).

The Up and Down buttons change the image resolution to one of the following:

160x120
320x240
480x320
640x480
800x640
1024x768
1280x720
1280x1024
1600x1200
2048x1536
2560x1920 (highest)

For the best picture quality, select 2560x1920. 640x480 images are about 50k bytes, 160x120 images are about 6kb. 2560x1920 images are about 320k bytes. Actual sizes will vary depending on the subject and JPEG compression.

Changing the photo capture resolutions

Take Your Photo

Now with the resolution chosen, you can take your pictures as noted on previous pages. Savor the glory of megapixels of resolution (or not).

Your Settings Are Saved Automatically

The MEMENTO uses non-volatile memory (NVM) to remember your settings, so next time your power on the MEMENTO, the resolution will still be set to the value you chose previously.

Text editor powered by tinymce.

Filters and Effects

The code has several fun filters and effects for photos. Feel free to be creative in how you take your pictures.

Getting Started

Be sure the MEMENTO is powered off. The display should be dark and no LED lights visible from the top of the camera.

Place a microSD card into the microSD card slot. Power on the camera.

Filters & Effects

Press the Right button to highlight the word "Normal" in the lower left corner of the display. This is the adjust filter mode.

Press Up or Down buttons to select the choices within the filter mode:

Normal image mode (color)
Invert
B&W (grayscale)
Reddish
Greenish
Bluish
Sepia (yellow tones)
Solarize (invert)

Subsequent pictures will use the chosen effect until it is changed.

Modes

The software also has several different effects modes.

Press the Right button to highlight "JPEG" in the lower right of the display. This menu allows you to pick among the modes.

Press the Up or Down buttons to select the choices within the effects mode:

JPEG (take JPEG image snapshots)
GIF (create animated GIFs at 240x176 resolution)
GBOY (shoot images that are 1-bit black & white dots like the Gameboy camera)
STOP (shoot a series of JPEG images for stop motion animation, includes translucent "onion skin" overlay of previous frame)
LAPS (create a series of time lapse images)

JPEG is the standard mode for taking pictures. GIF takes small animated GIFs and is covered in later pages along with STOP motion and time lapse (LAPS).

GBOY mode stands for Game Boy. The Game Boy camera from Nintendo produced small black and white images via stippling, small dots spaced such that the eye sees an image.

For many, a low resolution image taken in this mode will remind them of the Nintendo Gameboy camera.

These are shot at 240x240 resolution and saved to the microSD card as single frame GIF files.

Once you have selected the filter and/or effect, have fun taking pictures beyond the standard color image.

Text editor powered by tinymce.

Using the LED Ring, Brightness and Color

If you have the MEMENTO camera enclosure kit, the front, decorated with the Adafruit logo, has a ring of eight NeoPixel LEDs around the lens opening. These can light your subjects with different light levels and colors.

Take photos with different light levels and colors to see dark objects more clearly and to add some artistic tint.

Make sure you have also connected the cable between the MEMENTO A1 port and the front panel with the lights on it (it won't work without it). Refer to the guide page below on how it is assembled.

AdaBox 021

By John Park

MEMENTO Assembly

View Guide

Get Ready

Be sure your MEMENTO is powered off.

Load a microSD card into your MEMENTO.

Only insert or remove the microSD card when the MEMENTO camera is powered off to avoid data corruption.

Now you can turn on your camera.

Setting the Light Level

Press and release the Right button to pick the LED LV (LED level) menu (it will highlight and invert the text, you can cycle through all menus or press Left if you pass it).

It shows up in the upper left corner of the display, where the resolution is most often shown.

Press Up or Down to cycle between five brightness level presets for the LEDs (0%, 25%, 50%, 75%, 100%).

Setting the LED Color

To change the color of the NeoPixel ring, press and release Right button to pick the LED CLR (LED color) menu. LED CLR will be shown in the upper left corner of the display (where the resolution is usually displayed).

Press Up or Down to cycle between the color presets: warm white, green, yellow, red, purple, blue, cyan, or rainbow.

Taking Pictures

Once you have the lighting set, the NeoPixel ring will illuminate your subjects. All kinds of effects are possible, especially with colored lights.

On Power Cycle or Reset

The LEDs will be off after power cycling or resetting MEMENTO, the setting is not saved.

Text editor powered by tinymce.

Shooting an Animated GIF

You can create short animated GIFs with the MEMENTO, perfect for sharing in text chats!

The Fancy Camera CircuitPython program will record a 15 frame, 240x176 pixel GIF* of about two seconds in duration each time you press and release the shutter button.

Getting Started

Be sure the MEMENTO is powered off. The display should be dark and no LED lights visible from the top of the camera.

Place a microSD card into the microSD card slot.

Power on the camera.

Putting the Camera in GIF Mode

Press and release Right button to pick the Mode menu in the lower right of the display (by default it says JPEG).

Press and release the Up button to cycle between modes to get to GIF mode.

The resolution is no longer displayed. That's ok (as GIF making is fixed at 240x176 pixels).

Make a GIF

Now, you can frame your shot. Press and release the shutter button to record a two-second GIF animation. The GIF is saved automatically to the SD card.

There is no on-camera preview after you've taken the shot, so you'll need to put the SD card in your computer's SD card reader to view the results.

GIF mode is locked at 240x176 pixels, so you won't see the resolution selection option that is present in JPEG mode

Remember to turn the camera off before removing or reinserting the microSD card.

You can also still use the long-press focus technique to get a nice sharp focus on your subject.

Note: this will be a two-second long GIF, so don’t try to shoot anything too elaborate!

Taking Animated GIF Images with Effects

The default GIF is created without effects applied, but you can get creative by picking built-in effects before shooting a GIF.

Press the right button to highlight the effect menu item, by default it is the Normal effect. Press up/down to cycle between the effects:

Normal image mode (color)
Invert
B&W (grayscale)
Reddish
Greenish
Bluish
Sepia (yellow tones)
Solarize (invert)

Then, shoot your GIF by pressing the shutter button as usual.

An animated GIF made using the solarize effect.

NeoPixel Lighting

You can also add some NeoPixel lighting to your GIFs if you have the MEMENTO Camera Enclosure kit attached and connected using the short the JST cable (shown above on the left).

Using the four rear buttons in the diamond configuration, press the Right button until LED LV is highlighted, then press Up to pick a pre-set lighting level.

Press the Right button again to highlight LED CLR, then press the Up button to pick a pre-set color.

Here's an example of a weird guy with some magenta lighting that look particularly strange.

Post Processing

You can also use GIF editing tools (online or applications) to further edit your GIFs. Here's an example of creating a looping version of the basketball animation by doubling and re-ordering the frames:

* Pronounced GHIF as in. "Good grief, give me a break, go get some peanut butter for your graphics if you wanna say 'JIF'."

Don't @ me bro.

Text editor powered by tinymce.

Stop Motion

You can create stop motion animation with MEMENTO. Channel your inner Gumby, Wallace & Grommet, or Thunderbirds. LEGO minifigs are great. If you have AdaBox 021, there may be something in the box to help you do stop motion with.

Getting Started

Be sure the MEMENTO is powered off. The display should be dark and no LED lights visible from the top of the camera.

Place a microSD card into the microSD card slot.

With your MEMENTO off (unpowered), ensure you have a microSD card in the card slot and it is fully seated with a click.

Power on the camera.

If the microSD card is seated properly, "SD Ok" will be on the display in green in the top right of the display. If it says "NO SD" in red, turn the camera off and reseat the card.

Press and release the Right button to pick the Mode menu (by default it reads “JPEG” in the lower left of the display).

Press and release the Up button to cycle between modes and get to the “STOP” item.

You may want to pick a reasonable resolution for creating a movie from your frames, such as 1920x1080 (typical 1080p HD resolution).

Use the Right button to highlight the resolution then the Up button to get to the desired resolution.

Set your MEMENTO on a stable surface or secure it with a tripod mount case or other means.

Long-press the shutter button to focus on the center frame subject, such as a posing mannequin. Then a short press to take the picture.

Making Adjustments Between Shots

Adjust your subject, such as moving the arm of the mannequin.

Do a short press of the shutter button to shoot the next frame.

Repeat for as many frames as you want — typically stop motion is shot at 12 frames per second or even fewer when you’re first starting, so keep this in mind as you animate.

Making an Animated GIF or Video from the Still Images

Shoot a short test. Turn off your MEMENTO and remove the microSD card. Insert the card into a USB card reader then copy the frames to your computer and preview them.

You can use ezgif.com/maker on the web to create an animated GIF. See this guide page on how to do this.

You can also use a video editor such as Adobe Premiere or DaVinci Resolve to import the still images and create a movie.

Going Further

For more in-depth information, check out the following guides:

Adafruit MEMENTO Camera Board

By Liz Clark

Stop Motion

View Guide

Stop Motion Animation

By John Park

Overview

View Guide

Text editor powered by tinymce.

Timelapse Photography

The MEMENTO software allows for timelapse image capture -- a sequence of photos shot automatically with a set time interval between each shot.

Getting Started

Be sure the MEMENTO is powered off. The display should be dark and no LED lights visible from the top of the camera.

Place a microSD card into the microSD card slot.

Power on the camera.

If the microSD card is seated properly, "SD Ok" will be on the display in green in the top right of the display. If it says "NO SD" in red, turn the camera off and reseat the card.

Press and release the Up button to cycle among modes and get to the “LAPS” item.

To change the interval between captures, press the Right button to get to the interval item (by default, “5 S” for 5 seconds).

Press Up or Down to change the interval from 5 seconds up to 60 minutes between shots.

If you’re running on battery power, you can save some power by changing the timelapse power mode.

Press the Select button to cycle between LowPwr (dims the display, refreshes screen once per shot), MedPwr (updates display once per shot), or HiPwr (live preview).

You can long-press the shutter button (upper right top of the camera) to focus on your subject.

Press the OK button to begin shooting.

MEMENTO will shoot frames until you press OK button again to stop.

Making an Animated GIF or Video from the Still Images

Shoot a short test. Turn off your MEMENTO and remove the microSD card. Insert the card into a USB card reader then copy the frames to your computer and preview them.

You can use ezgif.com/maker on the web to create an animated GIF. See this guide page on how to do this.

You can also use a video editor such as Adobe Premiere or DaVinci Resolve to import the still images and create a movie.

For longer time lapse videos, you may want a large microSD card. Note 32GB is the maximum MEMENTO can handle.

Going Further

For more in-depth information, check out the following guide:

Adafruit MEMENTO Camera Board

By Liz Clark

Timelapse

View Guide

Text editor powered by tinymce.

Create a Rack Focus Shot

Rack focus photography is great for shifting attention between subjects without moving the camera. With a shallow depth of focus, the rack focus makes it clear where we should look, since blur quickly envelopes everything but the subject at the intended focal depth.

Getting Started

Be sure the MEMENTO is powered off. The display should be dark and no LED lights visible from the top of the camera.

Place a microSD card into the microSD card slot.

Power on the camera.

New Code

This example and the Macro Photography example use new code not in the CircuitPython Fancy Camera program.

If your camera has the factory camera code, identifiable by a screen at left, you will need to install CircuitPython first. Go to the Install CircuitPython Page in this guide to do so. Then come back here to load the code.

Start by downloading the code and library files from the following link to your computer.

Download the CircuitPython Code Bundle

Connect your computer to the camera via a known good USB-C power+data cable. A new flash drive should show up as CIRCUITPY in your computer's File Explorer/Finder (depending on your operating system).

Find the code zip file you saved above and open it.

camera_adafruit_products_Screenshot_2024-02-26_at_8.10.59_AM.jpg

Drag the contents of the uncompressed bundle directory for the version of CircuitPython you're running (e.g., /examples/camera/CircuitPython 9.x/) onto your MEMENTO CIRCUITPY drive, replacing any existing files or directories with the same names, and adding any new ones that are necessary.

Use the Eject drive function of your computer to safely be able to remove the USB card reader from the USB port. On Windows, right click the drive and select Eject (see above).

Your camera should be ready to do Rack Focus and Macro Photography.

To return to the Fancy Camera application, go back to the Install Fancy Camera App page.

Set Up Your Shot

Rack Focus works best on two or more items spaced within one camera frame where the first item is far and subsequent items are nearer until the last item is closest.

Set the MEMENTO on a stable surface or attach it to a tripod. Line up your subjects from far to near.

Shoot a Rack Focus Shot

Press the shutter release button on the top right of the camera.

The MEMENTO will snap pictures at the farthest to nearest depths.

Be sure you turn your MEMENTO off before removing the microSD card or reinstalling it again.

Frames to GIFs

Turn off your MEMENTO via the power switch. Remove the microSD card from the MEMENTO and insert it into an SD card reader on your computer.

Copy the image files to a local directory. Then, you can turn the individual frames into a movie using video editing software, or stitch them into a GIF. This page shows you how to do just that!.

With this software loaded, you can also check out Macro Photography with Focus Stacking on the next page.

Going Further

For more in-depth information, check out the following guide:

MEMENTO Focus Stacking

By John Park

Rack Focus

View Guide

Text editor powered by tinymce.

Macro Photography with Focus Stacking

Getting Started

Be sure the MEMENTO is powered off. The display should be dark and no LED lights visible from the top of the camera.

Place a microSD card into the microSD card slot.

Power on the camera.

New Code

This example and the Rack Focus example on the previous page use new code not in the CircuitPython Fancy Camera program.

If your camera has the CircuitPython Fancy Camera program, follow the steps below. If the camera already has the Focus Stacking code, skip to setting up your shot.

Start by downloading the code and library files from the following link to your computer.

Download the CircuitPython Code Bundle

Find the code zip file you saved above and open it.

Use the Eject drive function of your computer to safely be able to remove the USB card reader from the USB port. On Windows, right click the drive and select Eject (see above).

Your camera should be ready to do Rack Focus and Macro Photography.

To return to the Fancy Camera application, go back to the Install Fancy Camera App page.

Set Up Your Shot

Gather your subject(s). There should be some depth to what you are photographing. For example, John Park picked a selection of flowers with lots of color and spatial detail.

Shoot Your Macro Focus Shot

Set your MEMENTO on a stable surface or tripod mount, compose your picture.

Be sure you adequately light the subject to get the best result.

To start, press the shutter release button. It will start by taking a photo at the farthest focus, then adjust the lens by the lens voice motor coil increment set in the code and repeat until is has taken all the photos up to the nearest possible focus.

Turn off your MEMENTO in preparation of removing the microSD card.

With the camera powered off, push down on the microSD card to "unclick" it from the microSD card reader and remove with your fingernails.

Place the microSD card into a USB microSD card reader and plug it into your computer. In your File Explorer/Finder (depending on your operating system) you'll open the drive that pops up when you stick the reader into a USB port.