Make sure we do not try to send another report before the old one has finished sending

right/src/usb_interfaces/usb_interface_basic_keyboard.c

@@ -5,6 +5,7 @@ static usb_basic_keyboard_report_t usbBasicKeyboardReports[2];
 uint32_t UsbBasicKeyboardActionCounter;
 usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport = usbBasicKeyboardReports;
 static uint8_t usbBasicKeyboardInBuffer[USB_BASIC_KEYBOARD_REPORT_LENGTH];
+static volatile bool sendUsbBasicKeyboardReportCompleted = true;
 
 usb_basic_keyboard_report_t* GetInactiveUsbBasicKeyboardReport(void)
 {
@@ -23,12 +24,17 @@ void ResetActiveUsbBasicKeyboardReport(void)
 
 usb_status_t UsbBasicKeyboardAction(void)
 {
+    if (!sendUsbBasicKeyboardReportCompleted)
+        return kStatus_USB_Busy; // The previous report has not been sent yet
+
     UsbBasicKeyboardActionCounter++;
+    SwitchActiveUsbBasicKeyboardReport(); // Switch the active report
     usb_status_t usb_status = USB_DeviceHidSend(
             UsbCompositeDevice.basicKeyboardHandle, USB_BASIC_KEYBOARD_ENDPOINT_INDEX,
-            (uint8_t*)ActiveUsbBasicKeyboardReport, USB_BASIC_KEYBOARD_REPORT_LENGTH);
+            (uint8_t*)GetInactiveUsbBasicKeyboardReport(), USB_BASIC_KEYBOARD_REPORT_LENGTH);
-    if (usb_status == kStatus_USB_Success)
+    if (usb_status == kStatus_USB_Success) {
-        SwitchActiveUsbBasicKeyboardReport(); // Switch the active report if the data was sent successfully
+        sendUsbBasicKeyboardReportCompleted = false;
+    }
     return usb_status;
 }
 
@@ -37,7 +43,12 @@ 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:
+            sendUsbBasicKeyboardReportCompleted = true;
+            error = kStatus_USB_Success;
+            break;
+        case kUSB_DeviceHidEventRecvResponse:
         case kUSB_DeviceHidEventGetReport:
             error = kStatus_USB_InvalidRequest;
             break;
@@ -57,7 +68,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;
         }

right/src/usb_interfaces/usb_interface_media_keyboard.c

@@ -3,6 +3,7 @@
 uint32_t UsbMediaKeyboardActionCounter;
 static usb_media_keyboard_report_t usbMediaKeyboardReports[2];
 usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport = usbMediaKeyboardReports;
+static volatile bool sendUsbMediaKeyboardReportCompleted = true;
 
 usb_media_keyboard_report_t* GetInactiveUsbMediaKeyboardReport(void)
 {
@@ -21,12 +22,17 @@ void ResetActiveUsbMediaKeyboardReport(void)
 
 usb_status_t UsbMediaKeyboardAction()
 {
+    if (!sendUsbMediaKeyboardReportCompleted)
+        return kStatus_USB_Busy; // The previous report has not been sent yet
+
     UsbMediaKeyboardActionCounter++;
+    SwitchActiveUsbMediaKeyboardReport(); // Switch the active report
     usb_status_t usb_status = USB_DeviceHidSend(
             UsbCompositeDevice.mediaKeyboardHandle, USB_MEDIA_KEYBOARD_ENDPOINT_INDEX,
-            (uint8_t*)ActiveUsbMediaKeyboardReport, USB_MEDIA_KEYBOARD_REPORT_LENGTH);
+            (uint8_t*)GetInactiveUsbMediaKeyboardReport(), USB_MEDIA_KEYBOARD_REPORT_LENGTH);
-    if (usb_status == kStatus_USB_Success)
+    if (usb_status == kStatus_USB_Success) {
-        SwitchActiveUsbMediaKeyboardReport(); // Switch the active report if the data was sent successfully
+        sendUsbMediaKeyboardReportCompleted = false;
+    }
     return usb_status;
 }
 
@@ -35,7 +41,12 @@ 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:
+            sendUsbMediaKeyboardReportCompleted = true;
+            error = kStatus_USB_Success;
+            break;
+        case kUSB_DeviceHidEventRecvResponse:
         case kUSB_DeviceHidEventGetReport:
         case kUSB_DeviceHidEventSetReport:
         case kUSB_DeviceHidEventRequestReportBuffer:

right/src/usb_interfaces/usb_interface_mouse.c

@@ -3,6 +3,7 @@
 uint32_t UsbMouseActionCounter;
 static usb_mouse_report_t usbMouseReports[2];
 usb_mouse_report_t* ActiveUsbMouseReport = usbMouseReports;
