This project is a wonderful example of what can be accomplished with a rather complicated logic circuit. It’s an Etch-a-Sketch made from a 16×16 LED grid. That in itself is only somewhat interesting. But when hearing about the features and that it is driven by logic chips we were unable to dream up how it was designed. There’s no schematic but the video commentary explains all.
The thing that confused us the most is that the cursor is shining brighter than the rest of the pixels. This is done with two different 555 times and a duty cycle trick. When you turn the trimpots the cursor position is tracked by some decade counters. Pixels in your path are written to a RAM chip which acts as the frame buffer. And there’s even a level conversion hack that let’s the display run at 15v to achieve the desired brightness. Top notch!
Continue reading “LED Etch-a-Sketch built without a microcontroller”
Here’s a really fascinating circuit that implements a combination lock using relays and logic gates. Even with the schematic and written explanation of how it works we’re still left somewhat in the dark. We’ll either pull out some paper and do it by hand this weekend, or build it chunk by chunk in a simulator like Atanua. Either way, the project sparked our interest enough that we want to get elbow deep into its inner workings.
From the description we know that it uses a combination of CD4017, CD4030, CD4072, and CD4081 chips. You’re probably familiar with the 4017 which is a decade counter popular in a lot of project. The other chips provide XOR, OR, and AND gates respectively. The relays were chosen for two purposes. One of them activates when a correct combination has been entered, effectively serving as the output for the combo lock. The other two are for activating the clock and affecting a reset if the wrong combination is entered.
It makes us wonder if this would be incredibly simple to brute force the combination by listening for sound of the reset relay activating? It’s hard to tell from the video after the break if you can discern a wrong digit from a right once just based on sound.
Continue reading “Combo lock uses relays and logic gates”
[Fran] went all-out with her reverse engineering of the Apollo Saturn V LVDC board. Regular readers will remember that she was showing of the relic early this year when she took the board to her Dentist’s office to X-ray the circuit design. Since then she’s been hard at work trying to figure out how the thing functions using that look inside the board and components. When we say ‘hard at work’ we really mean it. Not only did she explore many different theories that resulted in dead ends, she also built her own version of the circuits to make sure they performed as she theorized. Above you can see her version of the NAND/AND gates used on the hardware.
We find her explanation of how the logic devices were originally fabricated to be very interesting. They started with a ceramic substrate and used additive processes to form the traces and add the gates. We’ve embedded her video explanation after the jump.
Continue reading “Digging deeper into the Apollo Saturn V LVDC”
The 6502 was a ubiquitous microprocessor back in the 80s, powering devices such as the Apple II and the Nintendo Entertainment System. [Ken] took an in depth look at a small part of the processor: the overflow circuit.
In order to do signed calculations, a microprocessor’s arithmetic logic unit (ALU) needs to be able to calculate when an overflow occurs. This happens when two numbers are added that cannot fit in a single byte. The result of a calculation will be incorrect, so the processor must inform the program that an overflow has occurred. This is done by setting an overflow flag.
[Ken] uses this example to first explain how the overflow circuit works in logic. He then looks at the gates and a transistor implementation of the logic. Finally, he walks us through the circuit on the actual 6502 die, showing how the circuit is constructed in silicon.
This is a great example to learn a bit more about how ALUs work and how integrated circuits get built.
This heavily populated PCB is a recreation of the original arcade version of Pong. That is an important distinction because the home version of Pong used a specialized chip to do much of the work. This is basically all stock logic, which explains the high component count. We wonder how many quarters it took just to pay for all 66 chips at the time?
[Pong74ls] was the person who took on this project. There is an original schematic available, but it’s incredibly crowded and rather difficult to figure out. Fortunately [Dan Boris] has already done a lot of the heavy work. He took the one-page nightmare and turned it into a sixteen page plan for building the original board (look for the schematic link under technical details).
Before the board could be laid out some redesign work was necessary. It sounds like some of the original chips are out of production and suitable replacements needed to be found. The board was then laid out in Eagle before sending the design off to a fab house. There was just one error which didn’t allow the ball to bounce when hitting a paddle while travelling downward. A couple of jumper wires fixed that right up!
[Original Reddit Post]
Although it’s not the best way of understanding computers, most people tend to imagine electronic devices as black boxes filled with magic and blue smoke. Even microcontrollers, the most fundamental means of computation, are treated like little black plastic centipedes with metal legs. In a series of blog posts, [Andrew Gibiansky] is tearing down the walls of obfuscation and illuminating the world of transistors, gates, and FPGAs.
The first blog post goes over the idea of electronic circuits as a waterfall; a positive voltage is a reservoir on a mountain top and ground is sea level. This idea is extended to the lowly transistor acting as an electronic switch, able to turn a circuit on and off.
Continuing on to logic gates, [Andrew] covers the NOT, AND, and OR gates before moving on the flip-flops and SRAM. These can, of course, be modeled in Verilog and VHDL – programming languages that abstract the world of transistors and gates into a much more human-readable form.
[Andrew] is far from done with his series of blog posts, but judging from his work so far it seems to be a great resource for untangling the obtuse concepts of gates and memory into the coherent design of a computer.
This frequency counter is [Miguel Pedroso’s] entry in the 7400 Logic contest. After looking at the design we think this is a perfect project for those who have not worked with logic ICs before. The concept is simple and [Miguel] does a great job of explaining his implementation.
At its heart the device simply counts the oscillations of an input signal for one second, then latches the total to the 7-segment displays before zeroing the counter block and starting over. Six 4029 decade counters give the device a range of 1MHz. A set of 4511 BCD to 7-segment decoders translate the count to the display. A 4521 frequency divider chip uses an on-board 4.194304 MHz crystal oscillator to time both the display latching and the counter clearing. [Miguel] mentions that tuning the load capacitors is a bit tricky. Since breadboards have their own capacitance issues it may be necessary to change the load capacitor values when moved to protoboard or the crystal won’t start oscillating. You can see those caps are not the same value, but the tests in the video after the break show that this is pretty much spot-on.
If you’d rather give this a try in HDL here’s an FPGA-based frequency counter from which you can draw some inspiration.
Continue reading “7400 frequency counter”