Currently available for freelance and full-time roles in the experiential media space!
Jason Webb

Interactive Wall for Artist in Residence show

September 2011

Created for the Artist in Residence show at the Walker Art Gallery at UNK, this interactive wall allows visitors to explore a dissonant web of common ‘things’ through an array of buttons that activate mechanical solenoids. This project is largely a reproduction of a project seen at, outlined in an article called Create a Simple Solenoid Musical Instrument. I do not take credit for the original idea or concept!

When I began the project, I planned to completely reproduce what I saw in that article on Jameco – clay pots, empty glass bottles and miscellaneous hardware. However, as I got further and further into the project, other ideas came to me, and it became my intent to create a final project that not only reproduces the concept of the original project, but implements plenty of customization to make it my own.

This article, as such, is meant to outline my customizations and changes to this original project, and how I personally went about executing it. If you want some more context and background, just read the Jameco article above before proceeding here.

Opening notes

The project seen at Jameco actually resulted in a kit that you can buy that contains all of the parts required to build two solenoid ‘thwackers’ yourself, with great instructions. However, I was planning on building either 10 or 15 of these, and wanted to reduce unnecessary parts where possible. Therefore, a modified bill of materials can be found after the schematic.

Just as the Jameco article suggested, I used the exact solenoids that are seen in the videos. They are 24VDC push-pull solenoids, but they work fine at 12V. Luckily, I had a 12V lab power supply laying around!

Solenoid driver schematic

The circuit to activate the solenoids is very simple. It uses a logic-level N-channel MOSFET to bring the solenoid to ground on command, using a 1n4007 small signal diode to help prevent damage from the inductive load of the plunger. Simply connect the 12V power supply ground to the ground of your Arduino, then connect a single pin from your Arduino to the terminal labelled ARDUINO_PIN. Whenever you bring this pin HIGH, the solenoid should actuate (but probably won’t until you do some mechanical tweaking, which we’ll talk about soon).

Solenoid driver parts list (single)

1 – 1N4007 diode
1 – 10k resistor (1/4W)
1 – RFP12N10L N-channel MOSFET (high-power transistor)
1 – 24VDC pull-type solenoid


2 – 2-pin terminal blocks

Solenoid driver circuit board design

A big part of the cost of the Music Maker Kit from Jameco is the perfboard – $5.95 is not cost effective when you want to build a lot of these things. Instead, I chose to wire 10 of these circuits up on a single breadboard from RadioShack (cost ~$3.00). I used EagleCAD’s PCB tool to design the following diagram to help me wire the components up.

Solenoid driver board perfboard layout

Although I designed a PCB layout, I don’t have the tools or skills (yet!) to etch and fabricate my own PCBs. Instead, this was meant to help me plan the soldering and wiring. This step is nothing too amazing – just place your parts and get soldering! Here is how I chose to implement my 10 drivers on perfboard:

Solenoid mechanical assembly design

Thwacker design

The next important step to take was to get the solenoid’s physical push-pull motion translated into something useful. Here is where some real hacking was needed, because the original project seen at Jameco utilized some really awesome laser-cut acrylic pieces designed by a member of a hackerspace. Well, I don’t have a laser-cutter, or any idea how to use one to make such a device, so I got a hold of a friend and asked him to make a more hackey version.

First, I simply mounted each of the solenoids onto small blocks of scrap wood using screws and zip-ties, so that the entire solenoid assembly can be handled as one discrete piece later on.

Next, Brian Margheim then came up with a simple mechanical solution that uses a straw and the spring from ball-point pens to translate the linear motion of the solenoid into a swinging motion for tapping on objects. After some experimentation with placements, we found a set up that works quite well and taps on objects with surprising force.

Adding objects to the wall

Placing different objects in the path of the thwacker produces wildly different noises, some more interesting than others. For example, a concrete block is nowhere near as interesting as a simple sheet of steel, or an aluminum bottle. Furthermore, I expect to experiment a little more with the material used to strike the objects to produce different tones. Right now, a small molding nail is pushed through the end of the straw, which is what actually makes contact with the object. Adding more nails, rubber bumpers or loose objects like keychains can result in different tones and percussive qualities.

Controlling the solenoids

In order to make use of the solenoids, I needed a microcontroller to translate interaction with some buttons into pulses to turn on/off the solenoids. I chose to use a Teensy++ 2.0 from due to the low cost and high pin count. For anyone interested in taking their Arduino projects to the next level, I highly recommend the Teensy series – they are immensely powerful, have native USB HID device functionality (including MIDI!) and can fit into the same sockets used by ICs!

The switches for my project were bought in an eBay auction by a contact at the Kearney Area Children’s Museum and came with some rather unusual connectors. They came in bundles of about 5, with toggles and on/off switches mixed and interconnected in some strange way. Obviously, these buttons were used in some specialized system somewhere, but I was just interested in the switches themselves. So, I cut all of the switches out and saved the connectors. I realized that the connectors actually had .100″ pitch, and therefore could be plugged directly into some breakaway .100″ headers I had laying around. So I soldered up all of the switches to the connectors in a way that made it easy to interface with.

Programming the control code

My end goal was to present 10 momentary buttons on a pedestal to visitors and let them have direct control over each solenoid from a distance. However, a direct 1:1 mapping (i.e. button on = solenoid on) would not be a great idea, because these particular solenoids were designed to work best with a 10% duty cycle. In other words, the manufacturer recommends that for every ten seconds of use, the solenoid only be activated for one second. I was curious what would happen if I exceeded that duty cycle, so I wrote code that pulsed one solenoid non-stop at a fast rate. The result was that the solenoid became very hot, very quickly. Lesson learned.

Therefore, I had to find a way to prevent a visitor from ‘spamming’ the switches to make the solenoids go faster than their recommended duty cycle rates. The simplest way I could think to do this was by using a buffer. In the code, each switch-solenoid pair also had a ‘bucket’ associated with it that acted as an intermediary between the two. When the switch is held down, this bucket is slowly filled, and only when the bucket is full does the solenoid actuate. This means that no matter how fast the visitor presses the switches, or how long, the solenoids will only ever actuate at the speed determined by the rate of this virtual bucket filling up and emptying.

Download the Arduino sketch

Note: The Interactive Wall was originally going to include six EL wires that are also controllable via toggle switches. The code reflects this decision, but it hasn’t been perfected in the physical project just yet.

Installation at Artist in Residence show

This piece was installed in the Artist in Residence show in October of 2011. The final piece ended up being a bit of a hack, with some solenoids working, some not. Nonetheless, once visitors realized they were actually allowed to press the buttons, they really seemed to enjoy it!