+volatile bool sendUsbMouseReportCompleted = true;
 
 usb_mouse_report_t* GetInactiveUsbMouseReport(void)
 {
@@ -21,32 +22,31 @@ void ResetActiveUsbMouseReport(void)
 
 usb_status_t usbMouseAction(void)
 {
+    if (!sendUsbMouseReportCompleted)
+        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*)ActiveUsbMouseReport, USB_MOUSE_REPORT_LENGTH);
+            (uint8_t*)GetInactiveUsbMouseReport(), USB_MOUSE_REPORT_LENGTH);
-    if (usb_status == kStatus_USB_Success)
+    if (usb_status == kStatus_USB_Success) {
-        SwitchActiveUsbMouseReport(); // Switch the active report if the data was sent successfully
+        sendUsbMouseReportCompleted = false;
+    }
     return usb_status;
 }
 
 usb_status_t UsbMouseCallback(class_handle_t handle, uint32_t event, void *param)
 {
-    static bool usbMouseActionActive = false;
     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) {
+            sendUsbMouseReportCompleted = true;
-                // Send out the last report continuously if the report was not zeros
+            error = kStatus_USB_Success;
-                usb_mouse_report_t *report = GetInactiveUsbMouseReport();
+            break;
-                uint8_t zeroBuf[sizeof(usb_mouse_report_t)] = { 0 };
+        case kUSB_DeviceHidEventRecvResponse:
-                bool reportChanged = memcmp(report, zeroBuf, sizeof(usb_mouse_report_t)) != 0;
-                if (usbMouseActionActive || reportChanged) {
-                    usbMouseActionActive = reportChanged; // Used to send out all zeros once after a report has been sent
-                    return usbMouseAction();
-                }
-            }
         case kUSB_DeviceHidEventGetReport:
         case kUSB_DeviceHidEventSetReport:
         case kUSB_DeviceHidEventRequestReportBuffer:

right/src/usb_interfaces/usb_interface_system_keyboard.c

@@ -3,6 +3,7 @@
 uint32_t UsbSystemKeyboardActionCounter;
 static usb_system_keyboard_report_t usbSystemKeyboardReports[2];
 usb_system_keyboard_report_t* ActiveUsbSystemKeyboardReport = usbSystemKeyboardReports;
+static volatile bool sendUsbSystemKeyboardReportCompleted = true;
 
 usb_system_keyboard_report_t* GetInactiveUsbSystemKeyboardReport()
 {
@@ -21,12 +22,17 @@ void ResetActiveUsbSystemKeyboardReport(void)
 
 usb_status_t UsbSystemKeyboardAction(void)
 {
+    if (!sendUsbSystemKeyboardReportCompleted)
+        return kStatus_USB_Busy; // The previous report has not been sent yet
+
     UsbSystemKeyboardActionCounter++;
+    SwitchActiveUsbSystemKeyboardReport(); // Switch the active report
     usb_status_t usb_status = USB_DeviceHidSend(
             UsbCompositeDevice.systemKeyboardHandle, USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX,
-            (uint8_t*)ActiveUsbSystemKeyboardReport, USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
+            (uint8_t*)GetInactiveUsbSystemKeyboardReport(), USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
-    if (usb_status == kStatus_USB_Success)
+    if (usb_status == kStatus_USB_Success) {
-        SwitchActiveUsbSystemKeyboardReport(); // Switch the active report if the data was sent successfully
+        sendUsbSystemKeyboardReportCompleted = false;
+    }
     return usb_status;
 }
 
@@ -35,7 +41,12 @@ 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:
+            sendUsbSystemKeyboardReportCompleted = true;
+            error = kStatus_USB_Success;
+            break;
+        case kUSB_DeviceHidEventRecvResponse:
         case kUSB_DeviceHidEventGetReport:
         case kUSB_DeviceHidEventSetReport:
         case kUSB_DeviceHidEventRequestReportBuffer:

right/src/usb_report_updater.c

@@ -426,8 +426,10 @@ void UpdateUsbReports(void)
         UsbSystemKeyboardAction();
     }
 
+    // Send out the report continuously if the report was not zeros
     bool HasUsbMouseReportChanged = false;
-    if (memcmp(ActiveUsbMouseReport, GetInactiveUsbMouseReport(), sizeof(usb_mouse_report_t)) != 0) {
+    uint8_t zeroBuf[sizeof(usb_mouse_report_t)] = { 0 };
+    if (memcmp(ActiveUsbMouseReport, zeroBuf, sizeof(usb_mouse_report_t)) != 0) {
         HasUsbMouseReportChanged = true;
         usbMouseAction();
     }