Skip to main content
MEMENTO Wireless Remote with TouchOSC

MEMENTO Wireless Remote with TouchOSC

Image for user johnpark
by John Park
published January 24, 2024, last updated October 09, 2024
posted in Sensors/ Camera Internet of Things - IOT/ Wireless CircuitPython Breakout Boards/ WiFi
Save Subscribe Download
12
Updated
Beginner
Project guide

Overview

camera_memrem_beauty02.jpg

A wireless remote control can be very helpful for certain types of photography -- maybe you want to take a group photo and actually be in the photo this time! Or perhaps you're shooting stop motion animation and need to avoid bumping the camera out of position.

Thanks to the WiFi built into the MEMENTO ESP32-S2 chip, you can trigger any camera function you like with wireless commands sent with an iOS or Android app using the OSC protocol.

camera_memrem_beauty03.jpg
OSC stands for Open Sound Protocol, but you can use it for a whole lot more than audio and synthesizers. It's a communication protocol designed for real-time control in multimedia applications, similar in some ways to MIDI, but much more advanced and flexible.

Parts

Video of a DIY camera on a lazy susan.
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
Add to Wishlist
+ New List
Lithium Ion Polymer Battery 3.7v 420mAh with JST 2-PH connector and short cable
Lithium-ion polymer (also known as 'lipo' or 'lipoly') batteries are thin, light, and powerful. The output ranges from 4.2V when completely charged to 3.7V. This...
$6.95
In Stock
Add to Cart
Add to Wishlist
+ New List
Angled shot of Small microSD card 256mb
Add storage in a jiffy using this 256MB microSD card. Preformatted to FAT32, so it works out of the packaging with our projects. Works great with any device in the...
$4.50
In Stock
Add to Cart
Add to Wishlist
+ New List
NOTE: You can use cards with up to 32GB capacity in the MEMENTO.
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
Add to Wishlist
+ New List
camera_oscdesk.jpg

TouchOSC

This project uses TouchOSC by Hexler Limited, available here. As of this time, TouchOSC is $12.99 in the Apple App Store for iOS and in the Google Play store for Android.

The layout can be edited (or even created from scratch) on the mobile app, but the desktop version for Mac, Windows, or Linux makes it a lot easier. The desktop license costs $25.50 at this time.

Since OSC is a free, open standard, you could adapt the code very easily to use other OSC apps of your choosing.

Mobile Device

You can use nearly any iOS or Android device with WiFi to run TouchOSC.

Optional:

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.
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
$9.95
In Stock
Add to Cart
Add to Wishlist
+ New List
Angled shot of JST PH 3-pin Plug-Plug Cable - 100mm long.
This cable is a little over 100mm / 4" long and fitted with JST-PH 3-pin connectors on either end. We dig the solid and compact nature of these connectors and the...
$0.75
In Stock
Add to Cart
Add to Wishlist
+ New List

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

Your board will reboot after running this.

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

adafruit_products_resetNeo.jpg

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.

adafruit_products_cameraboot.png

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

install_circuitpython_on_most_boards_CIRCUITPY.jpg

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

That's it!

Text editor powered by tinymce.

Create Your settings.toml File

CircuitPython works with WiFi-capable boards to enable you to make projects that have network connectivity. This means working with various passwords and API keys. As of CircuitPython 8, there is support for a settings.toml file. This is a file that is stored on your CIRCUITPY drive, that contains all of your secret network information, such as your SSID, SSID password and any API keys for IoT services. It is designed to separate your sensitive information from your code.py file so you are able to share your code without sharing your credentials.

CircuitPython previously used a secrets.py file for this purpose. The settings.toml file is quite similar.

Your settings.toml file should be stored in the main directory of your CIRCUITPY drive. It should not be in a folder.

CircuitPython settings.toml File

This section will provide a couple of examples of what your settings.toml file should look like, specifically for CircuitPython WiFi projects in general.

The most minimal settings.toml file must contain your WiFi SSID and password, as that is the minimum required to connect to WiFi. Copy this example, paste it into your settings.toml, and update:

  • your_wifi_ssid
  • your_wifi_password
