Cascading Counters Video Lecture | Digital Electronics - Electrical Engineering (EE)

>> Good day.
This is Jim Pytel from Columbia
Gorge Community College.
This is Digital Electronics.
This lecture is entitled Fixed
Function Integrated Circuit
Counters and Cascading Counters.
Pay no attention to our
multicolored GTL circuit
on the upper left-hand corner.
What I want to do is talk
about the general
description of a counter.
So, the general vanilla counter,
what I've drawn is a very
simplified logic diagram
right here.
What is it?
It's a synchronous counter.
And I can tell it's
a modulus 10 counter
because it says CTR
counter, DIV 10.
What is the term modulus mean?
It means the maximum number
of counting positions.
Okay. So when I say modulus 10,
what it really means
it counts from 0 to 9.
Something with a modulus
of 10 counts from 0 to 9.
What about something
a modulus of 16?
It goes from 0 to 15.
That is a counter
with a modulus of 10.
Here is a counter
with a modulus of 16.
The outputs.
What are the outputs?
The critical thing,
what are we looking for?
It's the outputs, right there.
Those are the ones
that go from 0 to 9.
Q3, it's the MSV.
Q0, it's the LSV.
There are other outputs
which we'll go
over in a little bit here.
The inputs.
So here's an input.
It's a clock signal, obviously,
it drives the synchronous
counter and all stages
for that synchronous
counter get that same clock.
What this -- what does
this enable signal here?
What's an enable, okay?
It is allowing that clock
to count when it's enabled.
What are these other
things at the top, here?
Okay. Those are data
inputs and the load input.
Those data inputs, D3,
the MSV, down to D0.
It's kind of like a preset,
and what is the load?
Well, that is what
your presetting it to.
They're kind of like combination
of presets and clears.
Again, this is just
a vanilla description
of this whole thing here.
When the load command is
issued, I load something,
what that counter does it
takes that D3 to D0 input
and sets those outputs to
equal D3 through to D0.
Okay. So I can perhaps, you
know, start at 6, count up to 9,
and then if we -- if I
want to load that 6 again,
I'd start up at 6 and go to 9.
Okay. And additionally, I mean
if I start at 6 and go to 9,
if I'm not loading the
6 where would I go to?
I'd go to 0.
So, you could potentially
use those an inputs.
This other thing, TC,
to the right-hand side.
That's what's known
as terminal count.
It is also an output.
What terminal count in its
most general terms is it's a
signification, okay.
I've reached my maximum, or
in the case of a down counter,
my minimum count sequence.
So what that terminal
count is saying, okay,
this is modulus 10 counter
has reached its maximums.
So assumes it's an up counter.
And basically it's signifying,
hey, I'm at position 9.
And what's neat about
that terminal count in,
by the way it is called other
things, a max min position,
or a ripple count out.
There are number
of different names,
but the general terminology for
it is called terminal count.
Okay. It's reached its maximum
or minimum in that sequence,
but that can be used to enable
other devices downstream.
Okay, let's go ahead and see
what I'm talking about this.
So consider this
arrangement here,
where I 've got a
low order counter
and I've got a high
order counter.
Both of them are modulus 10,
meaning the low order will count
from 0 to 9 and the high
order will count from 0 to 9.
What's the advantage
of something like this?
Well, it's this relationship
right here.
Between terminal
count and enable.
Consider all counters
stages are currently at 0.
Okay. It's zeroed out.
Notice the clock.
It is tied to every
single one of them.
What is the terminal count
for the low order counter?
Well, it's not reached its
maximum, so it's probably low.
And it's going to count up
on that first clock signal.
Notice this high order.
It's also getting the
same clock signal.
Is it enabled?
The answer is is no.
It is not enabled.
Because the terminal count for
the low order is still low.
Okay. What happens when the
next clock signal counts
to 2, 3, 4, 5, 6, 7, 8, 9.
It has reached its
maximum, the low order,
at which point the high
order is finally enabled
and the next clock
signal what happens?
Well what happens is the
low order recycles to 0
and the high order is
incremented up to 1.
If you could imagine
what's going on here,
and I know this is --
we're going to have to
read from right to left.
It's going 00.
And then it goes to 01,
all the way up to 02,
all the way up to 09, the
next clock pulse comes along,
what have we incremented up to?
10. 10. Okay.
For again, we're reading it
backwards, right to left there.
Next clock sequence,
what happens?
11, 12, 13, 14, 15,
16, 17, 18, 19.
The terminal count goes high,
the next high order
counter is enabled.
Next clock pulse, 20.
What are we creating here?
We're creating a basically
a cascaded arrangement
between two modulus 10 counters,
which enables us to create,
if this is a whole big box here,
it's a modulus 100 counter,
which will count
from 00 up to 99.
You want to create a
1000 modulus counter,
add another modulus
10 counter at this end
which is enabled
by this high order.
So these cascading arrangements
for fixed function integrated
circuit, you can use them
to create a higher count
sequences than what they are by
and in and of themselves
capable of doing.
So quick note about the
terminal count signal
for a modulus 10 counter,
that goes high or is asserted,
pretend that you know it
could be an active low signal.
It either could go low,
that drives me crazy, too.
It only is asserted
a 1/10 of the time.
So this clock frequency
that's come in in,
let's just do a very
simple example.
It's a 100 hertz clock.
Every 10 that is asserted,
what is the frequency of this?
It's 10 hertz.
And then, it is a 1/10
for this higher order one.
It's a 1/10 of its
input enabled.
So what is that?
That's 1 hertz.
So with modulus 10
counters we are capable
of doing frequency
division by 10.
Whereas previously if we were
stuck with a modulus 16 counter,
by using those previous stages
Q0, Q1, Q2, Q3, we were limited
to 1/2, 1/4, 1/8, 1/16,
basically a power of 2,
we could potentially divide
our clocks by 10 in this case,
using a modulus 10 counter.
So that vanilla description
right there for counter.
It's going to serve for a
general -- general purposes.
Now let's just talk about
some specific counters here.
Okay. Notice I did not have an
up or a down input to this one.
There are fixed function
integrated circuits
that have basically two
modes, up mode and down mode.
If it's a modulus 10
counter in up mode it counts
from 0 to 9 and recycles.
If it's a modulus 10 counter
that's in down mode it counts
from 9 to 0 and recycles.
Okay? As you'd expect.
The two fixed function
integrated circuits very
commonly used is the
74190 and the 74191.
Okay. The 74190, it's a decade
counter, i.e., a modulus 10.
It counts from 0 to 9
or 9 to 0, as we'll see.
It's an up down counter.
74191 it's a 4-bit binary,
full sequence up down.
What's awesome about
these things,
they have the same pinouts.
Okay. Now let's go ahead and
look at our pinout diagram
and all the things in green.
Those are our inputs.
All the things that are in
yellow, those are our outputs.
All the things that are in
pink are things that are --
make this thing work and without
them they're not going to work.
PIN 8 and 16 obviously are
VCC and ground connections.
Let's go ahead and
look at our outputs.
PIN 7, 6, 2 and 3.
Those are our count
outputs from MSB to LSB.
QD, QC, QB, QA.
What's PIN 12 and 13?
That's kind -- it's kind of
two terminal count outputs.
The max min.
It goes high when it is at
its maximum in an up sequence.
It goes high when it's at its
minimum in a down sequence.
So if it's counting from 0 to
9, obviously it's an up mode,
again, for 74190 we're
talking about here.
When it reaches 9
that goes high.
What's number 13, well
that's what ripple count out.
Okay, its, notice the
bar over the top of it.
That goes low once it's gotten
to its maximum position,
or minimum positioned
depending on which mode it's in,
but it's only asserted
fora brief moment.
So I'll show you in
the timing diagrams
within the datasheet
what I mean by that.
Okay. What are our inputs there?
Those are all of the greens.
Where's our enabled?
Well it's PIN 4.
Count enable with a bar over it.
It's active low enable.
So I have to have a 0 on PIN 4
to even get this
thing to work at all.
PIN 5, what is it?
It's a single pin
with two inputs on it.
Okay what does that mean?
Well, if it's a single
pin, it's binary.
0 or 1. When it's a
0 what mode is it in?
It's in up mode.
Because notice the
bar over the up.
When it's a 1, what
mode is it in?
It's in down mode, because
there's no bar over it.
You've got two choices.
Mutually exclusive, and
you can neither go up
and down simultaneously.
You can only down or
you can only go up.
What are the other inputs?
Obviously our clock, PIN 14.
What are the data inputs?
You know in our general -- in
our general diagram over here,
D3 down to D0, our specific
diagram, this is a --
somebody's made this thing
and it's got its own
pinouts and pinins.
Well, where's 9?
PIN number 9 is our D3.
It's called D. PIN 10, that's C.
PIN 1 is B. PIN 15 is A. That's
corresponding to
our data inputs.
Okay. How do I preload those?
Well, with PIN 11.
Okay. If PIN 11 goes low, I
load D, C, B and A onto QD, QC,
QB, and QA, respectively.
Well I've talked about some of
the basic terminology of this.
Basic configuration
of basic counter.
Talked about specific counters
there, and the only difference,
when, again, between the 74190
and the 74191 is you go ahead
and put the 74190 in up mode
and let it count,
it goes from 0 to 9.
Put the 74191 in up mode
and it counts from 0 to 15.
Let's look at the
datasheet specifically.
I'm just going to show you
some pretty neat things
about a datasheet of
the full datasheet.
If you look at these things,
the datasheets tell you
how these things work.
And this is one of
those things I --
I just can't do all the
TTL datasheets for you.
Just grab it.
Just grab the TTL.
Go grab a datasheet and just
look at it and start looking
at how these things work,
because it's really neat.
74190 and 191 on the datasheet
they actually have example wave
forms to see how these work.
So let's go ahead and
take a look at a datasheet
and we'll describe
exactly what I did here.
Here is the 74190 and
the 74191 datasheet,
and that's showing us our
pinout configuration and again,
what is it showing
us right here?
Its main function?
It's going to count, 8, 4, 2,
1, B, C, D, that's the 74190.
Or binary.
That's the 74191.
It's got an up or down mode.
It's got a count enable.
I need to turn the whole thing
off or turn the whole thing on.
It's going to have a ripple
output four cascading just
like we talked about there.
There's basically a terminal
count output in the form of RCO
and max min that could
potentially enable
another device.
And additionally it's talk
about asynchronously
resettable with a load control.
That's when load goes low,
those D inputs are brought
to the Q outputs, and again
what are those outputs?
Well they're parallel.
You know, you don't have to wait
for a serial stream
of data to come out.
They're all simultaneously
available.
And then cascadable, again,
for N-bit applications.
When that letter N is in there,
it's for how many N's you want.
How many -- how many -- what's
your -- your larger modulus.
So let's go ahead and
skip over to page 4
for this guy, excuse me, page 5.
So page 5 on the 74190
74191 datasheet here.
This is where the
money's at, here.
Just by looking at this
diagram here I can figure
out how this thing works.
This is for the 74190.
The decade counter.
Notice at this moment here it
is given in active low load.
What is its loading?
It's loading 0, 1, 1, 1 i.e., 7.
What happens?
Well obviously our output
should go 2, 0, 1, 1, 1 i.e., 7.
So that's what it's showing you.
It's showing you
an active low load.
Take those data inputs, load
them on with the outputs,
and what is all this
stuff right here?
It means it doesn't matter
because it doesn't matter what
some of these data inputs.
It never goes low again.
Okay? Never load anything again
for this particular sequence.
Notice here we've
got account enable.
It's enabled because it's low.
It's not enabled.
Look what it's telling you.
It's inhibiting count
operations.
Okay. And at which point it goes
low again, it will be enabled.
Notice here, too, here
is our other input.
Down and up.
It's two choices.
What is it mean, here?
Okay. See, D has no bar over it.
U has a bar over it.
So it's active low up.
So between for this
section right here,
as long as it's enabled,
it will count up.
For this section here, as long
as it's enabled,
it will count down.
So we start it at 7, we are
enabled, what does it do?
We're in up mode.
We count to 8.
Look at what happens to
our maximum minimum there.
It's telling us decimal 8.
How can I read that?
It's 1, 0, 0, 0.
That's what that
means, right there.
Now I count up again.
I go to 9, 1, 0, 0, 1.
Notice what happens
to maximum minimum.
I'm at the maximum my count
sequence, because we're at --
we're at a decade counter.
Notice what happens to RCO.
It goes low but it's
a brief pause.
Okay. Whereas maximum
and minimum goes high
the whole time it's 9,
RCO goes low only
for a brief moment.
That could potentially,
because it's active low,
be used to enable another
active low enabled device.
Like another 74190.
Again, we are in count up mode.
We go to step 0, 1, 2.
We are inhibited.
We stay at 2.
We're at 2, now we're
in down mode, though.
The next positive edge,
we were at 2, we go to 1.
Now we go to 0.
What happens to RCO?
It goes low.
What happens to maximum
and minimum?
It goes high.
Okay? It's -- those are kind
of your combined terminal
count outputs there.
It's telling us it's at
either the maximum or minimum.
Again max positive
edge comes along.
We are in down mode.
We're currently at 0.
What to do?
It recycles to 9.
It goes to 8.
It goes to 7.
And again if you want
those binary inputs
for the decimal equivalent,
where are they?
They're right here.
QD, QC, QB, and QA.
So not only does the
datasheet give you those pinout
configurations, it's also giving
you the how this thing functions
in addition to all
that performance data.
As we wrap our lecture on fixed
function integrated circuit
counters and cascading
counters I would be remiss
if I did not include this
example here that has appeared
in pretty much every
digital electronics textbook
since the Roman Empire.
This is the classic
digital clock application
of cascading counters.
What we've got in the
upper right-hand corner is,
assuming 60 hertz AC,
not certain if the
Roman's had 60 hertz AC,
if they had something
different they'd have
to do a little bit different
here, but what we're feeding it
to is what's called a
wave shaping circuit.
You may have done this already
in semiconductor
devices and circuits.
If not, you'll probably
do it this quarter.
But what it's creating, it's
creating the same frequency.
Okay. So that output
still has 60 hertz output.
However, it's TTL compatible.
It goes from 0 to 5 or in --
this if you wanted to do CMOS
because you're 0 to 3.3.
But again, its frequency
is still the same.
It is no longer 0 centered.
So we've got 60 hertz AC being
fed into our weave shaper,
and we've got 60 hertz 0 to
5 TTL compatible coming out.
What is it being fed into?
It's being fed into a modulus 10
counter and a modulus 6 counter.
What is that whole
thing taken together?
It's a modulus 60 counter.
That counts from 00 to 59.
Okay. It's modulus 60.
So if you look at the -- the
terminal count right there,
that goes high every 10 times,
that's 1 of every 10 times
that the low order counter
goes through its sequence.
So what is its frequency?
It's 6 hertz.
Okay, what's the output here
for the terminal cutoff?
The modulus 6 counter because
again it goes from 0 to 5,
it's going high when it reaches
5, i.e., once every 6 of them,
so what is the frequency there?
It's 1 hertz.
So one cycle per second.
That is now our new clock.
That's the green light.
Look at this.
That green clock,
the new green clock,
which has been generated has
now being fed to our hour,
minute and second display.
And what we're showing
here is again,
is three separate sections here.
I've got seconds,
minutes, and hours.
They're all being
clocked simultaneously.
What is the seconds?
It's a modulus 60 counter,
consisting of a 10 and a 6.
When that low order is enabled
the terminal count goes high
every 10th of a time,
so it counts from 0 to 9
at which time the higher order
second is enabled and it goes
to 10, 11, 12, all the way
up to 20, 30, 40, 50, 59.
And then it enables this one.
And that first minute
is incremented.
And same thing.
It's a modulus 60 counter.
And it goes from 0 to 59 at
which point the hour is enabled
and what we've got here is
a 24 hour clock example.
The only way time should be
presented is in 24 hours.
What this thing is going to
do is going to count up to 24
and then I have not drawn
a reset on this here,
but we're just going to
have to go back to 00000.
What is being presented
below here,
well that is our display
drivers and our displays
for each individual digit within
the hour, minute and second.
And what that's implying
is there is the outputs
for that stage go to that
one, into that driver,
which goes into a 7 second
display, and if we wanted
to be especially cunning we
could potentially do this single
driver and display multiplex
at extremely fast rate
for all 6 of those displays.
It's an application
of a cascaded counter,
basically the high order second
only enables the low order
minute every 60 --
every 60 times.
So once every 60 times
as you would expect.
So it's got to count from 0
to 59 to get a full minute.
Then you go up one to 1 minute.
Then you've got to have 60
minutes to enable the hour.
Classic example of
cascading counters here.
Again, just think of it
in a vanilla terminology.
If you want to do a specific
device, 74190 or 191,
you might have to
use the datasheet
because as I showed those
were active low enables,
maximum minimum terminal counts.
This concludes this
portion of the lecture.
Let's move on to the next topic.