Bump version to 8.0.1

changed I2C watchdog timer implementation, as LPTMR was already used by key scanner
fixed and enabled software watchdog timer
2017-12-25 23:16:27 +01:00 · 2017-12-25 17:15:41 +01:00 · 2017-12-24 12:06:46 +01:00 · 2017-12-23 16:11:47 +01:00 · 2017-12-23 16:08:45 +01:00 · 2017-12-23 16:06:24 +01:00
88 changed files with 1454 additions and 888 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,9 +5,62 @@ 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.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 +68,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`
- Set UsbResponse_InvalidCommand upon encountering with an invalid USB command. `USBPROTOCOL:MINOR`
- Remove UsbCommandId_ReadMergeSensor now that it can be queried via UsbCommandId_GetKeyboardState. `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. `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. `DEVICEPROTOCOL:MINOR`
+- 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. `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`
- Make the reenumerate USB command accept a timeout value. `USBPROTOCOL:MINOR`
- Make the config parser read the device name. `DATAMODEL:MAJOR`
+- Add UsbCommand_SendKbootCommand. `DEVICEPROTOCOL:MINOR`
+- Make the reenumerate USB command accept a timeout value. `DEVICEPROTOCOL:MINOR`
+- 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`
- Throw ParserError_InvalidKeymapCount if keymapCount == 0. `DATAMODEL:PATCH`
+- Add merge sensor state and attached module IDs to GetDebugInfo(). `DEVICEPROTOCOL: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
--- a/left/build/uhk60-left_debug_jlink.launch
+++ b/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>
--- a/left/build/uhk60-left_release_jlink.launch
+++ b/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>
--- a/left/src/i2c_watchdog.c
+++ b/left/src/i2c_watchdog.c
@@ -3,36 +3,42 @@
 #include "i2c_watchdog.h"
 #include "test_led.h"
 #include "init_peripherals.h"
+#include "main.h"

-//static uint32_t prevWatchdogCounter = 0;
-uint32_t I2cWatchdog_RecoveryCounter;
-volatile uint32_t I2cWatchdog_WatchCounter;
+/* NOTE: Because of a bug in the ROM bootloader of the KL03Z, the watchdog timer is disabled and cannot be re-enabled.
+ * See https://community.nxp.com/thread/457893
+ * Therefore the hardware watchdog timer cannot be used without an extra way to enter bootloader or application mode.
+ */
+#if KEY_USE_I2C_WATCHDOG_TIMER
+  static uint32_t prevWatchdogCounter = 0;
+  static uint32_t I2cWatchdog_RecoveryCounter; /* counter for how many times we had to recover and restart */
+#endif

 void InitI2cWatchdog(void)
 {
-    lptmr_config_t lptmrConfig;
-    LPTMR_GetDefaultConfig(&lptmrConfig);
-    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)
+
+#if KEY_USE_I2C_WATCHDOG_TIMER
+void RunWatchdog(void)
 {
-    TEST_LED_TOGGLE();
-    I2cWatchdog_WatchCounter++;
+	static volatile uint32_t I2cWatchdog_WatchCounter = 0; /* counter for timer */
+	static int cntr = 0;

-    if (I2C_Watchdog == prevWatchdogCounter) { // Restart I2C if there hasn't been any interrupt during 100 ms
-//        NVIC_SystemReset();
-        I2cWatchdog_RecoveryCounter++;
-        I2C_SlaveDeinit(I2C_BUS_BASEADDR);
-        InitI2c();
-    }
+	cntr++;
+	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 */
+		cntr=0;
+		TEST_LED_TOGGLE();
+		I2cWatchdog_WatchCounter++;

-    prevWatchdogCounter = I2C_Watchdog;
-
-    LPTMR_ClearStatusFlags(LPTMR0, kLPTMR_TimerCompareFlag);
+		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
+		//        NVIC_SystemReset();
+				I2cWatchdog_RecoveryCounter++;
+				I2C_SlaveDeinit(I2C_BUS_BASEADDR);
+				InitI2c();
+			}
+		}
+		prevWatchdogCounter = I2C_Watchdog; /* remember previous counter */
+	}
 }
-*/
+#endif
--- a/left/src/init_peripherals.c
+++ b/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;
@@ -85,7 +86,9 @@ void InitPeripherals(void)
    InitLedDriver();
    InitTestLed();
    LedPwm_Init();
-//    InitI2cWatchdog();
    DebugOverSpi_Init();
    InitI2c();
+#if KEY_USE_I2C_WATCHDOG_TIMER
+    InitI2cWatchdog();
+#endif
 }
--- a/left/src/key_scanner.c
+++ b/left/src/key_scanner.c
@@ -1,10 +1,16 @@
 #include "fsl_lptmr.h"
 #include "key_scanner.h"
 #include "main.h"
+#if KEY_USE_I2C_WATCHDOG_TIMER
+  #include "i2c_watchdog.h"
+#endif

 void KEY_SCANNER_HANDLER(void)
 {
    KeyMatrix_ScanRow(&keyMatrix);
+#if KEY_USE_I2C_WATCHDOG_TIMER
+    RunWatchdog();
+#endif
    LPTMR_ClearStatusFlags(KEY_SCANNER_LPTMR_BASEADDR, kLPTMR_TimerCompareFlag);
 }

--- a/left/src/main.h
+++ b/left/src/main.h
@@ -14,4 +14,6 @@

    extern key_matrix_t keyMatrix;

+   #define KEY_USE_I2C_WATCHDOG_TIMER   (1) /* if set to 1, every 100 ms the I2C communication is checked */
+
 #endif
--- a/left/src/module.h
+++ b/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
--- a/left/src/slave_protocol_handler.c
+++ b/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: {
-                    TxMessage.data[0] = MODULE_PROTOCOL_VERSION;
+                case SlaveProperty_KeyCount: {
+                    TxMessage.data[0] = MODULE_KEY_COUNT;
                    TxMessage.length = 1;
                    break;
                }
-                case SlaveProperty_Features: {
-                    uhk_module_features_t *moduleFeatures = (uhk_module_features_t*)&TxMessage.data;
-                    moduleFeatures->keyCount = MODULE_KEY_COUNT;
-                    moduleFeatures->hasPointer = MODULE_HAS_POINTER;
-                    TxMessage.length = sizeof(uhk_module_features_t);
+                case SlaveProperty_PointerCount: {
+                    TxMessage.data[0] = MODULE_POINTER_COUNT;
+                    TxMessage.length = 1;
                    break;
                }
            }
--- a/lib/agent
+++ b/lib/agent
--- a/right/build/uhk60-right_debug_standalone_jlink.launch
+++ b/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>
--- a/right/src/config_parser/basic_types.c
+++ b/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;
--- a/right/src/config_parser/config_globals.c
+++ b/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;
+    }
+}
--- a/right/src/config_parser/config_globals.h
+++ b/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
--- a/right/src/config_parser/parse_config.c
+++ b/right/src/config_parser/parse_config.c
@@ -4,35 +4,94 @@
 #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"

 static parser_error_t parseModuleConfiguration(config_buffer_t *buffer)
 {
    uint8_t id = ReadUInt8(buffer);
-    uint8_t initialPointerSpeed = ReadUInt8(buffer);
-    uint8_t pointerAcceleration = ReadUInt8(buffer);
-    uint8_t maxPointerSpeed = ReadUInt8(buffer);
+    uint8_t pointerMode = ReadUInt8(buffer);  // move vs scroll
+    uint8_t deceleratedPointerSpeedMultiplier = 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)pointerAcceleration;
-    (void)maxPointerSpeed;
+    (void)pointerMode;
+    (void)deceleratedPointerSpeedMultiplier;
+    (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;
-    ReadString(buffer, &len); // Ignore device name
-    uint16_t moduleConfigurationCount = ReadCompactLength(buffer);
+    const char *deviceName = ReadString(buffer, &len);
+    uint16_t doubleTapSwitchLayerTimeout = ReadUInt16(buffer);

-    (void)dataModelVersion;
+    (void)userConfigLength;
+    (void)dataModelMajorVersion;
+    (void)dataModelMinorVersion;
+    (void)dataModelPatchVersion;
+    (void)deviceName;
+
+    // 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 +104,8 @@ parser_error_t ParseConfig(config_buffer_t *buffer)
        }
    }

+    // Macros
+
    macroCount = ReadCompactLength(buffer);
    if (macroCount > MAX_MACRO_NUM) {
        return ParserError_InvalidMacroCount;
@@ -57,6 +118,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 +132,35 @@ 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;
+        Slaves[SlaveId_LeftLedDriver].isConnected = false;
+        Slaves[SlaveId_RightLedDriver].isConnected = false;
+
+        // 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;
    }
--- a/right/src/config_parser/parse_config.h
+++ b/right/src/config_parser/parse_config.h
@@ -8,20 +8,21 @@
 // Typedefs:

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

 // Functions:
--- a/right/src/config_parser/parse_keymap.c
+++ b/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) {
-        case SerializedMouseAction_LeftClick:
-            keyAction->mouse.buttonActions = MouseButton_Left;
-            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;
+
+    uint8_t mouseAction = ReadUInt8(buffer);
+    if (mouseAction > SerializedMouseAction_Last) {
+        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, pointerRole);
+    return parseKeyActions(layer, buffer, moduleId);
 }

 static parser_error_t parseLayer(config_buffer_t *buffer, uint8_t layer)
--- a/right/src/config_parser/parse_keymap.h
+++ b/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:
--- a/right/src/eeprom.c
+++ b/right/src/eeprom.c
@@ -10,7 +10,7 @@ bool IsEepromBusy;
 static eeprom_operation_t CurrentEepromOperation;
 static config_buffer_id_t CurrentConfigBufferId;
 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, targetEepromOffset);
+    SetBufferUint16Be(buffer, 0, eepromStartAddress + sourceOffset);
    writeLength = MIN(sourceLength - sourceOffset, EEPROM_PAGE_SIZE);
-    memcpy(buffer+EEPROM_ADDRESS_LENGTH, sourceBuffer+sourceOffset, writeLength);
-    status_t status = i2cAsyncWrite(buffer, writeLength+EEPROM_ADDRESS_LENGTH);
+    memcpy(buffer+EEPROM_ADDRESS_SIZE, sourceBuffer+sourceOffset, writeLength);
+    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;
+}
--- a/right/src/eeprom.h
+++ b/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:

@@ -31,5 +31,6 @@

    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
--- a/right/src/i2c.h
+++ b/right/src/i2c.h
@@ -11,8 +11,9 @@
    // Main bus

    #define I2C_MAIN_BUS_BASEADDR  I2C0
-    #define I2C_MASTER_BUS_CLK_SRC I2C0_CLK_SRC
-    #define I2C_MAIN_BUS_BAUD_RATE 100000 // 100 kHz works even with a 20 meter long bridge cable.
+    #define I2C_MAIN_BUS_IRQ_ID    I2C0_IRQn
+    #define I2C_MAIN_BUS_CLK_SRC   I2C0_CLK_SRC
+    #define I2C_MAIN_BUS_BAUD_RATE 100000  // 100 kHz works even with a 20 meter long bridge cable.
    #define I2C_MAIN_BUS_MUX       kPORT_MuxAlt7

    #define I2C_MAIN_BUS_SDA_GPIO  GPIOD
@@ -28,8 +29,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
--- a/right/src/init_peripherals.c
+++ b/right/src/init_peripherals.c
@@ -8,20 +8,22 @@
 #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"

 void InitInterruptPriorities(void)
 {
-    NVIC_SetPriority(I2C0_IRQn, 1);
-    NVIC_SetPriority(I2C1_IRQn, 1);
-    NVIC_SetPriority(USB0_IRQn, 1);
-    NVIC_SetPriority(PIT1_IRQn, 6);
+    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);
 }

 void delay(void)
@@ -77,7 +79,7 @@ void InitI2cMainBus(void)
    i2c_master_config_t masterConfig;
    I2C_MasterGetDefaultConfig(&masterConfig);
    masterConfig.baudRate_Bps = I2C_MAIN_BUS_BAUD_RATE;
-    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);
 }

@@ -125,5 +127,4 @@ void InitPeripherals(void)
 #endif
    InitKeyDebouncer();
    EEPROM_Init();
-    //microseconds_init();
 }
--- a/right/src/key_action.h
+++ b/right/src/key_action.h
@@ -1,5 +1,5 @@
-#ifndef __ACTION_H__
-#define __ACTION_H__
+#ifndef __KEY_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"
-
-// Macros:
-
-    #define MOUSE_WHEEL_SPEED   1
-    #define MOUSE_WHEEL_DIVISOR 4
-
-    #define MOUSE_MAX_SPEED           10
-    #define MOUSE_SPEED_ACCEL_DIVISOR 50
+    #include "config_parser/parse_keymap.h"

 // 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;
-                mouse_scroll_t scrollActions;
-                mouse_move_action_t moveActions;
-            } ATTR_PACKED mouse;
-            struct {
-                bool isToggle;
+                switch_layer_mode_t mode;
                uint8_t layer;
            } ATTR_PACKED switchLayer;
            struct {
--- a/right/src/key_scanner.c
+++ b/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);
 }

--- a/right/src/key_scanner.h
+++ b/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);
--- a/right/src/keymap.c
+++ b/right/src/keymap.c
@@ -332,23 +332,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, .mouse = { .moveActions = MouseMove_Up }},
-            { .type = KeyActionType_Mouse, .mouse = { .buttonActions = MouseButton_5 }},
-            { .type = KeyActionType_Mouse, .mouse = { .buttonActions = MouseButton_t }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_Button_4 },
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_MoveUp },
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_Button_5 },
+            { .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, .mouse = { .moveActions = MouseMove_Down }},
-            { .type = KeyActionType_Mouse, .mouse = { .moveActions = MouseMove_Right }},
+            { .type = KeyActionType_Mouse, .mouseAction= SerializedMouseAction_MoveLeft },
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_MoveDown },
+            { .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 +391,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, .mouse = { .buttonActions = MouseButton_Middle }},
-            { .type = KeyActionType_Mouse, .mouse = { .buttonActions = MouseButton_Left }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_RightClick },
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_MiddleClick },
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_LeftClick },
            { .type = KeyActionType_None },
            { .type = KeyActionType_None },

@@ -411,8 +411,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, .mouse = { .moveActions = MouseMove_Accelerate }},
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_Decelerate },
+            { .type = KeyActionType_Mouse, .mouseAction = SerializedMouseAction_Accelerate },
            { .type = KeyActionType_None },
        }
    },
--- a/right/src/layer.c
+++ b/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) {
-                toggledLayer = LayerId_Base;
+            if (ToggledLayer == layerId) {
+                ToggledLayer = LayerId_Base;
                break;
-            } else if (toggledLayer == LayerId_Base) {
-                toggledLayer = layerId;
+            } else if (ToggledLayer == LayerId_Base && pressedLayers[layerId] == SwitchLayerMode_Toggle) {
+                ToggledLayer = layerId;
                break;
            }
        }
    }

-    if (toggledLayer != LayerId_Base) {
-        return toggledLayer;
+    if (ToggledLayer != LayerId_Base) {
+        return ToggledLayer;
    }

    // Handle held layers
--- a/right/src/layer.h
+++ b/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
--- a/right/src/led_display.c
+++ b/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][12] = allSegmentSets & 0b00000010 ? LED_BRIGHTNESS_LEVEL : 0;
+    LedDriverValues[LedDriverId_Left][11] = allSegmentSets & 0b00000001 ? AlphanumericSegmentsBrightness : 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;
    }
@@ -94,11 +97,11 @@ void LedDisplay_SetLayer(uint8_t layerId)
    }

    if (layerId >= LayerId_Mod && layerId <= LayerId_Mouse) {
-        LedDriverValues[LedDriverId_Left][16 * layerId - 3] = LED_BRIGHTNESS_LEVEL;
+        LedDriverValues[LedDriverId_Left][16 * layerId - 3] = IconsAndLayerTextsBrightness;
    }
 }

 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;
 }
--- a/right/src/led_display.h
+++ b/right/src/led_display.h
@@ -14,6 +14,11 @@
        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);
--- a/right/src/main.c
+++ b/right/src/main.c
@@ -1,79 +1,16 @@
 #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"
-
-bool UsbBasicKeyboardReportEverSent = false;
-bool UsbMediaKeyboardReportEverSent = false;
-bool UsbSystemKeyboardReportEverSent = false;
-bool UsbMouseReportEverSentEverSent = false;
-
-void updateUsbReports(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;
-}
+#include "usb_report_updater.h"

 bool IsEepromInitialized = false;
 bool IsConfigInitialized = false;
@@ -105,7 +42,7 @@ void main(void)
        InitSlaveScheduler();
        KeyMatrix_Init(&RightKeyMatrix);
        InitKeyScanner();
-        updateUsbReports();
+        UpdateUsbReports();
        InitUsb();

        while (1) {
@@ -113,7 +50,7 @@ void main(void)
                UsbCommand_ApplyConfig();
                IsConfigInitialized = true;
            }
-            updateUsbReports();
+            UpdateUsbReports();
            __WFI();
        }
    }
--- a/right/src/main.h
+++ b/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
--- a/right/src/slave_drivers/is31fl3731_driver.c
+++ b/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);
-    LedDisplay_SetCurrentKeymapText();
+    memset(LedDriverValues[ledDriverId], KeyBacklightBrightness, LED_DRIVER_LED_COUNT);
+
+    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)
--- a/right/src/slave_drivers/is31fl3731_driver.h
+++ b/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:
--- a/right/src/slave_drivers/uhk_module_driver.c
+++ b/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;
@@ -87,30 +93,52 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
            bool isSyncValid = memcmp(rxMessage->data, SlaveSyncString, SLAVE_SYNC_STRING_LENGTH) == 0;
            status = kStatus_Uhk_NoTransfer;
            *uhkModulePhase = isSyncValid && isMessageValid
-                ? UhkModulePhase_RequestProtocolVersion
+                ? UhkModulePhase_RequestModuleProtocolVersion
                : UhkModulePhase_RequestSync;
            break;
        }

-        // Get protocol version
-        case UhkModulePhase_RequestProtocolVersion:
+        // Get module protocol version
+        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;
-            *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_NoTransfer;
+            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModuleId : UhkModulePhase_RequestFirmwareVersion;
            break;
        }

@@ -132,29 +160,51 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
                uhkModuleState->moduleId = rxMessage->data[0];
            }
            status = kStatus_Uhk_NoTransfer;
-            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModuleFeatures : UhkModulePhase_RequestModuleId;
+            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModuleKeyCount : UhkModulePhase_RequestModuleId;
            break;
        }

-        // Get module features
-        case UhkModulePhase_RequestModuleFeatures:
+        // Get module key count
+        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;
-            *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_NoTransfer;
+            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestKeyStates : UhkModulePhase_RequestModulePointerCount;
            break;
        }

@@ -172,25 +222,12 @@ 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);
-                for (uint8_t keyId=0; keyId<uhkModuleState->features.keyCount; keyId++) {
+                BoolBitsToBytes(rxMessage->data, keyStatesBuffer, uhkModuleState->keyCount);
+                for (uint8_t keyId=0; keyId<uhkModuleState->keyCount; keyId++) {
                    KeyStates[slotId][keyId].current = keyStatesBuffer[keyId];
                }
            }
            status = kStatus_Uhk_NoTransfer;
-            *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;

--- a/right/src/slave_drivers/uhk_module_driver.h
+++ b/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_ReceiveProtocolVersion,
-        UhkModulePhase_ProcessProtocolVersion,
+        UhkModulePhase_RequestModuleProtocolVersion,
+        UhkModulePhase_ReceiveModuleProtocolVersion,
+        UhkModulePhase_ProcessModuleProtocolVersion,
+
+        // Get firmware version
+        UhkModulePhase_RequestFirmwareVersion,
+        UhkModulePhase_ReceiveFirmwareVersion,
+        UhkModulePhase_ProcessFirmwareVersion,

        // Get module id
        UhkModulePhase_RequestModuleId,
        UhkModulePhase_ReceiveModuleId,
        UhkModulePhase_ProcessModuleId,

-        // Get module features
-        UhkModulePhase_RequestModuleFeatures,
-        UhkModulePhase_ReceiveModuleFeatures,
-        UhkModulePhase_ProcessModuleFeatures,
+        // Get module key count
+        UhkModulePhase_RequestModuleKeyCount,
+        UhkModulePhase_ReceiveModuleKeyCount,
+        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;
-        bool jumpToBootloader;
+        uint8_t keyCount;
+        uint8_t pointerCount;
    } uhk_module_state_t;

    typedef struct {
--- a/right/src/slave_scheduler.c
+++ b/right/src/slave_scheduler.c
@@ -1,7 +1,6 @@
 #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"
--- a/right/src/slot.h
+++ b/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:

--- a/right/src/timer.c
+++ b/right/src/timer.c
@@ -14,15 +14,30 @@ 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);
 }

+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;
 }
--- a/right/src/timer.h
+++ b/right/src/timer.h
@@ -16,6 +16,8 @@
 // Functions:

    void Timer_Init(void);
+    void Timer_SetCurrentTime(uint32_t *time);
    uint32_t Timer_GetElapsedTime(uint32_t *time);
+    uint32_t Timer_GetElapsedTimeAndSetCurrent(uint32_t *time);

 #endif
--- a/right/src/usb_api.h
+++ b/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
--- a/right/src/usb_commands/usb_command_get_debug_buffer.c
+++ b/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, CurrentTime);
+    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;
+}
--- a/right/src/usb_commands/usb_command_get_debug_buffer.h
+++ b/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
--- a/right/src/usb_commands/usb_command_get_device_property.c
+++ b/right/src/usb_commands/usb_command_get_device_property.c
@@ -0,0 +1,62 @@
+#include "fsl_common.h"
+#include "usb_commands/usb_command_get_device_property.h"
+#include "usb_protocol_handler.h"
+#include "eeprom.h"
+#include "versions.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;
+        default:
+            SetUsbTxBufferUint8(0, UsbStatusCode_GetDeviceProperty_InvalidProperty);
+            break;
+    }
+}
--- a/right/src/usb_commands/usb_command_get_device_property.h
+++ b/right/src/usb_commands/usb_command_get_device_property.h
@@ -0,0 +1,20 @@
+#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,
+    } system_property_t;
+
+    typedef enum {
+        UsbStatusCode_GetDeviceProperty_InvalidProperty = 2,
+    } usb_status_code_get_device_property_t;
+
+// Functions:
+
+    void UsbCommand_GetDeviceProperty(void);
+
+#endif
--- a/right/src/usb_commands/usb_command_get_keyboard_state.c
+++ b/right/src/usb_commands/usb_command_get_keyboard_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"
--- a/right/src/usb_commands/usb_command_get_keyboard_state.h
+++ b/right/src/usb_commands/usb_command_get_keyboard_state.h
--- a/right/src/usb_commands/usb_command_get_module_property.c
+++ b/right/src/usb_commands/usb_command_get_module_property.c
@@ -0,0 +1,21 @@
+#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);
+    }
+
+    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 + 2 + sizeof(version_t), &moduleState->firmwareVersion, sizeof(version_t));
+}
--- a/right/src/usb_commands/usb_command_get_module_property.h
+++ b/right/src/usb_commands/usb_command_get_module_property.h
@@ -0,0 +1,14 @@
+#ifndef __USB_COMMAND_GET_MODULE_PROPERTY_H__
+#define __USB_COMMAND_GET_MODULE_PROPERTY_H__
+
+// Functions:
+
+    void UsbCommand_GetModuleProperty();
+
+// Typedefs:
+
+    typedef enum {
+        UsbStatusCode_GetModuleProperty_InvalidModuleSlotId = 2,
+    } usb_status_code_get_module_property_t;
+
+#endif
--- a/right/src/usb_commands/usb_command_get_property.c
+++ b/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;
-    }
-}
--- a/right/src/usb_commands/usb_command_get_property.h
+++ b/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
--- a/right/src/usb_commands/usb_command_jump_to_module_bootloader.c
+++ b/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;
+}
--- a/right/src/usb_commands/usb_command_jump_to_module_bootloader.h
+++ b/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
--- a/right/src/usb_commands/usb_command_jump_to_slave_bootloader.c
+++ b/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;
-}
--- a/right/src/usb_commands/usb_command_jump_to_slave_bootloader.h
+++ b/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
--- a/right/src/usb_commands/usb_command_launch_eeprom_transfer.c
+++ b/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);
+    }
+}
--- a/right/src/usb_commands/usb_command_launch_eeprom_transfer.h
+++ b/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
--- a/right/src/usb_commands/usb_command_launch_eeprom_transfer_legacy.c
+++ b/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;
-    }
-}
--- a/right/src/usb_commands/usb_command_launch_eeprom_transfer_legacy.h
+++ b/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
--- a/right/src/usb_commands/usb_command_read_config.c
+++ b/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);
-    uint16_t offset = GetUsbRxBufferUint16(2);
+    config_buffer_id_t configBufferId = GetUsbRxBufferUint8(1);
+    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;
-    uint16_t bufferLength = isHardware ? HARDWARE_CONFIG_SIZE : USER_CONFIG_SIZE;
+    config_buffer_t *buffer = ConfigBufferIdToConfigBuffer(configBufferId);
+    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);
 }
--- a/right/src/usb_commands/usb_command_read_config.h
+++ b/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_BufferOutOfBounds = 3,
+        UsbStatusCode_ReadConfig_InvalidConfigBufferId = 2,
+        UsbStatusCode_ReadConfig_LengthTooLarge        = 3,
+        UsbStatusCode_ReadConfig_BufferOutOfBounds     = 4,
    } usb_status_code_read_config_t;

 #endif
--- a/right/src/usb_commands/usb_command_send_kboot_command.h
+++ b/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
--- a/right/src/usb_commands/usb_command_send_kboot_command_to_module.c
+++ b/right/src/usb_commands/usb_command_send_kboot_command_to_module.c
@@ -1,8 +1,8 @@
 #include "usb_protocol_handler.h"
-#include "usb_commands/usb_command_send_kboot_command.h"
+#include "usb_commands/usb_command_send_kboot_command_to_module.h"
 #include "slave_drivers/kboot_driver.h"

-void UsbCommand_SendKbootCommand(void)
+void UsbCommand_SendKbootCommandToModule(void)
 {
    KbootDriverState.phase = 0;
    KbootDriverState.i2cAddress  = GetUsbRxBufferUint8(2);
--- a/right/src/usb_commands/usb_command_send_kboot_command_to_module.h
+++ b/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
--- a/right/src/usb_commands/usb_command_write_config.c
+++ b/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;
-    uint16_t bufferLength = isHardware ? HARDWARE_CONFIG_SIZE : USER_CONFIG_SIZE;
+    uint8_t *buffer = ConfigBufferIdToConfigBuffer(configBufferId)->buffer;
+    uint16_t bufferLength = ConfigBufferIdToBufferSize(configBufferId);

    if (offset + length > bufferLength) {
        SetUsbTxBufferUint8(0, UsbStatusCode_WriteConfig_BufferOutOfBounds);
--- a/right/src/usb_commands/usb_command_write_config.h
+++ b/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
--- a/right/src/usb_composite_device.c
+++ b/right/src/usb_composite_device.c
@@ -5,37 +5,175 @@
 #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] = {
-    {UsbGenericHidCallback,     (class_handle_t)NULL, &UsbGenericHidClass},
-    {UsbBasicKeyboardCallback,  (class_handle_t)NULL, &UsbBasicKeyboardClass},
-    {UsbMediaKeyboardCallback,  (class_handle_t)NULL, &UsbMediaKeyboardClass},
-    {UsbSystemKeyboardCallback, (class_handle_t)NULL, &UsbSystemKeyboardClass},
-    {UsbMouseCallback,          (class_handle_t)NULL, &UsbMouseClass},
-};
+static usb_device_class_config_list_struct_t UsbDeviceCompositeConfigList = {
+    .deviceCallback = usbDeviceCallback,
+    .count = USB_DEVICE_CONFIG_HID,
+    .config = (usb_device_class_config_struct_t[USB_DEVICE_CONFIG_HID]) {{
+        .classCallback = UsbGenericHidCallback,
+        .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 = {
-    UsbDeviceCompositeClassConfig,
-    UsbDeviceCallback,
-    USB_DEVICE_CONFIG_HID
-};
-
-static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event, void *param)
+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) {
-        return error;
+        return status;
    }

    switch (event) {
        case kUSB_DeviceEventBusReset:
            UsbCompositeDevice.attach = 0;
-            error = kStatus_USB_Success;
+            status = kStatus_USB_Success;
            break;
        case kUSB_DeviceEventSetConfiguration:
            UsbCompositeDevice.attach = 1;
@@ -45,11 +183,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 +200,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 +208,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 +245,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 +256,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);
--- a/right/src/usb_interfaces/usb_interface_basic_keyboard.c
+++ b/right/src/usb_interfaces/usb_interface_basic_keyboard.c
@@ -1,46 +1,7 @@
-#include "main.h"
-#include "key_action.h"
-#include "fsl_port.h"
-#include "usb_api.h"
 #include "usb_composite_device.h"
-#include "peripherals/test_led.h"
-#include "fsl_i2c.h"
-#include "i2c.h"
-#include "i2c_addresses.h"
-
-static usb_device_endpoint_struct_t UsbBasicKeyboardEndpoints[USB_BASIC_KEYBOARD_ENDPOINT_COUNT] = {{
-    USB_BASIC_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-    USB_ENDPOINT_INTERRUPT,
-    USB_BASIC_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
-}};
-
-static usb_device_interface_struct_t UsbBasicKeyboardInterface[] = {{
-    USB_INTERFACE_ALTERNATE_SETTING_NONE,
-    {USB_BASIC_KEYBOARD_ENDPOINT_COUNT, UsbBasicKeyboardEndpoints},
-    NULL,
-}};
-
-static usb_device_interfaces_struct_t UsbBasicKeyboardInterfaces[USB_BASIC_KEYBOARD_INTERFACE_COUNT] = {{
-    USB_CLASS_HID,
-    USB_HID_SUBCLASS_BOOT,
-    USB_HID_PROTOCOL_KEYBOARD,
-    USB_BASIC_KEYBOARD_INTERFACE_INDEX,
-    UsbBasicKeyboardInterface,
-    sizeof(UsbBasicKeyboardInterface) / sizeof(usb_device_interfaces_struct_t),
-}};
-
-static usb_device_interface_list_t UsbBasicKeyboardInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
-    USB_BASIC_KEYBOARD_INTERFACE_COUNT,
-    UsbBasicKeyboardInterfaces,
-}};
-
-usb_device_class_struct_t UsbBasicKeyboardClass = {
-    UsbBasicKeyboardInterfaceList,
-    kUSB_DeviceClassTypeHid,
-    USB_DEVICE_CONFIGURATION_COUNT,
-};

 static usb_basic_keyboard_report_t usbBasicKeyboardReports[2];
+uint32_t UsbBasicKeyboardActionCounter;
 usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport = usbBasicKeyboardReports;
 bool IsUsbBasicKeyboardReportSent = false;

@@ -65,6 +26,7 @@ static usb_status_t UsbBasicKeyboardAction(void)
        UsbCompositeDevice.basicKeyboardHandle, USB_BASIC_KEYBOARD_ENDPOINT_INDEX,
        (uint8_t*)getInactiveUsbBasicKeyboardReport(), USB_BASIC_KEYBOARD_REPORT_LENGTH);
    IsUsbBasicKeyboardReportSent = true;
+    UsbBasicKeyboardActionCounter++;
    return status;
 }

--- a/right/src/usb_interfaces/usb_interface_basic_keyboard.h
+++ b/right/src/usb_interfaces/usb_interface_basic_keyboard.h
@@ -32,7 +32,7 @@
 // Variables:

    extern bool IsUsbBasicKeyboardReportSent;
-    extern usb_device_class_struct_t UsbBasicKeyboardClass;
+    extern uint32_t UsbBasicKeyboardActionCounter;
    extern usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport;

 // Functions:
--- a/right/src/usb_interfaces/usb_interface_generic_hid.c
+++ b/right/src/usb_interfaces/usb_interface_generic_hid.c
@@ -1,47 +1,7 @@
 #include "usb_composite_device.h"
-#include "usb_interface_generic_hid.h"
 #include "usb_protocol_handler.h"

-static usb_device_endpoint_struct_t UsbGenericHidEndpoints[USB_GENERIC_HID_ENDPOINT_COUNT] =
-{
-    {
-        USB_GENERIC_HID_ENDPOINT_IN_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-        USB_ENDPOINT_INTERRUPT,
-        USB_GENERIC_HID_INTERRUPT_IN_PACKET_SIZE,
-    },
-    {
-        USB_GENERIC_HID_ENDPOINT_OUT_INDEX | (USB_OUT << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-        USB_ENDPOINT_INTERRUPT,
-        USB_GENERIC_HID_INTERRUPT_OUT_PACKET_SIZE,
-    }
-};
-
-static usb_device_interface_struct_t UsbGenericHidInterface[] = {{
-    USB_INTERFACE_ALTERNATE_SETTING_NONE,
-    {USB_GENERIC_HID_ENDPOINT_COUNT, UsbGenericHidEndpoints},
-    NULL,
-}};
-
-static usb_device_interfaces_struct_t UsbGenericHidInterfaces[USB_GENERIC_HID_INTERFACE_COUNT] = {{
-    USB_CLASS_HID,
-    USB_HID_SUBCLASS_NONE,
-    USB_HID_PROTOCOL_NONE,
-    USB_GENERIC_HID_INTERFACE_INDEX,
-    UsbGenericHidInterface,
-    sizeof(UsbGenericHidInterface) / sizeof(usb_device_interfaces_struct_t),
-}};
-
-static usb_device_interface_list_t UsbGenericHidInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
-    USB_GENERIC_HID_INTERFACE_COUNT,
-    UsbGenericHidInterfaces,
-}};
-
-usb_device_class_struct_t UsbGenericHidClass = {
-    UsbGenericHidInterfaceList,
-    kUSB_DeviceClassTypeHid,
-    USB_DEVICE_CONFIGURATION_COUNT,
-};
-
+uint32_t UsbGenericHidActionCounter;
 uint8_t GenericHidInBuffer[USB_GENERIC_HID_IN_BUFFER_LENGTH];
 uint8_t GenericHidOutBuffer[USB_GENERIC_HID_OUT_BUFFER_LENGTH];

@@ -67,6 +27,7 @@ usb_status_t UsbGenericHidCallback(class_handle_t handle, uint32_t event, void *
                              USB_GENERIC_HID_ENDPOINT_IN_INDEX,
                              GenericHidOutBuffer,
                              USB_GENERIC_HID_OUT_BUFFER_LENGTH);
+            UsbGenericHidActionCounter++;
            return UsbReceiveData();
            break;
        case kUSB_DeviceHidEventGetReport:
--- a/right/src/usb_interfaces/usb_interface_generic_hid.h
+++ b/right/src/usb_interfaces/usb_interface_generic_hid.h
@@ -25,7 +25,7 @@

 // Variables:

-    extern usb_device_class_struct_t UsbGenericHidClass;
+    extern uint32_t UsbGenericHidActionCounter;
    extern uint8_t GenericHidInBuffer[USB_GENERIC_HID_IN_BUFFER_LENGTH];
    extern uint8_t GenericHidOutBuffer[USB_GENERIC_HID_OUT_BUFFER_LENGTH];

--- a/right/src/usb_interfaces/usb_interface_media_keyboard.c
+++ b/right/src/usb_interfaces/usb_interface_media_keyboard.c
@@ -1,45 +1,6 @@
-#include "main.h"
-#include "key_action.h"
-#include "fsl_port.h"
-#include "usb_api.h"
 #include "usb_composite_device.h"
-#include "peripherals/test_led.h"
-#include "fsl_i2c.h"
-#include "i2c.h"
-#include "i2c_addresses.h"
-
-static usb_device_endpoint_struct_t UsbMediaKeyboardEndpoints[USB_MEDIA_KEYBOARD_ENDPOINT_COUNT] = {{
-    USB_MEDIA_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-    USB_ENDPOINT_INTERRUPT,
-    USB_MEDIA_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
-}};
-
-static usb_device_interface_struct_t UsbMediaKeyboardInterface[] = {{
-    USB_INTERFACE_ALTERNATE_SETTING_NONE,
-    {USB_MEDIA_KEYBOARD_ENDPOINT_COUNT, UsbMediaKeyboardEndpoints},
-    NULL,
-}};
-
-static usb_device_interfaces_struct_t UsbMediaKeyboardInterfaces[USB_MEDIA_KEYBOARD_INTERFACE_COUNT] = {{
-    USB_CLASS_HID,
-    USB_HID_SUBCLASS_BOOT,
-    USB_HID_PROTOCOL_KEYBOARD,
-    USB_MEDIA_KEYBOARD_INTERFACE_INDEX,
-    UsbMediaKeyboardInterface,
-    sizeof(UsbMediaKeyboardInterface) / sizeof(usb_device_interfaces_struct_t),
-}};
-
-static usb_device_interface_list_t UsbMediaKeyboardInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
-    USB_MEDIA_KEYBOARD_INTERFACE_COUNT,
-    UsbMediaKeyboardInterfaces,
-}};
-
-usb_device_class_struct_t UsbMediaKeyboardClass = {
-    UsbMediaKeyboardInterfaceList,
-    kUSB_DeviceClassTypeHid,
-    USB_DEVICE_CONFIGURATION_COUNT,
-};

+uint32_t UsbMediaKeyboardActionCounter;
 static usb_media_keyboard_report_t usbMediaKeyboardReports[2];
 usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport = usbMediaKeyboardReports;
 bool IsUsbMediaKeyboardReportSent = false;
@@ -65,6 +26,7 @@ static usb_status_t UsbMediaKeyboardAction(void)
        UsbCompositeDevice.mediaKeyboardHandle, USB_MEDIA_KEYBOARD_ENDPOINT_INDEX,
        (uint8_t*)getInactiveUsbMediaKeyboardReport(), USB_MEDIA_KEYBOARD_REPORT_LENGTH);
    IsUsbMediaKeyboardReportSent = true;
+    UsbMediaKeyboardActionCounter++;
    return status;
 }

--- a/right/src/usb_interfaces/usb_interface_media_keyboard.h
+++ b/right/src/usb_interfaces/usb_interface_media_keyboard.h
@@ -29,7 +29,7 @@
 // Variables:

    extern bool IsUsbMediaKeyboardReportSent;
-    extern usb_device_class_struct_t UsbMediaKeyboardClass;
+    extern uint32_t UsbMediaKeyboardActionCounter;
    extern usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport;

 // Functions:
--- a/right/src/usb_interfaces/usb_interface_mouse.c
+++ b/right/src/usb_interfaces/usb_interface_mouse.c
@@ -1,45 +1,7 @@
 #include "usb_composite_device.h"
-#include "usb_interface_mouse.h"
-#include "fsl_i2c.h"
-#include "i2c.h"
-#include "peripherals/reset_button.h"
-#include "key_action.h"
-#include "buffer.h"
-#include "usb_commands/usb_command_get_debug_buffer.h"

-static usb_device_endpoint_struct_t UsbMouseEndpoints[USB_MOUSE_ENDPOINT_COUNT] = {{
-    USB_MOUSE_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-    USB_ENDPOINT_INTERRUPT,
-    USB_MOUSE_INTERRUPT_IN_PACKET_SIZE,
-}};
-
-static usb_device_interface_struct_t UsbMouseInterface[] = {{
-    USB_INTERFACE_ALTERNATE_SETTING_NONE,
-    {USB_MOUSE_ENDPOINT_COUNT, UsbMouseEndpoints},
-    NULL,
-}};
-
-static usb_device_interfaces_struct_t UsbMouseInterfaces[USB_MOUSE_INTERFACE_COUNT] = {{
-    USB_CLASS_HID,
-    USB_HID_SUBCLASS_BOOT,
-    USB_HID_PROTOCOL_MOUSE,
-    USB_MOUSE_INTERFACE_INDEX,
-    UsbMouseInterface,
-    sizeof(UsbMouseInterface) / sizeof(usb_device_interfaces_struct_t),
-}};
-
-static usb_device_interface_list_t UsbMouseInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
-    USB_MOUSE_INTERFACE_COUNT,
-    UsbMouseInterfaces,
-}};
-
-usb_device_class_struct_t UsbMouseClass = {
-    UsbMouseInterfaceList,
-    kUSB_DeviceClassTypeHid,
-    USB_DEVICE_CONFIGURATION_COUNT,
-};
-
-usb_mouse_report_t usbMouseReports[2];
+uint32_t UsbMouseActionCounter;
+static usb_mouse_report_t usbMouseReports[2];
 usb_mouse_report_t* ActiveUsbMouseReport = usbMouseReports;
 bool IsUsbMouseReportSent = false;

@@ -58,16 +20,9 @@ void ResetActiveUsbMouseReport(void)
    bzero(ActiveUsbMouseReport, USB_MOUSE_REPORT_LENGTH);
 }

-static uint32_t count1 = 0;
-static uint32_t count2 = 0;
-static uint32_t count3 = 0;
-
 static volatile usb_status_t usbMouseAction(void)
 {
-    count3++;
    usb_mouse_report_t *mouseReport = getInactiveUsbMouseReport();
-    SetDebugBufferUint16(29, mouseReport->x);
-    SetDebugBufferUint16(31, mouseReport->y);
    IsUsbMouseReportSent = true;
    return USB_DeviceHidSend(UsbCompositeDevice.mouseHandle, USB_MOUSE_ENDPOINT_INDEX,
               (uint8_t*)mouseReport, USB_MOUSE_REPORT_LENGTH);
@@ -75,17 +30,11 @@ static volatile usb_status_t usbMouseAction(void)

 usb_status_t UsbMouseCallback(class_handle_t handle, uint32_t event, void *param)
 {
-    SetDebugBufferUint32(17, count1);
-    SetDebugBufferUint32(21, count2);
-    SetDebugBufferUint32(25, count3);
-
-    count1++;
-
+    UsbMouseActionCounter++;
    usb_status_t error = kStatus_USB_Error;

    switch (event) {
        case kUSB_DeviceHidEventSendResponse:
-            count2++;
            if (UsbCompositeDevice.attach) {
                return usbMouseAction();
            }
--- a/right/src/usb_interfaces/usb_interface_mouse.h
+++ b/right/src/usb_interfaces/usb_interface_mouse.h
@@ -25,14 +25,14 @@
        uint8_t buttons;
        int16_t x;
        int16_t y;
-        int8_t wheelX;
        int8_t wheelY;
+        int8_t wheelX;
    } ATTR_PACKED usb_mouse_report_t;

 // Variables:

    extern bool IsUsbMouseReportSent;
-    extern usb_device_class_struct_t UsbMouseClass;
+    extern uint32_t UsbMouseActionCounter;
    extern usb_mouse_report_t* ActiveUsbMouseReport;

 // Functions:
--- a/right/src/usb_interfaces/usb_interface_system_keyboard.c
+++ b/right/src/usb_interfaces/usb_interface_system_keyboard.c
@@ -1,45 +1,6 @@
-#include "main.h"
-#include "key_action.h"
-#include "fsl_port.h"
-#include "usb_api.h"
 #include "usb_composite_device.h"
-#include "peripherals/test_led.h"
-#include "fsl_i2c.h"
-#include "i2c.h"
-#include "i2c_addresses.h"
-
-static usb_device_endpoint_struct_t UsbSystemKeyboardEndpoints[USB_SYSTEM_KEYBOARD_ENDPOINT_COUNT] = {{
-    USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-    USB_ENDPOINT_INTERRUPT,
-    USB_SYSTEM_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
-}};
-
-static usb_device_interface_struct_t UsbSystemKeyboardInterface[] = {{
-    USB_INTERFACE_ALTERNATE_SETTING_NONE,
-    {USB_SYSTEM_KEYBOARD_ENDPOINT_COUNT, UsbSystemKeyboardEndpoints},
-    NULL,
-}};
-
-static usb_device_interfaces_struct_t UsbSystemKeyboardInterfaces[USB_SYSTEM_KEYBOARD_INTERFACE_COUNT] = {{
-    USB_CLASS_HID,
-    USB_HID_SUBCLASS_BOOT,
-    USB_HID_PROTOCOL_KEYBOARD,
-    USB_SYSTEM_KEYBOARD_INTERFACE_INDEX,
-    UsbSystemKeyboardInterface,
-    sizeof(UsbSystemKeyboardInterface) / sizeof(usb_device_interfaces_struct_t),
-}};
-
-static usb_device_interface_list_t UsbSystemKeyboardInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
-    USB_SYSTEM_KEYBOARD_INTERFACE_COUNT,
-    UsbSystemKeyboardInterfaces,
-}};
-
-usb_device_class_struct_t UsbSystemKeyboardClass = {
-    UsbSystemKeyboardInterfaceList,
-    kUSB_DeviceClassTypeHid,
-    USB_DEVICE_CONFIGURATION_COUNT,
-};

+uint32_t UsbSystemKeyboardActionCounter;
 static usb_system_keyboard_report_t usbSystemKeyboardReports[2];
 usb_system_keyboard_report_t* ActiveUsbSystemKeyboardReport = usbSystemKeyboardReports;
 bool IsUsbSystemKeyboardReportSent = false;
@@ -65,6 +26,7 @@ static usb_status_t UsbSystemKeyboardAction(void)
        UsbCompositeDevice.systemKeyboardHandle, USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX,
        (uint8_t*)getInactiveUsbSystemKeyboardReport(), USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
    IsUsbSystemKeyboardReportSent = true;
+    UsbSystemKeyboardActionCounter++;
    return status;
 }

--- a/right/src/usb_interfaces/usb_interface_system_keyboard.h
+++ b/right/src/usb_interfaces/usb_interface_system_keyboard.h
@@ -30,7 +30,7 @@
 // Variables:

    extern bool IsUsbSystemKeyboardReportSent;
-    extern usb_device_class_struct_t UsbSystemKeyboardClass;
+    extern uint32_t UsbSystemKeyboardActionCounter;
    extern usb_system_keyboard_report_t* ActiveUsbSystemKeyboardReport;

 // Functions:
--- a/right/src/usb_protocol_handler.c
+++ b/right/src/usb_protocol_handler.c
@@ -1,68 +1,69 @@
 #include "usb_protocol_handler.h"
 #include "buffer.h"
-#include "usb_commands/usb_command_get_property.h"
+#include "usb_commands/usb_command_get_device_property.h"
+#include "usb_commands/usb_command_get_module_property.h"
 #include "usb_commands/usb_command_reenumerate.h"
 #include "usb_commands/usb_command_set_test_led.h"
 #include "usb_commands/usb_command_write_config.h"
 #include "usb_commands/usb_command_apply_config.h"
 #include "usb_commands/usb_command_set_led_pwm_brightness.h"
 #include "usb_commands/usb_command_get_adc_value.h"
-#include "usb_commands/usb_command_launch_eeprom_transfer_legacy.h"
+#include "usb_commands/usb_command_launch_eeprom_transfer.h"
 #include "usb_commands/usb_command_read_config.h"
-#include "usb_commands/usb_command_get_keyboard_state.h"
+#include "usb_commands/usb_command_get_device_state.h"
 #include "usb_commands/usb_command_get_debug_buffer.h"
-#include "usb_commands/usb_command_jump_to_slave_bootloader.h"
-#include "usb_commands/usb_command_send_kboot_command.h"
+#include "usb_commands/usb_command_jump_to_module_bootloader.h"
+#include "usb_commands/usb_command_send_kboot_command_to_module.h"

 void UsbProtocolHandler(void)
 {
    bzero(GenericHidOutBuffer, USB_GENERIC_HID_OUT_BUFFER_LENGTH);
    uint8_t command = GetUsbRxBufferUint8(0);
    switch (command) {
-        case UsbCommandId_GetProperty:
-            UsbCommand_GetProperty();
+        case UsbCommandId_GetDeviceProperty:
+            UsbCommand_GetDeviceProperty();
            break;
        case UsbCommandId_Reenumerate:
            UsbCommand_Reenumerate();
            break;
-        case UsbCommandId_SetTestLed:
-            UsbCommand_SetTestLed();
+        case UsbCommandId_JumpToModuleBootloader:
+            UsbCommand_JumpToModuleBootloader();
            break;
-        case UsbCommandId_WriteUserConfig:
-            UsbCommand_WriteConfig(false);
+        case UsbCommandId_SendKbootCommandToModule:
+            UsbCommand_SendKbootCommandToModule();
+            break;
+        case UsbCommandId_ReadConfig:
+            UsbCommand_ReadConfig();
+            break;
+        case UsbCommandId_WriteHardwareConfig:
+            UsbCommand_WriteConfig(ConfigBufferId_HardwareConfig);
+            break;
+        case UsbCommandId_WriteStagingUserConfig:
+            UsbCommand_WriteConfig(ConfigBufferId_StagingUserConfig);
            break;
        case UsbCommandId_ApplyConfig:
            UsbCommand_ApplyConfig();
            break;
-        case UsbCommandId_SetLedPwmBrightness:
-            UsbCommand_SetLedPwmBrightness();
+        case UsbCommandId_LaunchEepromTransfer:
+            UsbCommand_LaunchEepromTransfer();
+            break;
+        case UsbCommandId_GetDeviceState:
+            UsbCommand_GetKeyboardState();
+            break;
+        case UsbCommandId_SetTestLed:
+            UsbCommand_SetTestLed();
+            break;
+        case UsbCommandId_GetDebugBuffer:
+            UsbCommand_GetDebugBuffer();
            break;
        case UsbCommandId_GetAdcValue:
            UsbCommand_GetAdcValue();
            break;
-        case UsbCommandId_LaunchEepromTransferLegacy:
-            UsbCommand_LaunchEepromTransferLegacy();
+        case UsbCommandId_SetLedPwmBrightness:
+            UsbCommand_SetLedPwmBrightness();
            break;
-        case UsbCommandId_ReadHardwareConfig:
-            UsbCommand_ReadConfig(true);
-            break;
-        case UsbCommandId_WriteHardwareConfig:
-            UsbCommand_WriteConfig(true);
-            break;
-        case UsbCommandId_ReadUserConfig:
-            UsbCommand_ReadConfig(false);
-            break;
-        case UsbCommandId_GetKeyboardState:
-            UsbCommand_GetKeyboardState();
-            break;
-        case UsbCommandId_GetDebugInfo:
-            UsbCommand_GetDebugBuffer();
-            break;
-        case UsbCommandId_JumpToModuleBootloader:
-            UsbCommand_JumpToSlaveBootloader();
-            break;
-        case UsbCommandId_SendKbootCommandToModule:
-            UsbCommand_SendKbootCommand();
+        case UsbCommandId_GetModuleProperty:
+            UsbCommand_GetModuleProperty();
            break;
        default:
            SetUsbTxBufferUint8(0, UsbStatusCode_InvalidCommand);
--- a/right/src/usb_protocol_handler.h
+++ b/right/src/usb_protocol_handler.h
@@ -13,21 +13,24 @@
 // Typedefs:

    typedef enum {
-        UsbCommandId_GetProperty                =  0,
-        UsbCommandId_Reenumerate                =  1,
-        UsbCommandId_SetTestLed                 =  2,
-        UsbCommandId_WriteUserConfig            =  8,
-        UsbCommandId_ApplyConfig                =  9,
-        UsbCommandId_SetLedPwmBrightness        = 10,
-        UsbCommandId_GetAdcValue                = 11,
-        UsbCommandId_LaunchEepromTransferLegacy = 12,
-        UsbCommandId_ReadHardwareConfig         = 13,
-        UsbCommandId_WriteHardwareConfig        = 14,
-        UsbCommandId_ReadUserConfig             = 15,
-        UsbCommandId_GetKeyboardState           = 16,
-        UsbCommandId_GetDebugInfo               = 17,
-        UsbCommandId_JumpToModuleBootloader     = 18,
-        UsbCommandId_SendKbootCommandToModule   = 19,
+        UsbCommandId_GetDeviceProperty        = 0x00,
+
+        UsbCommandId_Reenumerate              = 0x01,
+        UsbCommandId_JumpToModuleBootloader   = 0x02,
+        UsbCommandId_SendKbootCommandToModule = 0x03,
+
+        UsbCommandId_ReadConfig               = 0x04,
+        UsbCommandId_WriteHardwareConfig      = 0x05,
+        UsbCommandId_WriteStagingUserConfig   = 0x06,
+        UsbCommandId_ApplyConfig              = 0x07,
+        UsbCommandId_LaunchEepromTransfer     = 0x08,
+
+        UsbCommandId_GetDeviceState           = 0x09,
+        UsbCommandId_SetTestLed               = 0x0a,
+        UsbCommandId_GetDebugBuffer           = 0x0b,
+        UsbCommandId_GetAdcValue              = 0x0c,
+        UsbCommandId_SetLedPwmBrightness      = 0x0d,
+        UsbCommandId_GetModuleProperty        = 0x0e,
    } usb_command_id_t;

    typedef enum {
--- a/right/src/usb_report_updater.c
+++ b/right/src/usb_report_updater.c
@@ -1,3 +1,4 @@
+#include <math.h>
 #include "key_action.h"
 #include "led_display.h"
 #include "layer.h"
@@ -13,76 +14,185 @@
 #include "usb_report_updater.h"
 #include "timer.h"
 #include "key_debouncer.h"
+#include "config_parser/parse_keymap.h"
+#include "usb_commands/usb_command_get_debug_buffer.h"

 uint32_t UsbReportUpdateTime = 0;
-
-static uint8_t mouseWheelDivisorCounter = 0;
-static uint8_t mouseSpeedAccelDivisorCounter = 0;
-static uint8_t mouseSpeed = 10;
-static bool wasPreviousMouseActionWheelAction = false;
 static uint32_t elapsedTime;

-void processMouseAction(key_action_t *action)
+uint16_t DoubleTapSwitchLayerTimeout = 250;
+
+static bool activeMouseStates[ACTIVE_MOUSE_STATES_COUNT];
+
+mouse_kinetic_state_t MouseMoveState = {
+    .isScroll = false,
+    .upState = SerializedMouseAction_MoveUp,
+    .downState = SerializedMouseAction_MoveDown,
+    .leftState = SerializedMouseAction_MoveLeft,
+    .rightState = SerializedMouseAction_MoveRight,
+    .intMultiplier = 25,
+    .initialSpeed = 5,
+    .acceleration = 35,
+    .deceleratedSpeed = 10,
+    .baseSpeed = 40,
+    .acceleratedSpeed = 80,
+};
+
+mouse_kinetic_state_t MouseScrollState = {
+    .isScroll = true,
+    .upState = SerializedMouseAction_ScrollDown,
+    .downState = SerializedMouseAction_ScrollUp,
+    .leftState = SerializedMouseAction_ScrollLeft,
+    .rightState = SerializedMouseAction_ScrollRight,
+    .intMultiplier = 1,
+    .initialSpeed = 20,
+    .acceleration = 20,
+    .deceleratedSpeed = 10,
+    .baseSpeed = 20,
+    .acceleratedSpeed = 50,
+};
+
+void processMouseKineticState(mouse_kinetic_state_t *kineticState)
 {
-    bool isWheelAction = action->mouse.scrollActions && !action->mouse.moveActions && !action->mouse.buttonActions;
-    uint16_t distance = mouseSpeed * elapsedTime / 25;
+    float initialSpeed = kineticState->intMultiplier * kineticState->initialSpeed;
+    float acceleration = kineticState->intMultiplier * kineticState->acceleration;
+    float deceleratedSpeed = kineticState->intMultiplier * kineticState->deceleratedSpeed;
+    float baseSpeed = kineticState->intMultiplier * kineticState->baseSpeed;
+    float acceleratedSpeed = kineticState->intMultiplier * kineticState->acceleratedSpeed;

-    if (isWheelAction && wasPreviousMouseActionWheelAction) {
-        mouseWheelDivisorCounter++;
+    if (!kineticState->wasMoveAction && !activeMouseStates[SerializedMouseAction_Decelerate]) {
+        kineticState->currentSpeed = initialSpeed;
    }

-    if (action->mouse.scrollActions) {
-        if (mouseWheelDivisorCounter == MOUSE_WHEEL_DIVISOR) {
-            mouseWheelDivisorCounter = 0;
-            if (action->mouse.scrollActions & MouseScroll_Up) {
-                ActiveUsbMouseReport->wheelX = 1;
-            }
-            if (action->mouse.scrollActions & MouseScroll_Down) {
-                ActiveUsbMouseReport->wheelX = -1;
-            }
-        }
+    bool isMoveAction = activeMouseStates[kineticState->upState] ||
+                        activeMouseStates[kineticState->downState] ||
+                        activeMouseStates[kineticState->leftState] ||
+                        activeMouseStates[kineticState->rightState];
+
+    mouse_speed_t mouseSpeed = MouseSpeed_Normal;
+    if (activeMouseStates[SerializedMouseAction_Accelerate]) {
+        kineticState->targetSpeed = acceleratedSpeed;
+        mouseSpeed = MouseSpeed_Accelerated;
+    } else if (activeMouseStates[SerializedMouseAction_Decelerate]) {
+        kineticState->targetSpeed = deceleratedSpeed;
+        mouseSpeed = MouseSpeed_Decelerated;
+    } else if (isMoveAction) {
+        kineticState->targetSpeed = baseSpeed;
    }

-    if (action->mouse.moveActions & MouseMove_Accelerate || action->mouse.moveActions & MouseMove_Decelerate) {
-        mouseSpeedAccelDivisorCounter++;
-
-        if (mouseSpeedAccelDivisorCounter == MOUSE_SPEED_ACCEL_DIVISOR) {
-            mouseSpeedAccelDivisorCounter = 0;
-
-            if (action->mouse.moveActions & MouseMove_Accelerate) {
-                if (mouseSpeed < MOUSE_MAX_SPEED) {
-                    mouseSpeed++;
-                }
-            }
-            if (action->mouse.moveActions & MouseMove_Decelerate) {
-                if (mouseSpeed > 1) {
-                    mouseSpeed--;
-                }
-            }
-        }
-    } else if (action->mouse.moveActions) {
-        if (action->mouse.moveActions & MouseMove_Left) {
-            ActiveUsbMouseReport->x = -distance;
-        }
-        if (action->mouse.moveActions & MouseMove_Right) {
-            ActiveUsbMouseReport->x = distance;
-        }
-        if (action->mouse.moveActions & MouseMove_Up) {
-            ActiveUsbMouseReport->y = -distance;
-        }
-        if (action->mouse.moveActions & MouseMove_Down) {
-            ActiveUsbMouseReport->y = distance;
-        }
+    if (mouseSpeed == MouseSpeed_Accelerated || (kineticState->wasMoveAction && isMoveAction && (kineticState->prevMouseSpeed != mouseSpeed))) {
+        kineticState->currentSpeed = kineticState->targetSpeed;
    }

-    ActiveUsbMouseReport->buttons |= action->mouse.buttonActions;
+    if (isMoveAction) {
+        if (kineticState->currentSpeed < kineticState->targetSpeed) {
+            kineticState->currentSpeed += acceleration * elapsedTime / 1000;
+            if (kineticState->currentSpeed > kineticState->targetSpeed) {
+                kineticState->currentSpeed = kineticState->targetSpeed;
+            }
+        } else {
+            kineticState->currentSpeed -= acceleration * elapsedTime / 1000;
+            if (kineticState->currentSpeed < kineticState->targetSpeed) {
+                kineticState->currentSpeed = kineticState->targetSpeed;
+            }
+        }

-    wasPreviousMouseActionWheelAction = isWheelAction;
+        float distance = kineticState->currentSpeed * elapsedTime / 1000;
+
+
+        if (kineticState->isScroll && !kineticState->wasMoveAction) {
+            kineticState->xSum = 0;
+            kineticState->ySum = 0;
+        }
+
+        // Update horizontal state
+
+        bool horizontalMovement = true;
+        if (activeMouseStates[kineticState->leftState]) {
+            kineticState->xSum -= distance;
+        } else if (activeMouseStates[kineticState->rightState]) {
+            kineticState->xSum += distance;
+        } else {
+            horizontalMovement = false;
+        }
+
+        float xSumInt;
+        float xSumFrac = modff(kineticState->xSum, &xSumInt);
+        kineticState->xSum = xSumFrac;
+        kineticState->xOut = xSumInt;
+
+        if (kineticState->isScroll && !kineticState->wasMoveAction && kineticState->xOut == 0 && horizontalMovement) {
+            kineticState->xOut = kineticState->xSum > 0 ? 1 : -1;
+            kineticState->xSum = 0;
+        }
+
+        // Update vertical state
+
+        bool verticalMovement = true;
+        if (activeMouseStates[kineticState->upState]) {
+            kineticState->ySum -= distance;
+        } else if (activeMouseStates[kineticState->downState]) {
+            kineticState->ySum += distance;
+        } else {
+            verticalMovement = false;
+        }
+
+        float ySumInt;
+        float ySumFrac = modff(kineticState->ySum, &ySumInt);
+        kineticState->ySum = ySumFrac;
+        kineticState->yOut = ySumInt;
+
+        if (kineticState->isScroll && !kineticState->wasMoveAction && kineticState->yOut == 0 && verticalMovement) {
+            kineticState->yOut = kineticState->ySum > 0 ? 1 : -1;
+            kineticState->ySum = 0;
+        }
+    } else {
+        kineticState->currentSpeed = 0;
+    }
+
+    kineticState->prevMouseSpeed = mouseSpeed;
+    kineticState->wasMoveAction = isMoveAction;
 }

+void processMouseActions()
+{
+    processMouseKineticState(&MouseMoveState);
+    ActiveUsbMouseReport->x = MouseMoveState.xOut;
+    ActiveUsbMouseReport->y = MouseMoveState.yOut;
+    MouseMoveState.xOut = 0;
+    MouseMoveState.yOut = 0;
+
+    processMouseKineticState(&MouseScrollState);
+    ActiveUsbMouseReport->wheelX = MouseScrollState.xOut;
+    ActiveUsbMouseReport->wheelY = MouseScrollState.yOut;
+    MouseScrollState.xOut = 0;
+    MouseScrollState.yOut = 0;
+
+//  The following line makes the firmware crash for some reason:
+//  SetDebugBufferFloat(60, mouseScrollState.currentSpeed);
+//  TODO: Figure out why.
+//  Oddly, the following line (which is the inlined version of the above) works:
+//  *(float*)(DebugBuffer + 60) = mouseScrollState.currentSpeed;
+//  The value parameter of SetDebugBufferFloat() seems to be the culprit because
+//  if it's not used within the function it doesn't crash anymore.
+
+    if (activeMouseStates[SerializedMouseAction_LeftClick]) {
+        ActiveUsbMouseReport->buttons |= MouseButton_Left;
+    }
+    if (activeMouseStates[SerializedMouseAction_MiddleClick]) {
+        ActiveUsbMouseReport->buttons |= MouseButton_Middle;
+    }
+    if (activeMouseStates[SerializedMouseAction_RightClick]) {
+        ActiveUsbMouseReport->buttons |= MouseButton_Right;
+    }
+}
+
+static layer_id_t previousLayer = LayerId_Base;
 static uint8_t basicScancodeIndex = 0;
 static uint8_t mediaScancodeIndex = 0;
 static uint8_t systemScancodeIndex = 0;
+key_state_t *doubleTapSwitchLayerKey;
+uint32_t doubleTapSwitchLayerStartTime;

 void applyKeyAction(key_state_t *keyState, key_action_t *action)
 {
@@ -90,6 +200,10 @@ void applyKeyAction(key_state_t *keyState, key_action_t *action)
        return;
    }

+    if (doubleTapSwitchLayerKey && doubleTapSwitchLayerKey != keyState && !keyState->previous) {
+        doubleTapSwitchLayerKey = NULL;
+    }
+
    switch (action->type) {
        case KeyActionType_Keystroke:
            ActiveUsbBasicKeyboardReport->modifiers |= action->keystroke.modifiers;
@@ -116,26 +230,42 @@ void applyKeyAction(key_state_t *keyState, key_action_t *action)
            }
            break;
        case KeyActionType_Mouse:
-            processMouseAction(action);
+            activeMouseStates[action->mouseAction] = true;
+            break;
+        case KeyActionType_SwitchLayer:
+            if (!keyState->previous && previousLayer == LayerId_Base && action->switchLayer.mode == SwitchLayerMode_HoldAndDoubleTapToggle) {
+                if (doubleTapSwitchLayerKey) {
+                    if (Timer_GetElapsedTimeAndSetCurrent(&doubleTapSwitchLayerStartTime) < DoubleTapSwitchLayerTimeout) {
+                        ToggledLayer = action->switchLayer.layer;
+                    }
+                    doubleTapSwitchLayerKey = NULL;
+                } else {
+                    doubleTapSwitchLayerKey = keyState;
+                    doubleTapSwitchLayerStartTime = CurrentTime;
+                }
+            }
            break;
        case KeyActionType_SwitchKeymap:
-            if (!keyState->previous && keyState->current) {
+            if (!keyState->previous) {
                SwitchKeymap(action->switchKeymap.keymapId);
            }
            break;
    }
 }

-static layer_id_t previousLayer = LayerId_Base;
 static uint8_t secondaryRoleState = SecondaryRoleState_Released;
 static uint8_t secondaryRoleSlotId;
 static uint8_t secondaryRoleKeyId;
 static secondary_role_t secondaryRole;

-void UpdateActiveUsbReports(void)
+#define pos 35
+void updateActiveUsbReports(void)
 {
+    SetDebugBufferUint32(pos, 1);
+    memset(activeMouseStates, 0, ACTIVE_MOUSE_STATES_COUNT);
+
    static uint8_t previousModifiers = 0;
-    elapsedTime = Timer_GetElapsedTime(&UsbReportUpdateTime);
+    elapsedTime = Timer_GetElapsedTimeAndSetCurrent(&UsbReportUpdateTime);

    basicScancodeIndex = 0;
    mediaScancodeIndex = 0;
@@ -163,6 +293,7 @@ void UpdateActiveUsbReports(void)
        memcpy(&ActiveUsbSystemKeyboardReport, &MacroSystemKeyboardReport, sizeof MacroSystemKeyboardReport);
        return;
    }
+    SetDebugBufferUint32(pos, 2);

    for (uint8_t slotId=0; slotId<SLOT_COUNT; slotId++) {
        for (uint8_t keyId=0; keyId<MAX_KEY_COUNT_PER_MODULE; keyId++) {
@@ -216,6 +347,10 @@ void UpdateActiveUsbReports(void)
            keyState->previous = keyState->current;
        }
    }
+    SetDebugBufferUint32(pos, 4);
+
+    processMouseActions();
+    SetDebugBufferUint32(pos, 5);

    // When a layer switcher key gets pressed along with another key that produces some modifiers
    // and the accomanying key gets released then keep the related modifiers active a long as the
@@ -230,4 +365,74 @@ void UpdateActiveUsbReports(void)

    previousModifiers = ActiveUsbBasicKeyboardReport->modifiers;
    previousLayer = activeLayer;
+    SetDebugBufferUint32(pos, 7);
+}
+
+bool UsbBasicKeyboardReportEverSent = false;
+bool UsbMediaKeyboardReportEverSent = false;
+bool UsbSystemKeyboardReportEverSent = false;
+bool UsbMouseReportEverSentEverSent = false;
+
+uint32_t UsbReportUpdateCounter;
+static uint32_t lastUsbUpdateTime;
+
+void UpdateUsbReports(void)
+{
+    UsbReportUpdateCounter++;
+
+    if (Timer_GetElapsedTime(&lastUsbUpdateTime) > 100) {
+        UsbBasicKeyboardReportEverSent = false;
+        UsbMediaKeyboardReportEverSent = false;
+        UsbSystemKeyboardReportEverSent = false;
+        UsbMouseReportEverSentEverSent = false;
+    }
+
+    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;
+
+    Timer_SetCurrentTime(&lastUsbUpdateTime);
 }
--- a/right/src/usb_report_updater.h
+++ b/right/src/usb_report_updater.h
@@ -1,8 +1,14 @@
 #ifndef __USB_REPORT_UPDATER_H__
 #define __USB_REPORT_UPDATER_H__

+// Includes:
+
+    #include "config_parser/parse_keymap.h"
+
 // Macros:

+    #define ACTIVE_MOUSE_STATES_COUNT (SerializedMouseAction_Last + 1)
+
    #define IS_SECONDARY_ROLE_MODIFIER(secondaryRole) (SecondaryRole_LeftCtrl <= (secondaryRole) && (secondaryRole) <= SecondaryRole_RightSuper)
    #define IS_SECONDARY_ROLE_LAYER_SWITCHER(secondaryRole) (SecondaryRole_Mod <= (secondaryRole) && (secondaryRole) <= SecondaryRole_Mouse)
    #define SECONDARY_ROLE_MODIFIER_TO_HID_MODIFIER(secondaryRoleModifier) (1 << ((secondaryRoleModifier) - 1))
@@ -30,4 +36,43 @@
        SecondaryRole_Mouse
    } secondary_role_t;

+    typedef enum {
+        MouseSpeed_Normal,
+        MouseSpeed_Accelerated,
+        MouseSpeed_Decelerated,
+    } mouse_speed_t;
+
+    typedef struct {
+        bool isScroll;
+        bool wasMoveAction;
+        serialized_mouse_action_t upState;
+        serialized_mouse_action_t downState;
+        serialized_mouse_action_t leftState;
+        serialized_mouse_action_t rightState;
+        mouse_speed_t prevMouseSpeed;
+        float intMultiplier;
+        float currentSpeed;
+        float targetSpeed;
+        uint8_t initialSpeed;
+        uint8_t acceleration;
+        uint8_t deceleratedSpeed;
+        uint8_t baseSpeed;
+        uint8_t acceleratedSpeed;
+        float xSum;
+        float ySum;
+        int16_t xOut;
+        int16_t yOut;
+    } mouse_kinetic_state_t;
+
+// Variables:
+
+    extern uint16_t DoubleTapSwitchLayerTimeout;
+    extern mouse_kinetic_state_t MouseMoveState;
+    extern mouse_kinetic_state_t MouseScrollState;
+    extern uint32_t UsbReportUpdateCounter;
+
+// Functions:
+
+    void UpdateUsbReports(void);
+
 #endif
--- a/scripts/generate-versions-h.js
+++ b/scripts/generate-versions-h.js
@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+const fs = require('fs');
+
+const versionPropertyPrefixes = ['firmware', 'deviceProtocol', 'moduleProtocol', 'userConfig', 'hardwareConfig'];
+const patchVersions = ['Major', 'Minor', 'Patch'];
+const package = JSON.parse(fs.readFileSync(`${__dirname}/package.json`));
+
+const versionVariables = versionPropertyPrefixes.map(versionPropertyPrefix => {
+    const versionPropertyName = `${versionPropertyPrefix}Version`
+    const versionPropertyValues = package[versionPropertyName].split('.');
+    return patchVersions.map(patchVersion => {
+        const versionPropertyValue = versionPropertyValues.shift();
+        const versionPropertyMacroName = `${versionPropertyPrefix}${patchVersion}Version`.split(/(?=[A-Z])/).join('_').toUpperCase()
+        return `    #define ${versionPropertyMacroName} ${versionPropertyValue}`;
+    }).join('\n') + '\n';
+}).join('\n');
+
+fs.writeFileSync(`${__dirname}/../shared/versions.h`,
+`// Please do not edit this file by hand!
+// It is to be regenerated by /scripts/generate-versions-h.js
+
+#ifndef __VERSIONS_H__
+#define __VERSIONS_H__
+
+// Includes:
+
+    #include "fsl_common.h"
+
+// Typedefs:
+
+    typedef struct {
+        uint16_t major;
+        uint16_t minor;
+        uint16_t patch;
+    } version_t;
+
+// Variables:
+
+${versionVariables}
+#endif
+`);
--- a/scripts/make-release.js
+++ b/scripts/make-release.js
@@ -5,8 +5,10 @@ require('shelljs/global');
 config.fatal = true;
 config.verbose = true;

