18f2550 - crear 5 ejes analogicos da mal funcionamiento

[kyle_katarn]

Hola a todo el mundo.
Despues de leer bastantes hilo por este y otros foros no he conseguido resolver mi problema, de hecho si no hubiera leido no habria llegado hasta este punto.

Estoy haciendo un dispositivo de juegos con un 18f2550 por USB HID y estoy usando CCS, el objetivo es que el dispositivo tenga 5 ejes.

Empece con el ejemplo que trae el compilador de un raton USB. Le modifique el descriptor y lo converti en dispoitivo de juegos, me costo, era una tonteria pero soy navato co los pic's y cada paso es despues de mucho leer y mucho probar. Tambien me apoye en el programa HID Descriptor Tool.

Otro logro, ayudado por el USBView fue, convertir el ejemplo del raton, de HID version 1.0 y USB 1.1 a HID 1.11 y USB 2.0, revisando los datos que me daba el programa del descriptor de un G27 que tengo enchufado.

Despues vino el modificar el ejemplo convertirlo en 5 ejes analogicos de 10 bits. Lo delos 10 bits lo resolvi rapido, pero lo de modificar el descriptor que lo veia facil, me costo bastantes dias de mas ller y mas probar, hasta que encontre un ejemplo de willynovi de un descriptor de un dispositivo de 6 ejes y vi el cielo abierto.

Pero algo debo tener mal en algun sitio, por que añadir mas de cuatro ejes supone que el dispositivo es detectado y enumerado correctamente, pero no recibe datos de los potenciometros de los ejes.
Los cinco ejes se quedan fijos en el centro de su recorrido y ya esta.
El concepto lo tengo bien, o eso creo, por que con 4 ejes el dispositivo funciona perfectamente, pero es añadir el 5 eje al descriptor y aumentar el array de recogida de datos en 2 bytes mas, y dejar de funcionar.

Creo que el problema puede estar en el tamaño del ENDPOINT que en el ejemplo del raton que use estaba a 8, supongo que es un tamaño de 8 bytes, segun lo que he leido de teoria del USB, pero aunque le ponga 10, 12 o 64, el tamaño maximo de los ENDPOINT, el comportamiento es el mismo.

Ya he agotado toda mi inventiva y rebuscando por los foros no veo donde tengo el problema, asi que acudo a alguien para que me revise y me diga donde esta el error, por que como os digo yo no lo veo.
A continuacion os pongo los codigos fuente de los archivos que estoy usando:

Código: [Seleccionar]

#define __USB_PIC_PERIF__ 1

  #include <18F2550.h>
  #DEVICE ADC=10
  //~~~ 20MHZ OSCILLATOR CONFIGS ~~~//
  //// FULL SPEED
  #fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN
  #use delay(clock=48000000)


#DEFINE USB_HID_DEVICE  TRUE  //Tells the CCS PIC USB firmware
                              //to include HID handling code.

//turn on EP1 for IN interrupt transfers.  (IN = PIC -> PC)
#define USB_EP1_TX_ENABLE  USB_ENABLE_INTERRUPT
#define USB_EP1_TX_SIZE 16     //max packet size of this endpoint


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


// Esta función configura el registro ADCON2.
void config_adcon2() {
   #asm
   movlw 0b10111110 ; justificacion_derecha,20Tad,Fosc/64
   iorwf 0xFC0,1    ; direccion de ADCON2.
   #endasm
}


void usb_debug_task(void) {
   static int8 last_connected;
   static int8 last_enumerated;
   int8 new_connected;
   int8 new_enumerated;

   new_connected=usb_attached();
   new_enumerated=usb_enumerated();


   last_connected=new_connected;
   last_enumerated=new_enumerated;
}

