21ic电子技术开发论坛 › 综合技术交流 › USB技术专区 › USB枚举问题
12下一页
返回列表 发新帖我要提问

USB枚举问题

[复制链接]
 楼主| ranxiaokang 发表于 2013-4-10 14:12 | 显示全部楼层 |阅读模式
USB, usb键盘, 数据包, 键盘, 大数据
请问大家一个问题，做USB键盘时，返回报告描述符时始终有几个字节数据没有返回（小于最大数据包大小）
回复 赏

举报

相关帖子
 楼主| ranxiaokang 发表于 2013-4-10 14:27 | 显示全部楼层
比如最后剩下12个字节数据，我发送到了端点0的缓冲区，主机并没有发起IN传输将这几个字节数据读走，就没有谁帮帮我吗。
回复 赏

举报

john_lee 发表于 2013-4-10 17:05 | 显示全部楼层
HID descriptor 中的 wDescriptorLength 是不是写小了？
回复 赏

举报

jornny520 发表于 2013-4-10 23:28 | 显示全部楼层
我也是刚学，，说一下，也不清楚是不是你想要的答案。主机在一开始的时候 并不是读取description里面的全部数据，而是先读部分，第一次的数据里面告诉了主机description的长度，后面他会再发一次指令要求输入全部的数据。
回复 赏

举报

 楼主| ranxiaokang 发表于 2013-4-11 10:01 | 显示全部楼层
john_lee 发表于 2013-4-10 17:05
HID descriptor 中的 wDescriptorLength 是不是写小了？

HID描述符的length没有写少
回复 赏

举报

 楼主| ranxiaokang 发表于 2013-4-11 10:02 | 显示全部楼层
jornny520 发表于 2013-4-10 23:28
我也是刚学，，说一下，也不清楚是不是你想要的答案。主机在一开始的时候 并不是读取description里 ...

报告描述符的长度从配置描述符中已知了，只需要获取完全就是了。
回复 赏

举报

john_lee 发表于 2013-4-11 11:57 | 显示全部楼层
ranxiaokang 发表于 2013-4-11 10:01
HID描述符的length没有写少

不是hid descriptor的length，而是hid descriptor中的每个report 的 length：

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复 赏

举报

 楼主| ranxiaokang 发表于 2013-4-11 14:59 | 显示全部楼层
john_lee 发表于 2013-4-11 11:57
不是hid descriptor的length，而是hid descriptor中的每个report 的 length：

谢谢版主的回答，这个是没有写少的。
回复 赏

举报

 楼主| ranxiaokang 发表于 2013-4-12 10:06 | 显示全部楼层
