Christmas Tree PCB

A 6-key macropad that doubles as an ornament.

This week I spent a fun hour or so assembling this adorable Chrismas Tree macropad.

This 6-key macropad was sold in a group by by Maple-Computing, with design by That-Canadian and SpaceCat, and optional custom dye sublimated keycaps by ChillCaps.

The Christmas Tree can function as an ornament if you choose, but it’s also fully functional. It runs QMK firmware, so will be infinitely programmable.

The macropad kit is exceedingly simple, there were a few options during the group buy for a full kit (including keycaps and switches), and other options with fewer parts. I opted for the kit that included everything except keycaps. There were switches included with the kit, but I used ones I had on hand instead.

Parts

  • PCB Material bottom plate
  • PCB
  • Arduino Pro Micro w/headers
  • 6x resistors
  • LEDs
  • Mounting hardware
My own Parts
  • 78g Zealio switches
  • 6x white DSA keycaps

Building

The build for this macropad was pretty straightforward. It’s probably one of the quickest builds I’ve done in a while. Typically a full on 60% board will take me 2 or 3 hours, I had this done in about 1.

Assembled

I bought this macropad on a lark, for the simple novelty of having a light up mechanical keyboard ornament, but I think I’ll actually find this practical after the tree goes down. I’ve tried a few other macropads in the past, and have always found them difficult to get myself to use. My biggest issue with macropads is that they’re always some square grid configuration, with far too many keys. I have a very difficult time orienting my hands on them with touch alone - meaning that I’ll often inadvertently trigger an incorrect macro. Or I’ll forget which key does what, because I’ve got 12 or so different macros configured. The result has always been that I abandon them after a few weeks of trying to make it work.

The Christmas tree shouldn’t suffer from this problem though, with its triangular layout and only 6 keys I think I’ll have an easy time using it. The layout should mean that I can orient my hands on it easily, and the reduced number of keys will mean I won’t need to remember nearly as many keys and their functions.

For the moment this macropad is fulfilling it’s primary purpose: being a cool light-up ornament.

After the tree goes down, I’ll take the time to get this properly programmed and see how to fit a macropad into my workflow again.


Typed on RedScarf II+ Ver.D

Christmas Tree Macro Pad Video Build Log


This week I spent a fun hour or so assembling this adorable Chrismas Tree macropad.

This 6-key macropad was sold in a group by by Maple-Computing, with design by That-Canadian and SpaceCat, and optional custom dye sublimated keycaps by ChillCaps.

The Christmas Tree can function as an ornament if you choose, but it’s also fully functional. It runs QMK firmware, so will be infinitely programmable.

For the moment this macropad is fulfilling it’s primary purpose: being a cool light-up ornament.

After the tree goes down, I’ll take the time to get this properly programmed and get it integrated into my workflow. Since I’m doing more and more video editing these days, this should make for a great editing tool.

For more information about this build, visit this post on the blog.


Typed on RedScarf II+ Ver.D

Universal iOS and Mac Apps


Mark Gurman writing for Bloomberg:

Starting as early as next year, software developers will be able to design a single application that works with a touchscreen or mouse and trackpad depending on whether it’s running on the iPhone and iPad operating system or on Mac hardware, according to people familiar with the matter.

The idea of unified apps (and potentially a unified operating system) has been discussed by many pundits and myself lately. Shifting to unified apps for iOS and macOS will make things easier for developers, they can write once and deploy to all the devices Apple makes.

If this comes at WWDC next summer, I would expect ARM based Macs running on A series chips to ship by the holiday season 2018.


Typed on MacBook

Brown Alps Iris Video


About a month ago I put together an Iris split keyboard. Iris is one of my favorite split keyboards, and uses a fantastic layout. Iris is available at Keeb.io.

This video log is up on the new Missouri Valley Tech YouTube channel, and is the first of many new videos I have planned.

The full build log blog post is here


Typed on ErgoDox Test Board

Brown Alps Iris Build Log


