Update versions.h to 8.1.1

Bump version to 8.1.1. Update package.json and the changelog.
Add doubleTapSwitchLayerReleaseTimeout and set it to 100ms. Resolves #79 .
2018-02-11 04:23:31 +01:00 · 2018-02-11 04:21:49 +01:00 · 2018-02-11 04:09:15 +01:00 · 2018-02-11 03:29:15 +01:00 · 2018-02-10 23:55:48 +01:00 · 2018-02-10 23:53:35 +01:00
69 changed files with 982 additions and 395 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,30 +5,81 @@ 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.1.1] - 2018-02-11
+
+Device Protocol: 4.2.0 | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Lock layers every time when double-tapping their layer switcher keys, regardless of how many times the layer switcher key was tapped before.
+- Only lock layers via double-tapping if the second tap gets released within 100ms.
+
+## [8.1.0] - 2018-01-15
+
+Device Protocol: 4.**2**.0 | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Enable left-half watchdog in reinit mode which seems to prevent freezes.
+- Slow down main bus I2C baud rate to 30kHz when BusPal is on to make firmware transfer more robust.
+- Implement UsbCommandId_GetSlaveI2cErrors. `DEVICEPROTOCOL:MINOR`
+- Implement UsbCommandId_SetI2cBaudRate. `DEVICEPROTOCOL:MINOR`
+- Implement DevicePropertyId_CurrentKbootCommand. `DEVICEPROTOCOL:MINOR`
+- Implement DevicePropertyId_I2cMainBusBaudRate. `DEVICEPROTOCOL:MINOR`
+- Implement DevicePropertyId_Uptime. `DEVICEPROTOCOL:MINOR`
+
+## [8.0.1] - 2017-12-25
+
+Device Protocol: 4.1.0 | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Implement I2C watchdog for the left keyboard half which should resolve the occasional hangs of the left keyboard half.
+
+## [8.0.0] - 2017-12-15
+
+Device Protocol: 4.**1.0** | Module Protocol: **4.0.0** | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Make the modules transfer the module protocol version and firmware version composed of a major, a minor and a patch number. `MODULEPROTOCOL:MAJOR`
+- Query module key count and pointer count in separate messages instead of a combined message for improved clarity. `MODULEPROTOCOL:MAJOR`
+- Add new UsbCommand_GetModuleProperties() device protocol command. `DEVICEPROTOCOL:MINOR`
+
+## [7.0.0] - 2017-12-14
+
+Device Protocol: **4.0.0** | Module Protocol: 3.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Make UsbCommand_JumpToModuleBootloader() more robust by not making it dependent on the state of the module driver.
+- Don't make horizontal scrolling and vertical scrolling affect each other.
+- Expose version numbers via the get property interface. `DEVICEPROTOCOL:MINOR`
+- Add DevicePropertyId_ConfigSizes. `DEVICEPROTOCOL:MINOR`
+- Remove DevicePropertyId_HardwareConfigSize and DevicePropertyId_UserConfigSize. `DEVICEPROTOCOL:MAJOR`
+
+## [6.0.0] - 2017-12-12
+
+Device Protocol: **3.0.0** | Module Protocol: 3.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Change the value of almost every Device Protocol commands because there were unused intervals between them. `DEVICEPROTOCOL:MAJOR`
+- Disable LED display icons by default.
+- Update LED brightness levels upon applying the configuration.
+
 ## [5.0.1] - 2017-12-09

-Data Model: 4.0.0 (unchanged) | USB Protocol: 2.0.0 (unchanged) | Slave Protocol: 3.0.0 (unchanged)
+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

-Data Model: 4.0.0 (major bump) | USB Protocol: 2.0.0 (unchanged) | Slave Protocol: 3.0.0 (unchanged)
+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. `DATAMODEL:MAJOR`
+- 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

