comm.cpp

磁卡读写测试程序

#include "stdafx.h"
#include "comm.h"

LPCOMMINFO BuildComm(
	LPCOMMINFO info,
    long DCBlength,				     // sizeof(DCB) .
    long BaudRate,					// current baud rate .
    BOOL fBinary,							// binary mode, no EOF check 
    BOOL fParity,							// enable parity checking 
    int fOutxCtsFlow,						// CTS output flow control 
    int fOutxDsrFlow,						// DSR output flow control 
    int fDtrControl,		// DTR flow control type 
    int fOutX,								// XON/XOFF out flow control 
    int fInX,								// XON/XOFF in flow control 
    int fRtsControl,		// RTS flow control 
    int fAbortOnError,						// abort reads/writes on error 
    int XonLim,							// transmit XON threshold 
    int XoffLim,							// transmit XOFF threshold 
    int ByteSize,							// number of bits/byte, 4-8 .
    int Parity,						// 0-4=no,odd,even,mark,space .
    int StopBits					// 0,1,2 = 1, 1.5, 2 
	)
	{
		return info;	
	}

BOOL  InitComm( LPCOMMINFO m_info, const char* strCom)
{
	if ( strcmp(strCom,"com1") != 0 )
		if ( strcmp(strCom ,"Com2" ) != 0)
			return FALSE;

	DCB m_initDCB;
	memset(&m_initDCB,0,sizeof(DCB));
	m_initDCB.DCBlength=sizeof(DCB);				// sizeof(DCB) .
    m_initDCB.BaudRate=CBR_9600;					// current baud rate .
    m_initDCB.fBinary=1;							// binary mode, no EOF check 
    m_initDCB.fParity=1;							// enable parity checking 
    m_initDCB.fOutxCtsFlow=0;						// CTS output flow control 
    m_initDCB.fOutxDsrFlow=0;						// DSR output flow control 
    m_initDCB.fDtrControl=DTR_CONTROL_ENABLE;		// DTR flow control type 
    m_initDCB.fOutX=1;								// XON/XOFF out flow control 
    m_initDCB.fInX=1;								// XON/XOFF in flow control 
    m_initDCB.fRtsControl=RTS_CONTROL_ENABLE;		// RTS flow control 
    m_initDCB.fAbortOnError=1;						// abort reads/writes on error 
    m_initDCB.XonLim=100;							// transmit XON threshold 
    m_initDCB.XoffLim=100;							// transmit XOFF threshold 
    m_initDCB.ByteSize=8;							// number of bits/byte, 4-8 .
    m_initDCB.Parity=NOPARITY;						// 0-4=no,odd,even,mark,space .
    m_initDCB.StopBits=ONESTOPBIT;					// 0,1,2 = 1, 1.5, 2 


	//创建COM文件
	m_info->hComm=CreateFile(strCom,
							GENERIC_READ | GENERIC_WRITE,
							0,
							NULL,
							OPEN_EXISTING,
							FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
							NULL);

	if (m_info->hComm==INVALID_HANDLE_VALUE)
	{
		return FALSE;
	}

	//设定掩码
	BOOL bRet=SetCommMask(m_info->hComm, EV_RXCHAR|EV_BREAK|EV_CTS|EV_DSR|EV_ERR|EV_RING|EV_RLSD|EV_RXFLAG|EV_TXEMPTY);
					//|EV_BREAK|EV_CTS|EV_DSR|EV_ERR|EV_RING|EV_RLSD|EV_RXFLAG|EV_TXEMPTY);
	if (!bRet)
	{
		CloseHandle(m_info->hComm);
		return FALSE;
	}

	//设定输入流缓存和输出流缓存长度
	bRet=SetupComm(m_info->hComm, BUFFLEN, BUFFLEN);
	if (!bRet)
	{
		CloseHandle(m_info->hComm);
		return FALSE;
	}

	//清空输入流缓存和输出流缓存
	bRet=PurgeComm(m_info->hComm, PURGE_TXABORT 
								| PURGE_RXABORT 
								| PURGE_TXCLEAR 
								| PURGE_RXCLEAR);

	if (!bRet)
	{
		CloseHandle(m_info->hComm);
		return FALSE;
	}

	//设定读写超时结构
	m_info->cto.ReadIntervalTimeout = 6000;//6000;//0xFFFFFFFF;
	m_info->cto.ReadTotalTimeoutMultiplier = 100;///1;
	m_info->cto.ReadTotalTimeoutConstant = 100;//1;//1000;
	m_info->cto.WriteTotalTimeoutMultiplier = 0;
	m_info->cto.WriteTotalTimeoutConstant = 1;//1;
	bRet=SetCommTimeouts(m_info->hComm, &m_info->cto);
	if (!bRet)
	{
		CloseHandle(m_info->hComm);
		return FALSE;
	}

	m_info->dcb.DCBlength=sizeof(DCB);

	//取COM通讯口状态
	bRet=GetCommState(m_info->hComm, &m_info->dcb);
	if (!bRet)
	{
		CloseHandle(m_info->hComm);
		return FALSE;
	}

	m_info->dcb.BaudRate=m_initDCB.BaudRate;
	m_info->dcb.ByteSize=m_initDCB.ByteSize;
	m_info->dcb.Parity=m_initDCB.Parity;
	m_info->dcb.StopBits=m_initDCB.StopBits;
	m_info->dcb.fOutxDsrFlow=m_initDCB.fOutxDsrFlow;
	m_info->dcb.fDtrControl=m_initDCB.fDtrControl;
	m_info->dcb.fOutxCtsFlow=m_initDCB.fOutxCtsFlow;
	m_info->dcb.fRtsControl=m_initDCB.fRtsControl;
	m_info->dcb.fInX=m_initDCB.fInX;
	m_info->dcb.fOutX=m_initDCB.fOutX;
	m_info->dcb.XonChar=m_initDCB.XonChar;
	m_info->dcb.XoffChar=m_initDCB.XoffChar;
	m_info->dcb.XonLim=m_initDCB.XonLim;
	m_info->dcb.XoffLim=m_initDCB.XoffLim;
	m_info->dcb.fBinary=m_initDCB.fBinary;
	m_info->dcb.fParity=m_initDCB.fParity;

	//设定COM通讯口状态
	bRet=SetCommState(m_info->hComm, &m_info->dcb);
	if (!bRet)
	{
		CloseHandle(m_info->hComm);
		return FALSE;
	}

	//创建事件
	m_info->hEvent=CreateEvent(NULL,    // no security
							TRUE,    // explicit reset req
							FALSE,   // initial event reset
							NULL ) ; // no name
	if (m_info->hEvent == NULL)
	{
		CloseHandle(m_info->hComm);
		return NULL;
	}

	m_info->osWait.hEvent=m_info->hEvent;
	m_info->osWait.Offset=0;
	m_info->osWait.OffsetHigh=0;
	m_info->osRead.hEvent=m_info->hEvent;
	m_info->osRead.Offset=0;
	m_info->osRead.OffsetHigh=0;
	m_info->osWrite.hEvent=m_info->hEvent;
	m_info->osWrite.Offset=0;
	m_info->osWrite.OffsetHigh=0;

	//指定COM通讯口执行扩展功能
	bRet=EscapeCommFunction(m_info->hComm, SETDTR);
	if (!bRet)
	{
		CloseHandle(m_info->hComm);
		return FALSE;
	}
	return TRUE;

}
BOOL  DestroyComm(LPCOMMINFO m_info)
{
	if ( m_info->hComm == 0 || INVALID_HANDLE_VALUE ==m_info->hComm)
		return FALSE;
	BOOL ret =  CloseHandle(m_info->hComm);
	m_info->hComm  = INVALID_HANDLE_VALUE;
	return ret;
}
 DWORD   Read(LPCOMMINFO m_info,BYTE * pBuffer)
{
	DWORD dwlen;
	DWORD dwEventMask;
	DWORD dwpos;
	BYTE vData[MAXBLOCKLEN+1];

	dwlen=0;
	dwpos=0;
	dwEventMask=0;
	//WaitCommEvent(m_info->hComm, &dwEventMask, NULL);
//	if ((dwEventMask & EV_RXCHAR) != EV_RXCHAR)
//		return dwlen;

	do
	{
		dwlen=ReadBlock(m_info,vData, MAXBLOCKLEN);
		if (dwlen>0)
		{
			memcpy(pBuffer+dwpos, vData, dwlen);
			dwpos=dwpos+dwlen;
		}
	}while(dwlen>0);

	return dwpos;
}

