Hypomnemata

Here’s a quick hack I keep meaning to release in a meaningful way: a morse code decoder in arduino.  Hook up a button to pin 2 (like you would for the button examples), and then watch the serial monitor.  If you key in SOS (…/—/…), it will light up the LED on pin 13.  My intention here was to use this to buzzy myself into my apartment building’s door, but I still haven’t gotten around to actually putting it inside the box yet(!).

Give it a go, and see what you think of it.  I’d also like to hook it up to an LCD panel and make a proper morse training device out of it, but that’s for another day, I think.

Leave comments here if you make any use of this, I’m keen on seeing what happens with it!

73 de KJ6ANM

Here’s the file: arduino_morse_decoder.pde(.txt to make things happier).

I recently centralized and tallied up my personal source repository: something like 100kloc and about 80 directories.  This represents around a decade of evenings and weekends spent writing code, in everything from C to Haskell, in environments from my low-level Unix home to PalmOS.  The most recent stuff is arduino and processing, but it also includes OCaml-gtk and a bit of Objective C (written on OS X 10.0).  The common themes through all this diversity?  It’s all hastily written, poorly documented, and nigh-unreleasable code.

That said, my friend Kragen caught wind of this and suggested I release it all.  While I won’t release everything (some of it is still very nascent and/or mostly vapor), I will be working my way through, giving some things Makefiles and READMEs before kicking them out the door.

Tonight is the first installment of this src parade.  It’s actually something I released years ago, which has fallen into a bit of disrepair, but was still pretty cool: Marginalia.  Marginalia was a firefox extension that allowed you to annotate webpages in-place, and see the annotations others had left behind.  Its plugin description was “Collaborative annotation for FireFox,” which pretty well fits.

Viewing an annotation placed with marginalia

Why did I build this in the first place?

It was meant to allow the disruptiveness of the web to become even more pervasive.  Imagine if citizen journalists could leave links to alternate coverage of stories on CNN.com, or add links to previous statements by politicians to their latest contradictory interview.  It predates youtube; nowadays, it would definitely allow embedding youtube clips for this.

What did I learn in building it?

Javascript is hard.  No, really, it is.  If you want to build something like this, performance matters, and it’s non-trivial to get correct.

HTML/DOM is hard.  It was never intended to do things like this, and you really have to bend over backwards to make it happen.

Don’t give up so soon.  Marginalia was pretty freaking awesome, if I do say so myself.  I didn’t push hard enough for others to adopt it, and I let it die too early and too easily.  It could have been a big deal, but I didn’t care enough to keep at it.  In my defense, I was in the second to last semester of undergrad, which was pretty intense.  I was working 20-30 hours a week and had two majors, so it was either hack on this or spend time with my girlfriend.  (I got to play with marginalia on the clock, but only so far as it didn’t interfere with keeping the lights on.)

Where does it stand today?

Marginalia fell to the wayside at some point.  Most significantly, it needs retouching to work with the latest firefox/gecko.  It currently doesn’t install, but I’m pretty sure it’s more than just updating the compatibility ranges.  If you’re interested in the problem, I’d suggest looking at newer web annotation systems  Wikipedia has a good list at [[Web annotation]].  The hardest technical problem you’ll face is actually kind of silly: figuring out where to attach the note based on the user’s click.  Have a look at how marginalia does it to see one solution; I’m sure there are others which are just as good.  (Hint: marginalia bundles a pure-javascript SHA-1 implementation)

You’ll find more text and a download at the Marginalia homepage.  The source is part of the download, though it doesn’t look like it.  XPI is, like JAR, a strange way to say ZIP.  That is: you can download the XPI file (right-click, save as), then unzip it (you might need to rename it to be a .ZIP file).  The guts of things are in chrome/marginalia/content/marginalia.js

Would I do it again?

