Computer Driven Eight Channel Programmable Sequencer for Neon

You've probably, at some time or another, wanted to do a dynamic, animated neon project. The glass part of the project probably wasn't a problem, but you've maybe gotten hung up on the electronics. Well, here is a solution for you, using parts that you probably either already have, or can get hold of reasonably cheap! What is presented here is an eight channel, build-it-yourself, computer operated sequencer.

Unlike mechanical type flashers and chasers usually used in neon work, you can make this unit sequence your tubes at virtually any rate, in any order (including completely random), and with virtually unlimited sequence length! And you can change these as you see fit, with only simple program modifications.

The magic component needed is an old Apple II or IBM compatible PC. You don't need anything fancy here at all! The most anemic, handicapped, monochrome, slow, and memory poor computer will work just fine for this application. All you need to make sure of is (1) that the computer works, (2) that it has a parallel printer port, and (3) that it has the BASIC computer language program available.

You, or someone you know, may even have one of these machines buried deep in a closet somewhere, long ago abandoned because of it's lack of capacity and computing power. Because of gigantic advances made in computer technology over the years, these early machines are just about worthless on the used market, but will work just fine for our purposes. You should be able to find someone who will just give you one for free, just to get rid of it. If you have to buy a used machine, don't pay too much! Also, be sure to get all the cables, manuals and documentation that originally came with the machine from the seller.

I am writing this article oriented towards the IBM machines. If you want to use an Apple II computer (not the MACs), the hardware shown here should work fine, although the parallel port pinout is probably different. You will have to modify the software to suit your machine. As I'm not as familiar with Apples as with IBMs, I am not including software specifics for them here, however, converting the examples to work on an Apple shouldn't be too difficult. Maybe some reader will do this and write an article on it.

