SerialPort类源代码分析

转载 2011年11月15日 11:21:29
 

转载于:http://hi.baidu.com/laoyang1018/blog/item/9949500f5e5f9a396059f3db.html

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

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

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

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;  //写缓冲大小

函数成员:

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(不阻塞询问)询问事件-->如果有事件来到-->到相应处理(关闭\读\写)}

详细代码如下:

//监视串口函数
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缓冲中,相关代码如下:

//接收数据
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

详细代码

//写数据
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,关闭等,比较简单,不做分析

代码如下

//
// 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代码分析到此为止,我水平有限,分析可能有不少问题,欢迎大家指出


相关文章推荐

CSerialPort串口类最新修正版2017-03-12

这是一份优秀的串口类文件,好多的地方值得我们学习,具体在多线程,事件,自定义消息,类的封装方面等等。 Remon提供的串口类网址为: http://codeguru.earthweb.com/netw...
  • itas109
  • itas109
  • 2016年05月07日 13:59
  • 5341

CSerialPort串口类最新修正版(解决关闭死锁问题)2014-01-11

CSerialPort串口类最初由Remon编写,是一份优秀的类文件,好多的地方值得我们学习,具体在多线程,事件,自定义消息,类的封装方面等等。由于已经运行十几年了,原文的问答部分列出来这么多年来的问...

CSerialPort类解析

CserialPort类的功能及成员函数介绍CserialPort类是免费提供的串口累,Codeguru是一个非常不错的源代码网站CserialPort类支持线连接(非MODEM)的串口编程操作。Cs...
  • Augusdi
  • Augusdi
  • 2014年05月15日 11:12
  • 15743

字符集研究之多字节字符集和unicode字符集

作者:朱金灿来源:http://blog.csdn.net/clever101         本文简单介绍计算机中两大字符集:多字节字符集和unicode字符集的出现及关系。         首先我...

VS 字符集:Unicode和多字节字符集的区别与联系

在程序正确编译运行的情况下,结果出现以下情况:可见,列表中出现了奇怪字符,我打开项目属性-配置属性-常规-字符集。发现,字符集是使用Unicode的。随后,我将该选项切换至多字节字符集。程序结果如下:...

SerialPort类源代码分析

前几篇串口编程大致讲述了Windows下串口的大致操作,接下来分析流行的SerialPort类,它把Windows API封装好,方便开发利用1、Win32下串口大致操作流程(1)打开串口:Creat...

c#serialport类实现串口通信的源代码

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; usin...

在C#中使用SerialPort类实现串口通信

在C#中使用SerialPort类实现串口通信(收藏  在.NET Framework 2.0中提供了SerialPort类,该类主要实现串口数据通信等。本文章将本人在学习过程中从网络上搜集到的相关...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:SerialPort类源代码分析
举报原因:
原因补充:

(最多只允许输入30个字)