Presenting the single ESC key USB keyboard


DSC00651_crop2 (1)

Glen Akins shares his latest build the single ESC key USB keyboard:

After building the “awesomely impractical” giant three-key keyboard, I decided it was time to build something a bit more practical—presenting the single ESC key USB keyboard! This keyboard has exactly one function which is to provide an optimal ESCing experience regardless of whatever keyboard you normally use. In exchange for giving up a USB port, you get a dedicated tactile, clicky Cherry MX blue ESC key.

See the full post on Photons, Electrons, and Dirt blog.

Remapcro: A hardware keyboard macro recorder


Anthony Lieuallen has published new build, a hardware keyboard macro recorder: Remapcro

I posted once recently about the prototype of this project, but as of today I’ve finished the first real one. The name Remapcro is a portmanteau of remap and macro, because that’s what it does. It’s an array of extra keys onto which macros can be stored, and then replayed at a touch. It works by sitting between your keyboard and computer. Normally key presses are passed straight through, but when recording a macro they are stored and then later replayed.

More details at

C64 Keyboard Emulation Over Serial

There’s a lot of reasons you might want to emulate the keyboard on your Commodore 64. The ravages of time and dust may have put the original keyboard out of order, or perhaps you need to type in a long program and don’t fancy pecking away with the less-than-stellar feedback of the standard keys. [podstawek] has come up with the solution: a Commodore 64 keyboard emulator that works over serial.

It’s a simple concept, but one that works well. A Python script accepts incoming keypresses or pre-typed text, then converts them into a 6-bit binary code, which is sent to an Arduino over the serial connection. The Arduino uses the 6-bit code as addresses for an MT8808 crosspoint switch.

MT8808 Functional Diagram from Datasheet

The MT8808 is essentially an 8×8 matrix of controllable switches, which acts as the perfect tool to interface with the C64’s 8×8 keyboard matrix. Hardware wise, this behaves as if someone were actually pressing the keys on the real keyboard. It’s just replacing the original key switches with an electronic version controlled by the Arduino.

[podstawek] already has the setup working on Mac, and it should work on Linux and Windows too. There’s a little more to do yet – modifying the script to allow complex macros and to enable keys to be held – so check out the Github if you want to poke around in the source. Overall it’s a tidy, useful hack to replace the stock keyboard.

The C64 remains a popular platform for hacking — it’s even had a Twitter client since 2009.

Filed under: classic hacks, computer hacks

Adding MIDI Out to the Casio PX410R

Since the 1980s, MIDI has been a great way to send data between electronic musical instruments. Beginning as a modified serial interface running through optoisolaters and DIN sockets, these days, your hardware is more likely to carry its MIDI data over USB instead. This is great if you want to hook up to a computer without a cumbersome interface, but not so great when you want to connect a bunch of instruments to each other.

The Roland Integra 7 is a rack mount synthesizer with classic MIDI ports. [adriangin] wanted to control the synthesizer over MIDI, but their Casio keyboard only had MIDI over USB available. To get around this, [adriangin] set out to add a standard MIDI Out port to the Casio PX410R.

If you want to be a hardware hacker, get familiar with standard serial communications. After some probing around the test pads while playing with the keyboard’s sustain pedal, [adriangin] found what looked like a MIDI signal between two ICs, but at a non-standard bitrate. The hunch turned out to be correct – the signal was going between the synthesizer DSP chip & the IC handling the USB connection. The standard MIDI interface operates at 31250 baud, while this signal was at 215500 baud. There’s no simple way to convert from one baud rate to another, so [adriangin] had to do it the hard way.

An Atmega32P was pressed into service, using a soft UART implemented on a digital pin to run at 215500 baud. At such a high bitrate, the soft UART required some cycle-accurate assembly programming to get everything humming along. The data would then be repeated over to the hardware UART running at 31250, which was wired to a standard DIN plug as used in classic MIDI. It’s a useful hack that allows the keyboard to work with a much wider range of hardware. It’s topped off by its clean execution, with the new port neatly integrated into the rear panel.

Check out these other great MIDI hacks, like this chiptune looper built from the ground up or this MIDI-enabled Stylophone.

Filed under: musical hacks

Do You Miss The Sound Of Your Model M?

There is one aspect of desktop computing in which there has been surprisingly little progress over the years. The keyboard you type on today will not be significantly different to the one in front of your predecessor from the 1970s. It may weigh less, its controller may be less power-hungry, and its interface will be different, but the typing experience is substantially identical. Or at least, in theory it will be identical. In fact it might be worse than the older peripheral, because its switches are likely to be more cheaply made.

The famous buckled springs in operation. Shaddim [CC BY-SA 3.0], via Wikimedia Commons.
The famous buckled spring in operation. Shaddim [CC BY-SA 3.0], via Wikimedia Commons.
Thus among keyboard aficionados the prized possessions are not necessarily the latest and greatest, but can often be the input devices of yesteryear. And one of the more famous of these old keyboards is the IBM Model M, a 1984 introduction from the computer behemoth that remains in production to this day. Its famous buckled-spring switches have a very positive action and a unique sound that once heard can never be forgotten.

