Kommunikation vom Pc zum PIC18f4550/4553 mittels USB

[Alex (Gast)]

Hallo
derzeit arbeite ich an einem Projekt, welches den PC mit einem 
PIC18f4553 mittels USB verbinden soll.

Dabei nutze ich unter Windows eine einfache Win32-Anwendung, in C++, um 
Zeichen zu empfangen und um Zeichen zu senden.

Der PIC wird in C und mit dem PCWHD Compiler Version 4.124 geflasht, 
außerdem wird ordnungsgemäß die Treibersoftware erkannt und es ist 
möglich mit dem Programm: USB View sämtliche Descritoren auszulesen.

Nun zu meinem Problem:
Die USB-Verbindung funktioniert nur einseitig, sprich ich kann vom PC 
aus senden, aber nichts am PC empfangen. Die Zeichen die gesendet 
werden, kommen im PIC richtig an.

Wenn ich aber vom PIC aus Zeichen senden will, kommt am PC nichts an. 
Ich habe auch schon versucht, mittels Sniffer-Programm, den Datenverkehr 
mitzuschneiden, aber leider war dieses erfolglos, da das Programm keinen 
ankommenden Datenstream anzeigte (Device Monitoring Studio 6.25).

Nun hoffe ich, dass mir irgendwer ein paar Tipps geben kann, damit der 
Datenverkehr auch in beide Richtungen funktioniert.

Danke schon mal im voraus. :)

Mit freundlichen Grüßen

Alex

Win32-Anwendung
Der Quellcode wurde von Microship verwendet und geändert.
Relevanteänderungen sind in der console.cpp in der Swtich-Anweisung 
gemacht worden (funktionen:writing(); reading(); dritter Codeblock)

MPUSBAPI Library Version 1.00

#ifndef _MPUSBAPI_H_
#define _MPUSBAPI_H_

#define  MPUSB_FAIL                  0
#define MPUSB_SUCCESS               1

#define MP_WRITE                    0
#define MP_READ                     1

// MAX_NUM_MPUSB_DEV is an abstract limitation.
// It is very unlikely that a computer system will have more
// then 127 USB devices attached to it. (single or multiple USB hosts)
#define MAX_NUM_MPUSB_DEV           127

DWORD (*MPUSBGetDLLVersion)(void);

DWORD (*MPUSBGetDeviceCount)(PCHAR pVID_PID);

HANDLE (*MPUSBOpen)(DWORD instance,         // Input
                 PCHAR pVID_PID,            // Input
                 PCHAR pEP,                 // Input
                 DWORD dwDir,               // Input
                 DWORD dwReserved);         // Input <Future Use>

DWORD (*MPUSBRead)(HANDLE handle,           // Input
                PVOID pData,                // Output
                DWORD dwLen,                // Input
                PDWORD pLength,             // Output
                DWORD dwMilliseconds);      // Input

DWORD (*MPUSBWrite)(HANDLE handle,          // Input
                 PVOID pData,               // Input
                 DWORD dwLen,               // Input
                 PDWORD pLength,            // Output
                 DWORD dwMilliseconds);     // Input

DWORD (*MPUSBReadInt)(HANDLE handle,        // Input
                   PVOID pData,             // Output
                   DWORD dwLen,             // Input
                   PDWORD pLength,          // Output
                   DWORD dwMilliseconds);   // Input

BOOL (*MPUSBClose)(HANDLE handle);

#endif

console.cpp

#include <stdio.h>
#include <windows.h>
#include <iostream>

using namespace std;

#pragma hdrstop

#include "mpusbapi.h"                   // MPUSBAPI Header File

//---------------------------------------------------------------------------
#pragma argsused

// Global Vars
char vid_pid[]= "vid_04d8&pid_000c";    // Default Demo Application Firmware
char out_pipe[]= "\\MCHP_EP1";
char in_pipe[]= "\\MCHP_EP1";

DWORD temp;

HINSTANCE libHandle;
HANDLE myOutPipe;
HANDLE myInPipe;

//---------------------------------------------------------------------------
// Prototypes
void GetSummary(void);
void LoadDLL(void);
void GetUSBDemoFWVersion(void);
DWORD SendReceivePacket(BYTE *SendData, DWORD SendLength, BYTE *ReceiveData,
                    DWORD *ReceiveLength, UINT SendDelay, UINT ReceiveDelay);
