Then the back panel will look like this;

Start Soldering

Now join some of the resistors using the unused legs.  When the two legs meet, twist them together, then solder them:

Now we use our wire to join together some of the pots.  The pots have two ways to join with the wire…  you can push it through the hole (assuming your pot has one), or bend the wire around the leg.  It can be a bit tricky, especially when there is more than one connection at one point, but with a bit of patience you’ll get there:

and now add a few more….

A quick test (if you have a multi-meter)…

At this point it would be a good time to grab the multi-meter and set it to continuity mode – probably shown as a speaker on the multi-meter panel (the mode where it beeps when you put the connectors together).  

Check your connections:  Hold one multi-meter connector to the solder on the Volume pot, and the other to the resonance pot solder joint.  If there’s a good connection it should beep.  If not re-flow the solder and try again.  

The next check: Keep one connector on the volume pot leg, and move the other near the frequency pot… put it on the other-side of the resistor (the one that has the 3 connections). You won’t get a beep if you test between the Freq pot and the resistor, as the resistor resists the signal.  Test on the other side.  The other side should beep, meaning there’s a good connection. Maybe this picture will clarify things;   

The green areas will beep, but not the red.

Info: Resistors in a circuit that’s soldered can’t be checked with the continuity function on a multimeter – they block the signal path – you can only check unobstructed wires. Also, you can use a multi-meter to read how much resistance a resistor has, but again you lose this ability once it’s been added/soldered to a circuit.

One last check: Now move the multi-meter connector to the switch, then midi port.  If it doesn’t beep you might not have joined it correctly -> check for any obvious problems, or try and re-solder the joints. Check your multi-meter is working by pressing its connectors together.  Throughout making the synth you can perform checks like this, just remember if a part is in the way it breaks the signal.

Back to Soldering

Time to solder some more wires. These next two wires we won’t connect to anything yet…  they’ll connect to the proto-board once we build that section.  Be sure to leave the wires long enough that we’ll be able to join to the proto-board without problem.  Say about 20cm each (you can always trim them down later):

Now solder the next wires (again leave 20cm of wire on the one cable that isn’t joined to anything).  If you have a multimeter, check the Vol to Audio Jack.  Then hold a connector to the two connections side of the resistor of the ‘res’, and see if you get a beep at freq, dky, atk, the switches and the middle of the Amt/Rate.

The final part of the back panel, all of these wires will connect to the proto-board, so leave at least 20cm of wire free on each wire for that:

To save on solder I use the legs of the capacitors/resistors to jump to different parts of the board.  So with this capacitor, the leg that comes through A7, I bend down to A12 and solder into place. Then from A12, use a previously cut leg to jump to G12.  You can hold down the previously cut leg with pliers as you solder it (otherwise you’ll burn your fingers).

Using the legs to jump to different areas

Under the board after adding the capacitor.  Here you can see how the legs are used to jump to different points (shown in the below diagrams as the ‘thinner line’ between solder points):

We still need to connect this to the panel components, but we’ll do after we finish adding parts to the board.

The MIDI circuit

This part lets our synth be controlled by external MIDI keyboards.

First we add a switch.  This is added so we can upload new code to our synth (for any future firmware updates etc).  The switch disconnects the Arduino from any random MIDI signals, meaning our code can be uploaded without interference. Once built, if you find you can’t control the synth try changing the switch position!

The bottom of the board with the 6n138 added:

Now let’s add a 270 ohm resistor between R6 and R8.  The problem we have here is there’s not enough room between the pins to lay the resistor down flat, so we’ll have to solder it standing up:

Easy right?  Your board should now look like this:

Underneath we join the resistor to the nearest pins:

Now let’s join the center of the switch to the 6n138.  Because the distance is quite great, we’ll use some wire to link the two;

Then we solder the points together;

Now let’s add the 1N914 diode.  Diodes let the current flow one way and not the other, so it’s important we install this the correct way around.  Luckily for us diodes have a black line to indicate where they should face, so pay attention to the diagram. We’ll install into pins W7 and W8, with the black line on W7.  you’ll notice these pins are close together, but luckily Diodes are smaller than resistors, so with a bit of bending of the legs you should be able to get it into place without having to stand it up;

