用Builder C++如何对串行口COM1或COM2进行读写操作
一个通讯类（对串口的读写），可以不用做修改就用在程序中 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; } //----------------------------------------------------------------