新手上路：请教usb开发的入门级问题

 请教各位侠哥侠姐，应用程序如何读写USB设备的数据？
 是Createfile(...),Readfile(...),WriteFile(...)吗？
 

然也 :cool:

honesttree兄，多谢你不吝赐教，那么createfile的第一个参数对于特定的设备该如何填写？

看看《USB大全》，很详细啊

也可察看帮助嘛。

也可查看帮助嘛，MSDN

#include \"stdafx.h\"

#include <windows.h>
#include <stdio.h>
#include <winioctl.h>
#include <basetyps.h>
#include <usbdi.h>

// Microsoft released two setupapi.h files: one in Win98 DDK and
// the other one in VC/C++. We shall use the one in Win98 DDK.
// In oder to resolve this conflict, we have copied setupapi.h
// and setupapi.lib from Win98 DDK to current working directory.
#include \"setupapi.h\"

#include \"ioctl.h\"
#include \"GUIDUDK.h\"

// Generated from the GUID registered by the driver itself
char completeDeviceName[256] = \"\";


HANDLE
OpenOneDevice (
    IN HDEVINFO                  HardwareDeviceInfo,
    IN PSP_DEVICE_INTERFACE_DATA DeviceInfoData,
IN char* devName
    )
/*++
Routine Description:

    Given the HardwareDeviceInfo, representing a handle to the plug and
    play information, and deviceInfoData, representing a specific usb device,
    open that device and fill in all the relevant information in the given
    USB_DEVICE_DESCRIPTOR structure.

Arguments:

    HardwareDeviceInfo:  handle to info obtained from Pnp mgr via SetupDiGetClassDevs()
    DeviceInfoData:      ptr to info obtained via SetupDiEnumInterfaceDevice()

Return Value:

    return HANDLE if the open and initialization was successfull,
else INVLAID_HANDLE_VALUE.

--*/
{
    PSP_INTERFACE_DEVICE_DETAIL_DATA     functionClassDeviceData = NULL;
    ULONG                                predictedLength = 0;
    ULONG                                requiredLength = 0;
HANDLE hOut = INVALID_HANDLE_VALUE;

    //
    // allocate a function class device data structure to receive the
    // goods about this particular device.
    //
    SetupDiGetInterfaceDeviceDetail
(
HardwareDeviceInfo,
DeviceInfoData,
NULL, // Probing so no output buffer yet
0, // Probing so output buffer length of zero
&requiredLength,
NULL // Not interested in the specific dev-node
);

    predictedLength = requiredLength;

    functionClassDeviceData = (PSP_INTERFACE_DEVICE_DETAIL_DATA)malloc (predictedLength);
    functionClassDeviceData->cbSize = sizeof (SP_INTERFACE_DEVICE_DETAIL_DATA);

    //
    // Retrieve the information from Plug and Play.
    //
    if (!SetupDiGetInterfaceDeviceDetail (
               HardwareDeviceInfo,
               DeviceInfoData,
               functionClassDeviceData,
               predictedLength,
               &requiredLength,
               NULL))
{
        return INVALID_HANDLE_VALUE;
    }

strcpy(devName,functionClassDeviceData->DevicePath);

    hOut = CreateFile (
               functionClassDeviceData->DevicePath,
               GENERIC_READ | GENERIC_WRITE,
               FILE_SHARE_READ | FILE_SHARE_WRITE,
               NULL, // No SECURITY_ATTRIBUTES structure
               OPEN_EXISTING, // No special create flags
               0, // No special attributes
               NULL); // No template file

    if (INVALID_HANDLE_VALUE == hOut)
{
    }

free(functionClassDeviceData);

return hOut;
}

HANDLE
OpenUsbDevice(LPGUID pGuid, char *outNameBuf)
/*++
Routine Description:

   Do the required PnP things in order to find
   the next available proper device in the system at this time.

Arguments:

    pGuid:      ptr to GUID registered by the driver itself
    outNameBuf: the generated name for this device

Return Value:

    return HANDLE if the open and initialization was successful,
else INVLAID_HANDLE_VALUE.
--*/
{
ULONG NumberDevices;
HANDLE hOut = INVALID_HANDLE_VALUE;
HDEVINFO                 hardwareDeviceInfo;
SP_DEVICE_INTERFACE_DATA deviceInfoData;
ULONG                    i;
BOOLEAN                  done;
PUSB_DEVICE_DESCRIPTOR   usbDeviceInst;
PUSB_DEVICE_DESCRIPTOR* UsbDevices = &usbDeviceInst;

*UsbDevices = NULL;
NumberDevices = 0;

//
// Open a handle to the plug and play dev node.
// SetupDiGetClassDevs() returns a device information set that contains info on all
// installed devices of a specified class.
//
hardwareDeviceInfo = SetupDiGetClassDevs(
                           pGuid,
                           NULL, // Define no enumerator (global)
                           NULL, // Define no
                           (DIGCF_PRESENT | // Only Devices present
                           DIGCF_INTERFACEDEVICE)); // Function class devices.

//
// Take a wild guess at the number of devices we have;
// Be prepared to realloc and retry if there are more than we guessed
//
NumberDevices = 4;
done = FALSE;
deviceInfoData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);

i = 0;
while (!done)
{
NumberDevices *= 2;

if (*UsbDevices)
{
*UsbDevices = (PUSB_DEVICE_DESCRIPTOR)realloc(*UsbDevices, (NumberDevices * sizeof(USB_DEVICE_DESCRIPTOR)));
}
else
{
*UsbDevices = (PUSB_DEVICE_DESCRIPTOR)calloc(NumberDevices, sizeof(USB_DEVICE_DESCRIPTOR));
}

if (NULL == *UsbDevices)
{
// SetupDiDestroyDeviceInfoList destroys a device information set
// and frees all associated memory.

SetupDiDestroyDeviceInfoList(hardwareDeviceInfo);
return INVALID_HANDLE_VALUE;
}

usbDeviceInst = *UsbDevices + i;

for (; i < NumberDevices; i++)
{
// SetupDiEnumDeviceInterfaces() returns information about device interfaces
// exposed by one or more devices. Each call returns information about one interface;
// the routine can be called repeatedly to get information about several interfaces
// exposed by one or more devices.

if (SetupDiEnumDeviceInterfaces(hardwareDeviceInfo,
                    0, // We don\'t care about specific PDOs
pGuid,
                    i,
                    &deviceInfoData))
{
           hOut = OpenOneDevice (hardwareDeviceInfo, &deviceInfoData, outNameBuf);
if (hOut != INVALID_HANDLE_VALUE)
{
done = TRUE;
break;
}
}
else
{
if (ERROR_NO_MORE_ITEMS == GetLastError())
{
done = TRUE;
break;
}
}
}
}

NumberDevices = i;

// SetupDiDestroyDeviceInfoList() destroys a device information set
// and frees all associated memory.

SetupDiDestroyDeviceInfoList(hardwareDeviceInfo);

if (*UsbDevices)
free(*UsbDevices);

return hOut;
}

BOOL
GetUsbDeviceFileName(LPGUID pGuid, char *outNameBuf)
/*++
Routine Description:

    Given a ptr to a driver-registered GUID, give us a string with the device name
    that can be used in a CreateFile() call.
    Actually briefly opens and closes the device and sets outBuf if successfull;
    returns FALSE if not

Arguments:

    pGuid:      ptr to GUID registered by the driver itself
    outNameBuf: the generated zero-terminated name for this device

Return Value:

    TRUE on success else FALSE

--*/
{
HANDLE hDev = OpenUsbDevice(pGuid, outNameBuf);
if (hDev != INVALID_HANDLE_VALUE)
{
CloseHandle(hDev);
return TRUE;
}
return FALSE;
}

HANDLE
open_dev()
/*++
Routine Description:

    Called by dumpUsbConfig() to open an instance of our device

Arguments:

    None

Return Value:

    Device handle on success else NULL

--*/
{

HANDLE hDEV = OpenUsbDevice((LPGUID)&GUID_NETAC_UDK2000, completeDeviceName);

return hDEV;
}

HANDLE
open_file(char *filename)
/*++
Routine Description:

    Called by main() to open an instance of our device after obtaining its name

Arguments:

    None

Return Value:

    Device handle on success else NULL

--*/
{
HANDLE h;

if (!GetUsbDeviceFileName(
(LPGUID) &GUID_NETAC_UDK2000,
completeDeviceName))
{
return  INVALID_HANDLE_VALUE;
}

    strcat(completeDeviceName, \"\\\\\");

    strcat(completeDeviceName, filename);

h = CreateFile(completeDeviceName,
GENERIC_WRITE | GENERIC_READ,
FILE_SHARE_WRITE | FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
0,
NULL);

return h;
}