Evil Mad Scientist Laboratories

TGIMBOEJ: One year later

Wed, 01 Jul 2009 05:15:01 -0700

One of the big projects that we launched in 2008 is The Great Internet Migratory Box Of Electronics Junk, a pay-it-forward style hardware sharing program for electronics.

Since our original article, TGIMBOEJ (pronounced Tig-Ihm-Boh-Edge) has somewhat taken on a life of its own. In that article, we set up simple guidelines for how to pass the box along, and in the interim we have taken a "laissez-faire" approach, watching and learning from the successes and troubles with that model.

Our mostly-hands-off approach to supervising TGIMBOEJ has worked remarkably well in some respects. There are upwards of 40 circulating boxes now, which have passed through hundreds of hands. And, hundreds of other people have signed up on our wiki site tgimboej.org as potential recipients.

On the down side, the mean free path of many of the boxes has been far too short-- some have made it just one hop before stopping.

In talking to folks about the boxes that got stuck, we identified three main stories (all of which point us towards fairly obvious solutions):

1: "I sent it to some guy, but I haven't heard anything since then."
2: "Oh yeah-- I've been meaning to ship it for some time."
3: "I got this box and I don't know what to do with it."

So now, it's time to get serious. First, we've been contacting the last known recipients of the stalled boxes, and trying to get more of the existing boxes back into circulation. Second, we're relaunching the tgimboej.org wiki site with a wholly new set of participation instructions and procedures.

To keep boxes in circulation longer, we're now encouraging that boxes should be sent to people who have specifically requested to participate-- i.e., people who are familiar with how the project works. We've also introduced language in the revised instructions that will guide participants to keep an eye on their box, even after it leaves their hands.

To further alleviate the potential problem of people ending up with boxes but not knowing what to do with them, we're standardizing the printed materials that go into each new box.

Gone are the cute but scrawled little notebooks, replaced by two neat PDF forms-- one to log the progress of the box, and the other with detailed instructions on how to participate.

Finally, we're launching (at least) three new TGIMBOEJ boxes this week, which -- along with the others that are coming back into circulation -- will help to increase the number and rate of box exchanges.

So now it's your turn. If you would enjoy trading electronics with like-minded individuals, this is becoming a great time to participate in The Great Internet Migratory Box Of Electronics Junk.

To get started, please read about how it works on the TGIMBOEJ wiki, and if you're game, add your name to the list of Box Requests.

Precision in packaging

Mon, 29 Jun 2009 13:52:33 -0700

Sichuan peppercorns, oh yeah! Raven of Made with Molecules after eating them wrote, "There's a war in my mouth." They create a riot of numbing and tingling sensations, particularly if you can get relatively fresh ones (i.e. not stale from sitting around in a Whole Foods bulk bin). Raven links to an abstract about the particular anesthetic-sensitive potassium channels inhibited by hydroxy-alpha-sanshool, one of the components of sichuan peppercorns that make them so exciting.

Science aside, we recently found some in a local asian grocery store, and were particularly struck by the packaging. American packaging often has annoying disclaimers about how contents are packed by weight and may have settled. These peppercorns were not only weighed, but the precision of the scale is indicated! If only all packaging was so straightforward. I was going to complain that the package doesn't say what kind of peppercorns were inside (sichuan peppercorns are not related to other peppercorns) but then realized that the Chinese characters are specific to these "flower peppers" even if the English words are more general. In any case, the reddish husks are recognizable through the bag.

Meggy Jr RGB Twitter Reader

Wed, 24 Jun 2009 05:24:54 -0700

We've turned Meggy Jr RGB into a multicolor scrolling LED twitter reader. It's a handy external ambient data device that displays things recently written by your friends on twitter.

This project was inspired in part by the excellent Twitter LED Scroller by David Nichols. The big idea is that we use a host computer to run a Processing application, which periodically checks Twitter for updates, and then sends "scrolling" data, one column at time, to the external LED display.

