[Don] put together a guide that will help you build your own Ambilight Clone for about $40 plus the cost of an Arduino. He’s using it with the HTPC seen above, and utilized modular concepts in building it so that you can easily disconnect your Arduino board when you want to use it for prototyping.

For RGB light sources [Don] grabbed six ShiftBrite modules. These are fully addressable cascading modules which make for very easy hardware setup. Instead of buying a driver shield he built his own using an LM317, heat sink, and wall wart to source enough current to drive all of the modules.

We really enjoy the mounting scheme used. Each module is attached to a piece of acrylic which is then mounted using the standard threaded VESA mounting holes on the back of the monitor. As with other Ambilight clones this one uses the Boblight package to get color information from the video as it plays.

A few weeks back we ran a piece about the convergence of making and baking in an attempt to create a cake festooned with working LEDs. The moral was that not every creative idea ends in victory, but we applauded the spirit it takes to post one’s goofs for the whole internet to see and to learn from.

[Craig]’s LED matrix proved unreliable…and the underlying cake didn’t fare much better, resembling that charred lump in the toaster oven in Time Bandits. The cakes-with-lights meme might have died right there if not for a fluke of association…

At the time the story ran, some of us were working on an unrelated LED project which involved experimenting with light diffusers, trying to spread distinct points of LED light to a more soothing glow. Drafting vellum and frosted acrylic both worked well, but small pieces of upholstery foam had proven especially effective.

Between seeing the cake project and handling squares of foam, an idea was jokingly tossed out: backlight a cake from below, using angel food cake as a light diffuser much like the foam we’d been experimenting with. The density, optical properties (and taste) do seem remarkably similar!

(On the left: polyurethane upholstery foam, the sort used in sofa cushions. On the right: angel food cake. Or…wait…is it the other way around?)

In the creative afterglow of Maker Faire (or more likely it was just exhaustion), this idea somehow made the jump from tongue-in-cheek to demo-or-die. The concept would look something like this:

A custom pedestal would secure the LEDs in place while providing a more prominent perch for the cake. A layer of glass or clear acrylic separates the two, so the LEDs would remain clean for future projects and the cake would not be sullied with any sort of flux or lead or other electronic residue. RoHS compliant cake!

Two questions then remained:

• What sort of display would we make? Static lighting would be boring, we knew this had to be animated. As a first crack at this sort of thing, we settled on a single seven-segment display, counting down.
• What type of LEDs to use? Instead of wiring up a pile of discrete LEDs, for the sake of a quick prototype we instead opted for serial addressible LEDs. Even then, there are decisions to be made:

(Left: BlinkM "smart LED." Right: MaceTech ShiftBrite. Top: RGB “pixels” available in various types from Adafruit, Bliptronics and Cool Neon.)

The choice of what type to use was based more on availability than on engineering: our Adafruit RGB pixels were tied up in another project, and we didn’t have enough BlinkMs or ShiftBrites on hand to build our prototype and didn’t want to wait around for shipping. We’d just bought a string of Cool Neon’s new “Total Control Lighting” LEDs at Maker Faire and were eager to try them in something, so they won by default. Looking back, these proved less than ideal for this particular project due to the diffuse bulbs, but we give them kudos for being among the easiest to program. Over the years we’ve messed with many different addressable LEDs, and have found that there is no One LED to Rule Them All — every one of them has unique and desirable attributes for different tasks.

We then fashioned an LED-holding template in Adobe Illustrator, sized to fit a single page:

This was printed and glued to a sheet of mat board, then the holes for the LEDs were laboriously cut out with a hobby knife. A laser cutter or even just a drill press would have made this much easier. For scale reference, each of the segments is about 1.5 inches wide, and with this just being a first prototype we didn’t bother with fancy beveled corners.

After cutting LED holes, the sidewalls and some supports were cut from foam core board and assembled using a hot glue gun. These added about two inches of height to the pedestal, to accommodate the bullet-shaped LED housings and the wires underneath. Then we punched each LED into place:

And there’s photographic proof of our first goof. Aside from the whole absurd idea, that is. These LED strings have connectors on both ends for daisy-chaining, with a distinct “in” and “out” end to each string. In our enthusiasm to attach a microcontroller, not thinking this through, we cut the “in” end and soldered our own breadboard wires. Electronically speaking this works just fine, but a better idea would be cutting the “out” connector, making that into our chip-to-LEDs adapter. Then this string would still work fine at the end of any chain, as well as with Cool Neon’s own driver circuits (which use the plug), and we’d have an adapter dongle for future applications with these strings. Lesson learned.