-Data Model: 3.0.0 (major bump) | USB Protocol: 2.0.0 (unchanged) | Slave Protocol: 3.0.0 (unchanged)
+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: dataModelMajorVersion, dataModelMinorVersion, dataModelPatchVersion, doubleTapSwitchLayerTimeout, iconsAndLayerTextsBrightness, alphanumericSegmentsBrightness, keyBacklightBrightness, mouseMoveInitialSpeed, mouseMoveAcceleration, mouseMoveDeceleratedSpeed, mouseMoveBaseSpeed, mouseMoveAcceleratedSpeed, mouseScrollInitialSpeed, mouseScrollAcceleration, mouseScrollDeceleratedSpeed, mouseScrollBaseSpeed, mouseScrollAcceleratedSpeed. `DATAMODEL:MAJOR`
+- 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.
@@ -36,49 +87,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/README.md
+++ b/README.md
@@ -4,6 +4,10 @@

 This repository hosts the firmware of the [Ultimate Hacking Keyboard](https://ultimatehackingkeyboard.com/).

+## Updating to the latest firmware
+
+Want to update your UHK to the latest firmware version? Simply download the [latest release of Agent](https://github.com/UltimateHackingKeyboard/agent/releases/latest) which includes the latest firmware version. You'll be easily able to update the firmware within Agent.
+
 ## Cloning the repository

 Please make sure to clone this repo with:
@@ -18,9 +22,13 @@ Install [Kinetis Design Studio](http://www.nxp.com/products/software-and-tools/r

 ## Building and flashing the firmware

-For the left keyboard half, make sure to power it via the right keyboard half (which must be powered via USB). Also connect the left keyboard half to your SEGGER J-Link USB debug probe (which must also be connected via USB). Then in KDS, click on *Run -> Run Configurations*, select *GDB SEGGER J-Link Debugging -> uhk-left release jlink*, and click on the *Debug* button.
+For the left keyboard half, make sure to power it via the right keyboard half (which must be powered via USB). Also connect the left keyboard half to your SEGGER J-Link USB debug probe (which must also be connected via USB). Then in KDS, click on *Run -> Run Configurations*, select *GDB SEGGER J-Link Debugging -> uhk60-left_release_jlink*, and click on the *Debug* button.

-For the right keyboard half, flash [the bootloader](https://github.com/UltimateHackingKeyboard/bootloader) first. Then in KDS, click on *Run -> Run Configurations*, select *C/C++ Application -> uhk-right release blhost*, and click on the *Debug* button. Please note that this update method only works on Linux out of the box. On other operating systems, you have to execute the relevant commands of the [blhost-unix.sh](right/build/kds/blhost-unix.sh) script.
+For the right keyboard half, flash [the bootloader](https://github.com/UltimateHackingKeyboard/bootloader) first.
+
+At this point, you can flash the right firmware via USB from KDS. To achieve this, you must build [Agent](https://github.com/UltimateHackingKeyboard/agent) that is Git submodule of the this repo and located in the `lib/agent` directory.  Then in KDS, click on *Run -> Run Configurations*, select *C/C++ Application -> uhk60-right_release_kboot*, and click on the *Run* button.
+
+From this point on, you can upgrade the firmwares of both halves via USB by using the uhk60-left_release_kboot and uhk60-right_release_kboot run configurations. Alternatively, you can use your SEGGER J-Link probe.

 ## Contributing

--- 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/config.h
+++ b/left/src/config.h
@@ -3,6 +3,11 @@

 // Macros:

+    #define I2C_WATCHDOG_VALUE_REINIT 1
+    #define I2C_WATCHDOG_VALUE_REBOOT 2
+
 //    #define DEBUG_OVER_SPI
+    #define I2C_WATCHDOG I2C_WATCHDOG_VALUE_REINIT
+//    #define I2C_WATCHDOG I2C_WATCHDOG_VALUE_REBOOT

 #endif
--- a/left/src/i2c_watchdog.c
+++ b/left/src/i2c_watchdog.c
@@ -3,36 +3,40 @@
 #include "i2c_watchdog.h"
 #include "test_led.h"
 #include "init_peripherals.h"
+#include "config.h"

-//static uint32_t prevWatchdogCounter = 0;
-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.
+ */
+#ifdef I2C_WATCHDOG
+  static uint32_t prevWatchdogCounter = 0;
+  static uint32_t I2cWatchdog_RecoveryCounter; /* counter for how many times we had to recover and restart */

-void InitI2cWatchdog(void)
+void RunWatchdog(void)
 {
-    lptmr_config_t lptmrConfig;
-    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)
-{
-    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++;
+
+        if (I2cWatchdog_WatchCounter>10) { /* do not check within the first 1000 ms, as I2C might not be running yet */
+            if (I2C_Watchdog == prevWatchdogCounter) { // Restart I2C if there hasn't been any interrupt during 100 ms. I2C_Watchdog gets incremented for every I2C transaction
+                I2cWatchdog_RecoveryCounter++;
+#if I2C_WATCHDOG == I2C_WATCHDOG_VALUE_REBOOT
+                NVIC_SystemReset();
+#endif
+#if I2C_WATCHDOG == I2C_WATCHDOG_VALUE_REINIT
+                I2C_SlaveDeinit(I2C_BUS_BASEADDR);
+                initI2c();
+#endif
+            }
+        }
+        prevWatchdogCounter = I2C_Watchdog; /* remember previous counter */
    }
-
-    prevWatchdogCounter = I2C_Watchdog;
-
-    LPTMR_ClearStatusFlags(LPTMR0, kLPTMR_TimerCompareFlag);
 }
-*/
+#endif
--- a/left/src/i2c_watchdog.h
+++ b/left/src/i2c_watchdog.h
@@ -13,7 +13,6 @@

 // Functions:

-    void InitI2cWatchdog(void);
    void RunWatchdog(void);

 #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;
@@ -44,14 +45,14 @@ static void i2cSlaveCallback(I2C_Type *base, i2c_slave_transfer_t *xfer, void *u
    }
 }

-void InitInterruptPriorities(void)
+void initInterruptPriorities(void)
 {
    NVIC_SetPriority(I2C0_IRQn, 1);
    NVIC_SetPriority(TPM1_IRQn, 1);
    NVIC_SetPriority(SPI0_IRQn, 1);
 }

-void InitI2c(void)
+void initI2c(void)
 {
    port_pin_config_t pinConfig = {
        .pullSelect = kPORT_PullUp,
@@ -81,11 +82,10 @@ void InitLedDriver(void)

 void InitPeripherals(void)
 {
-    InitInterruptPriorities();
+    initInterruptPriorities();
    InitLedDriver();
    InitTestLed();
    LedPwm_Init();
-//    InitI2cWatchdog();
    DebugOverSpi_Init();
-    InitI2c();
+    initI2c();
 }
--- a/left/src/init_peripherals.h
+++ b/left/src/init_peripherals.h
@@ -11,6 +11,6 @@
 // Functions:

    void InitPeripherals(void);
-    void InitI2c(void);
+    void initI2c(void);

 #endif
--- a/left/src/key_scanner.c
+++ b/left/src/key_scanner.c
@@ -1,10 +1,14 @@
 #include "fsl_lptmr.h"
 #include "key_scanner.h"
-#include "main.h"
+#include "config.h"
+#include "i2c_watchdog.h"

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

--- 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/KSDK_2.0_MK22FN512xxx12
+++ b/lib/KSDK_2.0_MK22FN512xxx12
--- 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.h
+++ b/right/src/config.h
@@ -4,6 +4,7 @@
 // Macros:

    #define I2C_WATCHDOG
+    #define LED_DRIVERS_ENABLED
 //    #define LED_DRIVER_STRESS_TEST

 #endif
--- 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
@@ -5,6 +5,10 @@
 #include "config_globals.h"
 #include "macros.h"
 #include "usb_report_updater.h"
+#include "led_display.h"
+#include "slave_scheduler.h"
+#include "slave_drivers/is31fl3731_driver.h"
+#include "config.h"

 static parser_error_t parseModuleConfiguration(config_buffer_t *buffer)
 {
@@ -59,10 +63,6 @@ parser_error_t ParseConfig(config_buffer_t *buffer)
    uint8_t alphanumericSegmentsBrightness = ReadUInt8(buffer);
    uint8_t keyBacklightBrightness = ReadUInt8(buffer);

-    (void)iconsAndLayerTextsBrightness;
-    (void)alphanumericSegmentsBrightness;
-    (void)keyBacklightBrightness;
-
    // Mouse kinetic properties

    uint8_t mouseMoveInitialSpeed = ReadUInt8(buffer);
@@ -138,6 +138,17 @@ parser_error_t ParseConfig(config_buffer_t *buffer)
    if (!ParserRunDry) {
        DoubleTapSwitchLayerTimeout = doubleTapSwitchLayerTimeout;

+        // Update LED brightnesses and reinitialize LED drivers
+
+        IconsAndLayerTextsBrightness = iconsAndLayerTextsBrightness;
+        AlphanumericSegmentsBrightness = alphanumericSegmentsBrightness;
+        KeyBacklightBrightness = keyBacklightBrightness;
+#ifdef LED_DRIVERS_ENABLED
+        Slaves[SlaveId_LeftLedDriver].isConnected = false;
+        Slaves[SlaveId_RightLedDriver].isConnected = false;
+#endif
+        // Update mouse key speeds
+
        MouseMoveState.initialSpeed = mouseMoveInitialSpeed;
        MouseMoveState.acceleration = mouseMoveAcceleration;
        MouseMoveState.deceleratedSpeed = mouseMoveDeceleratedSpeed;
@@ -150,6 +161,8 @@ parser_error_t ParseConfig(config_buffer_t *buffer)
        MouseScrollState.baseSpeed = mouseScrollBaseSpeed;
        MouseScrollState.acceleratedSpeed = mouseScrollAcceleratedSpeed;

+        // Update counts
+
        AllKeymapsCount = keymapCount;
        AllMacrosCount = macroCount;
    }
--- a/right/src/eeprom.c
+++ b/right/src/eeprom.c
@@ -125,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
@@ -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
@@ -10,11 +10,12 @@

    // Main bus

-    #define I2C_MAIN_BUS_BASEADDR  I2C0
-    #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_BASEADDR         I2C0
+    #define I2C_MAIN_BUS_IRQ_ID           I2C0_IRQn
+    #define I2C_MAIN_BUS_CLK_SRC          I2C0_CLK_SRC
+    #define I2C_MAIN_BUS_NORMAL_BAUD_RATE 100000
+    #define I2C_MAIN_BUS_BUSPAL_BAUD_RATE 30000
+    #define I2C_MAIN_BUS_MUX              kPORT_MuxAlt7

    #define I2C_MAIN_BUS_SDA_GPIO  GPIOD
    #define I2C_MAIN_BUS_SDA_PORT  PORTD
--- a/right/src/i2c_error_logger.c
+++ b/right/src/i2c_error_logger.c
@@ -0,0 +1,25 @@
+#include "fsl_i2c.h"
+#include "i2c_error_logger.h"
+
+i2c_slave_error_counter_t I2cSlaveErrorCounters[MAX_SLAVE_COUNT];
+
+void LogI2cError(uint8_t slaveId, status_t status)
+{
+    i2c_slave_error_counter_t *i2cSlaveErrorCounter = I2cSlaveErrorCounters + slaveId;
+    uint8_t errorIdx;
+
+    for (errorIdx=0; errorIdx<i2cSlaveErrorCounter->errorTypeCount; errorIdx++) {
+        i2c_error_count_t *currentI2cError = i2cSlaveErrorCounter->errors + errorIdx;
+        if (currentI2cError->status == status) {
+            currentI2cError->count++;
+            break;
+        }
+    }
+
+    if (errorIdx == i2cSlaveErrorCounter->errorTypeCount && errorIdx < MAX_LOGGED_I2C_ERROR_TYPES_PER_SLAVE) {
+        i2cSlaveErrorCounter->errorTypeCount++;
+        i2c_error_count_t *currentI2cError = i2cSlaveErrorCounter->errors + errorIdx;
+        currentI2cError->status = status;
+        currentI2cError->count = 1;
+    }
+}
--- a/right/src/i2c_error_logger.h
+++ b/right/src/i2c_error_logger.h
@@ -0,0 +1,33 @@
+#ifndef __I2C_ERROR_LOGGER_H__
+#define __I2C_ERROR_LOGGER_H__
+
+// Includes:
+
+    #include "fsl_common.h"
+    #include "slave_scheduler.h"
+
+// Macros:
+
+    #define MAX_LOGGED_I2C_ERROR_TYPES_PER_SLAVE 7
+
+// Typedefs:
+
+    typedef struct {
+        status_t status;
+        uint32_t count;
+    } i2c_error_count_t;
+
+    typedef struct {
+        uint8_t errorTypeCount;
+        i2c_error_count_t errors[MAX_LOGGED_I2C_ERROR_TYPES_PER_SLAVE];
+    } i2c_slave_error_counter_t;
+
+// Variables:
+
+    extern i2c_slave_error_counter_t I2cSlaveErrorCounters[MAX_SLAVE_COUNT];
+
+// Functions:
+
+    void LogI2cError(uint8_t slaveId, status_t status);
+
+#endif
--- a/right/src/i2c_watchdog.c
+++ b/right/src/i2c_watchdog.c
@@ -5,7 +5,6 @@
 #include "fsl_gpio.h"
 #include "i2c.h"
 #include "i2c_watchdog.h"
-#include "slave_scheduler.h"
 #include "init_peripherals.h"

 uint32_t I2cWatchdog_WatchCounter;
@@ -19,17 +18,13 @@ static uint32_t prevWatchdogCounter;
 void PIT_I2C_WATCHDOG_HANDLER(void)
 {
    I2cWatchdog_WatchCounter++;
+
    if (I2C_Watchdog == prevWatchdogCounter) { // Restart I2C if there haven't been any interrupts recently
        I2cWatchdog_RecoveryCounter++;
-        i2c_master_config_t masterConfig;
-        I2C_MasterGetDefaultConfig(&masterConfig);
-        I2C_MasterDeinit(I2C_MAIN_BUS_BASEADDR);
-        InitI2cMainBus();
-        InitSlaveScheduler();
+        ReinitI2cMainBus();
    }

    prevWatchdogCounter = I2C_Watchdog;
-
    PIT_ClearStatusFlags(PIT, PIT_I2C_WATCHDOG_CHANNEL, PIT_TFLG_TIF_MASK);
 }

--- a/right/src/init_peripherals.c
+++ b/right/src/init_peripherals.c
@@ -14,8 +14,22 @@
 #include "timer.h"
 #include "key_debouncer.h"
 #include "usb_api.h"
+#include "slave_scheduler.h"
+#include "bootloader/wormhole.h"

-void InitInterruptPriorities(void)
+bool IsBusPalOn;
+uint32_t I2cMainBusRequestedBaudRateBps = I2C_MAIN_BUS_NORMAL_BAUD_RATE;
+uint32_t I2cMainBusActualBaudRateBps;
+
+void initBusPalState(void) {
+    IsBusPalOn = Wormhole.magicNumber == WORMHOLE_MAGIC_NUMBER && Wormhole.enumerationMode == EnumerationMode_BusPal;
+    if (IsBusPalOn) {
+        Wormhole.magicNumber = 0;
+        I2cMainBusRequestedBaudRateBps = I2C_MAIN_BUS_BUSPAL_BAUD_RATE;
+    }
+}
+
+void initInterruptPriorities(void)
 {
    NVIC_SetPriority(PIT_I2C_WATCHDOG_IRQ_ID,  1);
    NVIC_SetPriority(PIT_TIMER_IRQ_ID,         2);
@@ -60,7 +74,7 @@ void recoverI2c(void)
    delay();
 }

-void InitI2cMainBus(void)
+void initI2cMainBus(void)
 {
    CLOCK_EnableClock(I2C_MAIN_BUS_SDA_CLOCK);
    CLOCK_EnableClock(I2C_MAIN_BUS_SCL_CLOCK);
@@ -78,9 +92,17 @@ void InitI2cMainBus(void)

    i2c_master_config_t masterConfig;
    I2C_MasterGetDefaultConfig(&masterConfig);
-    masterConfig.baudRate_Bps = I2C_MAIN_BUS_BAUD_RATE;
+    masterConfig.baudRate_Bps = I2cMainBusRequestedBaudRateBps;
    uint32_t sourceClock = CLOCK_GetFreq(I2C_MAIN_BUS_CLK_SRC);
    I2C_MasterInit(I2C_MAIN_BUS_BASEADDR, &masterConfig, sourceClock);
+    I2cMainBusActualBaudRateBps = I2C_ActualBaudRate;
+}
+
+void ReinitI2cMainBus(void)
+{
+    I2C_MasterDeinit(I2C_MAIN_BUS_BASEADDR);
+    initI2cMainBus();
+    InitSlaveScheduler();
 }

 void initI2cEepromBus(void)
@@ -91,7 +113,6 @@ void initI2cEepromBus(void)
       .mux = I2C_EEPROM_BUS_MUX,
   };

-
   CLOCK_EnableClock(I2C_EEPROM_BUS_SDA_CLOCK);
   CLOCK_EnableClock(I2C_EEPROM_BUS_SCL_CLOCK);

@@ -105,21 +126,22 @@ void initI2cEepromBus(void)
   I2C_MasterInit(I2C_EEPROM_BUS_BASEADDR, &masterConfig, sourceClock);
 }

-void InitI2c(void)
+void initI2c(void)
 {
-    InitI2cMainBus();
+    initI2cMainBus();
    initI2cEepromBus();
 }

 void InitPeripherals(void)
 {
-    InitInterruptPriorities();
+    initBusPalState();
+    initInterruptPriorities();
    Timer_Init();
    InitLedDriver();
    InitResetButton();
    InitMergeSensor();
    ADC_Init();
-    InitI2c();
+    initI2c();
    InitTestLed();
    LedPwm_Init();
 #ifdef I2C_WATCHDOG
--- a/right/src/init_peripherals.h
+++ b/right/src/init_peripherals.h
@@ -5,9 +5,15 @@

    #include "fsl_common.h"

+// Variables:
+
+    extern bool IsBusPalOn;
+    extern uint32_t I2cMainBusRequestedBaudRateBps;
+    extern uint32_t I2cMainBusActualBaudRateBps;
+
 // Functions:

    void InitPeripherals(void);
-    void InitI2cMainBus(void);
+    void ReinitI2cMainBus(void);

 #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
@@ -5,7 +5,6 @@
 #include "slave_scheduler.h"
 #include "bus_pal_hardware.h"
 #include "command.h"
-#include "bootloader/wormhole.h"
 #include "eeprom.h"
 #include "key_scanner.h"
 #include "usb_commands/usb_command_apply_config.h"
@@ -34,8 +33,7 @@ void main(void)
        EEPROM_LaunchTransfer(EepromOperation_Read, ConfigBufferId_HardwareConfig, hardwareConfigurationReadFinished);
    }

-    if (Wormhole.magicNumber == WORMHOLE_MAGIC_NUMBER && Wormhole.enumerationMode == EnumerationMode_BusPal) {
-        Wormhole.magicNumber = 0;
+    if (IsBusPalOn) {
        init_hardware();
        handleUsbBusPalCommand();
    } else {
--- 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/kboot_driver.c
+++ b/right/src/slave_drivers/kboot_driver.c
@@ -4,7 +4,7 @@

 kboot_driver_state_t KbootDriverState;

-static uint8_t rxBuffer[MAX_KBOOT_COMMAND_LENGTH];
+static uint8_t rxBuffer[KBOOT_PACKAGE_MAX_LENGTH];
 static uint8_t pingCommand[] = {0x5a, 0xa6};
 static uint8_t resetCommand[] = {0x5a, 0xa4, 0x04, 0x00, 0x6f, 0x46, 0x0b, 0x00, 0x00, 0x00};
 static uint8_t ackMessage[] = {0x5a, 0xa1};
@@ -27,50 +27,52 @@ status_t KbootSlaveDriver_Update(uint8_t kbootInstanceId)
 {
    status_t status = kStatus_Uhk_IdleSlave;

-    switch (KbootDriverState.commandType) {
+    switch (KbootDriverState.command) {
        case KbootCommand_Idle:
            break;
        case KbootCommand_Ping:
            switch (KbootDriverState.phase) {
-                case 0:
+                case KbootPhase_SendPing:
                    status = tx(pingCommand, sizeof(pingCommand));
-                    KbootDriverState.phase++;
+                    KbootDriverState.phase = KbootPhase_CheckPingStatus;
                    break;
-                case 1:
+                case KbootPhase_CheckPingStatus:
                    KbootDriverState.status = Slaves[SlaveId_KbootDriver].previousStatus;
-                    KbootDriverState.phase = KbootDriverState.status == kStatus_Success ? 2 : 0;
-                    return kStatus_Uhk_NoTransfer;
-                case 2:
-                    status = rx(10);
-                    KbootDriverState.phase++;
+                    KbootDriverState.phase = KbootDriverState.status == kStatus_Success
+                        ? KbootPhase_ReceivePingResponse
+                        : KbootPhase_SendPing;
+                    return kStatus_Uhk_IdleCycle;
+                case KbootPhase_ReceivePingResponse:
+                    status = rx(KBOOT_PACKAGE_LENGTH_PING_RESPONSE);
+                    KbootDriverState.phase = KbootPhase_CheckPingResponseStatus;
                    break;
-                case 3:
+                case KbootPhase_CheckPingResponseStatus:
                    KbootDriverState.status = Slaves[SlaveId_KbootDriver].previousStatus;
                    if (KbootDriverState.status == kStatus_Success) {
-                        KbootDriverState.commandType = KbootCommand_Idle;
+                        KbootDriverState.command = KbootCommand_Idle;
                    } else {
-                        KbootDriverState.phase = 0;
-                        return kStatus_Uhk_NoTransfer;
+                        KbootDriverState.phase = KbootPhase_SendPing;
+                        return kStatus_Uhk_IdleCycle;
                    }
                }
            break;
        case KbootCommand_Reset:
            switch (KbootDriverState.phase) {
-                case 0:
+                case KbootPhase_SendReset:
                    status = tx(resetCommand, sizeof(resetCommand));
-                    KbootDriverState.phase++;
+                    KbootDriverState.phase = KbootPhase_ReceiveResetAck;
                    break;
-                case 1:
-                    status = rx(2);
-                    KbootDriverState.phase++;
+                case KbootPhase_ReceiveResetAck:
+                    status = rx(KBOOT_PACKAGE_LENGTH_ACK);
+                    KbootDriverState.phase = KbootPhase_ReceiveResetGenericResponse;
                    break;
-                case 2:
-                    status = rx(18);
-                    KbootDriverState.phase++;
+                case KbootPhase_ReceiveResetGenericResponse:
+                    status = rx(KBOOT_PACKAGE_LENGTH_GENERIC_RESPONSE);
+                    KbootDriverState.phase = KbootPhase_CheckResetSendAck;
                    break;
-                case 3:
+                case KbootPhase_CheckResetSendAck:
                    status = tx(ackMessage, sizeof(ackMessage));
-                    KbootDriverState.commandType = KbootCommand_Idle;
+                    KbootDriverState.command = KbootCommand_Idle;
                    break;
            }
            break;
--- a/right/src/slave_drivers/kboot_driver.h
+++ b/right/src/slave_drivers/kboot_driver.h
@@ -7,7 +7,10 @@

 // Macros:

-    #define MAX_KBOOT_COMMAND_LENGTH 32
+    #define KBOOT_PACKAGE_MAX_LENGTH 32
+    #define KBOOT_PACKAGE_LENGTH_PING_RESPONSE 10
+    #define KBOOT_PACKAGE_LENGTH_ACK 2
+    #define KBOOT_PACKAGE_LENGTH_GENERIC_RESPONSE 18

 // Typedefs:

@@ -21,8 +24,22 @@
        KbootCommand_Reset,
    } kboot_command_t;

+    typedef enum {
+        KbootPhase_SendPing,
+        KbootPhase_CheckPingStatus,
+        KbootPhase_ReceivePingResponse,
+        KbootPhase_CheckPingResponseStatus,
+    } kboot_ping_phase_t;
+
+    typedef enum {
+        KbootPhase_SendReset,
+        KbootPhase_ReceiveResetAck,
+        KbootPhase_ReceiveResetGenericResponse,
+        KbootPhase_CheckResetSendAck,
+    } kboot_reset_phase_t;
+
    typedef struct {
-        kboot_command_t commandType;
+        kboot_command_t command;
        uint8_t i2cAddress;
        uint8_t phase;
        uint32_t status;
--- a/right/src/slave_drivers/uhk_module_driver.c
+++ b/right/src/slave_drivers/uhk_module_driver.c
@@ -69,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;
@@ -84,32 +91,54 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
        case UhkModulePhase_ProcessSync: {
            bool isMessageValid = CRC16_IsMessageValid(rxMessage);
            bool isSyncValid = memcmp(rxMessage->data, SlaveSyncString, SLAVE_SYNC_STRING_LENGTH) == 0;
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
            *uhkModulePhase = isSyncValid && isMessageValid
-                ? UhkModulePhase_RequestProtocolVersion
+                ? UhkModulePhase_RequestModuleProtocolVersion
                : UhkModulePhase_RequestSync;
            break;
        }

-        // Get protocol version
-        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;
+            status = kStatus_Uhk_IdleCycle;
+            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestFirmwareVersion : UhkModulePhase_RequestModuleProtocolVersion;
+            break;
+        }
+
+        // Get firmware version
+        case UhkModulePhase_RequestFirmwareVersion:
+            txMessage.data[0] = SlaveCommand_RequestProperty;
+            txMessage.data[1] = SlaveProperty_FirmwareVersion;
+            txMessage.length = 2;
+            status = tx(i2cAddress);
+            *uhkModulePhase = UhkModulePhase_ReceiveFirmwareVersion;
+            break;
+        case UhkModulePhase_ReceiveFirmwareVersion:
+            status = rx(rxMessage, i2cAddress);
+            *uhkModulePhase = UhkModulePhase_ProcessFirmwareVersion;
+            break;
+        case UhkModulePhase_ProcessFirmwareVersion: {
+            bool isMessageValid = CRC16_IsMessageValid(rxMessage);
+            if (isMessageValid) {
+                memcpy(&uhkModuleState->firmwareVersion, rxMessage->data, sizeof(version_t));
+            }
+            status = kStatus_Uhk_IdleCycle;
+            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModuleId : UhkModulePhase_RequestFirmwareVersion;
            break;
        }

@@ -130,30 +159,52 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
            if (isMessageValid) {
                uhkModuleState->moduleId = rxMessage->data[0];
            }
-            status = kStatus_Uhk_NoTransfer;
-            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModuleFeatures : UhkModulePhase_RequestModuleId;
+            status = kStatus_Uhk_IdleCycle;
+            *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;
+            status = kStatus_Uhk_IdleCycle;
+            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModulePointerCount : UhkModulePhase_RequestModuleKeyCount;
+            break;
+        }
+
+        // Get module pointer count
+        case UhkModulePhase_RequestModulePointerCount:
+            txMessage.data[0] = SlaveCommand_RequestProperty;
+            txMessage.data[1] = SlaveProperty_PointerCount;
+            txMessage.length = 2;
+            status = tx(i2cAddress);
+            *uhkModulePhase = UhkModulePhase_ReceiveModulePointerCount;
+            break;
+        case UhkModulePhase_ReceiveModulePointerCount:
+            status = rx(rxMessage, i2cAddress);
+            *uhkModulePhase = UhkModulePhase_ProcessModulePointerCount;
+            break;
+        case UhkModulePhase_ProcessModulePointerCount: {
+            bool isMessageValid = CRC16_IsMessageValid(rxMessage);
+            if (isMessageValid) {
+                uhkModuleState->pointerCount = rxMessage->data[0];
+            }
+            status = kStatus_Uhk_IdleCycle;
+            *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestKeyStates : UhkModulePhase_RequestModulePointerCount;
            break;
        }

@@ -171,32 +222,19 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
        case UhkModulePhase_ProcessKeystates:
            if (CRC16_IsMessageValid(rxMessage)) {
                uint8_t slotId = uhkModuleDriverId + 1;
-                BoolBitsToBytes(rxMessage->data, keyStatesBuffer, uhkModuleState->features.keyCount);
-                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;
-            }
+            status = kStatus_Uhk_IdleCycle;
            *uhkModulePhase = UhkModulePhase_SetTestLed;
            break;

        // Set test LED
        case UhkModulePhase_SetTestLed:
            if (uhkModuleSourceVars->isTestLedOn == uhkModuleTargetVars->isTestLedOn) {
-                status = kStatus_Uhk_NoTransfer;
+                status = kStatus_Uhk_IdleCycle;
            } else {
                txMessage.data[0] = SlaveCommand_SetTestLed;
                txMessage.data[1] = uhkModuleSourceVars->isTestLedOn;
@@ -210,7 +248,7 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
        // Set PWM brightness
        case UhkModulePhase_SetLedPwmBrightness:
            if (uhkModuleSourceVars->ledPwmBrightness == uhkModuleTargetVars->ledPwmBrightness) {
-                status = kStatus_Uhk_NoTransfer;
+                status = kStatus_Uhk_IdleCycle;
            } else {
                txMessage.data[0] = SlaveCommand_SetLedPwmBrightness;
                txMessage.data[1] = uhkModuleSourceVars->ledPwmBrightness;
@@ -227,8 +265,10 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)

 void UhkModuleSlaveDriver_Disconnect(uint8_t uhkModuleDriverId)
 {
+#ifdef LED_DRIVERS_ENABLED
    if (uhkModuleDriverId == SlaveId_LeftKeyboardHalf) {
        Slaves[SlaveId_LeftLedDriver].isConnected = false;
    }
    UhkModuleStates[uhkModuleDriverId].moduleId = 0;
+#endif
 }
--- 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
@@ -6,6 +6,8 @@
 #include "slave_drivers/kboot_driver.h"
 #include "i2c.h"
 #include "i2c_addresses.h"
+#include "config.h"
+#include "i2c_error_logger.h"

 uint32_t I2cSlaveScheduler_Counter;

@@ -29,6 +31,7 @@ uhk_slave_t Slaves[] = {
        .update = UhkModuleSlaveDriver_Update,
        .perDriverId = UhkModuleDriverId_RightAddon,
    },
+#ifdef LED_DRIVERS_ENABLED
    {
        .init = LedSlaveDriver_Init,
        .update = LedSlaveDriver_Update,
@@ -39,6 +42,7 @@ uhk_slave_t Slaves[] = {
        .update = LedSlaveDriver_Update,
        .perDriverId = LedDriverId_Left,
    },
+#endif
    {
        .init = KbootSlaveDriver_Init,
        .update = KbootSlaveDriver_Update,
@@ -48,23 +52,27 @@ uhk_slave_t Slaves[] = {

 static void slaveSchedulerCallback(I2C_Type *base, i2c_master_handle_t *handle, status_t previousStatus, void *userData)
 {
-    bool isFirstIteration = true;
+    bool isFirstCycle = true;
    bool isTransferScheduled = false;
    I2cSlaveScheduler_Counter++;

    do {
-        uhk_slave_t *previousSlave = Slaves + previousSlaveId;
        uhk_slave_t *currentSlave = Slaves + currentSlaveId;

-        previousSlave->previousStatus = previousStatus;
+        if (isFirstCycle) {
+            uhk_slave_t *previousSlave = Slaves + previousSlaveId;
+            previousSlave->previousStatus = previousStatus;
+            if (IS_STATUS_I2C_ERROR(previousStatus)) {
+                LogI2cError(previousSlaveId, previousStatus);
+            }

-        if (isFirstIteration) {
            bool wasPreviousSlaveConnected = previousSlave->isConnected;
            previousSlave->isConnected = previousStatus == kStatus_Success;
            if (wasPreviousSlaveConnected && !previousSlave->isConnected && previousSlave->disconnect) {
                previousSlave->disconnect(previousSlaveId);
            }
-            isFirstIteration = false;
+
+            isFirstCycle = false;
        }

        if (!currentSlave->isConnected) {
@@ -72,18 +80,21 @@ static void slaveSchedulerCallback(I2C_Type *base, i2c_master_handle_t *handle,
        }

        status_t currentStatus = currentSlave->update(currentSlave->perDriverId);
-        isTransferScheduled = currentStatus != kStatus_Uhk_IdleSlave && currentStatus != kStatus_Uhk_NoTransfer;
+        if (IS_STATUS_I2C_ERROR(currentStatus)) {
+            LogI2cError(currentSlaveId, currentStatus);
+        }
+        isTransferScheduled = currentStatus != kStatus_Uhk_IdleSlave && currentStatus != kStatus_Uhk_IdleCycle;
        if (isTransferScheduled) {
            currentSlave->isConnected = true;
        }

-        if (currentStatus != kStatus_Uhk_NoTransfer) {
+        if (currentStatus != kStatus_Uhk_IdleCycle) {
            previousSlaveId = currentSlaveId++;
+            if (currentSlaveId >= SLAVE_COUNT) {
+                currentSlaveId = 0;
+            }
        }

-        if (currentSlaveId >= (sizeof(Slaves) / sizeof(uhk_slave_t))) {
-            currentSlaveId = 0;
-        }
    } while (!isTransferScheduled);
 }

@@ -92,7 +103,7 @@ void InitSlaveScheduler(void)
    previousSlaveId = 0;
    currentSlaveId = 0;

-    for (uint8_t i=0; i<sizeof(Slaves) / sizeof(uhk_slave_t); i++) {
+    for (uint8_t i=0; i<SLAVE_COUNT; i++) {
        uhk_slave_t *currentSlave = Slaves + i;
        currentSlave->isConnected = false;
    }
--- a/right/src/slave_scheduler.h
+++ b/right/src/slave_scheduler.h
@@ -4,6 +4,14 @@
 // Includes:

    #include "fsl_common.h"
+    #include "config.h"
+
+// Macros:
+
+    #define SLAVE_COUNT (sizeof(Slaves) / sizeof(uhk_slave_t))
+    #define MAX_SLAVE_COUNT 6
+    #define IS_VALID_SLAVE_ID(slaveId) (0 <= slaveId && slaveId <= MAX_SLAVE_COUNT)
+    #define IS_STATUS_I2C_ERROR(status) (kStatus_I2C_Busy <= status && status <= kStatus_I2C_Timeout)

 // Typedefs:

@@ -11,8 +19,10 @@
        SlaveId_LeftKeyboardHalf,
        SlaveId_LeftAddon,
        SlaveId_RightAddon,
+#ifdef LED_DRIVERS_ENABLED
        SlaveId_RightLedDriver,
        SlaveId_LeftLedDriver,
+#endif
        SlaveId_KbootDriver,
    } slave_id_t;

@@ -30,12 +40,12 @@
    } uhk_slave_t;

    typedef enum {
-        kStatusGroup_Uhk = -1,
+        kStatusGroup_Uhk = 200,
    } uhk_status_group_t;

    typedef enum {
-        kStatus_Uhk_IdleSlave  = MAKE_STATUS(kStatusGroup_Uhk, 0), // Another slave should be scheduled
-        kStatus_Uhk_NoTransfer = MAKE_STATUS(kStatusGroup_Uhk, 1), // The same slave should be rescheduled
+        kStatus_Uhk_IdleSlave = MAKE_STATUS(kStatusGroup_Uhk, 0), // Another slave should be scheduled
+        kStatus_Uhk_IdleCycle = MAKE_STATUS(kStatusGroup_Uhk, 1), // The same slave should be rescheduled
    } uhk_status_t;

 // Variables:
--- 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/usb_commands/usb_command_get_device_property.c
+++ b/right/src/usb_commands/usb_command_get_device_property.c
@@ -0,0 +1,78 @@
+#include "fsl_common.h"
+#include "usb_commands/usb_command_get_device_property.h"
+#include "usb_protocol_handler.h"
+#include "eeprom.h"
+#include "versions.h"
+#include "slave_drivers/kboot_driver.h"
+#include "i2c.h"
+#include "init_peripherals.h"
+#include "fsl_i2c.h"
+#include "timer.h"
+
+version_t deviceProtocolVersion = {
+    DEVICE_PROTOCOL_MAJOR_VERSION,
+    DEVICE_PROTOCOL_MINOR_VERSION,
+    DEVICE_PROTOCOL_PATCH_VERSION,
+};
+
+version_t protocolVersions[] =
+{
+    {
+        FIRMWARE_MAJOR_VERSION,
+        FIRMWARE_MINOR_VERSION,
+        FIRMWARE_PATCH_VERSION,
+    },
+    {
+        DEVICE_PROTOCOL_MAJOR_VERSION,
+        DEVICE_PROTOCOL_MINOR_VERSION,
+        DEVICE_PROTOCOL_PATCH_VERSION,
+    },
+    {
+        MODULE_PROTOCOL_MAJOR_VERSION,
+        MODULE_PROTOCOL_MINOR_VERSION,
+        MODULE_PROTOCOL_PATCH_VERSION,
+    },
+    {
+        USER_CONFIG_MAJOR_VERSION,
+        USER_CONFIG_MINOR_VERSION,
+        USER_CONFIG_PATCH_VERSION,
+    },
+    {
+        HARDWARE_CONFIG_MAJOR_VERSION,
+        HARDWARE_CONFIG_MINOR_VERSION,
+        HARDWARE_CONFIG_PATCH_VERSION,
+    }
+};
+
+uint16_t configSizes[] = {HARDWARE_CONFIG_SIZE, USER_CONFIG_SIZE};
+
+void UsbCommand_GetDeviceProperty(void)
+{
+    uint8_t propertyId = GetUsbRxBufferUint8(1);
+
+    switch (propertyId) {
+        case DevicePropertyId_DeviceProtocolVersion:
+            memcpy(GenericHidOutBuffer+1, (uint8_t*)&deviceProtocolVersion, sizeof(deviceProtocolVersion));
+            break;
+        case DevicePropertyId_ProtocolVersions:
+            memcpy(GenericHidOutBuffer+1, (uint8_t*)&protocolVersions, sizeof(protocolVersions));
+            break;
+        case DevicePropertyId_ConfigSizes:
+            memcpy(GenericHidOutBuffer+1, (uint8_t*)&configSizes, sizeof(configSizes));
+            break;
+        case DevicePropertyId_CurrentKbootCommand:
+            GenericHidOutBuffer[1] = KbootDriverState.command;
+            break;
+        case DevicePropertyId_I2cMainBusBaudRate:
+            GenericHidOutBuffer[1] = I2C_MAIN_BUS_BASEADDR->F;
+            SetUsbTxBufferUint32(2, I2cMainBusRequestedBaudRateBps);
+            SetUsbTxBufferUint32(6, I2cMainBusActualBaudRateBps);
+            break;
+        case DevicePropertyId_Uptime:
+            SetUsbTxBufferUint32(1, CurrentTime);
+            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,23 @@
+#ifndef __USB_COMMAND_GET_DEVICE_PROPERTY_H__
+#define __USB_COMMAND_GET_DEVICE_PROPERTY_H__
+
+// Typedefs:
+
+    typedef enum {
+        DevicePropertyId_DeviceProtocolVersion = 0,
+        DevicePropertyId_ProtocolVersions      = 1,
+        DevicePropertyId_ConfigSizes           = 2,
+        DevicePropertyId_CurrentKbootCommand   = 3,
+        DevicePropertyId_I2cMainBusBaudRate    = 4,
+        DevicePropertyId_Uptime                = 5,
+    } device_property_t;
+
+    typedef enum {
+        UsbStatusCode_GetDeviceProperty_InvalidProperty = 2,
+    } usb_status_code_get_device_property_t;
+
+// Functions:
+
+    void UsbCommand_GetDeviceProperty(void);
+
+#endif
--- 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,26 @@
+#include "fsl_common.h"
+#include "usb_commands/usb_command_get_module_property.h"
+#include "usb_protocol_handler.h"
+#include "slot.h"
+#include "slave_drivers/uhk_module_driver.h"
+
+void UsbCommand_GetModuleProperty()
+{
+    slot_t slotId = GetUsbRxBufferUint8(1);
+
+    if (!IS_VALID_MODULE_SLOT(slotId)) {
+        SetUsbTxBufferUint8(0, UsbStatusCode_GetModuleProperty_InvalidModuleSlotId);
+    }
+
+    module_property_id_t modulePropertyId = GetUsbRxBufferUint8(2);
+    switch (modulePropertyId) {
+        case ModulePropertyId_VersionNumbers: {
+            uint8_t moduleDriverId = SLOT_ID_TO_UHK_MODULE_DRIVER_ID(slotId);
+            uhk_module_state_t *moduleState = UhkModuleStates + moduleDriverId;
+            GenericHidOutBuffer[1] = moduleState->moduleId;
+            memcpy(GenericHidOutBuffer + 2, &moduleState->moduleProtocolVersion, sizeof(version_t));
+            memcpy(GenericHidOutBuffer + 8, &moduleState->firmwareVersion, sizeof(version_t));
+            break;
+        }
+    }
+}
--- 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,18 @@
+#ifndef __USB_COMMAND_GET_MODULE_PROPERTY_H__
+#define __USB_COMMAND_GET_MODULE_PROPERTY_H__
+
+// Functions:
+
+    void UsbCommand_GetModuleProperty();
+
+// Typedefs:
+
+    typedef enum {
+        ModulePropertyId_VersionNumbers = 0,
+    } module_property_id_t;
+
+    typedef enum {
+        UsbStatusCode_GetModuleProperty_InvalidModuleSlotId = 2,
+    } usb_status_code_get_module_property_t;
+
+#endif
--- 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_get_slave_i2c_errors.c
+++ b/right/src/usb_commands/usb_command_get_slave_i2c_errors.c
@@ -0,0 +1,19 @@
+#include "fsl_common.h"
+#include "usb_commands/usb_command_get_slave_i2c_errors.h"
+#include "usb_protocol_handler.h"
+#include "slave_scheduler.h"
+#include "i2c_error_logger.h"
+
+void UsbCommand_GetSlaveI2cErrors()
+{
+    uint8_t slaveId = GetUsbRxBufferUint8(1);
+
+    if (!IS_VALID_SLAVE_ID(slaveId)) {
+        SetUsbTxBufferUint8(0, UsbStatusCode_GetModuleProperty_InvalidSlaveId);
+    }
+
+    i2c_slave_error_counter_t *i2cSlaveErrorCounter =  I2cSlaveErrorCounters + slaveId;
+
+    GenericHidOutBuffer[1] = i2cSlaveErrorCounter->errorTypeCount;
+    memcpy(GenericHidOutBuffer + 2, i2cSlaveErrorCounter->errors, sizeof(i2c_error_count_t) * MAX_LOGGED_I2C_ERROR_TYPES_PER_SLAVE);
+}
--- a/right/src/usb_commands/usb_command_get_slave_i2c_errors.h
+++ b/right/src/usb_commands/usb_command_get_slave_i2c_errors.h
@@ -0,0 +1,14 @@
+#ifndef __USB_COMMAND_GET_SLAVE_I2C_ERRORS_H__
+#define __USB_COMMAND_GET_SLAVE_I2C_ERRORS_H__
+
+// Functions:
+
+    void UsbCommand_GetSlaveI2cErrors();
+
+// Typedefs:
+
+    typedef enum {
+        UsbStatusCode_GetModuleProperty_InvalidSlaveId = 2,
+    } usb_status_code_get_slave_i2c_errors_t;
+
+#endif
--- a/right/src/usb_commands/usb_command_jump_to_module_bootloader.c
+++ b/right/src/usb_commands/usb_command_jump_to_module_bootloader.c
@@ -7,11 +7,11 @@ void UsbCommand_JumpToModuleBootloader(void)
 {
    uint8_t slotId = GetUsbRxBufferUint8(1);

-    if (!IS_VALID_SLAVE_SLOT(slotId)) {
+    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].jumpToBootloader = true;
+    UhkModuleStates[uhkModuleDriverId].phase = UhkModulePhase_JumpToBootloader;
 }
--- 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_to_module.c
+++ b/right/src/usb_commands/usb_command_send_kboot_command_to_module.c
@@ -6,5 +6,5 @@ void UsbCommand_SendKbootCommandToModule(void)
 {
    KbootDriverState.phase = 0;
    KbootDriverState.i2cAddress  = GetUsbRxBufferUint8(2);
-    KbootDriverState.commandType = GetUsbRxBufferUint8(1); // Command should be set last.
+    KbootDriverState.command = GetUsbRxBufferUint8(1); // Command should be set last.
 }
--- a/right/src/usb_commands/usb_command_set_i2c_baud_rate.c
+++ b/right/src/usb_commands/usb_command_set_i2c_baud_rate.c
@@ -0,0 +1,11 @@
+#include "usb_protocol_handler.h"
+#include "usb_commands/usb_command_set_i2c_baud_rate.h"
+#include "init_peripherals.h"
+#include "fsl_i2c.h"
+
+void UsbCommand_SetI2cBaudRate(void)
+{
+    uint32_t i2cBaudRate = GetUsbRxBufferUint32(1);
+    I2cMainBusRequestedBaudRateBps = i2cBaudRate;
+    ReinitI2cMainBus();
+}
--- a/right/src/usb_commands/usb_command_set_i2c_baud_rate.h
+++ b/right/src/usb_commands/usb_command_set_i2c_baud_rate.h
@@ -0,0 +1,8 @@
+#ifndef __USB_COMMAND_SET_I2C_BAUD_RATE__
+#define __USB_COMMAND_SET_I2C_BAUD_RATE__
+
+// Functions:
+
+    void UsbCommand_SetI2cBaudRate(void);
+
+#endif
--- 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_protocol_handler.c
+++ b/right/src/usb_protocol_handler.c
@@ -1,69 +1,78 @@
 #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_module_bootloader.h"
 #include "usb_commands/usb_command_send_kboot_command_to_module.h"
+#include "usb_commands/usb_command_get_slave_i2c_errors.h"
+#include "usb_commands/usb_command_set_i2c_baud_rate.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();
-            break;
-        case UsbCommandId_WriteUserConfig:
-            UsbCommand_WriteConfig(false);
-            break;
-        case UsbCommandId_ApplyConfig:
-            UsbCommand_ApplyConfig();
-            break;
-        case UsbCommandId_SetLedPwmBrightness:
-            UsbCommand_SetLedPwmBrightness();
-            break;
-        case UsbCommandId_GetAdcValue:
-            UsbCommand_GetAdcValue();
-            break;
-        case UsbCommandId_LaunchEepromTransferLegacy:
-            UsbCommand_LaunchEepromTransferLegacy();
-            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_GetDebugBuffer:
-            UsbCommand_GetDebugBuffer();
-            break;
        case UsbCommandId_JumpToModuleBootloader:
            UsbCommand_JumpToModuleBootloader();
            break;
        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_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_SetLedPwmBrightness:
+            UsbCommand_SetLedPwmBrightness();
+            break;
+        case UsbCommandId_GetModuleProperty:
+            UsbCommand_GetModuleProperty();
+            break;
+        case UsbCommandId_GetSlaveI2cErrors:
+            UsbCommand_GetSlaveI2cErrors();
+            break;
+        case UsbCommandId_SetI2cBaudRate:
+            UsbCommand_SetI2cBaudRate();
+            break;
        default:
            SetUsbTxBufferUint8(0, UsbStatusCode_InvalidCommand);
            break;
--- a/right/src/usb_protocol_handler.h
+++ b/right/src/usb_protocol_handler.h
@@ -13,21 +13,26 @@
 // Typedefs:

    typedef enum {
-        UsbCommandId_GetProperty                = 0x00,
-        UsbCommandId_Reenumerate                = 0x01,
-        UsbCommandId_SetTestLed                 = 0x02,
-        UsbCommandId_WriteUserConfig            = 0x08,
-        UsbCommandId_ApplyConfig                = 0x09,
-        UsbCommandId_SetLedPwmBrightness        = 0x0A,
-        UsbCommandId_GetAdcValue                = 0x0B,
-        UsbCommandId_LaunchEepromTransferLegacy = 0x0C,
-        UsbCommandId_ReadHardwareConfig         = 0x0D,
-        UsbCommandId_WriteHardwareConfig        = 0x0E,
-        UsbCommandId_ReadUserConfig             = 0x0F,
-        UsbCommandId_GetKeyboardState           = 0x10,
-        UsbCommandId_GetDebugBuffer             = 0x11,
-        UsbCommandId_JumpToModuleBootloader     = 0x12,
-        UsbCommandId_SendKbootCommandToModule   = 0x13,
+        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,
+        UsbCommandId_GetSlaveI2cErrors        = 0x0f,
+        UsbCommandId_SetI2cBaudRate           = 0x10,
    } usb_command_id_t;

    typedef enum {
--- a/right/src/usb_report_updater.c
+++ b/right/src/usb_report_updater.c
@@ -21,6 +21,7 @@ uint32_t UsbReportUpdateTime = 0;
 static uint32_t elapsedTime;

 uint16_t DoubleTapSwitchLayerTimeout = 250;
+uint16_t DoubleTapSwitchLayerReleaseTimeout = 100;

 static bool activeMouseStates[ACTIVE_MOUSE_STATES_COUNT];

@@ -99,15 +100,21 @@ void processMouseKineticState(mouse_kinetic_state_t *kineticState)

        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;
@@ -115,15 +122,20 @@ void processMouseKineticState(mouse_kinetic_state_t *kineticState)
        kineticState->xSum = xSumFrac;
        kineticState->xOut = xSumInt;

-        if (kineticState->isScroll && !kineticState->wasMoveAction && kineticState->xOut == 0) {
+        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;
@@ -131,7 +143,7 @@ void processMouseKineticState(mouse_kinetic_state_t *kineticState)
        kineticState->ySum = ySumFrac;
        kineticState->yOut = ySumInt;

-        if (kineticState->isScroll && !kineticState->wasMoveAction && kineticState->yOut == 0) {
+        if (kineticState->isScroll && !kineticState->wasMoveAction && kineticState->yOut == 0 && verticalMovement) {
            kineticState->yOut = kineticState->ySum > 0 ? 1 : -1;
            kineticState->ySum = 0;
        }
@@ -180,11 +192,13 @@ 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)
 {
+    static key_state_t *doubleTapSwitchLayerKey;
+    static uint32_t doubleTapSwitchLayerStartTime;
+    static uint32_t doubleTapSwitchLayerTriggerTime;
+
    if (keyState->suppressed) {
        return;
    }
@@ -222,16 +236,20 @@ void applyKeyAction(key_state_t *keyState, key_action_t *action)
            activeMouseStates[action->mouseAction] = true;
            break;
        case KeyActionType_SwitchLayer:
+            if (keyState->previous && doubleTapSwitchLayerKey == keyState &&
+                Timer_GetElapsedTime(&doubleTapSwitchLayerTriggerTime) > DoubleTapSwitchLayerReleaseTimeout)
+            {
+                ToggledLayer = LayerId_Base;
+            }
+
            if (!keyState->previous && previousLayer == LayerId_Base && action->switchLayer.mode == SwitchLayerMode_HoldAndDoubleTapToggle) {
-                if (doubleTapSwitchLayerKey) {
-                    if (Timer_GetElapsedTimeAndSetCurrent(&doubleTapSwitchLayerStartTime) < DoubleTapSwitchLayerTimeout) {
-                        ToggledLayer = action->switchLayer.layer;
-                    }
-                    doubleTapSwitchLayerKey = NULL;
+                if (doubleTapSwitchLayerKey && Timer_GetElapsedTimeAndSetCurrent(&doubleTapSwitchLayerStartTime) < DoubleTapSwitchLayerTimeout) {
+                    ToggledLayer = action->switchLayer.layer;
+                    doubleTapSwitchLayerTriggerTime = CurrentTime;
                } else {
                    doubleTapSwitchLayerKey = keyState;
-                    doubleTapSwitchLayerStartTime = CurrentTime;
                }
+                doubleTapSwitchLayerStartTime = CurrentTime;
            }
            break;
        case KeyActionType_SwitchKeymap:
--- 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": "5.0.1",
-  "dataModelVersion": "4.0.0",
-  "usbProtocolVersion": "2.0.0",
-  "slaveProtocolVersion": "3.0.0",
+  "firmwareVersion": "8.1.1",
+  "deviceProtocolVersion": "4.2.0",
+  "moduleProtocolVersion": "4.0.0",
+  "userConfigVersion": "4.0.0",
+  "hardwareConfigVersion": "1.0.0",
  "devices": [
    {
      "deviceId": 1,
--- 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 1
+    #define FIRMWARE_PATCH_VERSION 1
+
+    #define DEVICE_PROTOCOL_MAJOR_VERSION 4
+    #define DEVICE_PROTOCOL_MINOR_VERSION 2
+    #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	6881f8e340	Update versions.h to 8.1.1	2018-02-11 04:23:31 +01:00
László Monda	00cd1f65e8	Bump version to 8.1.1. Update package.json and the changelog.	2018-02-11 04:21:49 +01:00
László Monda	2c9a6c0bd2	Add doubleTapSwitchLayerReleaseTimeout and set it to 100ms. Resolves #79 .	2018-02-11 04:09:15 +01:00
László Monda	0c94cbb256	Make doubleTapSwitchLayerKey and doubleTapSwitchLayerStartTime static.	2018-02-11 03:29:15 +01:00
László Monda	275bfee860	Merge branch 'master' of github.com:UltimateHackingKeyboard/firmware	2018-02-10 23:55:48 +01:00
László Monda	8a655e3cfd	Lock layers every time when double-tapping their layer switcher keys. Fixes #81 .	2018-02-10 23:53:35 +01:00
László Monda	8521619783	Update README.md	2018-02-05 02:24:10 +01:00
László Monda	62184240df	Update README.md	2018-02-05 02:03:56 +01:00
László Monda	0b210ac68e	Update README.md	2018-02-01 18:39:20 +01:00
László Monda	56f7753afc	Bump firmware version to 8.1.0 and update changelog, package.json, and versions.h	2018-01-15 10:35:22 +01:00
László Monda	a0803875c4	Make UsbCommand_GetModuleProperty() branch based on modulePropertyId	2018-01-15 00:04:22 +01:00
László Monda	f5716bdadc	Rename some private functions in init_peripherals.c from upper to lower camel case.	2018-01-14 20:30:46 +01:00
László Monda	b76b3c0e4f	Slow down main bus I2C baud rate to 30kHz when BusPal is on to make firmware transfer more robust.	2018-01-14 20:27:17 +01:00
László Monda	2661c3d909	Implement DevicePropertyId_Uptime	2018-01-14 18:32:18 +01:00
László Monda	c854e98d84	Implement DevicePropertyId_I2cMainBusBaudRate	2018-01-14 18:10:04 +01:00
László Monda	72d8e49717	Make UsbProtocolHandler() invoke UsbCommand_SetI2cBaudRate() when requested.	2018-01-13 19:54:48 +01:00
László Monda	0fd95b71b2	Add usb_command_set_i2c_baud_rate.[ch]	2018-01-13 03:54:06 +01:00
László Monda	4d83bc2e75	Add I2cMainBusBaudRateBps	2018-01-13 03:29:01 +01:00
László Monda	cf7b05ab72	Make InitI2cMainBus() private.	2018-01-13 03:21:12 +01:00
László Monda	055f1945d0	Include slave_scheduler.h from init_peripherals.c instead of i2c_watchdog.c which I forgot to do in the previous commit.	2018-01-13 03:19:24 +01:00
László Monda	fa4a3abf84	Extract ReinitI2cMainBus()	2018-01-13 03:14:42 +01:00
László Monda	96c7ccd758	Remove some dead code from PIT_I2C_WATCHDOG_HANDLER	2018-01-13 03:03:42 +01:00
László Monda	76d319ec19	Remove comment that says that 100 kHz works with a 20 meter long bridge cable. It was true for UART, not so much for I2C.	2018-01-11 23:44:59 +01:00
László Monda	aab0e8473f	Enable left half I2C watchdog in reinit mode because it seems to improve things.	2018-01-11 23:43:34 +01:00
László Monda	4a4c471b9e	Implement DevicePropertyId_CurrentKbootCommand	2018-01-10 02:58:31 +01:00
László Monda	fcd75b2af2	Use identifiers instead of the magic numbers of kboot_driver.[ch]	2018-01-06 21:21:36 +01:00
László Monda	f318c6872e	Move the definition of previousSlave within the if (isFirstCycle) block.	2018-01-06 17:25:07 +01:00
László Monda	ae1240c103	Rename isFirstIteration to isFirstCycle and kStatus_Uhk_NoTransfer to kStatus_Uhk_IdleCycle.	2018-01-06 17:05:37 +01:00
László Monda	e75d366245	Update and log previous I2C status within the if (isFirstIteration) block.	2018-01-06 17:00:59 +01:00
László Monda	da20cdacc4	Only check currentSlaveId overrun after incrementing it.	2018-01-06 16:36:57 +01:00
László Monda	5a986d367e	Only call LogI2cError() if the passed status is an actual I2C error, otherwise it slows the mouse pointer down.	2018-01-06 02:04:47 +01:00
László Monda	f6b66283a7	Only count I2C errors.	2018-01-06 01:37:58 +01:00
László Monda	6ad425cbf9	Log I2C error counts on a per slave and per error type basis and expose them via USB.	2018-01-05 03:23:48 +01:00
László Monda	33e501cd83	Add SLAVE_COUNT	2018-01-04 23:16:48 +01:00
László Monda	fa558abef3	Add LED_DRIVERS_ENABLED	2017-12-28 00:08:29 +01:00
László Monda	25a2b3af93	Convert tabs to spaces.	2017-12-27 17:21:28 +01:00
László Monda	43587c2e1f	Define I2C_WATCHDOG_VALUE_REINIT and I2C_WATCHDOG_VALUE_REBOOT and make them work when assigned to I2C_WATCHDOG.	2017-12-27 17:07:04 +01:00
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