Vibrating pixel mirror

IMG_0338 IMG_0345smallIMG_0349small

This object translates vibration into visual output through a grid of mirrored disks. It is configured similarly to an LED display but instead of LEDs turning off and on, the mirrors can be activated to distort the reflected image. This final prototype, reflects a great deal of experimentation with material and construction. There is further potential for expanding the concept to a larger scale. A larger grid of these “pixels” would allow for more complex animations and could also incorporate sound and movement-reactive features for a more immersive and engaging experience.

2012-03-06_09-19-58_606 2012-03-06_11-10-24_547 2012-03-06_11-27-46_142The pixels are made up of a mirrored acrylic mounted to a piece of thin steel wire which is attached to a mini vibe motor at the other end. The transitions between these parts are facilitated by additional pieces of laser cut acrylic.

2012-03-07_03-30-28_5142012-03-06_08-39-08_565These parts are mounted to a piece of 1/4″ rubber adhered to the back of the panel. The wires are inserted through holes pierced in the rubber which holds them firmly while not dampening the vibration.

wire run 2012-03-07_09-20-56_259IMG_0357

The vibe motors are routed to the Arduino Uno through two 75HC595 Shift registers. The wiring diagram for this along with some basic sample code can be found here:

And heres the instructables page:


Vibration Display

I’m interested in working with mechanical pixels. Sort of like this:

My idea is to replace the “pixels” with little mirrors, or foam shapes, or bottle caps, or plastic toys…maybe they are interchangeable. These objects will then vibrate visibly when activated and stop when deactivated. The vibration is much more apparent in person but here’s a video of the prototype:

Each pixel will consist of a vibrating motor attached to a piece of wire with the object mounted on the other end. here’s a section:


These will be turned off and on by the arduino serial output routed through shift registers. Each register will control a group of pixels:


I could turn this into a mirror as in the given example, but I’m thinking more towards some simple animation. The content will also depend on how far I get – the more pixels, the greater resolution and potential. I could also envision this incorporated into a more 3 dimensional form – a sculpture that pulsates in weird ways.

Hand Shake Ring

So we decided to try incorporated a reed switch into a wearable article. We thought about how to activate the switch through the interaction of two people. We were sick and tired of those old fashioned, analog handshakes and hi-fives, and so the led ring was born.  We needed to make two rings, one for the led and switch, and another for the magnet that activates it.


May made a fabric ring


Wolfgang made a wooden one


Lusha and Vidhi tackled the electronics


we hooked it up to the battery and it worked great, like a super cheap, code-free proximity sensor. The battery’s not so pretty, but it could get redesigned with a coin cell maybe. The next model would also need to protect the reed switch a little better. The reed switch is basically just a tiny glass tube with tinier pieces of metal in it and it’s pretty fragile.


We made a spy movie out of it:



The Power Bracelet

This wearable housing for the Adafruit Flora incorporates light, sound and a unique capacitive touch sensing interface to allow a range of potential low-fi functions. This prototype functions as a light-up musical keyboard on your wrist for spontaneous musical interludes to your daily life.

lucy brandon

Kahler_W_bracelet 2 (1024x768)

Kahler_W_bracelet1 (1024x768)

A 3D printed enclosure is capped with a translucent lid of laser-cut and laminated acrylic. The wristband is of muslin, with a Velcro clasp.

Kahler_W_bracelet 4 (1024x768)

These capacitive buttons are very low-cost can be incorporated into a flexible medium, such as the fabric of the wristband, without adding bulk or rigidity. The consist of conductive fabric, with a machine-embroidered border and are connected to the micro-controller via conductive thread.


The Flora board is outfitted with two neopixels soldered directly to the board, a small rechargeable battery, and a piezo buzzer (shown unsoldered).

The computer models of the housing:

body lid

The bracelet is programmed to play four different arpeggiated chords in the key of G and flash a different color for each colors for each.

Watch the Video:

Here’s the code:

#include <CapPin.h>

