The Other Kind Of Static Hazard To Your Logic Circuits

November 24, 2023 by Dan Maloney 21 Comments

We’ve all heard of the dangers of static electricity when dealing with electronics, and we all take the proper precautions when working with static-sensitive components — don’t we? But as much as we fear punching an expensive hole in a chip with an errant spark, electrostatic discharge damage isn’t the only kind of static hazard your digital designs can face.

To be fair, the static hazard demonstrated by [Shane Oberloier] in the video below isn’t really an electrostatic problem. “Static” in this case refers to when a change to an input of a logic circuit gives an unexpected output until the circuit stabilizes. The circuit shown is pretty simple, with three inputs going into a combination of AND and NOT gates before going into an OR gate. The static hazard manifests as a glitch in the output when the middle input line’s logical state is toggled; according to the circuit’s truth table, the output shouldn’t change under these conditions, but the oscilloscope clearly captures a high-low-high blip. [Dr. Shane]’s explanation of why this happens makes perfect sense: the inverter on that input line has a brief but non-zero propagation time, putting the whole circuit in an ambiguous state before finally settling down to the correct output value.

So how do you fix something like this? This gets into the Boolean weeds a bit, and we won’t pretend to fully understand it, but at least for this case, [Dr. Shane] was able to add a single AND gate to sum the two other inputs and pipe the output into another input of the OR gate. That has the effect of canceling out the race condition caused by the inverter, but at the expense of a more complicated circuit, of course.

We found this to be a fascinating and informative discussion of a potential pitfall in logic design. But, if you still want to see some MOSFETs executed with static electricity, who are we to object?

Continue reading “The Other Kind Of Static Hazard To Your Logic Circuits” →

Partial Relay-Based Calculator Puts The Click Where It Counts

November 3, 2023 by Dan Maloney 15 Comments

It looks like [Michal Zalewski] is raising the next generation the right way. First, his eldest son asks for help building a one-bit computer from discrete transistors. Not to be left behind, his little brother then asked for help with an even more retro project, which resulted in this partially relay-based calculator. Maybe there is some hope for the future.

Now, purists will no doubt notice the ATmega64 microcontroller sitting in the middle of the main PCB on this project and cry “Foul!” But perfect is the enemy of done, and as [Michal] explains, at $6 a pop for the Omron relays he and his son chose, there’s only so far you can go with relay logic before you’re taking out a second mortgage. So the relays are limited to the ALU of the calculator, along with the drivers for the six seven-segment LED displays. The microcontroller is just there for housekeeping functions like scanning the keyboard and decoding digits. All the actual calculations are in the relay logic, not silicon. And we’d be remiss not to praise his son’s stylistic choices for this design — that it uses relays with clear covers, and that it has ~~single-sided~~ PCBs with curvy, ~~hand-drawn traces~~ traces that look hand-drawn on old-school yellow substrate. [Michal]’s heart must swell with pride to have fathered someone with such exquisite taste.

For his part, [Mikal] did some really good documentation for this build, including excellent descriptions of Boolean math with half- and full-adders and how relays are used to create the basic logic gates that comprise them. The calculator itself is still a work in progress, with microcontroller code still in development, but it’s working enough that you can enjoy the display driver’s clickiness in the video below. If that doesn’t do it for you, we’ve got other relay calculators to scratch that click itch. Continue reading “Partial Relay-Based Calculator Puts The Click Where It Counts” →

Patching Together Logic Gates

August 25, 2023 by Bryan Cockfield 14 Comments

The digital world offers many advantages over its analog relatives, the use of boolean logic among them. Some of the functions, like NOT, OR, and AND are fairly straightforward and line up nicely with their linguistic counterparts. Others are more elusive, like XOR and NAND. For those just getting their start in digital logic, this teaching tool allows different logic gates to be wired together with patch cables.

While [David] first thought to use 74-series logic circuits directly, a much more versatile solution was to use configurable custom logic — a feature found in AVR DA-series microcontrollers that allows for the creation of custom logic circuits without the need for external hardware or complex programming. He went with an ATmega4809 which is capable of supporting twelve gates which are depicted graphically on the board, where the patch cables can be connected between inputs and outputs from a set of switches on the left to another set of LEDs on the right. The microcontroller continually polls for connections, applies the correct logic via a lookup table, and lights the appropriate LED.

Even with only twelve gates, the amount of real-world analogs that can be created with this teaching tool are numerous and varied, from simple things like displaying traffic light patterns in the correct order to implementing a binary adder. It’s an excellent way to get started in digital logic or understanding gates, and much simpler than dealing with 74-series chips on a breadboard like many of us might have done, but those logic chips can be powerful tools to have on hand even in the modern world of microcontrollers.

GLASNOST Is A Computer That Makes Transparency A Priority

July 17, 2023 by Bryan Cockfield 7 Comments

