Gaming Layer (based on default QWERTY)


(Piers Cawley) #41

That’s a bug in Blizzard’s code though. I was suggesting deliberately tweaking keyboard firmware to get around the restriction. Mostly to see if it could be done :slight_smile:


(Michael Richters) #42

Ah, I think I understand now. And I’ve got so many ideas for Macro functions…


(Jan) #43

Thank you!

I look forward to seeing how you find it. I’m still waiting on my Model 01 to arrive, checking twitter, kickstarter and here everyday now…


(kajsa.anderson) #44

My alternative solution was to use the 2nd bind slot for “jump” and set it to backspace. I’ve been playing WoW, including raiding (heroic ToS, normal new raid) with my Model 01 for several weeks now. The only problem I’ve had is getting my one-shot modifiers stuck on, and adding the LED effect that shows that has helped tremendously.


(Jan) #45

What layout are you using if I may ask?


(kajsa.anderson) #46

Not sure if you’re asking me or someone else, but mine is viewable on github; it’s based on Dvorak - see https://github.com/kajsa/Model01-Firmware/blob/master/Model01-Firmware.ino Or were you asking about in-game keybindings? I’m not sure if there’s a simple way to export those, but mine are highly customized. (It’s a guild joke to NEVER ask me what the binding is for anything.)


(Piers Cawley) #47

My basic layout is somewhat more extreme. https://github.com/pdcawley/Model01-Maltron-Inspired.

On further reflection, I doubt I’ll be switching far away from that, just switching out my thumb keys for (probably) Key_Backspace, Key_LeftArrow, Key_UpArrow and Key_RightArrow and the palm for Key_LeftShift, which should place nicely with the (currently) SpaceCadet magic I’ve got going on with Key_E on the default layer. I’m going to need a couple of macros on Key_Slash and Key_Enter to toggle both send the key event and toggle a ‘chat’ layer (with the default thumb keys).

I should probably get on with implementing that shouldn’t I?


(Jan) #48

Finally received my Model 01 and mocked up the layout to the best of my ability. Have some issues, would love if someone with any level of competency could look over my code and let me know what I’m doing wrong:

