[Mike] Shows Us How To Use An Armature Growler

February 2, 2015 by Adam Fabio 24 Comments

[Mike] has put up a great video on his [SmallEngineMechanic] YouTube Channel about a tool we don’t see very often these days. He’s using an armature growler (YouTube link) to test the armature from a generator. Armature growlers (or just growlers for short) were commonplace years ago. Back when cars had generators, just about every auto mechanic had one on hand. They perform three simple tests: Check armature windings for shorts to other windings, for open windings, and for shorts to the armature body. [Mike’s] particular growler came to him as a basket case. The wiring was shot, it was rusty, and generally needed quite a bit of TLC. He restored it to like new condition, and uses it to help with his antique engine and genset ~~addiction~~ hobby.

Growlers essentially are a transformer primary with a V-shaped frame. The primary coil is connected to A/C mains. The armature to be tested sits in the “V” and through the magic of induction, some of the windings become the secondary coils (more on this later). This means some pretty high voltage will be exposed on commutator of the armature under test, so care should be taken when using one!

Testing for shorts to the ground or the core of the armature is a simple continuity test. Instead of a piezo beep though, a short will trigger the growler to turn on, which means the armature will jump a bit and everything will emit a loud A/C hum. It certainly makes testing more interesting!

Checking for open windings is a matter of energizing the growler’s coil, then probing pairs of contacts on the commutator. Voltage induced in the windings is displayed on the growler’s meter. Open windings will show 0 volts. Not all the armature’s windings will be in the field of the growler at once – so fully testing the armature will mean rotating it several times, as [Mike] shows in his video.

The final test is for shorted coils. This is where things get pretty darn cool. The growler is switched on and a thin piece of ferrous metal – usually an old hacksaw blade, is run along the core of the armature. If a short exists, the hacksaw blade will vibrate against the core of the armature above the shorted windings. We’re not 100% clear on how the coupling between the growler’s primary and two windings causes the blade to vibrate, so feel free to chime in over in the comments to explain things.

Most commercial shops don’t troubleshoot armatures anymore, they just slap new parts in until everything works again. As such the growler isn’t as popular as it once was. Still, if you work with DC motors or generators, it’s a great tool to have around, and it’s operation is a pretty darn cool hack in itself.

Click past the break for [Mike’s] video!

Continue reading “[Mike] Shows Us How To Use An Armature Growler” →

Building A Modern Retro Console

February 1, 2015 by Brian Benchoff 9 Comments

There are a few dozen classic re-imaginings of classic game consoles, using hardware ranging from the ATMegas of the Uzebox to everyone’s favorite, stuffing some ROMs on a Raspi and calling it a day. You don’t necessarily learn anything doing that, which puts [Mike]’s custom game console head and shoulders above the rest.

The build started off as a plan for a Z80 computer with a dual ATMega GPU. He progressed far enough in the design where it would have been a masterpiece, but the inability to mill double-sided boards at home killed the design. Plans then moved on to an FPGA, then to an ATMega with the Analog Device AD725 PAL/NTSC encoder chip. That idea had a similar architecture to the Uzebox, but [Mike] wanted more power. He eventually settled on a PIC32 with the AD725.

This setup was capable of pumping out some impressive graphics, but for moving bits to a screen, you need DMA. [Mike] ran into a problem where the DMA timer runs at a maximum rate of 3.7 MHz. It’s a problem documented in a few projects, leading [Mike] to change his plan once again, this time to the STM32F4.

The bugs are worked out, and now [Mike] can stream a whole lot of pixels to a screen while still having some processing power left over to play a game. It’s a project that’s more than a year and a half old at this point, and so far he’s learned a lot.

Resurrecting Capcom’s Kabuki

January 28, 2015 by Brian Benchoff 31 Comments

About a dozen old Capcom arcade titles were designed to run on a custom CPU. It was called the Kabuki, and although most of the core was a standard Z80, a significant portion of the die was dedicated to security. The problem back then was arcade board clones, and when the power was removed from a Kabuki CPU, the memory contents of this security setup were lost, the game wouldn’t play, and 20 years later, people writing emulators were tearing their hair out.

Now that these games are decades old, the on-chip security for the Kabuki CPU is a problem for those who have taken up the task of preserving these old games. However, now these CPUs can be decuicided, programming the chip and placing them in an arcade board without losing their memory contents.

Earlier we saw [ArcadeHacker] a.k.a. [Eduardo]’s efforts to resurrect these old CPUs. He was able to run new code on the Kabuki, but to run the original, unmodified ROMs that came in these arcade games required hardware. Now [ArcadeHacker] has it.

The setup consists of a chip clip that clamps over the Kabuki CPU. With a little bit of Arduino code, the security keys for original, unmodified ROMs can be flashed, put into the arcade board (where the contents of the memory are backed up by a battery), and the clip released. [ArcadeHacker] figures this is how each arcade board was programmed in the factory.

If you’re looking for an in-depth technical description of how to program a Kabuki, [ArcadeHacker] has an incredibly detailed PDF right here.

Continue reading “Resurrecting Capcom’s Kabuki” →

DIY 6502 Laptop Computer Looks And Works Great

January 27, 2015 by Adam Fabio 48 Comments

Over the years, we’ve seen a lot of DIY retro computers, but [Dirk Grappendorf] has created one of the most polished looking 6502 systems to date. His battery-powered portable machine utilizes a 4 line by 40 character LCD, and a modified USB keyboard. Cover all that in a slick 3D printed case, and you have a machine that reminds us quite a bit of the venerable TRS-80 Model 100.

