Introducing the Mouth Piano...

ITP Spring Show 2007

The Modular Prototype

After doing some more serious thinking about our design, Rosie came up with the idea to make the "piano" piece of the mouthguard, modular. Our goal was now to create a detachable mouth insert, that can be attached with velcro to the mouthguard. We created the insert using perf board, the cut the board using the scroll saw.


Then we "wired" up the perf board, WITHOUT using solder. This was a very tedious process, as it involved wrapping 30 gauge wire around each switch leg, several times. We opted to use an ethernet cord, because when stripped, it has exactly eight wires inside of it. And....

eight wires = eight digital pins = eight notes = one full octave!

And then we connected each of the switches' ground wires to the arduino digital pins.



Waterproofing was our next challenge. We decided to use shrink wrap, but we had to attach several pieces together, since the mouth insert was very wide.

Then we attached velro to both the modular insert and the mouthguard. And formed one, complete Mouth Piano!!!

The Balloon Prototype

During our final prototyping days, we explored more possibilities for the Mouth Piano. One of our biggest concerns was waterproofing the mouthguard. While in line at K-Mart buying saran wrap, I saw a birthday box at the impulse counter, which included balloons! Which got me thinking...balloons would at least be a fun, if not practical, waterproofing solution.

Latest Prototype

Tonight we started our new prototype using a Brux Guard(R) and mini switches.

A Switch to Switches

Change in plans -- we're going to use switches instead of FSRs. The FSRs were a nice idea because we could use the strength of a press to determine volume; however, they are just too fragile for our particular application. We tested a variety of switches to see which one(s) we could press with our tongues and settled on a small, 4-pin, push-button switch from Sparkfun.

Using Conductive Thread in our Prototype

During our previous prototyping, we used solder to connect components. While of course solder creates a very durable connection, it is not something that you would like to place into your mouth. Our alternative solution is to use conductive thread, for the areas that are in or near the user's mouth. I was able to receive a sample of 235/34 4-Ply from Shieldex.

To connect the conductive thread to the FSR, I poked a hole each of the prongs of the FSR, using a needle, and then wrapped the end of each string onto a wire. Then we connected the wires to the arduino.

We ran the below code and opened up the serial port, to see what kind of analog data we were receiving.

int potPin = 0; // Analog input pin that the potentiometer is attached to
int potValue = 0; // value read from the pot


void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
}

void loop() {
potValue = analogRead(potPin); // read the pot value
Serial.println(potValue); // print the pot value back to the debugger pane
delay(10); // wait 10 milliseconds before the next loop
}

We received a different range of results than we did with the soldered components. The soldered ranges started at 0 and reached between 300-400 when moderately pressed, and reached between 800-900 when hardly pressed.

The ranges when using the conductive thread, started at 0 and only went up to only about 50-60 when pressed hardly. We are not quite sure if the new connection is causing this change, or if the change has to do with the FSR now being punctured and possibly broken.

Our next step was to attached the FSR to mouth-guard using hot glue. Previously this step did not cause too many problems, and we were able to obtain great serial data before the mouth-guard was placed into a user's mouth. This time we were not as successful. Once the FSR was attached to the mouth-guard we only received 0 as our analog data, even when the FSR was pressed, and we were only able to obtain serial readings in the 900's when the conductive threads crossed each other.

Our next step is to meet with John Schimmel, one of our course instructors, and try to figure out what is going wrong with our prototype.

First Prototype

Yesterday we made our first prototype, pictured here. It features two .2" fsrs hot-glued to the inside of the mouth-guard. We were able to hook it up to a MIDI synth and play two different notes by pressing on the fsrs (holding the mouth-guard, not having it in my mouth). Unfortunately, when I put it in my mouth, we didn't get the same results. It seemed like one note would stay on no matter what, and one note only played some of the times we wanted it to. We're not sure if we damaged an fsr in all the twisting of wires or if I damaged one with saliva when the saran wrap accidentally slipped. Working with FSRs is SO frustrating!! They are incredibly delicate and break really easily. We've definitely broken at least two and haven't yet determined if the two that are attached to the mouthpiece are still working. So before Thursday, our goal is to test the FSRs on the mouthpiece to see if they're still working, and if not, replace them. We ordered 15 more FSRs over the weekend that will hopefully arrive before then.

The Code

#define fsr 0
#define fsr2 1

// Middle C (MIDI note value 60) is the lowest note we'll play:
#define middleC 60

// Variables:

int AnalogValue = 0;
int AnalogValue2 = 0; // value from the analog input
int lastNotePlayed = 0; // note turned on when you press the switch
int note=0;

void setup()

{
// set the states of the I/O pins:
pinMode(fsr, INPUT);
pinMode(fsr2, INPUT);
// Set MIDI baud rate:
Serial.begin(31250);
}

void loop()

{
AnalogValue = analogRead(0);
AnalogValue2 = analogRead(1);

//Serial.println(AnalogValue);

if (AnalogValue >100)

{
note = 60;
noteOn(0x90, note, 0x40);
// save the note we played, so we can turn it off:
lastNotePlayed = note;
}

else if (AnalogValue2 >100)

{
note = 70;
noteOn(0x90, note, 0x40);
// save the note we played, so we can turn it off:
lastNotePlayed = note;
}

}

void noteOn(char cmd, char data1, char data2)

{
Serial.print(cmd, BYTE);
Serial.print(data1, BYTE);
Serial.print(data2, BYTE);
}