描述符如下
复制
  1. unsigned char code device_descriptor[] = {
    

  2.         0x12,                /* bLength */
    

  3.         0x01,                /* bDescriptor */
    

  4.         0x10, 0x01,        /* bcdUSB */
    

  5.         0x00,                /* bDeviceClass */
    

  6.         0x00,                /* bDeviceSubClass */
    

  7.         0x00,                /* bDevcieProtocol */
    

  8.         //0x40,                /* bMaxPacketSize */
    

  9.         0x10,                /* bMaxPacketSize */
    

  10.         0x00, 0x80,        /* idVendor */
    

  11.         0x01, 0x00,        /* idProduct */
    

  12.         0x00, 0x01,        /* bcdDevice */
    

  13.         0x00,//0x01,                /* iManufacturer */
    

  14.         0x00,//0x02,                /* iProduct */
    

  15.         0x00,                /* iSerialNumber */
    

  16.         0x01                /* bNumConfigurations */
    

  17. };
    


  18. 

  19. unsigned char code config_descriptor[] = {
    

  20.         /* usb configuration descriptor */
    

  21.         0x09,                /* bLength */
    

  22.         0x02,                /* bDescriptorType */
    

  23.         0x22, 0x00,        /* wTotalLength */
    

  24.         0x01,                /* bNumInterfaces */
    

  25.         0x01,                /* bConfigurationValue */
    

  26.         0x00,                /* iConfiguration */
    

  27.         0x80,                /* bmAttributes */
    

  28.         0x32,                /* bMaxPower */
    


  29. 

  30.         /* usb interface descriptor */
    

  31.         0x09,                /* bLength */
    

  32.         0x04,                /* bDescriptorType */
    

  33.         0x00,                /* bInterfaceNumber */
    

  34.         0x00,                /* bAlternateSetting */
    

  35.         0x01,                /* bNumEndpoints */
    

  36.         0x03,                /* bInterfaceClass */
    

  37.         0x01,                /* bInterfaceSubClass */
    

  38.         0x01,                /* bInterfaceProtocol */
    

  39.         0x00,                /* iInterface */
    


  40. 

  41.         /* usb hid descriptor */
    

  42.         0x09,                /* bLength */
    

  43.         0x21,                /* bDescriptorType */
    

  44.         0x01, 0x01,        /* bcdHID */
    

  45.         0x00,                /* bCountryCode */
    

  46.         0x01,                /* bNumDescriptor */
    

  47.         0x22,                /* wDescriptorType */
    

  48.         0x2d, 0x00,        /* wDescriptorLength */
    


  49. 

  50.         /* usb endpoint descriptor */
    

  51.         0x07,                /* bLength */
    

  52.         0x05,                /* bDescriptorType */
    

  53.         0x81,                /* bEndpointAddress */
    

  54.         0x03,                /* bmAttributes */
    

  55.         0x08, 0x00,        /* wMaxPacketSize */
    

  56.         0x0a                /* bInterval */
    

  57. };
    


  58. 

  59. //#define USB_KEYBOARD_USE_LED                1
    

  60. #define REPORT_DESCRIPTOR_SIZE                0x3f
    

  61. #define REPORT_DESCRIPTOR_NOLED_SIZE        0x2d
    


  62. 

  63. /*
    

  64.  * 键盘有输入报告和输出报告，其中输入报告8个字节，输出报告1个字节
    

  65.  * 输入报告格式如下：
    

  66.  * [Key6][Key5][Key4][Key3][Key2][Key1][Reserved][Function Key]
    

  67.  * 输出报告格式如下：
    

  68.  * 7~5                4        3        2                1                0
    

  69.  * Reserved        Kana        Compose        Scroll Lock        Caps Lock        Num Lock
    

  70.  */
    

  71. unsigned char code report_descriptor[] = {
    

  72.         0x05, 0x01,        /* Usage Page(Generic Desktop) */
    

  73.         0x09, 0x06,        /* Usage(Keyboard) */
    

  74.         0xa1, 0x01,        /* Collection(Application) */
    


  75. 

  76.         /* function key, such as Ctrl, Shift... */
    

  77.         0x05, 0x07,        /* Usage Page(Keyboard) */
    

  78.         0x19, 0xe0,        /* Usage Minimum(Keyboard LeftControl) */
    

  79.         0x29, 0xe7,        /* Usage Maximum(Keyboard Right GUI) */
    

  80.         0x15, 0x00,        /* Logical Minimum(0) */
    

  81.         0x25, 0x01,        /* Logical Maximum(1) */
    

  82.         0x75, 0x01,        /* Report Size(1) */
    

  83.         0x95, 0x08,        /* Report Count(8) */
    

  84.         0x81, 0x02,        /* Input(Data, Variable, Absolute) */
    


  85. 

  86.         /* byte for reserved */
    

  87.         0x95, 0x01,        /* Report Count(1) */
    

  88.         0x75, 0x08,        /* Report Size(8) */
    

  89.         0x81, 0x01,        /* Input(Constant) */
    


  90. 

  91. #ifdef USB_KEYBOARD_USE_LED
    

  92.         /* for LED */
    

  93.         0x95, 0x05,        /* Report Count(5) */
    

  94.         0x75, 0x01,        /* Report Size(1) */
    

  95.         0x05, 0x08,        /* Usage Page(for LEDs) */
    

  96.         0x19, 0x01,        /* Usage Minimum(Num Lock) */
    

  97.         0x29, 0x05,        /* Usage Maximum(Kana) */
    

  98.         0x91, 0x02,        /* Output(Data, Variable, Absolute) */
    

  99.         0x95, 0x01,        /* Report Count(1) */
    

  100.         0x75, 0x03,        /* Report Size(3) */
    

  101.         0x91, 0x01,        /* Output(Constant) */
    

  102. #endif
    

  103.         /* generic key */
    

  104.         0x95, 0x06,        /* Report Count(6) */
    

  105.         0x75, 0x08,        /* Report Size(8) */
    

  106.         0x15, 0x00,        /* Logical Minimum(0) */
    

  107.         0x25, 0x65,        /* Logical Maximum(101) */
    

  108.         0x05, 0x07,        /* Usage Page(Key Codes) */
    

  109.         0x19, 0x00,        /* Usage Minimum(0) */
    

  110.         0x29, 0x65,        /* Usage Maximum(101) */
    

  111.         0x81, 0x00,        /* Input(Data, Array) */
    


  112. 

  113.         0xc0                /* End Collection */
    

  114. };
