syncserialcomm.cpp

RS232 user sample with windows API.

// SyncSerialComm.cpp: implementation of the CSyncSerialComm class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "SyncSerialComm.h"

#include <string.h>
#include <assert.h>

#include <sstream>

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CSyncSerialComm::CSyncSerialComm(const char *pszPortName)
	: m_hSerialComm(INVALID_HANDLE_VALUE)
{
	assert(pszPortName);

	m_pszPortName = new char[strlen(pszPortName)+1];
	strcpy(m_pszPortName, pszPortName);
}

CSyncSerialComm::~CSyncSerialComm()
{
	if(m_pszPortName)
		delete[] m_pszPortName;

	Close();
}

//////////////////////////////////////////////////////////////////////
// Name: Open
// Version: 1.0
//////////////////////////////////////////////////////////////////////

HRESULT CSyncSerialComm::Open()
{
	HRESULT hResult;

	m_hSerialComm = CreateFileA(m_pszPortName, /* Port Name */ 
							   GENERIC_READ | GENERIC_WRITE, /* Desired Access */ 
							   0, /* Shared Mode */
							   NULL, /* Security */
							   OPEN_EXISTING, /* Creation Disposition */
							   0,
							   NULL); /* Non Overlapped */

	if(m_hSerialComm == INVALID_HANDLE_VALUE)
	{
		unsigned long error = ::GetLastError();
		hResult = E_FAIL;
	}

	else
		hResult = S_OK;

	return hResult;
}

//////////////////////////////////////////////////////////////////////
// Name: Close
// Version: 1.0
// Return: HRESULT
//////////////////////////////////////////////////////////////////////

HRESULT CSyncSerialComm::Close()
{
	if(m_hSerialComm != INVALID_HANDLE_VALUE)
	{
		CloseHandle(m_hSerialComm);
		m_hSerialComm = INVALID_HANDLE_VALUE;
	}

	return S_OK;
}

//////////////////////////////////////////////////////////////////////
// Name: ConfigPort
// Version: 1.0
//////////////////////////////////////////////////////////////////////

HRESULT CSyncSerialComm::ConfigPort(DWORD dwBaudRate, DWORD dwTimeOutInSec)
{
	if(!SetupComm(m_hSerialComm, 1024, 1024))
		return E_FAIL;

	DCB dcbConfig;

	if(GetCommState(m_hSerialComm, &dcbConfig)) /* Configuring Serial Port Settings */
	{
		dcbConfig.BaudRate = dwBaudRate;
		dcbConfig.ByteSize = 8;
		dcbConfig.Parity = NOPARITY;
		dcbConfig.StopBits = ONESTOPBIT;
		//dcbConfig.fBinary = TRUE;
		//dcbConfig.fParity = TRUE;
		dcbConfig.fAbortOnError = TRUE;
	}

	else
		return E_FAIL;

	if(!SetCommState(m_hSerialComm, &dcbConfig))
		return E_FAIL;

	COMMTIMEOUTS commTimeout;
				
	if(GetCommTimeouts(m_hSerialComm, &commTimeout)) /* Configuring Read & Write Time Outs */
	{
		commTimeout.ReadIntervalTimeout = 1000*dwTimeOutInSec;
		commTimeout.ReadTotalTimeoutConstant = 1000*dwTimeOutInSec;
		commTimeout.ReadTotalTimeoutMultiplier = 0;
		commTimeout.WriteTotalTimeoutConstant = 1000*dwTimeOutInSec;
		commTimeout.WriteTotalTimeoutMultiplier = 0;
	}

	else
		return E_FAIL;

	if(SetCommTimeouts(m_hSerialComm, &commTimeout))
		return S_OK;

	else
		return E_FAIL;
}

//////////////////////////////////////////////////////////////////////
// Name: Read
// Version: 1.0
//////////////////////////////////////////////////////////////////////

HRESULT CSyncSerialComm::Read(char **ppszBuf, DWORD &dwSize)
{
	HRESULT hResult = S_OK;
	std::stringbuf sb;
	DWORD dwEventMask;
	DWORD	dwError;
	COMSTAT cs;

	ClearCommError(m_hSerialComm,&dwError,&cs);
	if(dwError) return E_FAIL;
//	if(!SetCommMask(m_hSerialComm, EV_RXCHAR)) /* Setting Event Type */
//		return E_FAIL;

//	if(WaitCommEvent(m_hSerialComm, &dwEventMask, NULL)) /* Waiting For Event to Occur */
	{
		char szBuf;
		DWORD dwIncommingReadSize;

		do
		{
			if(ReadFile(m_hSerialComm, &szBuf, 1, &dwIncommingReadSize, NULL) != 0)
			{
				if(dwIncommingReadSize > 0)
				{
					dwSize += dwIncommingReadSize;
					sb.sputn(&szBuf, dwIncommingReadSize);
				}
			}

			else
			{
				unsigned long error = ::GetLastError();
				hResult = E_FAIL;
				break;
			}

		} while(dwIncommingReadSize > 0);

		if(dwSize>0)
		{
			char content[11];
			

			*ppszBuf = new char[dwSize+1];
			//strcpy_s(*ppszBuf,dwSize+1, (sb.str()).c_str());
			sb.sgetn(*ppszBuf,dwSize);
		}
	
		return hResult;
	}

//	else
//		return E_FAIL;
}

//////////////////////////////////////////////////////////////////////
// Name: Write
// Version: 1.0
//////////////////////////////////////////////////////////////////////

HRESULT CSyncSerialComm::Write(const UCHAR *pszBuf, DWORD dwSize)
{
	HRESULT hResult = S_OK;

	assert(pszBuf);

	unsigned long dwNumberOfBytesSent = 0;

	while(dwNumberOfBytesSent < dwSize)
	{
		unsigned long dwNumberOfBytesWritten;

		if(WriteFile(m_hSerialComm, &pszBuf[dwNumberOfBytesSent], 1, &dwNumberOfBytesWritten, NULL) != 0)
		{
			if(dwNumberOfBytesWritten > 0)
				++dwNumberOfBytesSent;
			else
			{
				unsigned long error = ::GetLastError();
				hResult = E_FAIL;
				break;
			}
		}

		else
		{
			unsigned long error = ::GetLastError();
			hResult = E_FAIL;
			break;
		}
	}

	return hResult;
}

//////////////////////////////////////////////////////////////////////
// Name: Flush
// Version: 1.0
//////////////////////////////////////////////////////////////////////

HRESULT CSyncSerialComm::Flush(DWORD dwFlag)
{
	if(PurgeComm(m_hSerialComm, dwFlag))
		return S_OK;
	else
		return E_FAIL;
}