The string has 25 LEDs. Our display has seven segments, with three LEDs each. The last four LEDs were just wadded up under the pedestal and aren’t used here, but could have been made into ground effects lighting or something suitably corny.

After physical installation of the LEDs, we wrote and tested the code, which runs on an Arduino, natch. We’ll delve into the source later.

This pic shows the order in which the LEDs were installed and are addressed by the code. Also, the small boxes around each segment (more mat board and hot glue) restrict the diffuse outward glow from the lights and support the top acrylic for the cake:

We added contact paper to the bottom side of the acrylic, to further control stray light. This was probably overkill, but did help in positioning the cake segments later, as a sort of template. We’re not certain if acrylic is food-safe, so it’s possible that our eventual offspring may be born with tails or something. A small price to pay for SCIENCE!

Thus began the baking. And hilarity ensued…

(Devil’s food and angel food. In the same cake. You know this can’t end well.)

It was already determined that the segments would be angel food cake. The non-segment parts of the cake needed to be opaque…not just to contain the light, but as a vehicle for frosting, because a cake without frosting is no cake at all! We opted for chocolate, but most anything will do…red velvet, carrot cake, you name it. Not fruitcake though, it has an intense gravitational field from which not even light can escape.

The chocolate cake proceeded without incident. After baking and cooling, we trimmed down the risen center portion of the cake to give it a more uniform cross-section…this also provided essential sustenance to carry us through the next phase.

You’ll notice there are no photographs of the angel food cake being made. Oh, sure, [Craig] may be man enough to show his failures, but not us. We usually take umbrage to those television ads that depict the “man of the house” as an imbecile when confronted with domestic tasks, as if all males are HULK SMASH! brutes who can’t so much as feed or dress themselves. We’ve seen some awesome cooking hacks around here and know it’s simply not true. Then we tried baking an angel food cake…

Angel food cake (the name being an obvious conspiracy of marketing to lure us in) is a strange and alien thing, no doubt a product of NASA research that also brought us aerogels and space shuttle thermal tiles. The box contains what looks like diatomaceous earth, to which water is added. No eggs or oil or anything resembling, y’know, food. This is frothed in the mixer and poured in a pan, baked (during which it swells to over 6,000 times its original volume) and then, removed from the oven and allowed to cool (very important that it’s on its side, for whatever alien agenda reason) it proceeds to mock you for all eternity as an impenetrable sticky mass that defies all attempts at cutting or removal, like a loaf-pan version of the Blob from X-Men. We could actually hear the garbage disposal chewing as it worked on this. For five minutes.

After that experience, we’re officially declaring a one week moratorium on manly pride. If you see a guy washing his colors and whites together, or microwaving Hot Pockets and calling it “dinner,” he is totally fair game for mockery. You have our permission.

So, another trip to the grocery store, returning with a pre-made angel food loaf cake (day old, for extra durability)…which, we’ll note, would have been cheaper than buying the mix in the first place…and we can proceed…

Both cakes were carved into suitably-sized segments and arranged on the acrylic base/template. To help keep the angel food segments spotless and clean of frosting, we pre-frosted the top of the chocolate cake before carving it up, and would touch up the seams after the fact. Had to get creative with the last few rectangles of chocolate cake, but frosting hides all sins. The angel food cake should have been trimmed a bit thinner to match the height of the chocolate cake, but we were getting hungry after the whole emasculating fiasco and just wanted to see if this thing would work or not.

A quick test with the cake atop the LED pedestal showed a problem: the white cake picked up all diffuse light in the room, entirely washing out the backlighting. But we’d seen this problem before…of all things, a SparkFun capacitance meter kit, which suffers the same issue where its red LED segments are washed out by the white diffusers in a bright room. The fix there is to add a piece of smoked acrylic atop the display. So we applied a similar principle here, but wanting to keep everything edible we used fruit roll-ups instead of acrylic. Reflecting on it now, fruit jelly would have tasted better and would slice well with the rest of the cake.

The fruity fix didn’t address the problem completely, and it was still necessary to operate the cake in near-darkness for best effect, which may or may not be a problem since programmers normally thrive in low-light conditions. The photo above shows how the number “6” looks under normal room lighting…washed out and nearly indistinguishable from the full “8”. Using brighter, more directional LEDs (but still using the fruit topping) would probably help with this…BlinkMs or ShiftBrites or their higher-lumen equivalents. Not too much though, or you’ll go all Easy Bake Oven on it.

