Initial Dvorak Layout

[mygnu]

I can understand, It would be fine onece you get used to it. I would personally like to have a legend to start with. May be keyboardio can custom print some later.

[Jennigma (Jennifer Leigh)]

The keyboard ships with a laminated sheet:

I find if I keep it in view I’m better at looking up instead of down when I need to find a key in an unfamiliar place. Shouldn’t be hard to make one for Dvorak; I would guess they might ship one with the keycaps. The SVG is available and getting it printed and laminated at your local printshop should be straightforward even before the keycaps ship. I’m planning to make a personalized one myself when I stabilize my layout.

In the meantime, the back is blank:

so I can scribble away!

[jesse]

@Jennigma

In the meantime, the back is blank:

And I don’t think we’ve said it anywhere, but designed for use with a whiteboard marker while figuring out layouts

[Jennigma (Jennifer Leigh)]

I just ordered some wet erase markers, because I was accidentally rubbing off the wrong things. In the meantime I’m using sharpies and alcohol.

[jesse]

Heh. The other option, of course, is to print out the SVG

[Jennigma (Jennifer Leigh)]

And the other other option is to use KLE:

Jennigma’s layout

[amos]

This is off topic for here, but how are you liking the space and backspace on the palms?

[Jennigma (Jennifer Leigh)]

Love it! The above layout is stale, but I’ll keep the palms like this. I need space and backspace far more than function, and the palm keys are so convenient now that I’ve adapted to them. I keep them under the first joint of my thumb.

[blakej (Blake Jones)]

While I’ve been waiting for my keyboard, I’ve been thinking a bit about how I’ll get used to the new layout. I’ve been using a Kinesis Advantage in Dvorak mode for years now, in a setup that keeps me from looking at the keys, so I suspect my main problem will be getting used to the new modifier placement. But since I’ll be using the Model 01 in a similar setup, I want to avoid getting in the habit of looking at the keyboard itself while learning.

So I took the existing SVG for the QWERTY layout, found a simple SVG editor, and made a Dvorak version:

I’d be happy to provide the SVG and PDF to put in the repo.

[jesse]

Sure. I’d be hapy to take a pull request. (Or if that’s not easy for you, I can make the commit)

[bjn (Bart Nagel)]

I got my keyboard!

To start with I had it with stock firmware and with my OS mapping it to Dvorak, which is what I’ve done all these years. But while typing in IM software and such to get to grips with things I soon found I had no question mark key!

So time to flash the firmware with a Dvorak map. In installing the Arduino SDK I also found of course I have no slash key either, so it was back to the old keyboard for now.

I tried to figure out how to set up udev rules so that the Model 01 would be automatically set to standard US qwerty when plugged in but couldn’t get it working. I’ll ask about that in a new thread in due course, since for now I still want my old keyboard plugged in and set to Dvorak.

I couldn’t find an existing key map for Dvorak – maybe I wasn’t looking in the right place. But no matter, I had soon written in the mappings. I decided to leave the main layer as Jesse decided the keycaps would be printed for now, but when I got to the function layer I made quite a few changes.

• I removed all the media keys, since I don’t use them.
• I shifted the mouse movement keys one to the right, so they’re comfortable to use in the home position.
• That meant the mouse buttons had to move, and I put them where it feels somewhat natural to me. I left the warp keys alone.
• I moved the cursor keys to both Dvorak’s positions for HJKL (since these are what I use in vim all day long) and the right-hand home inverted-T position so they can also be used with a single hand.
• That meant the braces and brackets had to move, and I thought they might work pretty nicely clustered around the inverted-T arrows.
• I moved backslash to be on Dvorak’s slash key.
• I moved pipe to be on Dvorak’s hyphen key.
• These meant F11 and F12 had to move, and I’ve put those in a horizontal row in the very bottom right.
• I’ve duplicated page up and down to fn-B and fn-F to be like ctrl-F and ctrl-B in vim.

