deriveusb.cpp

能够读写USB设备,读的时候调用函数DeviceWrite(),写USB设备时候调用DeviceRead()

#include "stdafx.h"
#include ".\deriveusb.h"
#include "F32x_BulkFileTransferFunctions.h"//***************该头文件中定义了CUsbIF类对象

//volatile BOOL bThreadControl;
CEvent threadStart;
CEvent threadEnd;

DEFINE_GUID(GUID_INTERFACE_SILABS_BULK, 
0x37538c66, 0x9584, 0x42d3, 0x96, 0x32, 0xeb, 0xad, 0xa, 0x23, 0xd, 0x13);

#define SILABS_BULK_WRITEPIPE	"PIPE01"
#define SILABS_BULK_READPIPE		"PIPE00"

CDeriveUSB::CDeriveUSB(void)
{
	
}

CDeriveUSB::~CDeriveUSB(void)
{
}



BOOL CDeriveUSB::OnInit()
{
   CComboBox*	pDevList	= (CComboBox*)GetDlgItem(IDC_DEVICE_SELECT);
   CComboBox*	pDevList	=  &m_ComboBox;
	
	sgCUsbIF.SetGUID(GUID_INTERFACE_SILABS_BULK);                                //************
    // Get devices, init. combo box with their names
	FillDeviceList();
	
	if (pDevList)
	{
		// Open selected device.
		if (pDevList->GetCurSel() >= 0)
		{
			F32x_STATUS status = F32x_Open(pDevList->GetCurSel(), &m_hUSBDevice);//--------------------------------------------------

			// Open selected file.
			if (status == F32x_SUCCESS)
			{
				// Write file to device in MAX_PACKET_SIZE-byte chunks.
				// Get the write handle
				m_hUSBWrite = sgCUsbIF.OpenUSBfile(SILABS_BULK_WRITEPIPE);       //************

				if (m_hUSBWrite == INVALID_HANDLE_VALUE)
				{
					CString sMessage;
					sMessage.Format("Error opening Write device: %s\n\nApplication is aborting.\nReset hardware and try again.",SILABS_BULK_WRITEPIPE);
					AfxMessageBox(sMessage,MB_OK|MB_ICONEXCLAMATION);
				}

				// Get the read handle
				m_hUSBRead = sgCUsbIF.OpenUSBfile(SILABS_BULK_READPIPE);        //*************

				if (m_hUSBRead == INVALID_HANDLE_VALUE)
				{
					CString sMessage;
					sMessage.Format("Error opening Read device: %s\n\nApplication is aborting.\nReset hardware and try again.",SILABS_BULK_READPIPE);
					AfxMessageBox(sMessage,MB_OK|MB_ICONEXCLAMATION);
				}
			}
		}
	}

	//SetTimer(1,1000,NULL);

	bRun = FALSE;

	return TRUE;  // return TRUE  unless you set the focus to a control
}



void CDeriveUSB::UpdateDeviceList() 
{
	FillDeviceList();
}


void CDeriveUSB::FillDeviceList()
{
	F32x_DEVICE_STRING	devStr;
	DWORD				dwNumDevices	= 0;
	//CComboBox*			pDevList		= (CComboBox*)GetDlgItem(IDC_DEVICE_SELECT);
	  CComboBox*	pDevList	=  &m_ComboBox;
	

	if (pDevList)
	{
		int numDevs = pDevList->GetCount();

		for (int i = 0; i < numDevs; i++)
		{
			pDevList->DeleteString(0);
		}

	
		//---------------------------------------------------------------------
		F32x_STATUS status = F32x_GetNumDevices(&dwNumDevices);

		if (status == F32x_SUCCESS)
		{
			for (DWORD d = 0; d < dwNumDevices; d++)
			{
				status = F32x_GetProductString(d, devStr, F32x_RETURN_SERIAL_NUMBER);

				if (status == F32x_SUCCESS)
				{
					if (pDevList)				// Fill device list
						pDevList->AddString(devStr);
				}
			}
		}

		pDevList->SetCurSel(0);

		//---------------------------------------------------------------------
	}
}





//读取USB数据
BOOL CDeriveUSB::DeviceRead(BYTE* buffer, DWORD dwSize, DWORD* lpdwBytesRead, DWORD dwTimeout)
{
	F32x_STATUS	status			= F32x_SUCCESS;

	status = F32x_Read(m_hUSBRead, buffer, dwSize, lpdwBytesRead);

	return (status == F32x_SUCCESS);
}

//写USB数据
BOOL CDeriveUSB::DeviceWrite(BYTE* buffer, DWORD dwSize, DWORD* lpdwBytesWritten, DWORD dwTimeout)
{
	F32x_STATUS	status	= F32x_SUCCESS;

	status = F32x_Write(m_hUSBWrite, buffer, dwSize, lpdwBytesWritten);

	return (status == F32x_SUCCESS);
}





//*********************************以下全部为为全局函数************************************
//------------------------------------------------------------------------
// F32x_GetNumDevices()
//
// Determine number of Silabs devices connected to the system from the
// registry.
//------------------------------------------------------------------------
F32x_STATUS 
F32x_GetNumDevices(LPDWORD lpdwNumDevices)
{
	F32x_STATUS	status = F32x_DEVICE_NOT_FOUND;

	// Validate parameter
	if (!ValidParam(lpdwNumDevices))
	{
		return F32x_INVALID_PARAMETER;
	}

	// Must set the GUID for functions that access the registry.
	sgCUsbIF.SetGUID(GUID_INTERFACE_SILABS_BULK);
	*lpdwNumDevices = sgCUsbIF.GetNumDevices();

	if (*lpdwNumDevices > 0)
	{
		status = F32x_SUCCESS;
	}

	return status;
}


//------------------------------------------------------------------------
// F32x_GetProductString()
//
// Find the product string of a device by index in the registry.
//------------------------------------------------------------------------
F32x_STATUS 
F32x_GetProductString(DWORD dwDeviceNum, LPVOID lpvDeviceString, DWORD dwFlags)
{
	F32x_STATUS			status	= F32x_DEVICE_NOT_FOUND;
	CDeviceListEntry	dev;

	// Validate parameter
	if (!ValidParam(lpvDeviceString))
	{
		return F32x_INVALID_PARAMETER;
	}

	// Must set the GUID for functions that access the registry.
	sgCUsbIF.SetGUID(GUID_INTERFACE_SILABS_BULK);
	sgCUsbIF.GetDeviceStrings(dwDeviceNum, dev);

	switch (dwFlags)
	{
		case F32x_RETURN_SERIAL_NUMBER:
				if (dev.m_serialnumber.length() > 0)
				{
					strcpy((char*)lpvDeviceString, dev.m_serialnumber.c_str());
					status = F32x_SUCCESS;
				}
				break;
		case F32x_RETURN_DESCRIPTION:
				if (dev.m_friendlyname.length() > 0)
				{
					strcpy((char*)lpvDeviceString, dev.m_friendlyname.c_str());
					status = F32x_SUCCESS;
				}
				break;
		default:
				break;
    }

	return status;
}


//------------------------------------------------------------------------
// F32x_Open()
//
// Open a file handle to access a Silabs device by index number.  The open
// routine determines the device's full name and uses it to open the handle.
//------------------------------------------------------------------------
F32x_STATUS 
F32x_Open(DWORD dwDevice, HANDLE* cyHandle)
{
	F32x_STATUS	status = F32x_DEVICE_NOT_FOUND;

	// Validate parameter
	if (!ValidParam(cyHandle))
	{
		return F32x_INVALID_PARAMETER;
	}

	// Must set the GUID for functions that access the registry.
	sgCUsbIF.SetGUID(GUID_INTERFACE_SILABS_BULK);

	if (cyHandle)
	{
		*cyHandle = sgCUsbIF.Open(dwDevice);

		if (*cyHandle != INVALID_HANDLE_VALUE)
		{
			status = F32x_SUCCESS;
		}
	}
	else
	{
		status = F32x_INVALID_HANDLE;
	}

	return status;
}


//------------------------------------------------------------------------
// F32x_Close()
//
// Close file handle used to access a Silabs device.
//------------------------------------------------------------------------
F32x_STATUS
F32x_Close(HANDLE cyHandle)
{
	F32x_STATUS	status = F32x_INVALID_HANDLE;

	if ((cyHandle != NULL) && (cyHandle != INVALID_HANDLE_VALUE))
	{
		::CloseHandle(cyHandle);
		status = F32x_SUCCESS;
	}

	return status;
}


//------------------------------------------------------------------------
// F32x_Read()
//
// Read data from USB device.
// If read timeout value has been set, check RX queue until F32x_RX_COMPLETE
// flag bit is set.  If timeout the occurs before F32x_RX_COMPLETE, return
// error.  If no timeout has been set attempt read immediately. 
//------------------------------------------------------------------------
F32x_STATUS
F32x_Read(HANDLE cyHandle, LPVOID lpBuffer, DWORD dwBytesToRead, LPDWORD lpdwBytesReturned)
{
	F32x_STATUS	status = F32x_SUCCESS;

	// Validate parameters
	if (!ValidParam(lpBuffer, lpdwBytesReturned))
	{
		return F32x_INVALID_PARAMETER;
	}

	// Check for a valid Handle value
	if (cyHandle != INVALID_HANDLE_VALUE)
	{
		// Check that the read length is within range
		if ((dwBytesToRead > 0) && (dwBytesToRead <= F32x_MAX_READ_SIZE))
		{
			// Read transfer packet
			while(!ReadFile(cyHandle, lpBuffer, dwBytesToRead, lpdwBytesReturned, NULL))
			{	// Device IO failed.
				status = F32x_READ_ERROR;
			} 
		}
		else
			status = F32x_INVALID_REQUEST_LENGTH;
	}
	else 
		status = F32x_INVALID_HANDLE;

	return status;
}


//------------------------------------------------------------------------
// F32x_Write()
//
// Write data to USB device.
// If write timeout value has been set, continue write attempts until
// successful or timeout occurs.
//------------------------------------------------------------------------
F32x_STATUS
F32x_Write(HANDLE cyHandle, LPVOID lpBuffer, DWORD dwBytesToWrite, LPDWORD lpdwBytesWritten)
{
	F32x_STATUS	status = F32x_INVALID_HANDLE;

	// Validate parameters
	if (!ValidParam(lpBuffer, lpdwBytesWritten))
	{
		return F32x_INVALID_PARAMETER;
	}

	if (cyHandle != INVALID_HANDLE_VALUE)
	{
		if ((dwBytesToWrite > 0) && (dwBytesToWrite <= F32x_MAX_WRITE_SIZE))
		{
			if (!WriteFile(cyHandle, lpBuffer, dwBytesToWrite, lpdwBytesWritten, NULL))
			{
				status = F32x_WRITE_ERROR;

				if (sgdwWriteTimeout > 0)
				{
					DWORD	dwStart	= GetTickCount();
					DWORD	dwEnd	= GetTickCount();

					// Keep trying to write until success or timeout
					while((dwEnd - dwStart) < sgdwWriteTimeout && status != F32x_SUCCESS)
					{
						if (WriteFile(cyHandle, lpBuffer, dwBytesToWrite, lpdwBytesWritten, NULL))
						{
							status = F32x_SUCCESS;	// Write succeeded after > 1 attempts.
						}

						dwEnd = GetTickCount();
					}
				}
			}
			else
				status = F32x_SUCCESS;				// Write succeeded on first attempt.
		}
		else
			status = F32x_INVALID_REQUEST_LENGTH;
	}

	return status;
}

//------------------------------------------------------------------------
// ValidParam(LPDWORD)
//
// Checks validity of an LPDWORD pointer value.
//------------------------------------------------------------------------
static BOOL ValidParam(LPDWORD lpdwPointer)
{
	DWORD temp = 0;

	try 
	{
		temp = *lpdwPointer;
	}
	catch(...)
	{
		return FALSE;
	}
	return TRUE;
}


//------------------------------------------------------------------------
// ValidParam(LPVOID)
//
// Checks validity of an LPVOID pointer value.
//------------------------------------------------------------------------
static BOOL ValidParam(LPVOID lpVoidPointer)
{
	BYTE temp = 0;

	try 
	{
		temp = *((BYTE*)lpVoidPointer);
	}
	catch(...)
	{
		return FALSE;
	}
	return TRUE;
}


//------------------------------------------------------------------------
// ValidParam(HANDLE*)
//
// Checks validity of an HANDLE* pointer value.
//------------------------------------------------------------------------
static BOOL ValidParam(HANDLE* lpHandle)
{
	HANDLE temp = 0;

	try 
	{
		temp = *lpHandle;
	}
	catch(...)
	{
		return FALSE;
	}
	return TRUE;
}


//------------------------------------------------------------------------
// ValidParam(LPVOID, LPDWORD)
//
// Checks validity of LPVOID, LPDWORD pair of pointer values.
//------------------------------------------------------------------------
static BOOL ValidParam(LPVOID lpVoidPointer, LPDWORD lpdwPointer)
{
	if (ValidParam(lpVoidPointer))
		if (ValidParam(lpdwPointer))
			return TRUE;

	return FALSE;
}


//------------------------------------------------------------------------
// ValidParam(LPDWORD, LPDWORD)
//
// Checks validity of LPDWORD, LPDWORD pair of pointer values.
//------------------------------------------------------------------------
static BOOL ValidParam(LPDWORD lpdwPointer1, LPDWORD lpdwPointer2)
{
	if (ValidParam(lpdwPointer1))
		if (ValidParam(lpdwPointer2))
			return TRUE;

	return FALSE;
}

UINT ThreadProc(LPVOID param)
{
/*
	::MessageBox((HWND)param,"Thread actived!","Thread",MB_OK);
	while (bThreadControl)
	{
		;
	}
	//::MessageBox((HWND)param,"Thread stopped!","Thread",MB_OK);
*/
	::WaitForSingleObject(threadStart.m_hObject,INFINITE);
	::MessageBox((HWND)param,"Thread actived!","Thread",MB_OK);
	
	bool keepRunning = true;
	while (keepRunning)
	{
		int result = ::WaitForSingleObject(threadEnd.m_hObject,0);
		if (result == WAIT_OBJECT_0)
			keepRunning = false;
	}

	::PostMessage((HWND)param,WM_THREADENDED,0,0);
	return 0;
}