开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
serialport.cpp
资源名称：serialport.zip　[点击查看]
上传用户：hxj5298
上传日期：2007-01-03
资源大小：18k
文件大小：19k
源码类别：

通讯编程

开发平台：

Visual C++

serialport.cpp：源码内容
  1. /*
  2. Module : SERIALPORT.CPP
  3. Purpose: Implementation for an MFC wrapper class for serial ports
  4. Created: PJN / 31-05-1999
  5. History: PJN / 03-06-1999 1. Fixed problem with code using CancelIo which does not exist on 95.
  6.                           2. Fixed leaks which can occur in sample app when an exception is thrown
  7.          PJN / 16-06-1999 1. Fixed a bug whereby CString::ReleaseBuffer was not being called in 
  8.                              CSerialException::GetErrorMessage
  9.          PJN / 29-09-1999 1. Fixed a simple copy and paste bug in CSerialPort::SetDTR
  11. Copyright (c) 1999 by PJ Naughter.  
  12. All rights reserved.
  14. */
  16. /////////////////////////////////  Includes  //////////////////////////////////
  17. #include "stdafx.h"
  18. #include "serialport.h"
  19. #include "winerror.h"
  24. ///////////////////////////////// defines /////////////////////////////////////
  26. #ifdef _DEBUG
  27. #define new DEBUG_NEW
  28. #undef THIS_FILE
  29. static char THIS_FILE[] = __FILE__;
  30. #endif
  35. //////////////////////////////// Implementation ///////////////////////////////
  39. //Class which handles CancelIo function which must be constructed at run time
  40. //since it is not imeplemented on NT 3.51 or Windows 95. To avoid the loader
  41. //bringing up a message such as "Failed to load due to missing export...", the
  42. //function is constructed using GetProcAddress. The CSerialPort::CancelIo 
  43. //function then checks to see if the function pointer is NULL and if it is it 
  44. //throws an exception using the error code ERROR_CALL_NOT_IMPLEMENTED which
  45. //is what 95 would have done if it had implemented a stub for it in the first
  46. //place !!
  48. class _SERIAL_PORT_DATA
  49. {
  50. public:
  51. //Constructors /Destructors
  52.   _SERIAL_PORT_DATA();
  53.   ~_SERIAL_PORT_DATA();
  55.   HINSTANCE m_hKernel32;
  56.   typedef BOOL (CANCELIO)(HANDLE);
  57.   typedef CANCELIO* LPCANCELIO;
  58.   LPCANCELIO m_lpfnCancelIo;
  59. };
  61. _SERIAL_PORT_DATA::_SERIAL_PORT_DATA()
  62. {
  63.   m_hKernel32 = LoadLibrary(_T("KERNEL32.DLL"));
  64.   VERIFY(m_hKernel32 != NULL);
  65.   m_lpfnCancelIo = (LPCANCELIO) GetProcAddress(m_hKernel32, "CancelIo");
  66. }
  68. _SERIAL_PORT_DATA::~_SERIAL_PORT_DATA()
  69. {
  70.   FreeLibrary(m_hKernel32);
  71.   m_hKernel32 = NULL;
  72. }
  75. //The local variable which handle the function pointers
  77. _SERIAL_PORT_DATA _SerialPortData;
  82. ////////// Exception handling code
  84. void AfxThrowSerialException(DWORD dwError /* = 0 */)
  85. {
  86. if (dwError == 0)
  87. dwError = ::GetLastError();
  89. CSerialException* pException = new CSerialException(dwError);
  91. TRACE(_T("Warning: throwing CSerialException for error %dn"), dwError);
  92. THROW(pException);
  93. }
  95. BOOL CSerialException::GetErrorMessage(LPTSTR pstrError, UINT nMaxError, PUINT pnHelpContext)
  96. {
  97. ASSERT(pstrError != NULL && AfxIsValidString(pstrError, nMaxError));
  99. if (pnHelpContext != NULL)
  100. *pnHelpContext = 0;
  102. LPTSTR lpBuffer;
  103. BOOL bRet = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  104.                       NULL,  m_dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_SYS_DEFAULT),
  105.                       (LPTSTR) &lpBuffer, 0, NULL);
  107. if (bRet == FALSE)
  108. *pstrError = '';
  109. else
  110. {
  111. lstrcpyn(pstrError, lpBuffer, nMaxError);
  112. bRet = TRUE;
  114. LocalFree(lpBuffer);
  115. }
  117. return bRet;
  118. }
  120. CString CSerialException::GetErrorMessage()
  121. {
  122.   CString rVal;
  123.   LPTSTR pstrError = rVal.GetBuffer(4096);
  124.   GetErrorMessage(pstrError, 4096, NULL);
  125.   rVal.ReleaseBuffer();
  126.   return rVal;
  127. }
  129. CSerialException::CSerialException(DWORD dwError)
  130. {
  131. m_dwError = dwError;
  132. }
  134. CSerialException::~CSerialException()
  135. {
  136. }
  138. IMPLEMENT_DYNAMIC(CSerialException, CException)
  140. #ifdef _DEBUG
  141. void CSerialException::Dump(CDumpContext& dc) const
  142. {
  143. CObject::Dump(dc);
  145. dc << "m_dwError = " << m_dwError;
  146. }
  147. #endif
  153. ////////// The actual serial port code
  155. CSerialPort::CSerialPort()
  156. {
  157.   m_hComm = INVALID_HANDLE_VALUE;
  158.   m_bOverlapped = FALSE;
  159. }
  161. CSerialPort::~CSerialPort()
  162. {
  163.   Close();
  164. }
  166. IMPLEMENT_DYNAMIC(CSerialPort, CObject)
  168. #ifdef _DEBUG
  169. void CSerialPort::Dump(CDumpContext& dc) const
  170. {
  171. CObject::Dump(dc);
  173. dc << _T("m_hComm = ") << m_hComm << _T("n");
  174.   dc << _T("m_bOverlapped = ") << m_bOverlapped;
  175. }
  176. #endif
  178. void CSerialPort::Open(int nPort, DWORD dwBaud, Parity parity, BYTE DataBits, StopBits stopbits, FlowControl fc, BOOL bOverlapped)
  179. {
  180.   //Validate our parameters
  181.   ASSERT(nPort>0 && nPort<=255);
  183.   //Call CreateFile to open up the comms port
  184.   CString sPort;
  185.   sPort.Format(_T("\\.\COM%d"), nPort);
  186.   m_hComm = CreateFile(sPort, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, bOverlapped ? FILE_FLAG_OVERLAPPED : 0, NULL);
  187.   if (m_hComm == INVALID_HANDLE_VALUE)
  188.   {
  189.     TRACE(_T("Failed to open up the comms portn"));
  190.     AfxThrowSerialException();
  191.   }
  192.   
  193.   m_bOverlapped = bOverlapped;
  195.   //Get the current state prior to changing it
  196.   DCB dcb;
  197.   GetState(dcb);
  199.   //Setup the baud rate
  200.   dcb.BaudRate = dwBaud; 
  202.   //Setup the Parity
  203.   switch (parity)
  204.   {
  205.     case EvenParity:  dcb.Parity = EVENPARITY;  break;
  206.     case MarkParity:  dcb.Parity = MARKPARITY;  break;
  207.     case NoParity:    dcb.Parity = NOPARITY;    break;
  208.     case OddParity:   dcb.Parity = ODDPARITY;   break;
  209.     case SpaceParity: dcb.Parity = SPACEPARITY; break;
  210.     default:          ASSERT(FALSE);            break;
  211.   }
  213.   //Setup the data bits
  214.   dcb.ByteSize = DataBits;
  216.   //Setup the stop bits
  217.   switch (stopbits)
  218.   {
  219.     case OneStopBit:           dcb.StopBits = ONESTOPBIT;   break;
  220.     case OnePointFiveStopBits: dcb.StopBits = ONE5STOPBITS; break;
  221.     case TwoStopBits:          dcb.StopBits = TWOSTOPBITS;  break;
  222.     default:                   ASSERT(FALSE);               break;
  223.   }
  225.   //Setup the flow control 
  226.   dcb.fDsrSensitivity = FALSE;
  227.   switch (fc)
  228.   {
  229.     case NoFlowControl:
  230.     {
  231.       dcb.fOutxCtsFlow = FALSE;
  232.       dcb.fOutxDsrFlow = FALSE;
  233.       dcb.fOutX = FALSE;
  234.       dcb.fInX = FALSE;
  235.       break;
  236.     }
  237.     case CtsRtsFlowControl:
  238.     {
  239.       dcb.fOutxCtsFlow = TRUE;
  240.       dcb.fOutxDsrFlow = FALSE;
  241.       dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
  242.       dcb.fOutX = FALSE;
  243.       dcb.fInX = FALSE;
  244.       break;
  245.     }
  246.     case CtsDtrFlowControl:
  247.     {
  248.       dcb.fOutxCtsFlow = TRUE;
  249.       dcb.fOutxDsrFlow = FALSE;
  250.       dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
  251.       dcb.fOutX = FALSE;
  252.       dcb.fInX = FALSE;
  253.       break;
  254.     }
  255.     case DsrRtsFlowControl:
  256.     {
  257.       dcb.fOutxCtsFlow = FALSE;
  258.       dcb.fOutxDsrFlow = TRUE;
  259.       dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
  260.       dcb.fOutX = FALSE;
  261.       dcb.fInX = FALSE;
  262.       break;
  263.     }
  264.     case DsrDtrFlowControl:
  265.     {
  266.       dcb.fOutxCtsFlow = FALSE;
  267.       dcb.fOutxDsrFlow = TRUE;
  268.       dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
  269.       dcb.fOutX = FALSE;
  270.       dcb.fInX = FALSE;
  271.       break;
  272.     }
  273.     case XonXoffFlowControl:
  274.     {
  275.       dcb.fOutxCtsFlow = FALSE;
  276.       dcb.fOutxDsrFlow = FALSE;
  277.       dcb.fOutX = TRUE;
  278.       dcb.fInX = TRUE;
  279.       dcb.XonChar = 0x11;
  280.       dcb.XoffChar = 0x13;
  281.       dcb.XoffLim = 100;
  282.       dcb.XonLim = 100;
  283.       break;
  284.     }
  285.     default:
  286.     {
  287.       ASSERT(FALSE);
  288.       break;
  289.     }
  290.   }
  291.   
  292.   //Now that we have all the settings in place, make the changes
  293.   SetState(dcb);
  294. }
  296. void CSerialPort::Close()
  297. {
  298.   if (IsOpen())
  299.   {
  300.     BOOL bSuccess = CloseHandle(m_hComm);
  301.     m_hComm = INVALID_HANDLE_VALUE;
  302.     if (!bSuccess)
  303.       TRACE(_T("Failed to close up the comms port, GetLastError:%dn"), GetLastError());
  304.     m_bOverlapped = FALSE;
  305.   }
  306. }
  308. void CSerialPort::Attach(HANDLE hComm)
  309. {
  310.   Close();
  311.   m_hComm = hComm;  
  312. }
  314. HANDLE CSerialPort::Detach()
  315. {
  316.   HANDLE hrVal = m_hComm;
  317.   m_hComm = INVALID_HANDLE_VALUE;
  318.   return hrVal;
  319. }
  321. DWORD CSerialPort::Read(void* lpBuf, DWORD dwCount)
  322. {
  323.   ASSERT(IsOpen());
  324.   ASSERT(!m_bOverlapped);
  326.   DWORD dwBytesRead = 0;
  327.   if (!ReadFile(m_hComm, lpBuf, dwCount, &dwBytesRead, NULL))
  328.   {
  329.     TRACE(_T("Failed in call to ReadFilen"));
  330.     AfxThrowSerialException();
  331.   }
  333.   return dwBytesRead;
  334. }
  336. BOOL CSerialPort::Read(void* lpBuf, DWORD dwCount, OVERLAPPED& overlapped)
  337. {
  338.   ASSERT(IsOpen());
  339.   ASSERT(m_bOverlapped);
  340.   ASSERT(overlapped.hEvent);
  342.   DWORD dwBytesRead = 0;
  343.   BOOL bSuccess = ReadFile(m_hComm, lpBuf, dwCount, &dwBytesRead, &overlapped);
  344.   if (!bSuccess)
  345.   {
  346.     if (GetLastError() != ERROR_IO_PENDING)
  347.     {
  348.       TRACE(_T("Failed in call to ReadFilen"));
  349.       AfxThrowSerialException();
  350.     }
  351.   }
  352.   return bSuccess;
  353. }
  355. DWORD CSerialPort::Write(const void* lpBuf, DWORD dwCount)
  356. {
  357.   ASSERT(IsOpen());
  358.   ASSERT(!m_bOverlapped);
  360.   DWORD dwBytesWritten = 0;
  361.   if (!WriteFile(m_hComm, lpBuf, dwCount, &dwBytesWritten, NULL))
  362.   {
  363.     TRACE(_T("Failed in call to WriteFilen"));
  364.     AfxThrowSerialException();
  365.   }
  367.   return dwBytesWritten;
  368. }
  370. BOOL CSerialPort::Write(const void* lpBuf, DWORD dwCount, OVERLAPPED& overlapped)
  371. {
  372.   ASSERT(IsOpen());
  373.   ASSERT(m_bOverlapped);
  374.   ASSERT(overlapped.hEvent);
  376.   DWORD dwBytesWritten = 0;
  377.   BOOL bSuccess = WriteFile(m_hComm, lpBuf, dwCount, &dwBytesWritten, &overlapped);
  378.   if (!bSuccess)
  379.   {
  380.     if (GetLastError() != ERROR_IO_PENDING)
  381.     {
  382.       TRACE(_T("Failed in call to WriteFilen"));
  383.       AfxThrowSerialException();
  384.     }
  385.   }
  386.   return bSuccess;
  387. }
  389. void CSerialPort::GetOverlappedResult(OVERLAPPED& overlapped, DWORD& dwBytesTransferred, BOOL bWait)
  390. {
  391.   ASSERT(IsOpen());
  392.   ASSERT(m_bOverlapped);
  393.   ASSERT(overlapped.hEvent);
  395.   DWORD dwBytesWritten = 0;
  396.   if (!::GetOverlappedResult(m_hComm, &overlapped, &dwBytesTransferred, bWait))
  397.   {
  398.     if (GetLastError() != ERROR_IO_PENDING)
  399.     {
  400.       TRACE(_T("Failed in call to GetOverlappedResultn"));
  401.       AfxThrowSerialException();
  402.     }
  403.   }
  404. }
  406. void CSerialPort::_OnCompletion(DWORD dwErrorCode, DWORD dwCount, LPOVERLAPPED lpOverlapped)
  407. {
  408.   //Validate our parameters
  409.   ASSERT(lpOverlapped);
  411.   //Convert back to the C++ world
  412.   CSerialPort* pSerialPort = (CSerialPort*) lpOverlapped->hEvent;
  413.   ASSERT(pSerialPort->IsKindOf(RUNTIME_CLASS(CSerialPort)));
  415.   //Call the C++ function
  416.   pSerialPort->OnCompletion(dwErrorCode, dwCount, lpOverlapped);
  417. }
  419. void CSerialPort::OnCompletion(DWORD /*dwErrorCode*/, DWORD /*dwCount*/, LPOVERLAPPED lpOverlapped)
  420. {
  421.   //Just free up the memory which was previously allocated for the OVERLAPPED structure
  422.   delete lpOverlapped;
  424.   //Your derived classes can do something useful in OnCompletion, but don't forget to
  425.   //call CSerialPort::OnCompletion to ensure the memory is freed up
  426. }
  428. void CSerialPort::CancelIo()
  429. {
  430.   ASSERT(IsOpen());
  432.   if (_SerialPortData.m_lpfnCancelIo == NULL)
  433.   {
  434.     TRACE(_T("CancelIo function is not supported on this OS. You need to be running at least NT 4 or Win 98 to use this functionn"));
  435.     AfxThrowSerialException(ERROR_CALL_NOT_IMPLEMENTED);  
  436.   }
  438.   if (!::_SerialPortData.m_lpfnCancelIo(m_hComm))
  439.   {
  440.     TRACE(_T("Failed in call to CancelIOn"));
  441.     AfxThrowSerialException();
  442.   }
  443. }
  445. void CSerialPort::WriteEx(const void* lpBuf, DWORD dwCount)
  446. {
  447.   ASSERT(IsOpen());
  449.   OVERLAPPED* pOverlapped = new OVERLAPPED;
  450.   ZeroMemory(pOverlapped, sizeof(OVERLAPPED));
  451.   pOverlapped->hEvent = (HANDLE) this;
  452.   if (!WriteFileEx(m_hComm, lpBuf, dwCount, pOverlapped, _OnCompletion))
  453.   {
  454.     delete pOverlapped;
  455.     TRACE(_T("Failed in call to WriteFileExn"));
  456.     AfxThrowSerialException();
  457.   }
  458. }
  460. void CSerialPort::ReadEx(void* lpBuf, DWORD dwCount)
  461. {
  462.   ASSERT(IsOpen());
  464.   OVERLAPPED* pOverlapped = new OVERLAPPED;
  465.   ZeroMemory(pOverlapped, sizeof(OVERLAPPED));
  466.   pOverlapped->hEvent = (HANDLE) this;
  467.   if (!ReadFileEx(m_hComm, lpBuf, dwCount, pOverlapped, _OnCompletion))
  468.   {
  469.     delete pOverlapped;
  470.     TRACE(_T("Failed in call to ReadFileExn"));
  471.     AfxThrowSerialException();
  472.   }
  473. }
  475. void CSerialPort::TransmitChar(char cChar)
  476. {
  477.   ASSERT(IsOpen());
  479.   if (!TransmitCommChar(m_hComm, cChar))
  480.   {
  481.     TRACE(_T("Failed in call to TransmitCommCharn"));
  482.     AfxThrowSerialException();
  483.   }
  484. }
  486. void CSerialPort::GetConfig(COMMCONFIG& config)
  487. {
  488.   ASSERT(IsOpen());
  490.   DWORD dwSize = sizeof(COMMCONFIG);
  491.   if (!GetCommConfig(m_hComm, &config, &dwSize))
  492.   {
  493.     TRACE(_T("Failed in call to GetCommConfign"));
  494.     AfxThrowSerialException();
  495.   }
  496. }
  498. void CSerialPort::SetConfig(COMMCONFIG& config)
  499. {
  500.   ASSERT(IsOpen());
  502.   DWORD dwSize = sizeof(COMMCONFIG);
  503.   if (!SetCommConfig(m_hComm, &config, dwSize))
  504.   {
  505.     TRACE(_T("Failed in call to SetCommConfign"));
  506.     AfxThrowSerialException();
  507.   }
  508. }
  510. void CSerialPort::SetBreak()
  511. {
  512.   ASSERT(IsOpen());
  514.   if (!SetCommBreak(m_hComm))
  515.   {
  516.     TRACE(_T("Failed in call to SetCommBreakn"));
  517.     AfxThrowSerialException();
  518.   }
  519. }
  521. void CSerialPort::ClearBreak()
  522. {
  523.   ASSERT(IsOpen());
  525.   if (!ClearCommBreak(m_hComm))
  526.   {
  527.     TRACE(_T("Failed in call to SetCommBreakn"));
  528.     AfxThrowSerialException();
  529.   }
  530. }
  532. void CSerialPort::ClearError(DWORD& dwErrors)
  533. {
  534.   ASSERT(IsOpen());
  536.   if (!ClearCommError(m_hComm, &dwErrors, NULL))
  537.   {
  538.     TRACE(_T("Failed in call to ClearCommErrorn"));
  539.     AfxThrowSerialException();
  540.   }
  541. }
  543. void CSerialPort::GetDefaultConfig(int nPort, COMMCONFIG& config)
  544. {
  545.   //Validate our parameters
  546.   ASSERT(nPort>0 && nPort<=255);
  548.   //Create the device name as a string
  549.   CString sPort;
  550.   sPort.Format(_T("COM%d"), nPort);
  552.   DWORD dwSize = sizeof(COMMCONFIG);
  553.   if (!GetDefaultCommConfig(sPort, &config, &dwSize))
  554.   {
  555.     TRACE(_T("Failed in call to GetDefaultCommConfign"));
  556.     AfxThrowSerialException();
  557.   }
  558. }
  560. void CSerialPort::SetDefaultConfig(int nPort, COMMCONFIG& config)
  561. {
  562.   //Validate our parameters
  563.   ASSERT(nPort>0 && nPort<=255);
  565.   //Create the device name as a string
  566.   CString sPort;
  567.   sPort.Format(_T("COM%d"), nPort);
  569.   DWORD dwSize = sizeof(COMMCONFIG);
  570.   if (!SetDefaultCommConfig(sPort, &config, dwSize))
  571.   {
  572.     TRACE(_T("Failed in call to GetDefaultCommConfign"));
  573.     AfxThrowSerialException();
  574.   }
  575. }
  577. void CSerialPort::GetStatus(COMSTAT& stat)
  578. {
  579.   ASSERT(IsOpen());
  581.   DWORD dwErrors;
  582.   if (!ClearCommError(m_hComm, &dwErrors, &stat))
  583.   {
  584.     TRACE(_T("Failed in call to ClearCommErrorn"));
  585.     AfxThrowSerialException();
  586.   }
  587. }
  589. void CSerialPort::GetState(DCB& dcb)
  590. {
  591.   ASSERT(IsOpen());
  593.   if (!GetCommState(m_hComm, &dcb))
  594.   {
  595.     TRACE(_T("Failed in call to GetCommStaten"));
  596.     AfxThrowSerialException();
  597.   }
  598. }
  600. void CSerialPort::SetState(DCB& dcb)
  601. {
  602.   ASSERT(IsOpen());
  604.   if (!SetCommState(m_hComm, &dcb))
  605.   {
  606.     TRACE(_T("Failed in call to SetCommStaten"));
  607.     AfxThrowSerialException();
  608.   }
  609. }
  611. void CSerialPort::Escape(DWORD dwFunc)
  612. {
  613.   ASSERT(IsOpen());
  615.   if (!EscapeCommFunction(m_hComm, dwFunc))
  616.   {
  617.     TRACE(_T("Failed in call to EscapeCommFunctionn"));
  618.     AfxThrowSerialException();
  619.   }
  620. }
  622. void CSerialPort::ClearDTR()
  623. {
  624.   Escape(CLRDTR);
  625. }
  627. void CSerialPort::ClearRTS()
  628. {
  629.   Escape(CLRRTS);
  630. }
  632. void CSerialPort::SetDTR()
  633. {
  634.   Escape(SETDTR);
  635. }
  637. void CSerialPort::SetRTS()
  638. {
  639.   Escape(SETRTS);
  640. }
  642. void CSerialPort::SetXOFF()
  643. {
  644.   Escape(SETXOFF);
  645. }
  647. void CSerialPort::SetXON()
  648. {
  649.   Escape(SETXON);
  650. }
  652. void CSerialPort::GetProperties(COMMPROP& properties)
  653. {
  654.   ASSERT(IsOpen());
  656.   if (!GetCommProperties(m_hComm, &properties))
  657.   {
  658.     TRACE(_T("Failed in call to GetCommPropertiesn"));
  659.     AfxThrowSerialException();
  660.   }
  661. }
  663. void CSerialPort::GetModemStatus(DWORD& dwModemStatus)
  664. {
  665.   ASSERT(IsOpen());
  667.   if (!GetCommModemStatus(m_hComm, &dwModemStatus))
  668.   {
  669.     TRACE(_T("Failed in call to GetCommModemStatusn"));
  670.     AfxThrowSerialException();
  671.   }
  672. }
  674. void CSerialPort::SetMask(DWORD dwMask)
  675. {
  676.   ASSERT(IsOpen());
  678.   if (!SetCommMask(m_hComm, dwMask))
  679.   {
  680.     TRACE(_T("Failed in call to SetCommMaskn"));
  681.     AfxThrowSerialException();
  682.   }
  683. }
  685. void CSerialPort::GetMask(DWORD& dwMask)
  686. {
  687.   ASSERT(IsOpen());
  689.   if (!GetCommMask(m_hComm, &dwMask))
  690.   {
  691.     TRACE(_T("Failed in call to GetCommMaskn"));
  692.     AfxThrowSerialException();
  693.   }
  694. }
  696. void CSerialPort::Flush()
  697. {
  698.   ASSERT(IsOpen());
  700.   if (!FlushFileBuffers(m_hComm))
  701.   {
  702.     TRACE(_T("Failed in call to FlushFileBuffersn"));
  703.     AfxThrowSerialException();
  704.   }
  705. }
  707. void CSerialPort::Purge(DWORD dwFlags)
  708. {
  709.   ASSERT(IsOpen());
  711.   if (!PurgeComm(m_hComm, dwFlags))
  712.   {
  713.     TRACE(_T("Failed in call to PurgeCommn"));
  714.     AfxThrowSerialException();
  715.   }
  716. }
  718. void CSerialPort::TerminateOutstandingWrites()
  719. {
  720.   Purge(PURGE_TXABORT);
  721. }
  723. void CSerialPort::TerminateOutstandingReads()
  724. {
  725.   Purge(PURGE_RXABORT);
  726. }
  728. void CSerialPort::ClearWriteBuffer()
  729. {
  730.   Purge(PURGE_TXCLEAR);
  731. }
  733. void CSerialPort::ClearReadBuffer()
  734. {
  735.   Purge(PURGE_RXCLEAR);
  736. }
  738. void CSerialPort::Setup(DWORD dwInQueue, DWORD dwOutQueue)
  739. {
  740.   ASSERT(IsOpen());
  742.   if (!SetupComm(m_hComm, dwInQueue, dwOutQueue))
  743.   {
  744.     TRACE(_T("Failed in call to SetupCommn"));
  745.     AfxThrowSerialException();
  746.   }
  747. }
  749. void CSerialPort::SetTimeouts(COMMTIMEOUTS& timeouts)
  750. {
  751.   ASSERT(IsOpen());
  753.   if (!SetCommTimeouts(m_hComm, &timeouts))
  754.   {
  755.     TRACE(_T("Failed in call to SetCommTimeoutsn"));
  756.     AfxThrowSerialException();
  757.   }
  758. }
  760. void CSerialPort::GetTimeouts(COMMTIMEOUTS& timeouts)
  761. {
  762.   ASSERT(IsOpen());
  764.   if (!GetCommTimeouts(m_hComm, &timeouts))
  765.   {
  766.     TRACE(_T("Failed in call to GetCommTimeoutsn"));
  767.     AfxThrowSerialException();
  768.   }
  769. }
  771. void CSerialPort::Set0Timeout()
  772. {
  773.   COMMTIMEOUTS Timeouts;
  774.   ZeroMemory(&Timeouts, sizeof(COMMTIMEOUTS));
  775.   Timeouts.ReadIntervalTimeout = MAXDWORD;
  776.   Timeouts.ReadTotalTimeoutMultiplier = 0;
  777.   Timeouts.ReadTotalTimeoutConstant = 0;
  778.   Timeouts.WriteTotalTimeoutMultiplier = 0;
  779.   Timeouts.WriteTotalTimeoutConstant = 0;
  780.   SetTimeouts(Timeouts);
  781. }
  783. void CSerialPort::Set0WriteTimeout()
  784. {
  785.   COMMTIMEOUTS Timeouts;
  786.   GetTimeouts(Timeouts);
  787.   Timeouts.WriteTotalTimeoutMultiplier = 0;
  788.   Timeouts.WriteTotalTimeoutConstant = 0;
  789.   SetTimeouts(Timeouts);
  790. }
  792. void CSerialPort::Set0ReadTimeout()
  793. {
  794.   COMMTIMEOUTS Timeouts;
  795.   GetTimeouts(Timeouts);
  796.   Timeouts.ReadIntervalTimeout = MAXDWORD;
  797.   Timeouts.ReadTotalTimeoutMultiplier = 0;
  798.   Timeouts.ReadTotalTimeoutConstant = 0;
  799.   SetTimeouts(Timeouts);
  800. }
  802. void CSerialPort::WaitEvent(DWORD& dwMask)
  803. {
  804.   ASSERT(IsOpen());
  805.   ASSERT(!m_bOverlapped);
  807.   if (!WaitCommEvent(m_hComm, &dwMask, NULL))
  808.   {
  809.     TRACE(_T("Failed in call to WaitCommEventn"));
  810.     AfxThrowSerialException();
  811.   }
  812. }
  814. void CSerialPort::WaitEvent(DWORD& dwMask, OVERLAPPED& overlapped)
  815. {
  816.   ASSERT(IsOpen());
  817.   ASSERT(m_bOverlapped);
  818.   ASSERT(overlapped.hEvent);
  820.   if (!WaitCommEvent(m_hComm, &dwMask, &overlapped))
  821.   {
  822.     if (GetLastError() != ERROR_IO_PENDING)
  823.     {
  824.       TRACE(_T("Failed in call to WaitCommEventn"));
  825.       AfxThrowSerialException();
  826.     }
  827.   }
  828. }