K flip flop and ended up building one, but found it was a little bit challenging to build on a bread board because of the importance of the timing around the edge detection.

So in this video, I want to look at the 74 l s 76 which is a chip that has Jake a flip flop built on it and try to build something.

Something practical are interesting with it.

And there's other chips that have Jake a flip flops of 74 less 73 I think.

And, you know, I think pretty much anything you find.

It claims to be a Jake a flip flop.

If you've got the data sheet, you should probably be able to figure out howto had to set it up.

In this case, I've got a 74 lost 76 you can see it's got to Jake a flip flops in it.

If we just look at one of them, you've got the output.

So there's the Q output and then the Q inverted output.

And then, of course, you have the J input and the kidney and put somewhere here it is K input.

So you got the J and K in port on then that the two outputs toa que and the inverted Q.

We've also got the clock input here which, of course we want.

And you can see it's an inverted clock, which means that this is going to switch states on the falling edge of the clock, which doesn't make a big difference.

But it does mean, you know, just we should expect to see that the state change on the falling edge and they show the whole clock signal here because I think what they're implying is that, you know, after a complete clock signal, then it changes state.

And this also has a preset and a clear input.

And so pre set and clear are basically a way to ignore the clock and just set the output.

So they're active low.

You could see the little bubble here is telling us they're active.

Lowe S O.

Normally, they'd be high, preset and clear.

But if you take preset low than that, forces that Q put high, regardless of what's going on the clock or the J and K input.

So it's just kind of an override to preset Thea output and then clear is the same thing.

If you take that low, then it Then it forces the output low again regardless of what the clock or J.

R K and puts their doing and then, you know, both pre set and clear our low.

Then both the hell puts go high, and that's kind of an invalid state.

And in fact, they've cooled note for us here and says note, this configuration is non stable.

That is, it will not persist on the preset and or clear and puts return to their inactive high level.

So basically, they're telling us, Don't don't do that, but it is just kind of on override think so.

We'll send both of those high so that they're not being used.

So I accept this circuit up using this chip, and you can kind of see if I can fit it all in here.

But you can see, of course, we've got vcc and ground to provide power for chips of those air hooked up there.

And then the preset and clear are both high, which is they're inactive.

And then you can also see I've got the J and the kiddie inputs are set high.

So basically, I'm inputting No.

Ah, hi and hi to the JFK, which means that when our clock pulse comes, we'll toggle and you could see the two output my connect a clock up to our clock, which is been six.

Here you can see it's tangling with the chalk balls, and so if we look at it together with the clock, you can see it's toggle ing each time the clock is pulsing.

Interesting side effect here is if I just kind of easier to see if I take out the inverted que output.

But an interesting side effect here is that you can see the output is toggle in at half the speed of the clock.

And so this circuit is is sometimes referred to as a divide by two.

Because whatever speed the clock is coming in, the output here is that speed divided by two.

And I can get kind of interesting if we if we keep dividing by, too.

So if we take the output of the first flip flop and we use that as the clock for another and another flip flop, we see that now the second flip flop is toggle ing at half the speed of the first, which is talking at half the speed of our clock.

And of course, we can keep going.

It's now.

If we hook up two more of these, we could take the output of this one and feed it into the clock of the next one.

And then we could take the output of the next one and feed it into the clock of the last one.

And if I increase the speed of the clock a little bit, we'll see something interesting that's happening here because we're dividing by two each time.

What we've got is a binary counter.

0123456789 10 11 12 13 14 15 It's counting in binary.