Download File
Copy Code 
CIRCUITPY_WIFI_SSID = "your_wifi_ssid"
CIRCUITPY_WIFI_PASSWORD = "your_wifi_password"

Many CircuitPython network-connected projects on the Adafruit Learn System involve using Adafruit IO. For these projects, you must also include your Adafruit IO username and key. Copy the following example, paste it into your settings.toml file, and update:

  • your_wifi_ssid
  • your_wifi_password
  • your_aio_username
  • your_aio_key
Download File
Copy Code 
CIRCUITPY_WIFI_SSID = "your_wifi_ssid"
CIRCUITPY_WIFI_PASSWORD = "your_wifi_password"
ADAFRUIT_AIO_USERNAME = "your_aio_username"
ADAFRUIT_AIO_KEY = "your_aio_key"

Some projects use different variable names for the entries in the settings.toml file. For example, a project might use ADAFRUIT_AIO_ID in the place of ADAFRUIT_AIO_USERNAME. If you run into connectivity issues, one of the first things to check is that the names in the settings.toml file match the names in the code.

Not every project uses the same variable name for each entry in the settings.toml file! Always verify it matches the code.

settings.toml File Tips

Here is an example settings.toml file.

Download File
Copy Code 
# Comments are supported
CIRCUITPY_WIFI_SSID = "guest wifi"
CIRCUITPY_WIFI_PASSWORD = "guessable"
CIRCUITPY_WEB_API_PORT = 80
CIRCUITPY_WEB_API_PASSWORD = "passw0rd"
test_variable = "this is a test"
thumbs_up = "\U0001f44d"

In a settings.toml file, it's important to keep these factors in mind:

  • Strings are wrapped in double quotes; ex: "your-string-here"
  • Integers are not quoted and may be written in decimal with optional sign (+1, -1, 1000) or hexadecimal (0xabcd).
    • Floats, octal (0o567) and binary (0b11011) are not supported.
  • Use \u escapes for weird characters, \x and \ooo escapes are not available in .toml files
    • Example: \U0001f44d for 👍 (thumbs up emoji) and \u20ac for € (EUR sign)
  • Unicode emoji, and non-ASCII characters, stand for themselves as long as you're careful to save in "UTF-8 without BOM" format
adafruit_products_dotToml.jpg

 

 

When your settings.toml file is ready, you can save it in your text editor with the .toml extension.

Accessing Your settings.toml Information in code.py

In your code.py file, you'll need to import the os library to access the settings.toml file. Your settings are accessed with the os.getenv() function. You'll pass your settings entry to the function to import it into the code.py file.

Download File
Copy Code 
import os

print(os.getenv("test_variable"))
adafruit_products_tomlOutput.jpg

In the upcoming CircuitPython WiFi examples, you'll see how the settings.toml file is used for connecting to your SSID and accessing your API keys.

Text editor powered by tinymce.

Code the Wireless Remote Camera

Text Editor

Adafruit recommends using the Mu editor for editing your CircuitPython code. You can get more info in this guide.

Alternatively, you can use any text editor that saves simple text files.

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.

Drag the contents of the uncompressed bundle directory onto your board 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 & John Park for Adafruit Industries
#
# SPDX-License-Identifier: MIT
''' Wireless remote for MEMENTO camera with TouchOSC'''

import time
import os
import bitmaptools
import displayio
import gifio
import ulab.numpy as np
import adafruit_pycamera
import wifi
import socketpool
import microosc

UDP_HOST = ""
UDP_PORT = 8000
ssid = os.getenv("CIRCUITPY_WIFI_SSID")
password = os.getenv("CIRCUITPY_WIFI_PASSWORD")
print("connecting to WiFi", ssid)
wifi.radio.connect(ssid, password)
print("my ip address:", wifi.radio.ipv4_address)
socket_pool = socketpool.SocketPool(wifi.radio)
time.sleep(10)  # delay so people can get the IP address

