DIY Modular Synthesizer

Lately I've been building a lot of new modules, the most recent one being an envelope follower. Basically it converts amplitude to voltage. One way to use it is to take external input (like a drum machine, the radio, etc) and use its amplitude envelope of to control something else. For instance, if you take the audio output of an iPad running Korg Gadget playing a drum groove and take the CV output of the envelope follower and plug it into the cutoff of a filter, the filter cutoff will modulate based on the loudness of the drums. In other words, you can extract the amplitude envelope of one thing and use it to control another thing. As I understand it, this is how auto-wah filters and some kinds of compressors work! A cool little circuit.

Here's the envelope follower built and installed into the modular, using the radio as an envelope source, controlling all sorts of things:

https://www.instagram.com/p/BCQR2pHpHfC/

Here's a quick improvisation from last night when I had the envelope follower on the breadboard.

Korg Gadget running on iPad goes into a preamp, then into the envelope follower, and also one input in a mixer.

The output of the envelope follower controls the cutoff of a low pass filter, as well as the clock of a sequencer.

The sequencer sends CV to a pair of saw wave oscillators, which then go through the low pass filter, then finally into the mixer with the drums.

Check out the audio here:

http://www.chrisbeckstrom.com/korg-gadget-dual-saw-vco/

Got a new Mouser shipment in with a key item: Panel mount 5 pin DIN jack for MIDI!

Using the fantastic Mozzi Arduino library, I've managed to get MIDI input working! This is a huge step; now I can directly interface my modular with my various MIDI devices, especially my computer running Linux and its millions of modular MIDI generators.

So far I have a sine and saw wave with individually-attenuatable levels (via knobs on the panel). I've got a lot to learn when it comes to coding for Arduino, but I'm making progress! Here's a very short clip of the new module:

It's built and MIDI input works! Now it's time to program #synthdiy #arduino #modularsynth

A video posted by Chris Beckstrom (@cbfishes) on Feb 11, 2016 at 12:30pm PST

I've been doing a lot of building, patching, and recording lately. Getting better at the whole "video and audio record patches" thing, using my GoPro and Kdenlive video editing software on Linux. Here are three recent patches- my synth is growing and I think it sounds pretty wild.

Some beeps, bloops, and drones, experimenting with control voltage feedback:

A random-ish sequence generated by various clocks to shift register to r/2r ladder to VCO:

Qmidiarp MIDI sequencer running on Linux, sending MIDI to iOS which generates the sound, which is then manipulated via analog circuits and a digital reverb unit.Also, if you're following this project you might be interested to know I uploaded almost all the circuits to GitHub. They are mostly slight variations of circuits I found on the internet. Go look at the original circuits, not mine! Here's my repo:

https://github.com/chrisbeckstrom/diy_modular_synthesizer/

New video using my synth. Check it out!

More details:

For this track I recorded video while I recorded each part, then edited everything together in Ableton Live. It's certainly a lot of seeing my bearded face, but if you suspend your disbelief it's sort of like a band playing together in my basement.

- Technical stuff -

The track started with a patch on the modular. I clocked a 4-stage shift register with 16th notes from Ableton Live (clicks were generated in a Max for Live clock divider/multiplier I built, then sent to the modular through an audio cable), then sent a non-synced clock into the shift register, which created some cool variations. I took the 4 outputs of the shift register and ran them through an R/2R resistor ladder which then modulated the pitch of a VCO. I was trying to find a way to generate a funky 16th note sequence that didn't exactly repeat– and this does the trick! The only "regular" sequencer I have built so far is 10 steps, so it is limited in terms of loop length. At the beginning of the track only one of the shift register outputs is patched into the R/2R ladder. As I patch the other three, the sequence evolves and gets a bit more complicated.

The lead sound that I play with a keyboard is originally generated in Ableton Live as a square wave. I sent that square wave (via audio) into a 4040 clock divider, which in turn spits out an analog square wave an octave lower. I mixed two octaves to get a more interesting sound. I then patched those squares into a vactrol-controlled resonant low pass filter. Someday I'll build a MIDI to CV module, but for now this is the easiest way to play the modular with a "real" keyboard.

The "hihat" sound is a 40106 CMOS noise module (sort of like the Roland TR-808 cymbal circuit) going through a low pass gate which is modulated by my brand new slope generator (the pink panel module).