Probably not, actually.  This is mostly because others are solving the problem, but also a little bit because solving the problem is incredibly tedious.  Having written a handful of little firefox extensions, I now have zero urge to build on that platform any more.  I still love the idea of marginalia, but I would prefer to leave implementing it to someone else.

I recently worked on an art project called Perceptron, an interactive dance floor (it’s cool, check it out).  The kind folks at Langton Labs hosted our build process for a while, and it was there that I met the lamp of my dreams.

It was a sphere made out of pipette covers, which are a nice milky, translucent plastic, and diffuse light wonderfully.  In the center was an array of RGB LEDs, which would cycle through colors.  There were these gorgeous blues and reds in there that you just don’t see very often: they’re probably beyond what LCD technologies can produce, so it’s a redder red and a bluer blue than you’re used to seeing.

Tonight, while killing time waiting for something, I swung by my neighborhood Radio Shack and picked up an RGB LED.  When I got home, I plugged it into my arduino and got to hacking.  I now have a one-LED version of that lamp, which makes me really happy.  It’s a gorgeous thing to behold, and involves a fun little bit of code and math.  So, of course, I’m going to share it with you.

Color-wheel arduino video

To get the color transitions to be smooth, you can’t just ramp through levels of red, green, and blue: it winds up being a bunch of peaks and valleys.  Instead, you really want to go around the HSV color wheel, changing the hue as you go.  It generates a really smooth transition, which is most pleasant.  Unfortunately, due to how crappily I’m driving the LED, it’s not as smooth as it could be: the arduino has only so much resolution in how finely it can control the level of these LEDs.  This makes for a few little jerky transitions in the blue to red return.

Here’s the code, in full:

// This assumes you're using a RadioShack #276-0028 RGB LED
// 2011-05-12: Note!  The anode is the really long pin.
// You'll need to bend it to get it into Digital8.
//
//          ||  ||  ||  ||
//          ||  ||  ||  ||
//          ||  ||  ||  ||
//          G   B   ||  ||
//                  ||  R
//                   A
//         D11 D10 D08 D09 

int common_anode = 8;
int red_pin = 9;
int blue_pin = 10;
int green_pin = 11;

int red_min = 150;
int red_max = 255;

int blue_min = 185;
int blue_max = 255;

int green_min = 195;
int green_max = 255;

void hsv_to_rgb(float h, float s, float v, unsigned char *rc, unsigned char *gc, unsigned char *bc) {
int h_i = ((int)(h/60)) % 6;

float f = (h/60) - (int)(h/60);

float r,g,b;

float p = v * (1.0 - s);
float q = v * (1.0 - f*s);
float t = (1.0 - (1.0 - f)*s);

switch(h_i) {
case 0:  r = v; g = t; b = p; break;
case 1:  r = q; g = v; b = p; break;
case 2:  r = p; g = v; b = t; break;
case 3:  r = p; g = q; b = v; break;
case 4:  r = t; g = p; b = v; break;
case 5:  r = v; g = p; b = q; break;
}

*rc = red_max - (char)((red_max - red_min)*r);
*gc = green_max - (char)((green_max - green_min)*g);
*bc = blue_max - (char)((blue_max - blue_min)*b);
}

void setup() {
pinMode(common_anode, OUTPUT);
digitalWrite(common_anode, HIGH);

pinMode(red_pin, OUTPUT);
digitalWrite(red_pin, HIGH);

pinMode(green_pin, OUTPUT);
digitalWrite(green_pin, HIGH);

pinMode(blue_pin, OUTPUT);
digitalWrite(blue_pin, HIGH);

Serial.begin(9600);
}

float h = 0.0;
float s = 1.0;
float v = 0.8;

void loop() {

unsigned char r,g,b;

h += 1;
if (h > 360.0)  h -= 360.0;

hsv_to_rgb(h,s,v, &r,&g,&b);
analogWrite(red_pin, r);
analogWrite(green_pin, g);
analogWrite(blue_pin, b);

delay(100);
}