We live in a world where most of us take the transistor for granted. Within arm’s length of most people reading this, there are likely over ten billion of them sending electrons in every direction. But the transistor was not the first technology to come around to make the computer a possibility, but if you go to the lengths of building something with an alternative, like this vacuum tube computer, you may appreciate them just a tiny bit more.

This vacuum tube computer is called GLASNOST, which according to its creator [Paul] means “glass, no semiconductors” with the idea that the working parts of the computer (besides the passive components) are transparent glass tubes, unlike their opaque silicon-based alternatives. It boasts a graphical display on an oscilloscope, 4096 words of memory, and a custom four-bit architecture based only on NOT, NOR, and OR gates which are simpler to create with the bulky tubes.

The project is still a work in progress but already [Paul] has the core memory figured out and the computer modeled in a logic simulator. The next steps are currently being worked through which includes getting the logic gates to function in the real world. We eagerly await the next steps of this novel computer and, if you want to see one that was built recently and not in the distant past of the 1950s, take a look at the Electron Tube New Automatic Computer that was completed just a few years ago.

FPGA Plays Tic-Tac-Toe

June 24, 2023 by Bryan Cockfield 18 Comments

As computers get more and more powerful and artificial intelligence algorithms improve, few games remain where the best humans can reliably beat their electronic counterparts. In chess this barrier was passed in 2005 with the last human win against a computer, and recently humans lost to computers at go. Simpler games like tic-tac-toe have been solved for all possible positions for a while now, so even a simple computer will always win or tie the game. But that doesn’t mean that there’s nothing left to learn about these games as [Hayden] demonstrates with this tic-tac-toe game built entirely on an FPGA.

[Hayden] is making this as part of a college course on digital design, so it really starts at first principles for working with FPGAs. It’s programmed in Verilog on a Basys 3 board, which also hosts the switches used as the game’s input and handles the VGA video output as well. The build uses state machines to keep track of the moves played on each of the squares, and another state machine to keep track of whether or not the current game has been won. If so, it highlights the winning moves in red, and stops taking further inputs until it is reset. Some more logic ties everything together along with a customized VGA driver to produce the entire gaming experience.

A game like tic-tac-toe is a great way to master the fundamentals of a system like this before moving on to more complex programs, especially on an FPGA platform that might handle a lot of the things we take for granted on more traditional computing systems, such as the video output. If you’re interested in taking more of a deep dive into the world of FPGAs, we published a primer about them a few years ago that will get you started.

Continue reading “FPGA Plays Tic-Tac-Toe” →

Op-Amp Challenge: A Logic-Free BCD

June 8, 2023 by Dan Maloney 10 Comments

Of digital electronics, a wise man once said that “Every idiot can count to one.” Truer words have rarely been spoken, because at the end of the day, every digital circuit is really just an analog circuit with the interesting bits abstracted away. And to celebrate that way of looking at things, we’re pleased to present this BCD to seven-segment converter that uses no logic chips.

With cheap and easily available chips that perform this exact job, it might seem a little loopy to throw 20 LM324 op-amps at the job. But as [gschmidt958] explains, this is strictly for the challenge, plus it made a nice entry in the recently concluded Op-Amp Challenge contest. His work began in simulation, exploring op-amp versions of the basic logic gates — NAND, AND, OR, and NOT — all of which rely on using the LM324s as comparators. There were real-world curveballs, of course, not least of which was running out of the 10k resistors used for input averaging. Another plot twist was running out of time to order a PCB, which required designing one using MS Paint and etching it at home.

The demo video below shows the circuit at work, taking the BCD output of a 74HC393 counter — clocked by a 555, naturally — and driving a seven-segment LED. It’s honestly a lot of work for such a simple task, but there’s something satisfying about the whole project. We think [Widlar] would be proud.

Continue reading “Op-Amp Challenge: A Logic-Free BCD” →

Hackaday Prize 2023: Building A Relay ALU

June 1, 2023 by Dave Rowntree 9 Comments

There’s much truth in the advice that, to truly understand something, you need to build it yourself from the ground up. That’s the idea behind [Christian]’s entry for the Re-engineering Education category of the 2023 Hackaday Prize. Built as an educational demonstrator, this is a complete arithmetic-logic unit (ALU) using discrete relays — and not high-density types either — these are the big honking clear-cased kind.

The design is neatly, intentionally, partitioned along functional lines, with four custom PCB designs, each board operating on 4-bits. To handle a byte-length word, boards are simply cascaded, making a total of eight. The register, adder, logic function, and multiplex boards are the heart of the build with an additional two custom boards for visualization (using an Arduino for convenience) and IO forming the interface. After all, a basic CPU is just an ALU and some control around it, the magic is really in the ALU.

The fundamental logical operations operating upon two operands, {A, B} are A, ~A, B, ~B, A or B, A and B, A xor B, can be computed from just four relays per bit. The logic outputs do need to be fed into a 7-to-1 bit selector before being fed to the output register, but that’s the job of a separate board. The adder function is the most basic, simply a pair of half-adders and an OR-gate to handle the chaining of the carry inputs and generate the carry chain output.