• WS2801 LED Strips
• An Arduino Ethernet Board and a USB/Serial Light Adapter to upload the firmware
• 5 Volt power supply – I use an old ATX Power supply
• Optional: Grove — Base Shield and Cables

Also make sure that the StripInvaders Sketch is already on your Arduino!

This is my WS2801 LED Strip:

Now it’s time to connect the Grove Base Shield to the Arduino Ethernet:

Almost done, now connect the cable from the Arduino Grove Shield with the LED Strip and the 5V power supply. This should look like this:

Now connect the StripInvader to your LAN and power up StripInvaders. Try to ping the host “invader.local”, this is the mDNS name of the StripInvaders Arduino device.

The StripInvaders can be configured without re-uploading the Arduino sketch, by sending a special OSC messages (/cfg). Take a look at this PureData example:

In our example we send “/cfg 66 5 4 96″. The first parameter 66 is just a magic byte, it must be 66, period. The second parameter defines the data pin, the third parameter defines the clock pin and the last parameter define how many led pixels are installed.

Links: StripInvaders System

Look, it’s really easy ma:

Edit 4.2.2012:
I just released the StripInvaders config Tool (for OSX and Windows), this should simplify the setup process. Here is a screenshot:

• 15 different color modes
• Control StripInvaders with a Smartphone or Tablet
• Stepless adjust the RGB value and the animation delay
• Bonjour and mDNS support
• DHCP support
• All fits into the 30kb firmware
• The firmware is released on GitHub
• Strips available on my PixelInvaders.ch shop

StripInvaders will color up your flat, take a look at those images:

Here is the wiring between BusPirate and Arduino Ethernet
BP GND -> Pin 1 (Black)
BP 5v -> Pin 3 (Red)
BP MOSI -> Pin 4 (Red)
BP MISO -> Pin 5 (Yellow)
BP CLK -> Pin 6 (Blue)

Connect to your BusPirate (115200 BPS) and configure it to run in transparent serial mode

Exit the Terminal and switch over to your Arduino IDE. Now upload your sketch through the BusPirate.

Oh and if you’re asking yourself, where the OSC Gui definitions are, check this link.

I created a OSX Lion Boot DVD (re-downloaded it from the App Store) to reinstall OSX.
After swapping the disks I pressed the d key to boot from DVD. 25 Minutes later my OSX Lion was reinstalled, time to do some tweaks to optimize OSX for SSD drivers.

I installed some tools and noticed that the system was faster, but not THAT faster. In the System information view I saw that the negotiated SATA Link Speed was only 1.5Gbps (SATA1), however my NVidia MCP79 Controller should support 3Gbps (SATA2). After some research I found the solution for the SATA 1.5 Link issue in a OCZ support forum. I downloaded an ISO image from Rapidshare (!!) and patched my SSD drive. The result was very impressive! My boot time is less than 15s and man, I never saw the Eclipse IDE start so fast.

I used XBench to create some Benchmarks. I created some benchmark with 1.5Gbps link (blue) and with the 3.0Gbps link (red), see yourself.

I use the maven-instal-plugin to deploy some I-did-not-find-them-in-public-repos libraries, the pom.xml looks like this:

Now long story short I found a bug entry on jira which was not directly
related to my issue. However due lack of options I thought lets update the aether libraries on my system. Maven v3.0.3 uses v1.11 while v1.13 is currently the latest version. Delete all v1.11 jar files and replace’em with a v1.13. Now maven works as it should. Or wait for Maven v3.0.4…

Aether binaries: http://repo1.maven.org/maven2/org/sonatype/aether/
OSX Maven v3.0.3 library path: /usr/share/java/maven-3.0.3/lib

PixelController supports well-known industry and OpenSource standards, such as Art-Net, Mini-DMX, LPD6803 and Seeedstudio’s Rainbowduino. It is quite simple to support more standards protocols like WS2801, HL1606 etc.

