New BlinkMSequencer Features

ThingM’s Multitrack BlinkMSequencer has been updated to work with both LinkM and with Arduino running the BlinkMCommunicator sketch.


New Features and improvements include:

  • LinkM and Arduino connectivity support

    Previously, you used the new Multitrack Sequencer if you had a LinkM and the older single-track sequencer if you had an Arduino. Now the Multitrack Sequencer has Arduino connectivity suppport.

    To use:

    • Load the BlinkMCommunicator sketch onto your Arduino
    • Unplug the Arduino, plug in your BlinkM, plug back in the Arduino
    • Choose the “Connect to Arduino” item in the File menu
  • Gradient creator

    It’s now easy to create smooth gradients between color cells. To create a gradient, make a selection starting at your preferred start color and ending on your preferred ending color. Then choose “Make Gradient” from the Edit menu.

  • Set BlinkM to use ROM scripts like “Virtual Candle” and “SOS”

    BlinkM has 18 built-in ROM light scripts. A BlinkM can be told to play these on startup instead of a programmable script. Now you can easily select one of these scripts to run.

  • Change I2C address of BlinkMs

    In order to make best use of the multitrack aspect of the sequencer, you need to assign each BlinkM its own I2C address. The previous way of doing this was with “BlinkMTester” Arduino sketch in the BlinkM_examples bundle. Now you can do it from within the sequencer.

  • Copy-paste colors within a track

    The cut/copy/paste commands work to let you copy sections of tracks. This is really handy to create repeating color sequences. The left/right arrow keys can help position the paste point to make quick work of filling up an entire track.

  • Fixed colorchooser same-color-twice bug

    One of the biggest pet peeves we’ve had with the standard Java ColorChooser we use in the sequencer is the fact you couldn’t select the same color twice in a row. There is now a modification to the ColorChooser to allow you to do this.

  • Tooltips on colors in a sequencer

    When hovering over a color slot in the sequencer, you now get a tooltip showing the decimal RGB value.

  • Visual indication of connectedness

    The “Upload to BlinkM” and “Download from BlinkM” buttons now reflect if you are currently connected to a LinkM or Arduino by being disabled or enabled.

Autumn Lantern with BlinkM

Lantern in Daylight

It’s getting a little chillier in Southern California, but as an East Coast transplant I miss watching leaves change color.  Using a BlinkM has been a great chance for me to bring fall color into my life in the form of a Lantern.  When using a regular, tea light based lantern the only way to change the color is with the physical materials. Using a BlinkM I could imitate the way the leaves glow in the sunset with the light itself.

This is what it looks like done and blinking, kind of… the colors are a lot warmer than they are in the video (see the picture below)



For the non-BlinkM parts of this project I used items found in major chains (craft, hardware, office supply, grocery). All the BlinkM related items were sourced from SparkFun.

To create the light:

BlinkM from SparkFun or FunGizmos
LinkM from SparkFun or FunGizmos
Fall Flicker Script File The light script I wrote
The 5V DC to DC Step Up – 1xAA at SparkFun may seem a bit expensive, but it only uses 1 AA battery (disposable or rechargeable) to generate the 5V the BlinkM needs. Super super handy. (photo is theirs)

To make the lantern:

IMG_6692 A rotating photo cube from Michael’s
IMG_6740 Clear acrylic beads, also from Michael’s
IMG_6755 House paint in sample sizes
tin foil
tracing paper
a phillips head screwdriver to remove the rotating platform
a flat razor blade to scrape labels off with

Step 1: Pick Your Lantern

The lantern I used for this project is actually an “Unfinished Rotating Photo Cube”  from Michael’s.  I couldn’t find it on the web site, but they live in the in the paint-your-own section and run about $3.99 at both the one in El Segundo and in Santa Monica.

Pro: It is certainly big enough to a stash  most BlinkM appropriate power sources in it.

