Problema con el Descriptor HID

[nico-cettra]

Hola, les comento, he tratado de hacer un descriptor HID para un joystick usb. Este solo quiero que contenga dos axis, X e Y. Pero hay cosas del descriptor que no logro descifrar respecto al formato; este es el que he realizado sin éxito:

DESCRIPTOR:

Código: [Seleccionar]


#IFNDEF __USB_DESCRIPTORS__
#DEFINE __USB_DESCRIPTORS__
#include <usb.h>

const char USB_CLASS_SPECIFIC_DESC[] =
   {
    0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
    0x09, 0x04,                    // USAGE (Joystick)
    0xa1, 0x01,                    // COLLECTION (Application)
    0x05, 0x01,                    //   USAGE_PAGE (Generic Desktop)
    0x09, 0x01,                    //   USAGE (Pointer)
    0xa1, 0x00,                    //   COLLECTION (Physical)
    0x09, 0x30,                    //     USAGE (X)
    0x09, 0x31,                    //     USAGE (Y)
    0x15, 0x00,                    //     LOGICAL_MINIMUM (0)
    0x26, 0xff, 0x03,              //     LOGICAL_MAXIMUM (255)
    0x75, 0x08,                    //     REPORT_SIZE (8)
    0x95, 0x02,                    //     REPORT_COUNT (2)
    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
    0xc0,                          //     END_COLLECTION
   };

   const int16 USB_CLASS_SPECIFIC_DESC_LOOKUP[USB_NUM_CONFIGURATIONS][1] = {0};
   const int16 USB_CLASS_SPECIFIC_DESC_LOOKUP_SIZE[USB_NUM_CONFIGURATIONS][2] = {sizeof(USB_CLASS_SPECIFIC_DESC)};

   #DEFINE USB_TOTAL_CONFIG_LEN      41 //config+interface+class+endpoint

   const char USB_CONFIG_DESC[] = {
   //IN ORDER TO COMPLY WITH WINDOWS HOSTS, THE ORDER OF THIS ARRAY MUST BE:
      //    config(s)
      //    interface(s)
      //    class(es)
      //    endpoint(s)

   //config_descriptor for config index 1
         USB_DESC_CONFIG_LEN, //length of descriptor size          ==0
         USB_DESC_CONFIG_TYPE, //constant CONFIGURATION (CONFIGURATION 0x02)     ==1
         USB_TOTAL_CONFIG_LEN,0, //size of all data returned for this config      ==2,3
         1, //number of interfaces this device supports       ==4
         0x01, //identifier for this configuration.  (IF we had more than one configurations)      ==5
         0x00, //index of string descriptor for this configuration      ==6
         0xC0, //bit 6=1 if self powered, bit 5=1 if supports remote wakeup (we don't), bits 0-4 unused and bit7=1         ==7
         0x32, //maximum bus power required (maximum milliamperes/2)  (0x32 = 100mA)   //8

   //interface descriptor 1 (MOUSE)
         USB_DESC_INTERFACE_LEN, //length of descriptor      =9
         USB_DESC_INTERFACE_TYPE, //constant INTERFACE (INTERFACE 0x04)       =10
         0x00, //number defining this interface (IF we had more than one interface)    ==11
         0x00, //alternate setting     ==12
         2, //number of endpoints for this interface  //13
         0x03, //class code, 03 = HID     ==14
         0x00, //subclass code //boot     ==15
         0x00, //protocol code       ==16
         0x00, //index of string descriptor for interface      ==17

   //class descriptor 1  (HID)
         USB_DESC_CLASS_LEN, //length of descriptor    ==18
         USB_DESC_CLASS_TYPE, //dscriptor type (0x21 == HID)      ==19
         0x00,0x01, //hid class release number (1.0) (try 1.10)      ==20,21
         0x00, //localized country code (0 = none)       ==22
         0x01, //number of hid class descrptors that follow (1)      ==23
         0x22, //report descriptor type (0x22 == HID)                ==24
         USB_CLASS_SPECIFIC_DESC_LOOKUP_SIZE[0][0], 0x00, //length of report descriptor            ==25,26

   //endpoint descriptor 1 IN
         USB_DESC_ENDPOINT_LEN, //length of descriptor                   ==27
         USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (ENDPOINT 0x05)          ==28
         0x81, //endpoint number and direction (0x81 = EP1 IN)       ==29
         USB_ENDPOINT_TYPE_INTERRUPT, //transfer type supported (0x03 is interrupt)         ==30
         USB_EP1_TX_SIZE,0x00, //maximum packet size supported                  ==31,32
         10  //polling interval, in ms.  (cant be smaller than 10 for slow speed devices)     ==33

   //endpoint descriptor 1 OUT
         USB_DESC_ENDPOINT_LEN, //length of descriptor                   ==34
         USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (ENDPOINT 0x05)          ==35
         0x01, //endpoint number and direction (0x01 = EP1 OUT)       ==36
         USB_ENDPOINT_TYPE_INTERRUPT, //transfer type supported (0x03 is interrupt)         ==37
         USB_EP1_RX_SIZE,0x00, //maximum packet size supported                  ==38,39
         10  //polling interval, in ms.  (cant be smaller than 10 for slow speed devices)     ==40
   };

   #define USB_NUM_HID_INTERFACES   1
   #define USB_MAX_NUM_INTERFACES   1

   const char USB_NUM_INTERFACES[USB_NUM_CONFIGURATIONS]={1};
   const int16 USB_CLASS_DESCRIPTORS[USB_NUM_CONFIGURATIONS][1][1]= {18};

   #if (sizeof(USB_CONFIG_DESC) != USB_TOTAL_CONFIG_LEN)
      #error USB_TOTAL_CONFIG_LEN not defined correctly
   #endif