In this video (embedded above), we start out scrolling slowly and then advance to a faster rate by pressing buttons on the arrow keys on the laptop's keyboard-- interesting that you can still read it when it's much faster, but it does take a moment to adjust to the faster speed. (We've posted a second video as well, that's a little more "ambient.")

As we have it configured here, the Meggy Jr scrolls through the 5 most recent tweets of folks that we follow, and then repeats. Between repeat cycles, if enough time has elapsed, it also checks to see if there are new updates. The history length (number of tweets to repeat) and time delay are adjustable, subject to Twitter query rate limits.

The physical setup is pretty straightforward-- we hook up the Meggy Jr RGB to the computer with a USB-TTL cable. That's the normal configuration for serial programming and serial communication. If you plan to run for an extended period of time, it would be a good idea to hook up the Meggy Jr to external DC power.

The software for this project is released under the GPL. You can download it here (31 kB .ZIP file)The ZIP file consists of two parts, an Arduino sketch (that should be installed on the Meggy Jr RGB) and a Processing sketch (that runs on the host computer).

To try it out, download the code, install the Arduino sketch on the Meggy Jr RGB. Then configure and run the Processing sketch-- several variables (user name, serial port, etc) need to be set before it can work.

There's obviously a lot of potential for this sort of thing-- the Meggy Jr can be mounted to the front of the computer and used to display almost anything, and the same thing could be done wirelessly through various means. Also interesting would be to use the Meggy Jr for other types of Twitter applications-- displaying real-time search results, or monitoring a particular account for a particular event. Given the number of twittering devices out there, one could imagine a Meggy Jr RGB following the household plants, power usage, or cats and giving audible and visual alarms when certain conditions were met. It's a simple matter of continuing to close the loop of social networking for embedded devices.

Acknowledgements & code sources

Big API's, lots of code. As we said, this project was inspired by the Twitter LED Scroller by David Nichols, and part of the code design comes from that project. It uses the Twitter4j libraryand SimpleML library, as well as code from the Processing and Arduino serial communication examples by Tom Igoe. This discussion on the Processing forums was very helpful in showing how to put these parts together. The pixel font that we used is Liquid Mean.

The code that runs on the Meggy Jr itself was not modified much for this project; it's a combination of the text scrolling and serial-receiving example programs, documented as part of our Meggy Jr RGB library for Arduino.

Evil Mad Scientist Laboratories: Year 3

Sun, 21 Jun 2009 14:01:14 -0700

Happy birthday to us! Evil Mad Scientist Laboratories is now three years old.

To celebrate, we're rounding up our most interesting projects from this past year.

Quick projects and observations:

17 cool magnet tricks

The monetary density of things

Cheap Perpetual Calendar

Contact Lens Case Small Parts Tray

Simple LED Projects:

Quick, easy, temporary, and beautiful LED garden lights

RoboGames Awards

LED Ghosties for Halloween

Food Hacking:

The Hungry Scientist Handbook

South Indian Restaurant Menu Decoder

"That's no melon!"

Hot Dog Bun Grilling Jig

Improved Custom Message Hearts

Now that's an Apple Pie!

Eyeball Caprese

Fractal Snowflake Cupcakes

CandyFab

The CandyFab 6000

Papercraft

Cardboard Cat Chaise

Edge-Lit Holiday Cards

Hexagonal Stacking Boxes

Making a Frabjous

Electronics Projects

Interactive LED Dining Table Circuit

Giant seven segment displays

Dark detecting jack-o'-lantern

Simple Solar Circuits

Soft Circuit Merit Badge

Kit Projects

Meggy Jr RGB

Video Peggy in action

Peggy 2 RGB

ATtiny2313 breakout boards

Revised ATmegaXX8 boards

Crafty Projects

DIY d12 Handbag (of Holding)

Meggy Cozy

No-sew iPhone Cozy

