Knight Rider Style chaser lights, using basic logic chips.

KITT Style Chaser Lights

I built this project quite a few years ago, before I got more into microcontrollers.

In this project I created a KITT (from the TV show Knight Rider) style array of chaser lights using several quite basic chips to do the work. A set of scanning lights like this is also known as a “Larson Scanner”, after Glen. A. Larson (he produced Knight Rider and Battlestar Galactica).

I’ll follow up to this blog post later by creating the same results using a much simpler hardware setup with a bit of firmware to do the magic.

Kitt Style Chaser Lights (remember Knight Rider?)

 

Here are the instructions on how to create this circuit:

I built this circuit to light up LEDs in a way similar to what KITT from the Knight Rider series did (also known as LED chaser lights). This is of course a simplified back-and-forth version which doesn’t do all of the patterns KITT did, but it’s a nice project nonetheless.

Anyhow, I hope you enjoy this circuit and the explanation thereof. I don’t have a proper schematic drawn out, but you can click on the picture to get a large image that will help you replicate the circuit for yourself.

You can zoom right in to see all the details of the connections, and it also clearly shows the labels for all of the chips.

KITT_with_labels

 

Here are the notes I made regarding building the circuit:

KITT Chaser lights

* For wire hookup details, refer to the picture.

* I’m using 5 volts on my breadboard, as that’s the requirement for the LS series of chips.

We have 16 LEDs, lit up one at a time, going back and forth on the row. It starts with LEDs lighting one after the other until it gets to the end, at which point it reverses direction – like the lights on KITT on Knight Rider.

To do this, I used the following chips:

* one 4-bit counter chip (74LS193) which has up/down counting ability in the range of 1-16, and gives a binary output.

* two 3-to-8 line decoders (74HCT138) – these chips convert binary input into a single line output.

* one NE556 timer chip – this chip is the equivalent of two 555 timers. I used one for the timer, and the other for a flip-flop (one bit of memory)

* one 74LS00 quad nand-gate chip. I used 2 of the gates to determine which counter of the 74LS193 to give the clock input to, one gate as a not-gate to invert the flip-flop output, and one gate as a not-gate to invert the high-bit (bit 4, aka “8”) of the output of the 74LS193 counter chip.

In addition to the chips, I used these parts:

16 LEDs (I think they need around 2 to 3 volts)

1 360 ohm resistor – inline with the + side of the LEDs to reduce the 5 volt board voltage down to the LED required voltage.

2 10k ohm resistors – used to turn one 555 timer into a flip-flop (1 bit of memory)

1 1k ohm resistor – for R1 of the timer

1 2k ohm variable resistor (trim pot) – I hooked up one outer and the middle pin as R2 of the timer,

to allow adustment of clock speed

1 103 capacitor on the control of the timer to avoid electrical noise caused by the timer

1 10 uF capacitor for clock speed control on the timer (C1)

How it works:

Counter chip (74LS193) outputs for 1,2, and 4 are connected to both decoder chips (74HCT138).

Counter chip output for 8 is connected to one decoder chip’s enable pin. The same output also goes to one of the nand-gates on chip 74LS00, is inverted (not gate), and that connects to the other decoder chip’s enable pin.

The outputs of the decoder chips are hooked up to the -‘ve of the 16 individual LEDs.

The +’ve of the 16 LEDs are all linked together, and hooked to +5V using the 360 ohm resistor. Since only one light is on at a time, only one resistor is required.

One side of the NE556 timer chip is set up using the regular 555 timer instructions, which I think can be found on the 555 or 556 timer spec sheets, but is otherwise easily found online. In my case, the 10 uF cap, coupled with the 1k resistor and 2k variable resistor gives me the right range of speeds I want for the chaser lights. The 103 capacitor is just to reduce electrical noise caused by the timer.

Now if you were to hook up the timer to the up-counter of the counter chip, the lights would light in sequence from start to finish, and then from start to finish again, and so on.

To make the lights reverse direction we need the flip flop, one nand-gate as an inverter (not gate), and two nand-gates used as nand gates.

