Sawyer v2 schematic drawn in DipTrace

This schematic is basically the one drawn by Mike Ardai (N1ist) for his Color Stick project. I changed only three major things:

• He uses surface-mount components; I have changed this to a through-hole board.
• I’ve added an on-board power supply.
• Mike’s application requires three TLC5916 constant-current drivers, while in my project only one is needed. But the Star needs the addition of a 74HC595 and UDN2981 to source to the LEDs.

Through-hole vs. SMT: While I’m hoping to get some SMT experience in the coming months, I plan to build the first versions of this thing as through-hole because that’s where my comfort level is. From my readings in the DIY Christmas lights communities, it’s clear I’m not the only one who remains uncomfortable regarding SMT. I may redesign the PCB at some later point as SMT.

Power supply: I’ve been thinking about the power supply for the Sawyer Star for a long time. The originator, David Thorpe, uses a nine-volt battery, which he says runs his stars throughout the holiday season without needing a change; I think that with the RS485 chip and off-board PWM, a battery probably won’t hold up adequately.

After seeing the on-board power supplies of Robert Jordan and Robert Martin, I briefly considered bringing household current onto the board, but ultimately decided this would be a bad idea. I decided a so-called wall wart (a wall-plug transformer) would be a better idea.

My theory here is that many people have surplus wall warts hanging around the house, which would help reduce the cost of the completed circuit.

In my initial design of this circuit, I used a standard LM7805 linear regulator. The problem with this component is that it doesn’t adequately handle current above one amp. In testing, I found that the LM7805 got really, really hot without a heat-sink and even with one I was concerned about it’s ability to work properly.

I designed a second version of the power supply using an LM317-based circuits, which while typically used for adjustable supplies, also work in fixed-voltage situations (and handle 1½-amps of current). It’s a cheap part (50-to-60-cents) and only needs a couple of resistors and a diode to complement the design.

Unfortunately, the LM317 is, like the LM7805, a linear regulator and dissipates the difference between voltage-in and voltage-out as heat, so the switch from the 7805 to the 317 gains me nothing.

Based on work done by Robert Morgan, I stumbled across the LM2576, which is a switching regulator rather than a linear regulator. As a switching regulator, it lowers the voltage by literally turning it on and off (very fast), which is a technique called pulse-width modulation or PWM. This technique is also used as a method for dimming DC-based components such as LEDs (see below).

The LM2576 works up to three amps of current but it has a problem: it has a relatively high cost ($2) and requires an inductor, which is another uncheap part (40-cents). I’m awaiting these parts (hanging head in shame: ordered the wrong versions of both the regulator and the inductor previous) and will build them up on a breadboard to make sure they work.

I’ve also added a 40-cent bridge rectifier to the circuit so that virtually any wall wart – from 9-volt AC or DC to 24-volt AC or DC – can be used, as long as it is at least one amp. I am using a terminal block to bring in that input voltage rather than the coax connector typically used for a wall wart for two reasons: again, so that any scrounged wall wart can be used and because in many applications the wire will need to be longer than the standard length provided by manufacturers.

Driver chips: The choice of the ATTiny2313 means a relatively low number of pins and a certain constraint on internal memory are available (conversely, those compromises are rewarded with a relatively low chip price: ~$2). By necessity, then, the LEDs need to be handled through driver chips. I use two of those:

• The Texas Instruments TLC5916 is an eight-bit constant current, PWM serial sink driver with eight ports. That means it can control 256 levels (the eight-bit part) of dimming (PWM), provides the LEDs with the specific current they need (constant current), are driven by a serial signal and control the negative side of eight LED circuits. A serial signal allows you to drive a relatively unlimited number of ports with only two pins on the ATTiny2313. Multiple serial drivers can be “cascaded” together by merely taking the output of the first driver and wiring it to the input of the second.
• The commodity 74HC595 is a serial shift register chip that sinks eight ports. Like the TLC5916, it can drive eight LED circuits via a serial signal; unlike the TLC5916, it doesn’t have constant current or a PWM. An array of LEDs doesn’t need PWM or constant current on both the positive (rows) side of the circuit as well as the negative (columns) side – as long as they exist on one side or the other, they’re fine. But the 74HC595 is also like the TLC5916 in that it sinks – or handles the negative side of the – the output circuit. Two negative controls won’t work, so the 74HC595 has to be supplemented with another chip that takes the sink port and turn it into a source port – the UDN2981.

One last thought about this circuit: I drew it in DipTrace, which while not the easiest program I’ve ever used, did seem to become somewhat efficient by the time I finished. After I’ve built up this circuit on a breadboard, tested it and made sure it works, then I’ll move on the the application’s printed circuit board creation ability.

Since we last spoke I threw the LED matrix project out to the Do It Yourself Christmas community to see if I could get some others interested and willing to help. I got a couple of bites and have spent the last few months working with them, trying to further my goal of building an LED star that has 60 lamps, three colors and can be driven by DMX-512. You can see the discussions.