Fabric Klein Bottle

Reupholstery with Used Denim

Missile Command Circle Skirt

Fishbowl Cat Quilt

Turning Mollie into Maulie

Bicycle Frame Lunch Bag

Sinusoidal Bracelet Design

Microcontroller Projects

Tennis for Two, a video game from 1958

Scariest Jack-o'-Lantern of 2008

70 bits of gaming goodness

AVR Serial Communication

POV Lissajous figures

Single sided circuit board

A Bulbdial Clock

Geek Design

Vector Snowflake Application

(Whew!)

Linkdump: June 2009

Thu, 18 Jun 2009 04:08:28 -0700

This C-17 is actually quite impressive.
DIY Spider Catcher.
Warping text to splines
6174 is an interesting number. And so is 1729. In fact, some people claim that there is no such thing as an uninteresting number.
Rat or mouse?
Compact Marble Run, made in four hours.
Math Midway traveling exhibit.
Big switch lamp.
Some thoughts on edible lasers.
Hello Kthulhu.
Had not heard of Haidinger's Brush. Have you?
We want superconducting maglev train sets. Now.
Cloud wakes and vortices are visible from space. Did you know that an island can shed vortices in its wake?
Crocodile locomotion.

Making a Frabjous

Wed, 17 Jun 2009 09:59:28 -0700

George W. Hart is a professor at Stony Brook and is one of our favorite artists, making a wide variety of stunning geometric sculptures. On his of his many works that has particularly captivated us for some time is a sculpture called Frabjous.

When we realized that George had posted a template for this sculpture we dropped everything, grabbed the cardboard and hot glue, and raced to build our own.

You'll need papercraft type building materials: Paper, cardstock, or cardboard, and tape or glue. Also good scissors and/or a hobby knife with sharp blades. You can also build this with wood, plastic, or other materials, of course, but cardstock and cardboard are inexpensive and effective. Hot glue also proved to be excellent, providing sufficient strength and flexibility, and good working time.

You can download the PDF template for Frabjous on its web page.