If the PixelController software is launched, two windows are displayed. The first window shows the internal debug buffer while the second shows the simulated output matrix.

The internal imagebuffer in this example shows three different visuals. The number of visuals displayed corresponds to the configured output:

The simulated output matrix window shows the first Visual stretched over two matrices:

There are different possibilities to control PixelController, one of them is the PureData frontend:

Another possibility to control PixelController, using the simple TCP protocol with NetCat:

How to get PixelController?

PixelController is hosted on GitHub, so

• Browse the Source
• or download a version 1.0.3
• or check PixelInvaders Website for more information

Technical Specs

More information about PixelController.
Generators:

• Blinkenlights Movie Player
• Image Viewer
• Simple Plasma
• Simple Colors
• Fire
• Metaballs
• Pixelimage
• Texture Deformation
• Textwriter
• Image zoomer
• Cell
• Plasma Two
• FFT
• Bubble

Effects:

• Inverter
• Rotozoomer
• Horizontal Beat Shifter
• Vertical Beat Shifter
• Voluminize
• Tine
• Threshold
• Emboss

Mixer:

• Add Saturation
• Multiply
• Mix
• Negative Multiply
• Checkbox
• Voluminizer
• Xor
• Minus Half
• Either

Fader:

• Switch
• Crossfade
• Slide Upside Down
• Slide Left Right

Resizer:

• Pixel Resizer
• Quality Resizer

How to control the Software:

• PureData Frontend
• OSC Server/Client
• MIDI Device/Signal
• Command Line Interface
• Simple TCP Interface
• Audio input

Operation Mode:

• Manual
• Automatic aka. Randomizer
• Predefined settings

Supported Operating Systems:

• Microsoft Windows
• Apple OSX
• Linux
• Every OS that supports a JRE

Besides the hardware, the control software was a big task. I created PixelController, a modular software written in Java and released as OpenSource on GitHub.
The frontend is written as a PureData Sketch. That means you can easily adapt the frontend and use OSC applications (like TouchOSC) or Midi devices (like Akai MPD26) to control the software.

Here’s a picture of two PixelInvaders panels, controlled by an Akai MPD26:

Two PixelInvaders Panels in action:

More information / Links:

• I set up the project site at »www.pixelinvaders.ch
• The »PixelController project on GitHub
• I you need such a panel (and who does not?) you can easily »get one at my IndieGOGO campaign

Spread the word, I need support for my Indiegogo campaign!

In this tutorial we use a strand of 20 LPD6803 RGB LED as huge VU Meter. Processing will send serial data to the Arduino which will display it.

The source can be found on my GitHub site.

Check out my PixelInvaders Shop if you want to buy some LED strands!

Take a look at ladyada’s very informative post about the LPD6803 module.

So where to buy these Intelligent, LPD6803 based Pixels? At my PixelInvaders Shop for example!

Needed Hardware:

• An Arduino Compatible Board
• A 12V Power supply (an old ATX Power supply is perfectly fine)
• A strand of some LPD6803 based LED modules
• Some cables to connect the LPD6803 module

I had some cardboard angle laying around an thought, why not build a DIY Wall Washer.

Links:
- LPD6803 LED module shop
- All source files on GitHub

Two Videos showing the Wall Washer in action. Note: The Wall Washer looks brighter in reality.

http://www.shopify.com — not free, used as reference

http://www.foxycart.com/ — only free during development
http://www.vendder.com/ — nice looking, i18n
http://www.39shops.com — nice looking, payment process it too painfull (region, taxes…)
http://tinypay.me/ — nice looking
http://wosbee.com/ — looks ugly — didn’t try
http://yokaboo.com/ — only one image per product — didn’t try
http://bigcartel.com — 5 products and one image per product — didn’t try
http://www.pipfrog.com — limit monthly visits to 3000 views — didn’t try

http://simplecartjs.com/ — js solution

do YOU have some alternatives?

