Planet Arduino

[Giovanni Bernardo] has a very important job – managing the audio for several Christmas events. Desiring a simple and effective control interface, he designed a dedicated media keyboard to run the show.

The project began with an Arduino Leonardo, commonly used in projects that aim to create a USB Human Interface Device. [Giovanni] then installed the HID-Project library from [Nicohood]. This was used to enable the device to emulate media buttons typically found on keyboards, something the standard Arduino HID libraries were unable to do. It’s a useful tool, and one that can be implemented on even standard Arduino Unos when used in combination with the HoodLoader2 bootloader.

For ease of use and a little bit of cool factor, arcade buttons were used for the media functions. Simple to wire up, cheap, and with a great tactile feel, they’re a popular choice for fun human interface projects. It’s all wrapped up in a neat plastic box with Dymo labels outlining the functions. It’s a neat and tidy build that should make running the Christmas show a cinch!

We’ve noticed a rash of builds of [ FedorSosnin’s] do-it-yourself 3D-printed mechanical keyboard, SiCK-68 lately. The cost is pretty low — SiCK stands for Super, Inexpensive, Cheap, Keyboard. According to the bill of materials, the original cost about $50. Of course, that doesn’t include the cost of the 3D printer and soldering gear, but who doesn’t have all that already?

The brains behind this is a Teensy that scans the hand-wired key matrix. So the only electronics here are the switches, each with a companion diode, and the Teensy. The EasyAVR software does all the logical work both as firmware and a configuration GUI.

If you look at the many different builds, each has its own character. Yet they look overwhelmingly professional — like something you might buy at a store. This is the kind of project that would have been extremely difficult to pull off a decade ago. You could build the keyboard, of course, but making it look like a finished product was beyond most of us unless we were willing to make enough copies to justify having special tooling made to mold the cases.

PCBs are cheap now and we might be tempted to use one here. There are quite a few methods for using a 3D printer to create a board, so that would be another option. The hand wiring seems like it would be a drag, although manageable. If you need wiring inspiration, we can help.

For ultimate geek cred, combine this with Ploopy.

Today when you get a text, you can respond with message via an on-screen keyboard. Looking into the future, however, how would you interact unobtrusively with a device that’s integrated into eyeglasses, contacts, or perhaps even something else?

TipText is one solution envisioned by researchers at Dartmouth College, which uses a MPR121 capacitive touch sensor wrapped around one’s index finger as a tiny 2×3 grid QWERTY keyboard.

The setup incorporates an Arduino to process inputs on the grid and propose a number of possible words on a wrist-mounted display that the user can select by swiping right with the thumb. A new word is automatically started when the next text entry tap is received, allowing for a typing speed of around 12-13 words per minute.

In the heat of the moment, gamers live and die by the speed and user-friendliness of their input mechanisms. If you’re team PC, you have two controllers to worry about. Lots of times, players will choose a separate gaming keyboard over the all-purpose 104-banger type.

When [John Silvia]’s beloved Fang game pad went to that LAN party in the sky, he saw the opportunity to create a custom replacement exactly as he wanted it. Also, he couldn’t find one with his desired layout. Mechanical switches were a must, and he went with those Cherry MX-like Gaterons we keep seeing lately.

This 37-key game pad, which [John] named Eyetooth in homage to the Fang, has a couple of standout features. For one, any key can be reprogrammed key directly from the keypad itself, thanks to built-in macro commands. It’s keyboard-ception!

One of the macros toggles an optional auto-repeat feature. [John] says this is not for cheating, though you could totally use it for that if you were so inclined. He is physically unable to spam keys fast enough to satisfy some single-player games, so he designed this as a workaround. The auto-repeat’s frequency is adjustable in 5-millisecond increments using the up /down macros. There’s a lot more information about the macros on the project’s GitHub.

Eyetooth runs on an Arduino Pro Micro, so you can either use [John]’s code or something like QMK firmware. This baby is so open source that [John] even has a hot tip for getting quality grippy feet on the cheap: go to the dollar store and look for rubber heel grippers meant to keep feet from sliding around inside shoes.

If [John] finds himself doing a lot of reprogramming, adding a screen with a layout map could help him keep track of the key assignments.

If you have a serious visual impairment, using a computer isn’t easy. [Dhiraj] has a project that allows people fluent in Braille to use that language for input. In addition to having a set position for fingers, the device also reads the key pressed as you type. With some third party software it is possible to even create Word documents, according to [Dhiraj].

You can see the finished product in the video below. This is one of those projects where the idea is the hardest part. Reading six buttons and converting them into characters is fairly simple. Each Braille character uses a cell of six bumps and the buttons mimic those bumps (although laid out for your fingers).

Our thoughts are that it might be nice to have some tactile feedback on the first switch since the intended users probably can’t see the switches. Perhaps the audio sounds a little rough, but that could have been the speakers. Maybe also a dedicated spacebar and an easier way to select letters vs figures without moving your hands might be nice, too. None of that would be hard to fix.

The code was quite simple, though we can see that you might get some false keystrokes. Every 250 milliseconds the Arduino reads the seven input switches (the seventh switch is the letters/figures select). Then a giant if statement decodes the letter. Just stylistically, we would have probably built a number and used it to select from an array, as with 7 switches it would consume just 128 bytes. More importantly though we would probably wait for at least one on to off transition to start the decoding. The switches are active high, so we’d probably write something like this:

unsigned code,oldcode;
code=oldcode=0;
do {
   oldcode=code;
   code=read_button_code();  // get current code
   } while (oldcode<=code);
// process oldcode

