Streamlining and redesign

I know it's been a while since my last post (over a month now), and progress is going very slowly right now. But there has been at least some progress, even though I haven't been updating the blog.

Design
I have been talking with a friend of mine (let's call him Todd) about how to make the wall faster, cheaper, easier, lighter, and better. We came up with quite a few different ideas about what to do.

One of the biggest changes that Todd suggested was making everything less custom. His suggestion for the pixel walls was to use lots of pieces, all the same size, and all just a single pixel side long. This is a shift from the current method, which involves cutting lengths of 1, 2, 3, etc (up to 8 for the wall as it exists right now). The assembly then becomes slightly different, as I need the help of one or more jigs that hold the pieces in place as they're glued together.

Another big change we identified that positively affects price (cheaper!) and weight (lighter!) was using foam board instead of plywood for the pixel divisions. Similar to a honeycomb, many pieces of the relatively-weak foam board reinforce each other and create a rigid whole.

I found 1/4" self-adhesive velcro online, so I won't have to deal with cutting many yards of that stuff any more. The only cuts I might have to do are the edging pieces, which are small in number compared to the rest.

We also talked about many different things to test with the small 20-pixel box I'm currently making. For example:

• Do 3-color LEDs work just as well (or better) than 3 discrete LEDs? (They're certainly cheaper)
• Does a completely reflective surface work better than a flat, semi-glossy, or glossy white surface?
• Are there better or easier mounting locations for the LEDs other than the center?
• Side mounting
• Vertical orientation mounted in the floor
• Angled into the bottom, for better diffusion
  
• Can electronics be hidden inside the pixels without adversely affecting the color distribution? How much before it does?

Anyway, it was very productive, in the unproductive sort of way (nothing constructed, but things were striaghtened out in my head).

Stay tuned!

Miscellaneous Progress

Test Module
Progress continues on the smaller test module that I mentioned in my previous post.
I've got the pixel divider walls and the backing glued together, and I tested using aluminum tape on the floor of the pixels. As it turns out, Home Depot stopped carrying the 2'x4' 1/8" white marker board, and now only carry a brown version of it. It's not nearly as glossy (plus, it's brown), so I'm attempting to use the aluminum tape as a reflective agent on the floor as well.

The small number of pixels, combined with the assembly method I have, actually makes this small one not very easy to keep "true", as far as the pixel shapes are concerned. There are only 2 triangles that end up being "perfect", and they're not adjacent to each other (only kissing), so everything kinda wobbled around a little, until I got the floor glued to it.

Soldering
I started into soldering up another driver board, mainly to get myself back into things. The only components I got soldered onto the board were 2 resistors and 2 capacitors. The tip I had used for the first time around is basically useless for the very small-pitch components. It's gotten so built up with debris, and has probably had the tip melted or broken off, so it's not nearly as fine as I need it to be. I'll need to order about 5 of those bad-boys to keep me in stock.

Design
I just got a new tablet PC on Thursday and finally got that up and running. I got all of my development tools installed, brought the tablet over to the work space, and hooked it up to the processor to make sure everything works. It still does, thankfully, and having a small portable communication medium for programming it will be a great help. I also put the visualization Python code on it and tested it out for performance. It runs at about 1/2-1/3 the speed as my desktop, peaking at about 25ms per frame at the highest resolution, so I think it should be fine for "production" use.

I need to start writing more with that code, so other people can start playing around with it. It's pretty rudimentary right now, but I hope to get it to the point where patterns, shapes, text, etc. can be made as individual files and then loaded on the fly.

Media
OK, so you gotta start out small, I guess. I was contacted by one of the writer/director/producers of an up-coming short show called Center Earth about using the technowall as part of background for various scenes. Shooting is slated to start in mid April, and the wall will probably be needed some time in May-ish. There's not much more to say about it yet, but I'll keep everyone posted about progress with it.

New Space pictures

Work Space
I finally got some pictures taken of the new space. I haven't been working on the wall, really, although tonight, I layed it on the saw horses and opened it up to double-check things.

I got a dividing/pegboard storage wall built last Monday, so I finally have someplace other than the floor to store my tools.
Tonight, I also cobbled together some overhead storage for wood, so I can keep stuff out of the way a little bit better. I don't have any pictures of that, but it's pretty basic. I made it out of a single 8' 2x4, so it's obviously not too complicated.

Anywho... here're the pictures. I didn't get a shot of the table saw, for some reason, but you probably get the idea. It's basically just to the left of the 4th picture, straight back from the white bucket in the corner.


Design & Planning
I started thinking about different ways to make smaller versions of the wall for cheap. I can use just a single driver board to make a smaller 20-pixel or even 15- or 10-pixel piece (or anything under 20, I guess, really).
I can make a nice O shape with 18 pixels (the center 6 forming a hexagon, missing), but construction might be an issue. T'wood certainly be something to have fabricated for me.

The other issue would be the processor. I've briefly started looking at other Atmel processors that are in a DIP package, and there are several (too many, it seems) available. If I would make something cheaper, the goal would be to make it as simple as possible, and computer interface (real-time, anyway) would not be a feature of it. Also, I would have to make it power-friendly enough so that a wall wart adapter could work.

Even if I use the same processor I did for the big wall (which probably costs ~$50-75 in parts, currently), I could probably get the cost down to maybe $1000 for the small 18-pixel O shape.

Anyone have any comments or ideas? I'd be glad to hear them.

Microcontroller board design finished

As the title suggests, I've (basically) finished the PCB layout for the microcontroller (and associated circuitry). The main reason I haven't updated at all in the last week is that I've been working on that pretty much the entire time.

I basically finished the original layout on Wednesday-ish, but then I decided that I should probably put the ADC's on the board, mainly for cost reasons. I managed to squeeze the entire thing into 2.25"x2.25" (the LED driver boards are 1.9"x1.9"). It contains 44 components and 17 headers/connectors.
The biggest component is, of course, the microcontroller. It takes up the majority of the lower left-hand portion of the board and is bordered on two sides by headers.
The big headers J4 through J7 are the chip's 32 generic I/O ports (I'm not including P4, since it's just 2 pins and is only going to be used for the TWI).
J2 and J9 are the two interface ports, TWI and SPI. I use TWI for communicating to the driver chips, as well as the ADCs (which are placed on the same board). I'm currently not using the SPI, but I thought I should put it on there just in case I do.
There are 5 switch headers, so I can just solder some wire to them and place the switches on the frame somewhere. There is also a voltage input header, which will take voltage from the 5V power supply and a voltage/reset output header that will be sent to all of the driver boards. This voltage will be the 3.3V that the driver chips need, as opposed to the 5V that the power supply will be outputting.

I've provided 3 main images of the layout... The first being the top layer with the silkscreen mask, the second being just the top layer by itself, and the third being the bottom layer:



I've also got 2 images with highlighted regions to show some of the subcomponents.


The cyan-colored region is the current limiter for the USB port. We don't want to fry the port (especially on the computer's end), so this is a must.
The yellow-colored region is one of the 8-channel, 12-bit ADC's used for the distance sensors. Each input pin takes in an analog voltage between 0V and 2V and outputs (onto the TWI) a 12-bit digital signal based on the value of the voltage.
The green-colored region is the socket and capacitors for the crystal... not major, but I thought I'd point it out.
The orange-colored region is the voltage regulator. It will regulate any voltage (up to 40V I think) supplied to its input pin down to 3.3V. Also a necessity, since the voltage supply I need to drive the LEDs is 5V.
The blue-colored region is the second ADC. Same as the first, but I need 2 for each microcontroller.

If you haven't noticed (I wouldn't be surprised if you didn't), each layer has 2 different ground planes. The ground planes around the two ADC's are ground planes taken directly from the 5V voltage supply line instead of the digital ground from the USB and other areas. This is suggested by the datasheet for the ADC's for analog isolation. If this screws stuff up (which it might), I can always solder a jumper between the two ground planes to electrically connect them. The lower right-hand corner of the board has a short distance between two header pins of the two grounds, so it should take a very short jumper to accomplish this.

Assemblyline production (part deux)

LED Driver Boards

I must be getting better and more efficient at this soldering business.

It took me 3 hours to do boards #2 & #3 on Monday night. But by the end of board #3, my brain was kinda fried and I ended up soldering 2 of the headers on the wrong side of the chip before I realized it. It wasn't a big deal because they're just the headers for the LEDs, but it was still a screw-up.
Last night I decided to eschew the cross-pin resistance checking. I figured that it was just wasting time and probably making the solder connections worse in the end. Any sort of resistance was probably being caused by the flux and not because the solder between pins was "getting too close" to each other. I also decided to move towards a more-assemblyline approach and did 5 boards at once.

In total, it took me a shade over 3 hours to do all 5 boards.
On the top side, I spent 50 minutes doing all 10 driver chips, which included everything from fluxing the pads to doing connectivity testing and pin short testing. This comes out to being 12.5 seconds per pin. Not too shabby.
The bottom side faired even better for speed. It took me only 30 minutes to do all 10 driver chips. This comes out to be 7.5 seconds per pin, or 8 pins per minute. Basically, it was taking me about 1.5 minutes to place, align, and solder the chip, and another 1.5 minutes to test it.
Of the 480 driver chip pins that I soldered last night, there was only 1 pin that wasn't soldered correctly the first time and none of the pins were shorted. Yippie me!

I can't do any more boards at the moment because I've run out of driver chips. My initial order was only for 40 and I've used a few here-and-there for testing previously. So I need to order a few more of those before I can continue.


Wall Construction

I only spent a little bit of time on Tuesday cutting wood, but I basically doubled the amount that I had before and started on 6 more internal pieces. I realized that I need a lot more 1/2"x3" pieces and that the way I was cutting the small 5.5" pieces wasn't the way that the majority of them would need to be. Luckily, I only cut 4 of them this way (I need either 8 or 16 of them)... Wood is cheap anyway, so it wouldn't have been much of an issue either way.


Planning

I'll have to really dig into designing the microcontroller board now. I'm going to run out of stuff to do with the two current projects relatively soon, so I need to work on the other areas as well. I also need to decide on LED's. I still haven't purchased any large amounts of them or the resistors to go with them. I need to get a power cord for my power supply too, so I can test the LED's with the correct voltage.

Driver boards

Before going off into the driver boards, I did a small amount of searching online and found that the Budweiser Times Square ad has been in place since at least late 1998. As you can see in this picture:

The countdown timer says 369 days, 7 hours, ?? minutes, 24 seconds to the millenium, which puts the date of the picture somewhere about December 27th at around 5pm, 1998. The display is 16 triangles wide and about 42 triangles (41 + 2 halves) high (my approximation of 16x45 was pretty damn close). Thankfully, as this picture shows, the display can show more than just red, white, blue, and tan.
From this picture:

you can sort-of see that each triangle pixel is made up of 21 smaller hexagonal pixels (wow... nested coolness, huh?) and the nifty-looking stars they were displaying for the US flag.

Driver Boards and Soldering

Man, I'm glad I only ordered 2 of those boards and w/o silk screening or a solder mask. They look really sweet:

but I found out that the holes I specified for the headers were way too small and unusable. I had to redesign the layout slightly because the power traces I layed out couldn't fit between the largened holes any more. The design increased only 0.1" on each side and left me with slightly more room to work with (it doesn't really matter a whole lot because the minimum area for cost is 4 square inches.

I've got that basically done and I think I'm going to put in an order for about 50 or so tonight. I only need 12 for the entire wall, but I've got to plan for screw-ups. The little bit of soldering I did on one of the boards was rather troublesome. I'm getting better, but I've still got a long way to go if I want to make 12 completely-working boards. The main issues I'm having are that there ends up being non-infinite resistance between the pins. Anything under 1 MOhm, I've found, is just asking for trouble. Hopefully, the solder mask will help fix all of those issues.

Even with the holes being way too small, I was able to solder the headers on (with a ton of solder) and test the board out. Of the 4 chips soldered on one of the boards, I've only really been able to get 1 of them working properly.


Not a whole lot of progress other than that... I've got another list of random things I need to order from Digi-Key next, but they can wait until I have something else more critical to order.

Acrylic + Contact Paper = Super-Happy Fun Time

So I was informed (and it makes sense) that most people really don't have any idea what the wall will actually look like. I've talked a lot about it, but never really had any visual aide to go along with it. Well, here you go:



A small amount of explanation is in order for these pictures. The black-and-white one is fairly simplistic... just showing the pixels and the locations of the distance sensors. The heavy dark line running across the middle is the division between the two microcontrollers. One will be controlling the top half of components, another will be controlling the bottom half. The 2 zig-zag lines and the other 2 horizontal lines are meant to show how the LED driver boards are to be partitioned. Each board (with 4 driver chips) will cover a single region. Each of the 4 ADC's that I'm going to be using for the distance sensors will cover 2 rows of distance sensors.

If needed (for framerate reasons), I can also split the design up into 4 microcontroller regions, so each microcontroller has 60 pixels and 8 distance sensors. This may be a better approach, because I really have no idea how much computation or communication time is going to be needed for the ADC's. Switching over from 2 to 4 microcontrollers shouldn't be too much of an issue either. The colored plan is merely to illustrate the arrangement of driver chips to LEDs that they would be controlling. A single driver chip would be controlling all same-colored, touching triangles in a given region. So all of the bright yellow triangles on the first row are controlled by 1 driver chip, all of the darker yellow ones below it are controlled by a 2nd driver chip, etc. This makes 48 driver chips in total.


Acrylic + Contact Paper

So I picked up a smallish piece of acrylic, an acrylic knife, and a hard plastic "squegee" today for testing out my diffuser idea. First, I tried cutting the 0.093"-thick acrylic with the knife. It took about 10-20 scoring attempts before I was finally able to break it. If I were to use acrylic that thickness for the final project, I'll probably do 20-40 instead. It didn't quite shear perfectly.
After that, I attempted to apply contact paper to the thin strip I snapped off. It went OK, except that a few stray random hairs and other debris managed to get between the contact paper and the acrylic. The contact paper ripped rather easily if there is something hard under it when I was trying to remove air bubbles from under it. The effects of the rip were minimal and recoverable, but certainly not desirable.

For my second attempt, I moved to a safer area and tried to keep it as clean as possible. I was working on a much larger piece, one that required 2 full widths of contact paper to cover completely, so I had a much harder time getting it on there straight. I faired much better with debris between the contact paper and the acrylic, but it still wasn't perfect.

The results were, however, vastly superior to the paper I had been using before.
Here are 2 videos of the latest incarnation of microcontroller + driver chip test board with the acrylic and contact paper diffuser:

Dark Room (4.2MB)	Lightly Lit (3.7MB)

Of interest (that you can't tell at all from those videos) is that those 5 pixels are being driven by 2 driver chips. The first chip is driving the 2 pixels on the bottom (starting from the blank area) and the second chip is driving the remaining 3 pixels.
This setup is such that the contact paper is on the bottom side of the acrylic. I tried it the other way around (with the contact paper on the top surface) and it was far too fuzzy. My guess is that the light was getting diffused slightly through the acrylic and then hit the contact paper, which diffused it more, instead of the contact paper diffusing it completely and then the acrylic just transmitting the light. I'm no optics expert, but I do know what looks better.


Parts

I also got in another shipment of parts from DigiKey today. This shipment contained all the headers, sockets, and caps I'll need for the driver test boards that should be here on Wednesday. Progress marches on...

Driver board and parts

OK, it's been over a week since my last post again. My posts will probably be only 2-3 per week (or less, depending on how things go). It's summer and my desire to sit inside has waned slightly.

Driver Board Design

Last Friday/Saturday, I set out to design a board with 1 driver chip per board. This was fairly trivial, because it was just a single 24-pin chip, 2 resistors, 1 capacitor, and a bunch of headers (for input signals, LED power, and LED wires). The limiting factor on how small I was able to make it was the headers along the outside edge of the board. The final board for that design was 1.1" x 1.3".
Sunday/Monday, I decided to put 2 driver chips on a board. When I had computed the cost for ExpressPCB's "Production" service, they had a minimum area per board (for cost reasons) at 4 square inches, so if I ordered 48 driver boards, the per-area cost was very high. Also, I had a ton of dead space on the back side of the board (I basically didn't use it at all) and I could easily put the 2nd chip on the bottom of it without too much issue. The final size of that board was 1.2" x 1.3". I had expected it to grow a bit more than that, especially since I had switched to headers that were 2 rows instead of just 1.
Since the 2-board area was still well under 4 square inches, I decided to try to see how a 4-chip board would be. Man, oh, man was that rough to route. I placed the chips and optimized the routing so that the LED signal pins were the shortest and easiest to deal with, mainly because there are 60 on the board. What that left me was 4 chips (2 on each side of the board) basically in opposite corners all pointing at each other. While not extremely hard in itself, there are 3 common signal pins, power, ground, and a unique signal pin per chip that needed to be routed. And they all need to cross each other in the center of the board. Oh yeah, and I had to design the LED voltage source to be able to handle at least 1.2 amps (20mA per LED * 60 LEDs) so the traces needed to be pretty wide.

Here is the end result of 2-4 days of layout and tinkering:

Top + Silkscreen	Bottom	Top + Bottom

This board is 1.8" x 1.8" (which is over double the area of the 2-driver board, but this one was designed better with ground plane in mind. All of the shaded areas on those images are part of the ground plane. The thick traces running along the bottom edge of the board are able to hold at least 1A (and there's complementary traces on the top and bottom sides of the board to help distribute the power).
I ordered up 2 boards with just the "Standard" service (It doesn't have the silkscreen layer--the yellow outline in the first picture, nor does it have a solder mask--any non-via and non-contact areas are coated so the metal can't be soldered) to see how things work with it.

I also ordered a bunch of headers for the boards and a 12-bit, 8-channel ADC from DigiKey. The ADC has almost the same pin pitch as the driver chips (the ADC has a pitch of 0.65mm, which is 25.6mils) and has 16 pins, so that should be "fun" to test. With 14 distance sensors per half of the wall, that means I need 2 of those chips per half. I still really don't know how I'm going to test them, since their package is so small and I don't want to order up another batch of DIP adapter sockets. I will probably just design the board for them and see how it goes. The only major issue is that each chip is $8.10. Granted, I only need 4 of them, but if anything goes wrong, then that's potentially $16 I've wasted on lazyness.

Wall Construction Design

Since I had no suggestions about other materials to use for the pixel walls, I had to start hitting up people about any ideas they might have. One of my coworkers had a great idea of using tin to separate the pixel walls. It's light, opaque, relatively-easy to work with, and cheap. Since I need to be able to mount the distance sensors in every-other row, I need those rows to still be wood, but the off rows can be tin dividers. Also, each row's pixel divisions can be all tin as well. The outside walls will still need to be wood, as will the floor of the pixels (which will be about an inch down from the top).
To counter the fact that some rows will have a wide piece of wood and others will have a very thin piece of tin, I think the best approach is just to paint the underside of the acrylic black to make a uniform pixel boundary. I should be able to get straight-enough lines by using masking tape and then using some sort of black paint (I'm not sure which will stick to acrylic best yet... I'll take any suggestions/comments on it).

I also came up with a great idea for a different diffuser. I had some contact paper just lying around and decided one day as I was walking out the door to go to work to see how well it would work. I grabbed a roll, peeled off enough backing to stick it over a pixel, and turned the pixel on. It was amazing! Completely solid color with no "pulpy-ness" to the diffusivity. I actually kill 2 birds with 1 stone with this too. Not only does it diffuse amazingly well, it's also its own adhesive to the acrylic. I just have to stick it on and that's it. That's not to say that getting contact paper to stick to a large area without any creases or air bubbles is easy, but it would certainly be easier (and look better) than using a bunch of sheets of paper.



Once I get these test driver boards in and wire up more than 5 pixels, I will get some more cool-looking videos for everyone. (They better be cool-looking).

Progress Update

So it appears that my soldering job gets worse and worse with time.
I tried doing some code testing yesterday and I kept getting feedback voltage from the 4.5V (3 AA batteries) source into the microcontroller board. Very "not good".
I measured the resistance across the pins and it had dipped about 100X since Friday (down to ~4kOhms). I tried testing with the glued chip, but it was spotty at best and after a little bit, the chip accidentally stuck to my finger more than the adapter and popped completely off the adapter.

Thankfully, I have a new soldering iron coming tomorrow from Mouser (along with some more wick and 100 feet of 4-conductor wire). I already bought a 10-mil tip in my previous order from them and this is the iron that the tip goes with, so all should be well.

I settled in on a good size for the board. 15 pixels wide and 16 pixels high. At 5.5" on a side for the pixels, this makes the wall 3'8" wide and 6'4" high. Seems like a good size to me. A rough estimate of divider material (e.g. wood) needed is 175.5 feet. Youch. That comes out to be 48 4' pieces of wood. No only is that a lot of wood, it's a lot of weight. The outside shell should probably be wood, but the internal dividers don't necessarily need to be. I'm open to suggestions for materials, if anyone has any. It doesn't need to be super-thin (max of maybe 1" wide) and the only real requirements are that it must be opaque and must be drillable or glueable.

I spent a little bit of time fixing up the code and putting in some basic structure to deal with selecting different driver chips. Since I don't really have a good setup for testing the driver chips any more, I can only really compile it to make sure THAT works. I set up a function to deal with the 2-byte transfer method (1 address + 1 data) over TWI. I still have to make one that sends 9 bytes (1 address + 8 data) to control the LED intensity values. Just doing that really cleaned stuff up and made it so much more readable.

There won't be any more blog updates until Tuesday at the absolute earliest (most-likely Wednesday). I am taking a much-needed vacation and will be out of town until then.

Pixels galore

What a fun two days it's been.
I got my first "OTJ" injury yesterday. I was stripping the outer casing off some 6-wire phone cord with a scalpel. I got to the length that I wanted it to be stripped to and was attempting to cut off the excess casing. I was holding the wire in my left hand and cutting with my right. I was thinking about how dangerous what I was doing was and that I really shouldn't be when the blade slipped and went into my thumb. I won't get into any details, but it wasn't very bad.

Yesterday, I made 3 pixels out of cardboard, paper, & aluminum foil. The one I used in my first test was a pile of junk and just slapped together, with bad walls (they didn't go all the way up in the corners) so I wanted to make all new ones. Here's the 3 of them all spiffy-like with lighting:




That worked just fine. Here's a video of it all:
QuickTime Video (4.2MB)

Wonderful success. Only, I ran out of resistors. I had to scrounge to make the 3rd pixel even work. So off to Radio Shack I went today and picked up a few random resistors. I redid the layout on the breadboard, as it was a complete clusterfuck of wires. It's not much better now, but there's also 2 more pixels to deal with.

Videos of the action in action!:
QT Video #1 (3.8MB)
QT Video #2 (3.6MB)

So anyway, the pixels are 5.5" on a side and 1.5" tall. I'm really liking the size of the pixels; They're pretty visible, even from a fair distance away. Plus, it would be easier to make them (slightly). The 1.5" seems more than enough. If possible, 1/2" would be great, then I could hide all of the electronics behind that in a 1-2" gap, leaving the entire structure to be 1.5-2.5" deep in total. Quite nice. I'll have to stop by Home Depot or somewhere similar to look for what I can use for wood. I remember seeing 1x3" and 1x2" pieces there. They also had 1/2x3", but it was meant for stairs and was very expensive.

At this point, I really should design the driver boards and get them off and made. I'm sorta limited right now with what I can do with the driver chips and once I get those, I can test further.

I think I will have to bite the bullet and spend $140 on a new soldering iron too. Dealing with the hassle of trying to find someone to pay to do the soldering will be far worse and I think I would probably end up spending more than $140 trying to contract it out anyway.

I think at this point, I am almost ready to start designing the actual frame for the pixels. I will have to re-evaluate how large I want to make this thing (my previous count of 159 pixels was based on hexagons... it will be slightly different with triangles) and if I want to expand the design at all.

I've also been briefly toying around with the idea of having a main microcontroller whose sole purpose is to generate patterns and delegate information to the other microcontrollers. I wouldn't be able to use the TWI for that purpose, unless I figured out a way to get the other microcontrollers to disconnect themselves from the rest of the LED driver bus, which may be a bad idea in general. There is an SPI bus on the chip as well that I could use. It's still in very rough planning at this point, mainly because I only have one microcontroller to test with.

I found an 8-channel 12-bit ADC (analog to digital converter) chip that works on the I2C (TWI) bus. This would be a much better alternative to the single-channel one I had found earlier. I could use a single one of these for each microcontroller and get good coverage for the whole wall. I might have to order up one for my next Digi-Key order.

All in all, very promising results so far. Once I get a new soldering iron, I can solder up another driver chip and start testing multi-chip communication, which should be fun.

Color mixing

I put in another order with Digi-Key today. This order consists of the correct sizes of resistors and capacitors (hopefully). I also ordered a couple PLCC sockets for the uC as well as 3 uC's (just in case) and some other random sockets and headers I may or may not need.

My order of test LEDs from SuperBrightLEDs came in today.
I was hopefuly of the 3-color LEDs, but it turns out that the colors come out parallel, so that there's a small amount of overlap of colors, but the cones are all in a line and would never mix properly. Oh well, that's what testing is all about.
I also got 3 bright individual colors and used those to test instead. I had never really had a good setup to test mixing of colors; it was always just me trying to hold 3 different LEDs at 120-degree angles and all focused at the same point on a piece of paper while looking through the acrylic from the other side. Basically, a real hack job.
I grabbed some cardboard from a shipping box and cut out a square and then used a triangle pattern to form a triangle box to mount the LEDs. I lined this little box with aluminum foil and then taped a white paper triangle in the center. I cut slits in the middle of each of the walls, to hold the LEDs and... viola... this is what resulted:

Not especially snazzy, but hell, it works. Here's a bunch of pictures from the results of my test:

• Individual Colors:
  
• 2 Mixed Colors:
  
• All 3 Colors Mixed:
  
• An finally, a video of them

The white is kinda weak in the green and a little heavy in the red, but I think I can play around with that fairly easily. The top diffuser I used was just a white sheet of paper between the triangle box and the acrylic, so it's rather chunky and not really what I'm looking for in a diffuser.

component testing

Well, I spent a little time and tested the LEDs. The only 9V battery I had lying around was pretty much toast, so the LED tester didn't do a whole lot for me. I hooked 2 of the LED's up to my 4.5V test circuit that I used before and the intensity was amazing. I even think I was able to see some magenta through the sanded acrylic! Yippie!
I also tested the distance sensor. Damn, that thing is sweet. It was able to detect my hand just fine (the type of objects I wanted it to detect in the first place) and worked pretty close to the specified range. Nominal voltage was 0.2V and it peaked at about 2.4V at 10cm away. Under 10cm, it started to drop the voltage. I'm not really sure what that's all about. In the datasheet, it said the voltage is supposed to drop back down to 0.2V, but it hovered at around 1.3V.
The light sensor was really hard to test because it's a 2mm x 2mm surface mount component. I was sorta able to get it to work through some really tricky adhesive work, but the response time to go from ~4V to 0V was somewhere around 3 seconds. The datasheet has a nominal response time of < 1ms, but their test circuit had a resistor on the output pin, so that may have been my issue.
Anyway, very promising (especially the distance sensor) and hopefully, I can get a better test setup going.

parts and musings

I finally got a response from Hosfelt Electronics. I think they may have felt a little bad about taking so long. They shipped it yesterday (5/4) and it's scheduled to come tomorrow, so that's better. Yesterday, I also ordered 40 of the LED driver chips as well as a shit-ton of random stuff from Digi-Key. I knew I would need a lot of stuff from there and I already had a pretty big list of stuff picked out, so I ordered lots of surface-mount discrete components (resistors, caps, diodes, current limiter chip, voltage regulator), a few headers and connectors I figured I'd probably use, a bunch of tools for various tasks (tweezers, PCB vice, crimper, scalpel, breadboard, etc), and 2 sensors. I've been kicking around ideas about what else to do besides just lights. I can't really do touch sensors on a wall piece, so I started thumbing my way through the catalogue and came upon quite a variety of sensors. Two that struck my eye were a surface-mount illuminance photo-IC sensor and a distance measuring sensor. So I picked up one of each to give them a try.
The illuminance sensor measures about 1 to 3000 Ix and has a peak wavelength sensitivity of around 600nm. The wavelength response range is from about 350nm to about 825nm (visible light is between 400 (violet) and 700 (red) nm), so it reaches into IR a little bit (not a real issue, and could be rather useful). The output is analogue, so I'd need to send this through an ADC and then read off that.
The distance sensor is really quite sweet... I can't wait to get it so I can try it out. It's rather large (37mm x 19mm x 13.5mm tall), so that could be an issue, but I might be able to disguise it a bit. It's a nice all-in-one package. You just give it 5V and it outputs some voltage between ~0.5V and ~2V based on how close a "reflective" object is to it (I will need to experiment with how reflective objects need to be). The distance range for the one I ordered is 10cm to 80cm (4in to 31.5in), which is a pretty decent distance. Since this is an analogue output, I'd need to send it through an ADC as well.
What I'd like to do with one or both of these parts is place a few of them around the full pixel wall. With the distance sensors, I could have the wall react if anything came within range of it (and change the reaction based on how close the object was). Multiple sensors could be read to determine approximately where an object is (it could obviously be easily fooled). The distance sensors aren't exactly cheap either, so I would probably have maybe one every 1-2 feet.

I've been playing around some with the idea of using triangles instead of hexagons. Hexagons can really be thought of as 6 equilateral triangles (or 2, if you take the big one in the center and then the 3 smaller 1/3rds on the sides), so there's really no aleration I need to do to use triangles other than adjusting the side of them. The only thing that might be an issue with triangles is keeping the light diffused across the entire triangle face, especially in the corners. I'd have to make the walls thin enough (at the top anyway) to get color all the way to the edges.

Pictures added

OK, here are some pictures of the latest schematic and PCB layout top, bottom, and top+silkscreen layers. The size of this board is 2"x2", as stated in the previous post. There might be some minor tweaks to this, but it shouldn't be too drastic.

Here's a pic of what the hexagon wall currently looks (1:1 scale made with paper). The center would obviously be filled, and this is 11x14.5 pixels:



Here's a couple more pics, of the board and the engineering samples of the LED driver chips I received. Yes, 32 of those tiny chips need to be soldered! Markings on the ruler are inches, with tenths of inches in-between.


These two pictures demonstrate the before-and-after of my wonderful sanding job on the acrylic. If the pictures were better, they would demonstrate how much translucency it lost after sanding it. You can also see a slight hint of yellow in the last picture (which is what I eventually would want out of red and green LED's. The LED's I'm testing with are just pieces of crap that I had lying around.

Initial Post

This is the first post for a project I'm working on. The title is mostly a placeholder, as I haven't really figured out a name for it yet.

Anyway, the idea for this project is to create a wall hanging (or perhaps floor-standing that is next to a wall, depending on size and weight) that consists of semi-large pixels using discrete RGB LED's.

This post is going to be really big since this is about a month's worth of ideas coalescing into one post.

Current state of the project:

Physical:

• Since I've decided on regular hexagons, I also have to deal with the whole square-root-of-3 issue involved. Basically, if a hexagon (if measured from one side to its opposite) is, say, 4", then each side of the hexagon ends up being 2*side/sqrt(3), or 8/sqrt(3), or approximately 4.62" (4.6188021535170061160731902440157...). All the measuring I'm going to be doing are approximations anyway, so this shouldn't be too much of an issue.
• I'm almost positive that I will be making the pixels hexagon-shaped. This has several issues, compared to square pixels. Square pixels can be constructed fairly easily using long, straight runs of whatever building material is used. Hexagons need to have lots of individually-cut pieces attached to something (most-likely a firm backing in my case) attached at 120-degree angles.
• I've settled in on hexagons that are 3.5" across (each side is just over 2"). This seems a decent size (10.6 sq. inches) and a happy medium between constructability and nice, small pixels. As the size of the hexagons gets smaller, the structural integrity of the walls between the pixels becomes less and less.
• For the overall size of the wall, the size I've kinda accepted is 11 wide by 14.5 tall. So, first of all, an explanation of how that even makes sense. Take a regular hexagon (any will do... they're all the same) and orient it so that two of the edges are parallel to the ground. This is how all of them are oriented. Now, take a single hexagon and then place another identical one to its right, one-half pixel above it so that a single of the diagonal edges from each of them are abutted. Now, take another one and put it one-half pixel below the one that was just placed, so that there is a single edge's length distance between the 1st and 3rd pixels. Continue doing this for 11 pixels and this is how wide it is. Do this for 14 times and then take an additional 5 pixels and place them at the bottom of it, so that if the whole thing was folded over, the top and bottom edges would line exactly up. This gives us 11*14+5 = 159 pixels for the entire display.
  
• I still haven't figured out what to make the walls between the pixels, or how big they should be. I'm open to any suggestions. Wood would be the cheapest, but since I'm working with slightly small pixels, I need to keep the width of the wood narrow. This doesn't work to well with wood, but as long as I would use nails and glue instead of screws, I should be OK.
• For the outward-facing window, I found a 7'x3' piece of 1/4" acrylic at Ax-Man (I was lucky to find it). It's irregularly-shaped and about 2' of the 7' aren't really usable for a top window, so that leaves me about 5'x3'. That's fine because I can have a decent piece to test stuff out with. I also picked up some coarse- and fine-grain sandpaper blocks to use at improving the diffusivity of the acrylic. It's normally completely clear (which is what you want most of the time), so I tested sanding the clear surface down and it seems to have worked decently. I might be playing around with different things, based on how well the 1/4" works.
• I've come up with a way to map square pixels into hexagonal pixels. There's a small amount of distortion (each square pixel is stretched horizontally by about 15%) because of the whole square-root-of-3 issue again. Basically, the hexagons are split into two groups: the A-set and the B-set. The A-set gets its shade from 2 side-by-side square pixels. It takes 5/6 of the color from one and adds it to 1/6 of the color of the other to get its approximated color. For the B-set, it is slightly more-complicated (because of the half-pixel offset). Each B-set pixel gets its color from a 4-square of square pixels. It takes 5/12 of one pixel, 5/12 of the pixel directly below it, & 1/12 of each of the two remaining pixels.
  
• Now, naturally, this will look like ass on anything but a large number of pixels with a small size. So why do it at all you ask? Why even do hexagonal pixels at all? Because they're cool. That's why. Also, you can get some nice radial patterns with them, instead of the jaggy ones you see with square pixels. Hexagons are a better approximation of circles (the tightest packing of circles in a 2-d space is the same as what hexagons end up being) and they're one of the 3 regular polygons that tile perfectly with just themselves (equillateral triangles and, of course, squares are the other two). There are 3 straight lines of pixels, as compared to just 2 with squares. Granted, they're all at 120-degree separations from each other, but there are 3. Plus, squares are too easy. How am I supposed to have fun with bland-looking squares? Everything we look at is rectilinear, so why not spice it up a bit, huh? That's what I thought. So why not equillateral triangles then? Mainly, because I haven't really thought about it until now. After careful consideration, I'm not really sure myself. I will have to keep that in mind.
  

Electrical:

• After "much deliberation" (a.k.a. very little), I've decided to use Atmel's AT89C5131A-M microcontroller (uC). It is a USB C51-based Microcontroller with 32K Bytes Flash, 1K Byte Data EEPROM, 1280 bytes RAM, 7 USB Endpoints (not entirely sure what this means yet), TWI (Two-Wire Interface), SPI (Serial Peripheral Interface), UART (For RS-232), PCA (Programmable Counter Array). Of main use to me are the USB interface and the TWI (explained below). This will handle all of the signals to/from a computer and then dish other signals out to the LED drivers (over the TWI).
• For my LED driver setup, I've decided to go with Maxim's MAX6964. It's a 17-output LED driver with 4 per-channel bits of intensity control. It can sink up to 50mA per output, or 350mA max (for my uses, it will be a limit of 20mA per output). It accepts signals over a 400kbps TWI (hey, how about that... the uC I've chosen has just such outputs... I wonder if they're compatible...). What's annoying about it is that it's in a 24-pin QSOP surface-mount package (that's 25 mil [1 mil = 0.001"] spacing between the pins).
• I've ordered a few different intensities of LED's to test with, so I still haven't figured that out quite yet. No real updates here.
• To go along with the uC, I ordered (and received) a starter kit (AT89STK-05) through Digikey. The board is a pretty sweet package. It's roughly 4"x3", has RS-232, USB, TWI, SPI, and "LPC Test Mode" (not really sure about the uses for that) connectors on it, as well as 2 48-pin headers for pretty much every pin on the chip (and board) and a DC-in jack and a vertical header for a 9V power supply. There's an on-off switch, a switch to tell FLIP (explained later) how to put the data on the chip, a reset, INT0 (interrupt), ISP (In-System Programming), and USB Unload buttons for various testing purposes. There're 2 LED's for general status indication, 2 LED's for the RS-232 port (Rx & Tx), and 4 general-use LED's that are tied to some of the P3 output ports. The entire thing is clocked with a(n included) 16 Mhz crystal. All-in-all, a pretty good investment. I can do most of my testing directly with this board, instead of kludging up something on breadboard.
• The starter kit board came with FLIP (the acronym meaning eludes me and is meaningless anyway), which is Atmel's programming utility. You have the ability to program it directly through the USB port (it's also powered off the USB port). No need for RS-232, PIC programming socketes, or higher voltages. Fuck that bullshit.
• I have come up with the beginnings of a board to use in the actual wall. No way am I going to use the starter kit board in the actual installation. Because it was free, I have been using ExpressPCB's software to design the schematics and PCB. They are sorta tied together (you can load the schematic you created in ExpressSCH with ExpressPCB) and it will highlight pins on the same net, so you can visually check it for errors. The board I've got layed out is in a nice 2"x2" space, with 4 1/8" mounting holes in the corners, the PLCC-52 socket for the uC; a USB connector; a current limiting circuit for the USB port; a voltage regulator (to bring any power down to 3.3V); an external voltage input header; a crystal socket; power & ALE status LED's; TWI header pins; reset, SPI, & USB Unload buttons;regulated power, ground, & reset signal header; a switch for selecting the voltage source; and a power switch. Almost all of the design is taken directly from the starter kit electrical schematic drawings. Kudos to them for providing it. Pictures will come as soon as I get somewhere to put them.
• With 159 pixels and 3 LED's per pixel, that makes 477 LED's. Each driver chip supports up to 17 LED's. So My current approach is to do 5 pixels per driver chip, making 15 LED's per chip. 159/5 = 31.8, so I would need 32 driver chips. Each driver chip can be one of 4 unique addresses, so that would "normally" mean that I would need 8 uC's to drive the entire wall. This is A) ludicrous, B) expensive as hell (at ~$10 for each uC chip), and C) way overkill for what the uC can do. But wait, there is hope! The pin that defines the address to be used can be set to power, ground, or one of the two signal pins. Hm... what if I just connected an output port from the uC directly to this port and then just normally set each port to ground and then pulled up each driver chip individually to power as I need it. That way, I can even send the same signal to multiple driver chips at the same time! (You'd almost think I thought of this before or something). As luck (yeah... right... luck...) would have it, there are exactly 32 usable output ports on the uC (there are 34, but I am using 2 for the TWI). So with the size of the wall at 11x14.5 pixels, I can use exactly 1 uC to drive the entire thing. Crazy how it all falls into place like that ;)
  

Programming/System Integration:

• I really haven't done much in this arena yet, as it's the section that's the furthest away and the section that I'm least-worried about. I wrote a quick program in C (yay... no need to learn C51 assembly at this point) to randomly (using a wonderful 15-bit pseudo-random number generator in their stdlib library) turn the LED's on the board on and off. Very cool and very simple.