Controlling Lots of Outputs from a Microcontroller

Making LED displays is fun. There are a a few tools that get used all the time, from row-column scanning to LED driver chips to multplexers and shift registers. This tutorial discusses some of the more popular methods for controlling large amounts of LEDs from a microcontroller, including their various strengths and weaknesses, and how they work. For more on this subject see chapter 14 of “Physical Computing“, where Dan O’Sullivan and I discussed it in more depth.  I’ll also include some notes on how to apply these ideas to controlling multiple motors or other high-current loads.

Most microcontroller modules have a limited number of outputs. Even if you use the analog inputs as digital I/O, there are only 19 pins on an Arduino, for example. That’s a fairly typical number for an 8-bit controller, and it seems not nearly enough if you want to control, say, 100 LEDs or more.  There are a couple ways around this problem.  Without adding any additional hardware, you can make a matrix of your LEDs and control them using row-column scanning.  If you want discrete analog control over one output at a time, you can use a multiplexer. For digital control over multiple pins, you could use an addressable latch or a shift register. If you need pseudo-analog control over multiple pins, you could use a PWM driver.  There are also several LED driver chips that are designed specifically to control groups of LEDS.

Continue reading

Posted in arduino/wiring, circuits | Tagged , , , , | Leave a comment

CD4099 Addressable Latch Used to Control LEDs

This tutorial will show how to control multiple LED outputs from a microcontroller using a CD4099B  addressable latch.

Parts you’ll need:

  • CD4099B addressable latch
  • Arduino microcontroller (Any model will do)
  • 16 LEDs

Continue reading

Posted in arduino/wiring, circuits | Tagged , , | Leave a comment

CD4067 Multiplexer used to control LEDs

This tutorial will show how to control multiple LED outputs from a microcontroller using a CD4067  analog multiplexer.

This is a stub. More explanation will follow, but for now, here are schematics and code for Arduino.

Parts you’ll need:

  • CD4067B multiplexer
  • Arduino microcontroller
  • LEDs

Continue reading

Posted in arduino/wiring, circuits | Tagged , | 1 Comment

STP16C596 Shift Register

This tutorial will show how to control multiple LED outputs from a microcontroller using an STP16C596 shift register. The STP16C596 is similar to the popular 74HC595 shift register, but it’s nicer because it can sink a constant current to the LEDs it’s driving. It works slightly differently, however, so this code won’t work exactly for the ‘595.

This is a stub. More explanation will follow, but for now, here are schematics and code for Arduino.

Parts you’ll need:

  • STP16C596 shift register
  • Arduino microcontroller
  • LEDs
  • 1-kilohm resistor

Continue reading

Posted in arduino/wiring, circuits | Tagged , , , | Leave a comment

Tilty ball: Controlling 64 LEDs and a 2-axis accelerometer

This example shows how to control 64 LEDs and read the input from two axes of an accelerometer on an Arduino.  The Arduino used here is a Duemilanove, but it will work on any of the models out there prior to the Duemilanove as well.  This example uses row-column scanning as a way to control more LEDs than you have output pins.  It also uses some of the analog pins as digital I/O pins.

Parts you’ll need

  • Arduino Duemilanove or equivalent
  • 2-axis accelerometer. I used the ADXL335 breakout board from, and only used two axes.
  • 8×8 LED matrix.  I used one I bought surplus.  See this post for details on figuring out your matrix’s pins if you don’t have the data sheet.
  • Breadboard or prototyping shield.  I used the proto shield and tiny breadboard from

Continue reading

Posted in arduino/wiring, AVR, circuits | Tagged , , | 1 Comment

A Tale of Two Pongs

When I start learning a new  platform, I have a simple rule: If you don’t know what to do with it, make pong. What I love about pong is that it’s a simple rule set, easy to understand, and implementable on just about anything with a pixel display.  You can generally implement it in a day or less on any platform. And it’s a great example of engaging interaction.  People understand what’s going on right away, and, when implemented well, it’s just challenging enough to keep you engaged for several minutes at least.  That’s good interaction, to me.

I’m a big believer in starting with the application rather than the platform.  I think you do better work when the tools serve the need rather than the other way around.  But sometimes you get stuck with the assignment to learn a particular platform or tool, and you have to make up a project on the spot.  When that happens, make pong.