Con: There isn’t, however, a lot of natural diffusion going on to help direct the light from BlinkM out in all 4 directions.  I picked up some tracing paper, aluminum foil and “Decorative Accents – Clear Sparkling Jewels” (again not available online from Michaels) to help deal with this later.

Step 2: Paint The Lantern

I knew I was going to go with a classic fall palette and was not really interested in spending a bunch of time custom mixing so I went a few doors down from Michaels to the Home Depot to rustle up some house paint samples.  The queen of How-To herself, Martha Stewart, has a paint line, and, well, anything else you want to say about her, Martha curates a mean home décor color palette.  So Heath (think tree bark), Milk, and Saffron (daylight interest?) ended up in my grocery basket.

IMG_6697 IMG_6699 IMG_6696

Something to keep in mind: the color picked for the inside of the lantern becomes a reflecting surface for the BlinkM.  The lighter or brighter the color the more light will be bouncing around.   The light will also pick up any color that is in the paint, too.

I’m not actually going to spend a lot of time explaining how to paint in general since these lanterns are pretty basic. Some tips before you get started though –

–       Remove the spinning base (Phillips head screwdriver)

–       Sanding is always recommended (but I didn’t)

–       Paint your lighter colors first

–       Super cheap craft paint  brushes, even the foam popsicles are fine.

–       You will want at least one sharp edged detail brush to do edging where you have two colors meet.

–       Let things dry between coats. Really.

I made some experiments, but in the end the winner was the one shown with Saffron for the mid section and Heath for the lid and bottom lip.

painted cube

Once it was all totally dry I put the rotating bottom back on, too. Well, actually, I didn’t and plastic beads got a little everywhere when I did later. So you, you, should put yours back on here.

Step 4: Diffuse

As I mentioned before, the photo cube wasn’t designed to be a light source so it doesn’t have a nice shiny interior or frosted glass or anything like that.  Thankfully those kinds of features are easy to add in this case.

A) For a frosted glass look, line all  4 panels with tracing paper. Optionally you can print a pattern onto the tracing paper if you have an inkjet printer with a rear-loading tray. (link to PDF of pattern) I chose to put the tracing paper on the outside of the acrylic pieces for a softer feel. Putting the tracing paper on the outside also meant I could stress a bit less about getting absolutely every last trace of the adhesive from the stickers off, too. Shh. I didn’t tell you that.  (Soaking in hot water helps, razor blade makes neat work of it but be careful)

IMG_6720 IMG_6723 IMG_6728 IMG_6724

B) Put a square of tinfoil, shiny side up,  at the bottom of the lantern to reflect light back up since the BlinkM will be face down.   ( If the BlinkM was going to be sunny-side up I would have adhered the tinfoil to the lid)

IMG_6734 IMG_6736 IMG_6737

C) Add the acrylic beads / frosted marbles etc. to level high enough to reach the top of the lantern panes but leaving room to create a cozy little nook for the BlinkM. Check the effect with an actual BlinkM attached to the battery (the test pattern that comes preloaded on the BlinkM’s is fine for this)

IMG_6752 IMG_6753

Step 5: Let there be light

BlinkM in LinkM attached to the USB port of a computerUnlike a regular candle based lantern the “flame” color is also under your control.  The light itself is the real protagonist. I didn’t finalize my sequence for sure until after the lantern was painted and it would be easier to see what it looked like diffused.   If you want to just copy my pattern, these are the steps:

A) Download the BlinkM script by right-clicking or ctrl-clicking on the link and save it somewhere you can find it. It’s called BlinkM_FallFlicker_v1_0.txt

B) Download the BlinkM Script Tool and put it in the same folder/directory as the script for convenience. (download for Mac OS X, download for Windows, or get the source code)

C) Plug the BlinkM into LinkM and plug the LinkM+BlinkM into the USB port. (picture above)

D) Open the BlinkM Script Tool and press the “Load” button on the bottom left of the screen (labeled 1). You’ll get a file browsing dialog box. If you’ve put the Script Tool and the script in the same folder you should see “BlinkM_FallFlicker_v1_0.txt” immediately. Otherwise navigate your hard drive in the usual fashion to find BlinkM_FallFlicker.txt, select it as the file you want to load, and press the Open at the bottom right of the dialog box.

