Breathing New Life Into Old School ThinkPad Keyboards

May 26, 2020 by Tom Nardi 6 Comments

The ThinkPad is generally considered the unofficial laptop of hackerdom, so it’s no surprise that we see plenty of projects focused on repairing and modifying these reliable workhorses. But while we usually see folks working on relatively modern incarnations of this iconic line of computers, this project by [Frank Adams] and [Brian Chan] shows that the hacker’s love affair with the ThinkPad stretches back farther than many might realize.

As explained on the project’s Hackaday.io page, the duo have produced an open hardware board that will allow you to take the keyboard and trackpoint from a late ’90s ThinkPad 380ED and use it as a standard USB input device on a modern computer. According to [Frank], the keyboards on these machines are notable for having full-size keys rather than the “chicklet” boards that are so common today.

Now you may be wondering why this is significant. After all, we’ve seen plenty of projects that hook up an old keyboard to a USB-equipped microcontroller to get them speaking the lingua franca. Well, the trick here is that the trackpoint on these older ThinkPads actually required additional circuitry on the motherboard to function. The keyboard features three separate FPC connections for the matrix, the trackpoint buttons, and the analog strain gauges in the trackpoint itself.

After a considerable amount of reverse engineering, [Frank] and [Brian] have developed a board that uses the Teensy 3.2 to turn this plethora of pins into something useful. In the video after the break, you can see the new composite USB device working perfectly on a modern Windows computer.

It will probably come as little surprise to find that [Frank] is no stranger to hacking ThinkPad keyboards. In 2018 we covered a similar adapter he built for the far more modern T61, which was an absolute cakewalk by comparison.

Continue reading “Breathing New Life Into Old School ThinkPad Keyboards” →

Adding MIDI To An Old Casio Keyboard

May 23, 2020 by Lewin Day 22 Comments

Not content to rule the world of digital watches, Casio also dominated the home musical keyboard market in decades past. If you wanted an instrument to make noises that sounded approximately nothing like what they were supposed to be, you couldn’t go past a Casio. [Marwan] had just such a keyboard, and wanted to use it with their PC, but the low-end instrumented lacked MIDI. Of course, such functionality is but a simple hack away.

The hack involved opening up the instrument and wiring the original keyboard matrix to the digital inputs of an Arduino Uno. The keys are read as a simple multiplexed array, and with a little work, [Marwan] had the scheme figured out. With the Arduino now capable of detecting keypresses, [Marwan] whipped up some code to turn this into relevant MIDI data. Then, it was simply a case of reprogramming the Arduino Uno’s ATMega 16U2 USB interface chip to act as a USB-MIDI device, and the hack was complete.

Now, featuring a USB-MIDI interface, it’s easy to use the keyboard to play virtual instruments on any modern PC DAW. As it’s a popular standard, it should work with most tablets and smartphones too, if you’re that way inclined. Of course, if you’re more into modular synthesizers, you might want to think about working with CV instead!

More Terrible Keyboards That Nonetheless Work

May 23, 2020 by Lewin Day 5 Comments

For most of computing history, keyboards have featured at least one key per letter one may wish to type – as far as the Latin alphabet goes, anyway. Mobile phones of the 90s and 2000s showed us that basic typing could be accomplished with less. [foone], however, likes to go way out into left field when designing text entry methods, and post them up on Twitter.

The most elegant, in our opinion, is this binary-based design. 7 flip switches are used to set the binary value of the key you wish to press, at which point hitting the button will send the keypress. It’s painfully slow for just about anything except backspace – set all the switches on for keycode 127, and mash away.

This breadboard design is an excercise in frustration. A keycode is randomly generated approximately once every second. Press the button if this keycode is the one you wish to send. Reportedly, it took ten minutes to type “Hello!”. An analog dial design speeds things up a little, but not by much.

While these may not be useful, they’re fun experiments which we could imagine making an excellent contest at a future hacker con. If you’re a big fan of the esoteric and insane when it comes to input devices, consider this typewriter simulation design.

Keyboard Switch Is Really A Transformer

May 17, 2020 by Al Williams 11 Comments

