While you’re not likely to see this technique used very much today, there’s a lot you can do with a 555, some logic chips, and a handful of diodes. [Fran] is here with a great example of using these simple parts to build a circuit that counts to zero, using parts you can probably find under your workbench.
[Fran] was inspired to build this diode counter from one of [Dave]’s Mailbags and [Colin Mitchell]’s 555 circuit book. The 555 is the standard component found in every parts drawer, but since we have tiny microcontrollers that cost the same as a 555, we’re not seeing the artistry of a simple timer chip and a few logic chips much these days.
This circuit began with a 555 attached to a 4017B decade counter. Simply by tying a few LEDs to the output of the 4017, [Fran] made a bunch of LEDs light up in sequence. Cool, but nothing unexpected. The real trick uses a few diodes and six LEDs to build a scanner – a line of LEDs that will blink from left to right, then right to left. Impressive, and with a little more circuitry it’s a Larson Scanner, as seen in Battlestar Galactica and Knight Rider.
The real trick for this technique comes when [Fran] pulls out a piece of protoboard, several dozen diodes, and seven old transistors to have a seven-segment display count from zero to nine. The 4017 simply counts out on ten pins, and each of these pins is wired to a bunch of diodes for each segment in the display. Add in a few resistors and a transistor, and [Fran] replicated what’s inside a seven-segment driver with discrete parts.
If counting to zero isn’t enough proof that you can do a whole lot with some diodes and logic chips, how about programming an Atari 2600 with one?
Continue reading “Diode Steering and Counting With A 555″
This is an oldie, but oh, man is this ever good. It’s a Nixie clock made without a microcontroller. In fact, there aren’t any logic chips in this circuit, either. As far as we can tell, the logic in this clock is made with resistors, diodes, caps, and neon tubes.
The design of this is covered in the creator’s webpage. This clock was inspired by a few circuits found in a 1967 book Electronic Counting Circuits by J.B. Dance. The theory of these circuits rely on the different voltages required to light a neon lamp (the striking voltage) versus the voltage required to stay lit (the maintaining voltage). If you’re exceptionally clever with some diodes and resistors, you can create a counting circuit with these lamps, and since it’s pretty easy to get the mains frequency, a neon logic clock starts looking like a relatively easy project.
This clock, like a lot of the author’s other work, is built dead bug style, and everything looks phenomenal. It looks like this clock is mounted to a plastic plate; a good thing, because something of this size would be very, very fragile.
Video below, thanks [jp] for sending this one in.
Continue reading “A Nixie Clock with Neon Bulb Logic”
Watching [Matthias Wandel] fabricate this mechanical counter from scrap wood is just fascinating. He likens the mechanism to the counters you would find on decades-old cassette tape players.
You may recognize the quality of [Matthias’] work. We’ve seen several pieces, but his binary adder is still one of our favorites. This project gives us a very clear view of the development and fabrication process. He even posted a detailed guide if you want to build your own.
He started by prototyping a mechanism to increment and decrement the counter. With that proven design he started laying out the rest of the gears. These were cut from plywood scraps he had from other projects. Notice the small gears seen above which are missing parts of some teeth. Those sections were removed using a drill press with a Forstner bit. The missing teeth cause the next digit over to increment more slowly, resulting in a 1/10 ratio. This part of the design is demonstrated about three minutes into the video after the break.
Continue reading “Building a mechanical counter out of scrap wood”
[Deekshith Allamaneni] built this controller which will automatically turn the lights in a room on and off. No big deal, right? You can already get a replacement light switch at the home store that will do this for you. But there is one big difference. The commercial solutions we’ve seen simply rely in a motion sensor and a timer. But [Deekshith] found a way to count the number of people that enter a room, turning the lights on when the first person enters and off when the last person leaves.
The video after the break shows a demo of his test rig. At first we just thought that this was only counting how many times an object passes between the sensors. But it can also detect in which direction that object was traveling. Now the system just needs to be scaled up for use in a doorway.
It would be a great addition to the house that doesn’t have any light switches.
Continue reading “Lighting controller counts how many people are in a room”
[Udo Klein] took on the challenge of counting as fast as possible using an Arduino board. The quest involves a search for short-cuts that will let him drive a 20-bit counter as quickly as possible using the stock hardware. But the catch is that the Arduino environment has some overhead running in the background which will slow things down. He looks into each of these road bumps, then shows one way to get around them.
The code uses a command we don’t normally see in modern C embedded programming; the goto statement. He’s using this to bypass the extra cycles used by the Arduino’s in-built loop() function. The only command that is run within his hacked loop is a deeply nested set of macros. They’re toggling output pins using the hardware XOR built into the AVR chip. This is directly addressing the registers and thereby dumps the slowdown added by the digitalWrite() function.
The result is a software counter that toggles the output lights (see the clip after the break) at about 98.9% of the hardware clock speed. Pretty impressive, but [Udo] figures he can make it just a bit faster yet.
Continue reading “Thinking outside the IDE to make a fast-counting Arduino”
This is the bee counter which [Hydronics] designed. It’s made to attach to the opening for a hive, and will count the number of bees entering and exiting. We’re not experienced bee keepers ourselves (in fact we’re more of the mind of getting rid of stinging beasties) but we understand their important role in agriculture and ecosystem so we’re glad someone’s making a nice home for them.
Most of the apparatus is a circuit board lined with reflective sensors. There is a double-row of pin sockets on the top of the board which accepts the Teensy+ which monitors those sensors. The bees must pass below this PCB every time they enter or leave the hive, thereby tripping a sensor. In the video after the break [Hydronics] shows off the system with a netbook used to monitor the output. But it sounds like he has plans for an integrated display system in future versions of the bee counter.
Continue reading “Counting bees”
[StaticChanger] built a scoreboard to display his kill statistics from Halo for the PC. Yes, we’ve seen kill counters before, but we like the way that he gathers the data. This project is reading the score directly from an address in memory.
Using a program called Cheat Engine, the memory used by a program can be sniffed. After a few passes, the program will help you find a static memory address for your desired data. Once you have that it’s just a matter of using a pointer to that address in your desired programming language. In this case, a C# program polls the value and instructs an Arduino to display the value on a couple of 7-segment displays. Voila, the number appears next to your screen as you see in the image above.