Graphic Poi (LED Poi / Pixel Poi) and LPD6803 LEDS with Teensy

NOTE: see the updated pixel poi using APA102 led strips. cheaper, lighter, easier to build. Go here for > APA102 pixel poi writeup

End Point = 30 Pixel long RGB LED poi capable of displaying graphics by POV.

About two years ago I started working with a juggler / performance artist friend. We were talking one evening about how to do something a little special to tie in to his LED show. Now, the LED show was already very special and getting plenty of attention, so we had to do something pretty dynamic and interesting. We came to the conclusion that Persistence of Vision (or POV) kit was needed, and it had to be bright, oh, and it also had to show logos (it has to be able to pay for itself somehow!).

So we got thinking about what the essentials were. It needs to be as light as possible, give a good coverage across the performance area, be bright, give plenty of detail when being looked at, be easy to use, be reliable, be resistant to knocks, have a good viewing angle (we’ll get on to that) and lastly, cheap to make. We also needed a painless way to put images and patterns onto the poi for use during a performance.

I think that we did most of that except for the ‘cheap to make’ bit. Its just is not possible in the world of juggling kit to make high quality programmable POV / pixel poi as cheaply as many people think it should be.

This is a pic of the end product, and keep reading for a idea of how you can do it yourself.

graphic poi pixel poi
A version of the Graphic Poi with 30 pixels on each side
Graphic Poi using ws2811 and Teensy 3.0
Graphic Poi using ws2811 and Teensy 3.0

And here is an image of the new pixel poi using APA102 led strips. Really easy to build, cheap, and very fast update rates. This are the first led strips that update fast enough for proper pixel poi use, no speckled effect.

This is the APA102 Pixel poi / graphic poi with Teensy 3
This is the APA102 Pixel poi / graphic poi with Teensy 3

by the way, I realise that the term ‘pixel poi’ has been trade marked, but, unlike the wonderful use of ‘Hoover’, i shall not use it as a generic term, and use Graphic Poi instead, and now we all know what we’re talking about.

After a lot of background research I started working with the Arduino Nano. it is a tiny micro processor that would easily fit into a baton. The Arduino also has a brilliant forum and support structure for helping newbies out, and is generally nice to people if you approach it the right way and do your own homework first. Check them out here:

However, to cut a long story short, and we will get this later, I had to move on from the lovely little Arduino Nano as it just did not have enough umph to do what I was after. In steps the Teensy.

The Teensy can be programmed using the Arduino development environment and can run on the same code, pretty much, for most of the basic workings. It has a great advantage over the Arduino in the small form factor end of things, in that it has more storage and more RAM. It does lots more besides but we don’t need to go into that. I ended up using the Teensy 2++ at the time. There is Teensy 3.0 out which is superb, uses the ARM chip and is 32bit, so this is the way to go. But, to note, the 3.0 uses 3.3v and the 2.0 use 5v I believe.

Arduino Nano and Teensy 3.0

As you can see from the pic, both a use small form factor. The Arduino Nano uses an FTDI chip, which is on the underside.

The LPD6803
The LPD6803 LED is one of the many around that are what is known as ‘addressable’, meaning that you can assign information to go to it, and it alone will react upon receiving that information. Often, this will be as part of a chain of LEDs with each LED grabbing the information that was assigned to it and passing the rest of the information along the chain. This one is now getting a bit long in the tooth, and there are others which are better for various reasons, such as better colour definition. A library for running these addressable RGB LEDs can be found at the Adafruit site:

These LEDS are run on 16 bit, five for each of the Red, Green and Blue components. If you feel uncomfortable with what this means, just have a read of this great wiki site:

When you have a look at the library at Adafruit, or any of the other support material for these, you will see that you can programme the colour in a number of ways, the most simple being to use the helper function. Pop over to BlipTronics to get some more info.

At the time of building the poi, just two years ago, there were no Pixel led strips with the required density to give a nice image without it looking like a set of lines going round and round. I was also unwilling to get into the deep dark realms of a big array of chips and lots of wiring, so was looking for something that was addressable without the major headaches. For these reasons I decided to build the poi out of individual LEDs, on as small a footprint as possible. This is why I used the naked PCB LPD6803 type sold by Bliptronics:

LPD6803 RGB addressable LEDS
LPD6803 RGB addressable LEDS

These naked LEDs are 15mm in diameter, and were the smallest form I could get for an addressable LED at the time (from a trusted source). The LEDS are super easy to put together in a chain, and even have a data direction arrow printed on the board to ensure that you wire them up the right way round. I bought a large number of them and they came on sheets like this:

Sheet of LPD6803 LEDs from Bliptronics
Sheet of LPD6803 LEDs from Bliptronics
Reverse side
Reverse side

