The Kinesis Advantage
Contoured is an ergonomic keyboard which I have been using for four years.
It has many features that make it a great keyboard, and it’s certainly the best
I have ever used.
However, as you can also read on many places on the internet, many users have a
tiny problem with the keyboard: the modifier keys sometimes get stuck. For
example, you press Shift, followed by A, release Shift, press n. What appears
on your screen is AN instead of An. You can only get out of this state when
pressing Shift once again. It seems like the firmware doesn’t register the key
Last year, I decided to write Kinesis about it and they offered me a firmware
upgrade. I was surprised to learn that a firmware upgrade actually means
getting shipped a new microcontroller with a new firmware on it :-). After
swapping the microcontroller, I noticed that the problem did not appear as
often as it used to, but it still appeared. Of course, that is not satisfactory
for perfectionists and heavy keyboard users :-).
The Humble Hacker Keyboard
The Humble Hacker Keyboard
is a project by David Whetstone, who started out his project by modifying
existing keyboards, amongst them the Kinesis Contoured. Thankfully, he documented his modifications in his
After reading what he did, I decided to replicate his approach and swap the
electronics of my Kinesis. It seemed reasonably straight-forward: Use a
Teensy++ 2.0 USB development board,
connect the different parts of your Kinesis to it and use David’s Open Source
firmware. So I ordered the Teensy++ and had a look at how to modify my Kinesis
so that I could test whether everything works before destructively modifying
The flex connectors
In comparison to David’s version of the Kinesis Contoured, my version was newer
and used flex connectors for connecting the left/right keyboards to the
controller board, as you can see on the picture above. Thankfully, Kinesis is
very friendly to the enthusiast community around its products. Rick revealed
that they are using the Cvilux CF01131V000 flex connectors. Unfortunately, it
seems impossible to order just a few Cvilux parts to Europe.
From an earlier modification I still had a few spare Kinesis parts lying
around, so I decided to unsolder the flex connectors from those for a quick
test. Unfortunately, the grid of the flex connectors is different from the
usual 2.54mm grid, so you cannot simply use such a connector on a breadboard.
Volker came up with the idea of soldering a pin header directly to it, and that
worked (see the picture). I then used a bunch of jumper wires to connect the
flex connector to the Teensy++ and then the Kinesis keyboard parts to the flex
connector. After flashing the firmware, I could press keys on the Kinesis and
have them appear on my screen. Yay! :-)
Given that I could not order the Cvilux flex connectors directly, I spent quite
a bit of research into finding a compatible part. In the end, I found and used
39-53-2135 which you can order from RS components. They even have free
shipping for students :-).
The prototype board
Now that the proof of concept was done, it was time to design a prototype board
on which I can mount the Teensy++ and connect all the Kinesis keyboard parts —
essentially, one could call it a break-out board for the Teensy++. It really
doesn’t contain any electronics.
I created the layout and board files with the free version of CadSoft EAGLE, based on David’s
descriptions in his blog posts. I am not very experienced in EAGLE, so
thankfully my friend Moritz helped out with creating an EAGLE library for the
Molex flex connector and cleaning up my board.
We then milled the prototype board at Volker’s lab and soldered the flex
connectors and pin headers on the prototype board. Here are two pictures of the
board, one before soldering and the other one after putting it into the
Note that the thumb keyboards don’t use a flex connector — they are soldered
directly onto the controller board :-(. We decided to solder them to a pin
header so that we can connect and disconnect them at will.
After connecting the prototype board, most of the keyboard worked properly.
There unfortunately was one little mistake in the layout (and subsequently in
the board), which we were able to correct with a bit of wire. I then decided to
leave the prototype board in to test it for a bit of time until the PCBs were
manufactured and delivered.
Unfortunately, we only noticed that there have to be two holes in the center of
the board in order to be able to actually close the keyboard case. Furthermore,
the microcontroller doesn’t have a lot of space, so you need to be careful when
designing a board. I decided to eat my own dogfood and leave the Kinesis
half-open for a while.
Now that it was clear that the idea basically works, Volker and I decided to
take measurements of the original board and design a proper board — with holes
in it and LEDs on it. It took Volker about two hours to route the board, and the
result looks pretty good.
Afterwards, we submitted the board file to BILEX-LP, a cheap PCB manufacturer in
Bulgaria. It took them a few working days to manufacture the board and a few
more for shipping it, but it finally arrived about two weeks after we placed
the order. You can see the PCB on the picture below:
Of course, not everything was perfect, both with our board file and with the
One connection was disconnected because of a cut on the board. Not detecting
this in the quality control was the manufacturers fault. But you have to expect
this when ordering at a cheap PCB manufacturer — the other 5 boards look fine.
We were able to fix this with a bit of wire.
The bottom hole is too small for actually fitting the screw through it. That’s
not a big deal though, since the upper hole is good and the PCB is held in
place by the connection through the upper hole and the connected keyboards.
The drilling holes for the Teensy++ (in the middle of the board) are 0.8mil
instead of 0.9mil. Since the Teensy++ EAGLE library was downloaded from their
website, we thought it’d be fine, but we should have double-checked. Luckily,
you can still mount a pin header on the board, you just need to push a bit
So all in all, the PCB is usable, even though it’s not perfect. I then soldered
the ports onto it and we placed it in my Kinesis. Note: the Teensy++ faces the
board, so the USB connector is also facing the board. Therefore, we plugged in
the USB cable and positioned it so that the connected cable fits, then soldered
it onto the pin header.
For the USB connection, Volker suggested to just rip out the board on the other
side of the Kinesis case, then cut the cable and directly solder a USB cable to
it. That way, we re-use the original Kinesis strain-relief and their cable,
which is a pretty good idea. You can see the result here:
As expected, David’s Humble
Hacker Keyboard firmware does not suffer from the stuck-modifier bug that
motivated me to start this whole modification in the first place. However, I
noticed that some key presses were registered twice, so I implemented
debouncing and sent a pull request. The
whole implementation was finished surprisingly quickly, the code really is
pretty clean and easy to understand.
You can find my version of the firmware at http://code.stapelberg.de/git/kinesis-firmware/.
You can also download the .hex
firmware image that you can flash on your Teensy++ — but beware: I use neo-layout.org, so I remapped all the
keys in the firmware :-).
The layout and board files
In case you also want to replace the controller board of your Kinesis, or as a
foundation for similar projects, here are the EAGLE files:
Note that I also have 3 spare PCBs to sell. You can have one for 10 € plus
shipping, but without any warranty or support. First come, first serve.
Of course it was not strictly necessary to build my own keyboard controller. I
could have just lived with the bug. But it was fun and it’s a great feeling to
have a (mostly) selfmade keyboard with an Open Source firmware to type on :-).
The total amount of time spent on this project was about a full work week.
I also want to say a big thank you to David Whetstone for publishing his
experiments and firmware, to Moritz Augsburger for the help with the early
EAGLE files and last but not least to Volker Wunsch who spent a lot of time
with me and helped me a lot in order to get this project done.