Bump firmware version number to 5.0.1 and update changelog.

CHANGELOG.md

@@ -5,6 +5,19 @@ 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.
 
+## [5.0.1] - 2017-12-09
+
+Data Model: 4.0.0 (unchanged) | USB Protocol: 2.0.0 (unchanged) | Slave Protocol: 3.0.0 (unchanged)
+
+ - 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)
+
+- Move pointerRole from keymaps to module configurations as pointerMode. Add angularShift, modLayerPointerFunction, fnLayerPointerFunction, and mouseLayerPointerFunction to module configurations. `DATAMODEL: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)

right/src/config_parser/parse_config.c

@@ -9,14 +9,25 @@
 static parser_error_t parseModuleConfiguration(config_buffer_t *buffer)
 {
     uint8_t id = ReadUInt8(buffer);
+    uint8_t pointerMode = ReadUInt8(buffer);  // move vs scroll
     uint8_t deceleratedPointerSpeedMultiplier = ReadUInt8(buffer);
     uint8_t basePointerSpeedMultiplier = ReadUInt8(buffer);
     uint8_t acceleratedPointerSpeed = ReadUInt8(buffer);
+    uint16_t angularShift = ReadUInt16(buffer);
+    uint8_t modLayerPointerFunction = ReadUInt8(buffer);  // none vs invertMode vs decelerate vs accelerate
+    uint8_t fnLayerPointerFunction = ReadUInt8(buffer);  // none vs invertMode vs decelerate vs accelerate
+    uint8_t mouseLayerPointerFunction = ReadUInt8(buffer);  // none vs invertMode vs decelerate vs accelerate
 
     (void)id;
+    (void)pointerMode;
     (void)deceleratedPointerSpeedMultiplier;
     (void)basePointerSpeedMultiplier;
     (void)acceleratedPointerSpeed;
+    (void)angularShift;
+    (void)modLayerPointerFunction;
+    (void)fnLayerPointerFunction;
+    (void)mouseLayerPointerFunction;
+
     return ParserError_Success;
 }
 

right/src/config_parser/parse_keymap.c

@@ -116,7 +116,7 @@ static parser_error_t parseKeyAction(key_action_t *keyAction, config_buffer_t *b
     return ParserError_InvalidSerializedKeyActionType;
 }
 
-static parser_error_t parseKeyActions(uint8_t targetLayer, config_buffer_t *buffer, uint8_t moduleId, uint8_t pointerRole)
+static parser_error_t parseKeyActions(uint8_t targetLayer, config_buffer_t *buffer, uint8_t moduleId)
 {
     parser_error_t errorCode;
     uint16_t actionCount = ReadCompactLength(buffer);
@@ -137,9 +137,7 @@ static parser_error_t parseKeyActions(uint8_t targetLayer, config_buffer_t *buff
 static parser_error_t parseModule(config_buffer_t *buffer, uint8_t layer)
 {
     uint8_t moduleId = ReadUInt8(buffer);
-    uint8_t pointerRole = ReadUInt8(buffer);
-
-    return parseKeyActions(layer, buffer, moduleId, pointerRole);
+    return parseKeyActions(layer, buffer, moduleId);
 }
 
 static parser_error_t parseLayer(config_buffer_t *buffer, uint8_t layer)

right/src/key_scanner.c

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

right/src/key_scanner.h

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

right/src/timer.c

@@ -24,9 +24,20 @@ void Timer_Init(void)
     PIT_StartTimer(PIT, PIT_TIMER_CHANNEL);
 }
 
+void Timer_SetCurrentTime(uint32_t *time)
+{
+    *time = CurrentTime;
+}
+
 uint32_t Timer_GetElapsedTime(uint32_t *time)
 {
     uint32_t elapsedTime = CurrentTime - *time;
+    return elapsedTime;
+}
+
+uint32_t Timer_GetElapsedTimeAndSetCurrent(uint32_t *time)
+{
+    uint32_t elapsedTime = Timer_GetElapsedTime(time);
     *time = CurrentTime;
     return elapsedTime;
 }

right/src/timer.h

@@ -16,6 +16,8 @@
 // Functions:
 
     void Timer_Init(void);
+    void Timer_SetCurrentTime(uint32_t *time);
     uint32_t Timer_GetElapsedTime(uint32_t *time);
+    uint32_t Timer_GetElapsedTimeAndSetCurrent(uint32_t *time);
 
 #endif

right/src/usb_commands/usb_command_get_debug_buffer.c

@@ -5,6 +5,12 @@
 #include "i2c_watchdog.h"
 #include "buffer.h"
 #include "timer.h"
+#include "key_scanner.h"
+#include "usb_report_updater.h"
+#include "usb_interfaces/usb_interface_basic_keyboard.h"
+#include "usb_interfaces/usb_interface_media_keyboard.h"
+#include "usb_interfaces/usb_interface_system_keyboard.h"
+#include "usb_interfaces/usb_interface_mouse.h"
 
 uint8_t DebugBuffer[USB_GENERIC_HID_OUT_BUFFER_LENGTH];
 
@@ -14,7 +20,14 @@ void UsbCommand_GetDebugBuffer(void)
     SetDebugBufferUint32(5, I2cSlaveScheduler_Counter);
     SetDebugBufferUint32(9, I2cWatchdog_WatchCounter);
     SetDebugBufferUint32(13, I2cWatchdog_RecoveryCounter);
-    SetDebugBufferUint32(40, CurrentTime);
+    SetDebugBufferUint32(17, KeyScannerCounter);
+    SetDebugBufferUint32(21, UsbReportUpdateCounter);
+    SetDebugBufferUint32(25, CurrentTime);
+    SetDebugBufferUint32(29, UsbGenericHidActionCounter);
+    SetDebugBufferUint32(33, UsbBasicKeyboardActionCounter);
+    SetDebugBufferUint32(37, UsbMediaKeyboardActionCounter);
+    SetDebugBufferUint32(41, UsbSystemKeyboardActionCounter);
+    SetDebugBufferUint32(45, UsbMouseActionCounter);
 
     memcpy(GenericHidOutBuffer, DebugBuffer, USB_GENERIC_HID_OUT_BUFFER_LENGTH);
 }

right/src/usb_composite_device.c

@@ -5,37 +5,175 @@
 #include "bus_pal_hardware.h"
 #include "bootloader/wormhole.h"
 
-static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event, void *param);
 usb_composite_device_t UsbCompositeDevice;
+static usb_status_t usbDeviceCallback(usb_device_handle handle, uint32_t event, void *param);
 
-usb_device_class_config_struct_t UsbDeviceCompositeClassConfig[USB_DEVICE_CONFIG_HID] = {
-    {UsbGenericHidCallback,     (class_handle_t)NULL, &UsbGenericHidClass},
-    {UsbBasicKeyboardCallback,  (class_handle_t)NULL, &UsbBasicKeyboardClass},
-    {UsbMediaKeyboardCallback,  (class_handle_t)NULL, &UsbMediaKeyboardClass},
-    {UsbSystemKeyboardCallback, (class_handle_t)NULL, &UsbSystemKeyboardClass},
-    {UsbMouseCallback,          (class_handle_t)NULL, &UsbMouseClass},
-};
-
-usb_device_class_config_list_struct_t UsbDeviceCompositeConfigList = {
-    UsbDeviceCompositeClassConfig,
-    UsbDeviceCallback,
-    USB_DEVICE_CONFIG_HID
-};
-
-static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event, void *param)
+static usb_device_class_config_list_struct_t UsbDeviceCompositeConfigList = {
+    .deviceCallback = usbDeviceCallback,
+    .count = USB_DEVICE_CONFIG_HID,
+    .config = (usb_device_class_config_struct_t[USB_DEVICE_CONFIG_HID]) {{
+        .classCallback = UsbGenericHidCallback,
+        .classInfomation = (usb_device_class_struct_t[]) {{
+            .type = kUSB_DeviceClassTypeHid,
+            .configurations = USB_DEVICE_CONFIGURATION_COUNT,
+            .interfaceList = (usb_device_interface_list_t[USB_DEVICE_CONFIGURATION_COUNT]) {{
+                .count = USB_GENERIC_HID_INTERFACE_COUNT,
+                .interfaces = (usb_device_interfaces_struct_t[USB_GENERIC_HID_INTERFACE_COUNT]) {{
+                    .classCode = USB_CLASS_HID,
+                    .subclassCode = USB_HID_SUBCLASS_NONE,
+                    .protocolCode = USB_HID_PROTOCOL_NONE,
+                    .interfaceNumber = USB_GENERIC_HID_INTERFACE_INDEX,
+                    .count = 1,
+                    .interface = (usb_device_interface_struct_t[]) {{
+                        .alternateSetting = USB_INTERFACE_ALTERNATE_SETTING_NONE,
+                        .endpointList = {
+                            .count = USB_GENERIC_HID_ENDPOINT_COUNT,
+                            .endpoint = (usb_device_endpoint_struct_t[USB_GENERIC_HID_ENDPOINT_COUNT]) {
                                 {
-    usb_status_t error = kStatus_USB_Error;
+                                    .endpointAddress = USB_GENERIC_HID_ENDPOINT_IN_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+                                    .transferType = USB_ENDPOINT_INTERRUPT,
+                                    .maxPacketSize = USB_GENERIC_HID_INTERRUPT_IN_PACKET_SIZE,
+                                },
+                                {
+                                    .endpointAddress = USB_GENERIC_HID_ENDPOINT_OUT_INDEX | (USB_OUT << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+                                    .transferType = USB_ENDPOINT_INTERRUPT,
+                                    .maxPacketSize = USB_GENERIC_HID_INTERRUPT_OUT_PACKET_SIZE,
+                                }
+                            }
+                        }
+                    }}
+                }}
+            }}
+        }}
+    },
+    {
+        .classCallback = UsbBasicKeyboardCallback,
+        .classInfomation = (usb_device_class_struct_t[]) {{
+            .type = kUSB_DeviceClassTypeHid,
+            .configurations = USB_DEVICE_CONFIGURATION_COUNT,
+            .interfaceList = (usb_device_interface_list_t[USB_DEVICE_CONFIGURATION_COUNT]) {{
+                .count = USB_BASIC_KEYBOARD_INTERFACE_COUNT,
+                .interfaces = (usb_device_interfaces_struct_t[USB_BASIC_KEYBOARD_INTERFACE_COUNT]) {{
+                    .classCode = USB_CLASS_HID,
+                    .subclassCode = USB_HID_SUBCLASS_BOOT,
+                    .protocolCode = USB_HID_PROTOCOL_KEYBOARD,
+                    .interfaceNumber = USB_BASIC_KEYBOARD_INTERFACE_INDEX,
+                    .count = 1,
+                    .interface = (usb_device_interface_struct_t[]) {{
+                        .alternateSetting = USB_INTERFACE_ALTERNATE_SETTING_NONE,
+                        .endpointList = {
+                            USB_BASIC_KEYBOARD_ENDPOINT_COUNT,
+                            (usb_device_endpoint_struct_t[USB_BASIC_KEYBOARD_ENDPOINT_COUNT]) {{
+                                .endpointAddress = USB_BASIC_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+                                .transferType = USB_ENDPOINT_INTERRUPT,
+                                .maxPacketSize = USB_BASIC_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
+                            }}
+                        }
+                    }}
+                }}
+            }}
+        }}
+    },
+    {
+        .classCallback = UsbMediaKeyboardCallback,
+        .classInfomation = (usb_device_class_struct_t[]) {{
+            .type = kUSB_DeviceClassTypeHid,
+            .configurations = USB_DEVICE_CONFIGURATION_COUNT,
+            .interfaceList = (usb_device_interface_list_t[USB_DEVICE_CONFIGURATION_COUNT]) {{
+                .count = USB_MEDIA_KEYBOARD_INTERFACE_COUNT,
+                .interfaces = (usb_device_interfaces_struct_t[USB_MEDIA_KEYBOARD_INTERFACE_COUNT]) {{
+                    .classCode = USB_CLASS_HID,
+                    .subclassCode = USB_HID_SUBCLASS_BOOT,
+                    .protocolCode = USB_HID_PROTOCOL_KEYBOARD,
+                    .interfaceNumber = USB_MEDIA_KEYBOARD_INTERFACE_INDEX,
+                    .count = 1,
+                    .interface = (usb_device_interface_struct_t[]) {{
+                        .alternateSetting = USB_INTERFACE_ALTERNATE_SETTING_NONE,
+                        .endpointList = {
+                            USB_MEDIA_KEYBOARD_ENDPOINT_COUNT,
+                            (usb_device_endpoint_struct_t[USB_MEDIA_KEYBOARD_ENDPOINT_COUNT]) {{
+                                .endpointAddress = USB_MEDIA_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+                                .transferType = USB_ENDPOINT_INTERRUPT,
+                                .maxPacketSize = USB_MEDIA_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
+                            }}
+                        }
+                    }}
+                }}
+            }}
+        }}
+    },
+    {
+        .classCallback = UsbSystemKeyboardCallback,
+        .classInfomation = (usb_device_class_struct_t[]) {{
+            .type = kUSB_DeviceClassTypeHid,
+            .configurations = USB_DEVICE_CONFIGURATION_COUNT,
+            .interfaceList = (usb_device_interface_list_t[USB_DEVICE_CONFIGURATION_COUNT]) {{
+                .count = USB_SYSTEM_KEYBOARD_INTERFACE_COUNT,
+                .interfaces = (usb_device_interfaces_struct_t[USB_SYSTEM_KEYBOARD_INTERFACE_COUNT]) {{
+                    .classCode = USB_CLASS_HID,
+                    .subclassCode = USB_HID_SUBCLASS_BOOT,
+                    .protocolCode = USB_HID_PROTOCOL_KEYBOARD,
+                    .interfaceNumber = USB_SYSTEM_KEYBOARD_INTERFACE_INDEX,
+                    .count = 1,
+                    .interface = (usb_device_interface_struct_t[]) {{
+                        .alternateSetting = USB_INTERFACE_ALTERNATE_SETTING_NONE,
+                        .endpointList = {
+                            USB_SYSTEM_KEYBOARD_ENDPOINT_COUNT,
+                            (usb_device_endpoint_struct_t[USB_SYSTEM_KEYBOARD_ENDPOINT_COUNT]) {{
+                                .endpointAddress = USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+                                .transferType = USB_ENDPOINT_INTERRUPT,
+                                .maxPacketSize = USB_SYSTEM_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
+                            }}
+                        }
+                    }}
+                }}
+            }},
+        }}
+    },
+    {
+        .classCallback = UsbMouseCallback,
+        .classInfomation = (usb_device_class_struct_t[]) {{
+            .type = kUSB_DeviceClassTypeHid,
+            .configurations = USB_DEVICE_CONFIGURATION_COUNT,
+            .interfaceList = (usb_device_interface_list_t[USB_DEVICE_CONFIGURATION_COUNT]) {{
+                .count = USB_MOUSE_INTERFACE_COUNT,
+                .interfaces = (usb_device_interfaces_struct_t[USB_MOUSE_INTERFACE_COUNT]) {{
+                    .classCode = USB_CLASS_HID,
+                    .subclassCode = USB_HID_SUBCLASS_BOOT,
+                    .protocolCode = USB_HID_PROTOCOL_MOUSE,
+                    .interfaceNumber = USB_MOUSE_INTERFACE_INDEX,
+                    .count = 1,
+                    .interface = (usb_device_interface_struct_t[]) {{
+                        .alternateSetting = USB_INTERFACE_ALTERNATE_SETTING_NONE,
+                        .endpointList = {
+                            USB_MOUSE_ENDPOINT_COUNT,
+                            (usb_device_endpoint_struct_t[USB_MOUSE_ENDPOINT_COUNT]) {{
+                                .endpointAddress = USB_MOUSE_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+                                .transferType = USB_ENDPOINT_INTERRUPT,
+                                .maxPacketSize = USB_MOUSE_INTERRUPT_IN_PACKET_SIZE,
+                            }}
+                        }
+                    }}
+                }}
+            }}
+        }}
+    }
+}};
+
+static usb_status_t usbDeviceCallback(usb_device_handle handle, uint32_t event, void *param)
+{
+    usb_status_t status = kStatus_USB_Error;
     uint16_t *temp16 = (uint16_t*)param;
     uint8_t *temp8 = (uint8_t*)param;
 
     if (!param && event != kUSB_DeviceEventBusReset && event != kUSB_DeviceEventSetInterface) {
-        return error;
+        return status;
     }
 
     switch (event) {
         case kUSB_DeviceEventBusReset:
             UsbCompositeDevice.attach = 0;
-            error = kStatus_USB_Success;
+            status = kStatus_USB_Success;
             break;
         case kUSB_DeviceEventSetConfiguration:
             UsbCompositeDevice.attach = 1;
@@ -45,11 +183,11 @@ static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event,
             UsbMediaKeyboardSetConfiguration(UsbCompositeDevice.mediaKeyboardHandle, *temp8);
             UsbSystemKeyboardSetConfiguration(UsbCompositeDevice.systemKeyboardHandle, *temp8);
             UsbMouseSetConfiguration(UsbCompositeDevice.mouseHandle, *temp8);
-            error = kStatus_USB_Success;
+            status = kStatus_USB_Success;
             break;
         case kUSB_DeviceEventGetConfiguration:
             *temp8 = UsbCompositeDevice.currentConfiguration;
-            error = kStatus_USB_Success;
+            status = kStatus_USB_Success;
             break;
         case kUSB_DeviceEventSetInterface:
             if (UsbCompositeDevice.attach) {
@@ -62,7 +200,7 @@ static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event,
                     UsbMediaKeyboardSetInterface(UsbCompositeDevice.mediaKeyboardHandle, interface, alternateSetting);
                     UsbSystemKeyboardSetInterface(UsbCompositeDevice.systemKeyboardHandle, interface, alternateSetting);
                     UsbMouseSetInterface(UsbCompositeDevice.mouseHandle, interface, alternateSetting);
-                    error = kStatus_USB_Success;
+                    status = kStatus_USB_Success;
                 }
             }
             break;
@@ -70,32 +208,32 @@ static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event,
             uint8_t interface = (uint8_t)((*temp16 & 0xFF00) >> 8);
             if (interface < USB_DEVICE_CONFIG_HID) {
                 *temp16 = (*temp16 & 0xFF00) | UsbCompositeDevice.currentInterfaceAlternateSetting[interface];
-                error = kStatus_USB_Success;
+                status = kStatus_USB_Success;
             } else {
-                error = kStatus_USB_InvalidRequest;
+                status = kStatus_USB_InvalidRequest;
             }
             break;
         case kUSB_DeviceEventGetDeviceDescriptor:
-            error = USB_DeviceGetDeviceDescriptor(handle, (usb_device_get_device_descriptor_struct_t *)param);
+            status = USB_DeviceGetDeviceDescriptor(handle, (usb_device_get_device_descriptor_struct_t *)param);
             break;
         case kUSB_DeviceEventGetConfigurationDescriptor:
-            error = USB_DeviceGetConfigurationDescriptor(handle, (usb_device_get_configuration_descriptor_struct_t *)param);
+            status = USB_DeviceGetConfigurationDescriptor(handle, (usb_device_get_configuration_descriptor_struct_t *)param);
             break;
         case kUSB_DeviceEventGetStringDescriptor:
-            error = USB_DeviceGetStringDescriptor(handle, (usb_device_get_string_descriptor_struct_t *)param);
+            status = USB_DeviceGetStringDescriptor(handle, (usb_device_get_string_descriptor_struct_t *)param);
             break;
         case kUSB_DeviceEventGetHidDescriptor:
-            error = USB_DeviceGetHidDescriptor(handle, (usb_device_get_hid_descriptor_struct_t *)param);
+            status = USB_DeviceGetHidDescriptor(handle, (usb_device_get_hid_descriptor_struct_t *)param);
             break;
         case kUSB_DeviceEventGetHidReportDescriptor:
-            error = USB_DeviceGetHidReportDescriptor(handle, (usb_device_get_hid_report_descriptor_struct_t *)param);
+            status = USB_DeviceGetHidReportDescriptor(handle, (usb_device_get_hid_report_descriptor_struct_t *)param);
             break;
         case kUSB_DeviceEventGetHidPhysicalDescriptor:
-            error = USB_DeviceGetHidPhysicalDescriptor(handle, (usb_device_get_hid_physical_descriptor_struct_t *)param);
+            status = USB_DeviceGetHidPhysicalDescriptor(handle, (usb_device_get_hid_physical_descriptor_struct_t *)param);
             break;
     }
 
-    return error;
+    return status;
 }
 
 void USB0_IRQHandler(void)
@@ -107,9 +245,6 @@ void USB0_IRQHandler(void)
 
 void InitUsb(void)
 {
-    uint8_t usbDeviceKhciIrq[] = USB_IRQS;
-    uint8_t irqNumber = usbDeviceKhciIrq[CONTROLLER_ID - kUSB_ControllerKhci0];
-
     SystemCoreClockUpdate();
     CLOCK_EnableUsbfs0Clock(kCLOCK_UsbSrcIrc48M, 48000000);
 
@@ -121,6 +256,8 @@ void InitUsb(void)
     UsbCompositeDevice.systemKeyboardHandle = UsbDeviceCompositeConfigList.config[USB_SYSTEM_KEYBOARD_INTERFACE_INDEX].classHandle;
     UsbCompositeDevice.mouseHandle = UsbDeviceCompositeConfigList.config[USB_MOUSE_INTERFACE_INDEX].classHandle;
 
+    uint8_t usbDeviceKhciIrq[] = USB_IRQS;
+    uint8_t irqNumber = usbDeviceKhciIrq[CONTROLLER_ID - kUSB_ControllerKhci0];
     NVIC_EnableIRQ((IRQn_Type)irqNumber);
 
     USB_DeviceRun(UsbCompositeDevice.deviceHandle);

right/src/usb_interfaces/usb_interface_basic_keyboard.c

@@ -1,45 +1,7 @@
-#include "key_action.h"
-#include "fsl_port.h"
-#include "usb_api.h"
 #include "usb_composite_device.h"
-#include "peripherals/test_led.h"
-#include "fsl_i2c.h"
-#include "i2c.h"
-#include "i2c_addresses.h"
-
-static usb_device_endpoint_struct_t UsbBasicKeyboardEndpoints[USB_BASIC_KEYBOARD_ENDPOINT_COUNT] = {{
-    USB_BASIC_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-    USB_ENDPOINT_INTERRUPT,
-    USB_BASIC_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
-}};
-
-static usb_device_interface_struct_t UsbBasicKeyboardInterface[] = {{
-    USB_INTERFACE_ALTERNATE_SETTING_NONE,
-    {USB_BASIC_KEYBOARD_ENDPOINT_COUNT, UsbBasicKeyboardEndpoints},
-    NULL,
-}};
-
-static usb_device_interfaces_struct_t UsbBasicKeyboardInterfaces[USB_BASIC_KEYBOARD_INTERFACE_COUNT] = {{
-    USB_CLASS_HID,
-    USB_HID_SUBCLASS_BOOT,
-    USB_HID_PROTOCOL_KEYBOARD,
-    USB_BASIC_KEYBOARD_INTERFACE_INDEX,
-    UsbBasicKeyboardInterface,
-    sizeof(UsbBasicKeyboardInterface) / sizeof(usb_device_interfaces_struct_t),
-}};
-
-static usb_device_interface_list_t UsbBasicKeyboardInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
-    USB_BASIC_KEYBOARD_INTERFACE_COUNT,
-    UsbBasicKeyboardInterfaces,
-}};
-
-usb_device_class_struct_t UsbBasicKeyboardClass = {
-    UsbBasicKeyboardInterfaceList,
-    kUSB_DeviceClassTypeHid,
-    USB_DEVICE_CONFIGURATION_COUNT,
-};
 
 static usb_basic_keyboard_report_t usbBasicKeyboardReports[2];
+uint32_t UsbBasicKeyboardActionCounter;
 usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport = usbBasicKeyboardReports;
 bool IsUsbBasicKeyboardReportSent = false;
 
@@ -64,6 +26,7 @@ static usb_status_t UsbBasicKeyboardAction(void)
         UsbCompositeDevice.basicKeyboardHandle, USB_BASIC_KEYBOARD_ENDPOINT_INDEX,
         (uint8_t*)getInactiveUsbBasicKeyboardReport(), USB_BASIC_KEYBOARD_REPORT_LENGTH);
     IsUsbBasicKeyboardReportSent = true;
+    UsbBasicKeyboardActionCounter++;
     return status;
 }
 

right/src/usb_interfaces/usb_interface_basic_keyboard.h

@@ -32,7 +32,7 @@
 // Variables:
 
     extern bool IsUsbBasicKeyboardReportSent;
-    extern usb_device_class_struct_t UsbBasicKeyboardClass;
+    extern uint32_t UsbBasicKeyboardActionCounter;
     extern usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport;
 
 // Functions:

right/src/usb_interfaces/usb_interface_generic_hid.c

@@ -1,47 +1,7 @@
 #include "usb_composite_device.h"
-#include "usb_interface_generic_hid.h"
 #include "usb_protocol_handler.h"
 
-static usb_device_endpoint_struct_t UsbGenericHidEndpoints[USB_GENERIC_HID_ENDPOINT_COUNT] =
-{
-    {
-        USB_GENERIC_HID_ENDPOINT_IN_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-        USB_ENDPOINT_INTERRUPT,
-        USB_GENERIC_HID_INTERRUPT_IN_PACKET_SIZE,
-    },
-    {
-        USB_GENERIC_HID_ENDPOINT_OUT_INDEX | (USB_OUT << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-        USB_ENDPOINT_INTERRUPT,
-        USB_GENERIC_HID_INTERRUPT_OUT_PACKET_SIZE,
-    }
-};
-
-static usb_device_interface_struct_t UsbGenericHidInterface[] = {{
-    USB_INTERFACE_ALTERNATE_SETTING_NONE,
-    {USB_GENERIC_HID_ENDPOINT_COUNT, UsbGenericHidEndpoints},
-    NULL,
-}};
-
-static usb_device_interfaces_struct_t UsbGenericHidInterfaces[USB_GENERIC_HID_INTERFACE_COUNT] = {{
-    USB_CLASS_HID,
-    USB_HID_SUBCLASS_NONE,
-    USB_HID_PROTOCOL_NONE,
-    USB_GENERIC_HID_INTERFACE_INDEX,
-    UsbGenericHidInterface,
-    sizeof(UsbGenericHidInterface) / sizeof(usb_device_interfaces_struct_t),
-}};
-
-static usb_device_interface_list_t UsbGenericHidInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
-    USB_GENERIC_HID_INTERFACE_COUNT,
-    UsbGenericHidInterfaces,
-}};
-
-usb_device_class_struct_t UsbGenericHidClass = {
-    UsbGenericHidInterfaceList,
-    kUSB_DeviceClassTypeHid,
-    USB_DEVICE_CONFIGURATION_COUNT,
-};
-
+uint32_t UsbGenericHidActionCounter;
 uint8_t GenericHidInBuffer[USB_GENERIC_HID_IN_BUFFER_LENGTH];
 uint8_t GenericHidOutBuffer[USB_GENERIC_HID_OUT_BUFFER_LENGTH];
 
@@ -67,6 +27,7 @@ usb_status_t UsbGenericHidCallback(class_handle_t handle, uint32_t event, void *
                               USB_GENERIC_HID_ENDPOINT_IN_INDEX,
                               GenericHidOutBuffer,
                               USB_GENERIC_HID_OUT_BUFFER_LENGTH);
+            UsbGenericHidActionCounter++;
             return UsbReceiveData();
             break;
         case kUSB_DeviceHidEventGetReport:

right/src/usb_interfaces/usb_interface_generic_hid.h

@@ -25,7 +25,7 @@
 
 // Variables:
 
-    extern usb_device_class_struct_t UsbGenericHidClass;
+    extern uint32_t UsbGenericHidActionCounter;
     extern uint8_t GenericHidInBuffer[USB_GENERIC_HID_IN_BUFFER_LENGTH];
     extern uint8_t GenericHidOutBuffer[USB_GENERIC_HID_OUT_BUFFER_LENGTH];
 

right/src/usb_interfaces/usb_interface_media_keyboard.c

@@ -1,44 +1,6 @@
-#include "key_action.h"
-#include "fsl_port.h"
-#include "usb_api.h"
 #include "usb_composite_device.h"
-#include "peripherals/test_led.h"
-#include "fsl_i2c.h"
-#include "i2c.h"
-#include "i2c_addresses.h"
-
-static usb_device_endpoint_struct_t UsbMediaKeyboardEndpoints[USB_MEDIA_KEYBOARD_ENDPOINT_COUNT] = {{
-    USB_MEDIA_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-    USB_ENDPOINT_INTERRUPT,
-    USB_MEDIA_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
-}};
-
-static usb_device_interface_struct_t UsbMediaKeyboardInterface[] = {{
-    USB_INTERFACE_ALTERNATE_SETTING_NONE,
-    {USB_MEDIA_KEYBOARD_ENDPOINT_COUNT, UsbMediaKeyboardEndpoints},
-    NULL,
-}};
-
-static usb_device_interfaces_struct_t UsbMediaKeyboardInterfaces[USB_MEDIA_KEYBOARD_INTERFACE_COUNT] = {{
-    USB_CLASS_HID,
-    USB_HID_SUBCLASS_BOOT,
-    USB_HID_PROTOCOL_KEYBOARD,
-    USB_MEDIA_KEYBOARD_INTERFACE_INDEX,
-    UsbMediaKeyboardInterface,
-    sizeof(UsbMediaKeyboardInterface) / sizeof(usb_device_interfaces_struct_t),
-}};
-
-static usb_device_interface_list_t UsbMediaKeyboardInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
-    USB_MEDIA_KEYBOARD_INTERFACE_COUNT,
-    UsbMediaKeyboardInterfaces,
-}};
-
-usb_device_class_struct_t UsbMediaKeyboardClass = {
-    UsbMediaKeyboardInterfaceList,
-    kUSB_DeviceClassTypeHid,
-    USB_DEVICE_CONFIGURATION_COUNT,
-};
 
+uint32_t UsbMediaKeyboardActionCounter;
 static usb_media_keyboard_report_t usbMediaKeyboardReports[2];
 usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport = usbMediaKeyboardReports;
 bool IsUsbMediaKeyboardReportSent = false;
@@ -64,6 +26,7 @@ static usb_status_t UsbMediaKeyboardAction(void)
         UsbCompositeDevice.mediaKeyboardHandle, USB_MEDIA_KEYBOARD_ENDPOINT_INDEX,
         (uint8_t*)getInactiveUsbMediaKeyboardReport(), USB_MEDIA_KEYBOARD_REPORT_LENGTH);
     IsUsbMediaKeyboardReportSent = true;
+    UsbMediaKeyboardActionCounter++;
     return status;
 }
 

right/src/usb_interfaces/usb_interface_media_keyboard.h

@@ -29,7 +29,7 @@
 // Variables:
 
     extern bool IsUsbMediaKeyboardReportSent;
-    extern usb_device_class_struct_t UsbMediaKeyboardClass;
+    extern uint32_t UsbMediaKeyboardActionCounter;
     extern usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport;
 
 // Functions:

right/src/usb_interfaces/usb_interface_mouse.c

@@ -1,45 +1,7 @@
 #include "usb_composite_device.h"
-#include "usb_interface_mouse.h"
-#include "fsl_i2c.h"
-#include "i2c.h"
-#include "peripherals/reset_button.h"
-#include "key_action.h"
-#include "buffer.h"
-#include "usb_commands/usb_command_get_debug_buffer.h"
 
-static usb_device_endpoint_struct_t UsbMouseEndpoints[USB_MOUSE_ENDPOINT_COUNT] = {{
-    USB_MOUSE_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-    USB_ENDPOINT_INTERRUPT,
-    USB_MOUSE_INTERRUPT_IN_PACKET_SIZE,
-}};
-
-static usb_device_interface_struct_t UsbMouseInterface[] = {{
-    USB_INTERFACE_ALTERNATE_SETTING_NONE,
-    {USB_MOUSE_ENDPOINT_COUNT, UsbMouseEndpoints},
-    NULL,
-}};
-
-static usb_device_interfaces_struct_t UsbMouseInterfaces[USB_MOUSE_INTERFACE_COUNT] = {{
-    USB_CLASS_HID,
-    USB_HID_SUBCLASS_BOOT,
-    USB_HID_PROTOCOL_MOUSE,
-    USB_MOUSE_INTERFACE_INDEX,
-    UsbMouseInterface,
-    sizeof(UsbMouseInterface) / sizeof(usb_device_interfaces_struct_t),
-}};
-
-static usb_device_interface_list_t UsbMouseInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
-    USB_MOUSE_INTERFACE_COUNT,
-    UsbMouseInterfaces,
-}};
-
-usb_device_class_struct_t UsbMouseClass = {
-    UsbMouseInterfaceList,
-    kUSB_DeviceClassTypeHid,
-    USB_DEVICE_CONFIGURATION_COUNT,
-};
-
-usb_mouse_report_t usbMouseReports[2];
+uint32_t UsbMouseActionCounter;
+static usb_mouse_report_t usbMouseReports[2];
 usb_mouse_report_t* ActiveUsbMouseReport = usbMouseReports;
 bool IsUsbMouseReportSent = false;
 
@@ -58,16 +20,9 @@ void ResetActiveUsbMouseReport(void)
     bzero(ActiveUsbMouseReport, USB_MOUSE_REPORT_LENGTH);
 }
 
-static uint32_t count1 = 0;
-static uint32_t count2 = 0;
-static uint32_t count3 = 0;
-
 static volatile usb_status_t usbMouseAction(void)
 {
-    count3++;
     usb_mouse_report_t *mouseReport = getInactiveUsbMouseReport();
-    SetDebugBufferUint16(29, mouseReport->x);
-    SetDebugBufferUint16(31, mouseReport->y);
     IsUsbMouseReportSent = true;
     return USB_DeviceHidSend(UsbCompositeDevice.mouseHandle, USB_MOUSE_ENDPOINT_INDEX,
                (uint8_t*)mouseReport, USB_MOUSE_REPORT_LENGTH);
@@ -75,17 +30,11 @@ static volatile usb_status_t usbMouseAction(void)
 
 usb_status_t UsbMouseCallback(class_handle_t handle, uint32_t event, void *param)
 {
-    SetDebugBufferUint32(17, count1);
-    SetDebugBufferUint32(21, count2);
-    SetDebugBufferUint32(25, count3);
-
-    count1++;
-
+    UsbMouseActionCounter++;
     usb_status_t error = kStatus_USB_Error;
 
     switch (event) {
         case kUSB_DeviceHidEventSendResponse:
-            count2++;
             if (UsbCompositeDevice.attach) {
                 return usbMouseAction();
             }

right/src/usb_interfaces/usb_interface_mouse.h

@@ -32,7 +32,7 @@
 // Variables:
 
     extern bool IsUsbMouseReportSent;
-    extern usb_device_class_struct_t UsbMouseClass;
+    extern uint32_t UsbMouseActionCounter;
     extern usb_mouse_report_t* ActiveUsbMouseReport;
 
 // Functions:

right/src/usb_interfaces/usb_interface_system_keyboard.c

@@ -1,44 +1,6 @@
-#include "key_action.h"
-#include "fsl_port.h"
-#include "usb_api.h"
 #include "usb_composite_device.h"
-#include "peripherals/test_led.h"
-#include "fsl_i2c.h"
-#include "i2c.h"
-#include "i2c_addresses.h"
-
-static usb_device_endpoint_struct_t UsbSystemKeyboardEndpoints[USB_SYSTEM_KEYBOARD_ENDPOINT_COUNT] = {{
-    USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-    USB_ENDPOINT_INTERRUPT,
-    USB_SYSTEM_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
-}};
-
-static usb_device_interface_struct_t UsbSystemKeyboardInterface[] = {{
-    USB_INTERFACE_ALTERNATE_SETTING_NONE,
-    {USB_SYSTEM_KEYBOARD_ENDPOINT_COUNT, UsbSystemKeyboardEndpoints},
-    NULL,
-}};
-
-static usb_device_interfaces_struct_t UsbSystemKeyboardInterfaces[USB_SYSTEM_KEYBOARD_INTERFACE_COUNT] = {{
-    USB_CLASS_HID,
-    USB_HID_SUBCLASS_BOOT,
-    USB_HID_PROTOCOL_KEYBOARD,
-    USB_SYSTEM_KEYBOARD_INTERFACE_INDEX,
-    UsbSystemKeyboardInterface,
-    sizeof(UsbSystemKeyboardInterface) / sizeof(usb_device_interfaces_struct_t),
-}};
-
-static usb_device_interface_list_t UsbSystemKeyboardInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
-    USB_SYSTEM_KEYBOARD_INTERFACE_COUNT,
-    UsbSystemKeyboardInterfaces,
-}};
-
-usb_device_class_struct_t UsbSystemKeyboardClass = {
-    UsbSystemKeyboardInterfaceList,
-    kUSB_DeviceClassTypeHid,
-    USB_DEVICE_CONFIGURATION_COUNT,
-};
 
+uint32_t UsbSystemKeyboardActionCounter;
 static usb_system_keyboard_report_t usbSystemKeyboardReports[2];
 usb_system_keyboard_report_t* ActiveUsbSystemKeyboardReport = usbSystemKeyboardReports;
 bool IsUsbSystemKeyboardReportSent = false;
@@ -64,6 +26,7 @@ static usb_status_t UsbSystemKeyboardAction(void)
         UsbCompositeDevice.systemKeyboardHandle, USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX,
         (uint8_t*)getInactiveUsbSystemKeyboardReport(), USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
     IsUsbSystemKeyboardReportSent = true;
+    UsbSystemKeyboardActionCounter++;
     return status;
 }
 

right/src/usb_interfaces/usb_interface_system_keyboard.h

@@ -30,7 +30,7 @@
 // Variables:
 
     extern bool IsUsbSystemKeyboardReportSent;
-    extern usb_device_class_struct_t UsbSystemKeyboardClass;
+    extern uint32_t UsbSystemKeyboardActionCounter;
     extern usb_system_keyboard_report_t* ActiveUsbSystemKeyboardReport;
 
 // Functions:

right/src/usb_report_updater.c

@@ -25,6 +25,7 @@ uint16_t DoubleTapSwitchLayerTimeout = 250;
 static bool activeMouseStates[ACTIVE_MOUSE_STATES_COUNT];
 
 mouse_kinetic_state_t MouseMoveState = {
+    .isScroll = false,
     .upState = SerializedMouseAction_MoveUp,
     .downState = SerializedMouseAction_MoveDown,
     .leftState = SerializedMouseAction_MoveLeft,
@@ -38,6 +39,7 @@ mouse_kinetic_state_t MouseMoveState = {
 };
 
 mouse_kinetic_state_t MouseScrollState = {
+    .isScroll = true,
     .upState = SerializedMouseAction_ScrollDown,
     .downState = SerializedMouseAction_ScrollUp,
     .leftState = SerializedMouseAction_ScrollLeft,
@@ -97,6 +99,11 @@ void processMouseKineticState(mouse_kinetic_state_t *kineticState)
 
         float distance = kineticState->currentSpeed * elapsedTime / 1000;
 
+        if (kineticState->isScroll && !kineticState->wasMoveAction) {
+            kineticState->xSum = 0;
+            kineticState->ySum = 0;
+        }
+
         if (activeMouseStates[kineticState->leftState]) {
             kineticState->xSum -= distance;
         } else if (activeMouseStates[kineticState->rightState]) {
@@ -108,6 +115,11 @@ void processMouseKineticState(mouse_kinetic_state_t *kineticState)
         kineticState->xSum = xSumFrac;
         kineticState->xOut = xSumInt;
 
+        if (kineticState->isScroll && !kineticState->wasMoveAction && kineticState->xOut == 0) {
+            kineticState->xOut = kineticState->xSum > 0 ? 1 : -1;
+            kineticState->xSum = 0;
+        }
+
         if (activeMouseStates[kineticState->upState]) {
             kineticState->ySum -= distance;
         } else if (activeMouseStates[kineticState->downState]) {
@@ -118,6 +130,11 @@ void processMouseKineticState(mouse_kinetic_state_t *kineticState)
         float ySumFrac = modff(kineticState->ySum, &ySumInt);
         kineticState->ySum = ySumFrac;
         kineticState->yOut = ySumInt;
+
+        if (kineticState->isScroll && !kineticState->wasMoveAction && kineticState->yOut == 0) {
+            kineticState->yOut = kineticState->ySum > 0 ? 1 : -1;
+            kineticState->ySum = 0;
+        }
     } else {
         kineticState->currentSpeed = 0;
     }
@@ -207,7 +224,7 @@ void applyKeyAction(key_state_t *keyState, key_action_t *action)
         case KeyActionType_SwitchLayer:
             if (!keyState->previous && previousLayer == LayerId_Base && action->switchLayer.mode == SwitchLayerMode_HoldAndDoubleTapToggle) {
                 if (doubleTapSwitchLayerKey) {
-                    if (Timer_GetElapsedTime(&doubleTapSwitchLayerStartTime) < DoubleTapSwitchLayerTimeout) {
+                    if (Timer_GetElapsedTimeAndSetCurrent(&doubleTapSwitchLayerStartTime) < DoubleTapSwitchLayerTimeout) {
                         ToggledLayer = action->switchLayer.layer;
                     }
                     doubleTapSwitchLayerKey = NULL;
@@ -230,12 +247,14 @@ static uint8_t secondaryRoleSlotId;
 static uint8_t secondaryRoleKeyId;
 static secondary_role_t secondaryRole;
 
+#define pos 35
 void updateActiveUsbReports(void)
 {
+    SetDebugBufferUint32(pos, 1);
     memset(activeMouseStates, 0, ACTIVE_MOUSE_STATES_COUNT);
 
     static uint8_t previousModifiers = 0;
-    elapsedTime = Timer_GetElapsedTime(&UsbReportUpdateTime);
+    elapsedTime = Timer_GetElapsedTimeAndSetCurrent(&UsbReportUpdateTime);
 
     basicScancodeIndex = 0;
     mediaScancodeIndex = 0;
@@ -263,6 +282,7 @@ void updateActiveUsbReports(void)
         memcpy(&ActiveUsbSystemKeyboardReport, &MacroSystemKeyboardReport, sizeof MacroSystemKeyboardReport);
         return;
     }
+    SetDebugBufferUint32(pos, 2);
 
     for (uint8_t slotId=0; slotId<SLOT_COUNT; slotId++) {
         for (uint8_t keyId=0; keyId<MAX_KEY_COUNT_PER_MODULE; keyId++) {
@@ -316,8 +336,10 @@ void updateActiveUsbReports(void)
             keyState->previous = keyState->current;
         }
     }
+    SetDebugBufferUint32(pos, 4);
 
     processMouseActions();
+    SetDebugBufferUint32(pos, 5);
 
     // When a layer switcher key gets pressed along with another key that produces some modifiers
     // and the accomanying key gets released then keep the related modifiers active a long as the
@@ -332,6 +354,7 @@ void updateActiveUsbReports(void)
 
     previousModifiers = ActiveUsbBasicKeyboardReport->modifiers;
     previousLayer = activeLayer;
+    SetDebugBufferUint32(pos, 7);
 }
 
 bool UsbBasicKeyboardReportEverSent = false;
@@ -339,8 +362,20 @@ bool UsbMediaKeyboardReportEverSent = false;
 bool UsbSystemKeyboardReportEverSent = false;
 bool UsbMouseReportEverSentEverSent = false;
 
+uint32_t UsbReportUpdateCounter;
+static uint32_t lastUsbUpdateTime;
+
 void UpdateUsbReports(void)
 {
+    UsbReportUpdateCounter++;
+
+    if (Timer_GetElapsedTime(&lastUsbUpdateTime) > 100) {
+        UsbBasicKeyboardReportEverSent = false;
+        UsbMediaKeyboardReportEverSent = false;
+        UsbSystemKeyboardReportEverSent = false;
+        UsbMouseReportEverSentEverSent = false;
+    }
+
     if (IsUsbBasicKeyboardReportSent) {
         UsbBasicKeyboardReportEverSent = true;
     }
@@ -387,4 +422,6 @@ void UpdateUsbReports(void)
     IsUsbMediaKeyboardReportSent = false;
     IsUsbSystemKeyboardReportSent = false;
     IsUsbMouseReportSent = false;
+
+    Timer_SetCurrentTime(&lastUsbUpdateTime);
 }

right/src/usb_report_updater.h

@@ -43,6 +43,7 @@
     } mouse_speed_t;
 
     typedef struct {
+        bool isScroll;
         bool wasMoveAction;
         serialized_mouse_action_t upState;
         serialized_mouse_action_t downState;
@@ -68,6 +69,7 @@
     extern uint16_t DoubleTapSwitchLayerTimeout;
     extern mouse_kinetic_state_t MouseMoveState;
     extern mouse_kinetic_state_t MouseScrollState;
+    extern uint32_t UsbReportUpdateCounter;
 
 // Functions:
 

scripts/package.json

@@ -15,8 +15,8 @@
     "commander": "^2.11.0",
     "shelljs": "^0.7.8"
   },
-  "version": "4.0.0",
-  "dataModelVersion": "3.0.0",
+  "version": "5.0.1",
+  "dataModelVersion": "4.0.0",
   "usbProtocolVersion": "2.0.0",
   "slaveProtocolVersion": "3.0.0",
   "devices": [