Monthly Archive for August, 2010

LED Wall Lamp Schematics and PCB Layout

(Note: a hardware failure caused this post, originally posted August 17, to be lost…)

I’ve pretty much finalized the schematics for the wall lamps. They’re available as a PDF or as a gschem file (with a symbol for the TLC5926).

I chose TI’s TLC5926 to drive the LEDs. It is a constant current sink, so it can drive common anode LEDs. It has 16 output channels, each capable of sinking up to 120mA, and the outputs can be placed in parallel.

I decided to order some professionally-printed boards from ExpressPCB. I used their PCB layout tool (which runs fine in Linux under Wine) to create a board that could handle sinking up to a total of about 6A (roughly 2A per channel):

You can grab the PCB layout file here.

The 5926 is controlled by serial input, which should be a good way to get data over long distances. So, I wired up a DB9 connector with all of the relevant data lines that will come from the FPGA.

The boards should be here in a few days; ExpressPCB has really fast turnaround time for their MiniBoard service. I’ll end up with 6 of them, which will probably be useful if (i.e. when) I mess something up.

DIY Etching of QSOP Traces

Last week, I finally found some current sinking LED drivers that would work well with the LEDs that I chose for the wall lamps.  The TLC5926 has pretty much exactly the capability that I need to power these LED arrays.  Because the LEDs have a common anode instead of a common cathode, it is necessary to use constant current sinks instead of sources because they sit between the LED and ground.

Unfortunately, the only ones I could find in stock were in TI’s ultra-small QSOP package (other manufacturers use the term “SSOP”).  After they arrived, I realized that it would be pretty difficult to prototype with them.  Eventually, I planned to order PCBs from ExpressPCB (more on that later), but I wanted a quick way to access one of the drivers I had purchased for testing.  I started by trying some 30-gauge wrapping wire, but neither of my attempts yielded anything decent.

I then began reading about DIY PCB etching.  I’ve wanted to try this for a long time now (I even had a bottle of ferric chloride just waiting to be used).  Unfortunately, I don’t have a laser printer.  We do, however, have an old, half-broken laser copier, which decorates copied documents with ghost images and random streaks.  I couldn’t find any information on manually etching QSOP traces (they’re so small that I was almost positive either the inkjet printer or the copier wouldn’t have the resolution required to print the traces out).  So, I tried it out anyways.  I managed to print a simple breakout design and transfer it onto  the board using glossy photo paper, heating the board with an iron (on its highest temperature) for about 30 seconds, putting the transfer paper onto the board, and then just holding the iron in place for about 5 minutes.  After transferring the toner, part of the paper came off very easily, but the other piece needed to be dissolved away in water.

Next, it was time for the ferric chloride.  It’s pretty nasty stuff, so we did all of the work outside.  After about 45 minutes of swishing the board around (we should have masked more of the PCB to speed up the process), the copper had dissolved, and I washed the masked traces  off with some acetone.

Finally, it was just a matter of soldering the device onto the board.  To do this, I soldered all of the pins together and then used a wick to wipe away all the bridges, leaving nicely soldered joints.  If you saw the pictures above, you probably noticed that the traces aren’t the right size!  This is a result of the old copier we have; it somehow slightly changed the paper size.  Fortunately, it doesn’t matter for this chip, which only uses the first four pins on each side individually, while the rest of the pins are all combined together to act as one big current sink.

Surprisingly, it’s quite possible to etch QSOP-sized traces using the “standard” method of DIY PCB etching.

I’m currently in the process of testing these drivers.  In the meantime, I’ve already made an order with ExpressPCB for the actual driver boards.  I’ll post those, along with schematics for the entire wall lamp soon.

Replacing Leaky Caps in a 1992 Dodge Stealth

My mom drives a 1992 Dodge Stealth (Mitsubishi 3000GT). Despite the fact that the car is almost 20 years old, it still runs pretty well, with the occasional exception. For example, recently, the window regulator (on the driver’s side) broke and had to be fixed. Then, a few weeks later, the car would stall shortly after starting it, making a clicking noise in the process.

It turns out that one of the most likely causes for this failure is due to leakage of the electrolytic capacitors on the engine control module (ECM), the computer responsible for sparkplug timing. ECMs go for anywhere from $800-$1000, so if you can identify this problem and replace the capacitors, you will have saved quite a bit of money.

