The Lightuino is an Arduino-compatible circuit board that lets you easily drive lots of LEDs.

You’ve got 70 independent constant-current sink channels to play with, and can stack 3-4 LEDs in each channel. You get 16 500mA source channels. When used in combination with the 70 sink channels you can drive 1120 LEDs in grids like 70×16 or 35×32.

It also contains an IR universal remote receiver and an ambient light sensor to help control your projects. Source code libraries to drive all the hardware is included so you just program it using simple APIs. This board contains a ATMEGA 328p processor (same as the Duemlanove) and looks just like a Duemlanove to the Arduino IDE. The Lightuino powers the LEDs using a constant-current driver chip, so you get a consistent light intensity and you don’t have to deal with those pesky resistors.

The Lightuino is Arduino-shield compatible and comes with “super-stackable” headers (pins on the bottom and extra-height female headers on top). For example, you can put this on top of an Arduino and then put a shield on top of it! You can even stack multiple Lightuinos to light more LEDs. Just clip any pins you don’t want to be shared.


Anything that uses 0-20mA LEDs such as model train lighting, LED coffee tables, LED art, museum installations and indicator lighting (lighting locations on a map for example). The Lightuino can also be used to drive servos, DC motors, relays, etc, with minimal additional components (resistors, diodes and transistors)


coming soon…



100% Software compatible (and register compatible) with Arduino sketches. Open source software library (Arduino sketch compatible) lets you easily program the LED state, set LED brightness individually, do intensity fading, and access the IR receiver and ambient light sensors.



You can stack multiple Lightuinos to control more than 70 LEDs, or stack Arduinos or Arduino shields on top or below.

Almost 100% Shield compatible

_The Arduino’s 3.3v output pin is not provided_ (but you should be able to use a 3.3v shield by providing your own 3.3v supply). Use a USB connection or a USB to serial cable (FTDI cable) to talk to the board (FTDI thru hole footprint is not populated). Accepts USB power (with 500mA resettable fuse) or 7.5-16v DC via 2.1mm center positive jack (same size as the Arduino/Boarduino, etc).

common connectors

All LED sink control and power lines are exposed via 2 EIDE ribbon cable 40-pin connectors (AKA hard drive cables). This makes it very easy to connect up to LEDs. The source driver uses a 16 pin ribbon cable connector. This is a pretty common part and is also available cheaply through us.

CPU core

_This is just the highlights. Please refer to the ATMEGA 328 spec for more information_ AVR 328p microprocessor 8 Analog inputs 32k Flash 1K EEPROM 2K bytes SRAM 16 Mhz

LED Sink Drivers

2 M5451 constant current chips Capable of sinking 70 outputs at 15-20 mA, at 12 volts. This is *not an LED matrix driver* LEDs that are “on” do *not* blink giving you a much brighter light than a matrix driver. Independent control of all 70 outputs from CPU (on or off). Brightness of all LEDs can also be controlled, and apparent brightness of individual LEDs can be controlled via open-source software PWM library. Any 4 CPU IO pins can be selected to drive the LEDs via soldered jumper wires. This lets you stack Lightuinos or use Arduino-shields that do not let you choose their IO pins. Selectable LED voltage via a trim pot/variable resistor.

LED Source Driver

16 500mA outputs are available to drive current into LEDs or other devices. Note however that the board’s maximum current is less than 8A, so these cannot all be on at the same time at full power. In conjunction with the LED sink driver, you can make an LED matrix that is 70×16 (or 35×32) LEDs in size (1120 LEDS total).

Variable voltage regulator

An onboard 1.5Amp variable voltage regulator can be used to select the perfect voltage for your LEDs.

Ambient Light sensor

An ambient light sensor is onboard so you can automatically turn on your project in the evening!

IR receiver

This 38khz infrared receiver will work with most TV remotes and all “universal” remotes. Use a remote control to control your project!!


Software to drive all this hardware is available as an Arduino library, so you only need to write code specific to what you want to do.


coming soon…

Getting Started