pycam = adafruit_pycamera.PyCamera()
pycam.autofocus_init()

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

print("Starting!")
last_frame = displayio.Bitmap(pycam.camera.width, pycam.camera.height, 65535)
onionskin = displayio.Bitmap(pycam.camera.width, pycam.camera.height, 65535)

pycam.tone(800, 0.1)
pycam.tone(1200, 0.05)

def snap_jpeg():
    pycam.tone(600, 0.1)
    try:
        pycam.display_message("Snap!", color=0x0000FF)
        pycam.capture_jpeg()
        pycam.live_preview_mode()
    # pylint: disable=unused-variable
    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)

def snap_gboy():
    pycam.tone(600, 0.1)
    try:
        f = pycam.open_next_image("gif")
        pycam.display_message("Snap!", color=0x00ff44)
    # pylint: disable=unused-variable
    except RuntimeError as e:
        pycam.display_message("Error\nNo SD Card", color=0xFF0000)
        time.sleep(0.5)

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

def snap_gif():
    pycam.tone(600, 0.1)
    try:
        f = pycam.open_next_image("gif")
    # pylint: disable=unused-variable
    except RuntimeError as e:
        pycam.display_message("Error\nNo SD Card", color=0xFF0000)
        time.sleep(0.5)
    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()
    pycam.tone(1200, 0.15)

def snap_stop():
    pycam.tone(600, 0.1)
    pycam.capture_into_bitmap(last_frame)
    pycam.stop_motion_frame += 1
    try:
        pycam.display_message("Snap!", color=0x0000FF)
        pycam.capture_jpeg()
    # pylint: disable=unused-variable
    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()

def toggle_handler(msg):
    addr = msg.addr
    tog_num = int(addr.replace('/1/toggle',''))
    if msg.args[0] == 1.0:
        print(tog_num, "is ON")
    else:
        print(tog_num, "is off")

def fader_handler(msg):  # faders
    """Used to handle 'fader' OscMsgs, printing it as a '*' text progress bar
    :param OscMsg msg: message with one required float32 value
    """
    osc_addr = msg.addr.split('/')  # chop up the address into parts
    # page_num = osc_addr[1]
    fader_num = int(osc_addr[2].replace('fader', ''))  # get the number only
    if fader_num == 1:  # led level
        led_val = int(msg.args[0] * 5)
        pycam.led_level = led_val

mode_texts = ("JPEG", "GIF", "GBOY", "STOP")

def radio_handler(msg):  # Radio buttons
    osc_addr = msg.addr.split('/')  # chop up the address into parts
    print(osc_addr)
    page_num = osc_addr[1]
    print("page_num:", page_num)
    rad_num = int(osc_addr[2].replace('radio', ''))  # get the number only
    print("rad_num:", rad_num)
    if rad_num == 1:  # MODE
        print("switched mode to", mode_texts[msg.args[0]])
        pycam.mode = msg.args[0]
    if rad_num == 2:  # resolution
        print("switched resolution")
        pycam.resolution = msg.args[0]
    if rad_num == 3:  # LED color
        print("set color")
        pycam.led_color = msg.args[0]
    if rad_num == 4:  # effects
        print("switched effect")
        pycam.effect = msg.args[0]

def button_handler(msg):  # buttons
    addr = msg.addr
    button_num = int(addr.replace('/1/button',''))
    if msg.args[0] == 1.0:
        print(button_num, "is ON")
        if button_num == 1:
            pycam.tone(1200, 0.05)
            pycam.tone(1600, 0.05)
            if pycam.mode_text == "JPEG":
                snap_jpeg()
            if pycam.mode_text == "GBOY":
                snap_gboy()
            if pycam.mode_text == "GIF":
                snap_gif()
            if pycam.mode_text == "STOP":
                snap_stop()

        if button_num == 2:  # focus
            pycam.tone(1800, 0.05)
            print("FOCUS")
            print(pycam.autofocus_status)
            pycam.autofocus()
            print(pycam.autofocus_status)
            pycam.tone(1400, 0.05)

    else:
        print(button_num, "is off")