The current circuit is based on the Atmel ATTiny2313, two 74HC595 shift registers and a ULN2803 Darlington array to handle sink current (plus an RS485 chip to handle DMX signals and associated resistors and capacitors).

Unfortunately, I haven’t been able to make as much progress as I would have liked. I have a breadboarded circuit that works, but unfortunately, it works backwards. That is, when the DMX application sends a signal to an LED to light, it is dark; when there is a DMX signal but sent to have the LED dark, it lights.

Big brains in the DIYC community haven’t been able to figure this one out, so for now I remain mired in my own ignorance.

That’s all I know right now. Stay tuned for more information.

Henne’s DMX LED matrix schematic (click to download PDF).

Anyway, I fell back on my – ahem – process: first, draw the circuit in Adobe Illustrator and then build it on a breadboard.

(I have been asked in the past why I use Illustrator and not a regular schematic-drawing application such as Eagle or McCad. My first line of defense is the same as when I’m asked why I use InDesign to make slides rather than use the ubiquitous Microsoft PowerPoint: I use the Adobe Creative Suite on a daily basis and am something of an expert with its components. I can create a schematic [or slideshow] faster with the Adobe product than with anything else. Secondarily, I think I get a much better, graphically pleasing, schematic from Illustrator.)

So, there are some changes in this version of the schematic that aren’t electronically or function-driven: instead of the 10-position DIP switch, I have substituted a 2×10 header. This will save only a few cents (around 50) on the bill of materials, but will save some space on the board as well.

These switches signal to the ATMega8515 the DMX start channel to use. They’re set infrequently (probably only once a holiday season, maybe less) and the user (probably someone as unsophisticated as me) needs only to shunt the correct pairs depending upon the channel. How do you calculate the DMX start address? Just Google “DMX DIP switch calculator”.

