USB HID farklı endpointlere veri gönderme

[esensoy]

mcHID.dll host tan device a doğru hangi endpointi kullanarak veri gönderiyor? Daha doğrusu HID device ın birden fazla OUT endpointi (host tan device a doğru) varsa,
İstediğimiz herhangi birine data göndermek için ne yapmak lazım?
Farklı bir dll mi kullanacağız?

[t2]

Elimizde gerçek bir HID aygıt varsa ( yani yeni geliştirdiğimiz deneme yaptığımız aygıt değilse)
Bu HID device ın birden fazla OUT endpointi  varsa, aygıt  composite HID aygıt demektir.

composite HID aygıt birden fazla usb portuna bağlanmış farklı HID aygıtlar gibi kullanılır. yani endpoint numarası yine baştan başlar. ayrıca seçilmez.


Composite HID aygıtı yaptık veya hazırını bulduk diyelim:
Usb listesinde birden fazla hid aygıt şeklinde görünür. seri nosu varsa hepsinin seri nosu aynı. bunların farkı nasıl anlaşılacak hangi aygıta gönderdiğimizi nasıl bileceğiz? Windowsta bunların fiziksel tanımlayıcısı gibi benzersiz stringi vardır registryden okunur.  belki DLL in öyle bir fonksiyornu vardır. istediğimiz ayıta data gönderme işi  nasıl oluor bu DLL de? vendorID product ID ile oluyorsa composite HID aygıtta hep aynı olacaktır.

Eğer aygıt HID aygıt değilse bunlar composite olmasa bile,
endpoint numarası farklı olarak aynı aygıtta farklı endpointe data gönderilebilir.

[esensoy]

Yaptığım devre bir klavye devresi, aygıt yöneticisinde hem USB HID Keyboard, hem USB Giriş Aygıtı, hem de HID uyumlu aygıt olarak görüyor,
Normal kullandığım klavyeden num lock a basarsam, devremdeki led normal bir şekilde yanıp sönüyor, yani buraya kadar problem yok,

mcHID.dll in fonksiyonları da aşağıdaki gibi, bahsettiğiniz gibi ayırıcı bir fonksiyon göremiyorum,
HID device lara ve endpointlerine alternatif bir erişim dll i var mı?

    Declare Function hidConnect Lib "mcHID.dll" Alias "Connect" (ByVal pHostWin As Integer) As Boolean
    Declare Function hidDisconnect Lib "mcHID.dll" Alias "Disconnect" () As Boolean
    Declare Function hidGetItem Lib "mcHID.dll" Alias "GetItem" (ByVal pIndex As Integer) As Integer
    Declare Function hidGetItemCount Lib "mcHID.dll" Alias "GetItemCount" () As Integer
    Declare Function hidRead Lib "mcHID.dll" Alias "Read" (ByVal pHandle As Integer, ByRef pData As Byte) As Boolean
    Declare Function hidWrite Lib "mcHID.dll" Alias "Write" (ByVal pHandle As Integer, ByRef pData As Byte) As Boolean
    Declare Function hidReadEx Lib "mcHID.dll" Alias "ReadEx" (ByVal pVendorID As Integer, ByVal pProductID As Integer, ByRef pData As Byte) As Boolean
    Declare Function hidWriteEx Lib "mcHID.dll" Alias "WriteEx" (ByVal pVendorID As Integer, ByVal pProductID As Integer, ByRef pData As Byte) As Boolean
    Declare Function hidGetHandle Lib "mcHID.dll" Alias "GetHandle" (ByVal pVendoID As Integer, ByVal pProductID As Integer) As Integer
    Declare Function hidGetVendorID Lib "mcHID.dll" Alias "GetVendorID" (ByVal pHandle As Integer) As Integer
    Declare Function hidGetProductID Lib "mcHID.dll" Alias "GetProductID" (ByVal pHandle As Integer) As Integer
    Declare Function hidGetVersion Lib "mcHID.dll" Alias "GetVersion" (ByVal pHandle As Integer) As Integer
    Declare Function hidGetVendorName Lib "mcHID.dll" Alias "GetVendorName" (ByVal pHandle As Integer, ByVal pText As String, ByVal pLen As Integer) As Integer
    Declare Function hidGetProductName Lib "mcHID.dll" Alias "GetProductName" (ByVal pHandle As Integer, ByVal pText As String, ByVal pLen As Integer) As Integer
    Declare Function hidGetSerialNumber Lib "mcHID.dll" Alias "GetSerialNumber" (ByVal pHandle As Integer, ByVal pText As String, ByVal pLen As Integer) As Integer
    Declare Function hidGetInputReportLength Lib "mcHID.dll" Alias "GetInputReportLength" (ByVal pHandle As Integer) As Integer
    Declare Function hidGetOutputReportLength Lib "mcHID.dll" Alias "GetOutputReportLength" (ByVal pHandle As Integer) As Integer
    Declare Sub hidSetReadNotify Lib "mcHID.dll" Alias "SetReadNotify" (ByVal pHandle As Integer, ByVal pValue As Boolean)
    Declare Function hidIsReadNotifyEnabled Lib "mcHID.dll" Alias "IsReadNotifyEnabled" (ByVal pHandle As Integer) As Boolean
    Declare Function hidIsAvailable Lib "mcHID.dll" Alias "IsAvailable" (ByVal pVendorID As Integer, ByVal pProductID As Integer) As Boolean

[t2]

İfadem eksik oldu. Tek interface sahibi  aygıt da aygıt yöneticisinde birden fazla bileşen şeklinde görünebilir.

Belki sizin aygıt hem klavye hemde başka aygıt olarak görünüyor ? yani usbden komut alma ihtimali vardır.

Az önce HP marka USB klavye aygıtını taktım. kendi üzerindeki led yandı tekrar basınca söndü. fakat out endpointi yok bu klavyenin. bilgisayardan gelen veri ile bir şey yapabilecek hali yok. fare gibi sadece gönderiyor. USBlyser programıyla baktığımda tek interface görünüyor. Tek interface ile composite hid aygıt olmaz.

Composite hid aygıt ile haberleşebilen hazır DLL varsa ben bilmiyorum. açık kodlardan ihtiyaca göre yapmak gerek.
HID composite aygıt ve bununla haberleşecek DLL yapmak zordur. hidmakerFS diye program vardı o yapıyordu.

klavye ve fare gibi aygıtlar usbden komut alamaz diye biliyorum.
Komut alabilecek HID  interface'in  Custom Hid device olması uygundur. Bunun haricinde USBden komut alabilen başka HID interface türü de vardır fakat ben bilmiyorum.

Composite aygıtta resimde işeretli kısmın  1den büyük olması gerek.



Edit OG (görünmeyen resimler)

[z]

Peki iletişim hızımız her bir endpoint için gene 64K/sec mıdır?

İki endpoint tanımlasak toplamda 128K/sec transfer yapabilirmiyim?

[t2]

Hız kitaplarda öyle yazıyor her bir endpoint için 64K/s.
Gerçekte 2 endpointli composite HID  aygıt yaparak 128K/s hız elde edileceğine ben şahsen inanmıyorum.  yapanı da duymadım.
4 endpointli composite HID aygıt yaptım. her birinden ayrı data gönderip aldım. ama hız kısmını deneyemedim. led yak söndür gibi basit işler denedim

[esensoy]

Hocam endpointlere ayrı ayrı nasıl eriştiniz, paylaşmanız mümkün mü?

[z]

O zaman şöyle demek daha doğru galiba;

Her bir endpoint 64 Byte/mili sn veri paketi yollayabilir. Fakat 1 saniyedeki paket sayısı için garanti verilemez. Yani 64 K/sn nin garantisi olmaz.

[t2]

Composite HID aygıttaki Endpointlere erişmek için yöntem,
Aynı VID, PID ve seri no ya sahip birden fazla USB porta bağlı HID cihazlara erişmek ile aynıdır.

Önce  istediğimiz VID ve PID e sahip USB HID cihazların  listesini alıyoruz. listede 4 tane olsun.

Tek aygıta bağlanmayı sağlayan kod, nesne  veya komponent her ne ise ondan 4 tane kullanalım.
Bu nesne, aygıta başkası bağlıysa kendisi bağlanamasın. Listeyi aldı, ilk cihaza bağlanmaya çalıştı olmadı. sonrakini denedi oldu.

Bu şekilde oluyor. composite HID aygıttaki diğer out endpointlere  de erişebiliyoruz. Aynı VID, PID ve seri no ya sahip birden fazla USB porta bağlı HID cihazlara erişmek ile aynıdır.

[baran123]

mcHID.dll C# da kullanılabiliyor mu ? Bide veri gelince metoda düşebiliyor mu ? (otomatik olarak)

[esensoy]

Şöyle yaptım,
Microchip Application Library deki USB Device MSD + CDC uygulamasını açtım,
Bu uygulama bordu sanal rs232 CDC ve usb memory gibi sisteme tanıtıyor,
MSD kısmını HID Klavye olarak değiştirdim, şu an ikisi de sorunsuz çalışıyor,

Yalnızca driver yükletmem gerekecek, HID ile çözüp gerekmeseydi iyiydi ama bu şekilde de sorun yok, proje kaldırır, daha fazla zaman kaybetmek istemiyorum,
Belirtmeden geçmiyeyim, mutlaka ilgili örnek klasöründeki composite device driverını yüklemek gerekiyor, yoksa pc aygıtları düzgün tanımıyor,

İlginize teşekkürler


usb_descriptors.c

/********************************************************************
 FileName:     	usb_descriptors.c
 Dependencies:  See INCLUDES section
 Processor:	    PIC18, PIC24, dsPIC, and PIC32 USB Microcontrollers
 Hardware:      This demo is natively intended to be used on Microchip USB demo
                boards supported by the MCHPFSUSB stack.  See release notes for
                support matrix.  This demo can be modified for use on other 
                hardware platforms.
 Complier:  	Microchip C18 (for PIC18), C30 (for PIC24/33), C32 (for PIC32)
 Company:		Microchip Technology, Inc.

 Software License Agreement:

 The software supplied herewith by Microchip Technology Incorporated
 (the "Company") for its PIC� Microcontroller is intended and
 supplied to you, the Company's customer, for use solely and
 exclusively on Microchip PIC 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.


*********************************************************************
-usb_descriptors.c-
-------------------------------------------------------------------
Filling in the descriptor values in the usb_descriptors.c file:
-------------------------------------------------------------------

[Device Descriptors]
The device descriptor is defined as a USB_DEVICE_DESCRIPTOR type.  
This type is defined in usb_ch9.h  Each entry into this structure
needs to be the correct length for the data type of the entry.

[Configuration Descriptors]
The configuration descriptor was changed in v2.x from a structure
to a BYTE array.  Given that the configuration is now a byte array
each byte of multi-byte fields must be listed individually.  This
means that for fields like the total size of the configuration where
the field is a 16-bit value "64,0," is the correct entry for a
configuration that is only 64 bytes long and not "64," which is one
too few bytes.

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 usb_device.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 Descriptors]
Like the configuration descriptor, the endpoint descriptors were 
changed in v2.x of the stack from a structure to a BYTE array.  As
endpoint descriptors also has a field that are multi-byte entities,
please be sure to specify both bytes of the field.  For example, for
the endpoint size an endpoint that is 64 bytes needs to have the size
defined as "64,0," instead of "64,"

Take the following example:
    // Endpoint Descriptor //
    0x07,                       //the size of this descriptor //
    USB_DESCRIPTOR_ENDPOINT,    //Endpoint Descriptor
    _EP02_IN,                   //EndpointAddress
    _INT,                       //Attributes
    0x08,0x00,                  //size (note: 2 bytes)
    0x02,                       //Interval

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 usb_device.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 usb_device.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.

-------------------------------------------------------------------

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:
 * usb_device.h
 *
 * Configuration options are defined in:
 * usb_config.h
 ********************************************************************/
#ifndef __USB_DESCRIPTORS_C
#define __USB_DESCRIPTORS_C

/** INCLUDES *******************************************************/
#include "./USB/usb.h"

//#include "./USB/usb_function_msd.h"
#include "./USB/usb_function_hid.h"
#include "./USB/usb_function_cdc.h"

/** CONSTANTS ******************************************************/
#if defined(__18CXX)
#pragma romdata
#endif

/* Device Descriptor */
ROM USB_DEVICE_DESCRIPTOR device_dsc=
{
    0x12,    // Size of this descriptor in bytes
    USB_DESCRIPTOR_DEVICE,                // DEVICE descriptor type
    0x0200,                 // USB Spec Release Number in BCD format
    //0xEF,					// Class Code "MISC_DEVICE" (ex: uses IAD descriptor)
    0x00,
    //0x02,                   // Subclass code
    0x00,
    //0x01,                   // Protocol code
    0x00,
    USB_EP0_BUFF_SIZE,      // Max packet size for EP0, see usb_config.h
    0x04D8,                 // Vendor ID
    0x0057,                 // Product ID
    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 */
ROM BYTE configDescriptor1[]={
    /* Configuration Descriptor */
    9,    // Size of this descriptor in bytes
    USB_DESCRIPTOR_CONFIGURATION,                // CONFIGURATION descriptor type
    107, 0,                  // Total length of data for this cfg
    3,                      // Number of interfaces in this cfg
    1,                      // Index value of this configuration
    2,                      // Configuration string index
    _DEFAULT | _SELF | _RWU,       // Attributes, see usb_device.h
    50,                     // Max power consumption (2X mA)

/* Interface Descriptor */
    0x09,//sizeof(USB_INTF_DSC),   // Size of this descriptor in bytes
    USB_DESCRIPTOR_INTERFACE,               // INTERFACE descriptor type
    0,                      // Interface Number
    0,                      // Alternate Setting Number
    2,                      // Number of endpoints in this intf
    HID_INTF,               // Class code
    BOOT_INTF_SUBCLASS,     // Subclass code
    HID_PROTOCOL_KEYBOARD,     // Protocol code
    0,                      // Interface string index

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

    /* Endpoint Descriptor */
    0x07,/*sizeof(USB_EP_DSC)*/
    USB_DESCRIPTOR_ENDPOINT,    //Endpoint Descriptor
    HID_EP | _EP_IN,            //EndpointAddress
    _INTERRUPT,                       //Attributes
    DESC_CONFIG_WORD(9),        //size
    0x01,                        //Interval

    /* Endpoint Descriptor */
    0x07,/*sizeof(USB_EP_DSC)*/
    USB_DESCRIPTOR_ENDPOINT,    //Endpoint Descriptor
    HID_EP | _EP_OUT,            //EndpointAddress
    _INTERRUPT,                       //Attributes
    //DESC_CONFIG_WORD(1),        //size
    DESC_CONFIG_WORD(1),        //size
    0x01                        //Interval
    ,
    
//---------------IAD Descriptor------------------------------------
    /* Interface Association Descriptor: CDC Function 1*/ 
	0x08,             //sizeof(USB_IAD_DSC), // Size of this descriptor in bytes 
	0x0B,             // Interface assocication descriptor type 
	CDC_COMM_INTF_ID, // The first associated interface 
	2,                // Number of contiguous associated interface 
	COMM_INTF,        // bInterfaceClass of the first interface 
	ABSTRACT_CONTROL_MODEL, // bInterfaceSubclass of the first interface 
	V25TER,           // bInterfaceProtocol of the first interface 
	0,                // Interface string index 						

//---------------CDC Function 1 Descriptors------------------------
							
    /* Interface Descriptor: CDC Function 1, Status (communication) Interface */
    0x09,   //sizeof(USB_INTF_DSC),   // Size of this descriptor in bytes
    USB_DESCRIPTOR_INTERFACE,               // INTERFACE descriptor type
    CDC_COMM_INTF_ID,       // Interface Number
    0,                      // Alternate Setting Number
    1,                      // Number of endpoints in this intf
    COMM_INTF,              // Class code
    ABSTRACT_CONTROL_MODEL, // Subclass code
    V25TER,                 // Protocol code
    0,                      // Interface string index

    /* CDC Class-Specific Descriptors */
    //5 bytes: Header Functional Descriptor
    sizeof(USB_CDC_HEADER_FN_DSC), //Size of this descriptor in bytes (5)
    CS_INTERFACE,               //bDescriptorType (class specific)
    DSC_FN_HEADER,              //bDescriptorSubtype (header functional descriptor)
    0x20, 0x01,                 //bcdCDC (CDC spec version this fw complies with: v1.20 [stored in little endian])

    //4 bytes: Abstract Control Management Functional Descriptor
    sizeof(USB_CDC_ACM_FN_DSC), //Size of this descriptor in bytes (4)
    CS_INTERFACE,               //bDescriptorType (class specific)
    DSC_FN_ACM,                 //bDescriptorSubtype (abstract control management)
    USB_CDC_ACM_FN_DSC_VAL,     //bmCapabilities: (see PSTN120.pdf Table 4)

    //5 bytes: Union Functional Descriptor
    sizeof(USB_CDC_UNION_FN_DSC), //Size of this descriptor in bytes (5)
    CS_INTERFACE,                 //bDescriptorType (class specific)
    DSC_FN_UNION,                 //bDescriptorSubtype (union functional)
    CDC_COMM_INTF_ID,             //bControlInterface: Interface number of the communication class interface (1)
    CDC_DATA_INTF_ID,             //bSubordinateInterface0: Data class interface #2 is subordinate to this interface

    //5 bytes: Call Management Functional Descriptor
    sizeof(USB_CDC_CALL_MGT_FN_DSC), //Size of this descriptor in bytes (5)
    CS_INTERFACE,                    //bDescriptorType (class specific)
    DSC_FN_CALL_MGT,                 //bDescriptorSubtype (call management functional)
    0x00,                            //bmCapabilities: device doesn't handle call management
    CDC_DATA_INTF_ID,                //bDataInterface: Data class interface ID used for the optional call management

    /* Endpoint Descriptor */
    0x07,/*sizeof(USB_EP_DSC)*/
    USB_DESCRIPTOR_ENDPOINT,    //Endpoint Descriptor
    _EP02_IN,                   //EndpointAddress
    _INTERRUPT,                 //Attributes
    CDC_COMM_IN_EP_SIZE,0x00,   //size
    0x02,                       //Interval

    /* Interface Descriptor: CDC Function 1, Data Interface*/
    0x09,//sizeof(USB_INTF_DSC),   // Size of this descriptor in bytes
    USB_DESCRIPTOR_INTERFACE,      // INTERFACE descriptor type
    CDC_DATA_INTF_ID,       // Interface Number
    0,                      // Alternate Setting Number
    2,                      // Number of endpoints in this intf
    DATA_INTF,              // Class code
    0,                      // Subclass code
    NO_PROTOCOL,            // Protocol code
    0,                      // Interface string index
    
    /* Endpoint Descriptor */
    //sizeof(USB_EP_DSC),DSC_EP,_EP03_OUT,_BULK,CDC_BULK_OUT_EP_SIZE,0x00,
    0x07,/*sizeof(USB_EP_DSC)*/
    USB_DESCRIPTOR_ENDPOINT,    //Endpoint Descriptor
    _EP03_OUT,            //EndpointAddress
    _BULK,                       //Attributes
    CDC_DATA_OUT_EP_SIZE,0x00,                  //size
    0x00,                       //Interval

    /* Endpoint Descriptor */
    //sizeof(USB_EP_DSC),DSC_EP,_EP03_IN,_BULK,CDC_BULK_IN_EP_SIZE,0x00
    0x07,/*sizeof(USB_EP_DSC)*/
    USB_DESCRIPTOR_ENDPOINT,    //Endpoint Descriptor
    _EP03_IN,            //EndpointAddress
    _BULK,                       //Attributes
    CDC_DATA_IN_EP_SIZE,0x00,                  //size
    0x00                       //Interval
};


//Language code string descriptor
ROM struct{BYTE bLength;BYTE bDscType;WORD string[1];}sd000={
    sizeof(sd000),
    USB_DESCRIPTOR_STRING,
    {0x0409
    }
};
//Manufacturer string descriptor
ROM struct{BYTE bLength;BYTE bDscType;WORD string[25];}sd001={
sizeof(sd001),USB_DESCRIPTOR_STRING,
{'M','i','c','r','o','c','h','i','p',' ',
'T','e','c','h','n','o','l','o','g','y',' ','I','n','c','.'
}};

//Product string descriptor
ROM struct{BYTE bLength;BYTE bDscType;WORD string[28];}sd002={
sizeof(sd002),USB_DESCRIPTOR_STRING,
{'M','i','c','r','o','c','h','i','p',' ','C','o','m','p','o','s','i','t','e',' ','D','e','v','i','c','e'
}};

//Class specific descriptor - HID Keyboard
ROM struct{BYTE report[HID_RPT01_SIZE];}hid_rpt01={
{   0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
    0x09, 0x06,                    // USAGE (Keyboard)
    0xa1, 0x01,                    // COLLECTION (Application)
    0x85, 0x01,  /*   Report ID  */
    0x05, 0x07,                    //   USAGE_PAGE (Keyboard)
    0x19, 0xe0,                    //   USAGE_MINIMUM (Keyboard LeftControl)
    0x29, 0xe7,                    //   USAGE_MAXIMUM (Keyboard Right GUI)
    0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
    0x25, 0x01,                    //   LOGICAL_MAXIMUM (1)
    0x75, 0x01,                    //   REPORT_SIZE (1)
    0x95, 0x08,                    //   REPORT_COUNT (8)
    0x81, 0x02,                    //   INPUT (Data,Var,Abs)
    0x95, 0x01,                    //   REPORT_COUNT (1)
    0x75, 0x08,                    //   REPORT_SIZE (8)
    0x81, 0x03,                    //   INPUT (Cnst,Var,Abs)
    0x95, 0x05,                    //   REPORT_COUNT (5)
    0x75, 0x01,                    //   REPORT_SIZE (1)
    0x05, 0x08,                    //   USAGE_PAGE (LEDs)
    0x19, 0x01,                    //   USAGE_MINIMUM (Num Lock)
    0x29, 0x05,                    //   USAGE_MAXIMUM (Kana)
    0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
    0x95, 0x01,                    //   REPORT_COUNT (1)
    0x75, 0x03,                    //   REPORT_SIZE (3)
    0x91, 0x03,                    //   OUTPUT (Cnst,Var,Abs)
    0x95, 0x06,                    //   REPORT_COUNT (6)
    0x75, 0x08,                    //   REPORT_SIZE (8)
    0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
    0x25, 0x82,                    //   LOGICAL_MAXIMUM (101)
    0x05, 0x07,                    //   USAGE_PAGE (Keyboard)
    0x19, 0x00,                    //   USAGE_MINIMUM (Reserved (no event indicated))
    0x29, 0x82,                    //   USAGE_MAXIMUM (Keyboard Application)
    0x81, 0x00,                    //   INPUT (Data,Ary,Abs)
    0xc0,//}		/*		End Collection						*/

    0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
       0x09, 0x80,                    // USAGE (System Control)
       0xa1, 0x01,                    // COLLECTION (Application)
       0x85, 0x02,  /*   Report ID  */
           0x19, 0x81,                    //   USAGE_MINIMUM (System Sleep)
           0x29, 0x83,                    //   USAGE_MAXIMUM (System Wake Up)
           0x15, 0x00,                    //   LOGICAL_MINIMUM (0)   <---------- Add these three lines
           0x25, 0x01,                    //   LOGICAL_MAXIMUM (1)   <----------
           0x75, 0x01,                    //   REPORT_SIZE (1)       <----------
           0x95, 0x02,                    //   REPORT_COUNT (2)
           0x81, 0x06,                    //   INPUT (Data,Var,Rel)
           0x95, 0x06,                    //   REPORT_COUNT (6)
           0x81, 0x03,                    //   INPUT (Cnst,Var,Abs)
       0xc0}                           // END_COLLECTION

//        0x05, 0x0C, /*		Usage Page (Consumer Devices)		*/
//	0x09, 0x01, /*		Usage (Consumer Control)			*/
//	0xA1, 0x01, /*		Collection (Application)			*/
//	0x85, 0x02,	/*		Report ID=2							*/
//	0x05, 0x0C, /*		Usage Page (Consumer Devices)		*/
//	0x15, 0x00, /*		Logical Minimum (0)					*/
//	0x25, 0x01, /*		Logical Maximum (1)					*/
//	0x75, 0x01, /*		Report Size (1)						*/
//	0x95, 0x07, /*		Report Count (7)					*/
//	0x09, 0xB5, /*		Usage (Scan Next Track)				*/
//	0x09, 0xB6, /*		Usage (Scan Previous Track)			*/
//	0x09, 0xB7, /*		Usage (Stop)						*/
//	0x09, 0xCD, /*		Usage (Play / Pause)				*/
//	0x09, 0xE2, /*		Usage (Mute)						*/
//	0x09, 0xE9, /*		Usage (Volume Up)					*/
//	//0x09, 0xEA, /*		Usage (Volume Down)					*/
//        0x09, 0x30,
//	0x81, 0x02, /*		Input (Data, Variable, Absolute)	*/
//	0x95, 0x01, /*		Report Count (1)					*/
//	0x81, 0x01, /*		Input (Constant)					*/
//	0xC0}		/*		End Collection						*/
};

//Array of configuration descriptors
ROM BYTE *ROM USB_CD_Ptr[]=
{
    (ROM BYTE *ROM)&configDescriptor1
};

//Array of string descriptors
ROM BYTE *ROM USB_SD_Ptr[]=
{
    (ROM BYTE *ROM)&sd000,
    (ROM BYTE *ROM)&sd001,
    (ROM BYTE *ROM)&sd002
};

/** EOF usb_descriptors.c ***************************************************/

#endif

usb_config.c

/********************************************************************
 FileName:     	usb_config.h
 Dependencies: 	Always: GenericTypeDefs.h, usb_device.h
               	Situational: usb_function_hid.h, usb_function_cdc.h, usb_function_msd.h, etc.
 Processor:		PIC18 or PIC24 USB Microcontrollers
 Hardware:		The code is natively intended to be used on the following
 				hardware platforms: PICDEM� FS USB Demo Board, 
 				PIC18F87J50 FS USB Plug-In Module, or
 				Explorer 16 + PIC24 USB PIM.  The firmware may be
 				modified for use on other USB platforms by editing the
 				HardwareProfile.h file.
 Complier:  	Microchip C18 (for PIC18) or C30 (for PIC24)
 Company:		Microchip Technology, Inc.

 Software License Agreement:

 The software supplied herewith by Microchip Technology Incorporated
 (the �Company�) for its PIC� Microcontroller is intended and
 supplied to you, the Company�s customer, for use solely and
 exclusively on Microchip PIC 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.

********************************************************************
 File Description:

 Change History:
  Rev   Date         Description
  1.0   11/19/2004   Initial release
  2.1   02/26/2007   Updated for simplicity and to use common
                     coding style
 *******************************************************************/

/*********************************************************************
 * Descriptor specific type definitions are defined in: usbd.h
 ********************************************************************/

#ifndef USBCFG_H
#define USBCFG_H

/** DEFINITIONS ****************************************************/
#define USB_EP0_BUFF_SIZE		8	// Valid Options: 8, 16, 32, or 64 bytes.
								// Using larger options take more SRAM, but
								// does not provide much advantage in most types
								// of applications.  Exceptions to this, are applications
								// that use EP0 IN or OUT for sending large amounts of
								// application related data.
									
#define USB_MAX_NUM_INT     	3   // For tracking Alternate Setting
#define USB_MAX_EP_NUMBER	    3

//Device descriptor - if these two definitions are not defined then
//  a ROM USB_DEVICE_DESCRIPTOR variable by the exact name of device_dsc
//  must exist.

//#define USB_USER_DEVICE_DESCRIPTOR &device_dsc
//#define USB_USER_DEVICE_DESCRIPTOR_INCLUDE extern ROM USB_DEVICE_DESCRIPTOR device_dsc

//Configuration descriptors - if these two definitions do not exist then
//  a ROM BYTE *ROM variable named exactly USB_CD_Ptr[] must exist.
//#define USB_USER_CONFIG_DESCRIPTOR USB_CD_Ptr
//#define USB_USER_CONFIG_DESCRIPTOR_INCLUDE extern ROM BYTE *ROM USB_CD_Ptr[]

//Make sure only one of the below "#define USB_PING_PONG_MODE"
//is uncommented.
//#define USB_PING_PONG_MODE USB_PING_PONG__NO_PING_PONG
#define USB_PING_PONG_MODE USB_PING_PONG__FULL_PING_PONG
//#define USB_PING_PONG_MODE USB_PING_PONG__EP0_OUT_ONLY
//#define USB_PING_PONG_MODE USB_PING_PONG__ALL_BUT_EP0		//NOTE: This mode is not supported in PIC18F4550 family rev A3 devices

#define USB_POLLING
//#define USB_INTERRUPT

/* Parameter definitions are defined in usb_device.h */
#define USB_PULLUP_OPTION USB_PULLUP_ENABLE
//#define USB_PULLUP_OPTION USB_PULLUP_DISABLED

#define USB_TRANSCEIVER_OPTION USB_INTERNAL_TRANSCEIVER
//External Transceiver support is not available on all product families.  Please
//  refer to the product family datasheet for more information if this feature
//  is available on the target processor.
//#define USB_TRANSCEIVER_OPTION USB_EXTERNAL_TRANSCEIVER

#define USB_SPEED_OPTION USB_FULL_SPEED
//#define USB_SPEED_OPTION USB_LOW_SPEED //(not valid option for PIC24F devices)

//------------------------------------------------------------------------------------------------------------------
//Option to enable auto-arming of the status stage of control transfers, if no
//"progress" has been made for the USB_STATUS_STAGE_TIMEOUT value.
//If progress is made (any successful transactions completing on EP0 IN or OUT)
//the timeout counter gets reset to the USB_STATUS_STAGE_TIMEOUT value.
//
//During normal control transfer processing, the USB stack or the application 
//firmware will call USBCtrlEPAllowStatusStage() as soon as the firmware is finished
//processing the control transfer.  Therefore, the status stage completes as 
//quickly as is physically possible.  The USB_ENABLE_STATUS_STAGE_TIMEOUTS 
//feature, and the USB_STATUS_STAGE_TIMEOUT value are only relevant, when:
//1.  The application uses the USBDeferStatusStage() API function, but never calls
//      USBCtrlEPAllowStatusStage().  Or:
//2.  The application uses host to device (OUT) control transfers with data stage,
//      and some abnormal error occurs, where the host might try to abort the control
//      transfer, before it has sent all of the data it claimed it was going to send.
//
//If the application firmware never uses the USBDeferStatusStage() API function,
//and it never uses host to device control transfers with data stage, then
//it is not required to enable the USB_ENABLE_STATUS_STAGE_TIMEOUTS feature.

#define USB_ENABLE_STATUS_STAGE_TIMEOUTS    //Comment this out to disable this feature.  

//Section 9.2.6 of the USB 2.0 specifications indicate that:
//1.  Control transfers with no data stage: Status stage must complete within 
//      50ms of the start of the control transfer.
//2.  Control transfers with (IN) data stage: Status stage must complete within 
//      50ms of sending the last IN data packet in fullfilment of the data stage.
//3.  Control transfers with (OUT) data stage: No specific status stage timing
//      requirement.  However, the total time of the entire control transfer (ex:
//      including the OUT data stage and IN status stage) must not exceed 5 seconds.
//
//Therefore, if the USB_ENABLE_STATUS_STAGE_TIMEOUTS feature is used, it is suggested
//to set the USB_STATUS_STAGE_TIMEOUT value to timeout in less than 50ms.  If the
//USB_ENABLE_STATUS_STAGE_TIMEOUTS feature is not enabled, then the USB_STATUS_STAGE_TIMEOUT
//parameter is not relevant.

#define USB_STATUS_STAGE_TIMEOUT     (BYTE)45   //Approximate timeout in milliseconds, except when
                                                //USB_POLLING mode is used, and USBDeviceTasks() is called at < 1kHz
                                                //In this special case, the timeout becomes approximately:
//Timeout(in milliseconds) = ((1000 * (USB_STATUS_STAGE_TIMEOUT - 1)) / (USBDeviceTasks() polling frequency in Hz))
//------------------------------------------------------------------------------------------------------------------

#define USB_SUPPORT_DEVICE

#define USB_NUM_STRING_DESCRIPTORS 3

//#define USB_INTERRUPT_LEGACY_CALLBACKS
//#define USB_ENABLE_ALL_HANDLERS
//#define USB_ENABLE_SUSPEND_HANDLER
//#define USB_ENABLE_WAKEUP_FROM_SUSPEND_HANDLER
//#define USB_ENABLE_SOF_HANDLER
//#define USB_ENABLE_ERROR_HANDLER
//#define USB_ENABLE_OTHER_REQUEST_HANDLER
//#define USB_ENABLE_SET_DESCRIPTOR_HANDLER
//#define USB_ENABLE_INIT_EP_HANDLER
//#define USB_ENABLE_EP0_DATA_HANDLER
//#define USB_ENABLE_TRANSFER_COMPLETE_HANDLER
/** DEVICE CLASS USAGE *********************************************/
//#define USB_USE_MSD
#define USB_USE_HID
#define USB_USE_CDC

/** ENDPOINTS ALLOCATION *******************************************/

/* MSD */
/*
#define MSD_INTF_ID             0x00
#define MSD_IN_EP_SIZE          64
#define MSD_OUT_EP_SIZE         64
#define MAX_LUN                 0   //base 0 number.  0 == 1 LUN
#define MSD_DATA_IN_EP          1
#define MSD_DATA_OUT_EP         1
#define MSD_BUFFER_ADDRESS      0x600
*/

#define HID_INTF_ID             0x00
#define HID_EP                  1
#define HID_INT_OUT_EP_SIZE     1
#define HID_INT_IN_EP_SIZE      9
#define HID_NUM_OF_DSC          1
#define HID_RPT01_SIZE          92
//#define USER_GET_REPORT_HANDLER USBHIDCBGetReportHandler
#define USER_SET_REPORT_HANDLER USBHIDCBSetReportHandler

/* CDC */
#define CDC_COMM_INTF_ID        0x01
#define CDC_COMM_EP              2
#define CDC_COMM_IN_EP_SIZE      10

#define CDC_DATA_INTF_ID        0x02
#define CDC_DATA_EP             3
#define CDC_DATA_OUT_EP_SIZE    64
#define CDC_DATA_IN_EP_SIZE     64

#define USB_CDC_SET_LINE_CODING_HANDLER mySetLineCodingHandler
//#define USB_CDC_SUPPORT_HARDWARE_FLOW_CONTROL

//#define USB_CDC_SUPPORT_ABSTRACT_CONTROL_MANAGEMENT_CAPABILITIES_D2 //Send_Break command
#define USB_CDC_SUPPORT_ABSTRACT_CONTROL_MANAGEMENT_CAPABILITIES_D1 //Set_Line_Coding, Set_Control_Line_State, Get_Line_Coding, and Serial_State commands

/** DEFINITIONS ****************************************************/

#endif //USBCFG_H

[tmcone]

Çok işlevli bir USB HID aygıtı yapmak için iki yol mevcut:

1. Birden fazla "Collection" tanımlayarak bunların her birine farklı "report ID" verilir. Veri gönderilirken veya alırken önce kullanılacak işlevin report ID si belirtilir. Bu durumda sadece bir interface yeterlidir. Endpoint ortak kullanıldığından bantgenişliği paylaşılır.
2. Birden fazla interface tanımlanarak her birinde farklı işlevler ve endpoint tanımlanır.  Bu şekilde yapılırsa işlevin bantgenişliğinde azalma olmaz. PC programında VID&PID ile eşleşen cihazın interface leri diziye aktarılarak bunlar üzerinden her bir endpoint e ulaşmak mümkün.

Klavyedeki ledlerin durumu report descriptor daki "output" tipi ile gönderilebilir. Bunun için out endpoint tanımlı olmasına gerek yok. Kontrol transferindeki Set_Report fonksiyonu kullanılabilir.

[esensoy]

PC programında VID PID ile eşleşen cihazın interfaceleri diziye nasıl aktarılır?
(Yani diziye nasıl aktarılır derken bu interfaceler nasıl listelenir diye soruyorum)

[hasankara]

yakın zamanda aynı vid pid olan birden fazla aygıta aynı anda işlem yaptırmakla ilgilendim. hid aygıtları için yazılmış bir cs kütüphanesi edindim tamda istediğim işleri karşıladı. kendisi tek satırda aynı vid pid aygıtları tarayıp listeliyor bende tüm listedeki aygıtlara iş yaptırıyorum. işini görecek ise paylaşmamda bir problem yok.

[esensoy]

Ise yarar tabi,paylasirsaniz sevinirim