Here’s a video of the completed countdown cake in action:

So the idea does…kind of…work. Would we try it again? Probably not. It was a fun idea to mess around with – a hack – and any day you get to eat cake and call it your job is a good day indeed, but the effect ultimately wasn’t worth the effort. Like the original article, we hope this one can be filed under “heroic failure.” It’s progress though, and might give someone food for thought. Maybe third time’s the charm.

A closing thought is that this could be combined with a Wave Shield or the chipKIT digital audio technique from a prior article to play the Happy Birthday song, creating a cake that’s both fattening and incredibly annoying!

Finally, here’s the Arduino sketch that drives the LED display:

// 7-segment LED Cake Sketch for Arduino.
// Uses Cool Neon's "Total Control Lighting"
// addressible LEDs.  Data issued on Arduino
// digital pin 11, clock on pin 13.

#include <SPI.h>

// 7-segment bitmask for each digit.
// Bit-to-segment mapping is as follows:
//     1
//   2   0
//     6
//   3   5
//     4
// This corresponds to the order in which LEDs
// are mounted in the physical template.
byte segmask[] = {
  B0111111, B0100001, B1011011, // 0 - 2
  B1110011, B1100101, B1110110, // 3 - 5
  B1111110, B0100011, B1111111, // 6 - 8
  B1110111, B1111010,           // 9, ersatz 10
  B0100001, B0110000, B0011000, // Spinny thing
  B0001100, B0000110, B0000011
};

#define N_PIXELS  25
#define GAMMA    2.4
byte gamma[256];

void sendPixel(byte r, byte g, byte b)
{
  SPI.transfer(~((r >> 6)              |
                ((g >> 4) & B00001100) |
                ((b >> 2) & B00110000)));
  SPI.transfer(b);
  SPI.transfer(g);
  SPI.transfer(r);
}

void sendLatch()
{
  for(byte i = 0; i < 4; i++) SPI.transfer(0);
}

void setup()
{
  int i;

  // Initialize SPI communication:
  SPI.begin();
  // The following 3 lines can normally be
  // left out - Arduino's default SPI config
  // appears to be MSB, Mode 0 and runs at
  // 4 MHz (instead of 8 as is done here,
  // but still plenty quick).  But for
  // posterity, here's the full config:
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE0);
  SPI.setClockDivider(SPI_CLOCK_DIV2); // 8 MHz

  sendLatch(); // Wake up!

  // Set all pixels to initial "off" state:
  for(i = 0; i < N_PIXELS; i++) sendPixel(0, 0, 0);
  sendLatch();

  // Calculate gamma correction table.
  // Provides a perceptually more linear
  // fade between brightness levels.
  for(i = 0; i < 256; i++) {
    gamma[i] = (byte)(255.0 *
      pow((float)i / 255.0, GAMMA));
  }
}

byte digit = 10,
     prev  = 10;

void loop() {
  byte i, bit, x;
  int  fade;

  // Fade from previous to current digit:
  for(fade = 0;fade < 256; fade++ ) {

    // For each of 7 segments:
    for(bit = 0x01; bit < 0x80; bit <<= 1) {

      x = 0; // Assume segment is off by default
      if(segmask[digit] & bit) { // On, or fading on
        x = (segmask[prev] & bit) ? 255 : gamma[fade];
      } else if(segmask[prev] & bit) { // Fading off
        x = gamma[255 - fade];
      }

      // 3 LED "pixels" per segment
      for(i = 0; i < 3; i++) sendPixel(x, x, x);
    }

    // Last 4 pixels are unused and stay off
    for(i = 0; i < 4; i++) sendPixel(0, 0, 0);

    sendLatch(); // Update LEDs
    delay(1);    // ~1000 updates/sec
  }

  // Hold last image for remainder of ~1 sec.
  delay(1000 - 256);

  if(digit > 0) { // Still counting down
    prev = digit;
    digit--;
  } else { // Done counting, reset...
    // But show spinny animation first
    for(int n = 0; n < 5; n++) {
      for(digit = 11; digit <= 16; digit++) {
        for(bit = 0x01; bit < 0x80; bit <<= 1) {
          x = (segmask[digit] & bit) ? 255 : 0;
          for(i = 0; i < 3; i++) sendPixel(x, x, x);
        }
        for(i = 0; i < 4; i++) sendPixel(0, 0, 0);
        sendLatch();
        delay(100);
      }
    }
    digit = prev = 10;
  }
}

