USB Adapter For An Old VT100 Keyboard

August 13, 2013 by Brian Benchoff 25 Comments

VT100

Ah, the VT100, the first dumb terminal that was controlled with a microprocessor. This ancient beast from the late 70s is quite unlike the terminals you’d find from even five years after its vintage – the keyboard connects via a TRS quarter-inch jack – the electronic and code design of this terminal is a bit weird. [Seth] was up to the challenge of making this mechanical keyboard work as a standard USB device, so he created his own USB adapter.

On the little quarter-inch to USB adapter, [Seth] included an HD 6402 UART to talk to the keyboard, along with a Teensy dev board and a few bits of circuits stolen from DEC engineers. The protocol between the keyboard and terminal is a little weird – first the terminal sets a bit in a status word, then the keyboard scans all the key rows and columns in sequence before telling the terminal it’s done. Yes, this gives the VT100 full n-key rollover, but it’s just weird compared to even an IBM Model M keyboard that’s just a few years younger.

[Seth] finally completed his circuit and wired it up on a perfboard. Everything works just as it should, although a little key remapping was done to keep this keyboard adapter useful for Mac and Windows computers. It’s a wonderful bit of kit, and any insight we can get into the old DEC engineers is a wonderful read in any event.

Vidias below.

Continue reading “USB Adapter For An Old VT100 Keyboard” →

Converting A Flip-dot Display To Work Like Core Memory

August 12, 2013 by Mike Szczys 17 Comments

flip-dot-display-as-core-memory

It’s always interesting to see what will come out of a hacker meet-up. At the Observe, Hack, Make festival earlier this month [Bertho] was talking to a guy named [Erik] about how flip-dot displays work. [Erik] mentioned that the control theory is the same as core memory. So when [Bertho] got back to his home workshop he started playing around with it to see if a flip dot display can be made to behave exactly like core memory.

We’re really glad a successor to core memory was found since it’s pretty slow. But the concept still makes for some fun exploration (here’s the obligatory Arduino implementation of core memory). It uses magnetic rings with two conductors running through them that pass at right angles to each other. Sound familiar? This is exactly how flip-dot displays work.

There are, of course, some differences. The biggest one being that the displays don’t have the sense wire present in core memory. That was an easy enough thing for [Bertho] to get around. He added the grey sense wire by threading it through the inside of the hardware. The other hurdle he had to overcome was to alter the controller firmware to match the destructive tendency of core memory (reading the state also resets it).

So far he’s just set this up as a proof of concept, reading the sense wire while repetitively reading and writing to the “memory”. But it’s engaging to see what was captured on the scope. We asked him about his future plans, specifically what he would use to automatically read from the sense wire. His response is found after the jump.

Continue reading “Converting A Flip-dot Display To Work Like Core Memory” →

Making Vector Arcade Games With An FPGA

August 10, 2013 by Brian Benchoff 11 Comments

While we’re sure most Hackaday readers were raised by arcade games featuring sprites, pixels, and other shiny brightly colored squares, this was not always so. Many classic arcade games – Lunar Lander, Gravitar, and Asteroids in particular – used vector displays. Instead of drawing individual pixels, these games functioned more like an oscilloscope, drawing lines. When [Todd] and [Andrew] got their hands on a monitor from an old Asteroids cabinet, they knew what they had to do: build their own vector arcade game.

The guys made their own DAC and Amplifier board that plugs right in to a Nexys2 FPGA dev board. This was after they tested out some 3D drawing code with a gnarly handmade R2R DAC they used to draw and rotate a cube on an oscilloscope screen.

Not only did the guys build a vector video card, they also connected the FPGA’s VGA out to a monochrome monitor for an in-game HUD. Awesome work that blows away anything available in the golden days of vector arcade games. It’s a beautiful piece of engineering that certainly deserves its own cabinet.

Video of the game available below.

Continue reading “Making Vector Arcade Games With An FPGA” →

Avalanche Pulse Generator Design

August 6, 2013 by Mike Szczys 25 Comments

avalanche-pulse-generator

This avalanche pulse generator is a great way to test your mettle as an Electronics Engineer. The challenge is to truly understand how each part of the design works. We certainly got a failing grade when first studying the schematics more than a week ago. But we’re slowly beginning to understand what’s going on under the hood.

The concept of an avalanche transistor is some wicked voodoo from the analog side of the street which leverages a transistor’s breakdown voltage to achieve a predictable result. In laymen’s terms it (mis)uses a transistor to produce a really fast pulse. The write-up linked above references several previous avalanche pulse generator designs, but this one is a bit different in how it produces about 50V from a pair of AAA batteries using a multivibrator circuit.