I went out and bought the finest-tipped dry-erase markers I could find especially to fill in the laminated cheat sheet, and as you can see they’re not nearly fine enough!

I’m going to see how I do at getting used to this. There’s only one thing Dvorak-related I think is likely to change:

• As I’ve said before in this thread, I think backslash should have its own key in the bottom right, and equals should move to left of A. But I’ll wait and see if needing the function layer for backslash and pipe annoys me enough to abandon a nicely printed key first.

There are some other things I think I’ll change, but they don’t belong here since they’re not related to Dvorak. I’ll talk about those and some other general thoughts about the M01 in another thread in due course.

My current map:

And in code:

// -*- mode: c++ -*-
// vim: ts=32 sts=32 sw=32
// Copyright 2016 Keyboardio, inc. <jesse@keyboard.io>
// See "LICENSE" for license details

#ifndef BUILD_INFORMATION
#define BUILD_INFORMATION "locally built"
#endif


/**
 * These #include directives pull in the Kaleidoscope firmware core,
 * as well as the Kaleidoscope plugins we use in the Model 01's firmware
 */


// The Kaleidoscope core
#include "Kaleidoscope.h"

// Support for keys that move the mouse
#include "Kaleidoscope-MouseKeys.h"

// Support for macros
#include "Kaleidoscope-Macros.h"

// Support for controlling the keyboard's LEDs
#include "Kaleidoscope-LEDControl.h"

// Support for "Numlock" mode, which is mostly just the Numlock specific LED mode
#include "Kaleidoscope-Numlock.h"

// Support for an "LED off mode"
#include "LED-Off.h"

// Support for the "Boot greeting" effect, which pulses the 'LED' button for 10s
// when the keyboard is connected to a computer (or that computer is powered on)
#include "Kaleidoscope-LEDEffect-BootGreeting.h"

// Support for LED modes that set all LEDs to a single color
#include "Kaleidoscope-LEDEffect-SolidColor.h"

// Support for an LED mode that makes all the LEDs 'breathe'
#include "Kaleidoscope-LEDEffect-Breathe.h"

// Support for an LED mode that makes a red pixel chase a blue pixel across the keyboard
#include "Kaleidoscope-LEDEffect-Chase.h"

// Support for LED modes that pulse the keyboard's LED in a rainbow pattern
#include "Kaleidoscope-LEDEffect-Rainbow.h"

// Support for an LED mode that lights up the keys as you press them
#include "Kaleidoscope-LED-Stalker.h"

// Support for an LED mode that prints the keys you press in letters 4px high
#include "Kaleidoscope-LED-AlphaSquare.h"

// Support for Keyboardio's internal keyboard testing mode
#include "Kaleidoscope-Model01-TestMode.h"


/** This 'enum' is a list of all the macros used by the Model 01's firmware
  * The names aren't particularly important. What is important is that each
  * is unique.
  *
  * These are the names of your macros. They'll be used in two places.
  * The first is in your keymap definitions. There, you'll use the syntax
  * `M(MACRO_NAME)` to mark a specific keymap position as triggering `MACRO_NAME`
  *
  * The second usage is in the 'switch' statement in the `macroAction` function.
  * That switch statement actually runs the code associated with a macro when
  * a macro key is pressed.
  */

enum { MACRO_VERSION_INFO,
       MACRO_ANY
     };



