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.

ATTiny13 drives 5 LEDs; programming/test circuit (click to download PDF)

I spent a lot of time with some code that had been created for a Microchip PIC12F675 but it turned out that it was merely random on-off, not fading the way a flickering candle operates. I then spent some time with a second code set, also for a PIC12F675, that did fade nicely, but which had a problem with brightness that I was never able to rectify (it is a duty-cycle issue, I know; I just don’t know how to fix it).

But that second code set did point me in the direction of how to control individual LEDs while within a loop, using bitwise manipulation.

I decided on Sunday that I had a few hours to work on this project and I wanted it finally finished. While the result is not exactly what I wanted, it will suffice.

What I’ve built is a group of four LEDs that fade in and out in an inverse manner. While LED1 fades in, LED2 fades out and LED1 and LED3 work in synch, as do LED2 and LED4. So, when LED1 and LED3 fade out, LED2 and LED4 fade in and when LED2 and LED4 fade out, LED1 and LED3 fade in. It is random enough – and fast enough – that you can’t really tell they’re working inversely.

ATTiny13 drives 5 LEDs; production circuit (click to download PDF)

The fifth LED staying on all the time helps by keeping the candle from ever going completely dark. This effect would work just as well with only three LEDs, but the two extras throw off more light.

The finished code is at the end of this article.

In the prototype I’m using 10mm warm white LEDs that are rated at 85,000 millicandles; they have a 3.3-volt forward voltage, so I’m using 100-ohm, one-eighth watt resisters between the five pins of the microcontroller and the positive leg of the LED.

I have provided two circuit schematics; one is for a circuit to program and test the ATTiny13; the other is an operational circuit. I will be using this candle on my backyard railroad; you can see how I built the other flickering lights on the railroad here and you can assume I’ll use a similar plastic-canistter/wood/glue/screws building technique for this.

These schematics don’t detail the circuit that takes the raw Malibu 12-volt AC of my layout and turns it into filtered, five-volt DC for the microprocessor and LEDS; you can rest assured I built something eerily similar to this circuit.

I will build both circuits on a piece of RS project board, though I plan to attach the LEDs with one-inch long wire in order to be able to point them in various directions.

I’ve provided a video of the LEDs, one scene where they’re running on the breadboard bare and a second with a plastic canister, to give you an idea of how they will look on the layout.

/*
* Digital candle V2
* -----------
* Use random numbers to emulate a flickering candle on five LEDs without hardware PWM 
* 
* David M. Cole <dmcole at dmcole dot net>
* License: 2009 Creative Commons Attribution-Noncommercial-Share Alike 3.0 U.S.
* Target: ATTiny13
* Compiler: AVR-GCC
*/
 
#include <avr/io.h>											// Defines pins, po
#define led1_on PORTB |= 1 << 0										// PortB0 = on
#define led1_off PORTB &= ~(1 << 0)									// PortB0 = off
#define led2_on PORTB |= 1 << 1										// PortB1 = on
#define led2_off PORTB &= ~(1 << 1)									// PortB1 = off
#define led3_on PORTB |= 1 << 2										// PortB2 = on
#define led3_off PORTB &= ~(1 << 2)									// PortB2 = off
#define led4_on PORTB |= 1 << 3										// PortB3 = on
#define led4_off PORTB &= ~(1 << 3)									// PortB3 = off
#define led5_on PORTB |= 1 << 4										// PortB4 = on
#define led5_off PORTB &= ~(1 << 4)									// PortB4 = off
 
//	Declare variables
//	==============================================
	uint8_t y, z, i, j;
//	==============================================
 
	int main(void)
		{
			DDRB = 0b11111111;								// PortB all outputs
 			for(;;)										// loop forever
 				{
					y = rand(1,255);						// bottom of first loop
					z = rand(63,255);						// top of first loop
					for (i = z; i < y; i++)						// first fade loop
						{ 
							led1_off;
							led2_on;
							led3_off;					// set up for first fade
							led4_on;
							led5_on;					// led5 is always on
							for (j=0; j < y; j++)
								{
									if (j > i)
										{
											led1_on;
											led2_off;	// turn off lamps that were on
											led3_on;	// turn on lamps that were off
											led4_off;
											led5_on;	// led5 is always on
										}
								}
							}						// end first fade loop 
					y = rand(1,255);						// bottom of second looop
					z = rand(63,255);						// top of second looop
					for (i = y; i > z; i--)						// second fade loop
						{
							led1_on;
							led2_off;
							led3_on;					// note lamps swap state
							led4_off;					// from first loop
							led5_on;					// led5 is always on
							for (j=0; j < y; j++)
								{
									if (j > i)
										{
											led1_off;
											led2_on;
											led3_off;	// and again, change state
											led4_on;
											led5_on;	// led5 is always on
										}
								}
						}							// end second fade loop
				}
		}