void main(void) {

   long dato;
   int8 out_data[10];


         set_tris_a (0b0101111);
         set_tris_b (0b00000000);
         set_tris_c (0b00000000);

SETUP_ADC(ADC_CLOCK_DIV_64 || VSS_VREF);
SETUP_ADC_PORTS(AN0_TO_AN4);
   usb_init_cs();
   config_adcon2(); // Configuramos el conversor analógico digital.

   while (TRUE)
   {
      usb_task();
      usb_debug_task();
      if (usb_enumerated())
      {
        SET_ADC_CHANNEL(PIN_A0);
        dato= read_adc();
        out_data[0]=(int)dato;
        out_data[1]=dato>>8;
        SET_ADC_CHANNEL(PIN_A1);
        dato= read_adc();
        out_data[2]=(int)dato;
        out_data[3]=dato>>8;
        SET_ADC_CHANNEL(PIN_A2);
        dato= read_adc();
        out_data[4]=(int)dato;
        out_data[5]=dato>>8;
        SET_ADC_CHANNEL(PIN_A3);
        dato= read_adc();
        out_data[6]=(int)dato;
        out_data[7]=dato>>8;
        SET_ADC_CHANNEL(PIN_A5);
        dato= read_adc();
        out_data[8]=(int)dato;
        out_data[9]=dato>>8;
        usb_put_packet(1,out_data,10,USB_DTS_TOGGLE);
     }
   }
}

A continuacion el codigo del descriptor

Código: [Seleccionar]

#IFNDEF __USB_DESCRIPTORS__
#DEFINE __USB_DESCRIPTORS__

///////// config options, although it's best to leave alone for this demo /////
#define  USB_CONFIG_PID       0x0022
#define  USB_CONFIG_VID       0x0461
#define  USB_CONFIG_BUS_POWER 100   //100mA  (range is 0..500)
#define  USB_CONFIG_VERSION   0x0200      //01.00  //range is 00.00 to 99.99
//////// end config ///////////////////////////////////////////////////////////



#DEFINE USB_HID_DEVICE  TRUE  //Tells the CCS PIC USB firmware
                              //to include HID handling code.

//turn on EP1 for IN interrupt transfers.  (IN = PIC -> PC)
#define USB_EP1_TX_ENABLE  USB_ENABLE_INTERRUPT

#define USB_EP1_TX_SIZE 16     //max packet size of this endpoint

#include <usb.h>


   const char USB_CLASS_SPECIFIC_DESC[] =
   {
   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)
   0xc0
   };

   //if a class has an extra descriptor not part of the config descriptor,
   // this lookup table defines where to look for it in the const
   // USB_CLASS_SPECIFIC_DESC[] array.
   //first element is the config number (if your device has more than one config)
   //second element is which interface number
   //set element to 0xFFFF if this config/interface combo doesn't exist
   const int16 USB_CLASS_SPECIFIC_DESC_LOOKUP[USB_NUM_CONFIGURATIONS][1] =
   {
   //config 1
      //interface 0
         0
   };

   //if a class has an extra descriptor not part of the config descriptor,
   // this lookup table defines the size of that descriptor.
   //first element is the config number (if your device has more than one config)
   //second element is which interface number
   //set element to 0xFFFF if this config/interface combo doesn't exist
   const int16 USB_CLASS_SPECIFIC_DESC_LOOKUP_SIZE[USB_NUM_CONFIGURATIONS][1] =
   {
   //config 1
      //interface 0
      sizeof(USB_CLASS_SPECIFIC_DESC)
   };