dispatch_map = {
    "/": lambda msg: print("msg:", msg.addr, msg.args),  # prints all messages
    "/1/fader": fader_handler,
    "/2/fader": fader_handler,
    "/1/toggle": toggle_handler,
    "/1/button": button_handler,
    "/1/radio": radio_handler,
    "/2/radio": radio_handler
}

osc_server = microosc.OSCServer(socket_pool, UDP_HOST, UDP_PORT, dispatch_map)
print("MicroOSC server started on ", UDP_HOST, UDP_PORT)


while True:
    osc_server.poll()  # check for incoming OSC messages

    if pycam.mode_text == "STOP" and pycam.stop_motion_frame != 0:
        # alpha blend
        new_frame = pycam.continuous_capture()
        bitmaptools.alphablend(
            onionskin, last_frame, new_frame, displayio.Colorspace.RGB565_SWAPPED
        )
        pycam.blit(onionskin)
    elif pycam.mode_text == "GBOY":
        bitmaptools.dither(
            last_frame, pycam.continuous_capture(), displayio.Colorspace.RGB565_SWAPPED
        )
        pycam.blit(last_frame)
    else:
        pycam.blit(pycam.continuous_capture())

    pycam.keys_debounce()

    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":
            snap_stop()

        if pycam.mode_text == "GBOY":
            snap_gboy()

        if pycam.mode_text == "GIF":
            snap_gif()

        if pycam.mode_text == "JPEG":
            snap_jpeg()

    if pycam.card_detect.fell:
        print("SD card removed")
        pycam.unmount_sd_card()
        pycam.display.refresh()
    if pycam.card_detect.rose:
        print("SD card inserted")
        pycam.display_message("Mounting\nSD Card", color=0xFFFFFF)
        for _ in range(3):
            try:
                print("Mounting card")
                pycam.mount_sd_card()
                print("Success!")
                break
            except OSError as e:
                print("Retrying!", e)
                time.sleep(0.5)
        else:
            pycam.display_message("SD Card\nFailed!", color=0xFF0000)
            time.sleep(0.5)
        pycam.display.refresh()

    if pycam.up.fell:
        print("UP")
        key = settings[curr_setting]
        if key:
            setattr(pycam, key, getattr(pycam, key) + 1)
    if pycam.down.fell:
        print("DN")
        key = settings[curr_setting]
        if key:
            setattr(pycam, key, getattr(pycam, key) - 1)
    if pycam.left.fell:
        print("LF")
        curr_setting = (curr_setting + 1) % len(settings)
        print(settings[curr_setting])
        pycam.select_setting(settings[curr_setting])
    if pycam.right.fell:
        print("RT")
        curr_setting = (curr_setting - 1 + len(settings)) % len(settings)
        print(settings[curr_setting])
        pycam.select_setting(settings[curr_setting])
    if pycam.select.fell:
        print("SEL")
    if pycam.ok.fell:
        print("OK")
View on GitHub

How It Works

The code boots up, connects to your WiFi, launches the camera app, and then waits for interactions from either the hardware buttons on the MEMENTO itself, or the equivalent software commands sent from your mobile device in the OSC messages.

Libraries

First, the libraries are imported. For more info on the OSC integration, check out Todbot's microosc library.

Download File
Copy Code 
import time
import os
import bitmaptools
import displayio
import gifio
import ulab.numpy as np
import adafruit_pycamera
import wifi
import socketpool
import microosc

Wireless Setup

Next, the UDP_Host and UDP_Port are set for the OSC server, and the WiFi access point credentials are set.

Download File
Copy Code 
UDP_HOST = ""
UDP_PORT = 8000
ssid = os.getenv("CIRCUITPY_WIFI_SSID")
password = os.getenv("CIRCUITPY_WIFI_PASSWORD")
print("connecting to WiFi", ssid)
wifi.radio.connect(ssid, password)
print("my ip address:", wifi.radio.ipv4_address)
socket_pool = socketpool.SocketPool(wifi.radio)

