5.cb_com.cpp

C++Builder对串行口进行读写操作的一个通讯类

//C++Builder对串行口进行读写操作的一个通讯类，不用做修改即可用在程序中 

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