Introduction: Interactive, Light-Up Drum Table With Custom Interface

This project was a gift for my brother (a drummer), who decided to convert a kick drum into a table for his new apartment. I installed some RGB LEDs on the inside and designed an interface to control the lights in two different ways (mix mode & auto mode).

This Instructable will mostly cover each step of the design and fabrication processes. The circuit was built on concepts from this Instructable I authored a while back.


  • Soldering iron (I use a hakko)
  • Drill
  • Glue gun
  • Screwdrivers / wrenches/ pliers
  • FTDI Cable (to program Arduino Pro Mini)
  • Scoring knife (optional)


  • Arduino Pro Mini
  • PCB Board (with standoffs and mounting hardware)
  • Tip120 Transistors with heat sinks
  • RGB LED strip*
  • 12v power sourceAssorted wire
  • Toggle switches with long threaded bushings
  • Potentiometers with long threaded bushings
  • Potentiometer knobs
  • JB Weld Putty

* I built this piece in 2013 and am just getting to document it now. If I were to do it over again I would have used AdaFruit NeoPixels as they are individually addressable, use the same voltage as the Arduino (can share a power supply without any additional regulation), have fewer connections than a traditional 12V RGB LED strip, and do not require additional components like transistors/heat sinks (in smaller segments).

Step 1: Design & Plan

This project has several distinct components. Before attempting to make this or an inspired project, its probably best to think through each part of the system.

  1. Interface design
  2. Circuit-design & power
  3. Fabrication
  4. Code

1) Interface Design

Fundamentally, an interface is a shared boundary between an environment and a system (in this case, the knobs/switches and computer that controls the output). A good interface should communicate its function to the user.

I started this project with a blank slate. From the beginning I envisioned a manual color mixing mode as well as an automatic color changing (passive) mode. As part of design process, thinking about the capabilities and requirements informed the circuit design process. Aesthetic was also an important consideration when selecting the knobs/switches, as I desired the look/feel of an electric guitar's tone/volume interface and effectively transplanted my version of that on the drum.

Interface Guide:

  • The top 3 potentiometers are for color channel (R-G-B, respectively) in mix mode.
  • The bottom (red) pot is fade speed between color shifts in auto mode.
  • The top switch toggles modes and the bottom switch is on/off.

Post-mortem: If I had to redo the interface (given now how I've seen how people use it) I would have used different switch types (for on/off and mode toggle) and moved the mode toggle further away from the knobs. Also, I might have made the mode toggle the biggest switch to flag its importance/role (perhaps adding a label). That being said, its clear I did not practice all UX design principles, as gathering feedback from users is an important step to see how people actually interact with your system. I probably would have done this if I intended it to be a consumer product, but given that its a one-off, I figured it was overkill and its easy enough to explain/demo.

2) Circuit Design

When I start thinking about designing a circuit, a few thoughts come to mind:

  • What are the inputs and outputs (I/O)?
  • What are the power and/or communication requirements for the I/O?
  • What are the space requirements?
  • What will the enclosure look like? (this is another disciple/area of engineering)
  • How can it be repaired after installation if it needs maintenance? Will it need maintenance?
  • Is it safe/what could go wrong?

In this case, it was pretty simple - knobs & switches control the LEDs in some fashion (actually, two different fashions - manually mixing the RGB color channels and auto-fading colors according to a timed interval).

3) Fabrication

Starting with an object like the drum, it will need to be modified in a few ways:

  1. Drilling holes for interface components
  2. Attaching the potentiometers/switches
  3. Building the circuit, hooking up the components (best if done modularly).
  4. Creating a bottom platform (optional)

During the planning phase, you simply need to determine your requirements and gather materials.

4) Code

The circuit will be relatively simple, so there is no need to design/plan for this now. Code samples are provided as well.

Step 2: Build the Circuit

If you have never built a circuit before and you want to build this table, a good way to start is to purchase a small kit with an Arduino, a few buttons/potentiometers, and some LEDs. Play around and have fun, its relatively easy to learn (which in part explains its popularity) and there is no short of excellent tutorials on Instructables and on Arduino website.