PyCamera Initialization

The camera is set up as well as the autofocus.

Download File
Copy Code 
pycam = adafruit_pycamera.PyCamera()
pycam.autofocus_init()

Camera Functions

  • snap_jpeg(): Captures a JPEG image
  • snap_gboy(): Captures a frame for a Game Boy-style effect (GIF)
  • snap_gif(): Records a GIF animation
  • snap_stop(): Captures a frame, displays a ghost/onion skin of the previous frame for use in stop motion animation
Download File
Copy Code 
def snap_jpeg():
    pycam.tone(600, 0.1)
    try:
        pycam.display_message("Snap!", color=0x0000FF)
        pycam.capture_jpeg()
        pycam.live_preview_mode()
    # pylint: disable=unused-variable
    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)

def snap_gboy():
    pycam.tone(600, 0.1)
    try:
        f = pycam.open_next_image("gif")
        pycam.display_message("Snap!", color=0x00ff44)
    # pylint: disable=unused-variable
    except RuntimeError as e:
        pycam.display_message("Error\nNo SD Card", color=0xFF0000)
        time.sleep(0.5)

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

def snap_gif():
    pycam.tone(600, 0.1)
    try:
        f = pycam.open_next_image("gif")
    # pylint: disable=unused-variable
    except RuntimeError as e:
        pycam.display_message("Error\nNo SD Card", color=0xFF0000)
        time.sleep(0.5)
    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()
    pycam.tone(1200, 0.15)

def snap_stop():
    pycam.tone(600, 0.1)
    pycam.capture_into_bitmap(last_frame)
    pycam.stop_motion_frame += 1
    try:
        pycam.display_message("Snap!", color=0x0000FF)
        pycam.capture_jpeg()
    # pylint: disable=unused-variable
    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()

OSC Message Handlers

When different OSC messages are dispatched, the message handler functions are triggered. 

  • fader_handler(msg): Handles fader messages (float values) and adjusts the LED level based on the fader value.
  • radio_handler(msg): Handles radio button messages for adjusting mode, resolution, LED color, and effects.
  • button_handler(msg): Handles button messages (press/release) for setting focus and snapping the shutter

OSC Messages

The OSC messages contain path addresses and element names as well as values. For example: /1/button2 [1.0] is page1, button2 with a value of 1.0 which the button_handler() interprets as the focus button being pressed.

While /2/radio4 [5] is page2, radio button 3  with a value of 5. This means the blue LED value has been selected.

When the LED brightness fader is adjusted, the message will look like this: /2/fader1 [0.629] 

Download File
Copy Code 
def fader_handler(msg):  # faders
    """Used to handle 'fader' OscMsgs, printing it as a '*' text progress bar
    :param OscMsg msg: message with one required float32 value
    """
    osc_addr = msg.addr.split('/')  # chop up the address into parts
    # page_num = osc_addr[1]
    fader_num = int(osc_addr[2].replace('fader', ''))  # get the number only
    if fader_num == 1:  # led level
        led_val = int(msg.args[0] * 5)
        pycam.led_level = led_val

mode_texts = ("JPEG", "GIF", "GBOY", "STOP")

def radio_handler(msg):  # Radio buttons
    osc_addr = msg.addr.split('/')  # chop up the address into parts
    print(osc_addr)
    page_num = osc_addr[1]
    print("page_num:", page_num)
    rad_num = int(osc_addr[2].replace('radio', ''))  # get the number only
    print("rad_num:", rad_num)
    if rad_num == 1:  # MODE
        print("switched mode to", mode_texts[msg.args[0]])
        pycam.mode = msg.args[0]
    if rad_num == 2:  # resolution
        print("switched resolution")
        pycam.resolution = msg.args[0]
    if rad_num == 3:  # LED color
        print("set color")
        pycam.led_color = msg.args[0]
    if rad_num == 4:  # effects
        print("switched effect")
        pycam.effect = msg.args[0]