//////////////////////////////////////////////////////////////////
///
///   start device descriptors
///
//////////////////////////////////////////////////////////////////

   const char USB_DEVICE_DESC[] =
   {
      //starts of with device configuration. only one possible
         USB_DESC_DEVICE_LEN, //the length of this report   ==1
         0x01, //the constant DEVICE (DEVICE 0x01)  ==2
         0x10,0x01, //usb version in bcd (pic167xx is 1.1) ==3,4
         0x00, //class code ==5
         0x00, //subclass code ==6
         0x00, //protocol code ==7
         USB_MAX_EP0_PACKET_LENGTH, //max packet size for endpoint 0. (SLOW SPEED SPECIFIES 8) ==8
         0x61,0x04, //vendor id (0x04D8 is Microchip, or is it 0x0461 ??)
         0x57,0x00, //product id   ==11,12  //don't use ffff says usb-by-example guy.  oops
         0x00,0x01, //device release number  ==13,14
         0x01, //index of string description of manufacturer. therefore we point to string_1 array (see below)  ==15
         0x02, //index of string descriptor of the product  ==16
         0x00, //index of string descriptor of serial number  ==17
         USB_NUM_CONFIGURATIONS  //number of possible configurations  ==18
   };

   #if (sizeof(USB_DEVICE_DESC) != USB_DESC_DEVICE_LEN)
      #error USB_DESC_DEVICE_LEN not defined correctly
   #endif

const char USB_STRING_DESC_OFFSET[]={0,4,12};
#define USB_STRING_DESC_COUNT sizeof(USB_STRING_DESC_OFFSET)

char const USB_STRING_DESC[]={
   //string 0
         4, //length of string index
         USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
         0x09,0x04,   //Microsoft Defined for US-English
   //string 1
         8, //length of string index
         USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
         'U',0,
         'S',0,
         'B',0,
   //string 2
         34, //length of string index
         USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
         'J',0,
         'o',0,
         'y',0,
         's',0,
         't',0,
         'i',0,
         'c',0,
         'k',0,
         ' ',0,
         'Z',0,
         'u',0,
         'm',0,
         'o',0,
         'r',0,
         'r',0,
         'a',0,
         ' ',0,
};


MAIN:

Código: [Seleccionar]


#include <18F4550.h>
#device ADC = 8
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN
#use delay(clock=48000000)

#DEFINE USB_HID_DEVICE  TRUE
#define USB_EP1_TX_ENABLE  USB_ENABLE_INTERRUPT   //turn on EP1 for IN bulk/interrupt transfers
#define USB_EP1_TX_SIZE 4 //la longitud de la transmision es de 4 bytes

#include <pic18_usb.h>
#include <JOY_CETTRA_HID.h>               //USB Configuration and Device descriptors for this UBS device
#include <usb.c>                                 //handles usb setup tokens and get descriptor reports