/** The Model 01's key layouts are defined as 'keymaps'. By default, there are three
  * keymaps: The standard QWERTY keymap, the "Function layer" keymap and the "Numpad"
  * keymap.
  *
  * Each keymap is defined as a list using the 'KEYMAP_STACKED' macro, built
  * of first the left hand's layout, followed by the right hand's layout.
  *
  * Keymaps typically consist mostly of `Key_` definitions. There are many, many keys
  * defined as part of the USB HID Keyboard specification. You can find the names
  * (if not yet the explanations) for all the standard `Key_` defintions offered by
  * Kaleidoscope in these files:
  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/key_defs_keyboard.h
  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/key_defs_consumerctl.h
  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/key_defs_sysctl.h
  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/key_defs_keymaps.h
  *
  * Additional things that should be documented here include
  *   using ___ to let keypresses fall through to the previously active layer
  *   using XXX to mark a keyswitch as 'blocked' on this layer
  *   using ShiftToLayer() and LockLayer() keys to change the active keymap.
  *   the special nature of the PROG key
  *   keeping NUM and FN consistent and accessible on all layers
  *
  *
  * The "keymaps" data structure is a list of the keymaps compiled into the firmware.
  * The order of keymaps in the list is important, as the ShiftToLayer(#) and LockLayer(#)
  * macros switch to key layers based on this list.
  *
  *

  * A key defined as 'ShiftToLayer(FUNCTION)' will switch to FUNCTION while held.
  * Similarly, a key defined as 'LockLayer(NUMPAD)' will switch to NUMPAD when tapped.
  */

/**
  * Layers are "0-indexed" -- That is the first one is layer 0. The second one is layer 1.
  * The third one is layer 2.
  * This 'enum' lets us use names like QWERTY, FUNCTION, and NUMPAD in place of
  * the numbers 0, 1 and 2.
  */

enum { DVORAK, FUNCTION, NUMPAD }; // layers

/* This comment temporarily turns off astyle's indent enforcement
 *   so we can make the keymaps actually resemble the physical key layout better
 */
// *INDENT-OFF*

const Key keymaps[][ROWS][COLS] PROGMEM = {

  [DVORAK] = KEYMAP_STACKED
  (___,	Key_1,	Key_2,	Key_3,	Key_4,	Key_5,	Key_LEDEffectNext,
   Key_Backtick,	Key_Quote,	Key_Comma,	Key_Period,	Key_P,	Key_Y,	Key_Tab,
   Key_PageUp,	Key_A,	Key_O,	Key_E,	Key_U,	Key_I,	/* No key */
   Key_PageDown,	Key_Semicolon,	Key_Q,	Key_J,	Key_K,	Key_X,	Key_Escape,
   Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
   ShiftToLayer(FUNCTION),

   M(MACRO_ANY),	Key_6,	Key_7,	Key_8,	Key_9,	Key_0,	Key_KeypadNumLock,
   Key_Enter,	Key_F,	Key_G,	Key_C,	Key_R,	Key_L,	Key_Slash,
   /* No key */	Key_D,	Key_H,	Key_T,	Key_N,	Key_S,	Key_Minus,
   Key_RightAlt,	Key_B,	Key_M,	Key_W,	Key_V,	Key_Z,	Key_Equals,
   Key_RightShift, Key_LeftAlt, Key_Spacebar, Key_RightControl,
   ShiftToLayer(FUNCTION)),

  [FUNCTION] =  KEYMAP_STACKED
  (___,	Key_F1,	Key_F2,	Key_F3,	Key_F4,	Key_F5,	XXX,
   Key_Tab,	___,	Key_mouseBtnL,	Key_mouseUp,	Key_mouseBtnR,	Key_mouseWarpEnd,	Key_mouseWarpNE,
   Key_Home,	Key_mouseBtnM,	Key_mouseL,	Key_mouseDn,	Key_mouseR,	Key_mouseWarpNW,	/* No key */
   Key_End,	Key_PrintScreen,	Key_Insert,	Key_DownArrow,	Key_UpArrow,	Key_mouseWarpSW,	Key_mouseWarpSE,
   ___, Key_Delete, ___, ___,
   ___,

   ___,	Key_F6,	Key_F7,	Key_F8,	Key_F9,	Key_F10,	___,
   ___,	Key_PageDown,	Key_LeftCurlyBracket,	Key_UpArrow,	Key_RightCurlyBracket,	Key_RightArrow,	Key_Backslash,
   /* No key */	___,	Key_LeftArrow,	Key_DownArrow,	Key_RightArrow,	___,	Key_Pipe,
   ___,	Key_PageUp,	Key_LeftBracket,	___,	Key_RightBracket,	Key_F11,	Key_F12,
   ___, ___, Key_Enter, ___,
   ___),


  [NUMPAD] =  KEYMAP_STACKED
  (___,	___,	___,	___,	___,	___,	___,
   ___,	___,	___,	___,	___,	___,	___,
   ___,	___,	___,	___,	___,	___,	/* No key */
   ___,	___,	___,	___,	___,	___,	___,
   ___, ___, ___, ___,
   ___,

   M(MACRO_VERSION_INFO),	___,	Key_Keypad7,	Key_Keypad8,	Key_Keypad9,	Key_KeypadSubtract,	___,
   ___,	___,	Key_Keypad4,	Key_Keypad5,	Key_Keypad6,	Key_KeypadAdd,	___,
   /* No key */	___,	Key_Keypad1,	Key_Keypad2,	Key_Keypad3,	Key_Equals,	___,
   ___,	___,	Key_Keypad0,	Key_KeypadDot,	Key_KeypadMultiply,	Key_KeypadDivide,	Key_Enter,
   ___, ___, ___, ___,
   ___)
};

