PIC Comunicação USB HID com Pic18F2550

Henrique Morais · 5 de fevereiro de 2020

Boa Noite Pessoal, estou com um problema com a comunicação USB com pic18f2550.

Construí um dispositivo usb(joystick), porém no proteus ele funciona normal, no MCU ele reconhece, mas os botões e eixos nao funcionam.

codigo:

unsigned char readbuff[64] absolute 0x500;
unsigned char writebuff[64] absolute 0x540;

char btn = 0x00;
short  eixoX, eixoY, eixoZ = 0;


void interrupt()
{
 USB_Interrupt_Proc();
}


void readJoy(){
     ADC_Init();
     //------------ Bloco que converte o eixo Y --------------------
     eixoY = ADC_Read(1)/4;
     eixoY = eixoY - 127;
     if(eixoY >= -5 && eixoY <= 5)PORTA.RA4 = 1;
     else PORTA.RA4 = 0;
     
     //----------- Conversão do eixo X -------------
     eixoX = ADC_Read(0)/4;
     eixoX = eixoX - 127;
     if(eixoX >= -5 && eixoX <= 5)PORTA.RA3 = 1;
     else PORTA.RA3 = 0;
     
     //----------- Conversão do eixo Z digital-----------
     eixoZ = 0;
     if(!PORTA.RA2) eixoZ = 127;
     else {eixoZ = -127;}
     
     //------------ Acionamento dos botões -----------------
     if(!PORTB.RB0) btn.RB0 = 1;
     else btn.RB0 = 0;
     
     if(!PORTB.RB1) btn.RB1 = 1;
     else btn.RB1 = 0;
     
     if(!PORTB.RB2) btn.RB2 = 1;
     else btn.RB2 = 0;
     
     if(!PORTB.RB3) btn.RB3 = 1;
     else btn.RB3 = 0;
     
     if(!PORTB.RB4) btn.RB4 = 1;
     else btn.RB4 = 0;
     
     if(!PORTB.RB5) btn.RB5 = 1;
     else btn.RB5 = 0;
     
     if(!PORTB.RB6) btn.RB6 = 1;
     else btn.RB6 = 0;
     
     if(!PORTB.RB7) btn.RB7 = 1;
     else btn.RB7 = 0;
     // -------------- envia os dados para o buffer do usb ------------
     writebuff[0] = btn;
     writebuff[1] = eixoX;
     writebuff[2] = ~eixoY;
     writebuff[3] = eixoZ;
     
     
     while(!HID_Write(writebuff,9));
}

void main() {
        TRISB = 255;//define portb como entrada
        TRISA = 255;
        TRISC = 255;
        ADCON1 = 0x0D;//altera as entradas A0 e A1 analogicas
        PORTA = 0;
        PORTB = 0;
        PORTC = 0;
        CMCON = 0x07;
        
        HID_Enable(&readbuff, &writebuff);
        
        while(1){
                 readJoy();
                 Delay_ms(100);
        }

}

HID Descritor:

const unsigned int USB_VENDOR_ID = 0x0123;
const unsigned int USB_PRODUCT_ID = 0x0001;
const char USB_SELF_POWER = 0x80;            // Self powered 0xC0,  0x80 bus powered
const char USB_MAX_POWER = 50;               // Bus power required in units of 2 mA
const char HID_INPUT_REPORT_BYTES = 64;
const char HID_OUTPUT_REPORT_BYTES = 64;
const char USB_TRANSFER_TYPE = 0x03;         //0x03 Interrupt
const char EP_IN_INTERVAL = 1;
const char EP_OUT_INTERVAL = 1;

const char USB_INTERRUPT = 1;
const char USB_HID_EP = 1;
const char USB_HID_RPT_SIZE = 44;

