Introduction: PacificCV Controller for Modular Synths

A few weeks back I published an Instructable for the Oceania MIDI controller that I built to pair with my Make Noise 0-Coast. In it I mentioned that I was building a CV version as well, and here it is. Since the midi version was built to match to the 0-Coast, which (from the Make Noise Website) "...utilizes techniques from both the Moog and Buchla paradigms (aka “East Coast,” and “West Coast,” due to their locations), but is loyal to neither and thus implements “no coast synthesis.” Since this rack was explicitly inspired by the Buchla Music Easel (probably for most the primary visual representation of West Coast Synthesis) I named this one after a specific ocean.

If you're into Eurorack modular synths, this is essentially a DIY capacitive touch sensor keyboard like the Buchla LEM218 or the EDP Wasp. I've built it to take advantage of the "pressure sensitivity" inherent in the ATMega touch sensitivity, but there's no reason that you'd have to include that-it's just a nice "extra" that you could use for example to feed the CV of a filter in the patch. For most western musical control, you could get away with using a single DAC for CV and have it completely useable.

This unit will only output 4 octaves without any help (0-5v on the + rail) which is usually going to be more than enough, but if you really wanted to push it into the negative territory it's easy enough with outboard equipment. It's also a very satisfying "touch strip" feel in spite of the cut ridges.

Step 1: What You'll Need

Materials differ from the Oceania just a little:


1 Arduino Mega-I recommend the mini style (like this one at Amazon) to make it easier to mount under the sensor pads, but it's not absolutely necessary. You might even be able to use an Uno/Genuino or Mini or Feather, but that would probably require you to treat the ADC pins as digital and I don't know if the standard capacitance routine works on those. And you'd have to figure out the programming on your own.

1-2 Adafruit MCP 4725 I2C DAC break out boards

2-3 mono 3.5mm phono sockets

1 single sided sheet of copper clad (used for etching your own PCBs) to equal a strip about 18"x1 ⅛"

PCB strip board

16-32 solderable duPont pins (Arduino Style)

A Eurorack power bus compatible ribbon strip (pack of 10 from Amazon, or if you have an extra laying around.)

Stranded hookup wire (the thinner the better-I used this 30AWG, again from Amazon)


Something you like and are comfortable working with to mount it on


