Posts | Comments

Planet Arduino

Archive for the ‘keyboard’ Category

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.

One interesting thing is this: the inertia of users being familiar with a QWERTY layout is apparent even in a forward-thinking project like this one. We covered how Dvorak himself struggled with people’s unwillingness to change, even when there were clear benefits to doing so.

[via Arduino Blog]

The Arduino platform is one of the most versatile microcontroller boards available, coming in a wide variety of shapes and sizes perfect for everything from blinking a few LEDs to robotics to entire home automation systems. One of its more subtle features is the ability to use its serial libraries to handle keyboard and mouse duties. While this can be used for basic HID implementations, [Nathalis] takes it a step further by using a series of Arduinos as a KVM switch; although admittedly without the video and mouse functionality yet.

To start, an Arduino Uno accepts inputs from a keyboard which handles the incoming serial signals from the keyboard. From there, two Arduino Pro Micros are attached in parallel and receive signals from the Uno to send to their respective computers. The scroll lock key, which doesn’t do much of anything in modern times except upset Excel spreadsheeting, is the toggle switch between the two outputs. Everything is standard USB HID, so it should be compatible with pretty much everything out there. All of the source code and schematics are available in the project’s repository for anyone who wants to play along at home.

Using an Arduino to emulate a USB input device doesn’t have to be all work and no play, the same basic concept can also be used to build custom gaming controllers.

Just when we think we’ve peeped all the cool baby keebs out there, another think comes along. This bad boy built by [andyclymer] can be configured three different ways, depending on what kind of control you’re after.

As designed, the PCB can be used as a six-switch macro keyboard, or a rotary encoder with two switches, or a pair of rotary encoders. It’s meant to be controlled with Trinket M0, which means it can be programmed with Arduino or CircuitPython.

This could really only be cooler if the key switch PCB holes had sockets for hot-swapping the switches, because then you could use this thing as a functional switch tester. But hey, you can always add those yourself.

If you’re in the market for purpose-built add-on input device, but either don’t have the purpose nailed down just yet, or aren’t sure you want to design the thing yourself, this board would be a great place to start. Usually, all it takes is using someone else’s design to get used to using such a thing, at which point it’s natural to start thinking of ways to customize it. [andyclymer] is selling these boards over on Tindie, or you can roll your own from the repo.

Need just a few more inputs? We’ve got you covered.

Sometimes you might want to browse your favorite social media site while eating a sandwitch, or throwing darts, or fending off an attacker with a sword. You know, normal things that might occupy only one of your hands. If you’ve ever found yourself in such a situation, then this custom Reddit keyboard could be for you.

Built by [jangxx], this little board is about as simple as it gets. Even if you aren’t looking for a way to browse /r/cooking while practicing your single-handed egg cracking technique, the same principles could be used to quickly throw together a macro keyboard for whatever your particular needs might be.

Inside the 3D printed enclosure is nothing more exotic than an Arduino Pro Micro and five Cherry MX Red switches. The switches have been wired directly to the GPIO pins on the Arduino, and a simple Sketch takes care of the rest. [jangxx] has written the code in such a way that you can easily define the mapping of USB HID keys to physical switches right at the top of the file, making it easy to reuse for your own purposes.

As simple as this project is, we really like the trouble that [jangxx] went through on the 3D printed key caps. The white up and down arrows allow you to navigate through the posts, and the center key selects the one you want to view. Since it’s for Reddit, naturally the red and blue buttons for rapid voting. When you want to go back to the list of posts, just hit the center button again.

Back in 2011 we saw a dedicated Reddit voting peripheral, but we think the addition of simple navigation keys makes this project a bit more compelling. Incidentally, if you can think of any other reason you might want a one-handed keyboard for browsing Reddit…we definitely don’t want to hear about it.

When [easyjo] picked up this late ’80s Marconi mil-spec keyboard for cheap, he knew it wouldn’t be easy to convert it to USB — just that it would be worth it. Spoiler alert: those LEDs aren’t a mod, they’re native. They get their interesting shape from the key traces, which are in the four corners.

Despite having way-cool buttons such as WPNS HOLD, and the fact that Control is on the home row where it belongs, this keyboard does not look fun to type on at all for any length of time. Of course, the point of this keyboard is not comfort, but a reliable input device that keeps out dust, sweat, liquids, and the enemy.

This is probably why the controller is embedded into the underside of the key switch PCB instead of living on its own board.  [easyjo] tried to analyze the signals from the existing 26-pin connector, but it didn’t work out.

So once he was able to decode the matrix, he removed the controller chip and wired the rows and columns directly to an Arduino Leonardo. Fortunately, the LEDs were just a matter of powering their columns from the front side of the board.

The availability of certain kinds of military surplus can make for really interesting modernization projects, like adding POTS to a field telephone.

Via r/duino

[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.



  • Newsletter

    Sign up for the PlanetArduino Newsletter, which delivers the most popular articles via e-mail to your inbox every week. Just fill in the information below and submit.

  • Like Us on Facebook