So if you are a Model M enthusiast and you miss the characteristic clack of high-speed buckled-spring typing on your modern-day laptop, what’s to be done? Fortunately [Ico Doornekamp] has the answer, in the form of bucklespring, an IBM Model M sound emulator. Install it on your Linux box, your Mac, or your WIndows PC, and relive the classic sound of the 1980s as you type!

Yes, it’s gloriously silly, we’ll grant you that. And all your colleagues will hate you for it. But we know some of you won’t be able to help it, and will spend the next few days gleefully clacking away from your MacBook Airs until you get bored with it. After all, if using your computer no longer has the power to entertain, what’s the point?

If the Model M is too new for you, it’s not the only desirable IBM keyboard of yore, how about a Model F? Or give up on these newfangled electronics, and just use a typewriter.

Via Hacker News.

Header Model M image: Raymangold22 (Own work) [CC0], via Wikimedia Commons.

Filed under: classic hacks, hardware, peripherals hacks

Bringing USB Devices To The Apple Desktop Bus

During the development of the greatest member of the Apple II family, the Apple IIgs, someone suggested to [Woz] that a sort of universal serial bus was needed for keyboards, mice, trackballs, and other desktop peripherals. [Woz] disappeared for a time and came back with something wonderful: a protocol that could be daisy-chained from keyboard to a graphics tablet to a mouse. This protocol was easily implemented on a cheap microcontroller, provided 500mA to the entire bus, and was used for everything from license dongles to modems.

The Apple Desktop Bus, or ADB, was a decade ahead of its time, and was a mainstay of the Mac platform until Apple had the courage to kill it off with the iMac. At that time, an industry popped up overnight for ADB to USB converters. Even today, there’s a few mechanical keyboard aficionados installing Teensies in their favorite input devices to give them a USB port.

While plugging an old Apple keyboard into a modern computer is a noble pursuit — this post was written on an Apple M0116 keyboard with salmon Alps switches — sometimes you want to go the other way. Wouldn’t it be cool to use a modern USB mouse and keyboard with an old Mac? That’s what [anthon] thought, so he developed the ADB Busboy.

The ADB Busboy is the exact opposite of [tmk]’s ADB to USB converter firmware for the Teensy. Instead of turning an old ADB keyboard into a USB device, [anthon]’s ADB Busboy turns USB keyboards and mice into ADB devices. Now, every USB keyboard and mouse is compatible with almost every Macintosh ever made, save for the 128, 512, Mac Plus, PowerBook 150, and arguably a few other portable models.

Why would anyone want to do this? Because it’s neat. Check out the animated thing [anthon] made:

There’s no release for the ADB Busboy quite yet. [anthon] still needs to implement and test a few features, design a PCB, an enclosure, and hopefully sell these USB to ADB converters to some nerds who have far too many old computers in their basement. They’re collector’s items, get off my back.

[anthon] has a site up where he’ll eventually announce this project’s release. You can sign up for an email alert when that happens.

Filed under: classic hacks, peripherals hacks

DIY KVM Switch Lets You Use One Keyboard and Mouse With Multiple Computers

Here’s a quick DIY hack if you happen to have multiple computers at home or at the office and are tired of juggling mice and keyboards. [Kedar Nimbalkar] — striving for a solution — put together a keyboard, video and mouse switcher that allows one set to control two computers.

A DPDT switch is connected to a female USB port, and two male USB cables — with the ground and 5V wires twisted together and connected to the switch — each running to a PC. [Nimbalkar] suggests ensuring that the data lines are correctly wired, and testing that the 5V and ground are connected properly. He then covered the connections with some hot glue to make it a little more robust since it’s about to see a lot of use.

Now all that’s needed is a quick press of the button to change which PC you are working on, streamlining what can be a tedious changeover — especially useful if you have a custom keyboard you want to use all the time.

[Thanks for the submission, Kedar!]

Filed under: misc hacks, peripherals hacks

Custom Keyboard Makes the Case for Concrete

One of the worst things about your average modern keyboards is that they have a tendency to slide around on the desk. And why wouldn’t they? They’re just membrane keyboards encased in cheap, thin plastic. Good for portability, bad for actually typing once you get wherever you’re going.

When [ipee9932cd] last built a keyboard, finding the right case was crucial. And it never happened. [ipee9932cd] did what any of us would do and made a custom case out of the heaviest, most widely available casting material: concrete.

To start, [ipee9932cd] made a form out of melamine and poured 12 pounds of concrete over a foam rectangle that represents the keyboard. The edges of the form were caulked so that the case edges would come out round. Here’s the super clever part: adding a couple of LEGO blocks to make space for the USB cable and reset switch. After the concrete cured, it was sanded up to 20,000 grit and sealed to keep out sweat and Mountain Dew Code Red. We can’t imagine that it’s very comfortable to use, but it does look to be cool on the wrists. Check out the gallery after the break.

Concrete is quite the versatile building material. We’ve seen many applications for it from the turntable to the coffee table to the lathe.

Thanks for the tip, [Itay]. Via r/mechanicalkeyboards.

Filed under: computer hacks, how-to, lifehacks