int8 TxUSB[4]; //PAQUETE DE DATOS QUE SE ENVIARA
int8 enumerated; // es para indicar si el dispositivo esta conectado y configurado a la pc
int1 TX=0; //indica si los datos se estan transmitiendo a la pc
int1 Leer=0; //indica si se puede leer las entradas

int8 Eje1=0;
int8 Eje2=0;

void usb_debug_task(void) //creo que lo puedo borrar
{
   enumerated=usb_enumerated();
}

//LA INTERRUPCION ESTA SE USA PARA ACIVAR LA LECTURA DE LOS PINES DEL PIC
#int_RTCC
void RTCC_isr()
   {
   leer=1;
   }

void main()
{
   port_b_pullups(false);
   setup_adc_ports( AN0_TO_AN10 );
   setup_adc(ADC_CLOCK_INTERNAL );
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_128|RTCC_8_BIT);
   delay_ms(10);
   
   usb_init_cs();

   disable_interrupts(INT_TIMER1);
   disable_interrupts(int_tbe);
   enable_interrupts(INT_TIMER0);
   enable_interrupts(global);


while (TRUE)
   {
      usb_task();
      usb_debug_task();
      if(Leer)
      {
               Leer=0; //flanco que indica si leo las entradas del pic
               delay_us(5);
                                   
               //LEO ANALOGICAS
               set_adc_channel(0);  //PREPARO PARA EJE 1
               Eje1=read_adc();
               txusb[0] = Eje1;
               delay_us(10);
               set_adc_channel(1);  //PREPARO PARA EJE 2
               Eje2=read_adc();
               txusb[1] = Eje2;
               delay_us(10);
               
               Tx=1; //Todo listo para transmitir...
               
      }
      if(usb_enumerated())
      {
               if (TX) //TX es un flanco que indica que esta transmitiendo
               {
                     usb_put_packet(  1,  txusb, 4, USB_DTS_TOGGLE); //ENVIO TODO EL PAQUETE ANTERIOR
                     TX=0; // BAJO LA BANDERA DE TRANSMISION.
                     delay_ms(10);
               }
         }
     } //FIN WHILE TRUE
} //FIN MAIN



Mi objetivo inicialmente es comprender con más claridad la estructura del descriptor, por eso quise arrancar con la simple lectura de los axis, pero se complico.

Posteriormente como objetivo final quiero generar varios joystick con axis x e y con un mismo HID.

Estuve indagando bastante en Internet acerca de esto, y he encontrado varias referencias al tema, pero en ninguna me satisface, no son muy detallistas.

Desde ya gracias, ya sea por la ayuda o por la molestia de leer esto

Saludos !

[willynovi]

Hola Amigo,

hace tiempo hice un joystick con un 18f2550, que es similar al que usas tu.
Yo empecé con la documentación que ofrece microchip, el framework que lo puedes bajar del siguiente enlace

https://www.microchip.com/mplab/microchip-libraries-for-applications

Ahí vas a encontrar un ejemplo de joystick muy bien explicado.
Mas allá que no uses XC8, el descriptor te va a servir.

Aqui te paso un descriptor que hice para un joystick de 6 ejes y 36 botones

Código: [Seleccionar]

/*********************************************************************
 *
 *                Microchip USB C18 Firmware Version 1.2
 *
 *********************************************************************
 * FileName:        usbdsc.c
 * Dependencies:    See INCLUDES section below
 * Processor:       PIC18
 * Compiler:        C18 3.11+
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * The software supplied herewith by Microchip Technology Incorporated
 * (the “Company”) for its PICmicro® Microcontroller is intended and
 * supplied to you, the Company’s customer, for use solely and
 * exclusively on Microchip PICmicro Microcontroller products. The
 * software is owned by the Company and/or its supplier, and is
 * protected under applicable copyright laws. All rights are reserved.
 * Any use in violation of the foregoing restrictions may subject the
 * user to criminal sanctions under applicable laws, as well as to
 * civil liability for the breach of the terms and conditions of this
 * license.
 *
 * THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES,
 * WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
 * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,
 * IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
 * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
 *
 ********************************************************************/