//////////////////////////////////////////////////////////////////
///
///   start config descriptor
///   right now we only support one configuration descriptor.
///   the config, interface, class, and endpoint goes into this array.
///
//////////////////////////////////////////////////////////////////

   #DEFINE USB_TOTAL_CONFIG_LEN      34 //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          ==1
         USB_DESC_CONFIG_TYPE, //constant CONFIGURATION (CONFIGURATION 0x02)     ==2
         USB_TOTAL_CONFIG_LEN,0, //size of all data returned for this config      ==3,4
         1, //number of interfaces this device supports       ==5
         0x01, //identifier for this configuration.  (IF we had more than one configurations)      ==6
         0x00, //index of string descriptor for this configuration      ==7
         0xC0, //bit 6=1 if self powered, bit 5=1 if supports remote wakeup (we don't), bits 0-4 unused and bit7=1         ==8
         0x32, //bit 6=1 if self powered, bit 5=1 if supports remote wakeup (we don't), bits 0-4 unused and bit7=1         ==8

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

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

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


   //****** BEGIN CONFIG DESCRIPTOR LOOKUP TABLES ********
   //since we can't make pointers to constants in certain pic16s, this is an offset table to find
   //  a specific descriptor in the above table.

   //NOTE: DO TO A LIMITATION OF THE CCS CODE, ALL HID INTERFACES MUST START AT 0 AND BE SEQUENTIAL
   //      FOR EXAMPLE, IF YOU HAVE 2 HID INTERFACES THEY MUST BE INTERFACE 0 AND INTERFACE 1
   #define USB_NUM_HID_INTERFACES   1

   //the maximum number of interfaces seen on any config
   //for example, if config 1 has 1 interface and config 2 has 2 interfaces you must define this as 2
   #define USB_MAX_NUM_INTERFACES   1

   //define how many interfaces there are per config.  [0] is the first config, etc.
   const char USB_NUM_INTERFACES[USB_NUM_CONFIGURATIONS]={1};

   //define where to find class descriptors
   //first dimension is the config number
   //second dimension specifies which interface
   //last dimension specifies which class in this interface to get, but most will only have 1 class per interface
   //if a class descriptor is not valid, set the value to 0xFFFF
   const int16 USB_CLASS_DESCRIPTORS[USB_NUM_CONFIGURATIONS][USB_NUM_HID_INTERFACES][1]=
   {
   //config 1
      //interface 0
         //class 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
         0x00,0x02, //usb version in bcd (pic167xx is 2.0) ==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
         USB_CONFIG_VID & 0xFF, ((USB_CONFIG_VID >> 8) & 0xFF), //vendor id       ==9, 10
         USB_CONFIG_PID & 0xFF, ((USB_CONFIG_PID >> 8) & 0xFF), //product id, don't use 0xffff       ==11, 12
         USB_CONFIG_VERSION & 0xFF, ((USB_CONFIG_VERSION >> 8) & 0xFF), //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


//////////////////////////////////////////////////////////////////
///
///   start string descriptors
///   String 0 is a special language string, and must be defined.  People in U.S.A. can leave this alone.
///
//////////////////////////////////////////////////////////////////

//the offset of the starting location of each string.  offset[0] is the start of string 0, offset[1] is the start of string 1, etc.
const char USB_STRING_DESC_OFFSET[]={0,4,12};

//number of strings you have, including string 0.
#define USB_STRING_DESC_COUNT sizeof(USB_STRING_DESC_OFFSET)

// Here is where the "CCS" Manufacturer string and "CCS USB Mouse" are stored.
// Strings are saved as unicode.
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)
         'C',0,
         'C',0,
         'S',0,
   //string 2
         28, //length of string index
         USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
         'C',0,
         'C',0,
         'S',0,
         ' ',0,
         'U',0,
         'S',0,
         'B',0,
         ' ',0,
         'M',0,
         'o',0,
         'u',0,
         's',0,
         'e',0
};
Como ven todabia conservo el nombre del dispositivo del ejemplo del raton del CCS.
El proyecto lo compilo y lo quemo en el pic que lo tengo en una placa de prototipado, no uso emuladores.

Por si les sirve de algo la informacion, estoy usando Win7 64b y el CCS version 4.104


Muchas gracias por leerse el ladrillaco.

[Suky]

Una mirada rápida no me permitió detectar el error  Pero no se podría juntar todo en lugar de definir todo por separado, o sea:

Usage (X)
Usage (Y)
Usage (Z)
Usage (Rx)
Usage (Ry)
Log Min (0)
Log Max (1023)
Report Size (16)
Report Count (5)
Input (Data, Variable, Absolute)

?

Colocando USB_EP1_TX_SIZE en 10 es suficiente. Luego en SET_ADC_CHANNEL(...) va AN0, AN1, etc... También después de elegir el canal hay que esperar un par de us.

[kyle_katarn]

Hola Suky, gracias por tu ayuda.

Pues intente hacer el resumen que me propones, de hecho los ejes X e Y ya vienen resumidos, pero no me funciono, puede que me equivocara en algo, pero lo probare otra vez.
El EP1 esta a 16 por que se ha quedado asi de las ultimas pruebas, imaginaba que con 10 bastaria por lo que he leido.
Sobre el retardo despues de elegir canal, lo he visto en otros ejemplo, pero a mi me estaba funcionando sin poner ninguno, pero puede que el seleccionar el 5 canal, el no poner retardo le haga desincronizarse y por eso me esta fallando.

