Rename version from 8.1.6 to 8.2.0 because the minor device protocol version has changed.

Merge dev into master

CHANGELOG.md

@@ -5,9 +5,119 @@ All notable changes to this project will be documented in this file.
 The format is loosely based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to the [UHK Versioning](VERSIONING.md) conventions.
 
+## [8.2.0] - 2018-04-20
+
+Device Protocol: 4.**3.0** | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Change the scheduling of USB reports which changes mouse pointer speeds.
+- Disable LEDs while the host sleeps.
+- Make any key wake up the host while it sleeps.
+- Add UsbCommand_SwitchKeymap(). `DEVICEPROTOCOL:MINOR`
+- Make GCC optimize the release builds for execution speed (-O3).
+
+## [8.1.5] - 2018-04-04
+
+Device Protocol: 4.2.0 | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Set key debounce timeout from 30ms to 60ms. This should eliminate key chattering.
+- Use the correct scancode for the menu key of the factory keymap.
+
+## [8.1.4] - 2018-03-05
+
+Device Protocol: 4.2.0 | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Set key debounce timeout from 20ms to 30ms. This should eliminate key chattering.
+- Set double tap lock layer timeout from 250ms to 150ms. This should minimize the chance of locking layers accidentally by double tapping their keys.
+
+## [8.1.3] - 2018-02-18
+
+Device Protocol: 4.2.0 | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Fix system keyboard descriptor, so it is byte-aligned.
+- Set key debounce timeout from 15ms to 20ms. This should at least reduce and hopefully eliminate key chattering.
+
+## [8.1.2] - 2018-02-13
+
+Device Protocol: 4.2.0 | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Detect Caps Lock USB state and light up the Caps Lock icon of the LED display accordingly.
+- Set key debounce timeout from 10ms to 15ms. This should at least reduce and hopefully eliminate key chattering.
+
+## [8.1.1] - 2018-02-11
+
+Device Protocol: 4.2.0 | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Lock layers every time when double-tapping their layer switcher keys, regardless of how many times the layer switcher key was tapped before.
+- Only lock layers via double-tapping if the second tap gets released within 100ms.
+
+## [8.1.0] - 2018-01-15
+
+Device Protocol: 4.**2**.0 | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Enable left-half watchdog in reinit mode which seems to prevent freezes.
+- Slow down main bus I2C baud rate to 30kHz when BusPal is on to make firmware transfer more robust.
+- Implement UsbCommandId_GetSlaveI2cErrors. `DEVICEPROTOCOL:MINOR`
+- Implement UsbCommandId_SetI2cBaudRate. `DEVICEPROTOCOL:MINOR`
+- Implement DevicePropertyId_CurrentKbootCommand. `DEVICEPROTOCOL:MINOR`
+- Implement DevicePropertyId_I2cMainBusBaudRate. `DEVICEPROTOCOL:MINOR`
+- Implement DevicePropertyId_Uptime. `DEVICEPROTOCOL:MINOR`
+
+## [8.0.1] - 2017-12-25
+
+Device Protocol: 4.1.0 | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Implement I2C watchdog for the left keyboard half which should resolve the occasional hangs of the left keyboard half.
+
+## [8.0.0] - 2017-12-15
+
+Device Protocol: 4.**1.0** | Module Protocol: **4.0.0** | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Make the modules transfer the module protocol version and firmware version composed of a major, a minor and a patch number. `MODULEPROTOCOL:MAJOR`
+- Query module key count and pointer count in separate messages instead of a combined message for improved clarity. `MODULEPROTOCOL:MAJOR`
+- Add new UsbCommand_GetModuleProperties() device protocol command. `DEVICEPROTOCOL:MINOR`
+
+## [7.0.0] - 2017-12-14
+
+Device Protocol: **4.0.0** | Module Protocol: 3.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Make UsbCommand_JumpToModuleBootloader() more robust by not making it dependent on the state of the module driver.
+- Don't make horizontal scrolling and vertical scrolling affect each other.
+- Expose version numbers via the get property interface. `DEVICEPROTOCOL:MINOR`
+- Add DevicePropertyId_ConfigSizes. `DEVICEPROTOCOL:MINOR`
+- Remove DevicePropertyId_HardwareConfigSize and DevicePropertyId_UserConfigSize. `DEVICEPROTOCOL:MAJOR`
+
+## [6.0.0] - 2017-12-12
+
+Device Protocol: **3.0.0** | Module Protocol: 3.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Change the value of almost every Device Protocol commands because there were unused intervals between them. `DEVICEPROTOCOL:MAJOR`
+- Disable LED display icons by default.
+- Update LED brightness levels upon applying the configuration.
+
+## [5.0.1] - 2017-12-09
+
+Device Protocol: 2.0.0 | Module Protocol: 3.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+ - Make key presses continue to emit scancodes even if a USB interface (typically the mouse interface) is not polled by the host anymore.
+ - Make scrolling always immediately react to keypresses regardless of the previous internal scroll state.
+
+## [5.0.0] - 2017-12-04
+
+Device Protocol: 2.0.0 | Module Protocol: 3.0.0 | User Config: **4.0.0** | Hardware Config: 1.0.0
+
+- Move pointerRole from keymaps to module configurations as pointerMode. Add angularShift, modLayerPointerFunction, fnLayerPointerFunction, and mouseLayerPointerFunction to module configurations. `USERCONFIG:MAJOR`
+
+## [4.0.0] - 2017-11-30
+
+Device Protocol: 2.0.0 | Module Protocol: 3.0.0 | User Config: **3.0.0** | Hardware Config: 1.0.0
+
+- Implement mouse movement and scrolling deceleration and acceleration.
+- Toggle layers upon double tapping their keys. Make the double tap timeout configurable.
+- Make the parser read additional user configuration properties: userConfigMajorVersion, userConfigMinorVersion, userConfigPatchVersion, doubleTapSwitchLayerTimeout, iconsAndLayerTextsBrightness, alphanumericSegmentsBrightness, keyBacklightBrightness, mouseMoveInitialSpeed, mouseMoveAcceleration, mouseMoveDeceleratedSpeed, mouseMoveBaseSpeed, mouseMoveAcceleratedSpeed, mouseScrollInitialSpeed, mouseScrollAcceleration, mouseScrollDeceleratedSpeed, mouseScrollBaseSpeed, mouseScrollAcceleratedSpeed. `USERCONFIG:MAJOR`
+
 ## [3.0.0] - 2017-11-15
 
-Data Model: 2.0.0 (major bump) | USB Protocol: 2.0.0 (major bump) | Slave Protocol: 3.0.0 (major bump)
+Device Protocol: **2.0.0** | Module Protocol: **3.0.0** | User Config: **2.0.0** | Hardware Config: 1.0.0
 
 - Detect the use of USB interfaces and only wait for the ones that are actually used by the host.
 - Implement key debouncer.
@@ -15,49 +125,49 @@ Data Model: 2.0.0 (major bump) | USB Protocol: 2.0.0 (major bump) | Slave Protoc
 - Make pressing the reset button revert to the factory preset.
 - Revert to the factory default state when the reset button is pressed upon firmware startup. Display FTY on the display in this case.
 - Make the LED display show the abbreviation of the current keymap even when it gets reinitialized by the I2C watchdog.
-- Swap SlaveCommand_RequestKeyStates and SlaveCommand_JumpToBootloader, thereby making SlaveCommand_JumpToBootloader the lower number because it's more essential and shouldn't change in the future. `SLAVEPROTOCOL:MAJOR`
+- Swap SlaveCommand_RequestKeyStates and SlaveCommand_JumpToBootloader, thereby making SlaveCommand_JumpToBootloader the lower number because it's more essential and shouldn't change in the future. `MODULEPROTOCOL:MAJOR`
 - Suppress pressed keys upon layer switcher key release.
 - Handle secondary role modifiers and layer switchers.
-- Make UsbCommand_JumpToSlaveBootloader expect a slave slot id instead of a uhkModuleDriverId. `USBPROTOCOL:MAJOR`
+- Make UsbCommand_JumpToSlaveBootloader expect a slave slot id instead of a uhkModuleDriverId. `DEVICEPROTOCOL:MAJOR`
-- Set UsbResponse_InvalidCommand upon encountering with an invalid USB command. `USBPROTOCOL:MINOR`
+- Set UsbResponse_InvalidCommand upon encountering with an invalid USB command. `DEVICEPROTOCOL:MINOR`
-- Remove UsbCommandId_ReadMergeSensor now that it can be queried via UsbCommandId_GetKeyboardState. `USBPROTOCOL:MAJOR`
+- Remove UsbCommandId_ReadMergeSensor now that it can be queried via UsbCommandId_GetKeyboardState. `DEVICEPROTOCOL:MAJOR`
-- Make the getAdcValue and getDebugInfo USB commands utilize the first byte of the response to provide status as dictated by the UHK protocol. `USBPROTOCOL:MAJOR`
+- Make the getAdcValue and getDebugInfo USB commands utilize the first byte of the response to provide status as dictated by the UHK protocol. `DEVICEPROTOCOL:MAJOR`
 - Switch keymap only upon keypress.
 - Handle layer toggle actions.
 - Keep the active layer active even if another layer switcher key gets pressed while holding it.
-- Read the new UserConfig.userConfigLength user config field. `DATAMODEL:MAJOR`
+- Read the new UserConfig.userConfigLength user config field. `USERCONFIG:MAJOR`
 - Change Ctrl and Alt back according to the official UHK factory keymap.
 - Update system keyboard HID descriptor which doesn't make the pointer go to the top left corner on OSX anymore.
 - Scan keyboard matrices in a more efficient manner from timer interrupts instead of the main loop.
-- Add UsbCommand_SendKbootCommand. `USBPROTOCOL:MINOR`
+- Add UsbCommand_SendKbootCommand. `DEVICEPROTOCOL:MINOR`
-- Make the reenumerate USB command accept a timeout value. `USBPROTOCOL:MINOR`
+- Make the reenumerate USB command accept a timeout value. `DEVICEPROTOCOL:MINOR`
-- Make the config parser read the device name. `DATAMODEL:MAJOR`
+- Make the config parser read the device name. `USERCONFIG:MAJOR`
 - Update release file format containing device and module directories and hex files instead of srec.
 - Remove obsolete ARM GCC build files.
 
 ## [2.1.0] - 2017-10-13
 
-Data Model: 1.0.0 (unchanged) | USB Protocol: 1.2.0 (minor bump) | Slave Protocol: 2.1.0 (minor bump)
+Device Protocol: 1.**2.0** | Module Protocol: 2.**1.0** | User Config: 1.0.0 | Hardware Config: 1.0.0
 
-- Add jumpToSlaveBootloader USB and slave protocol command. `USBPROTOCOL:MINOR` `SLAVEPROTOCOL:MINOR`
+- Add jumpToSlaveBootloader USB and Module Protocol command. `DEVICEPROTOCOL:MINOR` `MODULEPROTOCOL:MINOR`
 - Fix generic HID descriptor enumeration error.
 
 ## [2.0.0] - 2017-10-10
 
-Data Model: 1.0.0 (unchanged) | USB Protocol: 1.1.0 (minor bump) | Slave Protocol: 2.0.0 (major bump)
+Device Protocol: 1.**1.0** | Module Protocol: **2.0.0** | User Config: 1.0.0 | Hardware Config: 1.0.0
 
 - Read the hardware and user configuration area of the EEPROM upon startup and set the default keymap.
 - Greatly improve the I2C watchdog and drivers. Communication between the halves or the add-ons should never fail again.
-- Implement generic enumeration sequence and per-slave state for UHK modules, allowing add-ons to be added. `SLAVEPROTOCOL:MAJOR`
+- Implement generic enumeration sequence and per-slave state for UHK modules, allowing add-ons to be added. `MODULEPROTOCOL:MAJOR`
 - Make the master cache the output fields of slave modules, allowing for more frequent input updates.
 - Optimize I2C protocol scheduler resulting in increased roustness and more efficient use of I2C bandwidth.
-- Add I2C message headers containing a length header, allowing for variable-length messages and a CRC16-CCITT checksum, allowing for robust communication. `SLAVEPROTOCOL:MAJOR`
+- Add I2C message headers containing a length header, allowing for variable-length messages and a CRC16-CCITT checksum, allowing for robust communication. `MODULEPROTOCOL:MAJOR`
 - Add mechanism to dump the internal state of the KL03 via SPI for debugging purposes.
-- Add merge sensor state and attached module IDs to GetDebugInfo(). `USBPROTOCOL:PATCH`
+- Add merge sensor state and attached module IDs to GetDebugInfo(). `DEVICEPROTOCOL:PATCH`
-- Throw ParserError_InvalidKeymapCount if keymapCount == 0. `DATAMODEL:PATCH`
+- Throw ParserError_InvalidKeymapCount if keymapCount == 0. `USERCONFIG:PATCH`
 
 ## [1.0.0] - 2017-08-30
 
-Data Model: 1.0.0 | USB Protocol: 1.0.0 | Slave Protocol: 1.0.0
+Device Protocol: 1.0.0 | Module Protocol: 1.0.0 | User Config: 1.0.0 | Hardware Config: 1.0.0
 
 - First Release

README.md

