xzycq_weilian.cpp

pci的windows系统驱动源码

// weilian.cpp : Defines the entry point for the DLL application.
//

#include "stdafx.h"
#include "weilian.h"
#include "stdlib.h"
#include "weilian_lib.h"

#include <conio.h>
#include "WEILIAN_lib.h"

#include "../../include/windrvr.h"
#ifdef _USE_SPECIFIC_KERNEL_DRIVER_
    #undef WD_Open
    #define WD_Open WD_OpenKernelHandle
    #if defined(UNIX)
        #undef WD_FUNCTION
        #define WD_FUNCTION(wFuncNum,h,pParam,dwSize,fWait) ((ULONG) ioctl((int)(h), wFuncNum, pParam))
    #endif
#endif

typedef struct WEILIAN_STRUCT
{
    HANDLE              hWD;
    HANDLE              hEvent;
    WD_USB_DEVICE_INFO  deviceInfo;
    DWORD               hDevice;
} WEILIAN_STRUCT;
WEILIAN_HANDLE WEILIAN_LocateAndOpenDevice(BOOL fUseDefault);
BOOL USB_Get_WD_handle(HANDLE *phWD);

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    switch (ul_reason_for_call)
	{
		case DLL_PROCESS_ATTACH:
		case DLL_THREAD_ATTACH:
		case DLL_THREAD_DETACH:
		case DLL_PROCESS_DETACH:
			break;
    }
    return TRUE;
}

WEILIAN_API WORD ReadData(WEILIAN_HANDLE hUsbDevice,WORD* pRdataAddr)
{
	DWORD dwBytesTransferred;
	int  dwSize,ii,xscan;
	dwSize=1024;
	
	BYTE pBuffer[1024];   
   
   if(hUsbDevice!=NULL)
   {
    // xscan=100;
	   for(xscan=0;xscan<240;xscan++)
	   {
	     
	      dwBytesTransferred = WEILIAN_ReadPipe82(hUsbDevice,  pBuffer , dwSize);
          if (dwBytesTransferred==0xffffffff) return 2;
		   
          for(ii=0;ii<319;ii++)
		    pRdataAddr[xscan*319+ii]=pBuffer[2*ii+1]*256+pBuffer[2*ii];
		 		  
	   }
      return 0;
   }
    return 1;
}
WEILIAN_API WEILIAN_HANDLE OpenDevice(void)
{
   // UINT cmd;
    HANDLE hWD;
   // DWORD dwUniqueID;
    DWORD dwAction = 0;
    BOOL fRegisteredEvent = FALSE;
    WEILIAN_HANDLE hWEILIAN = NULL;
	if (!USB_Get_WD_handle(&hWD)) 
        return NULL;
	WD_Close (hWD);

	hWEILIAN = WEILIAN_LocateAndOpenDevice(TRUE);
	return hWEILIAN;

}
WEILIAN_API   CloseDevice(WEILIAN_HANDLE hUsbDevice)
{
	WEILIAN_Close(hUsbDevice);
	hUsbDevice=NULL;
	 
}
WEILIAN_API BOOL WriteData(WEILIAN_HANDLE hUsbDevice,WORD* pWdataAddr,WORD Length)
{
   // WORD* OutBuffer;
    PVOID pBuffer;
    DWORD dwBytesTransferred;
    pBuffer=pWdataAddr;
	if(hUsbDevice!=NULL){
      dwBytesTransferred = WEILIAN_WritePipe01(hUsbDevice, pBuffer, Length);
	  if (dwBytesTransferred==0xffffffff){
               
			   MessageBox(NULL,"Error on transfer!","Write data",MB_OK);
        return FALSE;
	  }
      return TRUE;
	}
	MessageBox(NULL,"Please Open Devcie first!","Write data",MB_OK);
	return FALSE;
}
WEILIAN_API double GrayToTemprature(WORD GrayData,DEVICE_ENVIROMENT_PARAM const* Enviroment_Param)
{
	double TempratureData;
    TempratureData=GrayData*0.2+120;
	return TempratureData;
}

//
BOOL USB_Get_WD_handle(HANDLE *phWD)
{
    WD_VERSION ver;

    *phWD = INVALID_HANDLE_VALUE;
    *phWD = WD_Open();

    // Check whether handle is valid and version OK
    if (*phWD==INVALID_HANDLE_VALUE) 
    {
        
        return FALSE;
    }

    BZERO(ver);
    WD_Version(*phWD, &ver);
    if (ver.dwVer<WD_VER) 
    {
        
        WD_Close (*phWD);
        *phWD = INVALID_HANDLE_VALUE;
        return FALSE;
    }

    return TRUE;
}

WEILIAN_HANDLE WEILIAN_LocateAndOpenDevice(BOOL fUseDefault)
{
    WEILIAN_HANDLE hWEILIAN;
    DWORD uniqueId = 0, configNum = 0, dwInterface = 0, dwAlternate = 0;
    WD_USB_SCAN_DEVICES usbScan;
    WD_USB_CONFIGURATION config;
    HANDLE hWD;
    DWORD scanIndex;

    WEILIAN_RegisterWinDriver();

    if (!USB_Get_WD_handle(&hWD))
        return NULL;

    BZERO(usbScan);
    if (fUseDefault)
    {
        usbScan.searchId.dwVendorId = WEILIAN_DEFAULT_VENDOR_ID;
        usbScan.searchId.dwProductId = WEILIAN_DEFAULT_PRODUCT_ID;
    }

    WD_UsbScanDevice(hWD, &usbScan);
    if (!usbScan.dwDevices)
    {
     //   printf ("No deviced found\n");
		MessageBox(NULL,"No device found!","Scan device",MB_OK);

        WD_Close(hWD);
        return NULL;
    }
    if (fUseDefault)
    {
        for (scanIndex=0; scanIndex<usbScan.dwDevices; scanIndex++)
        {
            if (usbScan.deviceGeneralInfo[scanIndex].dwInterfaceNum==WEILIAN_DEFAULT_SCAN_INTERFACE)
            {
                uniqueId = usbScan.uniqueId[scanIndex];
                break;
            }
        }
        if (!uniqueId)
        {
        //    printf ("Could not find the device interface.\n");
			MessageBox(NULL,"Could not find the device interface!",
				"Device Interface",MB_OK);
            WD_Close(hWD);
            return NULL;
        }
        configNum = WEILIAN_DEFAULT_CONFIG;
        dwInterface = WEILIAN_DEFAULT_INTERFACE;
        dwAlternate = WEILIAN_DEFAULT_ALTERNATE;
    }
    else
    {
      
        if (!uniqueId)
        {
         //   printf ("Unique ID 0 is not valid\n");
			MessageBox(NULL,"Unique ID 0 is not valid!","Unique ID",MB_OK);
            WD_Close(hWD);
            return NULL;
        }
        for (scanIndex=0; scanIndex<usbScan.dwDevices; scanIndex++)
        {
            if (usbScan.uniqueId[scanIndex]==uniqueId)
                break;
        }
        if (scanIndex==usbScan.dwDevices)
        {
           
			MessageBox(NULL,"Unique ID was not found!","Find Unique ID",MB_OK);
            WD_Close(hWD);
            return NULL;
        }
        configNum = 0;
        if (usbScan.deviceGeneralInfo[scanIndex].dwConfigurationsNum>1)
        {
            
           configNum=usbScan.deviceGeneralInfo[scanIndex].dwConfigurationsNum - 1;
            
        }

        BZERO(config);
        config.uniqueId = uniqueId;
        config.dwConfigurationIndex = configNum;
        WD_UsbGetConfiguration(hWD, &config);
        if (config.dwInterfaceAlternatives==0)
        {
          //  printf ("No interfaces found\n");

            WD_Close(hWD);
            return NULL;
        }
        if (config.dwInterfaceAlternatives==1)
        {
            dwInterface = config.Interface[0].Interface.dwNumber;
            dwAlternate = config.Interface[0].Interface.dwAlternateSetting;
        }
        else
        {
         
            if (usbScan.deviceGeneralInfo[scanIndex].dwInterfaceNum!=WD_SINGLE_INTERFACE)
                dwInterface = usbScan.deviceGeneralInfo[scanIndex].dwInterfaceNum;
            else
            {
             
            }
         
        }
    }


    hWEILIAN = WEILIAN_Open (uniqueId, configNum, dwInterface, dwAlternate);
    if (!hWEILIAN)
    {
       
		MessageBox(NULL,"Device not Open!","Open device",MB_OK);
        WD_Close(hWD);
        return NULL;
    }

    WD_Close(hWD);
    return hWEILIAN;
}

void WEILIAN_RegisterWinDriver()
{
    HANDLE hWD;
    WD_LICENSE lic;

    hWD = WD_Open();
    if (hWD!=INVALID_HANDLE_VALUE)
    {
         strcpy(lic.cLicense, "68C9BECCEDE89D50638A21ECD7B87900.Warlock//SSG");
         WD_License(hWD, &lic);
         WD_Close(hWD);
    }
}

WEILIAN_HANDLE WEILIAN_Open(DWORD uniqueId, DWORD configIndex, DWORD dwInterface, DWORD dwAlternate)
{
    WEILIAN_HANDLE hWEILIAN = (WEILIAN_HANDLE) malloc (sizeof (WEILIAN_STRUCT));

    WD_VERSION ver;
    WD_USB_DEVICE_REGISTER devReg;

    BZERO(*hWEILIAN);

    WEILIAN_RegisterWinDriver();

    hWEILIAN->hDevice = 0;
    hWEILIAN->hWD = WD_Open();

    // Verify that the handle is valid and that the version number is correct
    if (hWEILIAN->hWD==INVALID_HANDLE_VALUE)
    {
       // sprintf (WEILIAN_ErrorString, "Failed opening WinDriver device\n");
        free(hWEILIAN);
        return NULL;
    }

    BZERO(ver);
    WD_Version(hWEILIAN->hWD, &ver);
    if (ver.dwVer<WD_VER)
    {
       // sprintf (WEILIAN_ErrorString, "Incorrect WinDriver version\n");
        WD_Close(hWEILIAN->hWD);
        free(hWEILIAN);
        return NULL;
    }

    BZERO(devReg);
    devReg.uniqueId = uniqueId;
    devReg.dwConfigurationIndex = configIndex;
    devReg.dwInterfaceNum = dwInterface;
    devReg.dwInterfaceAlternate = dwAlternate;
    WD_UsbDeviceRegister(hWEILIAN->hWD, &devReg);
    if (!devReg.hDevice)
    {
      //  sprintf (WEILIAN_ErrorString, "Could not open device\n");
        WD_Close(hWEILIAN->hWD);
        free(hWEILIAN);
        return NULL;
    }
    hWEILIAN->hDevice = devReg.hDevice;
    hWEILIAN->deviceInfo = devReg.Device;

    // Open finished OK
    return hWEILIAN;
}
DWORD WEILIAN_ReadPipe82(WEILIAN_HANDLE hWEILIAN, PVOID pBuffer, DWORD dwSize)
{
    WD_USB_TRANSFER transfer;

    BZERO(transfer);
    transfer.dwPipe = 0x82;
    transfer.dwBytes = dwSize;
    transfer.fRead = TRUE;
    transfer.pBuffer = pBuffer;
    transfer.hDevice = hWEILIAN->hDevice;
    transfer.dwTimeout = 300000;
    WD_UsbTransfer(hWEILIAN->hWD, &transfer);

    if (transfer.fOK)
        return transfer.dwBytesTransfered;
    return 0xffffffff;
}
void WEILIAN_Close(WEILIAN_HANDLE hWEILIAN)
{
    WD_USB_DEVICE_REGISTER devReg;

    BZERO(devReg);
    devReg.hDevice = hWEILIAN->hDevice;
    WD_UsbDeviceUnregister(hWEILIAN->hWD, &devReg);

    // close WinDriver
    WD_Close(hWEILIAN->hWD);
    free (hWEILIAN);
}
DWORD WEILIAN_WritePipe01(WEILIAN_HANDLE hWEILIAN, PVOID pBuffer, DWORD dwSize)
{
    WD_USB_TRANSFER transfer;

    BZERO(transfer);
    transfer.dwPipe = 0x01;
    transfer.dwBytes = dwSize;
    transfer.pBuffer = pBuffer;
    transfer.hDevice = hWEILIAN->hDevice;
    transfer.dwTimeout = 10000;
    WD_UsbTransfer(hWEILIAN->hWD, &transfer);

    if (transfer.fOK)
        return transfer.dwBytesTransfered;
    return 0xffffffff;
}