Even if you have no idea what’s going on here you may be interested in the last few paragraphs where the circuit is measured using a cutting-edge Teledyne LeCroy Wavemaster 820Zi-A. That’s a 20 GHz scope with a 15.3″ screen which you’ll never ever own.

[Sprite_TM] OHM2013 Talk: Hacking Hard Drive Controller Chips

August 2, 2013 by Mike Szczys 16 Comments

Even if he hadn’t done any firmware hacking on this hard drive [Sprite_TM’s] digital exploration of the controller is fascinating. He gave a talk at this year’s Observe, Hack, Make (OHM2013) — a non-commercial community run event in the Netherlands and we can’t wait for the video. But all the information on how he hacked into the three-core controller chip is included in his write up.

[Sprite_TM] mentions that you’re not going to find datasheets for the controllers on these drives. He got his foot in the door after finding a JTAG pinout mentioned on a forum post. The image above shows his JTAG hardware which he’s controlling with OpenOCD. This led him to discover that there are three cores inside the controller, each used for a different purpose. The difference between [Sprite_TM’s] work and that of mere mortals is that he has a knack for drawing surprisingly accurate conclusions from meager clues. To see what we mean check out the memory map for the second core which he posted on page 3 of his article.

Using JTAG he was able to inject a jump into the code (along with a filler word to keep the checksum valid) and run his own code. To begin the firmware hacking portion of the project he pulled the flash ROM off of the board and installed it on that little board sticking out on the left. This made it easy for him to backup and reflash the chip. Eventually this let him pull off the same proof of concept as a firmware-only hack (no JTAG necessary). He goes onto detail how an attacker who has root access could flash hacked firmware which compromises data without any indication to they system admin or user. But we also like his suggestion that you should try this out on your broken hard drives to see if you can reuse the controllers for embedded projects. That idea is a ton a fun!

When we were poking around the OHM2013 website (linked above) we noticed that the tickets are sold out; good for them! But if you were still able to buy them they take Bitcoin as one payment option. Are there any other conferences that allow Bitcoin for registration?

BeagleBone Black Becomes A Handheld Classic Gaming Console

July 30, 2013 by Brian Benchoff 13 Comments

Over at TI, the 2013 Intern Design Challenge is underway, an opportunity for the interns of TI to flex their engineering muscle for a few prizes and a chance to have their designs turned into actual products. We’re thinking [Max] might just pull this one out with his BeagleBone Gaming Cape, an add-on to the BeagleBone Black that turns this ARM-powered Linux board into a retro gaming system.

The build was inspired by [Max]’s earlier MSP430 Launchpad GamingPack, an add-on board for the Launchpad that put two NES controllers, a VGA out, and an FPGA to create a custom gaming console that’s up there with the brightest and best consoles of the 16-bit era. For the new BeagleBone-based build, [Max] eschewed off-board processing, but did manage to include a magnetometer/accelerometer and an audio codec IC to provide the best gaming experience for all those NES, Game Gear. Gameboy, GBA and Doom .wad games.

In addition to a fabulous piece of hardware, [Max] also has the case design down to a tee. He first printed out a dozen or so layers of his case, sandwiching the BeagleBone, his cape, battery holders, and LCD display. Once he knew the dimensions would work, he sent his files off to be laser cut out of a matte black delrin. The finished piece is a work of art, and considering how well everything goes together, we wouldn’t mind giving this new retro-gaming console a spin ourselves.

Rekindling Forth With A Propeller Jupiter Ace

July 28, 2013 by Brian Benchoff 26 Comments

Jupiter

The Jupiter Ace was a small membrane keyboard, cassette tape drive computer akin to the ZX Spectrum released in 1982. Priced at £90, it was a little more expensive than its home computer contemporaries, but had a very interesting feature: instead of BASIC, the Ace ran Forth. This interpreted stack-based language is far more capable than the BASIC variants found on home computers of the day, but unfortunately the Ace failed simply because Forth was so foreign to most consumers.

Not wanting to let a good idea die, [prof_braino] is bringing Forth back into the modern age. He’s using a Parallax Propeller to emulate a simple home computer running Forth. Instead of a book-sized computer, the new Propeller version runs on a single chip, with 8 CPU cores running 24 times faster than the original, with 32 times more RAM and an SD card for basically unlimited storage.