feat(usb): 添加USB CDC功能模块支持

- 在CMakeLists.txt中添加usb_cdc_module、usb_cdc_test_module和
  usb_device_module源文件
- 添加usb_cdc_rx_event、usb_cdc_tx_event、usb_device_state_event、
  usb_function_ready_event和usb_prepare_event事件定义
- 实现USB CDC串口通信功能，包括接收和发送数据处理
- 添加USB设备状态管理，支持连接、断开、激活等状态变化
- 配置设备树中的USB端点数量以支持CDC ACM功能
- 创建USB设备模块用于管理USB堆栈初始化和状态监控
- 添加USB功能就绪事件以协调不同USB功能的准备状态

src/events/usb_cdc_rx_event.c

@@ -0,0 +1,73 @@
+#include <ctype.h>
+#include <stdio.h>
+
+#include "usb_cdc_rx_event.h"
+
+#define USB_CDC_RX_EVENT_LOG_BUF_LEN 384
+
+static void log_usb_cdc_rx_event(const struct app_event_header *aeh)
+{
+	const struct usb_cdc_rx_event *event = cast_usb_cdc_rx_event(aeh);
+	char log_buf[USB_CDC_RX_EVENT_LOG_BUF_LEN];
+	int pos;
+
+	pos = snprintf(log_buf, sizeof(log_buf), "len:%zu ascii:\"",
+		       event->dyndata.size);
+	if ((pos < 0) || (pos >= sizeof(log_buf))) {
+		APP_EVENT_MANAGER_LOG(aeh, "log message preparation failure");
+		return;
+	}
+
+	for (size_t i = 0; i < event->dyndata.size; i++) {
+		int tmp = snprintf(&log_buf[pos], sizeof(log_buf) - pos, "%c",
+				   isprint(event->dyndata.data[i]) ?
+					   event->dyndata.data[i] : '.');
+
+		if ((tmp < 0) || ((pos + tmp) >= sizeof(log_buf))) {
+			APP_EVENT_MANAGER_LOG(aeh, "len:%zu ascii:\"...\"",
+					      event->dyndata.size);
+			return;
+		}
+
+		pos += tmp;
+	}
+
+	pos += snprintf(&log_buf[pos], sizeof(log_buf) - pos, "\" hex:");
+	if ((pos < 0) || (pos >= sizeof(log_buf))) {
+		APP_EVENT_MANAGER_LOG(aeh, "len:%zu ascii:\"...\"",
+				      event->dyndata.size);
+		return;
+	}
+
+	for (size_t i = 0; i < event->dyndata.size; i++) {
+		int tmp = snprintf(&log_buf[pos], sizeof(log_buf) - pos, " %02x",
+				   event->dyndata.data[i]);
+
+		if ((tmp < 0) || ((pos + tmp) >= sizeof(log_buf))) {
+			break;
+		}
+
+		pos += tmp;
+	}
+
+	APP_EVENT_MANAGER_LOG(aeh, "%s", log_buf);
+}
+
+static void profile_usb_cdc_rx_event(struct log_event_buf *buf,
+				     const struct app_event_header *aeh)
+{
+	const struct usb_cdc_rx_event *event = cast_usb_cdc_rx_event(aeh);
+
+	nrf_profiler_log_encode_uint8(buf, (uint8_t)event->dyndata.size);
+}
+
+APP_EVENT_INFO_DEFINE(usb_cdc_rx_event,
+		      ENCODE(NRF_PROFILER_ARG_U8),
+		      ENCODE("len"),
+		      profile_usb_cdc_rx_event);
+
+APP_EVENT_TYPE_DEFINE(usb_cdc_rx_event,
+		      log_usb_cdc_rx_event,
+		      &usb_cdc_rx_event_info,
+		      APP_EVENT_FLAGS_CREATE(
+			      APP_EVENT_TYPE_FLAGS_INIT_LOG_ENABLE));

src/events/usb_cdc_tx_event.c

@@ -0,0 +1,62 @@
+#include <ctype.h>
+#include <stdio.h>
+
+#include "usb_cdc_tx_event.h"
+
+#define USB_CDC_TX_EVENT_LOG_BUF_LEN 256
+
+static void log_usb_cdc_tx_event(const struct app_event_header *aeh)
+{
+	const struct usb_cdc_tx_event *event = cast_usb_cdc_tx_event(aeh);
+	char log_buf[USB_CDC_TX_EVENT_LOG_BUF_LEN];
+	int pos;
+
+	pos = snprintf(log_buf, sizeof(log_buf), "len:%zu ascii:\"",
+		       event->dyndata.size);
+	if ((pos < 0) || (pos >= sizeof(log_buf))) {
+		APP_EVENT_MANAGER_LOG(aeh, "log message preparation failure");
+		return;
+	}
+
+	for (size_t i = 0; i < event->dyndata.size; i++) {
+		int tmp = snprintf(&log_buf[pos], sizeof(log_buf) - pos, "%c",
+				   isprint(event->dyndata.data[i]) ?
+					   event->dyndata.data[i] : '.');
+
+		if ((tmp < 0) || ((pos + tmp) >= sizeof(log_buf))) {
+			APP_EVENT_MANAGER_LOG(aeh, "len:%zu ascii:\"...\"",
+					      event->dyndata.size);
+			return;
+		}
+
+		pos += tmp;
+	}
+
+	pos += snprintf(&log_buf[pos], sizeof(log_buf) - pos, "\"");
+	if ((pos < 0) || (pos >= sizeof(log_buf))) {
+		APP_EVENT_MANAGER_LOG(aeh, "len:%zu ascii:\"...\"",
+				      event->dyndata.size);
+		return;
+	}
+
+	APP_EVENT_MANAGER_LOG(aeh, "%s", log_buf);
+}
+
+static void profile_usb_cdc_tx_event(struct log_event_buf *buf,
+				     const struct app_event_header *aeh)
+{
+	const struct usb_cdc_tx_event *event = cast_usb_cdc_tx_event(aeh);
+
+	nrf_profiler_log_encode_uint8(buf, (uint8_t)event->dyndata.size);
+}
+
+APP_EVENT_INFO_DEFINE(usb_cdc_tx_event,
+		      ENCODE(NRF_PROFILER_ARG_U8),
+		      ENCODE("len"),
+		      profile_usb_cdc_tx_event);
+
+APP_EVENT_TYPE_DEFINE(usb_cdc_tx_event,
+		      log_usb_cdc_tx_event,
+		      &usb_cdc_tx_event_info,
+		      APP_EVENT_FLAGS_CREATE(
+			      APP_EVENT_TYPE_FLAGS_INIT_LOG_ENABLE));