/*********************************************************************
 * -usbdsc.c-
 * This file contains the USB descriptor information. It is used
 * in conjunction with the usbdsc.h file. When a descriptor is added
 * or removed from the main configuration descriptor, i.e. CFG01,
 * the user must also change the descriptor structure defined in
 * the usbdsc.h file. The structure is used to calculate the
 * descriptor size, i.e. sizeof(CFG01).
 *
 * A typical configuration descriptor consists of:
 * At least one configuration descriptor (USB_CFG_DSC)
 * One or more interface descriptors (USB_INTF_DSC)
 * One or more endpoint descriptors (USB_EP_DSC)
 *
 * Naming Convention:
 * To resolve ambiguity, the naming convention are as followed:
 * - USB_CFG_DSC type should be named cdxx, where xx is the
 *   configuration number. This number should match the actual
 *   index value of this configuration.
 * - USB_INTF_DSC type should be named i<yy>a<zz>, where yy is the
 *   interface number and zz is the alternate interface number.
 * - USB_EP_DSC type should be named ep<##><d>_i<yy>a<zz>, where
 *   ## is the endpoint number and d is the direction of transfer.
 *   The interface name should also be listed as a suffix to identify
 *   which interface does the endpoint belong to.
 *
 * Example:
 * If a device has one configuration, two interfaces; interface 0
 * has two endpoints (in and out), and interface 1 has one endpoint(in).
 * Then the CFG01 structure in the usbdsc.h should be:
 *
 * #define CFG01 rom struct                            \
 * {   USB_CFG_DSC             cd01;                   \
 *     USB_INTF_DSC            i00a00;                 \
 *     USB_EP_DSC              ep01o_i00a00;           \
 *     USB_EP_DSC              ep01i_i00a00;           \
 *     USB_INTF_DSC            i01a00;                 \
 *     USB_EP_DSC              ep02i_i01a00;           \
 * } cfg01
 *
 * Note the hierarchy of the descriptors above, it follows the USB
 * specification requirement. All endpoints belonging to an interface
 * should be listed immediately after that interface.
 *
 * -------------------------------------------------------------------
 * Filling in the descriptor values in the usbdsc.c file:
 * -------------------------------------------------------------------
 * Most items should be self-explanatory, however, a few will be
 * explained for clarification.
 *
 * [Configuration Descriptor(USB_CFG_DSC)]
 * The configuration attribute must always have the _DEFAULT
 * definition at the minimum. Additional options can be ORed
 * to the _DEFAULT attribute. Available options are _SELF and _RWU.
 * These definitions are defined in the usbdefs_std_dsc.h file. The
 * _SELF tells the USB host that this device is self-powered. The
 * _RWU tells the USB host that this device supports Remote Wakeup.
 *
 * [Endpoint Descriptor(USB_EP_DSC)]
 * Assume the following example:
 * sizeof(USB_EP_DSC),DSC_EP,_EP01_OUT,_BULK,64,0x00
 *
 * The first two parameters are self-explanatory. They specify the
 * length of this endpoint descriptor (7) and the descriptor type.
 * The next parameter identifies the endpoint, the definitions are
 * defined in usbdefs_std_dsc.h and has the following naming
 * convention:
 * _EP<##>_<dir>
 * where ## is the endpoint number and dir is the direction of
 * transfer. The dir has the value of either 'OUT' or 'IN'.
 * The next parameter identifies the type of the endpoint. Available
 * options are _BULK, _INT, _ISO, and _CTRL. The _CTRL is not
 * typically used because the default control transfer endpoint is
 * not defined in the USB descriptors. When _ISO option is used,
 * addition options can be ORed to _ISO. Example:
 * _ISO|_AD|_FE
 * This describes the endpoint as an isochronous pipe with adaptive
 * and feedback attributes. See usbdefs_std_dsc.h and the USB
 * specification for details. The next parameter defines the size of
 * the endpoint. The last parameter in the polling interval.
 *
 * -------------------------------------------------------------------
 * Adding a USB String
 * -------------------------------------------------------------------
 * A string descriptor array should have the following format:
 *
 * rom struct{byte bLength;byte bDscType;word string[size];}sdxxx={
 * sizeof(sdxxx),DSC_STR,<text>};
 *
 * The above structure provides a means for the C compiler to
 * calculate the length of string descriptor sdxxx, where xxx is the
 * index number. The first two bytes of the descriptor are descriptor
 * length and type. The rest <text> are string texts which must be
 * in the unicode format. The unicode format is achieved by declaring
 * each character as a word type. The whole text string is declared
 * as a word array with the number of characters equals to <size>.
 * <size> has to be manually counted and entered into the array
 * declaration. Let's study this through an example:
 * if the string is "USB" , then the string descriptor should be:
 * (Using index 02)
 * rom struct{byte bLength;byte bDscType;word string[3];}sd002={
 * sizeof(sd002),DSC_STR,'U','S','B'};
 *
 * A USB project may have multiple strings and the firmware supports
 * the management of multiple strings through a look-up table.
 * The look-up table is defined as:
 * rom const unsigned char *rom USB_SD_Ptr[]={&sd000,&sd001,&sd002};
 *
 * The above declaration has 3 strings, sd000, sd001, and sd002.
 * Strings can be removed or added. sd000 is a specialized string
 * descriptor. It defines the language code, usually this is
 * US English (0x0409). The index of the string must match the index
 * position of the USB_SD_Ptr array, &sd000 must be in position
 * USB_SD_Ptr[0], &sd001 must be in position USB_SD_Ptr[1] and so on.
 * The look-up table USB_SD_Ptr is used by the get string handler
 * function in usb9.c.
 *
 * -------------------------------------------------------------------
 *
 * The look-up table scheme also applies to the configuration
 * descriptor. A USB device may have multiple configuration
 * descriptors, i.e. CFG01, CFG02, etc. To add a configuration
 * descriptor, user must implement a structure similar to CFG01.
 * The next step is to add the configuration descriptor name, i.e.
 * cfg01, cfg02,.., to the look-up table USB_CD_Ptr. USB_CD_Ptr[0]
 * is a dummy place holder since configuration 0 is the un-configured
 * state according to the definition in the USB specification.
 *
 ********************************************************************/

