|
TSerialPort.h
#ifndef __SERIALPORT_H__
#define __SERIALPORT_H__
#define WM_COMM_BREAK_DETECTED WM_USER+1 // A break was detected on input.
#define WM_COMM_CTS_DETECTED WM_USER+2 // The CTS （clear-to-sennd） sig
nal changed state.
#define WM_COMM_DSR_DETECTED WM_USER+3 // The DSR （data-set-reaady） si
gnal changed state.
#define WM_COMM_ERR_DETECTED WM_USER+4 // A line-status error ooccurre
d. Line-status errors are CE_FRAME, CE_OVERRUN, and CE_RXPARITY.
#define WM_COMM_RING_DETECTED WM_USER+5 // A ring indicator was etec ted.
#define WM_COMM_RLSD_DETECTED WM_USER+6 // The RLSD （receive-lin
-sig
nal-detect） signal changed state.
#define WM_COMM_RXCHAR WM_USER+7 // A character w
s received and pl
aced in the input buffer.
#define WM_COMM_RXFLAG_DETECTED WM_USER+8 // The event character w
s
received and placed in the input buffer.
#define WM_COMM_TXEMPTY_DETECTED WM_USER+9 // The last character in
th
e output buffer was sent.
class TSerialPort
{
public:
// contruction and destruction
TSerialPort（）；
virtual ~TSerialPort（）；
// port initialisation
BOOL InitPort（TForm* pPortOwner, UINT portnr = 1, UINT baud =
19200,
char parity = 'N', UINT databits = 8, UINT stopsbits = 1, DWORD dwCom
mEvents = EV_RXCHAR | EV_CTS, UINT nBufferSize = 512）；
// start/stop comm watching
BOOL StartMonitoring（）；
BOOL RestartMonitoring（）；
BOOL StopMonitoring（）；
DWORD GetWriteBufferSize（）；
DWORD GetCommEvents（）；
DCB GetDCB（）；
void WriteToPort（char* string）；
protected:
// protected memberfunctions
void ProcessErrorMessage（char* ErrorText）；
static DWORD _stdcall CommThread（LPVOID pParam）；
static void ReceiveChar（TSerialPort* port, COMSTAT comstat）；
static void WriteChar（TSerialPort* port）；
// thread
HANDLE m_HThread；
// synchronisation objects
CRITICAL_SECTION m_csCommunicationSync；
BOOL m_bThreadAlive；
// handles
HANDLE m_hShutdownEvent；
HANDLE m_hComm；
HANDLE m_hWriteEvent；
// Event array.
// One element is used for each event. There are two event handles fo
r each port.
// A Write event and a receive character event which is located in th
e overlapped structure （m_ov.hEvent）.
// There is a general shutdown when the port is closed.
HANDLE m_hEventArray[3]；
// structures
OVERLAPPED m_ov；
COMMTIMEOUTS m_CommTimeouts；
DCB m_dcb；
// owner window
TForm* m_pOwner；
// misc
UINT m_nPortNr；
char* m_szWriteBuffer；
DWORD m_dwCommEvents；
DWORD m_nWriteBufferSize；
}；
#endif __SERIALPORT_H__
TSerialPort.cpp
#include
#pragma hdrstop
#include "SerialPort.h"
#include
#include
#pragma package（smart_init）
//
// Constructor
//
TSerialPort::TSerialPort（）
{
m_hComm = NULL；
// initialize overlapped structure members to zero
m_ov.Offset = 0；
m_ov.OffsetHigh = 0；
// create events
m_ov.hEvent = NULL；
m_hWriteEvent = NULL；
m_hShutdownEvent = NULL；
m_szWriteBuffer = NULL；
m_bThreadAlive = false；
}
//
// Delete dynamic memory
//
TSerialPort::~TSerialPort（）
{
do
{
SetEvent（m_hShutdownEvent）；
} while （m_bThreadAlive）；
delete [] m_szWriteBuffer；
}
//
// Initialize the port. This can be port 1 to 4.
//
BOOL TSerialPort::InitPort（TForm* pPortOwner, // the owner （CWnd） of t
he port （receives message）
UINT portnr,
/ portnumber （1..4）
UINT baud,
/ baudrate
char parity,
/ parity
UINT databits,
/ databits
UINT stopbits,
/ stopbits
DWORD dwCommEvents, // EV_RX
HAR, EV_CTS etc
UINT writebuffersize）
/ size to the writebuffer
{
assert（portnr ＞ 0 && portnr ＜ 5）；
assert（pPortOwner != NULL）；
// if the thread is alive: Kill
if （m_bThreadAlive）
{
do
{
SetEvent（m_hShutdownEvent）；
} while （m_bThreadAlive）；
}
// create events
if （m_ov.hEvent != NULL）
ResetEvent（m_ov.hEvent）；
m_ov.hEvent = CreateEvent（NULL, true, false, NULL）；
if （m_hWriteEvent != NULL）
ResetEvent（m_hWriteEvent）；
m_hWriteEvent = CreateEvent（NULL, true, false, NULL）；
if （m_hShutdownEvent != NULL）
ResetEvent（m_hShutdownEvent）；
m_hShutdownEvent = CreateEvent（NULL, true, false, NULL）；
// initialize the event objects
m_hEventArray[0] = m_hShutdownEvent； // highest priority
m_hEventArray[1] = m_ov.hEvent；
m_hEventArray[2] = m_hWriteEvent；
// initialize critical section
InitializeCriticalSection（&m_csCommunicationSync）；
// set buffersize for writing and save the owner
m_pOwner = pPortOwner；
if （m_szWriteBuffer != NULL）
delete [] m_szWriteBuffer；
m_szWriteBuffer = new char[writebuffersize]；
m_nPortNr = portnr；
m_nWriteBufferSize = writebuffersize；
m_dwCommEvents = dwCommEvents；
BOOL bResult = false；
char *szPort = new char[50]；
char *szBaud = new char[50]；
// now it critical!
EnterCriticalSection（&m_csCommunicationSync）；
// if the port is already opened: close it
if （m_hComm != NULL）
{
CloseHandle（m_hComm）；
m_hComm = NULL；
}
// prepare port strings
sprintf（szPort, "COM%d", portnr）；
sprintf（szBaud, "baud=%d parity=%c data=%d stop=%d", baud, parity, da
tabits, stopbits）；
// get a handle to the port
m_hComm = CreateFile（szPort,
/ communication port string （COMX）
GENERIC_READ | GENERIC_WRITE,
/ read/write types
0,
/ comm devices must be opened with exclusive acce
ss
ss
NULL,
/ no security attributes
OPEN_EXISTING,
/ comm devices must use OPEN_EXISTING
FILE_FLAG_OVERLAPPED,
/ Async I/O
0）；
/ template must be 0 for comm devices
if （m_hComm == INVALID_HANDLE_VALUE）
{
// port not found
delete [] szPort；
delete [] szBaud；
return false；
}
// set the timeout values
m_CommTimeouts.ReadIntervalTimeout = 1000；
m_CommTimeouts.ReadTotalTimeoutMultiplier = 1000；
m_CommTimeouts.ReadTotalTimeoutConstant = 1000；
m_CommTimeouts.WriteTotalTimeoutMultiplier = 1000；
m_CommTimeouts.WriteTotalTimeoutConstant = 1000；
// configure
if （SetCommTimeouts（m_hComm, &m_CommTimeouts））
{
if （SetCommMask（m_hComm, dwCommEvents））
{
if （GetCommState（m_hComm, &m_dcb））
{
m_dcb.fRtsControl = RTS_CONTROL_ENABLE；
/ set RTS bit high!
if （BuildCommDCB（szBaud, &m_dcb））
{
if （SetCommState（m_hComm, &m_dcb））
； // normal operation... continu
else
ProcessErrorMessage（"SetCommStat
（）"）；
}
else
ProcessErrorMessage（"BuildCommDCB（）"）；
}
else
ProcessErrorMessage（"GetCommState（）"）；
}
else
ProcessErrorMessage（"SetCommMask（）"）；
}
else
ProcessErrorMessage（"SetCommTimeouts（）"）；
delete [] szPort；
delete [] szBaud；
// flush the port
PurgeComm（m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PU
RGE_TXABORT）；
// release critical section
LeaveCriticalSection（&m_csCommunicationSync）；
return true；
}
//
// The CommThread Function.
//
DWORD _stdcall TSerialPort::CommThread（LPVOID pParam）
{
// Cast the void pointer passed to the thread back to
// a pointer of TSerialPort class
TSerialPort *port = （TSerialPort*）pParam；
// Set the status variable in the dialog class to
// TRUE to indicate the thread is running.
port-＞m_bThreadAlive = true；
// Misc. variables
DWORD BytesTransfered = 0；
DWORD Event = 0；
DWORD CommEvent = 0；
DWORD dwError = 0；
COMSTAT comstat；
BOOL bResult = true；
// Clear comm buffers at startup
if （port-＞m_hComm） // check if the port is opened
PurgeComm（port-＞m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_R
ABO
RT | PURGE_TXABORT）；
// begin forever loop. This loop will run as long as the thread is a
live.
for （；；）
{
// Make a call to WaitCommEvent（）. This call will return immedi
tly
// because our port was created as an async port （FILE_FLAG_OVER
APP
ED
// and an m_OverlappedStructerlapped structure specified）. This
cal
l will cause the
// m_OverlappedStructerlapped element m_OverlappedStruct.hEvent,
whi
ch is part of the m_hEventArray to
// be placed in a non-signeled state if there are no bytes avail
ble
to be read,
// or to a signeled state if there are bytes available. If this
eve
nt handle
// is set to the non-signeled state, it will be set to signeled
hen
a
// character arrives at the port.
// we do this for each port!
bResult = WaitCommEvent（port-＞m_hComm, &Event, &port-＞m_ov）；
if （!bResult）
{
// If WaitCommEvent（） returns FALSE, process the last er
or to dete
rmin
rmin
// the reason..
switch （dwError = GetLastError（））
{
case ERROR_IO_PENDING:
{
// This is a normal return value if ther
are no bytes
// to read at the port.
// Do nothing and continue
break；
}
case 87:
{
// Under Windows NT, this value is retur
ed for some reason.
// I have not investigated why, but it i
also a valid reply
// Also do nothing and continue.
break；
}
default:
{
// All other error codes indicate a seri
us error has
// occured. Process this error.
port-＞ProcessErrorMessage（"WaitCommEvent
）"）；
break；
}
}
}
else
{
// If WaitCommEvent（） returns TRUE, check to be sure the
e are
// actually bytes in the buffer to read.
//
// If you are reading more than one byte at a time from
he buffer
// （which this program does not do） you will have the si
uation occ
ur
// where the first byte to arrive will cause the WaitFor
ultipleObj
ects（）
// function to stop waiting. The WaitForMultipleObjects
） function
// resets the event handle in m_OverlappedStruct.hEvent
o the non-
signelead state
// as it returns.
//
// If in the time between the reset of this event and th
call to
// ReadFile（） more bytes arrive, the m_OverlappedStruct.
Event hand
le will be set again
// to the signeled state. When the call to ReadFile（） oc
urs, it wi
ll
// read all of the bytes from the buffer, and the progra
will
// loop back around to WaitCommEvent（）.
//
// At this point you will be in the situation where m_Ov
rlappedStr
uct.hEvent is set,
// but there are no bytes available to read. If you pro
eed and ca
ll
// ReadFile（）, it will return immediatly due to the asyn
port setu
p, but
// GetOverlappedResults（） will not return until the next
character
arrives.
//
// It is not desirable for the GetOverlappedResults（） fu
ction to b
e in
// this state. The thread shutdown event （event 0） and
he WriteFi
le（）
// event （Event2） will not work if the thread is blocked
by GetOver
lappedResults（）.
//
// The solution to this is to check the buffer with a ca
l to Clear
CommError（）.
// This call will reset the event handle, and if there a
e no bytes
to read
// we can loop back through WaitCommEvent（） again, then
roceed.
// If there are really bytes to read, do nothing and pro
eed.
bResult = ClearCommError（port-＞m_hComm, &dwError, &comst
t）；
if （comstat.cbInQue == 0）
continue；
} // end if bResult
// Main wait function. This function will normally block the th
ead
// until one of nine events occur that require action.
Event = WaitForMultipleObjects（3, port-＞m_hEventArray, false, IN
INI
TE）；
switch （Event）
{
case 0:
{
// Shutdown event. This is event zero so it wil
be
// the higest priority and be serviced first.
port-＞m_bThreadAlive = false；
// Kill this thread. break is not needed, but m
kes me feel bette
r.
ExitThread（100）；
break；
}
case 1: // read event
{
GetCommMask（port-＞m_hComm, &CommEvent）；
if （CommEvent & EV_CTS）
::SendMessage（port-＞m_pOwner-＞Handle, WM
COMM_CTS_DETECTED, （WPAR
AM） 0, （LPARAM） port-＞m_nPortNr）；
if （CommEvent & EV_RXFLAG）
::SendMessage（port-＞m_pOwner-＞Handle, WM
COMM_RXFLAG_DETECTED, （W
PARAM） 0, （LPARAM） port-＞m_nPortNr）；
if （CommEvent & EV_BREAK）
::SendMessage（port-＞m_pOwner-＞Handle, WM
COMM_BREAK_DETECTED, （WP
ARAM） 0, （LPARAM） port-＞m_nPortNr）；
if （CommEvent & EV_ERR）
::SendMessage（port-＞m_pOwner-＞Handle, WM
COMM_ERR_DETECTED, （WPAR
AM） 0, （LPARAM） port-＞m_nPortNr）；
if （CommEvent & EV_RING）
::SendMessage（port-＞m_pOwner-＞Handle, WM
COMM_RING_DETECTED, （WPA
RAM） 0, （LPARAM） port-＞m_nPortNr）；
if （CommEvent & EV_RXCHAR）
// Receive character event from port.
ReceiveChar（port, comstat）；
break；
}
case 2: // write event
{
// Write character event from port
WriteChar（port）；
break；
}
} // end switch
} // close forever loop
return 0；
}
//
//
// start comm watching
//
BOOL TSerialPort::StartMonitoring（）
{
DWORD lpThreadId；
m_HThread =CreateThread（NULL,
0,
CommThread,
this,
0,
&lpThreadId）；
if（m_HThread==NULL）
{
ProcessErrorMessage（"Create Thread Error"）；
return false；
}
return true；
}
//
// Restart the comm thread
//
//
BOOL TSerialPort::RestartMonitoring（）
{
ResumeThread（m_HThread）；
return true；
}
//
// Suspend the comm thread
//
BOOL TSerialPort::StopMonitoring（）
{
SuspendThread（m_HThread）；
return true；
}
//
// If there is a error, give the right message
//
void TSerialPort::ProcessErrorMessage（char* ErrorText）
{
char *Temp = new char[200]；
LPVOID lpMsgBuf；
FormatMessage（
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
GetLastError（）,
MAKELANGID（LANG_NEUTRAL, SUBLANG_DEFAULT）, // Default language
（LPTSTR） &lpMsgBuf,
0,
NULL
）；
sprintf（Temp, "WARNING: %s Failed with the following error: \n%s\nPo
rt: %d\n", （char*）ErrorText, lpMsgBuf, m_nPortNr）；
Application-＞MessageBox（Temp, "Application Error", MB_ICONSTOP）；
LocalFree（lpMsgBuf）；
delete[] Temp；
}
//
// Write a character.
//
void TSerialPort::WriteChar（TSerialPort* port）
{
BOOL bWrite = true；
BOOL bResult = true；
DWORD BytesSent = 0；
ResetEvent（port-＞m_hWriteEvent）；
// Gain ownership of the critical section
EnterCriticalSection（&port-＞m_csCommunicationSync）；
if （bWrite）
{
// Initailize variables
port-＞m_ov.Offset = 0；
port-＞m_ov.OffsetHigh = 0；
// Clear buffer
PurgeComm（port-＞m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_R
ABO
ABO
RT | PURGE_TXABORT）；
bResult = WriteFile（port-＞m_hComm,
/ Handle to COMM Port
port-＞m_szWriteBuffer, /
/ Pointer to message buffer in call
ing finction
strlen（（char*）port-＞m_sz
riteBuffer）, // Length of message to s
end
&BytesSent,
/ Where to store the number of bytes sent
&port-＞m_ov）；
/ Overlapped structure
// deal with any error codes
if （!bResult）
{
DWORD dwError = GetLastError（）；
switch （dwError）
{
case ERROR_IO_PENDING:
{
// continue to GetOverlappedResu
ts（）
BytesSent = 0；
bWrite = false；
break；
}
default:
{
// all other error codes
port-＞ProcessErrorMessage（"Write
ile（）"）；
}
}
}
else
{
LeaveCriticalSection（&port-＞m_csCommunicationSync）；
}
} // end if（bWrite）
if （!bWrite）
{
bWrite = true；
bResult = GetOverlappedResult（port-＞m_hComm, // Handle to COM
port
&port-
m_ov, // Overlapped structure
&Bytes
ent, // Stores number of bytes sent
true）；
// Wait flag
LeaveCriticalSection（&port-＞m_csCommunicationSync）；
// deal with the error code
if （!bResult）
{
port-＞ProcessErrorMessage（"GetOverlappedResults（） in Wri
eFile（）"）；
}
} // end if （!bWrite）
// Verify that the data size send equals what we tried to send
if （BytesSent != strlen（（char*）port-＞m_szWriteBuffer））
{
printf（"WARNING: WriteFile（） error.. Bytes Sent: %d； Message Len
th:
%d\n", BytesSent, strlen（（char*）port-＞m_szWriteBuffer））；
}
}
//
// Character received. Inform the owner
//
void TSerialPort::ReceiveChar（TSerialPort* port, COMSTAT comstat）
{
BOOL bRead = true；
BOOL bResult = true；
DWORD dwError = 0；
DWORD BytesRead = 0；
unsigned char RXBuff；
for （；；）
{
// Gain ownership of the comm port critical section.
// This process guarantees no other part of this program
// is using the port object.
EnterCriticalSection（&port-＞m_csCommunicationSync）；
// ClearCommError（） will update the COMSTAT structure and
// clear any other errors.
bResult = ClearCommError（port-＞m_hComm, &dwError, &comstat）；
LeaveCriticalSection（&port-＞m_csCommunicationSync）；
// start forever loop. I use this type of loop because I
// do not know at runtime how many loops this will have to
// run. My solution is to start a forever loop and to
// break out of it when I have processed all of the
// data available. Be careful with this approach and
// be sure your loop will exit.
// My reasons for this are not as clear in this sample
// as it is in my production code, but I have found this
// solutiion to be the most efficient way to do this.
if （comstat.cbInQue == 0）
{
// break out when all bytes have been read
break；
}
EnterCriticalSection（&port-＞m_csCommunicationSync）；
if （bRead）
{
bResult = ReadFile（port-＞m_hComm, // Handl
to COMM port
&RXBuff,
/ RX Buffer Pointer
1,
/ Read one byte
&BytesRead,
/ Stores number of bytes read
&port-＞m_ov）；
/ pointer to the m_ov structure
// deal with the error code
if （!bResult）
{
switch （dwError = GetLastError（））
{
case ERROR_IO_PENDING:
{
// asynchronous i/o is s
ill in progress
// Proceed on to GetOver
appedResults（）；
bRead = false；
break；
}
default:
{
// Another error has occ
red. Process this error.
port-＞ProcessErrorMessag
（"ReadFile（）"）；
break；
}
}
}
else
{
// ReadFile（） returned complete. It is not neces
ary to call GetOv
erlappedResults（）
bRead = true；
}
} // close if （bRead）
if （!bRead）
{
bRead = true；
bResult = GetOverlappedResult（port-＞m_hComm, // Handl
to COMM port
&port-＞m_ov, // Overlapped structure
&BytesRead, // Stores number of bytes read
true）； // Wait flag
// deal with the error code
if （!bResult）
{
port-＞ProcessErrorMessage（"GetOverlappedResults（
in ReadFile（）"）；
}
} // close if （!bRead）
LeaveCriticalSection（&port-＞m_csCommunicationSync）；
// notify parent that a byte was received
::SendMessage（（port-＞m_pOwner）-＞Handle, WM_COMM_RXCHAR, （WPARAM）
RXB
uff, （LPARAM） port-＞m_nPortNr）；
} // end forever loop
}
//
// Write a string to the port
//
void TSerialPort::WriteToPort（char* string）
{
assert（m_hComm != 0）；
memset（m_szWriteBuffer, 0, sizeof（m_szWriteBuffer））；
strcpy（m_szWriteBuffer, string）；
// set event for write
SetEvent（m_hWriteEvent）；
}
//
// Return the device control block
//
DCB TSerialPort::GetDCB（）
{
return m_dcb；
}
//
// Return the communication event masks
//
DWORD TSerialPort::GetCommEvents（）
{
return m_dwCommEvents；
}
//
// Return the output buffer size
//
DWORD TSerialPort::GetWriteBufferSize（）
{
return m_nWriteBufferSize；
}
//---------------------------------------------------------------- | 
更多内容请看C/C++技术专题、C/C++相关文章专题，或进入讨论组讨论。
