MEMENTO Camera Quick Start Guide

Get up to speed fast with your MEMENTO open source camera

by Anne Barela and John Park

published March 18, 2024, last edited August 11, 2025

posted in Sensors/ Camera CircuitPython AdaBox

Save Download

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

Out of Stock

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

Angle Front Shot of the MEMENTO LED Plate.

MEMENTO LED Ring Front Plate with 8 RGBW NeoPixels

This product is just the LED ring add-on board for the MEMENTO camera kit pack.

guides with product

$4.95

In Stock

Add to Cart

Angled shot of a coiled black, USB-C to USB-A cable.

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

Page last edited August 11, 2025

Text editor powered by tinymce.

Parts, Assembly, and Power On

A view of the MEMENTO camera unassembled including three black circuit boards, a battery, a short cable and sticky tape, an microSD card and screws

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.

Inserting a microSD card into the slot on the MEMENTO with the gold fingers visible from the back side of the camera

A view of MEMENTO with the microSD card in the microSD slot on the circuit board but not yet fully pressed in

Using a fingernail to press the inserted microSD card into the slot until it clicks, indicating a positive connection

A pictire of the side of the MEMENTO with a fully inserted microSD card

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.

Page last edited August 11, 2025

Text editor powered by tinymce.

Charging the Battery

The MEMENTO front half circuit board with a battery connected to a jack on the right side of the board and the battery is taped down nearby

The MEMENTO camera fully assembled on a table with the back facing the viewer

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).

The right and front sides of MEMENTO showing the USB-C port (with a USB-C cable attached for charging) and a small yellow LED light next to the USB-C connector indicating the camera is charging

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.

A rear view of MEMENTO, turned on and facing outward. A red circle on the screen shows the camera displaying the battery voltage

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

Page last edited August 11, 2025

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.

A microSD card has been inserted into MEMENTO with the gold contacts facing the rear of the camera. The card is still sticking up indicating it has not been fully inserted to click

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

A rear view of MEMENTO with the camera on showing the camera image on the rear display with status information overlaid on the screen

The LCD display on the rear frames the shot.

Holding the MEMENTO aimed at a target with the shutter button, on top right of camera circled. A finger is placed to take a picture.

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.

Pushing on the microSD card to have it pop out of it's holder

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 rear of MEMENTO with a picture on screen and the image size circled

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 rear of MEMENTO with an image which has been taken with the Sepia filter on, looking a yellowish color

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.

Page last edited August 11, 2025

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!

Page last edited August 11, 2025

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 os
import ssl
import time

import adafruit_ntp
import adafruit_requests
import bitmaptools
import displayio
import gifio
import rtc
import socketpool
import ulab.numpy as np
import wifi

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:
                pycam.display_message("Failed", color=0xFF0000)
                time.sleep(0.5)
            except RuntimeError:
                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:
                pycam.display_message("Failed", color=0xFF0000)
                time.sleep(0.5)
            except RuntimeError:
                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:
                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:
                pycam.display_message("Error\nNo SD Card", color=0xFF0000)
                time.sleep(0.5)
                continue
            i = 0
            ft = []
            pycam._mode_label.text = "RECORDING"

            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"
            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:
                pycam.display_message("Failed", color=0xFF0000)
                time.sleep(0.5)
                pycam.live_preview_mode()
            except RuntimeError:
                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 os
import ssl
import time

import adafruit_ntp
import adafruit_requests
import bitmaptools
import displayio
import gifio
import rtc
import socketpool
import ulab.numpy as np
import wifi

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:
                pycam.display_message("Failed", color=0xFF0000)
                time.sleep(0.5)
            except RuntimeError:
                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:
                pycam.display_message("Failed", color=0xFF0000)
                time.sleep(0.5)
            except RuntimeError:
                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:
                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:
                pycam.display_message("Error\nNo SD Card", color=0xFF0000)
                time.sleep(0.5)
                continue
            i = 0
            ft = []
            pycam._mode_label.text = "RECORDING"

            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"
            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:
                pycam.display_message("Failed", color=0xFF0000)
                time.sleep(0.5)
                pycam.live_preview_mode()
            except RuntimeError:
                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)