The Iris ergonomic split keyboard first appeared on my radar in September, when u/Bakingpy of Keeb.io posted a picture of the first Iris prototype on r/mk. Since building my test ErgoDox I’ve taken a serious interest in split keyboards, and was actively on the hunt for another split board. Most of the selection out there like Let’s Split and Orthodox are based on the 40% layout, as opposed to the 60% layout. While innovative and filling a niche, I find the 40% footprint to have too few keys for me, so something based on a 60% was what I was after.

Prior to seeing Iris, I’d taken an interest in the Dark Matter split keyboard. While 40% based, I loved the look, and had started some tentative plans to design and build my own custom split board. I even ordered MT3 keycaps to fit my hypothetical board. What caught my eye about Iris is its layout. Iris is laid out almost identical to the split board idea I’d been toying with. I knew as soon as I saw it that I had to have one.

Iris uses the same column stagger that ErgoDox does. It omits the inner 1.5u keys and most of the thumb cluster, opting for a single thumb key as opposed to the two side-by-side thumb keys on ErgoDox. Iris’ firmware and pin out are based on Keeb.io’s NyQuist split keyboard (another ortholinear split board), which is in turn based on Let’s Split. Iris also supports RGB underglow, LED backlighting, and can use MX or Alps switches. Pricing for Iris is extremely budget friendly - the PCBs, controllers, and case are just $70 combined. Significantly cheaper than the $100+ one would pay to get started on an ErgoDox. This board is actually inexpensive enough that I ended up ordering two!

The Parts

  • 2x White Iris PCBs
  • 2x White PCB material plates
  • 54x diodes
  • 54x Brown Alps Switches
  • 2x Arduino Pro Micros
  • OnePerDesk Alps keycaps

The PCBs & Plates

At launch, Iris was available with black, white, or blue PCBs. Cases were available in black PCB material or white acrylic. There’s been a trend lately of folks using PCB material for keyboard plates (popularized by the Mitosis keyboard). PCB material is great, it’s nearly as strong as metal plates, but at acrylic plate pricing. While white material plates were not offered at launch, I was able to score a set from Keeb.io out of the remainders of prototype plates. I love the contrast between the white plates and brown keycaps - it really makes this board pop.

The Switches

For the white Iris build I saw an opportunity to finally make use of a set of Brown Alps switches I’d been holding on to for over a year. To my knowledge brown alps were only ever in the IBM 5150 and Magnavox VideoWriter keyboards. When I bought them, they were still soldered to the 5150 keyboard. I bought the board without any specific project in mind, but I’m very glad that I did. They’re a lovely heavy tactile switch, with a strong, crisp tactile bump right at the top. They feel fantastic and might be my new favorite Alps switch; I’m glad to have finally had the chance to use them on something.

The Keycaps

In keeping with my other Alps build (white and blue), this board has keycaps that match the switches underneath them. With brown alps switches it’s only natural to use brown keycaps. I scored these on r/mechmarket after I ordered the Iris parts, so the timing was perfect.

These keycaps are from the One Per Desk computer keyboard. The board these come from actually isn’t mechanical, it uses sliders over membrane, fortunately these are still compatible with Alps switches. If the brown + red colorway seems familiar, you may recognize it from SA Retro. As it turns out, the One Per Desk served as the inspiration for that keycap set.

Assembly

For this build, I used a PCB holder for the first time. I’ve seen them on other build logs and have meant to buy one for a long time. The holder was a god-send for this build, and greatly simplified the process.

Assembly of Iris begins with soldering on diodes. Diodes are what gives a keyboard matrix n-key rollover. Diodes install on one side of the board, and are soldered on the other. I typically tape diodes down during soldering so that they don’t fall out.

After soldering diodes, headers for the Pro Micros are installed, along with a right-angle reset switch and TRRS jacks. Iris uses common TRRS cables over serial to connect the two halves.

After the somewhat tedious task of prepping the PCBs, it’s time to solder on switches.