A couple of notes on using the Total Control Lighting LEDs:

• Red wire = +5V. White = data (Arduino pin 11). Green = clock (Arduino pin 13). Blue = ground.
• The datasheet suggests issuing 32 consecutive zero bits to mark the start of a full frame of data, but we’d sometimes see a stray first or last pixel on the initial image. A more reliable approach has been to issue the 32 zeros at the program’s start, then after each full frame. Rock steady.

[Alex] has reduced the resolution of his timepiece as a trade-off for speedy-readability. At least that’s what he claims when describing his color-changing clock. It uses a ShiftBrite to slowly alter the hue of the clock based on the current time. The concept is interesting: 12:00 starts off at white and slowly fades to green at 3:00, blue at 6:00, red at 9:00, and back to white by 12:00 to start the process over again. He has gotten to the point where he can get the time within about 15 minutes just with a quick look. But he did need to spend a few days acquiring the skill by having the color clock sit next to a traditional digital clock.

The build is pretty simple and we’d bet you already have what you need to make your own. [Alex] is really just proving a concept by using the ShiftBrite and an mBed, there’s no precision RTC involved here. So grab your microcontroller of choice, and an RGB LED of your own and see if you can’t recreate his build.

Of course you could always choose to build a color-based timepiece that’s even harder to read.

[yergacheffe] was able to get his hands on a shiny new Google ADK board about a week before it was announced at I/O, and got busy putting together a neat project to show off some of the ADK’s features. His idea was to meld together the ADK and Google’s new music service, two items he says complement each other very well.

He had a handful of LED matrices left over from last year’s Maker Faire, which he decided to use as a Google music metadata display. The base of the display is made from laser-cut acrylic, with a few spare ShiftBrites lighting up the Google music beta logo.

He says it took literally just a couple lines of code to get his Android handset to talk with the display – a testament to just how easy it is to use the ADK.

Pretty much anyone can walk up, attach their phone, and see their current music track on the display with zero fuss, which you can see in the video demo below.