def button_handler(msg):  # buttons
    addr = msg.addr
    button_num = int(addr.replace('/1/button',''))
    if msg.args[0] == 1.0:
        print(button_num, "is ON")
        if button_num == 1:
            pycam.tone(1200, 0.05)
            pycam.tone(1600, 0.05)
            if pycam.mode_text == "JPEG":
                snap_jpeg()
            if pycam.mode_text == "GBOY":
                snap_gboy()
            if pycam.mode_text == "GIF":
                snap_gif()
            if pycam.mode_text == "STOP":
                snap_stop()

        if button_num == 2:  # focus
            pycam.tone(1800, 0.05)
            print("FOCUS")
            print(pycam.autofocus_status)
            pycam.autofocus()
            print(pycam.autofocus_status)
            pycam.tone(1400, 0.05)

    else:
        print(button_num, "is off")

Dispatch Map

The dispatch_map is a dictionary that maps the incoming OSC messages to their handler functions. You can get as granular as you like here, for example, dispatching messages from particular pages to their own functions.

Download File
Copy Code 
dispatch_map = {
    "/": lambda msg: print("msg:", msg.addr, msg.args),  # prints all messages
    "/1/fader": fader_handler,
    "/2/fader": fader_handler,
    "/1/toggle": toggle_handler,
    "/1/button": button_handler,
    "/1/radio": radio_handler,
    "/2/radio": radio_handler
}

OSC Server 

The OSC server is set up to receive messages using UDP.

osc_server = microosc.OSCServer(socket_pool, UDP_HOST, UDP_PORT, dispatch_map)

Main Loop

The main loop the code continuously polls the OSC server for incoming messages, which are then used by the dispatch_map.

Additionally, all of the hardware buttons on the MEMENTO are used to snap the shutter, autofocus on long hold, and adjust the settings. These are the same as in the original PyCamera library example code, but some of the code has been moved into functions that both the buttons and the OSC messages can use.

Download File
Copy Code 
osc_server.poll()  # check for incoming OSC messages

    if pycam.mode_text == "STOP" and pycam.stop_motion_frame != 0:
        # alpha blend
        new_frame = pycam.continuous_capture()
        bitmaptools.alphablend(
            onionskin, last_frame, new_frame, displayio.Colorspace.RGB565_SWAPPED
        )
        pycam.blit(onionskin)
    elif pycam.mode_text == "GBOY":
        bitmaptools.dither(
            last_frame, pycam.continuous_capture(), displayio.Colorspace.RGB565_SWAPPED
        )
        pycam.blit(last_frame)
    else:
        pycam.blit(pycam.continuous_capture())

    pycam.keys_debounce()

    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":
            snap_stop()

        if pycam.mode_text == "GBOY":
            snap_gboy()

        if pycam.mode_text == "GIF":
            snap_gif()

        if pycam.mode_text == "JPEG":
            snap_jpeg()

    if pycam.card_detect.fell:
        print("SD card removed")
        pycam.unmount_sd_card()
        pycam.display.refresh()
    if pycam.card_detect.rose:
        print("SD card inserted")
        pycam.display_message("Mounting\nSD Card", color=0xFFFFFF)
        for _ in range(3):
            try:
                print("Mounting card")
                pycam.mount_sd_card()
                print("Success!")
                break
            except OSError as e:
                print("Retrying!", e)
                time.sleep(0.5)
        else:
            pycam.display_message("SD Card\nFailed!", color=0xFF0000)
            time.sleep(0.5)
        pycam.display.refresh()

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

Text editor powered by tinymce.

TouchOSC Setup & Use

Download and Install TouchOSC from either the Apple App Store for iOS or Google Play store for Android.

"TouchOSC MkI" is the original version, while "TouchOSC" is the modern version that has been re-written from the ground up. That's the one we're using.
Play Video: JOHN PARK'S WORKSHOP LIVE 1/18/24 Wireless Camera Control

MEMENTO Layout

Download the TouchOSC layout file linked in the button below and uncompress it. You can then transfer it to your phone or tablet -- for example, on iOS an iCloud shared folder can be used.

