Above is the PowerPoint slideshow that Diego made for our in-class presentation. There is also copious supporting material at the following locations:

• Photos, with lots of chatty comments
  
• Videos, interspersed with kittenage
• Arduino code
• Processing code
  • colors_highlight_new_swatch – this is the color palette module. It reads a text file containing all the colors in the appropriate Krylon spraypaint line and outputs them as a grid of colored squares. The active swatch and rolled-over ones are highlighted with colored borders. It’s glitchy, as you can see if you look in the upper left corner, but basically it works.
  • spraycans – I would like to make my own set of brushes, based on Diego’s, that are all the same style but in different sizes. These would then be mapped to the number of fingers being held up, with more fingers triggering a bigger spray cone. This would make it easier for users to get predictable, slightly repeatable results. Toward that end, I made a spraycan object whose spray cone, label number (for the size), and can color (for the paint) are variable. Epileptics should probably not view this sketch.
  • Main application – The “final” in “final_application_4″ refers to the this being our final project for the semester, not to the code itself actually being final. For, verily, it is not. This is the wrapper into which all the other modules will eventually be rolled. It’s a whole lot of nested if statements and functions. This program doesn’t run unless the glove is plugged in; I should fix that, to make it easier to check code while programming.

This is the second smidgen of the code for our final project. It pulls RGB values and color names from a tab-delimited text file (which is, itself, based on the actual Krylon color options) and outputs this grid of swatches. The swatches don’t do anything yet—just drawing them took me, like, two days, thank you very much, and that was with some very helpful help from Shawn. Partly this is because I apparently can’t keep in my head for more than thirty seconds how arrays and objects work, and partly it’s because I just. can’t. focus. And partly it’s because I apparently have no idea what the fuck I’m doing.

I’m beginning to really like Diego’s Plan B, as proposed over the weekend:

Fake our own deaths.

I keep telling myself I have to not panic and just write the code one piece at a time. Then, later, I can get somebody to help me put it all together, which is something I know I have no clue how to do. But just accomplishing what seem like they should be simple things is stumping me. Most recently, I was trying to get the swatch name to be displayed when a square is rolled over. This is not by any means an important feature—in fact, it doesn’t really serve any purpose. But I should be able to do it, and I can’t figure out why it doesn’t work. I keep getting errors like “The function showName() does not exist” or “Cannot find anything named ’swatches.’” Both of these things do, of course, exist, and I can’t see any reason why they wouldn’t be found.

I know it’s pretty rare for computers to just fuck up and much more common for me to do so, so I’m sure the answer is that I’ve done something really dumb and sloppy somewhere. But it could easily take me two hours to find that error, and every new goddamn line of code seems to cause some new mysterious issue. I can feel myself growing older just thinking about it. And there are a lot more lines of code to go. Here’s the stuff I was hoping to get done, oh, by, say, last Thursday:

And that’s not including the task of sewing us a new glove, for which I bought fabric on Monday, as well as a book about how to use my virgin four-year-old Juki serger. I know that’ll be fun once I get started, but I just can’t get started.

Maybe I need a drink.

So then . . . The other day I was talking about the glove project with my friend Rose, and I rhetorically asked what the hell this kind of low-fi, large-format drawing setup would be good for. Rose’s answer was immediate: graffiti.

Duh.

So then, what we need is just a limited palette of Krylon spray paints, and a couple of brush types—say, a fat marker and three sizes of spray patterns. And then, when I asked my perpetual question of “What are the other fingers doing?,” Diego had this brilliant idea: the number of fingers you’re using determines the brush size. Index finger for the marker; index and middle for a small spray nozzle; index, middle, and ring for a medium spray; and all four fingers for the biggest spray—what you’d use to fill. That’s a pretty intuitive mapping. We wouldn’t need to track motion on all the fingers, just whether they’re flexed or not. And we could use an accelerometer to register wrist tilts, somewhat like the Rock ‘n’ Scroll, to cycle through the color palette.

The thumb would remain an on/off switch.

We could have different backgrounds to paint on, like brick walls, subway cars, trucks.

Bitchen.

This idea is, in fact, so cool that it has already been done.

Developing . . .

Photo: ASBO by rubberdreamfeet / David Hayward. Some rights reserved.

Get it now! Detailed, full-color documentation of the famed MC Squared midterm project!

MC_Squared(fin).pdf (14.68 MB; sorry, it contains a couple of embedded videos)