The flip-flop is created from the second 555 timer on the NE556 chip using the 2 10k resistors. The set and reset of the flip-flop are connected to the first and last of the LEDs. The output of the flip-flop goes to one nand-gate used as a not-gate, giving us the regular and inverted output as a normal flip-flop has. The regular flip-flop output goes into one nand-gate, whereas the inverted output goes into the last nand-gate left on the nand-chip. The other inputs of the nand-gates are both connected to the 555 timer output, ie the clock.

The clock pulses from the timer goes to the 2 nand-gates. The value of the flip-flop determines whether the up-clock or down-clock input on the counter chip gets the clock pulses.

So at first the flip-flop is at zero and the counter up-clock makes it count up and the LEDs light in sequence until it gets to the last LED which sets the flip-flop to one, at which point the nand-gates only allow clock pulses to pass to the down-clock, which makes the counter count down and thus the LEDs light up in sequence in the other direction, until it reaches the first LED which then resets the flip-flop to zero and the cycle repeats.

Options:

I found a circuit for this online, but it used chips that I didn’t have. While I had some of the same 74xx chips, the middle part was either LS or HCT which for that circuit did not behave the same. I was able to get the lights sequencing well enough using my inverter chip with some resistors and a capacitor to make a clock which luckily enough had roughly the right speed, but it wasn’t at all tuneable and I wasn’t able to get the other not-gates hooked up to make the flip-flop work. So I had to use a separate flip-flop chip, which actually worked really well.

I also had a different counter chip. the original design had a counter chip that has one clock input and an up/down pin. My counter chip has an up-clock and a down-clock, so that required some extra logic.

I later bought some NE556 timer chips which made a world of difference. These chips are designed for accurate timing, and so it was easy to set one up to produce just the right clock speed for these lights. Using the variable resistor made it completely adjustable on the fly even. As a bonus, the 556 chips have 2 timers on one chip, and it’s easy to turn one of the timers into a flip-flop, which for this application was exactly what I needed. So I was able to replace the hex inverter (6 not-gates) chip and the flip-flop chip with just one NE556 chip.

I also had to play around a bit before I found the clock speed I needed because I didn’t have a lot of choice in small polarized capacitors. So I ended up using a 10uF capacitor and just trying some different resistors until I got to the range I wanted. After that I replaced one resistor (aka R2) with the variable resistor (trim-pot) that has a range around the value of the resistor I replaced.

So if you don’t have exactly the chips or capacitors or resistors that I used here, you can change a fair bit of it around and still get it to work.

For the 360 ohm LED resistor, I have used 1k before, which just produces a dimmer light. You probably don’t want to go much less than 360 as you might end up overloading the LEDs.

The 10k resistors for the flip flop apparently only need to be “around 10k”.

Instead of the LS OR HCT chips you can probably use any chip that has the same functionality.

Instead of the NE556 timer chip you can use a 555 timer and a flip-flop.

Instead of a 555 timer you can use a hex-inverter chip (although I found this hard to tune).

You can also make a flip-flop using inverters (not-gates) so you could use one of those chips instead. To replace the 74LS00 you can replace 2 of the gates using inverters.

So one hex-inverter chip should be able to replace the timer, the flip-flop, and 2 of the nand-gates.

Replacing the other 2 nand-gates could be trickier, as I actually use them as nand-gates, but see what chips you have and check out the logic requirements and go from there. Maybe some AND-gates and inverters will do the trick. Still, the 7400 NAND chips are probably the most versatile chip out there, so you may want to go find some – they can usualy be found quite cheaply on eBay.

I’ve also heard that old computer boards can have logic chips on them, but computers that old may very well be collectible and hard to find too.

And here are a few things I haven’t had time to explain in detail, but you can find this or similar information with a quick google search:

* how a NAND gate can be made into a NOT gate

* how a 555 timer can be made into a flip-flop, also how one side of a 556 timer can be made into a flip-flop

* how to hook up a 555 timer for the clock speed we need, also how I did one side of the 556 timer this way.

* logical diagram for the nand-gates with clock input and flip-flop input and showing how only one of the gates gives clock output.

* complete circuit diagram.

Enjoy!

Post navigation

2 comments for “KITT Style Chaser Lights

  1. September 21, 2016 at 2:13 pm

    I could not resist commenting. Exceptionally well written!

  2. March 9, 2017 at 3:50 pm

    very nice put up, i definitely love this website, carry on it

Leave a Reply

Your email address will not be published. Required fields are marked *