21ic电子技术开发论坛 › 综合技术交流 › USB技术专区 › 好象USB可以枚举成两个VID/PID啊？
12
返回列表 发新帖我要提问

[USB接口] 好象USB可以枚举成两个VID/PID啊？

[复制链接]
john_lee 发表于 2017-12-15 18:26 | 显示全部楼层
一骑红尘追梦中 发表于 2017-12-15 17:45
现在需要将其做成复合设备，因为AP与BP之间的通信数据有音频数据、网络数据等等，考虑到传输时尽量互不干 ...

如果没有特殊需求，比如多个PID/VID之类，一般不建议做成compound，而应该做成composite，用device中的各种interface来实现各种相应的功能。
回复 赏

举报

一骑红尘追梦中 发表于 2017-12-15 21:13 | 显示全部楼层
john_lee 发表于 2017-12-15 18:26
如果没有特殊需求，比如多个PID/VID之类，一般不建议做成compound，而应该做成composite，用device中的各 ...

一个USB接口实现多个设备，坦白说，对USB复合设备和组合设备分的不是特别的清楚，在设备框架高速和全速结构体中都有IAD描述符，查资料有说USB复合设备一般用IAD实现...就像我上面所说，最终的USB设备具有多路复用的功能，传输各种数据信息，您觉得该设计成哪一种呢？还有，方便的话能加您的联系方式咨询一下吗？真的很急需这方面的帮助，等你的回复
回复 赏

举报

一骑红尘追梦中 发表于 2017-12-15 22:17 | 显示全部楼层
john_lee 发表于 2017-12-15 18:24
如果没有特殊需求，比如多个PID/VID之类，一般不建议做成compound，而应该做成composite，用device中的各种 ...

一个USB接口实现多个设备，坦白说，对USB复合设备和组合设备分的不是特别的清楚，在设备框架高速和全速结构体中都有IAD描述符，查资料有说USB复合设备一般用IAD实现...就像我上面所说，最终的USB设备具有多路复用的功能，传输各种数据信息，您觉得该设计成哪一种呢？还有，方便的话能加您的联系方式咨询一下吗？真的很急需这方面的帮助，等您的回复
回复 赏

举报

一骑红尘追梦中 发表于 2017-12-18 11:28 | 显示全部楼层
本帖最后由 一骑红尘追梦中 于 2017-12-19 17:28 编辑
zhs2007 发表于 2017-8-24 15:48
首选像说明一下，USB复合设备，是指一个配置Configuration下，通过多个接口Interface实现多个独立设备协议 ...

您好！想向您咨询一下问题，就是我的目标平台上有USB OTG接口与串口接口，其中串口接口上接WindowsPC，而由于目标平台将USB定义成CDC_ACM类，WindowsPC缺少相应的驱动，故将USB OTG接口上接LinuxPC进行调试，现在的情况是在Linux主机下可以建立高速模式的通信：
[  409.972173] usb 2-4: new high-speed USB device number 5 using ehci-pci
[  410.105181] usb 2-4: config 1 interface 0 altsetting 0 endpoint 0x84 has an invalid bInterval 255, changing to 11
[  410.105195] usb 2-4: config 1 interface 1 altsetting 0 bulk endpoint 0x1 has invalid maxpacket 64
[  410.105204] usb 2-4: config 1 interface 1 altsetting 0 bulk endpoint 0x82 has invalid maxpacket 64
[  410.106414] usb 2-4: New USB device found, idVendor=xxxx, idProduct=xxxx
[  410.106422] usb 2-4: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[  410.106428] usb 2-4: Product: EL Composite device
[  410.106434] usb 2-4: Manufacturer: Expres Logic
[  410.106441] usb 2-4: SerialNumber: 0001
[  410.140701] cdc_acm 2-4:1.0: ttyACM0: USB ACM device
[  410.141131] usbcore: registered new interface driver cdc_acm
[  410.141134] cdc_acm: USB Abstract Control Model driver for USB modems and ISDN adapters
此上为USB OTG接口与主机建立通信后的打印信息。在源码中定义了设备框架高速描述符结构体和全速描述符结构体，且都具有IAD描述符，想请教的是：
1、若想将设备接入时默认为低速模式，是不是添加Linux系统下USB低速模式设备的描述符即可（当然还需要修改控制器的寄存器配置）？
2、基于现况，是实现复合设备还是组合设备呢？两者有点混...
希望能得到您的帮助，谢谢！
回复 赏