Now join the diode pins to the chip;

Now we add a 220 ohm resistor to X7 and X11:

Bottom view after adding the resistor (X7 joins to W7, while X11 will be used later to join to the front panel):

The board is almost finished, just a few more wires to add now.  We’ll run a wire from Q6 to  N12;

And then solder it together;

Solder them in place:

Joining The Front Panel to the Proto-Board

Which goes into A3:

Then you solder it:

Which goes into X12:

…Which goes into W9.  Careful where you solder here, I admit I could’ve laid out the board better, but that would require foresight (which I failed to predict).

..solder it in place – make sure you get the correct pin soldered (look closely on the board for the direction of the connection:

That plugs in O12:

Because these wires do the same thing it doesn’t matter which is connected where, as long as one goes into P14 and the other O14:

OK, so we’re almost finished (the second time I’ve said that now) we just have a few wires from the pots left to solder.

We shall be using pins: A0, A1, A2, A3, A4 and A5.  Why not A6 and A7 you may ask, well…

Idiot alert: I’ve just noticed a difference from the Arduino Nano and the Arduino Uno, despite being smaller, the Nano has two extra analogue pins.  That means, if I wasn’t so stupid, we could’ve had two extra pots on our synth (full ADSR or something).  Oh well, maybe in the future, although you could look on the bright side and think we’ve saved some money + less work. No? I’ll get my jacket…

We’re nearly Finished (This time I promise)

Ok, I forgot to get you to wire up the switches. Then we’re finished.  I promise.  Let’s do that now.  

We’ll start with the LFO switch;

This wire connects to F10:

…and is soldered against the nano pin:

Now for the Wave Switch:

Put the wire into F11:

And then then solder to the nano pin:

Back view of synth – spaghetti junction!

Finished view of the proto-board (Note: wire colors don’t match examples)

Your board should look a little like this (Note: might not exactly match examples)

Now go get a beer.

Right, the synth is now complete – time now to give it a try.  Is it working?  Congratulations! Time for another beer.  It’s not working?  Time to for some problem solving;

Troubleshooting Guide

Just remember that every part used is a potential problem waiting to spoil your fun, but hopefully we’re going to get to the bottom of any faults.  Lets break different problems down into categories;

1. Code: 

The code definitely works (other people have confirmed this).  Did you check the ‘blink’ sketch is working on your Arduino (the one where a light flashes on and off)?  If not go back & read the code section of this guide again and get that working.  

The switch is set incorrectly: Now that your synth is soldered, you maybe have to change the switch position (the one found on the proto-board) to get it to upload.  From memory I believe the switch has to be pointing away from the nano to upload code, and closer to the nano to play the MIDI keyboard.  Try reversing this if it’s still not working.  

Once the blink sketch is working, you can be fairly certain the problem isn’t with the Arduino.  

The only other problem you might have if you copy and paste the synth code and either you miss some of it, or your browser adds some extra (unseen) characters.  Download the .ino file from my github (download everything as a zip).  Then open the .ino file directly with the Arduino IDE.  Once it’s confirmed its uploaded OK, you can be pretty sure the code/Arduino are working correctly.

 A few people have had problems with the midi switch. If you have a multimeter check for continuity on the switch legs. Only two pins should beep and one shouldn’t. If all 3 beep that’s the problem. If you don’t have a multimeter you could desolder the switch and join the two connections closest to the Arduino.

2. MIDI connection

The proto-board switch is set correctly.  You’re playing the synth with a MIDI keyboard.  Have you used this keyboard before and can confirm it works?  How about the MIDI cable?  And is it plugged in correctly?  From the keyboard it should leave from the MIDI-OUT port and go into the DIY synth (which is MIDI-IN).

3. Power

You need to plug in the synth with the USB cable.  Plug it into a mobile phone power supply, or maybe a laptop port (these can add noise to the audio).  The Arduino should have a red power LED that lights up.

4. Is the Volume turned up/down?

It seems simple, but it has caught me out before!  Also, there’s a chance I’ve made you solder the volume pot in reverse, so maybe try turning it all the way down just in case.

5. There’s a problem with this guide:

While I’ve tried really hard to write everything down without errors, it’s entirely possible I’ve missed something.  If you’re having a problem leave a comment and I can update the guide with any fixes.  Also leave a comment if you notice any mistakes.  Thanks.

6. You’ve done something wrong:

Along with me making a mistake with the guide, this is probably the most likely cause for problems.  We’ve made a lot of connections with the solder, and just one mistake could stop the whole thing.  Check the following;

Dry Solder: Sometimes there can be ‘dry’ solder connections, where the part is connected but not really.  You could try re-soldering/re-flowing these connections, or use a multi-meter in continuity mode to confirm they are good. 

Accidental joins: It’s possible some pins have accidentally been bridged while soldering.  Again, use a multi-meter to check and de-solder any problems.  

You’ve used different parts:  If you know what you’re doing then that’s fine, but if you’ve used different parts without really knowing what they do, then this may have caused a problem.  If you’ve used an Arduino Uno instead of a Nano, be aware the pins are in different places on the board (TX and RX pin I believe).

The Diode is the wrong way: Check the black line is facing the correct direction.  The diode needs to face the correct way to work (while the resistors and capacitor we used on the board will work in either direction, known as having no ‘polarity’).

You’ve joined the wrong wires:  Check check check!  Look through the guide and confirm everything is correct.

The Audio jack isn’t wired correctly: Check!

The LED light on the the Arduino Nano is showing midi is being sent, but I’m not getting Audio:  If I had to guess it might be you’ve wired the audio pot wrong (or I’ve told you to do something wrong; other people have reported back success so hopefully not). If the midi light is lighting when you’re pressing keys, then that part would appear to be working. Start with the simple things first: try turning the volume pot at different levels while playing the keys. Try this with all the knobs and buttons just to be sure. If that doesn’t work, double check your connections around pin 9 of the Arduino nano… it should lead to a resistor and capacitor – this is where the audio leaves the Nano, then it goes to the volume pot, then to the audio jack. If you can’t see a problem there then it’s time to check the audio jack… the most likely candidate. Are the wires correct? Perhaps they need reversing? Are the jack connections the same in the photos? Perhaps the jack has been screwed in upside down (ie so the top leg is now bottom etc). Hopefully you’ll find the problem. If you have a multi-meter you can check in continuity mode (the buzzer mode) that the bottom audio jack pin is going to ground… put one connector on the bottom jack, then the other connector on the Arduino nano pin that says ‘gnd’. Hopefully it should beep. 

7. There’s a fault with one of your parts:

Maybe you left the soldering iron too close to a part for too long?  I’ve never had it happen, but if you think you’ve mangled the soldering then look for burnt parts.  Perhaps it was never working in the first place?  While it’s possible, it’s also quite rare, even for dirt cheap parts.  It’s far more likely you’ve made a mistake somewhere else.  If you’ve checked everything else is ok, you could start swapping out parts, or start checking voltages etc with the multi-meter.  If you don’t know how to do this, there are no doubt good YouTube videos/guides for you to learn from.  You could also get into synth repair through this route, so while it’s frustrating your synth isn’t yet working, you are at least learning some new skills.

8. Wiggle

Try wiggling the wires to see if it suddenly starts working.  That’s the sign of a bad connection somewhere, or possibly a break in the wire.

9. Find a friend

If all else fails find someone else to help you fix it.  If you don’t know anyone personally you could try a local hack-space or friendly University department.  If they know a little about electronics, you’ll probably only have to show them the hand drawn schematic found at the top of this guide.

10. Try Running The Test Code

Tom Reid very nicely commented that he’d written some code to check the connections of the synth (copy & upload the blue code text into the Arduino IDE, and also open the serial monitor to view the results);

Great project and works well. I did knock together a short test program which checks all the switches and Pots. It gives an IDE monitor display so you can see the states and voltage. If you want a copy to post then you are more than welcome to post it.

Apologies for the delay – I need to add some comments into the code. Here is the code The test program checks the 2 switches and 6 controls. Also it generates a tone on the output socket. Compilied on IDE 1.8.42

>>>>>>>

/*
Test program for checking Pots, switches and Audio circuit

The program is designed to read the 6 volume controls and the 2 switches(LFO/WAV).

Yes I could have down this program cleaner with FOR loops, arrays etc – but it is only test program and took 20 minutes to knock up

Please feel to modify and improve on it.

Key elements the tester output will show on the monitor display

Note make sure switch is set to LOAD.

Switches
Wave Switch select0 Sq or Saw
LFO Switch select0 ON or OFF

Pots – set all Pots fully counter clockwise looking straight on to front panel

LFO RATE – Rate- clockwise increase volatage
LFO Rate – Amount – clockwies Voltage decreases

Filter– Cutoff – clockwies Voltage decreases
Filter– Res – clockwies Voltage increases

Envekope – Attack – clockwies Voltage decreases
Envelope – Release – Filter- clockwies Voltage increases


Audio output generates a Signal every

*/
//#include

float Volt0; // LFO Amount
float Volt1; // LFO Rate
float Volt2; // Filter cutoff
float Volt3; // Filter Res
float Volt4; // Envelope Release
float Volt5; // Envelope Attack


//wiring pins defined for the NANO version

int LFO;
int WAV;
int LFOPin = 3;
int WAVPin = 2;


void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
pinMode(A0, INPUT);
pinMode(A1, INPUT);
pinMode(A2, INPUT);
pinMode(A3, INPUT);
pinMode(A4, INPUT);
pinMode(A5, INPUT);

pinMode(LFOPin, INPUT);
pinMode(WAVPin, INPUT);


pinMode(9,OUTPUT);

}