If this looks confusing, try a few examples (you can do that online, too). At first, the oldcode is zero so code will never be less than that (note the integers are unsigned). As long as bits keep getting set, code will be greater than or equal to oldcode. However, if any bit goes from 1 to zero then the total magnitude of code must be less than oldcode. That triggers the processing. Of course, you might also want to debounce the switches in read_button_code to make sure you have a stable input, too.

Still, what a great and useful idea it is, and one easy enough to build on the original design. We’ve seen a Braille tablet before. If you have some spare space on your next PCB, you could always replace some community signs.

The modern keyboard enthusiast is blessed with innumerable choices when it comes to typing hardware. There are keyboards designed specifically for gaming, fast typing, ergonomics, and all manner of other criteria. [iot4c] undertook their own build for no other reason than nostalgia – which sounds plenty fun to us.

An Arduino Leonardo is pressed into service for this hack. With its USB HID capabilities, it’s perfectly suited for custom keyboard builds. It’s built into a working Atari 65XE computer, and connected to the keyboard matrix. The Keypad and Keyboard libraries are pressed into service to turn keypresses on the 80s keyboard into easily digseted USB data.

There’s plenty of room inside the computer for the added hardware, with the USB cable neatly sneaked out the rear. [iot4c] notes that everything still works and the added hardware does not cause any problems, as long as it’s not used as a computer and a keyboard at the same time.

It’s possible to do a similar hack on the Commodore 64, too. If you’re doing tricky keyboard builds yourself, you know where to send ’em.

Even on the go, there is no substitute for a physical keyboard with buttons that move and click. Sure, you could solder a bunch of tactile switches to some perfboard, but how about going all out and making something robust as [Anthony DiGirolamo] did for his Teensy Thumboard. Everything is insertion-mount so it is an approachable project for anyone who knows the dangerous end of a soldering iron, and that also makes it easy to hack on.

Each pin of the Teensy has an adjacent empty hole tied to it for easy access, and the serial data pins are exposed at the top of the board. All the holes use standard 0.1″ (2.54mm) spacing. The I/O points used by the keyboard are labeled, and the rest of them can use the space under the controller where proto-board style holes add some extra space for an IMU or whatever sensors suit your slant.

Most impressive is the shell, which is freely available on Thingiverse, where you can also find a bill of materials with links to everything you will need in case you don’t have drawers full of those tactile switches.

If this looks familiar, you have probably seen the PocketCHIP, and it is no secret that this project is an homage to that versatile pocket computer. We appreciate this kind of love for PocketCHIP, especially since they are now a limited commodity.

Macros are useful things. They allow one to execute a series of commands with a single keypress. There exists a wide variety of hardware and software solutions to create and use macros to improve your workflow, and now [Evan] has brought the open-source ManyKey into the fray, along with a build tutorial to boot.

The tutorial acts as a great introduction to ManyKey, as [Evan] walks through the construction of a macro keyboard designed to be operated by the feet. Based around the Arduino Leonardo and using off-the-shelf footswitches commonly used in guitar effects, it’s accessible while still hinting at the flexibility of the system. Macros are programmed into the keyboard through a Python app which communicates over serial, and configurations are saved into the Arduino’s onboard EEPROM. The ManyKey source is naturally available over at GitHub.

[Evan] tells us he uses his setup to run DJ software with his feet while his hands are busy on the turntables. That said, there’s all manner of other applications this could be used for. Efficiency is everything, and we love to see keyboard projects that aim to improve workflow with new ideas and custom builds – this shortcut keyboard makes a great example.

The first time I saw 3D modeling and 3D printing used practically was at a hack day event. We printed simple plastic struts to hold a couple of spring-loaded wires apart. Nothing revolutionary as far as parts go but it was the moment I realized the value of a printer.

Since then, I have used OpenSCAD because that is what I saw the first time but the intuitiveness of other programs led me to develop the OpenVectorKB which allowed the ubiquitous vectors in OpenSCAD to be changed at will while keeping the parametric qualities of the program, and even leveraging them.

All three values in a vector, X, Y, and Z, are modified by twisting encoder knobs. The device acts as a keyboard to

1. select the relevant value
2. replace it with an updated value
3. refresh the display
4. move the cursor back to the starting point

There is no software to install and it runs off a Teensy-LC so reprogramming it for other programs is possible in any program where rotary encoders may be useful. Additional modes include a mouse, arrow keys, Audacity editing controls, and VLC time searching.

Here’s an article in favor of OpenSCAD and here’s one against it. This article does a good job of explaining OpenSCAD.

[Editor’s note: This is a Hackaday writer’s hack, hence the “I” in place of the usual “we”. We all love custom peripherals though, and a good number of us love OpenSCAD, so you could probably read it either way, but we don’t want to take credit for [Brian]’s work.]

For anyone who has owned a boombox or an old(er) cassette player, the digital age volume controls feel incredibly awkward. Keep pressing buttons to get the volume just right can get tiresome real quick. The volume knob just makes sense and in a simple project, [Jeremy S Cook] brings us the Custom Computer Volume Control Knob.

The build employs an Adafruit Trinket board coupled with a rotary encoder and a push button as described by the designers themselves. We reached out to [Jeremy S Cook] to enquire about the build and it turns out his version uses an MDF enclosure as well as an MDF knob. A larger PCB has the encoder and button solder on with the Trinket board connecting to them via multi strand wires. An Acrylic sheet cut to the size serves as the top cover and completes the build.

The button serves as a play/pause button and can come in handy. Since the device enumerates as an HMI device, it should work with almost any OS. It could easily be extended to work with Android Tablets or even iPads. Check out the video below for a demonstration and if you like the idea of custom input devices, check out this DIY shortcut Keyboard.