jflanagan again

Build your own head tracker

Sat, 18 Jul 2020 18:40:31 -0500

My son has been playing a lot of the DCS World flight simulator lately, and started talking about building a head tracker. I didn’t even know this was a thing, outside of expensive Virtual Reality gear. A head tracker is a relatively low cost device that allows you to control your view in a game (look around the cockpit) just by moving your head - so you can keep your hands focused on steering and throttle, etc. He had read about building an infrared based tracker for $10 - but the parts needed didn’t seem convenient (PlayStation 3 camera and a floppy disk? - google it, you may like that solution better). Since I have experience with programming a Teensy, I knew it was possible to create a relatively cheap device that could simulate a game controller. After searching for “head tracker teensy” I came across this Inertial Head Tracker post which had the exact same idea, and had already done most of the hard work for me.

However, some of the details on that post were a little unclear, and I had a lot of trouble with the source code on that page - I have a feeling it was corrupted somehow in the publishing process because some of it just doesn’t make sense and will not compile. I’m going to add my interpretation, and code, for what needs to be done, but defer all credit for this idea to cmarzano, the author of that post.

Parts

Teensy 3.2 w/pins - you might be able to save some money by using the Teensy-LC - I have not tried it. Newer versions of the Teensy should also work. I bought the version with pins to save me some soldering work.
Teensy Prop Shield w/Motion Sensors - it should be obvious that you cannot use the low cost Prop Shield, since the motion sensors are the part we need.
A long micro-USB cable. Long enough to allow freedom to connect the device on your head to your computer. I went with one of these 10ft cables.
Some header pins to make it easier to mount the Prop Shield on the Teensy.
Teensyduino IDE - used to compile and publish programs to your Teensy.

Instructions

These instructions were mostly lifted from the original post - the original author deserves the credit, I just added some clarification on parts that confused me.

1) You need to connect the Prop Shield to the Teensy. The easiest way (assuming you have a soldering iron, and know how to use it), is to attach some female header connectors to the Prop Shield. You only need to connect the long sides. Connect the male header connectors to the bottom of the Teensy (or buy the version with pins). If you do not want to use header connectors, look at the diagram and table in the “Technical Details” section of the Prop Shield page to identify the pins that need to be connected to make the sensors work (follow the Used By column in the table). The header connectors make it easier to remove the Teensy from the Prop sheild, but if you want a permanant connection, you can probable get a lower profile by not using headers.

2) Mount the Teensy+Prop to a hat or headset. I 3D printed a small box to hold it, and used some heavy duty velcro to attach it (stick the soft side on the headset). It is important to mount it before calibrating it, since the calibration is impacted by other things around it.

3) Install and configure the Teensyduino/Arduino software. Open Teensy/Arduino - the first thing you should do is go to the Tools menu and choose your Board (Teensy 3.2 for me). Now when you open the File | Examples menu, there should be a Teensy 3.2 section that includes NXPMotionSense.

If you don’t see the NXPMotionSense examples, you can download them from the NXPMotionSense github page, click on Code, and Download Zip. Extract the zip to a directory.

Open the CalibrateSensors example sketch from the NXPMotionSense group. (File | Examples | NXPMotionSense | CalibrateSensors). Or File | Open and find the sketch in the examples directory of the extracted zip.

4) Click the Verify button (or Sketch | Verify menu) to make sure it works. If it compiles, connect the Teensy to your computer with the USB cable, and click the Upload button. This should start running the CalibrateSensors program on the Teensy. You can open the Serial Monitor from the Tools menu to see the calibration data output. You should notice different numbers change, depending on how you position the Teensy. After confirming it is working, close the Serial Monitor so that it does not interfere with MotionCal in the next step.

5) Download and run the MotionCal application from the Prop Shield page. Select the COM port for the Teensy. Move the Teensy around through all axis of rotation - you should see the red dots start to form a sphere. You need to move it around until all of the numbers are below 5%. Once you reach that goal, the “Send Cal” button will be enabled. Press that button to write the calibration data to the Teensy’s EEPROM.