Also, I eliminated a couple of superfluous components, including the potentiometer, its associated resistor and the J3, J4 and J5 headers (which are now direct connections to the shift register (74HC164).

The additional set of goodies that makes this an LED matrix circuit are the shift register, serial-in, parallel-out chip (U3 – the 74HC164), which in turn drives the sink chip (U4 – the ULN2803A). The shift-register gets us six extra wires (taking the two serial ouput lines and turning them into eight), while the sink-chip (a Darlington transistor array) allows the current load to increase to 500mA per line.

Otherwise, this is the exact same circuit as the transceiver.

Because I’m overtly ambitious, I’m going to redraw this circuit one more time – in McCad PCB-ST, so that I can make Gerber files and then, onward, to a printed circuit board.

Woo-hoo.

Henne’s DMX transceiver schematic (click to download PDF).

So, I’m working on an idea (I’ll post more when I get closer to the finish) that I want to add to my Christmas lights show, and it therefore needs to talk DMX. Numerous previous postings here will tell you that would mean I’d need to do this on an Atmel chip. Though there are a lot of DMX projects done on Microchips (PICs), fewer have been done on Atmels. And pretty much everyone who has done DMX on the Atmel has based some or all of their work on that of Hendrik Hölscher.

Fortunately for those monolinguists among us, Hendrik – who goes by “Henne” – writes in both German and English. He’s also moderately active on one of the Christmas lights forums.

My initial plans were to write my own code to get my idea off the ground; a few months(!) of fiddling around and I was never even able to pull off my main effect, no less receiving DMX.

During that fiddling, I ran across a web site in Germany that sold a bare printed circuit board for Henne’s basic DMX transceiver. It took PayPal, so I bought a couple of boards. And the next time I dropped by Jameco, I took along the bill of materials for the transceiver and bought the parts.

Then life intervened. It wasn’t until earlier this month that I got back on track on this project, which started out with a redrawing of Henne’s schematic. I then wanted to build the circuit on a breadboard. The design requires an external crystal and while I knew of the potential to “brick” the 8515, I didn’t think said bricking would be quite so easy.

So easy, in fact, that I bricked two.

The problem (for me, anyway), was a lack of understanding of terminology. While I’d started out using AVRDude on the command line, I somewhere along the line stumbled across AVRFuses, a Mac application that puts a graphical user interface on top of AVRDude.

Anway, AVRFuses uses the same terminology as FuseCalc and I find (found) both of them to be opaque. Suffice it to say, the 8MHz crystal used in Henne’s design is designated as “Ext. Crystal/Resonator Medium Freq.; Start-up time: 16K CK + 4 ms; [CSEL=1101 SUT=10].”

So, another trip to Jameco and this new-found knowledge (thanks Limor) and I had a functioning 8515.

But not a functioning circuit. The version displayed here clearly shows a ground on Pin 5 of U2, the 75176B, as well as five-volt power to Pin 8. Well, apparently some schematic-drawing programs don’t indicate such niceties and the drawing I was basing my work off of didn’t. So I sat here for almost two days, banging my head against the wall trying to figure out why the breadboarded circuit didn’t work. I wonder if I would have ever figured it out without help.

As Henne says, this is a simple circuit, with virtually all the heavy lifting happening in the software of the 8515. Suffice to say, U2 (the 75176B), an RS485 transceiver, receives the DMX signal and turns it into something the UART on the 8515 can read. The 8515, in turn, processes the signal and outputs it onto pins 32-39 (unless one of the many options is chosen, in which case signals can come out of the J4 Spare port as well).

Henne doesn’t explain why he chose the 8515 – it’s a big chip, taking up quite a bit of board real estate, and it’s not inexpensive (I’m too lazy to look it up, but I’m pretty sure that last winter when I bought the first set of these chips at Jameco, they were $4.50+/-; last week’s purchase they had gone down to $3.50. I just looked them up and at Mouser and Digi-Key, they’re $5.27). But for an eight-channel project (potentially 16-channel) that has DIP-switch control of the DMX start channel (another 10 pins), this really can’t be done in less than a 40-pin chip.

(Oh, and a note on the licensing: I had included my standard Creative Commons, Noncommercial Share-Alike license on the schematic and Henne asked that I remove it. In deference to the original author, I did. None of his schematics have licenses on them and he wrote, “You cannot license the schematic under cc since its based on my schematic / hw where unauthorized commercial production is prohibited. [This is necessary if some companies produce the boards in larger quantities...] I don’t want anyone to get into trouble…” Now you know what I know.)

Using Henne’s “board.hex” testing software, the red LED flashes a steady beat once power is applied; turning on DIP 2 (or, as in my case, shorting Pin 22 to ground), the green LED should light if the crystal fuses are set correctly.

Anyway, I finally got the circuit working on Saturday. Now, to add a couple of sub-circuits and get this idea – which I’ve been working since December 2007 – afloat.

Sample schematic to connect ATMega8 to 6-pin ISP (click to download PDF)

In 2008 I learned a little about Microchip’s PIC series of microprocessors because that was the favored chip by most of the developers in the DIY Christmas lighting world. Though I didn’t actually program PICs, I did learn how to burn HEX code into them using an ADM programmer. These too, had a drawback: you had to write the code and program the chip using, ugh, Windows.

Along the way, though, I heard about the AVR series of chips from Atmel Corp., which had a distinct advantage over PICAXEn and PICs: there was a small community of people who used Macintoshes to make them go. There was a full tool-chain for programming in C (a language I had no experience in) and there were USB devices that allowed for burning the code. Well, hello, sweetheart.

So, somewhere along the line in 2008 I bought myself an USBtinyISP programmer from Adafruit Industries; today’s price in March 2009 is $22 but I think I paid a little less for it than that. I didn’t build it after I got it; the board and components sat unworking for a couple of months while I finished the Christmas lights.

But once the lights were up and running, I decided to get moving on learning to program an AVR in C (maybe someday I’ll tackle assembly code, but I’m really a path-of-least-resistance guy). My first step was to set up a breadboard and get a chip in a position to program.

And herein I ran into a small problem: I had bought a bunch of ATMega8s to learn on and lo and behold, I couldn’t find how to connect a USBtinyISP to a Mega8.

Through trial-and-error and posting questions on Adafruit’s forums, I worked out a method to hook them together, but thought it would be worthwhile to post here not only the method, but draw up a schematic as well.

I should point out that for my initial set up I used a six-pin header that I soldered to six wires, which I then plugged into the breadboard; today I would advocate buying the header adapter sold by Sparkfun Electronics. Though initially designed to be an interface between 10-pin and six-pin headers, it has been adapted to allow you to put a row of header pins into one side that can plug directly into a breadboard. They’re only a buck, so I was forced to buy some other stuff to justify the postage …

The code that I wrote for the ATMega8 is pretty rudimentary (it flashes a single LED) but I reproduce it here for full disclosure.

/* Name: main.c
 * Author: David M. Cole
 * License: 2008-2009 Creative Commons Attribution-Noncommercial-Share Alike 3.0 U.S.
 * Target: ATMega8
 * Compiler: AVR-GCC
 */
 
#include <avr/io.h>									/* A file that defines inputs and outputs */
 
void delay_ms(uint16_t x)								/* Declare substitute delay function, bring in variable x */
	{
		uint8_t y, z;								/* Declare the variables y, z */
		for ( ; x > 0 ; x--)							/* Loop while x is less than zero; decrement */
			{
				for ( y = 0 ; y < 90 ; y++)				/* Loop while y is less than 90; increment */
					{
						for ( z = 0 ; z < 6 ; z++)		/* Loop while z is less than six */
							{
								asm volatile ("nop");	/* Inline assembler code: no operation performed; i.e.: do nothing */
							}
					}
			}
	}
 
int main(void)										/* Main function; every program has a main */
	{
		DDRD = 1 << 4;								/* make Pin 6 (PortD4) an output */
			for(;;)								/* Loop like forever */
				{
					char i;						/* Define the variable i */
					for(i = 0; i < 10; i++)				/* Loop while i is less than 10 */
						{
							delay_ms(50);			/* Hang on for a moment */
						}
					PORTD ^= 1 << 4;				/* toggle the LED; if it's off, turn it on */
				}
		return(0);								/* never reached */
	}