/*********************************************************************
 * Descriptor specific type definitions are defined in:
 * system\usb\usbdefs\usbdefs_std_dsc.h
 *
 * Configuration information is defined in:
 * autofiles\usbcfg.h
 ********************************************************************/

/** I N C L U D E S *************************************************/
#include "system\typedefs.h"
#include "system\usb\usb.h"

/** C O N S T A N T S ************************************************/
#pragma romdata

/* Device Descriptor */
rom USB_DEV_DSC device_dsc=
{
    sizeof(USB_DEV_DSC),    // Size of this descriptor in bytes
    DSC_DEV,                // DEVICE descriptor type
    0x0200,                 // USB Spec Release Number in BCD format
    0x00,                   // Class Code
    0x00,                   // Subclass code
    0x00,                   // Protocol code
    EP0_BUFF_SIZE,          // Max packet size for EP0, see usbcfg.h
    0x04D8,                 // Vendor ID
    0x0002,                 // Product ID: Joystick
    0x0001,                 // Device release number in BCD format
    0x01,                   // Manufacturer string index
    0x02,                   // Product string index
    0x00,                   // Device serial number string index
    0x01                    // Number of possible configurations
};

/* Configuration 1 Descriptor */
CFG01={
    /* Configuration Descriptor */
    sizeof(USB_CFG_DSC),    // Size of this descriptor in bytes
    DSC_CFG,                // CONFIGURATION descriptor type
    sizeof(cfg01),          // Total length of data for this cfg
    1,                      // Number of interfaces in this cfg
    1,                      // Index value of this configuration
    0,                      // Configuration string index
    _DEFAULT|_RWU|_SELF,    // Attributes, see usbdefs_std_dsc.h
    50,                     // Max power consumption (2X mA)

    /* Interface Descriptor */
    sizeof(USB_INTF_DSC),   // Size of this descriptor in bytes
    DSC_INTF,               // INTERFACE descriptor type
    0,                      // Interface Number
    0,                      // Alternate Setting Number
    1,                      // Number of endpoints in this intf
    HID_INTF,               // Class code
    0, // Subclass code (none)
    0, // Protocol code (none)
    0,                      // Interface string index

    /* HID Class-Specific Descriptor */
    sizeof(USB_HID_DSC),    // Size of this descriptor in bytes
    DSC_HID,                // HID descriptor type
    0x0101,                 // HID Spec Release Number in BCD format
    0x00,                   // Country Code (0x00 for Not supported)
    HID_NUM_OF_DSC,         // Number of class descriptors, see usbcfg.h
    DSC_RPT,                // Report descriptor type
    sizeof(hid_rpt01),      // Size of the report descriptor

    /* Endpoint Descriptor */
    sizeof(USB_EP_DSC),DSC_EP,_EP01_IN,_INT,HID_INT_IN_EP_SIZE,0x0A
};

rom struct{byte bLength;byte bDscType;word string[1];}sd000={
sizeof(sd000),DSC_STR,0x0409};

