Digitech JamMan Express Looper - Improved!

 Background

A few years ago I became interested in exploring the world of live looping and decided to dive in and buy a simple looper. The two that stood out at the time were the Digitech JamMan and the TC Electronic Ditto. Both are one-button loopers with a single volume control and LED indicators. The basic performance specs were nearly identical, so I based my choice on price and ease of use. The JamMan has three LEDs to indicate Record, Dub, and Play whereas the Ditto has a single bi-color LED. The three LED display of the Digitech was more user-friendly and as it turned out, it was also much less expensive than the Ditto. Choice made.

The problem

As I began my looping experiments I quickly uncovered two problems with the JamMan, and probably all single-button looper pedals for that matter and they are:

(1) A double-press of the footswitch is required to stop the loop, and

(2) once stopped, there's no LED indication that a loop still exists in memory.

For issue #1, my foot just isn't fast enough to stop playback, and it's more difficult because the double press isn't related to the tempo or rhythm I may be playing in. This is what prompted me to look into designing a single stop button that could replace the double press. Issue #2 gave me an idea of how to improve the UI. When the looper is stopped, all three LEDs are off, and there's no indication that any audio remains in memory. A long press of the footswitch will clear the memory unless one forgets to do that - which I did often enough that this was a problem, I decided to add a fourth LED to the pedal that would stay on after playback is stopped to indicate that a recording is still in memory. Performing the long press will clear the memory and turn off this LED.

Yes, I realize that these are "operator error" issues, and not necessarily deficiencies with the pedal :-) but it does point out that the design was based on constraints - using just one footswitch - and that had an impact on the user experience. 

The engineering method

As with any technical problem, there are numerous engineering solutions that will work. In the real world, our choices are limited by the constraints that are placed on the solution, whether they are time, cost, manpower/knowledge, parts availability, complexity, size, weight, noise, etc. In engineering, our primary task is to manage these constraints and deliver a solution that meets the desired performance specification and also falls within the constraints.

In this situation, I'm only building one of these, cost is not really an issue since I'm not selling it, so as long as my solution does the job reliably, and fits into the pedal case, I'm good. 

The Spec

The design must have the following:

• An external, single, momentary footswitch that triggers a circuit to generate a "double pulse" that will stop the loop playback
• This circuit can only be triggered when the looper is in the Play mode, and cannot affect any other state the looper pedal is in
• must operate on available internal DC voltages present in the pedal (9VDC and 3.3VDC)
• the looper pedal must operate as originally designed if the external Stop button is disconnected. 
• A simple cable connection to connect the external Stop footswitch to the JamMan that can be easily disconnected and replaced if necessary.
• An additional LED to indicate that a loop is still in memory and must be cleared before attempting a next recording. This LED will turn off when the memory has been cleared.
• The additional circuitry and LED must fit within the main housing of the pedal
• Note - it is acceptable if the pedal no longer will fit a 9VDC battery (it turns out that the JamMan eats 9V batteries rapidly, so using an external power supply is better anyway)

Reverse engineering the JamMan I determined the following:

• Location of the 9VDC main supply (from the external power supply or the 9VDC battery)
• A regulated 3.3V supply is available on the PCB
• The main footswitch is a momentary pull-down of a signal that is normally 3.3V
• The Record LED and PLAY LED are controlled by positive going 3.3V signals that turn on transistors to pull the cathode of each LED to ground to turn on the associated LEDs.

First design

Even with these requirements, there is some flexibility in the design. My first idea was to keep things simple (and old school) and use an NE555 timer chip. Why the 555? Well, it's a great chip with a long history, and I figured that it would be cool to design this without using a microcontroller, just because slapping an Arduino into everything seems to be the thing to do these days. 

The design I came up with uses one 555 to set the time delay between the two pulses as a 100mS one-shot, while the second 555 is triggered by the first and creates the actual pulse, a 50mS one-shot. Some things to keep in mind are that 555s are not re-triggerable, meaning that once triggered, they can't be triggered until it has finished the pulse, and second, they are triggered on the falling edge only, although the output pulse of a 555 is positive going. These two facts are important and required me to be creative as to how I triggered the second 555.

The circuit below was prototyped on a breadboard and tested, and it worked! The schematic was drawn in LTSpice and simulated before physically testing it.

The U1 NE555 is triggered by the falling edge of the voltage generator V2 (simulating the closing of a momentary footswitch), causing a positive going 100ms pulse at the output pin of U1. This falling edge from V2 is also coupled to U2 through diode D3, and in turn, triggers the first 50ms wide pulse of the Stop signal from U2.

The output of U1 is capacitively coupled by C5 to the resistor-diode network R3 and D2. The capacitor only couples the rising and falling edges however, the steady-state DC value is blocked, and D2 clamps the positive edge to Vcc, leaving only the falling edge from the U1 pulse to trigger U2 a second, delayed time. This is how the second 50ms pulse is triggered. The pulse train from U2 drive transistor Q1 which is connected across the two terminals of the main footswitch in the JamMan. 

