Bump firmware version to 8.3.2. Update changelog, package.json and versions.h

Fix key chattering

CHANGELOG.md

@@ -5,6 +5,36 @@ 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.3.2] - 2018-06-27
+
+Device Protocol: 4.3.1 | Module Protocol: 4.0.0 | User Config: 4.1.0 | Hardware Config: 1.0.0
+
+- Make the debouncer debounce not only on key presses but also on key releases, and change the debounce interval from 100ms to the suggested 5ms of MX switches.
+- Revert the Windows related commits of firmware 8.3.1 because they introduced a nondeterministic bug that made USB hang.
+- Add base layer key mappings for the left and right add-ons for testing purposes.
+
+## [8.3.1] - 2018-06-07
+
+Device Protocol: 4.3.1 | Module Protocol: 4.0.0 | User Config: 4.1.0 | Hardware Config: 1.0.0
+
+- Fix media key repetition bug on Windows.
+- Fix bug that made Windows unable to sleep when the UHK was plugged in.
+- Fix bug that made Chrome Remote Desktop blocked from interacting on Windows.
+- Fix bug that made locked layers not release. This bug was introduced in the previous release.
+
+## [8.3.0] - 2018-06-03
+
+Device Protocol: 4.3.1 | Module Protocol: 4.0.0 | User Config: 4.**1.0** | Hardware Config: 1.0.0
+
+- Make the config parser handle switch layer actions with hold on double tap disabled. `USERCONFIG:MINOR`
+- Set key debounce timeout from 80ms to 100ms. This should further reduce key chattering.
+
+## [8.2.5] - 2018-05-27
+
+Device Protocol: 4.3.1 | Module Protocol: 4.0.0 | User Config: 4.0.1 | Hardware Config: 1.0.0
+
+- Now really fix the bug that made the hardware and user configuration not load from the EEPROM on some hosts right after firmware update.
+
 ## [8.2.4] - 2018-05-21
 
 Device Protocol: 4.3.**1** | Module Protocol: 4.0.0 | User Config: 4.0.1 | Hardware Config: 1.0.0

right/src/config_parser/parse_keymap.c

