Electronics Forum / Basics / September 2006

A computer might be capable of that, but it might be cheaper to use many
microcontrollers, each with a few (10-50 depending on design) lamps and
then link them together on a bus (RS485) that is controlled from a PC.

Then the PC can send commands to each controller or to groups of
controllers. Storing preprogrammet patterens in the controllers it is
possible to make coordinatet effects on 1000's of lamps.

Holy crap! That's a hell of a wiring job. Why?

Are you talking about incandescant bulbs? Your power supply
requirements will get real ugly, in a hurry.  What is the
current required to light one of these bulbs? Multiply that
by the number of bulbs you intend to control. Ignoring
inrush current (when the filament is cold the bulb will
draw many times the current it draws when hot), your supply
will need to be capable of delivering at least that much
current.

Ed

I think what you are wanting to do is treat the bulbs as a big memory
matrix, and in that you may look into a static memory controller. The bulbs
will be the bits in the array. Each bulb will need a set/reset flip flop to
light it or turn it off. Then you will just need to send the pattern from
you pc to the crude latch board to set what lights are on and then send the
next pattern to load it.  Research into older static memory controllers. You
may have a big project on you hands. my 2c worth. JTT

First, did you realize some numbers: A thousend LEDs using 20mA each (a
common current for LEDs) require 20A of current and at 2.5V they will
produce 50W of heat? You can of course lower the current or use some kind of
matrix control (multiplexing) but at the cost of the amount of light. Most
LEDs function well enough with less then 20mA. As an alternative you may
look at low power LEDs.

To address 1024 LEDs you require 128 pieces of 8 bits registers. One
approach is using shiftregisters. The MC74HC595 for instance can do the job.
As it can provide enough current, you need only one resistor/LED. So you
will have 128 registers in series, shift in the 1024 bits and active the
latchclock pins to store the bits. You can use for pins of the parallel
output port to control data-in, shiftclock, latchclock and reset. You will
have to buffer the clocks and the reset as one output will not easily drive
128 inputs. Drawback: To change one LED you have to reload all the others as
well. You also may consider to make two strings of 64 shiftregisters and
control them simultaneously with the 8 bits output pins of the parallel
port.

To address the LEDS immediately you can use 128  pieces of 74HCT374. Also
able to provide enough current to the LEDs. But you will need an address
register and a 1 out of 128 address decoder (plus some gating) to access
them.

To avoid the huge amount of hardware, you can go multiplexing. This requires
microcontrollers otherwise the amount of standard logic required will become
enormous. As an example, a PIC16F628 can control up to 40 LEDs and can be
controlled by a serial interface using the on board UART. Drawbacks: You
will need some buffering for the rows (or columns) that have to sink the
current of eight LEDS and you loose brightness due to the relative short
time the LEDs are powered. A great deal of the software can be left to the
micro but you'll have to write it. You can build - let's say - 32 LEDs units
around the micro and make a protocol to controll them. Each unit will need
it's own address which can be stored in EEPROM.

petrus bitbyter

The below link is for a DIY setup to control 320 strings of
christmas lights from the parallel port.

http://computerchristmas.com/index.phtml?link=how_to&HowToId=4

Well, you may have a problem with thousands of Xmas lights since each
on requires about 150mA of current, so you need about 150 amps for 1000
lights all on at the same time.

I have a scaled down version I use at Christmas that controls 32 lights
from the serial port, but you can expand it by adding additional
74HC164 shift registers. The drawings showing the basic hookup for 16
lights is at:

http://ourworld.compuserve.com/homepages/Bill_Bowden/page3.htm#spr

-Bill

microcontrollers are probably the simplest solution

if the string is 10W for the string that'd be about 90mA (assuming 110V) to
light the lamps, so you'd need transistors (or something more expensive) in
there to switch the lamps as regular logic chips won't do it.

one way to handle the large number would be to drive them may be to matrix
them using diodes and drive power them from a 12V supply
(the bulbs will see actually closer to 10.5V after the diode and transistors
drops are included)  at that voltage they'll burn 17.6 times as energy
so you drive them for 1/17.6 the duration...

meaning you can do 17 columns and n (for 17 times n lamps)
rows and control them all with 17+n wires which could make the wiring
simpler.

the current will be in the ballpark of 1A so 1N4000 diodes would suit.

a microcontroller with n+6 pins and a couple of other cheap chips (shift
registers or johnson counters) to scan the columns and a bunch of transistors
17 big ones for columns and n smaller ones for the rows

and as many 1N4000 diodes as lamps (should cost less than $5us for 100 retail)
(you can use 1N4001 1N4002 etc instead - anything rated for atleast 12V 1A)

Bye.
  Jasen