Download my modified source rxtx-2.2pre5-src.zip
and the Windows and MacOSX binaries rxtx-2.2pre5-bin.zip

Here is the cvs diff.

Build RXTX library for Windows — make sure you installed Visual Studio Express.

We wrote a very simple firmware to perform some basic benchmarks — Paul wrote a simple c tool to measure the native latency, I wrote a simple tool in Java using rxtx lib to measure the latency in Java.

Long story short, here are the results:

Hint: These results are made on my MacBook (Model 5,1), Intel Core 2 Duo, 2GHz, uname output: “Darwin xxx 10.7.0 Darwin Kernel Version 10.7.0: Sat Jan 29 15:17:16 PST 2011; root:xnu-1504.9.37~1/RELEASE_I386 i386”

Conclusion:

• Java latency is at least 20ms
• The Arduino UNO may be slower than the Arduino 2009 if small a amount of serial bytes (<12b) are transferred
• The Teensy 2.0 board may be up to 18 times faster than an Arduino board

So this 20ms latency using the rxtx library looks quite promising… hmm take a look at this code snipped from the file SerialImp.c:

Replace this 20’000ms delay with a shorter (I used 2000ms), recompile and enjoy decreased latency!

Files used for this article:
- Performance test files
- RXTX TEST library, only 64b Mac OSX!

The rxtx lib is not very well tested (not at all!) — so leave a feedback if the lib is working fine for you!

Anyway, here are the results on OSX with the patched rxtx library:

Update 16.05.2011:
Paul did some more native performance tests, here are the results:

While the serial interface is not a part of the JRE (anymore), the network stack is. This means we can send network packets at full speed. And there should be some Network to Serial tools available for my Mac OSX. Nope! I found plenty of such tools, but not a single one was working:

First I checked the Arduino Playground about SerialIP. A Serial IP library for the Arduino exist — but I couldn’t find a SLIP utility for Mac OSX 10.6.6. There was once slattach — but only for pre OSX 10.6. I compiled the source myself without success.

The next step was another Arduino Playground wiki entry, about SerialNet. To make the long story short, here are the tools I tried without success:

• nc –l –p 4443 –D < /dev/tty.usbmodem621 > /dev/tty.usbmodem621
• ./ser2net –C “3001:raw:0:/dev/tty.usbmodem621:115200 NONE 1STOPBIT 8DATABITS –XONXOFF –LOCAL –RTSCTS”
• socat –d –d –d –x –s –t 30 TCP-LISTEN:4441 GOPEN:/dev/tty.usbmodem621,raw,ispeed=115200,ospeed=115200,ignoreeof
• Tinkerproxy v2.0

Socat v1.7.1.3 hints: the “nonblock” option for the serial device resulted in a “tcsetattr(3, TCSADRAIN, 0x7fff5fbfefd0): Invalid argument” error, I guess this operation is not supported by the OS. Gerhard gave me another hint, that I should use the GOPEN address type (I was using the PTY address type — this *should* create a new PTY and not open an existing one. This is a bug in the v1.7.1.3 version).

Disclaimer: Maybe I was just too stupid to use those tools correct…

The solution was a bit funky — I created a PureData patch. Whats PureData?

PureData is a real-time graphical programming environment for audio, video, and graphical processing.

But you can use it as network-to-serial relay too. Here is my patch as image:

You may download the patch here. Features of the v0.1 release:

• Autoconnect Serial Port
• Autoconnect back to your listening Server
• TCP and UDP supported (replace tcpreceive with udpreceive and tcpsend with udpsend)

Here is the processing sketch I used to test my solution:

And this is the Arduino Sketch:

Here are some performance results on Mac OSX v10.6.6, PureData v0.41.4-extended, Arduino v0022, Processing v1.2.1 — using an Arduino UNO:

Conclusion: Compared to using the rxtx JNI libraries I cannot see a huge performance boost! Sad but true. So my assumption was wrong — JNI is NOT the serial bottleneck using Arduino with the rxtx libraries. Again:

JNI is NOT the serial bottleneck using Arduino with the rxtx libraries

Side note: I read on several forum threads (mainly on the Arduino forum) that the baudrate should not matter is you use the USB version. This conclusion is just wrong! You can use my code above and run the tests with 9600 bps and 115200 bps — you’ll notice a HUGE difference!

Led Table by Sebastian Beyer:

Seeeduino Carnival entry by Janos Siklosi (ranked 3rd)

Some images by Fabius Steinberger:

Thanks for your messages guys!

If you like it — don’t forget to VOTE! for Ze Invaders! and Ze blinker!!).

I also started the Rainbowduino Wiki on garden.seeedstudio.com.

I use foamboard for the 80cm x 80cm x 20cm case and a lee filter “Heavy Frost” as a diffuser, inspired by http://jasoneppink.com/pixelator/,

Here is the final video — it’s basically a Space Invader generator — it will display a (more or less) random Invader head — inspired by “Space Invaders”:

I’m very sorry for the flickering — but its just visible by cam!

Kill ze Invaders!!

Here are some images from the build process:

…We replaced the aging FTDI chipset with a custom made usb-serial converter built with an Atmel ATmega8U2 this provides lower latency and doesn’t require to install any drivers on mac and linux…

As I don’t own a Arduinio UNO (yet) I asked in the Arduio Forum about UNO’s serial latency. Paul Stoffregen did some nice benchmarks about the Arduino boards (thanks again!), here are the results and the test-setup.

Arduino Firmware: neoLed

The results for sending 7 bytes and receive 4 bytes on Mac OSX:

So the new Arduino UNO’s serial latency is definitive better than the latency of the duemillanove.

Edit 10.2.2011:
However I use the Arduino from a Processing sketch — which uses the RXTX lib. And the RXTX lib use JNI to access the serial port — and after playing with the RXTX lib (changed some timeouts, changed JNI versions…) I guess the JNI interface adds some ms of latency. So the minimum latency using the RXTX lib was 20ms, period!

Peter also added a footnote about this measurement:

Something to keep in mind is this benchmark is only for the 7 byte TX, 4 byte RX case, and I only tested on Mac OS-X 10.5, and only for this specific C program. (I tried Linux briefly but had a lot of trouble getting Uno to work reliably). If you transmit 96 bytes, at 115200 baud between the chips, that’ll add about 8.3 ms. 96 bytes might change things for Teensy too, since that will become more than 1 USB packet.

How the software writes I/O operations also can matter greatly. In this test, I did a single 7 byte write, a single poll, and a single 4 byte read. In other testing I did with Puredata a few months ago, results varied quite a lot on each operating system. The size of the actual writes from the app to operating system matter greatly (only OS-X will combine smaller I/O operations together… Windows and Linux will happily pass single byte writes to the USB host controller, making horribly inefficient use of the bandwidth). Processing may or may not do things efficiently. It’s amazing how much difference it can make, especially on Windows due to what seems to be poor driver design. The point is differently designed software could attempt the same communication and get completely different results, especially if issues single-byte I/O operations.

Here are the test result details and test C program:

Arduino Duemilanove:

Arduino Uno:

For Teensy (with Serial.send_now() added)

The C Source to measure the latency (also done by Paul Stoffregen):

Here are some impressions:

The next step will be the case — and then add a filter, so the image will be more diffuse. When the Led Matrix is finished, I’ll release a step-by-step DIY buildplan.

Links to other LED Matrix information:

• http://spritesmods.com/?art=ledmatrix&page=1
• http://www.billporter.info/arduquee-an-arduino-powered-marquee-design-log/
• http://jasoneppink.com/pixelator/
• http://rgbledcoat.blogspot.com/
• http://tronixstuff.wordpress.com/2010/09/28/moving-forward-with-arduino-–-chapter-18-–-rgb-led-matrix/
• http://labs.ideo.com/2009/08/19/glass-block-led-wall-display/