@@ -48,7 +48,7 @@ static parser_error_t parseKeyStrokeAction(key_action_t *keyAction, uint8_t keyS
 static parser_error_t parseSwitchLayerAction(key_action_t *KeyAction, config_buffer_t *buffer)
 {
     uint8_t layer = ReadUInt8(buffer) + 1;
-    uint8_t mode = ReadBool(buffer) ? SwitchLayerMode_Toggle : SwitchLayerMode_HoldAndDoubleTapToggle;
+    switch_layer_mode_t mode = ReadUInt8(buffer);
 
     KeyAction->type = KeyActionType_SwitchLayer;
     KeyAction->switchLayer.layer = layer;

right/src/i2c.h

@@ -35,10 +35,12 @@
     #define I2C_EEPROM_BUS_BAUD_RATE 1000000  // 1 Mhz is the maximum speed of the EEPROM.
     #define I2C_EEPROM_BUS_MUX       kPORT_MuxAlt2
 
+    #define I2C_EEPROM_BUS_SDA_GPIO  GPIOC
     #define I2C_EEPROM_BUS_SDA_PORT  PORTC
     #define I2C_EEPROM_BUS_SDA_CLOCK kCLOCK_PortC
     #define I2C_EEPROM_BUS_SDA_PIN   11
 
+    #define I2C_EEPROM_BUS_SCL_GPIO  GPIOC
     #define I2C_EEPROM_BUS_SCL_PORT  PORTC
     #define I2C_EEPROM_BUS_SCL_CLOCK kCLOCK_PortC
     #define I2C_EEPROM_BUS_SCL_PIN   10

right/src/init_peripherals.c

@@ -21,6 +21,38 @@ bool IsBusPalOn;
 volatile uint32_t I2cMainBusRequestedBaudRateBps = I2C_MAIN_BUS_NORMAL_BAUD_RATE;
 volatile uint32_t I2cMainBusActualBaudRateBps;
 
+static i2c_bus_t i2cMainBus = {
+    .baseAddr = I2C_MAIN_BUS_BASEADDR,
+    .clockSrc = I2C_MAIN_BUS_CLK_SRC,
+    .mux = I2C_MAIN_BUS_MUX,
+
+    .sdaClock = I2C_MAIN_BUS_SDA_CLOCK,
+    .sdaGpio = I2C_MAIN_BUS_SDA_GPIO,
+    .sdaPort = I2C_MAIN_BUS_SDA_PORT,
+    .sdaPin = I2C_MAIN_BUS_SDA_PIN,
+
+    .sclClock = I2C_MAIN_BUS_SCL_CLOCK,
+    .sclGpio = I2C_MAIN_BUS_SCL_GPIO,
+    .sclPort = I2C_MAIN_BUS_SCL_PORT,
+    .sclPin = I2C_MAIN_BUS_SCL_PIN,
+};
+
+static i2c_bus_t i2cEepromBus = {
+    .baseAddr = I2C_EEPROM_BUS_BASEADDR,
+    .clockSrc = I2C_EEPROM_BUS_CLK_SRC,
+    .mux = I2C_EEPROM_BUS_MUX,
+
+    .sdaClock = I2C_EEPROM_BUS_SDA_CLOCK,
+    .sdaGpio = I2C_EEPROM_BUS_SDA_GPIO,
+    .sdaPort = I2C_EEPROM_BUS_SDA_PORT,
+    .sdaPin = I2C_EEPROM_BUS_SDA_PIN,
+
+    .sclClock = I2C_EEPROM_BUS_SCL_CLOCK,
+    .sclGpio = I2C_EEPROM_BUS_SCL_GPIO,
+    .sclPort = I2C_EEPROM_BUS_SCL_PORT,
+    .sclPin = I2C_EEPROM_BUS_SCL_PIN,
+};
+
 static void initBusPalState(void) {
     IsBusPalOn = Wormhole.magicNumber == WORMHOLE_MAGIC_NUMBER && Wormhole.enumerationMode == EnumerationMode_BusPal;
     if (IsBusPalOn) {
@@ -32,12 +64,12 @@ static void initBusPalState(void) {
 static void initInterruptPriorities(void)
 {
     NVIC_SetPriority(PIT_I2C_WATCHDOG_IRQ_ID,  1);
-    NVIC_SetPriority(PIT_TIMER_IRQ_ID,         2);
+    NVIC_SetPriority(I2C_EEPROM_BUS_IRQ_ID,    0);
-    NVIC_SetPriority(I2C_EEPROM_BUS_IRQ_ID,    2);
+    NVIC_SetPriority(PIT_TIMER_IRQ_ID,         3);
-    NVIC_SetPriority(PIT_KEY_SCANNER_IRQ_ID,   3);
+    NVIC_SetPriority(PIT_KEY_SCANNER_IRQ_ID,   4);
-    NVIC_SetPriority(PIT_KEY_DEBOUNCER_IRQ_ID, 3);
+    NVIC_SetPriority(PIT_KEY_DEBOUNCER_IRQ_ID, 4);
-    NVIC_SetPriority(I2C_MAIN_BUS_IRQ_ID,      3);
+    NVIC_SetPriority(I2C_MAIN_BUS_IRQ_ID,      4);
-    NVIC_SetPriority(USB_IRQ_ID,               3);
+    NVIC_SetPriority(USB_IRQ_ID,               4);
 }
 
 static void delay(void)
@@ -45,91 +77,73 @@ static void delay(void)
     for (volatile uint32_t i=0; i<62; i++);
 }
 
-static void recoverI2c(void)
+static void recoverI2cBus(i2c_bus_t *i2cBus)
 {
-    PORT_SetPinMux(I2C_MAIN_BUS_SDA_PORT, I2C_MAIN_BUS_SDA_PIN, kPORT_MuxAsGpio);
+    PORT_SetPinMux(i2cBus->sdaPort, i2cBus->sdaPin, kPORT_MuxAsGpio);
-    PORT_SetPinMux(I2C_MAIN_BUS_SCL_PORT, I2C_MAIN_BUS_SCL_PIN, kPORT_MuxAsGpio);
+    PORT_SetPinMux(i2cBus->sclPort, i2cBus->sclPin, kPORT_MuxAsGpio);
-    GPIO_PinInit(I2C_MAIN_BUS_SCL_GPIO, I2C_MAIN_BUS_SCL_PIN, &(gpio_pin_config_t){kGPIO_DigitalOutput, 1});
+    GPIO_PinInit(i2cBus->sclGpio, i2cBus->sclPin, &(gpio_pin_config_t){kGPIO_DigitalOutput, 1});
 
     bool isOn = true;
     for (int i=0; i<20; i++) {
-        GPIO_PinInit(I2C_MAIN_BUS_SDA_GPIO, I2C_MAIN_BUS_SDA_PIN, &(gpio_pin_config_t){kGPIO_DigitalInput});
+        GPIO_PinInit(i2cBus->sdaGpio, i2cBus->sdaPin, &(gpio_pin_config_t){kGPIO_DigitalInput});
-        bool isSdaHigh = GPIO_ReadPinInput(I2C_MAIN_BUS_SDA_GPIO, I2C_MAIN_BUS_SDA_PIN);
+        bool isSdaHigh = GPIO_ReadPinInput(i2cBus->sdaGpio, i2cBus->sdaPin);
-        GPIO_PinInit(I2C_MAIN_BUS_SDA_GPIO, I2C_MAIN_BUS_SDA_PIN, &(gpio_pin_config_t){kGPIO_DigitalOutput, 1});
+        GPIO_PinInit(i2cBus->sdaGpio, i2cBus->sdaPin, &(gpio_pin_config_t){kGPIO_DigitalOutput, 1});
 
         if (isSdaHigh) {
             return;
         }
 
-        GPIO_WritePinOutput(I2C_MAIN_BUS_SCL_GPIO, I2C_MAIN_BUS_SCL_PIN, isOn);
+        GPIO_WritePinOutput(i2cBus->sclGpio, i2cBus->sclPin, isOn);
         delay();
         isOn = !isOn;
     }
 
-    GPIO_WritePinOutput(I2C_MAIN_BUS_SDA_GPIO, I2C_MAIN_BUS_SDA_PIN, 0);
+    GPIO_WritePinOutput(i2cBus->sdaGpio, i2cBus->sdaPin, 0);
     delay();
-    GPIO_WritePinOutput(I2C_MAIN_BUS_SCL_GPIO, I2C_MAIN_BUS_SCL_PIN, 1);
+    GPIO_WritePinOutput(i2cBus->sclGpio, i2cBus->sclPin, 1);
     delay();
-    GPIO_WritePinOutput(I2C_MAIN_BUS_SDA_GPIO, I2C_MAIN_BUS_SDA_PIN, 1);
+    GPIO_WritePinOutput(i2cBus->sdaGpio, i2cBus->sdaPin, 1);
     delay();
 }
 
-static void initI2cMainBus(void)
+static void initI2cBus(i2c_bus_t *i2cBus)
 {
-    CLOCK_EnableClock(I2C_MAIN_BUS_SDA_CLOCK);
+    CLOCK_EnableClock(i2cBus->sdaClock);
-    CLOCK_EnableClock(I2C_MAIN_BUS_SCL_CLOCK);
+    CLOCK_EnableClock(i2cBus->sclClock);
 
-    recoverI2c();
+    recoverI2cBus(i2cBus);
 
     port_pin_config_t pinConfig = {
         .pullSelect = kPORT_PullUp,
         .openDrainEnable = kPORT_OpenDrainEnable,
-        .mux = I2C_MAIN_BUS_MUX,
+        .mux = i2cBus->mux,
     };
 
-    PORT_SetPinConfig(I2C_MAIN_BUS_SDA_PORT, I2C_MAIN_BUS_SDA_PIN, &pinConfig);
+    PORT_SetPinConfig(i2cBus->sdaPort, i2cBus->sdaPin, &pinConfig);
-    PORT_SetPinConfig(I2C_MAIN_BUS_SCL_PORT, I2C_MAIN_BUS_SCL_PIN, &pinConfig);
+    PORT_SetPinConfig(i2cBus->sclPort, i2cBus->sclPin, &pinConfig);
 
     i2c_master_config_t masterConfig;
     I2C_MasterGetDefaultConfig(&masterConfig);
-    masterConfig.baudRate_Bps = I2cMainBusRequestedBaudRateBps;
+    masterConfig.baudRate_Bps = i2cBus == &i2cMainBus ? I2cMainBusRequestedBaudRateBps : I2C_EEPROM_BUS_BAUD_RATE;
-    uint32_t sourceClock = CLOCK_GetFreq(I2C_MAIN_BUS_CLK_SRC);
+    uint32_t sourceClock = CLOCK_GetFreq(i2cBus->clockSrc);
-    I2C_MasterInit(I2C_MAIN_BUS_BASEADDR, &masterConfig, sourceClock);
+    I2C_MasterInit(i2cBus->baseAddr, &masterConfig, sourceClock);
-    I2cMainBusActualBaudRateBps = I2C_ActualBaudRate;
+
+    if (i2cBus == &i2cMainBus) {
+        I2cMainBusActualBaudRateBps = I2C_ActualBaudRate;
+    }
 }
 
 void ReinitI2cMainBus(void)
 {
     I2C_MasterDeinit(I2C_MAIN_BUS_BASEADDR);
-    initI2cMainBus();
+    initI2cBus(&i2cMainBus);
     InitSlaveScheduler();
 }
 
-static void initI2cEepromBus(void)
-{
-    port_pin_config_t pinConfig = {
-       .pullSelect = kPORT_PullUp,
-       .openDrainEnable = kPORT_OpenDrainEnable,
-       .mux = I2C_EEPROM_BUS_MUX,
-   };
-
-   CLOCK_EnableClock(I2C_EEPROM_BUS_SDA_CLOCK);
-   CLOCK_EnableClock(I2C_EEPROM_BUS_SCL_CLOCK);
-
-   PORT_SetPinConfig(I2C_EEPROM_BUS_SDA_PORT, I2C_EEPROM_BUS_SDA_PIN, &pinConfig);
-   PORT_SetPinConfig(I2C_EEPROM_BUS_SCL_PORT, I2C_EEPROM_BUS_SCL_PIN, &pinConfig);
-
-   i2c_master_config_t masterConfig;
-   I2C_MasterGetDefaultConfig(&masterConfig);
-   masterConfig.baudRate_Bps = I2C_EEPROM_BUS_BAUD_RATE;
-   uint32_t sourceClock = CLOCK_GetFreq(I2C_EEPROM_BUS_CLK_SRC);
-   I2C_MasterInit(I2C_EEPROM_BUS_BASEADDR, &masterConfig, sourceClock);
-}
-
 static void initI2c(void)
 {
-    initI2cMainBus();
+    initI2cBus(&i2cMainBus);
-    initI2cEepromBus();
+    initI2cBus(&i2cEepromBus);
 }
 
 void InitPeripherals(void)

right/src/init_peripherals.h

@@ -1,10 +1,28 @@
 #ifndef __INIT_PERIPHERALS_H__
 #define __INIT_PERIPHERALS_H__
 
-// Includes
+// Includes:
 
     #include "fsl_common.h"
 
+// Typedefs:
+
+    typedef struct {
+        clock_name_t clockSrc;
+        I2C_Type *baseAddr;
+        uint16_t mux;
+
+        clock_ip_name_t sdaClock;
+        GPIO_Type *sdaGpio;
+        PORT_Type *sdaPort;
+        uint32_t sdaPin;
+
+        clock_ip_name_t sclClock;
+        GPIO_Type *sclGpio;
+        PORT_Type *sclPort;
+        uint32_t sclPin;
+    } i2c_bus_t;
+
 // Variables:
 
     extern bool IsBusPalOn;

right/src/key_action.h

@@ -28,9 +28,9 @@
     } keystroke_type_t;
 
     typedef enum {
-        SwitchLayerMode_Hold,
         SwitchLayerMode_HoldAndDoubleTapToggle,
         SwitchLayerMode_Toggle,
+        SwitchLayerMode_Hold,
     } switch_layer_mode_t;
 
     typedef enum {

right/src/key_debouncer.c

@@ -11,8 +11,8 @@ void PIT_KEY_DEBOUNCER_HANDLER(void)
     for (uint8_t slotId=0; slotId<SLOT_COUNT; slotId++) {
         for (uint8_t keyId=0; keyId<MAX_KEY_COUNT_PER_MODULE; keyId++) {
             uint8_t *debounceCounter = &KeyStates[slotId][keyId].debounceCounter;
-            if (*debounceCounter < 0xff) {
+            if (*debounceCounter) {
-                (*debounceCounter)++;
+                --(*debounceCounter);
             }
         }
     }

right/src/key_debouncer.h

@@ -9,7 +9,7 @@
 // Macros:
 
     #define KEY_DEBOUNCER_INTERVAL_MSEC 1
-    #define KEY_DEBOUNCER_TIMEOUT_MSEC 80
+    #define KEY_DEBOUNCER_TIMEOUT_MSEC 5
 
 // Functions:
 

right/src/keymap.c

@@ -128,6 +128,102 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
             { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_V }},
             { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_B }},
 
+            // Row 5
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_LEFT_CONTROL }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_LEFT_GUI }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_LEFT_ALT }},
+            { .type = KeyActionType_SwitchLayer, .switchLayer = { .layer = LayerId_Fn }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_SPACE }},
+            { .type = KeyActionType_SwitchLayer, .switchLayer = { .layer = LayerId_Mod }},
+            { .type = KeyActionType_None },
+        },
+
+        // Left module
+        {
+            // Row 1
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_GRAVE_ACCENT_AND_TILDE }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_1_AND_EXCLAMATION }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_2_AND_AT }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_3_AND_HASHMARK }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_4_AND_DOLLAR }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_5_AND_PERCENTAGE }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_6_AND_CARET }},
+
+            // Row 2
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_TAB }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_Q }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_W }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_E }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_R }},
+            { .type = KeyActionType_None },
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_T }},
+
+            // Row 3
+            { .type = KeyActionType_SwitchLayer, .switchLayer = { .layer = LayerId_Mouse }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_A }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_S }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_D }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_F }},
+            { .type = KeyActionType_None },
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_G }},
+
+            // Row 4
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_LEFT_SHIFT }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_Z }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_X }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_C }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_V }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_B }},
+
+            // Row 5
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_LEFT_CONTROL }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_LEFT_GUI }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_LEFT_ALT }},
+            { .type = KeyActionType_SwitchLayer, .switchLayer = { .layer = LayerId_Fn }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_SPACE }},
+            { .type = KeyActionType_SwitchLayer, .switchLayer = { .layer = LayerId_Mod }},
+            { .type = KeyActionType_None },
+        },
+
+        // Right module
+        {
+            // Row 1
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_GRAVE_ACCENT_AND_TILDE }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_1_AND_EXCLAMATION }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_2_AND_AT }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_3_AND_HASHMARK }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_4_AND_DOLLAR }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_5_AND_PERCENTAGE }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_6_AND_CARET }},
+
+            // Row 2
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_TAB }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_Q }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_W }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_E }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_R }},
+            { .type = KeyActionType_None },
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_T }},
+
+            // Row 3
+            { .type = KeyActionType_SwitchLayer, .switchLayer = { .layer = LayerId_Mouse }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_A }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_S }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_D }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_F }},
+            { .type = KeyActionType_None },
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_G }},
+
+            // Row 4
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_LEFT_SHIFT }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_Z }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_X }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_C }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_V }},
+            { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_B }},
+
             // Row 5
             { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_LEFT_CONTROL }},
             { .type = KeyActionType_Keystroke, .keystroke = { .scancode = HID_KEYBOARD_SC_LEFT_GUI }},

