Merge pull request #120 from Lauszus/dev

The UHK now only sends out data when it changes

right/src/usb_interfaces/usb_interface_basic_keyboard.c

@@ -4,7 +4,6 @@
 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)
@@ -22,14 +21,12 @@ 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(
+    UsbBasicKeyboardActionCounter++;
+    return USB_DeviceHidSend(
             UsbCompositeDevice.basicKeyboardHandle, USB_BASIC_KEYBOARD_ENDPOINT_INDEX,
             (uint8_t*)getInactiveUsbBasicKeyboardReport(), USB_BASIC_KEYBOARD_REPORT_LENGTH);
-    IsUsbBasicKeyboardReportSent = true;
-    UsbBasicKeyboardActionCounter++;
-    return status;
 }
 
 usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
@@ -38,10 +35,6 @@ usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, voi
 
     switch (event) {
         case kUSB_DeviceHidEventSendResponse:
-            if (UsbCompositeDevice.attach) {
-                return UsbBasicKeyboardAction();
-            }
-            break;
         case kUSB_DeviceHidEventGetReport:
             error = kStatus_USB_InvalidRequest;
             break;
@@ -80,7 +73,7 @@ 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 UsbBasicKeyboardAction();
     }
     return kStatus_USB_Error;
 }
@@ -88,7 +81,7 @@ usb_status_t UsbBasicKeyboardSetConfiguration(class_handle_t handle, uint8_t con
 usb_status_t UsbBasicKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
 {
     if (USB_BASIC_KEYBOARD_INTERFACE_INDEX == interface) {
-        return UsbBasicKeyboardAction();
+        //return UsbBasicKeyboardAction();
     }
     return kStatus_USB_Error;
 }

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;
 
@@ -43,5 +42,6 @@
 
     void ResetActiveUsbBasicKeyboardReport(void);
     void SwitchActiveUsbBasicKeyboardReport(void);
+    usb_status_t UsbBasicKeyboardAction(void);
 
 #endif

right/src/usb_interfaces/usb_interface_media_keyboard.c

@@ -3,7 +3,6 @@
 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)
 {
@@ -20,14 +19,12 @@ void ResetActiveUsbMediaKeyboardReport(void)
     bzero(ActiveUsbMediaKeyboardReport, USB_MEDIA_KEYBOARD_REPORT_LENGTH);
 }
 
-static usb_status_t UsbMediaKeyboardAction(void)
+usb_status_t UsbMediaKeyboardAction()
 {
-    usb_status_t status = USB_DeviceHidSend(
+    UsbMediaKeyboardActionCounter++;
+    return USB_DeviceHidSend(
             UsbCompositeDevice.mediaKeyboardHandle, USB_MEDIA_KEYBOARD_ENDPOINT_INDEX,
             (uint8_t*)getInactiveUsbMediaKeyboardReport(), USB_MEDIA_KEYBOARD_REPORT_LENGTH);
-    IsUsbMediaKeyboardReportSent = true;
-    UsbMediaKeyboardActionCounter++;
-    return status;
 }
 
 usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
@@ -36,10 +33,6 @@ usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, voi
 
     switch (event) {
         case kUSB_DeviceHidEventSendResponse:
-            if (UsbCompositeDevice.attach) {
-                return UsbMediaKeyboardAction();
-            }
-            break;
         case kUSB_DeviceHidEventGetReport:
         case kUSB_DeviceHidEventSetReport:
         case kUSB_DeviceHidEventRequestReportBuffer:
@@ -60,7 +53,7 @@ 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 UsbMediaKeyboardAction();
     }
     return kStatus_USB_Error;
 }
