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.