A table saw (alternatively, a CNC or laser cutter would probably give you better results if you know what you're doing.)

A soldering iron and soldering tools, including pliers, flush-cutters and wire strippers

A printer (paper, not 3-d)(but maybe also 3-d)

A straight-edge

A permanent marker/markers

A drill (a drill press or rotary tool press would be best.)

A Rotary Tool or file

Steel wool (optional)

Step 2: The "Not Keys"

More or less copying myself from the other instructible, print out the attached pdf and cut out the out the reversed (top) version of the pattern (the one that doesn't have any note letters or Arduino pin numbers on it). If your copper clad piece isn't long enough then decide where to break and abut the sensor pads and cut the pattern at that/those point(s). Next, cut the copper clad into strips the same size as the strips of paper (each should be 1⅛" by however wide the pattern strips are.) Tape the paper strips to the backs of the pieces of copper clad and, using a permanent marker, mark the corners of the triangles, parallelograms and rectangles on the edges of the copper clad, then use a straight edge to connect them so that you have something that looks like the photo with this step.

Next, very carefully set the table saw blade so that the blade barely cuts above the table level. The point is to remove a blade-width of the copper side of the clad but not cut through the fiberglass substrate (at least not substantially.) You may want to test it with some of the "drop" left over from cutting the strips of copper clad to see that the blade is neither too high nor too low. Cut the clad off using the lines drawn on the back as guides with which to line up the blade. You'll want to use an angle guide with an extension. For this version, I built a jig that had 2 62.5˚ guides, but either way the diagonal lines should all be at 62.5˚. Go slowly. Again, my cuts didn't quite come out as perfectly as I'd hoped (but they were a little better than the MIDI version at least.)

Once the channels are cut into the clad, you'll want to file down any rough copper edges. This really lets you get that touch-strip feel, especially if you keep the solder blobbing to a minimum. I took some steel wool to mine to give it a brushed feel.

Needless to say, take all the usual precautions when working with a table saw. Wear safety glasses and use a push-stick, and FOR GOD'S SAKE IF YOU DON'T KNOW WHAT YOU'RE DOING DON'T EVEN TRY THIS! Again, I've formatted the pattern here as a PDF in hopes that if someone has a CNC machine or laser cutter they'd like to try this with that they can use the vectorized version of the layout and cut a professional looking one. (Please share the results if you do this.) I'm also thinking about trying to lay it out as an EagleCAD file or something and having a PCB house make a few of these with traces to match the Arduino to cut down on wiring and failure points, but I recon that would be prohibitively expensive and would make the controller deeper than I wanted for my project.

Once the not-keys are cut into the clad, drill holes with as small of a bit as your press can handle that will still allow you to get your hookup wire threads through into the tips or corners of the top rows of each of the not-key strips. As before, the shape here isn't important-if you wanted you could cut a traditionally shaped keyboard or a Penrose diagram or whatever you like (assuming you had that CNC or laser cutter.)

Step 3: Electronics

For the next steps, take a few minutes ahead of time to be thinking about how you want to mount everything in order to make an educated guess about how long to make the various connection wires.

Solder one piece of hookup wire to each of the not-keys by running the wire through the drill holes from the back side, then flush-cut the wire off from the copper side. Without being too technical, think about how you're going to mount it, and plan to make the wire just long enough to get from each not-key in each strip to the Arduino without having more than a couple mm of extra wire. Then, very carefully, one wire at a time, solder the wire from each not-key to to the Arduino Mega pin corresponding to the number marked on each not-key in the bottom diagram in the pdf attached to step 2. This is the make-or-break part of the operation. You may wish to skip ahead to the programming part and test the function of the keys after every few solder connections. (If you're not using the miniature 2560 then you may want to look at a solderable shield option or use more strip board and dupont pins.) I recommend using a rotary tool to smooth any jagged protrusions from the solder blobs on the faces of the not-keys.

Next, wire up the DACs as in the Fritzing diagram. Note that only on the one used by the expression CV out is the A0 tied to the 5v (this is in order to put it at a separate I2C address from the volt per octave output.) If you choose not to include the CV expression, then that's the ADC to leave out. Connect 5v to each Vdd, Gnd to Gnd, SDA to SDA, etc.

When the DACs are wired, you may wish to look for an I2C scanning sketch online in order to test that they are functioning and recognized, but this isn't strictly necessary-Adafruit has pretty high QC standards after all.

Next, attach the Vout terminals of the ADCs and the Arduino Pin 7 each to the tip connector of one of the 3.5mm jack sockets, and run the sleeve connector to one of the Ground lines. Note that if you plan to mount the jack sockets in a conductive metal plate that you usually only have to run a connection from one of the jacks or the plate itself to the Ground rail as most jack sleeve connections are designed to conduct to ground that way.

Finally, solder two rows of 8 duPont pins side by side in a piece of strip board and power the Arduino by connecting the Eurorack 5v to the Arduino Vin and one of the three Ground lines to the Arduino ground. (See the Fritzed diagram and the last illustration for the pin layout across the strips.) If you want to, you can create extra Eurorack bus rows by putting more 2x8 rows of pins across these same strips, and stagger them a few rows apart to give the plugs some room. I usually run a red sharpie along the -12v row since this method doesn't include plug shrouds-just be SUPER CAREFUL AND ATTENTIVE THAT YOU ALWAYS PLUG YOUR EURORACK GEAR IN CORRECTLY! Neither Instructables nor I can be held responsible for inattentive plugging and you don't want to let the magic smoke out of your expensive modules.

If you want you can solder the Eurorack connection pins and the ADCs onto the same piece of strip board as I did above, but this isn't super critical. However, if you keep it neat, it's more likely to work dependably.

Step 4: Mount It

Again, this is a part where how I chose to do it isn't critical. You can tell from the main photo at the top that used a construction of PVC sheets and aluminum and ran the wires from two strips of not-keys down grooves cut into them. I used puffy two-sided tape to attach the not keys.

There are advantages to using aluminum for the CV jacks. It's easy to work and conductive, so you can take advantage of the grounding effect I mentioned.

Mine was made to fill the top-front of an Apache case (Harbor Freight's version of a Pelican Case) that I outfitted to use as a double 84hp Eurorack case. (The whole thing was kind of inspired by the Buchla Music Easel-I want d the modules at the top and a control surface at the front.)

This would probably look great on wood too, but you can use anything you want as a mount-foam core, 3d printed PLA, cardboard, a chunk of flat fiber glass, etc.-any electrical insulator or surface that can be electrically isolated from the control surface enough to prevent capacitive interference, given your abilities and stock and preference for longevity.

Step 5: Program

As on the Oceania Midi programmer I'm not going to get into how to upload sketches to an Arduino. Use the getting started guides only instead of the "Blink" sketch use the two I've attached (it ended up on the introduction-this editor seems to recognize it as a different kind of media.

In the attached zip file are two sketches. Download and unzip them and add them to your Arduino sketch library. The first sketch(megaCapacitiveKeyboardTest) is an adaptation of the Arduino readCapacitivePin function which is here as a test that shows you what key is being pressed and the capacitance value for it while it's being pressed in the serial monitor. It will let you see some values and test the connections from the Arduino to the not-keys, and was what I meant for you to use when describing the testing of the soldering process. Load this onto the Arduino, open the serial monitor (make sure to set the serial monitor to the correct baud) and touch a few not-keys, noting the values for the heaviest and lightest touch you'd be using to play. These will be used for the minCap (lightest touch) and maxCap (heaviest) values in the second sketch (PacificCV), which is what you will actually load onto the controller when you're done and ready to play. If you need to adjust the values, do so, then save the sketch again and upload it to the PacificCV.

Step 6: Play

If you have a Eurorack system or any semi-modular Eurorack compatible synths, you should more or less understand what to do with this.

Plug the controller into the busboard using the ribbon and again be very careful to orient the cable right-if you do it upside down you could end up setting it up as a reversed +12v circuit through your Arduino, and there's a very real probability this mistake would fry it and/or cause damage to your rack power supply, so make sure that the Red stripe is at the bottom of the header row pairs as represented in the circuit diagram.

Patching is the fun part of modular synthesis. The outputs should look pretty familiar (so you may want to label them somehow after you mount them)- a volt-per-octave output usually feeds an oscillator and the gate will normally go to a low-pass gate (or an envelope generator for East-Coast purposes.) The pressure-sensitive CV can go to anything with a CV in-filters, gates, oscillators, mixers, etc.

The octave +/- pads seem to be pretty reliable on mine. Again it only goes from 0v-5v so you're limited to a range of 4 octaves, but using outboard equipment like the Make Noise Maths or the Erica Synths Pico Scaler you should be able to skew this up or down. From Ziv at Loopop (whom I highly encourage Eurorack and synthesis enthusiasts to watch and support on Patreon):

"Maths should do the trick just fine - plug your Arduino [volt per octave ADC out] into input 3, turn attenuverter 3 fully CW - and then use attenuverter 2 to add or subtract to it (it's normalled to 10v if nothing is plugged into it), and turn the attenuverter on input 2 fully CCW to go for the negative ranges. Use the SUM output as the result (and obviously make sure the envelopes aren't doing anything). I'm not sure maths goes above +10 or below -10 but any other range should be fine. If you have access to a VCA that adds gain you could also amplify the Arduino CV range beyond 5v and use your Arduino for 0-10v, -5 to +5, or any other 10v range, offset by maths."

I haven't actually tested that or the Erica, but let me know what you come up with-especially if you have and use this with a Mother 32.

Edit: I've linked to a video I did to demo this and a few other projects I've been working on. It's not Kaitlyn Aurelia Smith, but I'm proud of the units I'm using here.

Finally, I think there's still an Arduino contest open that I can enter this in and qualify for, so if this is at all helpful, please consider voting for me in it!


Arduino Contest 2019

Participated in the
Arduino Contest 2019