Arduinon’t

My latest PCBs from PCBWay arrived earlier this week. I assembled one today and, well, I almost got the design right.

Back in prehistory, on March 11, I wrote:

I’m actually breadboarding another controller, also based around an Arduino and a DAC chip, and it’s occurred to me I could probably design a PC board that’d work for both the ribbon controller and the new controller. The circuits are simple enough that a PCB seems almost overkill but at [Chinese fab] prices, why not?

Since then that intention’s evolved and multiplied. I started thinking about how a general Arduino+DAC PCB could be used for other synth projects. Then I found Synapse, an open source project by Vincenzo Pacella, which was nearly what I was thinking about doing. Except for a few things. Synapse is a shield for an Uno-form factor Arduino. I wanted something to plug a Nano into. Synapse has 3.5 mm jacks installed on the PCB; I wanted my 1/4″ jacks off board. Synapse has two each CV inputs and outputs and gate inputs and outputs; I wanted a few more inputs. Finally, Synapse has the ability to switch its CV output range between ±5V and 0–10V on the fly in software, which is kind of cool but I can’t think of any reason to want to do that, and it complicates the hardware.

So I forked Synapse and started modifying the hardware into the kind of board I had in mind. Lacking inspiration I called it dac/ino. With a lower case d, I don’t know why, it just is. Eventually I sort of forked the fork to become two designs: one full-featured one, intended to be the core of synth modules and to be powered by a synth’s ±12V supply, and one smaller, stripped down version, able to run on a single 9V supply, for use in controllers and so on. dac/ino lite, it’s called.

The board I got this week is the full dac/ino. It has up to four gate inputs, four CV inputs, two gate outputs, and two CV outputs. (If you don’t need all those inputs and outputs you can omit the relevant components.) To read front panel switches and pots, two more digital pins and four more analog pins are broken out to pads on the board. The Nano sits in the middle and sends the CV outputs via an MCP4922 12-bit DAC. There are jumpers to select the range for each CV output, 0–10V or ±5V. All the inputs and outputs as well as the +5V from the Arduino can connect via Molex connectors (or you can just solder them). The board is just a bit under 10 cm by 10 cm which means, first of all, it’s $5 for five boards from PCBWay and, second, it’ll fit parallel behind a 10 cm wide Kosmo front panel.

Assembly was pretty easy. A fair number of parts but given that most of them are the resistors, diodes, and transistors buffering and protecting multiple identical inputs and outputs, there was something of an assembly line quality to soldering them.

dac/ino, all ready for ICs and Arduino to be plugged in

I plugged it in and turned it on and… it semi worked.

The gate outputs worked, anyway. But I wasn’t getting anything good on the CV outputs. A little probing showed the right voltages coming off the DAC but not after the output op amp. And a check of the schematic revealed why: I’d gotten the inverting and non inverting inputs switched around.

Well.

As a kludge to move forward, I took the op amp out of the socket and inserted jumpers to send the DAC signals directly to the output connectors. (The DAC outputs don’t need buffering; the op amp is there to convert the DAC’s 0–5V range to the chosen output range.) Then I connected the CV outs back to the CV ins to verify the Arduino was reading those correctly, and it was. Likewise I fed the gate outs back to the gate ins, and those were being read too — backwards: Gate on was reading as off and vice versa. I need to take another look at the code but I think it’s supposed to be inverting the signal it sees and isn’t. It’s supposed to because the gate in circuitry inverts the input. The gate reading code and the gate input hardware both come straight from the Synapse project, I’m pretty sure, so I don’t know why it would be getting it wrong, but it is. Trivial to fix, though.

But the op amp mistake sets me back. I’ll need to do a new version of the board.

Once I do, and assuming it works, what then? Use it, of course. Pacella’s Synapse examples ought to work with little modification on it, giving some basic stuff you can do with it, and more ambitiously I’ve been thinking about a control voltage quantizer based on it. Or really the dac/ino is based on the quantizer — the requirements of the latter have driven the design of the former. I also was thinking about a dac/ino-based arpeggiator, but that concept sort of took off down the road and acquired a couple shift registers and, long story short, I’ve got a board design somewhat based on the dac/ino circuit but remixed specifically for the arpeggiator. But first, unless it too goes rogue, I’ll do the quantizer.

As for the dac/ino lite, I’ve got a project using that nearly finished. Stay tuned.

The dac/ino GitHub repository is here: https://github.com/holmesrichards/dac_ino.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s