/* Device Descriptor */
const struct {
    char bLength;               // bLength         - Descriptor size in bytes (12h)
    char bDescriptorType;       // bDescriptorType - The constant DEVICE (01h)
    unsigned int bcdUSB;         // bcdU SB          - USB specification release number (BCD)
    char bDeviceClass;          // bDeviceClass    - Class Code
    char bDeviceSubClass;       // bDeviceSubClass - Subclass code
    char bDeviceProtocol;       // bDeviceProtocol - Protocol code
    char bMaxPacketSize0;       // bMaxPacketSize0 - Maximum packet size for endpoint 0
    unsigned int idVendor;      // idVendor        - Vendor ID
    unsigned int idProduct;     // idProduct       - Product ID
    unsigned int bcdDevice;     // bcdDevice       - Device release number (BCD)
    char iManufacturer;         // iManufacturer   - Index of string descriptor for the manufacturer
    char iProduct;              // iProduct        - Index of string descriptor for the product.
    char iSerialNumber;         // iSerialNumber   - Index of string descriptor for the serial number.
    char bNumConfigurations;    // bNumConfigurations - Number of possible configurations
} device_dsc = {
      0x12,                   // bLength
      0x01,                   // bDescriptorType
      0x0200,                 // bcdUSB
      0x00,                   // bDeviceClass
      0x00,                   // bDeviceSubClass
      0x00,                   // bDeviceProtocol
      8,                      // bMaxPacketSize0
      USB_VENDOR_ID,          // idVendor
      USB_PRODUCT_ID,         // idProduct
      0x0001,                 // bcdDevice
      0x01,                   // iManufacturer
      0x02,                   // iProduct
      0x00,                   // iSerialNumber
      0x01                    // bNumConfigurations
  };

/* Configuration 1 Descriptor */
const char configDescriptor1[]= {
    // Configuration Descriptor
    0x09,                   // bLength             - Descriptor size in bytes
    0x02,                   // bDescriptorType     - The constant CONFIGURATION (02h)
    0x29,0x00,              // wTotalLength        - The number of bytes in the configuration descriptor and all of its subordinate descriptors
    1,                      // bNumInterfaces      - Number of interfaces in the configuration
    1,                      // bConfigurationValue - Identifier for Set Configuration and Get Configuration requests
    0,                      // iConfiguration      - Index of string descriptor for the configuration
    USB_SELF_POWER,         // bmAttributes        - Self/bus power and remote wakeup settings
    USB_MAX_POWER,          // bMaxPower           - Bus power required in units of 2 mA

    // Interface Descriptor
    0x09,                   // bLength - Descriptor size in bytes (09h)
    0x04,                   // bDescriptorType - The constant Interface (04h)
    0,                      // bInterfaceNumber - Number identifying this interface
    0,                      // bAlternateSetting - A number that identifies a descriptor with alternate settings for this bInterfaceNumber.
    2,                      // bNumEndpoint - Number of endpoints supported not counting endpoint zero
    0x03,                   // bInterfaceClass - Class code
    0,                      // bInterfaceSubclass - Subclass code
    0,                      // bInterfaceProtocol - Protocol code
    0,                      // iInterface - Interface string index

    // HID Class-Specific Descriptor
    0x09,                   // bLength - Descriptor size in bytes.
    0x21,                   // bDescriptorType - This descriptor's type: 21h to indicate the HID class.
    0x01,0x01,              // bcdHID - HID specification release number (BCD).
    0x00,                   // bCountryCode - Numeric expression identifying the country for localized hardware (BCD) or 00h.
    1,                      // bNumDescriptors - Number of subordinate report and physical descriptors.
    0x22,                   // bDescriptorType - The type of a class-specific descriptor that follows
    USB_HID_RPT_SIZE,0x00,  // wDescriptorLength - Total length of the descriptor identified above.

    // Endpoint Descriptor
    0x07,                   // bLength - Descriptor size in bytes (07h)
    0x05,                   // bDescriptorType - The constant Endpoint (05h)
    USB_HID_EP | 0x80,      // bEndpointAddress - Endpoint number and direction
    USB_TRANSFER_TYPE,      // bmAttributes - Transfer type and supplementary information
    0x40,0x00,              // wMaxPacketSize - Maximum packet size supported
    EP_IN_INTERVAL,         // bInterval - Service interval or NAK rate

    // Endpoint Descriptor
    0x07,                   // bLength - Descriptor size in bytes (07h)
    0x05,                   // bDescriptorType - The constant Endpoint (05h)
    USB_HID_EP,             // bEndpointAddress - Endpoint number and direction
    USB_TRANSFER_TYPE,      // bmAttributes - Transfer type and supplementary information
    0x40,0x00,              // wMaxPacketSize - Maximum packet size supported
    EP_OUT_INTERVAL         // bInterval - Service interval or NAK rate
};