[Andrew & Deborah O'Malley] were tapped to created an interactive exhibit. The mission was to show that social problems take continual support from a lot of people before they can be solved. The piece needed to be architectural in nature, and they ended up building this touch-sensitive model building with individually lighted windows.

The project log that the [O'Malleys] posted shows a well executed battle plan. They used tools we’re all familiar with to achieve a highly polished and pleasing result. The planning stages involved a virtual mock-up using Google SketchUp. The details needed to order the shell from a fabricator were pulled from this early work, while the team set their sights on the electronics that shed light and that make the piece interactive. The former is provided by a Shiftbrite module for each window, the latter comes from the Capacitive Sensing Library for Arduino. Despite some difficulty in tuning the capacitive grid, and getting all of those Shiftbrites to talk to each other, the exhibit went swimmingly. It’s not hard to imagine how easy it is to start a conversation once attendees are attracted by the seductive powers of touch sensitive blinky lights.

Control your tiny inexpensive helicopter with a Nokia N900. The chopper uses an infrared remote control, just like a television. Getting this to work was just a matter of figuring out the IR commands and writing an app for the phone to spit them out.

Fade to black; inconspicuously

Lost interest in your TV-B-Gone? Give it one last whirl by throwing it inside of an old iPod case. The dock connector hole is just about the right size for the LEDs and the kit fits nicely in the old 3G type iPods. With this kind of disguise it should be a lot harder to spot who’s messing with those TVs.

Surf your way to a cleaner house

This guy uses a roomba to clean his floors. The Wii balance board lets him lean forward and back to surf the little bot around the room. This seems a little more exciting than the exercise programs the board was originally designed for. [Thanks DXR]

G1 gamepad

[Tobias Weber] built a gamepad for the G1 Android phone. He used an old Atari control, cut out two buttons and the d-pad, and glued them in a housing to fit the G1 keyboard. Each presses a button on the phone’s keyboard which can be mapped through the emulator software.

Social power monitoring

Here you see a very small portion of the power meter installed in a Cafe at UC Berkeley. It shows the energy usage for the building, separated into categories such as lights, power outlets, and coffee machines. This lets students know how much juice they’re draining by plugging in their gadgets. The color bar uses 93 ShiftBrite modules controlled by an Arduino.

Here’s a project we’ve been wanting to do for a while. Over at macetech.com they’ve posted an LED coffee table that uses a 9×9 RGB LED grid. For the LEDs, they used the shiftbrite modules we’ve seen before. The table is capable of displaying pre written patterns as well as accepting patterns from a computer via bluetooth. They’ve set it up to connect to a twitter feed and display to a live cam on their site. Though we would love to reproduce this, we need a little more justification than “ooooh, shiny”  for the funds involved. Anyone want to donate 100 shiftbrights?

[Garret] and a couple of friends totally stole our idea wanted to light up their pumpkins a bit differently this year. They used some ShiftBrites and all the corresponding shift hardware (who knew there was so much shift out there) to bring their carved orange minions to life. Yes, this could be done a lot less modulated by using a regular LED and perhaps a PIC. Maybe it’s not the most technically challenging, but hey its in the spirit of Halloween – one of our favorite holidays. Speaking of which, doesn’t that fence look familiar? Check out a video after the break. Seriously, Mutton Chops?

[Steven] was inspired by the BlinkM and Shiftbrite modules, but really wanted something that could be controlled via RS232. He decided to build his own RGB LED module capable of PWM that fit his needs. He’s using a PIC16F628 microcontroller as the base. Each module has 4 individually addressable LEDs with multiple intensities for each color. The units can be daisy chained as well. The schematics and PCB files are available on his site for download.

[via Hacked Gadgets]

Macetech’s ShiftBrite is a high-power RGB LED coupled with an Allegro A6281 backpack. The A6281 uses three 10bit pulse-width modulators to mix millions of colors using the red, green, and blue elements in the RGB LED. Multiple modules can be chained together for bigger projects, like the ShiftBrite table.

Below the break we demonstrate a ShiftBrite module using the Bus Pirate. For a limited time you can get your own Bus Pirate, fully assembled and shipped worldwide, for only $30.

ShiftBrite RGB LED module (Macetech, $4.99). ShiftBrite datasheet and example code, Allegro A6281 datasheet (PDF).

The ShiftBrite module is a complete A6281 development board. It doesn’t require any extra parts, just a 5-9volt supply.

The A6281 is one of the most complete RGB LED driver ICs, but it’s only made in a tiny QFN package. The ShiftBrite is a good way to try the A6281 without soldering a small chip.

A bunch of A6281 modules can be chained together. Each module repeats all of the serial input signals on separate output pins, so the A6281 will work over long cable runs.

We used our Bus Pirate universal serial interface to demonstrate the ShiftBrite, but the command sequences will be the same for any microcontroller. We connected the Bus Pirate to the ShiftBrite as shown in the table above.

We setup the Bus Pirate for raw3wire mode (M, 8), and chose open drain outputs (Hi-Z) so we can interface the ShiftBrite at 5volts. The Bus Pirate can’t output 5volts directly, so we enabled the bus pull-up resistors (menu ‘p’ in v2) and attached the pull-up resistor voltage input pin to the 5volt supply. Finally, we enabled the on-board power supply (capital ‘W’).

Interfacing

The LED driver output is only active when the enable pin (EI) is held low.

RAW3WIRE>A <– capital ‘A’, EI pin high, output disabled
AUX HIGH
RAW3WIRE>a <– small ‘a’, EI pin low, output active
AUX LOW
RAW3WIRE>

We used the Bus Pirate’s auxiliary pin to toggle the A6281′s enable pin, but you could also bypass this feature by wiring EI directly to ground. A small ‘a’ in the Bus Pirate terminal takes the AUX/EI pin connection low, enabling the LED output.

Two commands update the A6281 settings. The configuration command controls dot correction and clock settings. The LED pulse-width modulator (PWM) command updates the three 10bit values that set the red, green, and blue channel brightness. Both commands are 32 bits (4 bytes) long, bit 30 selects the configuration or pulse-width modulator command. Refer to the chart above, or datasheet page 7.

The interface protocol is like SPI, but the master-input-slave-output pin is unused. Data is sent most significant bit first, starting with bit 31. Commands are sent by clocking 32 bits into the chip and then toggling the latch pin.

Before we can start mixing colors, we need to setup the A628a’s internal clock and write the dot correction values.

RAW3WIRE>0b01000111 0b11110001 0b11111100 0b01111111 ][
WRITE: 0x47 <--write 32bits of data
WRITE: 0xF1
WRITE: 0xFC
WRITE: 0x7F
CS DISABLED <--latch pin high
CS ENABLED <--latch pin low
RAW3WIRE>

We wrote the values in binary so it's easy to follow along in the table above. Remember that bit 31 is sent first, so the order of bits shown here is opposite of what is shown in the table.

The complete setup command is 32 bits (4 bytes) long. Bit 30 sets this as a configuration command (1). Bit 7 and 8 configure the clock source, value 00 configures the 800KHz internal oscillator (datasheet page 7). Three 7bit 'dot correction' values fine tune the LED color channels if you want to correct a wonky pixel in a large array (see the register locations in the table above). We set all the dot correction values to full (1111111). Several bits trigger test functions or don't have a purpose, these should be entered as 0.

After entering 32 bits, toggle the A6281 latch pin (][) to lock the data into the register. Now that the chip is configured and the output enabled, we can finally play with the LED.

RAW3WIRE>0b00111111 0b11111111 0b11111111 0b11111111 ][
WRITE: 0x3F
WRITE: 0xFF
WRITE: 0xFF
WRITE: 0xFF
CS DISABLED
CS ENABLED
RAW3WIRE>

First, turn all the colors to full. Bit 31 (0) is ignored, bit 30 (0) indicates a LED pulse-width modulator update command, and the remaining bits set all three channels to 100%.  The three PWM values control the output intensity of each color as follows: blue (bits 29:20), red (bits 19:10), and green (bits 9:0). Raise and lower the latch pin (][) to end the command.

Next, test each each color individually.

RAW3WIRE>0b00111111 0b11110000 0b00000000 0b00000000 ][
WRITE: 0x3F
WRITE: 0xF0
WRITE: 0x00
WRITE: 0x00
CS DISABLED
CS ENABLED
RAW3WIRE>

Bit 30 (0) signals an LED PWM update command, followed by a 100% setting for the blue channel (1111111111) and 0% settings for the red and green channels. When we toggle the latch pin (][) the new values are saved and the LED color changes to blue.

RAW3WIRE>0b00000000 0b00001111 0b11111100 0b00000000 ][
WRITE: 0x00
WRITE: 0x0F
WRITE: 0xFC
WRITE: 0x00
CS DISABLED
CS ENABLED
RAW3WIRE>

This time we'll set the LED to 100% red. Bit 30 (0) signals an LED PWM update command, followed by a 0% setting for the blue channel, a 100% setting for the red channel (1111111111), and a 0% setting for green.  When we toggle the latch pin (][) the LED color changes to red.

RAW3WIRE>0b00000000 0b00000000 0b00000011 0b11111111 ][
WRITE: 0x00
WRITE: 0x00
WRITE: 0x03
WRITE: 0xFF
CS DISABLED
CS ENABLED
RAW3WIRE>

Finally, we set the LED to 100% green. Bit 30 signals an LED PWM update, followed by 0% settings for the blue and red channels, and a 100% setting for the green channel (1111111111).  Toggle the latch pin (][) and the LED color changes to green.

Like this post? Check out the parts posts you may have missed. Want to request a part post? Please leave your suggestions in the comments.

Hack a Day review disclosure: Macetech gave us a couple free ShiftBrites at Maker Faire 2008.

[Garrett] took 30 of his ShiftBrite modules and mounted them to his front fence for Christmas. The ShiftBrite is a serially addressable high output RGB LED. The individual modules are quite adept at applications like this where you’re stringing multiple lights together. They have identical buses on either side, specifically for daisychaining. The installation above looks great.

You may remember [Eric] for building the IKEA MAME table and the TRS-80 wireless terminal.

[photo: skenmy]

UPDATE: [Garrett] of macetech is putting the finishing touches on his version which uses 32 ShiftBrite modules and 2 4-digit displays controlled by a CuBLOC.

While checking out Evil Mad Scientist Laboratories‘ latest generation CandyFab were given their AVR business card breakout board.

[Garrett] gave us a handful of ShiftBrites to play with in a future project.

We donated to the EFF, as we’re wont to do, and received a super bright blue flashlight for spotting the yellow tracking dots on color laser printouts. If you’re not familiar with this topic, you should check out bunnie’s blue light scanner.

Our final stop was at ifixit to pick up a free set of spatulas (spudgers?) for popping open iPods. All around a decent haul.