E) Back in the main BlinkM Script Tool window third from the left is the “Send” button. (labeled 2)  That is what puts the program on to the BlinkM.  Hit that and you’re done. You can remove the BlinkM and attach it you your external power supply for testing in your lantern.


If you want to change the Fall Flicker script you can do so right in the Script Tool.

Each line has the format:

{time, { c , red_value, green_value, blue_value}}

The red, green and blue values are on a scale from 0 to 255 which are represented by 0x00 to 0xFF in Hexadecimal. The script files can mix decimal in with the hex if that is easier for you. Mine is all in hex because I created the original Fall Flicker script as an export from the BlinkM Multitrack Sequencer (found from the right hand column of the LinkM page).

The BlinkM Multitrack Sequencer lets you visually create patterns where each “note” persists for the same amount of time.  That doesn’t work for flickering. While you absolutely can put the same color next to itself to create longer chunks, I found it easier to save my color sequence as a text file that could be opened it up in a text editor. Once opened I could randomly assign color lengths to each step. To preserve the custom lengths I used the script tool to do all further tweaking.

Going Further

And that was it! This is just one color scheme for a photo-cube lantern.

  • You might want to go white and orange for the wood on the outside with a green “flame” pattern for St. Patrick’s Day.
  • Or make a silver lantern with blues for an “under the sea” theme…
  • Gold lantern with bright jewel tones all over the map for a treasure chest lantern…

These are just some of my random ideas. Have some fun!

IMG_6811Honestly, though, the quickest and the dirtiest thing I could have done is grab a large glass jar, some tracing paper, shoved in a BlinkM, thrown some frosted marbles to help with light placement in and called it a day. Really. In fact I did. Let’s call this one “Summer in a Jar” for my friends back East who are going to want to save up the last traces of summer and keep them around for January. (see video)

Remember, you can let the light be the attraction rather than the physical form of the lantern itself, so I’d encourage you to experiment.  If you do decide that you want to go off the map and use something other than the Michaels’ photo-cube there are only three things really to keep in the back of your mind:

  • Where am I going to stash the batteries?
  • How am I going to help the light reach where I want it go ?
  • How am I going to turn it on and off?

Answer those questions and you can stick a little custom light show in the form of a BlinkM just about anywhere.

ThingM Newsletter for August 26, 2010


– Welcome Hot Solder UK!

– New Data Sheet for BlinkM/MaxM/MinM

– Did you know that BlinkMs takes sensor input with no microcontroller?

– Sketching in Hardware 2010: a recap

– Appearances

– Unsubscribe



We are pleased to announce our latest distributor: Hot Solder UK, based in the historic city of Exeter in Devonshire County, England. Wikipedia lists it as “the most south-westerly Roman fortified settlement in Britain” and “one of the top ten most profitable locations for a business to be based.” There’s also a pun to be made about the town’s location on the river Exe and Microsoft filename extensions, but we’re working very hard not to make it. ;-)

We are very pleased to have Hot Solder as one of our distributors. They currently have BlinkMs, LinkMs and MaxMs in stock.



We updated our BlinkM data sheet to include all three variants, including special sections on physical specifications for all three products, detailed information about how they vary, and updated specs (the new MaxMs are 18% more blindingly bright than the old ones, and MinMs can have fade times as long as 227 days–yes, days–for example).

You can download it here:



In many cases, BlinkMs can be interactive with no external hardware or microcontroller. Every BlinkM can change its behavior using its own inputs.

BlinkM MaxMs have analog inputs that read values from GND to +5v and can change either change brightness or color based on that input, which can be a simple potentiometer, or any sensor that can be made to output up to 5 volts (these are often called 5V TTL-compatible outputs). There are bend sensors, passive infrared sensors, tilt sensors. Thousands of TTL sensors can be directly connected to BlinkMs and used as inputs to switch between built-in scripts.