Schematic of circuit to fade, flicker single LED (click to download PDF)

The first solution to that problem was to modify LED tea candles — readily available at crafts stores and even Walgreens — so that they would work off of standard 12-volt garden lighting (aka: Malibu lighting).

The dirty little secret of that method is that all the tea candles flicker at the same time. I’m not quite sure why this is so — perhaps the proprietary microcontroller used in those devices is time based and since they all start at the same time, they seem to work in synch? In any event, it does make looking at all the “fires” on my layout pulse at the same time.

So, in the back of my mind, I knew I wanted something besides tea lights to make flickering light on the layout. I kept looking around the net, and in January a reader of the backyard illumination site pointed me to an Instructables that showed a circuit to increase the current that could pass through a tea light, allowing up to four LEDs to be driven in the circuit.

The Instructables site provides a “related” window in the right-rail and along with the increased current circuit there were a couple of other “LED candles” that caught my fancy.

One, which by March seems to have been removed from the site, used the concept of the linear feedback shift register to control the flickering. Unfortunately, it was written for a Pic12F675, not an AVR (reading the datasheets, I decided that an ATTiny13 would be the equivalent controller).

What I liked about this idea was that it utilized seven of the eight pins of the microcontroller — it drove five LEDs (which is five of the pins and one each for power and ground). There were other circuits on the ’Net and Instructables that used just one LED, but none used all five (this was in January).

So, I bought a handful of ATTiny13s at Jameco and set about to build the circuit and convert the code.

I didn’t really get anywhere. So, I started writing my own code. For the first shot, I decided to control just a single LED (crawl before walking).

The circuit illustrated above and the code below do that. What’s different (it turns out) from what I’ve done here and what others around the ’Net have done is that I’m fading the LED from dark to bright in a random manner.

I do this without using hardware pulse width modulation (PWM); I chose to skip hardware PWM because of the way the ATTiny13 is configured: the PWM pins are also the pins that are used for programming. To use hardware PWM I would have had to program the chip, power down the circuit, connect the LEDs, run the program and to debug, do the steps in the opposite order.

Easier to write my own PWM code, I thought …

The code makes (to my eye, at least) a more realistic candlelight flicker. But, it is just one LED and while that might be enough for somebody else, I’ve got four more pins to use in this project and I’m going to figure out how to use them.

I’m working with another developer over at Ladyada forums and I hope to have a five-LED version of fading code work on an ATTiny13 shortly.

For now, though, here’s Version 1, the single LED fading digital candle:

/*
* DigitalCandle -- Version 1
* -----------
* Use random numbers to emulate a flickering candle on a single LED without hardware PWM
*
* David M. Cole
 
* License: 2009 Creative Commons Attribution-Noncommercial-Share Alike 3.0 U.S.
* Target: ATTiny13
* Compiler: AVR-GCC
*/
 
#include 														// Defines pins, po
 
//	Declare variables
//	==============================================
	uint8_t x, y, z, i, j;
//	==============================================
 
	int main(void)
		{
			DDRB = 0b11111111;										// PortB all outputs
 			for(;;)												// loop forever
 				{
		 			x = 4;
					y = rand(1,255);
					z = rand(63,255);
					for (i = z; i < y; i++)								// the fading in loop
						{
							PORTB = 1 << x; 						// light on
							for (j=0; j < y; j++)
								{
									if (j > i)
										{
											PORTB = 0 << x;	 		// light off
										}
								}
							}								// end fade in
					y = rand(1,255);
					z = rand(63,255);
					for (i = y; i > z; i--)								// the fading out loop
						{
							PORTB = 1 << x;							// light on
							for (j=0; j < y; j++)
								{
									if (j > i)
										{
											PORTB = 0 << x;			// light off
										}
								}
						}									// end fade out
				}
		}