Hello and welcome to Part 3 of my Beginning Logic Design tutorial series!
So far, the circuits I’ve shared are pretty linear. The schematic diagrams have had inputs on the left and all signals move toward the outputs on the right. For sequential circuits, there is an element of feedback where some outputs are routed back into an earlier gate.
Let’s look at the concept of feedback using the
NOR gate as our base. I’ll provide one switch as input, and I’ll use it’s own output as the second input.
In this configuration, the
NOR cannot yet determine what it’s output should be, let’s look at the truth table for
NOR to understand why.
Looking at the truth table, if we only know one of the inputs and we know that it’s
0, we can’t determine the output. On the other hand if we know one of the inputs is
1 we can safely say the output is
Now the second input is also known, but something interesting happens if we turn the switch off now.
When the switch is off, the
NOR gate will flip its output back and forth due to the feedback loop. When the gate sees the
1 on its 2nd input it changes its output to
0, when it then sees both inputs as
0 it again starts to output
1. If we turn the switch back on, it again doesn’t matter what the second input is set to, the output will be locked to
The Set-Reset Latch
The sequential circuit with the single NOR doesn’t give us a very useful function. It initially has an undefined output state after which it can either have an off state when we give it an input of
1 or a crazy flipping back and forth state when we input
0. A design called the SR (Set-Reset) latch can provide a more useful operation. It is like the previous design but with two sides and the
NOR gates providing feedback to each other.
Just like before, the initial output cannot be determined. This time, by turning the top switch on, the top
NOR will now have a known output of
0. This will also cause the bottom
NOR to have a known output of
1 because both of its inputs are now
0. Since the bottom output is now
1, the top
NOR will stay
0 as the top switch goes back off.
When both inputs are
1, both outputs are
0 since neither
NOR gate has the two
0 inputs needed to output
The first switch to toggle to
1 will have its
NOR gate toggle output to
1 which will lock the opposite
NOR gate to
By convention, we refer to one of these inputs as
set and the other as
reset.The output state of a latch is usually labeled as Q and sometimes the latch will also output the opposite of Q. In this design Q is the output from the
NOR gate on the
reset side of the design. Since the design is symmetrical, it doesn’t matter which side you choose to be
Here’s a table that describes the various interactions we see for this design.
!Q is expected to be the opposite of
Q, the outputs are not considered valid with both inputs are
1 as that results in both outputs being
0. There is another model for the SR latch that is built using an
NOT gate to prioritize
In this design there is no
!Q output and if
1, the value of
set is effectively ignored since the
AND gate here will never output
There is also a way to make a similar SR latch with
NAND gates, though it has inverted operations where the output is stable when both inputs are
1 and you drop an input to
reset the output.
The last variation of the SR latch I want to share is the gated SR latch, which adds an
enable input that assist in controlling the latch operation.
The addition of the
AND gates with
enable input give you a bit extra control of when state changes are allowed. When the
enable input is
0, it will preserve the latches state. This allows you to setup
reset as you’d like, when you’re ready for the latch to operate you can toggle
enable on and off to perform the operation.
The SR latch is quite common and useful, and can be used as a basis for other common latches.
The Gated D Latch
I am a fan of the gated D latch, it is a slight variation to the SR latch that gives you a simple way of storing a single bit of information. By renaming
data, and replacing
reset with the inverse value of
data, we provide our bit to store via the
data input and use
enable to control when that data is latched.
This design removes the possibility of an input state that would set both
0, and lets use use a single input to choose if
Q will be
When Latches Become Flip-Flops
In the components section of Logicly there are a few objects under the category
Flip-Flops. There are SR, D, JK and T flip-flops. Latches and flip-flops are commonly confused. The first few designs we looked at have no inputs intended for synchronization, these are just called latches. We then looked at gated latches, which add an
enable input so that we can control when the data on the other input lines should be treated as valid. With a gated latch, the entire time the
enable signal is active, changes to the other inputs will affect the state of the latch. The special bit about a flip-flop is that the state of the latch is limited to the transition of
enable from low-to-high (rising or positive edge) or high-to-low (falling or negative edge).
A gated latch can be affected by it’s input during one half of the clock period, while a flip-flop is at a point in time. This is very helpful for digital designs that need more precise timings, such as a CPU.
The easiest way to build my own D flip-flop would be to first save my gated D latch as a component.
Now, I’ll place two D latches in my design and route the
q output of the first to the
data input of the second. By connecting a clock to the
enable input of the first, and providing the inverted clock signal to the second, it creates a circuit that will only change the output on the falling edge of the clock signal.
Now that’s a functional flip-flop! I encourage you to build this design yourself and play with the input as the clock changes to watch how it will only change as the clock transitions from
To make a flip flop that triggers on the rising clock edge, route the inverse clock to the first latch, and the normal clock to the second latch.
With that we now know how we can build our very own flip flops to store individual bits of data! For continued exploration on latches and flip flops, I encourage you to dive into the web and build your own JK and T type flip flops. You may also notice that the D flip-flops in logicly have some extra inputs for
preset; you can explore what those asynchronous inputs provide and see if you can add that functionality to your own flip flop implementation! It will all sink in with practice!
That wraps it up for this post. If you have any questions or feedback I would love to see your submission in the comments. Keep tinkering!