6) Open the MahonyIMU example sketch from the NXPMotionSense group (File|Examples|NXPMotionSense|MahonyIMU) In the Teensy IDE, change the USB Type from Serial to “Flight Sim Controls + Joystick”. Click the Verify button. If it works - great! But you will likely get a fatal error stating that it cannot find MahonyAHRS.h. You need to install the MahonyAHRS library. As of this writing, the version (1.1) available in the Arduine Library Manager does not work. You need to install the latest unreleased copy from the source. Go to https://github.com/PaulStoffregen/MahonyAHRS, click Code, Download Zip. Extract the zip to your Arduino libraries directory (which is likely Arduino/libraries in your user Documents directory). With the library installed, you should be able to Verify the sketch successfully. (I did see some warnings but they can be ignored). Once it is successfully verified, upload it to the Teensy.

7) from the original post

Put your headset on and open the Arduino Serial Monitor. You will see the current values of heading, pitch, and roll in order. The values shown will vary with each setup depending on the mounting orientation of your Teensy and the direction your computer desk is facing. Note the heading value when you are looking straight ahead after about 1 minute has elapsed. The 1 minute wait is necessary for the algorithm to reduce the error with the magnetometer.

8) Create a new Sketch (File | New), paste in the code from below, and save it as HeadtrackJoystick. Change the headingcenter=328 in the void setup() function and set it to the heading value you observed when facing your computer (from the previous step). This determines the center position of the joystick.

9) from the original post

Save the updated code to a safe place and flash the Teensy. It is now functioning as a USB joystick. You can view the output in the Arduino Serial Monitor for debugging if necessary, or launch the Windows “Set up USB Game Controllers” application to see windows receiving the data.

10) from the original post

Launch OpenTrack and adjust the input to use the Teensy. Depending on your luck, you may need to invert axes to match your movement. You can also adjust sensitivity, smoothing, and define curves in OpenTrack. For the output settings, set the interface option as “Use TrackIR, hide FreeTrack” to be compatible with most TrackIR compatible applications. I highly recommend setting a bind key for “Center” under “Options” to have the software adjust the resting center. This is to account for small differences in your positioning as every time you use the head tracker, you will have a slightly different resting position.

Code

Instead of using the code from the original post, use mine below (or, if gets mangled like it did on the original post, you can always get the latest version from my Github).

// HeadtrackJoystick, based on:
//
// Inertial Monitoring Unit (IMU) using Mahony filter.
// https://github.com/PaulStoffregen/NXPMotionSense/blob/master/examples/MahonyIMU/MahonyIMU.ino
//
// and inspired by the code example on http://crispycircuits.blogspot.com/2018/06/inertial-head-tracker.html

#include <NXPMotionSense.h>
#include <MahonyAHRS.h>
#include <Wire.h>
#include <EEPROM.h>

NXPMotionSense imu;
Mahony filter;

int joyheading;
int joypitch;
int joyroll;
float headingcenter = 180;
float headingoffset;
float adjustedheading;

void setup() {
  Serial.begin(9600);
  imu.begin();
  filter.begin(100); // 100 measurements per second

  //TODO: make this settable by pressing a button
  headingcenter=328;
  headingoffset = headingcenter - 180;
}

void loop() {
  float ax, ay, az;
  float gx, gy, gz;
  float mx, my, mz;
  float roll, pitch, heading;

  if (imu.available()) {
    // Read the motion sensors
    imu.readMotionSensor(ax, ay, az, gx, gy, gz, mx, my, mz);

    // Update the Mahony filter
    filter.update(gx, gy, gz, ax, ay, az, mx, my, mz);

    // print the heading, pitch and roll
    heading = filter.getYaw(); //  0..360
    pitch = filter.getPitch(); //  -90..90
    roll = filter.getRoll();   // -180..180

    Serial.print("Orientation: ");
    Serial.print(heading);
    Serial.print(" ");
    Serial.print(pitch);
    Serial.print(" ");
    Serial.println(roll);

    // The heading is a number retrieved from the sensor, which indicates a
    // compass direction (degrees) using a number from 0-359.
    // We want to use that number from a sensor to indicate which way our
    // "joystick" is pointing. If you are looking straight at your computer,
    // the joystick should be centered, and you can look up to 180 degrees in
    // each direction.
    // Since not everyone will be looking due South at the their computer, we
    // need to map their actual heading (specified by headingcenter) so that it
    // can be used as the neutral position of the joystick. The adjustedheading
    // is the actual heading, mapped to a new 360 degree range.
    adjustedheading = heading - headingoffset;
    if (adjustedheading < 0){
      adjustedheading = adjustedheading + 360;
    }
    if (adjustedheading > 360){
      adjustedheading = adjustedheading - 360;
    }
    // The heading value from the sensor has 360 values. The Teensy joystick
    // driver expects a value from 0-1023, with 512 indicating the center. Map
    // the sensor value as a fraction of the joystick range.
    joyheading = (adjustedheading / 360) * 1023;
    // The pitch value from the sensor has 180 values. Map the sensor value as
    // a fraction of the joystick range.
    joypitch = ((pitch + 90) / 180) * 1023;
    // The roll value from the center has 360 values. Map the sensor value as
    // a fraction of the joystick range.
    joyroll = ((roll + 180) / 360) * 1023;

    // Send the sensor data as joystick input to the computer
    Joystick.X(joyheading);
    Joystick.Y(joypitch);
    Joystick.Z(joyroll);

    Serial.print("Joyvalue: ");
    Serial.print(joyheading);
    Serial.print(" ");
    Serial.print(joypitch);
    Serial.print(" ");
    Serial.println(joyroll);
  }
}