void CheckInvalidHandle(void);



int reading(void);
int writing(void);
//---------------------------------------------------------------------------

int main(int argc, char* argv[])
{
    BOOLEAN bQuit;
    DWORD selection;
    bQuit = false;
  int x11,x12;
    // Load DLL when it is necessary, i.e. on start-up!
    LoadDLL();

    // Always a good idea to initialize the handles
    myOutPipe= INVALID_HANDLE_VALUE;
  myInPipe = INVALID_HANDLE_VALUE;


    printf("Microchip Technology Inc., 2004\r\n");
    printf("===============================\r\n");
    while(!bQuit)
    {
        printf("Select an option\r\n");
        printf("[1] Get MPUSBAPI Version\r\n");
        printf("[2] Summarize Instances\r\n");
        printf("[3] Get USB Demo Firmware Version\r\n");
        printf("[4] Daten schreiben\r\n");
    printf("[5] Daten lesen\r\n");
    printf("[6] Quit\r\n>>");
        scanf("%d",&selection);
    
        switch(selection)
        {
            case 1:
                temp = MPUSBGetDLLVersion();
                printf("MPUSBAPI Version: %d.%d\r\n",x11=HIWORD(temp),x12=LOWORD(temp));
                break;
            case 2:
                GetSummary();
                break;
            case 3:
                GetUSBDemoFWVersion();
                break;
      case 4:
                writing();
                break;
            case 5:
                reading();
                break;
      case 6:
                bQuit = true;
                break;

            default:
                break;
        }// end switch

        fflush(stdin);printf("\r\n");
    }//end while

    // Always check to close all handles before exiting!
    if (myOutPipe != INVALID_HANDLE_VALUE) MPUSBClose(myOutPipe);
    if (myInPipe != INVALID_HANDLE_VALUE) MPUSBClose(myInPipe);
    myOutPipe = myInPipe = INVALID_HANDLE_VALUE;

    // Always check to close the library too.
    if (libHandle != NULL) FreeLibrary(libHandle);

    return 0;
}//end main

//---------------------------------------------------------------------------

void GetSummary(void)
{
    HANDLE tempPipe = INVALID_HANDLE_VALUE;
    DWORD count = 0;
    DWORD max_count;

    max_count = MPUSBGetDeviceCount(vid_pid);

    printf("\r\n%d device(s) with %s currently attached\r\n",max_count,vid_pid);

    // Note:
    // The total number of devices using the generic driver could be
    // bigger than max_count. They could have different vid & pid numbers.
    // This means if max_count is 2, the valid instance index do not
    // necessary have to be '0' and '1'.
    //
    // Below is a sample code for searching for all valid instance indexes.
    // MAX_NUM_MPUSB_DEV is defined in _mpusbapi.h

    count = 0;
    for(int i = 0; i < MAX_NUM_MPUSB_DEV; i++)
    {
        tempPipe = MPUSBOpen(i,vid_pid,NULL,MP_READ,0);
        if(tempPipe != INVALID_HANDLE_VALUE)
        {
            printf("Instance Index # %d\r\n",i);
            MPUSBClose(tempPipe);
            count++;
        }
        if(count == max_count) break;
    }//end for
    printf("\r\n");
}//end GetSummary

//---------------------------------------------------------------------------

void LoadDLL(void)
{
    libHandle = NULL;
  
  libHandle = LoadLibrary(TEXT("mpusbapi.dll"));
    if(libHandle == NULL)
    {
        printf("Error loading mpusbapi.dll\r\n");
    }
    else
    {
        MPUSBGetDLLVersion=(DWORD(*)(void))\
                    GetProcAddress(libHandle,"_MPUSBGetDLLVersion");
        MPUSBGetDeviceCount=(DWORD(*)(PCHAR))\
                    GetProcAddress(libHandle,"_MPUSBGetDeviceCount");
        MPUSBOpen=(HANDLE(*)(DWORD,PCHAR,PCHAR,DWORD,DWORD))\
                    GetProcAddress(libHandle,"_MPUSBOpen");
        MPUSBWrite=(DWORD(*)(HANDLE,PVOID,DWORD,PDWORD,DWORD))\
                    GetProcAddress(libHandle,"_MPUSBWrite");
        MPUSBRead=(DWORD(*)(HANDLE,PVOID,DWORD,PDWORD,DWORD))\
                    GetProcAddress(libHandle,"_MPUSBRead");
        MPUSBReadInt=(DWORD(*)(HANDLE,PVOID,DWORD,PDWORD,DWORD))\
                    GetProcAddress(libHandle,"_MPUSBReadInt");
        MPUSBClose=(BOOL(*)(HANDLE))GetProcAddress(libHandle,"_MPUSBClose");

        if((MPUSBGetDeviceCount == NULL) || (MPUSBOpen == NULL) ||
            (MPUSBWrite == NULL) || (MPUSBRead == NULL) ||
            (MPUSBClose == NULL) || (MPUSBGetDLLVersion == NULL) ||
            (MPUSBReadInt == NULL))
            printf("GetProcAddress Error\r\n");
    }//end if else
}//end LoadDLL