Unpack your Lightuino and hook it up to your computer via a USB mini cable (not included). You should see the green, blue and red LEDs turn on and/or start blinking.

    • Hardware

      • Your board comes with a default sketch. If you attach some LEDs from +5v to the LED sink pins, you should see them blink! Make sure the LEDs are oriented in the correct direction (try both ways if in doubt). Reset the board after hooking them up since the demo sketch also runs through other routines that do not turn on the LEDs.
      • The sketch will also output to the serial port so you can test your USB or serial connection (9600 N81)
    • Software

      • Download and install the Arduino software here
      • Install the USB driver: On windows, I actually use the standard usbser.sys driver that ships with windows. There is a .inf file in the code repository (see download link below) that you should give to windows during the driver install process. Ignore the “driver signing” warning… since I am not even providing a driver, this is just silliness designed to make M$ more money! On Linux there is nothing to do! The Lightuino shows up as /dev/ttyACMx. If you do not see this in the Arduino IDE, please upgrade it to version 21 or greater.
      • To use the Lightuino USB, you need to add an entry in the boards.txt file, located at: < arduino_install_dir >/hardware/arduino/boards.txt. Or possibly in /usr/local/arduino/hardware/arduino/boards.txt. 5 16mhz
############################################################## 5 20mhz
    • Download the Lightuino library located here
    • Install the Lightuino library
    • Take a look at example sketches located at the arduino-m5451-current-driver google code site. This sketch is also located in the Arduino IDE at File->Examples->lightuino5->begin_here5
    • Upload it and see what happens! (please open the serial monitor, get ready with a IR remote, a bright light, and perhaps even connect up a LED)

Hardware Reference

The Lightuino board is a standalone Arduino-compatible (ATMEGA 328p) or a shield (daughtercard).

