The SynPad is a position sensitive midi drum pad that you can build yourself using simple materials and tools for around 50 UK pounds (depending on what materials you already have, and how many pads you want to make.) The pad can detect where you have hit it as well as how hard, so that the synth it is driving can change the sound continuously as you strike the pad in different places.
The software I have written to make the sounds is currently linux based, but would not require much work to adapt to a windows or mac environment.
The skills you need are basic wood and metal work (cutting and drilling), enough electronics knowledge to build a simple circuit from the schematic, and a moderate amount of experience with making music on the linux operating system. You don't need any programming experience to start making sounds under linux, but would if you want to create your own synths to make different sounds, or to port the program to another OS.
If you have built one of these pads, or are thinking of building one, it would be good to hear from you.
Hope you enjoy making and playing this instructable!
Remove these ads by
Signing UpStep 1: Design
The project is still in early prototype stage. The current design uses a 30 cm square aluminium sheet as the active surface, with piezo sensors mounted under each corner to pick up the pressure pulse caused when you hit the pad with a stick or your fingers. The pad is supported on closed cell foam rubber discs, inside a plywood frame. When you hit the pad, the sensors in each corner respond differently according to where you have hit it.
The signals from each sensor are captured by an arduino micro-controller board, which then sends the raw signal strength from each sensor to a computer over its usb cable. When the sensor data reaches the computer, it is interpreted by a python program which calculates the coordinates and velocity of the strike from the raw figures, and then maps this information onto midi note and controller values.
What happens next is up to you - if you want, you can feed the midi data into any Linux softsynth just as you would for any other midi source like a keyboard. To make the most of the position sensitivity of the pad, though, you want a synth that will change the sound produced according to the x and y position of the strike. The simplest way of doing this is to use one of the music programming languages like supercollider, csound, or pure data. Some example supercollider synths are in the archive attached to the final step of this instructable.
Unfortunately I forgot to take proper photos of each step as I was building the pad - the ones that I have attached are really assembly photos that show the main parts before you bolt them together. They should give you enough of an idea though to build one yourself.
The signals from each sensor are captured by an arduino micro-controller board, which then sends the raw signal strength from each sensor to a computer over its usb cable. When the sensor data reaches the computer, it is interpreted by a python program which calculates the coordinates and velocity of the strike from the raw figures, and then maps this information onto midi note and controller values.
What happens next is up to you - if you want, you can feed the midi data into any Linux softsynth just as you would for any other midi source like a keyboard. To make the most of the position sensitivity of the pad, though, you want a synth that will change the sound produced according to the x and y position of the strike. The simplest way of doing this is to use one of the music programming languages like supercollider, csound, or pure data. Some example supercollider synths are in the archive attached to the final step of this instructable.
Unfortunately I forgot to take proper photos of each step as I was building the pad - the ones that I have attached are really assembly photos that show the main parts before you bolt them together. They should give you enough of an idea though to build one yourself.
Visit Our Store »
Go Pro Today »
I will post a much more detailed tutorial of the whole process from making your own mesh heads to making your custom sensor mounts and the very little electronics involved in each double zone drum. Yes I know that you are building your module from scratch but this may help others less electronics savvy.
Great job by the way.
But I was just wondering, why not just use a diode?
What this circuit does is to halve the input voltage using a voltage divider, then use an opamp / transistor buffer to provide a constant voltage at that level (roughly 2.5 volts). Then when the voltage from the piezo goes negative, it's relative to that 2.5 volt false ground, not to the ground of the arduino.
The program on the arduino does a short calibration when it starts up to work out what the resting voltage from each piezo is. That value is then subtracted from each reading.
There might be better / simpler ways of doing this, but that's the way I did it in my first version, which I'm still using, and it seems to work ok.
I've taken another look at the circuit and brought up the datasheet for the TS912 and noticed a problem. In your schematic you have your ~2.5V output of the voltage divider section going into pin 1 of the TS912. According to the datasheet below, pin 1 is for output....are the pin numbers just incorrect in your schematic, or did you use a slightly different chip?
http://www.st.com/stonline/products/literature/ds/2325/ts912.pdf
Did you also happen to change the resistor values across each piezo from 10M to 1M? Or am I remembering it wrong?
The 2.5v divider should be feeding into the non-inverting input of the op-amp (pin 3), the feedback from the resistor should be on the inverting input (pin 2), and the output to the piezos should be on pin 1. It wouldn't hurt as well to put a high value electrolytic capacitor (100 uf?) across the 100 ohm resistor to make sure that the current into the piezos isn't drawing the ~2.5V rail up or down in voltage.
I had one question: I wasn't able to find the TS912 op-amp locally, but instead found the TL082. The package is labelled "Dual BiFET Op Amp", and here's some specs:
http://www.national.com/mpf/TL/TL082.html
Do you think that would work as a replacement?
Bear in mind that just using this circuit won't make your system more reliable - the reason for creating a 2.5v reference level like this is so that the firmware can detect both positive and negative going pulses from the piezos. Apart from that it will work pretty much like the simple input circuit you are using. Are you using shielded cable for the connection between the piezos and the arduino? This would help with reducing interference.
That opamp might work, but I'm not sure. It looks from the datasheet like it's designed for a higher voltage application, with split power supplies. The useful thing about the TS912 is it is 'rail to rail', which means that its input and output voltage ranges go right from the positive to the negative supply voltages. Also it's designed for low voltage applications (2.7 V minimum).
This isn't a very demanding use for an opamp, but it does need to be able to provide an output voltage of about 3.1V to drive the transistor. I'm not sure from the datasheet whether the TL082 will do that off a 5v single rail supply.
If you search for a general purpose rail to rail op-amp, you should find something that does the trick.
this looks deceptively simple, but as engaging as Randy Jones' physical drum model:
http://vimeo.com/2433260
before I try to emulate your hardware system, am I right in assuming you are using the Z-axis (force/velocity) from the piezo's as well as X/Y location? I wonder if four FSRs (under foam, then perspex) in each corner would work just as well?
Not sure about FSRs (force sensitive resistors?). They might be worth trying, and could work perfectly well because really it's just sensing the transferred pressure at each corner, but I don't know much about their properties.
I guess the thing would be to go ahead and try it - it would be good to have someone experimenting with a different physical construction, so let me know how you get on.
andy
I'll have a prototype ready in the new year
You could make a pad with an array of piezos controlled like you say, but that would be a different project.
XsavioR: your idea later in this thread about using a master and slave PICs to speed up the process is interesting, you should pursue the idea.
ganglion: You don't have to believe in patents for someone else to take the idea out from under you. This project introduces some tech that has some pretty awesome potential and if you apply it in the right area (buttonless drum pads for instance) audio geeks with eat it up like crazy. But luckily for all us hobby enthusiasts you put it out there in the public domain, which I can definitely appreciate.
The thing I want to do next is clean up the physical design a bit, and maybe paint it, and then work on making it possible to have several pads running at the same time.
What I'm planning to do is drill holes in the base to bring the cables to the bottom of the base, then add some thick foam rubber to lift it high enough up to fit an arduino pro-mini with a mini-usb connector on a bottom edge. That way you just need a usb hub to plug in several pads at the same time.
Also if I was trying to make something like this for a mass market, I probably wouldn't do it that way - I would spend time researching something like surface acoustic wave touchscreen technology, and do it in a more sophisticated way.
The point of this project for me (apart from having fun making something I could play myself) was to make something simple that anyone could build themselves out of simple components.
I see the Python code has some potentially CPU intensive math so it may introduce an unacceptable amount of lag if ported to the Arduino, but maybe not, especially if you upgrade to a more powerful Arduino or clone.
In practice do you find that the calibration functions you have written help much? Or did you introduce that because you noticed noise in the system? I would like to see if this device can be optimized into a more plug-and-play package. This sucker has some fantastic potential.
Personally I'm happy to have it split like this because the synth at the end is in supercollider so needs a computer to run on anyway. Also I am planning to add some extra functions to the midimapper which would be hard to do on a 'duino just because of speed and memory constraints.
Does your pad handle simultaneous taps at all? I'd imagine that multiple simultaneous taps may cause dampening of the vibrational waves, but maybe in practice its not too bad.
And using Python on Linux for 'duino serial data? That's f*cking hardcore, lol :P
It can't do simultaneous taps but the retriggering delay is quite short (15 msec), so sometimes it almost sounds like it can.