Newsgroup: it.hobby.elettronica.digitale
Titolo: chi si intende di HID report descriptor?

non ci sto capendo molto,
sto cercando di modificare una applicazione USB HID su NXP LPC11U14,qualcuno 
ha esperienza a riguardo?
 
 


Se vuoi provare a esporre i tuoi dubbi, forse, posso provare ad aiutarti
ciao
Angelo
 
 

 ha scritto nel messaggio 
news:4ffed116$0$1384$4faf...@reader1.news.tin.it...

grazie Angelo
ho questo microcontrollore,LPC11U14 dell'NXP che vorrei usare per trasferire 
dei dati acquisiti tra lui e un PC.
Per vedere qualcosa uso usbhidio_vc6  preso da 
http://www.lvr.com/hidpage.htm/
 con l'idea di usarlo come base per farci 
quello che mi serve
 
I dati riguardano una lettura di velocità,e non sarebbe male se fossero 
trasferiti man mano che vengono letti
Oppure potrebbero essere raccolti in RAM (non ne ho tantissima,ma 1KB su 4KB 
credo di poterlo riservare) e trasferiti tutti assieme
 
Mi sono riletto vari documenti riassuntivi su USB tipo 
www.beyondlogic.org/usbnutshell/usb1.shtml
 
e altri su HID report descriptor,
ma sto andando a tentoni e temo che anche le mie domande saranno 
inappropriate .
 
In particolare mi chiedo:
1)l'applicazione per il micro prevedeva risposte 0x01 o 0x00 a seconda che 
fosse schiacciato o meno un pulsante
se io invece per fare una prova volessi trasferire all'host un valore da 0 a 
255 (lettura ADC) devo o no toccare l'HID report descriptor in modo che 
durante l'enumerazione l'host apprenda il formato di questo valore?
 
2)L'applicazione per micro passa in continuazione e automaticamente(non 
chiamata da codice ma da eveno)dalla routine relativa all' Endpoint1.Chi è 
che potrebbe scegliere di passare per quella dell'Endpoint2?L'Host 
suppongo,è vero?
 
originariamente era così
/* HID Report Descriptor */
const uint8_t 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),
    HID_ReportSize(1),
    HID_Input(HID_Data | HID_Variable | HID_Absolute),
    HID_ReportCount(1),
    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,
};
 
ma non andrebbe modificato in qualcosa di simile a questo?
 
/* HID Report Descriptor */
const uint8_t HID_ReportDescriptor[] = {
  HID_UsagePageVendor(0x00),
  HID_Usage(0x01),
  HID_Collection(HID_Application),
    HID_UsagePage(HID_USAGE_GENERIC_X),//<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    HID_UsageMin(1),
    HID_UsageMax(3),
    HID_LogicalMin(0),
    HID_LogicalMax(255),//cambia valore max<<<<<<<<<<<<<<<<<<<<
    HID_ReportCount(1),//  1 byte <<<<<<<<<<<<
    HID_ReportSize(8),// 8 bit <<<<<<<<<<<<<<
    HID_Input(HID_Data | HID_Variable | HID_Absolute),
    HID_ReportCount(1),
    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,
};
 
 
se vuoi contattami in privato ,skype ecc ecc
 
grazie in ogni caso
 
 
 
 

 grazie in ogni caso
 
Ho esperienza (decennale) di firmware Usb per i Pic, per cui penso di 
poterti dare una mano, ma non sono in grado di entrare facilmente nello 
specifico del tuo micro.
vediamo cosa posso fare e se ti posso essere d'aiuto, piu' che contento
ciao
Angelo
 

 Angelo
 
grazie per i chiarimenti e soprattutto per la disponibilità.
 
Ho provato a copiare pari pari da un esempio Microchip un reprt descriptor 
più ridotto:
 