We don’t know why [TubeTime] decided to show off this oddball keyboard switch as a series of Twitter posts, but we were glad to see them somewhere. At first, the switch looks pretty conventional. But as the pictures reveal the insides, you’ll notice something unusual: a ferrite toroid! These switches operate as a transformer and are known as magnetic valve switches.

The switches have two sets of two pins — one set for the primary and one for the secondary of the transformer wound around the ferrite core. That transformer remains stationary, but a pair of permanent magnets move. When the key is up, the magnets are close to the core and cause the transformer to saturate, so there is little or no output at the secondary. When you depress the key, the magnet moves away from the core, allowing the signal to pass through the transformer. What that means is there is no mechanical contact, which is good for switch life. It is also important in environments where a small spark could cause an explosion. You can watch a video about a keyboard that used those switches, below.

Continue reading “Keyboard Switch Is Really A Transformer” →

Hackaday Podcast 067: Winking Out Of IoT, Seas Of LEDs, Stuffing PCBs, And Vectrex Is Awesome

May 15, 2020 by Mike Szczys No comments

Hackaday editors Mike Szczys and Elliot Williams explore the coolest hacks of the past 168 hours. The big news this week: will Wink customers pony up $5 a month to turn their lights on and off? There’s a new open source design for a pick and place machine. You may not have a Vectrex gaming console, but there’s a scratch-built board that can turn you oscilloscope into one. And you just can’t miss this LED sign technology that programs every pixel using projection mapping.

Take a look at the links below if you want to follow along, and as always, tell us what you think about this episode in the comments!

Direct download (60 MB or so.)

Continue reading “Hackaday Podcast 067: Winking Out Of IoT, Seas Of LEDs, Stuffing PCBs, And Vectrex Is Awesome” →

Floppy Drive Keyboard Is Inefficient Fun

May 13, 2020 by Lewin Day 39 Comments

Most of us are used to a typical 101-key setup for typing on our machines. Mobile and touchscreen devices have offered alternative interfaces over the years, but generally still sticking to QWERTY or other similar layouts. [foone] cares not for convention however, building a text-entry device based on the iconic floppy disk.

The build starts with a standard PC floppy drive, hooked up to an interface board to allow it to work over USB. It’s hooked up to a Raspberry Pi, which runs a Python program that listens out for media insertion events. When a new disk is detected, it reads the volume label, and sends it over to a Teensy LC which simulates a USB keyboard attached to the host PC. The setup uses 29 disks, for A-Z, !, shift, and space. It’s all stuffed inside a SCSI disk enclosure which helpfully provides a power supply along with the classic beige 90s aesthetic.

While you’re probably not going to be typing out your dissertation on this thing, it makes for an excellent conversation piece. We’ve featured some of [foone]’s eclectic work before, too. Video after the break.

Continue reading “Floppy Drive Keyboard Is Inefficient Fun” →

Touch-Typing On Fingertips? Prototype Says It Could Work

May 9, 2020 by Donald Papp 11 Comments

The fingertips are covered in touch sensors, each intended to be tapped by the thumbtip of the same hand.

Touch-typing with thumbs on a mobile phone keyboard is a pretty familiar way to input text, and that is part of what led to BiTipText, a method of allowing bimanual text input using fingertips. The idea is to treat the first segments of the index fingers as halves of a tiny keyboard, whose small imaginary keys are tapped with the thumbs. The prototype shown here was created to see how well the concept could work.

The prototype hardware uses touch sensors that can detect tap position with a high degree of accuracy, but the software side is where the real magic happens. Instead of hardcoding a QWERTY layout and training people to use it, the team instead ran tests to understand users’ natural expectations of which keys should be on which finger, and how exactly they should be laid out. This data led to an optimized layout, and when combined with predictive features, test participants could achieve an average text entry speed of 23.4 words per minute.

Judging by the prototype hardware, it’s understandable if one thinks the idea of fingertip keyboards may be a bit ahead of its time. But considering the increasingly “always on, always with you” nature of personal technology, the goal of the project was more about investigating ways for users to provide input in fast and subtle ways. It seems that the idea has some merit in principle. The project’s paper can be viewed online, and the video demonstration is embedded below.

Continue reading “Touch-Typing On Fingertips? Prototype Says It Could Work” →