void GetUSBDemoFWVersion(void)
{
    // First we need to open data pipes...
    DWORD selection;
    fflush(stdin);
    printf("Enter a valid instance index to open a USB connection: ");
    scanf("%d",&selection);

    myOutPipe = MPUSBOpen(selection,vid_pid,out_pipe,MP_WRITE,0);
    myInPipe = MPUSBOpen(selection,vid_pid,NULL,MP_READ,0);//out_pipe,MP_READ,0);
    if(myOutPipe == INVALID_HANDLE_VALUE || myInPipe == INVALID_HANDLE_VALUE)
    {
        printf("Failed to open data pipes.\r\n");
        return;
    }//end if


    // The default demo firmware application has a defined application
    // level protocol.
    // To read the firmware version, the host must send the READ_VERSION
    // command which is defined as 0x00, follows by the length of the
    // expected result, in this case is 2 bytes, major version, and minor
    // version.
    // i.e. <READ_VERSION><0x02>
    //
    // The response packet from the board has the following format:
    // <READ_VERSION><0x02><MINOR_VER><MAJOR_VER>

    // The receive buffer size must be equal to or larger than the maximum
    // endpoint size it is communicating with. In this case, 64 bytes.

    BYTE send_buf[64],receive_buf[64];
    DWORD RecvLength=4;

    #define READ_VERSION    0
    send_buf[0] = READ_VERSION;      // Command
    send_buf[1] = 0x02;              // Expected length of the result

    if(SendReceivePacket(send_buf,2,receive_buf,&RecvLength,1000,1000) == 1)
    {
        if(RecvLength == 4 && receive_buf[0] == READ_VERSION &&
            receive_buf[1] == 0x02)
        {
            printf("\nUSB Demo Firmware Version %d.%d\r\n",receive_buf[3],
                    receive_buf[2]);
        }
    }
    else
        printf("USB Operation Failed\r\n");

    // Let's close the data pipes since we have nothing left to do..
    MPUSBClose(myOutPipe);
    MPUSBClose(myInPipe);
    myOutPipe = myInPipe = INVALID_HANDLE_VALUE;
    
}//end GetUSBDemoFWVersion

//---------------------------------------------------------------------------

/////////////////////////////////////////////////////////////////////////////
//
// A typical application would send a command to the target device and expect
// a response.
// SendReceivePacket is a wrapper function that facilitates the
// send command / read response paradigm
//
// SendData - pointer to data to be sent
// SendLength - length of data to be sent
// ReceiveData - Points to the buffer that receives the data read from the call
// ReceiveLength - Points to the number of bytes read
// SendDelay - time-out value for MPUSBWrite operation in milliseconds
// ReceiveDelay - time-out value for MPUSBRead operation in milliseconds
//

DWORD SendReceivePacket(BYTE *SendData, DWORD SendLength, BYTE *ReceiveData,
                    DWORD *ReceiveLength, UINT SendDelay, UINT ReceiveDelay)
{
    DWORD SentDataLength;
    DWORD ExpectedReceiveLength = *ReceiveLength;

    if(myOutPipe != INVALID_HANDLE_VALUE && myInPipe != INVALID_HANDLE_VALUE)
    {
        if(MPUSBWrite(myOutPipe,SendData,SendLength,&SentDataLength,SendDelay))
        {

            if(MPUSBRead(myInPipe,ReceiveData, ExpectedReceiveLength,
                        ReceiveLength,ReceiveDelay))
            {
                if(*ReceiveLength == ExpectedReceiveLength)
                {
                    return 1;   // Success!
                }
                else if(*ReceiveLength < ExpectedReceiveLength)
                {
                    return 2;   // Partially failed, incorrect receive length
                }//end if else
            }
            else
                CheckInvalidHandle();
        }
        else
            CheckInvalidHandle();
    }//end if

    return 0;  // Operation Failed
}//end SendReceivePacket

