I use usb controller in Lpc2148. I get example code from keil website in HID class. I need adapt InReport up to 64 byte( InReport[0],InReport[1]....,InReport[64]) for send more data but I donn't good enough in C programming. How can I do? pleas give code. How can I develop application software in the host side. I need Visual Basic 6 thanks you
"I donn't good enough in C programming. How can I do?"
There's no way out - you're either going to have to learn 'C', or get someone else to do it for you: http://www.keil.com/condb/search.asp
"pleas give code"
If you don't know 'C', how will you understand it? How will that help?
"How can I develop application software in the host side."
Again, that's another programming task
"I need Visual Basic 6"
Why Visusal Basic? Why specifically 6?
If you're having trouble just learning 'C', why also try to learn another language (VB)?
You can download free "Express" versions of microsoft VisualStudio: msdn2.microsoft.com/.../aa700735.aspx
Borland have a similar arrangement with their "Turbo Explorer" products: www.codegear.com/.../turbo
Probably easier to go for something like that - rather than try to learn 2 different languages at once!
http://www.keil.com/books/genbooks.asp
and any decent bookshop or library will have shelves full of 'C' programming books...
The problem seems to lie in your understanding on USB rather than C itself. On the USB side, the descriptor work will finish it, as follows.
On the Axelson's HID page, you'll find host app examples for C#, VB6 and VC6 http://www.lvr.com/hidpage.htm
Tsuneo
#define INREPORT_SIZE 64 BYTE InReport[ INREPORT_SIZE ]; /* HID Input Report */ /* HID Report Descriptor */ const BYTE HID_ReportDescriptor[] = { HID_UsagePageVendor(0x00), HID_Usage(0x01), HID_Collection(HID_Application), HID_UsagePage(HID_USAGE_PAGE_BUTTON), HID_UsageMin(1), HID_UsageMax(3), HID_LogicalMin(0), HID_LogicalMax(1), // HID_ReportCount(3), // increase the size of report // HID_ReportSize(1), HID_ReportCount( INREPORT_SIZE ), // bytes HID_ReportSize(8), // bits HID_Input(HID_Data | HID_Variable | HID_Absolute), // HID_ReportCount(1), // <------ comment out these three lines // HID_ReportSize(5), // HID_Input(HID_Constant), HID_UsagePage(HID_USAGE_PAGE_LED), HID_Usage(HID_USAGE_LED_GENERIC_INDICATOR), HID_LogicalMin(0), HID_LogicalMax(1), HID_ReportCount(8), HID_ReportSize(1), HID_Output(HID_Data | HID_Variable | HID_Absolute), HID_EndCollection, }; /* USB Configuration Descriptor */ /* All Descriptors (Configuration, Interface, Endpoint, Class, Vendor */ const BYTE USB_ConfigDescriptor[] = { ... ... /* Endpoint, HID Interrupt In */ USB_ENDPOINT_DESC_SIZE, /* bLength */ USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType */ USB_ENDPOINT_IN(1), /* bEndpointAddress */ USB_ENDPOINT_TYPE_INTERRUPT, /* bmAttributes */ // WBVAL(0x0004), /* wMaxPacketSize */ // increase the max packet size WBVAL( 0x0040 ), /* wMaxPacketSize */ // = 64, this value is not directly 0x20, /* 32ms */ /* bInterval */ // concerned to INREPORT_SIZE /* Terminator */ 0 /* bLength */ };
Hello Tsuneo Chinzei,
I've implemented the code you suggested and I got it working just fine.
Could you please let me have details about modifiyng the OutReport so I can send 64byte to the board as well.
Thank you Aqua
i>"I've implemented the code you suggested and I got it working just fine."
Congratulation!
Then, the next exercise goes one step further. In this exercise, we implement OUT endpoint.
USB class implementation is divided into three parts. - Descriptor work - Class specific request handling - Endpoint handling
Descriptor work Above report descriptor is simplified as follows. This descriptor defines 64bytes Input and Output report
#define INREPORT_SIZE 64 #define OUTREPORT_SIZE 64 BYTE InReport[ INREPORT_SIZE ]; /* HID Input Report */ BYTE OutReport[ OUTREPORT_SIZE ]; /* HID Output Report */ /* HID Report Descriptor */ const BYTE HID_ReportDescriptor[] = { HID_UsagePageVendor( 0x00 ), HID_Usage( 0x01 ), HID_Collection( HID_Application ), HID_LogicalMin( 0 ), HID_LogicalMaxS( 0xFF ), HID_ReportSize( 8 ), // bits HID_ReportCount( INREPORT_SIZE ), // bytes HID_Usage( 0x01 ), HID_Input( HID_Data | HID_Variable | HID_Absolute ), HID_ReportCount( OUTREPORT_SIZE ), // bytes HID_Usage( 0x01 ), HID_Output( HID_Data | HID_Variable | HID_Absolute ), HID_EndCollection, };
In this example, no OUT endpoint (EP) is defined on the configuration set. To add the OUT EP, - Add the endpoint descriptor bytes to wTotalLength of Configuration descriptor - Add an OUT endpoint descriptor at the end of the configuration set. wTotalLength field represents the sum of bytes of all configuration set ie. wTotalLength = config + interface + HID desc + endpoints (IN and OUT).
/* USB Configuration Descriptor */ /* All Descriptors (Configuration, Interface, Endpoint, Class, Vendor */ const BYTE USB_ConfigDescriptor[] = { /* Configuration 1 */ USB_CONFIGUARTION_DESC_SIZE, /* bLength */ USB_CONFIGURATION_DESCRIPTOR_TYPE, /* bDescriptorType */ WBVAL( /* wTotalLength */ USB_CONFIGUARTION_DESC_SIZE + USB_INTERFACE_DESC_SIZE + HID_DESC_SIZE + USB_ENDPOINT_DESC_SIZE + // Add OUT EP descriptor bytes USB_ENDPOINT_DESC_SIZE ), 0x01, /* bNumInterfaces */ 0x01, /* bConfigurationValue */ 0x00, /* iConfiguration */ USB_CONFIG_BUS_POWERED /*|*/ /* bmAttributes */ /*USB_CONFIG_REMOTE_WAKEUP*/, USB_CONFIG_POWER_MA(100), /* bMaxPower */ ... /* Endpoint, HID Interrupt In */ USB_ENDPOINT_DESC_SIZE, /* bLength */ USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType */ USB_ENDPOINT_IN(1), /* bEndpointAddress */ USB_ENDPOINT_TYPE_INTERRUPT, /* bmAttributes */ WBVAL(0x0040), /* wMaxPacketSize */ // = 64 0x20, /* 32ms */ /* bInterval */ /* Endpoint, HID Interrupt Out */ USB_ENDPOINT_DESC_SIZE, /* bLength */ USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType */ USB_ENDPOINT_OUT(1), /* bEndpointAddress */ USB_ENDPOINT_TYPE_INTERRUPT, /* bmAttributes */ WBVAL(0x0040), /* wMaxPacketSize */ // = 64 0x20, /* 32ms */ /* bInterval */ /* Terminator */ 0 /* bLength */ };
The EP address for the OUT EP is set to 1. This address is the logical address. The two endpoints, IN EP1 and OUT EP1, are independent endpoints.
When wMaxPacketSize is set to 64, it means this endpoint exchanges 0 - 64 bytes packet. 64 is the max packet (payload) size for Full-Speed interrupt transfer.
You can define HID Report of more than 64 bytes. In this case, the report transfer is split into 64 bytes (or less) packets. For example, 150 bytes report is split into three packets, 64 + 64 + 22. You'll often see this "split transfer into packets" phrase in USB implementation.
I didn't touch the bInterval fields of endpoint descriptors. This value determines the interval between packtes. Smaller value results faster (more frequent) transfer. The minimum value is 1 ms. Tune it as you like.
Class specific request In this example, the Output report is supported through EP0 (default EP) using SetReport request. Now we define the dedicated endpoint for OUT. Then, this SetReport( Output ) handler is not used.
hiduser.c BOOL HID_SetReport (void) { /* ReportID = SetupPacket.wValue.WB.L; */ switch (SetupPacket.wValue.WB.H) { case HID_REPORT_INPUT: return (FALSE); /* Not Supported */ case HID_REPORT_OUTPUT: // OutReport = EP0Buf[0]; // delete three lines // SetOutReport(); // break; return (FALSE); /* Not Supported */ case HID_REPORT_FEATURE: return (FALSE); /* Not Supported */ } return (TRUE); }
On the host application, WriteFile() is used to send Output report, instead of HidD_SetOutputReport(). See the examples on Axelson's HID page http://www.lvr.com/hidpage.htm
Endpoint handling To the EP1 interrupt handler, add the OUT EP1 handler. Read out the OUT packet from the USB engine, and store it to OutReport. Then, call SetOutReport(). That is, the Output procedure in HID_SetReport() moves to here. Modify SetOutReport() as you like.
usbuser.c void USB_EndPoint1 (DWORD event) { switch (event) { case USB_EVT_IN: GetInReport(); USB_WriteEP(0x81, &InReport, sizeof(InReport)); break; case USB_EVT_OUT: USB_ReadEP(0x01, &OutReport); SetOutReport(); break; } }
That's all. Now, you have symmetric IN and OUT endpoints.
USB endpoint handling is like to UART. The interrupt of IN EP means that the packet is sent to the host and the EP is empty; TX empty. The interrupt of OUT EP means that a packet is received from the host on the EP; RX loaded.
In this modification, I showed a method to read or write the EPs in interrupt. However, you don't always need to handle the EPs in interrupt. It's also like to UART TX and RX; UART is handled either in interrupt or polling. The host determines the timing of the endpoint interrupt. However, you may have to follow another timing given by the device side. For example, USB mouse and keyboard send Input report just when the device detects user's action. In this case, handle the endpoint in polling method.
int InEP_empty = TRUE; int OutEP_loaded = FALSE; void USB_EndPoint1 (DWORD event) { switch (event) { case USB_EVT_IN: InEP_empty = TRUE; break; case USB_EVT_OUT: OutEP_loaded = TRUE; break; } } void Handle_user_action( void ) { if ( InEP_empty ) { // // fill an input report to InReport here // USB_WriteEP(0x81, &InReport, sizeof(InReport)); } } void Handle_next_command( void ) { if ( OutEP_loaded ) { USB_ReadEP(0x01, &OutReport); // // handle the command on output report here // } }
You don't need to read out OUT EPs immediately on interrupt. The host retries transfer while the OUT EP is occupied. Then, the device can make the host wait until the device unloads the OUT EP. No data loss. This is the flow control mechanism built-in to USB protocol (NAKing).
Aha, I missed to show the modification of interface descriptor.
/* Interface 0, Alternate Setting 0, HID Class */ USB_INTERFACE_DESC_SIZE, /* bLength */ USB_INTERFACE_DESCRIPTOR_TYPE, /* bDescriptorType */ 0x00, /* bInterfaceNumber */ 0x00, /* bAlternateSetting */ 0x02, /* bNumEndpoints */ USB_DEVICE_CLASS_HUMAN_INTERFACE, /* bInterfaceClass */ HID_SUBCLASS_NONE, /* bInterfaceSubClass */ HID_PROTOCOL_NONE, /* bInterfaceProtocol */ 0x5C, /* iInterface */
Okay, according to your directions I now have both in and out 64byte transfer. So far it looks fine. I'm going to involve it in one of my projects.
I just wonder if I did the DESCRIPTOR WORK as expected:
/* HID Report Descriptor */ const BYTE HID_ReportDescriptor[] = { HID_UsagePageVendor(0x00),
HID_Usage(0x01),
HID_Collection(HID_Application),
HID_UsagePage(HID_USAGE_PAGE_BUTTON),
HID_UsageMin(1),
HID_UsageMax(3),
HID_LogicalMin(0),
HID_LogicalMax(1),
HID_ReportCount(INREPORT_SIZE),
HID_ReportSize(8),
HID_Input(HID_Data | HID_Variable | HID_Absolute),
HID_UsagePage(HID_USAGE_PAGE_LED),
HID_Usage(HID_USAGE_LED_GENERIC_INDICATOR),
// HID_ReportCount(8),
// HID_ReportSize(1),
HID_Output(HID_Data | HID_Variable | HID_Absolute),
HID_EndCollection, };
Thank you for helping.
Aqua
I recommend you this simplified report descriptor (same as the report desc in my above (21-Nov-2007 17:02) post))
const BYTE HID_ReportDescriptor[] = { HID_UsagePageVendor( 0x00 ), HID_Usage( 0x01 ), HID_Collection( HID_Application ), HID_LogicalMin( 0 ), HID_LogicalMaxS( 0xFF ), HID_ReportSize( 8 ), // bits HID_ReportCount( INREPORT_SIZE ), // bytes HID_Usage( 0x01 ), HID_Input( HID_Data | HID_Variable | HID_Absolute ), HID_ReportCount( OUTREPORT_SIZE ), // bytes HID_Usage( 0x01 ), HID_Output( HID_Data | HID_Variable | HID_Absolute ), HID_EndCollection, };
You'll find the detailed (maybe too detailed :-) ) definition of the report descriptor here. "Device Class Definition for HID 1.11" - HID spec www.usb.org/.../HID1_11.pdf 6.2.2 Report Descriptor (HID1_11.pdf ver1.11 p23)
You can confirm your report descriptor using this tool. "HID Descriptor Tool" on USB.org www.usb.org/.../dt2_4.zip
If you aren't implementing a specific HID device like mouse and keyboard, however, above simplified report descriptor is enough.
Ummm.. In above posts, I didn't write about USB_Configure_Event() (usbuser.c) as the initialization of USB routines. But I won't write elaborate long post in this forum any more, because of the weird SPAM filter. You'll find me in these fora. See you in these fora again. Bye!!
LPC2000 tech.groups.yahoo.com/.../
USB-IF Developers " href= "http://www.cygnal.org/scripts/Ultimate.cgi?action=intro">www.cygnal.org/.../Ultimate.cgi
8052.com " http://www.keil.com/forum/docs/thread11241.asp
why did you put both handlers in the same endpoint if endpoints are unidiretional? I mean endpoint 1 will only be called if there's an event IN. Wouldn't you need to chance the EVENT OUT to antoher endpoint?
Hello Doug,
It's because KEIL implementation joins the handler for IN and OUT endpoints into single one. See following excerpt.
usbhw.c USB_ISR() { ... /* Endpoint's Slow Interrupt */ if (disr & EP_SLOW_INT) { while (EP_INT_STAT) { /* Endpoint Interrupt Status */ for (n = 0; n < USB_EP_NUM; n++) { /* Check All Endpoints */ if (EP_INT_STAT & (1 << n)) { m = n >> 1; // convert physical endpoint number to logical one EP_INT_CLR = 1 << n; while ((DEV_INT_STAT & CDFULL_INT) == 0); val = CMD_DATA; if ((n & 1) == 0) { /* OUT Endpoint */ if (n == 0) { /* Control OUT Endpoint */ if (val & EP_SEL_STP) { /* Setup Packet */ if (USB_P_EP[0]) { USB_P_EP[0](USB_EVT_SETUP); continue; } } } if (USB_P_EP[m]) { USB_P_EP[m](USB_EVT_OUT); // the same handler is called for IN and OUT } } else { /* IN Endpoint */ if (USB_P_EP[m]) { USB_P_EP[m](USB_EVT_IN); } } } } } } Endpoint handler function table - just 16 for 32 endpoints usbuser.c #define P_EP(n) ((USB_EP_EVENT & (1 << (n))) ? USB_EndPoint##n : NULL) /* USB Endpoint Events Callback Pointers */ void (* const USB_P_EP[16]) (DWORD event) = { P_EP(0), P_EP(1), P_EP(2), P_EP(3), P_EP(4), P_EP(5), P_EP(6), P_EP(7), P_EP(8), P_EP(9), P_EP(10), P_EP(11), P_EP(12), P_EP(13), P_EP(14), P_EP(15), };
Thanks, do you know any software I can use to debug the usb? I've followed the steps you've posted but haven't got any luck yet, I'm not sure what could be the cause of this.. if you could give me a hand that would be nice :) thanks in advance
Check the enumeration step on the USB bus. Do you have a hardware USB bus analyzer? If you don't have any one, download this software sniffer and 'evaluate' it :-)
Commercial, 1-month eval: SourceUSB http://www.sourcequest.com/
What is the last request on the bus? - If the last request fails (usually, followed by bus reset), the problem lies on the request handler on the firmware. - If the last request succeeds, and it is one of Get_Descriptor, the problem lies on the descriptor.
In this way, narrow down the problem, first.
To check the integrity of the HID report descriptor, this tool is helpful.
"HID Descriptor Tool" on USB.org www.usb.org/.../dt2_4.zip
This post to SiLabs forum shows a typical enumeration process of vendor-specific HID.
"Difference on HID enumeration on Win, Linux and Mac" www.cygnal.org/.../001325.html
Hi Tsuneo I've downloaded the software and the last thing on the bus was a "GET DESCRIPTOR FROM INTERFACE" after that it turns to "BULK OR INTERRUPT TRANSFER" but it always appear one "Sucess" and the next report is "Not Supported". I've also checked your post on how winxp sp2 enumeration process should go and mine isnt really like that it has some similarities. Now in your last post you said that if the last thing on bus was "GET DESCRIPTOR FROM INTERFACE" the problem should be on the descriptor however I'm not so sure what to look for since I've followed your instructions. Doug.
"GET DESCRIPTOR FROM INTERFACE"
I suppose you mean Get_Descriptor( Configuration ). Interface descriptor is not directly accessed by Get_Descriptor request.
When USB device receives Get_Descriptor( Configuration ), it returns full configuration set, ie. configuration / interface / HID / endpoints descriptors.
Can you post the configuration descriptor set?
Hi, sure here it is :) const BYTE USB_ConfigDescriptor[] = { /* Configuration 1 */ USB_CONFIGUARTION_DESC_SIZE, /* bLength */
USB_CONFIGURATION_DESCRIPTOR_TYPE, /*bDescriptorType */ WBVAL( /* wTotalLength */ USB_CONFIGUARTION_DESC_SIZE + USB_INTERFACE_DESC_SIZE + HID_DESC_SIZE + USB_ENDPOINT_DESC_SIZE + USB_ENDPOINT_DESC_SIZE ), 0x01, /* bNumInterfaces */ 0x01, /* bConfigurationValue */ 0x00, /* iConfiguration */ USB_CONFIG_BUS_POWERED /*|*/ /* bmAttributes */ /*USB_CONFIG_REMOTE_WAKEUP*/, USB_CONFIG_POWER_MA(100), /* bMaxPower */ /* Interface 0, Alternate Setting 0, HID Class */ USB_INTERFACE_DESC_SIZE, /* bLength */ USB_INTERFACE_DESCRIPTOR_TYPE,/* bDescriptorType */ 0x00, /* bInterfaceNumber */ 0x00, /* bAlternateSetting */ 0x02, /* bNumEndpoints */ USB_DEVICE_CLASS_HUMAN_INTERFACE,/* bInterfaceClass */ HID_SUBCLASS_NONE, /* bInterfaceSubClass */ HID_PROTOCOL_NONE, /* bInterfaceProtocol */ 0x5C, /* iInterface */ /* HID Class Descriptor */ /* HID_DESC_OFFSET = 0x0012 */ HID_DESC_SIZE, /* bLength */ HID_HID_DESCRIPTOR_TYPE, /* bDescriptorType */ WBVAL(0x0100), /* 1.00 */ /* bcdHID */ 0x00, /* bCountryCode */ 0x01, /* bNumDescriptors */ HID_REPORT_DESCRIPTOR_TYPE, /* bDescriptorType */ WBVAL(HID_REPORT_DESC_SIZE), /* wDescriptorLength */ /* Endpoint, HID Interrupt In */ USB_ENDPOINT_DESC_SIZE, /* bLength */ USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType */ USB_ENDPOINT_IN(1), /* bEndpointAddress */ USB_ENDPOINT_TYPE_INTERRUPT, /* bmAttributes */ WBVAL(0x0040), /* wMaxPacketSize */ 0x20, /* 32ms */ /* bInterval */ /* Endpoint, HID Interrupt Out */ USB_ENDPOINT_DESC_SIZE, /* bLength */ USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType */ USB_ENDPOINT_OUT(1), /* bEndpointAddress */ USB_ENDPOINT_TYPE_INTERRUPT, /* bmAttributes */ WBVAL(0x0040), /*wMaxPacketSize // = 64 0x20, /* 32ms */ /* bInterval */ /* Terminator */ 0 /* bLength */ };
Ok, I think this looks better
const BYTE USB_ConfigDescriptor[] = {
/* Configuration 1 */
USB_CONFIGUARTION_DESC_SIZE, /* bLength */
USB_CONFIGURATION_DESCRIPTOR_TYPE, /*DescriptorType */
WBVAL( /* wTotalLength */
USB_CONFIGUARTION_DESC_SIZE +
USB_INTERFACE_DESC_SIZE +
HID_DESC_SIZE +
USB_ENDPOINT_DESC_SIZE +
USB_ENDPOINT_DESC_SIZE ), 0x01, /* bNumInterfaces */
0x01, /* bConfigurationValue */
0x00, /* iConfiguration */
USB_CONFIG_BUS_POWERED /*|*/ /* bmAttributes */
/*USB_CONFIG_REMOTE_WAKEUP*/, USB_CONFIG_POWER_MA(100), /* bMaxPower */
/* Interface 0, Alternate Setting 0, HID Class */
USB_INTERFACE_DESC_SIZE, /* bLength */
USB_INTERFACE_DESCRIPTOR_TYPE, /*bDescriptorType */
0x00, /* bInterfaceNumber */
0x00, /* bAlternateSetting */
0x02, /* bNumEndpoints */
USB_DEVICE_CLASS_HUMAN_INTERFACE,/* bInterfaceClass */
HID_SUBCLASS_NONE, /* bInterfaceSubClass */
HID_PROTOCOL_NONE, /* bInterfaceProtocol */ 0x5C, /* iInterface */ /* HID Class Descriptor */
/* HID_DESC_OFFSET = 0x0012 */
HID_DESC_SIZE, /* bLength */
HID_HID_DESCRIPTOR_TYPE, /* bDescriptorType */
WBVAL(0x0100), /* 1.00 */ /* bcdHID */
0x00, /* bCountryCode */
0x01, /* bNumDescriptors */
HID_REPORT_DESCRIPTOR_TYPE, /* bDescriptorType */
WBVAL(HID_REPORT_DESC_SIZE),/* wDescriptorLength */
/* Endpoint, HID Interrupt In */ USB_ENDPOINT_DESC_SIZE, /* bLength */
USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType */
USB_ENDPOINT_IN(1), /* bEndpointAddress */
USB_ENDPOINT_TYPE_INTERRUPT, /* bmAttributes */
WBVAL(0x0040), /* wMaxPacketSize */
0x20, /* 32ms */ /* bInterval */
/* Endpoint, HID Interrupt Out */
USB_ENDPOINT_DESC_SIZE, /* bLength */
USB_ENDPOINT_OUT(1), /* bEndpointAddress */
WBVAL(0x0040), /* wMaxPacketSize */ // = 64
/* Terminator */
0 /* bLength */ }; Doug
How about using approporiate code formatting, as per the instructions above the text input window ?
const BYTE USB_ConfigDescriptor[] = { /* Configuration 1 */ USB_CONFIGUARTION_DESC_SIZE, /* bLength */ USB_CONFIGURATION_DESCRIPTOR_TYPE, /*DescriptorType */ WBVAL( /* wTotalLength */ USB_CONFIGUARTION_DESC_SIZE + USB_INTERFACE_DESC_SIZE + HID_DESC_SIZE + USB_ENDPOINT_DESC_SIZE + USB_ENDPOINT_DESC_SIZE ), 0x01, /* bNumInterfaces */ 0x01, /* bConfigurationValue */ 0x00, /* iConfiguration */ USB_CONFIG_BUS_POWERED /*|*/ /* bmAttributes */ /*USB_CONFIG_REMOTE_WAKEUP*/, USB_CONFIG_POWER_MA(100), /* bMaxPower */ /* Interface 0, Alternate Setting 0, HID Class */ USB_INTERFACE_DESC_SIZE, /* bLength */ USB_INTERFACE_DESCRIPTOR_TYPE, /*bDescriptorType */ 0x00, /* bInterfaceNumber */ 0x00, /* bAlternateSetting */ 0x02, /* bNumEndpoints */ USB_DEVICE_CLASS_HUMAN_INTERFACE,/* bInterfaceClass */ HID_SUBCLASS_NONE, /* bInterfaceSubClass */ HID_PROTOCOL_NONE, /* bInterfaceProtocol */ 0x5C, /* iInterface */ /* HID Class Descriptor */ /* HID_DESC_OFFSET = 0x0012 */ HID_DESC_SIZE, /* bLength */ HID_HID_DESCRIPTOR_TYPE, /* bDescriptorType */ WBVAL(0x0100), /* 1.00 */ /* bcdHID */ 0x00, /* bCountryCode */ 0x01, /* bNumDescriptors */ HID_REPORT_DESCRIPTOR_TYPE, /* bDescriptorType */ WBVAL(HID_REPORT_DESC_SIZE),/* wDescriptorLength */ /* Endpoint, HID Interrupt In */ USB_ENDPOINT_DESC_SIZE, /* bLength */ USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType */ USB_ENDPOINT_IN(1), /* bEndpointAddress */ USB_ENDPOINT_TYPE_INTERRUPT, /* bmAttributes */ WBVAL(0x0040), /* wMaxPacketSize */ 0x20, /* 32ms */ /* bInterval */ /* Endpoint, HID Interrupt Out */ USB_ENDPOINT_DESC_SIZE, /* bLength */ USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType */ USB_ENDPOINT_OUT(1), /* bEndpointAddress */ USB_ENDPOINT_TYPE_INTERRUPT, /* bmAttributes */ WBVAL(0x0040), /* wMaxPacketSize */ // = 64 0x20, /* 32ms */ /* bInterval */ /* Terminator */ 0 /* bLength */ };
Yeah I suppose thats better I didnt noticed that :) thanks
Your Configuration descriptor set is fine. I had jumped to wrong conclusion... OK, I reconsider on your previous post.
"the last thing on the bus was a "GET DESCRIPTOR FROM INTERFACE"
Humm.. then isn't it Get_Descriptor( HID_REPORT )?
bmRequestType: 0x81 (IN from interface) bRequest : 0x06 (GetDescriptor) wValue : 0x2200 (HID REport, report ID = 0) wIndex : 0x0000 (interface 0)
"after that it turns to "BULK OR INTERRUPT TRANSFER" but it always appear one "Sucess" and the next report is "Not Supported".
Is it the first Input report? What is the direction of the transfer? If so, the enumeration finishes successfully.
What do you mean "Not Supported"?
Tsuneo Like I said on my previous post I've donwloaded the sniffer you suggested. The software Im working on is the Keil HID example which is one their website. I've changed the code accoding to your posts. I think like you've said enumeration works fine, the majority of the reports are in.
The "not supported" message I get using the sniffer and it comes every other report after enumeration. I dont think this message causes any harm cause I've tested the original software and it shows just the same msg as the altered version. Still trying to figure this out, Doug
Hi I was wondering, don't I have to configure the endpoint in the usbcfg? The code says there's a wizard for that but just cant find it. Does anybody know ? Doug
"Don't I have to configure the endpoint in the usbcfg?"
I don't think so. If there is anything to modify on usbcfg.h, it's USB_EP_EVENT
usbcfg.h #define USB_EP_EVENT 0x0003
This constant works as a mask to the Events Callback function table in usbuser.c Please note, the logical endpoint number (joined IN and OUT) is applied here.
usbuser.c #define P_EP(n) ((USB_EP_EVENT & (1 << (n))) ? USB_EndPoint##n : NULL) /* USB Endpoint Events Callback Pointers */ void (* const USB_P_EP[16]) (DWORD event) = { P_EP(0), P_EP(1), P_EP(2), P_EP(3), P_EP(4), P_EP(5), P_EP(6), P_EP(7), P_EP(8), P_EP(9), P_EP(10), P_EP(11), P_EP(12), P_EP(13), P_EP(14), P_EP(15), };
Fortunately in this case, the USB_EndPoint1 has been already enabled for EP1 IN. Then, no specific modification for EP1 OUT is required.
As we've observed on the sniffer, the enumeration seems to finish successfully. To confirm it, run these tests.
Confirmation of Enumeration a) Windows Device Manager In the USB development, you should often summon up Device Manager. This is a tip to ease the procedure.
1) Copy these two lines to a blank text file, and rename the file to, for example, DevManager.bat (any .bat will do)
set devmgr_show_nonpresent_devices=1 start devmgmt.msc
2) Double click DevManager.bat, and Device Manager comes up.
(Note) When you select 'Show hidden devices' from 'View' menu, you can see all device instances, even if it isn't currently connected. This function is convenient to clean up the device instances for lost devices.
- Under 'Human Interface Device', can you see the device instance for your board? - Does the property window of the instance (double click the instance) show any trouble?
b) USBView (or UVCView) USBView and UVCView are MS tool to show how Windows recognize the USB devices.
The source code of the USBView is included in the WinDDK. C:\WINDDK\3790.1830\src\wdm\usb\usbview\
MS distribute free WinDDK on this page. "Download the Windows Server 2003 SP1 DDK [236 MB ISO file]" www.microsoft.com/.../default.mspx
SiLabs distributes USBView.exe on their KnowledgeBase page. See the right pane of this article for usbview.zip. "VID/PID/Descriptor Recovery" " " www.microsoft.com/.../WDKpkg.mspx
- Can you see the descriptors of your device properly on the USBView screen?
c) USB compliance test The USB compliance test (USBCV) is a good tool to debug the enumeration code, even if you don't apply the USB logo program of USB.org.
USBCV R1.3 www.usb.org/.../
When you run this tool, attach PS/2 mouse to your PC. USB mouse (and keyboard) doesn't work while this tool is running. Laptop PC is a good platform to run this app, because it usually has PS/2 pointing device. Also, a high-speed hub has to be connected between your PC and the device.
- Run Ch9 and HID test on USBCV
Tsuneo I've downloaded the win DDK and also the VC++ 9.0. I tried to compile with VC++ and had no luck. The compiler says it can't compile "enum.c".
Also I've checked the site you posted " is broken. Could you put the software somewhere I can download or tell me in which compiler the software will compile with?
As to the third thest, I don't have a high speed hub so that won't work.
I've done a couple tests maybe this will give you a hint of what might be: On
void USB_EndPoint1 (DWORD event) { switch (event) { case USB_EVT_IN: GetInReport(); IO1SET = 1 << 20; USB_WriteEP(0x81, InReport, sizeof(InReport)); break; case USB_EVT_OUT: IO1SET = 1 << 19; USB_ReadEP(0x01, OutReport); SetOutReport(); break; } })
I wrote code so that it sets leds 19 and 20 if events IN and OUT occur. The led 20 which represents event in is always set but the led 19 event OUT never gets set. So I went back and tried to use only InReport size of 64 and left the OutReport the ogirinal. The keil original code sends value on InReport[1] =0x01 so on my win application I've put a flag to show that it receives. The flag was never set.
I forgot to mention but on item a) of your post I did all the things that you've mentioned and Windows sees my device as a HID and it doesn't say its not working properly or anything of that sort.
I'm not sure but could there be a problem on my win application? It works fine with the keil example, even if I only change the InReport to 64 bytes the outreport still works fine. Im thinking no because its the device that tells the host how its configuration but Im not 100% sure.
Doug.
I've downloaded usbview. Doug
View all questions in Keil forum