We gave our presentation today, the thing mostly worked, and it wasn’t too embarrassing. And, unlike some people in the class, my group actually got two or three hours of precious, golden sleep the night—well, morning—before. (We closed down the floor at about 3:30 a.m., but a few of our classmates relocated to the library or some such place to keep working. Everybody seemed pretty crispy by 9:30 this morning.)

First I thought I’d use one of these nifty sensors I got from SparkFun,

but then I realized I have no idea how you’re supposed to hook them up. Stick the pins straight into the breadboard? Solder wires on? How long should the wires be? So instead I used the stupid knob again, plus one of the IRs I bought for our midterm project.

The thrill of the knob has totally worn off. Then I saw Jorge soldering wires to an ultrasonic range finder just like the one I have, and I thought maybe it was a good time to try out my own. Ha! Thus began one of my more frustrating soldering bouts so far.

It must have taken me forty-five minutes to solder three freaking wires onto this cookie . . . and then it took me another hour to realize that the reason it wasn’t working was that I’d soldered the yellow wire to the wrong hole. And then I couldn’t get it unsoldered to save my life, so I just attached a fourth wire.

Finally I got them all hooked up:

And then, there was serial output:

• “Now you get a range of garbage characters.”
• “List all the available serial ports.”
• // print out the values you got:
for (int sensorNum = 0; sensorNum < sensors.length; sensorNum++) {
print("Sensor " + sensorNum + ": " + sensors[sensorNum] + "\t");
}
// add a linefeed after all the sensor values are printed:
println();

Et cetera.