// the loop routine runs over and over again forever:

void loop()
{
// read the input on analog pin 0-5:

Volt0 = analogRead(A0);
Volt1 = analogRead(A1);
Volt2 = analogRead(A2);
Volt3 = analogRead(A3);
Volt4 = analogRead(A4);
Volt5 = analogRead(A5);

// Convert the analog reading (which goes from 0 – 1023) to a voltage (0 – 5V):

Volt0 = Volt0 * (5.0 / 1023.0); //LFO amount
Volt1 = Volt1 * (5.0 / 1023.0); // LFO Rate
Volt2 = Volt2 * (5.0 / 1023.0); //Filter Cutoff
Volt3 = Volt3 * (5.0 / 1023.0); //Filter Res
Volt4 = Volt4 * (5.0 / 1023.0); // Envelope Release
Volt5 = Volt5 * (5.0 / 1023.0); // Envelope Attack

LFO = digitalRead(LFOPin); // on/oFF
WAV = digitalRead(WAVPin); // Square or Saw wave

// print out the value
Serial.println(” LFO SW WAV SW LFO Rate LFO Amt Filter Cutoff Filter Res Env Rel Env Attack”);

//Print switches

if ( LFO == 0) {
Serial.print(” OFF “);
}
else
{ Serial.print(” ON “);
}

if ( WAV == 0) {
Serial.print(“SQR “);
}
else
{ Serial.print(“SAW “);
}

Serial.print(Volt1);
Serial.print(” “);
Serial.print(Volt0);
Serial.print(” “);
Serial.print(Volt2);
Serial.print(” “);
Serial.print(Volt3);
Serial.print(” “);
Serial.print(Volt4);
Serial.print(” “);
Serial.print(Volt5);

Serial.println();
Serial.println();

tone(9,50,1000); //sound tone for short burst.-

delay(2000); // 2 seoond update on screen


// No test routing for the MIDI at this time – easy wiring so easy to troubleshoot

}