//---------------------------------------------------------------------------

void CheckInvalidHandle(void)
{
    if(GetLastError() == ERROR_INVALID_HANDLE)
    {
        // Most likely cause of the error is the board was disconnected.
        MPUSBClose(myOutPipe);
        MPUSBClose(myInPipe);
        myOutPipe = myInPipe = INVALID_HANDLE_VALUE;
    }//end if
    else
        printf("Error Code \r\n",GetLastError());
}//end CheckInvalidHandle

writing(); reading()

//---------------------------------------------------------------------------
int writing(void)
{
  BYTE *SendData;
  DWORD SendLength=1; 
  BYTE *ReceiveData;
    DWORD ReceiveLength=1;
  UINT SendDelay=0;
  UINT ReceiveDelay=100;
  DWORD ExpectedReceiveLength=1;
  ReceiveData=0;

  DWORD SentDataLength;

  
  
  BYTE daten1[]="0";
  BYTE daten2[]="8";
  char daten[2]="7";

  myOutPipe=MPUSBOpen(0,vid_pid,out_pipe,MP_WRITE,0);
  myInPipe = MPUSBOpen(0,vid_pid,in_pipe,MP_READ,0);

  //SendReceivePacket(daten1, SendLength, daten2, &ReceiveLength, 1, 0);
  while(1)
  {
    std::cin>>daten1;
    MPUSBWrite(myOutPipe,daten1,1,&SentDataLength,0);
  if(daten1[0]==daten2[0])
  {
    break;
  }
  Sleep(150);
  }
  //MPUSBRead(myInPipe,daten,1,1,0);
  //MPUSBRead(myInPipe,daten, ExpectedReceiveLength,1000,1000);
  
  int temp=MPUSBRead(myInPipe,ReceiveData, ExpectedReceiveLength,&ReceiveLength,ReceiveDelay);
  if(temp!=0)
  {
    cout<<"\n\n"<<ReceiveData<<"\n\n";
  }

  MPUSBClose(myOutPipe);
  MPUSBClose(myInPipe);

  return 0;
}

int reading(void)
{
  BYTE *SendData;
  DWORD SendLength=1; 
  BYTE *ReceiveData;
    DWORD ReceiveLength=1;
  UINT SendDelay=0;
  UINT ReceiveDelay=100;
  DWORD ExpectedReceiveLength=1;
  ReceiveData=0;
  BYTE test[10];
  DWORD SentDataLength;
  ReceiveData=&test[0];
  BYTE daten1[]="0";
  BYTE daten2[]="8";
  char daten[2]="7";

  myOutPipe=MPUSBOpen(0,vid_pid,out_pipe,MP_WRITE,0);
  myInPipe = MPUSBOpen(0,vid_pid,in_pipe,MP_READ,0);
  int temp=0;
  while(1)
  {
    temp=MPUSBRead(myInPipe,ReceiveData, ExpectedReceiveLength,&ReceiveLength,ReceiveDelay);
    if(temp!=0)
    {
      cout<<"\n\n"<<ReceiveData<<"\n\n";
    }
  }

  MPUSBClose(myOutPipe);
  MPUSBClose(myInPipe);


  return 0;
}

//---------------------------------------------------------------------------

//---------------------------------------------------------------------- 
-

Controllerprogramm

main.c

#include <main.h>

#include <pic18_usb.h>
#include <usb_desc_scope2.h>
#include <usb.c>

int daten2[1]=0x30;
#int_RDA
void RDA_isr(void) 
{
   int Daten=RCREG;            //Daten  auslesen und zwischenspeichern
   TXREG=RCREG+1;              //Daten um eins erhöhen und zurück senden

   output_toggle(PIN_A1);
   
   usb_put_packet(0x81,daten2,1,USB_DTS_TOGGLE); 
        // usb_puts(0x82,daten2,1,500); 
   output_toggle(PIN_A0);
}

