mu

Rewrite MouseKeys plugin

.gitignore

@@ -13,3 +13,4 @@
 /results/
 generated-testcase.cpp
 .arduino
+/bin/arduino-cli

README.md

@@ -5,7 +5,7 @@ Flexible firmware for Arduino-powered keyboards.
 
 This package contains the "core" of Kaleidoscope and a number of [example firmware "Sketches"](https://github.com/keyboardio/Kaleidoscope/tree/master/examples).
 
-If you're just getting started with the Keyboardio Model 01, the [introductory docs are here](https://github.com/keyboardio/Kaleidoscope/wiki/Keyboardio-Model-01-Introduction) and the source for the basic firmware package is here: https://github.com/keyboardio/Model01-Firmware. It's probably a good idea to start there, learn how to modify your keymap and maybe turn some modules on or off, and then come back to the full repository when you have more complex changes in mind.
+If you're just getting started with the Keyboardio Model 01, the [introductory docs are here](https://github.com/keyboardio/Kaleidoscope/wiki/Keyboardio-Model-01-Introduction) and the source for the basic firmware package is here: https://github.com/keyboardio/Model01-Firmware. It's probably a good idea to start there, learn how to modify your keymap and maybe turn some modules on or off, and then come back to the full repository when you have more complex changes in mind. (The firmware for all other devices is inside examples/Devices in this Kaleidoscope repo.)
 
 # Getting Started
 

bin/focus-send

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# focus-send - Trivial Focus testing tool
+# Copyright (C) 2018-2022  Keyboard.io, Inc.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation, version 3.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program. If not, see <http://www.gnu.org/licenses/>.
+
+set -e
+
+OS=$(uname -s)
+
+# igncr absorbs CR from Focus CRLF line endings
+# -echo is needed because raw doesn't turn it off on Linux
+STTY_ARGS="9600 raw igncr -echo"
+
+case ${OS} in
+    Linux)
+        DEVICE="${DEVICE:-/dev/ttyACM0}"
+        ;;
+    Darwin)
+        # bash on macOS has a bug that randomly drops serial input
+        if [ -n "$BASH_VERSION" ] && [ -x /bin/dash ]; then
+            # Prevent loop in case someone exported it
+            export -n BASH_VERSION
+            exec /bin/dash "$0" "$@"
+        fi
+        DEVICE="${DEVICE:-/dev/cu.usbmodemCkbio01E}"
+        ;;
+    *)
+        echo "Error Unknown OS : ${OS}" >&2
+        exit 1
+        ;;
+esac
+
+# Redirect prior to running stty, because macOS sometimes resets termios
+# state upon last close of a terminal device.
+exec < "${DEVICE}"
+# shellcheck disable=SC2086 # intentional word splitting
+stty $STTY_ARGS
+
+read_reply () {
+    while read -r line; do
+        if [ "${line}" = "." ]; then
+            break
+        fi
+        echo "${line}"
+    done
+}
+
+# Flush any invalid commands out of input buffer.
+# This could happen after a failed upload.
+echo ' ' > "${DEVICE}"
+read_reply > /dev/null
+echo "$@" >"${DEVICE}"
+read_reply

bin/focus-test

@@ -1,45 +0,0 @@
-#!/usr/bin/env bash
-# focus-test - Trivial Focus testing tool
-# Copyright (C) 2018  Keyboard.io, Inc.
-#
-# This program is free software: you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation, version 3.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program. If not, see <http://www.gnu.org/licenses/>.
-
-set -e
-
-OS=$(uname -s)
-
-case ${OS} in
-    Linux)
-        DEVICE="${DEVICE:-/dev/ttyACM0}"
-        stty -F "${DEVICE}" 9600 raw -echo
-        ;;
-    Darwin)
-        DEVICE="${DEVICE:-/dev/cu.usbmodemCkbio01E}"
-        stty -f "${DEVICE}" 9600 raw -echo
-        ;;
-    *)
-        echo "Error Unknown OS : ${OS}" >&2
-        exit 1
-        ;;
-esac
-
-
-exec 3<"${DEVICE}"
-echo "$@" >"${DEVICE}"
-
-while read -r line <&3; do
-    line="$(echo -n "${line}" | tr -d '\r')"
-    if [ "${line}" == "." ]; then
-        break
-    fi
-    echo "${line}"
-done

docs/UPGRADING.md

@@ -273,8 +273,13 @@ class FocusExampleCommand : public Plugin {
     return ::Focus.sendName(F("FocusExampleCommand"));
   }
 