All good?

Hopefully you should have the synth up and running by now.  If not, check the comments to see if any common problems have started to emerge.  I’ll try and help where I can, but obviously my time is limited.

4. Making a Case

You can make a case out of anything (VHS box!), but this is how I do it:

The wood used: mine cost 3 Euros from an arts supply shop in Berlin. It measures 9.0 x 250 x 500 mm.  The same shop also sold perspex sheets for the front panel for 2 euros.  These sheets measure 3 mm, 3.0 x 120 x 250 mm.  Notice both the wood and perspex feature a 250mm measurement.  This means if we cut the wood correctly it will already have a length exactly the same as the panel.  This can save you some sawing, and you can also use the professionally cut sides at the front for a neater appearance (save your hack-saw work for the back!).  If you don’t have access to these supplies, I’m sure you can come up with you own method.

I used a laser engraver for the panel text, but if you don’t have one no worries, you could use a silver marker pen, or a label printer.  Other things you might need are wood glue and a saw.  Some screws to join the panel to the wood.  All things you should be able to get at a hardware store (or pay 3 times the price at an art supplies store).

Knobs: There are loads of types to choose from, here’s a Moog-style pack of ten for under 2 euros. Or some Dave Smith types for 1.40e.

Ok, lets make the case:

The longer parts of wood are 25cm (250mm – the exact same size as the perspex width).  Then we have the ends, remember, as well as the 12cm width of the front panel we also need to cover the two long bits of wood – these are 9mm each;

