Development

(NOTE: This post originally appeared on my personal blog here. I have copied it here for continuity.)

The rest of the keyglove hardware has arrived! Awesome!

In case you have no idea what I’m talking about, my previous posts about the keyglove are here, here, and here.

After I got the envelope open, I plugged the Arduino board in and, surpassing all expectations, had my prototype code running on it in about 10 seconds. It was literally that fast and easy. My code didn’t do much at the time and has required some changes, of course, but the interface couldn’t have been easier. I am very impressed with the board and the simple, effective development environment.

Most importantly, the silver epoxy showed up, and I’ve been able to test it on the glove’s fingertips. It is remarkably conductive, and in that sense it is exactly what I was hoping for. However, it is a pain to work with because of the nature of epoxy, and it is relatively expensive. I only did two of the contact pads, and it’s reasonable to believe that I could have used the rest of the tube on just that one glove. Silver is over $21/oz right now, and combined with the extra properties and manufacturing costs of the epoxy, that adds a good $30 to the materials cost of any single glove, not to mention a lot more work.

So, I’m going to try using adhesive copper foil tape instead (maybe with some regular epoxy to make sure it stays put). I don’t have any of it yet, but hopefully it will arrive in the next couple of days. In the mean time, I can work on my code and get it much closer to completion. I don’t think I’ll be able to get it to a true working state until after the PS/2 cable shows up and I can test the actual computer interface a bit. How that works will impact how I define the keycode constants. I want this thing to be customizable; the Arduino has 512 bytes of EEPROM memory which I should be able to use for persistent customization just such as this.

This is so awesome!

(NOTE: This post originally appeared on my personal blog here. I have copied it here for continuity.)

The first of the keyglove prototype hardware I ordered has arrived! So far, it’s just the gloves and wire and a few tools; I still need the silver epoxy and Arduino board. I got two pairs of gloves in case I screwed one up, since they were so cheap. I’m wearing them right now (and will try to continue to do so until/unless they become annoying). I want to see how easy it is for me to do regular daily tasks while wearing them.

Of course, there are a few reasons this “test run” isn’t quite realistic. First, I’m wearing two gloves right now, and for real usage, I’d really only be wearing one. Second, these gloves don’t have any hardware on the back or, more importantly, conductive pads on the front anywhere. Certain things that make strong use of the fingertips (such as typing) won’t feel accurate yet. But even so, it’s an interesting experiment. The hardware should add a negligible amount of weight, and the conductive pads should hopefully be thin enough not to be very disruptive.

Most of what I do during the day for work is typing or moving the mouse. Here are my observations so far:

• Freedom of movement is almost unchanged. The gloves don’t feel restrictive by themselves.
• It is much more difficult to find “home row” by touch on a keyboard through the gloves.
• Having found home row, typing takes only a slightly larger amount of concentration than usual.
• The gloves are thin enough that they don’t create “fat-finger” typos accidentally.
• Using a regular mouse is exactly the same with or without the gloves, except there is almost no grip when picking it up.
• Using the Trackpoint (a.k.a. “nub” or “button” mouse) on my Thinkpad is not difficult.
• Using my capacitive phone touchscreen is not impossible, but it is very difficult.

More to come later. I need to see if I can finish the Arduino code.

(NOTE: This post originally appeared on my personal blog here. I have copied it here for continuity.)

After I wrote my last post (not before, as I probably should have done), I googled “keyglove” to see what would come up. As it turns out, there are actually a few separate designs that are in some way similar to what I wrote about. My idea was an original thought for me, but it seems there are others who have also had the same original thought.

The least similar project is a 16-key wearable keyglove, which appears to be an early prototype that didn’t go very far. According to the article, it attempted to create all of the standard 101 keys of a full-size keyboard, but only succeeded in implementing 45 due to ergonomic constraints. They also seem to be using leather gloves, which are more restrictive than I prefer. I am not sure of the actual year of design.

The next attempt, on eyetap.org as a Key-Glove, looks incredibly similar to the physical design I imagined, but the implementation is a little different. They don’t make use of the palm area at all, at least in the default design, and they use 21 different sensors (made ingeniously from snap buttons) to achieve 8 * 13 = 104 possible 1-to-1 sensor combinations. The processor board is ripped from a standard 101-key keyboard though, so it is impossible to make use of multi-sensor combinations, and very difficult to customize once it’s built. The physical design is great though.