camera_memrem1.jpg
camera_memrem2.jpg
camera_memrem_scrn01.jpg

Open Document

In TouchOSC, tap the Editor Panel icon.

Then, scroll the toolbar to reveal the Open Document icon.

camera_memrem_scrn02.jpg

Tap it and browse for the MEMENTO_remote file.

Tap the Import button, this will open the layout into the TouchOSC editor.

A Comment popup will open, tap OK.

camera_memrem_scrn03.jpg

You can now close the Editor Panel by tapping the icon shown.

Connections

Tap the link icon to open the Connections page, this is where we'll establish UDP settings for the MEMENTO's server.

camera_IPScreen.jpg

IP Address

When you reset or power on the MEMENTO, look for the IP address listed at the bottom of the screen. This screen will pause for ten seconds so you can write down that IP address. This is the address you'll use on the next step in TouchOSC to fill in the Host settings.

Your IP address may change if your access point is updated or for other mysterious network reasons. If you ever have trouble connecting TouchOSC to your MEMENTO, double-check the IP address.
camera_memrem_scrn04.jpg

Tap the OSC button.

Check the box for Connection 1, select UDP from the dropdown menu, and then fill in the Host address of your MEMENTO (this is printed in the REPL serial output when the MEMENTO first connects to your WiFi access point). In my case it is 192.168.1.57 but this will most likely be different for you depending on your network.

Fill in the Send Port address as 8000. Then, tap Done to return to the editor.

camera_memrem_scrn05.jpg

Control Surface View

Scroll the top toolbar until you see the triangle "play" button. This launches the Control Surface view, which is the interaction mode of TouchOSC.

Press the big red button to snap the shutter on the camera -- remotely! This will send the OSC message over WiFi to tell the MEMENTO to take a picture (or start recording a GIF).

You can now also tap the focus button to have the camera focus on the center frame subject.

Tap any of the mode buttons at the bottom of the screen to pick among JPEG, GIF, Gameboy, and Stop motion modes.

The MEMENTO remote layout has two pages, which are selected with the tabs named remote and settings. Tap the settings tab now.

camera_memrem_beauty.jpg
camera_memrem_scrn06.jpg

Settings

The resolution page is broken into three columns.

In the Resolution column you can pick any of the available pixel resolutions.

In the LEDs column you can pick NeoPixel colors and adjust the brightness with the fader.

In the Effects column you can pick among any of the available effects.

To get back to the snapshot screen, tap the remote tab.

Any time you want to leave Control Surface view and return to the editor, tap the circle in the upper right corner of the screen.

camera_memrem_beauty03.jpg

Text editor powered by tinymce.

Related Guides
Adafruit MEMENTO Camera Board
By Liz Clark
45
Beginner
Updated
Facial Detection and Recognition with MEMENTO
By Brent Rubell
11
Intermediate
Updated
Remote Shutter Button for MEMENTO
By Ruiz Brothers
12
Beginner
Updated
Set up Web Workflow on the Adafruit MEMENTO
By M. LeBlanc-Williams
8
Beginner
Updated
3D Printed Camera Case for MEMENTO
By Ruiz Brothers
9
Beginner
Updated
Face Tracking Robot with MEMENTO
By Brent Rubell
13
Intermediate
Updated
IoT Bird Feeder with Camera
By Ruiz Brothers
24
Beginner
MEMENTO Camera Quick Start Guide
By Anne Barela
14
Beginner
Updated
AdaBox 021
By John Park
51
Beginner
Updated
OpenAI Image Descriptors with MEMENTO
By Liz Clark
26
Intermediate
Updated
MEMENTO Focus Stacking
By John Park
9
Beginner
LED Trampoline
By Ruiz Brothers
34
Beginner
PyBadger Event Badge
By Kattni Rembor
18
Beginner
CircuitPython Basics: Analog Inputs & Outputs
By Tony DiCola
51
Beginner
ESP32-S2 Reverse TFT Digital Clock Display featuring...
By Trevor Beaton
19
Beginner
Updated
Search

Search

Categories