A Handy Tester For A Mountain Of PS/2 Keybords

July 12, 2022 by Dan Maloney 16 Comments

The hacking life is not without its challenges, and chief among these is the tendency to always be in acquisition mode. When we come across a great deal on bulk equipment, or see a chance to rescue some obscure gear from the e-waste stream, we generally pounce on it, regardless of the advisability.

We imagine this is why [Nathan] ended up with a hoard of PS/2 keyboards. Seriously, there are like thousands of the things. And rather than lug a computer to them for testing, [Nathan] put together this handy Arduino-based portable tester to see which keyboards still have some life left in them. The video below goes into detail on the build, but the basics are pretty simple — an Arduino, a 16×2 LCD display, and a few bits and bobs to run it off a LiPo pack and charge it up. Plus, of course, a PS/2 jack to plug in a keyboard and power it up. Interestingly, the 16×2 display is an old Parallax unit, from the days when RadioShack still existed and sold their stuff. That required a little effort to get it working with the Arduino, but in the end it works like a charm — plug in a keyboard and whatever you type shows up on the screen.

Of course, it’s hard to look at something like this, and that mountain of keyboards in the background, and not scheme up ways to really automate the whole test process. Perhaps an old 3D printer with a stylus mounted where the hot end would go could press each key in turn while the tester output is recorded — something like this Wordle-bot, but on a keyboard scale. That kind of goes against [Nathan]’s portability goal, but it’s still fun to think about.

Continue reading “A Handy Tester For A Mountain Of PS/2 Keybords” →

photo of the CNC controller, with the PLCC socket for the CPU, surrounded by driver ICs

Old CNC Brain Swapped With An Arduino

July 11, 2022 by Arya Voronova 12 Comments

[Sebastian] and [Stefan Shütz] had a ISEL EP1090 CNC machine at home, sitting unused, and they decided to bring it to life. With pretty good mechanical specs, this CNC looked promising – alas, it was severely constrained by its controller. The built-in CPU’s software was severely outdated, had subpar algorithms for motor driving programmed in, and communication with the CNC was limited because the proprietary ISEL communications protocol that isn’t spoken by other devices.The two brothers removed the CPU from its PLCC socket, and went on to wiring a grbl-fueled Arduino into the controller box.

They reverse-engineered the motor driver connections – those go through a 74HC245 buffer between the original CPU and the drivers. Initially, they put an Arduino inside the control box of the CNC and it fit nicely, but it turned out the Arduino’s CPU would restart every time the spindle spun up – apparently, EMC would rear its head. So, they placed the Arduino out of the box, and used two CAT7 cables to wire up the motor and endstop signals to it.

For tapping into these signals, they took the 74HC245 out of its socket, and made an interposer from two small protoboards and some pin headers – letting them connect to the STEP and DIR lines without soldering wires into the original PCB. There’s extensive documentation, GRBL settings, and more pictures in their GitHub repo, too – in case you have a similar CNC and would like to learn about upgrading its controller board!

After this remake, the CNC starts up without hassles. Now, the brothers shall CNC on! Often, making an old CNC machine work is indeed that easy, and old controller retrofits have been a staple of ours. You can indeed use an Arduino, one of the various pre-made controller boards like Gerbil or TinyG, or even a Raspberry Pi – whatever helps you bridge the divide between you and a piece of desktop machinery you ought to start tinkering with.

Mis-captured signal transitions shown on the screen of the LA104, with problematic parts circled in red.

When Your Logic Analyzer Can’t Tell Good And Bad Signals Apart

July 9, 2022 by Arya Voronova 17 Comments

[Avian] has picked up a Miniware LA104 – a small battery-powered logic analyzer with builtin protocol decoders. Such analyzers are handy tools for when you quickly need to see what really is happening with a certain signal, and they’re cheap enough to be sacrificial when it comes to risky repairs. Sadly, he stumbled upon a peculiar problem – the analyzer would show the signal glitching every now and then, even at very low bitrates. Even more surprisingly, the glitches didn’t occur in the signal traces when exported and viewed on a laptop.

He dug into the problem, as [Avian] does. Going through the problem-ridden capture files helped him realize that the glitch would always happen when one of the signal edges would be delayed by a few microseconds relative to other signal edges — a regular occurrence when it comes to digital logic. This seems to stem from compression being used by the FPGA-powered “capture samples and send them” part of the analyzer. This bug only relates to the signal as it’s being displayed on the analyzer’s screen, and turned out that while most of this analyzer’s interface is drawn by the STM32 CPU, the trace drawing part specifically was done by the FPGA using a separate LCD interface.

