Zero Budget Pedalboard

Last version, I promise! This one’s called 3.2 on account of the three stereo lines that get mixed together and provide the nexus for routing:

New in this version:

    • Zoom G1X Four: the venerable RP80 has been replaced by a startlingly modern unit that completes the trio of entry-level multieffect brands. In keeping with the zero-budget theme, it was not bought but traded for services (not yet) rendered.
    • The big expression pedal was not particularly useful connected to the RP155, so it was switched to an input to the ESP32, providing MIDI control of the V-amps’ various CC parameters.
    • The display was updated to better suit the new setup, now reading

BBBBBBBB MMM PPP
NNNNNNNN RRRRRRR

B = Bank name
N = Preset name
R = RP155 preset
M = * mode
P = pedal mode

     • Filthy Frank is what the old MOFO prototype ended up as. For the nasty fuzz spot I went back to an old favorite based on Doug Deeper's Random Number Generator.

But most of all, after a year of tinkering I was finally able to record a couple of sounds coming out of this thing and put together a quick demo. Unfortunately my guitar playing is even worse than my programming.

So I did something silly: a couple of hours into configuring patches for the pedalboard I remembered I don’t actually like the sound of tubes and that an eight-button interface is fine for casually tweaking a preset but not much fun when you have to set 125 in one sitting. Sure, I don’t need a hundred presets and I was mostly done already but the idea had already taken over—I would use an ESP32 so I can configure everything with a web interface. And while at it, I also managed to squeeze in one more guitar processor instead of things I didn’t use.

The RP80 took over the RP155’s job as pre-distortion effect provider, while the RP155 with its more extensive reverb and delay options has become the purveyor of “wet” effects.

Does your head hurt too?

Lament Configuration V2

I had bought a couple of ESP32 modules for a future venture and since I had no previous experience with the platform I figured this could be a good learning opportunity. And not to have things too easy I also made it my first KiCad project.

The ugly formatting and abundance of jumper wires are due to lazyness though, not my lack of experience with KiCad. Same reason I “surface mounted” the THT components: I loathe drilling tiny holes.

I did finally buy a white-on-blue LCD that better fits the overall color scheme, so I guess the zero in “Zero Budget” has become about $10. Removing redundant information from the display allowed me to include a label for the ○ (function) button as well.

Of course the one time I didn’t use IC sockets I got a dead channel in the level shifter talking to the LCD. So I connected the input straight to the 3.3 V output and it works just fine, indicating I didn’t need that shifter anyway. The PCB transfer didn’t come out great but it’s still better than protoboard.

Believe it or not, it’s a lot more tidy.

I got bogged down in firmware land for a week due to what I hear is called “premature optimization”, but once I realized the ESP32 has massive ammounts of RAM and storage compared to an ATmega328P everything went smoothly. The ESP-WROVER I used even has extra PSRAM that I didn’t touch. My programming education started in the 5th grade and ended in the 8th, so I’ve attached the code in case anyone wants to point out my mistakes:

Lament Configuration V2 firmware and data folder.

Now interface design is something more up my alley, and I hope I kept it simple and funcional:

Clicking a bank from the left list loads its contents into the central table, where the 5 presets (and the bank’s name) can be edited at once.
The list of RP155 presets serves as a reference and their new ultra-wide 6 character labels can also be edited here.
Then the [save] button writes all the configuration data to SPIFFS in JSON format.

Teaching an RP80 to speak MIDI

First order of business for welcoming back this ancient processor was to give it a proper antique paint job.

Then I implemented a very quick hack for a MIDI upgrade: an ATmega328P reads the display to find where it’s at and shorts either the Up or Down button to ground if the last received MIDI Program Change is different from the active preset. The RP80’s digits and LEDs are all multiplexed so I used a hex inverter to kind of clean up the signal. It probably could be done programmatically and I’ll probably try in the future but right now I’m squeamish to delve into port registers and interrupts and whatever else would be involved. The current solution can only do 9 presets but it preserves the original functionality and it’s not essential.

RP80 MIDI firmware

Patchbay

The most trivial element of this build, motivated as I stumbled upon that 3 RCA socket assembly from an old SCART to A/V adapter. The plate was cut out of the same unidentified plastic (Delrin?) that makes up part of the Lament Configuration and covered with matte black vinyl.

I/O unit 

I’ve cut a bit off the PCB and enclosure because the initial preamp/buffer situation that required a separate 9 V supply was too much hassle. Original schematic with the removed preamp part shown in negative color:

VU meter

The movement from the cheapest analog multimeter, a custom-printed backing and a simple op-amp driver makes a bouncy needle toy.

OD

A fairly generic ‘three knob overdrive’ but all the knobs are ‘gain’ controls of sorts. The box had previously housed a distortion prototype but I had even less need for that than an overdrive, so here we are. The schematic is more of a guideline, as I ended up using 47 nF for C4, D1 is actually two antiparallel red LEDs and there’s an extra 1 nF cap across the ‘GAIN’ pot.

DickButt