Page last edited August 11, 2025

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.

Pushing down on an inserted microSD card to get it to lock in place

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.

Tthe LCD display, back of MEMENTO with status info on the top and bottom of the display: Upper left image size in pixels, upper right, SD inserted (OK green, not red), lower left the mode (showing normal) and lower right, showing JPEG images will be taken

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”.

Two side by side images of the back of MEMENTO showing "NO SD" on left and "SD OK" on right in upper left corner of screen

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

The rear of MEMENTO turned on, ready to take an image

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

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

Upper right via back of MEMENTO, right side of top, shutter button circled in red

Press-and-release the shutter button fairly quickly

Rear and top of MEMENTO with a finger depressing the shutter button momentarily

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

The MEMENTO being held, rear to viewer, finger on shutter button held to have camera autofocus

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.

Page last edited August 11, 2025

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.

MEMENTO right side, pushing on the microSD card to have it pop out of the socket

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.).

Pictures off various microSD card readers to use with a PC

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.

A Windows File Explorer screen showing the contents of the MEMENTO microSD card

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:

An image taken from MEMENTO and viewed on ones PC

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.

Showing copying images off of the microSD card to ones hard drive in Windows (mac, Linux similar)

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

Windows screen showing how to eject a removable drive to avoid data loss

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.

Two images, one showing "NO SD" in upper right of screen, one "SD OK" in upper right of screen

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.

Page last edited August 11, 2025

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 rear of MEMENTO's display, the image resolution is in the upper left of the LCD screen, circled in red

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.

Page last edited August 11, 2025

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.

Page last edited August 11, 2025

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.

Page last edited August 11, 2025

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.

Page last edited August 11, 2025

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

Page last edited August 11, 2025

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

Page last edited August 11, 2025

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

Page last edited August 11, 2025

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.

You should see a set of sequential JPEG images.

Copy the images to a directory on your computer.

One way to focus stack your images is with the web app Focus Stacking Online

Click the Add button and navigate to your image set.

Select the whole set and click OK.

Next, click the Stack! button and wait a few minutes for the images to be processed.

When it completes you can save your image by clicking the Download button.

The results can be stunning.

Overview

Parts

Parts, Assembly, and Power On

Inserting a microSD Card

Power On

Charging the Battery

Battery Status

The Stock Camera App

The microSD Card

If Your microSD Card is Not Formatted Prior to Use

Turning On Your Camera

Taking a Picture

Changing Settings

Image Resolution

Filters

Software to Revert to Factory Functionality

Install CircuitPython

CircuitPython Quickstart

Install the CircuitPython Fancy Camera App

CircuitPython

Download the Project Bundle

Use the Camera

Autofocus

Settings

Taking Your First Photo

Inserting a microSD Memory Card

Power On

Taking a Picture

Focusing

Have Fun

Getting Photos off the microSD Card

Where is my Picture?

Saving Your Pictures

Putting your microSD Card Back in Your Camera

Adjusting Photo Resolution

Changing the Resolution MEMENTO Uses to Take Pictures

Take Your Photo

Your Settings Are Saved Automatically

Filters and Effects

Getting Started

Filters & Effects

Modes

Using the LED Ring, Brightness and Color

Get Ready

Setting the Light Level

Setting the LED Color

Taking Pictures

On Power Cycle or Reset

Shooting an Animated GIF

Getting Started

Putting the Camera in GIF Mode

Make a GIF

Taking Animated GIF Images with Effects

NeoPixel Lighting

Post Processing

Stop Motion

Getting Started

Making Adjustments Between Shots

Making an Animated GIF or Video from the Still Images

Going Further

Timelapse Photography

Getting Started

Making an Animated GIF or Video from the Still Images

Going Further

Create a Rack Focus Shot

Getting Started

New Code

Set Up Your Shot

Shoot a Rack Focus Shot

Frames to GIFs

Going Further

Macro Photography with Focus Stacking

Getting Started

New Code

Set Up Your Shot

Shoot Your Macro Focus Shot

Further Reading

Search

Categories