回复 赏

举报

 楼主| ranxiaokang 发表于 2013-4-12 10:08 | 显示全部楼层
报告描述符长度为0x2d时，有0x0d字节未获取，如果是0x3f，则有0x0f字节未获取，感觉是丢掉了少于端点0最大数据包长度的数据。
回复 赏

举报

 楼主| ranxiaokang 发表于 2013-4-12 10:11 | 显示全部楼层
以下是枚举过程的代码：
复制
  1. #include "types.h"
    

  2. #include "printf.h"
    

  3. #include "time.h"
    

  4. #include "d12.h"
    

  5. #include "ch9.h"
    

  6. #include "usb.h"
    

  7. #include "hid.h"
    


  8. 


  9. 

  10. struct usb_device idata                device;
    


  11. 

  12. void usb_interrupt_handler(void) interrupt 0
    

  13. //void usb_interrupt_handler(void)
    

  14. {
    

  15.         struct usb_device *idata dev = &device;
    

  16.         u16 idata status;
    


  17. 

  18.         status = d12_read_interrupt_status();
    

  19.         //printf("status %x\r\n", (int)status);
    

  20.         switch (status) {
    

  21.         case D12_INT_BUS_RESET:
    

  22.                 //printf("usb bus reset.\r\n");
    

  23.                 break;
    

  24.         case D12_INT_SUSPEND_CHANGE:
    

  25.                 //printf("usb bus suspend.\r\n");
    

  26.                 break;
    

  27.         case D12_INT_EPT0_OUT:
    

  28.                 ept0out_event_handler(dev);
    

  29.                 break;
    

  30.         case D12_INT_EPT0_IN:
    

  31.                 ept0in_event_handler(dev);
    

  32.                 break;
    

  33.         case D12_INT_EPT1_OUT:
    

  34.                 break;
    

  35.         case D12_INT_EPT1_IN:
    

  36.                 d12_read_trans_status(D12_EPT1_IN);
    

  37.                 break;
    

  38.         default:
    

  39.                 break;
    

  40.         }
    

  41. }
    


  42. 

  43. void ept0out_event_handler(struct usb_device *dev)
    

  44. {
    

  45.         struct usb_setup_packet *idata pkt;
    

  46.         u8 idata buf[8];
    

  47.         u8 idata status;
    


  48. 

  49.         status = d12_read_trans_status(D12_EPT0_OUT);
    

  50.         pkt = (struct usb_setup_packet *)buf;
    


  51. 

  52.         //buf[0] = 0x80;
    

  53.         //puts("ept0out_event_handler\r\n");
    

  54.         if (status & D12_TRANS_STATUS_SETUP_PACKET) {
    

  55.                 d12_read_buffer(D12_EPT0_OUT, buf, 8);
    

  56.                 //printf("bmRequestType 0x%x bRequest 0x%x wValue 0x%x wIndex 0x%x wLength 0x%x\r\n",
    

  57.                 //        (int)pkt->bmRequestType, (int)pkt->bRequest, (int)pkt->wValue, (int)pkt->wIndex, (int)pkt->wLength);
    

  58.                 //printf("bRequest 0x%x\r\n", (int)pkt->bRequest);
    

  59.                 //printf("bmRequestType %x\r\n", (int)buf[0]);
    

  60.                 //printf("bRequest %x\r\n", buf[1]);
    

  61.                 //puts("usb setup request\r\n");
    

  62.                 //printf("读端点0缓冲区8个字节\r\n");
    

  63.                 //printf("0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\r\n",
    

  64.                 //        (int)buf[0], (int)buf[1], (int)buf[2], (int)buf[3], (int)buf[4], (int)buf[5], (int)buf[6], (int)buf[7], (int)buf[8]);
    

  65.                 d12_ack_setup();
    

  66.                 d12_clear_buffer();
    

  67.                 usb_setup_request(dev, pkt);
    

  68.         } else {
    

  69.                 d12_read_buffer(D12_EPT0_OUT, buf, 8);
    

  70.                 //d12_ack_setup();
    

  71.                 d12_clear_buffer();
    

  72.         }
    

  73. }
    


  74. 

  75. void usb_setup_request(struct usb_device *dev, struct usb_setup_packet *pkt)
    

  76. {
    

  77.         switch (pkt->bmRequestType & USB_TYPE_MASK) {
    

  78.         case USB_TYPE_STANDARD:
    

  79.                 //puts("usb standard request\r\n");
    

  80.                 usb_standard_request(dev, pkt);
    

  81.                 break;
    

  82.         case USB_TYPE_CLASS:
    

  83.                 usb_class_request(dev, pkt);
    

  84.                 break;
    

  85.         default:
    

  86.                 break;
    

  87.         }
    


  88. 

  89.         if (pkt->bmRequestType & 0x80) {
    

  90.                 dev->dir = USB_DIR_IN;
    

  91.                 usb_control_transfer(dev);
    

  92.         } else {
    

  93.                 dev->dir = USB_DIR_OUT;
    

  94.                 //d12_write_buffer(D12_EPT0_IN, (u8 *)0, 0);
    

  95.                 usb_control_transfer(dev);
    

  96.         }
    

  97.         
    

  98. }
    


  99. 

  100. void usb_standard_request(struct usb_device *dev, struct usb_setup_packet *pkt)
    

  101. {
    

  102.         //struct usb_request
    

  103.         u16 idata value = le16_to_cpu(pkt->wValue);
    

  104.         u16 idata index = le16_to_cpu(pkt->wIndex);
    

  105.         u16 idata length = le16_to_cpu(pkt->wLength);
    


  106. 

  107.         //printf("length = %x\r\n", (int)length);
    

  108.         switch (pkt->bRequest) {
    

  109.         case USB_REQ_GET_STATUS:
    

  110.                 //puts("get status\r\n");
    

  111.                 break;
    

  112.         case USB_REQ_CLEAR_FEATURE:
    

  113.                 //puts("clear feature\r\n");
    

  114.                 break;
    

  115.         //case USB_REQ_SET_FEATURE:
    

  116.         //        break;
    

  117.         case USB_REQ_SET_FEATURE:
    

  118.                 //puts("set feature\r\n");
    

  119.                 break;
    

  120.         case USB_REQ_SET_ADDRESS:
    

  121.                 d12_set_address((u8)value);
    

  122.                 //d12_write_buffer(D12_EPT0_IN, (u8 *)0, 0); /* return zero-length data packet */
    

  123.                 usb_set_device_state(dev, USB_STATE_ADDRESS);
    

  124.                 //puts("set address\r\n");
    

  125.                 break;
    

  126.         case USB_REQ_GET_DESCRIPTOR:
    

  127.                 //printf("length = %x\r\n", length);
    

  128.                 switch (value >> 8) {
    

  129.                 case USB_DT_DEVICE:
    

  130.                         dev->buf = device_descriptor;
    

  131.                         dev->size = MIN(0x12, length);
    

  132.                         //puts("get device descriptor\r\n");
    

  133.                         break;
    

  134.                 case USB_DT_CONFIG:
    

  135.                         dev->buf = config_descriptor;
    

  136.                         //dev->size = MIN(0x43, length);
    

  137.                         dev->size = MIN(0x22, length);
    

  138.                         //puts("get config descriptor\r\n");
    

  139.                         break;
    

  140.                 case USB_DT_STRING:
    

  141.                         break;
    

  142.                 case USB_DT_REPORT:
    

  143.                         dev->buf = report_descriptor;
    

  144.                         dev->size = MIN(0x2d, length);
    

  145.                         //printf("get report descriptor\r\n");
    

  146.                         //dev->size = 0x2d;
    

  147.                         break;
    

  148.                 }
    

  149.                 //puts("get device descriptor\r\n");
    

  150.                 //usb_control_transfer(dev);
    

  151.                 break;
    

  152.         case USB_REQ_SET_DESCRIPTOR:
    

  153.                 //puts("set descriptor\r\n");
    

  154.                 break;
    

  155.         case USB_REQ_GET_CONFIGURATION:
    

  156.                 dev->buf = &dev->config;
    

  157.                 dev->size = 1;
    

  158.                 //puts("get config\r\n");
    

  159.                 //usb_control_transfer(dev);
    

  160.                 break;
    

  161.         case USB_REQ_SET_CONFIGURATION:
    

  162.                 dev->config = (u8)value;
    

  163.                 //d12_endpoint_enable(ENABLE);
    

  164.                 d12_endpoint_enable(1);
    

  165.                 //d12_write_buffer(D12_EPT0_IN, (u8 *)0, 0);
    

  166.                 usb_set_device_state(dev, USB_STATE_CONFIGURED);
    

  167.                 //puts("set config\r\n");
    

  168.                 break;
    

  169.         case USB_REQ_GET_INTERFACE:
    

  170.                 //d12_write_buffer(D12_EPT0_IN, (u8 *)0, 0);
    

  171.                 //puts("get interface\r\n");
    

  172.                 break;
    

  173.         case USB_REQ_SET_INTERFACE:
    

  174.                 //puts("set interface\r\n");
    

  175.                 break;
    

  176.         default:
    

  177.                 break;
    

  178.         } 
    

  179. }
    


  180. 

  181. void usb_class_request(struct usb_device *dev, struct usb_setup_packet *pkt)
    

  182. {
    

  183.         hid_class_request(dev, pkt);
    

  184. }
    


  185. 

  186. void ept0in_event_handler(struct usb_device *dev)
    

  187. {
    

  188.         //puts("ept0in_event_handler\r\n");
    

  189.         d12_read_trans_status(D12_EPT0_IN);
    

  190.         
    

  191.         usb_control_transfer(dev);
    

  192. }
    


  193. 

  194. void usb_control_transfer(struct usb_device *dev)
    

  195. {
    

  196.         u8 code buf_size = 16;
    

  197.         u8 idata len;
    


  198. 

  199.         //printf("size %x\r\n", (int)dev->size);
    

  200.         //puts("control transfer\r\n");
    

  201.         if (dev->dir == USB_DIR_IN) {
    

  202.                 //puts("control transfer\r\n");
    

  203.                 //printf("size %x\r\n", (int)dev->size);
    

  204.                 if (dev->size != 0) {
    

  205.                         if (dev->size >= buf_size) {
    

  206.                                 len = buf_size;
    

  207.                                 dev->size -= len;
    

  208.                         } else {
    

  209.                                 len = dev->size;
    

  210.                                 dev->size = 0;
    

  211.                         }
    

  212.                         //dev->size -= len;
    


  213. 

  214.                         d12_write_buffer(D12_EPT0_IN, dev->buf, len);
    

  215.                         dev->buf += len;
    

  216.                 }
    

  217.         } else {
    

  218.                 d12_write_buffer(D12_EPT0_IN, (u8 *)0, 0);
    

  219.         }
    

  220. }
    


  221. 

  222. void usb_set_device_state(struct usb_device *dev, enum usb_device_state new_state)
    

  223. {
    

  224.         dev->state = new_state;
    

  225. }
    


  226. 

  227. enum usb_device_state usb_get_device_state(void)
    

  228. {
    

  229.         struct usb_device *dev = &device;
    


  230. 

  231.         return &dev->state;
    

  232. }
    


  233. 

  234. u8 usb_init(void)
    

  235. {
    

  236.         u16 chip_id;
    


  237. 

  238.         chip_id = d12_read_id();
    

  239.         if (chip_id != D12_CHIP_ID) {
    

  240.                 printf("d12 is not working.\r\n");
    

  241.                 return -1;
    

  242.         }
    


  243. 

  244.         d12_disconnect();
    

  245.         delayms(100);
    

  246.         d12_init();
    


  247. 

  248.         return 0;
    

  249. }