//读数据块
//lpData      存放数据的内存块指针
//dxMaxLen    内存块长度
 DWORD  ReadBlock(LPCOMMINFO m_info,void * lpData, DWORD dwMaxLen)
{
	DWORD dwlen;
	COMSTAT ComStat;
	DWORD dwErrorFlags;
	DWORD dwError;
	BOOL bRet;

	//请空错误码标志
	ClearCommError(m_info->hComm, &dwErrorFlags, &ComStat);
	dwlen=min(dwMaxLen, ComStat.cbInQue);

	if (dwlen==0)
		return dwlen;//return 0

	//读COM口
	bRet=ReadFile(m_info->hComm, lpData,
					dwlen, &dwlen, &(m_info->osRead));

	if (bRet)
		return dwlen;

	if (GetLastError()==ERROR_IO_PENDING)
	{
		//取操作结果
		while (!GetOverlappedResult(m_info->hComm, &(m_info->osRead),
									&dwlen, TRUE))
		{
			dwError=GetLastError();
			if (dwError==ERROR_IO_INCOMPLETE)
				continue;
			else
			{
				ClearCommError(m_info->hComm, &dwErrorFlags, &ComStat);
				break;
			}
		}
	}
	else
	{
		dwlen=0;
		ClearCommError(m_info->hComm, &dwErrorFlags, &ComStat);
	}

	return dwlen;
}

//写数据块
//lpData      存放数据的内存块指针
//dxMaxLen    内存块长度
BOOL WriteBlock(LPCOMMINFO m_info,void * lpData, DWORD dwlen)
{
	BOOL bRet;
	DWORD dwWrite;
	DWORD dwError;
	DWORD dwBytesSent=0;
	DWORD dwErrorFlags;
	COMSTAT ComStat;

	//写COM口
	bRet=WriteFile(m_info->hComm, lpData, dwlen, &dwWrite, &(m_info->osWrite));

	if (bRet)
		return TRUE;

	if(GetLastError()==ERROR_IO_PENDING)
	{
		while(!GetOverlappedResult(m_info->hComm, &(m_info->osWrite),
									&dwWrite, TRUE))
		{
			dwError=GetLastError();
			if(dwError==ERROR_IO_INCOMPLETE)
			{
				dwBytesSent+=dwWrite;
				continue;
			}
			else
			{
				ClearCommError(m_info->hComm, &dwErrorFlags, &ComStat);
				break;
			}
		}
		dwBytesSent+=dwWrite;

		if (dwBytesSent!=dwlen)
		{
			return FALSE;
		}
	}
	else
	{
		ClearCommError(m_info->hComm, &dwErrorFlags, &ComStat);
		return FALSE;
	}

	return TRUE;
}