2Nov/141

Atreus – My First Mechanical Keyboard

A certain geek *coughColecough* picked up an Ergodox some months back. After an initial period of smiling at his purchase while enjoying my work supplied ergonomic keyboard, I decided to take him up on his offer to type on it.

I can only say that in order to understand the draw of mechanical keyboards, you need to use one for an hour. They're pretty freaking cool. Sadly, the Ergodox is a bit out of my price range at the moment - saving up for a roadie while training for a triathalon next year. I also borrowed a Code keyboard using Cherry MX Clears, but decided I liked the ergonomics of the Dox.

Here's where the Atreus comes in. It's a 40% keyboard, so only has 42 keys instead of the 87/104 "normal" keyboards have. All the extra (punctuation, numeric, function) keys are accessed by switching "layers" - essentially shift on steroids. Jump in after the break!

The Atreus is built upon similar principles as the Ergodox. It's designed to be easily customized, plans/firmware are available as open source, and the Atreus is more ergonomic than "straight" keyboards.

You can order your own Atreus as either a kit or fully assembled . Alternately, just pick up the parts yourself and assemble using these instructions.

I decided to source my own parts, as I determined I could bring the price down near $90. Not bad for a mechanical keyboard!

First things first, I needed to pick up switches & keycaps. I badgered Sol into building one as well, so we decided to order in bulk. Here's the BOM if you're doing a solo build:

You'll also need:

  • Soldering Iron/Solder
  • Wire (gauge?)
  • M8 screws to bind the case
  • Hot glue gun
  • Digital multimeter
  • Mad skills (update: I have been informed that my skills are more on the mad side than the skilled side. I think I made people cry with my soldering...)

Finally, the case. There are a number of options, but you'll need the case models from github:

  • Order from an online laser cutting service
  • Bring out the jigsaw and have at it
  • Find someone local with a CNC or laser cutter, for instance, a Maker/Hacker Space.

Once I got all my parts together, Sol and I got together for some soldering fun. It took about a couple hours for the basic assembly. Being my first time, I took it slow. Once I got the firmware loaded to the teensy, I finished connecting up the spaghetti mess and soldered the teensy in. Aside from time spent on the firmware, I'd estimate a good 6 hours of time doing assembly. This may include Futurama & beer time however...

Basic Steps:IMG_20141108_211306534

  1. Place switches into mounting board.
  2. Flip board over and start soldering diodes to the higher switch pin, positive side toward the center
  3. Connect all 11 columns on the lower switch pin
  4. Verify all joints are solid
  5. Upload firmware to teensy
  6. Finish that spaghetti wiring
  7. Start typing!
  8. Post pictures to Imgur

I'll touch on a few of the hurdles I faced putting this together, but there is really no substitute for reading through Phil Hagelberg's documentation. Really, it's awesome - read through it.

Alright, placing the switches. If you look closely, you'll see that the switches are not precisely symmetrical. Looking at the base of the switch you should see a smooth side with the pins nearest to it; this is the "north" side. Push the switch into the base, repeat until all switches are placed. Hagelberg suggests using hot glue to keep the switches in place, but I found the laser cut wood holds them tightly enough so they don't pop out in normal usage.

Soldering the diodes is simple, anyone with any sort of soldering experience should be able to knock that out easily. I was not so lucky; I spent a while figuring out how to make the solder flow nicely and still never came out with a "good" joint. If I had to do it over, I'd probably pick up some Enablers to make a cleaner looking base.

For the 11 columns, I harvested wire from an ATX power supply. Bad idea! It looks bad and was a bear to work with. I swapped over to using wires stripped from a cat5 cable when connecting the teensy, and was much happier.

It took awhile to get my system setup to compile the firmware. Funky stuff with Linux Mint 16 - This Stack Overflow post goes over the necessary environment variables that needed to be set. Once I got going though, recompiling firmware is a breeze. I must say, I'd prefer a cleaner json > layout conversion. The current implementation is simply nested lists of lists containing each row's key declarations. I would prefer the parser was able to take a dictionary, something like:

{
  "layer0": {"row0": [], "row1": [], "row2": [], "row3": []},
  "layer1": {"row0": [], "row1": [], "row2": [], "row3": []},
  "layerx": {"row0": [], "row1": [], "row2": [], "row3": []},
}

I might take a look at the code and see if that is possible; it just seems a lot easier for human editing.

The rest is straight forward - make the appropriate connections to the teensy, then connect those to the appropriate rows and columns. D0-D3 should be connected to the positive side of a diode on each row, and the rows should be connected across the center of the board. The rest of the pinouts should be connected to a negative pin on each of the 11 columns. It doesn't really matter which switch you choose on each column, just make sure you don't double connect one column to two pinouts.

Outputs(should be connected to the positive end of a diode on each row):

|------------+----+----+----+----|
| row number | 0 | 1 | 2 | 3 |
|------------+----+----+----+----|
| pin number | D0 | D1 | D2 | D3 |
|------------+----+----+----+----|

Inputs(should be connected to the negative pin of a switch on each column):

|---------------+----+----+----+----+----+----+----+----+----+----+----|
| column number | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
|---------------+----+----+----+----+----+----+----+----+----+----+----|
| pin number | B0 | B1 | B2 | B3 | B4 | B5 | B6 | B7 | F4 | F5 | F6 |
|---------------+----+----+----+----+----+----+----+----+----+----+----|

Ok, now just bolt the case together without messing up your hard work. I'd suggest tossing rubber pads under the keyboard to keep it from scratching your desk. Plug the keyboard in, and start typing! For more pictures, check out my Imgur album.

IMG_20141111_160943253

  • http://gomechanicalkeyboard.com Kyle H

    Very nice build, love the use of wood.