Following switches, it’s time to solder on the Pro Micros. Note: during the initial build of this board I soldered both Pro Micros on with the same orientation. Desoldering a Pro Micro is a big pain. Don’t make the same mistake I did. Be sure to solder on the Pro Micro on the left with components up, and the right side with components down.

With control electronics soldered on, the last (optional) step of assembly was to add RGB LED strips to each hand. The Iris PCBs were designed with RGB underglow in mind. Previous boards I’ve build with RGBs have involved soldering directly to pins on a controller chip, this PCB has dedicated pinouts on each hand, greatly simplifying the process.

Lastly I assembled the case, and assembly was done.

The Code

Iris runs on QMK, my keyboard firmware of choice. The keymap files have been merged into the main QMK repository and are available here.

I had a small learning curve while building my keymap for Iris. It had been nearly a year since I’d build a QMK-based keyboard, so many things had changed and improved. QMK now supports arbitrary custom keycodes. With arbitrary keycodes you can keep a keymap cleaner and easier to read, and define function layers and macros much easier. In the past it was necessary to have a function inline in the keymap, like:

FN1

then define it with something like after the keymap with all the other function keys, like:

const uint16_t PROGMEM fn_actions[] = {
    [1]  = ACTION_LAYER_TAP_KEY(1, KC_SPC),

Now, you can have really simple definitions above you keymap, then drop the arbitray keycode into the keymap.

As an example, I can define a simple dual role function key (backspace when tapped, function key when held) with:

#define KC_BSLR LT(_LOWER,KC_BSPC)

then just use the keycode

BSLR

inside my keymap.

With its new build environment, flashing a keyboard is now far simpler and easier - especially for boards that use a Pro Micro. In the past it was necessary to compile your firmware, then plug in a promicro, trigger it’s reset mode, quickly find its COM port, then flash the firmware using another utility. Now one runs a simple command and QMK compiles & flashes the board in one step. For Iris the command is make iris/rev2:default:avrdude

My Iris keymap is below. Mostly an adaptation of my ErgoDox keymap, combine with how I typically lay out my 60% boards.

#define _QWERTY 0
#define _LOWER 1
#define _RAISE 2
#define _ADJUST 16

enum custom_keycodes {
  QWERTY = SAFE_RANGE,
  LOWER,
  RAISE,
  ADJUST,
};

#define KC_ KC_TRNS
#define _____ KC_TRNS

#define KC_LOWR LOWER
#define KC_RASE RAISE
#define KC_RST RESET
#define KC_BL_S BL_STEP

#define KC_CLCA CTL_T(KC_CAPS)
#define KC_SPLR LT(_LOWER,KC_SPC)
#define KC_BSLR LT(_LOWER,KC_BSPC)

#define KC_MHME LGUI(KC_LEFT)
#define KC_MEND LGUI(KC_RGHT)

const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

  [_QWERTY] = KC_KEYMAP(
  //,----+----+----+----+----+----.              ,----+----+----+----+----+----.
     EQL , 1  , 2  , 3  , 4  , 5  ,                6  , 7  , 8  , 9  , 0  ,MINS,
  //|----+----+----+----+----+----|              |----+----+----+----+----+----|
     TAB , Q  , W  , E  , R  , T  ,                Y  , U  , I  , O  , P  ,BSLS,
  //|----+----+----+----+----+----|              |----+----+----+----+----+----|
     LCTL, A  , S  , D  , F  , G  ,                H  , J  , K  , L  ,SCLN,QUOT,
  //|----+----+----+----+----+----+----.    ,----|----+----+----+----+----+----|
     LSFT, Z  , X  , C  , V  , B  ,BSLR ,    SPLR , N  , M  ,COMM,DOT ,SLSH,RSFT,
  //`----+----+----+--+-+----+----+----/    \----+----+----+----+----+----+----'
                       LALT,LGUI,BSLR ,        SPLR ,ENT ,DEL
  //                  `----+----+----'        `----+----+----'
  ),

  [_LOWER] = KC_KEYMAP(
  //,----+----+----+----+----+----.              ,----+----+----+----+----+----.
     ESC ,MUTE,VOLD,VOLU,MPRV,MPLY,               MNXT,    ,    ,SLSH,BSPC,    ,
  //|----+----+----+----+----+----|              |----+----+----+----+----+----|
         ,    , UP ,    ,MHME,MEND,               LBRC,  7 ,  8 ,  9 ,MINS,    ,
  //|----+----+----+----+----+----|              |----+----+----+----+----+----|
     CAPS,LEFT,DOWN,RGHT,HOME, END,               RBRC,  4 ,  5 ,  6 ,PLUS,    ,
  //|----+----+----+----+----+----+----.    ,----|----+----+----+----+----+----|
      RASE,    ,    ,    , SPC, ENT,TRNS,     TRNS, F13 ,  1 ,  2 ,  3 ,ENT ,GRV,
  //`----+----+----+--+-+----+----+----/    \----+----+----+----+----+----+----'
                           ,    ,TRNS,         TRNS,  0 , DOT
  //                  `----+----+----'        `----+----+----'
  ),

  [_RAISE] = KC_KEYMAP(
  //,----+----+----+----+----+----.              ,----+----+----+----+----+----.
     F12 , F1 , F2 , F3 , F4 , F5 ,                F6 , F7 , F8 , F9 ,F10 ,F11 ,
  //|----+----+----+----+----+----|              |----+----+----+----+----+----|
         ,    ,  Q ,    ,    ,    ,                   ,    ,    ,    ,   ,    ,
  //|----+----+----+----+----+----|              |----+----+----+----+----+----|
         ,    ,    ,    ,    ,    ,                   ,    ,    ,    ,    ,    ,
  //|----+----+----+----+----+----+----.    ,----|----+----+----+----+----+----|
    RASE ,    ,    ,    ,    ,    ,    ,         ,    ,    ,    ,    ,    ,    ,
  //`----+----+----+--+-+----+----+----/    \----+----+----+----+----+----+----'
                           ,    ,    ,             ,    ,
  //                  `----+----+----'        `----+----+----'
  ),

  [_ADJUST] = KEYMAP(
  //,--------+--------+--------+--------+--------+--------.                          ,--------+--------+--------+--------+--------+--------.
      _____, _____, _____, _____, _____, _____,                            _____, _____, _____, _____, _____, _____,
  //|--------+--------+--------+--------+--------+--------|                          |--------+--------+--------+--------+--------+--------|
      RGB_TOG, RGB_MOD, RGB_HUI, RGB_SAI, RGB_VAI, _____,                            _____, _____, _____, _____, _____, _____,
  //|--------+--------+--------+--------+--------+--------|                          |--------+--------+--------+--------+--------+--------|
      RESET  , DEBUG  , RGB_HUD, RGB_SAD, RGB_VAD, _____,                            _____, _____, _____, _____, _____, _____,
  //|--------+--------+--------+--------+--------+--------+--------.        ,--------|--------+--------+--------+--------+--------+--------|
      BL_STEP, _____, _____, _____, _____, _____, _____,          _____, _____, _____, _____, _____, _____, _____,
  //`--------+--------+--------+----+---+--------+--------+--------/        \--------+--------+--------+---+----+--------+--------+--------'
                                      _____, _____, _____,                  _____, _____, _____
  //                                `--------+--------+--------'                `--------+--------+--------'
  )

};

The Result

I’ve been really quite pleased with this board. It’s my first split since my test ErgoDox. I love the look, I love how compact yet functional it is. While Iris has fewer keys than ErgoDox, I find it nearly as productive. There’s a LOT of functionality baked into such a small board.

I’ve been daily driving it at work for a month or so now and have been loving it. The brown alps switches are just glorious. The keycaps feel great, and I love just looking at the thing.

Coming soon I’ll have another Iris build (as soon as keycaps arrive) - the next one will use a black case, Otemu Ice switches, and Russian MT3 keycaps. Stay tuned!


Typed on Brown Alps Iris