So my dad and I took apart the car, following these instructions and extracted the ECM. When we opened it up, we found that two of the caps had pretty heavily leaked on the board, while the other two (yes, there were four in this car — not sure why given that every guide I’ve seen has shown 3) were probably okay. We decided to clean the board replace all of them. Unfortunately, the board was covered in a conformal coating, and we didn’t remove the coating before working, which lead to having to fix things very carefully afterwards. I think that in the end, this would have been the best way to do things.

  1. Completely remove the conformal coating in the area surrounding (and under!) the capacitors using alcohol.
  2. Desolder the capacitors from the board and use a solder sucker to clear the barrels. Note that you need a fairly powerful iron — a standard microelectronics iron won’t work as effectively as a larger iron with a chisel tip.
  3. Clean the board with more alcohol to remove the fluid that has leaked from the capacitors. In our case, it hadn’t actually corroded the board yet, so it wasn’t necessary to repair the underlying PCB. But, it was important to ensure that all of the electrolyte was removed.
  4. Ensure that the barrels are okay. It might even be a good idea to very gently sand them to reveal a fresh layer of copper.
  5. Solder new capacitors onto the board. On our board, there were two 47uF @ 50V caps, one 100uF @ 16V, and one 22uF @ 50V. We used caps that were rated up to 105C. Use lots of flux.
  6. Ensure that all electrical connections are good. Then, inspect to make sure that the caps are mechanically sound.
  7. Clean off the flux with alcohol.
  8. Apply a new conformal coating. We used acrylic coating, but maybe urethane or silicon coating would be better. As you can see below, I inspected the coating with a blu-ray laser (UV light works well too). I chose not to coat the capacitors entirely, but that probably would have been a good idea.

Removing the conformal coating before doing anything else really is a necessary first step. I thought it wasn’t, and that heat from my iron would lift the coating easily, but it didn’t. Otherwise, we were able to create pretty decent solder joints.

Here are a few pictures of the process. Unfortunately, I forgot to take more in order to really illustrate the removal of the conformal coating, but these are sufficient. In the first two pictures, we see the leakage of the electrolyte. Next, we see the result of cleaning the area around the capacitor (again, I didn’t remove the conformal coating before desoldering like I should have). Finally, in the last two pictures, the new capacitors are safely in place and the board is ready to be installed back into the car.

Evaluating LEDs for ACRIS

I got sidetracked (what else is new) from my audio visualization project and things have been progressing somewhat slowly.  First of all, my oscilloscope has randomly decided to stop displaying channel 2, so I need to fix that at some point so that I can use my spectrum analyzer again.

Anyways, I recently received four RGB LEDs from DealExtreme.  DX sells two types, so I bought two of each to determine which one to buy for my lighting project.  The first one I saw is on a star board and is cheaper than the second, which is enclosed in its own casing.

First, a few pictures:

These pictures were taken while the LEDs were being driven with very little current.  The star emitter is supposedly rated at 350mA for each channel and when each color is driven at this current, the LED is extremely bright.  I initially anticipated needing around 20-25 LEDs for each wall lamp, but I can see that 5-10 will definitely suffice.

I think I know why the star emitter is so cheap.  It’s labeled incorrectly.  The emitter, like most others, is common anode, meaning that the + terminal is common to all three colors.  The markings on the board are indeed wrong.  The enclosed emitter is also common anode.

Here’s a graph of some preliminary tests of driving the diodes at different voltages.  I pushed the enclosed one a lot harder, so I will need to set up a more rigorous test for complete characterization of the diode.  Also, I wasn’t able to heatsink the encased emitter, but stuck the star emitter on a big block of aluminum with some thermal compound.

As is fairly easy to see, the voltage curves look very similar between the two emitter models, except for the green channel.  However, it is also important to note that at 350mA, the first LED did not get anywhere near its rated operating voltage.  I haven’t pushed it far enough to see just how much current is necessary for it to be at is operating voltage, but the diode is certainly bright enough at 350mA.  I don’t want to overly degrade the diode by pushing it too far, or my wall lights will keep breaking.

I’ll probably go with the star emitter because it’s easier to attach a bunch of them to a heatsink block.  I’ll definitely need some kind of diffuser for the lamp, though.

The enclosed diodes are great for custom LED projects where you only need one or two of them; I wouldn’t recommend it for creating a compact array, though.  I might use them in my computer case or something; I could make them change color depending on processor load.