I am trying to make a Colormap for each of my 5 layers, so I can clearly tell what layer I am on. Please help me get it to work.
My colormap is defined for all 5 layers.
But currently, it only works for the first layer, and is all white for everything above the first layer.
I do have
ColormapEffect.max_layers(8);
so it’s not that.
Here is the code:
// -*- mode: c++ -*-
// Copyright 2016-2022 Keyboardio, inc. <jesse@keyboard.io>
// See "LICENSE" for license details
/**
* These #include directives pull in the Kaleidoscope firmware core,
* as well as the Kaleidoscope plugins we use in the Model 100's firmware
*/
// The Kaleidoscope core
#include "Kaleidoscope.h"
// Support for storing the keymap in EEPROM
#include "Kaleidoscope-EEPROM-Settings.h"
#include "Kaleidoscope-EEPROM-Keymap.h"
// Support for communicating with the host via a simple Serial protocol
#include "Kaleidoscope-FocusSerial.h"
// Support for querying the firmware version via Focus
#include "Kaleidoscope-FirmwareVersion.h"
// Support for keys that move the mouse
#include "Kaleidoscope-MouseKeys.h"
// Support for macros
#include "Kaleidoscope-Macros.h"
// my plugins
#include "Kaleidoscope-LED-Palette-Theme.h"
// my LED plugins
// LED plugins go here
// Support for controlling the keyboard's LEDs
#include "Kaleidoscope-LEDControl.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 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 shared palettes for other plugins, like Colormap below
#include "Kaleidoscope-LED-Palette-Theme.h"
// Support for an LED mode that lets one configure per-layer color maps
#include "Kaleidoscope-Colormap.h"
// Support for turning the LEDs off after a certain amount of time
#include "Kaleidoscope-IdleLEDs.h"
// Support for setting and saving the default LED mode
#include "Kaleidoscope-DefaultLEDModeConfig.h"
// Support for Keyboardio's internal keyboard testing mode
#include "Kaleidoscope-HardwareTestMode.h"
// Support for host power management (suspend & wakeup)
#include "Kaleidoscope-HostPowerManagement.h"
// Support for magic combos (key chords that trigger an action)
#include "Kaleidoscope-MagicCombo.h"
// Support for USB quirks, like changing the key state report protocol
#include "Kaleidoscope-USB-Quirks.h"
// Support for secondary actions on keys
#include "Kaleidoscope-Qukeys.h"
// Support for one-shot modifiers and layer keys
#include "Kaleidoscope-OneShot.h"
#include "Kaleidoscope-Escape-OneShot.h"
// Support for dynamic, Chrysalis-editable macros
#include "Kaleidoscope-DynamicMacros.h"
// Support for SpaceCadet keys
#include "Kaleidoscope-SpaceCadet.h"
// Support for editable layer names
#include "Kaleidoscope-LayerNames.h"
// Support for the GeminiPR Stenography protocol
#include "Kaleidoscope-Steno.h"
/** This 'enum' is a list of all the macros used by the Model 100'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 100'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/kaleidoscope/key_defs/keyboard.h
* https://github.com/keyboardio/Kaleidoscope/blob/master/src/kaleidoscope/key_defs/consumerctl.h
* https://github.com/keyboardio/Kaleidoscope/blob/master/src/kaleidoscope/key_defs/sysctl.h
* https://github.com/keyboardio/Kaleidoscope/blob/master/src/kaleidoscope/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.
* keeping NUM and FN consistent and accessible on all layers
*
* The PROG key is special, since it is how you indicate to the board that you
* want to flash the firmware. However, it can be remapped to a regular key.
* When the keyboard boots, it first looks to see whether the PROG key is held
* down; if it is, it simply awaits further flashing instructions. If it is
* not, it continues loading the rest of the firmware and the keyboard
* functions normally, with whatever binding you have set to PROG. More detail
* here: https://community.keyboard.io/t/how-the-prog-key-gets-you-into-the-bootloader/506/8
*
* 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 { QWERTY, REDLAYER, GREENLAYER, BLUELAYER, PURPLELAYER }; // layers
/* This comment temporarily turns off astyle's indent enforcement
* so we can make the keymaps actually resemble the physical key layout better
*/
// clang-format off
KEYMAPS(
[QWERTY] = KEYMAP_STACKED
(Key_LeftGui, LCTRL(Key_B), LCTRL(Key_I), LCTRL(Key_LeftShift), LALT(Key_LeftShift), LCTRL(LALT(Key_LeftShift)), LCTRL(Key_LeftArrow),
Key_mouseBtnL, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Enter,
___, Key_A, Key_S, Key_D, Key_F, Key_G,
___, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Delete,
Key_LeftControl, Key_Backspace, Key_LeftShift, Key_Spacebar,
ShiftToLayer(REDLAYER),
LCTRL(Key_RightArrow), LockLayer(PURPLELAYER), ___, ___, ___, ___, ___,
LCTRL(Key_LeftAlt), Key_Y, Key_U, Key_I, Key_O, Key_P, Key_mouseBtnR,
Key_H, Key_J, Key_K, Key_L, Key_Home, LCTRL(Key_UpArrow),
Key_UpArrow, Key_N, Key_M, Key_Comma, Key_Period, Key_End, LCTRL(Key_DownArrow),
Key_LeftAlt, Key_LeftArrow, Key_DownArrow, Key_RightArrow,
ShiftToLayer(GREENLAYER)),
[REDLAYER] = KEYMAP_STACKED
(___, ___, ___, ___, ___, ___, LSHIFT(LCTRL(Key_LeftArrow)),
___, Key_Backtick, Key_Keypad7, Key_Keypad8, Key_Keypad9, Key_KeypadAdd, ___,
___, LSHIFT(Key_3), Key_Keypad4, Key_Keypad5, Key_Keypad6, Key_KeypadDot,
___, Key_Backslash, Key_Keypad1, Key_Keypad2, Key_Keypad3, Key_Keypad0, ___,
___, ___, ___, ___,
___,
LSHIFT(LCTRL(Key_RightArrow)), ___, ___, ___, ___, ___, ___,
___, LSHIFT(Key_1), LSHIFT(Key_Slash), LSHIFT(Key_7), LSHIFT(Key_Quote), LSHIFT(Key_2), ___,
Key_Quote, LSHIFT(Key_Backtick), Key_KeypadMultiply, Key_Pipe, Key_PageUp, LSHIFT(LCTRL(Key_UpArrow)),
___, Key_Semicolon, LSHIFT(Key_Semicolon), ___, ___, Key_PageDown, LSHIFT(LCTRL(Key_DownArrow)),
___, ___, ___, ___,
ShiftToLayer(BLUELAYER)),
// Key_Insert
[GREENLAYER] = KEYMAP_STACKED
(___, ___, ___, ___, ___, ___, LSHIFT(LCTRL(Key_LeftArrow)),
___, Key_Equals, Key_F7, Key_F8, Key_F9, Key_F12, LSHIFT(Key_Tab),
___, Key_Slash, Key_F4, Key_F5, Key_F6, Key_F11,
___, Key_KeypadSubtract, Key_F1, Key_F2, Key_F3, Key_F10, Key_LEDEffectNext,
___, Key_Escape, ___, Key_Tab,
ShiftToLayer(BLUELAYER),
LSHIFT(LCTRL(Key_RightArrow)), ___, ___, ___, ___, ___, ___,
___, LSHIFT(Key_5), LSHIFT(Key_4), Key_mouseUp, Key_LeftBracket, Key_RightBracket, ___,
LSHIFT(Key_6), Key_mouseL, Key_mouseDn, Key_mouseR, ___, LSHIFT(LCTRL(Key_UpArrow)),
LSHIFT(Key_UpArrow), LSHIFT(Key_9), LSHIFT(Key_0), Key_LeftCurlyBracket, Key_RightCurlyBracket, ___, LSHIFT(LCTRL(Key_DownArrow)),
___, LSHIFT(Key_LeftArrow), LSHIFT(Key_DownArrow), LSHIFT(Key_RightArrow),
___),
[BLUELAYER] = KEYMAP_STACKED
(___, Key_F1, Key_F2, Key_F3, Key_F4, Key_F5, LSHIFT(LCTRL(Key_LeftArrow)),
___, Key_KeypadMultiply, Key_Keypad7, Key_Keypad8, Key_Keypad9, Key_KeypadAdd, LSHIFT(Key_Tab),
Key_PageUp, Key_KeypadSubtract, Key_Keypad4, Key_Keypad5, Key_Keypad6, Key_KeypadDot,
Key_PageDown, Key_KeypadEquals, Key_Keypad1, Key_Keypad2, Key_Keypad3, Key_Keypad0, Key_LEDEffectNext,
___, Key_Escape, ___, Key_Tab,
___,
LSHIFT(LCTRL(Key_RightArrow)), ___, Key_F7, Key_F8, Key_F9, Key_F10, Key_F11,
___, Key_Insert, Key_LeftCurlyBracket, Key_RightCurlyBracket, Key_LeftBracket, Key_RightBracket, Key_F12,
Key_mouseL, Key_mouseDn, Key_mouseUp, Key_mouseR, ___, ___,
___, Key_mouseBtnL, Key_mouseBtnR, ___, ___, Key_Backslash, Key_Pipe,
___, ___, ___, ___,
___),
[PURPLELAYER] = KEYMAP_STACKED
(___, Key_F1, Key_F2, Key_F3, Key_F4, Key_F5, LSHIFT(LCTRL(Key_LeftArrow)),
___, Key_KeypadMultiply, Key_Keypad7, Key_Keypad8, Key_Keypad9, Key_KeypadAdd, LSHIFT(Key_Tab),
Key_PageUp, Key_KeypadSubtract, Key_Keypad4, Key_Keypad5, Key_Keypad6, Key_KeypadDot,
Key_PageDown, Key_KeypadEquals, Key_Keypad1, Key_Keypad2, Key_Keypad3, Key_Keypad0, Key_LEDEffectNext,
___, Key_Escape, ___, Key_Tab,
___,
LSHIFT(LCTRL(Key_RightArrow)), ___, Key_F7, Key_F8, Key_F9, Key_F10, Key_F11,
___, Key_Insert, Key_LeftCurlyBracket, Key_RightCurlyBracket, Key_LeftBracket, Key_RightBracket, Key_F12,
Key_mouseL, Key_mouseDn, Key_mouseUp, Key_mouseR, ___, ___,
___, Key_mouseBtnL, Key_mouseBtnR, ___, ___, Key_Backslash, Key_Pipe,
___, ___, ___, ___,
___),
) // KEYMAPS(
// Colors names of the EGA palette, for convenient use in colormaps. Should
// match the palette definition below. Optional, one can just use the indexes
// directly, too.
enum {
BLACK,
BLUE,
GREEN,
CYAN,
RED,
MAGENTA,
BROWN,
LIGHT_GRAY,
DARK_GRAY,
BRIGHT_BLUE,
BRIGHT_GREEN,
BRIGHT_CYAN,
BRIGHT_RED,
BRIGHT_MAGENTA,
YELLOW,
WHITE
};
// Define an EGA palette. Conveniently, that's exactly 16 colors, just like the
// limit of LEDPaletteTheme.
PALETTE(
CRGB(0x00, 0x00, 0x00), // [0x0] black
CRGB(0x00, 0x00, 0xaa), // [0x1] blue
CRGB(0x00, 0xaa, 0x00), // [0x2] green
CRGB(0x00, 0xaa, 0xaa), // [0x3] cyan
CRGB(0xaa, 0x00, 0x00), // [0x4] red
CRGB(0xaa, 0x00, 0xaa), // [0x5] magenta
CRGB(0xaa, 0x55, 0x00), // [0x6] brown
CRGB(0xaa, 0xaa, 0xaa), // [0x7] light gray
CRGB(0x55, 0x55, 0x55), // [0x8] dark gray
CRGB(0x55, 0x55, 0xff), // [0x9] bright blue
CRGB(0x55, 0xff, 0x55), // [0xa] bright green
CRGB(0x55, 0xff, 0xff), // [0xb] bright cyan
CRGB(0xff, 0x55, 0x55), // [0xc] bright red
CRGB(0xff, 0x55, 0xff), // [0xd] bright magenta
CRGB(0xff, 0xff, 0x55), // [0xe] yellow
CRGB(0xff, 0xff, 0xff) // [0xf] white
)
COLORMAPS(
[QWERTY] = COLORMAP_STACKED
(BLACK, GREEN, GREEN, GREEN, GREEN, GREEN, BLUE,
MAGENTA, CYAN, CYAN, CYAN, CYAN, CYAN, RED,
BROWN, CYAN, CYAN, CYAN, CYAN, CYAN,
BROWN, CYAN, CYAN, CYAN, CYAN, CYAN, RED,
LIGHT_GRAY, RED, LIGHT_GRAY, LIGHT_GRAY,
BLACK,
BLACK, BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN, BLACK,
BRIGHT_RED, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, YELLOW,
BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_RED, BRIGHT_RED,
BLACK, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED,
DARK_GRAY, BRIGHT_RED, DARK_GRAY, DARK_GRAY,
BLACK),
[REDLAYER] = COLORMAP_STACKED
(BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED,
MAGENTA, CYAN, CYAN, CYAN, CYAN, CYAN, RED,
BROWN, CYAN, CYAN, CYAN, CYAN, CYAN,
BROWN, CYAN, CYAN, CYAN, CYAN, CYAN, RED,
LIGHT_GRAY, RED, LIGHT_GRAY, LIGHT_GRAY,
BLACK,
BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED,
BRIGHT_RED, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, YELLOW,
BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_RED, BRIGHT_RED,
BLACK, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED,
DARK_GRAY, BRIGHT_RED, DARK_GRAY, DARK_GRAY,
BLACK),
[GREENLAYER] = COLORMAP_STACKED
(BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN,
MAGENTA, CYAN, CYAN, CYAN, CYAN, CYAN, RED,
BROWN, CYAN, CYAN, CYAN, CYAN, CYAN,
BROWN, CYAN, CYAN, CYAN, CYAN, CYAN, RED,
LIGHT_GRAY, RED, LIGHT_GRAY, LIGHT_GRAY,
BLACK,
BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN, BRIGHT_GREEN,
BRIGHT_RED, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, YELLOW,
BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_RED, BRIGHT_RED,
BLACK, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED,
DARK_GRAY, BRIGHT_RED, DARK_GRAY, DARK_GRAY,
BLACK),
[BLUELAYER] = COLORMAP_STACKED
(BRIGHT_BLUE, BRIGHT_BLUE, BRIGHT_BLUE, BRIGHT_BLUE, BRIGHT_BLUE, BRIGHT_BLUE, BRIGHT_BLUE,
MAGENTA, CYAN, CYAN, CYAN, CYAN, CYAN, RED,
BROWN, CYAN, CYAN, CYAN, CYAN, CYAN,
BROWN, CYAN, CYAN, CYAN, CYAN, CYAN, RED,
LIGHT_GRAY, RED, LIGHT_GRAY, LIGHT_GRAY,
BLACK,
BRIGHT_BLUE, BRIGHT_BLUE, BRIGHT_BLUE, BRIGHT_BLUE, BRIGHT_BLUE, BRIGHT_BLUE, BRIGHT_BLUE,
BRIGHT_RED, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, YELLOW,
BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_RED, BRIGHT_RED,
BLACK, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED,
DARK_GRAY, BRIGHT_RED, DARK_GRAY, DARK_GRAY,
BLACK),
[PURPLELAYER] = COLORMAP_STACKED
(BRIGHT_MAGENTA, BRIGHT_MAGENTA, BRIGHT_MAGENTA, BRIGHT_MAGENTA, BRIGHT_MAGENTA, BRIGHT_MAGENTA, BRIGHT_MAGENTA,
MAGENTA, CYAN, CYAN, CYAN, CYAN, CYAN, RED,
BROWN, CYAN, CYAN, CYAN, CYAN, CYAN,
BROWN, CYAN, CYAN, CYAN, CYAN, CYAN, RED,
LIGHT_GRAY, RED, LIGHT_GRAY, LIGHT_GRAY,
BLACK,
BRIGHT_MAGENTA, BRIGHT_MAGENTA, BRIGHT_MAGENTA, BRIGHT_MAGENTA, BRIGHT_MAGENTA, BRIGHT_MAGENTA, BRIGHT_MAGENTA,
BRIGHT_RED, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, YELLOW,
BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_RED, BRIGHT_RED,
BLACK, BRIGHT_CYAN, BRIGHT_CYAN, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED, BRIGHT_RED,
DARK_GRAY, BRIGHT_RED, DARK_GRAY, DARK_GRAY,
BLACK)
)
/* Re-enable astyle's indent enforcement */
// clang-format on
/** 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 macro_id, KeyEvent &event) {
switch (macro_id) {
}
return MACRO_NONE;
}
/** toggleLedsOnSuspendResume toggles the LEDs off when the host goes to sleep,
* and turns them back on when it wakes up.
*/
void toggleLedsOnSuspendResume(kaleidoscope::plugin::HostPowerManagement::Event event) {
switch (event) {
case kaleidoscope::plugin::HostPowerManagement::Suspend:
LEDControl.disable();
break;
case kaleidoscope::plugin::HostPowerManagement::Resume:
LEDControl.enable();
break;
case kaleidoscope::plugin::HostPowerManagement::Sleep:
break;
}
}
/** hostPowerManagementEventHandler dispatches power management events (suspend,
* resume, and sleep) to other functions that perform action based on these
* events.
*/
void hostPowerManagementEventHandler(kaleidoscope::plugin::HostPowerManagement::Event event) {
toggleLedsOnSuspendResume(event);
}
/** This 'enum' is a list of all the magic combos used by the Model 100's
* firmware The names aren't particularly important. What is important is that
* each is unique.
*
* These are the names of your magic combos. They will be used by the
* `USE_MAGIC_COMBOS` call below.
*/
enum {
// Toggle between Boot (6-key rollover; for BIOSes and early boot) and NKRO
// mode.
COMBO_TOGGLE_NKRO_MODE,
// Enter test mode
COMBO_ENTER_TEST_MODE
};
/** Wrappers, to be used by MagicCombo. **/
/**
* This simply toggles the keyboard protocol via USBQuirks, and wraps it within
* a function with an unused argument, to match what MagicCombo expects.
*/
static void toggleKeyboardProtocol(uint8_t combo_index) {
USBQuirks.toggleKeyboardProtocol();
}
/**
* Toggles between using the built-in keymap, and the EEPROM-stored one.
*/
static void toggleKeymapSource(uint8_t combo_index) {
if (Layer.getKey == Layer.getKeyFromPROGMEM) {
Layer.getKey = EEPROMKeymap.getKey;
} else {
Layer.getKey = Layer.getKeyFromPROGMEM;
}
}
/**
* This enters the hardware test mode
*/
static void enterHardwareTestMode(uint8_t combo_index) {
HardwareTestMode.runTests();
}
/** Magic combo list, a list of key combo and action pairs the firmware should
* recognise.
*/
USE_MAGIC_COMBOS({.action = toggleKeyboardProtocol,
// Left Fn + Esc + Shift
.keys = {R3C6, R2C6, R3C7}},
{.action = enterHardwareTestMode,
// Left Fn + Prog + LED
.keys = {R3C6, R0C0, R0C6}},
{.action = toggleKeymapSource,
// Left Fn + Prog + Shift
.keys = {R3C6, R0C0, R3C7}});
// First, 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_INIT_PLUGINS(
// The EEPROMSettings & EEPROMKeymap plugins make it possible to have an
// editable keymap in EEPROM.
EEPROMSettings,
EEPROMKeymap,
// SpaceCadet can turn your shifts into parens on tap, while keeping them as
// Shifts when held. SpaceCadetConfig lets Chrysalis configure some aspects of
// the plugin.
SpaceCadet,
SpaceCadetConfig,
// Focus allows bi-directional communication with the host, and is the
// interface through which the keymap in EEPROM can be edited.
Focus,
// FocusSettingsCommand adds a few Focus commands, intended to aid in
// changing some settings of the keyboard, such as the default layer (via the
// `settings.defaultLayer` command)
FocusSettingsCommand,
// FocusEEPROMCommand adds a set of Focus commands, which are very helpful in
// both debugging, and in backing up one's EEPROM contents.
FocusEEPROMCommand,
// 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.
HardwareTestMode,
// LEDControl provides support for other LED modes
LEDControl,
// We start with the LED effect that turns off all the LEDs.
LEDOff,
// 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,
// The breathe effect slowly pulses all of the LEDs on your keyboard
LEDBreatheEffect,
// The stalker effect lights up the keys you've pressed recently
StalkerEffect,
// The LED Palette Theme plugin provides a shared palette for other plugins,
// like Colormap below
LEDPaletteTheme,
// The Colormap effect makes it possible to set up per-layer colormaps
ColormapEffect,
// The macros plugin adds support for macros
Macros,
// The MouseKeys plugin lets you add keys to your keymap which move the mouse.
MouseKeys,
// my plugins
DefaultColormap,
// The HostPowerManagement plugin allows us to turn LEDs off when then host
// goes to sleep, and resume them when it wakes up.
HostPowerManagement,
// The MagicCombo plugin lets you use key combinations to trigger custom
// actions - a bit like Macros, but triggered by pressing multiple keys at the
// same time.
MagicCombo,
// The USBQuirks plugin lets you do some things with USB that we aren't
// comfortable - or able - to do automatically, but can be useful
// nevertheless. Such as toggling the key report protocol between Boot (used
// by BIOSes) and Report (NKRO).
USBQuirks,
// The Qukeys plugin enables the "Secondary action" functionality in
// Chrysalis. Keys with secondary actions will have their primary action
// performed when tapped, but the secondary action when held.
Qukeys,
// Enables the "Sticky" behavior for modifiers, and the "Layer shift when
// held" functionality for layer keys.
OneShot,
EscapeOneShot,
EscapeOneShotConfig,
// Turns LEDs off after a configurable amount of idle time.
IdleLEDs,
PersistentIdleLEDs,
// Enables dynamic, Chrysalis-editable macros.
DynamicMacros,
// The FirmwareVersion plugin lets Chrysalis query the version of the firmware
// programmatically.
FirmwareVersion,
// The LayerNames plugin allows Chrysalis to display - and edit - custom layer
// names, to be shown instead of the default indexes.
LayerNames,
// Enables setting, saving (via Chrysalis), and restoring (on boot) the
// default LED mode.
DefaultLEDModeConfig,
// Enables the GeminiPR Stenography protocol. Unused by default, but with the
// plugin enabled, it becomes configurable - and then usable - via Chrysalis.
GeminiPR);
/** 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();
// Set the hue of the boot greeting effect to something that will result in a
// nice green color.
BootGreetingEffect.hue = 85;
// 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(255);
LEDRainbowWaveEffect.brightness(255);
// Set the action key the test mode should listen for to Left Fn
HardwareTestMode.setActionKey(R3C6);
// 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/blob/master/docs/plugins/LED-Stalker.md
StalkerEffect.variant = STALKER(BlazingTrail);
// To make the keymap editable without flashing new firmware, we store
// additional layers in EEPROM. For now, we reserve space for eight layers. If
// one wants to use these layers, just set the default layer to one in EEPROM,
// by using the `settings.defaultLayer` Focus command, or by using the
// `keymap.onlyCustom` command to use EEPROM layers only.
EEPROMKeymap.setup(8);
// We need to tell the Colormap plugin how many layers we want to have custom
// maps for. To make things simple, we set it to eight layers, which is how
// many editable layers we have (see above).
ColormapEffect.max_layers(8);
ColormapEffect.activate();
DefaultColormap.setup();
// For Dynamic Macros, we need to reserve storage space for the editable
// macros. A kilobyte is a reasonable default.
DynamicMacros.reserve_storage(1024);
// If there's a default layer set in EEPROM, we should set that as the default
// here.
Layer.move(EEPROMSettings.default_layer());
// To avoid any surprises, SpaceCadet is turned off by default. However, it
// can be permanently enabled via Chrysalis, so we should only disable it if
// no configuration exists.
SpaceCadetConfig.disableSpaceCadetIfUnconfigured();
// Editable layer names are stored in EEPROM too, and we reserve 16 bytes per
// layer for them. We need one extra byte per layer for bookkeeping, so we
// reserve 17 / layer in total.
LayerNames.reserve_storage(17 * 8);
// Unless configured otherwise with Chrysalis, 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
DefaultLEDModeConfig.activateLEDModeIfUnconfigured(&LEDOff);
}
/** 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();
}