/* CapPin
* Capacitive Library CapPin Demo Sketch
* Paul Badger 2011
* This class uses the bullt-in pullup resistors read the capacitance on a pin
* The pin is set to input and then the pullup is set,
* A loop times how long the pin takes to go HIGH.
* The readPin method is fast and can be read 1000 times in under 10 mS.
* By reading the pin repeated you can sense “hand pressure”
* at close range with a small sensor. A larger sensor (piece of foil/metal) will yield
* larger return values and be able to sense at more distance. For
* a more senstive method of sensing pins see CapTouch
* Hook up a wire with or without a piece of foil attached to the pin.
* I suggest covering the sensor with mylar, packing tape, paper or other insulator
* to avoid having users directly touch the pin.

CapPin cPin_2 = CapPin(2); // read pin 5
CapPin cPin_3 = CapPin(3);
CapPin cPin_4 = CapPin(9);
CapPin cPin_5 = CapPin(10);

#include <Adafruit_NeoPixel.h>

#define PIN 12

// Parameter 1 = number of pixels in strip
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
// NEO_KHZ400 400 KHz (classic ‘v1’ (not v2) FLORA pixels, WS2811 drivers)
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(2, PIN, NEO_GRB + NEO_KHZ800);

float smoothed;
float smoothed2;
float smoothed3;
float smoothed4;
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978

void setup()

strip.begin();; // Initialize all pixels to ‘off’
// slider_2_7.calibrateSlider();


void loop()
long total1 = 0;
long start = millis();
long total = cPin_2.readPin(2000);
long total2 = cPin_3.readPin(2000);
long total3 = cPin_4.readPin(2000);
long total4 = cPin_5.readPin(2000);
// simple lowpass filter to take out some of the jitter
// change parameter (0 is min, .99 is max) or eliminate to suit
smoothed = smooth(total, .1, smoothed);
smoothed2 = smooth(total2, .1, smoothed2);
smoothed3 = smooth(total3, .1, smoothed3);
smoothed4 = smooth(total4, .1, smoothed4);

//Serial.print( millis() – start); // time to execute in mS
//Serial.print(total); // raw total
//Serial.println((int) smoothed); // smoothed
//Serial.println((int) smoothed2); // smoothed
//Serial.println((int) smoothed3); // smoothed
//Serial.println((int) smoothed4); // smoothed

if (smoothed>100 and smoothed2<100 and smoothed3<100 and smoothed4<100){
G_5 ();
if (smoothed<100 and smoothed2>100 and smoothed3<100 and smoothed4<100){
D_6 ();
if (smoothed<100 and smoothed2<100 and smoothed3>100 and smoothed4<100){
G_5 ();
if (smoothed<100 and smoothed2<100 and smoothed3<100 and smoothed4>100){
C_5 ();
if (smoothed<100 and smoothed2<100 and smoothed3<100 and smoothed4<100){
void C_5(){
colorWipe(strip.Color(50, 50, 0), 0);
tone(1, NOTE_C5);
colorWipe(strip.Color(150, 150, 0), 0);
tone (1, NOTE_E5);
colorWipe(strip.Color(250, 250, 0), 0);
tone(1, NOTE_G5);
//tone (1, NOTE_C4);
colorWipe(strip.Color(0, 0, 0), 0);
void G_5(){
colorWipe(strip.Color(50, 50, 50), 0);
tone(1, NOTE_G5);
colorWipe(strip.Color(150, 150, 150), 0);
tone (1, NOTE_B5);
colorWipe(strip.Color(250, 250, 250), 0);
tone(1, NOTE_D6);
//tone (1, NOTE_C4);
colorWipe(strip.Color(0, 0, 0), 0);
void D_6(){
colorWipe(strip.Color(50, 0, 50), 0);
tone(1, NOTE_D6);
colorWipe(strip.Color(150, 0, 150), 0);
tone (1, NOTE_A5);
colorWipe(strip.Color(250, 0, 250), 0);
tone(1, NOTE_FS5);
colorWipe(strip.Color(0, 0, 0), 0);
void colorWipe(uint32_t c, uint8_t wait) {
for(uint16_t i=0; i<strip.numPixels(); i++) {
strip.setPixelColor(i, c);;
// simple lowpass filter
// requires recycling the output in the “smoothedVal” param
int smooth(int data, float filterVal, float smoothedVal){

if (filterVal > 1){ // check to make sure param’s are within range
filterVal = .999999;
else if (filterVal <= 0){
filterVal = 0;

smoothedVal = (data * (1 – filterVal)) + (smoothedVal * filterVal);

return (int)smoothedVal;

reverse wipe

Hey everyone,

I figured out how to make the noepixel strip wipe in reverse…pretty exciting stuff! here’s how:

reverse wipe code

1. Starting with the strandtest sample, I deleted everything under the loop except two of the color wipes (red and blue).

2. I changed the name of the second color wipe to colorwipe2

2. Scrolling down the page I copied the “void colorwipe” code and pasted it below changing the name to “void colorwipe2”

3. In the void colorwipe2 code I changed “i=0” to “i=19” meaning that  the pattern is starting from the 20th led instead of the 1st

4. I changed i++ (which translates to i=i+1) to i=i-1

The result:



Kaleidescopic Explorations…and a light

This project began with a simple hands-on exercise – the construction of a series of kaleidoscope-like objects of varying shapes and sizes using metallic faced card stock. This exploration not only produced some pretty neat effects but offered hands-on insight into the interaction between light and mirror, and inspired ideas for how the construction might be tweaked to produce effects beyond that of the traditional kaleidoscope.

a flock of kaleidoscopes
a flock of kaleidoscopes
kaleidoscopes exposed
kaleidoscopes exposed
photos taken through kaleidescopes - of printed slides and scraps of paper
photos taken through kaleidoscopes – of printed slides, scraps of paper, and the reflection of the camera

The Selfy

The Selfy is a conceptual tool for reflection. The lens of the traditional kaleidoscope is twisted back on on the viewer who, looking into his own multiplied eyes, is compelled to contemplate the phenomenon of self-awareness.

Brandon models the Selfy mid-existential crisis
Brandon models the Selfy mid-existential crisis


Spider Eyes

prototypes for a revolution in eyewear fashion

20130908kaleidescope022 20130909kaleidescope037 20130909kaleidescope036


These formal explorations moved towards the idea of projection. It was discovered that by shining a light through a kaleidoscopic object a large surface could be illuminated with a relatively small aperture and from a close distance. The width, length and shape of the tube can drastically alter the pattern created, creating limitless opportunities for experimentation. A next step might be to incorporate slides which (as initial tests have confirmed) produce a grid of duplicate images on the the surface.

20130908kaleidescope011 20130908kaleidescope014 20130908kaleidescope015

The Kaleidoscopic Projector Light

The experiments with projection produced this wall or ceiling-mounted lighting design. A kaleidoscopic tube scatters the light from a single 3-watt led onto the back of a sheet of translucent rice paper to create a diffuse but visually interesting light source. The pattern can be varied by changing out the mirrored tubes, and in some instances is reminiscent of dappled light filtered through tree canopies.

The KPL (Kaleidoscopic Projector Light)
The KPL (Kaleidoscopic Projector Light)
The KPL (Kaleidoscopic Projector Light)
the KPL illuminated
the KPL illuminated
the KPL illuminated
the KPL illuminated
the KPL illuminated
the KPL illuminated