@@ -4,6 +4,10 @@
 
 This repository hosts the firmware of the [Ultimate Hacking Keyboard](https://ultimatehackingkeyboard.com/).
 
+## Updating to the latest firmware
+
+Want to update your UHK to the latest firmware version? Simply download the [latest release of Agent](https://github.com/UltimateHackingKeyboard/agent/releases/latest) which includes the latest firmware version. You'll be easily able to update the firmware within Agent.
+
 ## Cloning the repository
 
 Please make sure to clone this repo with:
@@ -18,9 +22,13 @@ Install [Kinetis Design Studio](http://www.nxp.com/products/software-and-tools/r
 
 ## Building and flashing the firmware
 
-For the left keyboard half, make sure to power it via the right keyboard half (which must be powered via USB). Also connect the left keyboard half to your SEGGER J-Link USB debug probe (which must also be connected via USB). Then in KDS, click on *Run -> Run Configurations*, select *GDB SEGGER J-Link Debugging -> uhk-left release jlink*, and click on the *Debug* button.
+For the left keyboard half, make sure to power it via the right keyboard half (which must be powered via USB). Also connect the left keyboard half to your SEGGER J-Link USB debug probe (which must also be connected via USB). Then in KDS, click on *Run -> Run Configurations*, select *GDB SEGGER J-Link Debugging -> uhk60-left_release_jlink*, and click on the *Debug* button.
 
-For the right keyboard half, flash [the bootloader](https://github.com/UltimateHackingKeyboard/bootloader) first. Then in KDS, click on *Run -> Run Configurations*, select *C/C++ Application -> uhk-right release blhost*, and click on the *Debug* button. Please note that this update method only works on Linux out of the box. On other operating systems, you have to execute the relevant commands of the [blhost-unix.sh](right/build/kds/blhost-unix.sh) script.
+For the right keyboard half, flash [the bootloader](https://github.com/UltimateHackingKeyboard/bootloader) first.
+
+At this point, you can flash the right firmware via USB from KDS. To achieve this, you must build [Agent](https://github.com/UltimateHackingKeyboard/agent) that is Git submodule of the this repo and located in the `lib/agent` directory.  Then in KDS, click on *Run -> Run Configurations*, select *C/C++ Application -> uhk60-right_release_kboot*, and click on the *Run* button.
+
+From this point on, you can upgrade the firmwares of both halves via USB by using the uhk60-left_release_kboot and uhk60-right_release_kboot run configurations. Alternatively, you can use your SEGGER J-Link probe.
 
 ## Contributing
 

left/build/.cproject

@@ -17,7 +17,7 @@
 				<configuration artifactExtension="elf" artifactName="${ProjName}" buildArtefactType="org.eclipse.cdt.build.core.buildArtefactType.exe" buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug,org.eclipse.cdt.build.core.buildArtefactType=org.eclipse.cdt.build.core.buildArtefactType.exe" cleanCommand="${cross_rm} -rf" description="" id="ilg.gnuarmeclipse.managedbuild.cross.config.elf.debug.1792027861" name="uhk60-left_debug" parent="ilg.gnuarmeclipse.managedbuild.cross.config.elf.debug">
 					<folderInfo id="ilg.gnuarmeclipse.managedbuild.cross.config.elf.debug.1792027861." name="/" resourcePath="">
 						<toolChain id="ilg.gnuarmeclipse.managedbuild.cross.toolchain.elf.debug.439601044" name="Cross ARM GCC" superClass="ilg.gnuarmeclipse.managedbuild.cross.toolchain.elf.debug">
-							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.level.780228407" name="Optimization Level" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.level" value="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.level.none" valueType="enumerated"/>
+							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.level.780228407" name="Optimization Level" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.level" value="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.level.most" valueType="enumerated"/>
 							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.messagelength.1547417078" name="Message length (-fmessage-length=0)" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.messagelength" value="true" valueType="boolean"/>
 							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.signedchar.765602671" name="'char' is signed (-fsigned-char)" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.signedchar" value="true" valueType="boolean"/>
 							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.functionsections.910567930" name="Function sections (-ffunction-sections)" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.functionsections" value="true" valueType="boolean"/>

left/build/.gitignore

@@ -1,3 +1,4 @@
 /.settings/
 /uhk60-left_debug/
 /uhk60-left_release/
+/uhk60-left_release/

left/build/uhk60-left_debug_jlink.launch

@@ -50,7 +50,7 @@
 <intAttribute key="org.eclipse.cdt.debug.gdbjtag.core.portNumber" value="2331"/>
 <booleanAttribute key="org.eclipse.cdt.debug.gdbjtag.core.setPcRegister" value="false"/>
 <booleanAttribute key="org.eclipse.cdt.debug.gdbjtag.core.setResume" value="false"/>
-<booleanAttribute key="org.eclipse.cdt.debug.gdbjtag.core.setStopAt" value="false"/>
+<booleanAttribute key="org.eclipse.cdt.debug.gdbjtag.core.setStopAt" value="true"/>
 <stringAttribute key="org.eclipse.cdt.debug.gdbjtag.core.stopAt" value="main"/>
 <stringAttribute key="org.eclipse.cdt.debug.gdbjtag.core.symbolsFileName" value=""/>
 <stringAttribute key="org.eclipse.cdt.debug.gdbjtag.core.symbolsOffset" value=""/>
@@ -77,6 +77,6 @@
 <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
 <listEntry value="4"/>
 </listAttribute>
-<stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#10;&lt;memoryBlockExpressionList context=&quot;Context string&quot;/&gt;&#10;"/>
+<stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#13;&#10;&lt;memoryBlockExpressionList context=&quot;Context string&quot;/&gt;&#13;&#10;"/>
 <stringAttribute key="process_factory_id" value="org.eclipse.cdt.dsf.gdb.GdbProcessFactory"/>
 </launchConfiguration>

left/build/uhk60-left_release_jlink.launch

@@ -77,6 +77,6 @@
 <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
 <listEntry value="4"/>
 </listAttribute>
-<stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#10;&lt;memoryBlockExpressionList context=&quot;Context string&quot;/&gt;&#10;"/>
+<stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#13;&#10;&lt;memoryBlockExpressionList context=&quot;Context string&quot;/&gt;&#13;&#10;"/>
 <stringAttribute key="process_factory_id" value="org.eclipse.cdt.dsf.gdb.GdbProcessFactory"/>
 </launchConfiguration>

left/src/config.h

@@ -3,6 +3,11 @@
 
 // Macros:
 
+    #define I2C_WATCHDOG_VALUE_REINIT 1
+    #define I2C_WATCHDOG_VALUE_REBOOT 2
+
 //    #define DEBUG_OVER_SPI
+    #define I2C_WATCHDOG I2C_WATCHDOG_VALUE_REINIT
+//    #define I2C_WATCHDOG I2C_WATCHDOG_VALUE_REBOOT
 
 #endif

left/src/i2c_watchdog.c

@@ -3,36 +3,40 @@
 #include "i2c_watchdog.h"
 #include "test_led.h"
 #include "init_peripherals.h"
+#include "config.h"
 
-//static uint32_t prevWatchdogCounter = 0;
+/* NOTE: Because of a bug in the ROM bootloader of the KL03Z, the watchdog timer is disabled and cannot be re-enabled.
-uint32_t I2cWatchdog_RecoveryCounter;
+ * See https://community.nxp.com/thread/457893
-volatile uint32_t I2cWatchdog_WatchCounter;
+ * Therefore the hardware watchdog timer cannot be used without an extra way to enter bootloader or application mode.
+ */
+#ifdef I2C_WATCHDOG
+  static uint32_t prevWatchdogCounter = 0;
+  static uint32_t I2cWatchdog_RecoveryCounter; /* counter for how many times we had to recover and restart */
 
-void InitI2cWatchdog(void)
+void RunWatchdog(void)
 {
-    lptmr_config_t lptmrConfig;
+    static volatile uint32_t I2cWatchdog_WatchCounter = 0; /* counter for timer */
-    LPTMR_GetDefaultConfig(&lptmrConfig);
+    static int cntr = 0;
-    LPTMR_Init(LPTMR0, &lptmrConfig);
-    LPTMR_SetTimerPeriod(LPTMR0, USEC_TO_COUNT(LPTMR_USEC_COUNT, LPTMR_SOURCE_CLOCK));
-    LPTMR_EnableInterrupts(LPTMR0, kLPTMR_TimerInterruptEnable);
-    EnableIRQ(LPTMR0_IRQn);
-    LPTMR_StartTimer(LPTMR0);
-}
-/*
-void I2C_WATCHDOG_LPTMR_HANDLER(void)
-{
-    TEST_LED_TOGGLE();
-    I2cWatchdog_WatchCounter++;
 
-    if (I2C_Watchdog == prevWatchdogCounter) { // Restart I2C if there hasn't been any interrupt during 100 ms
+    cntr++;
-//        NVIC_SystemReset();
+    if (cntr==100) { /* we get called from KEY_SCANNER_HANDLER() which runs at 1ms, thus scaling down by 100 here to get 100 ms period */
-        I2cWatchdog_RecoveryCounter++;
+        cntr=0;
-        I2C_SlaveDeinit(I2C_BUS_BASEADDR);
+        TEST_LED_TOGGLE();
-        InitI2c();
+        I2cWatchdog_WatchCounter++;
+
+        if (I2cWatchdog_WatchCounter>10) { /* do not check within the first 1000 ms, as I2C might not be running yet */
+            if (I2C_Watchdog == prevWatchdogCounter) { // Restart I2C if there hasn't been any interrupt during 100 ms. I2C_Watchdog gets incremented for every I2C transaction
+                I2cWatchdog_RecoveryCounter++;
+#if I2C_WATCHDOG == I2C_WATCHDOG_VALUE_REBOOT
+                NVIC_SystemReset();
+#endif
+#if I2C_WATCHDOG == I2C_WATCHDOG_VALUE_REINIT
+                I2C_SlaveDeinit(I2C_BUS_BASEADDR);
+                initI2c();
+#endif
+            }
+        }
+        prevWatchdogCounter = I2C_Watchdog; /* remember previous counter */
     }
-
-    prevWatchdogCounter = I2C_Watchdog;
-
-    LPTMR_ClearStatusFlags(LPTMR0, kLPTMR_TimerCompareFlag);
 }
-*/
+#endif

left/src/i2c_watchdog.h

@@ -13,7 +13,6 @@
 
 // Functions:
 
-    void InitI2cWatchdog(void);
     void RunWatchdog(void);
 
 #endif

left/src/init_peripherals.c

@@ -10,6 +10,7 @@
 #include "slave_protocol_handler.h"
 #include "i2c_watchdog.h"
 #include "debug_over_spi.h"
+#include "main.h"
 
 i2c_slave_config_t slaveConfig;
 i2c_slave_handle_t slaveHandle;
@@ -44,14 +45,14 @@ static void i2cSlaveCallback(I2C_Type *base, i2c_slave_transfer_t *xfer, void *u
     }
 }
 
-void InitInterruptPriorities(void)
+void initInterruptPriorities(void)
 {
     NVIC_SetPriority(I2C0_IRQn, 1);
     NVIC_SetPriority(TPM1_IRQn, 1);
     NVIC_SetPriority(SPI0_IRQn, 1);
 }
 
-void InitI2c(void)
+void initI2c(void)
 {
     port_pin_config_t pinConfig = {
         .pullSelect = kPORT_PullUp,
@@ -81,11 +82,10 @@ void InitLedDriver(void)
 
 void InitPeripherals(void)
 {
-    InitInterruptPriorities();
+    initInterruptPriorities();
     InitLedDriver();
     InitTestLed();
     LedPwm_Init();
-//    InitI2cWatchdog();
     DebugOverSpi_Init();
-    InitI2c();
+    initI2c();
 }

left/src/init_peripherals.h

@@ -11,6 +11,6 @@
 // Functions:
 
     void InitPeripherals(void);
-    void InitI2c(void);
+    void initI2c(void);
 
 #endif

left/src/key_scanner.c

@@ -1,10 +1,14 @@
 #include "fsl_lptmr.h"
 #include "key_scanner.h"
-#include "main.h"
+#include "config.h"
+#include "i2c_watchdog.h"
 
 void KEY_SCANNER_HANDLER(void)
 {
     KeyMatrix_ScanRow(&keyMatrix);
+#ifdef I2C_WATCHDOG
+    RunWatchdog();
+#endif
     LPTMR_ClearStatusFlags(KEY_SCANNER_LPTMR_BASEADDR, kLPTMR_TimerCompareFlag);
 }
 

left/src/module.h

@@ -6,6 +6,6 @@
     #define MODULE_PROTOCOL_VERSION 1
     #define MODULE_ID ModuleId_LeftKeyboardHalf
     #define MODULE_KEY_COUNT (KEYBOARD_MATRIX_ROWS_NUM * KEYBOARD_MATRIX_COLS_NUM)
-    #define MODULE_HAS_POINTER false
+    #define MODULE_POINTER_COUNT 0
 
 #endif

left/src/slave_protocol_handler.c

@@ -10,10 +10,23 @@
 #include "bool_array_converter.h"
 #include "bootloader.h"
 #include "module.h"
+#include "versions.h"
 
 i2c_message_t RxMessage;
 i2c_message_t TxMessage;
 
+static version_t moduleProtocolVersion = {
+    MODULE_PROTOCOL_MAJOR_VERSION,
+    MODULE_PROTOCOL_MINOR_VERSION,
+    MODULE_PROTOCOL_PATCH_VERSION,
+};
+
+static version_t firmwareVersion = {
+    FIRMWARE_MAJOR_VERSION,
+    FIRMWARE_MINOR_VERSION,
+    FIRMWARE_PATCH_VERSION,
+};
+
 void SlaveRxHandler(void)
 {
     if (!CRC16_IsMessageValid(&RxMessage)) {
@@ -51,21 +64,29 @@ void SlaveTxHandler(void)
                     TxMessage.length = SLAVE_SYNC_STRING_LENGTH;
                     break;
                 }
+                case SlaveProperty_ModuleProtocolVersion: {
+                    memcpy(TxMessage.data, &moduleProtocolVersion, sizeof(version_t));
+                    TxMessage.length = sizeof(version_t);
+                    break;
+                }
+                case SlaveProperty_FirmwareVersion: {
+                    memcpy(TxMessage.data, &firmwareVersion, sizeof(version_t));
+                    TxMessage.length = sizeof(version_t);
+                    break;
+                }
                 case SlaveProperty_ModuleId: {
                     TxMessage.data[0] = MODULE_ID;
                     TxMessage.length = 1;
                     break;
                 }
-                case SlaveProperty_ProtocolVersion: {
+                case SlaveProperty_KeyCount: {
-                    TxMessage.data[0] = MODULE_PROTOCOL_VERSION;
+                    TxMessage.data[0] = MODULE_KEY_COUNT;
                     TxMessage.length = 1;
                     break;
                 }
-                case SlaveProperty_Features: {
+                case SlaveProperty_PointerCount: {
-                    uhk_module_features_t *moduleFeatures = (uhk_module_features_t*)&TxMessage.data;
+                    TxMessage.data[0] = MODULE_POINTER_COUNT;
-                    moduleFeatures->keyCount = MODULE_KEY_COUNT;
+                    TxMessage.length = 1;
-                    moduleFeatures->hasPointer = MODULE_HAS_POINTER;
-                    TxMessage.length = sizeof(uhk_module_features_t);
                     break;
                 }
             }

right/build/.cproject

@@ -17,7 +17,7 @@
 				<configuration artifactExtension="elf" artifactName="${ProjName}" buildArtefactType="org.eclipse.cdt.build.core.buildArtefactType.exe" buildProperties="org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release,org.eclipse.cdt.build.core.buildArtefactType=org.eclipse.cdt.build.core.buildArtefactType.exe" cleanCommand="${cross_rm} -rf" description="" id="ilg.gnuarmeclipse.managedbuild.cross.config.elf.release.1939339834.1692217331" name="uhk60-right_release" parent="ilg.gnuarmeclipse.managedbuild.cross.config.elf.release">
 					<folderInfo id="ilg.gnuarmeclipse.managedbuild.cross.config.elf.release.1939339834.1692217331." name="/" resourcePath="">
 						<toolChain id="ilg.gnuarmeclipse.managedbuild.cross.toolchain.elf.release.453692058" name="Cross ARM GCC" superClass="ilg.gnuarmeclipse.managedbuild.cross.toolchain.elf.release">
-							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.level.8609064" name="Optimization Level" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.level" value="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.level.size" valueType="enumerated"/>
+							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.level.8609064" name="Optimization Level" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.level" value="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.level.most" valueType="enumerated"/>
 							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.messagelength.704315278" name="Message length (-fmessage-length=0)" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.messagelength" value="true" valueType="boolean"/>
 							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.signedchar.108613118" name="'char' is signed (-fsigned-char)" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.signedchar" value="true" valueType="boolean"/>
 							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.functionsections.916504304" name="Function sections (-ffunction-sections)" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.optimization.functionsections" value="true" valueType="boolean"/>
@@ -136,9 +136,6 @@
 							</tool>
 						</toolChain>
 					</folderInfo>
-					<fileInfo id="ilg.gnuarmeclipse.managedbuild.cross.config.elf.release.1939339834.1692217331.621318926" name="wormhole.c" rcbsApplicability="disable" resourcePath="bootloader-shared/wormhole.c" toolsToInvoke="ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.813655335.948885614">
-						<tool id="ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.813655335.948885614" name="Cross ARM C Compiler" superClass="ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.813655335"/>
-					</fileInfo>
 				</configuration>
 			</storageModule>
 			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>

right/build/MK22FN512xxx12_flash.ld

@@ -196,21 +196,27 @@ SECTIONS
   text_end = ORIGIN(m_text) + LENGTH(m_text);
   ASSERT(__DATA_END <= text_end, "region m_text overflowed with text and data")
 
-  USB_RAM_GAP = DEFINED(__usb_ram_size__) ? __usb_ram_size__ : 0x800;
   /* Uninitialized data section */
-  .bss :
+  .bss : ALIGN(4)
   {
     /* This is used by the startup in order to initialize the .bss section */
-    . = ALIGN(4);
     __START_BSS = .;
     __bss_start__ = .;
     *(.bss)
     *(.bss*)
-    . = ALIGN(512);
-    USB_RAM_START = .;
-    . += USB_RAM_GAP;
     *(COMMON)
     . = ALIGN(4);
+  } > m_data
+  
+  .m_usb_bdt (NOLOAD) :
+  {
+    . = ALIGN(512); 
+    *(m_usb_bdt)
+  } > m_data
+
+  .m_usb_global (NOLOAD) :
+  {
+    *(m_usb_global)
     __bss_end__ = .;
     __END_BSS = .;
   } > m_data
@@ -239,17 +245,6 @@ SECTIONS
     . += STACK_SIZE;
   } > m_data_2
 
-  m_usb_bdt USB_RAM_START (NOLOAD) :
-  {
-    *(m_usb_bdt)
-    USB_RAM_BDT_END = .;
-  }
-
-  m_usb_global USB_RAM_BDT_END (NOLOAD) :
-  {
-    *(m_usb_global)
-  }
-
   /* Initializes stack on the end of block */
   __StackTop   = ORIGIN(m_data_2) + LENGTH(m_data_2);
   __StackLimit = __StackTop - STACK_SIZE;

right/build/uhk60-right_debug_standalone_jlink.launch

@@ -64,10 +64,10 @@
 <intAttribute key="org.eclipse.cdt.launch.ATTR_BUILD_BEFORE_LAUNCH_ATTR" value="2"/>
 <stringAttribute key="org.eclipse.cdt.launch.COREFILE_PATH" value=""/>
 <stringAttribute key="org.eclipse.cdt.launch.DEBUGGER_REGISTER_GROUPS" value=""/>
-<stringAttribute key="org.eclipse.cdt.launch.PROGRAM_NAME" value="uhk60-right_debug/uhk-right.elf"/>
+<stringAttribute key="org.eclipse.cdt.launch.PROGRAM_NAME" value="uhk60-right_debug_standalone/uhk-right.elf"/>
 <stringAttribute key="org.eclipse.cdt.launch.PROJECT_ATTR" value="uhk-right"/>
 <booleanAttribute key="org.eclipse.cdt.launch.PROJECT_BUILD_CONFIG_AUTO_ATTR" value="false"/>
-<stringAttribute key="org.eclipse.cdt.launch.PROJECT_BUILD_CONFIG_ID_ATTR" value="ilg.gnuarmeclipse.managedbuild.cross.config.elf.release.1939339834.1692217331.1297236062.2081695142"/>
+<stringAttribute key="org.eclipse.cdt.launch.PROJECT_BUILD_CONFIG_ID_ATTR" value=""/>
 <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
 <listEntry value="/uhk-right"/>
 </listAttribute>
@@ -77,6 +77,6 @@
 <listAttribute key="org.eclipse.debug.ui.favoriteGroups">
 <listEntry value="org.eclipse.debug.ui.launchGroup.debug"/>
 </listAttribute>
-<stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#10;&lt;memoryBlockExpressionList context=&quot;Context string&quot;/&gt;&#10;"/>
+<stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#13;&#10;&lt;memoryBlockExpressionList context=&quot;Context string&quot;/&gt;&#13;&#10;"/>
 <stringAttribute key="process_factory_id" value="org.eclipse.cdt.dsf.gdb.GdbProcessFactory"/>
 </launchConfiguration>

right/src/config.h

@@ -4,6 +4,7 @@
 // Macros:
 
     #define I2C_WATCHDOG
+    #define LED_DRIVERS_ENABLED
 //    #define LED_DRIVER_STRESS_TEST
 
 #endif

right/src/config_parser/basic_types.c

@@ -8,7 +8,6 @@ uint8_t ReadUInt8(config_buffer_t *buffer)
 uint16_t ReadUInt16(config_buffer_t *buffer)
 {
     uint16_t uInt16 = ReadUInt8(buffer);
-
     uInt16 |= ReadUInt8(buffer) << 8;
     return uInt16;
 }
@@ -26,14 +25,12 @@ bool ReadBool(config_buffer_t *buffer)
 uint16_t ReadCompactLength(config_buffer_t *buffer)
 {
     uint16_t compactLength = ReadUInt8(buffer);
-
     return compactLength == 0xFF ? ReadUInt16(buffer) : compactLength;
 }
 
 const char *ReadString(config_buffer_t *buffer, uint16_t *len)
 {
     const char *string;
-
     *len = ReadCompactLength(buffer);
     string = (const char *)(buffer->buffer + buffer->offset);
     buffer->offset += *len;

right/src/config_parser/config_globals.c

@@ -12,6 +12,11 @@ config_buffer_t ValidatedUserConfigBuffer = { validatedUserConfig };
 
 bool ParserRunDry;
 
+bool IsConfigBufferIdValid(config_buffer_id_t configBufferId)
+{
+    return ConfigBufferId_HardwareConfig <= configBufferId && configBufferId <= ConfigBufferId_ValidatedUserConfig;
+}
+
 config_buffer_t* ConfigBufferIdToConfigBuffer(config_buffer_id_t configBufferId)
 {
     switch (configBufferId) {
@@ -25,3 +30,16 @@ config_buffer_t* ConfigBufferIdToConfigBuffer(config_buffer_id_t configBufferId)
             return NULL;
     }
 }
+
+uint16_t ConfigBufferIdToBufferSize(config_buffer_id_t configBufferId)
+{
+    switch (configBufferId) {
+        case ConfigBufferId_HardwareConfig:
+            return HARDWARE_CONFIG_SIZE;
+        case ConfigBufferId_StagingUserConfig:
+        case ConfigBufferId_ValidatedUserConfig:
+            return USER_CONFIG_SIZE;
+        default:
+            return 0;
+    }
+}

right/src/config_parser/config_globals.h

@@ -23,6 +23,8 @@
 
     // Functions:
 
+    bool IsConfigBufferIdValid(config_buffer_id_t configBufferId);
     config_buffer_t* ConfigBufferIdToConfigBuffer(config_buffer_id_t configBufferId);
+    uint16_t ConfigBufferIdToBufferSize(config_buffer_id_t configBufferId);
 
 #endif

right/src/config_parser/parse_config.c

@@ -4,35 +4,96 @@
 #include "keymap.h"
 #include "config_globals.h"
 #include "macros.h"
+#include "usb_report_updater.h"
+#include "led_display.h"
+#include "slave_scheduler.h"
+#include "slave_drivers/is31fl3731_driver.h"
+#include "config.h"
 
 static parser_error_t parseModuleConfiguration(config_buffer_t *buffer)
 {
     uint8_t id = ReadUInt8(buffer);
-    uint8_t initialPointerSpeed = ReadUInt8(buffer);
+    uint8_t pointerMode = ReadUInt8(buffer);  // move vs scroll
-    uint8_t pointerAcceleration = ReadUInt8(buffer);
+    uint8_t deceleratedPointerSpeedMultiplier = ReadUInt8(buffer);
-    uint8_t maxPointerSpeed = ReadUInt8(buffer);
+    uint8_t basePointerSpeedMultiplier = ReadUInt8(buffer);
+    uint8_t acceleratedPointerSpeed = ReadUInt8(buffer);
+    uint16_t angularShift = ReadUInt16(buffer);
+    uint8_t modLayerPointerFunction = ReadUInt8(buffer);  // none vs invertMode vs decelerate vs accelerate
+    uint8_t fnLayerPointerFunction = ReadUInt8(buffer);  // none vs invertMode vs decelerate vs accelerate
+    uint8_t mouseLayerPointerFunction = ReadUInt8(buffer);  // none vs invertMode vs decelerate vs accelerate
 
     (void)id;
-    (void)initialPointerSpeed;
+    (void)pointerMode;
-    (void)pointerAcceleration;
+    (void)deceleratedPointerSpeedMultiplier;
-    (void)maxPointerSpeed;
+    (void)basePointerSpeedMultiplier;
+    (void)acceleratedPointerSpeed;
+    (void)angularShift;
+    (void)modLayerPointerFunction;
+    (void)fnLayerPointerFunction;
+    (void)mouseLayerPointerFunction;
+
     return ParserError_Success;
 }
 
 parser_error_t ParseConfig(config_buffer_t *buffer)
 {
+    // Miscellaneous properties
+
     uint16_t len;
     uint16_t macroCount;
     uint16_t keymapCount;
     parser_error_t errorCode;
 
-    uint16_t dataModelVersion = ReadUInt16(buffer);
+    uint16_t dataModelMajorVersion = ReadUInt16(buffer);
+    uint16_t dataModelMinorVersion = ReadUInt16(buffer);
+    uint16_t dataModelPatchVersion = ReadUInt16(buffer);
     uint16_t userConfigLength = ReadUInt16(buffer);
-    (void)userConfigLength;
+    const char *deviceName = ReadString(buffer, &len);
-    ReadString(buffer, &len); // Ignore device name
+    uint16_t doubleTapSwitchLayerTimeout = ReadUInt16(buffer);
-    uint16_t moduleConfigurationCount = ReadCompactLength(buffer);
 
-    (void)dataModelVersion;
+    (void)userConfigLength;
+    (void)dataModelMajorVersion;
+    (void)dataModelMinorVersion;
+    (void)dataModelPatchVersion;
+    (void)deviceName;
+    (void)doubleTapSwitchLayerTimeout;
+
+    // LED brightness
+
+    uint8_t iconsAndLayerTextsBrightness = ReadUInt8(buffer);
+    uint8_t alphanumericSegmentsBrightness = ReadUInt8(buffer);
+    uint8_t keyBacklightBrightness = ReadUInt8(buffer);
+
+    // Mouse kinetic properties
+
+    uint8_t mouseMoveInitialSpeed = ReadUInt8(buffer);
+    uint8_t mouseMoveAcceleration = ReadUInt8(buffer);
+    uint8_t mouseMoveDeceleratedSpeed = ReadUInt8(buffer);
+    uint8_t mouseMoveBaseSpeed = ReadUInt8(buffer);
+    uint8_t mouseMoveAcceleratedSpeed = ReadUInt8(buffer);
+    uint8_t mouseScrollInitialSpeed = ReadUInt8(buffer);
+    uint8_t mouseScrollAcceleration = ReadUInt8(buffer);
+    uint8_t mouseScrollDeceleratedSpeed = ReadUInt8(buffer);
+    uint8_t mouseScrollBaseSpeed = ReadUInt8(buffer);
+    uint8_t mouseScrollAcceleratedSpeed = ReadUInt8(buffer);
+
+    if (mouseMoveInitialSpeed == 0 ||
+        mouseMoveAcceleration == 0 ||
+        mouseMoveDeceleratedSpeed == 0 ||
+        mouseMoveBaseSpeed == 0 ||
+        mouseMoveAcceleratedSpeed == 0 ||
+        mouseScrollInitialSpeed == 0 ||
+        mouseScrollAcceleration == 0 ||
+        mouseScrollDeceleratedSpeed == 0 ||
+        mouseScrollBaseSpeed == 0 ||
+        mouseScrollAcceleratedSpeed == 0)
+    {
+        return ParserError_InvalidMouseKineticProperty;
+    }
+
+    // Module configurations
+
+    uint16_t moduleConfigurationCount = ReadCompactLength(buffer);
 
     if (moduleConfigurationCount > 255) {
         return ParserError_InvalidModuleConfigurationCount;
@@ -45,6 +106,8 @@ parser_error_t ParseConfig(config_buffer_t *buffer)
         }
     }
 
+    // Macros
+
     macroCount = ReadCompactLength(buffer);
     if (macroCount > MAX_MACRO_NUM) {
         return ParserError_InvalidMacroCount;
@@ -57,6 +120,8 @@ parser_error_t ParseConfig(config_buffer_t *buffer)
         }
     }
 
+    // Keymaps
+
     keymapCount = ReadCompactLength(buffer);
     if (keymapCount == 0 || keymapCount > MAX_KEYMAP_NUM) {
         return ParserError_InvalidKeymapCount;
@@ -69,7 +134,36 @@ parser_error_t ParseConfig(config_buffer_t *buffer)
         }
     }
 
+    // If parsing succeeded then apply the parsed values.
+
     if (!ParserRunDry) {
+//        DoubleTapSwitchLayerTimeout = doubleTapSwitchLayerTimeout;
+
+        // Update LED brightnesses and reinitialize LED drivers
+
+        IconsAndLayerTextsBrightness = iconsAndLayerTextsBrightness;
+        AlphanumericSegmentsBrightness = alphanumericSegmentsBrightness;
+        KeyBacklightBrightness = keyBacklightBrightness;
+#ifdef LED_DRIVERS_ENABLED
+        Slaves[SlaveId_LeftLedDriver].isConnected = false;
+        Slaves[SlaveId_RightLedDriver].isConnected = false;
+#endif
+        // Update mouse key speeds
+
+        MouseMoveState.initialSpeed = mouseMoveInitialSpeed;
+        MouseMoveState.acceleration = mouseMoveAcceleration;
+        MouseMoveState.deceleratedSpeed = mouseMoveDeceleratedSpeed;
+        MouseMoveState.baseSpeed = mouseMoveBaseSpeed;
+        MouseMoveState.acceleratedSpeed = mouseMoveAcceleratedSpeed;
+
+        MouseScrollState.initialSpeed = mouseScrollInitialSpeed;
+        MouseScrollState.acceleration = mouseScrollAcceleration;
+        MouseScrollState.deceleratedSpeed = mouseScrollDeceleratedSpeed;
+        MouseScrollState.baseSpeed = mouseScrollBaseSpeed;
+        MouseScrollState.acceleratedSpeed = mouseScrollAcceleratedSpeed;
+
+        // Update counts
+
         AllKeymapsCount = keymapCount;
         AllMacrosCount = macroCount;
     }

right/src/config_parser/parse_config.h

@@ -8,20 +8,21 @@
 // Typedefs:
 
     typedef enum {
-        ParserError_Success,
+        ParserError_Success                             =  0,
-        ParserError_InvalidSerializedKeystrokeType,
+        ParserError_InvalidSerializedKeystrokeType      =  1,
-        ParserError_InvalidSerializedMouseAction,
+        ParserError_InvalidSerializedMouseAction        =  2,
-        ParserError_InvalidSerializedKeyActionType,
+        ParserError_InvalidSerializedKeyActionType      =  3,
-        ParserError_InvalidLayerCount,
+        ParserError_InvalidLayerCount                   =  4,
-        ParserError_InvalidModuleCount,
+        ParserError_InvalidModuleCount                  =  5,
-        ParserError_InvalidActionCount,
+        ParserError_InvalidActionCount                  =  6,
-        ParserError_InvalidSerializedMacroActionType,
+        ParserError_InvalidSerializedMacroActionType    =  7,
-        ParserError_InvalidSerializedSwitchKeymapAction,
+        ParserError_InvalidSerializedSwitchKeymapAction =  8,
-        ParserError_InvalidModuleConfigurationCount,
+        ParserError_InvalidModuleConfigurationCount     =  9,
-        ParserError_InvalidKeymapCount,
+        ParserError_InvalidKeymapCount                  = 10,
-        ParserError_InvalidAbbreviationLen,
+        ParserError_InvalidAbbreviationLen              = 11,
-        ParserError_InvalidMacroCount,
+        ParserError_InvalidMacroCount                   = 12,
-        ParserError_InvalidSerializedPlayMacroAction,
+        ParserError_InvalidSerializedPlayMacroAction    = 13,
+        ParserError_InvalidMouseKineticProperty         = 14,
     } parser_error_t;
 
 // Functions:

right/src/config_parser/parse_keymap.c

@@ -48,11 +48,11 @@ static parser_error_t parseKeyStrokeAction(key_action_t *keyAction, uint8_t keyS
 static parser_error_t parseSwitchLayerAction(key_action_t *KeyAction, config_buffer_t *buffer)
 {
     uint8_t layer = ReadUInt8(buffer) + 1;
-    bool isToggle = ReadBool(buffer);
+    uint8_t mode = ReadBool(buffer) ? SwitchLayerMode_Toggle : SwitchLayerMode_HoldAndDoubleTapToggle;
 
     KeyAction->type = KeyActionType_SwitchLayer;
     KeyAction->switchLayer.layer = layer;
-    KeyAction->switchLayer.isToggle = isToggle;
+    KeyAction->switchLayer.mode = mode;
     return ParserError_Success;
 }
 
@@ -82,53 +82,16 @@ static parser_error_t parsePlayMacroAction(key_action_t *keyAction, config_buffe
 
 static parser_error_t parseMouseAction(key_action_t *keyAction, config_buffer_t *buffer)
 {
-    uint8_t mouseAction = ReadUInt8(buffer);
-
     keyAction->type = KeyActionType_Mouse;
-    memset(&keyAction->mouse, 0, sizeof keyAction->mouse);
+
-    switch (mouseAction) {
+    uint8_t mouseAction = ReadUInt8(buffer);
-        case SerializedMouseAction_LeftClick:
+    if (mouseAction > SerializedMouseAction_Last) {
-            keyAction->mouse.buttonActions = MouseButton_Left;
+        return ParserError_InvalidSerializedMouseAction;
-            break;
-        case SerializedMouseAction_MiddleClick:
-            keyAction->mouse.buttonActions = MouseButton_Middle;
-            break;
-        case SerializedMouseAction_RightClick:
-            keyAction->mouse.buttonActions = MouseButton_Right;
-            break;
-        case SerializedMouseAction_MoveUp:
-            keyAction->mouse.moveActions = MouseMove_Up;
-            break;
-        case SerializedMouseAction_MoveDown:
-            keyAction->mouse.moveActions = MouseMove_Down;
-            break;
-        case SerializedMouseAction_MoveLeft:
-            keyAction->mouse.moveActions = MouseMove_Left;
-            break;
-        case SerializedMouseAction_MoveRight:
-            keyAction->mouse.moveActions = MouseMove_Right;
-            break;
-        case SerializedMouseAction_ScrollUp:
-            keyAction->mouse.scrollActions = MouseScroll_Up;
-            break;
-        case SerializedMouseAction_ScrollDown:
-            keyAction->mouse.scrollActions = MouseScroll_Down;
-            break;
-        case SerializedMouseAction_ScrollLeft:
-            keyAction->mouse.scrollActions = MouseScroll_Left;
-            break;
-        case SerializedMouseAction_ScrollRight:
-            keyAction->mouse.scrollActions = MouseScroll_Right;
-            break;
-        case SerializedMouseAction_Accelerate:
-            keyAction->mouse.moveActions = MouseMove_Accelerate;
-            break;
-        case SerializedMouseAction_Decelerate:
-            keyAction->mouse.moveActions = MouseMove_Decelerate;
-            break;
-        default:
-            return ParserError_InvalidSerializedMouseAction;
     }
+
+    memset(&keyAction->mouseAction, 0, sizeof keyAction->mouseAction);
+    keyAction->mouseAction = mouseAction;
+
     return ParserError_Success;
 }
 
@@ -153,7 +116,7 @@ static parser_error_t parseKeyAction(key_action_t *keyAction, config_buffer_t *b
     return ParserError_InvalidSerializedKeyActionType;
 }
 
-static parser_error_t parseKeyActions(uint8_t targetLayer, config_buffer_t *buffer, uint8_t moduleId, uint8_t pointerRole)
+static parser_error_t parseKeyActions(uint8_t targetLayer, config_buffer_t *buffer, uint8_t moduleId)
 {
     parser_error_t errorCode;
     uint16_t actionCount = ReadCompactLength(buffer);
@@ -174,9 +137,7 @@ static parser_error_t parseKeyActions(uint8_t targetLayer, config_buffer_t *buff
 static parser_error_t parseModule(config_buffer_t *buffer, uint8_t layer)
 {
     uint8_t moduleId = ReadUInt8(buffer);
-    uint8_t pointerRole = ReadUInt8(buffer);
+    return parseKeyActions(layer, buffer, moduleId);
-
-    return parseKeyActions(layer, buffer, moduleId, pointerRole);
 }
 
 static parser_error_t parseLayer(config_buffer_t *buffer, uint8_t layer)

right/src/config_parser/parse_keymap.h

@@ -48,6 +48,10 @@
         SerializedMouseAction_ScrollRight,
         SerializedMouseAction_Accelerate,
         SerializedMouseAction_Decelerate,
+        SerializedMouseAction_Last = SerializedMouseAction_Decelerate,
+        SerializedMouseAction_Button_4,
+        SerializedMouseAction_Button_5,
+        SerializedMouseAction_Button_6,
     } serialized_mouse_action_t;
 
 // Functions:

right/src/eeprom.c

@@ -6,11 +6,11 @@
 #include "config_parser/config_globals.h"
 #include "buffer.h"
 
-bool IsEepromBusy;
+volatile bool IsEepromBusy;
 static eeprom_operation_t CurrentEepromOperation;
 static config_buffer_id_t CurrentConfigBufferId;
-status_t LastEepromTransferStatus;
+static status_t LastEepromTransferStatus;
-void (*SuccessCallback)();
+void (*SuccessCallback)(void);
 
 static i2c_master_handle_t i2cHandle;
 static i2c_master_transfer_t i2cTransfer;
@@ -21,7 +21,6 @@ static uint16_t eepromStartAddress;
 static uint16_t sourceLength;
 static uint8_t writeLength;
 static bool isReadSent;
-static uint8_t addressBuffer[EEPROM_ADDRESS_LENGTH];
 
 static status_t i2cAsyncWrite(uint8_t *data, size_t dataSize)
 {
@@ -44,11 +43,10 @@ static status_t i2cAsyncRead(uint8_t *data, size_t dataSize)
 static status_t writePage(void)
 {
     static uint8_t buffer[EEPROM_BUFFER_SIZE];
-    uint16_t targetEepromOffset = sourceOffset + eepromStartAddress;
+    SetBufferUint16Be(buffer, 0, eepromStartAddress + sourceOffset);
-    SetBufferUint16Be(buffer, 0, targetEepromOffset);
     writeLength = MIN(sourceLength - sourceOffset, EEPROM_PAGE_SIZE);
-    memcpy(buffer+EEPROM_ADDRESS_LENGTH, sourceBuffer+sourceOffset, writeLength);
+    memcpy(buffer+EEPROM_ADDRESS_SIZE, sourceBuffer+sourceOffset, writeLength);
-    status_t status = i2cAsyncWrite(buffer, writeLength+EEPROM_ADDRESS_LENGTH);
+    status_t status = i2cAsyncWrite(buffer, writeLength+EEPROM_ADDRESS_SIZE);
     return status;
 }
 
@@ -104,16 +102,17 @@ status_t EEPROM_LaunchTransfer(eeprom_operation_t operation, config_buffer_id_t
 
     CurrentEepromOperation = operation;
     CurrentConfigBufferId = config_buffer_id;
-
     SuccessCallback = successCallback;
+
     bool isHardwareConfig = CurrentConfigBufferId == ConfigBufferId_HardwareConfig;
     eepromStartAddress = isHardwareConfig ? 0 : HARDWARE_CONFIG_SIZE;
-    SetBufferUint16Be(addressBuffer, 0, eepromStartAddress);
 
     switch (CurrentEepromOperation) {
         case EepromOperation_Read:
             isReadSent = false;
-            LastEepromTransferStatus = i2cAsyncWrite(addressBuffer, EEPROM_ADDRESS_LENGTH);
+            static uint8_t addressBuffer[EEPROM_ADDRESS_SIZE];
+            SetBufferUint16Be(addressBuffer, 0, eepromStartAddress);
+            LastEepromTransferStatus = i2cAsyncWrite(addressBuffer, EEPROM_ADDRESS_SIZE);
             break;
         case EepromOperation_Write:
             sourceBuffer = ConfigBufferIdToConfigBuffer(CurrentConfigBufferId)->buffer;
@@ -126,3 +125,8 @@ status_t EEPROM_LaunchTransfer(eeprom_operation_t operation, config_buffer_id_t
     IsEepromBusy = LastEepromTransferStatus == kStatus_Success;
     return LastEepromTransferStatus;
 }
+
+bool IsEepromOperationValid(eeprom_operation_t operation)
+{
+    return operation == EepromOperation_Read || operation == EepromOperation_Write;
+}

right/src/eeprom.h

@@ -11,9 +11,9 @@
     #define HARDWARE_CONFIG_SIZE 64
     #define USER_CONFIG_SIZE (EEPROM_SIZE - HARDWARE_CONFIG_SIZE)
 
-    #define EEPROM_ADDRESS_LENGTH 2
+    #define EEPROM_ADDRESS_SIZE 2
     #define EEPROM_PAGE_SIZE 64
-    #define EEPROM_BUFFER_SIZE (EEPROM_ADDRESS_LENGTH + EEPROM_PAGE_SIZE)
+    #define EEPROM_BUFFER_SIZE (EEPROM_ADDRESS_SIZE + EEPROM_PAGE_SIZE)
 
 // Typedefs:
 
@@ -24,12 +24,12 @@
 
 // Variables:
 
-    extern bool IsEepromBusy;
+    extern volatile bool IsEepromBusy;
-    extern status_t EepromTransferStatus;
 
 // Functions:
 
     void EEPROM_Init(void);
     status_t EEPROM_LaunchTransfer(eeprom_operation_t operation, config_buffer_id_t config_buffer_id, void (*successCallback));
+    bool IsEepromOperationValid(eeprom_operation_t operation);
 
 #endif

right/src/i2c.h

@@ -10,10 +10,12 @@
 
     // Main bus
 
-    #define I2C_MAIN_BUS_BASEADDR  I2C0
+    #define I2C_MAIN_BUS_BASEADDR         I2C0
-    #define I2C_MASTER_BUS_CLK_SRC I2C0_CLK_SRC
+    #define I2C_MAIN_BUS_IRQ_ID           I2C0_IRQn
-    #define I2C_MAIN_BUS_BAUD_RATE 100000 // 100 kHz works even with a 20 meter long bridge cable.
+    #define I2C_MAIN_BUS_CLK_SRC          I2C0_CLK_SRC
-    #define I2C_MAIN_BUS_MUX       kPORT_MuxAlt7
+    #define I2C_MAIN_BUS_NORMAL_BAUD_RATE 100000
+    #define I2C_MAIN_BUS_BUSPAL_BAUD_RATE 30000
+    #define I2C_MAIN_BUS_MUX              kPORT_MuxAlt7
 
     #define I2C_MAIN_BUS_SDA_GPIO  GPIOD
     #define I2C_MAIN_BUS_SDA_PORT  PORTD
@@ -28,8 +30,9 @@
     // EEPROM bus
 
     #define I2C_EEPROM_BUS_BASEADDR  I2C1
+    #define I2C_EEPROM_BUS_IRQ_ID    I2C1_IRQn
     #define I2C_EEPROM_BUS_CLK_SRC   I2C1_CLK_SRC
-    #define I2C_EEPROM_BUS_BAUD_RATE 1000000 // 1 Mhz is the maximum speed of the EEPROM.
+    #define I2C_EEPROM_BUS_BAUD_RATE 1000000  // 1 Mhz is the maximum speed of the EEPROM.
     #define I2C_EEPROM_BUS_MUX       kPORT_MuxAlt2
 
     #define I2C_EEPROM_BUS_SDA_PORT  PORTC

right/src/i2c_error_logger.c

@@ -0,0 +1,25 @@
+#include "fsl_i2c.h"
+#include "i2c_error_logger.h"
+
+i2c_slave_error_counter_t I2cSlaveErrorCounters[MAX_SLAVE_COUNT];
+
+void LogI2cError(uint8_t slaveId, status_t status)
+{
+    i2c_slave_error_counter_t *i2cSlaveErrorCounter = I2cSlaveErrorCounters + slaveId;
+    uint8_t errorIdx;
+
+    for (errorIdx=0; errorIdx<i2cSlaveErrorCounter->errorTypeCount; errorIdx++) {
+        i2c_error_count_t *currentI2cError = i2cSlaveErrorCounter->errors + errorIdx;
+        if (currentI2cError->status == status) {
+            currentI2cError->count++;
+            break;
+        }
+    }
+
+    if (errorIdx == i2cSlaveErrorCounter->errorTypeCount && errorIdx < MAX_LOGGED_I2C_ERROR_TYPES_PER_SLAVE) {
+        i2cSlaveErrorCounter->errorTypeCount++;
+        i2c_error_count_t *currentI2cError = i2cSlaveErrorCounter->errors + errorIdx;
+        currentI2cError->status = status;
+        currentI2cError->count = 1;
+    }
+}

right/src/i2c_error_logger.h

@@ -0,0 +1,33 @@
+#ifndef __I2C_ERROR_LOGGER_H__
+#define __I2C_ERROR_LOGGER_H__
+
+// Includes:
+
+    #include "fsl_common.h"
+    #include "slave_scheduler.h"
+
+// Macros:
+
+    #define MAX_LOGGED_I2C_ERROR_TYPES_PER_SLAVE 7
+
+// Typedefs:
+
+    typedef struct {
+        status_t status;
+        uint32_t count;
+    } i2c_error_count_t;
+
+    typedef struct {
+        uint8_t errorTypeCount;
+        i2c_error_count_t errors[MAX_LOGGED_I2C_ERROR_TYPES_PER_SLAVE];
+    } i2c_slave_error_counter_t;
+
+// Variables:
+
+    extern i2c_slave_error_counter_t I2cSlaveErrorCounters[MAX_SLAVE_COUNT];
+
+// Functions:
+
+    void LogI2cError(uint8_t slaveId, status_t status);
+
+#endif

right/src/i2c_watchdog.c

@@ -5,7 +5,6 @@
 #include "fsl_gpio.h"
 #include "i2c.h"
 #include "i2c_watchdog.h"
-#include "slave_scheduler.h"
 #include "init_peripherals.h"
 
 uint32_t I2cWatchdog_WatchCounter;
@@ -19,17 +18,13 @@ static uint32_t prevWatchdogCounter;
 void PIT_I2C_WATCHDOG_HANDLER(void)
 {
     I2cWatchdog_WatchCounter++;
+
     if (I2C_Watchdog == prevWatchdogCounter) { // Restart I2C if there haven't been any interrupts recently
         I2cWatchdog_RecoveryCounter++;
-        i2c_master_config_t masterConfig;
+        ReinitI2cMainBus();
-        I2C_MasterGetDefaultConfig(&masterConfig);
-        I2C_MasterDeinit(I2C_MAIN_BUS_BASEADDR);
-        InitI2cMainBus();
-        InitSlaveScheduler();
     }
 
     prevWatchdogCounter = I2C_Watchdog;
-
     PIT_ClearStatusFlags(PIT, PIT_I2C_WATCHDOG_CHANNEL, PIT_TFLG_TIF_MASK);
 }
 

right/src/init_peripherals.c

@@ -8,28 +8,44 @@
 #include "peripherals/led_driver.h"
 #include "peripherals/merge_sensor.h"
 #include "led_pwm.h"
-#include "slave_scheduler.h"
 #include "peripherals/adc.h"
 #include "init_peripherals.h"
 #include "eeprom.h"
-#include "microseconds/microseconds_pit.c"
 #include "timer.h"
 #include "key_debouncer.h"
+#include "usb_api.h"
+#include "slave_scheduler.h"
+#include "bootloader/wormhole.h"
 
-void InitInterruptPriorities(void)
+bool IsBusPalOn;
-{
+volatile uint32_t I2cMainBusRequestedBaudRateBps = I2C_MAIN_BUS_NORMAL_BAUD_RATE;
-    NVIC_SetPriority(I2C0_IRQn, 1);
+volatile uint32_t I2cMainBusActualBaudRateBps;
-    NVIC_SetPriority(I2C1_IRQn, 1);
+
-    NVIC_SetPriority(USB0_IRQn, 1);
+static void initBusPalState(void) {
-    NVIC_SetPriority(PIT1_IRQn, 6);
+    IsBusPalOn = Wormhole.magicNumber == WORMHOLE_MAGIC_NUMBER && Wormhole.enumerationMode == EnumerationMode_BusPal;
+    if (IsBusPalOn) {
+        Wormhole.magicNumber = 0;
+        I2cMainBusRequestedBaudRateBps = I2C_MAIN_BUS_BUSPAL_BAUD_RATE;
+    }
 }
 
-void delay(void)
+static void initInterruptPriorities(void)
+{
+    NVIC_SetPriority(PIT_I2C_WATCHDOG_IRQ_ID,  1);
+    NVIC_SetPriority(PIT_TIMER_IRQ_ID,         2);
+    NVIC_SetPriority(PIT_KEY_SCANNER_IRQ_ID,   3);
+    NVIC_SetPriority(PIT_KEY_DEBOUNCER_IRQ_ID, 3);
+    NVIC_SetPriority(I2C_MAIN_BUS_IRQ_ID,      3);
+    NVIC_SetPriority(I2C_EEPROM_BUS_IRQ_ID,    3);
+    NVIC_SetPriority(USB_IRQ_ID,               3);
+}
+
+static void delay(void)
 {
     for (volatile uint32_t i=0; i<62; i++);
 }
 
-void recoverI2c(void)
+static void recoverI2c(void)
 {
     PORT_SetPinMux(I2C_MAIN_BUS_SDA_PORT, I2C_MAIN_BUS_SDA_PIN, kPORT_MuxAsGpio);
     PORT_SetPinMux(I2C_MAIN_BUS_SCL_PORT, I2C_MAIN_BUS_SCL_PIN, kPORT_MuxAsGpio);
@@ -58,7 +74,7 @@ void recoverI2c(void)
     delay();
 }
 
-void InitI2cMainBus(void)
+static void initI2cMainBus(void)
 {
     CLOCK_EnableClock(I2C_MAIN_BUS_SDA_CLOCK);
     CLOCK_EnableClock(I2C_MAIN_BUS_SCL_CLOCK);
@@ -76,12 +92,20 @@ void InitI2cMainBus(void)
 
     i2c_master_config_t masterConfig;
     I2C_MasterGetDefaultConfig(&masterConfig);
-    masterConfig.baudRate_Bps = I2C_MAIN_BUS_BAUD_RATE;
+    masterConfig.baudRate_Bps = I2cMainBusRequestedBaudRateBps;
-    uint32_t sourceClock = CLOCK_GetFreq(I2C_MASTER_BUS_CLK_SRC);
+    uint32_t sourceClock = CLOCK_GetFreq(I2C_MAIN_BUS_CLK_SRC);
     I2C_MasterInit(I2C_MAIN_BUS_BASEADDR, &masterConfig, sourceClock);
+    I2cMainBusActualBaudRateBps = I2C_ActualBaudRate;
 }
 
-void initI2cEepromBus(void)
+void ReinitI2cMainBus(void)
+{
+    I2C_MasterDeinit(I2C_MAIN_BUS_BASEADDR);
+    initI2cMainBus();
+    InitSlaveScheduler();
+}
+
+static void initI2cEepromBus(void)
 {
     port_pin_config_t pinConfig = {
        .pullSelect = kPORT_PullUp,
@@ -89,7 +113,6 @@ void initI2cEepromBus(void)
        .mux = I2C_EEPROM_BUS_MUX,
    };
 
-
    CLOCK_EnableClock(I2C_EEPROM_BUS_SDA_CLOCK);
    CLOCK_EnableClock(I2C_EEPROM_BUS_SCL_CLOCK);
 
@@ -103,21 +126,22 @@ void initI2cEepromBus(void)
    I2C_MasterInit(I2C_EEPROM_BUS_BASEADDR, &masterConfig, sourceClock);
 }
 
-void InitI2c(void)
+static void initI2c(void)
 {
-    InitI2cMainBus();
+    initI2cMainBus();
     initI2cEepromBus();
 }
 
 void InitPeripherals(void)
 {
-    InitInterruptPriorities();
+    initBusPalState();
+    initInterruptPriorities();
     Timer_Init();
     InitLedDriver();
     InitResetButton();
     InitMergeSensor();
     ADC_Init();
-    InitI2c();
+    initI2c();
     InitTestLed();
     LedPwm_Init();
 #ifdef I2C_WATCHDOG
@@ -125,5 +149,4 @@ void InitPeripherals(void)
 #endif
     InitKeyDebouncer();
     EEPROM_Init();
-    //microseconds_init();
 }

right/src/init_peripherals.h

@@ -5,9 +5,15 @@
 
     #include "fsl_common.h"
 
+// Variables:
+
+    extern bool IsBusPalOn;
+    extern volatile uint32_t I2cMainBusRequestedBaudRateBps;
+    extern volatile uint32_t I2cMainBusActualBaudRateBps;
+
 // Functions:
 
     void InitPeripherals(void);
-    void InitI2cMainBus(void);
+    void ReinitI2cMainBus(void);
 
 #endif

right/src/key_action.h

@@ -1,5 +1,5 @@
-#ifndef __ACTION_H__
+#ifndef __KEY_ACTION_H__
-#define __ACTION_H__
+#define __KEY_ACTION_H__
 
 // Includes:
 
@@ -7,16 +7,8 @@
     #include "attributes.h"
     #include "lufa/HIDClassCommon.h"
     #include "usb_composite_device.h"
-    #include "main.h"
     #include "module.h"
-
+    #include "config_parser/parse_keymap.h"
-// Macros:
-
-    #define MOUSE_WHEEL_SPEED   1
-    #define MOUSE_WHEEL_DIVISOR 4
-
-    #define MOUSE_MAX_SPEED           10
-    #define MOUSE_SPEED_ACCEL_DIVISOR 50
 
 // Typedefs:
 
@@ -36,32 +28,21 @@
         KeystrokeType_System,
     } keystroke_type_t;
 
+    typedef enum {
+        SwitchLayerMode_Hold,
+        SwitchLayerMode_HoldAndDoubleTapToggle,
+        SwitchLayerMode_Toggle,
+    } switch_layer_mode_t;
+
     typedef enum {
         MouseButton_Left   = 1 << 0,
         MouseButton_Right  = 1 << 1,
         MouseButton_Middle = 1 << 2,
         MouseButton_4      = 1 << 3,
         MouseButton_5      = 1 << 4,
-        MouseButton_t      = 1 << 5,
+        MouseButton_6      = 1 << 5,
     } mouse_button_t;
 
-    typedef enum {
-        MouseMove_Up    = 1 << 0,
-        MouseMove_Down  = 1 << 1,
-        MouseMove_Left  = 1 << 2,
-        MouseMove_Right = 1 << 3,
-
-        MouseMove_Accelerate = 1 << 4,
-        MouseMove_Decelerate = 1 << 5,
-    } mouse_move_action_t;
-
-    typedef enum {
-        MouseScroll_Up    = 1 << 0,
-        MouseScroll_Down  = 1 << 1,
-        MouseScroll_Left  = 1 << 2,
-        MouseScroll_Right = 1 << 3,
-    } mouse_scroll_t;
-
     typedef struct {
         uint8_t type;
         union {
@@ -71,13 +52,9 @@
                 uint8_t modifiers;
                 uint16_t scancode;
             } ATTR_PACKED keystroke;
+            serialized_mouse_action_t mouseAction;
             struct {
-                mouse_button_t buttonActions;
+                switch_layer_mode_t mode;
-                mouse_scroll_t scrollActions;
-                mouse_move_action_t moveActions;
-            } ATTR_PACKED mouse;
-            struct {
-                bool isToggle;
                 uint8_t layer;
             } ATTR_PACKED switchLayer;
             struct {

right/src/key_debouncer.h

@@ -9,7 +9,7 @@
 // Macros:
 
     #define KEY_DEBOUNCER_INTERVAL_MSEC 1
-    #define KEY_DEBOUNCER_TIMEOUT_MSEC 10
+    #define KEY_DEBOUNCER_TIMEOUT_MSEC 60
 
 // Functions:
 

right/src/key_scanner.c

@@ -1,9 +1,12 @@
 #include "fsl_pit.h"
 #include "key_scanner.h"
 
+uint32_t KeyScannerCounter;
+
 void PIT_KEY_SCANNER_HANDLER(void)
 {
     KeyMatrix_ScanRow(&RightKeyMatrix);
+    KeyScannerCounter++;
     PIT_ClearStatusFlags(PIT, PIT_KEY_SCANNER_CHANNEL, PIT_TFLG_TIF_MASK);
 }
 

right/src/key_scanner.h

@@ -10,6 +10,10 @@
 
     #define KEY_SCANNER_INTERVAL_USEC (1000 / RIGHT_KEY_MATRIX_ROWS_NUM)
 
+// Variables:
+
+    extern uint32_t KeyScannerCounter;
+
 // Functions:
 
     void InitKeyScanner(void);

right/src/keymap.c

@@ -6,12 +6,19 @@
 #include "config_parser/config_globals.h"
 #include "macros.h"
 
-keymap_reference_t AllKeymaps[MAX_KEYMAP_NUM] = { { "FTY", 0, 3 } };
+keymap_reference_t AllKeymaps[MAX_KEYMAP_NUM] = {
+    {
+        .abbreviation = "FTY",
+        .offset = 0,
+        .abbreviationLen = 3
+    }
+};
+
 uint8_t AllKeymapsCount;
 uint8_t DefaultKeymapIndex;
 uint8_t CurrentKeymapIndex = 0;
 
-void SwitchKeymap(uint8_t index)
+void SwitchKeymapById(uint8_t index)
 {
     CurrentKeymapIndex = index;
     ValidatedUserConfigBuffer.offset = AllKeymaps[index].offset;
@@ -19,6 +26,18 @@ void SwitchKeymap(uint8_t index)
     LedDisplay_SetCurrentKeymapText();
 }
 
+bool SwitchKeymapByAbbreviation(uint8_t length, char *abbrev)
+{
+    for (uint8_t i=0; i<AllKeymapsCount; i++) {
+        keymap_reference_t *keymap = AllKeymaps + i;
+        if (keymap->abbreviationLen == length && memcmp(keymap->abbreviation, abbrev, length) == 0) {
+            SwitchKeymapById(i);
+            return true;
+        }
+    }
+    return false;
+}
+
 // The factory keymap is initialized before it gets overwritten by the default keymap of the EEPROM.
 key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] = {
     // Base layer
@@ -157,7 +176,7 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
             { .type = KeyActionType_None },
             { .type = KeyActionType_None },
             { .type = KeyActionType_None },
-            { .type = HID_KEYBOARD_SC_MENU },
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_APPLICATION }},
             { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_RIGHT_SHIFT }},
             { .type = KeyActionType_None },
 
@@ -332,23 +351,23 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
             { .type = KeyActionType_None },
 
             // Row 2
-            { .type = KeyActionType_Mouse, .mouse = { .buttonActions = MouseButton_4 }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_Button_4 },
-            { .type = KeyActionType_Mouse, .mouse = { .moveActions = MouseMove_Up }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_MoveUp },
-            { .type = KeyActionType_Mouse, .mouse = { .buttonActions = MouseButton_5 }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_Button_5 },
-            { .type = KeyActionType_Mouse, .mouse = { .buttonActions = MouseButton_t }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_Button_6 },
             { .type = KeyActionType_None },
             { .type = KeyActionType_None },
             { .type = KeyActionType_None },
-            { .type = KeyActionType_Mouse, .mouse = { .scrollActions = MouseScroll_Up }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_ScrollUp },
 
             // Row 3
-            { .type = KeyActionType_Mouse, .mouse = { .moveActions = MouseMove_Left }},
+            { .type = KeyActionType_Mouse, .mouseAction= SerializedMouseAction_MoveLeft },
-            { .type = KeyActionType_Mouse, .mouse = { .moveActions = MouseMove_Down }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_MoveDown },
-            { .type = KeyActionType_Mouse, .mouse = { .moveActions = MouseMove_Right }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_MoveRight },
             { .type = KeyActionType_None },
             { .type = KeyActionType_None },
             { .type = KeyActionType_None },
-            { .type = KeyActionType_Mouse, .mouse = { .scrollActions = MouseScroll_Down }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_ScrollDown },
 
             // Row 4
             { .type = KeyActionType_None },
@@ -391,9 +410,9 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
             // Row 3
             { .type = KeyActionType_SwitchLayer, .switchLayer = { .layer = LayerId_Mouse }},
             { .type = KeyActionType_None },
-            { .type = KeyActionType_Mouse, .mouse = { .buttonActions = MouseButton_Right }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_RightClick },
-            { .type = KeyActionType_Mouse, .mouse = { .buttonActions = MouseButton_Middle }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_MiddleClick },
-            { .type = KeyActionType_Mouse, .mouse = { .buttonActions = MouseButton_Left }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_LeftClick },
             { .type = KeyActionType_None },
             { .type = KeyActionType_None },
 
@@ -411,8 +430,8 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
             { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_LEFT_GUI }},
             { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_LEFT_ALT }},
             { .type = KeyActionType_None },
-            { .type = KeyActionType_Mouse, .mouse = { .moveActions = MouseMove_Decelerate }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_Decelerate },
-            { .type = KeyActionType_Mouse, .mouse = { .moveActions = MouseMove_Accelerate }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_Accelerate },
             { .type = KeyActionType_None },
         }
     },

right/src/keymap.h

@@ -29,6 +29,7 @@
 
 // Functions:
 
-    void SwitchKeymap(uint8_t index);
+    void SwitchKeymapById(uint8_t index);
+    bool SwitchKeymapByAbbreviation(uint8_t length, char *abbrev);
 
 #endif

right/src/layer.c

@@ -5,7 +5,7 @@
 #include "keymap.h"
 
 static bool heldLayers[LAYER_COUNT];
-static bool pressedLayers[LAYER_COUNT];
+static switch_layer_mode_t pressedLayers[LAYER_COUNT];
 
 void updateLayerStates(void)
 {
@@ -18,10 +18,11 @@ void updateLayerStates(void)
             if (keyState->current) {
                 key_action_t action = CurrentKeymap[LayerId_Base][slotId][keyId];
                 if (action.type == KeyActionType_SwitchLayer) {
-                    if (!action.switchLayer.isToggle) {
+                    if (action.switchLayer.mode != SwitchLayerMode_Toggle) {
                         heldLayers[action.switchLayer.layer] = true;
-                    } else if (!keyState->previous && keyState->current) {
+                    }
-                        pressedLayers[action.switchLayer.layer] = true;
+                    if (action.switchLayer.mode != SwitchLayerMode_Hold && !keyState->previous && keyState->current) {
+                        pressedLayers[action.switchLayer.layer] = action.switchLayer.mode;
                     }
                 }
             }
@@ -30,6 +31,7 @@ void updateLayerStates(void)
 }
 
 layer_id_t PreviousHeldLayer = LayerId_Base;
+layer_id_t ToggledLayer = LayerId_Base;
 
 layer_id_t GetActiveLayer()
 {
@@ -37,22 +39,20 @@ layer_id_t GetActiveLayer()
 
     // Handle toggled layers
 
-    static layer_id_t toggledLayer = LayerId_Base;
-
     for (layer_id_t layerId=LayerId_Mod; layerId<=LayerId_Mouse; layerId++) {
         if (pressedLayers[layerId]) {
-            if (toggledLayer == layerId) {
+            if (ToggledLayer == layerId) {
-                toggledLayer = LayerId_Base;
+                ToggledLayer = LayerId_Base;
                 break;
-            } else if (toggledLayer == LayerId_Base) {
+            } else if (ToggledLayer == LayerId_Base && pressedLayers[layerId] == SwitchLayerMode_Toggle) {
-                toggledLayer = layerId;
+                ToggledLayer = layerId;
                 break;
             }
         }
     }
 
-    if (toggledLayer != LayerId_Base) {
+    if (ToggledLayer != LayerId_Base) {
-        return toggledLayer;
+        return ToggledLayer;
     }
 
     // Handle held layers

right/src/layer.h

@@ -21,10 +21,10 @@
 // Variables:
 
     extern layer_id_t PreviousHeldLayer;
+    extern layer_id_t ToggledLayer;
 
 // Functions:
 
     layer_id_t GetActiveLayer();
 
-
 #endif

right/src/led_display.c

@@ -3,6 +3,9 @@
 #include "layer.h"
 #include "keymap.h"
 
+uint8_t IconsAndLayerTextsBrightness = 0xff;
+uint8_t AlphanumericSegmentsBrightness = 0xff;
+
 static const uint16_t capitalLetterToSegmentSet[] = {
     0b0000000011110111,
     0b0001001010001111,
@@ -69,13 +72,13 @@ void LedDisplay_SetText(uint8_t length, const char* text)
             allSegmentSets |= characterToSegmentSet(text[0]);
     }
 
-    LedDriverValues[LedDriverId_Left][11] = allSegmentSets & 0b00000001 ? LED_BRIGHTNESS_LEVEL : 0;
+    LedDriverValues[LedDriverId_Left][11] = allSegmentSets & 0b00000001 ? AlphanumericSegmentsBrightness : 0;
-    LedDriverValues[LedDriverId_Left][12] = allSegmentSets & 0b00000010 ? LED_BRIGHTNESS_LEVEL : 0;
+    LedDriverValues[LedDriverId_Left][12] = allSegmentSets & 0b00000010 ? AlphanumericSegmentsBrightness : 0;
     allSegmentSets >>= 2;
 
     for (uint8_t i = 24; i <= 136; i += 16) {
         for (uint8_t j = 0; j < 5; j++) {
-            LedDriverValues[LedDriverId_Left][i + j] = allSegmentSets & 1 << j ? LED_BRIGHTNESS_LEVEL : 0;
+            LedDriverValues[LedDriverId_Left][i + j] = allSegmentSets & 1 << j ? AlphanumericSegmentsBrightness : 0;
         }
         allSegmentSets >>= 5;
     }
@@ -87,18 +90,23 @@ void LedDisplay_SetCurrentKeymapText(void)
     LedDisplay_SetText(currentKeymap->abbreviationLen, currentKeymap->abbreviation);
 }
 
-void LedDisplay_SetLayer(uint8_t layerId)
+void LedDisplay_SetLayer(layer_id_t layerId)
 {
     for (uint8_t i = 13; i <= 45; i += 16) {
         LedDriverValues[LedDriverId_Left][i] = 0;
     }
 
     if (layerId >= LayerId_Mod && layerId <= LayerId_Mouse) {
-        LedDriverValues[LedDriverId_Left][16 * layerId - 3] = LED_BRIGHTNESS_LEVEL;
+        LedDriverValues[LedDriverId_Left][16 * layerId - 3] = IconsAndLayerTextsBrightness;
     }
 }
 
+bool LedDisplay_GetIcon(led_display_icon_t icon)
+{
+    return LedDriverValues[LedDriverId_Left][8 + icon];
+}
+
 void LedDisplay_SetIcon(led_display_icon_t icon, bool isEnabled)
 {
-    LedDriverValues[LedDriverId_Left][8 + icon] = isEnabled ? LED_BRIGHTNESS_LEVEL : 0;
+    LedDriverValues[LedDriverId_Left][8 + icon] = isEnabled ? IconsAndLayerTextsBrightness : 0;
 }

right/src/led_display.h

@@ -5,6 +5,7 @@
 
     #include <stdint.h>
     #include <stdbool.h>
+    #include "layer.h"
 
 // Typedefs:
 
@@ -14,11 +15,18 @@
         LedDisplayIcon_Adaptive,
     } led_display_icon_t;
 
+// Variables:
+
+    extern uint8_t IconsAndLayerTextsBrightness;
+    extern uint8_t AlphanumericSegmentsBrightness;
+
 // Functions:
 
     void LedDisplay_SetText(uint8_t length, const char* text);
     void LedDisplay_SetCurrentKeymapText(void);
-    void LedDisplay_SetLayer(uint8_t layerId);
+    void LedDisplay_SetLayer(layer_id_t layerId);
     void LedDisplay_SetIcon(led_display_icon_t icon, bool isEnabled);
 
+    bool LedDisplay_GetIcon(led_display_icon_t icon);
+
 #endif

right/src/main.c

@@ -1,89 +1,25 @@
 #include "config.h"
-#include "main.h"
 #include "init_clock.h"
 #include "init_peripherals.h"
 #include "usb_composite_device.h"
-#include "peripherals/led_driver.h"
-#include "key_action.h"
 #include "slave_scheduler.h"
-#include "peripherals/test_led.h"
-#include "usb_interfaces/usb_interface_basic_keyboard.h"
-#include "usb_interfaces/usb_interface_media_keyboard.h"
-#include "usb_protocol_handler.h"
 #include "bus_pal_hardware.h"
 #include "command.h"
-#include "bootloader/wormhole.h"
 #include "eeprom.h"
-#include "right_key_matrix.h"
 #include "key_scanner.h"
-#include "key_states.h"
 #include "usb_commands/usb_command_apply_config.h"
 #include "peripherals/reset_button.h"
+#include "usb_report_updater.h"
 
-bool UsbBasicKeyboardReportEverSent = false;
+static bool IsEepromInitialized = false;
-bool UsbMediaKeyboardReportEverSent = false;
+static bool IsConfigInitialized = false;
-bool UsbSystemKeyboardReportEverSent = false;
-bool UsbMouseReportEverSentEverSent = false;
 
-void updateUsbReports(void)
+static void userConfigurationReadFinished(void)
-{
-    if (IsUsbBasicKeyboardReportSent) {
-        UsbBasicKeyboardReportEverSent = true;
-    }
-    if (IsUsbMediaKeyboardReportSent) {
-        UsbMediaKeyboardReportEverSent = true;
-    }
-    if (IsUsbSystemKeyboardReportSent) {
-        UsbSystemKeyboardReportEverSent = true;
-    }
-    if (IsUsbMouseReportSent) {
-        UsbMouseReportEverSentEverSent = true;
-    }
-
-    bool areUsbReportsSent = true;
-    if (UsbBasicKeyboardReportEverSent) {
-        areUsbReportsSent &= IsUsbBasicKeyboardReportSent;
-    }
-    if (UsbMediaKeyboardReportEverSent) {
-        areUsbReportsSent &= IsUsbMediaKeyboardReportSent;
-    }
-    if (UsbSystemKeyboardReportEverSent) {
-        areUsbReportsSent &= IsUsbSystemKeyboardReportSent;
-    }
-    if (UsbMouseReportEverSentEverSent) {
-        areUsbReportsSent &= IsUsbMouseReportSent;
-    }
-    if (!areUsbReportsSent) {
-        return;
-    }
-
-    ResetActiveUsbBasicKeyboardReport();
-    ResetActiveUsbMediaKeyboardReport();
-    ResetActiveUsbSystemKeyboardReport();
-    ResetActiveUsbMouseReport();
-
-    UpdateActiveUsbReports();
-
-    SwitchActiveUsbBasicKeyboardReport();
-    SwitchActiveUsbMediaKeyboardReport();
-    SwitchActiveUsbSystemKeyboardReport();
-    SwitchActiveUsbMouseReport();
-
-    IsUsbBasicKeyboardReportSent = false;
-    IsUsbMediaKeyboardReportSent = false;
-    IsUsbSystemKeyboardReportSent = false;
-    IsUsbMouseReportSent = false;
-}
-
-bool IsEepromInitialized = false;
-bool IsConfigInitialized = false;
-
-void userConfigurationReadFinished(void)
 {
     IsEepromInitialized = true;
 }
 
-void hardwareConfigurationReadFinished(void)
+static void hardwareConfigurationReadFinished(void)
 {
     EEPROM_LaunchTransfer(EepromOperation_Read, ConfigBufferId_StagingUserConfig, userConfigurationReadFinished);
 }
@@ -97,15 +33,14 @@ void main(void)
         EEPROM_LaunchTransfer(EepromOperation_Read, ConfigBufferId_HardwareConfig, hardwareConfigurationReadFinished);
     }
 
-    if (Wormhole.magicNumber == WORMHOLE_MAGIC_NUMBER && Wormhole.enumerationMode == EnumerationMode_BusPal) {
+    if (IsBusPalOn) {
-        Wormhole.magicNumber = 0;
         init_hardware();
         handleUsbBusPalCommand();
     } else {
         InitSlaveScheduler();
         KeyMatrix_Init(&RightKeyMatrix);
         InitKeyScanner();
-        updateUsbReports();
+        UpdateUsbReports();
         InitUsb();
 
         while (1) {
@@ -113,7 +48,7 @@ void main(void)
                 UsbCommand_ApplyConfig();
                 IsConfigInitialized = true;
             }
-            updateUsbReports();
+            UpdateUsbReports();
             __WFI();
         }
     }

right/src/main.h

@@ -1,10 +0,0 @@
-#ifndef __MAIN_H__
-#define __MAIN_H__
-
-// Includes:
-
-    #include "key_matrix.h"
-    #include "slot.h"
-    #include "module.h"
-
-#endif

right/src/peripherals/adc.c

@@ -2,7 +2,7 @@
 #include "fsl_port.h"
 #include "peripherals/adc.h"
 
-adc16_channel_config_t adc16ChannelConfigStruct;
+static adc16_channel_config_t adc16ChannelConfigStruct;
 
 void ADC_Init(void)
 {

right/src/slave_drivers/is31fl3731_driver.c

@@ -3,6 +3,7 @@
 #include "slave_scheduler.h"
 #include "led_display.h"
 
+uint8_t KeyBacklightBrightness = 0xff;
 uint8_t LedDriverValues[LED_DRIVER_MAX_COUNT][LED_DRIVER_LED_COUNT];
 
 static led_driver_state_t ledDriverStates[LED_DRIVER_MAX_COUNT] = {
@@ -70,8 +71,14 @@ void LedSlaveDriver_Init(uint8_t ledDriverId)
     led_driver_state_t *currentLedDriverState = ledDriverStates + ledDriverId;
     currentLedDriverState->phase = LedDriverPhase_SetFunctionFrame;
     currentLedDriverState->ledIndex = 0;
-    memset(LedDriverValues[ledDriverId], LED_BRIGHTNESS_LEVEL, LED_DRIVER_LED_COUNT);
+    memset(LedDriverValues[ledDriverId], KeyBacklightBrightness, LED_DRIVER_LED_COUNT);
-    LedDisplay_SetCurrentKeymapText();
+
+    if (ledDriverId == LedDriverId_Left) {
+        LedDisplay_SetIcon(LedDisplayIcon_CapsLock, false);
+        LedDisplay_SetIcon(LedDisplayIcon_Agent, false);
+        LedDisplay_SetIcon(LedDisplayIcon_Adaptive, false);
+        LedDisplay_SetCurrentKeymapText();
+    }
 }
 
 status_t LedSlaveDriver_Update(uint8_t ledDriverId)

right/src/slave_drivers/is31fl3731_driver.h

@@ -12,7 +12,6 @@
     #define LED_CONTROL_REGISTERS_COMMAND_LENGTH 19
     #define PMW_REGISTER_UPDATE_CHUNK_SIZE 8
     #define PWM_REGISTER_BUFFER_LENGTH (1 + PMW_REGISTER_UPDATE_CHUNK_SIZE)
-    #define LED_BRIGHTNESS_LEVEL 0xff
 
     #define IS_ISO true
     #define ISO_KEY_LED_DRIVER_ID LedDriverId_Left
@@ -45,6 +44,7 @@
 
 // Variables:
 
+    extern uint8_t KeyBacklightBrightness;
     extern uint8_t LedDriverValues[LED_DRIVER_MAX_COUNT][LED_DRIVER_LED_COUNT];
 
 // Functions:

right/src/slave_drivers/kboot_driver.c

@@ -4,7 +4,7 @@
 
 kboot_driver_state_t KbootDriverState;
 
-static uint8_t rxBuffer[MAX_KBOOT_COMMAND_LENGTH];
+static uint8_t rxBuffer[KBOOT_PACKAGE_MAX_LENGTH];
 static uint8_t pingCommand[] = {0x5a, 0xa6};
 static uint8_t resetCommand[] = {0x5a, 0xa4, 0x04, 0x00, 0x6f, 0x46, 0x0b, 0x00, 0x00, 0x00};
 static uint8_t ackMessage[] = {0x5a, 0xa1};
@@ -27,50 +27,52 @@ status_t KbootSlaveDriver_Update(uint8_t kbootInstanceId)
 {
     status_t status = kStatus_Uhk_IdleSlave;
 
-    switch (KbootDriverState.commandType) {
+    switch (KbootDriverState.command) {
         case KbootCommand_Idle:
             break;
         case KbootCommand_Ping:
             switch (KbootDriverState.phase) {
-                case 0:
+                case KbootPhase_SendPing:
                     status = tx(pingCommand, sizeof(pingCommand));
-                    KbootDriverState.phase++;
+                    KbootDriverState.phase = KbootPhase_CheckPingStatus;
                     break;
-                case 1:
+                case KbootPhase_CheckPingStatus:
                     KbootDriverState.status = Slaves[SlaveId_KbootDriver].previousStatus;
-                    KbootDriverState.phase = KbootDriverState.status == kStatus_Success ? 2 : 0;
+                    KbootDriverState.phase = KbootDriverState.status == kStatus_Success
-                    return kStatus_Uhk_NoTransfer;
+                        ? KbootPhase_ReceivePingResponse
-                case 2:
+                        : KbootPhase_SendPing;
-                    status = rx(10);
+                    return kStatus_Uhk_IdleCycle;
-                    KbootDriverState.phase++;
+                case KbootPhase_ReceivePingResponse:
+                    status = rx(KBOOT_PACKAGE_LENGTH_PING_RESPONSE);
+                    KbootDriverState.phase = KbootPhase_CheckPingResponseStatus;
                     break;
-                case 3:
+                case KbootPhase_CheckPingResponseStatus:
                     KbootDriverState.status = Slaves[SlaveId_KbootDriver].previousStatus;
                     if (KbootDriverState.status == kStatus_Success) {
-                        KbootDriverState.commandType = KbootCommand_Idle;
+                        KbootDriverState.command = KbootCommand_Idle;
                     } else {
-                        KbootDriverState.phase = 0;
+                        KbootDriverState.phase = KbootPhase_SendPing;
-                        return kStatus_Uhk_NoTransfer;
+                        return kStatus_Uhk_IdleCycle;
                     }
                 }
             break;
         case KbootCommand_Reset:
             switch (KbootDriverState.phase) {
-                case 0:
+                case KbootPhase_SendReset:
                     status = tx(resetCommand, sizeof(resetCommand));
-                    KbootDriverState.phase++;
+                    KbootDriverState.phase = KbootPhase_ReceiveResetAck;
                     break;
-                case 1:
+                case KbootPhase_ReceiveResetAck:
-                    status = rx(2);
+                    status = rx(KBOOT_PACKAGE_LENGTH_ACK);
-                    KbootDriverState.phase++;
+                    KbootDriverState.phase = KbootPhase_ReceiveResetGenericResponse;
                     break;
-                case 2:
+                case KbootPhase_ReceiveResetGenericResponse:
-                    status = rx(18);
+                    status = rx(KBOOT_PACKAGE_LENGTH_GENERIC_RESPONSE);
-                    KbootDriverState.phase++;
+                    KbootDriverState.phase = KbootPhase_CheckResetSendAck;
                     break;
-                case 3:
+                case KbootPhase_CheckResetSendAck:
                     status = tx(ackMessage, sizeof(ackMessage));
-                    KbootDriverState.commandType = KbootCommand_Idle;
+                    KbootDriverState.command = KbootCommand_Idle;
                     break;
             }
             break;

right/src/slave_drivers/kboot_driver.h

@@ -7,7 +7,10 @@
 
 // Macros:
 
-    #define MAX_KBOOT_COMMAND_LENGTH 32
+    #define KBOOT_PACKAGE_MAX_LENGTH 32
+    #define KBOOT_PACKAGE_LENGTH_PING_RESPONSE 10
+    #define KBOOT_PACKAGE_LENGTH_ACK 2
+    #define KBOOT_PACKAGE_LENGTH_GENERIC_RESPONSE 18
 
 // Typedefs:
 
@@ -21,8 +24,22 @@
         KbootCommand_Reset,
     } kboot_command_t;
 
+    typedef enum {
+        KbootPhase_SendPing,
+        KbootPhase_CheckPingStatus,
+        KbootPhase_ReceivePingResponse,
+        KbootPhase_CheckPingResponseStatus,
+    } kboot_ping_phase_t;
+
+    typedef enum {
+        KbootPhase_SendReset,
+        KbootPhase_ReceiveResetAck,
+        KbootPhase_ReceiveResetGenericResponse,
+        KbootPhase_CheckResetSendAck,
+    } kboot_reset_phase_t;
+
     typedef struct {
-        kboot_command_t commandType;
+        kboot_command_t command;
         uint8_t i2cAddress;
         uint8_t phase;
         uint32_t status;

right/src/slave_drivers/uhk_module_driver.c

@@ -3,7 +3,6 @@
 #include "slave_scheduler.h"
 #include "slave_drivers/uhk_module_driver.h"
 #include "slave_protocol.h"
-#include "main.h"
 #include "peripherals/test_led.h"
 #include "bool_array_converter.h"
 #include "crc16.h"
@@ -70,6 +69,13 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
 
     switch (*uhkModulePhase) {
 
+        // Jump to bootloader
+        case UhkModulePhase_JumpToBootloader:
+            txMessage.data[0] = SlaveCommand_JumpToBootloader;
+            txMessage.length = 1;
+            status = tx(i2cAddress);
+            break;
+
         // Sync communication
         case UhkModulePhase_RequestSync:
             txMessage.data[0] = SlaveCommand_RequestProperty;
@@ -85,32 +91,54 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
         case UhkModulePhase_ProcessSync: {
             bool isMessageValid = CRC16_IsMessageValid(rxMessage);
             bool isSyncValid = memcmp(rxMessage->data, SlaveSyncString, SLAVE_SYNC_STRING_LENGTH) == 0;
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
             *uhkModulePhase = isSyncValid && isMessageValid
-                ? UhkModulePhase_RequestProtocolVersion
+                ? UhkModulePhase_RequestModuleProtocolVersion
                 : UhkModulePhase_RequestSync;
             break;
         }
 
-        // Get protocol version
+        // Get module protocol version
-        case UhkModulePhase_RequestProtocolVersion:
+        case UhkModulePhase_RequestModuleProtocolVersion:
             txMessage.data[0] = SlaveCommand_RequestProperty;
-            txMessage.data[1] = SlaveProperty_ProtocolVersion;
+            txMessage.data[1] = SlaveProperty_ModuleProtocolVersion;
             txMessage.length = 2;
             status = tx(i2cAddress);
-            *uhkModulePhase = UhkModulePhase_ReceiveProtocolVersion;
+            *uhkModulePhase = UhkModulePhase_ReceiveModuleProtocolVersion;
             break;
-        case UhkModulePhase_ReceiveProtocolVersion:
+        case UhkModulePhase_ReceiveModuleProtocolVersion:
             status = rx(rxMessage, i2cAddress);
-            *uhkModulePhase = UhkModulePhase_ProcessProtocolVersion;
+            *uhkModulePhase = UhkModulePhase_ProcessModuleProtocolVersion;
             break;
-        case UhkModulePhase_ProcessProtocolVersion: {
+        case UhkModulePhase_ProcessModuleProtocolVersion: {
             bool isMessageValid = CRC16_IsMessageValid(rxMessage);
             if (isMessageValid) {
-                uhkModuleState->protocolVersion = rxMessage->data[0];
+                memcpy(&uhkModuleState->moduleProtocolVersion, rxMessage->data, sizeof(version_t));
             }
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
-            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModuleId : UhkModulePhase_RequestProtocolVersion;
+            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestFirmwareVersion : UhkModulePhase_RequestModuleProtocolVersion;
+            break;
+        }
+
+        // Get firmware version
+        case UhkModulePhase_RequestFirmwareVersion:
+            txMessage.data[0] = SlaveCommand_RequestProperty;
+            txMessage.data[1] = SlaveProperty_FirmwareVersion;
+            txMessage.length = 2;
+            status = tx(i2cAddress);
+            *uhkModulePhase = UhkModulePhase_ReceiveFirmwareVersion;
+            break;
+        case UhkModulePhase_ReceiveFirmwareVersion:
+            status = rx(rxMessage, i2cAddress);
+            *uhkModulePhase = UhkModulePhase_ProcessFirmwareVersion;
+            break;
+        case UhkModulePhase_ProcessFirmwareVersion: {
+            bool isMessageValid = CRC16_IsMessageValid(rxMessage);
+            if (isMessageValid) {
+                memcpy(&uhkModuleState->firmwareVersion, rxMessage->data, sizeof(version_t));
+            }
+            status = kStatus_Uhk_IdleCycle;
+            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModuleId : UhkModulePhase_RequestFirmwareVersion;
             break;
         }
 
@@ -131,30 +159,52 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
             if (isMessageValid) {
                 uhkModuleState->moduleId = rxMessage->data[0];
             }
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
-            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModuleFeatures : UhkModulePhase_RequestModuleId;
+            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModuleKeyCount : UhkModulePhase_RequestModuleId;
             break;
         }
 
-        // Get module features
+        // Get module key count
-        case UhkModulePhase_RequestModuleFeatures:
+        case UhkModulePhase_RequestModuleKeyCount:
             txMessage.data[0] = SlaveCommand_RequestProperty;
-            txMessage.data[1] = SlaveProperty_Features;
+            txMessage.data[1] = SlaveProperty_KeyCount;
             txMessage.length = 2;
             status = tx(i2cAddress);
-            *uhkModulePhase = UhkModulePhase_ReceiveModuleFeatures;
+            *uhkModulePhase = UhkModulePhase_ReceiveModuleKeyCount;
             break;
-        case UhkModulePhase_ReceiveModuleFeatures:
+        case UhkModulePhase_ReceiveModuleKeyCount:
             status = rx(rxMessage, i2cAddress);
-            *uhkModulePhase = UhkModulePhase_ProcessModuleFeatures;
+            *uhkModulePhase = UhkModulePhase_ProcessModuleKeyCount;
             break;
-        case UhkModulePhase_ProcessModuleFeatures: {
+        case UhkModulePhase_ProcessModuleKeyCount: {
             bool isMessageValid = CRC16_IsMessageValid(rxMessage);
             if (isMessageValid) {
-                memcpy(&uhkModuleState->features, rxMessage->data, sizeof(uhk_module_features_t));
+                uhkModuleState->keyCount = rxMessage->data[0];
             }
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
-            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestKeyStates : UhkModulePhase_RequestModuleFeatures;
+            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModulePointerCount : UhkModulePhase_RequestModuleKeyCount;
+            break;
+        }
+
+        // Get module pointer count
+        case UhkModulePhase_RequestModulePointerCount:
+            txMessage.data[0] = SlaveCommand_RequestProperty;
+            txMessage.data[1] = SlaveProperty_PointerCount;
+            txMessage.length = 2;
+            status = tx(i2cAddress);
+            *uhkModulePhase = UhkModulePhase_ReceiveModulePointerCount;
+            break;
+        case UhkModulePhase_ReceiveModulePointerCount:
+            status = rx(rxMessage, i2cAddress);
+            *uhkModulePhase = UhkModulePhase_ProcessModulePointerCount;
+            break;
+        case UhkModulePhase_ProcessModulePointerCount: {
+            bool isMessageValid = CRC16_IsMessageValid(rxMessage);
+            if (isMessageValid) {
+                uhkModuleState->pointerCount = rxMessage->data[0];
+            }
+            status = kStatus_Uhk_IdleCycle;
+            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestKeyStates : UhkModulePhase_RequestModulePointerCount;
             break;
         }
 
@@ -172,32 +222,19 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
         case UhkModulePhase_ProcessKeystates:
             if (CRC16_IsMessageValid(rxMessage)) {
                 uint8_t slotId = uhkModuleDriverId + 1;
-                BoolBitsToBytes(rxMessage->data, keyStatesBuffer, uhkModuleState->features.keyCount);
+                BoolBitsToBytes(rxMessage->data, keyStatesBuffer, uhkModuleState->keyCount);
-                for (uint8_t keyId=0; keyId<uhkModuleState->features.keyCount; keyId++) {
+                for (uint8_t keyId=0; keyId<uhkModuleState->keyCount; keyId++) {
                     KeyStates[slotId][keyId].current = keyStatesBuffer[keyId];
                 }
             }
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
-            *uhkModulePhase = UhkModulePhase_JumpToBootloader;
-            break;
-
-        // Jump to bootloader
-        case UhkModulePhase_JumpToBootloader:
-            if (uhkModuleState->jumpToBootloader) {
-                txMessage.data[0] = SlaveCommand_JumpToBootloader;
-                txMessage.length = 1;
-                status = tx(i2cAddress);
-                uhkModuleState->jumpToBootloader = false;
-            } else {
-                status = kStatus_Uhk_NoTransfer;
-            }
             *uhkModulePhase = UhkModulePhase_SetTestLed;
             break;
 
         // Set test LED
         case UhkModulePhase_SetTestLed:
             if (uhkModuleSourceVars->isTestLedOn == uhkModuleTargetVars->isTestLedOn) {
-                status = kStatus_Uhk_NoTransfer;
+                status = kStatus_Uhk_IdleCycle;
             } else {
                 txMessage.data[0] = SlaveCommand_SetTestLed;
                 txMessage.data[1] = uhkModuleSourceVars->isTestLedOn;
@@ -211,7 +248,7 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
         // Set PWM brightness
         case UhkModulePhase_SetLedPwmBrightness:
             if (uhkModuleSourceVars->ledPwmBrightness == uhkModuleTargetVars->ledPwmBrightness) {
-                status = kStatus_Uhk_NoTransfer;
+                status = kStatus_Uhk_IdleCycle;
             } else {
                 txMessage.data[0] = SlaveCommand_SetLedPwmBrightness;
                 txMessage.data[1] = uhkModuleSourceVars->ledPwmBrightness;
@@ -228,8 +265,10 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
 
 void UhkModuleSlaveDriver_Disconnect(uint8_t uhkModuleDriverId)
 {
+#ifdef LED_DRIVERS_ENABLED
     if (uhkModuleDriverId == SlaveId_LeftKeyboardHalf) {
         Slaves[SlaveId_LeftLedDriver].isConnected = false;
     }
     UhkModuleStates[uhkModuleDriverId].moduleId = 0;
+#endif
 }

right/src/slave_drivers/uhk_module_driver.h

@@ -5,6 +5,7 @@
 
     #include "fsl_common.h"
     #include "crc16.h"
+    #include "versions.h"
 
 // Macros:
 
@@ -29,19 +30,29 @@
         UhkModulePhase_ProcessSync,
 
         // Get protocol version
-        UhkModulePhase_RequestProtocolVersion,
+        UhkModulePhase_RequestModuleProtocolVersion,
-        UhkModulePhase_ReceiveProtocolVersion,
+        UhkModulePhase_ReceiveModuleProtocolVersion,
-        UhkModulePhase_ProcessProtocolVersion,
+        UhkModulePhase_ProcessModuleProtocolVersion,
+
+        // Get firmware version
+        UhkModulePhase_RequestFirmwareVersion,
+        UhkModulePhase_ReceiveFirmwareVersion,
+        UhkModulePhase_ProcessFirmwareVersion,
 
         // Get module id
         UhkModulePhase_RequestModuleId,
         UhkModulePhase_ReceiveModuleId,
         UhkModulePhase_ProcessModuleId,
 
-        // Get module features
+        // Get module key count
-        UhkModulePhase_RequestModuleFeatures,
+        UhkModulePhase_RequestModuleKeyCount,
-        UhkModulePhase_ReceiveModuleFeatures,
+        UhkModulePhase_ReceiveModuleKeyCount,
-        UhkModulePhase_ProcessModuleFeatures,
+        UhkModulePhase_ProcessModuleKeyCount,
+
+        // Get module key count
+        UhkModulePhase_RequestModulePointerCount,
+        UhkModulePhase_ReceiveModulePointerCount,
+        UhkModulePhase_ProcessModulePointerCount,
 
         // Get key states
         UhkModulePhase_RequestKeyStates,
@@ -49,9 +60,9 @@
         UhkModulePhase_ProcessKeystates,
 
         // Misc phases
-        UhkModulePhase_JumpToBootloader,
         UhkModulePhase_SetTestLed,
         UhkModulePhase_SetLedPwmBrightness,
+        UhkModulePhase_JumpToBootloader,
 
     } uhk_module_phase_t;
 
@@ -62,15 +73,16 @@
 
     typedef struct {
         uint8_t moduleId;
-        uint8_t protocolVersion;
+        version_t moduleProtocolVersion;
+        version_t firmwareVersion;
         uhk_module_phase_t phase;
         uhk_module_vars_t sourceVars;
         uhk_module_vars_t targetVars;
         i2c_message_t rxMessage;
         uint8_t firmwareI2cAddress;
         uint8_t bootloaderI2cAddress;
-        uhk_module_features_t features;
+        uint8_t keyCount;
-        bool jumpToBootloader;
+        uint8_t pointerCount;
     } uhk_module_state_t;
 
     typedef struct {

right/src/slave_scheduler.c

@@ -1,12 +1,13 @@
 #include "fsl_i2c.h"
 #include "slave_scheduler.h"
 #include "slot.h"
-#include "main.h"
 #include "slave_drivers/is31fl3731_driver.h"
 #include "slave_drivers/uhk_module_driver.h"
 #include "slave_drivers/kboot_driver.h"
 #include "i2c.h"
 #include "i2c_addresses.h"
+#include "config.h"
+#include "i2c_error_logger.h"
 
 uint32_t I2cSlaveScheduler_Counter;
 
@@ -30,6 +31,7 @@ uhk_slave_t Slaves[] = {
         .update = UhkModuleSlaveDriver_Update,
         .perDriverId = UhkModuleDriverId_RightAddon,
     },
+#ifdef LED_DRIVERS_ENABLED
     {
         .init = LedSlaveDriver_Init,
         .update = LedSlaveDriver_Update,
@@ -40,6 +42,7 @@ uhk_slave_t Slaves[] = {
         .update = LedSlaveDriver_Update,
         .perDriverId = LedDriverId_Left,
     },
+#endif
     {
         .init = KbootSlaveDriver_Init,
         .update = KbootSlaveDriver_Update,
@@ -49,23 +52,27 @@ uhk_slave_t Slaves[] = {
 
 static void slaveSchedulerCallback(I2C_Type *base, i2c_master_handle_t *handle, status_t previousStatus, void *userData)
 {
-    bool isFirstIteration = true;
+    bool isFirstCycle = true;
     bool isTransferScheduled = false;
     I2cSlaveScheduler_Counter++;
 
     do {
-        uhk_slave_t *previousSlave = Slaves + previousSlaveId;
         uhk_slave_t *currentSlave = Slaves + currentSlaveId;
 
-        previousSlave->previousStatus = previousStatus;
+        if (isFirstCycle) {
+            uhk_slave_t *previousSlave = Slaves + previousSlaveId;
+            previousSlave->previousStatus = previousStatus;
+            if (IS_STATUS_I2C_ERROR(previousStatus)) {
+                LogI2cError(previousSlaveId, previousStatus);
+            }
 
-        if (isFirstIteration) {
             bool wasPreviousSlaveConnected = previousSlave->isConnected;
             previousSlave->isConnected = previousStatus == kStatus_Success;
             if (wasPreviousSlaveConnected && !previousSlave->isConnected && previousSlave->disconnect) {
                 previousSlave->disconnect(previousSlaveId);
             }
-            isFirstIteration = false;
+
+            isFirstCycle = false;
         }
 
         if (!currentSlave->isConnected) {
@@ -73,18 +80,21 @@ static void slaveSchedulerCallback(I2C_Type *base, i2c_master_handle_t *handle,
         }
 
         status_t currentStatus = currentSlave->update(currentSlave->perDriverId);
-        isTransferScheduled = currentStatus != kStatus_Uhk_IdleSlave && currentStatus != kStatus_Uhk_NoTransfer;
+        if (IS_STATUS_I2C_ERROR(currentStatus)) {
+            LogI2cError(currentSlaveId, currentStatus);
+        }
+        isTransferScheduled = currentStatus != kStatus_Uhk_IdleSlave && currentStatus != kStatus_Uhk_IdleCycle;
         if (isTransferScheduled) {
             currentSlave->isConnected = true;
         }
 
-        if (currentStatus != kStatus_Uhk_NoTransfer) {
+        if (currentStatus != kStatus_Uhk_IdleCycle) {
             previousSlaveId = currentSlaveId++;
+            if (currentSlaveId >= SLAVE_COUNT) {
+                currentSlaveId = 0;
+            }
         }
 
-        if (currentSlaveId >= (sizeof(Slaves) / sizeof(uhk_slave_t))) {
-            currentSlaveId = 0;
-        }
     } while (!isTransferScheduled);
 }
 
@@ -93,7 +103,7 @@ void InitSlaveScheduler(void)
     previousSlaveId = 0;
     currentSlaveId = 0;
 
-    for (uint8_t i=0; i<sizeof(Slaves) / sizeof(uhk_slave_t); i++) {
+    for (uint8_t i=0; i<SLAVE_COUNT; i++) {
         uhk_slave_t *currentSlave = Slaves + i;
         currentSlave->isConnected = false;
     }

right/src/slave_scheduler.h

@@ -4,6 +4,14 @@
 // Includes:
 
     #include "fsl_common.h"
+    #include "config.h"
+
+// Macros:
+
+    #define SLAVE_COUNT (sizeof(Slaves) / sizeof(uhk_slave_t))
+    #define MAX_SLAVE_COUNT 6
+    #define IS_VALID_SLAVE_ID(slaveId) (0 <= slaveId && slaveId <= MAX_SLAVE_COUNT)
+    #define IS_STATUS_I2C_ERROR(status) (kStatus_I2C_Busy <= status && status <= kStatus_I2C_Timeout)
 
 // Typedefs:
 
@@ -11,8 +19,10 @@
         SlaveId_LeftKeyboardHalf,
         SlaveId_LeftAddon,
         SlaveId_RightAddon,
+#ifdef LED_DRIVERS_ENABLED
         SlaveId_RightLedDriver,
         SlaveId_LeftLedDriver,
+#endif
         SlaveId_KbootDriver,
     } slave_id_t;
 
@@ -30,12 +40,12 @@
     } uhk_slave_t;
 
     typedef enum {
-        kStatusGroup_Uhk = -1,
+        kStatusGroup_Uhk = 200,
     } uhk_status_group_t;
 
     typedef enum {
-        kStatus_Uhk_IdleSlave  = MAKE_STATUS(kStatusGroup_Uhk, 0), // Another slave should be scheduled
+        kStatus_Uhk_IdleSlave = MAKE_STATUS(kStatusGroup_Uhk, 0), // Another slave should be scheduled
-        kStatus_Uhk_NoTransfer = MAKE_STATUS(kStatusGroup_Uhk, 1), // The same slave should be rescheduled
+        kStatus_Uhk_IdleCycle = MAKE_STATUS(kStatusGroup_Uhk, 1), // The same slave should be rescheduled
     } uhk_status_t;
 
 // Variables:

right/src/slot.h

@@ -13,7 +13,7 @@
 // Macros:
 
     #define SLOT_COUNT 4
-    #define IS_VALID_SLAVE_SLOT(slotId) (SlotId_LeftKeyboardHalf <= (slotId) && (slotId) <= SlotId_RightModule)
+    #define IS_VALID_MODULE_SLOT(slotId) (SlotId_LeftKeyboardHalf <= (slotId) && (slotId) <= SlotId_RightModule)
 
 // Typedefs:
 

right/src/timer.c

@@ -1,7 +1,7 @@
 #include "fsl_pit.h"
 #include "timer.h"
 
-uint32_t CurrentTime;
+static volatile uint32_t CurrentTime;
 
 void PIT_TIMER_HANDLER(void)
 {
@@ -14,15 +14,34 @@ void Timer_Init(void)
     pit_config_t pitConfig;
     PIT_GetDefaultConfig(&pitConfig);
     PIT_Init(PIT, &pitConfig);
-    PIT_SetTimerPeriod(PIT, PIT_TIMER_CHANNEL, MSEC_TO_COUNT(TIMER_INTERVAL_MSEC, PIT_SOURCE_CLOCK));
+
+    // TODO: Why the interval needs to be multiplied by two to arrive to the correct timing?
+    // Figure it out and clean this up.
+    PIT_SetTimerPeriod(PIT, PIT_TIMER_CHANNEL, MSEC_TO_COUNT(TIMER_INTERVAL_MSEC*2, PIT_SOURCE_CLOCK));
+
     PIT_EnableInterrupts(PIT, PIT_TIMER_CHANNEL, kPIT_TimerInterruptEnable);
     EnableIRQ(PIT_TIMER_IRQ_ID);
     PIT_StartTimer(PIT, PIT_TIMER_CHANNEL);
 }
 
+uint32_t Timer_GetCurrentTime() {
+    return CurrentTime;
+}
+
+void Timer_SetCurrentTime(uint32_t *time)
+{
+    *time = CurrentTime;
+}
+
 uint32_t Timer_GetElapsedTime(uint32_t *time)
 {
     uint32_t elapsedTime = CurrentTime - *time;
+    return elapsedTime;
+}
+
+uint32_t Timer_GetElapsedTimeAndSetCurrent(uint32_t *time)
+{
+    uint32_t elapsedTime = Timer_GetElapsedTime(time);
     *time = CurrentTime;
     return elapsedTime;
 }

right/src/timer.h

@@ -9,13 +9,12 @@
 
     #define TIMER_INTERVAL_MSEC 1
 
-// Variables:
-
-    extern uint32_t CurrentTime;
-
 // Functions:
 
     void Timer_Init(void);
+    uint32_t Timer_GetCurrentTime();
+    void Timer_SetCurrentTime(uint32_t *time);
     uint32_t Timer_GetElapsedTime(uint32_t *time);
+    uint32_t Timer_GetElapsedTimeAndSetCurrent(uint32_t *time);
 
 #endif

right/src/usb_api.h

@@ -18,6 +18,7 @@
     #define USB_DEVICE_CLASS 0x00
     #define USB_DEVICE_SUBCLASS 0x00
     #define USB_DEVICE_PROTOCOL 0x00
+    #define USB_IRQ_ID USB0_IRQn
 
     #define USB_INTERFACE_ALTERNATE_SETTING_NONE 0x00
     #define USB_STRING_DESCRIPTOR_NONE           0x00

right/src/usb_commands/usb_command_apply_config.c

@@ -45,15 +45,9 @@ void UsbCommand_ApplyConfig(void)
     }
 
     // Switch to the keymap of the updated configuration of the same name or the default keymap.
-
+    if (SwitchKeymapByAbbreviation(oldKeymapAbbreviationLen, oldKeymapAbbreviation)) {
-    for (uint8_t keymapId = 0; keymapId < AllKeymapsCount; keymapId++) {
+        return;
-        if (AllKeymaps[keymapId].abbreviationLen == oldKeymapAbbreviationLen &&
-            !memcmp(oldKeymapAbbreviation, AllKeymaps[keymapId].abbreviation, oldKeymapAbbreviationLen))
-        {
-            SwitchKeymap(keymapId);
-            return;
-        }
     }
 
-    SwitchKeymap(DefaultKeymapIndex);
+    SwitchKeymapById(DefaultKeymapIndex);
 }

right/src/usb_commands/usb_command_get_debug_buffer.c

@@ -5,6 +5,12 @@
 #include "i2c_watchdog.h"
 #include "buffer.h"
 #include "timer.h"
+#include "key_scanner.h"
+#include "usb_report_updater.h"
+#include "usb_interfaces/usb_interface_basic_keyboard.h"
+#include "usb_interfaces/usb_interface_media_keyboard.h"
+#include "usb_interfaces/usb_interface_system_keyboard.h"
+#include "usb_interfaces/usb_interface_mouse.h"
 
 uint8_t DebugBuffer[USB_GENERIC_HID_OUT_BUFFER_LENGTH];
 
@@ -14,15 +20,16 @@ void UsbCommand_GetDebugBuffer(void)
     SetDebugBufferUint32(5, I2cSlaveScheduler_Counter);
     SetDebugBufferUint32(9, I2cWatchdog_WatchCounter);
     SetDebugBufferUint32(13, I2cWatchdog_RecoveryCounter);
-    SetDebugBufferUint32(40, CurrentTime);
+    SetDebugBufferUint32(17, KeyScannerCounter);
+    SetDebugBufferUint32(21, UsbReportUpdateCounter);
+    SetDebugBufferUint32(25, Timer_GetCurrentTime());
+    SetDebugBufferUint32(29, UsbGenericHidActionCounter);
+    SetDebugBufferUint32(33, UsbBasicKeyboardActionCounter);
+    SetDebugBufferUint32(37, UsbMediaKeyboardActionCounter);
+    SetDebugBufferUint32(41, UsbSystemKeyboardActionCounter);
+    SetDebugBufferUint32(45, UsbMouseActionCounter);
 
     memcpy(GenericHidOutBuffer, DebugBuffer, USB_GENERIC_HID_OUT_BUFFER_LENGTH);
-
-/*    uint64_t ticks = microseconds_get_ticks();
-    uint32_t microseconds = microseconds_convert_to_microseconds(ticks);
-    uint32_t milliseconds = microseconds/1000;
-    *(uint32_t*)(GenericHidOutBuffer+1) = ticks;
-*/
 }
 
 void SetDebugBufferUint8(uint32_t offset, uint8_t value)
@@ -39,3 +46,23 @@ void SetDebugBufferUint32(uint32_t offset, uint32_t value)
 {
     SetBufferUint32(DebugBuffer, offset, value);
 }
+
+void SetDebugBufferInt8(uint32_t offset, int8_t value)
+{
+    SetBufferInt8(DebugBuffer, offset, value);
+}
+
+void SetDebugBufferInt16(uint32_t offset, int16_t value)
+{
+    SetBufferInt16(DebugBuffer, offset, value);
+}
+
+void SetDebugBufferInt32(uint32_t offset, int32_t value)
+{
+    SetBufferInt32(DebugBuffer, offset, value);
+}
+
+void SetDebugBufferFloat(uint32_t offset, float value)
+{
+    *(float*)(DebugBuffer + offset) = value;
+}

right/src/usb_commands/usb_command_get_debug_buffer.h

@@ -17,4 +17,10 @@
     void SetDebugBufferUint16(uint32_t offset, uint16_t value);
     void SetDebugBufferUint32(uint32_t offset, uint32_t value);
 
+    void SetDebugBufferInt8(uint32_t offset, int8_t value);
+    void SetDebugBufferInt16(uint32_t offset, int16_t value);
+    void SetDebugBufferInt32(uint32_t offset, int32_t value);
+
+    void SetDebugBufferFloat(uint32_t offset, float value);
+
 #endif

right/src/usb_commands/usb_command_get_device_property.c

@@ -0,0 +1,78 @@
+#include "fsl_common.h"
+#include "usb_commands/usb_command_get_device_property.h"
+#include "usb_protocol_handler.h"
+#include "eeprom.h"
+#include "versions.h"
+#include "slave_drivers/kboot_driver.h"
+#include "i2c.h"
+#include "init_peripherals.h"
+#include "fsl_i2c.h"
+#include "timer.h"
+
+version_t deviceProtocolVersion = {
+    DEVICE_PROTOCOL_MAJOR_VERSION,
+    DEVICE_PROTOCOL_MINOR_VERSION,
+    DEVICE_PROTOCOL_PATCH_VERSION,
+};
+
+version_t protocolVersions[] =
+{
+    {
+        FIRMWARE_MAJOR_VERSION,
+        FIRMWARE_MINOR_VERSION,
+        FIRMWARE_PATCH_VERSION,
+    },
+    {
+        DEVICE_PROTOCOL_MAJOR_VERSION,
+        DEVICE_PROTOCOL_MINOR_VERSION,
+        DEVICE_PROTOCOL_PATCH_VERSION,
+    },
+    {
+        MODULE_PROTOCOL_MAJOR_VERSION,
+        MODULE_PROTOCOL_MINOR_VERSION,
+        MODULE_PROTOCOL_PATCH_VERSION,
+    },
+    {
+        USER_CONFIG_MAJOR_VERSION,
+        USER_CONFIG_MINOR_VERSION,
+        USER_CONFIG_PATCH_VERSION,
+    },
+    {
+        HARDWARE_CONFIG_MAJOR_VERSION,
+        HARDWARE_CONFIG_MINOR_VERSION,
+        HARDWARE_CONFIG_PATCH_VERSION,
+    }
+};
+
+uint16_t configSizes[] = {HARDWARE_CONFIG_SIZE, USER_CONFIG_SIZE};
+
+void UsbCommand_GetDeviceProperty(void)
+{
+    uint8_t propertyId = GetUsbRxBufferUint8(1);
+
+    switch (propertyId) {
+        case DevicePropertyId_DeviceProtocolVersion:
+            memcpy(GenericHidOutBuffer+1, (uint8_t*)&deviceProtocolVersion, sizeof(deviceProtocolVersion));
+            break;
+        case DevicePropertyId_ProtocolVersions:
+            memcpy(GenericHidOutBuffer+1, (uint8_t*)&protocolVersions, sizeof(protocolVersions));
+            break;
+        case DevicePropertyId_ConfigSizes:
+            memcpy(GenericHidOutBuffer+1, (uint8_t*)&configSizes, sizeof(configSizes));
+            break;
+        case DevicePropertyId_CurrentKbootCommand:
+            GenericHidOutBuffer[1] = KbootDriverState.command;
+            break;
+        case DevicePropertyId_I2cMainBusBaudRate:
+            GenericHidOutBuffer[1] = I2C_MAIN_BUS_BASEADDR->F;
+            SetUsbTxBufferUint32(2, I2cMainBusRequestedBaudRateBps);
+            SetUsbTxBufferUint32(6, I2cMainBusActualBaudRateBps);
+            break;
+        case DevicePropertyId_Uptime:
+            SetUsbTxBufferUint32(1, Timer_GetCurrentTime());
+            break;
+        default:
+            SetUsbTxBufferUint8(0, UsbStatusCode_GetDeviceProperty_InvalidProperty);
+            break;
+    }
+}

right/src/usb_commands/usb_command_get_device_property.h

@@ -0,0 +1,23 @@
+#ifndef __USB_COMMAND_GET_DEVICE_PROPERTY_H__
+#define __USB_COMMAND_GET_DEVICE_PROPERTY_H__
+
+// Typedefs:
+
+    typedef enum {
+        DevicePropertyId_DeviceProtocolVersion = 0,
+        DevicePropertyId_ProtocolVersions      = 1,
+        DevicePropertyId_ConfigSizes           = 2,
+        DevicePropertyId_CurrentKbootCommand   = 3,
+        DevicePropertyId_I2cMainBusBaudRate    = 4,
+        DevicePropertyId_Uptime                = 5,
+    } device_property_t;
+
+    typedef enum {
+        UsbStatusCode_GetDeviceProperty_InvalidProperty = 2,
+    } usb_status_code_get_device_property_t;
+
+// Functions:
+
+    void UsbCommand_GetDeviceProperty(void);
+
+#endif

right/src/usb_commands/usb_command_get_device_state.c

@@ -1,5 +1,5 @@
 #include "fsl_common.h"
-#include "usb_commands/usb_command_get_keyboard_state.h"
+#include "usb_commands/usb_command_get_device_state.h"
 #include "usb_protocol_handler.h"
 #include "eeprom.h"
 #include "peripherals/merge_sensor.h"

right/src/usb_commands/usb_command_get_module_property.c

@@ -0,0 +1,26 @@
+#include "fsl_common.h"
+#include "usb_commands/usb_command_get_module_property.h"
+#include "usb_protocol_handler.h"
+#include "slot.h"
+#include "slave_drivers/uhk_module_driver.h"
+
+void UsbCommand_GetModuleProperty()
+{
+    slot_t slotId = GetUsbRxBufferUint8(1);
+
+    if (!IS_VALID_MODULE_SLOT(slotId)) {
+        SetUsbTxBufferUint8(0, UsbStatusCode_GetModuleProperty_InvalidModuleSlotId);
+    }
+
+    module_property_id_t modulePropertyId = GetUsbRxBufferUint8(2);
+    switch (modulePropertyId) {
+        case ModulePropertyId_VersionNumbers: {
+            uint8_t moduleDriverId = SLOT_ID_TO_UHK_MODULE_DRIVER_ID(slotId);
+            uhk_module_state_t *moduleState = UhkModuleStates + moduleDriverId;
+            GenericHidOutBuffer[1] = moduleState->moduleId;
+            memcpy(GenericHidOutBuffer + 2, &moduleState->moduleProtocolVersion, sizeof(version_t));
+            memcpy(GenericHidOutBuffer + 8, &moduleState->firmwareVersion, sizeof(version_t));
+            break;
+        }
+    }
+}

right/src/usb_commands/usb_command_get_module_property.h

@@ -0,0 +1,18 @@
+#ifndef __USB_COMMAND_GET_MODULE_PROPERTY_H__
+#define __USB_COMMAND_GET_MODULE_PROPERTY_H__
+
+// Functions:
+
+    void UsbCommand_GetModuleProperty();
+
+// Typedefs:
+
+    typedef enum {
+        ModulePropertyId_VersionNumbers = 0,
+    } module_property_id_t;
+
+    typedef enum {
+        UsbStatusCode_GetModuleProperty_InvalidModuleSlotId = 2,
+    } usb_status_code_get_module_property_t;
+
+#endif

right/src/usb_commands/usb_command_get_property.c

@@ -1,33 +0,0 @@
-#include "fsl_common.h"
-#include "usb_commands/usb_command_get_property.h"
-#include "usb_protocol_handler.h"
-#include "eeprom.h"
-
-void UsbCommand_GetProperty(void)
-{
-    uint8_t propertyId = GetUsbRxBufferUint8(1);
-
-    switch (propertyId) {
-        case SystemPropertyId_UsbProtocolVersion:
-            SetUsbTxBufferUint8(1, SYSTEM_PROPERTY_USB_PROTOCOL_VERSION);
-            break;
-        case SystemPropertyId_BridgeProtocolVersion:
-            SetUsbTxBufferUint8(1, SYSTEM_PROPERTY_BRIDGE_PROTOCOL_VERSION);
-            break;
-        case SystemPropertyId_DataModelVersion:
-            SetUsbTxBufferUint8(1, SYSTEM_PROPERTY_DATA_MODEL_VERSION);
-            break;
-        case SystemPropertyId_FirmwareVersion:
-            SetUsbTxBufferUint8(1, SYSTEM_PROPERTY_FIRMWARE_VERSION);
-            break;
-        case SystemPropertyId_HardwareConfigSize:
-            SetUsbTxBufferUint16(1, HARDWARE_CONFIG_SIZE);
-            break;
-        case SystemPropertyId_UserConfigSize:
-            SetUsbTxBufferUint16(1, USER_CONFIG_SIZE);
-            break;
-        default:
-            SetUsbTxBufferUint8(0, UsbStatusCode_GetProperty_InvalidProperty);
-            break;
-    }
-}

right/src/usb_commands/usb_command_get_property.h

@@ -1,30 +0,0 @@
-#ifndef __USB_COMMAND_GET_PROPERTY_H__
-#define __USB_COMMAND_GET_PROPERTY_H__
-
-// Macros:
-
-    #define SYSTEM_PROPERTY_USB_PROTOCOL_VERSION      1
-    #define SYSTEM_PROPERTY_BRIDGE_PROTOCOL_VERSION   1
-    #define SYSTEM_PROPERTY_DATA_MODEL_VERSION        1
-    #define SYSTEM_PROPERTY_FIRMWARE_VERSION          1
-
-// Typedefs:
-
-    typedef enum {
-        SystemPropertyId_UsbProtocolVersion    = 0,
-        SystemPropertyId_BridgeProtocolVersion = 1,
-        SystemPropertyId_DataModelVersion      = 2,
-        SystemPropertyId_FirmwareVersion       = 3,
-        SystemPropertyId_HardwareConfigSize    = 4,
-        SystemPropertyId_UserConfigSize        = 5,
-    } system_property_t;
-
-    typedef enum {
-        UsbStatusCode_GetProperty_InvalidProperty = 2,
-    } usb_status_code_get_property_t;
-
-// Functions:
-
-    void UsbCommand_GetProperty(void);
-
-#endif

right/src/usb_commands/usb_command_get_slave_i2c_errors.c

@@ -0,0 +1,19 @@
+#include "fsl_common.h"
+#include "usb_commands/usb_command_get_slave_i2c_errors.h"
+#include "usb_protocol_handler.h"
+#include "slave_scheduler.h"
+#include "i2c_error_logger.h"
+
+void UsbCommand_GetSlaveI2cErrors()
+{
+    uint8_t slaveId = GetUsbRxBufferUint8(1);
+
+    if (!IS_VALID_SLAVE_ID(slaveId)) {
+        SetUsbTxBufferUint8(0, UsbStatusCode_GetModuleProperty_InvalidSlaveId);
+    }
+
+    i2c_slave_error_counter_t *i2cSlaveErrorCounter =  I2cSlaveErrorCounters + slaveId;
+
+    GenericHidOutBuffer[1] = i2cSlaveErrorCounter->errorTypeCount;
+    memcpy(GenericHidOutBuffer + 2, i2cSlaveErrorCounter->errors, sizeof(i2c_error_count_t) * MAX_LOGGED_I2C_ERROR_TYPES_PER_SLAVE);
+}

right/src/usb_commands/usb_command_get_slave_i2c_errors.h

@@ -0,0 +1,14 @@
+#ifndef __USB_COMMAND_GET_SLAVE_I2C_ERRORS_H__
+#define __USB_COMMAND_GET_SLAVE_I2C_ERRORS_H__
+
+// Functions:
+
+    void UsbCommand_GetSlaveI2cErrors();
+
+// Typedefs:
+
+    typedef enum {
+        UsbStatusCode_GetModuleProperty_InvalidSlaveId = 2,
+    } usb_status_code_get_slave_i2c_errors_t;
+
+#endif

right/src/usb_commands/usb_command_jump_to_module_bootloader.c

@@ -0,0 +1,17 @@
+#include "usb_protocol_handler.h"
+#include "usb_commands/usb_command_jump_to_module_bootloader.h"
+#include "slot.h"
+#include "slave_drivers/uhk_module_driver.h"
+
+void UsbCommand_JumpToModuleBootloader(void)
+{
+    uint8_t slotId = GetUsbRxBufferUint8(1);
+
+    if (!IS_VALID_MODULE_SLOT(slotId)) {
+        SetUsbTxBufferUint8(0, UsbStatusCode_JumpToModuleBootloader_InvalidSlaveSlotId);
+        return;
+    }
+
+    uint8_t uhkModuleDriverId = SLOT_ID_TO_UHK_MODULE_DRIVER_ID(slotId);
+    UhkModuleStates[uhkModuleDriverId].phase = UhkModulePhase_JumpToBootloader;
+}

right/src/usb_commands/usb_command_jump_to_module_bootloader.h

@@ -0,0 +1,14 @@
+#ifndef __USB_COMMAND_JUMP_TO_MODULE_BOOTLOADER_H__
+#define __USB_COMMAND_JUMP_TO_MODULE_BOOTLOADER_H__
+
+// Functions:
+
+    void UsbCommand_JumpToModuleBootloader(void);
+
+// Typedefs:
+
+    typedef enum {
+        UsbStatusCode_JumpToModuleBootloader_InvalidSlaveSlotId = 2,
+    } usb_status_code_jump_to_module_bootloader_t;
+
+#endif

right/src/usb_commands/usb_command_jump_to_slave_bootloader.c

@@ -1,17 +0,0 @@
-#include "usb_protocol_handler.h"
-#include "usb_commands/usb_command_jump_to_slave_bootloader.h"
-#include "slot.h"
-#include "slave_drivers/uhk_module_driver.h"
-
-void UsbCommand_JumpToSlaveBootloader(void)
-{
-    uint8_t slotId = GetUsbRxBufferUint8(1);
-
-    if (!IS_VALID_SLAVE_SLOT(slotId)) {
-        SetUsbTxBufferUint8(0, UsbStatusCode_JumpToSlaveBootloader_InvalidSlaveSlotId);
-        return;
-    }
-
-    uint8_t uhkModuleDriverId = SLOT_ID_TO_UHK_MODULE_DRIVER_ID(slotId);
-    UhkModuleStates[uhkModuleDriverId].jumpToBootloader = true;
-}

right/src/usb_commands/usb_command_jump_to_slave_bootloader.h

@@ -1,14 +0,0 @@
-#ifndef __USB_COMMAND_JUMP_TO_SLAVE_BOOTLOADER_H__
-#define __USB_COMMAND_JUMP_TO_SLAVE_BOOTLOADER_H__
-
-// Functions:
-
-    void UsbCommand_JumpToSlaveBootloader(void);
-
-// Typedefs:
-
-    typedef enum {
-        UsbStatusCode_JumpToSlaveBootloader_InvalidSlaveSlotId = 2,
-    } usb_status_code_jump_to_slave_bootloader_t;
-
-#endif

right/src/usb_commands/usb_command_launch_eeprom_transfer.c

@@ -0,0 +1,25 @@
+#include "fsl_common.h"
+#include "usb_commands/usb_command_launch_eeprom_transfer.h"
+#include "usb_protocol_handler.h"
+#include "eeprom.h"
+#include "config_parser/config_globals.h"
+
+void UsbCommand_LaunchEepromTransfer(void)
+{
+    eeprom_operation_t eepromOperation = GetUsbRxBufferUint8(1);
+    config_buffer_id_t configBufferId = GetUsbRxBufferUint8(2);
+
+    if (!IsEepromOperationValid(eepromOperation)) {
+        SetUsbTxBufferUint8(0, UsbStatusCode_LaunchEepromTransfer_InvalidEepromOperation);
+    }
+
+    if (!IsConfigBufferIdValid(configBufferId)) {
+        SetUsbTxBufferUint8(0, UsbStatusCode_LaunchEepromTransfer_InvalidConfigBufferId);
+    }
+
+    status_t status = EEPROM_LaunchTransfer(eepromOperation, configBufferId, NULL);
+    if (status != kStatus_Success) {
+        SetUsbTxBufferUint8(0, UsbStatusCode_LaunchEepromTransfer_TransferError);
+        SetUsbTxBufferUint32(1, status);
+    }
+}

right/src/usb_commands/usb_command_launch_eeprom_transfer.h

@@ -0,0 +1,16 @@
+#ifndef __USB_COMMAND_LAUNCH_EEPROM_TRANSFER_H__
+#define __USB_COMMAND_LAUNCH_EEPROM_TRANSFER_H__
+
+// Typedef
+
+    typedef enum {
+        UsbStatusCode_LaunchEepromTransfer_InvalidEepromOperation = 2,
+        UsbStatusCode_LaunchEepromTransfer_InvalidConfigBufferId = 3,
+        UsbStatusCode_LaunchEepromTransfer_TransferError = 4,
+    } usb_status_code_launch_eeprom_transfer_t;
+
+// Functions:
+
+    void UsbCommand_LaunchEepromTransfer(void);
+
+#endif

right/src/usb_commands/usb_command_launch_eeprom_transfer_legacy.c

@@ -1,23 +0,0 @@
-#include "fsl_common.h"
-#include "usb_commands/usb_command_launch_eeprom_transfer_legacy.h"
-#include "usb_protocol_handler.h"
-#include "eeprom.h"
-
-void UsbCommand_LaunchEepromTransferLegacy(void)
-{
-    uint8_t legacyEepromTransferId = GetUsbRxBufferUint8(1);
-    switch (legacyEepromTransferId) {
-    case 0:
-        EEPROM_LaunchTransfer(EepromOperation_Read, ConfigBufferId_HardwareConfig, NULL);
-        break;
-    case 1:
-        EEPROM_LaunchTransfer(EepromOperation_Write, ConfigBufferId_HardwareConfig, NULL);
-        break;
-    case 2:
-        EEPROM_LaunchTransfer(EepromOperation_Read, ConfigBufferId_ValidatedUserConfig, NULL);
-        break;
-    case 3:
-        EEPROM_LaunchTransfer(EepromOperation_Write, ConfigBufferId_ValidatedUserConfig, NULL);
-        break;
-    }
-}

right/src/usb_commands/usb_command_launch_eeprom_transfer_legacy.h

@@ -1,8 +0,0 @@
-#ifndef __USB_COMMAND_LAUNCH_EEPROM_TRANSFER_LEGACY_H__
-#define __USB_COMMAND_LAUNCH_EEPROM_TRANSFER_LEGACY_H__
-
-// Functions:
-
-    void UsbCommand_LaunchEepromTransferLegacy(void);
-
-#endif

right/src/usb_commands/usb_command_read_config.c

@@ -3,23 +3,28 @@
 #include "usb_protocol_handler.h"
 #include "eeprom.h"
 
-void UsbCommand_ReadConfig(bool isHardware)
+void UsbCommand_ReadConfig()
 {
-    uint8_t length = GetUsbRxBufferUint8(1);
+    config_buffer_id_t configBufferId = GetUsbRxBufferUint8(1);
-    uint16_t offset = GetUsbRxBufferUint16(2);
+    uint8_t length = GetUsbRxBufferUint8(2);
+    uint16_t offset = GetUsbRxBufferUint16(3);
+
+    if (!IsConfigBufferIdValid(configBufferId)) {
+        SetUsbTxBufferUint8(0, UsbStatusCode_ReadConfig_InvalidConfigBufferId);
+    }
 
     if (length > USB_GENERIC_HID_OUT_BUFFER_LENGTH - USB_STATUS_CODE_SIZE) {
         SetUsbTxBufferUint8(0, UsbStatusCode_ReadConfig_LengthTooLarge);
         return;
     }
 
-    uint8_t *buffer = isHardware ? HardwareConfigBuffer.buffer : ValidatedUserConfigBuffer.buffer;
+    config_buffer_t *buffer = ConfigBufferIdToConfigBuffer(configBufferId);
-    uint16_t bufferLength = isHardware ? HARDWARE_CONFIG_SIZE : USER_CONFIG_SIZE;
+    uint16_t bufferLength = ConfigBufferIdToBufferSize(configBufferId);
 
     if (offset + length > bufferLength) {
         SetUsbTxBufferUint8(0, UsbStatusCode_ReadConfig_BufferOutOfBounds);
         return;
     }
 
-    memcpy(GenericHidOutBuffer + USB_STATUS_CODE_SIZE, buffer + offset, length);
+    memcpy(GenericHidOutBuffer + USB_STATUS_CODE_SIZE, buffer->buffer + offset, length);
 }

right/src/usb_commands/usb_command_read_config.h

@@ -3,13 +3,14 @@
 
 // Functions:
 
-    void UsbCommand_ReadConfig(bool isHardware);
+    void UsbCommand_ReadConfig();
 
 // Typedefs:
 
     typedef enum {
-        UsbStatusCode_ReadConfig_LengthTooLarge    = 2,
+        UsbStatusCode_ReadConfig_InvalidConfigBufferId = 2,
-        UsbStatusCode_ReadConfig_BufferOutOfBounds = 3,
+        UsbStatusCode_ReadConfig_LengthTooLarge        = 3,
+        UsbStatusCode_ReadConfig_BufferOutOfBounds     = 4,
     } usb_status_code_read_config_t;
 
 #endif

right/src/usb_commands/usb_command_send_kboot_command.c

@@ -1,10 +0,0 @@
-#include "usb_protocol_handler.h"
-#include "usb_commands/usb_command_send_kboot_command.h"
-#include "slave_drivers/kboot_driver.h"
-
-void UsbCommand_SendKbootCommand(void)
-{
-    KbootDriverState.phase = 0;
-    KbootDriverState.i2cAddress  = GetUsbRxBufferUint8(2);
-    KbootDriverState.commandType = GetUsbRxBufferUint8(1); // Command should be set last.
-}

right/src/usb_commands/usb_command_send_kboot_command.h

@@ -1,8 +0,0 @@
-#ifndef __USB_COMMAND_SEND_KBOOT_COMMAND_H__
-#define __USB_COMMAND_SEND_KBOOT_COMMAND_H__
-
-// Functions:
-
-    void UsbCommand_SendKbootCommand(void);
-
-#endif

right/src/usb_commands/usb_command_send_kboot_command_to_module.c

@@ -0,0 +1,10 @@
+#include "usb_protocol_handler.h"
+#include "usb_commands/usb_command_send_kboot_command_to_module.h"
+#include "slave_drivers/kboot_driver.h"
+
+void UsbCommand_SendKbootCommandToModule(void)
+{
+    KbootDriverState.phase = 0;
+    KbootDriverState.i2cAddress  = GetUsbRxBufferUint8(2);
+    KbootDriverState.command = GetUsbRxBufferUint8(1); // Command should be set last.
+}

right/src/usb_commands/usb_command_send_kboot_command_to_module.h

@@ -0,0 +1,8 @@
+#ifndef __USB_COMMAND_SEND_KBOOT_COMMAND_TO_MODULE_H__
+#define __USB_COMMAND_SEND_KBOOT_COMMAND_TO_MODULE_H__
+
+// Functions:
+
+    void UsbCommand_SendKbootCommandToModule(void);
+
+#endif

right/src/usb_commands/usb_command_set_i2c_baud_rate.c

@@ -0,0 +1,11 @@
+#include "usb_protocol_handler.h"
+#include "usb_commands/usb_command_set_i2c_baud_rate.h"
+#include "init_peripherals.h"
+#include "fsl_i2c.h"
+
+void UsbCommand_SetI2cBaudRate(void)
+{
+    uint32_t i2cBaudRate = GetUsbRxBufferUint32(1);
+    I2cMainBusRequestedBaudRateBps = i2cBaudRate;
+    ReinitI2cMainBus();
+}

right/src/usb_commands/usb_command_set_i2c_baud_rate.h

@@ -0,0 +1,8 @@
+#ifndef __USB_COMMAND_SET_I2C_BAUD_RATE__
+#define __USB_COMMAND_SET_I2C_BAUD_RATE__
+
+// Functions:
+
+    void UsbCommand_SetI2cBaudRate(void);
+
+#endif

right/src/usb_commands/usb_command_switch_keymap.c

@@ -0,0 +1,17 @@
+#include "usb_protocol_handler.h"
+#include "usb_commands/usb_command_switch_keymap.h"
+#include "keymap.h"
+
+void UsbCommand_SwitchKeymap(void)
+{
+    uint32_t keymapLength = GetUsbRxBufferUint8(1);
+    char *keymapAbbrev = (char*)GenericHidInBuffer + 2;
+
+    if (keymapLength > KEYMAP_ABBREVIATION_LENGTH) {
+        SetUsbTxBufferUint8(0, UsbStatusCode_SwitchKeymap_InvalidAbbreviationLength);
+    }
+
+    if (!SwitchKeymapByAbbreviation(keymapLength, keymapAbbrev)) {
+        SetUsbTxBufferUint8(0, UsbStatusCode_SwitchKeymap_InvalidAbbreviation);
+    }
+}

right/src/usb_commands/usb_command_switch_keymap.h

@@ -0,0 +1,15 @@
+#ifndef __USB_COMMAND_SWITCH_KEYMAP_H__
+#define __USB_COMMAND_SWITCH_KEYMAP_H__
+
+// Functions:
+
+    void UsbCommand_SwitchKeymap(void);
+
+// Typedefs:
+
+    typedef enum {
+        UsbStatusCode_SwitchKeymap_InvalidAbbreviationLength = 2,
+        UsbStatusCode_SwitchKeymap_InvalidAbbreviation = 3,
+    } usb_status_code_switch_keymap_t;
+
+#endif

right/src/usb_commands/usb_command_write_config.c

@@ -3,7 +3,7 @@
 #include "usb_protocol_handler.h"
 #include "eeprom.h"
 
-void UsbCommand_WriteConfig(bool isHardware)
+void UsbCommand_WriteConfig(config_buffer_id_t configBufferId)
 {
     uint8_t length = GetUsbRxBufferUint8(1);
     uint16_t offset = GetUsbRxBufferUint16(2);
@@ -14,8 +14,8 @@ void UsbCommand_WriteConfig(bool isHardware)
         return;
     }
 
-    uint8_t *buffer = isHardware ? HardwareConfigBuffer.buffer : StagingUserConfigBuffer.buffer;
+    uint8_t *buffer = ConfigBufferIdToConfigBuffer(configBufferId)->buffer;
-    uint16_t bufferLength = isHardware ? HARDWARE_CONFIG_SIZE : USER_CONFIG_SIZE;
+    uint16_t bufferLength = ConfigBufferIdToBufferSize(configBufferId);
 
     if (offset + length > bufferLength) {
         SetUsbTxBufferUint8(0, UsbStatusCode_WriteConfig_BufferOutOfBounds);

right/src/usb_commands/usb_command_write_config.h

@@ -1,9 +1,9 @@
 #ifndef __USB_COMMAND_WRITE_CONFIG_H__
 #define __USB_COMMAND_WRITE_CONFIG_H__
 
-// Functions:
+// Includes:
 
-    void UsbCommand_WriteConfig(bool isHardware);
+    #include "config_parser/config_globals.h"
 
 // Typedefs:
 
@@ -12,4 +12,8 @@
         UsbStatusCode_WriteConfig_BufferOutOfBounds = 3,
     } usb_status_code_write_config_t;
 
+// Functions:
+
+    void UsbCommand_WriteConfig(config_buffer_id_t configBufferId);
+
 #endif

right/src/usb_composite_device.c

@@ -1,3 +1,6 @@
+#include "config.h"
+#include "led_display.h"
+#include "slave_drivers/is31fl3731_driver.h"
 #include "usb_device_config.h"
 #include "usb_composite_device.h"
 #include "usb_descriptors/usb_descriptor_hid.h"
@@ -5,37 +8,243 @@
 #include "bus_pal_hardware.h"
 #include "bootloader/wormhole.h"
 
-static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event, void *param);
 usb_composite_device_t UsbCompositeDevice;
+static usb_status_t usbDeviceCallback(usb_device_handle handle, uint32_t event, void *param);
 
-usb_device_class_config_struct_t UsbDeviceCompositeClassConfig[USB_DEVICE_CONFIG_HID] = {
+static usb_device_class_config_list_struct_t UsbDeviceCompositeConfigList = {
-    {UsbGenericHidCallback,     (class_handle_t)NULL, &UsbGenericHidClass},
+    .deviceCallback = usbDeviceCallback,
-    {UsbBasicKeyboardCallback,  (class_handle_t)NULL, &UsbBasicKeyboardClass},
+    .count = USB_DEVICE_CONFIG_HID,
-    {UsbMediaKeyboardCallback,  (class_handle_t)NULL, &UsbMediaKeyboardClass},
+    .config = (usb_device_class_config_struct_t[USB_DEVICE_CONFIG_HID]) {{
-    {UsbSystemKeyboardCallback, (class_handle_t)NULL, &UsbSystemKeyboardClass},
+        .classCallback = UsbGenericHidCallback,
-    {UsbMouseCallback,          (class_handle_t)NULL, &UsbMouseClass},
+        .classInfomation = (usb_device_class_struct_t[]) {{
-};
+            .type = kUSB_DeviceClassTypeHid,
+            .configurations = USB_DEVICE_CONFIGURATION_COUNT,
+            .interfaceList = (usb_device_interface_list_t[USB_DEVICE_CONFIGURATION_COUNT]) {{
+                .count = USB_GENERIC_HID_INTERFACE_COUNT,
+                .interfaces = (usb_device_interfaces_struct_t[USB_GENERIC_HID_INTERFACE_COUNT]) {{
+                    .classCode = USB_CLASS_HID,
+                    .subclassCode = USB_HID_SUBCLASS_NONE,
+                    .protocolCode = USB_HID_PROTOCOL_NONE,
+                    .interfaceNumber = USB_GENERIC_HID_INTERFACE_INDEX,
+                    .count = 1,
+                    .interface = (usb_device_interface_struct_t[]) {{
+                        .alternateSetting = USB_INTERFACE_ALTERNATE_SETTING_NONE,
+                        .endpointList = {
+                            .count = USB_GENERIC_HID_ENDPOINT_COUNT,
+                            .endpoint = (usb_device_endpoint_struct_t[USB_GENERIC_HID_ENDPOINT_COUNT]) {
+                                {
+                                    .endpointAddress = USB_GENERIC_HID_ENDPOINT_IN_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+                                    .transferType = USB_ENDPOINT_INTERRUPT,
+                                    .maxPacketSize = USB_GENERIC_HID_INTERRUPT_IN_PACKET_SIZE,
+                                },
+                                {
+                                    .endpointAddress = USB_GENERIC_HID_ENDPOINT_OUT_INDEX | (USB_OUT << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+                                    .transferType = USB_ENDPOINT_INTERRUPT,
+                                    .maxPacketSize = USB_GENERIC_HID_INTERRUPT_OUT_PACKET_SIZE,
+                                }
+                            }
+                        }
+                    }}
+                }}
+            }}
+        }}
+    },
+    {
+        .classCallback = UsbBasicKeyboardCallback,
+        .classInfomation = (usb_device_class_struct_t[]) {{
+            .type = kUSB_DeviceClassTypeHid,
+            .configurations = USB_DEVICE_CONFIGURATION_COUNT,
+            .interfaceList = (usb_device_interface_list_t[USB_DEVICE_CONFIGURATION_COUNT]) {{
+                .count = USB_BASIC_KEYBOARD_INTERFACE_COUNT,
+                .interfaces = (usb_device_interfaces_struct_t[USB_BASIC_KEYBOARD_INTERFACE_COUNT]) {{
+                    .classCode = USB_CLASS_HID,
+                    .subclassCode = USB_HID_SUBCLASS_BOOT,
+                    .protocolCode = USB_HID_PROTOCOL_KEYBOARD,
+                    .interfaceNumber = USB_BASIC_KEYBOARD_INTERFACE_INDEX,
+                    .count = 1,
+                    .interface = (usb_device_interface_struct_t[]) {{
+                        .alternateSetting = USB_INTERFACE_ALTERNATE_SETTING_NONE,
+                        .endpointList = {
+                            USB_BASIC_KEYBOARD_ENDPOINT_COUNT,
+                            (usb_device_endpoint_struct_t[USB_BASIC_KEYBOARD_ENDPOINT_COUNT]) {{
+                                .endpointAddress = USB_BASIC_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+                                .transferType = USB_ENDPOINT_INTERRUPT,
+                                .maxPacketSize = USB_BASIC_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
+                            }}
+                        }
+                    }}
+                }}
+            }}
+        }}
+    },
+    {
+        .classCallback = UsbMediaKeyboardCallback,
+        .classInfomation = (usb_device_class_struct_t[]) {{
+            .type = kUSB_DeviceClassTypeHid,
+            .configurations = USB_DEVICE_CONFIGURATION_COUNT,
+            .interfaceList = (usb_device_interface_list_t[USB_DEVICE_CONFIGURATION_COUNT]) {{
+                .count = USB_MEDIA_KEYBOARD_INTERFACE_COUNT,
+                .interfaces = (usb_device_interfaces_struct_t[USB_MEDIA_KEYBOARD_INTERFACE_COUNT]) {{
+                    .classCode = USB_CLASS_HID,
+                    .subclassCode = USB_HID_SUBCLASS_BOOT,
+                    .protocolCode = USB_HID_PROTOCOL_KEYBOARD,
+                    .interfaceNumber = USB_MEDIA_KEYBOARD_INTERFACE_INDEX,
+                    .count = 1,
+                    .interface = (usb_device_interface_struct_t[]) {{
+                        .alternateSetting = USB_INTERFACE_ALTERNATE_SETTING_NONE,
+                        .endpointList = {
+                            USB_MEDIA_KEYBOARD_ENDPOINT_COUNT,
+                            (usb_device_endpoint_struct_t[USB_MEDIA_KEYBOARD_ENDPOINT_COUNT]) {{
+                                .endpointAddress = USB_MEDIA_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+                                .transferType = USB_ENDPOINT_INTERRUPT,
+                                .maxPacketSize = USB_MEDIA_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
+                            }}
+                        }
+                    }}
+                }}
+            }}
+        }}
+    },
+    {
+        .classCallback = UsbSystemKeyboardCallback,
+        .classInfomation = (usb_device_class_struct_t[]) {{
+            .type = kUSB_DeviceClassTypeHid,
+            .configurations = USB_DEVICE_CONFIGURATION_COUNT,
+            .interfaceList = (usb_device_interface_list_t[USB_DEVICE_CONFIGURATION_COUNT]) {{
+                .count = USB_SYSTEM_KEYBOARD_INTERFACE_COUNT,
+                .interfaces = (usb_device_interfaces_struct_t[USB_SYSTEM_KEYBOARD_INTERFACE_COUNT]) {{
+                    .classCode = USB_CLASS_HID,
+                    .subclassCode = USB_HID_SUBCLASS_BOOT,
+                    .protocolCode = USB_HID_PROTOCOL_KEYBOARD,
+                    .interfaceNumber = USB_SYSTEM_KEYBOARD_INTERFACE_INDEX,
+                    .count = 1,
+                    .interface = (usb_device_interface_struct_t[]) {{
+                        .alternateSetting = USB_INTERFACE_ALTERNATE_SETTING_NONE,
+                        .endpointList = {
+                            USB_SYSTEM_KEYBOARD_ENDPOINT_COUNT,
+                            (usb_device_endpoint_struct_t[USB_SYSTEM_KEYBOARD_ENDPOINT_COUNT]) {{
+                                .endpointAddress = USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+                                .transferType = USB_ENDPOINT_INTERRUPT,
+                                .maxPacketSize = USB_SYSTEM_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
+                            }}
+                        }
+                    }}
+                }}
+            }},
+        }}
+    },
+    {
+        .classCallback = UsbMouseCallback,
+        .classInfomation = (usb_device_class_struct_t[]) {{
+            .type = kUSB_DeviceClassTypeHid,
+            .configurations = USB_DEVICE_CONFIGURATION_COUNT,
+            .interfaceList = (usb_device_interface_list_t[USB_DEVICE_CONFIGURATION_COUNT]) {{
+                .count = USB_MOUSE_INTERFACE_COUNT,
+                .interfaces = (usb_device_interfaces_struct_t[USB_MOUSE_INTERFACE_COUNT]) {{
+                    .classCode = USB_CLASS_HID,
+                    .subclassCode = USB_HID_SUBCLASS_BOOT,
+                    .protocolCode = USB_HID_PROTOCOL_MOUSE,
+                    .interfaceNumber = USB_MOUSE_INTERFACE_INDEX,
+                    .count = 1,
+                    .interface = (usb_device_interface_struct_t[]) {{
+                        .alternateSetting = USB_INTERFACE_ALTERNATE_SETTING_NONE,
+                        .endpointList = {
+                            USB_MOUSE_ENDPOINT_COUNT,
+                            (usb_device_endpoint_struct_t[USB_MOUSE_ENDPOINT_COUNT]) {{
+                                .endpointAddress = USB_MOUSE_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+                                .transferType = USB_ENDPOINT_INTERRUPT,
+                                .maxPacketSize = USB_MOUSE_INTERRUPT_IN_PACKET_SIZE,
+                            }}
+                        }
+                    }}
+                }}
+            }}
+        }}
+    }
+}};
 
-usb_device_class_config_list_struct_t UsbDeviceCompositeConfigList = {
+static bool computerSleeping = false;
-    UsbDeviceCompositeClassConfig,
+#ifdef LED_DRIVERS_ENABLED
-    UsbDeviceCallback,
+static uint8_t oldKeyBacklightBrightness = 0xFF;
-    USB_DEVICE_CONFIG_HID
+static bool capsLockOn = false, agentOn = false, adaptiveOn = false;
-};
+#endif
 
-static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event, void *param)
+bool IsComputerSleeping(void) {
+    return computerSleeping;
+}
+
+static void ComputerIsSleeping(void) {
+    computerSleeping = true;
+#ifdef LED_DRIVERS_ENABLED
+    // Save the state of the icons
+    capsLockOn = LedDisplay_GetIcon(LedDisplayIcon_CapsLock);
+    agentOn = LedDisplay_GetIcon(LedDisplayIcon_Agent);
+    adaptiveOn = LedDisplay_GetIcon(LedDisplayIcon_Adaptive);
+
+    // Disable keyboard backlight
+    oldKeyBacklightBrightness = KeyBacklightBrightness;
+    KeyBacklightBrightness = 0;
+    LedSlaveDriver_Init(LedDriverId_Right);
+    LedSlaveDriver_Init(LedDriverId_Left);
+
+    // Turn layer LEDs off
+    LedDisplay_SetLayer(LayerId_Base);
+
+    // Clear the text
+    LedDisplay_SetText(0, NULL);
+#endif
+}
+
+void WakeupComputer(bool sendResume) {
+    if (sendResume) // The device should wake up the computer
+        USB_DeviceSetStatus(UsbCompositeDevice.deviceHandle, kUSB_DeviceStatusBus, NULL); // Send resume signal - this will call USB_DeviceKhciControl(khciHandle, kUSB_DeviceControlResume, NULL);
+
+    computerSleeping = false; // The computer is now awake
+
+#ifdef LED_DRIVERS_ENABLED
+    // Restore keyboard backlight and text
+    KeyBacklightBrightness = oldKeyBacklightBrightness;
+    LedSlaveDriver_Init(LedDriverId_Right);
+    LedSlaveDriver_Init(LedDriverId_Left);
+
+    // Update the active layer
+    LedDisplay_SetLayer(GetActiveLayer());
+
+    // Restore icon states
+    LedDisplay_SetIcon(LedDisplayIcon_CapsLock, capsLockOn);
+    LedDisplay_SetIcon(LedDisplayIcon_Agent, agentOn);
+    LedDisplay_SetIcon(LedDisplayIcon_Adaptive, adaptiveOn);
+#endif
+}
+
+static usb_status_t usbDeviceCallback(usb_device_handle handle, uint32_t event, void *param)
 {
-    usb_status_t error = kStatus_USB_Error;
+    usb_status_t status = kStatus_USB_Error;
     uint16_t *temp16 = (uint16_t*)param;
     uint8_t *temp8 = (uint8_t*)param;
 
-    if (!param && event != kUSB_DeviceEventBusReset && event != kUSB_DeviceEventSetInterface) {
+    if (!param && event != kUSB_DeviceEventBusReset && event != kUSB_DeviceEventSetInterface && event != kUSB_DeviceEventSuspend && event != kUSB_DeviceEventResume) {
-        return error;
+        return status;
     }
 
+    if (computerSleeping)
+        WakeupComputer(false); // Wake up the keyboard if there is any activity on the bus
+
     switch (event) {
         case kUSB_DeviceEventBusReset:
             UsbCompositeDevice.attach = 0;
-            error = kStatus_USB_Success;
+            status = kStatus_USB_Success;
+            break;
+        case kUSB_DeviceEventSuspend:
+            if (UsbCompositeDevice.attach) {
+                ComputerIsSleeping(); // The computer sends this event when it goes to sleep, so turn off all the LEDs
+                status = kStatus_USB_Success;
+            }
+            break;
+        case kUSB_DeviceEventResume:
+            // We will just wake up the computer if there is any activity on the bus
+            // The problem is that the computer won't send a resume event when it boots, so the lights will never come back on
+            status = kStatus_USB_Success;
             break;
         case kUSB_DeviceEventSetConfiguration:
             UsbCompositeDevice.attach = 1;
@@ -45,11 +254,11 @@ static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event,
             UsbMediaKeyboardSetConfiguration(UsbCompositeDevice.mediaKeyboardHandle, *temp8);
             UsbSystemKeyboardSetConfiguration(UsbCompositeDevice.systemKeyboardHandle, *temp8);
             UsbMouseSetConfiguration(UsbCompositeDevice.mouseHandle, *temp8);
-            error = kStatus_USB_Success;
+            status = kStatus_USB_Success;
             break;
         case kUSB_DeviceEventGetConfiguration:
             *temp8 = UsbCompositeDevice.currentConfiguration;
-            error = kStatus_USB_Success;
+            status = kStatus_USB_Success;
             break;
         case kUSB_DeviceEventSetInterface:
             if (UsbCompositeDevice.attach) {
@@ -62,7 +271,7 @@ static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event,
                     UsbMediaKeyboardSetInterface(UsbCompositeDevice.mediaKeyboardHandle, interface, alternateSetting);
                     UsbSystemKeyboardSetInterface(UsbCompositeDevice.systemKeyboardHandle, interface, alternateSetting);
                     UsbMouseSetInterface(UsbCompositeDevice.mouseHandle, interface, alternateSetting);
-                    error = kStatus_USB_Success;
+                    status = kStatus_USB_Success;
                 }
             }
             break;
@@ -70,32 +279,32 @@ static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event,
             uint8_t interface = (uint8_t)((*temp16 & 0xFF00) >> 8);
             if (interface < USB_DEVICE_CONFIG_HID) {
                 *temp16 = (*temp16 & 0xFF00) | UsbCompositeDevice.currentInterfaceAlternateSetting[interface];
-                error = kStatus_USB_Success;
+                status = kStatus_USB_Success;
             } else {
-                error = kStatus_USB_InvalidRequest;
+                status = kStatus_USB_InvalidRequest;
             }
             break;
         case kUSB_DeviceEventGetDeviceDescriptor:
-            error = USB_DeviceGetDeviceDescriptor(handle, (usb_device_get_device_descriptor_struct_t *)param);
+            status = USB_DeviceGetDeviceDescriptor(handle, (usb_device_get_device_descriptor_struct_t *)param);
             break;
         case kUSB_DeviceEventGetConfigurationDescriptor:
-            error = USB_DeviceGetConfigurationDescriptor(handle, (usb_device_get_configuration_descriptor_struct_t *)param);
+            status = USB_DeviceGetConfigurationDescriptor(handle, (usb_device_get_configuration_descriptor_struct_t *)param);
             break;
         case kUSB_DeviceEventGetStringDescriptor:
-            error = USB_DeviceGetStringDescriptor(handle, (usb_device_get_string_descriptor_struct_t *)param);
+            status = USB_DeviceGetStringDescriptor(handle, (usb_device_get_string_descriptor_struct_t *)param);
             break;
         case kUSB_DeviceEventGetHidDescriptor:
-            error = USB_DeviceGetHidDescriptor(handle, (usb_device_get_hid_descriptor_struct_t *)param);
+            status = USB_DeviceGetHidDescriptor(handle, (usb_device_get_hid_descriptor_struct_t *)param);
             break;
         case kUSB_DeviceEventGetHidReportDescriptor:
-            error = USB_DeviceGetHidReportDescriptor(handle, (usb_device_get_hid_report_descriptor_struct_t *)param);
+            status = USB_DeviceGetHidReportDescriptor(handle, (usb_device_get_hid_report_descriptor_struct_t *)param);
             break;
         case kUSB_DeviceEventGetHidPhysicalDescriptor:
-            error = USB_DeviceGetHidPhysicalDescriptor(handle, (usb_device_get_hid_physical_descriptor_struct_t *)param);
+            status = USB_DeviceGetHidPhysicalDescriptor(handle, (usb_device_get_hid_physical_descriptor_struct_t *)param);
             break;
     }
 
-    return error;
+    return status;
 }
 
 void USB0_IRQHandler(void)
@@ -107,9 +316,6 @@ void USB0_IRQHandler(void)
 
 void InitUsb(void)
 {
-    uint8_t usbDeviceKhciIrq[] = USB_IRQS;
-    uint8_t irqNumber = usbDeviceKhciIrq[CONTROLLER_ID - kUSB_ControllerKhci0];
-
     SystemCoreClockUpdate();
     CLOCK_EnableUsbfs0Clock(kCLOCK_UsbSrcIrc48M, 48000000);
 
@@ -121,7 +327,8 @@ void InitUsb(void)
     UsbCompositeDevice.systemKeyboardHandle = UsbDeviceCompositeConfigList.config[USB_SYSTEM_KEYBOARD_INTERFACE_INDEX].classHandle;
     UsbCompositeDevice.mouseHandle = UsbDeviceCompositeConfigList.config[USB_MOUSE_INTERFACE_INDEX].classHandle;
 
-    NVIC_SetPriority((IRQn_Type)irqNumber, USB_DEVICE_INTERRUPT_PRIORITY);
+    uint8_t usbDeviceKhciIrq[] = USB_IRQS;
+    uint8_t irqNumber = usbDeviceKhciIrq[CONTROLLER_ID - kUSB_ControllerKhci0];
     NVIC_EnableIRQ((IRQn_Type)irqNumber);
 
     USB_DeviceRun(UsbCompositeDevice.deviceHandle);

right/src/usb_composite_device.h

@@ -33,5 +33,7 @@
 //Functions:
 
     void InitUsb(void);
+    bool IsComputerSleeping(void);
+    void WakeupComputer(bool sendResume);
 
 #endif

right/src/usb_descriptors/usb_descriptor_basic_keyboard_report.c

@@ -36,7 +36,7 @@ uint8_t UsbBasicKeyboardReportDescriptor[USB_BASIC_KEYBOARD_REPORT_DESCRIPTOR_LE
 
         // Scancodes
         HID_RI_LOGICAL_MINIMUM(8, 0x00),
-        HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
+        HID_RI_LOGICAL_MAXIMUM(16, 0xFF),
         HID_RI_USAGE_PAGE(8, HID_RI_USAGE_PAGE_KEY_CODES),
         HID_RI_USAGE_MINIMUM(8, 0x00),
         HID_RI_USAGE_MAXIMUM(8, 0xFF),

right/src/usb_descriptors/usb_descriptor_basic_keyboard_report.h

@@ -3,7 +3,7 @@
 
 // Macros:
 
-    #define USB_BASIC_KEYBOARD_REPORT_DESCRIPTOR_LENGTH 63
+    #define USB_BASIC_KEYBOARD_REPORT_DESCRIPTOR_LENGTH 64
     #define USB_BASIC_KEYBOARD_MAX_KEYS 6
 
 // Variables:

right/src/usb_descriptors/usb_descriptor_generic_hid_report.c

@@ -10,7 +10,7 @@ uint8_t UsbGenericHidReportDescriptor[USB_GENERIC_HID_REPORT_DESCRIPTOR_LENGTH]
         // Input flowing from device to host
         HID_RI_USAGE(8, USB_GENERIC_HID_REPORT_DESCRIPTOR_VENDOR_USAGE_DATA_IN),
         HID_RI_LOGICAL_MINIMUM(8, 0x00),
-        HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
+        HID_RI_LOGICAL_MAXIMUM(16, 0xFF),
         HID_RI_REPORT_SIZE(8, 0x08),
         HID_RI_REPORT_COUNT(8, USB_GENERIC_HID_INTERRUPT_IN_PACKET_SIZE),
         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
@@ -18,7 +18,7 @@ uint8_t UsbGenericHidReportDescriptor[USB_GENERIC_HID_REPORT_DESCRIPTOR_LENGTH]
         // Output flowing from host to device
         HID_RI_USAGE(8, USB_GENERIC_HID_REPORT_DESCRIPTOR_VENDOR_USAGE_DATA_OUT),
         HID_RI_LOGICAL_MINIMUM(8, 0x00),
-        HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
+        HID_RI_LOGICAL_MAXIMUM(16, 0xFF),
         HID_RI_REPORT_SIZE(8, 0x08),
         HID_RI_REPORT_COUNT(8, USB_GENERIC_HID_INTERRUPT_OUT_PACKET_SIZE),
         HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),

right/src/usb_descriptors/usb_descriptor_generic_hid_report.h

@@ -3,7 +3,7 @@
 
 // Macros:
 
-    #define USB_GENERIC_HID_REPORT_DESCRIPTOR_LENGTH 31
+    #define USB_GENERIC_HID_REPORT_DESCRIPTOR_LENGTH 33
 
     #define USB_GENERIC_HID_REPORT_DESCRIPTOR_VENDOR_USAGE_PAGE_INDEX 0x80
     #define USB_GENERIC_HID_REPORT_DESCRIPTOR_VENDOR_USAGE_COLLECTION 0x81

right/src/usb_descriptors/usb_descriptor_system_keyboard_report.c

@@ -5,14 +5,16 @@ uint8_t UsbSystemKeyboardReportDescriptor[USB_SYSTEM_KEYBOARD_REPORT_DESCRIPTOR_
     HID_RI_USAGE_PAGE(8, HID_RI_USAGE_PAGE_GENERIC_DESKTOP),
     HID_RI_USAGE(8, HID_RI_USAGE_GENERIC_DESKTOP_SYSTEM_CONTROL),
     HID_RI_COLLECTION(8, HID_RI_COLLECTION_APPLICATION),
-        // System key
+        // System keys
-        HID_RI_REPORT_SIZE(8, 2),
+        HID_RI_USAGE_MINIMUM(8, 0x81), // SYSTEM_POWER_DOWN, SYSTEM_SLEEP and SYSTEM_WAKE_UP
-        HID_RI_REPORT_COUNT(8, USB_SYSTEM_KEYBOARD_MAX_KEYS),
+        HID_RI_USAGE_MAXIMUM(8, 0x83),
-        HID_RI_LOGICAL_MINIMUM(8, 1),
+        HID_RI_REPORT_SIZE(8, 1),
-        HID_RI_LOGICAL_MAXIMUM(8, 3),
+        HID_RI_REPORT_COUNT(8, 3),
-        HID_RI_USAGE(8, 0x82),
+        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
-        HID_RI_USAGE(8, 0x81),
+
-        HID_RI_USAGE(8, 0x83),
+        // Padding
-        HID_RI_INPUT(8, HID_IOF_NO_PREFERRED_STATE | HID_IOF_NULLSTATE),
+        HID_RI_REPORT_SIZE(8, 1),
+        HID_RI_REPORT_COUNT(8, 5),
+        HID_RI_INPUT(8, HID_IOF_CONSTANT | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
     HID_RI_END_COLLECTION(0),
 };