回复 赏

举报

 楼主| ranxiaokang 发表于 2013-4-12 10:13 | 显示全部楼层
获取设备描述符、配置描述符都是对的，希望大虾们帮我看看是哪里出了问题。
回复 赏

举报

 楼主| ranxiaokang 发表于 2013-4-16 16:47 | 显示全部楼层
:(
回复 赏

举报

liyihong028 发表于 2013-4-16 23:40 | 显示全部楼层
device_descriptor[]中的bMaxPacketSize应该为0x40,而不是0x10.
回复 赏

举报

 楼主| ranxiaokang 发表于 2013-4-20 10:52 | 显示全部楼层
本帖最后由 ranxiaokang 于 2013-4-20 11:02 编辑
liyihong028 发表于 2013-4-16 23:40
device_descriptor[]中的bMaxPacketSize应该为0x40,而不是0x10.

device_descriptor[]中的bMaxPacketSize表示端点0的最大传输能力，d12就是16个字节，而不是64个字节。
回复 赏

举报

jiege0129 发表于 2013-4-22 11:35 | 显示全部楼层
报告描述符的长度为63，而你在hid描述符中写0x2d，改为63应该就可以了，还有，你报告描述符中有输出功能，但是你没有定义输出端点，应该增加一个端点作为输出。
回复 赏

举报

 楼主| ranxiaokang 发表于 2013-4-22 14:11 | 显示全部楼层
jiege0129 发表于 2013-4-22 11:35
报告描述符的长度为63，而你在hid描述符中写0x2d，改为63应该就可以了，还有，你报告描述符中有输出功能， ...

不是这个问题啊，报告描述符中如果使用LED，那么描述符长度为63，如果不使用LED的话，长度就是0x2d，也就不需要输出端点了。
回复 赏

举报

jiege0129 发表于 2013-4-22 16:44 | 显示全部楼层
ranxiaokang 发表于 2013-4-22 14:11
不是这个问题啊，报告描述符中如果使用LED，那么描述符长度为63，如果不使用LED的话，长度就是0x2d，也就 ...

对啊，那你描述符里有写啊，这样后面的数据就忽略了，oxc0不就也会被忽略吗
回复 赏

举报

 楼主| ranxiaokang 发表于 2013-4-22 16:55 | 显示全部楼层
jiege0129 发表于 2013-4-22 16:44
对啊，那你描述符里有写啊，这样后面的数据就忽略了，oxc0不就也会被忽略吗 ...

我有宏定义会忽略这部分的定义。
回复 赏

举报

jiege0129 发表于 2013-4-22 19:10 | 显示全部楼层
ranxiaokang 发表于 2013-4-22 16:55
我有宏定义会忽略这部分的定义。

哦，看到了，那描述符应该是没问题，那你枚举成功了吗，用bus hound抓的数据确实是不完全的，至少报告描述符不能全部抓到。
回复 赏

举报

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

本版积分规则

ranxiaokang

1

主题

14

帖子

1

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