Handle = HID_OpenDevice(PID,  VID,  VersionNumber,  Index)

CountReadBytes = HID_ReadDevice(Handle,  *buffer,   LenBuffer)

CountWriteBytes = HID_WriteDevice(Handle,  *buffer,   LenBuffer)

Result = HID_CloseDevice(Handle)

    Public Declare Function HID_OpenDevice Lib "HID_Lib_PB.dll" _
    (ByVal PID As Integer, ByVal VID As Integer, ByVal VersionNumber As Integer, _
     ByVal Index As Integer) As Integer

 Dim vid As Integer = 5824
     Dim pid As Integer = 1503

        Dim ver As Integer = -1
        Dim ind As Integer = 0
        Dim Handle As Integer
        Dim res

        Handle = HID_OpenDevice(vid, pid, ver, ind)

#USB_PID          = $33  ; Идентификаторы PicKit 2
#USB_VID          = $4D8

Lib=LoadLibrary_("HID_Lib_PB.dll")
If Lib=0
 MessageRequester("PicKit 2 Test", "Нет HID_Lib_PB.dll!", 48)
 End
EndIf

; Декларация функций HID_Lib_PB.dll
Prototype HID_OpenDevice(PID.w, VID.w, VersionNumber.w, Index.w)
Prototype HID_WriteDevice(Handle,  *buffer,   LenBuffer)
Prototype HID_CloseDevice(Handle)
HID_OpenDevice.HID_OpenDevice=GetProcAddress_(Lib, "HID_OpenDevice")
Global HID_WriteDevice.HID_WriteDevice=GetProcAddress_(Lib, "HID_WriteDevice")
HID_CloseDevice.HID_CloseDevice=GetProcAddress_(Lib, "HID_CloseDevice")

Procedure VddOn(Handle) ; Включить питание программируемого МК
 Protected Dim OutBuffer.c(68)
 OutBuffer(0)=0
 OutBuffer(1)=$A6 ; EXECUTE_SCRIPT
 OutBuffer(2)=2
 OutBuffer(3)=$FC ; _VDD_GND_OFF
 OutBuffer(4)=$FF ; _VDD_ON
ProcedureReturn HID_WriteDevice(Handle, @OutBuffer(), 65) ; Отсылаем данные девайсу PicKit 2
EndProcedure

Procedure VddOff(Handle) ; Выключить питание программируемого МК
 Protected Dim OutBuffer.c(68)
 OutBuffer(0)=0
 OutBuffer(1)=$A6 ; EXECUTE_SCRIPT
 OutBuffer(2)=2
 OutBuffer(3)=$FE ; _VDD_OFF
 OutBuffer(4)=$FD ; _VDD_GND_ON
ProcedureReturn HID_WriteDevice(Handle, @OutBuffer(), 65) ; Отсылаем данные девайсу PicKit 2
EndProcedure

Handle=HID_OpenDevice(#USB_PID, #USB_VID, -1, 0) ; Установка связи с PicKit 2
 If Handle
   VddOn(Handle)                                 ; Включить питание
   Delay(1000)                                   ; Пауза 1 секунда
   VddOff(Handle)                                ; Выключить питание
   HID_CloseDevice(Handle)                       ; Разрыв связи с PicKit 2
 Else
   MessageRequester("PicKit 2 Test", "Нет связи с PicKit2!", 48)
 EndIf

usbDevice_t *dev;
char        buffer[129];    /* room for dummy report ID */               128 с нулем
int         err;

    if(argc < 2){
        usage(argv[0]);
        exit(1);
    }
    if((dev = openDevice()) == NULL)
        exit(1);
    if(strcasecmp(argv[1], "read") == 0){
        int len = sizeof(buffer);
        if((err = usbhidGetReport(dev, 0, buffer, &len)) != 0){
            fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
        }else{
            hexdump(buffer + 1, sizeof(buffer) - 1);
        }
    }else if(strcasecmp(argv[1], "write") == 0){
        int i, pos;
        bzero(buffer, sizeof(buffer));
        for(pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++){
            pos += hexread(buffer + pos, argv[i], sizeof(buffer) - pos);
        }
        if((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0)   /* add a dummy report ID */
            fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
    }else{
        usage(argv[0]);
        exit(1);
    }
    usbhidCloseDevice(dev);

/* usbFunctionRead() is called when the host requests a chunk of data from
 * the device. For more information see the documentation in usbdrv/usbdrv.h.
 */
uchar   usbFunctionRead(uchar *data, uchar len)
{
    if(len > bytesRemaining)
        len = bytesRemaining;
    eeprom_read_block(data, (uchar *)0 + currentAddress, len);
    currentAddress += len;
    bytesRemaining -= len;
    return len;
}

/* usbFunctionWrite() is called when the host sends a chunk of data to the
 * device. For more information see the documentation in usbdrv/usbdrv.h.
 */
uchar   usbFunctionWrite(uchar *data, uchar len)
{
    if(bytesRemaining == 0)
        return 1;               /* end of transfer */
    if(len > bytesRemaining)
        len = bytesRemaining;
    eeprom_write_block(data, (uchar *)0 + currentAddress, len);
    currentAddress += len;
    bytesRemaining -= len;
    return bytesRemaining == 0; /* return 1 if this was the last chunk */
}

/* ---------- */

usbMsgLen_t usbFunctionSetup(uchar data[8])
{
usbRequest_t    *rq = (void *)data;

    if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS){    /* HID class request */
        if(rq->bRequest == USBRQ_HID_GET_REPORT){  /* wValue: ReportType (highbyte), ReportID (lowbyte) */
            /* since we have only one report type, we can ignore the report-ID */
            bytesRemaining = 128;
            currentAddress = 0;
            return USB_NO_MSG;  /* use usbFunctionRead() to obtain data */
        }else if(rq->bRequest == USBRQ_HID_SET_REPORT){
            /* since we have only one report type, we can ignore the report-ID */
            bytesRemaining = 128;
            currentAddress = 0;
            return USB_NO_MSG;  /* use usbFunctionWrite() to receive data from host */
        }
    }else{
        /* ignore vendor type requests, we don't use any */
    }
    return 0;
}

PROGMEM char usbHidReportDescriptor[22] = {    /* USB report descriptor */
    0x06, 0x00, 0xff,              // USAGE_PAGE (Generic Desktop)
    0x09, 0x01,                    // USAGE (Vendor Usage 1)
    0xa1, 0x01,                    // COLLECTION (Application)
    0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
    0x26, 0xff, 0x00,              //   LOGICAL_MAXIMUM (255)
    0x75, 0x08,                    //   REPORT_SIZE (8) ----------  вот они ----------
    0x95, 0x01,                    //   REPORT_COUNT (1)
    0x09, 0x00,                    //   USAGE (Undefined)
    0xb2, 0x02, 0x01,              //   FEATURE (Data,Var,Abs,Buf)
    0xc0                           // END_COLLECTION
};
А вот они в файле usbdrv.c
/* ---------- Device Descriptor ---------- */

#if USB_CFG_DESCR_PROPS_DEVICE == 0
#undef USB_CFG_DESCR_PROPS_DEVICE
#define USB_CFG_DESCR_PROPS_DEVICE  sizeof(usbDescriptorDevice)
PROGMEM char usbDescriptorDevice[] = {    /* USB device descriptor */
    18,         /* sizeof(usbDescriptorDevice): length of descriptor in bytes */
    USBDESCR_DEVICE,        /* descriptor type */
    0x10, 0x01,             /* USB version supported */
    USB_CFG_DEVICE_CLASS,
    USB_CFG_DEVICE_SUBCLASS,
    0,                      /* protocol */
    8,                      /* max packet size */ ------и здесь ----------

и, собственно, сами байты в usbdrv.h
----------
typedef struct usbRequest{
    uchar       bmRequestType; //1
    uchar       bRequest; //2
    usbWord_t   wValue; //3,4
    usbWord_t   wIndex; //5,6
    usbWord_t   wLength; //7,8
}usbRequest_t;
----------
Все 8 штук, обращаюсь при чтении и записи
un.dataBuffer - это мой массив обмена
----------
usbMsgLen_t usbFunctionSetup(uchar data[8])
{
usbRequest_t    *rq = (void *)data;

    if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_VENDOR){
        DBG1(0x50, &rq->bRequest, 1);   /* debug output: print our request */ // прием
        if(rq->bRequest == CUSTOM_RQ_SET_STATUS)
      {
           un.dataBuffer[0] = rq->wValue.bytes[0];
           un.dataBuffer[1] = rq->wValue.bytes[1];
           un.dataBuffer[2] = rq->wIndex.bytes[0];
           un.dataBuffer[3] = rq->wIndex.bytes[1];
      flag=1;
                usbMsgPtr = un.dataBuffer;         /* tell the driver which data to return */
           return 4;
        }else if(rq->bRequest == CUSTOM_RQ_GET_STATUS){
                /* buffer must stay valid when usbFunctionSetup returns */
            //dataBuffer[0] = ((LED_PORT_OUTPUT & _BV(LED_BIT)) != 0);   // передача
      // данные в буфере должны быть готовы
   un.dataBuffer[0]=0x12;
   un.dataBuffer[1]=0x34;   
            usbMsgPtr = un.dataBuffer;         /* tell the driver which data to return */
            return 2;                       /* tell the driver to send 1 byte */
        }
    }else{
        /* calss requests USBRQ_HID_GET_REPORT and USBRQ_HID_SET_REPORT are
         * not implemented since we never call them. The operating system
         * won't call them either because our descriptor defines no meaning.
         */
    }
    return 0;   /* default for not implemented requests: return no data back to host */
}

// HID дескриптор репорта
PROGMEM const char usbHidReportDescriptor[USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH] =
{
    0x06, 0x00, 0xff,       // USAGE_PAGE (Vendor Defined Page 1)
    0x09, 0x01,              // USAGE (Vendor Usage 1)
    0xa1, 0x02,          //   COLLECTION (Logical)
    0x85, 0x77,                //   REPORT_ID (0x77)
    0x09, 0x01,                 //   USAGE (Pointer)
    0x15, 0x00,                 //   LOGICAL_MINIMUM (0)
    0x25, 0x01,                 //   LOGICAL_MAXIMUM (1)
    0x75, 0x08,                 //   REPORT_SIZE (8)
    0x95, 0x03,                 //   REPORT_COUNT (3)
    0x81, 0x02,                 //   INPUT (Data,Var,Abs)
    0x09, 0x01,                 //   USAGE (Pointer)
    0x15, 0x00,                 //   LOGICAL_MINIMUM (0)
    0x26, 0xff, 0x00,           //   LOGICAL_MAXIMUM (255)
    0x75, 0x08,                 //   REPORT_SIZE (8)
    0x95, 0x08,                 //   REPORT_COUNT (8)
    0x91, 0x02,                 //   OUTPUT (Data,Var,Abs)
    0xc0                   // END_COLLECTION
};