/* HID Report Descriptor */
const uint8_t HID_ReportDescriptor[] = {
  HID_UsagePageVendor(0x00),
  HID_Usage(0x01),
 
  HID_UsagePage(HID_USAGE_PAGE_GENERIC),
  HID_Usage(HID_USAGE_GENERIC_GAMEPAD),
 
  HID_Collection(HID_Application),
     HID_Usage(HID_USAGE_GENERIC_POINTER),
     HID_Collection(HID_Physical),
    HID_Usage(HID_USAGE_GENERIC_X),
    HID_Usage(HID_USAGE_GENERIC_Y),
 
    HID_LogicalMin(0),
    HID_LogicalMax(255),
    HID_ReportCount(2),
    HID_ReportSize(8),
    HID_Input(HID_Data | HID_Variable | HID_Absolute),
 
      HID_EndCollection,
  HID_EndCollection
};
 
ma non riesco ad avere il device detected
 
la domanda delle 8 di mattina oggi è quindi:
Supponiamo di avere un report descriptor che in sè è sensato.
Se non è seguito da un report coerente immagino che avrò un errore,ma 
possibile che abbia "Device not detected" senza neanche mostrarmi il Device 
Descriptor?
 
grazie ancora
 
 
 


 
correzione usando USBView  questo mi dà indicazione di errore ma un pò di 
cose me le vede:
 
Device Descriptor:
bcdUSB:             0x0200
bDeviceClass:         0x00
bDeviceSubClass:      0x00
bDeviceProtocol:      0x00
bMaxPacketSize0:      0x40 (64)
idVendor:           0x1FC9
idProduct:          0x0003
bcdDevice:          0x0100
iManufacturer:        0x01
iProduct:             0x02
iSerialNumber:        0x03
bNumConfigurations:   0x01
 
ConnectionStatus: DeviceConnected
Current Config Value: 0x00
Device Bus Speed:      Low
Device Address:       0x00
Open Pipes:              0
 
qual'è l'errore? grazie ancora
 
 
 

 qual'è l'errore? grazie ancora
 
Non sono in grado di aiutarti leggendo quanto sopra.
Puoi postare report e device descriptor?
Attento che nel device descriptor devi inserire (variare) la lunghezza 
del descrittore e il numero di endpoint da usare.
Dai uno sguardo qui sotto, e' il config descriptor di un joystick 
analogico e sono sicuro che funziona.
 
****
// Configuration 1 Descriptor
ROM BYTE configDescriptor1[] =
{
               // Config Descriptor
   0x09,                         // 1 Byte Size of this descriptor in bytes
   USB_DESCRIPTOR_CONFIGURATION, // 1 Byte CONFIGURATION descriptor type 
(02)
               //FIXME
               //Valore da cambiare ***
   DESC_CONFIG_WORD(CONFIG_DESCRIPTOR_SIZE),// 2 Byte Total length of 
data for this cfg (configDescriptor1)
               //FIXME
               //Valore da cambiare ***
   USB_MAX_NUM_INT,              // 1 Byte Number of interfaces in this cfg
   1,                            // 1 Byte Index value of this configuration
   4,                            // 1 Byte Configuration string index
   _DEFAULT | _SELF,             // 1 Byte Attributes, see usb_device.h
   50,                           // 1 Byte Max power consumption (2X mA)
                                 // 9      9
               // Interface 1 Descriptor
   0x09,                         // 1 Byte Size of this descriptor in bytes
   USB_DESCRIPTOR_INTERFACE,     // 1 Byte INTERFACE descriptor type
   HID01_INTF_ID,                // 1 Byte Interface Number (0 Based)
   0,                            // 1 Byte Alternate Setting Number
               //FIXME
               //Valore da cambiare ***
   HID01_NUM_ENDPOINT,           // 1 Byte Number of endpoints presenti 
in questa interfaccia
   HID_INTF,                     // 1 Byte Class code
   0,                            // 1 Byte Subclass code
   0,                            // 1 Byte Protocol code
   5,                            // 1 Byte Interface string index
                                 // 9      18
   // HID Class-Specific Interface 1 Descriptor
   0x09,                         // 1 Byte Size of this descriptor in 
bytes RRoj hack
   DSC_HID,                      // 1 Byte HID descriptor type 
(Descriptor HID = 0x21)
   DESC_CONFIG_WORD(0x0111),     // 2 Byte HID Spec Release Number in 
BCD format (1.11)
   0x00,                         // 1 Byte Country Code (0x00 for Not 
supported)
               //FIXME
               //Valore da cambiare ***
   HID01_NUM_OF_DSC,             // 1 Byte Number of class Hid 