The third keyglove, adapted from the one on eyetap.org, is over at wirejunkie.com. It’s closer in comfort to what I envisioned, but other than being an ergonomically refined version of the previous glove, it is very similar. It does make more use of keyboard remapping though.

There is also the Thumbcode glove from Stanford. This is also close to what I had in mind, though the approach is different. They have only buttons on the three segments of each of four fingers, and achieve multiple combinations by detecting which fingers are touching together. It is a very interesting glove.

Finally, there is the KiTTY input device (kittytech.com). This is a unique kind of glove-like device which was originally designed for both hands and made to be easy for people who are already good at touch typing. It is not quite like any of the other above mentioned devices, but it is also not quite like what I had in mind.

None of these designs take advantage of the relative ease with which the human hand can use two or more fingers to touch the same area on the same hand. They are also usually not easy to customize after building beyond OS-based keyboard remapping, and the sensors are quite small due to the hardware used (snap buttons, except in the case of the KiTTY). Additionally, two of the gloves were leather, which impedes other kind of precision activities (like writing or typing on a regular keyboard).

Because this is inexplicably interesting to me, I’ve come up with a set of requirements and parts for the prototype I’ve decided to build. So far, the research and design has amounted to about three hours. I haven’t put in any implementation time yet since I don’t have any of the parts, but I might try working on some of the processing code at some point soon. Here are my requirements:

• Lightweight
• Doesn’t inhibit other activities, like writing or using a phone
• Totally customizable through software
• Utilizes as many finger arrangements as possible
• Requires no extra devices or surfaces
• Adaptable to a battery-powered Bluetooth interface
• Easily removable

I haven’t figured out specifically how to address the Bluetooth issue, but I have ideas for the rest of the requirements. Here are the relevant parts required for my initial prototype:

• Jeffers black handbell glove ($2.95 per pair)
• MG Silver Conductive Epoxy ($26.99 per 14oz)
• 26 AWG wire-wrap grade wire
• Arduino Mega microcontroller board ($32 from eBay)

The handbell glove is very comfortable and quite thin. The Arduino Mega board looks awesome for prototyping; it’s too big for a finished product, but that’s not what it’s designed for. It should allow me to do about as much customization as I can think of. The silver epoxy is a gamble. It’s suppose to be highly conductive (volume resistance < 1 ohm), so my goal is to use it to create relatively large thin conductive pads on the glove in which I can simply set the wires and allow everything to dry. It might not work though, in which case I’ll probably have to try something metal. I’d rather use epoxy since it’s less potentially damaging to other surfaces. My glove sensor arrangement is shown on the right.

I still need to finish mapping the sensor connection possibilities, and then take a shot at mapping the keys, and then I’ll be ready for hardware! This is exciting.

(NOTE: This post originally appeared on my personal blog here. I have copied it here for continuity.)

Recently, I came across something in Olli Markkanen’s blog about his wearable computer which intrigued me. Of course, wearable computers have always been intriguing to me, but while most of the hardware has reached or passed the point of being tiny and inexpensive enough, there are two things that aren’t yet as far as I can tell: the display and the input method.

Now, I’m not going to really discuss the display, since I know very little about optics or display technology. There are some incredible devices out there, but they all suffer from at least one of the following problems:

• Too expensive
• Too low-resolution
• Too obtrusive to vision
• Too bulky
• Not available outside the military

My ideal wearable display would be a monocular (single-screen) device, perhaps a couple hundred dollars, that could clip on to either side of any normal pair of glasses and use a tiny prism and projection device to create a mostly transparent viewport for one eye. But again, I don’t really know much about optics, so this might be impossible. But it doesn’t seem like it.

Anyway, my main interest is in the input device. There are also many one-handed keyboards out there. Many of them are designed to accommodate people who have the use of only one of their hands. Some are relatively small, while some are nowhere near small enough to use as a portable device on a wearable computer. Most of the most promising ones are either some type of contoured multi-button device that you hold in one hand, or else a miniature armband keyboard.

The armband keyboards are about like what you might find on a cellphone. They have a lot of buttons, but they’re very small and require precise movements. They have a lot of keys, but it is difficult to be fast on them and virtually impossible to use them accurately without looking.