right/src/layer.c

@@ -5,12 +5,12 @@
 #include "keymap.h"
 
 static bool heldLayers[LAYER_COUNT];
-static switch_layer_mode_t pressedLayers[LAYER_COUNT];
+static bool toggledLayers[LAYER_COUNT];
 
 void updateLayerStates(void)
 {
     memset(heldLayers, false, LAYER_COUNT);
-    memset(pressedLayers, false, LAYER_COUNT);
+    memset(toggledLayers, false, LAYER_COUNT);
 
     for (uint8_t slotId=0; slotId<SLOT_COUNT; slotId++) {
         for (uint8_t keyId=0; keyId<MAX_KEY_COUNT_PER_MODULE; keyId++) {
@@ -20,9 +20,8 @@ void updateLayerStates(void)
                 if (action.type == KeyActionType_SwitchLayer) {
                     if (action.switchLayer.mode != SwitchLayerMode_Toggle) {
                         heldLayers[action.switchLayer.layer] = true;
-                    }
+                    } else if (!keyState->previous) {
-                    if (action.switchLayer.mode != SwitchLayerMode_Hold && !keyState->previous && keyState->current) {
+                        toggledLayers[action.switchLayer.layer] = true;
-                        pressedLayers[action.switchLayer.layer] = action.switchLayer.mode;
                     }
                 }
             }
@@ -40,11 +39,11 @@ layer_id_t GetActiveLayer()
     // Handle toggled layers
 
     for (layer_id_t layerId=LayerId_Mod; layerId<=LayerId_Mouse; layerId++) {
-        if (pressedLayers[layerId]) {
+        if (toggledLayers[layerId]) {
             if (ToggledLayer == layerId) {
                 ToggledLayer = LayerId_Base;
                 break;
-            } else if (ToggledLayer == LayerId_Base && pressedLayers[layerId] == SwitchLayerMode_Toggle) {
+            } else if (ToggledLayer == LayerId_Base && toggledLayers[layerId] == SwitchLayerMode_Toggle) {
                 ToggledLayer = layerId;
                 break;
             }

right/src/usb_report_updater.c

@@ -191,23 +191,56 @@ static void processMouseActions()
 }
 
 static layer_id_t previousLayer = LayerId_Base;
+
+static void handleSwitchLayerAction(key_state_t *keyState, key_action_t *action)
+{
+    static key_state_t *doubleTapSwitchLayerKey;
+    static uint32_t doubleTapSwitchLayerStartTime;
+    static uint32_t doubleTapSwitchLayerTriggerTime;
+    static bool isLayerDoubleTapToggled;
+
+    if (doubleTapSwitchLayerKey && doubleTapSwitchLayerKey != keyState && !keyState->previous) {
+        doubleTapSwitchLayerKey = NULL;
+    }
+
+    if (!keyState->previous && isLayerDoubleTapToggled && ToggledLayer == action->switchLayer.layer) {
+        ToggledLayer = LayerId_Base;
+        isLayerDoubleTapToggled = false;
+    }
+
+    if (action->type != KeyActionType_SwitchLayer) {
+        return;
+    }
+
+    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 && Timer_GetElapsedTimeAndSetCurrent(&doubleTapSwitchLayerStartTime) < DoubleTapSwitchLayerTimeout) {
+            ToggledLayer = action->switchLayer.layer;
+            isLayerDoubleTapToggled = true;
+            doubleTapSwitchLayerTriggerTime = Timer_GetCurrentTime();
+        } else {
+            doubleTapSwitchLayerKey = keyState;
+        }
+        doubleTapSwitchLayerStartTime = Timer_GetCurrentTime();
+    }
+}
+
 static uint8_t basicScancodeIndex = 0;
 static uint8_t mediaScancodeIndex = 0;
 static uint8_t systemScancodeIndex = 0;
 
 static 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;
     }
 
-    if (doubleTapSwitchLayerKey && doubleTapSwitchLayerKey != keyState && !keyState->previous) {
+    handleSwitchLayerAction(keyState, action);
-        doubleTapSwitchLayerKey = NULL;
-    }
 
     switch (action->type) {
         case KeyActionType_Keystroke:
@@ -238,21 +271,7 @@ static void applyKeyAction(key_state_t *keyState, key_action_t *action)
             activeMouseStates[action->mouseAction] = true;
             break;
         case KeyActionType_SwitchLayer:
-            if (keyState->previous && doubleTapSwitchLayerKey == keyState &&
+            // Handled by handleSwitchLayerAction()
-                Timer_GetElapsedTime(&doubleTapSwitchLayerTriggerTime) > DoubleTapSwitchLayerReleaseTimeout)
-            {
-                ToggledLayer = LayerId_Base;
-            }
-
-            if (!keyState->previous && previousLayer == LayerId_Base && action->switchLayer.mode == SwitchLayerMode_HoldAndDoubleTapToggle) {
-                if (doubleTapSwitchLayerKey && Timer_GetElapsedTimeAndSetCurrent(&doubleTapSwitchLayerStartTime) < DoubleTapSwitchLayerTimeout) {
-                    ToggledLayer = action->switchLayer.layer;
-                    doubleTapSwitchLayerTriggerTime = Timer_GetCurrentTime();
-                } else {
-                    doubleTapSwitchLayerKey = keyState;
-                }
-                doubleTapSwitchLayerStartTime = Timer_GetCurrentTime();
-            }
             break;
         case KeyActionType_SwitchKeymap:
             if (!keyState->previous) {
@@ -305,10 +324,10 @@ static void updateActiveUsbReports(void)
             key_state_t *keyState = &KeyStates[slotId][keyId];
             key_action_t *action = &CurrentKeymap[activeLayer][slotId][keyId];
 
-            if (keyState->debounceCounter < KEY_DEBOUNCER_TIMEOUT_MSEC) {
+            if (keyState->debounceCounter) {
                 keyState->current = keyState->previous;
-            } else if (!keyState->previous && keyState->current) {
+            } else if (keyState->previous != keyState->current) {
-                keyState->debounceCounter = 0;
+                keyState->debounceCounter = KEY_DEBOUNCER_TIMEOUT_MSEC + 1;
             }
 
             if (keyState->current) {

scripts/package.json

@@ -15,10 +15,10 @@
     "commander": "^2.11.0",
     "shelljs": "^0.7.8"
   },
-  "firmwareVersion": "8.2.4",
+  "firmwareVersion": "8.3.2",
   "deviceProtocolVersion": "4.3.1",
   "moduleProtocolVersion": "4.0.0",
-  "userConfigVersion": "4.0.1",
+  "userConfigVersion": "4.1.0",
   "hardwareConfigVersion": "1.0.0",
   "devices": [
     {

shared/versions.h

@@ -19,8 +19,8 @@
 // Variables:
 
     #define FIRMWARE_MAJOR_VERSION 8
-    #define FIRMWARE_MINOR_VERSION 2
+    #define FIRMWARE_MINOR_VERSION 3
-    #define FIRMWARE_PATCH_VERSION 4
+    #define FIRMWARE_PATCH_VERSION 2
 
     #define DEVICE_PROTOCOL_MAJOR_VERSION 4
     #define DEVICE_PROTOCOL_MINOR_VERSION 3
@@ -31,8 +31,8 @@
     #define MODULE_PROTOCOL_PATCH_VERSION 0
 
     #define USER_CONFIG_MAJOR_VERSION 4
-    #define USER_CONFIG_MINOR_VERSION 0
+    #define USER_CONFIG_MINOR_VERSION 1
-    #define USER_CONFIG_PATCH_VERSION 1
+    #define USER_CONFIG_PATCH_VERSION 0
 
     #define HARDWARE_CONFIG_MAJOR_VERSION 1
     #define HARDWARE_CONFIG_MINOR_VERSION 0