Infinity ErgoDox Build Guide Companion

Sat, 21 Nov 2015 18:49:27 -0600

This article is intended to be a companion to the official Infinity ErgoDox build guide maintained by Input Club. As a first-time keyboard builder, there were a number of steps that were not very clear to me. My hope is that this will help other novice builders build their keyboard with more confidence. It is not intended to replace the build guide, and it skips some steps that do not require any further clarification.

NOTE: You should be aware that there are two different build guides for the Infinity ErgoDox on the input.club site. Which one you get depends on the navigation steps you take. The one that appears to be the most up-to-date is the one I linked to above - you reach it by choosing “Infinity ErgoDox Kit” from the “Devices” menu on the input.club website, and then following the link to the Build Guide (it will have “devices” in the url). However, if you choose “FAQs” from the “Forums” top menu, and follow the “Build Guide: Infinity ErgoDox” link, you will see an older version of the build guide (it will have “knowledgebase” in the url).

Pre-step 1 warning:

The latest version of the build guide (as of this writing) contains a warning before the first step about a potential weakness of the USB connectors. It suggests adding some solder to the pins, but those connections looked way too small for my soldering experience level and/or tools. Instead, I opted to reinforce all of the connectors with non-conductive metal epoxy, as suggested in the forums. The forums weren’t very specific on how much, so I covered the ports as much as I could. I spent too much money and waited too long to have the keyboard break on me now. But a bit of warning - it was only after I assembled the full keyboard that I realized the case is transparent, so my sloppy globs of epoxy on the USB-A connector are visible. I can live with that, as long as it all stays together, but you may want to be more careful to stay to the sides and back of those connectors (the micro-B connectors are covered after assembly, so it is okay to cover them - just be aware if you make the covering too thick, it may interfere with attaching the PCB to the switch plate).

Step 1:

Verify your components. I didn’t really know what I was looking for at the time, but after I assembled my keyboard I had one key that didn’t work, which I traced to a faulty diode. It was crooked, and the casing was slightly peeled back. I contacted Massdrop support as they suggest, and they sent me a few spare diodes right away. This is just a reminder that they are there to help if needed.

Step 3:

This step tells you to verify that you have all of the case layers. It lists them out, but unfortunately, the names like “Top Plate #1” didn’t mean much to me. I could count the layers and verify there were two of each shape. But throughout the build I was worried that I would mess up the order of the layers. I’m not sure if you can put them together improperly, but just in case, I’ve taken some photos to help you identify them:

The top plates go above the switch plate. You can differentiate the top plates from the bottom spacer plates because the top plates are a closed shape that goes around the entire perimeter of the keyboard. The bottom spacer plates are open, in that there is a break in the perimeter (where the USB connectors go). Click the plate names to see a photo.

Top Plate #2: the thinner of the two closed shapes. The acrylic covers the area where the LCD will be (top-left on left-hand keyboard).
Top Plate #1: the thicker of the two closed shapes. There is an opening where the LCD will be.
Switch Plate: this is more obvious, as the only aluminum piece.
Spacer Plate #1: the thinner of the two open shapes. It has a larger notch for the LCD.
Spacer Plate #2: the thicker of the two open shapes. It has a small notch for the LCD.
Bottom Plate: also obvious, as it is the only acrylic piece that doesn’t have a hole it the middle. It covers the entire bottom of the keyboard.

Step 4:

Remove the backing paper. I wish I had a good tip for this step. It took me much longer than I care to admit. You can probably do it a lot faster if you are more aggressive.

Steps 5-7:

Definitely the most confusing steps in the guide. I think it assumes a lot more familiarity with stabilizers. They are the white plastic pieces that help keep the larger keycaps from wobbling on top of the switch. Hopefully a photo of the finished product will help you better visualize each step.

The other confusing part of this step is that it refers to the “stabilized switches”, and even shows a switch mounted on the switch plate, and yet none of the previous steps mentioned anything about mounting a switch! It wasn’t clear to me if I should be attaching a switch so early in the process. It turns out you can - but you’ll want to make sure you mount it in the correct direction. When the switch is face up (you can press in the mechanical button on the top), there are two clips on the north and south edges (I’m referring to a Cherry MX switch, I am not sure how much other brands differ). On the north side, you can see the word “Cherry” in the plastic. This is the same end that has the two pins on the bottom of the switch. When attaching the thumb keys that have the stabilizers, it is very important that you position the end of the switch with the pins so that they are closer to the inner/main body of the plate. The other end is toward the outer/thumb area edge of the plate.

Step 7:

This is the most vague step. At this point you should have two long white plastic stabilizer inserted into the switch plate (for each stabilized key), and a switch mounted in between them (pins closer to the main portion). Attach the wire to the two stabilizers as shown in the build guide, with the wire going along the edge closer to the outside of the keyboard. Now locate the keycaps that will attach to the stabilized switches. If you bought your keycaps from Massdrop, these will be the largest size keycaps. They have three holes on the bottom. The middle hole will attach to the switch. For the other holes, you need to insert the small white plastic pieces that came with the stabilizers. When “face up” (the part that will insert into keycap on top), there is a longer portion that extends from one end. You want this end facing toward the inner body of the keyboard. Figure out which way you want to mount your keycaps (mine have one side that is vertical, and the other side is slanted - I chose to mount mine with the vertical side facing the inner part of the keyboard), and then attach the two white inserts in the outer holes on the keycap so that the long edge of the inserts face the correct direction. Now press on the middle of the wire so that the ends angle up slightly. Connect the keycap with the inserts to one edge of the wire, by pushing the wire through the hole on the insert. Then try and angle the keycap down so that you can put the other end of the wire into the hole on the other insert. This can be tricky. I used a tiny screwdriver to push out against the side of the wire to make it open wider when attaching the second insert. Once the wire is in both ends, try and position the “button” on the switch so that it is lined up with the middle hole on the keycap, and then push down firmly. Press the key a few times to make sure it is connected, and slides up and down easily. The stabilizer might “catch”, preventing the key from rising back to its proper height. This seems to be a common problem. I fixed mine by just pressing it a bunch and it worked itself out. Other people suggest lubricating the stabilizers. This video shows is a good demonstration of attaching the keycap to the stabilizers and switch, and also shows how to lubricate them, if needed.

Step 8:

Again, take care that you orient the switches correctly. It helps to look at the PCB to see the holes through which the switch pins will go. The switches will attach to the side of the PCB with the LCD face up. In most places, this means the pins of the switch will be on the south edge (so the Cherry logo is upside-down). There are a few places where the switch is oriented side-ways - in those cases, the pins should be oriented so that they are on the edge closer to the inner part of the keyboard.

Step 9:

If you have trouble attaching the switch plate to the PCB, you probably have some of the switches in the wrong direction, so the pins aren’t lined up with any holes (I had this problem my first time). Remove the misplaced switch (squeeze the 2 clips on the top and bottom) and re-position.

Step 10:

After soldering on the stabilized switches, I think its a good idea to verify things are working properly. Plug the PCB back into computer (as in Step #2) and press the keys. Hopefully, you should see the proper response from the computer. See the configurator to get an idea of expected functions of each key in the default layout. The stabilized keys should be (left hand) Backspace and Delete, and (right hand) Space and Return. I did this verification occassionally throughout the entire process of soldering on the rest of the switches (unplugging from the computer during the soldering steps).

Step 13:

This is a good point to flash your keyboard with the latest firmware. The layout that comes pre-installed does not include a function for entering Flash mode, which means you need to disassemble the keyboard (so that you can press the flash button on the bottom of the PCB) any time you want to upgrade the firmware/change the layout. The latest firmware maps a key to Flash mode, so you do not have to press the button on the bottom.

Step 16:

Installing the (optional) LEDs is mostly straightforward, but there are a couple tips that will make things go more smoothly. After you have pushed the LED through the switch and PCB (correctly oriented so the long wire goes through the square hole), make sure it is in as far as it will go before you solder it. I held a finger against the LED on the other side of the board while I soldered it to make sure it didn’t slip out at all. If the LED sits just a small amount above the switch, it may interfere with the keycap when you press the key. After the two wires are soldered in, you’ll need to trim them as close to the solder joint as possible. If the wires extend too long, they will make it difficult to attach the backplate and get a tight seal, and put extra pressure on the solder joints. However, be careful when clipping the wires - make sure you dont clip any adjacent components on the board.

Step 18a:

I already mentioned that Step 13 is a better time to flash your keyboard - not sure why they suggest waiting until you have it stacked on all of the acrylic pieces. However, this is a good time to consider drilling a hole in the backplate to allow access to the flash button on the PCB. Since the backplate is attached to the PCB (but not screwed it), you can mark the location for the drill hole above the flash button with a small marker. Then you’ll remove the backplate and do the drilling.

WARNING: Massdrop does not recommend the drilling step, as you may seriously crack or damage the acrylic. It worked well for me and others, but there is definitely risk involved.

Step 20:

Installing DCS caps is a bit tedious. The first step is to sort all of the keycaps into the four different slopes (1-4). This can be a little tricky, as they can look very similar. If you look at an individual keycap from above, you’ll notice that one of the four sides is not sloped. Organize all of your keys so that the side without the slope is on the left. If you line up keys against each other, with the unsloped end aways on the left, you will be able to tell if they are the same or not. If they are the same, place the match in line behind the first one. If the are not the same, place it to the side to start a new line. You should end up with four different lines. This photo should help you identify the keyboard row number for each line (in increasing order from left to right): Row 1 is the tallest and row 4 has the steepest top slope. Once you know the row number, you can use this illustration as a guide to where each type of keycap belongs. When you attach the keycaps, the non-sloped side should face either the top (north) end of the keyboard, or the inner part of the keyboard (if it is a sideways key).

Conclusion

I plan to post a follow-up article with instructions on customizing your keyboard layout. Until then, check out the online configurator and the controller code wiki.

You should also check out the burritoware commentary, as I found it helpful during my first build.

If any of the steps above need correction or clarification, please mention it on the input.club forums, or contact me on twitter.

Infinity Ergodox Build Guide Companion by Joshua Flanagan is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License. Explicit permission is granted to the Infinity ErgoDox Build Guide hosted at http://input.club/devices/infinity-ergodox/infinity-ergodox-build-guide to incorporate any portion of this work without attribution.

Build Your Own Single Function Keyboard

Sat, 07 Nov 2015 08:34:14 -0600

I mentioned in my last post that it took months between the time I ordered my Infinity Ergodox keyboard and the time it arrived. In the meantime, I started reading up on it, and learned that the firmware could also run on a Teensy. I didn’t know what a Teensy was, so started researching. Its a low-cost development board that is (mostly) Arduino compatible, and excels at building USB input devices. Using the Teensyduino software, you can easily configure the type of device it will appear as to your computer (USB mouse, USB keyboard, etc).

I decided I’d try my hand at building my own keyboard. But this one would be very special. It would have one key, with one function: approve GitHub pull requests! At ShippingEasy, all of our code goes through a Pull Request. Before you can merge the Pull Request, someone else has to approve it. By convention, we indicate approval with the :+1: emoji (also :thumbsup:). So I wanted a big, red button that I could slap to approve a pull request.

Turns out, its pretty easy to do. My search for a big red button led me to the Staples Easy Button, which has a good reputation for these types of crafty projects. The button is very sturdy, so it can handle your emphatic code review approvals.

The electronics part of the project was very straightforward. I disassembled the Easy button (good instructions) and got rid of the speaker. I used some hookup wire to connect the Easy button’s existing button circuitry to one of the input pins (20) and Ground on the Teensy LC. To verify the button was connected properly, I wrote a simple program for the Teensy that lit up the onboard LED when there was input on pin 20.

The hardest part, by far, of the entire project was trying to fit and secure the new board inside, and be able to close it back up. I also needed a hole in the case so the USB cable could go from the Teensy to the computer. Luckily I have a Dremel tool, which is perfect for this type of job. I used it to carve out a lot of the internal plastic, and drilling a hole in the side for the cable. I got a little creative and glued in a carved-up a plug protector I found in the junk drawer. This serves as a mount for the Teensy, so it won’t rattle around inside.

The final, and easiest, step was to write the software for my new “keyboard”. I used the Teensyduino add-on for the Arduino IDE, and set the USB Type to Keyboard. All Arduino programs (“sketches”) consist of a setup and a loop function. The setup is run once, and is where I configure the hardware pins. The Teensy LC’s onboard LED is available on pin 13 - I configure that as an output (to aid debugging). Then I need to configure pin 20 as an input (you’ll recall I soldered a wire from the button to pin 20). The loop function runs repeatedly, forever, while the device has power. I use the Button library which nicely encapsulates the logic for detecting button presses on an input pin. When the button is pressed, I turn on the LED and then send the sequence of characters :+1:, followed by Command+Enter to submit the PR comment form (probably needs to be changed to ALT+Enter on Windows). The Keyboard library handles all the details of sending the proper USB HID codes to the computer. Full source code:

/* Add +1 comment to Github Pull Request

   You must select Keyboard from the "Tools > USB Type" menu
*/

#include <Bounce.h>

const int ledPin = 13;
const int buttonPin = 20;
const int debounceTime = 10; //ms

Bounce button20 = Bounce(buttonPin, debounceTime);


void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT_PULLUP);
}