descriptors, see usbcfg.h
   DSC_RPT,                      // 1 Byte Descriptor type (Descriptor 
Report = 0x22)
               //FIXME
               //Valore da cambiare ***
   DESC_CONFIG_WORD(HID01_RPT_SIZE),// 2 Byte Size of the report 
descriptor Hid 1
                                 // 9      27
               // Endpoint Interface 1 Descriptor
   0x07,                         // 1 Byte Size of this descriptor in bytes
   USB_DESCRIPTOR_ENDPOINT,      // 1 Byte Endpoint Descriptor
   //FIXME
   //Valore da cambiare ***
   HID01_EP | _EP_IN,            // 1 Byte EndpointAddress
   _INTERRUPT,                   // 1 Byte Attributes
               //FIXME
               //Valore da cambiare ***
   DESC_CONFIG_WORD(HID01_INT_IN_EP_SIZE),// 2 Byte Maximum endpoint 
packet size
   0x14,                         // 1 Byte Interval
                                 // 7      34
               // Interface 2 Descriptor
   0x09,                         // 1 Byte Size of this descriptor in bytes
   USB_DESCRIPTOR_INTERFACE,     // 1 Byte INTERFACE descriptor type
   HID02_INTF_ID,                // 1 Byte Interface Number (0 Based)
   0,                            // 1 Byte Alternate Setting Number
               //FIXME
               //Valore da cambiare ***
   HID02_NUM_ENDPOINT,           // 1 Byte Number of endpoints presenti 
in questa interfaccia
   HID_INTF,                     // 1 Byte Class code
   0,                            // 1 Byte Subclass code
   0,                            // 1 Byte Protocol code
   6,                            // 1 Byte Interface string index
                                 // 9      43
   // HID Class-Specific Interface 2 Descriptor
   0x09,//sizeof(USB_HID_DSC)+3, // 1 Byte Size of this descriptor in 
bytes RRoj hack
   DSC_HID,                      // 1 Byte HID descriptor type 
(Descriptor HID = 0x21)
   DESC_CONFIG_WORD(0x0111),     // 2 Byte HID Spec Release Number in 
BCD format (1.11)
   0x00,                         // 1 Byte Country Code (0x00 for Not 
supported)
               //FIXME
               //Valore da cambiare ***
   HID02_NUM_OF_DSC,             // 1 Byte Number of class Hid 
descriptors, see usbcfg.h
   DSC_RPT,                      // 1 Byte Descriptor type (Descriptor 
Report = 0x22)
               //FIXME
               //Valore da cambiare ***
   DESC_CONFIG_WORD(HID02_RPT_SIZE),// 2 Byte Size of the report 
descriptor Hid 2
                                 // 9      52
               // Endpoint Interface 2 Descriptor
   0x07,//sizeof(USB_EP_DSC)     // 1 Byte Size of this descriptor in bytes
   USB_DESCRIPTOR_ENDPOINT,      // 1 Byte Endpoint Descriptor
   //FIXME
   //Valore da cambiare ***
   HID02_EP | _EP_IN,            // 1 Byte EndpointAddress
   _INTERRUPT,                   // 1 Byte Attributes
   //FIXME
   //Valore da cambiare ***
   DESC_CONFIG_WORD(HID02_INT_IN_EP_SIZE),// 2 Byte Maximum endpoint 
packet size
   0x14,                         // 1 Byte Interval
   // 7      59
   // 59 Byte (0x3b) Report ConfigDescriptor1 Lenght
};
***
 