After all that hair-pulling, the ultrasonic sensor was giving me really erratic readings (then again, so was the push-button switch: its value didn't change when I pushed the button, but it did when I touched the button). So I switched to two IR sensors, since I had so many lying around.

Then I got to the part about the handshake. Handshaking? Was not happening for me. I think it may have had something to do with this:

The Processing application was looking for the word "hello," but the Arduino didn't seem to be able to say the word without stuttering horribly. I tried for more than an hour, I think, to get them to talk to each other, but finally I had to just give up.

Part 2 in the saga that began last week.

After spending about an hour playing with the Minim library in Processing, I went into the lab to see if I could get it to work with actual input from our IR sensors. This was basically a repeat of this week’s homework, which I’d done, for once, before the morning it was due, so the wiring part was uncharacteristically easy. I need to get some header pins, though; the stranded wire on the IR sensors is a pain to plug into a breadboard.

So our project—which I realize I didn’t explain last week—is going to be a cubeoid musical (or, at least, noisy) instrument with an infrared sensor set into each side, mounted corner-up (as demonstrated by Diego) on a camera tripod. One or more players can then use their hands or other body parts or utensils or pets to trigger different sounds from each side. We were thinking that for Phase One, i.e., this week, we’d have the sounds be synthesized tones, and that for Phase Two, the final version, we’d make it play various different loops.

It turned out, however, that it’s far easier—for me, at least—to get Minim to play loops than to synthesize sounds. And there are a lot of free sound clips out there in the world. I got mine from CanadianMusicArtists.com. This pre-prototype, therefore, has only two sensors, both of which trigger audio loops. It also has the beginnings of a lame-ass bouncing ball animation, but it doesn’t do what I want it to do, mostly because the signal’s changing too rapidly. Graphics were a tentative feature for Phase Two, so I’m not going to fuss with that part any more this week.

Here’s some crappy video of Filippo (left) and Diego (right) making the sensors generate noise. You can barely hear it, unfortunately—listen for the annoying rapid clicking sound, which I think is the hi-hat sound.

The beauty part? This doubles as my ICM homework.

Here’s the Arduino code:

/* Reads data from two analog sensors (IR sensors, in this specific example)
and outputs the values in a format that can be easily parsed in Processing.
*/

int ledPin = 7;
int irSensor0 = 0;
int irSensor1 = 1;
int sensorValue = 0;

void setup()
{
// Flash the LED three times to announce the start of program.
pinMode( 7, OUTPUT );
digitalWrite( 7, LOW );
delay( 300 );
digitalWrite( 7, HIGH );
delay( 300 );
digitalWrite( 7, LOW );
delay( 300 );
digitalWrite( 7, HIGH );
delay( 300 );
digitalWrite( 7, LOW );
delay( 300 );
digitalWrite( 7, HIGH );
delay( 300 );
digitalWrite( 7, LOW );

// Start serial port at 9600 bps:
Serial.begin( 9600 );
}

void loop()
{
if (Serial.available() > 0)
{
// Read the first (0) sensor:
sensorValue = analogRead( irSensor1 );

// print the results:
Serial.print( sensorValue, DEC );
Serial.print( "\t" );

// read the second (1) sensor:
sensorValue = analogRead( irSensor0 );
// print the results:
Serial.println( sensorValue, DEC );

// Follow the last sensor value with a println() so that
// each set of four readings prints on a line by itself:
Serial.println( sensorValue, DEC );
// delay ( 100 );
}
}

And here’s the Processing code, where most of the excitement takes place.

I was trying to figure out the math to make part of the graph show up as brown—i.e., earth—and then scatter flowers on top, but something wasn’t working out and I was running late, so I gave up.

Anyway, here are the progress shots:

Setup:

Pot hooked up:

Blinking LED:

I also shot a fascinating movie of the program loading on the Arduino and starting up—you know, flickering yellow light, then blinking LED; hot stuff:

Final code on Arduino:

int potPin = 0;
int potValue = 0;
int ledPin = 2;

void setup()
{
// flash LED three times to announce start of program
pinMode( 2, OUTPUT );
digitalWrite( 2, LOW );
delay( 500 );
digitalWrite( 2, HIGH );
delay( 500 );
digitalWrite( 2, LOW );
delay( 500 );
digitalWrite( 2, HIGH );
delay( 500 );
digitalWrite( 2, LOW );
delay( 500 );
digitalWrite( 2, HIGH );
delay( 500 );
digitalWrite( 2, LOW );
delay( 500 );
digitalWrite( 2, HIGH );

// start serial port at 9600 bps:
Serial.begin( 9600 );
}

void loop()
{
// read analog input, divide by 4 to fit it in the range 0-255:
potValue = analogRead( potPin );
potValue = potValue / 4;
Serial.print( potValue, BYTE );
// pause for 10 milliseconds:
delay( 10 );
}


Final Processing applet

Crank your speakers and click to play

Sorry about the wobbles.

This is my video journal of the Servo lab for PhysComp, filmed for CommLab on a Sanyo Xacti 6MP digital movie camera.

I tried to edit this within the Xacti, but I ended up joining the clips together in the wrong order. It was way too much work to separate them again—it’s just a lousy way to edit—so then I dumped the mess into iMovie HD (an older version, recommended by Bre Pettis in his very fine Getting Started in Video series), recut and rearranged it, and added title frames from Photoshop (too bad they look like crap after compression) and CC-licensed music by the excellent Kristin Hersh. This was my first time using iMovie; I found it reasonably intuitive.

So, basically, it’s just the worst video for a Kristin Hersh song ever. Rock on.

I managed to strip three wires in less than five minutes—a huge improvement over last week—but I still suck at soldering:

My hands shake a lot, I’ve learned. Also, I can’t see. I had to bring in the nasty fluorescent work light that I use when I’m doing proofreading, and even then I had to get my eyes down so close to what I was soldering that I almost soldered my face. Another thing I’ve learned thus far is that you basically get one chance at making each join. If you mess up on the first try, any attempts to fix it just seem to make matters worse. And smoky.

The first part of this assignment went smoothly. I had no problem matching my setup to the photo in the instructions, and turning the knob actually did what it was supposed to do. Yay!

Bright vs. Dim

(I know it doesn’t look very dim, but trust me.)

Swapping in other kinds of variable resistors required my actually thinking, however, and that part didn’t go so well.

I had wanted to get a flex sensor, but the computer store suddenly changed its hours—I guess because we’re three weeks into the semester?—and was closed five minutes before I arrived. So no Hug-O-Meter for me. Instead, I rewired the board with a photocell, a thermistor, and two LEDs, per the other photo, and then changed the code accordingly. Only one of the LEDs was responding, though, and it was the wrong one. Covering the photocell made the green LED dim instead of the red one. So I fiddled with the code a bit, checking the Serial.print output to see if the thermistor was doing anything at all, and eventually I turned around the red LED.

Aaah. I really need to learn which leg of an LED goes where.

So then both LEDs were lit, and the red one was responding to the photocell, but the green one wasn’t doing squat. I fiddled with the code some more, changing analogWrite(ledB, potValueB/4); to analogWrite(ledB, potValueB*4);, but that didn’t do anything. So I took out the resistor (a 220) that was adjacent to the thermistor, and the Serial.print numbers shot up and the LED got a lot brighter. So then I swapped in different resistors: 10 was no good, 100 was no good, but 1,000 did the trick: finally, the changes in brightness were visible.

Both LEDs off:

Both LEDs on:

Covering the photocell—red LED dims:

Nice nail polish, huh.

Holding the thermistor—green LED dims:

Do I understand why this worked? Absolutely not. But it worked! Woot!

11:15: I forgot how hard you have to pull to strip the insulation off the wire (or is it just me?).

11:30: Wow, I totally remember that smell of hot soldering iron from my childhood. Nevertheless, I am the worst solderer ever.

11:45: Yes, worst solderer ever. Not being able to see anything close up anymore doesn’t help, either; obviously, I should have gone to ITP while I was still in my twenties and only half-blind.

11:50: Oh, yeah—now I remember how to use wire strippers. Rotate.

12:15: Looking up resistor values. Did I miss some introductory class where we were supposed to learn all this shit? Honestly, if I hadn’t spent weekend afternoons sorting resistors for my dad when I was in grade school, I think I’d be completely lost right now. Setting up a straightforward circuit on a breadboard should not be taking this long.

Resistor Values

Cheat cheet: http://www.iguanalabs.com/resistors.htm

10 x brown black black gold = 10

10 x brown black brown gold = 100

10 x red red brown gold = 220

10 x brown black red gold = 1,000

10 x brown black orange gold = 10,000

5 x orange black orange gold = 30,000

5 x brown black yellow gold = 100,000

12:50: Done sorting resistors, distributing into parts box, drawing and inserting labels.

1:15: Finally, my circuit looks like the photo on the website (well, except for the googly eyes). Woot!

Does it do anything, though?

1:25: Aaargh! The answer to that question is, No.

Problem uploading to board. See http://www.arduino.cc/en/Guide/Troubleshooting#upload for suggestions.

Binary sketch size: 1126 bytes (of a 14336 byte maximum)

avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_recv(): programmer is not responding

1:28: Hmm. It uploads fine when nothing is connected to the board.

1:30: Okay, the red LED lights up when I hold down the switch. The green LED doesn’t do anything, though.

1:35: Troubleshooting. Tried swapping the red and green LEDs: now nothing works. Replaced the green LED with a yellow one: nothing. Re-uploaded the program to the board (which worked just fine this time): nothing. Shite.

Unplugged everything except the USB cable, hit reset, re-uploaded program: error message. Reset, tried uploading again: worked. Plugged breadboard back in: nothing happening.

Hit reset, re-uploaded program: error message.
No reset, re-uploaded program: error message.
Reset, re-uploaded program: upload okay, but no lights.
Jiggled all the connections. Nothing.
Unplugged & replugged USB cable, reset, re-upload: nothing.

AAAAARRRRGGGHHH!!!! I give up.

Reversed the legs of the yellow LED: lit up. Hmm. Reversed legs of red LED: lit up. Now both are lit. When I hold down the switch, both turn off.

Reset, re-upload: error, both lights on.
Reset, re-upload: okay, both lights on.

Changed code to

if (switchState == 1) {
// if the switch is closed:
digitalWrite(yellowLedPin, HIGH); // turn on the yellow LED
digitalWrite(redLedPin, HIGH); // turn off the red LED
}
else {
// if the switch is open:
digitalWrite(yellowLedPin, LOW); // turn off the yellow LED
digitalWrite(redLedPin, LOW); // turn on the red LED

Reset, re-upload: okay, lights off. Pressing switch turns both on.

. . .

YAAAAYY!! In switching the LEDs around, at some point I got one leg into the wrong row. Everything now works exactly as intended! Aaaand . . . it’s 2 a.m. Bummer. So much for Part II of this week’s homework: making a combination lock using a LEGO phone.

So.

I don’t feel like I had any idea what I was doing with this assignment, besides trying to copy the photo exactly. I didn’t refer to the diagram much, because I don’t really remember from high school how to read an electrical diagram. All in all, I felt pretty uninformed. It would have helped to be doing this in the lab at school, surrounded by other cursing, frustrated people, but I would have had to bend space and time rather drastically in order to be able to work there. Other inhabitants of the universe might have thereby been inconvenienced.