src/events/usb_device_state_event.c

@@ -0,0 +1,46 @@
+#include "usb_device_state_event.h"
+
+static const char *usb_device_state_name(enum usb_device_state state)
+{
+	switch (state) {
+	case USB_DEVICE_STATE_DISCONNECTED:
+		return "disconnected";
+	case USB_DEVICE_STATE_POWERED:
+		return "powered";
+	case USB_DEVICE_STATE_ACTIVE:
+		return "active";
+	case USB_DEVICE_STATE_SUSPENDED:
+		return "suspended";
+	default:
+		return "?";
+	}
+}
+
+static void log_usb_device_state_event(const struct app_event_header *aeh)
+{
+	const struct usb_device_state_event *event =
+		cast_usb_device_state_event(aeh);
+
+	APP_EVENT_MANAGER_LOG(aeh, "state:%s",
+			      usb_device_state_name(event->state));
+}
+
+static void profile_usb_device_state_event(struct log_event_buf *buf,
+					   const struct app_event_header *aeh)
+{
+	const struct usb_device_state_event *event =
+		cast_usb_device_state_event(aeh);
+
+	nrf_profiler_log_encode_uint8(buf, event->state);
+}
+
+APP_EVENT_INFO_DEFINE(usb_device_state_event,
+		      ENCODE(NRF_PROFILER_ARG_U8),
+		      ENCODE("state"),
+		      profile_usb_device_state_event);
+
+APP_EVENT_TYPE_DEFINE(usb_device_state_event,
+		      log_usb_device_state_event,
+		      &usb_device_state_event_info,
+		      APP_EVENT_FLAGS_CREATE(
+			      APP_EVENT_TYPE_FLAGS_INIT_LOG_ENABLE));

src/events/usb_function_ready_event.c

@@ -0,0 +1,42 @@
+#include "usb_function_ready_event.h"
+
+static const char *usb_function_name(uint8_t function_mask)
+{
+	switch (function_mask) {
+	case USB_FUNCTION_HID:
+		return "hid";
+	case USB_FUNCTION_CDC_ACM:
+		return "cdc_acm";
+	default:
+		return "?";
+	}
+}
+
+static void log_usb_function_ready_event(const struct app_event_header *aeh)
+{
+	const struct usb_function_ready_event *event =
+		cast_usb_function_ready_event(aeh);
+
+	APP_EVENT_MANAGER_LOG(aeh, "function:%s",
+			      usb_function_name(event->function_mask));
+}
+
+static void profile_usb_function_ready_event(struct log_event_buf *buf,
+					     const struct app_event_header *aeh)
+{
+	const struct usb_function_ready_event *event =
+		cast_usb_function_ready_event(aeh);
+
+	nrf_profiler_log_encode_uint8(buf, event->function_mask);
+}
+
+APP_EVENT_INFO_DEFINE(usb_function_ready_event,
+		      ENCODE(NRF_PROFILER_ARG_U8),
+		      ENCODE("function_mask"),
+		      profile_usb_function_ready_event);
+
+APP_EVENT_TYPE_DEFINE(usb_function_ready_event,
+		      log_usb_function_ready_event,
+		      &usb_function_ready_event_info,
+		      APP_EVENT_FLAGS_CREATE(
+			      APP_EVENT_TYPE_FLAGS_INIT_LOG_ENABLE));

src/events/usb_prepare_event.c

@@ -0,0 +1,24 @@
+#include "usb_prepare_event.h"
+
+static void log_usb_prepare_event(const struct app_event_header *aeh)
+{
+	APP_EVENT_MANAGER_LOG(aeh, "prepare");
+}
+
+static void profile_usb_prepare_event(struct log_event_buf *buf,
+				      const struct app_event_header *aeh)
+{
+	ARG_UNUSED(buf);
+	ARG_UNUSED(aeh);
+}
+
+APP_EVENT_INFO_DEFINE(usb_prepare_event,
+		      ENCODE(),
+		      ENCODE(),
+		      profile_usb_prepare_event);
+
+APP_EVENT_TYPE_DEFINE(usb_prepare_event,
+		      log_usb_prepare_event,
+		      &usb_prepare_event_info,
+		      APP_EVENT_FLAGS_CREATE(
+			      APP_EVENT_TYPE_FLAGS_INIT_LOG_ENABLE));