void main()
{   
SPBRG=25;               //9600Baud //EUSART Baud Rate Generator Register Low Byte

   int temp;
   int daten1[1]=0;

   delay_ms(250);
   output_high(PIN_D1);

   usb_init();
   usb_wait_for_enumeration();

   output_low(PIN_D1);

   setup_adc_ports(NO_ANALOGS);

   enable_interrupts(INT_RDA);

   enable_interrupts(GLOBAL);

   delay_ms(250);
   
   while(true)
   {
      output_toggle(PIN_D0);              //blinkende LED zeigt Aktivität
      usb_put_packet(0x81,daten2,1,USB_DTS_TOGGLE);
      delay_ms(333);
      
      if(usb_kbhit(1)==TRUE)              //Daten wurden empfangen
      {
         output_toggle(PIN_A0);           //LED blinkt 
         usb_get_packet(0x01,daten1,1);   //wurde mittels UART und Debugmodus kontrolliert 
      }
   }
}

main.h

#include <18F4553.h>
#device adc=16
#device ICD=TRUE

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES PLL2                     //1.00   PLL1   No PLL PreScaler
#FUSES CPUDIV4                  //CPUDIV2   System Clock by 2
#FUSES XTPLL                    //XTPLL   Crystal/Resonator with PLL enabled
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
#FUSES VREGEN                   //USB voltage regulator enabled      
#FUSES NOUSBDIV

#FUSES HSPLL
#FUSES ECPLL
#FUSES EC_IO
#FUSES VREGEN

#use delay(crystal=8000000,clock=8000000)

#use FIXED_IO( A_outputs=PIN_A3,PIN_A2,PIN_A1,PIN_A0 )

#use FIXED_IO( D_outputs=PIN_D3,PIN_D2,PIN_D1,PIN_D0 )


#use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
//funktioniert nur wenn man danach nochmal die Baudrate per hand setzt
//sonst wird diese doppelt so groß gesetzt

//++++++++++RS-232-Start++++++++++//
#byte RCSTA   =  0xFAB           //RECEIVE STATUS AND CONTROL REGISTER
#byte TXSTA   =  0xFAC           //TRANSMIT STATUS AND CONTROL REGISTER
#byte TXREG   =  0xFAD           //EUSART Transmit Register
#byte RCREG   =  0xFAE           //EUSART Receive Register
#byte SPBRG   =  0xFAF           //EUSART Baud Rate Generator Register Low Byte
#byte SPBRGH  =  0xFB0           //EUSART Baud Rate Generator Register High Byte
#byte BAUDCON =  0xFB8           //BAUD RATE CONTROL REGISTER


//#byte RCSTA   =  0xFAB         //RECEIVE STATUS AND CONTROL REGISTER

#bit RX9D     =  RCSTA.0         //9th Bit of Received Data 
#bit OERR     =  RCSTA.1         //Overrun Error bit 
#bit FERR     =  RCSTA.2         //Framing Error bit 
#bit ADDEN    =  RCSTA.3         //Address Detect Enable bit
#bit CREN     =  RCSTA.4         //Continuous Receive Enable bit
#bit SREN     =  RCSTA.5         //Single Receive Enable bit 
#bit RX9      =  RCSTA.6         //9-Bit Receive Enable bit 
#bit SPEN     =  RCSTA.7         //Serial Port Enable bit 

//#byte TXSTA   =  0xFAC         //TRANSMIT STATUS AND CONTROL REGISTER

#bit TX9D     =  TXSTA.0         //9th Bit of Transmit Data 
#bit TRMT     =  TXSTA.1         //Transmit Shift Register Status bit 
#bit BRGH     =  TXSTA.2         //High Baud Rate Select bit
#bit SENDB    =  TXSTA.3         //Send Break Character bit 
#bit SYNC     =  TXSTA.4         //EUSART Mode Select bit 
#bit TXEN     =  TXSTA.5         //Transmit Enable bit 
#bit TX9      =  TXSTA.6         //9-Bit Transmit Enable bit 
#bit CSRC     =  TXSTA.7         //Clock Source Select bit

//#byte BAUDCON =  0xFB8         //BAUD RATE CONTROL REGISTER

#bit ABDEN    =  BAUDCON.0       //Auto-Baud Detect Enable bit 
#bit WUE      =  BAUDCON.1       //Wake-up Enable bit 
#bit BRG16    =  BAUDCON.3       //16-Bit Baud Rate Register Enable bit 
#bit TXCKP    =  BAUDCON.4       //Clock and Data Polarity Select bit 
#bit RXDTP    =  BAUDCON.5       //Data/Receive Polarity Select bit 
#bit RCIDL    =  BAUDCON.6       //Receive Operation Idle Status bit 
#bit ABDOVF   =  BAUDCON.7       //Auto-Baud Acquisition Rollover Status bit 

//++++++++++RS-232-Ende++++++++++//

usb_desc_scope2.h   geänderte Decriptoren Quelle:Microship

///////////////////////////////////////////////////////////////////////////
////                         usb_desc_scope.h                          ////
////                                                                   ////
//// An example set of device / configuration descriptors for use with ////
//// the USB Bulk demo (see ex_usb_scope.c)                            ////
////                                                                   ////
//// This file is part of CCS's PIC USB driver code.  See USB.H        ////
//// for more documentation and a list of examples.                    ////
////                                                                   ////
///////////////////////////////////////////////////////////////////////////
////                                                                   ////
//// Version History:                                                  ////
////                                                                   ////
//// March 5th, 2009:                                                  ////
////   Cleanup for Wizard.                                             ////
////   PIC24 Initial release.                                          ////
////                                                                   ////
//// July 13th, 2005:                                                  ////
////   Endpoint descriptor works if USB_EP1_TX_SIZE is 16bits          ////
////   Endpoint descriptor works if USB_EP1_RX_SIZE is 16bits          ////
////                                                                   ////
//// June 20th, 2005:                                                  ////
////   18fxx5x Initial release.                                        ////
////                                                                   ////
//// March 21st, 2005:                                                 ////
////   EP 0x01 and EP 0x81 now use USB_EP1_TX_SIZE and USB_EP1_RX_SIZE ////
////      to define max packet size, to make it easier for dynamically ////
////      changed code.                                                ////
////                                                                   ////
//// June 24th, 2002: Cleanup                                          ////
////                                                                   ////
//// May 6th, 2003: Fixed non-HID descriptors pointing to faulty       ////
////                strings                                            ////
////                                                                   ////
//// August 2nd, 2002: Initial Public Release                          ////
////                                                                   ////
////                                                                   ////
///////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996,2009 Custom Computer Services           ////
//// This source code may only be used by licensed users of the CCS    ////
//// C compiler.  This source code may only be distributed to other    ////
//// licensed users of the CCS C compiler.  No other use,              ////
//// reproduction or distribution is permitted without written         ////
//// permission.  Derivative programs created using this software      ////
//// in object code form are not restricted in any way.                ////
///////////////////////////////////////////////////////////////////////////

#IFNDEF __USB_DESCRIPTORS__
#DEFINE __USB_DESCRIPTORS__

///////// config options, although it's best to leave alone for this demo /////
#define  USB_CONFIG_PID       0x000c//0x0003   //changing this value may make the driver incompatible
#define  USB_CONFIG_VID       0x04d8//0x0461   //changing this value may make the driver incompatible
#define  USB_CONFIG_BUS_POWER 250   //100mA  (range is 0..500)
#define  USB_CONFIG_VERSION   0x0100      //01.00  //range is 00.00 to 99.99
//////// end config ///////////////////////////////////////////////////////////

#DEFINE USB_HID_DEVICE     FALSE
#define USB_EP2_TX_ENABLE  USB_ENABLE_BULK  //turn on EP1 for IN bulk/interrupt transfers
#define USB_EP1_RX_ENABLE  USB_ENABLE_BULK  //turn on EP1 for OUT bulk/interrupt transfers

#ifndef USB_EP2_TX_SIZE
#define USB_EP2_TX_SIZE    64  //size to allocate for the tx endpoint 1 buffer
#endif

#ifndef USB_EP1_RX_SIZE
#define USB_EP1_RX_SIZE    8   //size to allocate for the rx endpoint 1 buffer
#endif

#include <usb.h>

//////////////////////////////////////////////////////////////////
///
///   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      32 //config+interface+class+endpoint

   //configuration descriptor
   char const USB_CONFIG_DESC[] = {
   //config_descriptor for config index 1
         USB_DESC_CONFIG_LEN,     //length of descriptor size
         USB_DESC_CONFIG_TYPE,         //constant CONFIGURATION (0x02)
         USB_TOTAL_CONFIG_LEN,0,  //size of all data returned for this config
         1,      //number of interfaces this device supports
         0x01,                //identifier for this configuration.  (IF we had more than one configurations)
         0x00,                //index of string descriptor for this configuration
        #if USB_CONFIG_BUS_POWER
         0x80, //bit 6=1 if self powered, bit 5=1 if supports remote wakeup (we don't), bits 0-4 unused and bit7=1         ==7
        #else
         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
        #endif
         USB_CONFIG_BUS_POWER/2, //maximum bus power required (maximum milliamperes/2)  (0x32 = 100mA)   ==8

   //interface descriptor 0 alt 0
         USB_DESC_INTERFACE_LEN,  //length of descriptor
         USB_DESC_INTERFACE_TYPE,      //constant INTERFACE (0x04)
         0x00,                //number defining this interface (IF we had more than one interface)
         0x00,                //alternate setting
         2,       //number of endpoints, not counting endpoint 0.
         0xFF,                //class code, FF = vendor defined
         0xFF,                //subclass code, FF = vendor
         0xFF,                //protocol code, FF = vendor
         0x00,                //index of string descriptor for interface

   //endpoint descriptor
         USB_DESC_ENDPOINT_LEN, //length of descriptor
         USB_DESC_ENDPOINT_TYPE,     //constant ENDPOINT (0x05)
         0x81//0x81,              //endpoint number and direction (0x81 = EP1 IN)
         USB_EP2_TX_ENABLE,              //transfer type supported (0 is control, 1 is iso, 2 is bulk, 3 is interrupt)
         USB_EP2_TX_SIZE & 0xFF,USB_EP11_TX_SIZE >> 8,         //maximum packet size supported
         0x01,              //polling interval in ms. (for interrupt transfers ONLY)

   //endpoint descriptor
         USB_DESC_ENDPOINT_LEN, //length of descriptor
         USB_DESC_ENDPOINT_TYPE,     //constant ENDPOINT (0x05)
         0x01//0x01,              //endpoint number and direction (0x01 = EP1 OUT)
         USB_EP1_RX_ENABLE,              //transfer type supported (0 is control, 1 is iso, 2 is bulk, 3 is interrupt)
         USB_EP1_RX_SIZE & 0xFF,USB_EP1_RX_SIZE >> 8,         //maximum packet size supported
         0x01,              //polling interval in ms. (for interrupt transfers ONLY)
  };

   //****** 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   0

   //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};

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


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

   //device descriptor
   char const USB_DEVICE_DESC[] ={
         USB_DESC_DEVICE_LEN,          //the length of this report
         0x01,                //constant DEVICE (0x01)
         0x10,0x01,           //usb version in bcd
         0x00,                //class code (if 0, interface defines class.  FF is vendor defined)
         0x00,                //subclass code
         0x00,                //protocol code
         USB_MAX_EP0_PACKET_LENGTH,   //max packet size for endpoint 0. (SLOW SPEED SPECIFIES 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)
         0x02,                //index of string descriptor of the product
         0x00,                //index of string descriptor of serial number
         USB_NUM_CONFIGURATIONS   //number of possible configurations
   };

//////////////////////////////////////////////////////////////////
///
///   start string descriptors
///   String 0 is a special language string, and must be defined.  People in U.S.A. can leave this alone.
///
///   You must define the length else get_next_string_character() will not see the string
///   Current code only supports 10 strings (0 thru 9)
///
//////////////////////////////////////////////////////////////////

//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};

#define USB_STRING_DESC_COUNT sizeof(USB_STRING_DESC_OFFSET)

// Here is where the "CCS" Manufacturer string and "CCS Bulk Demo" are stored.
// Strings are saved as unicode.
// These strings are mostly only displayed during the add hardware wizard.
// Once the operating system drivers have been installed it will usually display
// the name from the drivers .INF.
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)
         '1',0,
         '3',0,
         '3',0,
         '7',0,
         ' ',0,
         't',0,
         'e',0,
         's',0,
         't',0,
         ' ',0,
         ':',0,
         ')',0,
         ' ',0
};

#ENDIF