> // -*- mode: c++ -*-
> // 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 "Numpad" mode, which is mostly just the Numpad specific LED mode
> #include "Kaleidoscope-NumPad.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 { COLEMAK, FUNCTION, NUMPAD, GAMING QWERTY }; // 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 = {
> 
>   [COLEMAK] = KEYMAP_STACKED
>   (___,          Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext,
>    Key_Backtick, Key_Q, Key_W, Key_F, Key_P, Key_G, Key_Tab,
>    Key_PageUp,   Key_A, Key_R, Key_S, Key_T, Key_D,
>    Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, 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_J, Key_L, Key_U,     Key_Y,         Key_Semicolon, Key_Equals,
>                   Key_H, Key_N, Key_E,     Key_I,         Key_O,         Key_Quote,
>    Key_RightAlt,  Key_K, Key_M, Key_Comma, Key_Period,    Key_Slash,     Key_Minus,
>    LockLayer(GAMING QWERTY), Key_LeftAlt, Key_Spacebar, Key_RightControl,
>    ShiftToLayer(FUNCTION)),
> 
> 
>   [NUMPAD] =  KEYMAP_STACKED
>   (___, ___, ___, ___, ___, ___, ___,
>    ___, ___, ___, ___, ___, ___, ___,
>    ___, ___, ___, ___, ___, ___,
>    ___, ___, ___, ___, ___, ___, ___,
>    ___, ___, ___, ___,
>    ___,
> 
>    M(MACRO_VERSION_INFO),  ___, Key_Keypad7, Key_Keypad8,   Key_Keypad9,        Key_KeypadSubtract, ___,
>    ___,                    ___, Key_Keypad4, Key_Keypad5,   Key_Keypad6,        Key_KeypadAdd,      ___,
>                            ___, Key_Keypad1, Key_Keypad2,   Key_Keypad3,        Key_Equals,         Key_Quote,
>    ___,                    ___, Key_Keypad0, Key_KeypadDot, Key_KeypadMultiply, Key_KeypadDivide,   Key_Enter,
>    ___, ___, ___, ___,
>    ___),
> 
>   [FUNCTION] =  KEYMAP_STACKED
>   (___,      Key_F1,           Key_F2,      Key_F3,     Key_F4,        Key_F5,           XXX,
>    Key_Tab,  ___,              Key_mouseUp, ___,        Key_mouseBtnR, Key_mouseWarpEnd, Key_mouseWarpNE,
>    Key_Home, Key_mouseL,       Key_mouseDn, Key_mouseR, Key_mouseBtnL, Key_mouseWarpNW,
>    Key_End,  Key_PrintScreen,  Key_Insert,  ___,        Key_mouseBtnM, Key_mouseWarpSW,  Key_mouseWarpSE,
>    ___, Key_Delete, ___, ___,
>    ___,
> 
>    Consumer_ScanPreviousTrack, Key_F6,                 Key_F7,                   Key_F8,                   Key_F9,          Key_F10,          Key_F11,
>    Consumer_PlaySlashPause,    Consumer_ScanNextTrack, Key_LeftCurlyBracket,     Key_RightCurlyBracket,    Key_LeftBracket, Key_RightBracket, Key_F12,
>                                Key_LeftArrow,          Key_DownArrow,            Key_UpArrow,              Key_RightArrow,  ___,              ___,
>    Key_PcApplication,          Consumer_Mute,          Consumer_VolumeDecrement, Consumer_VolumeIncrement, ___,             Key_Backslash,    Key_Pipe,
>    ___, ___, Key_Enter, ___,
>    ___)
> 
>   [GAMING QWERTY] = KEYMAP_STACKED
>   (Key_Escape,    Key_1, Key_2, Key_3, Key_4, Key_5, Key_T,
>    Key_Backtick,  Key_Tab, Key_Q, Key_W, Key_E, Key_R, Key_G,
>    Key_PageUp,    Key_LeftShift, Key_A, Key_S, Key_D, Key_F,
>    Key_PageDown,  Key_LeftControl, Key_Z, Key_X, Key_C, Key_V, Key_B,
>    Key_LeftControl, Key_LeftAlt, Key_Spacebar, Key_LeftShift,
>    ShiftToLayer(FUNCTION),
>    
>    M(MACRO_ANY),   Key_6, Key_7, Key_8,     Key_9,      Key_0,         Key_KeypadNumLock
>    Key_Enter,      Key_Y, Key_U, Key_I,     Key_O,      Key_P,         Key_Equals,
>                    Key_H, Key_J, Key_K,     Key_L,      Key_Semicolon, Key_Quote
>    LockLayer(COLEMAK),   Key_N, Key_M, Key_Comma, Key_Period, Key_Slash,     Key_Minus,
>    Key_RightShift, Key_LeftAlt, Key_Spacebar, Key_RightControl,
>    ShiftToLayer(FUNCTION)),
> 
> 
> 
> };
> 
> /* 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 numpad plugin is responsible for lighting up the 'numpad' mode
>     // with a custom LED effect
>     &NumPad,
> 
>     // 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 NumPad plugin
>   // needs to be explicitly told which keymap layer is your numpad layer
>   NumPad.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();
> }

Tried to verify, got this error:

> Arduino: 1.8.5 (Windows Store 1.8.10.0) (Windows 10), Board: "Keyboardio Model 01"
> 
> Model01-Firmware:189: error: macro "KEYMAP_STACKED" requires 64 arguments, but only 62 given
> 
>     ShiftToLayer(FUNCTION)),
> 
>                           ^
> 
> Multiple libraries were found for "HID.h"
>  Used: C:\Users\xxx\Documents\ArduinoData\packages\keyboardio\hardware\avr\1.22.0\libraries\HID
>  Not used: C:\Program Files\WindowsApps\ArduinoLLC.ArduinoIDE_1.8.10.0_x86__mdqgnx93n4wtt\hardware\arduino\avr\libraries\HID
> exit status 1
> macro "KEYMAP_STACKED" requires 64 arguments, but only 62 given
> 
> This report would have more information with
> "Show verbose output during compilation"
> option enabled in File -> Preferences.


(Jan) #49

I just noticed the last line of my GAMING QWERTY key layout is highlighted in red, the one that says:

ShiftToLayer(FUNCTION)),

for the right side of the board.

No idea what’s going on.

I created a thread in the Help and Getting Started area here

Will update this thread when I figure out what I’m doing wrong…


(Jan) #50

Also, I realised I didn’t program the function keys for this layout as I originally planned in the original post. Will first figure out how to make it function in it’s most basic form before doing anything else.


#51

This is essentially a double post and it’s been solved here Error: “macro “KEYMAP_STACKED” requires 64 arguments, but only 62 given”. Help please


(Jan) #52

Ok, so I’m typing this on my Model 01 finally. I decided to learn Colemak so my typing speed is crippled.

What I had wrong was a few missing commas, layouts in the wrong order and a misuse of the switch layout mechanism. Thanks to all who fixed it for me, you did far more than just help.

I’ve been playing Overwatch with the QWERTY layout proposed in the OP. It’s been working well, sometimes I think I should have drawn up the layout for reference but other than occasional hesitation I get by just fine.

It does take some getting used to, probably even more so for me since I still use regular keyboards at the office, but I find I don’t have to contort my fingers as much as before which I appreciate.


(Liam Mitchell) #53

Gaming on the keyboardio is horrible (then again I still struggle to type on it and cursor keys suck being horizontal)

Is there a git repo or something for this mapping?

Make U up cursor key can move the { to Y
Would Any key switch a toggle for the cursor mapping layer?

Would like to be able to play games requiring left and right hand on keyboard as well as FPS games.
I could re-map per game I suppose but would be more convenient to map the keyboard.