BlinkM MinMs and recent (firmware version {‘a’,’d’} and above) BlinkMs have digital input capabilities. This capability makes it very easy to directly connect a button, a switch or a simple binary sensor and change between behaviors.

Direct input makes it much easier to create sophisticated reactive lighting effects using very little additional hardware, since the BlinkM will handle most of the input work for you.

For more info and example code, see sections 3.4 and 4.5 in our new data sheet for information on input commands (which are “Knob Read RGB”, ” Knob Read HSB”, “Jump, relative”, “Input Read & Jump”, and “Input Jump Immediate”). And yes, for those keeping track, we HAVE introduced the equivalent of GOTO into the command set. ;-)

You can upload scripts that use the new commands to BlinkMs with the BlinkMScriptTool for Arduino and BlinkMScriptTool2 for LinkM (both written in Processing).

You can find the source to BlinkMScriptTool here:

And BlinkMScriptTool2:



Mike organized and ThingM sponsored the fifth annual Sketching in Hardware meeting this year in LA. A group of 40 toolkit builders, educators, manufacturers and users met and talked (and talked…and talked…) about how to use electronics as a creative medium.

As in years past, we were flattered at the fantastic group of folks who accepted our invitation and traveled from all over the world for the event.

Some of the awesome new technologies shown at Sketching included:

Phil Van Allen’s NETLab Toolkit:

Shigeru Kobayashi’s physical.wonderfl online hardware IDE:

Ed Baafi’s ModKit, another online IDE for visually programming Arduinos:

Jason K. Johnson’s Firefly, which connects the Arduino with the Grasshopper generative architecture environment:

Nwanua Elumeze showed the ingenious Schemer online IDE and light sensor programming system:

Rob Faludi demoed his ZigBee Internet Gateway:

Others presented about how lightweight physical computing tools are being adopted by everyone from middle school children to dancers and climate scientists.

The presentations from many of the attendees are downloadable here:

The event itself was held in the historic, and awesome, LAX Theme Building, and at Art Center College of Design’s equally awesome Wind Tunnel building. Here’s a history and profile of the Theme Building from Wikipedia:

You can find photos from the event on Flickr:



August 28: Come to Crash Space LA, the hacker space Tod co-founded, for a fundraiser and demo of the secret Hackerspace Challenge product that Crash Space has been working on! More info:

September 14: Mike will be part of a group of folks giving the closing keynote–a tribute to Mark Weiser–at Appnation in San Francisco:

September 23: Mike will be on a panel discussion of Open Hardware business models at the Open Hardware Summit:

September 30: Mike will be talking about frameworks for the design of devices and services at Mobilize 10 in San Francisco:

Welcome Hot Solder, our newest UK distributor!

Hot Solder Electronics,, is a UK/EU distributor of ThingM products
Hot Solder Electronics,, is a UK/EU distributor of ThingM products

We are very pleased to announce that Hot Solder Electronics is the newest UK/EU distributor for ThingM products. Hot Solder are a full-featured electronics boutique. They sell a hand-selected range of breakout boards and development modules, basic components and tools. They even offer engineering, PCB layout and firmware development services. We are very happy  to have them as part of the extended ThingM family.

You can find BlinkMs on their site here:

Document your BlinkM/MaxM/MinM project, get a free MinM

(Public domain image from )

We want to know what you (or anyone you know) has done with BlinkMs, MinMs or MaxMs!

Send us documentation of your working BlinkM project and we will send you a MinM (which normally sells for $13-20). The first 50 people who send in a description that meets the requirements below will get a free MinM. If we think a description is particularly awesome, we’ll put it in our projects gallery, give you full credit, and link it to your blog/FB/Twitter page.

