Merge branch 'dev' of https://github.com/Lauszus/firmware into Lauszus-dev

2018-06-27 13:44:17 -07:00
parent 5c3e2966c4 8c02f3db53
commit 5d621880ec
14 changed files with 244 additions and 130 deletions
--- a/right/Makefile
+++ b/right/Makefile
@@ -38,7 +38,7 @@ JLINK_SCRIPT = ../scripts/flash-right.jlink
 BUILD_FLAGS = -DCPU_$(PART)_cm4 -DUSB_STACK_BM -DBL_HAS_BOOTLOADER_CONFIG=1

 # Address of the app vector table. The bootloader will take up the flash before this address.
-BL_APP_VECTOR_TABLE_ADDRESS = 0xc000
+BL_APP_VECTOR_TABLE_ADDRESS ?= 0xc000

 # Source files.
 SOURCE = $(wildcard src/*.c) \
--- a/right/build/.cproject
+++ b/right/build/.cproject
@@ -457,4 +457,87 @@
 			<resource resourceType="PROJECT" workspacePath="/uhk-right"/>
 		</configuration>
 	</storageModule>
+	<storageModule moduleId="com.crt.config">
+		<projectStorage>&lt;?xml version="1.0" encoding="UTF-8"?&gt;
+&lt;TargetConfig&gt;
+&lt;Properties property_3="NXP" property_4="MK22FN512xxx12" property_count="5" version="70200"/&gt;
+&lt;infoList vendor="NXP"&gt;&lt;info chip="MK22FN512xxx12" name="MK22FN512xxx12"&gt;&lt;chip&gt;&lt;name&gt;MK22FN512xxx12&lt;/name&gt;
+&lt;family&gt;K2x&lt;/family&gt;
+&lt;vendor&gt;NXP&lt;/vendor&gt;
+&lt;memory can_program="true" id="Flash" is_ro="true" size="512" type="Flash"/&gt;
+&lt;memory id="RAM" size="128" type="RAM"/&gt;
+&lt;memoryInstance derived_from="Flash" driver="FTFA_2K.cfx" id="PROGRAM_FLASH" location="0x0" size="0x80000"/&gt;
+&lt;memoryInstance derived_from="RAM" id="SRAM_UPPER" location="0x20000000" size="0x10000"/&gt;
+&lt;memoryInstance derived_from="RAM" id="SRAM_LOWER" location="0x1fff0000" size="0x10000"/&gt;
+&lt;peripheralInstance derived_from="FTFA_FlashConfig" id="FTFA_FlashConfig" location="0x400"/&gt;
+&lt;peripheralInstance derived_from="DMA" id="DMA" location="0x40008000"/&gt;
+&lt;peripheralInstance derived_from="FB" id="FB" location="0x4000C000"/&gt;
+&lt;peripheralInstance derived_from="FMC" id="FMC" location="0x4001F000"/&gt;
+&lt;peripheralInstance derived_from="FTFA" id="FTFA" location="0x40020000"/&gt;
+&lt;peripheralInstance derived_from="DMAMUX" id="DMAMUX" location="0x40021000"/&gt;
+&lt;peripheralInstance derived_from="FTM0" id="FTM0" location="0x40038000"/&gt;
+&lt;peripheralInstance derived_from="FTM1" id="FTM1" location="0x40039000"/&gt;
+&lt;peripheralInstance derived_from="FTM2" id="FTM2" location="0x4003A000"/&gt;
+&lt;peripheralInstance derived_from="FTM3" id="FTM3" location="0x40026000"/&gt;
+&lt;peripheralInstance derived_from="ADC0" id="ADC0" location="0x4003B000"/&gt;
+&lt;peripheralInstance derived_from="ADC1" id="ADC1" location="0x40027000"/&gt;
+&lt;peripheralInstance derived_from="DAC0" id="DAC0" location="0x4003F000"/&gt;
+&lt;peripheralInstance derived_from="DAC1" id="DAC1" location="0x40028000"/&gt;
+&lt;peripheralInstance derived_from="RNG" id="RNG" location="0x40029000"/&gt;
+&lt;peripheralInstance derived_from="LPUART0" id="LPUART0" location="0x4002A000"/&gt;
+&lt;peripheralInstance derived_from="SPI0" id="SPI0" location="0x4002C000"/&gt;
+&lt;peripheralInstance derived_from="SPI1" id="SPI1" location="0x4002D000"/&gt;
+&lt;peripheralInstance derived_from="I2S0" id="I2S0" location="0x4002F000"/&gt;
+&lt;peripheralInstance derived_from="CRC" id="CRC" location="0x40032000"/&gt;
+&lt;peripheralInstance derived_from="PDB0" id="PDB0" location="0x40036000"/&gt;
+&lt;peripheralInstance derived_from="PIT" id="PIT" location="0x40037000"/&gt;
+&lt;peripheralInstance derived_from="RTC" id="RTC" location="0x4003D000"/&gt;
+&lt;peripheralInstance derived_from="RFVBAT" id="RFVBAT" location="0x4003E000"/&gt;
+&lt;peripheralInstance derived_from="LPTMR0" id="LPTMR0" location="0x40040000"/&gt;
+&lt;peripheralInstance derived_from="RFSYS" id="RFSYS" location="0x40041000"/&gt;
+&lt;peripheralInstance derived_from="SIM" id="SIM" location="0x40047000"/&gt;
+&lt;peripheralInstance derived_from="PORTA" id="PORTA" location="0x40049000"/&gt;
+&lt;peripheralInstance derived_from="PORTB" id="PORTB" location="0x4004A000"/&gt;
+&lt;peripheralInstance derived_from="PORTC" id="PORTC" location="0x4004B000"/&gt;
+&lt;peripheralInstance derived_from="PORTD" id="PORTD" location="0x4004C000"/&gt;
+&lt;peripheralInstance derived_from="PORTE" id="PORTE" location="0x4004D000"/&gt;
+&lt;peripheralInstance derived_from="WDOG" id="WDOG" location="0x40052000"/&gt;
+&lt;peripheralInstance derived_from="EWM" id="EWM" location="0x40061000"/&gt;
+&lt;peripheralInstance derived_from="MCG" id="MCG" location="0x40064000"/&gt;
+&lt;peripheralInstance derived_from="OSC" id="OSC" location="0x40065000"/&gt;
+&lt;peripheralInstance derived_from="I2C0" id="I2C0" location="0x40066000"/&gt;
+&lt;peripheralInstance derived_from="I2C1" id="I2C1" location="0x40067000"/&gt;
+&lt;peripheralInstance derived_from="UART0" id="UART0" location="0x4006A000"/&gt;
+&lt;peripheralInstance derived_from="UART1" id="UART1" location="0x4006B000"/&gt;
+&lt;peripheralInstance derived_from="UART2" id="UART2" location="0x4006C000"/&gt;
+&lt;peripheralInstance derived_from="USB0" id="USB0" location="0x40072000"/&gt;
+&lt;peripheralInstance derived_from="CMP0" id="CMP0" location="0x40073000"/&gt;
+&lt;peripheralInstance derived_from="CMP1" id="CMP1" location="0x40073008"/&gt;
+&lt;peripheralInstance derived_from="VREF" id="VREF" location="0x40074000"/&gt;
+&lt;peripheralInstance derived_from="LLWU" id="LLWU" location="0x4007C000"/&gt;
+&lt;peripheralInstance derived_from="PMC" id="PMC" location="0x4007D000"/&gt;
+&lt;peripheralInstance derived_from="SMC" id="SMC" location="0x4007E000"/&gt;
+&lt;peripheralInstance derived_from="RCM" id="RCM" location="0x4007F000"/&gt;
+&lt;peripheralInstance derived_from="GPIOA" id="GPIOA" location="0x400FF000"/&gt;
+&lt;peripheralInstance derived_from="GPIOB" id="GPIOB" location="0x400FF040"/&gt;
+&lt;peripheralInstance derived_from="GPIOC" id="GPIOC" location="0x400FF080"/&gt;
+&lt;peripheralInstance derived_from="GPIOD" id="GPIOD" location="0x400FF0C0"/&gt;
+&lt;peripheralInstance derived_from="GPIOE" id="GPIOE" location="0x400FF100"/&gt;
+&lt;peripheralInstance derived_from="SystemControl" id="SystemControl" location="0xE000E000"/&gt;
+&lt;peripheralInstance derived_from="SysTick" id="SysTick" location="0xE000E010"/&gt;
+&lt;peripheralInstance derived_from="NVIC" id="NVIC" location="0xE000E100"/&gt;
+&lt;peripheralInstance derived_from="MCM" id="MCM" location="0xE0080000"/&gt;
+&lt;/chip&gt;
+&lt;processor&gt;&lt;name gcc_name="cortex-m4"&gt;Cortex-M4&lt;/name&gt;
+&lt;family&gt;Cortex-M&lt;/family&gt;
+&lt;/processor&gt;
+&lt;link href="MK22F51212_internal_peripheral.xml" show="embed" type="simple"/&gt;
+&lt;/info&gt;
+&lt;/infoList&gt;
+&lt;/TargetConfig&gt;</projectStorage>
+	</storageModule>
+	<storageModule moduleId="com.nxp.mcuxpresso.core.datamodels">
+		<sdkName>SDK_2.x_MK22FN512xxx12</sdkName>
+		<sdkVersion>2.3.1</sdkVersion>
+	</storageModule>
 </cproject>
--- a/right/src/main.c
+++ b/right/src/main.c
@@ -45,7 +45,6 @@ int main(void)
        InitSlaveScheduler();
        KeyMatrix_Init(&RightKeyMatrix);
        InitKeyScanner();
-        UpdateUsbReports();
        InitUsb();

        while (1) {
--- a/right/src/timer.c
+++ b/right/src/timer.c
@@ -1,12 +1,15 @@
 #include "fsl_pit.h"
 #include "timer.h"
+#include "peripherals/test_led.h"

 static volatile uint32_t CurrentTime;
+static uint32_t timerClockFrequency;

 void PIT_TIMER_HANDLER(void)
 {
    CurrentTime++;
-    PIT_ClearStatusFlags(PIT, PIT_TIMER_CHANNEL, PIT_TFLG_TIF_MASK);
+    //TEST_LED_TOGGLE();
+    PIT_ClearStatusFlags(PIT, PIT_TIMER_CHANNEL, kPIT_TimerFlag);
 }

 void Timer_Init(void)
@@ -15,9 +18,8 @@ void Timer_Init(void)
    PIT_GetDefaultConfig(&pitConfig);
    PIT_Init(PIT, &pitConfig);

-    // TODO: Why the interval needs to be multiplied by two to arrive to the correct timing?
-    // Figure it out and clean this up.
-    PIT_SetTimerPeriod(PIT, PIT_TIMER_CHANNEL, MSEC_TO_COUNT(TIMER_INTERVAL_MSEC*2, PIT_SOURCE_CLOCK));
+    timerClockFrequency = PIT_SOURCE_CLOCK;
+    PIT_SetTimerPeriod(PIT, PIT_TIMER_CHANNEL, MSEC_TO_COUNT(TIMER_INTERVAL_MSEC, timerClockFrequency));

    PIT_EnableInterrupts(PIT, PIT_TIMER_CHANNEL, kPIT_TimerInterruptEnable);
    EnableIRQ(PIT_TIMER_IRQ_ID);
@@ -28,20 +30,50 @@ uint32_t Timer_GetCurrentTime() {
    return CurrentTime;
 }

+uint32_t Timer_GetCurrentTimeMicros() {
+    uint32_t primask, count, ms;
+    primask = DisableGlobalIRQ(); // Make sure the read is atomic
+    count = PIT_GetCurrentTimerCount(PIT, PIT_TIMER_CHANNEL); // Read the current timer count
+    ms = CurrentTime; // Read the overflow counter
+    EnableGlobalIRQ(primask); // Enable interrupts again if they where enabled before - this should make it interrupt safe
+
+    // Calculate the counter value in microseconds - note that the PIT timer is counting downward, so we need to subtract the count from the period value
+    uint32_t us = 1000U * TIMER_INTERVAL_MSEC - COUNT_TO_USEC(count, timerClockFrequency);
+    return ms * 1000U * TIMER_INTERVAL_MSEC + us;
+}
+
 void Timer_SetCurrentTime(uint32_t *time)
 {
-    *time = CurrentTime;
+    *time = Timer_GetCurrentTime();
+}
+
+void Timer_SetCurrentTimeMicros(uint32_t *time)
+{
+    *time = Timer_GetCurrentTimeMicros();
 }

 uint32_t Timer_GetElapsedTime(uint32_t *time)
 {
-    uint32_t elapsedTime = CurrentTime - *time;
+    uint32_t elapsedTime = Timer_GetCurrentTime() - *time;
+    return elapsedTime;
+}
+
+uint32_t Timer_GetElapsedTimeMicros(uint32_t *time)
+{
+    uint32_t elapsedTime = Timer_GetCurrentTimeMicros() - *time;
    return elapsedTime;
 }

 uint32_t Timer_GetElapsedTimeAndSetCurrent(uint32_t *time)
 {
    uint32_t elapsedTime = Timer_GetElapsedTime(time);
-    *time = CurrentTime;
+    *time = Timer_GetCurrentTime();
+    return elapsedTime;
+}
+
+uint32_t Timer_GetElapsedTimeAndSetCurrentMicros(uint32_t *time)
+{
+    uint32_t elapsedTime = Timer_GetElapsedTimeMicros(time);
+    *time = Timer_GetCurrentTimeMicros();
    return elapsedTime;
 }
--- a/right/src/timer.h
+++ b/right/src/timer.h
@@ -13,8 +13,12 @@

    void Timer_Init(void);
    uint32_t Timer_GetCurrentTime();
+    uint32_t Timer_GetCurrentTimeMicros();
    void Timer_SetCurrentTime(uint32_t *time);
+    void Timer_SetCurrentTimeMicros(uint32_t *time);
    uint32_t Timer_GetElapsedTime(uint32_t *time);
+    uint32_t Timer_GetElapsedTimeMicros(uint32_t *time);
    uint32_t Timer_GetElapsedTimeAndSetCurrent(uint32_t *time);
+    uint32_t Timer_GetElapsedTimeAndSetCurrentMicros(uint32_t *time);

 #endif
--- a/right/src/usb_interfaces/usb_interface_basic_keyboard.c
+++ b/right/src/usb_interfaces/usb_interface_basic_keyboard.c
@@ -4,17 +4,16 @@
 static usb_basic_keyboard_report_t usbBasicKeyboardReports[2];
 uint32_t UsbBasicKeyboardActionCounter;
 usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport = usbBasicKeyboardReports;
-volatile bool IsUsbBasicKeyboardReportSent = false;
 static uint8_t usbBasicKeyboardInBuffer[USB_BASIC_KEYBOARD_REPORT_LENGTH];

-static usb_basic_keyboard_report_t* getInactiveUsbBasicKeyboardReport(void)
+usb_basic_keyboard_report_t* GetInactiveUsbBasicKeyboardReport(void)
 {
    return ActiveUsbBasicKeyboardReport == usbBasicKeyboardReports ? usbBasicKeyboardReports+1 : usbBasicKeyboardReports;
 }

-void SwitchActiveUsbBasicKeyboardReport(void)
+static void SwitchActiveUsbBasicKeyboardReport(void)
 {
-    ActiveUsbBasicKeyboardReport = getInactiveUsbBasicKeyboardReport();
+    ActiveUsbBasicKeyboardReport = GetInactiveUsbBasicKeyboardReport();
 }

 void ResetActiveUsbBasicKeyboardReport(void)
@@ -22,14 +21,20 @@ void ResetActiveUsbBasicKeyboardReport(void)
    bzero(ActiveUsbBasicKeyboardReport, USB_BASIC_KEYBOARD_REPORT_LENGTH);
 }

-static usb_status_t UsbBasicKeyboardAction(void)
+usb_status_t UsbBasicKeyboardAction(void)
 {
-    usb_status_t status = USB_DeviceHidSend(
-        UsbCompositeDevice.basicKeyboardHandle, USB_BASIC_KEYBOARD_ENDPOINT_INDEX,
-        (uint8_t*)getInactiveUsbBasicKeyboardReport(), USB_BASIC_KEYBOARD_REPORT_LENGTH);
-    IsUsbBasicKeyboardReportSent = true;
+    if (((usb_device_hid_struct_t *)UsbCompositeDevice.basicKeyboardHandle)->interruptInPipeBusy)
+        return kStatus_USB_Busy; // The previous report has not been sent yet
+
    UsbBasicKeyboardActionCounter++;
-    return status;
+    SwitchActiveUsbBasicKeyboardReport(); // Switch the active report
+    usb_status_t usb_status = USB_DeviceHidSend(
+            UsbCompositeDevice.basicKeyboardHandle, USB_BASIC_KEYBOARD_ENDPOINT_INDEX,
+            (uint8_t*)GetInactiveUsbBasicKeyboardReport(), USB_BASIC_KEYBOARD_REPORT_LENGTH);
+    if (usb_status != kStatus_USB_Success) {
+        SwitchActiveUsbBasicKeyboardReport(); // Switch back, as the command failed
+    }
+    return usb_status;
 }

 usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
@@ -37,11 +42,11 @@ usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, voi
    usb_status_t error = kStatus_USB_Error;

    switch (event) {
+        // This report is received when the report has been sent
        case kUSB_DeviceHidEventSendResponse:
-            if (UsbCompositeDevice.attach) {
-                return UsbBasicKeyboardAction();
-            }
+            error = kStatus_USB_Success;
            break;
+        case kUSB_DeviceHidEventRecvResponse:
        case kUSB_DeviceHidEventGetReport:
            error = kStatus_USB_InvalidRequest;
            break;
@@ -61,7 +66,7 @@ usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, voi
                report->reportBuffer = usbBasicKeyboardInBuffer;
                error = kStatus_USB_Success;
            } else {
-                error = kStatus_USB_InvalidRequest;
+                error = kStatus_USB_AllocFail;
            }
            break;
        }
@@ -79,16 +84,10 @@ usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, voi

 usb_status_t UsbBasicKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration)
 {
-    if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
-        return UsbBasicKeyboardAction();
-    }
    return kStatus_USB_Error;
 }

 usb_status_t UsbBasicKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
 {
-    if (USB_BASIC_KEYBOARD_INTERFACE_INDEX == interface) {
-        return UsbBasicKeyboardAction();
-    }
    return kStatus_USB_Error;
 }
--- a/right/src/usb_interfaces/usb_interface_basic_keyboard.h
+++ b/right/src/usb_interfaces/usb_interface_basic_keyboard.h
@@ -31,7 +31,6 @@

 // Variables:

-    extern volatile bool IsUsbBasicKeyboardReportSent;
    extern uint32_t UsbBasicKeyboardActionCounter;
    extern usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport;

@@ -42,6 +41,7 @@
    usb_status_t UsbBasicKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);

    void ResetActiveUsbBasicKeyboardReport(void);
-    void SwitchActiveUsbBasicKeyboardReport(void);
+    usb_basic_keyboard_report_t* GetInactiveUsbBasicKeyboardReport(void);
+    usb_status_t UsbBasicKeyboardAction(void);

 #endif
--- a/right/src/usb_interfaces/usb_interface_media_keyboard.c
+++ b/right/src/usb_interfaces/usb_interface_media_keyboard.c
@@ -3,16 +3,15 @@
 uint32_t UsbMediaKeyboardActionCounter;
 static usb_media_keyboard_report_t usbMediaKeyboardReports[2];
 usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport = usbMediaKeyboardReports;
-volatile bool IsUsbMediaKeyboardReportSent = false;

-static usb_media_keyboard_report_t* getInactiveUsbMediaKeyboardReport(void)
+usb_media_keyboard_report_t* GetInactiveUsbMediaKeyboardReport(void)
 {
    return ActiveUsbMediaKeyboardReport == usbMediaKeyboardReports ? usbMediaKeyboardReports+1 : usbMediaKeyboardReports;
 }

-void SwitchActiveUsbMediaKeyboardReport(void)
+static void SwitchActiveUsbMediaKeyboardReport(void)
 {
-    ActiveUsbMediaKeyboardReport = getInactiveUsbMediaKeyboardReport();
+    ActiveUsbMediaKeyboardReport = GetInactiveUsbMediaKeyboardReport();
 }

 void ResetActiveUsbMediaKeyboardReport(void)
@@ -20,14 +19,20 @@ void ResetActiveUsbMediaKeyboardReport(void)
    bzero(ActiveUsbMediaKeyboardReport, USB_MEDIA_KEYBOARD_REPORT_LENGTH);
 }

-static usb_status_t UsbMediaKeyboardAction(void)
+usb_status_t UsbMediaKeyboardAction(void)
 {
-    usb_status_t status = USB_DeviceHidSend(
-        UsbCompositeDevice.mediaKeyboardHandle, USB_MEDIA_KEYBOARD_ENDPOINT_INDEX,
-        (uint8_t*)getInactiveUsbMediaKeyboardReport(), USB_MEDIA_KEYBOARD_REPORT_LENGTH);
-    IsUsbMediaKeyboardReportSent = true;
+    if (((usb_device_hid_struct_t *)UsbCompositeDevice.mediaKeyboardHandle)->interruptInPipeBusy)
+        return kStatus_USB_Busy; // The previous report has not been sent yet
+
    UsbMediaKeyboardActionCounter++;
-    return status;
+    SwitchActiveUsbMediaKeyboardReport(); // Switch the active report
+    usb_status_t usb_status = USB_DeviceHidSend(
+            UsbCompositeDevice.mediaKeyboardHandle, USB_MEDIA_KEYBOARD_ENDPOINT_INDEX,
+            (uint8_t*)GetInactiveUsbMediaKeyboardReport(), USB_MEDIA_KEYBOARD_REPORT_LENGTH);
+    if (usb_status != kStatus_USB_Success) {
+        SwitchActiveUsbMediaKeyboardReport(); // Switch back, as the command failed
+    }
+    return usb_status;
 }

 usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
@@ -35,11 +40,11 @@ usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, voi
    usb_status_t error = kStatus_USB_Error;

    switch (event) {
+        // This report is received when the report has been sent
        case kUSB_DeviceHidEventSendResponse:
-            if (UsbCompositeDevice.attach) {
-                return UsbMediaKeyboardAction();
-            }
+            error = kStatus_USB_Success;
            break;
+        case kUSB_DeviceHidEventRecvResponse:
        case kUSB_DeviceHidEventGetReport:
        case kUSB_DeviceHidEventSetReport:
        case kUSB_DeviceHidEventRequestReportBuffer:
@@ -59,16 +64,10 @@ usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, voi

 usb_status_t UsbMediaKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration)
 {
-    if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
-        return UsbMediaKeyboardAction();
-    }
    return kStatus_USB_Error;
 }

 usb_status_t UsbMediaKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
 {
-    if (USB_MEDIA_KEYBOARD_INTERFACE_INDEX == interface) {
-        return UsbMediaKeyboardAction();
-    }
    return kStatus_USB_Error;
 }
--- a/right/src/usb_interfaces/usb_interface_media_keyboard.h
+++ b/right/src/usb_interfaces/usb_interface_media_keyboard.h
@@ -28,7 +28,6 @@

 // Variables:

-    extern volatile bool IsUsbMediaKeyboardReportSent;
    extern uint32_t UsbMediaKeyboardActionCounter;
    extern usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport;

@@ -39,6 +38,7 @@
    usb_status_t UsbMediaKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);

    void ResetActiveUsbMediaKeyboardReport(void);
-    void SwitchActiveUsbMediaKeyboardReport(void);
+    usb_media_keyboard_report_t* GetInactiveUsbMediaKeyboardReport(void);
+    usb_status_t UsbMediaKeyboardAction();

 #endif
--- a/right/src/usb_interfaces/usb_interface_mouse.c
+++ b/right/src/usb_interfaces/usb_interface_mouse.c
@@ -3,16 +3,15 @@
 uint32_t UsbMouseActionCounter;
 static usb_mouse_report_t usbMouseReports[2];
 usb_mouse_report_t* ActiveUsbMouseReport = usbMouseReports;
-volatile bool IsUsbMouseReportSent = false;

-static usb_mouse_report_t* getInactiveUsbMouseReport(void)
+usb_mouse_report_t* GetInactiveUsbMouseReport(void)
 {
    return ActiveUsbMouseReport == usbMouseReports ? usbMouseReports+1 : usbMouseReports;
 }

-void SwitchActiveUsbMouseReport(void)
+static void SwitchActiveUsbMouseReport(void)
 {
-    ActiveUsbMouseReport = getInactiveUsbMouseReport();
+    ActiveUsbMouseReport = GetInactiveUsbMouseReport();
 }

 void ResetActiveUsbMouseReport(void)
@@ -20,25 +19,32 @@ void ResetActiveUsbMouseReport(void)
    bzero(ActiveUsbMouseReport, USB_MOUSE_REPORT_LENGTH);
 }

-static volatile usb_status_t usbMouseAction(void)
+usb_status_t usbMouseAction(void)
 {
-    usb_mouse_report_t *mouseReport = getInactiveUsbMouseReport();
-    IsUsbMouseReportSent = true;
-    return USB_DeviceHidSend(UsbCompositeDevice.mouseHandle, USB_MOUSE_ENDPOINT_INDEX,
-               (uint8_t*)mouseReport, USB_MOUSE_REPORT_LENGTH);
+    if (((usb_device_hid_struct_t *)UsbCompositeDevice.mouseHandle)->interruptInPipeBusy)
+        return kStatus_USB_Busy; // The previous report has not been sent yet
+
+    UsbMouseActionCounter++;
+    SwitchActiveUsbMouseReport(); // Switch the active report
+    usb_status_t usb_status = USB_DeviceHidSend(
+            UsbCompositeDevice.mouseHandle, USB_MOUSE_ENDPOINT_INDEX,
+            (uint8_t*)GetInactiveUsbMouseReport(), USB_MOUSE_REPORT_LENGTH);
+    if (usb_status != kStatus_USB_Success) {
+        SwitchActiveUsbMouseReport(); // Switch back, as the command failed
+    }
+    return usb_status;
 }

 usb_status_t UsbMouseCallback(class_handle_t handle, uint32_t event, void *param)
 {
-    UsbMouseActionCounter++;
    usb_status_t error = kStatus_USB_Error;

    switch (event) {
+        // This report is received when the report has been sent
        case kUSB_DeviceHidEventSendResponse:
-            if (UsbCompositeDevice.attach) {
-                return usbMouseAction();
-            }
+            error = kStatus_USB_Success;
            break;
+        case kUSB_DeviceHidEventRecvResponse:
        case kUSB_DeviceHidEventGetReport:
        case kUSB_DeviceHidEventSetReport:
        case kUSB_DeviceHidEventRequestReportBuffer:
@@ -58,16 +64,10 @@ usb_status_t UsbMouseCallback(class_handle_t handle, uint32_t event, void *param

 usb_status_t UsbMouseSetConfiguration(class_handle_t handle, uint8_t configuration)
 {
-    if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
-        return usbMouseAction();
-    }
    return kStatus_USB_Error;
 }

 usb_status_t UsbMouseSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
 {
-    if (USB_MOUSE_INTERFACE_INDEX == interface) {
-        return usbMouseAction();
-    }
    return kStatus_USB_Error;
 }
--- a/right/src/usb_interfaces/usb_interface_mouse.h
+++ b/right/src/usb_interfaces/usb_interface_mouse.h
@@ -31,7 +31,6 @@

 // Variables:

-    extern volatile bool IsUsbMouseReportSent;
    extern uint32_t UsbMouseActionCounter;
    extern usb_mouse_report_t* ActiveUsbMouseReport;

@@ -42,6 +41,7 @@
    usb_status_t UsbMouseSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);

    void ResetActiveUsbMouseReport(void);
-    void SwitchActiveUsbMouseReport(void);
+    usb_mouse_report_t* GetInactiveUsbMouseReport(void);
+    usb_status_t usbMouseAction(void);

 #endif
--- a/right/src/usb_interfaces/usb_interface_system_keyboard.c
+++ b/right/src/usb_interfaces/usb_interface_system_keyboard.c
@@ -3,16 +3,15 @@
 uint32_t UsbSystemKeyboardActionCounter;
 static usb_system_keyboard_report_t usbSystemKeyboardReports[2];
 usb_system_keyboard_report_t* ActiveUsbSystemKeyboardReport = usbSystemKeyboardReports;
-volatile bool IsUsbSystemKeyboardReportSent = false;

-static usb_system_keyboard_report_t* getInactiveUsbSystemKeyboardReport()
+usb_system_keyboard_report_t* GetInactiveUsbSystemKeyboardReport()
 {
    return ActiveUsbSystemKeyboardReport == usbSystemKeyboardReports ? usbSystemKeyboardReports+1 : usbSystemKeyboardReports;
 }

-void SwitchActiveUsbSystemKeyboardReport(void)
+static void SwitchActiveUsbSystemKeyboardReport(void)
 {
-    ActiveUsbSystemKeyboardReport = getInactiveUsbSystemKeyboardReport();
+    ActiveUsbSystemKeyboardReport = GetInactiveUsbSystemKeyboardReport();
 }

 void ResetActiveUsbSystemKeyboardReport(void)
@@ -20,14 +19,20 @@ void ResetActiveUsbSystemKeyboardReport(void)
    bzero(ActiveUsbSystemKeyboardReport, USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
 }

-static usb_status_t UsbSystemKeyboardAction(void)
+usb_status_t UsbSystemKeyboardAction(void)
 {
-    usb_status_t status = USB_DeviceHidSend(
-        UsbCompositeDevice.systemKeyboardHandle, USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX,
-        (uint8_t*)getInactiveUsbSystemKeyboardReport(), USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
-    IsUsbSystemKeyboardReportSent = true;
+    if (((usb_device_hid_struct_t *)UsbCompositeDevice.systemKeyboardHandle)->interruptInPipeBusy)
+        return kStatus_USB_Busy; // The previous report has not been sent yet
+
    UsbSystemKeyboardActionCounter++;
-    return status;
+    SwitchActiveUsbSystemKeyboardReport(); // Switch the active report
+    usb_status_t usb_status = USB_DeviceHidSend(
+            UsbCompositeDevice.systemKeyboardHandle, USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX,
+            (uint8_t*)GetInactiveUsbSystemKeyboardReport(), USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
+    if (usb_status != kStatus_USB_Success) {
+        SwitchActiveUsbSystemKeyboardReport(); // Switch back, as the command failed
+    }
+    return usb_status;
 }

 usb_status_t UsbSystemKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
@@ -35,11 +40,11 @@ usb_status_t UsbSystemKeyboardCallback(class_handle_t handle, uint32_t event, vo
    usb_status_t error = kStatus_USB_Error;

    switch (event) {
+        // This report is received when the report has been sent
        case kUSB_DeviceHidEventSendResponse:
-            if (UsbCompositeDevice.attach) {
-                return UsbSystemKeyboardAction();
-            }
+            error = kStatus_USB_Success;
            break;
+        case kUSB_DeviceHidEventRecvResponse:
        case kUSB_DeviceHidEventGetReport:
        case kUSB_DeviceHidEventSetReport:
        case kUSB_DeviceHidEventRequestReportBuffer:
@@ -59,16 +64,10 @@ usb_status_t UsbSystemKeyboardCallback(class_handle_t handle, uint32_t event, vo

 usb_status_t UsbSystemKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration)
 {
-    if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
-        return UsbSystemKeyboardAction();
-    }
    return kStatus_USB_Error;
 }

 usb_status_t UsbSystemKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
 {
-    if (USB_SYSTEM_KEYBOARD_INTERFACE_INDEX == interface) {
-        return UsbSystemKeyboardAction();
-    }
    return kStatus_USB_Error;
 }
--- a/right/src/usb_interfaces/usb_interface_system_keyboard.h
+++ b/right/src/usb_interfaces/usb_interface_system_keyboard.h
@@ -29,7 +29,6 @@

 // Variables:

-    extern volatile bool IsUsbSystemKeyboardReportSent;
    extern uint32_t UsbSystemKeyboardActionCounter;
    extern usb_system_keyboard_report_t* ActiveUsbSystemKeyboardReport;

@@ -40,6 +39,7 @@
    usb_status_t UsbSystemKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);

    void ResetActiveUsbSystemKeyboardReport(void);
-    void SwitchActiveUsbSystemKeyboardReport(void);
+    usb_system_keyboard_report_t* GetInactiveUsbSystemKeyboardReport();
+    usb_status_t UsbSystemKeyboardAction(void);

 #endif
--- a/right/src/usb_report_updater.c
+++ b/right/src/usb_report_updater.c
@@ -285,6 +285,8 @@ static uint8_t secondaryRoleState = SecondaryRoleState_Released;
 static uint8_t secondaryRoleSlotId;
 static uint8_t secondaryRoleKeyId;
 static secondary_role_t secondaryRole;
+static bool simulateKeypresses = false;
+static bool sendChar = false;

 static void updateActiveUsbReports(void)
 {
@@ -319,6 +321,16 @@ static void updateActiveUsbReports(void)
        return;
    }

+    key_state_t *testKeyState = &KeyStates[SlotId_LeftKeyboardHalf][0];
+    if (!testKeyState->previous && testKeyState->current && activeLayer == LayerId_Fn) {
+        simulateKeypresses = !simulateKeypresses;
+    }
+
+    if (simulateKeypresses) {
+        sendChar = !sendChar;
+        ActiveUsbBasicKeyboardReport->scancodes[basicScancodeIndex++] = sendChar ? HID_KEYBOARD_SC_A : HID_KEYBOARD_SC_B;
+    }
+
    for (uint8_t slotId=0; slotId<SLOT_COUNT; slotId++) {
        for (uint8_t keyId=0; keyId<MAX_KEY_COUNT_PER_MODULE; keyId++) {
            key_state_t *keyState = &KeyStates[slotId][keyId];
@@ -390,27 +402,20 @@ static void updateActiveUsbReports(void)
 }

 uint32_t UsbReportUpdateCounter;
-static uint32_t lastMouseUpdateTime;
+static uint32_t lastMouseUpdateTimeMicros;

 void UpdateUsbReports(void)
 {
    UsbReportUpdateCounter++;
-
-    // Process the key inputs at a constant rate when moving the mouse, so the mouse speed is consistent.
-    bool hasActiveMouseState = false;
-    for (uint8_t i=0; i<ACTIVE_MOUSE_STATES_COUNT; i++) {
-        hasActiveMouseState = true;
-        break;
-    }
-
-    if (hasActiveMouseState) {
-        if (Timer_GetElapsedTime(&lastMouseUpdateTime) < USB_MOUSE_INTERRUPT_IN_INTERVAL) {
-            return;
-        }
-        Timer_SetCurrentTime(&lastMouseUpdateTime);
-    } else if (!IsUsbBasicKeyboardReportSent || !IsUsbMediaKeyboardReportSent || !IsUsbSystemKeyboardReportSent || !IsUsbMouseReportSent) {
+    if (((usb_device_hid_struct_t *)UsbCompositeDevice.basicKeyboardHandle)->interruptInPipeBusy ||
+            ((usb_device_hid_struct_t *)UsbCompositeDevice.mediaKeyboardHandle)->interruptInPipeBusy ||
+            ((usb_device_hid_struct_t *)UsbCompositeDevice.systemKeyboardHandle)->interruptInPipeBusy ||
+            ((usb_device_hid_struct_t *)UsbCompositeDevice.mouseHandle)->interruptInPipeBusy) {
+        return;
+    } else if (Timer_GetElapsedTimeMicros(&lastMouseUpdateTimeMicros) < 1000U * USB_BASIC_KEYBOARD_INTERRUPT_IN_INTERVAL) {
        return;
    }
+    Timer_SetCurrentTimeMicros(&lastMouseUpdateTimeMicros);

    ResetActiveUsbBasicKeyboardReport();
    ResetActiveUsbMediaKeyboardReport();
@@ -419,35 +424,29 @@ void UpdateUsbReports(void)

    updateActiveUsbReports();

-    static usb_basic_keyboard_report_t last_basic_report = { .scancodes[0] = 0xFF };
-    if (memcmp(ActiveUsbBasicKeyboardReport, &last_basic_report, sizeof(usb_basic_keyboard_report_t)) != 0) {
-        last_basic_report = *ActiveUsbBasicKeyboardReport;
-        SwitchActiveUsbBasicKeyboardReport();
-        IsUsbBasicKeyboardReportSent = false;
+    bool HasUsbBasicKeyboardReportChanged = memcmp(ActiveUsbBasicKeyboardReport, GetInactiveUsbBasicKeyboardReport(), sizeof(usb_basic_keyboard_report_t)) != 0;
+    if (HasUsbBasicKeyboardReportChanged) {
+        UsbBasicKeyboardAction();
    }

-    static usb_media_keyboard_report_t last_media_report = { .scancodes[0] = 0xFF };
-    if (memcmp(ActiveUsbMediaKeyboardReport, &last_media_report, sizeof(usb_media_keyboard_report_t)) != 0) {
-        last_media_report = *ActiveUsbMediaKeyboardReport;
-        SwitchActiveUsbMediaKeyboardReport();
-        IsUsbMediaKeyboardReportSent = false;
+    bool HasUsbMediaKeyboardReportChanged = memcmp(ActiveUsbMediaKeyboardReport, GetInactiveUsbMediaKeyboardReport(), sizeof(usb_media_keyboard_report_t)) != 0;
+    if (HasUsbMediaKeyboardReportChanged) {
+        UsbMediaKeyboardAction();
    }

-    static usb_system_keyboard_report_t last_system_report = { .scancodes[0] = 0xFF };
-    if (memcmp(ActiveUsbSystemKeyboardReport, &last_system_report, sizeof(usb_system_keyboard_report_t)) != 0) {
-        last_system_report = *ActiveUsbSystemKeyboardReport;
-        SwitchActiveUsbSystemKeyboardReport();
-        IsUsbSystemKeyboardReportSent = false;
+    bool HasUsbSystemKeyboardReportChanged = memcmp(ActiveUsbSystemKeyboardReport, GetInactiveUsbSystemKeyboardReport(), sizeof(usb_system_keyboard_report_t)) != 0;
+    if (HasUsbSystemKeyboardReportChanged) {
+        UsbSystemKeyboardAction();
    }

-    static usb_mouse_report_t last_mouse_report = { .buttons = 0xFF };
-    if (memcmp(ActiveUsbMouseReport, &last_mouse_report, sizeof(usb_mouse_report_t)) != 0) {
-        last_mouse_report = *ActiveUsbMouseReport;
-        SwitchActiveUsbMouseReport();
-        IsUsbMouseReportSent = false;
+    // Send out the mouse position and wheel values continuously if the report is not zeros, but only send the mouse button states when they change.
+    bool HasUsbMouseReportChanged = memcmp(ActiveUsbMouseReport, GetInactiveUsbMouseReport(), sizeof(usb_mouse_report_t)) != 0;
+    if (HasUsbMouseReportChanged || ActiveUsbMouseReport->x || ActiveUsbMouseReport->y ||
+            ActiveUsbMouseReport->wheelX || ActiveUsbMouseReport->wheelY) {
+        usbMouseAction();
    }

-    if ((previousLayer != LayerId_Base || !IsUsbBasicKeyboardReportSent || !IsUsbMediaKeyboardReportSent || !IsUsbSystemKeyboardReportSent || !IsUsbMouseReportSent) && IsHostSleeping) {
+    if (IsHostSleeping && (previousLayer != LayerId_Base || HasUsbBasicKeyboardReportChanged || HasUsbMediaKeyboardReportChanged || HasUsbSystemKeyboardReportChanged || HasUsbMouseReportChanged)) {
        WakeUpHost(true); // Wake up the host if any key is pressed and the computer is sleeping.
    }
 }