Simplest way to propagate a digital pulse?

Throw away the clock. Call the FF in each module, MyTurn. Run a wire from that FF to the next module. On the falling edge of the input signal, clock a 1 into the local MyTurn. When that module has finished doing whatever it does, reset the FF. That falling edge will start the next module.

--
These are my opinions, not necessarily my employer\'s.  I hate spam.

I disagree with this method. All it takes is one edge getting "lost" somewhere and everything stops. What about changing your input from a pulse to a high. When a module sees a high in, it does its thing, and then propagates the high out. So: out = in and done, in and not done = start

Dan

Hi Dan,

The down side of this is that the operation time of each module isn't specified. There's no specific amount of time it takes to do anything. It comes on and stays on until I want it off. That's why I was thinking of using the pulse width to set the on time. Propagating the "on" isn't the tough part. It's propagating the amount of on time.

Regards, Max

Hi Hal,

The problem is that each module doesn't really have a finite set of tasks it does before it can turn off. It is simply on or off. (I likely wasn't clear about that.)

I just want only one on at a time in the chain. Further, I want to be able to have the time on set by the pulse that starts the whole thing, and have that "time on" period propagate as well.

Regards, Max

If you want it to propogate you'll need to store it somehow so that it can be passed on. Are the devices capable of that or will you have to add this feature? how much accuracy do you need?

Aach stage could take in a high pulse and operate while measuring the length of the pulse, and then when the pulse ends, emit a pulse of equal length to the input of the next device pulse based on its measurement of that.

you say 100 stages so I'm guessing that you'll want 1% or better precision in replicating the pulse-length.

this may be possible with an analogue circuit, but certainly is possible using a cheap microcontroller. and at 100 pieces a self contained microcontroller will probably win on price too.

Drive your 25-foot clock line with a decent (i.e., fast) rail-to-rail opamp, and terminate it properly at the far end. Use CMOS inputs for all of the modules' clock inputs, and you should be home free.

Have Fun! Rich

100 modules,

irst

e

ting pulse on

ally

You presumably also have a 'reset' line somewhere, so that this bunch of modules will do the same thing all over again someday.

As far as long clock lines are concerned, a differential driver and receiver can do it fine (like AM26LS31 and AM26LS32). You can also daisy-chain (each module receives the clock, buffers it, and sends it to the next in ripple fashion).

If you really implement the 'wait till module N is done before module N+1 starts' functionality, every single module is a point-of-failure for all the rest. That can be made to work, but this is a kind of control counter, and its state has

100 elements, so the problem is one of one hundred state bits. If a central controller turns the modules on, the problem is log_2(100), which is a seven bit state; this is usually preferable because it is easier to troubleshoot.

whit3rd wrote in news:48b94f59-7441-46bf-926d- snipped-for-privacy@q9g2000yqc.googlegroups.com:

I originally thought of using a 10-line ribbon (7 plus a few extra) cable to run down the line with a decoder at each module for the very reasons you say. I shied away from that, trading for fewer wires and parts. I'm still not sure what I should do for sure. I guess that's where prototyping comes in.