Here’s what we need from you:

  • A 300-word (or more!) step-by-step description of what you did. This doesn’t have the be the best documentation in the universe, but it should describe the project well enough so that someone could follow the steps and repeat it. For example, you could start with why you did this project, then describe what materials you used, what steps you followed, what you ended up with, and what you learned from it.
  • At least 5 high-resolution (800×600 or more) images of your project. Ideally, these pictures will illustrate various parts of your description.
  • Your address, so we can mail you a MinM.

Email the description, photos, and address to

This offer is good until August 13, 2010 or until we’ve gotten 50 complete descriptions, whichever comes first, so hurry!

Note: by sending us your description, you agree that we can use it in our project gallery and newsletter, but we promise to give you credit if we use it.

Open Source BlinkM/LinkM Code on Google Code

We’re continuously developing small pieces of code to do interesting things with BlinkMs, and we decided to put much of this on Google Code, Google’s Open Source code repository.

You can find BlinkM example code, all the code for our TweetM Wifi Twitter client, and the experimental code for FreeM, our infrared BlinkM controller here:

And you can find the source for LinkM firmware here:

Since we’re firm believers in Open Source as a model, we encourage everyone to take a look at the code, play with it, change it and check it back in. We’d love to know what you make with it, and if you have questions/comments/thoughts, please feel free to post them here.

FreeM, an infrared BlinkM controller

Since we first announced BlinkMs, people have asked us how to control them wirelessly. It’s relatively straightforward to make something that controls a BlinkM wirelessly. There are plenty of technologies to choose from–Bluetooth, Zigbee, Z-wave, Wifi, etc.–and we experimented with most of them, but none of them combined the core qualities that we wanted:

  • low-power use
  • compact form factor
  • easy configuration.

For example, TweetM is (at its core) a Wi-Fi BlinkM controller, but it’s a relatively pricy solution whose main advantage over a cheap netbook is its tiny form factor (it does have other advantages that I’ll cover in a future blog post). We shelved the problem until we could come up with a better solution. Infrared came up in the discussions several times, but it seemed too limited relative to all of the idea of distributed self-configuring networks that worked through walls.

Last year, however, we had a change of heart about IR. We were looking at how to control BlinkMs fifty feet from the control device. This is nearly impossible with stock I2C because of line noise, and leads to very slow data speeds in the best cases (not that stock I2C is all that fast to start with). However, we had clear line of sight between the controller and the BlinkMs, so IR control suddenly made sense. We also rethought our attachment to more complex technologies and decided that they were unnecessary. In most cases infrared’s low bandwidth and line of sight operation works just fine. Most of our products are LED-based, and typically if you can see an LED that’s producing light, you’re within line of sight of its controller. Tod dusted off the part of his brain from a college summer job programming universal remotes, and put together a prototype.

Infrared is a somewhat maligned communication technology, thanks to the failure of IrDA to be broadly used for anything, even though it was installed in nearly every device in the late 90s (apologies if you love IrDA). However, thanks to more than 30 years of infrared TV remotes, the basic technology is cheap and robust, so the task became one of translating BlinkM commands sent over I2C to infrared sequences to create an “invisible wire” that connected the controller and BlinkM. The idea for FreeM was born.

As a first step, Tod implemented Sony’s IR remote protocol (SIRCS), which is (somewhat) well documented and relatively straightforward. The FreeM Kit’s beta firmware is primarily a Sony remote-to-BlinkM I2C converter. It maps a number of common remote functions to BlinkM commands, enabling simple infrared control of BlinkMs/MaxMs/MinMs.

One use we particularly like for it is when it’s coupled with a MaxM Master board to control an RGB LED light strip. Since it’s sending BlinkM commands, MaxMs work out of the box. The MaxM Master can power an 8-10 foot LED strip, so the combination of FreeM + MaxM + LED strip means that you can have the equivalent of a single giant RGB infrared-controllable LED.

FreeM also does some generic I2C-to-IR conversion as a first step to a true “invisible wire” that passes I2C commands transparently to I2C devices, but that’s still highly experimental code. Use at your own risk.

The FreeM Beta Kit is available immediately from our friends at FunGizmos. They’re pretty easy to assemble, with only a handful of big, through-hole parts that are easy to solder. The firmware is already on the chip. You just need to point a Sony remote at it to make it go.

