SerialPort类源代码分析

最新推荐文章于 2025-06-10 13:08:48 发布

转载最新推荐文章于 2025-06-10 13:08:48 发布 · 2.8k 阅读

文章标签：

#代码分析 #thread #structure #null #buffer #character

本文分析了Windows环境下SerialPort类的实现细节，介绍了串口初始化、监控线程管理、数据读写等核心功能。通过实例展示了异步I/O模型下的串口通信机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前几篇串口编程大致讲述了Windows下串口的大致操作，接下来分析流行的SerialPort类，它把Windows API封装好，方便开发利用

1、Win32下串口大致操作流程
(1)打开串口：CreateFile函数
(2)建立串口通信事件:CreateEvent函数
(3)初始化串口:SetCommState函数
(4)建立监视线程,即读写数据线程,因为我们不知道什么时候数据会到来,这里是一个异步事件
(5)写数据:WriteFile
(6)结束:关闭线程->停止WaitCommEvent->CloseHandle

2.SerialPort类的数据结构
大致了解操作流程后,先看一下SerialPort类,均在代码注释了
数据成员:

view plain copy to clipboard print ? public : int m_nWriteSize; //要写入串口的数据大小 HANDLE m_hComm; //串口句柄 protected : // thread监视线程 CWinThread* m_Thread; // synchronisation objects //临界资源 CRITICAL_SECTION m_csCommunicationSync; //监视线程运行标志 BOOL m_bThreadAlive; // handles /*事件句柄*/ HANDLE m_hWriteEvent; HANDLE m_hShutdownEvent; // There is a general shutdown when the port is closed. //事件数组，包括一个写事件，接收事件，关闭事件 HANDLE m_hEventArray[3]; // structures OVERLAPPED m_ov; //异步I/O模型 COMMTIMEOUTS m_CommTimeouts; //超时设置 DCB m_dcb; //设备控制块 // owner window CWnd* m_pOwner; // misc UINT m_nPortNr; char * m_szWriteBuffer; //写缓冲区 DWORD m_dwCommEvents; // DWORD m_nWriteBufferSize; //写缓冲大小函数成员： view plain copy to clipboard print ? public : /*******************Port Operation***********************/ // port initialisation /*初始化串口*/ BOOL InitPort(CWnd* pPortOwner, UINT portnr = 1, UINT baud = 19200, char parity = 'N' , UINT databits = 8, UINT stopbits = 1, DWORD dwCommEvents = EV_RXCHAR, UINT writebuffersize = 1024); //关闭端口 void ClosePort(); // start/stop comm watching //控制串口监视线程 BOOL StartMonitoring(); //开启 BOOL RestartMonitoring(); //复位 BOOL StopMonitoring(); //停止 DWORD GetWriteBufferSize(); //获取写缓冲大小 DWORD GetCommEvents(); //获取事件 DCB GetDCB(); //获取DCB //写数据到串口 void WriteToPort( char * string); void WriteToPort( char * string, int n); void WriteToPort( LPCTSTR string); void WriteToPort( LPCTSTR string, int n); protected : /***************** protected memberfunctions **********************/ void ProcessErrorMessage( char * ErrorText); //线程函数 static UINT CommThread( LPVOID pParam); //接收字符 static void ReceiveChar(CSerialPort* port, COMSTAT comstat); //写字符 static void WriteChar(CSerialPort* port);

3.串口操作

(1)初始化串口

流程：检查参数-->检测线程-->创建事件(监视线程)-->打开端口-->设置异步IO结构参数,详细见代码:

/*初始化串口*/   
    BOOL  CSerialPort::InitPort(CWnd* pPortOwner,     // the owner (CWnd) of the port (receives message)   
                               UINT   portnr,         // portnumber (1..4)   
                               UINT   baud,           // baudrate   
                               char   parity,         // parity    
                               UINT   databits,       // databits    
                               UINT   stopbits,       // stopbits    
                               DWORD  dwCommEvents,   // EV_RXCHAR, 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);  
            TRACE("Thread ended/n" );  
        }  
      
        // create events   
        //创建事件   
        if  (m_ov.hEvent != NULL)  
            ResetEvent(m_ov.hEvent);  
        else   
            m_ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);  
      
        if  (m_hWriteEvent != NULL)  
            ResetEvent(m_hWriteEvent);  
        else   
            m_hWriteEvent = CreateEvent(NULL, TRUE, FALSE, NULL);  
          
        if  (m_hShutdownEvent != NULL)  
            ResetEvent(m_hShutdownEvent);  
        else   
            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和LeaveCriticalSection函数。  
        **********************************************************************/   
        //进入临界区   
        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, databits, stopbits);  
      
        // get a handle to the port   
        /****************************************************************  
        *通信程序在CreateFile处指定串口设备及相关的操作属性，再返回一个句柄，  
        *该句柄将被用于后续的通信操作，并贯穿整个通信过程串口打开后，其属性  
        *被设置为默认值，根据具体需要，通过调用GetCommState(hComm,&&dcb)读取  
        *当前串口设备控制块DCB设置，修改后通过SetCommState(hComm,&&dcb)将其写  
        *入。运用ReadFile()与WriteFile()这两个API函数实现串口读写操作，若为异  
        *步通信方式，两函数中最后一个参数为指向OVERLAPPED结构的非空指针，在读  
        *写函数返回值为FALSE的情况下，调用GetLastError()函数，返回值为ERROR_IO_PENDING，  
        *表明I/O操作悬挂，即操作转入后台继续执行。此时，可以用WaitForSingleObject()  
        *来等待结束信号并设置最长等待时间  
        *****************************************************************/   
        m_hComm = CreateFile(szPort,                        // communication port string (COMX)串口号   
                             GENERIC_READ | GENERIC_WRITE,  // read/write types 可以读写   
                             0,                             // comm devices must be opened with exclusive access独占方式打开串口   
                             NULL,                          // no security attributes 无安全属性   
                             OPEN_EXISTING,                 // comm devices must use OPEN_EXISTING   
                             FILE_FLAG_OVERLAPPED,          // Async I/O 异步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   
        //设置超时上限(异步IO)   
        m_CommTimeouts.ReadIntervalTimeout = 1000;  
        m_CommTimeouts.ReadTotalTimeoutMultiplier = 1000;  
        m_CommTimeouts.ReadTotalTimeoutConstant = 1000;  
        m_CommTimeouts.WriteTotalTimeoutMultiplier = 1000;  
        m_CommTimeouts.WriteTotalTimeoutConstant = 1000;  
      
        // configure   
        /*分别调用Windows API设置串口参数*/   
        if  (SetCommTimeouts(m_hComm, &m_CommTimeouts))           //设置超时   
        {     
            /*******************************************************  
            若对端口数据的响应时间要求较严格，可采用事件驱动方式。  
            事件驱动方式通过设置事件通知，当所希望的事件发生时，Windows  
            发出该事件已发生的通知，这与DOS环境下的中断方式很相似。Windows  
            定义了9种串口通信事件，较常用的有以下三种：   
     
            EV_RXCHAR:接收到一个字节，并放入输入缓冲区；   
     
            EV_TXEMPTY:输出缓冲区中的最后一个字符，发送出去；   
     
            EV_RXFLAG:接收到事件字符(DCB结构中EvtChar成员)，放入输入缓冲区  
     
            在用SetCommMask()指定了有用的事件后，应用程序可调用WaitCommEvent()来等待事  
            件的发生。SetCommMask(hComm,0)可使WaitCommEvent()中止。  
            **************************************************************/               
            if  (SetCommMask(m_hComm, dwCommEvents))              //设置通信事件    
            {  
                if  (GetCommState(m_hComm, &m_dcb))               //获取当前DCB参数   
                {  
                    m_dcb.EvtChar = 'q' ;                     //设置字件字符   
                    m_dcb.fRtsControl = RTS_CONTROL_ENABLE;     // set RTS bit high!   
                    if  (BuildCommDCB(szBaud, &m_dcb))        //填写DCB结构   
                    {  
                        if  (SetCommState(m_hComm, &m_dcb))   //配置DCB   
                            ; // normal operation... continue   
                        else   
                            ProcessErrorMessage("SetCommState()" );  
                    }  
                    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 | PURGE_TXABORT);  
      
        // release critical section   
        //出临界区   
        LeaveCriticalSection(&m_csCommunicationSync);  
      
        TRACE("Initialisation for communicationport %d completed./nUse Startmonitor to communicate./n" , portnr);  
      
        return  TRUE;  
    }

(2)监视线程的控制

先看比较简单的线程控制吧，主要有开启线程，复位和停止

//开始监视串口 BOOL CSerialPort::StartMonitoring() { if (!(m_Thread = AfxBeginThread(CommThread, this ))) return FALSE; TRACE("Thread started/n" ); return TRUE; } // // Restart the comm thread // //重启监视线程（挂起重启） BOOL CSerialPort::RestartMonitoring() { TRACE("Thread resumed/n" ); m_Thread->ResumeThread(); return TRUE; } // // Suspend the comm thread // //挂起监视线程 BOOL CSerialPort::StopMonitoring() { TRACE("Thread suspended/n" ); m_Thread->SuspendThread(); return TRUE; } (3)监视线程我们把读写串口的操作全部交给监视线程，现在简单看一下监视线程的大致流程：检查串口-->进入循环{WaitCommEvent(不阻塞询问)询问事件-->如果有事件来到-->到相应处理(关闭/读/写)} 详细代码如下: view plain copy to clipboard print ? //监视串口函数 UINT CSerialPort::CommThread( LPVOID pParam) { // Cast the void pointer passed to the thread back to // a pointer of CSerialPort class CSerialPort *port = (CSerialPort*)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_RXABORT | PURGE_TXABORT); // begin forever loop. This loop will run as long as the thread is alive. //不断读取数据 for (;;) { // Make a call to WaitCommEvent(). This call will return immediatly // because our port was created as an async port (FILE_FLAG_OVERLAPPED // and an m_OverlappedStructerlapped structure specified). This call will cause the // m_OverlappedStructerlapped element m_OverlappedStruct.hEvent, which is part of the m_hEventArray to // be placed in a non-signeled state if there are no bytes available to be read, // or to a signeled state if there are bytes available. If this event handle // is set to the non-signeled state, it will be set to signeled when a // character arrives at the port. // we do this for each port! /******************************************************************** WaitCommEvent函数第3个参数1pOverlapped可以是一个OVERLAPPED结构的变量指针，也可以是NULL，当用NULL时，表示该函数是同步的，否则表示该函数是异步的。调用WaitCommEvent时，如果异步操作不能立即完成，会立即返回FALSE，系统在 WaitCommEvent返回前将OVERLAPPED结构成员hEvent设为无信号状态，等到产生通信事件时，系统将其置有信号 ***********************************************************************/ bResult = WaitCommEvent(port->m_hComm, &Event, &port->m_ov);//表示该函数是异步的 if (!bResult) { //如果WaitCommEvent返回Error为NULL，则查询错误信息 // If WaitCommEvent() returns FALSE, process the last error to determin // the reason.. switch (dwError = GetLastError()) { case ERROR_IO_PENDING: //正常情况，没有字符可读 { // This is a normal return value if there are no bytes // to read at the port. // Do nothing and continue break ; } case 87: //系统错误 { // Under Windows NT, this value is returned for some reason. // I have not investigated why, but it is also a valid reply // Also do nothing and continue. break ; } default : //发生其他错误 { // All other error codes indicate a serious error has // occured. Process this error. port->ProcessErrorMessage("WaitCommEvent()" ); break ; } } } else //WaitCommEvent()能正确返回 { // If WaitCommEvent() returns TRUE, check to be sure there are // actually bytes in the buffer to read. // // If you are reading more than one byte at a time from the buffer // (which this program does not do) you will have the situation occur // where the first byte to arrive will cause the WaitForMultipleObjects() // function to stop waiting. The WaitForMultipleObjects() function // resets the event handle in m_OverlappedStruct.hEvent to the non-signelead state // as it returns. // // If in the time between the reset of this event and the call to // ReadFile() more bytes arrive, the m_OverlappedStruct.hEvent handle will be set again // to the signeled state. When the call to ReadFile() occurs, it will // read all of the bytes from the buffer, and the program will // loop back around to WaitCommEvent(). // // At this point you will be in the situation where m_OverlappedStruct.hEvent is set, // but there are no bytes available to read. If you proceed and call // ReadFile(), it will return immediatly due to the async port setup, but // GetOverlappedResults() will not return until the next character arrives. // // It is not desirable for the GetOverlappedResults() function to be in // this state. The thread shutdown event (event 0) and the WriteFile() // event (Event2) will not work if the thread is blocked by GetOverlappedResults(). // // The solution to this is to check the buffer with a call to ClearCommError(). // This call will reset the event handle, and if there are no bytes to read // we can loop back through WaitCommEvent() again, then proceed. // If there are really bytes to read, do nothing and proceed. bResult = ClearCommError(port->m_hComm, &dwError, &comstat); if (comstat.cbInQue == 0) continue ; } // end if bResult //主等待函数，会阻塞线程 // Main wait function. This function will normally block the thread // until one of nine events occur that require action. //等待3个事件：关断/读/写，有一个事件发生就返回 Event = WaitForMultipleObjects(3, //3个事件 port->m_hEventArray,//事件数组 FALSE, //有一个事件发生就返回 INFINITE); //超时时间 switch (Event) { case 0: { // Shutdown event. This is event zero so it will be // the higest priority and be serviced first. //关断事件，关闭串口 CloseHandle(port->m_hComm); port->m_hComm=NULL; port->m_bThreadAlive = FALSE; // Kill this thread. break is not needed, but makes me feel better. AfxEndThread(100); break ; } case 1: // read event 将定义的各种消息发送出去 { //接收 GetCommMask(port->m_hComm, &CommEvent); if (CommEvent & EV_RXCHAR) // Receive character event from port. ReceiveChar(port, comstat); if (CommEvent & EV_CTS) ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_CTS_DETECTED, (WPARAM ) 0, ( LPARAM ) port->m_nPortNr); if (CommEvent & EV_BREAK) ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_BREAK_DETECTED, (WPARAM ) 0, ( LPARAM ) port->m_nPortNr); if (CommEvent & EV_ERR) ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_ERR_DETECTED, (WPARAM ) 0, ( LPARAM ) port->m_nPortNr); if (CommEvent & EV_RING) ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_RING_DETECTED, (WPARAM ) 0, ( LPARAM ) port->m_nPortNr); if (CommEvent & EV_RXFLAG) ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_RXFLAG_DETECTED, (WPARAM ) 0, ( LPARAM ) port->m_nPortNr); break ; } case 2: // write event发送数据 { // Write character event from port //写 WriteChar(port); break ; } } // end switch } // close forever loop return 0; } (4)读取数据操作读取数据是一个异步操作，当有数据发来时，会触发读事件m_ov.hEvent，监视线程捕捉到事件后并获知是读事件，进入相关读处理，这里调用函数ReceiveChar ，ReceiveChar中调用ReadFile函数将串口数据读到Buffer缓冲中，相关代码如下： view plain copy to clipboard print ? //接收数据 void CSerialPort::ReceiveChar(CSerialPort* 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. //更新COMSTAT 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, // Handle 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 still in progress // Proceed on to GetOverlappedResults(); //异步IO仍在进行 bRead = FALSE; break ; } default : { //其他错误处理 // Another error has occured. Process this error. port->ProcessErrorMessage("ReadFile()" ); break ; } } } else { //ReadFile返回TRUE // ReadFile() returned complete. It is not necessary to call GetOverlappedResults() bRead = TRUE; } } // close if (bRead) //异步IO操作仍在进行，需要调用GetOverlappedResult查询 if (!bRead) { bRead = TRUE; bResult = GetOverlappedResult(port->m_hComm, // Handle 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)->m_hWnd, WM_COMM_RXCHAR, (WPARAM ) RXBuff, ( LPARAM ) port->m_nPortNr); } // end forever loop }

(5)写数据

也是由监视线程操作，不过触发事件交给主线程来触发，函数是WriteToPort

//   
    // Write a string to the port   
    //   
    void  CSerialPort::WriteToPort( char * string)  
    {         
        assert(m_hComm != 0);  
        //写进写缓冲区   
        memset(m_szWriteBuffer, 0, sizeof (m_szWriteBuffer));  
        strcpy(m_szWriteBuffer, string);  
        m_nWriteSize=strlen(string);  
      
        // set event for write   
        SetEvent(m_hWriteEvent);  
    }  
线程调用的函数WriteChar，把缓冲里的数据写到串口中，期间调用WriteFile
详细代码：
view plain copy to clipboard print ?
    //写数据   
    void  CSerialPort::WriteChar(CSerialPort* 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_RXABORT | PURGE_TXABORT);  
      
            //串口写入   
            bResult = WriteFile(port->m_hComm,                           // Handle to COMM Port   
                                port->m_szWriteBuffer,                   // Pointer to message buffer in calling finction   
    //                          strlen((char*)port->m_szWriteBuffer),    // Length of message to send   
                                port->m_nWriteSize,  // Length of message to send   
                                &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 GetOverlappedResults()   
                            BytesSent = 0;  
                            bWrite = FALSE;  
                            break ;  
                        }  
                    default :  
                        {  
                            // all other error codes   
                            port->ProcessErrorMessage("WriteFile()" );  
                        }  
                }  
            }   
            else   
            {  
                LeaveCriticalSection(&port->m_csCommunicationSync);  
            }  
        } // end if(bWrite)   
      
        if  (!bWrite)  
        {  
            bWrite = TRUE;  
          
            bResult = GetOverlappedResult(port->m_hComm, // Handle to COMM port    
                                          &port->m_ov,       // Overlapped structure   
                                          &BytesSent,       // Stores number of bytes sent   
                                          TRUE);            // Wait flag   
      
            LeaveCriticalSection(&port->m_csCommunicationSync);  
      
            // deal with the error code    
    //      if (!bResult)     
            {  
    //          port->ProcessErrorMessage("GetOverlappedResults() in WriteFile()");   
            }     
        } // end if (!bWrite)   
      
        //Verify that the data size send equals what we tried to send   
        if  (BytesSent != port->m_nWriteSize)  // Length of message to send)   
        {  
            TRACE("WARNING: WriteFile() error.. Bytes Sent: %d; Message Length: %d/n" , BytesSent, strlen(( char *)port->m_szWriteBuffer));  
        }  
    //  ::SendMessage((port->m_pOwner)->m_hWnd, WM_COMM_TXEMPTY_DETECTED, (WPARAM) RXBuff, (LPARAM) port->m_nPortNr);   
    //  ::SendMessage((port->m_pOwner)->m_hWnd, WM_COMM_TXEMPTY_DETECTED,0,(LPARAM) port->m_nPortNr);   
    }  
(6)其他操作
其他比如获取DCB，关闭等，比较简单，不做分析
代码如下：
view plain copy to clipboard print ?
    //   
    // Return the device control block   
    //   
    DCB CSerialPort::GetDCB()  
    {  
        return  m_dcb;  
    }  
      
    //   
    // Return the communication event masks   
    //   
    DWORD  CSerialPort::GetCommEvents()  
    {  
        return  m_dwCommEvents;  
    }  
      
    //   
    // Return the output buffer size   
    //   
    DWORD  CSerialPort::GetWriteBufferSize()  
    {  
        return  m_nWriteBufferSize;  
    }  
      
      
    void  CSerialPort::ClosePort()  
    {  
            SetEvent(m_hShutdownEvent);  
    }

好了，SerialPort代码分析到此为止，我水平有限，分析可能有不少问题，欢迎大家指出