The Collective DJ – Winter Show 2012


The Collective DJ

Created by Andrew Cerrito, Mary Fe,

Colin Narver, and Azure Qian



The Collective DJ is a project that allows people to create music through touch and collaboration.

Four different sets of two handpads each are mounted on a wall, spaced apart from each other. When two users each put one hand on a handpad and use their other hand to touch one another, they can trigger an audio sample to turn on or off. Since there are four sets of handpads, up to four samples can be triggered at once, allowing multiple groups of people to DJ a track together.

How it works:

When two people connected to the pads touch each other, a small amount of electricity rushes through them and they complete a circuit. The circuit completion is detected by a microcontroller, which uses keyboard emulation to send one of four keystrokes to a computer running Ableton Live. In Ableton, the four keys are assigned to different samples of an audio track, and those samples are turned on or off via keypress.

Iteration history and design considerations:

This project was actually the second version of The Collective DJ. The first version was a project created in ITP’s Applications class as a reaction to a talk given by Nathan Shedroff on sci-fi interfaces. The talk got us thinking about what kind of novel interfaces we could design, and since our presentation was in the middle of midterm projects period, we wanted to give our class a fun and positive experience.  This version was designed for a large auditorium, and it involved 8 rows of floorpads that triggered 8 different sounds and effects. It was used by the entire 2014 class of ITP, which is approximately 110 people. (A video is posted below.)

For the Winter Show version, we had a much smaller space to work with – a narrow hallway in the back section of the ITP floor. We decided not to use floorpads, as people would have to take off their shoes – an action that would both dissuade some people from participating and create a traffic jam in the busy hallway. Wall-mounted hand-pads were much more appropriate for the audience and the space.

The first iteration had 8 sets of floorpads and 8 samples, but we scaled down to 4 in order to make the installation easier to comprehend at a glance and to make sure each sample could be distinctly heard amidst the crowded, noisy atmosphere of the show.

Our wall space had both a long unsightly whiteboard that couldn’t be removed and a kiosk window. In order to disguise these, we papered over the whiteboard with heavy black paper and nailed a large piece of dense white matte board over the kiosk. For visual contrast, we mounted the white hand-pads on the black backing and vice versa. The pads also had a lasercut hand design in order to provide visual context to the users. We mounted the wires to the wall using nails and tape so that they were organized and not visually distracting (a big problem with our first iteration), and we directed them to our computer station to the side of the installation.







Video of the first iteration:




Slapstream is a video game where you have to dodge onscreen obstacles by slapping yourself in the face.

It uses a Kinect to track the position and velocity of your hands and their distance from your face. Once it detects a slap, your onscreen character will move in the direction that your face reels. A more powerful slap to the face will result in greater movement onscreen.

The idea came out of my interest in making a novel game interface, and also sort of as an experiment to see how much inconvenience people will put up with for the sake of fun or competition.

To see my initial project proposal, click here.


Current code:

The code is available on Github here. There is also some incremental update history here, but I lost tracking of some of my later development updates because my saving practices broke my Github directories. I’ll try to restore them to working order before I continue work on the program.

Current state and future plans:

When I demoed Slapstream, it was still very much a prototype – the hero and obstacles were represented by circles, debug information was visible all over the screen, and many features I wanted to implement were missing.  However, I was pleased with the actual action of slapping – it was fairly responsive, and the movement of the character onscreen did map pretty well to the direction and speed of the user’s slaps.

I’d like to implement a scoring system, make obstacles fall more quickly over time, add 2-player capability, and replace the circles with less abstract graphics.

I got started learning the process of coding with the Kinect from the book Making Things See by Greg Borenstein.

The parallax motion of the stars was just very slightly modified from the motion seen in William Smith’s sketch on OpenProcessing.

Special thanks to Dan Shiffman, Mark Kleback, Ben Smith, and Genevieve Hoffman for coding help.

The Embarrassed Book


The Embarrassed Book is a shy book that is reluctant to divulge its contents. It will sense when a user opens it via a flex sensor in the spine, and, as the user reads, it will give mild audio cues cluing the user into its discomfort. Eventually, it will get too embarrassed, shriek “Don’t look at me!”, and snap its own cover shut via a motor embedded in the back half of the book. It is important that the book resembles a normal book so that the user will not suspect something upon their first encounter. Ideally, the book will be a self-help book about asserting yourself, getting over shyness, or something of that nature.


I started prototyping by hollowing out the pages of the back half of a book to form an electronics compartment. Cutting by hand with a boxcutter was time-consuming and difficult. Pictures are below:

The yellow wire (a prototyping substitute for clear fishing line) was attached to the inside cover, and was threaded through the spine of the book into the secret compartment at the book’s end. Unfortunately, when I pulled the wire, the book cover would not close. This is because I needed some upward force to the pull, but because the compartment was by necessity lower than the inside cover, this seemed difficult to achieve. After spending quite awhile trying to think of a different way to close the book, I was unable to come up with one that wouldn’t unduly compromise the book’s normal appearance.

Iterating and Building

After considering my options, I decided to construct a lectern for the book that will house all the electronic components. This is different from my original vision of a self-contained book, but at least this way the book can remain unaltered and have a completely normal appearance. There will be a slot in the lectern through which a tiny arm can come up and push the book cover closed at the appropriate moment. The arm will be powered by a high-torque servomotor. Instead of using a flex sensor in the cover, I will now use a photocell embedded in the lectern to detect if the cover has been opened.

After constructing the base, I had to make the top plate of the lectern. I cut a slit in the top cover of plywood using the chopsaw, and made it fairly wide so that the servo’s plastic mount and arm would fit through it. I also drilled a small hole in which to embed a photocell, but made it smaller than the cell so that it would not sink through. I then lasercut a small pushing arm (about 5″ long) out of acrylic to attach to the servo, and mounted the servo to the underside of the plywood so that the arm could push upwards through the slot.

After everything was in place on the lectern top, it was functional but very ugly – the slit cut roughly, there were a few errant screwholes, and the plywood itself wasn’t in the best shape. To attempt to make it look a little nicer, I bought a large piece of self-adhesive foamboard, lasercut the slit and photocell holes in it, and attached it to the top of the plywood. Unfortunately, to fit in the laser cutter, I had to saw the foamboard in two which created fringing along the edges. In the end, though, it still looked marginally better than the plywood. I finished construction by affixing some leftover plywood strips to the lectern to serve as a book stand. Here’s a picture of it as it was presented in class:

The Embarrassed Book

Wiring and Code

The wiring for the book’s circuits was relatively simple, as there weren’t that many different elements in play. Since the servo required its own power supply with higher amperage than the Arduino could handle, I split the breadboard halves into a servo half and a photocell/mp3 trigger half. Here’s the diagram in Fritzing:

Book - Circuit

The program to control the book used a boolean logic system and timers to keep track of when the book’s cover was opened, when audio cues should play, and when the servo should close the book. The code is on Github and can be seen here.

Final Documentation

Build Issues

The biggest issues I had in this project were mainly related to the mp3 trigger. When I had first soldered header pins to it and hooked it up, I noticed that it would not maintain a constant power connection – jostling it even slightly would cause it to turn off. I figured that the header pins I had used must have been loose, so I attempted to desolder them. In the process, I managed to scorch the VCC pin and the trace leading to it.

After that, I had to hook up the trigger to external power, but I could not get it to work properly no matter what I did. I thought it might be a software serial issue, so I checked and rechecked my programming, but it wouldn’t initiate communication even with the simple example provided with the Arduino IDE. I thought that the trigger might be shorting out somewhere due to the damage I gave it, but I tested all the relevant pins with a multimeter and they all appeared to function normally. In the end, after a lot of stress and wasted time, it turned out that the firmware was simply not up to date. Lesson learned – try the simple solutions first!

Other than mp3 trigger troubles, I didn’t really bump into any major problems during construction and testing. I did manage to ruin an Arduino screwshield by following the wrong instructions online, but I’m not going to elaborate on that because it’s embarrassing.


Once I shifted focus from the electronics being entirely self-contained in the book to using a lectern, the project became much more basic – it’s just a photocell, a mounted motor, and an mp3 player, and computer speakers. Nevertheless, I did learn some important skills along the way. Laser cutting in particular was a pleasant surprise – it’s relatively simple to setup and immensely satisfying to execute. Software serial emulation seemed like a confusing concept at the time but ended up also being pretty simple, and it seems like a powerful tool for future projects. And after leaving a wake of destruction, my soldering skills have reached an acceptable level, and I got to use a few new shop tools to boot.

If I expand upon this idea later, it’d be neat to have different books have different personalities and reactions. Although I used a Processing instructional book for prototyping, my intent was to have the embarrassed book be a self-help book about learning to assert yourself. It’d be fun to have some other books around as well – maybe a prudish art book that censors itself once you reach a nude portrait, or an old antique book that suffers from senility. This could be done using RFID tags and a reader.