const struct {
  char report[];
}hid_rpt_desc =
  {
    0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
    0x09, 0x05,                    // USAGE (Game Pad)
    0xa1, 0x01,                    // COLLECTION (Application)
    0xa1, 0x00,                    //   COLLECTION (Physical)
    0x05, 0x09,                    //     USAGE_PAGE (Button)
    0x19, 0x01,                    //     USAGE_MINIMUM (Button 1)
    0x29, 0x08,                    //     USAGE_MAXIMUM (Button 
    0x15, 0x00,                    //     LOGICAL_MINIMUM (0)
    0x25, 0x01,                    //     LOGICAL_MAXIMUM (1)
    0x95, 0x08,                    //     REPORT_COUNT (8)
    0x75, 0x01,                    //     REPORT_SIZE (1)
    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
    0x05, 0x01,                    //     USAGE_PAGE (Generic Desktop)
    0x09, 0x30,                    //     USAGE (X)
    0x09, 0x31,                    //     USAGE (Y)
    0x09, 0x32,                    //     USAGE (Z)
    0x15, 0x81,                    //     LOGICAL_MINIMUM (-127)
    0x25, 0x7f,                    //     LOGICAL_MAXIMUM (127)
    0x75, 0x08,                    //     REPORT_SIZE (8)
    0x95, 0x04,                    //     REPORT_COUNT (4)
    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
    0xc0,                          //     END_COLLECTION
    0xc0                           // END_COLLECTION
  };
//Language code string descriptor
const struct {
  char bLength;
  char bDscType;
  unsigned int string[1];
  } strd1 = {
      4,
      0x03,
      {0x0409}
    };


//Manufacturer string descriptor
const struct{
  char bLength;
  char bDscType;
  unsigned int string[17];
  }strd2={
    36,           //sizeof this descriptor string
    0x03,
    {'J','O','Y'}
  };

//Product string descriptor
const struct{
  char bLength;
  char bDscType;
  unsigned int string[14];
}strd3={
    30,          //sizeof this descriptor string
    0x03,
    {'F','i','r','s','t','S','u','c','e','s','s'}
 };

//Array of configuration descriptors
const char* USB_config_dsc_ptr[1];

//Array of string descriptors
const char* USB_string_dsc_ptr[3];

void USB_Init_Desc(){
  USB_config_dsc_ptr[0] = &configDescriptor1;
  USB_string_dsc_ptr[0] = (const char*)&strd1;
  USB_string_dsc_ptr[1] = (const char*)&strd2;
  USB_string_dsc_ptr[2] = (const char*)&strd3;
}

Ligação no proteus está igual a ligação na ProtoBoard:

vtrx · 6 de fevereiro de 2020

No PC ele enumera corretamente?

Outra coisa,experimente mudar aqui:

while(!HID_Write(writebuff,9));
 para
while(!HID_Write(writebuff,4));

Olhando o descritor me parece que ele trabalha com 4 bytes,um para o botão e mais três para os eixos X,Y e Z.

Se voce 'enviar' mais bytes ou menos bytes que o descritor mostrou que trabalha,o dispositivo não responde.

Henrique Morais · 6 de fevereiro de 2020

@vtrx

Em 06/02/2020 às 01:29, vtrx disse:
No PC ele enumera corretamente?

Outra coisa,experimente mudar aqui:
while(!HID_Write(writebuff,9));
 para
while(!HID_Write(writebuff,4));
Olhando o descritor me parece que ele trabalha com 4 bytes,um para o botão e mais três para os eixos X,Y e Z.

Se voce 'enviar' mais bytes ou menos bytes que o descritor mostrou que trabalha,o dispositivo não responde.
Expandir

Obrigado pela atenção, vou testar aqui e retorno... estranho que pelo proteus funciona normal.

vtrx · 6 de fevereiro de 2020

Em 06/02/2020 às 01:48, Henrique Morais disse:

@vtrx

Obrigado pela atenção, vou testar aqui e retorno... estranho que pelo proteus funciona normal.

Expandir

Baixe o aplicativo em anexo.

Se seu dispositivo é reconhecido normalmente pelo Windows,execute o aplicativo,selecione seu dispositivo e clique em INFO,em "Input Report Size=" voce saberá quantos bytes o sistema espera que seu dispositivo envie ->(while(!HID_Write(writebuff,?));).

UsagesDemo.rarBuscando informações...