It would appear Miniware didn’t do enough testing, and it’s impossible to distinguish a good signal from a faulty one when using a LA104 – arguably, the primary function of a logic analyzer. In the best of Miniware traditions, going as far as being hostile to open-source firmware at times, the FPGA bistream source code is proprietary. Thus, this bug is not something we can easily fix ourselves, unless Miniware steps up and releases a gateware update. Until then, if you bought a LA104, you can’t rely on the signal it shows on the screen.

When it comes to Miniware problems, we’ve recently covered a Miniware tweezer repair, requiring a redesign of the shell originally held together with copious amount of glue. At times, it feels like there’s something in common between glue-filled unrepairable gadgets and faulty proprietary firmware. If this bug ruins the LA104 for you, hey, at least you can reflash it to work as an electronics interfacing multitool.

Pulling A Chainsaw With Gravity

July 8, 2022 by Matthew Carlson 18 Comments

[Flowering Elbow] had a large ash log that needed to be milled. He had his chainsaw and shared an excellent technique for an easier cut. After cutting down a tree, letting it dry for a season, and then hauling it to your saw site, you’re ready to cut. However, cutting a humongous tree with a chainsaw is an enormous task. A few hacks make it better, like tilting your log slightly downhill, so the chainsaw flows downhill or using a jig to keep the cut straight. Some use a winch system to drag the jig along to assist, so it’s not just pure manpower. The problem is that a winch will exert more force if the saw hits a knot or challenging section. So you would want to slow down and let the saw work through the area.

[Flowering Elbow] uses a pulley and offcut from the log and hangs it from a tree. The log drops as the cut progresses and exerts a constant force. This means that the saw can slow down during challenging sections and take the time it needs, extending the blade’s life. There are other excellent tips in the video, and combined with his earlier chainsaw mill jig, you’ll be set to mill up logs with nothing but a chainsaw and some ingenuity.

Video after the break.

Continue reading “Pulling A Chainsaw With Gravity” →

Photovoltaic Cells In LTSpice

July 4, 2022 by Al Williams 19 Comments

We like to build things using real parts. But we do think the more you can model using tools like LTSpice, the less time you can spend going down dead ends. If you need to model a common component like a resistor or even an active device, most simulators have great models and you can tweak them to have realistic parasitic effects. But what if the component you want isn’t in the library or doesn’t have the fidelity you want? [FesZ] wanted to model photovoltaic cells and had to build his own model. The resulting two videos are well worth watching.

Building your own models in Spice isn’t necessarily very difficult. However, knowing exactly what to add to model different real-world effects can be challenging. The videos do a good job of showing how to mutate a simple diode into one that produces current when exposed to light.

Continue reading “Photovoltaic Cells In LTSpice” →

Testing A Tube Without A Tube Tester

July 3, 2022 by Al Williams 10 Comments

[M Caldeira] needed to test a tube and didn’t have a spare to do the old swap test. He also didn’t have a tube tester handy. Drawing inspiration from a 2015 video, he managed to cobble up an ad hoc tube tester using stuff around the workbench. You can see a video of the process below.

To duplicate his effort, you are going to need a few meters. Good thing they are relatively cheap these days. Usually, a tube tester has a way to adjust all the different parameters for the tube, but there’s no reason you can’t just set those parameters using your testbench power supplies.

Continue reading “Testing A Tube Without A Tube Tester” →

An Affordable Reference Mic You Can Build Yourself

July 2, 2022 by Lewin Day 12 Comments

Reference mics are vital tools for audio work. They’re prized for their flat frequency response, and are often used for characterizing the audio response of a room or space. OpenRefMic aims to be an open source design for producing reference mics without paying exorbitant retail prices.

The heart of the build is a preamplifier that runs off standard 48 V phantom power, and is responsible for both biasing the electret microphone element and acting as a buffer for the mic signal. It’s designed specifically to work with the PUI AOM-5024L-HD-F-R mic capsule, chosen for its good performance and low noise characteristics. However, other electric mics should work, too. The hardware is wrapped up in a 3D printed case which can readily be made on most basic printers. It’s complete with a press-fit grille that holds the mic capsule in place.

The prime goal of the project is low noise; the project creator, [loudifier], notes that most commercial reference mics focus first on flat frequency response and then reducing noise. OpenRefMic performs well in this area, and its lack of a perfectly flat frequency response is countered with calibrated equalization. It also works with regular pro-grade XLR cables and phantom power, rather than needing fancy laboratory-spec cables and interfaces.

The final result is a credit to [loudifier], who demonstrates a strong understanding of the principles of reference mic design. We’ve seen some other great low-cost reference mics recently, too!