+exec(`${__dirname}/generate-versions-h.js`);
+
 const package = JSON.parse(fs.readFileSync(`${__dirname}/package.json`));
-const version = package.version;
+const version = package.firmwareVersion;
 const releaseName = `uhk-firmware-${version}`;
 const releaseDir = `${__dirname}/${releaseName}`;
 const modulesDir = `${releaseDir}/modules`;
@@ -28,7 +30,7 @@ exec(`/opt/Freescale/KDS_v3/eclipse/kinetis-design-studio \
 -cleanBuild uhk-right`
 );

-for (let device of package.devices) {
+for (const device of package.devices) {
    const deviceDir = `${releaseDir}/devices/${device.name}`;
    const deviceSource = `${__dirname}/../${device.source}`;
    mkdir('-p', deviceDir);
@@ -37,7 +39,7 @@ for (let device of package.devices) {
    exec(`${usbDir}/user-config-json-to-bin.ts ${deviceDir}/config.bin`);
 }

-for (let module of package.modules) {
+for (const module of package.modules) {
    const moduleDir = `${releaseDir}/modules`;
    const moduleSource = `${__dirname}/../${module.source}`;
    mkdir('-p', moduleDir);
--- a/scripts/package.json
+++ b/scripts/package.json
@@ -15,10 +15,11 @@
    "commander": "^2.11.0",
    "shelljs": "^0.7.8"
  },
-  "version": "3.0.0",
-  "dataModelVersion": "1.0.0",
-  "usbProtocolVersion": "1.2.0",
-  "slaveProtocolVersion": "2.1.0",
+  "firmwareVersion": "8.0.1",
+  "deviceProtocolVersion": "4.1.0",
+  "moduleProtocolVersion": "4.0.0",
+  "userConfigVersion": "4.0.0",
+  "hardwareConfigVersion": "1.0.0",
  "devices": [
    {
      "deviceId": 1,
--- a/shared/buffer.c
+++ b/shared/buffer.c
@@ -45,6 +45,21 @@ void SetBufferUint32(uint8_t *buffer, uint32_t offset, uint32_t value)
    *(uint32_t*)(buffer + offset) = value;
 }

+void SetBufferInt8(uint8_t *buffer, uint32_t offset, int8_t value)
+{
+    *(int8_t*)(buffer + offset) = value;
+}
+
+void SetBufferInt16(uint8_t *buffer, uint32_t offset, int16_t value)
+{
+    *(int16_t*)(buffer + offset) = value;
+}
+
+void SetBufferInt32(uint8_t *buffer, uint32_t offset, int32_t value)
+{
+    *(int32_t*)(buffer + offset) = value;
+}
+
 void SetBufferUint8Be(uint8_t *buffer, uint32_t offset, uint8_t value)
 {
    buffer[offset] = value;
@@ -63,3 +78,8 @@ void SetBufferUint32Be(uint8_t *buffer, uint32_t offset, uint32_t value)
    buffer[offset+2] = (value >>  8) & 0xff;
    buffer[offset+3] = (value >>  0) & 0xff;
 }
+
+void SetBufferFloat(uint8_t *buffer, uint32_t offset, float value)
+{
+    *(float*)(buffer + offset) = value;
+}
--- a/shared/buffer.h
+++ b/shared/buffer.h
@@ -19,8 +19,14 @@
    void SetBufferUint16(uint8_t *buffer, uint32_t offset, uint16_t value);
    void SetBufferUint32(uint8_t *buffer, uint32_t offset, uint32_t value);

+    void SetBufferInt8(uint8_t *buffer, uint32_t offset, int8_t value);
+    void SetBufferInt16(uint8_t *buffer, uint32_t offset, int16_t value);
+    void SetBufferInt32(uint8_t *buffer, uint32_t offset, int32_t value);
+
    void  SetBufferUint8Be(uint8_t *buffer, uint32_t offset, uint8_t value);
    void SetBufferUint16Be(uint8_t *buffer, uint32_t offset, uint16_t value);
    void SetBufferUint32Be(uint8_t *buffer, uint32_t offset, uint32_t value);

+    void SetBufferFloat(uint8_t *buffer, uint32_t offset, float value);
+
 #endif
--- a/shared/slave_protocol.h
+++ b/shared/slave_protocol.h
@@ -27,9 +27,11 @@

    typedef enum {
        SlaveProperty_Sync,
-        SlaveProperty_ProtocolVersion,
+        SlaveProperty_ModuleProtocolVersion,
+        SlaveProperty_FirmwareVersion,
        SlaveProperty_ModuleId,
-        SlaveProperty_Features,
+        SlaveProperty_KeyCount,
+        SlaveProperty_PointerCount,
    } slave_property_t;

    typedef enum {
@@ -40,11 +42,6 @@
        ModuleId_TouchpadRight    = 5,
    } module_id_t;

-    typedef struct {
-        uint8_t keyCount;
-        bool hasPointer;
-    } uhk_module_features_t;
-
    typedef struct {
        uint8_t length;
        uint16_t crc;
--- a/shared/versions.h
+++ b/shared/versions.h
@@ -0,0 +1,41 @@
+// Please do not edit this file by hand!
+// It is to be regenerated by /scripts/generate-versions-h.js
+
+#ifndef __VERSIONS_H__
+#define __VERSIONS_H__
+
+// Includes:
+
+    #include "fsl_common.h"
+
+// Typedefs:
+
+    typedef struct {
+        uint16_t major;
+        uint16_t minor;
+        uint16_t patch;
+    } version_t;
+
+// Variables:
+
+    #define FIRMWARE_MAJOR_VERSION 8
+    #define FIRMWARE_MINOR_VERSION 0
+    #define FIRMWARE_PATCH_VERSION 1
+
+    #define DEVICE_PROTOCOL_MAJOR_VERSION 4
+    #define DEVICE_PROTOCOL_MINOR_VERSION 1
+    #define DEVICE_PROTOCOL_PATCH_VERSION 0
+
+    #define MODULE_PROTOCOL_MAJOR_VERSION 4
+    #define MODULE_PROTOCOL_MINOR_VERSION 0
+    #define MODULE_PROTOCOL_PATCH_VERSION 0
+
+    #define USER_CONFIG_MAJOR_VERSION 4
+    #define USER_CONFIG_MINOR_VERSION 0
+    #define USER_CONFIG_PATCH_VERSION 0
+
+    #define HARDWARE_CONFIG_MAJOR_VERSION 1
+    #define HARDWARE_CONFIG_MINOR_VERSION 0
+    #define HARDWARE_CONFIG_PATCH_VERSION 0
+
+#endif
Author	SHA1	Message	Date
László Monda	c51542795f	Bump version to 8.0.1	2017-12-25 23:16:27 +01:00
Erich Styger	7eb83173ed	changed I2C watchdog timer implementation, as LPTMR was already used by key scanner	2017-12-25 17:15:41 +01:00
Erich Styger	5581dd26b5	fixed and enabled software watchdog timer	2017-12-24 12:06:46 +01:00
László Monda	1ac637af0f	Rename the GetProperty command to GetDeviceProperty.	2017-12-23 16:11:47 +01:00
László Monda	36951d1a34	Minor cleanups regarding the previous rename.	2017-12-23 16:08:45 +01:00
László Monda	5190265a2c	Rename get_module_properties.[ch] to get_module_property.[ch]. It seems that the header wasn't included in usb_protocol_handler.c possibly causing issues when using these commands.	2017-12-23 16:06:24 +01:00
László Monda	40bf252852	Bump version to 8.0.0. Update version numbers. Update changelog.	2017-12-15 04:03:51 +01:00
László Monda	85e92d21b4	Add new UsbCommand_GetModuleProperties() device protocol command.	2017-12-15 02:46:30 +01:00
László Monda	fd43e81e46	Query module key count and pointer count in separate messages instead of a combined message for better clarity.	2017-12-15 02:13:58 +01:00
László Monda	c994a97d03	Make the modules transfer their firmware version to the device. Fix the message length of the module protocol version.	2017-12-15 01:42:58 +01:00
László Monda	d59ba83d99	Make the modules transfer a module protocol version composed of a major, a minor and a patch number.	2017-12-15 01:28:13 +01:00
László Monda	c1b887cea8	Rename UhkModulePhase_ProtocolVersion to UhkModulePhase_ModuleProtocolVersion.	2017-12-15 01:16:27 +01:00
László Monda	bd53b73685	Rename usb_command_get_keyboard_state.[ch] to usb_command_get_device_state.[ch]	2017-12-14 23:10:13 +01:00
László Monda	beb7c3d4ee	Forgot to update versions.h for the previous release. Updating now.	2017-12-14 23:08:34 +01:00
László Monda	17571a5feb	Bump version to 7.0.0. Update changelog and package.json	2017-12-14 21:51:07 +01:00
László Monda	83e782d74a	Remove DevicePropertyId_HardwareConfigSize and DevicePropertyId_UserConfigSize	2017-12-14 21:49:15 +01:00
László Monda	312f56048b	Add DevicePropertyId_ConfigSizes.	2017-12-14 16:40:44 +01:00
László Monda	494621a841	Expose version numbers via the get property interface.	2017-12-14 16:16:11 +01:00
László Monda	94af52892c	Add generate-versions-h.js and versions.h. Execute generate-versions-h.js from make-release.js	2017-12-14 15:41:20 +01:00
László Monda	5862a34f18	Use const instead of let wherever possible in make-release.js	2017-12-14 04:01:13 +01:00
László Monda	9b9e5ed1b5	Rename the version property to firmwareVersion in package.json	2017-12-14 03:52:56 +01:00
László Monda	4393377365	Rename version properties in package.json	2017-12-14 03:48:59 +01:00
László Monda	1570364741	Add hardware config versions to releases.	2017-12-14 03:38:24 +01:00
László Monda	738a240860	Rename slave protocol to module protocol.	2017-12-14 03:36:29 +01:00
László Monda	43b48aa643	Rename USB protocol to device protocol.	2017-12-14 03:25:47 +01:00
László Monda	61a0540007	Rename data model to user config.	2017-12-14 03:24:29 +01:00
László Monda	f2e313dd0a	Put the data model version as the last element of the version list.	2017-12-14 03:22:04 +01:00
László Monda	b239d0da50	Mark bumped version numbers by making them bold.	2017-12-14 03:14:41 +01:00
László Monda	23459e3791	Don't make horizontal scrolling and vertical scrolling affect each other.	2017-12-14 01:30:06 +01:00
László Monda	6a54944cb1	Make UsbCommand_JumpToModuleBootloader() more robust by not making it dependent on the state of the module driver.	2017-12-13 01:27:04 +01:00
László Monda	a52df9da7e	Bump version to 6.0.0, update changelog and package.json	2017-12-12 18:44:12 +01:00
László Monda	28f98f179a	Change the value of UsbCommandId_{GetDeviceState,SetTestLed,GetDebugBuffer,GetAdcValue,SetLedPwmBrightness}.	2017-12-12 18:38:01 +01:00
László Monda	5798f9e4fb	Refactor UsbCommandId_LaunchEepromTransfer, change its arguments, and change its ID to 0x08.	2017-12-12 03:24:34 +01:00
László Monda	4fe5ce45ac	Change UsbCommandId_ApplyConfig to 0x07.	2017-12-12 02:15:20 +01:00
László Monda	a212c254a9	Change UsbCommandId_WriteHardwareConfig and UsbCommandId_WriteUserConfig to 0x05 and 0x06.	2017-12-12 01:59:53 +01:00
László Monda	235e18d706	Fix UsbCommandId_WriteHardwareConfig that I previously screwed up.	2017-12-12 01:29:49 +01:00
László Monda	7c91f8f6d1	Replace UsbCommandId_ReadHardwareConfig and UsbCommandId_ReadUserConfig with UsbCommandId_ReadConfig.	2017-12-12 01:22:26 +01:00
László Monda	c8cfe53136	Change UsbCommandId_SendKbootCommandToModule from 0x13 to 0x03.	2017-12-11 22:15:46 +01:00
László Monda	f1f47ece14	Change UsbCommandId_JumpToModuleBootloader from 0x12 to 0x02.	2017-12-11 21:44:35 +01:00
László Monda	a0dba2fa66	Change UsbCommandId_SetTestLed from 0x02 to 0x14.	2017-12-11 21:21:41 +01:00
László Monda	0f34b01189	Update LED brightness levels upon applying the configuration.	2017-12-10 20:48:26 +01:00
László Monda	5a449ad5c5	Disable LED display icons by default.	2017-12-10 15:35:03 +01:00
László Monda	0d6a5ae902	Bump firmware version number to 5.0.1 and update changelog.	2017-12-09 16:44:11 +01:00
László Monda	2f7f7b1cd2	Make scrolling immediately react to keypresses regardless of the previous internal scroll state.	2017-12-07 04:44:45 +01:00
László Monda	2eb25ce05c	Make UpdateUsbReports() not exit prematurely even if a previously active USB interface is not polled anymore by the host. Tweak the Timer API to not set the current time automatically.	2017-12-07 03:24:53 +01:00
László Monda	6e47707037	Rename the misleadingly named error variable of usbDeviceCallback() to status. Clean up InitUsb() a bit.	2017-12-05 00:56:52 +01:00
László Monda	0932c14a2c	Lowercamelcase UsbDeviceCallback because it's local.	2017-12-04 22:51:04 +01:00
László Monda	e57c2c21ca	Don't define the NULL members of UsbDeviceCompositeConfigList.	2017-12-04 20:43:57 +01:00
László Monda	a5ce90779c	Merge all the substructures of UsbDeviceCompositeConfigList across different files to a single structure.	2017-12-04 20:41:22 +01:00
László Monda	e9bf3dc355	Expand UsbDeviceCompositeClassConfig and UsbDeviceCompositeConfigList using structure member names.	2017-12-04 20:05:28 +01:00
László Monda	8cb8654459	Merge the substructures of UsbMouseClass into a single structure.	2017-12-04 19:57:43 +01:00
László Monda	745e8e1cf0	Merge the substructures of UsbSystemKeyboardClass into a single structure.	2017-12-04 19:50:39 +01:00
László Monda	5341109845	Merge the substructures of UsbMediaKeyboardClass into a single structure.	2017-12-04 19:41:51 +01:00
László Monda	ff0e5b0aa3	Merge the structs of UsbBasicKeyboardClass into a single structure.	2017-12-04 19:33:53 +01:00
László Monda	c4e79d8ed2	Merge the all the structures of UsbGenericHidClass into a single structure.	2017-12-04 19:16:04 +01:00
László Monda	6780c8177c	Expose per-interface count values for debugging purposes via USB.	2017-12-04 17:38:31 +01:00
László Monda	71d6db0f35	Update CHANGELOG.md and package.json for version 5.0.0	2017-12-04 00:40:07 +01:00
László Monda	9b9bdbc03d	Rename baseLayerPointerFunction to modLayerPointerFunction and modLayerPointerFunction to fnLayerPointerFunction. Suppress unused variable compilation warnings.	2017-12-03 23:53:32 +01:00
László Monda	bb5c118e97	Move pointerRole from keymaps to module configurations as pointerMode. Add angularShift, baseLayerPointerFunction, modLayerPointerFunction, and mouseLayerPointerFunction to module configurations.	2017-12-03 23:25:55 +01:00
László Monda	b3cbb8ea97	Bump version to 4.0.0	2017-11-30 20:31:09 +01:00
László Monda	f76780ec48	Make the parser parse mouse properties, LED brightness values, and double tap switch layer timeout. Rename pointer config properties.	2017-11-30 18:20:00 +01:00
László Monda	b7e73b7b38	Clean up the debug lines of processMouseAction()	2017-11-28 22:45:51 +01:00
László Monda	7318175ce7	Tweak scroll kinetic properties.	2017-11-28 22:39:37 +01:00
László Monda	420078449d	Finish the fine-tuning of default mouse movement kinetic settings.	2017-11-28 20:12:01 +01:00
László Monda	dda3799877	Don't make the pointer jump when accelerating from zero while the decelerate key is pressed.	2017-11-28 19:10:13 +01:00
László Monda	712b87182a	Double timer interval that wasn't right for an unknown reason. Adjust mouse kinetic values accordingly. Reprioritize interrupts to make mouse pointer movement as smooth as possible.	2017-11-28 18:52:39 +01:00
László Monda	46126e1e78	Tweak kinetic mouse values further. Temporarily maximize / minimize the acceleratedSpeed / deceleratedSpeed values for testing purposes.	2017-11-28 17:25:46 +01:00
László Monda	2ac9ca5d67	Make the initialSpeed, acceleration, deceleratedSpeed, baseSpeed, and acceleratedSpeed kinetic properties uint8_t and multiply them by intMultiplier to provide a fixed set of steps to choose from.	2017-11-28 03:23:09 +01:00
László Monda	729e0be0ad	Make scrolling utilize mouse_kinetic_state_t, just like mouse movements. Fix scrolling issue by making distance float. Add new debug functions for ints and float.	2017-11-28 02:01:26 +01:00
László Monda	0867132ba3	Adjust the distance divisor from 10 to 1000 and other kinetic values accordingly.	2017-11-27 02:09:45 +01:00
László Monda	1b9273a5e5	Make processMouseKineticState() work with float x,y offsets to accumulate fractions.	2017-11-27 01:24:03 +01:00
László Monda	ebbd74407d	Extract code into processMouseKineticState() and add mouse_kinetic_state_t	2017-11-26 21:35:50 +01:00
László Monda	5df6220ab7	Slightly reorder mouse movement related variables.	2017-11-26 02:32:53 +01:00
László Monda	3d0993998c	Add double tap switch layer timeout.	2017-11-26 01:05:36 +01:00
László Monda	071be7e815	Implement "hold and double tap" layer switch mode and temporarily treat every hold mode keys this way.	2017-11-26 00:23:50 +01:00
László Monda	bb7faaa799	Make non-accelerated movements gradually accelerate from the start. Make all other movements and speed transitions immediate.	2017-11-24 22:49:39 +01:00
László Monda	368c724e6a	Fix the stuck state of the decelerate key that triggered once it was pressed.	2017-11-24 17:39:45 +01:00
László Monda	210ef31f27	Implement mouse movement acceleration and deceleration.	2017-11-24 13:00:05 +01:00
László Monda	0cb3c7e0ad	Implement horizontal scrolling.	2017-11-24 01:00:02 +01:00
László Monda	ab7e25692a	Use hex numbers as the values of UsbCommandId_*	2017-11-23 04:18:37 +01:00
László Monda	b68e8a736e	Make processMouseAction() handle acceleration and deceleration, even though I can't yet trigger these actions for some reason.	2017-11-23 01:54:54 +01:00
László Monda	4d211f0fe1	Reset mouseMoveCurrentSpeed when the mouse movement keys are no longer pressed, even if a mouse button key stays pressed due to drag and drop or selection purposes.	2017-11-22 02:34:37 +01:00
László Monda	8429ee2b71	Implement mouse acceleration.	2017-11-21 21:15:12 +01:00
László Monda	4bbc49f4ca	Clean up processMouseAction() by using floats instead of divisor values. Move MouseSpeed_* into mouse_speed_action_t	2017-11-21 19:01:59 +01:00
László Monda	322ee0b35f	Rename the misnamed MouseButton_t to MouseButton_6	2017-11-21 16:42:27 +01:00
László Monda	8252da86d8	Rename some files and identifiers that are related to USB commands.	2017-11-18 03:30:24 +01:00
László Monda	086ab239b4	Fix the previously introduced EEPROM read bug by making addressBuffer static. Rename EEPROM_ADDRESS_LENGTH to EEPROM_ADDRESS_SIZE.	2017-11-18 03:18:37 +01:00
László Monda	a7ba0add18	Simplify eeprom.c	2017-11-18 03:11:17 +01:00
László Monda	d2ef63184b	Move updateUsbReports() from main.c to usb_report_updater.c and delete main.h	2017-11-17 01:21:30 +01:00