The "cowbell" sound is just two square waves through a diode mixer (again, similar to the TR-808 cowbell) patched through the low pass gate, triggered by a manual button.

There's some other stuff going on, but after I disassembled the patches I forgot how I made those sounds. That's what happens when you use a modular! I think one of the sounds was a square wave patched into the slope generator for wave shaping, then patched into a distortion module, then into the low pass filter and the cutoff was modulated by a 9 step sequence. Pretty sure I also modulated the pitch of the oscillator with another oscillator which created those weird sci-fi sounds. In mixing I panned that stuff all over the place which I think sounds pretty cool, maybe a little disconcerting if you're listening on headphones.

There are some feedback-ish sounds that happen, and those are created by feeding the output of a Live plate-ish reverb back into itself.

The drums were recorded with three mics; the bass drum goes into Ableton Live and then through an EQ and gate, which then heads into the modular via audio to trigger the twin-T drum module. Basically the "real" bass drum triggers the synth bass drum, which I think sounds pretty badass.

The other stuff is pretty simple: bass through a tube preamp into Live, saxophone through a Røde NT1-A, the tube pre, then into Live.

All audio went through my analog Mackie mixer on its way into the computer, which I think helps give everything a bit of an analog flavor.

Musically, I'm interested in the intersection of old-school style Detroit techno and 70's-style funk. I happen to think modular synths can be amazingly funky, and I really like the combination of super tight synth lines with loosey goosey drum playing.

I put down my soldering iron to attempt to make some music with my creation.

My goodness do I love how it sounds. Sure it's imperfect– I'm positive I've done a million weird things in my circuits– but it makes a wonderful noise. Actually, many noises.

And of course by playing this instrument, I can figure out what I need more of. Right now that is mixers, VCAs, and envelope generators.

I've started to put documentation together about the synth. Everything is in a million different places (Google Docs, pen and paper, scraps of wood, etc); seems like it would be useful to put everything together.

The synth is now on GitHub:

https://github.com/chrisbeckstrom/diy_modular_synthesizer

So far I've added some of my (super simple) panel designs, a TouchOSC template, and the PureData patch that is running on the Raspberry Pi. I'll be scanning or taking pictures of the actual circuits and putting them on GitHub as well. I'm not sure about the etiquette as far as that goes, however, because most of the circuits came from people on the internet. Of course I want to give credit where it's due; perhaps I'll just link to their original posts.

Of course I'll also put other related documents like my 6U case "plan" (if you could even call it that) and any other helper software related to the synth.

In the mean time, watch the GitHub repository for more details.

After a few months focused on other things (fishing, cooking, kayaking, etc) I'm back on the synthesizer building war path."In the past few weeks I filled my third 19" x 6U rack and built another. Some of the new modules:

– Multiple clock module (40106)– I wanted more clocks; something went wrong in building the circuit so I only got 5 instead of the 6 on the chip. Oh well!

– Dual 4-bit shift register (4015). This was completely inspired by Elliot Williams' post about shift registers in the Hackaday Logic Noise series (http://hackaday.com/2015/05/04/logic-noise-taming-the-wild-shift-register/). I love watching the blinking lights! I also discovered (stumbled upon) if I take the output of each step of the register and run it into a R/2R ladder, which then modulates the pitch of a VCO, I get a psuedo-random (but repeating) series of notes. It sounds great!

– Spring Reverb – I have an old spring reverb I got on ebay, which I'd been using with tube preamps to boost the input and output. I wanted to integrate reverb into the synth itself, so I used a pair of op amps to build some preamps/amps for the reverb. In the process of doing that I discovered the idea of feedback on a modular synth; running the output of the reverb through a filter then back into the input, I'm able to get some absolutely gorgeous very warm-sounding distortion oscillations. Aside from that, a bit of spring reverb makes everything the synth does sound even more awesome.

– Simple vactrol VCA (voltage controlled attenuator)– Still haven't figured out how to make a good active VCA, so I built another vactrol-controlled one. It's just an LED stuck to a LDR that controls volume. I'm not able to modulate the amplitude with audio-rate CV, but it works great for simple envelopes and on/off. The characteristics of the LED (I used a blue one) create a very nice quick decay when the VCA is pinged, creating excellent percussive sounds which I love.

– Quad AND gate (4070) - just wired the pins to the panel. Works great with my new clock module– run a bunch of clocks into the AND gate and get a variety of sort-of-random-repeating clock outputs. When connected to my 10 step sequencer it makes cool stuttering sequences.