We are going to program our machine using the BASIC computer language. Make sure your machine has this. Most copies of DOS (the disk operating system) include BASIC. Any version (BASIC, BASICA, GWBASIC, QBASIC, etc.) will work. Note: the really early IBMs had BASIC built into the ROM BIOS (that part of the machine which tells it how to operate it's hardware). With these, you don't even need any disk drives on the machine - just the bare bones minimum.

I assume that you have enough knowledge of your machine to start up the BASIC interpreter, enter, edit, and save simple programs. If not, the tutorial manuals which come with most machines will help you here. If you don't know BASIC, don't worry. Use the sample programs included here as a starting point, and tweak them to suit your needs. Of course, the more familiar you become with your machine and with BASIC, the easier it will become to create the visual effects you want. If you are already proficient in some other computer language, feel free to use it instead.

Part 1: Building the Hardware

To use a computer to sequence neon, you need some way to connect the two together. To do this, we will use what are known as solid-state relays. These are electronic components which can switch 120 VAC power using only a small low voltage DC control signal. These components are used by the bucketload in industrial equipment, and are readily available on the surplus market. If, for some reason, you can't find them used, the new prices are fairly cheap, about a buck an amp of current rating (i.e. a 25 amp relay for $25, a 10 amp relay for $10, etc.)

The typical solid-state relay is generally shaped as a small rectangular block, with four screw terminals for connecting wires to it. You will also find them as modules which plug into a circuit card, where the wiring connections are made. Either style will work. What is important is the ratings of the relay. You need relays which (1) can control 120 VAC, at (2) 5 to 25 amps, and (3) is controllable by a 5 VDC signal voltage. Choose a current rating large enough to handle whatever size transformers you are using on your piece. Note: solid state relays are also available for controlling low voltage D.C. (i.e., 12 VDC), for switching solid state transformers, if you are using them.

I built my prototype of this project in a wooden box, with the relays mounted inside on the bottom, and four standard household duplex receptacles mounted to the top. I cut the jumper strap between the upper and lower outlet on each receptacle on the hot (gold screw) side. This gives me two independent outlets per receptacle assembly.

If you are powering a really large, Las Vegas sized piece, mount your relays on a metal plate, to act as a heat sink. If you don't need all eight channels, you don't need to mount all eight relays.

Fabricate a connecting cable using a length of multiwire round cable (with at least 9 wires) and the 25 pin female 'D' connector specified in the drawing. This cable connects the computer to the relay box. Neatly solder the cable wires to the connector, using insulating sleeving as needed to prevent shorts. Make a list of what color wire goes where. Cover the finished connector with a plastic backshell, available where you got the connector. This provides strain relief for the cable. Note: it may be cheaper to buy a prefabricated computer printer cable, and just cut off the connector at the printer end.

Connect the wires at the other end of the cable to the negative control voltage terminals on your relays (use the list you just made). Wire all positive control terminals from your relays together. This wire goes to a source of +5 volts, DC. You can get this from a number of places, including (1) inside the computer itself (the red wire on the four wire power cables to the disk drives, for example), (2) from a joystick port, if you have one (needs a 15 pin male 'D' connector, or old joystick cable to attach), or (3) from your own power supply. If you use the computer as a power source, the negative power connection is already made for you. If you are using your own supply, connect it's negative lead to the common wire from the cable.

In my prototype, I built my own power supply, using parts from Radio Shack, on a small piece of circuit board, and mounted it in the box with the relays. This keeps connections to the computer down to a minimum. Use whatever method works best for you.

Wire one terminal of the load side of each relay to each receptacle (gold screw), or if building the relays directly into your piece, directly to one side of each transformer. Wire the other relay load terminal to a source of 120 VAC. Although not shown in the drawing, putting a fuse in each of these relay leads wouldn't hurt. Wire the other side of each receptacle (silver screw) or transformer to the neutral side of your AC source. Of course, connect up the grounds from your receptacles or transformers to ground.

WHATEVER YOU DO, KEEP THE AC WIRING WELL SEPARATED FROM THE LOW VOLTAGE WIRING TO THE COMPUTER. A SHORT HERE WILL INSTANTLY TOAST THE COMPUTER!

To test the finished unit, I made eight light bulb test loads by cutting up a string of outdoor Christmas lights into individual sockets, each with a short wire lead, and then attaching a plug on each lead. These could then be plugged into the eight receptacles on my relay box.

Safety note: power should always be disconnected completely from the relays before working on your neon. This is because of the way the circuitry inside the relays work: they are never truly 'off'. There is a slight leakage current (a couple of milliamps). This is enough to create a stimulating high voltage on your transformer secondaries.

Part 2: Software

Theory of operation

A computer communicates with an attached printer by sending it codes and commands as a sequence of numbers. Each letter, digit, or symbol that the printer prints can be expressed as a numeric code. The computer treats our attached relay box similarly to the printer: by sending various numeric values to the printer port, we can turn on or off the various relays.

A computer holds numbers internally as a group of one or more bytes, where each byte contains eight bits, and each bit can have a value of either 'one' or 'zero'. Coincidence! We just happen to have eight relays under our control, one for each bit in a byte of data. All we have to do is send a series of data bytes, where each bit in the data byte indicate the desired state of it's driven relay, on ('one') or off ('zero'), to our printer port, with an appropriate time delay between each byte.

A data byte can be expressed as a numeric value from 0 (all relays off) to 255 (all relays on). Each bit in the byte (and therefore, each relay) has a numeric weight, based on a binary sequence: The first bit (relay #1) is worth 1, the 2nd bit (relay #2) is worth 2, the third bit (relay #3) is worth 4, etc., following the binary sequence 1, 2, 4, 8, 16, 32, 64, 128.

Therefore, if we want to turn on, for example, relays #1, #2, #5, and #8, we add up their bit weights, 1, 2, 16, and 128. The total, 147, is 'conditioned' (described later) and sent to the printer port, activating the appropriate relays. All other relays stay off.

These number values typically come from (1) a predetermined sequential list of data bytes (called an 'array') which you enter, or (2) can be generated on the fly, based on the value of the previous byte sent. Random sequences usually use the former method, while chase sequences use the latter.

The delay between data bytes is generated by having the computer perform some mindless task, like 'counting by ones' up to some large number (the bigger the number, the longer the delay). Again, this target number can be a constant value, an item from a list of numbers, or based on the previous number, depending on what kind of delay you want. The value needed will vary depending on the speed of your machine. You will undoubtedly need to change the numbers used in my examples to run properly on your machine.

If the delay isn't great enough, you can program two layers of counters, where you count up to some large number a large number of times. The delay is approximately the product of the two counts. On the other hand, try to avoid flashing neon faster than 4-8 times a second. The relays and transformers don't seem to like it.

One final detail: we need to tell the computer which printer port (there are three possible) to send our data bytes to. Each port is referred to by it's address. The three addresses are '3BC', '378', and '278'. The easiest way to determine which one it is, is to try them, one at a time, in the sample programs. If the address is wrong, nothing happens. By the way, if your computer has multiple printer ports, there is nothing keeping you from fabricating up to three relay boxes, for a total of 24 channels!

Example Program #1

Lets look at the first example program. This is an eight bulb chase sequence, i.e. each relay is turned on, in numerical sequence. After a set time delay, that relay turns off, and the next one turns on. This repeats for all eight relays, and then the entire sequence repeats, endlessly.

100 '----------------------------------------------------------------
110 ' title: example program #1
120 ' 8 light chase
150 '----------------------------------------------------------------
160 '
170 DEFINT A-Z
180 '
200 VALUE = 1
210 FOR I = 1 TO 8
220   GOSUB 940
230   VALUE = VALUE * 2
240   DELAY = 10:GOSUB 840
250 NEXT I
260 '
700 GOTO 200
800 '
810 ' Delay Subroutine
820 ' This subroutine wastes time
830 '
840 FOR DI = 1 TO 6 * DELAY:NEXT DI:RETURN
900 '
910 ' Output Relay Driver
920 ' Transfer relay image value to the hardware
930 '
940 OUT &H3BC, VALUE XOR &HFF:RETURN

Here's how the code gets the job done. Line 100, and every line starting with an apostrophe, is a comment line (i.e. notes written to ourselves). They do nothing in the program. You don't even need to enter them - your program will work fine. They do help remind you of your train of thought when you re-read your program six months from now.

Line 170 declares all 'variables', which are named places where a number can be stored, as 'integers'. Line 200 puts the number '1' in a variable named 'value'. Line 210 is the beginning of a 'loop', which is a sequence of code lines which are executed repeatedly. In this loop, all following lines down to line 250 (the end of the loop), are executed eight times. The 'I' variable is a counter for the loop.

Line 220 causes the program to go to line 940, do whatever is says, and then come back here. Line 940 'conditions' the number contained in the variable 'value', and then sends it to the printer port. As the current number in 'value' is 1, the first relay should turn on. Note the address of my port was '3BC'. If yours is different, change the value here. Be sure that the '&H' prefix is in front of your address number - it tells the machine what kind of number (hexadecimal) it is.

Line 230 doubles whatever number is in 'value'. 1 becomes 2, 2 becomes 4, and so on. Note this follows our binary number sequence, described earlier. Line 240 puts the number 10 into a variable named 'delay', and then goes and does whatever is on line 840.

Line 840 is our time wasting loop. It tells the computer to count from 1 to a number 6 times whatever value 'delay' contains. By changing the value put in 'delay', we can adjust the amount of time wasted. The faster your computer, the bigger a value you'll need. The number '6' is arbitrary. I chose it such that any change made to the value of 'delay' would have a noticeable effect on the delay time. You can use any value here you see fit.

Line 250 is the end of the loop. After eight passes through the loop, one for each relay, line 700 tells the program to go back to line 200 and do it all over again.

Example Program #2

Suppose we want to modify our sequence order, from relay 1, 2, 3, ..., 8 and then back to 1, to one which oscillates back and forth, i.e., 1, 2, ..., 7, 8, 7, ... , 2, 1 and then repeat.

100 '----------------------------------------------------------------
110 ' title: example program #2
120 ' 8 light oscillation
150 '----------------------------------------------------------------
160 '
170 DEFINT A-Z
180 '
200 VALUE = 1
210 FOR I = 1 TO 8
220   GOSUB 940
230   VALUE = VALUE * 2
240   DELAY = 10:GOSUB 840
250 NEXT I
260 '
270 VALUE = 128
280 FOR I = 1 TO 8
290   GOSUB 940
300   VALUE = VALUE / 2
310   DELAY=10:GOSUB 840
320 NEXT I
330 '
700 GOTO 200
800 '
810 ' Delay Subroutine
820 ' This subroutine wastes time
830 '
840 FOR DI = 1 TO 6 * DELAY:NEXT DI:RETURN
900 '
910 ' Output Relay Driver
920 ' Transfer relay image value to the hardware
930 '
940 OUT &H3BC, VALUE XOR &HFF:RETURN

Note that lines 200 through 250 are similar to the previous example. The difference is the added lines 270 to 320. While lines 200 to 250 cause the relays to sequence from 1 to 8, lines 270 to 320 sequence the relays from 8 to 1 (reverse order). Note that both code blocks use the same delay routine (line 840) and port output routine (line 940). This way, any future changes to these functions need only be made in one place.

Example Program #3

If you run example program #2, you will probably notice that the effect is visually somewhat harsh. We can soften it by having two adjacent channels active at any given time. This example activates relays in the following order: 1, 1 and 2, 2 and 3, 3 and 4, etc. The method used to implement this example is different than the previous ones. Here, we create a list (an 'array') which holds our desired sequence, and we use the counter in our loop to select which entry in the list is sent to the printer port.

100 '----------------------------------------------------------------
110 ' title: example program #3
120 ' 8 light soft oscillation
150 '----------------------------------------------------------------
160 '
170 DEFINT A-Z
180 '
200 NUMBER = 16
210 '
220 DIM SEQ(NUMBER)
230 SEQ(1) = 1
240 SEQ(2) = 3
250 SEQ(3) = 6
260 SEQ(4) = 12
270 SEQ(5) = 24
280 SEQ(6) = 48
290 SEQ(7) = 96
300 SEQ(8) = 192
310 SEQ(9) = 128
320 SEQ(10) = 192
330 SEQ(11) = 96
340 SEQ(12) = 48
350 SEQ(13) = 24
360 SEQ(14) = 12
370 SEQ(15) = 6
380 SEQ(16) = 3
390 '
400 FOR I = 1 TO NUMBER
410   VALUE = SEQ(I)
420   GOSUB 940
430   DELAY = 1: GOSUB 840
440 NEXT I
450 GOTO 400
800 '
810 ' Delay Subroutine
820 ' This subroutine wastes time
830 '
840 SOUND 32767, DELAY: RETURN
900 '
910 ' Output Relay Driver
920 ' Transfer relay image value to the hardware
930 '
940 OUT &H3BC, VALUE XOR &HFF: RETURN

Line 220 defines a array of numbers, named 'seq', 16 entries long. Lines 230 through 380 assign values to the array. Line 400 is the loop instruction. 'I' is the loop counter variable.

Line 410 sets the variable 'value' to a value from the array, as selected (indexed) by 'I'. Line 420 causes the program to call our port transmission function on line 940. Line 430 calls a new time delay function. The rest of the program is similar to previous examples.

As you can see, using an array to hold our sequence allows us to create any pattern imaginable. You could supplement this by creating a second array to hold a list of delay values, allowing different delay times for each step in the sequence. For any given sequence step, use the same index number to access each array.

We have also introduced a 'basic' trick to make the time delay more machine independent. We have used the sound function, normally used to produce a tone in the computer speaker, as a time delay device. By selecting a frequency (32767 hz) above the normal hearing range, no audible sound is emitted, but the tone period function still works, and the machine stays inside the sound function for the specified time.

Summary

The software examples presented here hardly even scratch the surface of what is possible for a creative person to do. The methods I used in my elementary examples represent only one of probably dozens of different ways to program the described sequences. You will undoubtedly find your own preferred methods. You can create sequences using a multiple of different techniques, all in the same program. There is no 'right' or 'wrong' way to write the program, as long as you are getting the results you want. Experiment! Enjoy!

NOTICE: The information presented in this article is for experimental / informational purposes only. I will not be responsible in any way whatsoever for the accuracy of this information, or accept liability of any kind for it's use.

If you have questions regarding this article, contact:

Telford Dorr
eMail

ver 1.0.5
Copyright © 1995-2019 Telford Dorr. All rights reserved.

TD links