/* Re-enable astyle's indent enforcement */
// *INDENT-ON*

/** versionInfoMacro handles the 'firmware version info' macro
 *  When a key bound to the macro is pressed, this macro
 *  prints out the firmware build information as virtual keystrokes
 */

static void versionInfoMacro(uint8_t keyState) {
  if (keyToggledOn(keyState)) {
    Macros.type(PSTR("Keyboardio Model 01 - Kaleidoscope "));
    Macros.type(PSTR(BUILD_INFORMATION));
  }
}

/** anyKeyMacro is used to provide the functionality of the 'Any' key.
 *
 * When the 'any key' macro is toggled on, a random alphanumeric key is
 * selected. While the key is held, the function generates a synthetic
 * keypress event repeating that randomly selected key.
 *
 */

static void anyKeyMacro(uint8_t keyState) {
  static Key lastKey;
  if (keyToggledOn(keyState))
    lastKey.keyCode = Key_A.keyCode + (uint8_t)(millis() % 36);

  if (keyIsPressed(keyState))
    kaleidoscope::hid::pressKey(lastKey);
}


/** macroAction dispatches keymap events that are tied to a macro
    to that macro. It takes two uint8_t parameters.

    The first is the macro being called (the entry in the 'enum' earlier in this file).
    The second is the state of the keyswitch. You can use the keyswitch state to figure out
    if the key has just been toggled on, is currently pressed or if it's just been released.

    The 'switch' statement should have a 'case' for each entry of the macro enum.
    Each 'case' statement should call out to a function to handle the macro in question.

 */

const macro_t *macroAction(uint8_t macroIndex, uint8_t keyState) {
  switch (macroIndex) {

  case MACRO_VERSION_INFO:
    versionInfoMacro(keyState);
    break;

  case MACRO_ANY:
    anyKeyMacro(keyState);
    break;
  }
  return MACRO_NONE;
}



// These 'solid' color effect definitions define a rainbow of
// LED color modes calibrated to draw 500mA or less on the
// Keyboardio Model 01.


static kaleidoscope::LEDSolidColor solidRed(160, 0, 0);
static kaleidoscope::LEDSolidColor solidOrange(140, 70, 0);
static kaleidoscope::LEDSolidColor solidYellow(130, 100, 0);
static kaleidoscope::LEDSolidColor solidGreen(0, 160, 0);
static kaleidoscope::LEDSolidColor solidBlue(0, 70, 130);
static kaleidoscope::LEDSolidColor solidIndigo(0, 0, 170);
static kaleidoscope::LEDSolidColor solidViolet(130, 0, 120);