@@ -68,7 +61,7 @@ usb_status_t UsbMediaKeyboardSetConfiguration(class_handle_t handle, uint8_t con
 usb_status_t UsbMediaKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
 {
     if (USB_MEDIA_KEYBOARD_INTERFACE_INDEX == interface) {
-        return UsbMediaKeyboardAction();
+        //return UsbMediaKeyboardAction();
     }
     return kStatus_USB_Error;
 }

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;
 
@@ -40,5 +39,6 @@
 
     void ResetActiveUsbMediaKeyboardReport(void);
     void SwitchActiveUsbMediaKeyboardReport(void);
+    usb_status_t UsbMediaKeyboardAction();
 
 #endif

right/src/usb_interfaces/usb_interface_mouse.c

@@ -3,7 +3,6 @@
 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)
 {
@@ -20,25 +19,31 @@ 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();
+    UsbMouseActionCounter++;
-    IsUsbMouseReportSent = true;
+    return USB_DeviceHidSend(
-    return USB_DeviceHidSend(UsbCompositeDevice.mouseHandle, USB_MOUSE_ENDPOINT_INDEX,
+            UsbCompositeDevice.mouseHandle, USB_MOUSE_ENDPOINT_INDEX,
-               (uint8_t*)mouseReport, USB_MOUSE_REPORT_LENGTH);
+            (uint8_t*)getInactiveUsbMouseReport(), USB_MOUSE_REPORT_LENGTH);
 }
 
 usb_status_t UsbMouseCallback(class_handle_t handle, uint32_t event, void *param)
 {
-    UsbMouseActionCounter++;
+    static bool usbMouseActionActive = false;
     usb_status_t error = kStatus_USB_Error;
 
     switch (event) {
         case kUSB_DeviceHidEventSendResponse:
             if (UsbCompositeDevice.attach) {
+                // Send out the report continuously if the report is not zeros
+                usb_mouse_report_t *report = getInactiveUsbMouseReport();
+                uint8_t zeroBuf[sizeof(usb_mouse_report_t)] = { 0 };
+                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();
                 }
-            break;
+            }
         case kUSB_DeviceHidEventGetReport:
         case kUSB_DeviceHidEventSetReport:
         case kUSB_DeviceHidEventRequestReportBuffer:
@@ -59,7 +64,7 @@ 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 usbMouseAction();
     }
     return kStatus_USB_Error;
 }