12cm + 9mm + 9mm = 13.8cm

Tip: Depending how good you are with a saw, I’d cut each part 14cm long and then be prepared to sand down the excess.  

Depth:  I used 7cm as the depth of the wood.  The nano and proto-board are about 5cm, so by using 7cm we give ourselves some room.

So you should now have wood like this:

If you have the same wood skills as me, you’ll probably have a few rough edges.  You can use sanding paper or nail files to correct this:

Putting it all together:

We’ll need wood glue.  Remove all the components from the front panel and lay it down flat (or if you don’t want to take the parts out: lay down four books and balance the panel in the middle, so it lays flat with the knobs hanging freely in the middle).  

Stand the wooden sides around it and glue them together.  You want a good fit where the panel meets the wood, so either hold it in place or use string and tie it together.  Wood glue dries pretty quickly (5 – 10 min), so you won’t get too bored.  Think of it as birthing the synth.

Tip: You can buy a strap spanner to hold the wood tightly together for you, but it’s a luxury item that you can do without.

Wipe away any excess glue (especially on the outside, where it can effect varnishing the wood).  Now we cut a strip of 1cm-ish squared wood, cut into four 6cm pieces:

Tip: You can buy precut 1cm x 1cm wood from the store

Glue each of these pieces to the corners, making a good connection with the wood and also the front panel (these are where we’ll screw in our synth panel):

When finished our case should look like this:

Tip: If you find the center of the perspex a little wobbly when playing the synth you can glue another 1cm piece to the center top or bottom of the case.  Do this after you’ve finished so you don’t get in the way of components.

Wipe away the excess glue.

Our case should now look like this:

Sand down any over-hanging edges if you like, or any glue that has leaked out.

The synth could be finished if you want to keep the wood looking natural, if not we can remove the panel and start to stain it.

I use a Mahogany stain like this;

The wood is thirsty, so you’ll need maybe 3 or 4 coats.  Add each layer evenly.

Eventually it’ll turn a colour you’re happy with: 

I also varnish the wood with a lacquer which gives it some protection and a bit of shine.  You don’t need to do this, but you can.

Apply a small amount with an old rag and finely distribute:

Leave to dry overnight and we’re finished with the case!

Add the front panel.  Drill the screw holes if you haven’t already, using the smallest drill bit and slowly working up to a size 3 bit (or however large your screw holes need to be).  Work your way up slowly otherwise the perspex will crack.

If you’ve lazered the text, you can fill it in with acrylic paint, then wipe away the excess:

Then peel away the protective film:

Tip: If you’ve missed some paint on the panel (like I have in the above picture on the LFO switch), you can still paint on the perspex, but just be aware it scratches easier this way.