Local tests success

Author: annejan

main/badge_hid_drivers.c

@@ -10,6 +10,7 @@
  */
 #include "badge_hid_drivers.h"
 #include <string.h>
+#include "esp_err.h"
 #include "esp_log.h"
 #include "usb/hid.h"
 
@@ -141,7 +142,7 @@ esp_err_t analyze_mouse_layout(const uint8_t* desc, int desc_len, mouse_field_la
         }
     }
 
-    return layout_out->has_x && layout_out->has_y;
+    return layout_out->has_x && layout_out->has_y ? ESP_OK : ESP_FAIL;
 }
 
 esp_err_t analyze_gamepad_layout(const uint8_t* desc, int desc_len, gamepad_field_layout_t* layout_out) {
@@ -172,6 +173,11 @@ esp_err_t analyze_gamepad_layout(const uint8_t* desc, int desc_len, gamepad_fiel
             data |= ((uint32_t)desc[i++]) << (j * 8);
         }
 
+        // Reset usage list when starting new section
+        if (type == HID_TYPE_GLOBAL && (tag == HID_TAG_USAGE_PAGE || tag == HID_TAG_REPORT_ID)) {
+            usage_index = 0;
+        }
+
         switch (type) {
             case HID_TYPE_GLOBAL:
                 switch (tag) {
@@ -191,25 +197,33 @@ esp_err_t analyze_gamepad_layout(const uint8_t* desc, int desc_len, gamepad_fiel
                 }
                 break;
 
-            case HID_TYPE_LOCAL: 
+            case HID_TYPE_LOCAL:
                 if (tag == HID_TAG_USAGE && usage_index < 32) {
                     usages[usage_index++] = data;
                 }
                 break;
 
             case HID_TYPE_MAIN:
                 if (tag == HID_TAG_INPUT) {
-                    if (usage_page == USAGE_PAGE_BUTTON && usage_index >= 1 && usages[0] >= USAGE_BUTTON_MIN && usages[0] <= USAGE_BUTTON_MAX) {
+                    bool is_constant = (data & 0x01) != 0;
+
+                    if (usage_page == USAGE_PAGE_BUTTON && usage_index >= 1 &&
+                        usages[0] >= USAGE_BUTTON_MIN && usages[0] <= USAGE_BUTTON_MAX) {
                         if (!layout_out->has_buttons) layout_out->button_bit_offset = bit_offset;
-                        layout_out->has_buttons      = true;
+                        layout_out->has_buttons     = true;
                         layout_out->button_bit_count += report_count;
-                        bit_offset                   += report_size * report_count;
-                        last_input_was_button_array  = true;
+                        last_input_was_button_array = true;
+                        bit_offset += report_size * report_count;
                     } else if (usage_page == USAGE_PAGE_BUTTON && usage_index == 0 && last_input_was_button_array) {
                         bit_offset += report_size * report_count;
                     } else {
-                        for (int u = 0; u < usage_index; u++) {
-                            uint16_t usage = usages[u];
+                        for (int u = 0; u < report_count; u++) {
+                            uint16_t usage = (u < usage_index) ? usages[u] :
+                                             (usage_index > 0 ? usages[usage_index - 1] : 0xFFFF);
+                            if (usage == 0xFFFF) {
+                                bit_offset += report_size;
+                                continue;
+                            }
 
                             if (usage_page == USAGE_PAGE_GENERIC_DESKTOP) {
                                 switch (usage) {
@@ -239,7 +253,8 @@ esp_err_t analyze_gamepad_layout(const uint8_t* desc, int desc_len, gamepad_fiel
                                         layout_out->ry_bit_size   = report_size;
                                         break;
                                 }
-                            } else if (usage_page == USAGE_PAGE_SIMULATION && (usage == USAGE_ACCELERATOR || usage == USAGE_BRAKE)) {
+                            } else if (usage_page == USAGE_PAGE_SIMULATION &&
+                                      (usage == USAGE_ACCELERATOR || usage == USAGE_BRAKE)) {
                                 if (!layout_out->has_lt) {
                                     layout_out->has_lt        = true;
                                     layout_out->lt_bit_offset = bit_offset;
@@ -253,22 +268,25 @@ esp_err_t analyze_gamepad_layout(const uint8_t* desc, int desc_len, gamepad_fiel
 
                             bit_offset += report_size;
                         }
-                        // Handle excess usages vs report count
-                        if (usage_index == 0 || usage_index < report_count) {
-                            bit_offset += report_size * (report_count - usage_index);
-                        }
+
                         last_input_was_button_array = false;
                     }
 
-                    usage_index = 0;
+                    // Clear usages after each input block
                 }
+                                    usage_index = 0;
+
                 break;
         }
     }
 
-    return layout_out->has_dpad && layout_out->has_buttons;
+    return ESP_OK;
 }
 
+
+
+
+
 esp_err_t decode_descriptor_register_driver(const uint8_t* const desc, const int desc_len, const uint8_t proto) {
     if (HID_PROTOCOL_KEYBOARD == proto) {
         ESP_LOGI(TAG, "Keyboard uses generic (boot) driver");

main/badge_hid_drivers.h

@@ -127,37 +127,38 @@ typedef struct {
 } mouse_field_layout_t;
 
 typedef struct {
+    bool     has_dpad;
+    bool     has_buttons;
+    bool     has_lx;
+    bool     has_ly;
+    bool     has_rx;
+    bool     has_ry;
+    bool     has_lt;
+    bool     has_rt;
+
     uint8_t report_id;
 
-    bool     has_dpad;
     uint16_t dpad_bit_offset;
     uint8_t  dpad_bit_size;
 
-    bool     has_buttons;
     uint16_t button_bit_offset;
     uint8_t  button_bit_count;
 
-    bool     has_lx;
     uint16_t lx_bit_offset;
     uint8_t  lx_bit_size;
 
-    bool     has_ly;
     uint16_t ly_bit_offset;
     uint8_t  ly_bit_size;
 
-    bool     has_rx;
     uint16_t rx_bit_offset;
     uint8_t  rx_bit_size;
 
-    bool     has_ry;
     uint16_t ry_bit_offset;
     uint8_t  ry_bit_size;
 
-    bool     has_lt;
     uint16_t lt_bit_offset;
     uint8_t  lt_bit_size;
 
-    bool     has_rt;
     uint16_t rt_bit_offset;
     uint8_t  rt_bit_size;
 } gamepad_field_layout_t;

test_native/badge_hid_drivers.o

@@ -56,7 +56,7 @@ void print_layout(gamepad_field_layout_t* layout) {
 
 int main(void) {
     mouse_field_layout_t mouse_layout = {0};
-    assert(analyze_mouse_layout(mouse1_desc, mouse1_len, &mouse_layout));
+    assert(ESP_OK == analyze_mouse_layout(mouse1_desc, mouse1_len, &mouse_layout));
 
     assert(mouse_layout.has_buttons);
     assert(mouse_layout.has_x);
@@ -81,7 +81,7 @@ int main(void) {
 
     printf("Logitech M705 passed\n");
 
-    assert(analyze_mouse_layout(mouse2_desc, mouse2_len, &mouse_layout));
+    assert(ESP_OK == analyze_mouse_layout(mouse2_desc, mouse2_len, &mouse_layout));
 
     assert(mouse_layout.has_buttons);
     assert(mouse_layout.has_x);
@@ -103,7 +103,7 @@ int main(void) {
 
     printf("Trust Kuza passed\n");
 
-    assert(analyze_mouse_layout(mouse3_desc, mouse3_len, &mouse_layout));
+    assert(ESP_OK == analyze_mouse_layout(mouse3_desc, mouse3_len, &mouse_layout));
 
     assert(mouse_layout.has_buttons);
     assert(mouse_layout.has_x);
@@ -126,7 +126,7 @@ int main(void) {
     printf("Fujitsu M520 passed\n");
 
     gamepad_field_layout_t pad_layout = {0};
-    assert(analyze_gamepad_layout(gamepad1_desc, gamepad1_len, &pad_layout));
+    assert(ESP_OK == analyze_gamepad_layout(gamepad1_desc, gamepad1_len, &pad_layout));
     print_layout(&pad_layout);
 
     assert(pad_layout.has_dpad);
@@ -138,28 +138,28 @@ int main(void) {
     assert(pad_layout.has_lt);
     assert(pad_layout.has_rt);
 
-    assert(20 == pad_layout.dpad_bit_offset);
+    assert(8 == pad_layout.dpad_bit_offset);
     assert(4  == pad_layout.dpad_bit_size);
 
-    assert(24 == pad_layout.button_bit_offset);
+    assert(16 == pad_layout.button_bit_offset);
     assert(15 == pad_layout.button_bit_count);
 
-    assert(40 == pad_layout.lx_bit_offset);
+    assert(32 == pad_layout.lx_bit_offset);
     assert(8  == pad_layout.lx_bit_size);
 
-    assert(48 == pad_layout.ly_bit_offset);
+    assert(40 == pad_layout.ly_bit_offset);
     assert(8  == pad_layout.ly_bit_size);
 
-    assert(64 == pad_layout.rx_bit_offset);
+    assert(48 == pad_layout.rx_bit_offset);
     assert(8  == pad_layout.rx_bit_size);
 
-    assert(72 == pad_layout.ry_bit_offset);
+    assert(56 == pad_layout.ry_bit_offset);
     assert(8  == pad_layout.ry_bit_size);
 
-    assert(88 == pad_layout.lt_bit_offset);
+    assert(64 == pad_layout.lt_bit_offset);
     assert(8  == pad_layout.lt_bit_size);
 
-    assert(96 == pad_layout.rt_bit_offset);
+    assert(72 == pad_layout.rt_bit_offset);
     assert(8  == pad_layout.rt_bit_size);
 
     printf("Stadia controller passed\n");