Probare tus sugerencias y comentare el resultado.
Gracias de nuevo.

[kyle_katarn]

Bueno, pues tengo una mala y una buena.
La mala es que si se resumen los ejes no los reconoce, solo aparecen los ejes X e Y.
La buena es que he conseguido que funcione, pero para buena verdad no veo ninguna diferencia entre el codigo de mi primer post y como esta ahora mismo funcionando.

Despues de conseguirlo he retocado un pelin el codigo y lo he dejado mas limpio usando un array de long en vez de int8, asi que no hay que desplazar los MSB y LSB para colocarlos en el array de forma correcta.
Solo hay que tener en cuenta el numero de bytes que ocupa el array y decirselo al usb_put_packet.
Pongo el codigo para referencias de otros y para ver si encontrais alguna diferencia, por que yo no la veo...

Código: [Seleccionar]

#define __USB_PIC_PERIF__ 1

  #include <18F2550.h>
  #DEVICE ADC=10
  //~~~ 20MHZ OSCILLATOR CONFIGS ~~~//
  //// FULL SPEED
  #fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN
  #use delay(clock=48000000)

#DEFINE USB_HID_DEVICE  TRUE  //Tells the CCS PIC USB firmware
                              //to include HID handling code.

//turn on EP1 for IN interrupt transfers.  (IN = PIC -> PC)
#define USB_EP1_TX_ENABLE  USB_ENABLE_INTERRUPT
#define USB_EP1_TX_SIZE 10     //max packet size of this endpoint

#define USB_EP2_TX_ENABLE  USB_ENABLE_INTERRUPT
#define USB_EP2_RX_ENABLE  USB_ENABLE_INTERRUPT
#define USB_EP2_TX_SIZE 8     //max packet size of this endpoint
#define USB_EP2_RX_SIZE 8     //max packet size of this endpoint

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

#use fast_io(a)
#use fast_io(b)
#use fast_io(c)


// Esta función configura el registro ADCON2.
void config_adcon2() {
   #asm
   movlw 0b10111110 ; justificacion_derecha,20Tad,Fosc/64
   iorwf 0xFC0,1    ; direccion de ADCON2.
   #endasm
}


void usb_debug_task(void) {
   static int8 last_connected;
   static int8 last_enumerated;
   int8 new_connected;
   int8 new_enumerated;

   new_connected=usb_attached();
   new_enumerated=usb_enumerated();


   last_connected=new_connected;
   last_enumerated=new_enumerated;
}

void main(void) {

   long out_data[5];

    set_tris_a (0b0101111);
    set_tris_b (0b0000000);
    set_tris_c (0b00000000);
         
   SETUP_ADC(ADC_CLOCK_DIV_64 || VSS_VREF);
   SETUP_ADC_PORTS(AN0_TO_AN4);
   usb_init_cs();
   config_adcon2(); // Configuramos el conversor analógico digital.


   while (TRUE)
   {
      usb_task();
      usb_debug_task();
      if (usb_enumerated())
      {
        SET_ADC_CHANNEL(PIN_A0);
        out_data[0]=read_adc();
        SET_ADC_CHANNEL(PIN_A1);
        out_data[1]=read_adc();
        SET_ADC_CHANNEL(PIN_A2);
        out_data[2]=read_adc();
        SET_ADC_CHANNEL(PIN_A3);
        out_data[3]=read_adc();
        SET_ADC_CHANNEL(PIN_A4);
        out_data[4]=read_adc();
        dato=out_data[4];
        usb_put_packet(1,out_data,10,USB_DTS_TOGGLE);
      }
   }
}

El EPX2 es para poner un PWM, que me esta costando enterarme de como funciona, estoy leyendo hilos del foro me sinceramente me entero de poco, me ha parecido mas sencillo el ADC, aunque parece que la opinion general es la contraria....
Las funciones fast_io() he leido que son para agilizar la entrada salida de los puertos?¿?¿?¿
No se exactamente que hacen, pero no molestan jejeje

Código: [Seleccionar]

#IFNDEF __USB_DESCRIPTORS__
#DEFINE __USB_DESCRIPTORS__