举报

xcvista 发表于 2017-12-22 01:31 | 显示全部楼层
USB 复合设备其实只有一个 VID/PID，但是在其内部通过 Interface 或 Interface Aggregation 的方式实现了若干不同的设备类。举个例子，如下的设备描述符（截取的 DAP42 源代码，项目本身开源）：
复制
  1. static const struct usb_device_config_descriptor usb_device_config_desc =
    

  2. {
    

  3.                 .config_descriptor =
    

  4.                 {
    

  5.                                 .bLength             = sizeof(struct usb_config_descriptor),
    

  6.                                 .bDescriptorType     = USB_DTYPE_CONFIGURATION,
    

  7.                                 .wTotalLength        = sizeof(struct usb_device_config_descriptor),
    

  8.                                 .bNumInterfaces      = 3,
    

  9.                                 .bConfigurationValue = 1,
    

  10.                                 .iConfiguration      = NO_DESCRIPTOR,
    

  11.                         .bmAttributes        = USB_CFG_ATTR_RESERVED | USB_CFG_ATTR_SELFPOWERED,
    

  12.                         .bMaxPower           = USB_CFG_POWER_MA(450)
    

  13.                 },
    


  14. 

  15.                 .hid_iad_descriptor =
    

  16.                 {
    

  17.                             .bLength             = sizeof(struct usb_iad_descriptor),
    

  18.                             .bDescriptorType     = USB_DTYPE_INTERFASEASSOC,
    

  19.                             .bFirstInterface     = 0,
    

  20.                             .bInterfaceCount     = 1,
    

  21.                             .bFunctionClass      = USB_CLASS_HID,
    

  22.                             .bFunctionSubClass   = USB_HID_SUBCLASS_NONBOOT,
    

  23.                             .bFunctionProtocol   = USB_HID_PROTO_NONBOOT,
    

  24.                             .iFunction           = 3
    

  25.                 },
    

  26.                 .hid_interface_descriptor =
    

  27.                 {
    

  28.                             .bLength             = sizeof(struct usb_interface_descriptor),
    

  29.                             .bDescriptorType     = USB_DTYPE_INTERFACE,
    

  30.                             .bInterfaceNumber    = 0,
    

  31.                             .bAlternateSetting   = 0,
    

  32.                             .bNumEndpoints       = 2,
    

  33.                             .bInterfaceClass     = USB_CLASS_HID,
    

  34.                             .bInterfaceSubClass  = USB_HID_SUBCLASS_NONBOOT,
    

  35.                             .bInterfaceProtocol  = USB_HID_PROTO_NONBOOT,
    

  36.                             .iInterface          = 3
    

  37.                 },
    

  38.                 .hid_descriptor =
    

  39.                 {
    

  40.                                 .bLength             = sizeof(struct usb_hid_descriptor),
    

  41.                                 .bDescriptorType     = USB_DTYPE_HID,
    

  42.                                 .bcdHID              = VERSION_BCD(1, 1, 1),
    

  43.                                 .bCountryCode        = USB_HID_COUNTRY_US,
    

  44.                                 .bNumDescriptors     = 1,
    

  45.                                 .bDescriptorType0    = USB_DTYPE_HID_REPORT,
    

  46.                                 .wDescriptorLength0  = sizeof(usb_hid_report_descriptor)
    

  47.                 },
    

  48.                 .hid_ep_in_descriptor =
    

  49.                 {
    

  50.                         .bLength             = sizeof(struct usb_endpoint_descriptor),
    

  51.                         .bDescriptorType     = USB_DTYPE_ENDPOINT,
    

  52.                         .bEndpointAddress    = USB_HID_IN_EP,
    

  53.                         .bmAttributes        = USB_EPTYPE_INTERRUPT,
    

  54.                         .wMaxPacketSize      = USB_PKT_SIZE,
    

  55.                         .bInterval           = 1
    

  56.                 },
    

  57.                 .hid_ep_out_descriptor =
    

  58.                 {
    

  59.                         .bLength             = sizeof(struct usb_endpoint_descriptor),
    

  60.                         .bDescriptorType     = USB_DTYPE_ENDPOINT,
    

  61.                         .bEndpointAddress    = USB_HID_OUT_EP,
    

  62.                         .bmAttributes        = USB_EPTYPE_INTERRUPT,
    

  63.                         .wMaxPacketSize      = USB_PKT_SIZE,
    

  64.                         .bInterval           = 1
    

  65.                 },
    


  66. 

  67.                 .cdc_iad_descriptor =
    

  68.                 {
    

  69.                             .bLength             = sizeof(struct usb_iad_descriptor),
    

  70.                             .bDescriptorType     = USB_DTYPE_INTERFASEASSOC,
    

  71.                             .bFirstInterface     = 1,
    

  72.                             .bInterfaceCount     = 2,
    

  73.                             .bFunctionClass      = USB_CLASS_CDC,
    

  74.                             .bFunctionSubClass   = USB_CDC_SUBCLASS_ACM,
    

  75.                             .bFunctionProtocol   = USB_CDC_PROTO_V25TER,
    

  76.                             .iFunction           = 4
    

  77.                 },
    

  78.                 .cdc_ctrl_interface_descriptor =
    

  79.                 {
    

  80.                             .bLength             = sizeof(struct usb_interface_descriptor),
    

  81.                             .bDescriptorType     = USB_DTYPE_INTERFACE,
    

  82.                             .bInterfaceNumber    = 1,
    

  83.                             .bAlternateSetting   = 0,
    

  84.                             .bNumEndpoints       = 1,
    

  85.                             .bInterfaceClass     = USB_CLASS_CDC,
    

  86.                             .bInterfaceSubClass  = USB_CDC_SUBCLASS_ACM,
    

  87.                             .bInterfaceProtocol  = USB_CDC_PROTO_V25TER,
    

  88.                             .iInterface          = 4
    

  89.                 },
    

  90.                 .cdc_header_descriptor =
    

  91.                 {
    

  92.                         .bFunctionLength     = sizeof(struct usb_cdc_header_desc),
    

  93.                         .bDescriptorType     = USB_DTYPE_CS_INTERFACE,
    

  94.                         .bDescriptorSubType  = USB_DTYPE_CDC_HEADER,
    

  95.                         .bcdCDC              = VERSION_BCD(1,1,0)
    

  96.                 },
    

  97.                 .cdc_call_management_descriptor =
    

  98.                 {
    

  99.                         .bFunctionLength     = sizeof(struct usb_cdc_call_mgmt_desc),
    

  100.                         .bDescriptorType     = USB_DTYPE_CS_INTERFACE,
    

  101.                         .bDescriptorSubType  = USB_DTYPE_CDC_CALL_MANAGEMENT,
    

  102.                         .bmCapabilities      = 0,
    

  103.                         .bDataInterface      = 2
    

  104.                 },
    

  105.             .cdc_acm_descriptor =
    

  106.             {
    

  107.                 .bFunctionLength         = sizeof(struct usb_cdc_acm_desc),
    

  108.                 .bDescriptorType         = USB_DTYPE_CS_INTERFACE,
    

  109.                 .bDescriptorSubType      = USB_DTYPE_CDC_ACM,
    

  110.                 .bmCapabilities          = USB_CDC_CAP_LINE,
    

  111.             },
    

  112.             .cdc_union_descriptor =
    

  113.             {
    

  114.                 .bFunctionLength         = sizeof(struct usb_cdc_union_desc),
    

  115.                 .bDescriptorType         = USB_DTYPE_CS_INTERFACE,
    

  116.                 .bDescriptorSubType      = USB_DTYPE_CDC_UNION,
    

  117.                 .bMasterInterface0       = 1,
    

  118.                 .bSlaveInterface0        = 2,
    

  119.             },
    

  120.                 .cdc_ep_ctrl_descriptor =
    

  121.                 {
    

  122.                         .bLength             = sizeof(struct usb_endpoint_descriptor),
    

  123.                         .bDescriptorType     = USB_DTYPE_ENDPOINT,
    

  124.                         .bEndpointAddress    = USB_CDC_CTRL_EP,
    

  125.                         .bmAttributes        = USB_EPTYPE_INTERRUPT,
    

  126.                         .wMaxPacketSize      = USB_PKT_SIZE,
    

  127.                         .bInterval           = 1
    

  128.                 },
    

  129.                 .cdc_data_interface_descriptor =
    

  130.                 {
    

  131.                             .bLength             = sizeof(struct usb_interface_descriptor),
    

  132.                             .bDescriptorType     = USB_DTYPE_INTERFACE,
    

  133.                             .bInterfaceNumber    = 2,
    

  134.                             .bAlternateSetting   = 0,
    

  135.                             .bNumEndpoints       = 2,
    

  136.                             .bInterfaceClass     = USB_CLASS_CDC_DATA,
    

  137.                             .bInterfaceSubClass  = USB_SUBCLASS_NONE,
    

  138.                             .bInterfaceProtocol  = USB_PROTO_NONE,
    

  139.                             .iInterface          = 4
    

  140.                 },
    

  141.                 .cdc_ep_data_rx_descriptor =
    

  142.                 {
    

  143.                         .bLength             = sizeof(struct usb_endpoint_descriptor),
    

  144.                         .bDescriptorType     = USB_DTYPE_ENDPOINT,
    

  145.                         .bEndpointAddress    = USB_CDC_DATA_OUT_EP,
    

  146.                         .bmAttributes        = USB_EPTYPE_BULK,
    

  147.                         .wMaxPacketSize      = USB_PKT_SIZE,
    

  148.                         .bInterval           = 1
    

  149.                 },
    

  150.                 .cdc_ep_data_tx_descriptor =
    

  151.                 {
    

  152.                         .bLength             = sizeof(struct usb_endpoint_descriptor),
    

  153.                         .bDescriptorType     = USB_DTYPE_ENDPOINT,
    

  154.                         .bEndpointAddress    = USB_CDC_DATA_IN_EP,
    

  155.                         .bmAttributes        = USB_EPTYPE_BULK,
    

  156.                         .wMaxPacketSize      = USB_PKT_SIZE,
    

  157.                         .bInterval           = 1
    

  158.                 },
    

  159. };
这个设备描述符通过 IAD 的方式复合了一个 HID 和一个 CDC 串口设备。CDC 本身因为使用了两个 Interface 因此需要 IAD，如果是譬如 HID 这种只需要一个 Interface 的通信协议的话可以不用 IAD。（这个设备其实我计划了 CDC+HID+MSC 的三路复合设备，就是希望 STM32F042K6 能放得下这点代码。）
回复 赏

举报

sipodev 发表于 2022-10-17 19:55 | 显示全部楼层
有做出来了吗？
回复 赏

举报

sipodev 发表于 2022-10-17 19:56 | 显示全部楼层
就算你配置好了HUB, 一个普通的USB设备不可能处理多个USB地址的数据，怎么处理多个地址的问题呢？
回复 赏

举报

12
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

快速回复 在线客服 返回列表 返回顶部