I have a passion for learning about technology. My desire to understand more about how things work has driven me to dive into lower and lower levels of computing systems. For the last couple years I’ve been trying to go all the way down to working with the basic digital components. I did not find many resources to help learning these low level basics, so today I am kicking off a series to teach others how easy it can be to get started with digital logic design.
How We’ll Be Learning
There are not a lot of tools I’ve found that are modern, useful or stable enough to use to get started with learning basic digital design. Most legit hardware design tools are based on using a Hardware Description Language such as VHDL or SystemVerilog. I think the early digital knowledge you need is best solidified with schematic design and simulation; by working with the most basic logic gates to understand how larger and more complex designs can be made from very simple components.
The best tool I’ve found so far for digital logic design and simulation is logic.ly, an educational piece of software that has a clean and usable interface along with a good set of features around managing subcomponents. It is not free software, a full license runs around $60, but there is a free trial that you can use for up to 30 days. It is also only supported for Windows and OSX, though I have had good luck running it via Wine on my Ubuntu box.
The best free (and open source!) alternative to this I found was BOOLR, which is a fairly impressive simulator but as of this writing is not stable enough to recommend. I’ll be keeping an eye on that project to see where it goes.
To get started, download Logicly and get it installed. Activate your 30-day trial and fire it up!
To get the lay of the land, let’s look at some of the most basic components Logicly has to offer.
I have Logicly’s 5 input devices on the left and its 2 output devices on the right.
Starting from the top of the inputs, Logicly has a toggle switch that operates very similar to a light switch, it outputs 0 when the switch is off and 1 when the switch is on. Below that is a button, or momentary switch, that normally outputs 0, but while it is held down will output 1. The next input devices is a clock signal, it automatically flips its output after a configurable time, one second by default. The last two inputs are constants, always 1 or always 0.
On the right side we have the outputs. The light bulb is lit or unlit depending on the signal being driven to it. The second output device is a digit display, which will show a 0-F hexadecimal value based on its 4 input bits. We’ll only be using the light bulb for this lesson.
Feel free to dabble with these components if you’d like, we’ll use them to explore the logic gates in the next section.
Basic Logic Gates
Logicly has 9 components in it’s Logic Gates category, we’ll explore them each here.
The first row has the
Buffer and the
NOT gate. These are the simplest gates. The
Buffer simply outputs an identical signal to its input, in Logicly this is generally only useful for adding a bit of delay to signal propagation. We won’t be using the
Buffer component very much, if at all. The
NOT gate will output the opposite of its input.
As you can see above, when the switch is on, the light behind the buffer is also on, while the
NOT gate inverts the signal and the light behind it stays off. Notice the similarity of the component symbols, in digital design you’ll often see a small circle that indicates the inversion of a signal from low to high or high to low.
The next row of components is the
AND gate and the
NAND (NOT-AND) gate. The
AND gate will output 1 only if all inputs provided to it are 1.
NAND gate has the opposite output of the
AND gate, similar to what you’d see if you used a
NOT gate to invert the output of an
The next two gates are
OR gate will output 1 if any input is 1, and 0 if all inputs are 0.
As you may expect, the
NOR gate is very similar to the
OR gate, but with inverted outputs.
The next couple gates are
XOR gate, short for exclusive-or, is a little bit trickier. In a 2-input configuration it will output 1 if the two inputs differ, and 0 if the two inputs are the same.
This symbol for
XOR is very similar to
OR, but has an extra curved line on its input side to stand apart. Just like with the other N* gates the
XNOR has the opposite outputs of
The last basic logic gate Logicly gives us is a
Tri-State Gate. It is very similar to the
Buffer with the addition of a signal to control if the output of the buffer is enabled. If the
Tri-State is enabled, the output will match the input, if disabled it will not emit an output which leaves the connection unset, or floating, allowing something else to control the output line its connected to. Don’t worry about this gate for now, we won’t use it for a bit.
It can take a while to get used to these symbols and their outputs, here’s a diagram that shows the truth tables, and boolean algebraic expressions for these gates.
These gates are each fairly simple but all digital electronics are composed of just these gates in various arrangements! It may take a while to understand how things like RAM, CPUs and entire computers can be built from such simple components, but as you practice building incrementally more complex circuits it will begin to make sense.
Functionally Complete Gates
Two of these logic gates (
NOR) have a very special feature, they are functionally complete. This means that any other gate, and therefore any digital machine, can be made of just
NAND gates or just
NOR gates. This has some significant benefits for manufacturing electronics, but since we’re not fabs we’ll just explore this property to get a bit of practice building some simple circuits. NAND logic is a bit more popular for various reasons, so let’s explore how we can make some of other other basic gates by using just
To start off with, here’s a
NAND gate setup to work just like a
NOT gate, I have these gates in parallel so they share the same input to allow for easy comparison.
By simply wiring the switch to both
NAND inputs, we get the exact same behavior as a
We can use this same concept to implement an
AND gate. Since
NAND has the opposite output of
AND, we can use the previous
NOT-like configuration to flip the output of
NAND to match
For some solo practice, try your hand at replicating the function of
XOR gates using only
NAND gates. If you get stuck (I did), reference Wikipedia’s page on NAND Logic for the solution and look at the wire states in Logicly as you toggle the inputs and think about why it works.
This is a whopper of a first lesson, but I hope it’s useful for folks just starting out. If you have any questions or feedback please leave a note in the comments and I’d be glad to help you out. In the next post we’ll be exploring some of the interesting things you can do by combining these basic logic gates. Keep tinkering!