///////// config options, although it's best to leave alone for this demo /////
#define  USB_CONFIG_PID       0x0022
#define  USB_CONFIG_VID       0x0461
#define  USB_CONFIG_BUS_POWER 100   //100mA  (range is 0..500)
#define  USB_CONFIG_VERSION   0x0200      //01.00  //range is 00.00 to 99.99
//////// end config ///////////////////////////////////////////////////////////



#DEFINE USB_HID_DEVICE  TRUE  //Tells the CCS PIC USB firmware
                              //to include HID handling code.

//turn on EP1 for IN interrupt transfers.  (IN = PIC -> PC)
#define USB_EP1_TX_ENABLE  USB_ENABLE_INTERRUPT

#define USB_EP1_TX_SIZE 16     //max packet size of this endpoint

#include <usb.h>

   //////////////////////////////////////////////////////////////////
   ///
   ///  HID Report.  Tells HID driver how to handle and deal with
   ///  received data.  HID Reports can be extremely complex,
   ///  see HID specifcation for help on writing your own.
   ///
   ///  This examples configures HID driver to take received data
   ///  as mouse x, y and button data.
   ///
   //////////////////////////////////////////////////////////////////

   const char USB_CLASS_SPECIFIC_DESC[] =
   {
   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)
   0xc0
   };

   //if a class has an extra descriptor not part of the config descriptor,
   // this lookup table defines where to look for it in the const
   // USB_CLASS_SPECIFIC_DESC[] array.
   //first element is the config number (if your device has more than one config)
   //second element is which interface number
   //set element to 0xFFFF if this config/interface combo doesn't exist
   const int16 USB_CLASS_SPECIFIC_DESC_LOOKUP[USB_NUM_CONFIGURATIONS][1] =
   {
   //config 1
      //interface 0
         0
   };

   //if a class has an extra descriptor not part of the config descriptor,
   // this lookup table defines the size of that descriptor.
   //first element is the config number (if your device has more than one config)
   //second element is which interface number
   //set element to 0xFFFF if this config/interface combo doesn't exist
   const int16 USB_CLASS_SPECIFIC_DESC_LOOKUP_SIZE[USB_NUM_CONFIGURATIONS][1] =
   {
   //config 1
      //interface 0
      sizeof(USB_CLASS_SPECIFIC_DESC)
   };



