After extensive conversation with K, we settled on a parts list. Here it is:

• 24 strands
• 35 power connectors (mini-t: reg-to-strand F)
• 35 power connectors (mini-t: reg-to-strand M)
• 35 inter-cable M
• 35 inter-cable F
• 3 arduino to power bus connector
• 3 battery
• 2 chargers
• 29 power connectors (tamiya: bus-to-reg)
• 26 regulators
• 3 arduino mega
• 6 mega protoshield

And we created an assembly plan:

Steps in assembly (electrical and electronic):

1) create the power bus. Basically this is pair of 16awg wires that wrap around the back of the coat at hip length. Tails are spliced in to connect to the power connectors for the regulators (8 F mini-tamiyas), to the battery (1 M mini-tamiya), and to the arduino (1 M power jack). This is mostly working with the wire: cutting to length, stripping, attaching pieces with a heat shrink crimped butt connector (the two ends from the bus + the tail). 10 pairs of joins per coat.

1b) The F mini-tamiya plugs go on each tail that will connect to a regulator. If the related strand ends really close to the power bus, the leads from the plug go straight into the splice on the bus; otherwise, a 16awg wire runs from the power bus to where the strand begins (and where the regulator will live). [footnote 1] (lineman’s join, solder + heatshrink)
1c) One M mini-tamiya goes on the tail that goes to the battery; (lineman’s join, solder + heatshrink 3pr)
1d) one power jack goes on the tail that goes to the Arduino (screw terminal block + electrical tape)

[footnote 1: Note for measurement: as you’re figuring out where each strand starts relative to the power bus, keep in mind that you have 20-24″ of additional run. This comes from the connections that result from the tails on the mini-tamiyas, the regulator itself, and the tails on the connectors between the regulator and the strand. Detail: the mini-tamiya has a 6″ tail; with 2″ lost on each end, that’s at least 8″ added to the run between bus and regulator. The regulator itself has 7cm leads on one end, is about 5cm, then has a 15cm lead on the other end. To the regulator output, we’ll solder a power connector, and a power connector to the leads from the strand, adding 2×6″. We can trim all these substantially if the strand starts closer to the bus]

2) attach a F mini-tamiya to each set of battery leads (lineman’s join, solder + heatshrink 3pr). Note that this lead has to connect to the lead (1c) from the power bus.

3) add M mini-tamiya to each regulator input (lineman’s join, solder + heatshrink 24pr)

4) add 22awg F to each regulator output (lineman’s join, solder + heatshrink 24pr)

5) add 22awg M to each strand power (lineman’s join, solder + heatshrink 24pr)

3) create 22awg inter-strand connectors, length depending on layout (22awgx3, inter-cable connectors on each end, lineman’s join, solder + heatshrink 21triples). Some strands may connect to each other directly and therefore not need an inter-strand connecting cable. We need to know how many inter-strand cables we need, and how long.

3a) create a connector from the first strand to the arduino. (lineman’s join, solder + heatshrink 3triples). how long?

4) assemble protoshields; solder inter-cable connector to SPI pins; solder inter-cable connector to pins for touch sensor. Add potentiometer and program select switches.

5) plug it all together, and debug.

Here’s where I landed:

• 8 strands of 25 lights each
• 1 pack F batteries
• 8 regulators
• 1 arduino (the 2860 Mega because we need the additional memory)

The attached drawing gives a sense of what it will look like. Here are the design questions I have:

• Where’s the power bus? This is the big wire from the battery for power for strands and Arduino. I’m thinking of it as a 14 awg wire that runs from the left edge of the coat’s opening around the back to the right edge, roughly at hip level. Sound good?
• Where’s the battery (just one pack)? it should be within <4″ from the bus. It’s 10.5″  x 3.6″  x  1.3″, 4.4lbs.Where is the Arduino? it must connect to the power bus and the first strand, but both connections can be up to say 2′.

• For the first strand, where does it start? that is, what’s the run for the signal cable to the Arduino?
• For each strand, where is it’s starting point? This is for the run to the power bus. Good to be short where possible. One regulator goes between the power bus and each strand’s start.
• For strands 0..6, where do they end? for the inter-strand connection. There can be a cable run in between strands, up to say 2′.

Must converge soon.

The first strand came from Adafruit, yay!  There was a significant kerfluffle with UPS who lost the package, then found it, came to my office but at the last second decided that their tracking system wouldn’t let us have it, then wandered back to their warehouse in Menlo Park. Sheesh, what a PITA. Interesting, though, that on the brink of Facebook’s IPO, the (not so mean) streets of Menlo Park E of 101 seem to have more Maseratis and McLarens than is Right. They expect great things over at Sun Quentin apparently.

Still in baby steps as I figure out how to solder stuff to make connectors. I did a crude hack, got leads from the Arduino into the breadboard and thence to the strand. Blinkies were achieved!

