The geekeyboard
V2.3
Geekeyboard v2.3 is working as of today, Feb 24. It's the first
version to actually be implemented as keys on a keyboard. Other than
that, the main change
here is that there is one global sync generator for all the keys, and
then there are smaller modules, each of which controls about 5
displays. V2.3 allows me to flexibly add new displays as
wanted/needed. It's an implementation of part of the system described
here. I'm currently using an atmega48 for the
sync generator(overkill, but it was lying on my desk) and atmega16s to
control 4 displays each. Source code is here.
Everything's still breadboarded, so no schematics yet, although I'm
working on an eagle board
More pictures of v2.3 are here. A short
movie of animations running on the keys lives here. Version 2.4 should include
serial communication for changing the displays, and versions 3 and
beyond will probably switch to pic hardware.
V2.2
In October or so, I was drooling over slashdot(a popular pastime)
when I noticed a post about a new keyboard, the Optimus keyboard. It
had color OLED screens on each key, and they could change to different
letters, icons, or even animations. I immediately wrote my mother and
said that I was selling all my clothes, and would henceforth shroud
myself only in keyboards.
Unfortunately, it wasn't coming out anytime soon. A 3-key version,
the Optimus 3, came out in february 06, costing $100. The 64x64 OLED
screens cost at least $20 in larg quantities anywhere I looked, and so
I coulnd't see a 100 key keyboard being very cheap. I grit my teeth,
set my jaw, and decided to build my own.
Since the OLED displays were prohibitively expensive, I looked for
other things. I found these nice 5X7 LED displays which were about
key size, and didn't cost too much(about a buck, depending on where
you look). I was very interested in keeping the price down, what with
being a broke student and all, and needing to make 100 keys worth of
displays.
The displays came in a few days later and I sat down and worked out
the guts. They're common cathode/column, and there's a pin for each
row and each column. I programmed an atmel to sweep through the
columns and load the data for each column into the rows as it pulls the current
through the column pin. Then I got to work writing code.
I made a program that let me graphically design a character, and
then compute the binary values for the microcontroller, and then
happily put down my notepad. After a few minutes, I had all the
letters mapped out and my micro was happily displaying them. The
letters seemed kinda boring, so I modified the character editing
program to same the data in frames, and I started making animations.
The result was incredibly pleasing. I was using an atmega48 at 20
mhz, and it had plenty of cycles to animate two displays as fast as I
wanted. I amused myself and bored my friends by making countless
cutesy animations, and then started designing how I would actually
make a keyboard work.
Before I write more boring details, though, let me talk a bit about
how cool this idea actually is. The company that makes the optimus
keyboard is playing up changing the keys to display different icons
for different programs, but that's only the tip of the iceberg. If
you think about it, when you learn to use a new program, a lot of the
time you spend is learning and remembering where each function is
located, and how to use it. Now, the programmers are usually nice and
write in keyboard shortcuts, but you have to memorize those, too.
Normally, when you hit ALT or CTRL on your keyboard, it actually
changes the meanings of all the keys. For example, when you're
holding down CTRL, 'p' no longer means the letter p, it means Print.
You don't know that at first--you have to look at the little pull-down
menu to figure it out, but wouldn't it be nice if all the keys
displayed their new, different functionality when you hit a function
key? This way, it would take much less time to learn a new program.
Another cool thing would be to put some display functionality into the
keyboard. For example, the F* keys, sitting on top of your keyboard,
are rarely used, but they could be displaying a line of text, if you
were so inclined. With the resolution I'm designing, your numpad is a
20X35 screen, which isn't great resolution, but is enough to show
rough pictures or other simple information. And, of course, it's a
piece of case to swap between QWERTY and DVORAK, spanish and english,
and countless other keyboard styles. In addition, you could make a
keyboard which runs a predictive typing program, and adds more of the
letters you are likely to type to speed up your typing. Other silly
ideas include 'screensavers' where the keys chase eachother around the
keyboard, animated letters, playing low-res video on your keyboard,
and extending the bottom of the desktop onto the keyboard.
But back to the geeking. To make a proper keyboard, I need
something that can hold the five bytes of data and play them back as
it scans through the displays. I need to be able to quickly address
and change the data for each key, and have good enough data rates for
the keyboard to play 30fps video. There are roughly 100 keys, and 5
bytes per key, plus 1 address byte, so we need ~18kB/s communication
to do that, and that's nice and possible. To cut down on the number
of chips, I changed to scanning through the rows, and putting the data
on the columns, I put in a central system to scan through the rows of
every display, as well as to generate a clock signal to synch each
display to the scan. The result is that you need 5 pins per display
for the data, plus a UART receive line and a clock line. I opted to
use a microcontroller to control some number of displays, since it
cuts down on the number of chips and is simple, I can change the code
afterwards, and it's pretty cheap. Each micro will have a small bit
of on-board EEPROM which tells it which display numbers it's
responsible for. I know it sounds kind of dense. Maybe the picture
below makes more sense.
I'm not sure what micro I want to use. The pic 16F946 gives me 53
I/O lines for $2, which would make the total chip price for the
display controllers only $20! Add in another ~10 for the USB
interface and drivers, and something like $100-150 for the displays,
plus maybe $75 for the PCB, and that's about a $200 keyboard, which is
pretty affordable for something so cool. I'm in the process of
designing a board which should cut up into key-sized chunks, and fit
into the holes where normal keys usually go(turns out that computer
keys are somewhat standardized, and you can swap them between
different brand keyboards). The final product will fit inside a
functioning keyboard, but the keyboard guts will still be
functioning. The computer interface will be a seperate USB cable.
I'm planning to make all the hardware and software open-source, and
maybe assemble some keyboards on the side for a small cost if
anyone's interested. The final prototype should be on my desk by
early march. Until then, back to work on version 2.2!