The handheld ones are typically better, but since they have perhaps only seven or eight keys, they take a lot of getting used to. Once you learn the new combinations required, you can use them with reasonable speed without looking. However, you still usually have to hold something, and your hand needs to be in a specific position to use it. On top of that, your hand is pretty much unusable for anything else while you’re holding whatever it is you need to hold. The particular device that got me interested in this is known as a SpiffChorder.

One thing that every one of the handheld devices seem to have in common is that the keys must be pressed. Whether they are full-sized keys or simply very small buttons, they require a definite force and a pressing action to trigger them. This requires more work and usually more space.

So, here is my idea. Instead of this, I would very much like to see a glove that has resistive touch sensors in strategic locations (finger segments and tips, three rows on the palm, and three on the thumb side of the index finger). The basic usage would be by touching sensors together, rather than pressing designated keys on a separate device. I believe that with the correct calibration of touch sensitivity, this “keyglove” could be used without any extra devices (key grips to hold) or surfaces (tabletops), and certainly without looking once the technique is learned.

This keyglove would need a small amount of sensor wiring on the back side of the glove, and USB or battery powered Bluetooth processor probably in the wrist somewhere, but since the hard part would be handled by software, it would mostly be able to look and feel like a regular glove. It would definitely be thin and light enough to leave your hand available for other things if desired, such as writing with a pen, dialing a phone, holding a steering wheel, working with tools, or any other activity that wouldn’t risk damaging the glove.

In the arrangement in the photo on the right, there are a total of 20 unique sensors on a single hand. The palm sensors could be broken into four parts each, but that is probably not worthwhile mainly because it is difficult to touch your palm with any fingertip on the same hand in all but one vertical “column” of skin. That is, it is very hard to touch your palm directly below your index finger using any other finger. The software would be able to tell which finger is doing the pressing as well as whether the palm is being pressed anyway.

From my experiments with my own fingers, it is obviously impossible for each sensor to be used in at least one combination with every other sensor. Some sensors cannot interact due to the human physiology. For example, only the fingertip sensors can reasonably press the palm sensors. Only the two thumb sensors can reasonably press the side index sensors. With these kinds of restrictions in mind, there are exactly 30 combinations of unique two-sensor combinations. I won’t list them all here, but feel free to figure them out on your own (or contradict me).

The standard full-size desktop keyboard has 104 keys. This is by no means a minimal keyboard, especially since it includes the number pad, every single key of which is a duplicate of another. In reality, for full functionality, you could argue for:

• 26 letters
• 10 numbers
• 11 symbols
• 4 directional keys (U/D/L/R)
• 3 modifiers (shift/ctrl/alt)
• Insert/Delete
• Home/End
• Page Up/Page Down
• Enter
• Backspace
• Tab
• Escape
• Context Menu (critical for mouseless operation)

You may also add to that 10 or 12 function keys, depending on your application requirements. This is a grand total of 77 keys, including 12 function keys. Note that I listed only 11 symbols, while there are in reality 29 on my keyboard. However, there are only 11 dedicated symbol keys, and the remaining symbols are achieved by using shift along with the symbol keys and the number keys.

Now, back to our keyglove sensors. 30 unique combinations is actually pretty good, all things considered. But it certainly doesn’t meet the requirements all by itself. To take care of that, we have to incorporate combinations of more than two sensors. For example, instead of an “A” being generated by touching your palm with your index fingertip, perhaps it would require the simultaneous touch of your index and middle fingertips. This kind of combining allows an extra 66 combinations by using three sensors at a time and 22 combinations using four sensors at a time. This gives us a total of 118 possibilities. Now we’re getting somewhere!

Some of these combinations are very easy, while some are more difficult. Also, you’d want to take into consideration the fact that modifier combinations—especially shift—should be as non-intrusive as possible, and allow for the largest number of simultaneous other possibilities (either that, or you’ll end up using something like StickyKeys to take care of modifiers using software only).

If I had some test sensors, I would build the glove myself and then build the key combination set (also called a “chordset”). I am confident such a glove could work well, and could allow all kinds of wearable PC control, or even just typing quickly on a phone with no hardware keyboard. It might even entice me to buy a phone without a hardware keyboard, ha!