Adafruit publishes a library for addressing the WS2801 strands, but it’s a little slow and cumbersome. Fast_SPI is a little hairier to hack, but clearly the Right Way to do it.

Some hacking was required. The Fast_SPI library isn’t very well maintained, and there were growing pains as Aduino launched v1.0. Finally I was able to get it working using mods found in the google.code’s issues thread.  Thanks, ashley.r!

The video below shows my strand running the Fast_SPI example code. This is a highly satisfying result.

Things are really going now. I’m collaborating with K, who is amazing. She can sew, which is so far beyond my capabilities I can’t even imagine how it works. And she can do good design, and seems to have a real appreciation for straight lines. I think we’re a good team.

Meanwhile back in the design, I’m struggling to solve the power problem. In short: we need a lot of power for the 200 LEDs, something like 200 @ 60 mA = 12A. That’s a *lot* to put through the LED strand. It would melt. So we need to supply power at low amps to small chunks of strands.

I had a good convo with Adafruit who sold me the first strand. Upshot: they find that lots of the LEDs bought from China are faulty, lots of testing is required, so they think it’s worth it to sell at $1.65/pixel (i.e., $40 for a strand of 25 pixels) instead of the $0.95 Boz’s Shenzhen supplier allegedly had (we never got the link so I don’t know).

The strands are 78″ stretched out. The LEDs are bigger than I expected, nearly the thickness of my index finger. Of course, 12mm, I should have realized.

Thus my sense of the topography is changing. I’m going to spend the money to get the 25-LED strands from Adafruit because this gives us a bunch of flexibility.

Still trying to figure out how many battery packs we want. Smaller packs are lighter, could be distributed around the coat, but will be a huge PITA to charge.

And then there’s the voltage problem. The batteries will provide 7-9v (depending on how I set them up). The LEDs want 5v. How to step down? A little regulator for each strand, or a big regulator for the whole power bus? Given the power efficiency needs, a simple LM7805 regulator would lose so much in heat it won’t work. I feel like keeping the voltage high to the last point would be more efficient, too. Hmm, unsolved problem.

The canonical first thing to do with an Arduino is make LEDs blink. Let’s do it. I started with the Arduino Cookbook, which is excellent but not very deep, I gobbled it in a few days.

I created first a basic LED sequence, which was easy and I was delighted by.

The programming was so simple I looked for more. I adapted some code from the Cookbook and got a more interesting pattern and an RGB LED going.

This was a very satisfying set of hacks. The Arduino Wiring language is nearly C++, and really only C if you do simple stuff. Still, I live a lot higher in the stack (e.g., R, python, bash), so getting into bits requires me to think hard. That’s the point, of course, so it’s all good.

At Burning Man, I’ve long been entranced by projects with hundreds of pixels, that is, LEDs that can change brightness and color under individual computer control. If you array a lot of these, they can do very, very cool patterns. What if we made a coat that could do the patterns? Of course, it’s been done, and Arren is way, way deeper geek than me. Still, it sounds fun, and I could learn a lot. Here we go.

I met Boz at Noisebridge, and he started me down the path with basic Arduino ideas and some wiring thoughts. I spent a few days thrashing around worrying about how to solder hundreds of tiny LEDs on top of fake fur, but that was a wrong direction. Boz pointed me at LED strands from Adafruit. These have 25 LEDs in a continuous strand. Each pixel has an LED and WS2801 chip, so each pixel on the whole strand can be addressed individually with only two wires (CLK and DATA), plus GND and +5v.

Boz also alerted me that supplying power is going to be a significant problem. Each strand of 25 LEDs will draw approximately 600 mA per LED * 25 = 1.5Ah. That’s a whole lotta power. Thinking starts.

A side note: starting about 11 years ago, I spent quite a while building desktop computers. I built maybe 10 of them for myself and others, buying the CPU, motherboard, memory DIMMs, disks, case, power supply, etc. Then I’d install gnu/linux on them, and enjoy. The point was not so much to get a cheaper computer (they were always more expensive than a comparable Dell). The point was not so much to get a computer that did not have Windows pre-installed, though that was a plus. I did it because it was fun and I liked learning how all the pieces interact. I don’t do it any more because a) I use OSX now and the hardware is utterly unhackable; and b) I use laptops. I still have a giant, ridiculously heavy, power-hungry, and now underpowered machine I use as a linux box when that’s useful.

Anyway, the coat is “for Burning Man” in the same sense that the computers I used to build were “for computing.” Yes, that’s how I’ll use it, but there were much easier paths. The journey is the way, the destination a side effect.

I’ve wanted to do hobbyist electronics for ages. I’ve been to Maker Faire, seen geeks doing cool stuff, even plinked around on a breadboard occasionally. And now I had an idea: the LED blinky-coat (more on this as it happens). First stop was Circuit Hacking Mondays at Noisebridge. I met Boz and Mitch, started talking about the idea, and Mitch suggested I build an Arduino (actually a Diavolino) from a very small starter kit. Excellent! Project #1: check.