Hello and welcome to Part 3 of my Beginning Logic Design tutorial series!
In the last post we explored a common combinational circuit, the adder. In this post I’ll explore some of the basic sequential logic elements: latches and flip-flops.
Sequential Circuits
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 0.
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 0.
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 1.
The first switch to toggle to 1 will have its NOR gate toggle output to 1 which will lock the opposite NOR gate to 0.
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 set or reset.
Here’s a table that describes the various interactions we see for this design.
Since !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 AND, OR and NOT gate to prioritize reset over set.
In this design there is no !Q output and if reset is 1, the value of set is effectively ignored since the AND gate here will never output 0 when reset is 1.
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 0 to set or 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 set and 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 set to 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 Q and !Q to 0, and lets use use a single input to choose if Q will be 1 or 0.
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 1 to 0.
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 clear and 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!