If you have already used an Arduino or similar micro-controller, you can build the circuit portion of this project using the instructions in this tutorial (or use NeoPixels for a much simplier circuit).

Once you have a working breadboarded circuit, I recommend transferring to PCB and soldering the components into place. For the interface components, stranded wire is best to connect components & PCB (be sure to provide enough length to cover distance from interface to circuitboard). I see many Arduino projects that never make the transition from breadboard to circuitboard, and its really worth it here to avoid maintenance if you want this thing to last (this one has been running the same code for 3 years and has never need to be serviced).

My general process:

  1. Decide what I want the circuit to do (design)
  2. Draw a layout of the circuit (plan)
  3. Gather parts so I can assemble in one sitting (prepare)
  4. Breadboard it, test and ensure its functional
  5. Layout parts on PCB board (or use design software)
  6. Take time soldering each wire to Arduino and components
  7. Test components one at a time with Serial Monitor
  8. Desolder / resolder if necessary
  9. Mount circuit board with stand-off to a base

Important: One important "gotcha" when working with two power sources to the Arduino is that you can harm it if both power sources are activated simultaneously. For instance, in the circuit, the 12V supply powers the LEDs and Arduino (via 7805 voltage regulator). However, when debugging your code with a computer connection (using FTDI cable), you are also powering your Arduino via USB. Be sure to unplug the 12V supply when connected with a computer. You won't be able to drive the LEDs while plugging into your computer, but you can read the values of each component using the Serial Monitor to ensure everything is properly connected.

Step 3: Install Interface Components

After building the circuit, next up is installing the UI components and LEDs. I measured and then drilled equidistant holes for each potentiometer & switch (pre-drilling first, as not to crack the drum's glassy veneer).

Given the drum wall's thickness, I needed potentiometers with longer-than-standard threaded bushings, which were difficult to find. The problem with the ones I purchased was that they were too thin to be screw fastened to the fancy-looking knobs. A relatively simple solution was to cake on some quick twist adhesive, let it harden a bit, and carve/shape it before it solidifies. I recommend waiting for the adhesive to completely try before fastening the knobs to the pots (in case you ever need to disassemble). With or without the extra step with the putty, install the potentiometers (can finger tighten and then use a pair of pliers to tighten more if necessary), and then screw or snap the knobs onto the potentiometers. Pay attention where the indicators on the knobs start and stop (i.e. the range of motion) before fully tightening).

At this point, the knobs should twist without rotating and the LEDs & circuitboard should be secure/stable. Try twisting the knobs with a little force, as if your niece/nephew were to play with the interface, to see if they are really secure.

Lastly, attach the LEDs to the interior of the drum. I found the perfect balance of brightness and diffusion by placing them in the center of the shell, and simply hot glued the strip to the interior wall.

Step 4: Mount, Connect, Secure

At this stage, the interface elements and LEDs should be in place. As an optional phase of this project, you can create a bottom piece for the drum. You don't necessarily need one, especially if the drum will be sitting in one place for a long time (and not used as an instrument) or you want to put a skin on the bottom - in my case I wanted the circuit to be easily accessible if it needed maintenance (which thankfully its never has thus far).

I scored a piece of acrylic that I had lying around to fit it snug onto the underside and used an existing piece of hardware to rest it on. Another optional step is to use sticky rubber feet or two-sided velcro to secure the circuitboard to the bottom piece.

Step 5: Test, Fix, and Re-Upload (repeat)

Now that everything is in place, its time to upload the code!

I've posted my code to github. Find instructions there for this project's sketches (general process is below).

Please keep in mind that this is not the original code I uploaded to the drum (unfortunately don't have a copy of it), but the final sketch should be identical as far as behavior. If not, feel free to submit an issue if you're experiencing a problem or submit a pull request if you'd like to fix something (github it relatively easy to use and free). If you like the project, feel free to star it.


  1. Upload first test program and log output of all switches.
  2. Upload second test program to check the LED output.
  3. Upload master program.

Step 6: Finishing

Finishing touch (optional) - put on a drum head or laser-cut a transparent top!

Happy making!!