Stai usando l'interfacciamento tramite interrupt oppure come gestisci lo 
scambio dati?
Non ricordo dove, ma in un descrittore devi specificare se vai con 
interrupt oppure no; se ti serve, pero', posso essere piu' preciso al 
riguardo, mi basterebbe dare un'occhiata piu' approfondita ai descrittori.
ciao
Angelo
 
 
 
 
 


se riuscissimo a stabilire un contatto audio ,tipo su Skype,probabilmente 
conversando capiresti la mia incompetenza e magari scopriresti che ho 
saltato delle cose grandi così
 
 
//*************************************************************
 
/* HID Report Descriptor */
const uint8_t HID_ReportDescriptor[] = {
  HID_UsagePageVendor(0x00),
  HID_Usage(0x01),
 
  HID_UsagePage(HID_USAGE_PAGE_GENERIC),
  HID_Usage(HID_USAGE_GENERIC_GAMEPAD),
 
  HID_Collection(HID_Application),
     HID_Usage(HID_USAGE_GENERIC_POINTER),
     HID_Collection(HID_Physical),
    HID_Usage(HID_USAGE_GENERIC_X),
    //HID_Usage(HID_USAGE_GENERIC_Y),
 
    HID_LogicalMin(0),
    HID_LogicalMax(255),
    HID_ReportCount(1),
    HID_ReportSize(8),
    HID_Input(HID_Data | HID_Variable | HID_Absolute),
 
      HID_EndCollection,
  HID_EndCollection,
 
 
};
 
//*************************************************************
const uint16_t HID_ReportDescSize = sizeof(HID_ReportDescriptor);
 
//*************************************************************
 
/* USB Standard Device Descriptor */
const uint8_t USB_DeviceDescriptor[] = {
  USB_DEVICE_DESC_SIZE,              /* bLength */
  USB_DEVICE_DESCRIPTOR_TYPE,        /* bDescriptorType */
#if LPM_SUPPORT
  WBVAL(0x0201), /* 2.01 */          /* bcdUSB */
#else
  WBVAL(0x0200), /* 2.00 */          /* bcdUSB */
#endif
  0x00,                              /* bDeviceClass */
  0x00,                              /* bDeviceSubClass */
  0x00,                              /* bDeviceProtocol */
  USB_MAX_PACKET0,                   /* bMaxPacketSize0 */
  WBVAL(0x1FC9),                     /* idVendor */
//  WBVAL(0x000B),                     /* idProduct */
  WBVAL(0x0003),                     /* idProduct */
  WBVAL(0x0100), /* 1.00 */          /* bcdDevice */
  0x01,                              /* iManufacturer */
  0x02,                              /* iProduct */
  0x03,                              /* iSerialNumber */
  0x01                               /* bNumConfigurations: one possible 
configuration*/
};
 
/* USB Configuration Descriptor */
/*   All Descriptors (Configuration, Interface, Endpoint, Class, Vendor) */
const uint8_t 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 */
#if REMOTE_WAKEUP_ENABLE    /* bmAttributes */
  USB_CONFIG_BUS_POWERED|USB_CONFIG_REMOTE_WAKEUP,
#else
  USB_CONFIG_BUS_POWERED,
#endif
  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 */
  0x00,                              /* 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(HID_EP_IN), /* bEndpointAddress */
  USB_ENDPOINT_TYPE_INTERRUPT,       /* bmAttributes */
  WBVAL(0x0004),                     /* wMaxPacketSize */
  0x20,          /* 32ms */          /* bInterval */
/* Endpoint, HID Interrupt Out */
  USB_ENDPOINT_DESC_SIZE,            /* bLength */
  USB_ENDPOINT_DESCRIPTOR_TYPE,      /* bDescriptorType */
  USB_ENDPOINT_OUT(HID_EP_OUT),      /* bEndpointAddress */
  USB_ENDPOINT_TYPE_INTERRUPT,       /* bmAttributes */
  WBVAL(0x0004),                     /* wMaxPacketSize */
  0x20,          /* 32ms */          /* bInterval */