rom struct{byte bLength;byte bDscType;word string[22];}sd001={
sizeof(sd001),DSC_STR,
'W','i','l','l','y','N','o','v','i',' ',
'R','a','c','i','n','g',' ','T','e','a','m','.'};

rom struct{byte bLength;byte bDscType;word string[12];}sd002={
sizeof(sd002),DSC_STR,
'J','o','y','s','t','i','c','k',' ','0','.','1'};

rom struct{byte report[HID_RPT01_SIZE];}hid_rpt01={
0x05, 0x01, // Usage Page (Generic Desktop)
0x09, 0x04, // Usage (Joy)
0xA1, 0x00, // Collection (Physical)
0x09, 0x30, //   Usage (X)
0x09, 0x31, //   Usage (Y)
0x15, 0x00, //   Log Min (0)
0x26, 0xFF, 0x03, //   Log Max (1023)
0x75, 0x10, //   Report Size (16)
0x95, 0x02, //   Report Count (2)
0x81, 0x02, //   Input (Data, Variable, Absolute)
0x09, 0x32, //   Usage (Z)
0x15, 0x00, //   Log Min (0)
0x26, 0xFF, 0x03, //   Log Max (1023)
0x75, 0x10, //   Report Size (16)
0x95, 0x01, //   Report Count (1)
0x81, 0x02, //   Input (Data, Variable, Absolute)
0x09, 0x33, //   Usage (Rx)
0x15, 0x00, //   Log Min (0)
0x26, 0xFF, 0x03, //   Log Max (1023)
0x75, 0x10, //   Report Size (16)
0x95, 0x01, //   Report Count (1)
0x81, 0x02, //   Input (Data, Variable, Absolute)
0x09, 0x34, //   Usage (Ry)
0x15, 0x00, //   Log Min (0)
0x26, 0xFF, 0x03, //   Log Max (1023)
0x75, 0x10, //   Report Size (16)
0x95, 0x01, //   Report Count (1)
0x81, 0x02, //   Input (Data, Variable, Absolute)
0x09, 0x35, //   Usage (Rz)
0x15, 0x00, //   Log Min (0)
0x26, 0xFF, 0x03, //   Log Max (1023)
0x75, 0x10, //   Report Size (16)
0x95, 0x01, //   Report Count (1)
0x81, 0x02, //   Input (Data, Variable, Absolute)
0x09, 0x39, //    Usage (Hat Sw)
0x15, 0x00, //   Log Min (0)
0x25, 0x07, //   Log Max (7)
0x35, 0x00, //    Phy Min (0)
0x46, 0x3B, 0x01, //    Phy Max (315)
0x65, 0x12, //    Unit (SI Rot : Ang Pos)
0x75, 0x08, //   Report Size (8)
0x95, 0x01, //   Report Count (1)
0x81, 0x02, //   Input (Data, Variable, Absolute)
// 0x75, 0x04,
// 0x95, 0x01,
// 0x81, 0x03,
0x05, 0x09, //    Usage Page (Button)
0x19, 0x01, //    Usage Min (1)
0x29, 0x20, //    Usage Max (32)
0x15, 0x00, //   Log Min (0)
0x25, 0x01, //   Log Max (1)
0x75, 0x01, //   Report Size (1)
0x95, 0x20, //   Report Count (32)
0x81, 0x02, //   Input (Data, Variable, Absolute)
// 0x75, 0x04,
// 0x95, 0x01,
// 0x81, 0x03,
0xC0}; // End Collection

rom const unsigned char *rom USB_CD_Ptr[]=
{
    (rom const unsigned char *rom)&cfg01,
    (rom const unsigned char *rom)&cfg01
};
rom const unsigned char *rom USB_SD_Ptr[]=
{
    (rom const unsigned char *rom)&sd000,
    (rom const unsigned char *rom)&sd001,
    (rom const unsigned char *rom)&sd002
};

rom pFunc ClassReqHandler[1]=
{
    &USBCheckHIDRequest
};

#pragma code

/** EOF usbdsc.c ****************************************************/

Y por último, te recomiendo que uses las herramientas de Microchip, quizas resulten mas dificiles al principio, pero con el tiempo vas a ganar en menos dolores de cabeza.

[nico-cettra]

Bien, ya estoy bajando el XC8, habrá que aprender.

Gracias por tu ayuda y tiempo