The sculpture is made out of 30 identical pieces, with this S-curve shape. (We'll look at the reason for the shape a little later.) The design is scaleable: print out the template at the size that you would like to make it. Larger means more time cutting but it might be easier to assemble.

Cut out your template at your scale of choice. You can directly make 30 of those as a paper model or trace and cut out the model, like we did in cardboard.

You need 30 pieces so this can *ahem* take a while. The good news is that the sculpture will still work even if your pieces are banged up, have lost some stiffness, or have occasional mistakes.

Big hint for cardboard: replace your blade often. (Here is where we get ours.)

Once you have all the pieces, then comes the challenging part, putting it all together.

The first hint about construction is to look at the corners. Every intersection between the pieces is attached the same way: the flat ends are glued together, in a symmetrical arrangement. Unfortunately, this only gets you so far, and constructing the rest from that principle is a true puzzle indeed. To understand which pieces should go where, it's helpful to look at the design from a geometric standpoint.

The parent shape donating its symmetry is a simple dodecahedron.

Within that shape we inscribe a line segment between two vertices: this is where our "puzzle pieces" will go-- each will go where a line segment is and connect two vertices of the dodecahedron.

Each vertex of the dodecahedron is also a vertex of three bordering pentagons. To draw a line segment, pick one of those three pentagons, and connect the vertex to the corresponding opposite vertex of the neighboring pentagon as shown. This is probably the single most important thing for understanding how the sculpture goes together-- that each piece fits in that relation to the overall shape.

Now, we've only drawn segment coming out from that top vertex, but obviously there are three such possible segments because there are three pentagons that touch there. This intersection of three "puzzle pieces" at the corners is exactly what we saw in the completed sculpture, where three pieces get glued together at each intersection.

Now what happens when we start drawing the segments coming out of more than one vertex?

Here we've drawn one segment originating at each vertex of the top face. Unfortunately, this shows that our model-- connecting vertex pairs as we have, with simple segments-- leads to a problem. All five of these puzzle pieces would intersect.

The solution is to "bend" the segments to avoid the intersection:

Here's a corrected curvy "segment" that will hopefully avoid bumping into others as we start to add more to our sculpture.

Yes-- looks like we're now avoiding intersection.

Taking a look at the model from the top, we can also now begin to see the "vortex" shapes from the original sculpture start to appear.

Adding the rest of the curves, between every relevant vertex pair, the sculpture emerges. In particular, note that we can now see the three pieces that come together at each vertex of the dodecahedron.

Without the framing dodecahedron, the shape looks more mysterious once again.

We have the geometry now, but we still need to replace our curves with flat shapes to begin to approximate the appearance of Frabjous.

It's a slightly crude drawing, but it might be helpful in seeing how the real-world version fits together.

You can see more pictures and renderings of this sculpture in this flickr photo set.

Basics: Serial communication with AVR microcontrollers

Wed, 10 Jun 2009 18:17:32 -0700

One of the distinguishing characteristics of beginner-friendly microcontroller platforms-- Arduino, PICAXE, and a few dozen others-- is that they neatly wrap up and hide the nuts-and-bolts details of interfacing with the hardware.

Like everything else, it's a blessing and a curse. The benefits are clear: A new user who has just acquired an Arduino can plug it in, blink an LED, and have a working demonstration of two-way serial communication in just a few minutes.

The drawbacks are a little harder to see. When you just use one line of initialization that calls a "library," it's easy to overlook exactly what's involved: how many lines of code have invisibly been added to your program? What memory structures have been allocated? What interrupts are now going to disrupt program flow and timing? There's also a portability issue. We often hear from people who got started with Arduino but now want to explore other AVR microcontroller systems, and don't know how or where to start the migration process.

In what follows we discuss a minimal setup for serial communication with AVR microcontrollers, and give two example implementations, on an ATmega168 and on an ATtiny2313. While this fundamental "AVR 101" stuff, we're approaching the problem (this time) from the migration standpoint. Suppose that you had an Arduino based project, where you relied on serial communication-- using the library functions--between that hardware and your computer. From there, how would you migrate to a stand-alone AVR microcontroller with similar functionality, or even to a different microcontroller?

The answers, of course, are (1) that you have to hook things up correctly and (2) it's nice to have some simple and lightweight set of routines as a good starting point.

To begin with, we need a good working cross-platform example of two-way communication between the host computer and the Arduino. We chose as the starting point the Processing sketch (example program) "Serial Call-Response" by Tom Igoe. This is actually a two-part program, where one half runs on your computer and the other half on the microcontroller. What we're doing is to create a functional clone of the microcontroller program, that can still talk to the host-side program (which is still running in Processing on your computer).

Let's look at the chips:

We've drawn the ATmega168 and ATtiny2313 here, with the pinouts for power supply and the serial port transmitter (TX) and receiver (RX) pins highlighted. These are some but (probably) not all of the pins that you'll need. For example, if you want to program the AVR in circuit, it's often best to do that with an ISP programmer, and our article aboutminimal target boards explains how to hook one up.

Back to the serial ports. If you look in the datasheets for these chips, you'll find each serial port labeled as a "USART," for Universal Synchronous and Asynchronous serial Receiver and Transmitter. Now, the microcontroller USART pins are designed to operate at logic levels-- between 0 and 3-5 V. This means that they can't directly hook up to RS-232 without a level adaptor. They also aren't set up for directly hooking to USB, so an adapter of some sort is usually needed unless you're talking directly to another microcontroller.

Our adapter of choice is the FTDI USB-TTL cable:

This cable has an integrated circuit built in that translates between a microcontroller's serial port (USART) and USB. (That's in fact the same chip that the Arduino has on board for the same reason.)

Here's how to hook it up to one of the microcontrollers:

Three pins on the connector are relevant for us: TX, RX, and ground. (Ground so that your computer and microcontroller board have a common voltage reference.) The TX (transmit) pin of your microcontroller goes to the RX (receive) pin of the cable/computer, and vice versa.

In practice you can do this with a 5 pin header with two teeth cut out, where the fifth pin is connected to ground. This can be done on a target board like we've done here or on a breadboard-- it's a quick way to hook things up without laying out a special board just for the serial port. The serial port pins on the '2313 (above) and '168 (below) are in the same place, so you can hook this up identically on either board.

Now that we have the physical connections ready, we need the software. You can download our example code for the ATmega168 ishere (5 kB .ZIP file), and the code example for the ATtiny2313 is here (5 kB .ZIP file).

Both source code examples contain a C source file and a makefile; they can be compiled and loaded onto the microcontrollers from AVR-GCC or compatible systems; if you've never put code onto an AVR before, you might find our list ofResources for getting started with AVRs helpful.

The source code is meant to be a minimal implementation of bidirectional communication that can talk to the "Serial Call-Response" sketch. The two implementations, for the two different chips, are mostly identical.

We begin by setting several pins to be outputs, using the "data direction registers" defined in the datasheet. The only one of these that's actually important is pin D1, the TX pin, on each board. We also have a place to put an indicator LED on each board, and a few other outputs for optional debugging.

The baud rate is implemented using a non-obvious but relatively compact scheme taken from the datasheet. It takes as inputs the CPU rate and the desired baud rate. The CPU clock frequency is 16 MHz from an external crystal oscillator on the '168 example and 8 MHz from the internal RC oscillator on the '2313 example. (If desired those can be changed with the fuse settings. You know about the AVR fuse calculator, right?)

Communication is implemented through four serial functions: serialCheckRxComplete (which checks whether there is serial data ready to read), serialCheckTxReady (which checks if the serial port is ready to transmit new data), serialRead (which reads a byte of data from the serial port), and serialWrite (which transmits one byte from the serial port).

These functions work directly with the hardware; buffering and interrupts are not implemented. This makes the program lean and mean, with a tiny footprint. Working without interrupts and buffers means that you need to poll (i.e., check for new incoming data) at least as often as new data could appear-- e.g., about 1 kHz or faster for 9600 baud. It also means that incoming serial data will never interrupt time-critical functions that are executing. And the memory footprint is much, much lower. This takes mere bytes of RAM to implement-- making it quite practical on the ATtiny2313 which only has 128 bytes of RAM. (For comparison: the Arduino serial library usually allocates 128 bytes of RAM as a RX buffer alone.)

So, there are tradeoffs-- but these lightweight functions work well enough, and should provide another helpful stepping stoneto AVR, from either above or below.

RoboGames Awards

Sat, 06 Jun 2009 00:30:45 -0700

We've been helping out RoboGames with getting the award designs ready for next weekend. We just got the final prototypes done and handed over for production and we're loving how they turned out! The awesome official artwork by Doctor Popular (below) features prominently on the medals, lit by throwie-style LEDs hidden between layers of acrylic. You want one of these around your neck, don't you?

The event runs Friday-Sunday, June 12-14 at Fort Mason in San Francisco. Get your tickets now!

We'll be bringing CandyFab to show off and lots of kits and pretty LEDs for sale. We hope to see lots of you there next weekend!

Fabbing at Maker Faire

Fri, 05 Jun 2009 11:40:15 -0700

CandyFab managed to infiltrate a couple of the other 3D printing projects at Maker Faire this past weekend. That's me above, at the MakerBot booth, in my brand-new MakerBot shirt, explaining MakerBot to some Maker Faire visitors. Below, Kenji's Fab at Home sports a brand new CandyFab vinyl racing sticker. CandyFab itself performed like a champ, printing candy and raising blood sugar levels all weekend while we talked shop with all the other fabbers.