The purpose of the board is to expand the number of outputs available to the Arduino user and to provide outputs optimised for driving LEDs, optocouplers, relays, etc. Instead of providing additional digital logic, the Lightuino offers 70 constant current pins that can sink up to approximately 20 milliAmps of current per output, and 16 500mA source drivers to push current into your project. It also provides an IR receiver (for use with most remote TV or universal remote controls, and an ambient light sensor.

This is different then digital logic chips. Digital logic provide a constant voltage; i.e. when the pin is 1 or “high” you will see 5 volts (say) if a meter is placed across the pin and ground. When the pin 0 or “low”, it drives the voltage to 0. When a constant current output pin is 1 or “on” it will vary the voltage as necessary to allow a specific current through the pin to ground. This means that “on” looks like a logic “0” or pulled low (the pin sinks the current) and that an LED can be placed directly between V+ and the pin without using an additional resistor. In fact, using a constant current driver is better than using a resistor for LEDs because the constant current driver will compensate for variations in the LEDs, for LED aging, and finally be safe if the LED fails by shorting. Additionally, when the constant current output pin is 0 or “off” it acts like it is disconnected. So this kind of interface is called “open drain” because it acts like a switch that is “open” when 0, and it grounds or “drains current away” when it is logic 1.


Front Side

For all locations described on this page, please hold the board in front of you so that the “Toasted circuits” silkscreen is right-side up. This is the “front” of the board. I will call the edge the power jack is on the top.

Back Side

Most of the chips are located on the “back” of the board. The “standard” orientation is as shown (flip the board around a vertical axis).



There are several solder blob jumpers on the board. A solder blob jumper looks like 2 metal pads right near eachother. If you heat them up with a soldering iron and apply some solder it is fairly easy to get the solder to bridge the 2 jumpers, making a connection. This is an inexpensive and more importantly physically small and flat replacement to the traditional mechanical jumper. All jumpers are labelled on the board. Here is the list:

    • VINLEDS: Let power go directly from the DC jack to a pin on the IDE cable. This is OPEN by default because it is easy to accidently touch this to another pin and possibly fry something.
    • V5LEDS: Let power go directly from the CPU’s or USB 5 volt supply to a pin on the IDE cable. This is OPEN by default because it is easy to accidently touch this to another pin. If more than 6v are put on it you WILL burn out your onboard CPU, reducing your lightuino to a shield :-(. So close this with caution. But if your installation uses USB power only, you will be safe and can either close this and receive the power from the IDE pin, OR pull the power from the normal Arduino header pin marked 5v.
    • GNDLEDS: Let the groun plane out to the IDE cables, pin 40 (top of the board the bottom pin). This is OPEN by default because you would only need electrical ground out there if you are connecting the Lightuino to another circuit board rather than LEDs. And if it is presented there is always a chance it could be shorted against a supply pin.
    • USR: This is a PIN, not a jumper, located right between the standard Arduino Analog and Power headers. This pin is provided for you to send a custom signal or voltage out the IDE cables. This is connected to the IDE cable pin marked “usr” (third from the top of the board, bottom pin).
    • BRIGHT: This is a 3 pad jumper, with 2 settings. If the jumper shorts the right (marked 5v) and middle pin, overall brightness is controlled solely by the trim pots. If the jumper shorts the left (marked “pin”) and middle pin (as pictured), overall brightness can be software controlled by the PWM pin selected in the “Pin Selection” section. If the blob is removed, no LEDs will light!
    • VIN_PASS: If this blob is present then power is shared between this board AND and Arduino Header’s Vin pin. This allows you to use a single wall-wart for multiple stacked boards.

Pin Selection

The pin select footprint lets you choose which digital IOs control the LEDs. The top footprint holes (covered by solder) correspond to the signals that control the current sources and sinks. The bottom footprint holes correspond to digital IOs 0 through 13 moving from left to right.
The solder blobs create default selections so your sketches will work by simply including:
#include < lightuino5.h >
But if you want to move these selections to stack Lightuinos or to accomodate shields you may do so. To accomplish this, first melt the solder blob and then you must solder wires between a hole on the lower bank to a hole in the upper bank (if it is not already done). *Make sure your wire does not short against some other connector on the board!*
Once you change the defaults, you will need to enter this information into your sketch (when you construct the LightuinoSink or LightuinoSource object) so it knows what pins to use.
Make sure these blobs do not short against the top “CY7C” line of pads. These pads would allow the USB controller to drive the chips directly instead of the Arduino.


    • ICSP: The ICSP header is used to program the boot image, just like on an Arduino. Pin 1 is on the bottom right.
    • FTDI: The FTDI header is not populated because the USB is the default choice. But if you want, you may program sketches via an FTDI cable, connected to these pins. The BLACK FTDI wire should be on the LEFT the GREEN on the right (as marked on the board).You may purchase an FTDI cable through me, through adafruit, or other places.
    • USB: This is a standard USB micro AB port. Use it to program your device and to do serial communications. In the sketch, use the “Usb.println()” functions, not the serial.println() functions (see begin_here5).
    • Source driver: This is where the 15 500mA driver signals are output.
  • Left and right IDE headers: This is where the 70 constant current sinks are located.


If your are turning these and nothing seems to be happening, hook up a multimeter so you can really see what is going on. For LED_VADJ measure the voltage, for BRILEFT and and BRIRIGHT set it up to measure current. If nothing is STILL happening your screwdriver is probably not actually turning the pot. What you see turning on top seems to be a kind of “cap” that can sometimes turn without the underlying pot actually turning. Use a #0 jewellers screwdriver and it will work.

    • LED_VADJ: This potentiometer (the middle) controls the voltage level expressed on the VCC pin (37, or top pin, 2nd from the top of the board) of the IDE cables. The voltage can range from 0 to whatever your DC wall wart is providing (up to a max of about 20 volts).
    • BRILEFT, BRIRIGHT: These 2 potentiometers adjust the brightness (i.e. current) output on the left and right IDE cables respectively. Generally they are used to match the sides so that the exact same intensities are generated. However you can set them differently to generate different intensities per side. Note that you may also use the provided library to implement software PWM to individually control brightness. It is possible to turn these up too high and burn out your LEDs and even your M5451 chip (if you drive lots of LEDs too high). Set them for a maximum of 20mA and verify this by connecting an ammeter (your multimeter set up to measure current) between one of the voltage sources on the board and a LED sink pin. Then write a sketch to turn on the LED (or all of them, it doesn’t matter) to measure the current going through the ammeter. Or just hook up a LED and visually check that it is not that bright!

Analog voltage divider footprint

If you need to implement a voltage divider connected to your analog pins, these resistor footprints do the trick. They bridge 5V and the analog pins. Put a resistor there, and connect your pot or sensor from the pin to ground and you will have a voltage divider! For example, the supplied light sensor does exactly that.


The reset button is located on the bottom right underneath the LEDs. This reset button resets the AVR (Arduino) CPU only. If your USB is not responding you need to power the board off and back on.


The LEDs are located in the front right.

  • The leftmost (blue) LED indicates USB activity.
  • The middlemost (green) LED indicates 5v power (CPU power).
  • The rightmost (red) LED is the pin 13 LED used in a lot of sketches like the “blink” sketch. It will also flicker rapidly when a sketch is being downloaded or USB serial communication occurs.

IDE cable pinout

The left and right IDE cable pinouts identical. Since the header does a right angle turn to leave the board on the side, a pin on the top of the left side is on the bottom on the right side. This may be unintuitive but it this does mean that the pinout is exactly the same coming out of a left IDE cable verses a right one. All pins are marked. For example, pin 37 (the LED power pin) on the circuitboard is on the upper left and right corner, marked “LED” and has a white circle. These 2 pins (one on each side) are the most important. They are where the power comes from the voltage regulator to drive your LEDs.

    • Pin 40 GND Pin: This pin is ground IF the appropriate VPASS jumper is closed. Otherwise it is unused. Since ground is not needed when driving LEDs VPASS is open by default. By the way, the point of having the VPASS jumper is to protect you from accidently shorting a LED to ground.
    • Pin 39 Vin Pin: This is the raw voltage coming from the wall wart. Only use this pin if you are using too much power for the voltage regulator to handle. But remember, the LEDs sinks MUST have less than 12v! And do NOT trust the printed voltage on your wall-wart transformer. Measure it! The printed voltage on “unregulated” (normal) wall wart transformers is the minimum voltage — the actual voltage is typically 25-50% higher.
    • Pin 38 5V Pin: This pin provides 5 volts. Use this pin to drive logic. NOTE: if you accidently short Vin or VSEL against this pin your CPU will see that voltage. If it is higher than 6-7 volts it is possible to burn out your CPU! Therefore be very careful or even clip the pin if you are not a careful person
    • Pin 37 VSEL Pin: This pin provides whatever voltage is selected via the VSEL variable resistor (1.5 Amps max). If in doubt, use THIS pin to drive your LEDs, etc.
    • Pin 36 ANY Pin: This pin can be used for anything; it is exposed on the rightmost pin of the VPASS header (on the board “USRPIN” is silkscreened next to it).
    • Pin 35 – Pin 1: These are the individually controllable constant current sink pins. Connect your load from one of the voltage pins described above to one of these pins.

In code,

// A nice little PIN identifier sketch.  It assigns the extreme 4 pins (2 on each side)
// different values.  Hook a multimeter up in series with an LED and measure the current
// flowing through when the LED is connected to each pin.  You will see different currents
// on each pin.  
// You can use the same technique to find LED pins in the middle of the connector!
#include <lightuino5.h>  // Include the Lightuino version 5 library
Lightuino board;   
FlickerBrightness leds(board);
void loop() 
  board.flags = Lightuino_FASTSET;
  while (1)
  leds.brightness[0] = 32;      // This is the near side top pin on the LEFT connector
  leds.brightness[34] = 64;     // This is 2-from-the-far side top pin on the LEFT connector
  leds.brightness[35] = 127;    // This is the near side bottom pin on the RIGHT IDE connector  
  leds.brightness[69] = 255;    // This is 2-from-the-far side bottom pin on the RIGHT IDE connector
  for (int i=0;i != 10;i++) leds.loop();

*Note, sometimes the IDE cable will reverse what is bottom and top, so while the code comments are accurate for your connector they may not be accurate for the output of the IDE cable. Just experiment!*



Note that the M5451 chip can dissipate 1 Watt at 25 Celsius, so you must work within this limit. For example let’s say that you are putting 5V across the circuit, and the LEDs use 3V. This means that 2V will be dissipated in the chip (5 minus 3). At 10mA current, this is 20mW per line (power = volts*amps) or 20*35 LEDs = 700mW total dissipated in the chip. So you are ok. But if you used 20mA current, you would have 1.4Watts when all the LEDs are lit. Not so good.

However, there is more than one way to fix the problem. First, you can change the LED_VADJ pot to adjust the input voltage to a bit above what your LEDs require. Second, if only half of the LEDs are simultaneously on (maybe your application blinks them), then you are back to 700mW so are ok. But of course this means a bug in your program might cause all the LEDs to turn on and the chip to burn out… Or maybe you could install a heat sink onto the M5451 chip and do some testing to ensure you don’t start a fire :-).

Voltage Settings and Sources

The Lightuino’s M5451 chips and can take up to 12volts. And the voltage regulator can take quite a bit more. This means that you can put several LEDs in series PER Lightuino sink line!

However, during your hacking sessions running 6 volts or greater is dangerous because if you accidently short the LED voltage to the cpu’s voltage you *WILL* burn out the cpu. So let me recommend saving this technique for the finished project. You can use the LED_VADJ to jack the LED voltage down to 5v and solve 99% of the issue. However you still have the Arduino’s Vin pin and the DC jack that is showing the full voltage coming from the power supply. Therefore it is best to choose a 5-6 volt regulated wall wart power supply as that will be incapable of generating voltages dangerous to the cpu. Or you can use the USB power, coming out the normal Arduino 5v header. But the USB will limit itself to 500mA to protect your laptop, so it is not appropriate for complete projects with 70 bright LEDs.


Code is at

Library Reference

coming soon…