As you can see from the above, these addressable LEDS have the chip on the underside. Newer LEDS such as the WS2811 have the chip embedded within the housing of the three colour LEDS, giving a lower weight, and a smaller footprint. It looks like a small black dot.

Building the strip
The next step was build these individual LEDs into a strip. This is where the weight started to build up, and why the preferred option is really to use one of the high density pre-made pixel strips that are now available. Each of these type of pixels has four solder points on each side of the LED. They are ground, negative, clock and data. These need to be wired to their neighbours. I just soldered them directly using a solder bridging technique for the ground and live solder points on each side. Not pretty, not very light, but it certainly worked.

pixel soldered connections
pixel soldered connections
building the pixel strip
building the pixel strip

So, as you can see from the above pics, I used a strong glue to fix the pixels onto a clear polycarbonate strip. This has proved to be very secure. As you can also see from this pic, we are only using pixels facing two directions. Our tests showed that you really only need pixels to face away from each other to give a good spread of light to the audience if you have nothing close to the pixels, and you use a good casing system.

Driving the LEDs
Using the Arduino developer environment is pretty straight forward, and as mentioned above, the Teensy microprocessor runs through this scripting environment without any hassle. In order to use it for the Teensy, you will need to download the software that lets the Arduino environment recognise the Teensy board. The software “Teensyduino” can be found here:

You just download it, extract it, hit run, and it takes you through the process of installing the required libraries to the right folder. This is important, as Arduino is all about having things in the right place.

teensyduino loader

Its a quick and easy process, and there are instructions for it on the pjrc website. You will also need to choose and load a library for running your LEDS. There are a few out there, and these keep getting updated, outdate, changed, whatever, all the time as the available LEDS change. You can’t go too far wrong by having a look at the FastSPI_LED library put together by Daniel Garcia. Have a read all about it here:

The new release of the Library makes it easy to select the right drivers for your type of LED. I am using the old version of this library now Deprecated, as, like I said, these LEDS are a bit long in the tooth these days.

Talking about different LEDS and their drivers, here’s a picture of a row of single LPD6803 5050 LEDS all soldered together to form the POV row, set next to a strip of newly available WS2811 5050 LEDs. A little bit shorter, a lot lighter (weight), almost no soldering (and so probably more robust, and saving three evenings work). One thing to think about, though, it to make sure that the ws2811 chip (or which ever one you go with) can handle the refresh rate.

Visual comparison of WS2811 strip with individual LEDS
Visual comparison of WS2811 strip with individual LEDS

By the way, these 5v strips are cuttable, show the direction of data travel for easy recognition of which end to wire up, and also use only three lines to work – ground, live and data.

Graphic Poi and Arduino / Teensy wiring and code
These Leds, when soldered together, act as a strip or chain, similar to the strips of addressable leds that you can buy off the shelf. As I said above, you are probably better off going down the route of a strip seeing as you can buy them at a good densitiy now. The LPD6803 individual leds have four wires, +ve, ground, data and clock.

schematic for pixel chain
The above schematic is from Bliptronics

You may well find that when you come to wiring things up, you will have to share the ground pin with that of the arduino / Teensy in order for the Leds to behave correctly.

Hooking up the data and clock lines to the Teensy will depend on the library you are using to run the Leds as you will find a number of different default pin settings. It should be clear in accompanying documentation or visible in the code itself as to what the pins are. For the FastSPI_LED library in this instance they were clock -pin 13, and data pin 11. In FastSPI you will also need to use the setChipset function. This library has been built to run a number of different led setups, so you need to specify which one you are using by inserting the line: FastSPI_LED.setChipset(CFastSPI_LED::SPI_LPD6803);

But, before getting into that any further, in order to get the Teensy to have code that works the Leds we need to put a few things together. The way that we put a programme into the micro controller using the Arduino environment is by writing a sketch. A sketch is page or set of pages with our code written down. The arduino environment takes this, goes and gets all the extra we have asked for, puts the code together and then squirts it over to the micro controller (in our case the Teensy). So, within the sketch we will need to:
– define the external libraries that will are using, such as FastSPI
– set up the memory space within the micro controller
– initialise the running of the fastSPI methods
– complete some parameters set up, such as length of led chain/strip
– have our main loop (the code that runs over and over)
– write our methods to go within the loop.

There are a couple of different ways that Graphic (pixel) Poi are used. Firstly they are used to display images, such as a picture of something, and secondly they are used to great effect to show abstract patterns. Personally, I think that their greatest impact is in showing really good abstract patterns in sequences that catch the eye. In this blog we will initially focus on the abstract pattern element as this is the easiest part.

more to follow

5 Trackbacks