wip: set usb hid and cdc

Author: heiso

.vscode/macrolev.code-workspace

@@ -68,9 +68,11 @@
       "forward_list": "cpp",
       "list": "cpp",
       "format": "cpp",
-      "functional": "cpp"
+      "functional": "cpp",
+      "queue.h": "c"
     },
     "typescript.tsdk": "./node_modules/typescript/lib",
-    "tailwindCSS.classAttributes": ["class", "className", ".*Styles", ".*Class"]
+    "tailwindCSS.classAttributes": ["class", "className", ".*Styles", ".*Class"],
+    "cSpell.enabled": false
   }
 }

firmware/esp32-s3/config.json

@@ -1,5 +1,5 @@
 idf_component_register(
-  SRCS "main.c" "macrolev.c"
+  SRCS "main.c" "macrolev.c" "usb_descriptors.c"
   INCLUDE_DIRS "."
   PRIV_REQUIRES esp_adc esp_timer esp_driver_gpio spiffs json
 )

firmware/esp32-s3/main/CMakeLists.txt

@@ -1,4 +1,5 @@
 #include "cJSON.h"
+#include "class/hid/hid_device.h"
 #include "driver/gpio.h"
 #include "esp_adc/adc_continuous.h"
 #include "esp_log.h"
@@ -205,7 +206,7 @@ static esp_err_t init_spiffs(void) {
   esp_vfs_spiffs_conf_t conf = {
     .base_path = "/spiffs",
     .partition_label = NULL,
-    .max_files = 5,
+    .max_files = 1,
     .format_if_mount_failed = true
   };
 
@@ -249,6 +250,7 @@ esp_err_t save_json_to_file(const char *filename, cJSON *json) {
   free(json_string);
 
   ESP_LOGI(TAG, "JSON saved to file: %s", filepath);
+  ESP_LOGI(TAG, "JSON: %s", cJSON_Print(json));
   return ESP_OK;
 }
 
@@ -296,6 +298,13 @@ cJSON *load_json_from_file(const char *filename) {
   return json;
 }
 
+#define CDC_ACCUM_BUF_SIZE (1024 * 1024) // 1MB buffer for large JSON payloads
+static char cdc_accum_buf[CDC_ACCUM_BUF_SIZE];
+static size_t cdc_accum_len = 0;
+
+#define MARKER "[EOF]"
+#define MARKER_LEN (sizeof(MARKER) - 1)
+
 /**
  * @brief CDC device RX callback
  *
@@ -307,77 +316,48 @@ cJSON *load_json_from_file(const char *filename) {
 void tinyusb_cdc_rx_callback(int itf, cdcacm_event_t *event) {
   size_t rx_size = 0;
   esp_err_t ret = tinyusb_cdcacm_read(itf, rx_buf, CONFIG_TINYUSB_CDC_RX_BUFSIZE, &rx_size);
-  if (ret == ESP_OK) {
-    // Null terminate the received data
-    rx_buf[rx_size] = '\0';
-
-    // Try to parse as JSON
-    cJSON *json = cJSON_Parse((char *)rx_buf);
-    if (json != NULL) {
-      // Valid JSON received, save it
-      ESP_LOGI(TAG, "Valid JSON received, saving to config.json");
-      esp_err_t save_ret = save_json_to_file(JSON_FILENAME, json);
-
-      // Send response
-      const char *response;
-      if (save_ret == ESP_OK) {
-        response = "JSON saved successfully\r\n";
-      } else {
-        response = "Error saving JSON\r\n";
-      }
-      tinyusb_cdcacm_write_queue(itf, (uint8_t *)response, strlen(response));
-      tinyusb_cdcacm_write_flush(itf, 0);
-
-      cJSON_Delete(json);
-    } else {
-      // Not valid JSON, echo back as normal
-      usb_message_t tx_msg = {
-        .buf_len = rx_size,
-        .itf = itf,
-      };
-      memcpy(tx_msg.buf, rx_buf, rx_size);
-      xQueueSend(usb_queue, &tx_msg, 0);
-    }
-  } else {
-    ESP_LOGE(TAG, "Read Error");
-  }
-}
-
-/**
- * @brief CDC device line change callback
- *
- * CDC device signals, that the DTR, RTS states changed
- *
- * @param[in] itf   CDC device index
- * @param[in] event CDC event type
- */
-void tinyusb_cdc_line_state_changed_callback(int itf, cdcacm_event_t *event) {
-  int dtr = event->line_state_changed_data.dtr;
-  int rts = event->line_state_changed_data.rts;
-  ESP_LOGI(TAG, "Line state changed on channel %d: DTR:%d, RTS:%d", itf, dtr, rts);
-
-  // When DTR is set, terminal connection is opened
-  if (dtr) {
-    // Send welcome message
-    const char *hello = "Hello! ESP32-S3 CDC device is ready!\r\n";
-    tinyusb_cdcacm_write_queue(itf, (uint8_t *)hello, strlen(hello));
-    tinyusb_cdcacm_write_flush(itf, 0);
-
-    // Load and send current JSON content
-    cJSON *json = load_json_from_file(JSON_FILENAME);
-    if (json != NULL) {
-      char *json_str = cJSON_PrintUnformatted(json);
-      if (json_str != NULL) {
-        tinyusb_cdcacm_write_queue(itf, (uint8_t *)json_str, strlen(json_str));
-        tinyusb_cdcacm_write_queue(itf, (uint8_t *)"\r\n", 2);
-        tinyusb_cdcacm_write_flush(itf, 0);
-        free(json_str);
+  ESP_LOGI(TAG, "CDC RX callback: ret=%d, rx_size=%d", ret, rx_size);
+  if (ret == ESP_OK && rx_size > 0) {
+    ESP_LOGI(TAG, "Accumulating %d bytes to buffer (current len: %d)", rx_size, cdc_accum_len);
+    // Check for buffer overflow
+    if (cdc_accum_len + rx_size < CDC_ACCUM_BUF_SIZE) {
+      memcpy(&cdc_accum_buf[cdc_accum_len], rx_buf, rx_size);
+      cdc_accum_len += rx_size;
+      ESP_LOGI(TAG, "Buffer after accumulation: len=%d", cdc_accum_len);
+      ESP_LOG_BUFFER_HEXDUMP(TAG, rx_buf, rx_size, ESP_LOG_INFO);
+
+      // Robustly search for marker anywhere in the buffer
+      if (cdc_accum_len >= MARKER_LEN) {
+        for (size_t i = 0; i <= cdc_accum_len - MARKER_LEN; ++i) {
+          if (memcmp(&cdc_accum_buf[i], MARKER, MARKER_LEN) == 0) {
+            ESP_LOGI(TAG, "Marker detected ([EOF]) at position %d. Attempting to parse JSON.", (int)i);
+            cdc_accum_buf[i] = '\0'; // Null-terminate before marker
+
+            // Try to parse as JSON
+            cJSON *json = cJSON_Parse(cdc_accum_buf);
+            if (json != NULL) {
+              ESP_LOGI(TAG, "Valid JSON received, saving to config.json");
+              save_json_to_file(JSON_FILENAME, json);
+              cJSON_Delete(json);
+            } else {
+              ESP_LOGE(TAG, "Invalid JSON received. Parse failed.");
+            }
+            // Move any data after the marker to the start of the buffer (for next message)
+            size_t remaining = cdc_accum_len - (i + MARKER_LEN);
+            if (remaining > 0) {
+              memmove(cdc_accum_buf, &cdc_accum_buf[i + MARKER_LEN], remaining);
+            }
+            cdc_accum_len = remaining;
+            ESP_LOGI(TAG, "Buffer reset for next message. Remaining bytes: %d", (int)cdc_accum_len);
+            ESP_LOGI(TAG, "Last 16 bytes: %.*s", 16, &cdc_accum_buf[cdc_accum_len > 16 ? cdc_accum_len - 16 : 0]);
+            break; // Only handle one message per callback
+          }
+        }
       }
-      cJSON_Delete(json);
     } else {
-      const char *no_json = "No JSON configuration found\r\n";
-      tinyusb_cdcacm_write_queue(itf, (uint8_t *)no_json, strlen(no_json));
-      tinyusb_cdcacm_write_flush(itf, 0);
+      // Buffer overflow, reset (no response)
+      ESP_LOGE(TAG, "CDC accumulation buffer overflow. Resetting buffer.");
+      cdc_accum_len = 0;
     }
   }
 }
@@ -393,12 +373,7 @@ void app_main(void) {
 
   // Initialize TinyUSB
   ESP_LOGI(TAG, "USB initialization");
-  const tinyusb_config_t tusb_cfg = {
-    .device_descriptor = NULL,
-    .string_descriptor = NULL,
-    .external_phy = false,
-    .configuration_descriptor = NULL,
-  };
+  extern const tinyusb_config_t tusb_cfg;
   ESP_ERROR_CHECK(tinyusb_driver_install(&tusb_cfg));
 
   // Initialize CDC
@@ -407,28 +382,68 @@ void app_main(void) {
     .cdc_port = TINYUSB_CDC_ACM_0,
     .callback_rx = &tinyusb_cdc_rx_callback,
     .callback_rx_wanted_char = NULL,
-    .callback_line_state_changed = &tinyusb_cdc_line_state_changed_callback,
-    .callback_line_coding_changed = NULL
+    .callback_line_state_changed = NULL,
+    .callback_line_coding_changed = NULL,
+    .rx_unread_buf_sz = CONFIG_TINYUSB_CDC_RX_BUFSIZE
   };
   ESP_ERROR_CHECK(tusb_cdc_acm_init(&acm_cfg));
 
   ESP_LOGI(TAG, "USB initialization DONE");
 
+  // test init json
+  cJSON *json = load_json_from_file(JSON_FILENAME);
+  ESP_LOGI(TAG, "JSON: %s", cJSON_PrintUnformatted(json));
+  // const int size = cJSON_GetArraySize(json);
+  // for (int i = 0; i < size; i++) {
+  //   cJSON *item = cJSON_GetArrayItem(json, i);
+  //   cJSON *id = cJSON_GetObjectItemCaseSensitive(item, "id");
+  //   cJSON *hardware = cJSON_GetObjectItemCaseSensitive(item, "hardware");
+  //   cJSON *adcChannel = cJSON_GetObjectItemCaseSensitive(hardware, "adcChannel");
+  //   cJSON *muxChannel = cJSON_GetObjectItemCaseSensitive(hardware, "muxChannel");
+  //   cJSON *magnetDirection = cJSON_GetObjectItemCaseSensitive(hardware, "magnetDirection");
+  //   ESP_LOGI(TAG, "id: %d", id->valueint);
+  //   ESP_LOGI(TAG, "adcChannel: %d", adcChannel->valueint);
+  //   ESP_LOGI(TAG, "muxChannel: %d", muxChannel->valueint);
+  //   ESP_LOGI(TAG, "magnetDirection: %d", magnetDirection->valueint);
+  // }
+  // cJSON_Delete(json);
+
   // Main loop
   while (1) {
-    if (xQueueReceive(usb_queue, &msg, portMAX_DELAY)) {
-      if (msg.buf_len) {
-        // Print received data
-        ESP_LOGI(TAG, "Data from channel %d:", msg.itf);
-        ESP_LOG_BUFFER_HEXDUMP(TAG, msg.buf, msg.buf_len, ESP_LOG_INFO);
-
-        // Echo back
-        tinyusb_cdcacm_write_queue(msg.itf, msg.buf, msg.buf_len);
-        esp_err_t err = tinyusb_cdcacm_write_flush(msg.itf, 0);
-        if (err != ESP_OK) {
-          ESP_LOGE(TAG, "CDC write error: %s", esp_err_to_name(err));
-        }
-      }
-    }
+    vTaskDelay(pdMS_TO_TICKS(10));
+    // if (xQueueReceive(usb_queue, &msg, portMAX_DELAY)) {
+    //   if (msg.buf_len) {
+    //     // Print received data
+    //     ESP_LOGI(TAG, "Data from channel %d with length %d", msg.itf, msg.buf_len);
+    //     ESP_LOG_BUFFER_HEXDUMP(TAG, msg.buf, msg.buf_len, ESP_LOG_INFO);
+
+    //     // // Echo back
+    //     // tinyusb_cdcacm_write_queue(msg.itf, msg.buf, msg.buf_len);
+    //     // esp_err_t err = tinyusb_cdcacm_write_flush(msg.itf, 0);
+    //     // if (err != ESP_OK) {
+    //     //   ESP_LOGE(TAG, "CDC write error: %s", esp_err_to_name(err));
+    //     // }
+    //   }
+    // }
   }
 }
+
+/********* TinyUSB HID callbacks ***************/
+
+// Invoked when received GET_REPORT control request
+// Application must fill buffer report's content and return its length.
+// Return zero will cause the stack to STALL request
+uint16_t tud_hid_get_report_cb(uint8_t instance, uint8_t report_id, hid_report_type_t report_type, uint8_t *buffer, uint16_t reqlen) {
+  (void)instance;
+  (void)report_id;
+  (void)report_type;
+  (void)buffer;
+  (void)reqlen;
+
+  return 0;
+}
+
+// Invoked when received SET_REPORT control request or
+// received data on OUT endpoint ( Report ID = 0, Type = 0 )
+void tud_hid_set_report_cb(uint8_t instance, uint8_t report_id, hid_report_type_t report_type, uint8_t const *buffer, uint16_t bufsize) {
+}

firmware/esp32-s3/main/main.c

@@ -0,0 +1,61 @@
+#include "tinyusb.h"
+
+// Interface definitions
+enum {
+  ITF_NUM_HID = 0,
+  ITF_NUM_CDC,
+  ITF_NUM_CDC_DATA,
+  ITF_NUM_TOTAL
+};
+
+#define TUSB_DESC_TOTAL_LEN (TUD_CONFIG_DESC_LEN + TUD_HID_DESC_LEN * CFG_TUD_HID + TUD_CDC_DESC_LEN * CFG_TUD_CDC)
+
+/**
+ * @brief HID report descriptor
+ *
+ * In this example we implement Keyboard + Mouse HID device,
+ * so we must define both report descriptors
+ */
+const uint8_t hid_report_descriptor[] = {
+  TUD_HID_REPORT_DESC_KEYBOARD(HID_REPORT_ID(HID_ITF_PROTOCOL_KEYBOARD)),
+};
+
+const char *string_descriptor[] = {
+  // array of pointer to string descriptors
+  (char[]){ 0x09, 0x04 },                  // 0: is supported language is English (0x0409)
+  CONFIG_TINYUSB_DESC_MANUFACTURER_STRING, // 1: Manufacturer
+  CONFIG_TINYUSB_DESC_PRODUCT_STRING,      // 2: Product
+  CONFIG_TINYUSB_DESC_SERIAL_STRING,       // 3: Serials, should use chip ID
+  CONFIG_TINYUSB_DESC_CDC_STRING,          // 4: CDC Interface
+  "Macrolev HID Device",                   // 5: HID Interface
+};
+
+/**
+ * @brief Configuration descriptor
+ *
+ * This is a simple configuration descriptor that defines 1 configuration and 1 HID interface
+ */
+static uint8_t configuration_descriptor[] = {
+  // Configuration number, interface count, string index, total length, attribute, power in mA
+  TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, TUSB_DESC_TOTAL_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
+
+  // Interface number, string index, boot protocol, report descriptor len, EP In address, size & polling interval
+  TUD_HID_DESCRIPTOR(ITF_NUM_HID, 5, HID_ITF_PROTOCOL_KEYBOARD, sizeof(hid_report_descriptor), 0x83, CFG_TUD_HID_EP_BUFSIZE, 10),
+
+  // Interface number, string index, EP notification address and size, EP data address (out, in) and size.
+  TUD_CDC_DESCRIPTOR(ITF_NUM_CDC, 4, 0x81, 8, 0x02, 0x82, TUD_OPT_HIGH_SPEED ? 512 : 64),
+};
+
+// Invoked when received GET HID REPORT DESCRIPTOR request
+// Application return pointer to descriptor, whose contents must exist long enough for transfer to complete
+uint8_t const *tud_hid_descriptor_report_cb(uint8_t instance) {
+  // We use only one interface and one HID report descriptor, so we can ignore parameter 'instance'
+  return hid_report_descriptor;
+}
+
+const tinyusb_config_t tusb_cfg = {
+  .device_descriptor = NULL,
+  .string_descriptor = string_descriptor,
+  .external_phy = false,
+  .configuration_descriptor = configuration_descriptor,
+};

firmware/esp32-s3/main/usb_descriptors.c

@@ -1,12 +1,17 @@
 # This file was generated using idf.py save-defconfig. It can be edited manually.
-# Espressif IoT Development Framework (ESP-IDF) 5.5.0 Project Minimal Configuration
+# Espressif IoT Development Framework (ESP-IDF) 5.4.1 Project Minimal Configuration
 #
 CONFIG_IDF_TARGET="esp32s3"
 CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
 CONFIG_PARTITION_TABLE_CUSTOM=y
 CONFIG_LOG_COLORS=y
 CONFIG_WL_SECTOR_SIZE_512=y
+CONFIG_TINYUSB_DEBUG_LEVEL=3
 CONFIG_TINYUSB_DESC_MANUFACTURER_STRING="Heiso"
 CONFIG_TINYUSB_DESC_PRODUCT_STRING="Macrolev Rev.2"
 CONFIG_TINYUSB_DESC_CDC_STRING="Macrolev CDC Device"
+CONFIG_TINYUSB_MSC_ENABLED=y
 CONFIG_TINYUSB_CDC_ENABLED=y
+CONFIG_TINYUSB_CDC_RX_BUFSIZE=1024
+CONFIG_TINYUSB_CDC_TX_BUFSIZE=1024
+CONFIG_TINYUSB_HID_COUNT=1

firmware/esp32-s3/sdkconfig.defaults

@@ -0,0 +1,28 @@
+import os
+import sys
+import time
+
+if len(sys.argv) < 3:
+    print("Usage: python3 send_cdc.py <serial_port> <file_path>")
+    sys.exit(1)
+
+SERIAL_PORT = sys.argv[1]
+FILE_PATH = sys.argv[2]
+CHUNK_SIZE = 64
+MARKER = b'[EOF]'
+
+# Open serial port
+fd = os.open(SERIAL_PORT, os.O_WRONLY | os.O_NOCTTY)
+
+with open(FILE_PATH, 'rb') as f:
+    while True:
+        chunk = f.read(CHUNK_SIZE)
+        if not chunk:
+            break
+        os.write(fd, chunk)
+        print(f"Sent {len(chunk)} bytes")
+        time.sleep(0.01)  # 10ms delay
+
+os.write(fd, MARKER)
+print("Sent marker [EOF]. Done.")
+os.close(fd)