Let us address the second point first: I had always wondered why, in a schematics application (such as Eagle), when you placed an integrated circuit, for example, the pins were not displayed in sequence. Pins 12-18 might be, for example, in the upper-left-hand corner, while pins 1, 2, 8 and 11 might be in the lower left-hand corner, with pins 3-7, 9 and 10, might be scattered to what seemed like the wind.

I have lost the actual link, but somewhere recently I read a forum posting where it was patiently explained to we non-electrical engineers, that the pins are grouped by internal logical function rather than arranged physically. Also, many integrated circuits are available in a variety of formats – through-hole and surface mount and sometimes in a variety of surface-mount formats as well, where the pin numbers are not the same.

So, what I have been drawing have been diagrams that make it easier for me to breadboard (or perf-board) circuits. While those are beneficial, rarely can they be used for anything else.

My other major gripe with schematics programs (aside from the lack of choices in the Macintosh world) was the difficulty I had in making the wires actually attach. I can’t remember any specific applications, but I definitely remember that the large part of what turned me off to schematics applications was the actual difficulty I had in making wires connect.

Further, I had deluded myself into believing that I could create PCB files that could be sent to board manufacturing companies (called “Gerber files”) by using Illustrator. I had run across a set of instructions for converting Illustrator files to Gerber files and believed they would work.

And, after extensive experimentation, I found that they did … almost. The one part that doesn’t work is the ability to put text onto the silkscreen layer. If I were building PCBs exclusively for myself, that wouldn’t be a problem, but I have envisioned that the DMX/LED matrix circuit I hope to one day design will be something that I can give back to the community, and for those types of boards, you really need to indicate component positions with silkscreened text.

So, that was out.

A few weeks back I stumbled across a conversation on a forum where folks were talking about a schematics and PCB application called DipTrace. Most of the comments were positive; there were plenty of people who said it was easy to use; it had a free version for non-profit use that topped out at 300 pins (about twice what I’d need) and it created Gerber files.

The only downside was that it ran under Windows (patooie!), not on the Mac. I do have an old Compaq sitting here that I use to test web sites out on and to run the Christmas lights, so I thought I could actually break down and try to use DipTrace on it.

I was able to go through the tutorial in about an hour and had both a schematic and a Gerber file (albeit of only seven components, but nonetheless …) to show for it.

I’ve recently begun work on a new matrix circuit and rather than draw it in Illustrator, I decided to use DipTrace. I’ll post when I have something I feel comfortable showing.

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.

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 */
	}

A few months back it became clear that this electronics thing wasn’t going to go away. I was, in fact, going to be building more circuits over time and perhaps even designing them. I had chronicled the lighting of the backyard railroad at 45mm.com, while the Christmas lights project was at PacificaLights.info.

But that scattered stuff all over the map and I didn’t have a good place to put things that fell in between. Plus, I had never installed WordPress and was interested in giving it a try (we won’t talk about the ill-fated, three-day attempt to get Movable Type to work).

Plus, I had all these iterations of the domain name dmcole — so why not use one for its own content?

I don’t expect to post here often; I don’t expect the material to be earth-shattering. I do expect it to be of mild interest to those who are interested in do-it-yourself digital lighting solutions and those who are microcontroller hobbyists.

Now, I’ve set up by blog and I’m ready to go.

Onward.

\dmc