We’re still gauging the interest in FreeM before we commit to a complete production run, but in weeks since we first showed it at Maker Faire, response has been pretty positive, so we’re seriously considering moving forward to make it a full-fledged member of the BlinkM family.

Stay tuned!

BlinkM Hello, Video Guides, Example Code

[originally published on 25 Jan 2008 on todbot blog]

This is a BlinkM:

BlinkMs are “smart LEDs”, a type of smart interface component. A BlinkM consists of an ultrabirght RGB LED backed with a microcontroller with built-in knowledge about 24-bit color spaces, color fading, and color pattern generation. All in a package 0.6” wide. You talk to it over I2C, a serial protocol spoken by many different things. (Arduino speaks it, as do Basic Stamps, and your PC) And you can have over 100 BlinkMs on the same serial bus, each individually addressable. Here’s how they can hook up to an Arduino:

BlinkMs are available from, SparkFun (US) and other electronics vendors. It’s hard to show in just static pictures how fun and easy it is to play with BlinkMs, so here’s a few quick video guides.

Video Quick Start Guide

A video version of the BlinkM Quick Start Guide.

Playing with BlinkMTester

A demonstration of one of the example Arduino sketches “BlinkMTester”, which lets you exercise a BlinkM by typing simple commands to the Arduino.

Exampe Code

There are a couple of examples of how to talk to BlinkMs all zipped up in You can also peruse them unzipped if you like. The examples are predominately for Arduino currently, but any I2C master will work. Some of the examples so far:

  • BlinkMCommunicator
    A simple serial-to-i2c gateway for PC controlling of BlinkM (for instance via Processing or the BlinkM Sequencer)
  • BlinkMTester
    A general tool to play with a single BlinkM
  • BlinkMMulti
    An example showing how to communicate with multiple BlinkMs
  • BlinkMScriptWriter
    A demonstration of how to write BlinkM light scripts with Arduino
  • BlinkMChuck
    Control the hue & brightness of a BlinkM with a Wii Nunchuck

More examples will be added periodically.

For the Arduino examples, a convenience library called BlinkM_funcs.h has been created. Just drop this .h file into your sketch folder and call the functions to start playing with BlinkM.

The complete list of functions is below, though you’ll probably only use a few of them for a particular project.

BlinkM_beginWithPowerPins(byte pwrpin, byte gndpin);
BlinkM_sendCmd(byte addr, byte* cmd, int cmdlen);
BlinkM_setAddress(byte newaddress);

BlinkM_setFadeSpeed(byte addr, byte fadespeed);
BlinkM_setTimeAdj(byte addr, byte timeadj);

BlinkM_fadeToRGB(byte addr, byte red, byte grn, byte blu);
BlinkM_fadeToHSB(byte addr, byte hue, byte saturation, byte brightness);
BlinkM_setRGB(byte addr, byte red, byte grn, byte blu);

BlinkM_fadeToRandomRGB(byte addr, byte rrnd, byte grnd, byte brnd);
BlinkM_fadeToRandomHSB(byte addr, byte hrnd, byte srnd, byte brnd);

BlinkM_getRGBColor(byte addr, byte* r, byte* g, byte* b);

BlinkM_playScript(byte addr, byte script_id, byte reps, byte pos);
BlinkM_stopScript(byte addr);
BlinkM_setScriptLengthReps(byte addr, byte script_id, byte len, byte reps);
BlinkM_writeScriptLine(byte addr, byte script_id, byte pos, byte dur,
                                byte cmd, byte arg1, byte arg2, byte arg3);
BlinkM_writeScript(byte addr, byte script_id, 
                          byte len, byte reps,   blinkm_script_line* lines);

And More

For more information, including a datasheet, example code and sequencer application for Mac/Windows/Linux visit

If you want to talk about BlinkM, leave a comment or participate in discussions on ThingM’s Satisfaction page.