All pretty simple, right? 

Signals: V(trigger1) is the signal from the simulated external footswitch, the falling edge triggers U1. V(timer) is the 100mS pulse generated by U1. V(trigger2) is the signal that triggers U2 - the first falling edge triggers the first 50mS pulse, whereas the second pulse (very short, created by the cap -diode-resistor network) is created by the falling edge of V(timer) and triggers the second 50mS pulse. V(pulse) is the output of U2 and is a pulse train of two 50mS pulses, 50mS apart. These positive going pulses are inverted by the output transistor Q1, which triggered the JamMan.

Notice that I had not yet implemented the logic to determine the state of the pedal and to prevent false triggers. The above circuit by itself can be triggered at any time, which will result in some erroneous results. After some consideration, I decided that this approach would be too complex, so I pivoted.

I slapped in an Arduino.

The Arduino approach

Let's start with the new schematic, and go from there:

Using an Adafruit ItsyBitsy M0 Express primarily for its size - the entire circuit needs to fit in the existing looper housing. In order to accomplish this, there will no longer be room for the 9V battery, but that's ok, as the pedal eats batteries quickly anyway. It's more practical to use an external 9V power supply.

First, we need to drop the 9VDC power from the pedal down to about 4.5V or so. There's no need to regulate this voltage since the M0 has an onboard 3.3V regulator, the only requirement is that the voltage is in the range of 3.5 to 6VDC. An LM78L05 would work just as well, but here I used a 2N5551 as a pass transistor and set the emitter voltage with R1 and R2.

Transistor Q2 is connected across the JamMan's footswitch. The Record LED (red) and Play LED (green) signals come from the JamMan and are used as indicators of the looper's state. The STOP footswitch is connected to D10 on the ItsyBitsy, and the Data LED is the indicator that the audio needs to be cleared. 

During operation, the STOP signal should only be applied when the JamMan is in PLAY mode (green LED is on). Any other double-press will put the pedal into a different mode (another fault of the JamMan pedal). To prevent these false triggers, the code only allows the Stop signal when the pedal's green LED is on.

The Record LED is also monitored so that the code can determine that a loop was created - a flag is set in the code and the Data LED will be lit after the Stop signal is executed. Long-pressing the JamMan's footswitch will erase the previous loop, and the code will turn off the Data LED.

Connection points on the JamMan PCB:

The Code

The Adafruit ItsyBitsy M0 Express can be programmed either in C, the Arduino's native language, or in Circuit Python, which is Adafruit's version of MicroPython, a specific version of Python optimized for embedded design. For fun, I decided to give Circuit Python a try. The code is essentially a state machine, looking for the status of the Play and Stop LEDs. A stop_Loop() function is defined to create the double 50mS pulse train.

# Looper Control 11/15/2022

# the Voltist

# simulates the double press of the footswitch, so that

# only one press of an external FTSW causes the looper to stop

import board

import gc

import time

from digitalio import DigitalInOut, Direction, Pull

gc.collect()   # make some rooooom

# ...... OUTPUTS .....

# Built in red LED

led = DigitalInOut(board.LED)

led.direction = Direction.OUTPUT

stop_Signal = DigitalInOut(board.D12)

stop_Signal.direction = Direction.OUTPUT

play_Led = DigitalInOut(board.D9)

play_Led.direction = Direction.OUTPUT

# ......INPUTS......

stop_Button = DigitalInOut(board.D10)

stop_Button.direction = Direction.INPUT

stop_Button.pull = Pull.UP

play_State = DigitalInOut(board.D7)

play_State.direction = Direction.INPUT

play_State.pull = Pull.DOWN

record_State = DigitalInOut(board.D11)

record_State.direction = Direction.INPUT

record_State.pull = Pull.DOWN

# ...........FLAGS..........

record_Flag = False

i = 0

# ....... Functions ............

def stop_Loop():

    stop_Signal.value = True

    time.sleep(0.05)

    stop_Signal.value = False

    time.sleep(0.05)

    stop_Signal.value = True

    time.sleep(0.05)

    stop_Signal.value = False

    time.sleep(0.05)

# ..............MAIN LOOP ................

while True:

    if record_State.value and record_Flag:

        i = i + 1

        play_Led.value = True

        # print("counter: ", i , end='\n')

    if i > 1:

        record_Flag = False

        play_Led.value = False

        i = 0

    if not stop_Button.value and play_State.value:

        led.value = True

        stop_Loop()

        play_Led.value = True

        record_Flag = True

        led.value =False

    time.sleep(0.01)  # debounce delay

Conclusion

The circuit works as expected. I no longer need to double-press the JamMan footswitch, my external footswitch only requires one press to stop playback. The newly added "Audio Present" LED effectively reminds me that I haven't erased the old loop so I can avoid the mistake of accidentally starting the old loop when I meant to record a new one. Everything fits into the JamMan housing, and all I needed to do was drill a hole for the new LED and the 1.8" jack on the side to connect to the external footswitch.

This was a fun little project that made my looper easier for me to use.