@@ -67,7 +72,7 @@ usb_status_t UsbMouseSetConfiguration(class_handle_t handle, uint8_t configurati
 usb_status_t UsbMouseSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
 {
     if (USB_MOUSE_INTERFACE_INDEX == interface) {
-        return usbMouseAction();
+        //return usbMouseAction();
     }
     return kStatus_USB_Error;
 }

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;
 
@@ -43,5 +42,6 @@
 
     void ResetActiveUsbMouseReport(void);
     void SwitchActiveUsbMouseReport(void);
+    usb_status_t usbMouseAction(void);
 
 #endif

right/src/usb_interfaces/usb_interface_system_keyboard.c

@@ -3,7 +3,6 @@
 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()
 {
@@ -20,14 +19,12 @@ 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(
+    UsbSystemKeyboardActionCounter++;
+    return USB_DeviceHidSend(
             UsbCompositeDevice.systemKeyboardHandle, USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX,
             (uint8_t*)getInactiveUsbSystemKeyboardReport(), USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
-    IsUsbSystemKeyboardReportSent = true;
-    UsbSystemKeyboardActionCounter++;
-    return status;
 }
 
 usb_status_t UsbSystemKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
@@ -36,10 +33,6 @@ usb_status_t UsbSystemKeyboardCallback(class_handle_t handle, uint32_t event, vo
 
     switch (event) {
         case kUSB_DeviceHidEventSendResponse:
-            if (UsbCompositeDevice.attach) {
-                return UsbSystemKeyboardAction();
-            }
-            break;
         case kUSB_DeviceHidEventGetReport:
         case kUSB_DeviceHidEventSetReport:
         case kUSB_DeviceHidEventRequestReportBuffer:
@@ -60,7 +53,7 @@ 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 UsbSystemKeyboardAction();
     }
     return kStatus_USB_Error;
 }
@@ -68,7 +61,7 @@ usb_status_t UsbSystemKeyboardSetConfiguration(class_handle_t handle, uint8_t co
 usb_status_t UsbSystemKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
 {
     if (USB_SYSTEM_KEYBOARD_INTERFACE_INDEX == interface) {
-        return UsbSystemKeyboardAction();
+        //return UsbSystemKeyboardAction();
     }
     return kStatus_USB_Error;
 }

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;
 
@@ -41,5 +40,6 @@
 
     void ResetActiveUsbSystemKeyboardReport(void);
     void SwitchActiveUsbSystemKeyboardReport(void);
+    usb_status_t UsbSystemKeyboardAction(void);
 
 #endif

right/src/usb_report_updater.c

@@ -389,8 +389,6 @@ void UpdateUsbReports(void)
             return;
         }
         Timer_SetCurrentTime(&lastMouseUpdateTime);
-    } else if (!IsUsbBasicKeyboardReportSent || !IsUsbMediaKeyboardReportSent || !IsUsbSystemKeyboardReportSent || !IsUsbMouseReportSent) {
-        return;
     }
 
     ResetActiveUsbBasicKeyboardReport();
@@ -401,34 +399,42 @@ void UpdateUsbReports(void)
     updateActiveUsbReports();
 
     static usb_basic_keyboard_report_t last_basic_report = { .scancodes[0] = 0xFF };
+    bool HasUsbBasicKeyboardReportChanged = false;
     if (memcmp(ActiveUsbBasicKeyboardReport, &last_basic_report, sizeof(usb_basic_keyboard_report_t)) != 0) {
         last_basic_report = *ActiveUsbBasicKeyboardReport;
         SwitchActiveUsbBasicKeyboardReport();
-        IsUsbBasicKeyboardReportSent = false;
+        HasUsbBasicKeyboardReportChanged = true;
+        UsbBasicKeyboardAction();
     }
 
     static usb_media_keyboard_report_t last_media_report = { .scancodes[0] = 0xFF };
+    bool HasUsbMediaKeyboardReportChanged = false;
     if (memcmp(ActiveUsbMediaKeyboardReport, &last_media_report, sizeof(usb_media_keyboard_report_t)) != 0) {
         last_media_report = *ActiveUsbMediaKeyboardReport;
+        HasUsbMediaKeyboardReportChanged = true;
         SwitchActiveUsbMediaKeyboardReport();
-        IsUsbMediaKeyboardReportSent = false;
+        UsbMediaKeyboardAction();
     }
 
     static usb_system_keyboard_report_t last_system_report = { .scancodes[0] = 0xFF };
+    bool HasUsbSystemKeyboardReportChanged = false;
     if (memcmp(ActiveUsbSystemKeyboardReport, &last_system_report, sizeof(usb_system_keyboard_report_t)) != 0) {
         last_system_report = *ActiveUsbSystemKeyboardReport;
+        HasUsbSystemKeyboardReportChanged = true;
         SwitchActiveUsbSystemKeyboardReport();
-        IsUsbSystemKeyboardReportSent = false;
+        UsbSystemKeyboardAction();
     }
 
     static usb_mouse_report_t last_mouse_report = { .buttons = 0xFF };
+    bool HasUsbMouseReportChanged = false;
     if (memcmp(ActiveUsbMouseReport, &last_mouse_report, sizeof(usb_mouse_report_t)) != 0) {
         last_mouse_report = *ActiveUsbMouseReport;
+        HasUsbMouseReportChanged = true;
         SwitchActiveUsbMouseReport();
-        IsUsbMouseReportSent = false;
+        usbMouseAction();
     }
 
-    if ((previousLayer != LayerId_Base || !IsUsbBasicKeyboardReportSent || !IsUsbMediaKeyboardReportSent || !IsUsbSystemKeyboardReportSent || !IsUsbMouseReportSent) && IsHostSleeping) {
+    if ((previousLayer != LayerId_Base || HasUsbBasicKeyboardReportChanged || HasUsbMediaKeyboardReportChanged || HasUsbSystemKeyboardReportChanged || HasUsbMouseReportChanged) && IsHostSleeping) {
         WakeUpHost(true); // Wake up the host if any key is pressed and the computer is sleeping.
     }
 }