-  EventHandlerResult onFocusEvent(const char *command) {
+  EventHandlerResult onFocusEvent(const char *input) {
-    if (strcmp_P(command, PSTR("example")) != 0)
+    const char *cmd = PSTR("example");
+
+    if (::Focus.inputMatchesHelp(input))
+      return ::Focus.printHelp(cmd);
+
+    if (!::Focus.inputMatchesCommand(input, cmd))
       return EventHandlerResult::OK;
 
     ::Focus.send(F("This is an example response. Hello world!"));
@@ -348,8 +353,8 @@ class ExamplePlugin : public Plugin {
  public:
   ExamplePlugin();
 
-  EventHandlerResult onFocusEvent(const char *command) {
+  EventHandlerResult onFocusEvent(const char *input) {
-    if (strcmp_P(command, PSTR("example.toggle")) != 0)
+    if (!::Focus.inputMatchesCommand(input, PSTR("example.toggle")))
       return EventHandlerResult::OK;
 
     example_toggle_ = !example_toggle_;
@@ -408,8 +413,8 @@ class ExampleOptionalCommand : public Plugin {
  public:
   ExampleOptionalCommand() {}
 
-  EventHandlerResult onFocusEvent(const char *command) {
+  EventHandlerResult onFocusEvent(const char *input) {
-    if (strcmp_P(command, PSTR("optional")) != 0)
+    if (!::Focus.inputMatchesCommand(input, PSTR("optional")))
       return EventHandlerResult::OK;
 
     ::Focus.send(Layer.getLayerState());

docs/api-reference/device-apis.md

@@ -175,7 +175,7 @@ struct KeypadProps : kaleidoscope::device::ATmega32U4KeyboardProps {
   };
 
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
-  typedef kaleidoscope::driver::bootloader::avr::Caterina BootLoader;
+  typedef kaleidoscope::driver::bootloader::avr::Caterina Bootloader;
   static constexpr const char *short_name = "imaginary-keypad";
 };
 

etc/60-kaleidoscope.rules

@@ -14,3 +14,5 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="1209", ATTRS{idProduct}=="2300", SYMLINK+="
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="1209", ATTRS{idProduct}=="2301", SYMLINK+="model01", ENV{ID_MM_DEVICE_IGNORE}:="1", ENV{ID_MM_CANDIDATE}:="0", TAG+="uaccess", TAG+="seat"
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="1209", ATTRS{idProduct}=="2302", SYMLINK+="Atreus2", ENV{ID_MM_DEVICE_IGNORE}:="1", ENV{ID_MM_CANDIDATE}:="0", TAG+="uaccess", TAG+="seat"
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="1209", ATTRS{idProduct}=="2303", SYMLINK+="Atreus2", ENV{ID_MM_DEVICE_IGNORE}:="1", ENV{ID_MM_CANDIDATE}:="0", TAG+="uaccess", TAG+="seat"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="3496", ATTRS{idProduct}=="0005", SYMLINK+="model100", ENV{ID_MM_DEVICE_IGNORE}:="1", ENV{ID_MM_CANDIDATE}:="0", TAG+="uaccess", TAG+="seat"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="3496", ATTRS{idProduct}=="0006", SYMLINK+="model100", ENV{ID_MM_DEVICE_IGNORE}:="1", ENV{ID_MM_CANDIDATE}:="0", TAG+="uaccess", TAG+="seat"

etc/makefiles/sketch.mk

@@ -164,7 +164,7 @@ endif
 compile: kaleidoscope-hardware-configured
 
 
-	$(QUIET) install -d "${OUTPUT_PATH}"
+	-$(QUIET) install -d "${OUTPUT_PATH}"
 	$(QUIET) $(ARDUINO_CLI) compile --fqbn "${FQBN}" ${ARDUINO_VERBOSE} ${ccache_wrapper_property} ${local_cflags_property} \
 	  ${_arduino_local_libraries_prop} ${_ARDUINO_CLI_COMPILE_CUSTOM_FLAGS} \
 	  --library "${KALEIDOSCOPE_DIR}" \
@@ -191,9 +191,8 @@ endif
 #TODO (arduino team) I'd love to do this with their json output
 #but it's short some of the data we kind of need
 
-flashing_instructions = $(call _arduino_prop,build.flashing_instructions)
 
-_device_port = $(shell $(ARDUINO_CLI) board list --format=text | grep $(FQBN) |cut -d' ' -f 1)
+flashing_instructions = $(call _arduino_prop,build.flashing_instructions)
 
 flash: ${HEX_FILE_PATH}
 ifneq ($(flashing_instructions),)
@@ -204,14 +203,12 @@ endif
 	$(info )
 	$(info When you're ready to proceed, press 'Enter'.)
 	$(info )
-	$(info Your FQBN is $(FQBN))
-	$(info I think the device port is: )
-	$(info '$(_device_port)')
 	@$(shell read _)
 	# If we have a device serial port available, try to trigger a Kaliedoscope reset
-ifneq ($(_device_port),) 
+	-$(QUIET) export DEVICE=$(shell $(ARDUINO_CLI) board list --format=text | grep $(FQBN) |cut -d' ' -f 1) && \
-	$(QUIET) echo "device.reset" > $(_device_port)
+		[ -e "$$DEVICE" ] && \
-endif
+		$(KALEIDOSCOPE_DIR)/bin/focus-send "device.reset" && \
+		sleep 2
 	$(QUIET) $(ARDUINO_CLI) upload --fqbn $(FQBN) \
 	$(shell $(ARDUINO_CLI) board list --format=text | grep $(FQBN) |cut -d' ' -f 1 | xargs -n 1 echo "--port" ) \
 	--input-dir "${OUTPUT_PATH}" \

examples/Devices/Keyboardio/Atreus/Atreus.ino

@@ -1,6 +1,6 @@
 /* -*- mode: c++ -*-
  * Atreus -- Chrysalis-enabled Sketch for the Keyboardio Atreus
- * Copyright (C) 2018, 2019  Keyboard.io, Inc
+ * Copyright (C) 2018-2022  Keyboard.io, Inc
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,13 +24,16 @@
 #include "Kaleidoscope.h"
 #include "Kaleidoscope-EEPROM-Settings.h"
 #include "Kaleidoscope-EEPROM-Keymap.h"
+#include "Kaleidoscope-Escape-OneShot.h"
+#include "Kaleidoscope-FirmwareVersion.h"
 #include "Kaleidoscope-FocusSerial.h"
 #include "Kaleidoscope-Macros.h"
 #include "Kaleidoscope-MouseKeys.h"
 #include "Kaleidoscope-OneShot.h"
 #include "Kaleidoscope-Qukeys.h"
 #include "Kaleidoscope-SpaceCadet.h"
-
+#include "Kaleidoscope-DynamicMacros.h"
+#include "Kaleidoscope-LayerNames.h"
 
 #define MO(n) ShiftToLayer(n)
 #define TG(n) LockLayer(n)
@@ -100,6 +103,7 @@ KEYMAPS(
 // clang-format on
 
 KALEIDOSCOPE_INIT_PLUGINS(
+  EscapeOneShot,
   EEPROMSettings,
   EEPROMKeymap,
   Focus,
@@ -109,7 +113,11 @@ KALEIDOSCOPE_INIT_PLUGINS(
   SpaceCadet,
   OneShot,
   Macros,
-  MouseKeys);
+  DynamicMacros,
+  MouseKeys,
+  EscapeOneShotConfig,
+  FirmwareVersion,
+  LayerNames);
 
 const macro_t *macroAction(uint8_t macro_id, KeyEvent &event) {
   if (keyToggledOn(event.state)) {
@@ -135,7 +143,13 @@ const macro_t *macroAction(uint8_t macro_id, KeyEvent &event) {
 void setup() {
   Kaleidoscope.setup();
   SpaceCadet.disable();
-  EEPROMKeymap.setup(10);
+  EEPROMKeymap.setup(9);
+
+  DynamicMacros.reserve_storage(48);
+
+  LayerNames.reserve_storage(63);
+
+  Layer.move(EEPROMSettings.default_layer());
 }
 
 void loop() {

examples/Devices/Keyboardio/Model01/Makefile

@@ -1,6 +1,8 @@
 # This makefile for a Kaleidoscope sketch pulls in all the targets
 # required to build the example
 
+# Compile without deprecated code to save space
+LOCAL_CFLAGS ?= -DNDEPRECATED -DONESHOT_WITHOUT_METASTICKY
 
 
 

examples/Devices/Keyboardio/Model01/Model01.ino

@@ -1,106 +1,522 @@
-/* -*- mode: c++ -*-
+// -*- mode: c++ -*-
- * Kaleidoscope - A Kaleidoscope example
+// Copyright 2016 Keyboardio, inc. <jesse@keyboard.io>
- * Copyright (C) 2016-2019  Keyboard.io, Inc.
+// See "LICENSE" for license details
- *
+
- * This program is free software: you can redistribute it and/or modify it under
+#ifndef BUILD_INFORMATION
- * the terms of the GNU General Public License as published by the Free Software
+#define BUILD_INFORMATION "locally built on " __DATE__ " at " __TIME__
- * Foundation, version 3.
+#endif
- *
+
- * This program is distributed in the hope that it will be useful, but WITHOUT
+
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+/**
- * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * These #include directives pull in the Kaleidoscope firmware core,
- * details.
+ * as well as the Kaleidoscope plugins we use in the Model 01's firmware
- *
- * You should have received a copy of the GNU General Public License along with
- * this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#define DEBUG_SERIAL false
 
+// 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 & dynamic macros
 #include "Kaleidoscope-Macros.h"
+#include "Kaleidoscope-DynamicMacros.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"
-#include "Kaleidoscope-HardwareTestMode.h"
-#include "Kaleidoscope-MagicCombo.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"
 
-#define NUMPAD_KEYMAP 2
+// Support for shared palettes for other plugins, like Colormap below
-
+#include "Kaleidoscope-LED-Palette-Theme.h"
-// clang-format off
+
-#define GENERIC_FN2  KEYMAP_STACKED ( \
+// Support for an LED mode that lets one configure per-layer color maps
-         ___,      Key_F1,        Key_F2,      Key_F3,     Key_F4,          Key_F5,          XXX,            \
+#include "Kaleidoscope-Colormap.h"
-        Key_Tab,  Key_mouseBtnM, Key_mouseUp, ___,        Key_mouseWarpNW, Key_mouseWarpNE, Consumer_ScanNextTrack, \
+
-        Key_Home, Key_mouseL,    Key_mouseDn, Key_mouseR, Key_mouseWarpSW, Key_mouseWarpSE, \
+// Support for Keyboardio's internal keyboard testing mode
-        Key_End,  Key_Z,         Key_X,       Key_C,      Key_V,           Key_mouseWarpEnd, ___,    \
+#include "Kaleidoscope-HardwareTestMode.h"
-                                                        Key_LeftControl, Key_mouseBtnL, Key_LeftGui, Key_LeftShift,                \
+
-                                                                                    ___, \
+// Support for host power management (suspend & wakeup)
-\
+#include "Kaleidoscope-HostPowerManagement.h"
-        XXX,        Key_F6,         Key_F7,            Key_F8,                   Key_F9,              ___,                   ___, \
+
-        Key_Delete, Consumer_PlaySlashPause,  Key_LeftCurlyBracket, Key_RightCurlyBracket, Key_LeftBracket, Key_RightBracket, System_Sleep, \
+// Support for magic combos (key chords that trigger an action)
-                    Key_LeftArrow,            Key_DownArrow,        Key_UpArrow,           Key_RightArrow,  Key_F11,                   Key_F12, \
+#include "Kaleidoscope-MagicCombo.h"
-        ___,        Consumer_VolumeDecrement, Consumer_VolumeIncrement,   Key_BacklightDown,   Key_BacklightUp,    Key_Backslash,      Key_Pipe, \
+
-        Key_RightShift, Key_RightAlt, Key_mouseBtnR, Key_RightControl, \
+// Support for secondary actions (one action when tapped, another when held)
-        ___\
+#include "Kaleidoscope-Qukeys.h"
-)
+
-
+// Support for USB quirks, like changing the key state report protocol
-#define NUMPAD KEYMAP  (\
+#include "Kaleidoscope-USB-Quirks.h"
-         ___, ___, ___, ___, ___, ___, ___,                           ___, ___, Key_Keypad7, Key_Keypad8,   Key_Keypad9,        Key_KeypadSubtract, ___, \
+
-        ___, ___, ___, ___, ___, ___, ___,                            ___, ___, Key_Keypad4, Key_Keypad5,   Key_Keypad6,        Key_KeypadAdd,  ___, \
+/** This 'enum' is a list of all the macros used by the Model 01's firmware
-        ___, ___, ___, ___, ___, ___,                                      ___, Key_Keypad1, Key_Keypad2,   Key_Keypad3,        Key_Equals,      Key_Quote, \
+  * The names aren't particularly important. What is important is that each
-        ___, ___, ___, ___, ___, ___, ___,                            ___, ___, Key_Keypad0, Key_KeypadDot, Key_KeypadMultiply, Key_KeypadDivide, Key_Enter, \
+  * is unique.
-       Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,    Key_RightShift, Key_RightAlt, Key_Spacebar, Key_RightControl, \
+  *
-                                 Key_Keymap1_Momentary,               Key_Keymap1_Momentary \
+  * 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`
-#define QWERTY KEYMAP ( \
+  *
-        ___,          Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext,         ___,        Key_6, Key_7, Key_8,     Key_9,      Key_0,         Key_KeypadNumLock, \
+  * The second usage is in the 'switch' statement in the `macroAction` function.
-        Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,                   Key_Enter,  Key_Y, Key_U, Key_I,     Key_O,      Key_P,         Key_Equals, \
+  * That switch statement actually runs the code associated with a macro when
-        Key_PageUp,   Key_A, Key_S, Key_D, Key_F, Key_G,                                        Key_H, Key_J, Key_K,     Key_L,      Key_Semicolon, Key_Quote, \
+  * a macro key is pressed.
-        Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape,                 ___,       Key_N, Key_M, Key_Comma, Key_Period, Key_Slash,     Key_Minus, \
+  */
-                 Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,        Key_RightShift, Key_RightAlt, Key_Spacebar, Key_RightControl, \
+
-                                              Key_KeymapNext_Momentary,         Key_KeymapNext_Momentary \
+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/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 { PRIMARY,
+       NUMPAD,
+       FUNCTION };  // layers
+
+
+/**
+  * To change your keyboard's layout from QWERTY to DVORAK or COLEMAK, comment out the line
+  *
+  * #define PRIMARY_KEYMAP_QWERTY
+  *
+  * by changing it to
+  *
+  * // #define PRIMARY_KEYMAP_QWERTY
+  *
+  * Then uncomment the line corresponding to the layout you want to use.
+  *
+  */
+
+#define PRIMARY_KEYMAP_QWERTY
+// #define PRIMARY_KEYMAP_DVORAK
+// #define PRIMARY_KEYMAP_COLEMAK
+// #define PRIMARY_KEYMAP_CUSTOM
+
+
+/* This comment temporarily turns off astyle's indent enforcement
+ *   so we can make the keymaps actually resemble the physical key layout better
+ */
+// *INDENT-OFF*
 
 KEYMAPS(
-  QWERTY,
+
-  GENERIC_FN2,
+#if defined(PRIMARY_KEYMAP_QWERTY)
-  NUMPAD
+  [PRIMARY] = KEYMAP_STACKED(___, Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext, Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab, Key_PageUp, Key_A, Key_S, Key_D, Key_F, Key_G, Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape, Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift, ShiftToLayer(FUNCTION),
-)
+
-// clang-format on
+                             M(MACRO_ANY),
-
+                             Key_6,
-static kaleidoscope::plugin::LEDSolidColor solidRed(60, 0, 0);
+                             Key_7,
-static kaleidoscope::plugin::LEDSolidColor solidOrange(60, 20, 0);
+                             Key_8,
-static kaleidoscope::plugin::LEDSolidColor solidYellow(40, 35, 0);
+                             Key_9,
-static kaleidoscope::plugin::LEDSolidColor solidGreen(0, 100, 0);
+                             Key_0,
-static kaleidoscope::plugin::LEDSolidColor solidBlue(0, 15, 100);
+                             LockLayer(NUMPAD),
-static kaleidoscope::plugin::LEDSolidColor solidIndigo(0, 0, 100);
+                             Key_Enter,
-static kaleidoscope::plugin::LEDSolidColor solidViolet(70, 0, 60);
+                             Key_Y,
+                             Key_U,
+                             Key_I,
+                             Key_O,
+                             Key_P,
+                             Key_Equals,
+                             Key_H,
+                             Key_J,
+                             Key_K,
+                             Key_L,
+                             Key_Semicolon,
+                             Key_Quote,
+                             Key_RightAlt,
+                             Key_N,
+                             Key_M,
+                             Key_Comma,
+                             Key_Period,
+                             Key_Slash,
+                             Key_Minus,
+                             Key_RightShift,
+                             Key_LeftAlt,
+                             Key_Spacebar,
+                             Key_RightControl,
+                             ShiftToLayer(FUNCTION)),
+
+#elif defined(PRIMARY_KEYMAP_DVORAK)
+
+  [PRIMARY] = 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, 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,
+                             LockLayer(NUMPAD),
+                             Key_Enter,
+                             Key_F,
+                             Key_G,
+                             Key_C,
+                             Key_R,
+                             Key_L,
+                             Key_Slash,
+                             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)),
+
+#elif defined(PRIMARY_KEYMAP_COLEMAK)
+
+  [PRIMARY] = 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,
+                             LockLayer(NUMPAD),
+                             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,
+                             Key_RightShift,
+                             Key_LeftAlt,
+                             Key_Spacebar,
+                             Key_RightControl,
+                             ShiftToLayer(FUNCTION)),
+
+#elif defined(PRIMARY_KEYMAP_CUSTOM)
+  // Edit this keymap to make a custom layout
+  [PRIMARY] = KEYMAP_STACKED(___, Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext, Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab, Key_PageUp, Key_A, Key_S, Key_D, Key_F, Key_G, 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,
+                             LockLayer(NUMPAD),
+                             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,
+                             Key_RightAlt,
+                             Key_N,
+                             Key_M,
+                             Key_Comma,
+                             Key_Period,
+                             Key_Slash,
+                             Key_Minus,
+                             Key_RightShift,
+                             Key_LeftAlt,
+                             Key_Spacebar,
+                             Key_RightControl,
+                             ShiftToLayer(FUNCTION)),
+
+#else
+
+#error "No default keymap defined. You should make sure that you have a line like '#define PRIMARY_KEYMAP_QWERTY' in your sketch"
+
+#endif
+
+
+  [NUMPAD] = KEYMAP_STACKED(___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___,
+
+                            M(MACRO_VERSION_INFO),
+                            ___,
+                            Key_7,
+                            Key_8,
+                            Key_9,
+                            Key_KeypadSubtract,
+                            ___,
+                            ___,
+                            ___,
+                            Key_4,
+                            Key_5,
+                            Key_6,
+                            Key_KeypadAdd,
+                            ___,
+                            ___,
+                            Key_1,
+                            Key_2,
+                            Key_3,
+                            Key_Equals,
+                            ___,
+                            ___,
+                            ___,
+                            Key_0,
+                            Key_Period,
+                            Key_KeypadMultiply,
+                            Key_KeypadDivide,
+                            Key_Enter,
+                            ___,
+                            ___,
+                            ___,
+                            ___,
+                            ___),
+
+  [FUNCTION] = KEYMAP_STACKED(___, Key_F1, Key_F2, Key_F3, Key_F4, Key_F5, Key_CapsLock, 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,
+                              ___,
+                              ___))  // KEYMAPS(
+
+/* 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 key_state) {
+  if (keyToggledOn(key_state)) {
+    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(KeyEvent &event) {
+  if (keyToggledOn(event.state)) {
+    event.key.setKeyCode(Key_A.getKeyCode() + (uint8_t)(millis() % 36));
+    event.key.setFlags(0);
+  }
+}
+
+
+/** 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) {
-  if (macro_id == 1 && keyToggledOn(event.state)) {
+  switch (macro_id) {
-    Kaleidoscope.serialPort().print("Keyboard.IO keyboard driver v0.00");
+
-    return MACRO(I(25),
+  case MACRO_VERSION_INFO:
-                 D(LeftShift),
+    versionInfoMacro(event.state);
-                 T(M),
+    break;
-                 U(LeftShift),
+
-                 T(O),
+  case MACRO_ANY:
-                 T(D),
+    anyKeyMacro(event);
-                 T(E),
+    break;
-                 T(L),
-                 T(Spacebar),
-                 W(100),
-                 T(0),
-                 T(1));
   }
   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::plugin::LEDSolidColor solidRed(160, 0, 0);
+static kaleidoscope::plugin::LEDSolidColor solidOrange(140, 70, 0);
+static kaleidoscope::plugin::LEDSolidColor solidYellow(130, 100, 0);
+static kaleidoscope::plugin::LEDSolidColor solidGreen(0, 160, 0);
+static kaleidoscope::plugin::LEDSolidColor solidBlue(0, 70, 130);
+static kaleidoscope::plugin::LEDSolidColor solidIndigo(0, 0, 170);
+static kaleidoscope::plugin::LEDSolidColor solidViolet(130, 0, 120);
+
+/** 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 01'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();
+}
+
 /**
  *  This enters the hardware test mode
  */
@@ -112,13 +528,62 @@ static void enterHardwareTestMode(uint8_t combo_index) {
 /** Magic combo list, a list of key combo and action pairs the firmware should
  * recognise.
  */
-USE_MAGIC_COMBOS({.action = enterHardwareTestMode,
+USE_MAGIC_COMBOS({.action = toggleKeyboardProtocol,
+                  // Left Fn + Esc + Shift
+                  .keys = {R3C6, R2C6, R3C7}},
+                 {.action = enterHardwareTestMode,
                   // Left Fn + Prog + LED
                   .keys = {R3C6, R0C0, R0C6}});
 
-KALEIDOSCOPE_INIT_PLUGINS(HardwareTestMode,
+// 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,
+
+  // 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 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,
@@ -126,21 +591,105 @@ KALEIDOSCOPE_INIT_PLUGINS(HardwareTestMode,
   solidBlue,
   solidIndigo,
   solidViolet,
+
+  // The breathe effect slowly pulses all of the LEDs on your keyboard
   LEDBreatheEffect,
-                          LEDRainbowEffect,
+
-                          LEDChaseEffect,
+  // 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 numpad plugin is responsible for lighting up the 'numpad' mode
+  // with a custom LED effect
   NumPad,
+
+  // The macros plugin adds support for macros, DynamicMacros does the same for
+  // Chrysalis-editable, dynamic ones.
   Macros,
+  DynamicMacros,
+
+  // The MouseKeys plugin lets you add keys to your keymap which move the mouse.
   MouseKeys,
-                          MagicCombo);
 
+  // Qukeys lets you add secondary actions to keys, such that they do their
+  // original action on tap, but another action (usually a modifier or a layer
+  // shift action) when held.
+  Qukeys,
+
+  // 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 FirmwareVersion plugin lets Chrysalis query the version of the firmware
+  // programmatically.
+  FirmwareVersion);
+
+/** 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();
 
-  NumPad.numPadLayer = NUMPAD_KEYMAP;
+  // 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 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);
+
+  // Set the action key the test mode should listen for to Left Fn
+  HardwareTestMode.setActionKey(R3C6);
+
+  // 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();
+
+  // To make the keymap editable without flashing new firmware, we store
+  // additional layers in EEPROM. For now, we reserve space for five 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(5);
+
+  // 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 five layers, which is how
+  // many editable layers we have (see above).
+  ColormapEffect.max_layers(5);
+
+  // For Dynamic Macros, we need to reserve storage space for the editable
+  // macros.
+  DynamicMacros.reserve_storage(128);
+
+  // If there's a default layer set in EEPROM, we should set that as the default
+  // here.
+  Layer.move(EEPROMSettings.default_layer());
 }
 
+/** 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();

examples/Devices/Keyboardio/Model100/Model100.ino

@@ -1,18 +1,12 @@
 // -*- mode: c++ -*-
-// Copyright 2016 Keyboardio, inc. <jesse@keyboard.io>
+// Copyright 2016-2022 Keyboardio, inc. <jesse@keyboard.io>
 // See "LICENSE" for license details
 
-#ifndef BUILD_INFORMATION
-#define BUILD_INFORMATION "locally built on " __DATE__ " at " __TIME__
-#endif
-
-
 /**
  * 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"
 
@@ -23,8 +17,11 @@
 // 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"
+// #include "Kaleidoscope-MouseKeys.h"
 
 // Support for macros
 #include "Kaleidoscope-Macros.h"
@@ -33,7 +30,7 @@
 #include "Kaleidoscope-LEDControl.h"
 
 // Support for "Numpad" mode, which is mostly just the Numpad specific LED mode
-#include "Kaleidoscope-NumPad.h"
+// #include "Kaleidoscope-NumPad.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)
@@ -63,6 +60,12 @@
 // 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"
 
@@ -75,6 +78,25 @@
 // 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.
@@ -105,10 +127,10 @@ enum {
   * 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/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/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/sysctl.h
-  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/kaleidoscope/key_defs_keymaps.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
@@ -144,8 +166,9 @@ enum {
 
 enum {
   PRIMARY,
-  NUMPAD,
+  // NUMPAD,
   FUNCTION,
+  ETC,
 };  // layers
 
 
@@ -162,10 +185,10 @@ enum {
   *
   */
 
-#define PRIMARY_KEYMAP_QWERTY
+// #define PRIMARY_KEYMAP_QWERTY
 // #define PRIMARY_KEYMAP_DVORAK
 // #define PRIMARY_KEYMAP_COLEMAK
-// #define PRIMARY_KEYMAP_CUSTOM
+#define PRIMARY_KEYMAP_CUSTOM
 
 
 /* This comment temporarily turns off astyle's indent enforcement
@@ -175,82 +198,37 @@ enum {
 
 KEYMAPS(
 
-#if defined (PRIMARY_KEYMAP_QWERTY)
-  [PRIMARY] = KEYMAP_STACKED
-  (___,          Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext,
-   Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,
-   Key_PageUp,   Key_A, Key_S, Key_D, Key_F, Key_G,
-   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,         LockLayer(NUMPAD),
-   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,
-   Key_RightAlt,  Key_N, Key_M, Key_Comma, Key_Period,    Key_Slash,     Key_Minus,
-   Key_RightShift, Key_LeftAlt, Key_Spacebar, Key_RightControl,
-   ShiftToLayer(FUNCTION)),
-
-#elif defined (PRIMARY_KEYMAP_DVORAK)
-
   [PRIMARY] = KEYMAP_STACKED
-  (___,          Key_1,         Key_2,     Key_3,      Key_4, Key_5, Key_LEDEffectNext,
+  (___,          ___,        ___,   ___,   ___,   ___,   Key_LEDEffectNext,
-   Key_Backtick, Key_Quote,     Key_Comma, Key_Period, Key_P, Key_Y, Key_Tab,
+   ___,          Key_Q,      Key_W, Key_D, Key_F, Key_K, Key_Tab,
-   Key_PageUp,   Key_A,         Key_O,     Key_E,      Key_U, Key_I,
+   ___,          Key_A,      Key_S, Key_E, Key_T, Key_G,
-   Key_PageDown, Key_Semicolon, Key_Q,     Key_J,      Key_K, Key_X, Key_Escape,
+   Key_Backtick, Key_Z,      Key_X, Key_C, Key_V, Key_B, LCTRL(LALT(Key_LeftGui)),
-   Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
+   GUI_T(Tab), ALT_T(Backspace), CTL_T(Escape), Key_LeftShift,
    ShiftToLayer(FUNCTION),
 
-   M(MACRO_ANY),   Key_6, Key_7, Key_8, Key_9, Key_0, LockLayer(NUMPAD),
+   M(MACRO_ANY),              ___,  Key_LeftArrow, Key_DownArrow, Key_UpArrow, Key_RightArrow, ___,
-   Key_Enter,      Key_F, Key_G, Key_C, Key_R, Key_L, Key_Slash,
+   Consumer_VolumeIncrement, Key_J, Key_U,         Key_R,         Key_L,       Key_Semicolon,  Key_Backslash,
-                   Key_D, Key_H, Key_T, Key_N, Key_S, Key_Minus,
+                             Key_Y, Key_N,         Key_I,         Key_O,       Key_H,          Key_Quote,
-   Key_RightAlt,   Key_B, Key_M, Key_W, Key_V, Key_Z, Key_Equals,
+   Consumer_VolumeDecrement, Key_P, Key_M,         Key_Comma,     Key_Period,  Key_Slash,      ___,
-   Key_RightShift, Key_LeftAlt, Key_Spacebar, Key_RightControl,
+   Key_RightShift, ALT_T(Enter), Key_Spacebar, GUI_T(Tab),
    ShiftToLayer(FUNCTION)),
 
-#elif defined (PRIMARY_KEYMAP_COLEMAK)
+  [FUNCTION] =  KEYMAP_STACKED
-
+  (___,                  Key_F1,        Key_F2,        Key_F3,                  Key_F4,                   Key_F5,                ___,
-  [PRIMARY] = KEYMAP_STACKED
+   ___,                  LSHIFT(Key_1), LSHIFT(Key_2), LSHIFT(Key_LeftBracket), LSHIFT(Key_RightBracket), LSHIFT(Key_Backslash), ___,
-  (___,          Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext,
+   LSHIFT(Key_7),        LSHIFT(Key_3), LSHIFT(Key_4), LSHIFT(Key_9),           LSHIFT(Key_0),            Key_Backslash,
-   Key_Backtick, Key_Q, Key_W, Key_F, Key_P, Key_G, Key_Tab,
+   LSHIFT(Key_Backtick), LSHIFT(Key_5), LSHIFT(Key_6), Key_LeftBracket,         Key_RightBracket,         LSHIFT(Key_8),         ___,
-   Key_PageUp,   Key_A, Key_R, Key_S, Key_T, Key_D,
+   ___, Key_Delete, ___, ___,
-   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,         LockLayer(NUMPAD),
-   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,
-   Key_RightShift, Key_LeftAlt, Key_Spacebar, Key_RightControl,
-   ShiftToLayer(FUNCTION)),
-
-#elif defined (PRIMARY_KEYMAP_CUSTOM)
-  // Edit this keymap to make a custom layout
-  [PRIMARY] = KEYMAP_STACKED
-  (___,          Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext,
-   Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,
-   Key_PageUp,   Key_A, Key_S, Key_D, Key_F, Key_G,
-   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,         LockLayer(NUMPAD),
-   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,
-   Key_RightAlt,  Key_N, Key_M, Key_Comma, Key_Period,    Key_Slash,     Key_Minus,
-   Key_RightShift, Key_LeftAlt, Key_Spacebar, Key_RightControl,
-   ShiftToLayer(FUNCTION)),
-
-#else
-
-#error "No default keymap defined. You should make sure that you have a line like '#define PRIMARY_KEYMAP_QWERTY' in your sketch"
-
-#endif
-
 
+   ___, Key_F6,            Key_F7, Key_F8, Key_F9, Key_F10,            Key_F11,
+   ___, Key_Equals,        Key_7,  Key_8,  Key_9,  LSHIFT(Key_Equals), Key_F12,
+        Key_Minus,         Key_4,  Key_5,  Key_6,  Key_Quote,          ___,
+   ___, LSHIFT(Key_Minus), Key_1,  Key_2,  Key_3,  LSHIFT(Key_Quote),  ___,
+   ___, ___, Key_Enter, Key_0,
+   ___),
 
-  [NUMPAD] =  KEYMAP_STACKED
+  [ETC] =  KEYMAP_STACKED
   (___, ___, ___, ___, ___, ___, ___,
    ___, ___, ___, ___, ___, ___, ___,
    ___, ___, ___, ___, ___, ___,
@@ -258,27 +236,13 @@ KEYMAPS(
    ___, ___, ___, ___,
    ___,
 
-   M(MACRO_VERSION_INFO),  ___, Key_7, Key_8,      Key_9,              Key_KeypadSubtract, ___,
+   ___, ___, ___,    ___,    ___,    ___,        ___,
-   ___,                    ___, Key_4, Key_5,      Key_6,              Key_KeypadAdd,      ___,
+   ___, ___, Key_F7, Key_F8, Key_F9, Key_Home,   ___,
-                           ___, Key_1, Key_2,      Key_3,              Key_Equals,         ___,
+        ___, Key_F4, Key_F5, Key_F6, Key_End,    ___,
-   ___,                    ___, Key_0, Key_Period, Key_KeypadMultiply, Key_KeypadDivide,   Key_Enter,
+   ___, ___, Key_F1, Key_F2, Key_F3, Key_Insert, ___,
    ___, ___, ___, ___,
-   ___),
-
-  [FUNCTION] =  KEYMAP_STACKED
-  (___,      Key_F1,           Key_F2,      Key_F3,     Key_F4,        Key_F5,           Key_CapsLock,
-   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, ___,
    ___)
+
 ) // KEYMAPS(
 
 /* Re-enable astyle's indent enforcement */
@@ -291,8 +255,8 @@ KEYMAPS(
 
 static void versionInfoMacro(uint8_t key_state) {
   if (keyToggledOn(key_state)) {
-    Macros.type(PSTR("Keyboardio Model 100 - Kaleidoscope "));
+    Macros.type(PSTR("Keyboardio Model 100 - Firmware version "));
-    Macros.type(PSTR(BUILD_INFORMATION));
+    Macros.type(PSTR(KALEIDOSCOPE_FIRMWARE_VERSION));
   }
 }
 
@@ -401,6 +365,17 @@ 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
  */
@@ -417,7 +392,10 @@ USE_MAGIC_COMBOS({.action = toggleKeyboardProtocol,
                   .keys = {R3C6, R2C6, R3C7}},
                  {.action = enterHardwareTestMode,
                   // Left Fn + Prog + LED
-                  .keys = {R3C6, R0C0, R0C6}});
+                  .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
@@ -428,6 +406,12 @@ KALEIDOSCOPE_INIT_PLUGINS(
   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,
@@ -495,13 +479,13 @@ KALEIDOSCOPE_INIT_PLUGINS(
 
   // The numpad plugin is responsible for lighting up the 'numpad' mode
   // with a custom LED effect
-  NumPad,
+  // NumPad,
 
   // The macros plugin adds support for macros
   Macros,
 
   // The MouseKeys plugin lets you add keys to your keymap which move the mouse.
-  MouseKeys,
+  // MouseKeys,
 
   // The HostPowerManagement plugin allows us to turn LEDs off when then host
   // goes to sleep, and resume them when it wakes up.
@@ -516,7 +500,42 @@ KALEIDOSCOPE_INIT_PLUGINS(
   // 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);
+  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
@@ -526,9 +545,13 @@ 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;
+
   // 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;
+  // NumPad.numPadLayer = NUMPAD;
 
   // We configure the AlphaSquare effect to use RED letters
   AlphaSquare.color = CRGB(255, 0, 0);
@@ -546,22 +569,41 @@ void setup() {
   // https://github.com/keyboardio/Kaleidoscope/blob/master/docs/plugins/LED-Stalker.md
   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();
-
   // To make the keymap editable without flashing new firmware, we store
-  // additional layers in EEPROM. For now, we reserve space for five layers. If
+  // 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(5);
+  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 five layers, which is how
+  // 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(5);
+  ColormapEffect.max_layers(8);
+
+  // 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();
+  // SpaceCadet.disable();
+
+  // 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.

examples/Features/CycleTimeReport/CycleTimeReport.ino

@@ -40,11 +40,20 @@ KEYMAPS(
 )
 // clang-format on
 
+// Override CycleTimeReport's reporting function:
+void kaleidoscope::plugin::CycleTimeReport::report(uint16_t mean_cycle_time) {
+  Serial.print(F("average loop time = "));
+  Serial.println(mean_cycle_time, DEC);
+}
+
 KALEIDOSCOPE_INIT_PLUGINS(CycleTimeReport);
 
 void setup() {
   Kaleidoscope.serialPort().begin(9600);
   Kaleidoscope.setup();
+
+  // Change the report interval to 2 seconds:
+  CycleTimeReport.setReportInterval(2000);
 }
 
 void loop() {

examples/Features/FocusSerial/FocusSerial.ino

@@ -44,13 +44,13 @@ class FocusTestCommand : public Plugin {
  public:
   FocusTestCommand() {}
 
-  EventHandlerResult onFocusEvent(const char *command) {
+  EventHandlerResult onFocusEvent(const char *input) {
     const char *cmd = PSTR("test");
 
-    if (::Focus.handleHelp(command, cmd))
+    if (::Focus.inputMatchesHelp(input))
-      return EventHandlerResult::OK;
+      return ::Focus.printHelp(cmd);
 
-    if (strcmp_P(command, cmd) == 0) {
+    if (::Focus.inputMatchesCommand(input, cmd)) {
       ::Focus.send(F("ok!"));
       return EventHandlerResult::EVENT_CONSUMED;
     }
@@ -63,8 +63,9 @@ class FocusHelpCommand : public Plugin {
  public:
   FocusHelpCommand() {}
 
-  EventHandlerResult onFocusEvent(const char *command) {
+  EventHandlerResult onFocusEvent(const char *input) {
-    ::Focus.handleHelp(command, PSTR("help"));
+    if (::Focus.inputMatchesHelp(input))
+      return ::Focus.printHelp(PSTR("help"));
 
     return EventHandlerResult::OK;
   }

examples/Keystrokes/LeaderPrefix/LeaderPrefix.ino

@@ -17,7 +17,7 @@
 
 #include <Kaleidoscope.h>
 #include <Kaleidoscope-Leader.h>
-#include <Kaleidoscope-Macros.h>
+#include <Kaleidoscope-MacroSupport.h>
 
 #include <Kaleidoscope-Ranges.h>
 #include "kaleidoscope/KeyEventTracker.h"
@@ -176,7 +176,7 @@ void leaderTestPrefix(uint8_t seq_index) {
   uint8_t prefix_arg = LeaderPrefix.arg();
   // Use a Macros helper function to tap the `X` key repeatedly.
   while (prefix_arg-- > 0)
-    Macros.tap(Key_X);
+    MacroSupport.tap(Key_X);
 }
 
 static const kaleidoscope::plugin::Leader::dictionary_t leader_dictionary[] PROGMEM =

examples/Keystrokes/PrefixLayer/PrefixLayer.ino

@@ -0,0 +1,69 @@
+// -*- mode: c++ -*-
+
+/* This example demonstrates the Model 01 / Model 100 butterfly logo key as a
+ * tmux prefix key. When the key is held, Ctrl-B is pressed prior to the key
+ * you pressed.
+ *
+ * This example also demonstrates the purpose of using an entire layer for this
+ * plugin: the h/j/k/l keys in the TMUX layer are swapped for arrow keys to
+ * make switching between panes easier.
+ */
+
+#include <Kaleidoscope.h>
+#include <Kaleidoscope-PrefixLayer.h>
+
+enum {
+  PRIMARY,
+  TMUX,
+};  // layers
+
+/* Used in setup() below. */
+static const kaleidoscope::plugin::PrefixLayer::Entry prefix_layers[] PROGMEM = {
+  kaleidoscope::plugin::PrefixLayer::Entry(TMUX, LCTRL(Key_B)),
+};
+
+// clang-format off
+KEYMAPS(
+  [PRIMARY] = KEYMAP_STACKED
+  (XXX,          Key_1, Key_2, Key_3, Key_4, Key_5, XXX,
+   Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,
+   Key_PageUp,   Key_A, Key_S, Key_D, Key_F, Key_G,
+   Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape,
+   Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
+   XXX,
+
+   XXX,                Key_6, Key_7, Key_8,     Key_9,      Key_0,         XXX,
+   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,
+   ShiftToLayer(TMUX), Key_N, Key_M, Key_Comma, Key_Period, Key_Slash,     Key_Minus,
+   Key_RightShift, Key_RightAlt, Key_Spacebar, Key_RightControl,
+   XXX),
+
+  [TMUX] = KEYMAP_STACKED
+  (___, ___, ___, ___, ___, ___, ___,
+   ___, ___, ___, ___, ___, ___, ___,
+   ___, ___, ___, ___, ___, ___,
+   ___, ___, ___, ___, ___, ___, ___,
+   ___, ___, ___, ___,
+   ___,
+
+   ___, ___,           ___,           ___,         ___,            ___, ___,
+   ___, ___,           ___,           ___,         ___,            ___, ___,
+        Key_LeftArrow, Key_DownArrow, Key_UpArrow, Key_RightArrow, ___, ___,
+   ___, ___,           ___,           ___,         ___,            ___, ___,
+   ___, ___, ___, ___,
+   ___),
+)
+// clang-format on
+
+KALEIDOSCOPE_INIT_PLUGINS(PrefixLayer);
+
+void setup() {
+  Kaleidoscope.setup();
+  /* Configure the previously-defined prefix layers. */
+  PrefixLayer.setPrefixLayers(prefix_layers);
+}
+
+void loop() {
+  Kaleidoscope.loop();
+}

examples/Keystrokes/PrefixLayer/sketch.json

@@ -0,0 +1,6 @@
+{
+  "cpu": {
+    "fqbn": "keyboardio:avr:model01",
+    "port": ""
+  }
+}

examples/Keystrokes/SpaceCadet/SpaceCadet.ino

@@ -59,7 +59,7 @@ void setup() {
     SPACECADET_MAP_END,
   };
   //Set the map.
-  SpaceCadet.map = spacecadetmap;
+  SpaceCadet.setMap(spacecadetmap);
 }
 
 void loop() {

examples/LEDs/Colormap/Colormap.ino

@@ -1,6 +1,6 @@
 /* -*- mode: c++ -*-
  * Kaleidoscope-EEPROM-Colormap -- Per-layer colormap effect
- * Copyright (C) 2017, 2018  Keyboard.io, Inc
+ * Copyright (C) 2017-2022  Keyboard.io, Inc
  *
  * This program is free software: you can redistribute it and/or modify it under it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -17,6 +17,7 @@
 
 #include <Kaleidoscope.h>
 #include <Kaleidoscope-EEPROM-Settings.h>
+#include <Kaleidoscope-EEPROM-Keymap.h>
 #include <Kaleidoscope-Colormap.h>
 #include <Kaleidoscope-FocusSerial.h>
 #include <Kaleidoscope-LED-Palette-Theme.h>
@@ -25,7 +26,7 @@
 // clang-format off
 KEYMAPS(
   [0] = KEYMAP_STACKED
-  (Key_LEDEffectNext, Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext,
+  (Key_NoKey,    Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext,
    Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,
    Key_PageUp,   Key_A, Key_S, Key_D, Key_F, Key_G,
    Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape,
@@ -42,17 +43,90 @@ KEYMAPS(
    Key_NoKey),
 )
 
+// 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(
+    [0] = 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)
+)
+
 // clang-format on
 
 KALEIDOSCOPE_INIT_PLUGINS(EEPROMSettings,
+                          EEPROMKeymap,
+                          LEDControl,
                           LEDPaletteTheme,
+                          LEDOff,
                           ColormapEffect,
-                          Focus);
+                          DefaultColormap,
+                          Focus,
+                          FocusEEPROMCommand,
+                          FocusSettingsCommand);
 
 void setup() {
   Kaleidoscope.setup();
+
+  EEPROMKeymap.setup(1);
+
   ColormapEffect.max_layers(1);
   ColormapEffect.activate();
+
+  DefaultColormap.setup();
 }
 
 void loop() {

examples/LEDs/LED-Palette-Theme/LED-Palette-Theme.ino

@@ -27,7 +27,7 @@ class TestLEDMode : public kaleidoscope::plugin::LEDMode {
  public:
   TestLEDMode() {}
 
-  kaleidoscope::EventHandlerResult onFocusEvent(const char *command);
+  kaleidoscope::EventHandlerResult onFocusEvent(const char *input);
 
  protected:
   void setup() final;
@@ -48,8 +48,8 @@ void TestLEDMode::update(void) {
 }
 
 kaleidoscope::EventHandlerResult
-TestLEDMode::onFocusEvent(const char *command) {
+TestLEDMode::onFocusEvent(const char *input) {
-  return LEDPaletteTheme.themeFocusEvent(command, PSTR("testLedMode.map"), map_base_, 1);
+  return LEDPaletteTheme.themeFocusEvent(input, PSTR("testLedMode.map"), map_base_, 1);
 }
 
 }  // namespace example

plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShift.cpp

@@ -29,25 +29,6 @@
 namespace kaleidoscope {
 namespace plugin {
 
-// =============================================================================
-// AutoShift static class variables
-
-// Configuration settings that can be saved to persistent storage.
-AutoShift::Settings AutoShift::settings_ = {
-  .enabled            = true,
-  .timeout            = 175,
-  .enabled_categories = AutoShift::Categories::printableKeys(),
-};
-
-// The event tracker ensures that the `onKeyswitchEvent()` handler will follow
-// the rules in order to avoid interference with other plugins and prevent
-// processing the same event more than once.
-KeyEventTracker AutoShift::event_tracker_;
-
-// If there's a delayed keypress from AutoShift, this stored event will contain
-// a valid `KeyAddr`.  The default constructor produces an event addr of
-// `KeyAddr::none()`, so the plugin will start in an inactive state.
-KeyEvent pending_event_;
 
 // =============================================================================
 // AutoShift functions

plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShift.h

@@ -134,17 +134,17 @@ class AutoShift : public Plugin {
   // Configuration functions
 
   /// Returns `true` if AutoShift is active, `false` otherwise
-  static bool enabled() {
+  bool enabled() {
     return settings_.enabled;
   }
   /// Activates the AutoShift plugin (held keys will trigger auto-shift)
-  static void enable() {
+  void enable() {
     settings_.enabled = true;
   }
   /// Deactivates the AutoShift plugin (held keys will not trigger auto-shift)
-  static void disable();
+  void disable();
   /// Turns AutoShift on if it's off, and vice versa
-  static void toggle() {
+  void toggle() {
     if (settings_.enabled) {
       disable();
     } else {
@@ -153,16 +153,16 @@ class AutoShift : public Plugin {
   }
 
   /// Returns the hold time required to trigger auto-shift (in ms)
-  static uint16_t timeout() {
+  uint16_t timeout() {
     return settings_.timeout;
   }
   /// Sets the hold time required to trigger auto-shift (in ms)
-  static void setTimeout(uint16_t new_timeout) {
+  void setTimeout(uint16_t new_timeout) {
     settings_.timeout = new_timeout;
   }
 
   /// Returns the set of categories currently eligible for auto-shift
-  static Categories enabledCategories() {
+  Categories enabledCategories() {
     return settings_.enabled_categories;
   }
   /// Adds `category` to the set eligible for auto-shift
@@ -175,19 +175,19 @@ class AutoShift : public Plugin {
   ///  - `AutoShift::Categories::functionKeys()`
   ///  - `AutoShift::Categories::printableKeys()`
   ///  - `AutoShift::Categories::allKeys()`
-  static void enable(Categories category) {
+  void enable(Categories category) {
     settings_.enabled_categories.add(category);
   }
   /// Removes a `Key` category from the set eligible for auto-shift
-  static void disable(Categories category) {
+  void disable(Categories category) {
     settings_.enabled_categories.remove(category);
   }
   /// Replaces the list of `Key` categories eligible for auto-shift
-  static void setEnabled(Categories categories) {
+  void setEnabled(Categories categories) {
     settings_.enabled_categories = categories;
   }
   /// Returns `true` if the given category is eligible for auto-shift
-  static bool isEnabled(Categories category) {
+  bool isEnabled(Categories category) {
     return settings_.enabled_categories.contains(category);
   }
 
@@ -225,7 +225,7 @@ class AutoShift : public Plugin {
   ///
   /// This function can be overridden by the user sketch to configure which keys
   /// can trigger auto-shift.
-  static bool isAutoShiftable(Key key);
+  bool isAutoShiftable(Key key);
 
   // ---------------------------------------------------------------------------
   // Event handlers
@@ -237,19 +237,19 @@ class AutoShift : public Plugin {
   /// A container for AutoShift configuration settings
   struct Settings {
     /// The overall state of the plugin (on/off)
-    bool enabled;
+    bool enabled = true;
     /// The length of time (ms) a key must be held to trigger auto-shift
-    uint16_t timeout;
+    uint16_t timeout = 175;
     /// The set of `Key` categories eligible to be auto-shifted
-    Categories enabled_categories;
+    Categories enabled_categories = AutoShift::Categories::printableKeys();
   };
-  static Settings settings_;
+  Settings settings_;
 
   // ---------------------------------------------------------------------------
   // Key event queue state variables
 
   // A device for processing only new events
-  static KeyEventTracker event_tracker_;
+  KeyEventTracker event_tracker_;
 
   // The maximum number of events in the queue at a time.
   static constexpr uint8_t queue_capacity_{4};
@@ -257,12 +257,17 @@ class AutoShift : public Plugin {
   // The event queue stores a series of press and release events.
   KeyAddrEventQueue<queue_capacity_> queue_;
 
+  // If there's a delayed keypress from AutoShift, this stored event will
+  // contain a valid `KeyAddr`.  The default constructor produces an event addr
+  // of `KeyAddr::none()`, so the plugin will start in an inactive state.
+  KeyEvent pending_event_;
+
   void flushQueue();
   void flushEvent(bool is_long_press = false);
   bool checkForRelease() const;
 
   /// The default function for `isAutoShiftable()`
-  static bool enabledForKey(Key key);
+  bool enabledForKey(Key key);
 };
 
 // =============================================================================
@@ -270,11 +275,11 @@ class AutoShift : public Plugin {
 class AutoShiftConfig : public Plugin {
  public:
   EventHandlerResult onSetup();
-  EventHandlerResult onFocusEvent(const char *command);
+  EventHandlerResult onFocusEvent(const char *input);
 
  private:
   // The base address in persistent storage for configuration data
-  static uint16_t settings_base_;
+  uint16_t settings_base_;
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShiftConfig.cpp

@@ -17,10 +17,10 @@
 
 #include "kaleidoscope/plugin/AutoShift.h"  // IWYU pragma: associated
 
-#include <Arduino.h>                       // for PSTR, strcmp_P, strncmp_P
+#include <Arduino.h>                       // for PSTR
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
-#include <stdint.h>                        // for uint16_t, uint8_t
+#include <stdint.h>                        // for uint8_t, uint16_t
 
 #include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
 #include "kaleidoscope/device/device.h"         // for VirtualProps::Storage, Base<>::Storage
@@ -32,42 +32,40 @@ namespace plugin {
 // =============================================================================
 // AutoShift configurator
 
-uint16_t AutoShiftConfig::settings_base_;
-
 EventHandlerResult AutoShiftConfig::onSetup() {
-  settings_base_ = ::EEPROMSettings.requestSlice(sizeof(AutoShift::settings_));
+  settings_base_ = ::EEPROMSettings.requestSlice(sizeof(AutoShift::Settings));
 
   if (Runtime.storage().isSliceUninitialized(
         settings_base_,
-        sizeof(AutoShift::settings_))) {
+        sizeof(AutoShift::Settings))) {
     // If our slice is uninitialized, set sensible defaults.
-    Runtime.storage().put(settings_base_, AutoShift::settings_);
+    Runtime.storage().put(settings_base_, ::AutoShift.settings_);
     Runtime.storage().commit();
   }
 
-  Runtime.storage().get(settings_base_, AutoShift::settings_);
+  Runtime.storage().get(settings_base_, ::AutoShift.settings_);
   return EventHandlerResult::OK;
 }
 
-EventHandlerResult AutoShiftConfig::onFocusEvent(const char *command) {
+EventHandlerResult AutoShiftConfig::onFocusEvent(const char *input) {
   enum {
     ENABLED,
     TIMEOUT,
     CATEGORIES,
   } subCommand;
 
-  if (::Focus.handleHelp(command, PSTR("autoshift.enabled\n"
+  const char *cmd_enabled    = PSTR("autoshift.enabled");
-                                       "autoshift.timeout\n"
+  const char *cmd_timeout    = PSTR("autoshift.timeout");
-                                       "autoshift.categories")))
+  const char *cmd_categories = PSTR("autoshift.categories");
-    return EventHandlerResult::OK;
 
-  if (strncmp_P(command, PSTR("autoshift."), 10) != 0)
+  if (::Focus.inputMatchesHelp(input))
-    return EventHandlerResult::OK;
+    return ::Focus.printHelp(cmd_enabled, cmd_timeout, cmd_categories);
-  if (strcmp_P(command + 10, PSTR("enabled")) == 0)
+
+  if (::Focus.inputMatchesCommand(input, cmd_enabled))
     subCommand = ENABLED;
-  else if (strcmp_P(command + 10, PSTR("timeout")) == 0)
+  else if (::Focus.inputMatchesCommand(input, cmd_timeout))
     subCommand = TIMEOUT;
-  else if (strcmp_P(command + 10, PSTR("categories")) == 0)
+  else if (::Focus.inputMatchesCommand(input, cmd_categories))
     subCommand = CATEGORIES;
   else
     return EventHandlerResult::OK;
@@ -112,7 +110,7 @@ EventHandlerResult AutoShiftConfig::onFocusEvent(const char *command) {
     break;
   }
 
-  Runtime.storage().put(settings_base_, AutoShift::settings_);
+  Runtime.storage().put(settings_base_, ::AutoShift.settings_);
   Runtime.storage().commit();
   return EventHandlerResult::EVENT_CONSUMED;
 }

plugins/Kaleidoscope-CharShift/src/kaleidoscope/plugin/CharShift.cpp

@@ -35,14 +35,6 @@
 namespace kaleidoscope {
 namespace plugin {
 
-// =============================================================================
-// CharShift class variables
-CharShift::KeyPair const *CharShift::progmem_keypairs_{nullptr};
-uint8_t CharShift::num_keypairs_{0};
-
-bool CharShift::reverse_shift_state_{false};
-
-
 // =============================================================================
 // Event handlers
 

plugins/Kaleidoscope-CharShift/src/kaleidoscope/plugin/CharShift.h

@@ -77,42 +77,42 @@ class CharShift : public Plugin {
   /// Generally, it will be called via the `KEYPAIRS()` preprocessor macro, not
   /// directly by user code.
   template<uint8_t _num_keypairs>
-  static void setProgmemKeyPairs(KeyPair const (&keypairs)[_num_keypairs]) {
+  void setProgmemKeyPairs(KeyPair const (&keypairs)[_num_keypairs]) {
     progmem_keypairs_ = keypairs;
     num_keypairs_     = _num_keypairs;
   }
 
  private:
   // A pointer to an array of `KeyPair` objects in PROGMEM
-  static KeyPair const *progmem_keypairs_;
+  KeyPair const *progmem_keypairs_ = nullptr;
   // The size of the PROGMEM array of `KeyPair` objects
-  static uint8_t num_keypairs_;
+  uint8_t num_keypairs_ = 0;
 
   // If a `shift` key needs to be suppressed in `beforeReportingState()`
-  static bool reverse_shift_state_;
+  bool reverse_shift_state_ = false;
 
   /// Test for keys that should be handled by CharShift
-  static bool isCharShiftKey(Key key);
+  bool isCharShiftKey(Key key);
 
   /// Look up the `KeyPair` specified by the given keymap entry
-  static KeyPair decodeCharShiftKey(Key key);
+  KeyPair decodeCharShiftKey(Key key);
 
   /// Get the total number of KeyPairs defined
   ///
   /// This function can be overridden in order to store the `KeyPair` array in
   /// EEPROM instead of PROGMEM.
-  static uint8_t numKeyPairs();
+  uint8_t numKeyPairs();
 
   /// Get the `KeyPair` at the specified index from the defined `KeyPair` array
   ///
   /// This function can be overridden in order to store the `KeyPair` array in
   /// EEPROM instead of PROGMEM.
-  static KeyPair readKeyPair(uint8_t n);
+  KeyPair readKeyPair(uint8_t n);
 
   // Default for `keypairsCount()`: size of the PROGMEM array
-  static uint8_t numProgmemKeyPairs();
+  uint8_t numProgmemKeyPairs();
   // Default for `readKeypair(i)`: fetch the value from PROGMEM
-  static KeyPair readKeyPairFromProgmem(uint8_t n);
+  KeyPair readKeyPairFromProgmem(uint8_t n);
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-Colormap/README.md

@@ -11,30 +11,60 @@ plugin, which also provides palette editing capabilities.
  [plugin:focusserial]: Kaleidoscope-FocusSerial.md
  [plugin:l-p-t]: Kaleidoscope-LED-Palette-Theme.md
 
+It is also possible to set up a default palette and colormap, using the
+`DefaultColormap` plugin, also provided by this package. See below for its
+documentation.
+
 ## Using the extension
 
 To use the extension, include the header, tell it the number of layers you have,
-register the `Focus` hooks, and it will do the rest.
+register the `Focus` hooks, and it will do the rest. We'll also set up a default
+for both the palette, and the colormap.
 
 ```c++
 #include <Kaleidoscope.h>
 #include <Kaleidoscope-EEPROM-Settings.h>
+#include <Kaleidoscope-LEDControl.h>
 #include <Kaleidoscope-Colormap.h>
 #include <Kaleidoscope-FocusSerial.h>
 #include <Kaleidoscope-LED-Palette-Theme.h>
 
 KALEIDOSCOPE_INIT_PLUGINS(EEPROMSettings,
+                          LEDControl,
                           LEDPaletteTheme,
                           ColormapEffect,
+                          DefaultColormap,
                           Focus);
 
-void setup(void) {
+PALETTE(
+ /* A list of 16 cRGB colors... */
+)
+
+COLORMAPS(
+ [0] = COLORMAP(
+  // List of palette indexes for each key, using the same layout
+  // as the `KEYMAP` macro does for keys.
+ ),
+ [1] = COLORMAP_STACKED(
+  // List of palette indexes for each key, using the same layout
+  // as the `KEYMAP_STACKED` macro does for keys.
+ )
+)
+
+void setup() {
   Kaleidoscope.setup();
 
   ColormapEffect.max_layers(1);
+  DefaultColormap.setup();
 }
 ```
 
+The `PALETTE` and `COLORMAPS` macros are only used for the `DefaultColormap`
+plugin, `ColormapEffect` itself makes no use of them. The `PALETTE` must always
+contain a full 16-color palette. `COLORMAPS` can define colormaps for as many
+layers as one wishes, but the `DefaultColormap` plugin will only copy over as
+many as `ColormapEffect` is configured to support.
+
 ## Plugin methods
 
 The extension provides an `ColormapEffect` singleton object, with a single method:
@@ -44,6 +74,19 @@ The extension provides an `ColormapEffect` singleton object, with a single metho
 > Tells the extension to reserve space in EEPROM for up to `max` layers. Can
 > only be called once, any subsequent call will be a no-op.
 
+Also provided is an optional `DefaultColormap` plugin, with two methods:
+
+### `.setup()`
+
+> Intended to be called from the `setup()` method of the sketch, it checks if
+> the `ColormapEffect` plugin is initialized, and if not, then copies the
+> palette and the colormap over from the firmware to EEPROM.
+
+### `.install()`
+
+> Same as `.setup()` above, but without the initialized check. Intended to be
+> used when one wants to restore the colormap to factory settings.
+
 ## Focus commands
 
 ### `colormap.map`
@@ -55,6 +98,14 @@ The extension provides an `ColormapEffect` singleton object, with a single metho
 > ignore anything past the last key on the last layer (as set by the
 > `.max_layers()` method).
 
+If the `DefaultColormap` plugin is also in use, an additional focus command is
+made available:
+
+### `colormap.install`
+
+> Copies the default colormap and palette built into the firmware into EEPROM,
+> effectively performing a factory reset for both.
+
 ## Dependencies
 
 * [Kaleidoscope-EEPROM-Settings](Kaleidoscope-EEPROM-Settings.md)

plugins/Kaleidoscope-Colormap/src/Kaleidoscope-Colormap.h

@@ -1,6 +1,6 @@
 /* -*- mode: c++ -*-
  * Kaleidoscope-Colormap -- Per-layer colormap effect
- * Copyright (C) 2016, 2017  Keyboard.io, Inc
+ * Copyright (C) 2016-2022  Keyboard.io, Inc
  *
  * This program is free software: you can redistribute it and/or modify it under it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -18,3 +18,4 @@
 #pragma once
 
 #include "kaleidoscope/plugin/Colormap.h"         // IWYU pragma: export
+#include "kaleidoscope/plugin/DefaultColormap.h"  // IWYU pragma: export

plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/Colormap.cpp

@@ -1,6 +1,6 @@
 /* -*- mode: c++ -*-
  * Kaleidoscope-Colormap -- Per-layer colormap effect
- * Copyright (C) 2016, 2017, 2018, 2021  Keyboard.io, Inc
+ * Copyright (C) 2016-2022  Keyboard.io, Inc
  *
  * This program is free software: you can redistribute it and/or modify it under it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -47,7 +47,18 @@ EventHandlerResult ColormapEffect::onNameQuery() {
   return ::Focus.sendName(F("ColormapEffect"));
 }
 
-void ColormapEffect::TransientLEDMode::onActivate(void) {
+bool ColormapEffect::isUninitialized() {
+  return ::LEDPaletteTheme.isThemeUninitialized(map_base_, max_layers_);
+}
+
+void ColormapEffect::updateColorIndexAtPosition(uint8_t layer, uint16_t position, uint8_t palette_index) {
+  if (layer >= max_layers_) return;
+
+  uint16_t index = Runtime.device().led_count * layer + position;
+  ::LEDPaletteTheme.updateColorIndexAtPosition(map_base_, index, palette_index);
+}
+
+void ColormapEffect::TransientLEDMode::onActivate() {
   if (!Runtime.has_leds)
     return;
 
@@ -67,8 +78,8 @@ EventHandlerResult ColormapEffect::onLayerChange() {
   return EventHandlerResult::OK;
 }
 
-EventHandlerResult ColormapEffect::onFocusEvent(const char *command) {
+EventHandlerResult ColormapEffect::onFocusEvent(const char *input) {
-  return ::LEDPaletteTheme.themeFocusEvent(command, PSTR("colormap.map"), map_base_, max_layers_);
+  return ::LEDPaletteTheme.themeFocusEvent(input, PSTR("colormap.map"), map_base_, max_layers_);
 }
 
 }  // namespace plugin

plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/Colormap.h

@@ -1,6 +1,6 @@
 /* -*- mode: c++ -*-
  * Kaleidoscope-Colormap -- Per-layer colormap effect
- * Copyright (C) 2016, 2017, 2018, 2021  Keyboard.io, Inc
+ * Copyright (C) 2016-2022  Keyboard.io, Inc
  *
  * This program is free software: you can redistribute it and/or modify it under it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -32,13 +32,14 @@ class ColormapEffect : public Plugin,
                        public LEDModeInterface,
                        public AccessTransientLEDMode {
  public:
-  ColormapEffect(void) {}
-
   void max_layers(uint8_t max_);
 
   EventHandlerResult onLayerChange();
   EventHandlerResult onNameQuery();
-  EventHandlerResult onFocusEvent(const char *command);
+  EventHandlerResult onFocusEvent(const char *input);
+
+  static bool isUninitialized();
+  static void updateColorIndexAtPosition(uint8_t layer, uint16_t position, uint8_t palette_index);
 
   // This class' instance has dynamic lifetime
   //
@@ -54,7 +55,7 @@ class ColormapEffect : public Plugin,
    protected:
     friend class ColormapEffect;
 
-    void onActivate(void) final;
+    void onActivate() final;
     void refreshAt(KeyAddr key_addr) final;
 
    private:

plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/DefaultColormap.cpp

@@ -0,0 +1,94 @@
+/* -*- mode: c++ -*-
+ * Kaleidoscope-Colormap -- Per-layer colormap effect
+ * Copyright (C) 2022  Keyboard.io, Inc
+ *
+ * This program is free software: you can redistribute it and/or modify it under it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "kaleidoscope/plugin/Colormap.h"  // for Colormap
+#include "kaleidoscope/plugin/DefaultColormap.h"
+
+#include <Arduino.h>                         // for F, PSTR, __FlashStringHelper
+#include <Kaleidoscope-FocusSerial.h>        // for Focus, FocusSerial
+#include <Kaleidoscope-LEDControl.h>         // for LEDControl
+#include <Kaleidoscope-LED-Palette-Theme.h>  // for LEDPaletteTheme
+#include <stdint.h>                          // for uint8_t, uint16_t
+
+#include "kaleidoscope/KeyAddr.h"  // for KeyAddr
+#include "kaleidoscope/Runtime.h"  // for Runtime, Runtime_
+
+namespace kaleidoscope {
+namespace plugin {
+
+namespace defaultcolormap {
+__attribute__((weak)) extern const cRGB palette[]                                                                                                = {};
+__attribute__((weak)) extern bool palette_defined                                                                                                = false;
+__attribute__((weak)) extern const uint8_t colormaps[][kaleidoscope_internal::device.matrix_rows * kaleidoscope_internal::device.matrix_columns] = {};
+__attribute__((weak)) extern uint8_t colormap_layers                                                                                             = 0;
+}  // namespace defaultcolormap
+
+void DefaultColormap::setup() {
+  // If the colormap is already initialized, return early.
+  if (!::ColormapEffect.isUninitialized())
+    return;
+
+  install();
+}
+
+void DefaultColormap::install() {
+  if (!defaultcolormap::palette_defined) return;
+
+  for (uint8_t i = 0; i < 16; i++) {
+    cRGB color;
+
+    color.r = pgm_read_byte(&(defaultcolormap::palette[i].r));
+    color.g = pgm_read_byte(&(defaultcolormap::palette[i].g));
+    color.b = pgm_read_byte(&(defaultcolormap::palette[i].b));
+
+    ::LEDPaletteTheme.updatePaletteColor(i, color);
+  }
+
+  if (defaultcolormap::colormap_layers == 0) return;
+
+  for (uint8_t layer = 0; layer < defaultcolormap::colormap_layers; layer++) {
+    for (int8_t i = 0; i < Runtime.device().numKeys(); i++) {
+      const int8_t post = Runtime.device().ledDriver().getLedIndex(i);
+      const uint8_t idx = pgm_read_byte(&(defaultcolormap::colormaps[layer][i]));
+      ::ColormapEffect.updateColorIndexAtPosition(layer, post, idx);
+    }
+  }
+  Runtime.storage().commit();
+
+  ::LEDControl.refreshAll();
+}
+
+EventHandlerResult DefaultColormap::onFocusEvent(const char *input) {
+  if (!Runtime.has_leds)
+    return EventHandlerResult::OK;
+
+  const char *cmd = PSTR("colormap.install");
+
+  if (::Focus.inputMatchesHelp(input))
+    return ::Focus.printHelp(cmd);
+
+  if (!::Focus.inputMatchesCommand(input, cmd))
+    return EventHandlerResult::OK;
+
+  install();
+  return EventHandlerResult::EVENT_CONSUMED;
+}
+
+}  // namespace plugin
+}  // namespace kaleidoscope
+
+kaleidoscope::plugin::DefaultColormap DefaultColormap;

plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/DefaultColormap.h

@@ -0,0 +1,96 @@
+/* -*- mode: c++ -*-
+ * Kaleidoscope-Colormap -- Per-layer colormap effect
+ * Copyright (C) 2022  Keyboard.io, Inc
+ *
+ * This program is free software: you can redistribute it and/or modify it under it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <Arduino.h>  // for PROGMEM
+#include <stdint.h>   // for uint8_t
+
+#include "kaleidoscope_internal/device.h"       // for device
+#include "kaleidoscope/device/device.h"         // for cRGB
+#include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
+#include "kaleidoscope/plugin.h"                // for Plugin
+
+namespace kaleidoscope {
+namespace plugin {
+
+// clang-format off
+
+#define COLORMAPS(layers...)                                            \
+  namespace kaleidoscope {                                              \
+  namespace plugin {                                                    \
+  namespace defaultcolormap {                                           \
+  const uint8_t colormaps[][kaleidoscope_internal::device.matrix_rows * kaleidoscope_internal::device.matrix_columns] PROGMEM = { \
+      layers                                                            \
+  };                                                                    \
+  uint8_t colormap_layers =                                             \
+      sizeof(colormaps) / sizeof(*colormaps);                           \
+  } /* defaultcolormap */                                               \
+  } /* plugin */                                                        \
+  } /* kaleidoscope */
+
+#define __IDENTITY__(X) X
+
+#ifdef PER_KEY_DATA_STACKED
+#define COLORMAP_STACKED(...)                                           \
+  {                                                                     \
+    MAP_LIST(__IDENTITY__, PER_KEY_DATA_STACKED(0, __VA_ARGS__))        \
+  }
+#endif
+
+#ifdef PER_KEY_DATA
+#define COLORMAP(...)                                    \
+  {                                                      \
+    MAP_LIST(__IDENTITY__, PER_KEY_DATA(0, __VA_ARGS__)) \
+  }
+#endif
+
+#define PALETTE(p0, p1, p2, p3, p4, p5, p6, p7,           \
+                p8, p9, pa, pb, pc, pd, pe, pf)           \
+  namespace kaleidoscope {                                \
+  namespace plugin {                                      \
+  namespace defaultcolormap {                             \
+    const cRGB palette[] PROGMEM = {                      \
+      p0, p1, p2, p3, p4, p5, p6, p7,                     \
+      p8, p9, pa, pb, pc, pd, pe, pf                      \
+    };                                                    \
+    bool palette_defined = true;                          \
+  } /* defaultcolormap */                                 \
+  } /* plugin */                                          \
+  } /* kaleidoscope */
+
+// clang-format on
+
+namespace defaultcolormap {
+extern bool palette_defined;
+extern const cRGB palette[];
+extern const uint8_t colormaps[][kaleidoscope_internal::device.matrix_rows * kaleidoscope_internal::device.matrix_columns];
+extern uint8_t colormap_layers;
+}  // namespace defaultcolormap
+
+class DefaultColormap : public Plugin {
+ public:
+  static void setup();
+  static void install();
+
+  EventHandlerResult onFocusEvent(const char *input);
+};
+
+}  // namespace plugin
+}  // namespace kaleidoscope
+
+extern kaleidoscope::plugin::DefaultColormap DefaultColormap;

plugins/Kaleidoscope-Cycle/README.md

@@ -34,7 +34,7 @@ void cycleAction(Key previous_key, uint8_t cycle_count) {
 
 KALEIDOSCOPE_INIT_PLUGINS(Cycle);
 
-void setup(void) {
+void setup() {
   Kaleidoscope.setup();
 }
 ```

plugins/Kaleidoscope-Cycle/src/kaleidoscope/plugin/Cycle.cpp

@@ -31,11 +31,6 @@
 
 namespace kaleidoscope {
 namespace plugin {
-// --- state ---
-Key Cycle::last_non_cycle_key_;
-KeyAddr Cycle::cycle_key_addr_{KeyAddr::invalid_state};
-uint8_t Cycle::current_modifier_flags_;
-uint8_t Cycle::cycle_count_;
 
 // --- helpers ---
 

plugins/Kaleidoscope-Cycle/src/kaleidoscope/plugin/Cycle.h

@@ -38,20 +38,18 @@ namespace kaleidoscope {
 namespace plugin {
 class Cycle : public kaleidoscope::Plugin {
  public:
-  Cycle(void) {}
+  void replace(Key key);
-
+  void replace(uint8_t cycle_size, const Key cycle_steps[]);
-  static void replace(Key key);
-  static void replace(uint8_t cycle_size, const Key cycle_steps[]);
 
   EventHandlerResult onNameQuery();
   EventHandlerResult onKeyEvent(KeyEvent &event);
 
  private:
-  static uint8_t toModFlag(uint8_t keyCode);
+  uint8_t toModFlag(uint8_t keyCode);
-  static Key last_non_cycle_key_;
+  Key last_non_cycle_key_;
-  static KeyAddr cycle_key_addr_;
+  KeyAddr cycle_key_addr_{KeyAddr::invalid_state};
-  static uint8_t cycle_count_;
+  uint8_t cycle_count_;
-  static uint8_t current_modifier_flags_;
+  uint8_t current_modifier_flags_;
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-CycleTimeReport/README.md

@@ -16,7 +16,7 @@ the box, without any further configuration:
 
 KALEIDOSCOPE_INIT_PLUGINS(CycleTimeReport);
 
-void setup (void) {
+void setup () {
   Kaleidoscope.serialPort().begin(9600);
   Kaleidoscope.setup ();
 }
@@ -25,25 +25,23 @@ void setup (void) {
 ## Plugin methods
 
 The plugin provides a single object, `CycleTimeReport`, with the following
-property. All times are in milliseconds.
+methods:
 
-### `.average_loop_time`
+### `.setReportInterval(interval)`
 
-> A read-only by contract value, the average time of main loop lengths between
+> Sets the length of time between reports to `interval` milliseconds.  The
-> two reports.
+> default is `1000`, so it will report once per second.
 
-## Overrideable methods
+### `.report(mean_cycle_time)`
 
-### `cycleTimeReport()`
+> Reports the average (mean) cycle time since the previous report.  This method
-
+> is called automatically, once per report interval (see above).  By default, it
-> Reports the average loop time. By default, it does so over `Serial`, every
+> does so over `Serial`.
-> time when the report period is up.
 >
 > It can be overridden, to change how the report looks, or to make the report
 > toggleable, among other things.
 >
-> It takes no arguments, and returns nothing, but has access to
+> It takes no arguments, and returns nothing.
-> `CycleTimeReport.average_loop_time` above.
 
 ## Further reading
 

plugins/Kaleidoscope-CycleTimeReport/src/kaleidoscope/plugin/CycleTimeReport.cpp

@@ -26,43 +26,40 @@
 
 namespace kaleidoscope {
 namespace plugin {
-uint16_t CycleTimeReport::last_report_time_;
-uint32_t CycleTimeReport::loop_start_time_;
-uint32_t CycleTimeReport::average_loop_time;
-
-EventHandlerResult CycleTimeReport::onSetup() {
-  last_report_time_ = Runtime.millisAtCycleStart();
-  return EventHandlerResult::OK;
-}
 
 EventHandlerResult CycleTimeReport::beforeEachCycle() {
-  loop_start_time_ = micros();
+  // A counter storing the number of cycles since the last mean cycle time
-  return EventHandlerResult::OK;
+  // report was sent:
-}
+  static uint16_t elapsed_cycles = 0;
-
-EventHandlerResult CycleTimeReport::afterEachCycle() {
-  uint32_t loop_time = micros() - loop_start_time_;
 
-  if (average_loop_time)
+  // We only compute the mean cycle time once per report interval.
-    average_loop_time = (average_loop_time + loop_time) / 2;
+  if (Runtime.hasTimeExpired(last_report_millis_, report_interval_)) {
-  else
+    uint32_t elapsed_time    = micros() - last_report_micros_;
-    average_loop_time = loop_time;
+    uint32_t mean_cycle_time = elapsed_time / elapsed_cycles;
 
-  if (Runtime.hasTimeExpired(last_report_time_, uint16_t(1000))) {
+    report(mean_cycle_time);
-    cycleTimeReport();
 
-    average_loop_time = 0;
+    // Reset the cycle counter and timestamps.
-    last_report_time_ = Runtime.millisAtCycleStart();
+    elapsed_cycles = 0;
+    last_report_millis_ += report_interval_;
+    last_report_micros_ = micros();
   }
 
+  // Increment the cycle counter unconditionally.
+  ++elapsed_cycles;
+
   return EventHandlerResult::OK;
 }
 
+__attribute__((weak)) void CycleTimeReport::report(uint16_t mean_cycle_time) {
+  Focus.send(Focus.COMMENT,
+             F("mean cycle time:"),
+             mean_cycle_time,
+             F("µs"),
+             Focus.NEWLINE);
+}
+
 }  // namespace plugin
 }  // namespace kaleidoscope
 
-__attribute__((weak)) void cycleTimeReport(void) {
-  Focus.send(Focus.COMMENT, F("average loop time:"), CycleTimeReport.average_loop_time, Focus.NEWLINE);
-}
-
 kaleidoscope::plugin::CycleTimeReport CycleTimeReport;

plugins/Kaleidoscope-CycleTimeReport/src/kaleidoscope/plugin/CycleTimeReport.h

@@ -17,31 +17,49 @@
 
 #pragma once
 
-#include <stdint.h>  // for uint32_t, uint16_t
+#include <stdint.h>  // for uint16_t, uint32_t
 
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
 #include "kaleidoscope/plugin.h"                // for Plugin
+// -----------------------------------------------------------------------------
+// Deprecation warning messages
+#include "kaleidoscope_internal/deprecations.h"  // for DEPRECATED
+
+#define _DEPRECATED_MESSAGE_CYCLETIMEREPORT_AVG_TIME                      \
+  "The `CycleTimeReport.average_loop_time` variable is deprecated. See\n" \
+  "the current documentation for CycleTimeReport for details.\n"          \
+  "This variable will be removed after 2022-09-01."
+// -----------------------------------------------------------------------------
 
 namespace kaleidoscope {
 namespace plugin {
 class CycleTimeReport : public kaleidoscope::Plugin {
  public:
-  CycleTimeReport() {}
-
-  EventHandlerResult onSetup();
   EventHandlerResult beforeEachCycle();
-  EventHandlerResult afterEachCycle();
 
+#ifndef NDEPRECATED
+  DEPRECATED(CYCLETIMEREPORT_AVG_TIME)
   static uint32_t average_loop_time;
+#endif
+
+  /// Set the length of time between reports (in milliseconds)
+  void setReportInterval(uint16_t interval) {
+    report_interval_ = interval;
+  }
+
+  /// Report the given mean cycle time in microseconds
+  void report(uint16_t mean_cycle_time);
 
  private:
-  static uint16_t last_report_time_;
+  // Interval between reports, in milliseconds
-  static uint32_t loop_start_time_;
+  uint16_t report_interval_ = 1000;
+
+  // Timestamps recording when the last report was sent
+  uint16_t last_report_millis_ = 0;
+  uint32_t last_report_micros_ = 0;
 };
 
 }  // namespace plugin
 }  // namespace kaleidoscope
 
-void cycleTimeReport(void);
-
 extern kaleidoscope::plugin::CycleTimeReport CycleTimeReport;

plugins/Kaleidoscope-DefaultLEDModeConfig/README.md

@@ -0,0 +1,62 @@
+# DefaultLEDModeConfig
+
+The `DefaultLEDModeConfig` plugin provides a way to set a default LED mode, the
+LED mode the device starts up with active, via Focus.
+
+By default the first LED mode enabled will be the active one, unless set
+otherwise in `setup()`. To make this configurable, without having to reorder the
+LED modes, this plugin provides the necessary tools to accomplish that.
+
+## Using the plugin
+
+The example below shows how to use the plugin, including setting up a LED mode
+other than the first to use as a default in case EEPROM is uninitialized.
+
+```c++
+#include <Kaleidoscope.h>
+#include <Kaleidoscope-EEPROM-Settings.h>
+#include <Kaleidoscope-LEDControl.h>
+#include <Kaleidoscope-DefaultLEDModeConfig.h>
+#include <Kaleidoscope-LEDEffect-Rainbow.h>
+#include <Kaleidoscope-FocusSerial.h>
+
+KALEIDOSCOPE_INIT_PLUGINS(EEPROMSettings,
+                          LEDControl,
+                          LEDOff,
+                          LEDRainbowEffect,
+                          LEDRainbowWaveEffect,
+                          Focus,
+                          DefaultLEDModeConfig);
+
+void setup() {
+  Kaleidoscope.setup();
+
+  DefaultLEDModeConfig.activateLEDModeIfUnconfigured(
+    &LEDRainbowWaveEffect
+  );
+}
+```
+
+## Plugin methods
+
+The plugin provides a singleton object called `DefaultLEDModeConfig`, with a single method:
+
+### `.activateLEDModeIfUnconfigured(&LEDModePlugin)`
+
+> Activates the LED mode pointed to by `&LEDModePlugin` if and only if the
+> EEPROM slice of the plugin is unconfigured. This lets us set a default LED
+> mode without persisting it into storage, or hard-coding it.
+
+## Focus commands
+
+### `led_mode.default`
+
+> Without arguments, prints the default LED mode's index.
+>
+> If an argument is given, it must be the index of the LED mode we wish to set
+> as the default.
+
+## Dependencies
+
+* [Kaleidoscope-EEPROM-Settings](Kaleidoscope-EEPROM-Settings.md)
+* [Kaleidoscope-FocusSerial](Kaleidoscope-FocusSerial.md)

plugins/Kaleidoscope-DefaultLEDModeConfig/library.properties

@@ -0,0 +1,7 @@
+name=Kaleidoscope-DefaultLEDModeConfig
+version=0.0.0
+sentence=Save & restore the default LED mode
+maintainer=Kaleidoscope's Developers <jesse@keyboard.io>
+url=https://github.com/keyboardio/Kaleidoscope
+author=Keyboardio
+paragraph=

plugins/Kaleidoscope-DefaultLEDModeConfig/src/Kaleidoscope-DefaultLEDModeConfig.h

@@ -0,0 +1,20 @@
+/* -*- mode: c++ -*-
+ * Kaleidoscope - Firmware for computer input devices
+ * Copyright (C) 2022  Keyboard.io, Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "kaleidoscope/plugin/DefaultLEDModeConfig.h"  // IWYU pragma: export

plugins/Kaleidoscope-DefaultLEDModeConfig/src/kaleidoscope/plugin/DefaultLEDModeConfig.cpp

@@ -0,0 +1,89 @@
+/* -*- mode: c++ -*-
+ * Kaleidoscope - Firmware for computer input devices
+ * Copyright (C) 2022  Keyboard.io, Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "kaleidoscope/plugin/DefaultLEDModeConfig.h"
+
+#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper
+#include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
+#include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
+#include <stdint.h>                        // for uint8_t, uint16_t
+
+#include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
+#include "kaleidoscope/device/device.h"         // for VirtualProps::Storage, Base<>::Storage
+#include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult, EventHandlerResult::OK
+#include "kaleidoscope/plugin/LEDControl.h"     // for LEDControl
+
+namespace kaleidoscope {
+namespace plugin {
+
+uint16_t DefaultLEDModeConfig::settings_base_;
+struct DefaultLEDModeConfig::settings DefaultLEDModeConfig::settings_;
+
+EventHandlerResult DefaultLEDModeConfig::onSetup() {
+  settings_base_ = ::EEPROMSettings.requestSlice(sizeof(settings_));
+
+  Runtime.storage().get(settings_base_, settings_);
+
+  // If our slice is uninitialized, then return early, without touching the
+  // current mode.
+  if (Runtime.storage().isSliceUninitialized(settings_base_, sizeof(settings_)))
+    return EventHandlerResult::OK;
+
+  ::LEDControl.set_mode(settings_.default_mode_index);
+
+  return EventHandlerResult::OK;
+}
+
+EventHandlerResult DefaultLEDModeConfig::onFocusEvent(const char *input) {
+  const char *cmd = PSTR("led_mode.default");
+
+  if (::Focus.inputMatchesHelp(input))
+    return ::Focus.printHelp(cmd);
+
+  if (!::Focus.inputMatchesCommand(input, cmd))
+    return EventHandlerResult::OK;
+
+  if (::Focus.isEOL()) {
+    ::Focus.send(settings_.default_mode_index);
+  } else {
+    uint8_t idx;
+    ::Focus.read(idx);
+    settings_.default_mode_index = idx;
+
+    ::LEDControl.set_mode(idx);
+    Runtime.storage().put(settings_base_, settings_);
+    Runtime.storage().commit();
+  }
+
+  return EventHandlerResult::EVENT_CONSUMED;
+}
+
+EventHandlerResult DefaultLEDModeConfig::onNameQuery() {
+  return ::Focus.sendName(F("DefaultLEDModeConfig"));
+}
+
+void DefaultLEDModeConfig::activateLEDModeIfUnconfigured(LEDModeInterface *plugin) {
+  if (!Runtime.storage().isSliceUninitialized(settings_base_, sizeof(settings_)))
+    return;
+
+  plugin->activate();
+}
+
+}  // namespace plugin
+}  // namespace kaleidoscope
+
+kaleidoscope::plugin::DefaultLEDModeConfig DefaultLEDModeConfig;

plugins/Kaleidoscope-DefaultLEDModeConfig/src/kaleidoscope/plugin/DefaultLEDModeConfig.h

@@ -0,0 +1,47 @@
+/* -*- mode: c++ -*-
+ * Kaleidoscope - Firmware for computer input devices
+ * Copyright (C) 2022  Keyboard.io, Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <stdint.h>  // for uint8_t, uint16_t
+
+#include "kaleidoscope/event_handler_result.h"     // for EventHandlerResult
+#include "kaleidoscope/plugin.h"                   // for Plugin
+#include "kaleidoscope/plugin/LEDModeInterface.h"  // for LEDModeInterface
+
+namespace kaleidoscope {
+namespace plugin {
+
+class DefaultLEDModeConfig : public kaleidoscope::Plugin {
+ public:
+  EventHandlerResult onSetup();
+  EventHandlerResult onNameQuery();
+  EventHandlerResult onFocusEvent(const char *input);
+
+  void activateLEDModeIfUnconfigured(LEDModeInterface *plugin);
+
+ private:
+  static uint16_t settings_base_;
+  static struct settings {
+    uint8_t default_mode_index;
+  } settings_;
+};
+
+}  // namespace plugin
+}  // namespace kaleidoscope
+
+extern kaleidoscope::plugin::DefaultLEDModeConfig DefaultLEDModeConfig;

plugins/Kaleidoscope-Devel-ArduinoTrace/README.md

@@ -15,7 +15,7 @@ the box, without any further configuration:
 
 /* ... */
 
-void setup (void) {
+void setup () {
   Kaleidoscope.setup ();
   TRACE()
 }

plugins/Kaleidoscope-DynamicMacros/README.md

@@ -19,9 +19,9 @@ except the amount of storage available on the keyboard.
 
 ## Using the plugin
 
-To use the plugin, we need to include the header, tell the firmware to `use` the
+To use the plugin, we need to include the header, initialize the plugin with
-plugin, and reserve storage space for the macros. This is best illustrated with
+`KALEIDOSCOPE_INIT_PLUGINS()`, and reserve storage space for the macros. This is
-an example:
+best illustrated with an example:
 
 ```c++
 #include <Kaleidoscope.h>
@@ -96,5 +96,6 @@ The plugin provides two Focus commands: `macros.map` and `macros.trigger`.
 
 ## Dependencies
 
+* [Kaleidoscope-MacroSupport](Kaleidoscope-MacroSupport.md)
 * [Kaleidoscope-EEPROM-Settings](Kaleidoscope-EEPROM-Settings.md)
 * [Kaleidoscope-FocusSerial](Kaleidoscope-FocusSerial.md)

plugins/Kaleidoscope-DynamicMacros/src/kaleidoscope/plugin/DynamicMacros.cpp

@@ -16,15 +16,14 @@
 
 #include "kaleidoscope/plugin/DynamicMacros.h"
 
-#include <Arduino.h>                   // for delay, PSTR, strcmp_P, F, __FlashStri...
+#include <Arduino.h>                   // for delay, PSTR, F, __FlashStri...
 #include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
 #include <Kaleidoscope-Ranges.h>       // for DYNAMIC_MACRO_FIRST, DYNAMIC_MACRO_LAST
 
-#include "kaleidoscope/KeyAddr.h"                 // for KeyAddr
 #include "kaleidoscope/KeyEvent.h"                // for KeyEvent
 #include "kaleidoscope/Runtime.h"                 // for Runtime, Runtime_
 #include "kaleidoscope/device/device.h"           // for VirtualProps::Storage, Base<>::Storage
-#include "kaleidoscope/keyswitch_state.h"         // for INJECTED, IS_PRESSED, WAS_PRESSED
+#include "kaleidoscope/keyswitch_state.h"         // for keyToggledOn
 #include "kaleidoscope/plugin/EEPROM-Settings.h"  // for EEPROMSettings
 // This is a special exception to the rule of only including a plugin's
 // top-level header file, because DynamicMacros doesn't depend on the Macros
@@ -34,38 +33,7 @@
 namespace kaleidoscope {
 namespace plugin {
 
-uint16_t DynamicMacros::storage_base_;
-uint16_t DynamicMacros::storage_size_;
-uint16_t DynamicMacros::map_[];
-uint8_t DynamicMacros::macro_count_;
-Key DynamicMacros::active_macro_keys_[];
-
 // =============================================================================
-// It might be possible to use Macros instead of reproducing it
-void DynamicMacros::press(Key key) {
-  Runtime.handleKeyEvent(KeyEvent(KeyAddr::none(), IS_PRESSED | INJECTED, key));
-  for (Key &mkey : active_macro_keys_) {
-    if (mkey == Key_NoKey) {
-      mkey = key;
-      break;
-    }
-  }
-}
-
-void DynamicMacros::release(Key key) {
-  for (Key &mkey : active_macro_keys_) {
-    if (mkey == key) {
-      mkey = Key_NoKey;
-    }
-  }
-  Runtime.handleKeyEvent(KeyEvent(KeyAddr::none(), WAS_PRESSED | INJECTED, key));
-}
-
-void DynamicMacros::tap(Key key) {
-  Runtime.handleKeyEvent(KeyEvent(KeyAddr::none(), IS_PRESSED | INJECTED, key));
-  Runtime.handleKeyEvent(KeyEvent(KeyAddr::none(), WAS_PRESSED | INJECTED, key));
-}
-
 uint8_t DynamicMacros::updateDynamicMacroCache() {
   uint16_t pos       = storage_base_;
   uint8_t current_id = 0;
@@ -228,6 +196,7 @@ bool isDynamicMacrosKey(Key key) {
 
 // -----------------------------------------------------------------------------
 EventHandlerResult DynamicMacros::onKeyEvent(KeyEvent &event) {
+  // Ignore everything except DynamicMacros keys
   if (!isDynamicMacrosKey(event.key))
     return EventHandlerResult::OK;
 
@@ -235,37 +204,24 @@ EventHandlerResult DynamicMacros::onKeyEvent(KeyEvent &event) {
     uint8_t macro_id = event.key.getRaw() - ranges::DYNAMIC_MACRO_FIRST;
     play(macro_id);
   } else {
-    for (Key key : active_macro_keys_) {
+    clear();
-      release(key);
-    }
   }
 
   return EventHandlerResult::EVENT_CONSUMED;
 }
 
-EventHandlerResult DynamicMacros::beforeReportingState(const KeyEvent &event) {
-  // Here we add keycodes to the HID report for keys held in a macro sequence.
-  // This is necessary because Kaleidoscope doesn't know about the supplemental
-  // `active_macro_keys_[]` array.
-  for (Key key : active_macro_keys_) {
-    if (key != Key_NoKey)
-      Runtime.addToReport(key);
-  }
-  return EventHandlerResult::OK;
-}
-
 EventHandlerResult DynamicMacros::onNameQuery() {
   return ::Focus.sendName(F("DynamicMacros"));
 }
 
-EventHandlerResult DynamicMacros::onFocusEvent(const char *command) {
+EventHandlerResult DynamicMacros::onFocusEvent(const char *input) {
-  if (::Focus.handleHelp(command, PSTR("macros.map\nmacros.trigger")))
+  const char *cmd_map     = PSTR("macros.map");
-    return EventHandlerResult::OK;
+  const char *cmd_trigger = PSTR("macros.trigger");
 
-  if (strncmp_P(command, PSTR("macros."), 7) != 0)
+  if (::Focus.inputMatchesHelp(input))
-    return EventHandlerResult::OK;
+    return ::Focus.printHelp(cmd_map, cmd_trigger);
 
-  if (strcmp_P(command + 7, PSTR("map")) == 0) {
+  if (::Focus.inputMatchesCommand(input, cmd_map)) {
     if (::Focus.isEOL()) {
       for (uint16_t i = 0; i < storage_size_; i++) {
         uint8_t b;
@@ -284,17 +240,18 @@ EventHandlerResult DynamicMacros::onFocusEvent(const char *command) {
       Runtime.storage().commit();
       macro_count_ = updateDynamicMacroCache();
     }
-  }
+    return EventHandlerResult::EVENT_CONSUMED;
-
+  } else if (::Focus.inputMatchesCommand(input, cmd_trigger)) {
-  if (strcmp_P(command + 7, PSTR("trigger")) == 0) {
     uint8_t id = 0;
     ::Focus.read(id);
     play(id);
-  }
 
     return EventHandlerResult::EVENT_CONSUMED;
   }
 
+  return EventHandlerResult::OK;
+}
+
 // public
 void DynamicMacros::reserve_storage(uint16_t size) {
   storage_base_ = ::EEPROMSettings.requestSlice(size);

plugins/Kaleidoscope-DynamicMacros/src/kaleidoscope/plugin/DynamicMacros.h

@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <Kaleidoscope-MacroSupport.h>  // for MacroSupport
 #include <Kaleidoscope-Ranges.h>        // for DYNAMIC_MACRO_FIRST
 #include <stdint.h>                     // for uint16_t, uint8_t
 
@@ -26,8 +27,6 @@
 
 #define DM(n) ::kaleidoscope::plugin::DynamicMacrosKey(n)
 
-#define MAX_CONCURRENT_DYNAMIC_MACRO_KEYS 8
-
 namespace kaleidoscope {
 namespace plugin {
 
@@ -39,23 +38,26 @@ class DynamicMacros : public kaleidoscope::Plugin {
  public:
   EventHandlerResult onNameQuery();
   EventHandlerResult onKeyEvent(KeyEvent &event);
-  EventHandlerResult beforeReportingState(const KeyEvent &event);
+  EventHandlerResult onFocusEvent(const char *input);
-  EventHandlerResult onFocusEvent(const char *command);
+  EventHandlerResult beforeReportingState(const KeyEvent &event) {
+    return ::MacroSupport.beforeReportingState(event);
+  }
 
-  static void reserve_storage(uint16_t size);
+  void reserve_storage(uint16_t size);
 
   void play(uint8_t seq_id);
 
  private:
-  static uint16_t storage_base_;
+  uint16_t storage_base_;
-  static uint16_t storage_size_;
+  uint16_t storage_size_;
-  static uint16_t map_[32];
+  uint16_t map_[32];
-  static uint8_t macro_count_;
+  uint8_t macro_count_;
-  static uint8_t updateDynamicMacroCache();
+  uint8_t updateDynamicMacroCache();
-  static Key active_macro_keys_[MAX_CONCURRENT_DYNAMIC_MACRO_KEYS];
+
-  static void press(Key key);
+  inline void press(Key key) { ::MacroSupport.press(key); }
-  static void release(Key key);
+  inline void release(Key key) { ::MacroSupport.release(key); }
-  static void tap(Key key);
+  inline void tap(Key key) const { ::MacroSupport.tap(key); }
+  inline void clear() { ::MacroSupport.clear(); }
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-DynamicTapDance/src/kaleidoscope/plugin/DynamicTapDance.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/DynamicTapDance.h"
 
-#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper, strcmp_P
+#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
 #include <stdint.h>                        // for uint16_t, uint8_t
@@ -34,13 +34,6 @@
 namespace kaleidoscope {
 namespace plugin {
 
-uint16_t DynamicTapDance::storage_base_;
-uint16_t DynamicTapDance::storage_size_;
-uint16_t DynamicTapDance::map_[];
-uint8_t DynamicTapDance::offset_;
-uint8_t DynamicTapDance::dance_count_;
-constexpr uint8_t DynamicTapDance::reserved_tap_dance_key_count_;
-
 void DynamicTapDance::updateDynamicTapDanceCache() {
   uint16_t pos              = storage_base_;
   uint8_t current_id        = 0;
@@ -100,14 +93,15 @@ EventHandlerResult DynamicTapDance::onNameQuery() {
   return ::Focus.sendName(F("DynamicTapDance"));
 }
 
-EventHandlerResult DynamicTapDance::onFocusEvent(const char *command) {
+EventHandlerResult DynamicTapDance::onFocusEvent(const char *input) {
-  if (::Focus.handleHelp(command, PSTR("tapdance.map")))
+  const char *cmd_map = PSTR("tapdance.map");
-    return EventHandlerResult::OK;
 
-  if (strncmp_P(command, PSTR("tapdance."), 9) != 0)
+  if (::Focus.inputMatchesHelp(input))
+    return ::Focus.printHelp(cmd_map);
+
+  if (!::Focus.inputMatchesCommand(input, cmd_map))
     return EventHandlerResult::OK;
 
-  if (strcmp_P(command + 9, PSTR("map")) == 0) {
   if (::Focus.isEOL()) {
     for (uint16_t i = 0; i < storage_size_; i += 2) {
       Key k;
@@ -127,7 +121,6 @@ EventHandlerResult DynamicTapDance::onFocusEvent(const char *command) {
     Runtime.storage().commit();
     updateDynamicTapDanceCache();
   }
-  }
 
   return EventHandlerResult::EVENT_CONSUMED;
 }

plugins/Kaleidoscope-DynamicTapDance/src/kaleidoscope/plugin/DynamicTapDance.h

@@ -30,23 +30,21 @@ namespace plugin {
 
 class DynamicTapDance : public kaleidoscope::Plugin {
  public:
-  DynamicTapDance() {}
-
   EventHandlerResult onNameQuery();
-  EventHandlerResult onFocusEvent(const char *command);
+  EventHandlerResult onFocusEvent(const char *input);
 
-  static void setup(uint8_t dynamic_offset, uint16_t size);
+  void setup(uint8_t dynamic_offset, uint16_t size);
 
-  static bool dance(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count, TapDance::ActionType tap_dance_action);
+  bool dance(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count, TapDance::ActionType tap_dance_action);
 
  private:
-  static uint16_t storage_base_;
+  uint16_t storage_base_;
-  static uint16_t storage_size_;
+  uint16_t storage_size_;
   static constexpr uint8_t reserved_tap_dance_key_count_ = ranges::TD_LAST - ranges::TD_FIRST + 1;
-  static uint16_t map_[reserved_tap_dance_key_count_];
+  uint16_t map_[reserved_tap_dance_key_count_];  // NOLINT(runtime/arrays)
-  static uint8_t dance_count_;
+  uint8_t dance_count_;
-  static uint8_t offset_;
+  uint8_t offset_;
-  static void updateDynamicTapDanceCache();
+  void updateDynamicTapDanceCache();
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-EEPROM-Keymap-Programmer/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/EEPROM-Keymap-Programmer.h"
 
-#include <Arduino.h>                     // for PSTR, strcmp_P
+#include <Arduino.h>                     // for PSTR
 #include <Kaleidoscope-EEPROM-Keymap.h>  // for EEPROMKeymap
 #include <Kaleidoscope-FocusSerial.h>    // for Focus, FocusSerial
 #include <stdint.h>                      // for uint16_t, uint8_t
@@ -33,12 +33,8 @@
 
 namespace kaleidoscope {
 namespace plugin {
-uint16_t EEPROMKeymapProgrammer::update_position_;
-EEPROMKeymapProgrammer::state_t EEPROMKeymapProgrammer::state_;
-EEPROMKeymapProgrammer::mode_t EEPROMKeymapProgrammer::mode;
-Key EEPROMKeymapProgrammer::new_key_;
 
-void EEPROMKeymapProgrammer::nextState(void) {
+void EEPROMKeymapProgrammer::nextState() {
   switch (state_) {
   case INACTIVE:
     state_ = WAIT_FOR_KEY;
@@ -58,7 +54,7 @@ void EEPROMKeymapProgrammer::nextState(void) {
   }
 }
 
-void EEPROMKeymapProgrammer::cancel(void) {
+void EEPROMKeymapProgrammer::cancel() {
   update_position_ = 0;
   new_key_         = Key_NoKey;
   state_           = INACTIVE;
@@ -110,13 +106,13 @@ EventHandlerResult EEPROMKeymapProgrammer::onKeyEvent(KeyEvent &event) {
   return EventHandlerResult::EVENT_CONSUMED;
 }
 
-EventHandlerResult EEPROMKeymapProgrammer::onFocusEvent(const char *command) {
+EventHandlerResult EEPROMKeymapProgrammer::onFocusEvent(const char *input) {
   const char *cmd = PSTR("keymap.toggleProgrammer");
 
-  if (::Focus.handleHelp(command, cmd))
+  if (::Focus.inputMatchesHelp(input))
-    return EventHandlerResult::OK;
+    return ::Focus.printHelp(cmd);
 
-  if (strcmp_P(command, cmd) != 0)
+  if (!::Focus.inputMatchesCommand(input, cmd))
     return EventHandlerResult::OK;
 
   if (state_ == INACTIVE)

plugins/Kaleidoscope-EEPROM-Keymap-Programmer/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.h

@@ -32,18 +32,16 @@ class EEPROMKeymapProgrammer : public kaleidoscope::Plugin {
     CODE,
     COPY,
   } mode_t;
-  static mode_t mode;
+  mode_t mode;
 
-  EEPROMKeymapProgrammer(void) {}
+  void activate() {
-
-  static void activate(void) {
     nextState();
   }
-  static void nextState(void);
+  void nextState();
-  static void cancel(void);
+  void cancel();
 
   EventHandlerResult onKeyEvent(KeyEvent &event);
-  EventHandlerResult onFocusEvent(const char *command);
+  EventHandlerResult onFocusEvent(const char *input);
 
  private:
   typedef enum {
@@ -52,10 +50,10 @@ class EEPROMKeymapProgrammer : public kaleidoscope::Plugin {
     WAIT_FOR_CODE,
     WAIT_FOR_SOURCE_KEY,
   } state_t;
-  static state_t state_;
+  state_t state_;
 
-  static uint16_t update_position_;  // layer, row, col
+  uint16_t update_position_;  // layer, row, col
-  static Key new_key_;
+  Key new_key_;
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-EEPROM-Keymap/src/kaleidoscope/plugin/EEPROM-Keymap.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/EEPROM-Keymap.h"
 
-#include <Arduino.h>                       // for PSTR, strcmp_P, F, __FlashStringHelper
+#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
 #include <stdint.h>                        // for uint8_t, uint16_t
@@ -82,7 +82,7 @@ Key EEPROMKeymap::getKeyExtended(uint8_t layer, KeyAddr key_addr) {
   return getKey(layer - progmem_layers_, key_addr);
 }
 
-uint16_t EEPROMKeymap::keymap_base(void) {
+uint16_t EEPROMKeymap::keymap_base() {
   return keymap_base_;
 }
 
@@ -101,14 +101,15 @@ void EEPROMKeymap::dumpKeymap(uint8_t layers, Key (*getkey)(uint8_t, KeyAddr)) {
   }
 }
 
-EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) {
+EventHandlerResult EEPROMKeymap::onFocusEvent(const char *input) {
-  if (::Focus.handleHelp(command, PSTR("keymap.custom\nkeymap.default\nkeymap.onlyCustom")))
+  const char *cmd_custom     = PSTR("keymap.custom");
-    return EventHandlerResult::OK;
+  const char *cmd_default    = PSTR("keymap.default");
+  const char *cmd_onlyCustom = PSTR("keymap.onlyCustom");
 
-  if (strncmp_P(command, PSTR("keymap."), 7) != 0)
+  if (::Focus.inputMatchesHelp(input))
-    return EventHandlerResult::OK;
+    return ::Focus.printHelp(cmd_custom, cmd_default, cmd_onlyCustom);
 
-  if (strcmp_P(command + 7, PSTR("onlyCustom")) == 0) {
+  if (::Focus.inputMatchesCommand(input, cmd_onlyCustom)) {
     if (::Focus.isEOL()) {
       ::Focus.send((uint8_t)::EEPROMSettings.ignoreHardcodedLayers());
     } else {
@@ -128,7 +129,7 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) {
     return EventHandlerResult::EVENT_CONSUMED;
   }
 
-  if (strcmp_P(command + 7, PSTR("default")) == 0) {
+  if (::Focus.inputMatchesCommand(input, cmd_default)) {
     // By using a cast to the appropriate function type,
     // tell the compiler which overload of getKeyFromPROGMEM
     // we actully want.
@@ -138,7 +139,7 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) {
     return EventHandlerResult::EVENT_CONSUMED;
   }
 
-  if (strcmp_P(command + 7, PSTR("custom")) != 0)
+  if (!::Focus.inputMatchesCommand(input, cmd_custom))
     return EventHandlerResult::OK;
 
   if (::Focus.isEOL()) {

plugins/Kaleidoscope-EEPROM-Keymap/src/kaleidoscope/plugin/EEPROM-Keymap.h

@@ -33,17 +33,15 @@ class EEPROMKeymap : public kaleidoscope::Plugin {
     EXTEND
   };
 
-  EEPROMKeymap(void) {}
-
   EventHandlerResult onSetup();
   EventHandlerResult onNameQuery();
-  EventHandlerResult onFocusEvent(const char *command);
+  EventHandlerResult onFocusEvent(const char *input);
 
   static void setup(uint8_t max);
 
   static void max_layers(uint8_t max);
 
-  static uint16_t keymap_base(void);
+  static uint16_t keymap_base();
 
   static Key getKey(uint8_t layer, KeyAddr key_addr);
   static Key getKeyExtended(uint8_t layer, KeyAddr key_addr);
@@ -55,7 +53,7 @@ class EEPROMKeymap : public kaleidoscope::Plugin {
   static uint8_t max_layers_;
   static uint8_t progmem_layers_;
 
-  static Key parseKey(void);
+  static Key parseKey();
   static void printKey(Key key);
   static void dumpKeymap(uint8_t layers, Key (*getkey)(uint8_t, KeyAddr));
 };

plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/EEPROM-Settings.h"
 
-#include <Arduino.h>                   // for PSTR, strcmp_P, F, __FlashStringHelper
+#include <Arduino.h>                   // for PSTR, F, __FlashStringHelper
 #include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
 #include <stdint.h>                    // for uint16_t, uint8_t
 
@@ -30,11 +30,6 @@
 namespace kaleidoscope {
 namespace plugin {
 
-struct EEPROMSettings::settings EEPROMSettings::settings_;
-bool EEPROMSettings::is_valid_;
-bool EEPROMSettings::sealed_;
-uint16_t EEPROMSettings::next_start_ = sizeof(EEPROMSettings::settings);
-
 EventHandlerResult EEPROMSettings::onSetup() {
   Runtime.storage().get(0, settings_);
 
@@ -70,11 +65,11 @@ EventHandlerResult EEPROMSettings::beforeEachCycle() {
   return EventHandlerResult::OK;
 }
 
-bool EEPROMSettings::isValid(void) {
+bool EEPROMSettings::isValid() {
   return is_valid_;
 }
 
-uint16_t EEPROMSettings::crc(void) {
+uint16_t EEPROMSettings::crc() {
   if (sealed_)
     return settings_.crc;
   return 0;
@@ -105,7 +100,7 @@ void EEPROMSettings::ignoreHardcodedLayers(bool value) {
   update();
 }
 
-void EEPROMSettings::seal(void) {
+void EEPROMSettings::seal() {
   sealed_ = true;
 
   CRCCalculator.finalize();
@@ -146,22 +141,22 @@ uint16_t EEPROMSettings::requestSlice(uint16_t size) {
   return start;
 }
 
-void EEPROMSettings::invalidate(void) {
+void EEPROMSettings::invalidate() {
   is_valid_ = false;
 }
 
-uint16_t EEPROMSettings::used(void) {
+uint16_t EEPROMSettings::used() {
   return next_start_;
 }
 
-void EEPROMSettings::update(void) {
+void EEPROMSettings::update() {
   Runtime.storage().put(0, settings_);
   Runtime.storage().commit();
   is_valid_ = true;
 }
 
 /** Focus **/
-EventHandlerResult FocusSettingsCommand::onFocusEvent(const char *command) {
+EventHandlerResult FocusSettingsCommand::onFocusEvent(const char *input) {
   enum {
     DEFAULT_LAYER,
     IS_VALID,
@@ -169,19 +164,21 @@ EventHandlerResult FocusSettingsCommand::onFocusEvent(const char *command) {
     GET_CRC,
   } sub_command;
 
-  if (::Focus.handleHelp(command, PSTR("settings.defaultLayer\nsettings.valid?\nsettings.version\nsettings.crc")))
+  const char *cmd_defaultLayer = PSTR("settings.defaultLayer");
-    return EventHandlerResult::OK;
+  const char *cmd_isValid      = PSTR("settings.valid?");
+  const char *cmd_version      = PSTR("settings.version");
+  const char *cmd_crc          = PSTR("settings.crc");
 
-  if (strncmp_P(command, PSTR("settings."), 9) != 0)
+  if (::Focus.inputMatchesHelp(input))
-    return EventHandlerResult::OK;
+    return ::Focus.printHelp(cmd_defaultLayer, cmd_isValid, cmd_version, cmd_crc);
 
-  if (strcmp_P(command + 9, PSTR("defaultLayer")) == 0)
+  if (::Focus.inputMatchesCommand(input, cmd_defaultLayer))
     sub_command = DEFAULT_LAYER;
-  else if (strcmp_P(command + 9, PSTR("valid?")) == 0)
+  else if (::Focus.inputMatchesCommand(input, cmd_isValid))
     sub_command = IS_VALID;
-  else if (strcmp_P(command + 9, PSTR("version")) == 0)
+  else if (::Focus.inputMatchesCommand(input, cmd_version))
     sub_command = GET_VERSION;
-  else if (strcmp_P(command + 9, PSTR("crc")) == 0)
+  else if (::Focus.inputMatchesCommand(input, cmd_crc))
     sub_command = GET_CRC;
   else
     return EventHandlerResult::OK;
@@ -211,21 +208,25 @@ EventHandlerResult FocusSettingsCommand::onFocusEvent(const char *command) {
   return EventHandlerResult::EVENT_CONSUMED;
 }
 
-EventHandlerResult FocusEEPROMCommand::onFocusEvent(const char *command) {
+EventHandlerResult FocusEEPROMCommand::onFocusEvent(const char *input) {
   enum {
     CONTENTS,
     FREE,
     ERASE,
   } sub_command;
 
-  if (::Focus.handleHelp(command, PSTR("eeprom.contents\neeprom.free\neeprom.erase")))
+  const char *cmd_contents = PSTR("eeprom.contents");
-    return EventHandlerResult::OK;
+  const char *cmd_free     = PSTR("eeprom.free");
+  const char *cmd_erase    = PSTR("eeprom.erase");
+
+  if (::Focus.inputMatchesHelp(input))
+    return ::Focus.printHelp(cmd_contents, cmd_free, cmd_erase);
 
-  if (strcmp_P(command, PSTR("eeprom.contents")) == 0)
+  if (::Focus.inputMatchesCommand(input, cmd_contents))
     sub_command = CONTENTS;
-  else if (strcmp_P(command, PSTR("eeprom.free")) == 0)
+  else if (::Focus.inputMatchesCommand(input, cmd_free))
     sub_command = FREE;
-  else if (strcmp_P(command, PSTR("eeprom.erase")) == 0)
+  else if (::Focus.inputMatchesCommand(input, cmd_erase))
     sub_command = ERASE;
   else
     return EventHandlerResult::OK;

plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings.h

@@ -24,10 +24,17 @@
 
 namespace kaleidoscope {
 namespace plugin {
+
 class EEPROMSettings : public kaleidoscope::Plugin {
- public:
+ private:
-  EEPROMSettings(void) {}
+  struct Settings {
+    uint8_t default_layer : 7;
+    bool ignore_hardcoded_layers : 1;
+    uint8_t version;
+    uint16_t crc;
+  };
 
+ public:
   EventHandlerResult onSetup();
   EventHandlerResult beforeEachCycle();
 
@@ -46,53 +53,45 @@ class EEPROMSettings : public kaleidoscope::Plugin {
    * fall back to not using it. */
   static constexpr uint8_t VERSION_CURRENT = 0x01;
 
-  static void update(void);
+  void update();
-  static bool isValid(void);
+  bool isValid();
-  static void invalidate(void);
+  void invalidate();
-  static uint8_t version(void) {
+  uint8_t version() {
     return settings_.version;
   }
 
-  static uint16_t requestSlice(uint16_t size);
+  uint16_t requestSlice(uint16_t size);
-  static void seal(void);
+  void seal();
-  static uint16_t crc(void);
+  uint16_t crc();
-  static uint16_t used(void);
+  uint16_t used();
 
-  static uint8_t default_layer(uint8_t layer);
+  uint8_t default_layer(uint8_t layer);
-  static uint8_t default_layer() {
+  uint8_t default_layer() {
     return settings_.default_layer;
   }
-  static void ignoreHardcodedLayers(bool value);
+  void ignoreHardcodedLayers(bool value);
-  static bool ignoreHardcodedLayers() {
+  bool ignoreHardcodedLayers() {
     return settings_.ignore_hardcoded_layers;
   }
 
  private:
   static constexpr uint8_t IGNORE_HARDCODED_LAYER = 0x7e;
-  static uint16_t next_start_;
-  static bool is_valid_;
-  static bool sealed_;
 
-  static struct settings {
+  uint16_t next_start_ = sizeof(EEPROMSettings::Settings);
-    uint8_t default_layer : 7;
+  bool is_valid_;
-    bool ignore_hardcoded_layers : 1;
+  bool sealed_;
-    uint8_t version;
+
-    uint16_t crc;
+  Settings settings_;
-  } settings_;
 };
 
 class FocusSettingsCommand : public kaleidoscope::Plugin {
  public:
-  FocusSettingsCommand() {}
+  EventHandlerResult onFocusEvent(const char *input);
-
-  EventHandlerResult onFocusEvent(const char *command);
 };
 
 class FocusEEPROMCommand : public kaleidoscope::Plugin {
  public:
-  FocusEEPROMCommand() {}
+  EventHandlerResult onFocusEvent(const char *input);
-
-  EventHandlerResult onFocusEvent(const char *command);
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings/crc.h

@@ -34,10 +34,8 @@ class CRC_ {
  public:
   uint16_t crc = 0;
 
-  CRC_(void){};
-
   void update(const void *data, uint8_t len);
-  void finalize(void) {
+  void finalize() {
     reflect(16);
   }
   void reflect(uint8_t len);

plugins/Kaleidoscope-Escape-OneShot/src/kaleidoscope/plugin/Escape-OneShot-Config.cpp

@@ -17,10 +17,9 @@
 
 #include "kaleidoscope/plugin/Escape-OneShot.h"  // IWYU pragma: associated
 
-#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper, strcmp_P
+#include <Arduino.h>                       // for PSTR, F, __FlashStringHelper
 #include <Kaleidoscope-EEPROM-Settings.h>  // for EEPROMSettings
 #include <Kaleidoscope-FocusSerial.h>      // for Focus, FocusSerial
-#include <stdint.h>                        // for uint16_t
 
 #include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
 #include "kaleidoscope/device/device.h"         // for VirtualProps::Storage, Base<>::Storage
@@ -30,20 +29,18 @@
 namespace kaleidoscope {
 namespace plugin {
 
-uint16_t EscapeOneShotConfig::settings_base_;
-
 EventHandlerResult EscapeOneShotConfig::onSetup() {
   settings_base_ = ::EEPROMSettings.requestSlice(sizeof(EscapeOneShot::settings_));
 
   if (Runtime.storage().isSliceUninitialized(
         settings_base_,
-        sizeof(EscapeOneShot::settings_))) {
+        sizeof(EscapeOneShot::Settings))) {
     // If our slice is uninitialized, set sensible defaults.
-    Runtime.storage().put(settings_base_, EscapeOneShot::settings_);
+    Runtime.storage().put(settings_base_, ::EscapeOneShot.settings_);
     Runtime.storage().commit();
   }
 
-  Runtime.storage().get(settings_base_, EscapeOneShot::settings_);
+  Runtime.storage().get(settings_base_, ::EscapeOneShot.settings_);
   return EventHandlerResult::OK;
 }
 
@@ -51,11 +48,12 @@ EventHandlerResult EscapeOneShotConfig::onNameQuery() {
   return ::Focus.sendName(F("EscapeOneShot"));
 }
 
-EventHandlerResult EscapeOneShotConfig::onFocusEvent(const char *command) {
+EventHandlerResult EscapeOneShotConfig::onFocusEvent(const char *input) {
-  if (::Focus.handleHelp(command, PSTR("escape_oneshot.cancel_key")))
+  const char *cmd_cancel_key = PSTR("escape_oneshot.cancel_key");
-    return EventHandlerResult::OK;
+  if (::Focus.inputMatchesHelp(input))
+    return ::Focus.printHelp(cmd_cancel_key);
 
-  if (strcmp_P(command, PSTR("escape_oneshot.cancel_key")) != 0)
+  if (!::Focus.inputMatchesCommand(input, cmd_cancel_key))
     return EventHandlerResult::OK;
 
   if (::Focus.isEOL()) {
@@ -66,7 +64,7 @@ EventHandlerResult EscapeOneShotConfig::onFocusEvent(const char *command) {
     ::EscapeOneShot.setCancelKey(k);
   }
 
-  Runtime.storage().put(settings_base_, EscapeOneShot::settings_);
+  Runtime.storage().put(settings_base_, ::EscapeOneShot.settings_);
   Runtime.storage().commit();
   return EventHandlerResult::EVENT_CONSUMED;
 }

plugins/Kaleidoscope-Escape-OneShot/src/kaleidoscope/plugin/Escape-OneShot.cpp

@@ -21,15 +21,12 @@
 
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult, EventHandlerResult::E...
-#include "kaleidoscope/key_defs.h"              // for Key, Key_Escape, Key_NoKey
+#include "kaleidoscope/key_defs.h"              // for Key, Key_NoKey
 #include "kaleidoscope/keyswitch_state.h"       // for keyIsInjected, keyToggledOn
 
 namespace kaleidoscope {
 namespace plugin {
 
-EscapeOneShot::Settings EscapeOneShot::settings_ = {
-  .cancel_oneshot_key = Key_Escape};
-
 EventHandlerResult EscapeOneShot::onKeyEvent(KeyEvent &event) {
   // We only act on an escape key (or `cancel_oneshot_key_`, if that has been
   // set) that has just been pressed, and not generated by some other

plugins/Kaleidoscope-Escape-OneShot/src/kaleidoscope/plugin/Escape-OneShot.h

@@ -22,7 +22,7 @@
 
 #include "kaleidoscope/KeyEvent.h"              // for KeyEvent
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
-#include "kaleidoscope/key_defs.h"              // for Key
+#include "kaleidoscope/key_defs.h"              // for Key, Key_Escape
 #include "kaleidoscope/plugin.h"                // for Plugin
 
 // DEPRECATED: `OneShotCancelKey` doesn't match our normal naming, and should
@@ -35,14 +35,12 @@ namespace plugin {
 
 class EscapeOneShot : public kaleidoscope::Plugin {
  public:
-  EscapeOneShot(void) {}
-
   EventHandlerResult onKeyEvent(KeyEvent &event);
 
-  static void setCancelKey(Key cancel_key) {
+  void setCancelKey(Key cancel_key) {
     settings_.cancel_oneshot_key = cancel_key;
   }
-  static Key getCancelKey() {
+  Key getCancelKey() {
     return settings_.cancel_oneshot_key;
   }
 
@@ -52,17 +50,17 @@ class EscapeOneShot : public kaleidoscope::Plugin {
   struct Settings {
     Key cancel_oneshot_key;
   };
-  static Settings settings_;
+  Settings settings_ = {.cancel_oneshot_key = Key_Escape};
 };
 
 class EscapeOneShotConfig : public Plugin {
  public:
   EventHandlerResult onSetup();
-  EventHandlerResult onFocusEvent(const char *command);
+  EventHandlerResult onFocusEvent(const char *input);
   EventHandlerResult onNameQuery();
 
  private:
-  static uint16_t settings_base_;
+  uint16_t settings_base_;
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-FingerPainter/src/kaleidoscope/plugin/FingerPainter.cpp

@@ -1,6 +1,6 @@
 /* -*- mode: c++ -*-
  * Kaleidoscope-FingerPainter -- On-the-fly keyboard painting.
- * Copyright (C) 2017-2021  Keyboard.io, Inc
+ * Copyright (C) 2017-2022  Keyboard.io, Inc
  *
  * This program is free software: you can redistribute it and/or modify it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/FingerPainter.h"
 
-#include <Arduino.h>                         // for PSTR, strcmp_P, F, __FlashStringHelper
+#include <Arduino.h>                         // for PSTR, F, __FlashStringHelper
 #include <Kaleidoscope-FocusSerial.h>        // for Focus, FocusSerial
 #include <Kaleidoscope-LED-Palette-Theme.h>  // for LEDPaletteTheme
 #include <stdint.h>                          // for uint16_t, uint8_t
@@ -33,9 +33,6 @@
 namespace kaleidoscope {
 namespace plugin {
 
-uint16_t FingerPainter::color_base_;
-bool FingerPainter::edit_mode_;
-
 EventHandlerResult FingerPainter::onNameQuery() {
   return ::Focus.sendName(F("FingerPainter"));
 }
@@ -45,7 +42,7 @@ EventHandlerResult FingerPainter::onSetup() {
   return EventHandlerResult::OK;
 }
 
-void FingerPainter::update(void) {
+void FingerPainter::update() {
   ::LEDPaletteTheme.updateHandler(color_base_, 0);
 }
 
@@ -53,7 +50,7 @@ void FingerPainter::refreshAt(KeyAddr key_addr) {
   ::LEDPaletteTheme.refreshAt(color_base_, 0, key_addr);
 }
 
-void FingerPainter::toggle(void) {
+void FingerPainter::toggle() {
   edit_mode_ = !edit_mode_;
 }
 
@@ -92,25 +89,26 @@ EventHandlerResult FingerPainter::onKeyEvent(KeyEvent &event) {
   ::LEDPaletteTheme.updateColorIndexAtPosition(color_base_,
                                                Runtime.device().getLedIndex(event.addr),
                                                color_index);
+  Runtime.storage().commit();
 
   return EventHandlerResult::EVENT_CONSUMED;
 }
 
-EventHandlerResult FingerPainter::onFocusEvent(const char *command) {
+EventHandlerResult FingerPainter::onFocusEvent(const char *input) {
   enum {
     TOGGLE,
     CLEAR,
   } sub_command;
 
-  if (::Focus.handleHelp(command, PSTR("fingerpainter.toggle\nfingerpainter.clear")))
+  const char *cmd_toggle = PSTR("fingerpainter.toggle");
-    return EventHandlerResult::OK;
+  const char *cmd_clear  = PSTR("fingerpainter.clear");
 
-  if (strncmp_P(command, PSTR("fingerpainter."), 14) != 0)
+  if (::Focus.inputMatchesHelp(input))
-    return EventHandlerResult::OK;
+    return ::Focus.printHelp(cmd_toggle, cmd_clear);
 
-  if (strcmp_P(command + 14, PSTR("toggle")) == 0)
+  if (::Focus.inputMatchesCommand(input, cmd_toggle))
     sub_command = TOGGLE;
-  else if (strcmp_P(command + 14, PSTR("clear")) == 0)
+  else if (::Focus.inputMatchesCommand(input, cmd_clear))
     sub_command = CLEAR;
   else
     return EventHandlerResult::OK;

plugins/Kaleidoscope-FingerPainter/src/kaleidoscope/plugin/FingerPainter.h

@@ -33,22 +33,20 @@ namespace plugin {
 //
 class FingerPainter : public LEDMode {
  public:
-  FingerPainter(void) {}
+  void toggle();
-
-  static void toggle(void);
 
   EventHandlerResult onKeyEvent(KeyEvent &event);
-  EventHandlerResult onFocusEvent(const char *command);
+  EventHandlerResult onFocusEvent(const char *input);
   EventHandlerResult onSetup();
   EventHandlerResult onNameQuery();
 
  protected:
-  void update(void) final;
+  void update() final;
   void refreshAt(KeyAddr key_addr) final;
 
  private:
-  static uint16_t color_base_;
+  uint16_t color_base_;
-  static bool edit_mode_;
+  bool edit_mode_;
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-FirmwareDump/src/kaleidoscope/plugin/FirmwareDump.cpp

@@ -50,13 +50,13 @@ EventHandlerResult FirmwareDump::onSetup() {
   return EventHandlerResult::OK;
 }
 
-EventHandlerResult FirmwareDump::onFocusEvent(const char *command) {
+EventHandlerResult FirmwareDump::onFocusEvent(const char *input) {
   const char *cmd = PSTR("firmware.dump");
 
-  if (::Focus.handleHelp(command, cmd))
+  if (::Focus.inputMatchesHelp(input))
-    return EventHandlerResult::OK;
+    return ::Focus.printHelp(cmd);
 
-  if (strcmp_P(command, cmd) != 0)
+  if (!::Focus.inputMatchesCommand(input, cmd))
     return EventHandlerResult::OK;
 
   uint16_t flash_size = (FLASHEND + 1L);

plugins/Kaleidoscope-FirmwareDump/src/kaleidoscope/plugin/FirmwareDump.h

@@ -33,10 +33,8 @@ namespace plugin {
 
 class FirmwareDump : public kaleidoscope::Plugin {
  public:
-  FirmwareDump() {}
-
   EventHandlerResult onSetup();
-  EventHandlerResult onFocusEvent(const char *command);
+  EventHandlerResult onFocusEvent(const char *input);
 
  private:
   uint16_t bootloader_size_;

plugins/Kaleidoscope-FirmwareVersion/README.md

@@ -0,0 +1,36 @@
+# FirmwareVersion
+
+Implements a new focus command - version - that simply prints the version set up
+at compile time.
+
+## Using the plugin
+
+To use the plugin, first define the version to be printed, then include the
+header, and activate the plugin.
+
+```c++
+#define KALEIDOSCOPE_FIRMWARE_VERSION "0.1.2"
+
+#include <Kaleidoscope.h>
+#include <Kaleidoscope-FirmwareVersion.h>
+#include <Kaleidoscope-FocusSerial.h>
+
+KALEIDOSCOPE_INIT_PLUGINS(Focus,
+                          FirmwareVersion);
+
+void setup () {
+  Kaleidoscope.setup ();
+}
+```
+
+## Focus commands
+
+The plugin provides a single Focus command: `version`.
+
+### `version`
+
+> Prints the version configured at build time.
+
+## Dependencies
+
+* [Kaleidoscope-FocusSerial](Kaleidoscope-FocusSerial.md)

plugins/Kaleidoscope-FirmwareVersion/library.properties

@@ -0,0 +1,7 @@
+name=Kaleidoscope-FirmwareVersion
+version=0.0.0
+sentence=Provides a Focus command to print a preconfigured version
+maintainer=Kaleidoscope's Developers <jesse@keyboard.io>
+url=https://github.com/keyboardio/Kaleidoscope
+author=Keyboardio
+paragraph=

plugins/Kaleidoscope-FirmwareVersion/src/Kaleidoscope-FirmwareVersion.h

@@ -0,0 +1,20 @@
+/* -*- mode: c++ -*-
+ * Kaleidoscope-FirmwareVersion -- Provides a Focus command to print a version
+ * Copyright (C) 2022  Keyboard.io, Inc
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "kaleidoscope/plugin/FirmwareVersion.h"  // IWYU pragma: export

plugins/Kaleidoscope-FirmwareVersion/src/kaleidoscope/plugin/FirmwareVersion.h

@@ -0,0 +1,56 @@
+/* -*- mode: c++ -*-
+ * Kaleidoscope-FirmwareVersion -- Provides a Focus command to print a version
+ * Copyright (C) 2022  Keyboard.io, Inc
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#ifndef KALEIDOSCOPE_FIRMWARE_VERSION
+#define KALEIDOSCOPE_FIRMWARE_VERSION "0.0.0"
+#endif
+
+#include <Arduino.h>                            // for PSTR, F, __FlashStringHelper
+#include "Kaleidoscope-FocusSerial.h"           // for Focus, FocusSerial
+#include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult
+#include "kaleidoscope/plugin.h"                // for Plugin
+
+namespace kaleidoscope {
+namespace plugin {
+
+class FirmwareVersion : public Plugin {
+ public:
+  EventHandlerResult onFocusEvent(const char *input) {
+    const char *cmd_version = PSTR("version");
+
+    if (::Focus.inputMatchesHelp(input))
+      return ::Focus.printHelp(cmd_version);
+
+    if (!::Focus.inputMatchesCommand(input, cmd_version))
+      return EventHandlerResult::OK;
+
+#ifdef KALEIDOSCOPE_FIRMWARE_VERSION
+    ::Focus.send(F(KALEIDOSCOPE_FIRMWARE_VERSION));
+#else
+    ::Focus.send(F("0.0.0"));
+#endif
+
+    return EventHandlerResult::OK;
+  }
+};
+
+}  // namespace plugin
+}  // namespace kaleidoscope
+
+kaleidoscope::plugin::FirmwareVersion FirmwareVersion;

plugins/Kaleidoscope-FocusSerial/README.md

@@ -20,14 +20,17 @@ Nevertheless, a very simple example is shown below:
 namespace kaleidoscope {
 class FocusTestCommand : public Plugin {
  public:
-  FocusTestCommand() {}
-
   EventHandlerResult onNameQuery() {
     return ::Focus.sendName(F("FocusTestCommand"));
   }
 
-  EventHandlerResult onFocusEvent(const char *command) {
+  EventHandlerResult onFocusEvent(const char *input) {
-    if (strcmp_P(command, PSTR("test")) != 0)
+    const char *cmd = PSTR("test");
+
+    if (::Focus.inputMatchesHelp(input))
+      return ::Focus.printHelp(cmd);
+
+    if (!::Focus.inputMatchesCommand(input, cmd))
       return EventHandlerResult::OK;
 
     ::Focus.send(F("Congratulations, the test command works!"));
@@ -49,6 +52,18 @@ void setup () {
 
 The plugin provides the `Focus` object, with a couple of helper methods aimed at developers. Terminating the response with a dot on its own line is handled implicitly by `FocusSerial`, one does not need to do that explicitly.
 
+### `.inputMatchesHelp(input)`
+
+Returns `true` if the given `input` matches the `help` command. To be used at the top of `onFocusEvent()`, followed by `.printHelp(...)`.
+
+### `.printHelp(...)`
+
+Given a series of strings (stored in `PROGMEM`, via `PSTR()`), prints them one per line. Assumes it is run as part of handling the `help` command. Returns `EventHandlerResult::OK`.
+
+### `.inputMatchesCommand(input, command)`
+
+Returns `true` if the `input` matches the expected `command`, false otherwise. A convenience function over `strcmp_P()`.
+
 ### `.send(...)`
 ### `.sendRaw(...)`
 

plugins/Kaleidoscope-FocusSerial/src/kaleidoscope/plugin/FocusSerial.cpp

@@ -19,7 +19,6 @@
 
 #include <Arduino.h>         // for PSTR, __FlashStringHelper, F, strcmp_P
 #include <HardwareSerial.h>  // for HardwareSerial
-#include <stdint.h>          // for uint8_t
 #include <string.h>          // for memset
 
 #include "kaleidoscope/Runtime.h"               // for Runtime, Runtime_
@@ -33,10 +32,8 @@
 namespace kaleidoscope {
 namespace plugin {
 
-char FocusSerial::command_[32];
-uint8_t FocusSerial::buf_cursor_ = 0;
-
 EventHandlerResult FocusSerial::afterEachCycle() {
+  int c;
   // GD32 doesn't currently autoflush the very last packet. So manually flush here
   Runtime.serialPort().flush();
   // If the serial buffer is empty, we don't have any work to do
@@ -45,33 +42,28 @@ EventHandlerResult FocusSerial::afterEachCycle() {
   }
 
   do {
-    command_[buf_cursor_++] = Runtime.serialPort().read();
+    // If there's a newline pending, don't read it
-  } while (command_[buf_cursor_ - 1] != SEPARATOR && buf_cursor_ < sizeof(command_) && Runtime.serialPort().available() && (Runtime.serialPort().peek() != NEWLINE));
+    if (Runtime.serialPort().peek() == NEWLINE) {
-
+      break;
-
-  // If there was no command, there's nothing to do
-  if (command_[0] == '\0') {
-    buf_cursor_ = 0;
-    memset(command_, 0, sizeof(command_));
-    return EventHandlerResult::OK;
     }
+    c = Runtime.serialPort().read();
+    // Don't store the separator; just stash it
+    if (c == SEPARATOR) {
+      break;
+    }
+    input_[buf_cursor_++] = c;
+  } while (buf_cursor_ < (sizeof(input_) - 1) && Runtime.serialPort().available());
 
-  if ((command_[buf_cursor_ - 1] != SEPARATOR) && (Runtime.serialPort().peek() != NEWLINE) && buf_cursor_ < sizeof(command_)) {
+  if ((c != SEPARATOR) && (Runtime.serialPort().peek() != NEWLINE) && buf_cursor_ < (sizeof(input_) - 1)) {
     // We don't have enough command to work with yet.
     // Let's leave the buffer around for another cycle
     return EventHandlerResult::OK;
   }
 
-  // If this was a command with a space-delimited payload,
-  // strip the space delimiter off
-  if ((command_[buf_cursor_ - 1] == SEPARATOR)) {
-    command_[buf_cursor_ - 1] = '\0';
-  }
-
   // Then process the command
-  Runtime.onFocusEvent(command_);
+  Runtime.onFocusEvent(input_);
   while (Runtime.serialPort().available()) {
-    char c = Runtime.serialPort().read();
+    c = Runtime.serialPort().read();
     if (c == NEWLINE) {
       // newline serves as an end-of-command marker
       // don't drain the buffer past there
@@ -81,28 +73,23 @@ EventHandlerResult FocusSerial::afterEachCycle() {
   // End of command processing is signalled with a CRLF followed by a single period
   Runtime.serialPort().println(F("\r\n."));
   buf_cursor_ = 0;
-  memset(command_, 0, sizeof(command_));
+  memset(input_, 0, sizeof(input_));
   return EventHandlerResult::OK;
 }
 
-bool FocusSerial::handleHelp(const char *command,
+EventHandlerResult FocusSerial::onFocusEvent(const char *input) {
-                             const char *help_message) {
+  const char *cmd_help    = PSTR("help");
-  if (strcmp_P(command, PSTR("help")) != 0)
+  const char *cmd_reset   = PSTR("device.reset");
-    return false;
+  const char *cmd_plugins = PSTR("plugins");
 
-  Runtime.serialPort().println((const __FlashStringHelper *)help_message);
+  if (inputMatchesHelp(input))
-  return true;
+    return printHelp(cmd_help, cmd_reset, cmd_plugins);
-}
 
-EventHandlerResult FocusSerial::onFocusEvent(const char *command) {
+  if (inputMatchesCommand(input, cmd_reset)) {
-  if (handleHelp(command, PSTR("help\ndevice.reset\nplugins")))
-    return EventHandlerResult::OK;
-
-  if (strcmp_P(command, PSTR("device.reset")) == 0) {
     Runtime.device().rebootBootloader();
     return EventHandlerResult::EVENT_CONSUMED;
   }
-  if (strcmp_P(command, PSTR("plugins")) == 0) {
+  if (inputMatchesCommand(input, cmd_plugins)) {
     kaleidoscope::Hooks::onNameQuery();
     return EventHandlerResult::EVENT_CONSUMED;
   }
@@ -110,10 +97,27 @@ EventHandlerResult FocusSerial::onFocusEvent(const char *command) {
   return EventHandlerResult::OK;
 }
 
+#ifndef NDEPRECATED
+bool FocusSerial::handleHelp(const char *input, const char *help_message) {
+  if (!inputMatchesHelp(input)) return false;
+
+  printHelp(help_message);
+  return true;
+}
+#endif
+
 void FocusSerial::printBool(bool b) {
   Runtime.serialPort().print((b) ? F("true") : F("false"));
 }
 
+bool FocusSerial::inputMatchesHelp(const char *input) {
+  return inputMatchesCommand(input, PSTR("help"));
+}
+
+bool FocusSerial::inputMatchesCommand(const char *input, const char *expected) {
+  return strcmp_P(input, expected) == 0;
+}
+
 }  // namespace plugin
 }  // namespace kaleidoscope
 

plugins/Kaleidoscope-FocusSerial/src/kaleidoscope/plugin/FocusSerial.h

@@ -26,6 +26,15 @@
 #include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult, EventHandlerResult::OK
 #include "kaleidoscope/key_defs.h"              // for Key
 #include "kaleidoscope/plugin.h"                // for Plugin
+// -----------------------------------------------------------------------------
+// Deprecation warning messages
+#include "kaleidoscope_internal/deprecations.h"  // for DEPRECATED
+
+#define _DEPRECATED_MESSAGE_FOCUS_HANDLEHELP                      \
+  "The `Focus.handleHelp()` method is deprecated. Please use\n"   \
+  "`Focus.inputMatchesHelp()` and `Focus.printHelp()` instead.\n" \
+  "This method will be removed after 2022-12-26."
+// -----------------------------------------------------------------------------
 
 // IWYU pragma: no_include "WString.h"
 
@@ -33,19 +42,32 @@ namespace kaleidoscope {
 namespace plugin {
 class FocusSerial : public kaleidoscope::Plugin {
  public:
-  FocusSerial(void) {}
-
   static constexpr char COMMENT   = '#';
   static constexpr char SEPARATOR = ' ';
   static constexpr char NEWLINE   = '\n';
 
-  bool handleHelp(const char *command,
+#ifndef NDEPRECATED
-                  const char *help_message);
+  DEPRECATED(FOCUS_HANDLEHELP)
+  bool handleHelp(const char *input, const char *help_message);
+#endif
+
+  bool inputMatchesHelp(const char *input);
+  bool inputMatchesCommand(const char *input, const char *expected);
+
+  EventHandlerResult printHelp() {
+    return EventHandlerResult::OK;
+  }
+  template<typename... Vars>
+  EventHandlerResult printHelp(const char *h1, Vars... vars) {
+    Runtime.serialPort().println((const __FlashStringHelper *)h1);
+    delayAfterPrint();
+    return printHelp(vars...);
+  }
 
   EventHandlerResult sendName(const __FlashStringHelper *name) {
     Runtime.serialPort().print(name);
     delayAfterPrint();
-    Runtime.serialPort().print(NEWLINE);
+    Runtime.serialPort().println();
     delayAfterPrint();
     return EventHandlerResult::OK;
   }
@@ -96,6 +118,9 @@ class FocusSerial : public kaleidoscope::Plugin {
     color.g = Runtime.serialPort().parseInt();
     color.b = Runtime.serialPort().parseInt();
   }
+  void read(char &c) {
+    Runtime.serialPort().readBytes(&c, 1);
+  }
   void read(uint8_t &u8) {
     u8 = Runtime.serialPort().parseInt();
   }
@@ -112,18 +137,18 @@ class FocusSerial : public kaleidoscope::Plugin {
 
   /* Hooks */
   EventHandlerResult afterEachCycle();
-  EventHandlerResult onFocusEvent(const char *command);
+  EventHandlerResult onFocusEvent(const char *input);
 
  private:
-  static char command_[32];
+  char input_[32];
-  static uint8_t buf_cursor_;
+  uint8_t buf_cursor_ = 0;
-  static void printBool(bool b);
+  void printBool(bool b);
 
   // This is a hacky workaround for the host seemingly dropping characters
   // when a client spams its serial port too quickly
   // Verified on GD32 and macOS 12.3 2022-03-29
   static constexpr uint8_t focus_delay_us_after_character_ = 100;
-  static void delayAfterPrint() { delayMicroseconds(focus_delay_us_after_character_); }
+  void delayAfterPrint() { delayMicroseconds(focus_delay_us_after_character_); }
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-GhostInTheFirmware/src/kaleidoscope/plugin/GhostInTheFirmware.cpp

@@ -28,12 +28,8 @@
 
 namespace kaleidoscope {
 namespace plugin {
-const GhostInTheFirmware::GhostKey *GhostInTheFirmware::ghost_keys;
-bool GhostInTheFirmware::is_active_       = false;
-uint16_t GhostInTheFirmware::current_pos_ = 0;
-uint16_t GhostInTheFirmware::start_time_;
 
-void GhostInTheFirmware::activate(void) {
+void GhostInTheFirmware::activate() {
   is_active_ = true;
 }
 

plugins/Kaleidoscope-GhostInTheFirmware/src/kaleidoscope/plugin/GhostInTheFirmware.h

@@ -32,18 +32,16 @@ class GhostInTheFirmware : public kaleidoscope::Plugin {
     uint16_t press_time;
     uint16_t delay;
   };
-  static const GhostKey *ghost_keys;
+  const GhostKey *ghost_keys;
 
-  GhostInTheFirmware(void) {}
+  void activate();
-
-  static void activate(void);
 
   EventHandlerResult afterEachCycle();
 
  private:
-  static bool is_active_;
+  bool is_active_       = false;
-  static uint16_t current_pos_;
+  uint16_t current_pos_ = 0;
-  static uint16_t start_time_;
+  uint16_t start_time_;
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/Raise.h

@@ -170,7 +170,7 @@ struct RaiseProps : kaleidoscope::device::BaseProps {
   typedef RaiseKeyScanner KeyScanner;
   typedef RaiseStorageProps StorageProps;
   typedef kaleidoscope::driver::storage::Flash<StorageProps> Storage;
-  typedef kaleidoscope::driver::bootloader::samd::Bossac BootLoader;
+  typedef kaleidoscope::driver::bootloader::samd::Bossac Bootloader;
 
   typedef RaiseSideFlasherProps SideFlasherProps;
   typedef kaleidoscope::util::flasher::KeyboardioI2CBootloader<SideFlasherProps> SideFlasher;

plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/Focus.cpp

@@ -33,24 +33,37 @@ namespace raise {
 #define RAISE_FIRMWARE_VERSION "<unknown>"
 #endif
 
-EventHandlerResult Focus::onFocusEvent(const char *command) {
+EventHandlerResult Focus::onFocusEvent(const char *input) {
-  if (::Focus.handleHelp(command, PSTR("hardware.version\nhardware.side_power\nhardware.side_ver\nhardware.sled_ver\nhardware.sled_current\nhardware.layout\nhardware.joint\nhardware.keyscan\nhardware.crc_errors\nhardware.firmware")))
+  const char *cmd_version      = PSTR("hardware.version");
-    return EventHandlerResult::OK;
+  const char *cmd_side_power   = PSTR("hardware.side_power");
-
+  const char *cmd_side_ver     = PSTR("hardware.side_ver");
-  if (strncmp_P(command, PSTR("hardware."), 9) != 0)
+  const char *cmd_sled_ver     = PSTR("hardware.sled_ver");
-    return EventHandlerResult::OK;
+  const char *cmd_sled_current = PSTR("hardware.sled_current");
-
+  const char *cmd_layout       = PSTR("hardware.layout");
-  if (strcmp_P(command + 9, PSTR("version")) == 0) {
+  const char *cmd_joint        = PSTR("hardware.joint");
+  const char *cmd_keyscan      = PSTR("hardware.keyscan");
+  const char *cmd_crc_errors   = PSTR("hardware.crc_errors");
+  const char *cmd_firmware     = PSTR("hardware.firmware");
+
+  if (::Focus.inputMatchesHelp(input))
+    return ::Focus.printHelp(cmd_version,
+                             cmd_side_power,
+                             cmd_side_ver,
+                             cmd_sled_ver,
+                             cmd_sled_current,
+                             cmd_layout,
+                             cmd_joint,
+                             cmd_keyscan,
+                             cmd_crc_errors,
+                             cmd_firmware);
+
+  if (::Focus.inputMatchesCommand(input, cmd_version)) {
     ::Focus.send("Dygma Raise");
     return EventHandlerResult::EVENT_CONSUMED;
-  }
+  } else if (::Focus.inputMatchesCommand(input, cmd_firmware)) {
-
-  if (strcmp_P(command + 9, PSTR("firmware")) == 0) {
     ::Focus.send(RAISE_FIRMWARE_VERSION);
     return EventHandlerResult::EVENT_CONSUMED;
-  }
+  } else if (::Focus.inputMatchesCommand(input, cmd_side_power)) {
-
-  if (strcmp_P(command + 9, PSTR("side_power")) == 0) {
     if (::Focus.isEOL()) {
       ::Focus.send(Runtime.device().side.getPower());
       return EventHandlerResult::EVENT_CONSUMED;
@@ -60,37 +73,29 @@ EventHandlerResult Focus::onFocusEvent(const char *command) {
       Runtime.device().side.setPower(power);
       return EventHandlerResult::EVENT_CONSUMED;
     }
-  }
+  } else if (::Focus.inputMatchesCommand(input, cmd_side_ver)) {
-
-  if (strcmp_P(command + 9, PSTR("side_ver")) == 0) {
     ::Focus.send("left:");
     ::Focus.send(Runtime.device().side.leftVersion());
-    ::Focus.send("\nright:");
+    ::Focus.send("\r\nright:");
     ::Focus.send(Runtime.device().side.rightVersion());
     return EventHandlerResult::EVENT_CONSUMED;
-  }
+  } else if (::Focus.inputMatchesCommand(input, cmd_crc_errors)) {
-
-  if (strcmp_P(command + 9, PSTR("crc_errors")) == 0) {
     ::Focus.send("left:");
     ::Focus.send(Runtime.device().side.leftCRCErrors());
-    ::Focus.send("\nright:");
+    ::Focus.send("\r\nright:");
     ::Focus.send(Runtime.device().side.rightCRCErrors());
     return EventHandlerResult::EVENT_CONSUMED;
-  }
+  } else if (::Focus.inputMatchesCommand(input, cmd_sled_ver)) {
-
-  if (strcmp_P(command + 9, PSTR("sled_ver")) == 0) {
     ::Focus.send("left:");
     ::Focus.send(Runtime.device().side.leftSLEDVersion());
-    ::Focus.send("\nright:");
+    ::Focus.send("\r\nright:");
     ::Focus.send(Runtime.device().side.rightSLEDVersion());
     return EventHandlerResult::EVENT_CONSUMED;
-  }
+  } else if (::Focus.inputMatchesCommand(input, cmd_sled_current)) {
-
-  if (strcmp_P(command + 9, PSTR("sled_current")) == 0) {
     if (::Focus.isEOL()) {
       ::Focus.send("left:");
       ::Focus.send(Runtime.device().side.leftSLEDCurrent());
-      ::Focus.send("\nright:");
+      ::Focus.send("\r\nright:");
       ::Focus.send(Runtime.device().side.rightSLEDCurrent());
       return EventHandlerResult::EVENT_CONSUMED;
     } else {
@@ -99,20 +104,14 @@ EventHandlerResult Focus::onFocusEvent(const char *command) {
       Runtime.device().side.setSLEDCurrent(current);
       return EventHandlerResult::EVENT_CONSUMED;
     }
-  }
+  } else if (::Focus.inputMatchesCommand(input, cmd_layout)) {
-
-  if (strcmp_P(command + 9, PSTR("layout")) == 0) {
     static const auto ANSI = Runtime.device().settings.Layout::ANSI;
     ::Focus.send(Runtime.device().settings.layout() == ANSI ? "ANSI" : "ISO");
     return EventHandlerResult::EVENT_CONSUMED;
-  }
+  } else if (::Focus.inputMatchesCommand(input, cmd_joint)) {
-
-  if (strcmp_P(command + 9, PSTR("joint")) == 0) {
     ::Focus.send(Runtime.device().settings.joint());
     return EventHandlerResult::EVENT_CONSUMED;
-  }
+  } else if (::Focus.inputMatchesCommand(input, cmd_keyscan)) {
-
-  if (strcmp_P(command + 9, PSTR("keyscan")) == 0) {
     if (::Focus.isEOL()) {
       ::Focus.send(Runtime.device().settings.keyscanInterval());
       return EventHandlerResult::EVENT_CONSUMED;

plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/Focus.h

@@ -29,7 +29,7 @@ namespace raise {
 
 class Focus : public kaleidoscope::Plugin {
  public:
-  EventHandlerResult onFocusEvent(const char *command);
+  EventHandlerResult onFocusEvent(const char *input);
 };
 
 }  // namespace raise

plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/SideFlash.h

@@ -34,12 +34,14 @@ class SideFlash : public kaleidoscope::Plugin {
   _Firmware firmware;
 
  public:
-  EventHandlerResult onFocusEvent(const char *command) {
+  EventHandlerResult onFocusEvent(const char *input) {
-    if (::Focus.handleHelp(command, PSTR("hardware.flash_left_side\nhardware.flash_right_side\nhardware.verify_left_side\nhardware.verify_right_side")))
+    const char *cmd_flash_left   = PSTR("hardware.flash_left_side");
-      return EventHandlerResult::OK;
+    const char *cmd_flash_right  = PSTR("hardware.flash_right_side");
+    const char *cmd_verify_left  = PSTR("hardware.verify_left_side");
+    const char *cmd_verify_right = PSTR("hardware.verify_right_side");
 
-    if (strncmp_P(command, PSTR("hardware."), 9) != 0)
+    if (::Focus.inputMatchesHelp(input))
-      return EventHandlerResult::OK;
+      return ::Focus.printHelp(cmd_flash_left, cmd_flash_right, cmd_verify_left, cmd_verify_right);
 
     auto sideFlasher           = Runtime.device().sideFlasher();
     uint8_t left_boot_address  = Runtime.device().side.left_boot_address;
@@ -50,16 +52,16 @@ class SideFlash : public kaleidoscope::Plugin {
     } sub_command;
     uint8_t address = 0;
 
-    if (strcmp_P(command + 9, PSTR("flash_left_side")) == 0) {
+    if (::Focus.inputMatchesCommand(input, cmd_flash_left)) {
       sub_command = FLASH;
       address     = left_boot_address;
-    } else if (strcmp_P(command + 9, PSTR("flash_right_side")) == 0) {
+    } else if (::Focus.inputMatchesCommand(input, cmd_flash_right)) {
       sub_command = FLASH;
       address     = right_boot_address;
-    } else if (strcmp_P(command + 9, PSTR("verify_left_side")) == 0) {
+    } else if (::Focus.inputMatchesCommand(input, cmd_verify_left)) {
       sub_command = VERIFY;
       address     = left_boot_address;
-    } else if (strcmp_P(command + 9, PSTR("verify_right_side")) == 0) {
+    } else if (::Focus.inputMatchesCommand(input, cmd_verify_right)) {
       sub_command = VERIFY;
       address     = right_boot_address;
     } else {

plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox.cpp

@@ -38,15 +38,9 @@ namespace kaleidoscope {
 namespace device {
 namespace ez {
 
-ErgoDoxScanner ErgoDox::scanner_;
-uint8_t ErgoDox::previousKeyState_[matrix_rows];
-uint8_t ErgoDox::keyState_[matrix_rows];
-uint8_t ErgoDox::debounce_matrix_[matrix_rows][matrix_columns];
-uint8_t ErgoDox::debounce = 5;
-
 static bool do_scan_ = 1;
 
-void ErgoDox::setup(void) {
+void ErgoDox::setup() {
   wdt_disable();
   delay(100);
 

plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox.h

@@ -60,11 +60,9 @@ struct ErgoDoxProps : public kaleidoscope::device::ATmega32U4KeyboardProps {
 #ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 class ErgoDox : public kaleidoscope::device::ATmega32U4Keyboard<ErgoDoxProps> {
  public:
-  ErgoDox(void) {}
+  void scanMatrix();
-
+  void readMatrix();
-  void scanMatrix(void);
+  void actOnMatrixScan();
-  void readMatrix(void);
-  void actOnMatrixScan(void);
   void setup();
 
   bool isKeyswitchPressed(KeyAddr key_addr);
@@ -80,17 +78,17 @@ class ErgoDox : public kaleidoscope::device::ATmega32U4Keyboard<ErgoDoxProps> {
   void setStatusLED(uint8_t led, bool state = true);
   void setStatusLEDBrightness(uint8_t led, uint8_t brightness);
 
-  static uint8_t debounce;
+  uint8_t debounce = 5;
 
  private:
-  static ErgoDoxScanner scanner_;
+  ErgoDoxScanner scanner_;
-  static uint8_t previousKeyState_[matrix_rows];
+  uint8_t previousKeyState_[matrix_rows];  // NOLINT(runtime/arrays)
-  static uint8_t keyState_[matrix_rows];
+  uint8_t keyState_[matrix_rows];          // NOLINT(runtime/arrays)
-  static uint8_t debounce_matrix_[matrix_rows][matrix_columns];
+  uint8_t debounce_matrix_[matrix_rows][matrix_columns];
-
+
-  static uint8_t debounceMaskForRow(uint8_t row);
+  uint8_t debounceMaskForRow(uint8_t row);
-  static void debounceRow(uint8_t change, uint8_t row);
+  void debounceRow(uint8_t change, uint8_t row);
-  static void readMatrixRow(uint8_t row);
+  void readMatrixRow(uint8_t row);
 };
 #else   // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
 class ErgoDox;

plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox/ErgoDoxScanner.h

@@ -35,8 +35,6 @@ namespace ez {
 
 class ErgoDoxScanner {
  public:
-  ErgoDoxScanner() {}
-
   void begin();
   void toggleATMegaRow(int row);
   void selectExtenderRow(int row);

plugins/Kaleidoscope-Hardware-GD32-Eval/src/kaleidoscope/device/gd32/Eval.h

@@ -37,7 +37,7 @@ struct EvalProps : kaleidoscope::device::BaseProps {
   typedef kaleidoscope::driver::hid::KeyboardioProps HIDProps;
   typedef kaleidoscope::driver::hid::Keyboardio<HIDProps> HID;
 
-  typedef kaleidoscope::driver::bootloader::gd32::Base BootLoader;
+  typedef kaleidoscope::driver::bootloader::gd32::Base Bootloader;
   typedef EvalStorageProps StorageProps;
   typedef kaleidoscope::driver::storage::GD32Flash<StorageProps> Storage;
 

plugins/Kaleidoscope-Hardware-Keyboardio-Atreus/src/kaleidoscope/device/keyboardio/Atreus2.h

@@ -45,7 +45,7 @@ struct AtreusProps : kaleidoscope::device::ATmega32U4KeyboardProps {
   };
 
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
-  typedef kaleidoscope::driver::bootloader::avr::Caterina BootLoader;
+  typedef kaleidoscope::driver::bootloader::avr::Caterina Bootloader;
   static constexpr const char *short_name = "atreus";
 };
 

plugins/Kaleidoscope-Hardware-Keyboardio-Imago/src/kaleidoscope/device/keyboardio/Imago.cpp

@@ -102,7 +102,7 @@ void ImagoLEDDriver::twiSend(uint8_t addr, uint8_t Reg_Add, uint8_t Reg_Dat) {
   uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0);
 }
 
-void ImagoLEDDriver::unlockRegister(void) {
+void ImagoLEDDriver::unlockRegister() {
   twiSend(LED_DRIVER_ADDR, CMD_WRITE_ENABLE, WRITE_ENABLE_ONCE);  //unlock
 }
 

plugins/Kaleidoscope-Hardware-Keyboardio-Imago/src/kaleidoscope/device/keyboardio/Imago.h

@@ -99,7 +99,7 @@ struct ImagoProps : kaleidoscope::device::ATmega32U4KeyboardProps {
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
   typedef ImagoLEDDriverProps LEDDriverProps;
   typedef ImagoLEDDriver LEDDriver;
-  typedef kaleidoscope::driver::bootloader::avr::Caterina BootLoader;
+  typedef kaleidoscope::driver::bootloader::avr::Caterina Bootloader;
   static constexpr const char *short_name = "imago";
 };
 

plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/device/keyboardio/Model01.cpp

@@ -56,7 +56,7 @@ struct Model01Hands {
 driver::keyboardio::Model01Side Model01Hands::leftHand(0);
 driver::keyboardio::Model01Side Model01Hands::rightHand(3);
 
-void Model01Hands::setup(void) {
+void Model01Hands::setup() {
   // This lets the keyboard pull up to 1.6 amps from the host.
   // That violates the USB spec. But it sure is pretty looking
   DDRE |= _BV(6);
@@ -149,7 +149,7 @@ driver::keyboardio::keydata_t Model01KeyScanner::rightHandState;
 driver::keyboardio::keydata_t Model01KeyScanner::previousLeftHandState;
 driver::keyboardio::keydata_t Model01KeyScanner::previousRightHandState;
 
-void Model01KeyScanner::enableScannerPower(void) {
+void Model01KeyScanner::enableScannerPower() {
   // Turn on power to the LED net
   DDRC |= _BV(7);
   PORTC |= _BV(7);

plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/device/keyboardio/Model01.h

@@ -126,7 +126,7 @@ struct Model01Props : public kaleidoscope::device::ATmega32U4KeyboardProps {
   typedef Model01LEDDriver LEDDriver;
   typedef Model01KeyScannerProps KeyScannerProps;
   typedef Model01KeyScanner KeyScanner;
-  typedef kaleidoscope::driver::bootloader::avr::Caterina BootLoader;
+  typedef kaleidoscope::driver::bootloader::avr::Caterina Bootloader;
   static constexpr const char *short_name = "kbio01";
 };
 

plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model100.cpp

@@ -44,7 +44,7 @@ struct Model100Hands {
 driver::keyboardio::Model100Side Model100Hands::leftHand(0);
 driver::keyboardio::Model100Side Model100Hands::rightHand(3);
 
-void Model100Hands::setup(void) {
+void Model100Hands::setup() {
   Model100KeyScanner::enableScannerPower();
   Wire.begin();
   Wire.setClock(400000);
@@ -123,7 +123,7 @@ driver::keyboardio::keydata_t Model100KeyScanner::rightHandState;
 driver::keyboardio::keydata_t Model100KeyScanner::previousLeftHandState;
 driver::keyboardio::keydata_t Model100KeyScanner::previousRightHandState;
 
-void Model100KeyScanner::enableScannerPower(void) {
+void Model100KeyScanner::enableScannerPower() {
   // Turn on the switched 5V network.
   //  make sure this happens at least 100ms after USB connect
   // to satisfy inrush limits
@@ -137,7 +137,7 @@ void Model100KeyScanner::enableScannerPower(void) {
   digitalWrite(PB15, LOW);
 }
 
-void Model100KeyScanner::disableScannerPower(void) {
+void Model100KeyScanner::disableScannerPower() {
   // Turn on power to the 5V net
   //
   pinMode(PB9, OUTPUT_OPEN_DRAIN);

plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model100.h

@@ -141,7 +141,7 @@ struct Model100Props : public kaleidoscope::device::BaseProps {
   typedef Model100StorageProps StorageProps;
   typedef kaleidoscope::driver::storage::GD32Flash<StorageProps> Storage;
 
-  typedef kaleidoscope::driver::bootloader::gd32::Base BootLoader;
+  typedef kaleidoscope::driver::bootloader::gd32::Base Bootloader;
   static constexpr const char *short_name = "kbio100";
 
   typedef kaleidoscope::driver::mcu::GD32Props MCUProps;

plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/Model100Side.cpp

@@ -214,6 +214,7 @@ void Model100Side::sendLEDData() {
   }
 }
 
+auto constexpr gamma8 = kaleidoscope::driver::color::gamma_correction;
 
 void Model100Side::sendLEDBank(uint8_t bank) {
   uint8_t data[LED_BYTES_PER_BANK + 1];
@@ -229,25 +230,25 @@ void Model100Side::sendLEDBank(uint8_t bank) {
     else
       c = 0;
 
-    data[i + 1] = c;
+    data[i + 1] = pgm_read_byte(&gamma8[c]);
   }
   uint8_t result = writeData(data, ELEMENTS(data));
 }
 
 void Model100Side::setAllLEDsTo(cRGB color) {
   uint8_t data[] = {TWI_CMD_LED_SET_ALL_TO,
-                    color.b,
+                    pgm_read_byte(&gamma8[color.b]),
-                    color.g,
+                    pgm_read_byte(&gamma8[color.g]),
-                    color.r};
+                    pgm_read_byte(&gamma8[color.r])};
   uint8_t result = writeData(data, ELEMENTS(data));
 }
 
 void Model100Side::setOneLEDTo(uint8_t led, cRGB color) {
   uint8_t data[] = {TWI_CMD_LED_SET_ONE_TO,
                     led,
-                    color.b,
+                    pgm_read_byte(&gamma8[color.b]),
-                    color.g,
+                    pgm_read_byte(&gamma8[color.g]),
-                    color.r};
+                    pgm_read_byte(&gamma8[color.r])};
   uint8_t result = writeData(data, ELEMENTS(data));
 }
 

plugins/Kaleidoscope-Hardware-SOFTHRUF-Splitography/src/kaleidoscope/device/softhruf/Splitography.h

@@ -53,7 +53,7 @@ struct SplitographyProps : kaleidoscope::device::ATmega32U4KeyboardProps {
 #endif  // KALEIDOSCOPE_VIRTUAL_BUILD
   };
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
-  typedef kaleidoscope::driver::bootloader::avr::FLIP BootLoader;
+  typedef kaleidoscope::driver::bootloader::avr::FLIP Bootloader;
   static constexpr const char *short_name = "splitography";
 };
 

plugins/Kaleidoscope-Hardware-Technomancy-Atreus/src/kaleidoscope/device/technomancy/Atreus.h

@@ -67,9 +67,9 @@ struct AtreusProps : kaleidoscope::device::ATmega32U4KeyboardProps {
   typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
 
 #ifdef KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_LEGACY_TEENSY2
-  typedef kaleidoscope::driver::bootloader::avr::HalfKay BootLoader;
+  typedef kaleidoscope::driver::bootloader::avr::HalfKay Bootloader;
 #else
-  typedef kaleidoscope::driver::bootloader::avr::Caterina BootLoader;
+  typedef kaleidoscope::driver::bootloader::avr::Caterina Bootloader;
 #endif
   static constexpr const char *short_name = "atreus";
 };

plugins/Kaleidoscope-HardwareTestMode/src/kaleidoscope/plugin/HardwareTestMode.cpp

@@ -53,7 +53,7 @@ void HardwareTestMode::setLeds(cRGB color) {
   waitForKeypress();
 }
 
-void HardwareTestMode::testLeds(void) {
+void HardwareTestMode::testLeds() {
   constexpr cRGB red         = CRGB(255, 0, 0);
   constexpr cRGB blue        = CRGB(0, 0, 255);
   constexpr cRGB green       = CRGB(0, 255, 0);

plugins/Kaleidoscope-HardwareTestMode/src/kaleidoscope/plugin/HardwareTestMode.h

@@ -33,8 +33,6 @@ class HardwareTestMode : public kaleidoscope::Plugin {
   } chatter_data;
   static uint8_t actionKey;
 
-  HardwareTestMode(void) {}
-
   static void runTests();
   static void setActionKey(uint8_t key);
 

plugins/Kaleidoscope-Heatmap/src/kaleidoscope/plugin/Heatmap.cpp

@@ -41,13 +41,13 @@ uint8_t Heatmap::heat_colors_length = 4;
 // number of millisecond to wait between each heatmap computation
 uint16_t Heatmap::update_delay = 1000;
 
+uint16_t Heatmap::highest_ = 1;
+uint16_t Heatmap::heatmap_[];
+
 Heatmap::TransientLEDMode::TransientLEDMode(const Heatmap *parent)
-  :  // store the number of times each key has been strock
+  :  // last heatmap computation time
-    heatmap_{},
+    last_heatmap_comp_time_(Runtime.millisAtCycleStart()),
-    // max of heatmap_ (we divide by it so we start at 1)
+    parent_(parent) {}
-    highest_(1),
-    // last heatmap computation time
-    last_heatmap_comp_time_(Runtime.millisAtCycleStart()) {}
 
 cRGB Heatmap::TransientLEDMode::computeColor(float v) {
   // compute the color corresponding to a value between 0 and 1
@@ -107,21 +107,21 @@ cRGB Heatmap::TransientLEDMode::computeColor(float v) {
   return {b, g, r};
 }
 
-void Heatmap::TransientLEDMode::shiftStats(void) {
+void Heatmap::TransientLEDMode::shiftStats() {
   // this method is called when:
   // 1. a value in heatmap_ reach INT8_MAX
   // 2. highest_ reach heat_colors_length*512 (see Heatmap::loopHook)
 
   // we divide every heatmap element by 2
   for (auto key_addr : KeyAddr::all()) {
-    heatmap_[key_addr.toInt()] = heatmap_[key_addr.toInt()] >> 1;
+    parent_->heatmap_[key_addr.toInt()] = parent_->heatmap_[key_addr.toInt()] >> 1;
   }
 
   // and also divide highest_ accordingly
-  highest_ = highest_ >> 1;
+  parent_->highest_ = parent_->highest_ >> 1;
 }
 
-void Heatmap::resetMap(void) {
+void Heatmap::resetMap() {
 
   if (::LEDControl.get_mode_index() != led_mode_id_)
     return;
@@ -134,10 +134,10 @@ void Heatmap::TransientLEDMode::resetMap() {
   // this method can be used as a way to work around an existing bug with a single key
   // getting special attention or if the user just wants a button to reset the map
   for (auto key_addr : KeyAddr::all()) {
-    heatmap_[key_addr.toInt()] = 0;
+    parent_->heatmap_[key_addr.toInt()] = 0;
   }
 
-  highest_ = 1;
+  parent_->highest_ = 1;
 }
 
 // It may be better to use `onKeyswitchEvent()` here
@@ -167,17 +167,17 @@ EventHandlerResult Heatmap::onKeyEvent(KeyEvent &event) {
 
 EventHandlerResult Heatmap::TransientLEDMode::onKeyEvent(KeyEvent &event) {
   // increment the heatmap_ value related to the key
-  heatmap_[event.addr.toInt()]++;
+  parent_->heatmap_[event.addr.toInt()]++;
 
   // check highest_
-  if (highest_ < heatmap_[event.addr.toInt()]) {
+  if (parent_->highest_ < parent_->heatmap_[event.addr.toInt()]) {
-    highest_ = heatmap_[event.addr.toInt()];
+    parent_->highest_ = parent_->heatmap_[event.addr.toInt()];
 
     // if highest_ (and so heatmap_ value related to the key)
     // is close to overflow: call shiftStats
     // NOTE: this is barely impossible since shiftStats should be
     //       called much sooner by Heatmap::loopHook
-    if (highest_ == INT16_MAX)
+    if (parent_->highest_ == INT16_MAX)
       shiftStats();
   }
 
@@ -204,13 +204,13 @@ EventHandlerResult Heatmap::TransientLEDMode::beforeEachCycle() {
   // didn't lose any precision in our heatmap since between each color we have a
   // maximum precision of 256 ; said differently, there is 256 state (at max)
   // between heat_colors[x] and heat_colors[x+1].
-  if (highest_ > (static_cast<uint16_t>(heat_colors_length) << 9))
+  if (parent_->highest_ > (static_cast<uint16_t>(heat_colors_length) << 9))
     shiftStats();
 
   return EventHandlerResult::OK;
 }
 
-void Heatmap::TransientLEDMode::update(void) {
+void Heatmap::TransientLEDMode::update() {
   if (!Runtime.has_leds)
     return;
 
@@ -229,7 +229,7 @@ void Heatmap::TransientLEDMode::update(void) {
   for (auto key_addr : KeyAddr::all()) {
     // how much the key was pressed compared to the others (between 0 and 1)
     // (total_keys_ can't be equal to 0)
-    float v = static_cast<float>(heatmap_[key_addr.toInt()]) / highest_;
+    float v = static_cast<float>(parent_->heatmap_[key_addr.toInt()]) / parent_->highest_;
     // we could have used an interger instead of a float, but then we would
     // have had to change some multiplication in division.
     // / on uint is slower than * on float, so I stay with the float

plugins/Kaleidoscope-Heatmap/src/kaleidoscope/plugin/Heatmap.h

@@ -34,12 +34,11 @@ class Heatmap : public Plugin,
                 public LEDModeInterface,
                 public AccessTransientLEDMode {
  public:
-  Heatmap(void) {}
-
   static uint16_t update_delay;
   static const cRGB *heat_colors;
   static uint8_t heat_colors_length;
-  void resetMap(void);
+
+  void resetMap();
 
   EventHandlerResult onKeyEvent(KeyEvent &event);
   EventHandlerResult beforeEachCycle();
@@ -62,15 +61,18 @@ class Heatmap : public Plugin,
     void update() final;
 
    private:
-    uint16_t heatmap_[Runtime.device().numKeys()];
-    uint16_t highest_;
     uint16_t last_heatmap_comp_time_;
+    const Heatmap *parent_;
 
-    void shiftStats(void);
+    void shiftStats();
     cRGB computeColor(float v);
 
     friend class Heatmap;
   };
+
+ private:
+  static uint16_t heatmap_[Runtime.device().numKeys()];
+  static uint16_t highest_;
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-HostOS/README.md

@@ -21,7 +21,7 @@ The extension provides a `HostOS` singleton object.
 #include <Kaleidoscope.h>
 #include <Kaleidoscope-HostOS.h>
 
-void someFunction(void) {
+void someFunction() {
   if (HostOS.os() == kaleidoscope::hostos::LINUX) {
     // do something linux-y
   }
@@ -32,7 +32,7 @@ void someFunction(void) {
 
 KALEIDOSCOPE_INIT_PLUGINS(HostOS)
 
-void setup(void) {
+void setup() {
   Kaleidoscope.setup ();
 }
 ```

plugins/Kaleidoscope-HostOS/src/kaleidoscope/plugin/HostOS-Focus.cpp

@@ -17,7 +17,7 @@
 
 #include "kaleidoscope/plugin/HostOS-Focus.h"
 
-#include <Arduino.h>                   // for PSTR, strcmp_P
+#include <Arduino.h>                   // for PSTR
 #include <Kaleidoscope-FocusSerial.h>  // for Focus, FocusSerial
 #include <stdint.h>                    // for uint8_t
 
@@ -27,12 +27,13 @@
 namespace kaleidoscope {
 namespace plugin {
 
-EventHandlerResult FocusHostOSCommand::onFocusEvent(const char *command) {
+EventHandlerResult FocusHostOSCommand::onFocusEvent(const char *input) {
   const char *cmd = PSTR("hostos.type");
 
-  if (::Focus.handleHelp(command, cmd))
+  if (::Focus.inputMatchesHelp(input))
-    return EventHandlerResult::OK;
+    return ::Focus.printHelp(cmd);
-  if (strcmp_P(command, cmd) != 0)
+
+  if (!::Focus.inputMatchesCommand(input, cmd))
     return EventHandlerResult::OK;
 
   if (::Focus.isEOL()) {

plugins/Kaleidoscope-HostOS/src/kaleidoscope/plugin/HostOS-Focus.h

@@ -25,8 +25,7 @@ namespace plugin {
 
 class FocusHostOSCommand : public kaleidoscope::Plugin {
  public:
-  FocusHostOSCommand() {}
+  EventHandlerResult onFocusEvent(const char *input);
-  EventHandlerResult onFocusEvent(const char *command);
 };
 
 }  // namespace plugin

plugins/Kaleidoscope-HostOS/src/kaleidoscope/plugin/HostOS.cpp

@@ -26,7 +26,7 @@
 namespace kaleidoscope {
 namespace plugin {
 
-EventHandlerResult HostOS::onSetup(void) {
+EventHandlerResult HostOS::onSetup() {
   if (is_configured_)
     return EventHandlerResult::OK;
 

plugins/Kaleidoscope-HostOS/src/kaleidoscope/plugin/HostOS.h

@@ -41,10 +41,9 @@ typedef enum {
 
 class HostOS : public kaleidoscope::Plugin {
  public:
-  HostOS() {}
   EventHandlerResult onSetup();
 
-  hostos::Type os(void) {
+  hostos::Type os() {
     return os_;
   }
   void os(hostos::Type new_os);

plugins/Kaleidoscope-HostPowerManagement/src/kaleidoscope/plugin/HostPowerManagement.cpp

@@ -20,39 +20,41 @@
 #include <Arduino.h>  // IWYU pragma: keep
 #include <stdint.h>   // for uint8_t
 
-#include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult, EventHandlerResult::OK
+#ifdef ARDUINO_ARCH_GD32
+#include "USBCore.h"
+#endif
 
-// This is a terrible hack until Arduino#6964 gets implemented.
+#include "kaleidoscope/event_handler_result.h"  // for EventHandlerResult, EventHandlerResult::OK
-// It makes the `_usbSuspendState` symbol available to us.
-extern uint8_t _usbSuspendState;
 
 namespace kaleidoscope {
 namespace plugin {
 
 bool HostPowerManagement::was_suspended_ = false;
-bool HostPowerManagement::initial_suspend_ = true;
 
-EventHandlerResult HostPowerManagement::beforeEachCycle() {
+bool HostPowerManagement::isSuspended() {
+#if defined(__AVR__)
+  return USBDevice.isSuspended();
+#elif defined(ARDUINO_ARCH_GD32)
+  return USBCore().isSuspended();
+#else
+  return false;
+#endif
+}
 
-#ifdef __AVR__
+EventHandlerResult HostPowerManagement::beforeEachCycle() {
-  if ((_usbSuspendState & (1 << SUSPI))) {
+  if (isSuspended()) {
-    if (!initial_suspend_) {
     if (!was_suspended_) {
       was_suspended_ = true;
       hostPowerManagementEventHandler(Suspend);
     } else {
       hostPowerManagementEventHandler(Sleep);
     }
-    }
   } else {
-    if (initial_suspend_)
-      initial_suspend_ = false;
     if (was_suspended_) {
       was_suspended_ = false;
       hostPowerManagementEventHandler(Resume);
     }
   }
-#endif
 
   return EventHandlerResult::OK;
 }

plugins/Kaleidoscope-HostPowerManagement/src/kaleidoscope/plugin/HostPowerManagement.h

@@ -30,13 +30,12 @@ class HostPowerManagement : public kaleidoscope::Plugin {
     Resume,
   } Event;
 
-  HostPowerManagement(void) {}
-
   EventHandlerResult beforeEachCycle();
 
  private:
   static bool was_suspended_;
-  static bool initial_suspend_;
+
+  bool isSuspended();
 };
 
 }  // namespace plugin