void loop() {
  button20.update();

  if (button20.fallingEdge()) {
    digitalWrite(ledPin, HIGH);
    Keyboard.println(":+1:");

    // submit form (Command+Return)
    Keyboard.press(KEY_LEFT_GUI);
    Keyboard.press(KEY_RETURN);
    delay(100);
    Keyboard.releaseAll();

  } else if (button20.risingEdge()){
    digitalWrite(ledPin, LOW);
  }
}

I had a blast with this project, and its a great introduction to building a simple device that can talk to a computer. Using the Teensy and a big button, you can send anything that a USB mouse or keyboard can send. Think of the possibilities! Special shout-out to Sharon Cichelli for her enthusiasm in showing how accessible and fun these hardware projects can be - hi Sharon!

Infinity ErgoDox

Mon, 02 Nov 2015 17:40:31 -0600

I’ve always been picky about my keyboard, but recently discovered an entirely new world of keyboard enthusiasts. Aaron Patterson was on the Ruby Rogues podcast talking about mechanical keyboard kits. As in, keyboards you build yourself. You pick out the key switches (get just the right clicky feel), you pick out the keycaps, you pick a layout, etc. And then you solder all the parts together. That sounded pretty extreme to me! But I was just getting back into hardware hacking (arduino, etc) and figured it would make for a fun project.

Intrigued, I did some research, and discovered that Massdrop was just starting an effort to build the Infinity ErgoDox

an update to the popular ErgoDox. Perfect, I placed an order (I went with Cherry MX Blue switches and blank DCS keycaps, in case that means anything to you). And waited. That was back in April. I pretty much forgot about it until a box arrived from Massdrop a couple weeks ago.

I finally got a rainy weekend to dedicate some time to it. Reading the forums, people were saying that this was a much easier build than the ErgoDox, with one mentioning a 20 minute build time. I think it took me 20 minutes to get all my tools out and unwrap everything. This was not a cheap keyboard, the parts are currently scarce, and most of the documentation seems to assume more knowledge of the process than I had. But taking my time, soldering the key switches to the PCB, installing the stabilizers, assembling the case, I had a working keyboard about four hours later!

Well, kinda. The hardware is only half of the story. The cool thing about the Infinity ErgoDox is that it has a completely customizable (open source) firmware. Now that I have a device with a bunch of keys on it, I can decide exactly what all of the keys do. It has an online configurator to build your customized firmware for you, if all you want to do is re-map keys. But if you really want to get fancy, you can build the firmware from source. This exposes all of the capabilities of the device. Specifically, this keyboard kit includes a 128x32 LCD panel, as well as a controller to individually address each key’s backlight LED (not included in the kit - bring your own fun colors).

The best part is that there is a lot of unexplored territory. The existing firmware code has some very crude support for the LCD and LEDs - just enough to prove that they work. So there is a lot of room to flesh them out further, to try and support all the silly things people might want to light up while they type. That’s the part I am most excited about. Eventually, I’ll probably enjoy typing on it, too.