/* Terminator */
  0                                  /* bLength */
};
 
 
//************************************************************* 
 
 

 };
 
Spero di averti dato qualcosa su cui lavorare per risolvere
ciao
Angelo
 
 
 

 Il 13/07/2012 12:02, blisca ha scritto:
 
Angelo ti ringrazio del non poco tempo dedicatomi,sono informazioni utili 
che si integrano con quanto sto leggendo,ma non mi aiutano a risolvere nulla 
purtroppo e temo che mi toccherà mollare il colpo dopo vari giorni 
improduttivi,e quindi non pagati.
 
Provo a riassumere in  altre domande più specifica:
vevo un codice per micro HID,questo rispondeva con un bit a seconda che un 
pulsante fosse premuto o meno
ho modificato il Report Descriptor (spero correttamente) per avere invece un 
dato a 8 bit.
Oltre al report descriptor cosa va modificato?
 
HID_REPORT_DESC_SIZE viene adattato da
#define HID_REPORT_DESC_SIZE (sizeof(HID_ReportDescriptor))
per cui penso sia corretto
 
l'In report era
 
void GetInReport (void)
{
    // Check if PBINT is pressed
     if ( LPC_GPIO->PIN[0] & (1<<1) )
    {     InReport = 0x01;
    }
    else
    {
      InReport = 0x00;
    }
}
 
però InReport è deinita come unsigned char,per cui anche prima si aspettava 
un byte 
 
 

ok,togliendo 2 righe di troppo nel Report descriptor sono ruscito a non 
avere pi� errore,e in qualche modo vedo(con USBtrace) che il mio micro manda 
dei BULK OR INTERRUPT TRANSFER in continuazione
 
con USBtrace per� non riesco a capire se sto trasferendo il dato che 
voglio(lettura ADC)
 
 
per� col tool HID Test mi fallisce HID_Get_Configuration e 
HID_Get_PhysicalDescriptor...boh 
 
 


ok,i conti cominciano a tornare 
 
 

 ha scritto nel messaggio 
news:jtqcfo$q8e$1...@speranza.aioe.org...

era solo un errore nell HID_Report_Descriptor
 
commentando le prime 2 righe � tutto ok
 
/* HID Report Descriptor */
 
const uint8_t HID_ReportDescriptor[] = {
  //HID_UsagePageVendor(0x00),
 // HID_Usage(0x01),
 
  HID_UsagePage(HID_USAGE_PAGE_GENERIC),
  HID_Usage(HID_USAGE_GENERIC_GAMEPAD),
 
  HID_Collection(HID_Application),
    HID_Usage(HID_USAGE_GENERIC_POINTER),
    HID_Collection(HID_Physical),
    HID_Usage(HID_USAGE_GENERIC_X),
    HID_Usage(HID_USAGE_GENERIC_Y),
 
    HID_LogicalMin(0),
    HID_LogicalMax(255),
    HID_ReportCount(2),
    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_LogicalMin(0),
    HID_LogicalMax(1),
    HID_ReportCount(8),
    HID_ReportSize(1),
    HID_Output(HID_Data | HID_Variable | HID_Absolute),
    HID_EndCollection,
  HID_EndCollection,
 
};
 
grazie ancora,Deh 
 
 

con piccola soddisfazione,appoggiandomi a ci� che ricordavo di Visual C++ e 
modificando un esempio rovato in rete, sono riuscito a rappresentare 
graficamente  la tensione al cursore di un potenziometro a,cquisita da NXP 
LPC11U14 del quale ho modificato il FW tratto da un esempio nel quale il 
reeport fornito rappresentava solo lo stato di un pulsante
 
tel chi
http://img254.imageshack.us/img254/8960/schermataprova.jpg
 
 
grazie ancora e ciao 
 
 

 con piccola soddisfazione,appoggiandomi a ciò che ricordavo di Visual C++ e

Complimenti per non aver rinunciato dopo le prime avversita' e per il 
risultato.
ciao
Angelo