As an example of this, I built pong for two platforms yesterday: an Arduino Mega with 2 8×8 LED matrices (based on my earlier post), and Processing.  Since Arduino’s programming syntax was based closely on Processing’s, I figured it should be possible to port the code from one to the other pretty quickly. It took about ten minutes to go from Arduino to Processing.  Following, I’ll describe the thought process of putting the game together for both, as a hopeful aid to beginning programmers.

Continue reading

Posted in arduino/wiring, circuits, Processing | Tagged , , , | 6 Comments

8×8 LED matrix control on an Arduino Mega

Once you’ve mastered microcontroller programming, you might be tempted to control a lot of LEDs.  Lots of people have this desire once they master the basics. Many microcontrollers have a limited number of output pins, however, so you might think that limits how many LEDs you can control.  I’ve written about a few different methods around this before, in chapter 14 of Physical Computing, and in this tutorial on this the ITP physical computing site.

By matrixing your LEDs, you can control many more than the number of pins you have.  For example, with the Arduino Duemilanove and earlier models, you had up to 20 digital outputs (13 labeled digital I/O 0 through 13, plus the six analog outputs, which double as digital I/O 14 through 19).  With 16 of those, you can control an 8×8 matrix of LEDs.  That’s 64 LEDs.  With the Arduino Mega, you have 54 digital I/O pins, so you can control a lot more.  This example uses 32 of them to control 2 8×8 matrices, for a total of 128 LEDs from one controller.

To make this example, you’ll need:

  • Arduino Mega
  • Breadboard or prototyping shield. I’m using Smart Projects’ proto shields, which were designed at the same time as the Mega itself.  I love them.
  • 8×8 LED matrix.  I got mine in a surplus shop in China, but you can also get them from most electronics retailers
  • male pin headers
  • female pin headers
  • Wires

Continue reading

Posted in arduino/wiring, AVR, circuits | Tagged , | 6 Comments

Controlling Inkjet Printers from a microcontroller

There was an interesting thread on the Sketching in Hardware mailing list a while back on how to control an inkjet printer.   Wendy Ju started the discussion. Following are some of the links from that thread:

A closed, proprietary portable printer:  Xyron Design Runner

Nice explanation of how inkjets work and how to control them in general. Link submitted by Scott Minneman

Instructions for now sold-out Parallax Serial Inkjet Kit (which does include inkjet cartridge pinouts for the HP 51604A Black Inkjet Cartridge, as well as board schematics, parts and instruction routines for  writing to the cartridge). Even without the device, Parallax’ documentation is handy.

Instructions on how to build your own DNA microarrayer using commercial off-the-shelf parts, including inkjet technologies.  The last two links submitted by Wendy.

Haven’t had occasion to use these yet, but they seem handy.

Posted in arduino/wiring, AVR, BX-24, circuits, pBasic (Basic stamp), PIC | Tagged | 1 Comment

Dynohubs: power from bikers

Lots of people are into mechanical generation of electrical power these days, so here’s a nice tip from the guys at Uncommon Projects: dynohubs.  I had a note in my inbox for months that just said “dynohubs, Tarikh.”  So I wrote, and he offered a lovely explanation, and a link:

Dynohubs are cool. They are sort of stepper motors in reverse,
actually sealed in a bicycle hub. They generate AC current which can be
easily rectified and smoothed to DC and (mine anyway) generates nearly 400mA
without significant speed. There’s some minor friction from the magnets but
they’re much better than the old style “bottle” hubs (which are
significantly cheaper).

Dynohub in Uncommon Action!

Perhaps you were asking me because I’ve been meaning to make an instructible
for months about how to power or charge your iphone/device from your bike?

They’re not necessarily cheap. A quick google search for the Shimano 3N71 that Tarikh mentions comes up with prices ranging from $99 – $150.  3W at 6V, that’s half an amp. Not a bad start.

Posted in circuits, construction | Tagged | Leave a comment

Surplus Center

Mike Olson likes to move heavy things.  So when he says something like this:

Hands down the best site for finding cheap powerful motors is:

You can’t search by torque, but they usually have an excellent seclection of powerful gearheads and linear actuators.

I had great results with one of these guys a while back. Probably bigger than what you need, but produces huge torque with very little current. The only problem is that it’s very heavy.

I believe him.  So if you’re looking for motors that can lift heavy stuff, follow Mike’s lead.

Posted in circuits, construction | Tagged | Leave a comment