[Dirk] has some great documentation to go with his computer. He started with a classic MOS 6502 processor. He surrounded the processor with a number of support chips correct for the early 80’s period. RAM is easy-to -use static RAM, while ROM is handled by UV erasable EPROM. A pair of MOS 6522 Versatile Interface Adapter (VIA) chips connect the keyboard, LCD, and any other peripherals to the CPU. Sound is of course provided by the 6581 SID chip. All this made for a heck of a lot of wires when built up on a breadboard. The only thing missing from this build is a way to store software written on the machine. [Dirk] already is looking into ways to add an SD card interface to the machine.

The home building didn’t stop there though. [Dirk] designed and etched his own printed circuit board (PCB) for his computer. DIY PCBs with surface mount components are easy these days, but things are a heck of a lot harder with older through hole components. Every through hole pin and via had to be drilled, and soldered to the top and bottom layers of the board. Not to mention the fact that both layers had to line up perfectly to avoid missing holes! To say this was a lot of work would be an understatement.

[Dirk] designed a custom 3D printed case for his computer and printed it out on his Ultimaker. To make things fit, he created his design in halves, and glued the case once printing was complete.

If awesome hardware and a case weren’t enough, [Dirk] also spent time designing software for the machine. He wrote his own abbreviated BASIC interpreter along with several BASIC programs. You can find everything over on his GitHub repository.

We always love writing up well-documented, and just generally awesome projects like [Dirk’s]. If you know of any retro computers like this one, drop us a tip!

[Thanks MicroHex!]

A Portable KIM-1

January 20, 2015 by Brian Benchoff 26 Comments

The KIM-1 was the first computer to use the 6502, a CPU that would later be found in the Apple, Ataris, Commodores, and the Nintendo Entertainment System. Being the first, the KIM-1 didn’t actually do a whole lot with only 1k of ROM and a bit more than 1k of RAM. This is great news for anyone with an Arduino; you can easily replicate an entire KIM-1, with a keypad and 7-segment display. That’s what [Scott] did, and he put it in an enclosure that would look right at home in a late 70s engineering lab.

The impetus for this build was [Scott]’s discovery of the KIM-Uno, a kit clone of the KIM-1 using an Arduino Pro Mini. The kit should arrive in a few weeks, so until then he decided to see if he could cobble one together with parts he had sitting around.

Inside a handheld industrial enclosure is an Arduino Uno, with a protoshield connecting the keypad and display. The display is an 11-digit, seven-segment display [Scott] picked up at a surplus shop, and the metal dome keypad came from a hamfest.

Getting the software working took a bit of work, but the most important parts are just modifications to the standard Arduino libraries.

Now that [Scott] has a KIM-1 replica, he can program this virtual 6502 one hex digit at a time, run Microchess, or use the entire thing as a programmable calculator.

Arduino Reads Punch Cards

January 17, 2015 by Adam Fabio 14 Comments

Punch cards were a standard form of program and data storage for decades, but you’d never know it by looking around today. Card punches and even readers are becoming rare and expensive. Sometimes it takes a bit of hacking [YouTube link] to get that old iron running again!

[Antiquekid3] managed to score an old punch card reader on Ebay, but didn’t have a way to interface with it. The reader turned out to be a Documation M-1000-L. After a bit of searching, [Antiquekid3] managed to find the manual [PDF link] on BitSavers. It turns out that the Documation reader used a discrete output for each row of data. One would think the Documation reader would be a perfect fit for the PDP-8 lurking in the background of [Antiquekid3’s] video, but unfortunately the ‘8 lacks the necessary OMNIBUS card to interface with a reader.

Undaunted, [Antiquekid3] threw some modern hardware into the mix, and used an Arduino Uno as a Documation to Serial interface. The Arduino had plenty of I/O to wire up with the card reader’s interface. It also had a serial interface which made outputting data a snap. The ATmega328 even had enough power to translate each card from one of IBM’s many keypunch formats to serial.

[Antiquekid3’s] test deck of cards turned out to be a floating point data set. Plotting the data with a spreadsheet results in a nice linear set of data points. Of course, no one knows what the data is supposed to mean! Want more punch card goodness? Check out this tweeting punch card reader, or this Arduino based reader which uses LEGO and a digital camera to coax the data from the paper.

Continue reading “Arduino Reads Punch Cards” →

Twisted String Actuators

January 17, 2015 by Brian Benchoff 39 Comments

[Travis] tells us about a neat actuator concept that’s as old as dirt. It’s capable of lifting 7kg when powered by a pager motor, and the only real component is a piece of string.

The concept behind the twisted string actuator, as it’s known to academia, is as simple as putting a motor on one end of a piece of string, tying the other end off to a load, and putting a few twists in the string. It’s an amazingly simple concept that has been known and used for thousands of years: ballistas and bow-string fire starters use the same theory.

Although the concept of a twisted string actuator is intuitively known by anyone over the age of six, there aren’t many studies and even fewer projects that use this extremely high gear ratio, low power, and very cheap form of linear motion. A study from 2012 (PDF) put some empirical data behind this simple device. The takeaway from this study is that tension on the string doesn’t matter, and more strands or larger diameter strands means the actuator shrinks with a fewer number of turns. Fewer strands and smaller diameter strands take more turns to shrink to the same length.

As for useful applications of these twisted string actuators, there are a few projects that have used these systems in anthropomorphic hands and elbows. No surprise there, really; strings don’t take up much space, and they work just like muscles and tendons do in the human body.

Thanks [ar0cketman] for the link.