//////////////////////////////////////////////////////////////////
///
///   start config descriptor
///   right now we only support one configuration descriptor.
///   the config, interface, class, and endpoint goes into this array.
///
//////////////////////////////////////////////////////////////////

   #DEFINE USB_TOTAL_CONFIG_LEN      34 //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          ==1
         USB_DESC_CONFIG_TYPE, //constant CONFIGURATION (CONFIGURATION 0x02)     ==2
         USB_TOTAL_CONFIG_LEN,0, //size of all data returned for this config      ==3,4
         1, //number of interfaces this device supports       ==5
         0x01, //identifier for this configuration.  (IF we had more than one configurations)      ==6
         0x00, //index of string descriptor for this configuration      ==7
         0xC0, //bit 6=1 if self powered, bit 5=1 if supports remote wakeup (we don't), bits 0-4 unused and bit7=1         ==8
         0x32, //bit 6=1 if self powered, bit 5=1 if supports remote wakeup (we don't), bits 0-4 unused and bit7=1         ==8

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

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

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


   //****** BEGIN CONFIG DESCRIPTOR LOOKUP TABLES ********
   //since we can't make pointers to constants in certain pic16s, this is an offset table to find
   //  a specific descriptor in the above table.

   //NOTE: DO TO A LIMITATION OF THE CCS CODE, ALL HID INTERFACES MUST START AT 0 AND BE SEQUENTIAL
   //      FOR EXAMPLE, IF YOU HAVE 2 HID INTERFACES THEY MUST BE INTERFACE 0 AND INTERFACE 1
   #define USB_NUM_HID_INTERFACES   1

   //the maximum number of interfaces seen on any config
   //for example, if config 1 has 1 interface and config 2 has 2 interfaces you must define this as 2
   #define USB_MAX_NUM_INTERFACES   1

   //define how many interfaces there are per config.  [0] is the first config, etc.
   const char USB_NUM_INTERFACES[USB_NUM_CONFIGURATIONS]={1};

   //define where to find class descriptors
   //first dimension is the config number
   //second dimension specifies which interface
   //last dimension specifies which class in this interface to get, but most will only have 1 class per interface
   //if a class descriptor is not valid, set the value to 0xFFFF
   const int16 USB_CLASS_DESCRIPTORS[USB_NUM_CONFIGURATIONS][USB_NUM_HID_INTERFACES][1]=
   {
   //config 1
      //interface 0
         //class 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
         0x00,0x02, //usb version in bcd (pic167xx is 2.0) ==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
         USB_CONFIG_VID & 0xFF, ((USB_CONFIG_VID >> 8) & 0xFF), //vendor id       ==9, 10
         USB_CONFIG_PID & 0xFF, ((USB_CONFIG_PID >> 8) & 0xFF), //product id, don't use 0xffff       ==11, 12
         USB_CONFIG_VERSION & 0xFF, ((USB_CONFIG_VERSION >> 8) & 0xFF), //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


//////////////////////////////////////////////////////////////////
///
///   start string descriptors
///   String 0 is a special language string, and must be defined.  People in U.S.A. can leave this alone.
///
//////////////////////////////////////////////////////////////////

//the offset of the starting location of each string.  offset[0] is the start of string 0, offset[1] is the start of string 1, etc.
const char USB_STRING_DESC_OFFSET[]={0,4,12};

//number of strings you have, including string 0.
#define USB_STRING_DESC_COUNT sizeof(USB_STRING_DESC_OFFSET)

// Here is where the "CCS" Manufacturer string and "CCS USB Mouse" are stored.
// Strings are saved as unicode.
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)
         'C',0,
         'C',0,
         'S',0,
   //string 2
         28, //length of string index
         USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
         'C',0,
         'C',0,
         'S',0,
         ' ',0,
         'U',0,
         'S',0,
         'B',0,
         ' ',0,
         'M',0,
         'o',0,
         'u',0,
         's',0,
         'e',0
};

[Suky]

Perdón por insistir, pero SET_ADC_CHANNEL(...) según la ayuda de CCS no debe recibir PIN_Ax, sino ANx... Son definiciones totalmente distintas, puede que funcione porque se trunque su valor y lo tome correcto, pero solo por suerte 

[kyle_katarn]

Gracias, no habia entendido que te referias a que cambiara eso, lo probare asi, pero las definiciones de los pines en la libreria 18f2550.h son
#define PIN_A0  31744
#define PIN_A1  31745
#define PIN_A2  31746
#define PIN_A3  31747
#define PIN_A4  31748
#define PIN_A5  31749
#define PIN_A6  31750

#define PIN_B0  31752
#define PIN_B1  31753
#define PIN_B2  31754
#define PIN_B3  31755
#define PIN_B4  31756
#define PIN_B5  31757
#define PIN_B6  31758
#define PIN_B7  31759

#define PIN_C0  31760
#define PIN_C1  31761
#define PIN_C2  31762
#define PIN_C4  31764
#define PIN_C5  31765
#define PIN_C6  31766
#define PIN_C7  31767

#define PIN_E3  31779

Por eso lo estoy usando asi.
De hecho, mientras escribo esto, lo he probado como tu me aconsejas y no recibe señal por AN0, que es el que he modificado para probarlo.

Ademas en 18f2550.h esta definida la siguiente linea
#define AN0          0x0E   // A0
dentro del apartado de los ADC, para la funcion SETUP_ADC_PORTS, por lo que al hacer SET_ADC_CHANNEL(AN0), el eje x, que es el que usa el conversor del pin AN0, no se queda en el centro del rango, que es lo que suele hacer cuando no esta cogiendo señal o esta mal configurado, si no que se queda en una posicion determinada del recorrido bastante cercana a uno de los margenes del recorrido, por que imagino que esta fijando el valor de entrada del pin AN0 a 0x0E.

El tema del PWM he encontrado un hilo donde Nocturno pone un ejemplo sencillo y ya por  lo menos puedo activarlo y usarlo en el CCP1, aunque no se bien como se configura, seguire haciendo pruebas, a ver si me entero