Keyboard buzzer to replace console bell

+ = ?

The Idea
Being a console junky, I am always looking for ways to improve my experience at the terminal. One thing that is is dire need of improvement is the console bell. You know, the really annoying beeping sound that occurs when you pressed the wrong key, that you immediately disable when setting up a new computer. Unfortunately, the bell really does provide a useful service: that of allowing the system to notify you when you need to fix your input. It is possible to turn on a ‘visible bell,’ which inverts the foreground and background colors of the console. In practice, though, I find this almost as annoying as the bell, and disable it as well.

So what else can we try? It occurred to me that there is an obvious solution: haptic feedback! The only trouble is, I don’t know of many keyboards that have a vibrating motor built in. Of course, this is an easy thing for a DIYer to fix. It turns out that is is quite straightforward to add the vibrator motor to the keyboard, however patching a terminal program to activate the buzzer took a bit more head scratching. Instructions after the break…

Preparing the Vibrator Motor
The first step was to secure a vibrator motor. I happened to have one from an old cell phone, so I pulled it out and dusted it off. It had very short leads on it, so the first order of business was to solder some longer wires to it.

Because the leads were so tiny and fragile, I added some shrink tubing to hold everything together. I put a small diameter tube over each wire individually, then two layers of larger shrink tubing over the whole thing. It ended up looking like this:

Later on, I added a connector to the end of the motor leads.

Interfacing to the keyboard
The next step was to figure out how to hook the motor up to the keyboard. Because I was using a USB keyboard, I knew that there would be a good 5v power source available. To trigger the motor, I decided to use the scroll lock LED. My initial plan was to use a sneaky signaling system where I would flash the LED faster then the eye can see, and program a microcontroller to look for the signal and turn on the vibrator. That turned out to be overkill, and I ended up switching the motor on and off using the scroll lock LED directly. I decided to modify my Microsoft Natural Ergonomic Keyboard 4000. Getting it apart was a little tricky. All the screws in the back had to be removed, then the space bar was (carefully) popped off, revealing two further screws. There was a final clip at the front center of the keyboard, which came apart easily once the space bar screws were removed.

I really lucked out choosing this keyboard- the controller board uses nice, through-hole discrete components. It was short work to hook up a multimeter and figure out which of the large resistors connected to our Scroll Lock LED. To do this, I attached one lead to a ground connection, and then probed the ends of the resistors with the other lead while toggling the scroll lock LED (tip: if the scroll lock button is disabled on your system like it is on my Ubuntu one, you can use the command ‘xset led 3′ to turn it on, and ‘xset -led 3′ to turn it off).

Once I identified the proper end of the proper resistor, I rigged up a transistor to drive the motor. Because the LED is being controlled from the low side (meaning it is always connected to +5v, and the controller connects and disconnects the ground side to turn it on and off), I needed to use a PNP transistor to turn the motor on and off in phase with the LED. I replaced the original resistor that was powering the LED to get a higher motor current, and added a transient suppression diode in parallel with the motor:

I soldered some leads onto the +5v and GND connections from where the USB connector interfaced with the board, and also soldered a lead to the LED wire that I had identified previously. I then built a prototype of the circuit on a breadboard, and connected it up:

Once I was satisfied that the circuit would work, I mounted it on a little pc board from radio shack and stuck it in the keyboard.

The final mechanical bit was to attach the buzzer motor to the keyboard. I decided to glue it to the left-side wrist rest, so that it would be closest to my hand when it vibrated. I had some Aleene’s 7800 adhesive laying around that I decided to try; I will try to remember to update later to tell if it worked or not. Before gluing the two parts together, I used some sandpaper to rough them up, and some IPA to clean off the sanded surfaces. I then used a ‘C’ clamp to hold the two pieces together during drying.

Modifying the Terminal Program
With the hardware bit finished up, it was time to work on the software bit. So far, I had been triggering the LED on and off manually, and I needed a way to integrate the buzzer into the terminal. I first pulled down the source for gnome-terminal, but found that it was really a front-end for a library, and that I would need to compile and install the library to get it to work. Instead, I switched to Xterm, which implements its terminal functions directly.
I modified Xterm version 235 (available here) to flash the scroll lock LED instead of turning on that horrid buzzer. It turned out that I only had to patch one file, misc.c. I am not an experienced X11 programmer, so it took a while to figure that out :-). The patch follows. Of course, the best way to do this would be to modify the low-level X libraries, but that would be significantly more work.

787a788,816
> 
> #define CAPSLOCKLED     1
> #define NUMLOCKLED      2
> #define SCROLLLOCKLED   3
> 
> /* Turn the Scroll Lock LED on momentarily, to trigger a vibration motor */
> void
> VibrateBell()
> {
>     TScreen *screen = TScreenOf(term);
>     XKeyboardControl keyboard_control;
>     unsigned long mask = KBLed | KBLedMode;
> 
>     /* Turn the Scroll Lock LED on */
>     keyboard_control.led = SCROLLLOCKLED;
>     keyboard_control.led_mode = LedModeOn;
>     XChangeKeyboardControl(screen->display, mask, &keyboard_control);
>     XSync(screen->display, false);
> 
>     /* Wait a while */
>     usleep(100000);
> 
>     /* Turn the Scroll Lock LED off */
>     keyboard_control.led = SCROLLLOCKLED;
>     keyboard_control.led_mode = LedModeOff;
>     XChangeKeyboardControl(screen->display, mask, &keyboard_control);
> }
> 
> 
824c853
< 	XkbBell(screen->display, VShellWindow, percent, which);
---
> //	XkbBell(screen->display, VShellWindow, percent, which);
826c855
< 	XBell(screen->display, percent);
---
> //	XBell(screen->display, percent);
827a857,858
> 
>     VibrateBell();

Results
After re-assembling the keyboard, the modified Xterm program was run. The vibrator does work as designed; however, the vibration is too weak to shake the keyboard, and as a result is too hard to feel well. The vibration definitely can be heard, which means that it works as a notification of sorts. I might try replacing the PNP transistor with a P-channel MOSFET, which has the potential to drive the buzzer harder. During testing, I noticed that it is currently drawing 65 mA using the current setup, while it is capable of 100 mA when connected directly to the power supply. All in all, a fun experiment!

As a side note, this method could probably be used as a simple way to control other devices using the computer. It is especially handy for ones that you want mounted in or near the keyboard. Be careful when driving devices directly from an LED signal though, in case a rogue program decides to turn it on for a long time.