A Raygun Youth Chaos Fuzz with minimal modifications like electronic bypass and a couple of extra selection modes. I was very fortunate to find a small 6 position rotary switch in some old BOSS pedal I cannibalized. The enclosure came from the tuner that now sits in the Lament Configuration, and since one non-latching footswitch has been sitting in my parts bin since 2014, I used it for some momentary fuzzy glitchy stabs.

Tube Boomer

One of if not the main purposes of DSP multieffects is to replace big heavy tube amps. But guitar players love to fetishize their gear and a rich mythology has been built around the Tube Sound and how digital (or analog solid state for that matter) simulations could never capture its mysterious essence. Not being one of them, I find myself free of such preconceptions. But I had already built a Soldano SLO type of preamp with two 12AX7s, along with its own power supply, for a different project that got shelved / redesigned. Since I had some room and apparently nothing better to do, I decided to cram it into the pedalboard. I made the aluminium enclosure out of a PC PSU and some wire mesh, but after fiddling with stuffed PCBs running at 300+ V with intermittent contacts and strained wires, I decided to adjust my plans. So “Might as well include this preamp since it’s basically done” turned into a week of frustration as I made the switching system twice and shifted to a hybrid design with one 12AX7 and one op-amp, similar to the Blackstar HT series. This left me with plenty of room for point-to-point wiring for even more mojo.

The most interesting part of it is probably the switching: it’s powered by a separate 9 V supply (shared with the rest of the pedals), which allows me to turn off the tube PSU when I’m not using it (close to always). This prevents unnecessary wear on the heater and interference from the HV plate and high current heater rails while still passing the signal in bypass mode.

Oh, and the name comes from this brilliant YouTube comment:

The brains of this operation reside in this slightly wedge-shaped enclosure I built from acrylic (covered with auto window tint), MDF, some unidentified white plastic sheet, two hinges and a bit of aluminium:

I also made the footswitches out of nuts and bolts and springs, since even the cheapest momentary stomp switch is about $2, and that multiplied by nine does not equal zero budget.

The main board just haphazardly holds the LCD, Arduino and Raspberry Pi together, along with a 5 V regulator. This assembly is joined by the guts of a guitar tuner with a nice big display.

The RP155 board is screwed directly to the particle board base of the pedalboard. Why is it missing the two‑digit display? Because I unsuccessfully tried to move it and made a mess of the pads and traces.

Interface

Half a sheet of A4 showing the extent of my planning:

The V-amps have presets in sets of five (A through E) organized in 25 banks and the controller mimics this layout:

- buttons ˄ and ˅ increment and decrement the current bank
- buttons A, B, C, D and E recall the corresponding preset
- button ○ or • or just * is for an assignable special function on each preset:

• TAP : Tap tempo for time-based effects
• VERB: Toggle reverb on/off
• MUTE: Toggle mute for both V-amps (set to tuner mode)
• M V3: Mute V-amp 3
• M V2: Mute V-amp 2
• FX : Toggle V-amp effects on/off
• Rpbp: Toggle RP155 effects on/off
• DET: Toggle V-amp ‘drive’ mode

Since this function, the preset name and the state of the analog pedals need to be set and saved, a configuration mode was needed and it is accessed by pressing the ˄ and * buttons simultaneously:

Here’s what the buttons do in edit mode:

˄ / ˅ = scroll preset name
D / * = scroll RP preset
A = cycle Tube Boomer mode
C = cycle * mode
E = save and exit edit mode
B = exit without saving

The state of the other controllable pedals (NR300 and SF5) is automatically read and stored when saving.

And here’s the breakdown of the display:

Main screen 

NN BBBBBBBB RRRR 
 A PPPPPPPP MMMM

Edit screen

NN PPPPPPPP 
 A RRRR TT *MMMM

N = Bank number
B = Bank name
R = RP preset number (shows ‘…’ while the Pi is booting)
A = Preset index (A/B/C/D/E)
P = Preset name
M = * mode
T = Tube Boomer mode

The Raspberry Pi is essentially being used as a MIDI to USB bridge: all it does is read a MIDI input via ttyMIDI and pass it on to the RP155 USB MIDI port through an ALSA connection. It also sets a pin high to signal when it’s booted and ready. Why not do everything in the Pi? Because it takes a while to boot. By using DietPi and optimizing it to the best of my knowledge (which is not much, as this was my first project involving a Pi), I got it down to about 13 seconds. Which is less than what it takes for the 12AX7 in the Tube Boomer to heat up. The V-amps themselves take about 5 seconds to boot up, so I could probably make it work, but I’m more comfortable with the Arduino and I don’t mind the modularity.

Indexed view of all the components:

1. patch bay
2. I/O unit
3. Behringer CC300, a Dimension C clone
4. Behringer V-amp 2
5. Behringer V-amp 3
6. PSU for Digitech RP155
7. PSUs for V-amps
8. PSU for the pedals and everything else
9. PSU for CC300 and I/O unit
10. PSU for Tube Boomer
11. Power switch for Tube Boomer
12. VU meter for input/DI level
13. expression pedal for RP155
14. Behringer NR300, an NS-2 clone
15. Tube Boomer preamp
16. DickButt fuzz
17. DOOM overdrive
18. Ibanez SF5, a Big Muff style fuzz
19. Lament Configuration

Signal flow diagram: