#include "StdAfx.h"
#include "stdafx.h"
#include "stdio.h"
#include ".\usbextend.h"


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"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif



CUSBExtend::CUSBExtend(void)                          //構造函數
{
	m_USBDeviceNames.strUSBDevice[0] = "";
	m_USBDeviceNames.strUSBDevice[1] = "";
	m_USBDeviceNames.strUSBDevice[2] = "";
	m_USBDeviceNames.strUSBDevice[3] = "";
	m_USBDeviceNames.iUSBTotalNumber = 0;
	m_USBDeviceNames.iCurrentSelectNumber = 0;

}

CUSBExtend::~CUSBExtend(void)                        //析構函數
{
}


//完成與USB相關的初始化
BOOL CUSBExtend::OnInit()
{
	//  CComboBox*	pDevList	= (CComboBox*)GetDlgItem(IDC_DEVICE_SELECT);

	//sgCUsbIF.SetGUID(GUID_INTERFACE_SILABS_BULK);                                //**
	SetGUID(GUID_INTERFACE_SILABS_BULK);
	// Get devices, init. combo box with their names
	FillDeviceList();

	//if (pDevList)
	//{
	// Open selected device.
	//	if (pDevList->GetCurSel() >= 0)
	if( m_USBDeviceNames.iCurrentSelectNumber >= 0)
	{
		F32x_STATUS status = F32x_Open(m_USBDeviceNames.iCurrentSelectNumber, &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);       //**
			m_hUSBWrite = 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 = 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);
			}
		
		
		}
	
	
	}



	bRun = FALSE;

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


//更新顯示USB設備名稱的相關控件（CComBox）
void CUSBExtend::UpdateDeviceList() 
{
	FillDeviceList();
}


//將搜索到的USB設備名稱填寫到控件(CComBox)中
void CUSBExtend::FillDeviceList()
{
	F32x_DEVICE_STRING	devStr;
	DWORD				dwNumDevices	= 0;
	//CComboBox*			pDevList		= (CComboBox*)GetDlgItem(IDC_DEVICE_SELECT);
	//  CComboBox*	pDevList	=  &m_ComboBox;
	

//	if (pDevList)
//	{
		int numDevs = m_USBDeviceNames.iUSBTotalNumber;

		for (int i = 0; i < numDevs; i++)
		{
			//pDevList->DeleteString(0);
			m_USBDeviceNames.strUSBDevice[i] = "";
			m_USBDeviceNames.iUSBTotalNumber = 0;

		}

	
		//-----------------------------------
		F32x_STATUS status = F32x_GetNumDevices(&dwNumDevices);
		m_USBDeviceNames.iUSBTotalNumber = 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);
					static int addUSBDeviceName = 0;
					m_USBDeviceNames.strUSBDevice[addUSBDeviceName] = devStr;
                    addUSBDeviceName++;

				}
			}
		}

		//pDevList->SetCurSel(0);
		m_USBDeviceNames.iCurrentSelectNumber = 0;

	//}
}





//讀取USB數據
BOOL CUSBExtend::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 CUSBExtend::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);
}





//*********************************以下全部為為全局函數(與USB相關)************************************
//------------------------------------------------------------------------
// F32x_GetNumDevices()
//
// Determine number of Silabs devices connected to the system from the
// registry.
//------------------------------------------------------------------------
F32x_STATUS CUSBExtend::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);
	SetGUID(GUID_INTERFACE_SILABS_BULK);
	//*lpdwNumDevices = sgCUsbIF.GetNumDevices();
	*lpdwNumDevices = 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 CUSBExtend::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);

	SetGUID(GUID_INTERFACE_SILABS_BULK);
	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 CUSBExtend::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);
	SetGUID(GUID_INTERFACE_SILABS_BULK);


	if (cyHandle)
	{
	//	*cyHandle = sgCUsbIF.Open(dwDevice);
		*cyHandle = 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 CUSBExtend::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 CUSBExtend::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 CUSBExtend::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.
//------------------------------------------------------------------------
 BOOL ValidParam(LPDWORD lpdwPointer)
{
	DWORD temp = 0;

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


//------------------------------------------------------------------------
// ValidParam(LPVOID)
//
// Checks validity of an LPVOID pointer value.
//------------------------------------------------------------------------
 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.
//------------------------------------------------------------------------
 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.
//------------------------------------------------------------------------
 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.
//------------------------------------------------------------------------
 BOOL ValidParam(LPDWORD lpdwPointer1, LPDWORD lpdwPointer2)
{
	if (ValidParam(lpdwPointer1))
		if (ValidParam(lpdwPointer2))
			return TRUE;

	return FALSE;
}