– Active LP and HP filters (no resonance)– I didn't have any high pass filters so I created this module. I put a switch on the panel which, when flipped, sends the output of the low pass filter into the input of the high pass filter. My idea was to make it into a band pass filter. It doesn't work exactly as I expected, but that's part of the charm of this whole synthesizer. Somehow the high pass filter also amplifies the signal a lot (I think I used the wrong size resistor) which sounds really cool.

– Super growly amplifier/distortion– I wanted to create another amplifier/preamp specifically for taking external sounds and bumping them up to my synth level (it's very hot!) but instead ended up creating an op amp distortion circuit. It easily turns sine waves into square waves. Love it! Great for growly sounds.

– Headphone output– I've been running my synth through an old analog mixer which goes into Ableton Live running on my computer, but sometimes I want to keep the computer off and just plug in headphones. I didn't have any stereo 1/4" jacks so I soldered some wire onto a mono jack to make one. Added a simple attenuator and now I have a stereo (TRS) headphone output. Nifty!

I've also been experimenting with other ways to control the synth, especially using piezo pickups as triggers:

https://vine.co/v/eDbZddKYDDA

After adding those modules I've mostly been working on ways to integrate a Raspberry Pi Model B+ into the synth. I've been doing a lot of programming in PureData running on the (headless) Pi– here's what happens:

– MIDI comes into the Pi via a USB MIDI device

– PureData takes the MIDI and uses it to generate gate on/off messages which are sent to the GPIO pins or the right channel of the audio output (timing is better this way), which can then be used in the rest of my synth

– PureData also takes the MIDI, converts it to frequency, and uses it to control various software oscillators. So far I have a few oscillator modes: tones (sine, triangle, saw, square, with a few weird digital-sounding ones in there like sinesum square, whatever that really means), noise (white, pink), an a very cool sounding additive oscillator (16 sine wave oscillators pitched in the harmonic series above the incoming frequency). The oscillators

– A 16-step gate sequencer that listens to external clock input (via GPIO) and spits out gate messages (via GPIO).

– the PureData patch is controlled by various GPIO pins (buffered logic inputs from the synth) as well as OSC messages coming from TouchOSC running on an old iPhone I mounted to the panel. It might be the coolest thing I've done yet; I built a touch interface in TouchOSC that lets me control various features of the oscillators. The iPhone is also how the 16-step gate sequencer is programmed.

Originally my goal was to create an all-analog synth, but my limited skills with analog electronics have made creating exponential oscillators very difficult. In other words, I can't really "play" them with my keyboard so the notes fit the traditional equal-tempered scale. Generating the a square oscillator in PD and running that into a 4040 divider spits out a great analog square– which may be the weirdest way I've seen to implement MIDI control of an analog synth... but it works!

Here are some videos:

https://instagram.com/p/6-lGfSJHeu/?taken-by=cbfishes

https://instagram.com/p/6-Zh3FpHSG/

My synth now has a digital brain and a touchscreen controller. #weekendproject #diysynth #raspberrypi
A video posted by Chris Beckstrom (@cbfishes) on Aug 29, 2015 at 10:03am PDT

Analog and digital, bffs #diysynth #electronics #puredata #raspberrypi
A video posted by Chris Beckstrom (@cbfishes) on Aug 29, 2015 at 11:44am PDT

And even the totally digital oscillator sounds from PD sound good– they are at the beginning of the signal path, and after going through all the analog circuitry (especially the resonant LP filter!!) they sound warm and fuzzy and wonderful... and in tune. Because the Raspberry Pi is hooked up to my main computer via MIDI, now I can sequence my analog synth with Ableton Live. It's amazing!

Here's a finished song using the synth and a drum set (this one doesn't use any PureData sounds– it's all analog):

https://chrisbeckstrom.bandcamp.com/track/soundcheck

At some point maybe I'll share all the circuits I've used (at the risk of showing how little I really understand about electronics!). Almost all of them exist only in hand-drawn circuits on paper, but I think they might be helpful for other newbies like me; it really is possible to build stuff like this without an extensive knowledge or understanding of electronics (or even with that many components).

Thanks, Hackaday! I couldn't have done this without you (especially you and your Logic Noise series, Elliot Williams!!) Also fantastic is the electro-music.com DIY forum. Check it out!