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.