/** The 'setup' function is one of the two standard Arduino sketch functions.
  * It's called when your keyboard first powers up. This is where you set up
  * Kaleidoscope and any plugins.
  */

void setup() {
  // First, call Kaleidoscope's internal setup function
  Kaleidoscope.setup();

  // Next, tell Kaleidoscope which plugins you want to use.
  // The order can be important. For example, LED effects are
  // added in the order they're listed here.
  Kaleidoscope.use(
    // The boot greeting effect pulses the LED button for 10 seconds after the keyboard is first connected
    &BootGreetingEffect,

    // The hardware test mode, which can be invoked by tapping Prog, LED and the left Fn button at the same time.
    &TestMode,

    // LEDControl provides support for other LED modes
    &LEDControl,

    // We start with the LED effect that turns off all the LEDs.
    &LEDOff,

    // The rainbow effect changes the color of all of the keyboard's keys at the same time
    // running through all the colors of the rainbow.
    &LEDRainbowEffect,

    // The rainbow wave effect lights up your keyboard with all the colors of a rainbow
    // and slowly moves the rainbow across your keyboard
    &LEDRainbowWaveEffect,

    // The chase effect follows the adventure of a blue pixel which chases a red pixel across
    // your keyboard. Spoiler: the blue pixel never catches the red pixel
    &LEDChaseEffect,

    // These static effects turn your keyboard's LEDs a variety of colors
    &solidRed, &solidOrange, &solidYellow, &solidGreen, &solidBlue, &solidIndigo, &solidViolet,

    // The breathe effect slowly pulses all of the LEDs on your keyboard
    &LEDBreatheEffect,

    // The AlphaSquare effect prints each character you type, using your
    // keyboard's LEDs as a display
    &AlphaSquareEffect,

    // The stalker effect lights up the keys you've pressed recently
    &StalkerEffect,

    // The numlock plugin is responsible for lighting up the 'numpad' mode
    // with a custom LED effect
    &NumLock,

    // The macros plugin adds support for macros
    &Macros,

    // The MouseKeys plugin lets you add keys to your keymap which move the mouse.
    &MouseKeys
  );

  // While we hope to improve this in the future, the NumLock plugin
  // needs to be explicitly told which keymap layer is your numpad layer
  NumLock.numPadLayer = NUMPAD;

  // We configure the AlphaSquare effect to use RED letters
  AlphaSquare.color = { 255, 0, 0 };

  // We set the brightness of the rainbow effects to 150 (on a scale of 0-255)
  // This draws more than 500mA, but looks much nicer than a dimmer effect
  LEDRainbowEffect.brightness(150);
  LEDRainbowWaveEffect.brightness(150);

  // The LED Stalker mode has a few effects. The one we like is
  // called 'BlazingTrail'. For details on other options,
  // see https://github.com/keyboardio/Kaleidoscope-LED-Stalker
  StalkerEffect.variant = STALKER(BlazingTrail);

  // We want to make sure that the firmware starts with LED effects off
  // This avoids over-taxing devices that don't have a lot of power to share
  // with USB devices
  LEDOff.activate();
}

/** loop is the second of the standard Arduino sketch functions.
  * As you might expect, it runs in a loop, never exiting.
  *
  * For Kaleidoscope-based keyboard firmware, you usually just want to
  * call Kaleidoscope.loop(); and not do anything custom here.
  */

void loop() {
  Kaleidoscope.loop();
}

[fishheadsoup (JP)]

Very nice. So many movement keys… I must admit, am I the only one with a not so clean pristine desk? And thanks for including it in code, I’ll copy that and compare/maybe try out.

[pnunn]

Did the SVG make it into the repo?, and if it did, where do we find it. I need to print this out with my mods on it.
Ta

[jesse]

keyboardio/Model01-Legends

[pnunn]

Thanks Jesse. I did find it eventually and have printed it out and modified for my slight changes.