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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
CommPort.cpp
资源名称：faxengine-1.0.3.zip　[点击查看]
上传用户：glass0516
上传日期：2010-01-11
资源大小：104k
文件大小：21k
源码类别：

传真(Fax)编程

开发平台：

Visual C++

CommPort.cpp：源码内容
  1. /*****************************************************************************
  2. * RelayFax Open Source Project
  3. * Copyright 1996-2004 Alt-N Technologies, Ltd.
  4. * All rights reserved.
  5. *
  6. * Redistribution and use in source and binary forms, with or without
  7. * modification, are permitted only as authorized by the RelayFax Open 
  8. * Source License.  A copy of this license is available in file LICENSE 
  9. * in the top-level directory of the distribution.
  10. *
  11. * RelayFax is a registered trademark of Alt-N Technologies, Ltd.
  12. *
  13. * Individual files and/or contributed packages may be copyright by
  14. * other parties and subject to additional restrictions.
  15. *****************************************************************************/
  17. ////////////////////////////////////////////////////////////////////////////////
  18. //
  19. // The purpose of CCommPort is to encapsulate all the Win32 communication API
  20. //
  21. ////////////////////////////////////////////////////////////////////////////////
  23. #include "stdafx.h"
  24. #include "CommPort.h"
  27. CLS1SPEEDS cls1Speeds[MAX_CLS1SPEEDS] = 
  28. { 
  29. 0x00, 24, 24, 2400, 0, // 2400, v.27 ter
  30. 0x04, 48, 48, 4800, 1, // 4800, v.27
  31. 0x0c, 72, 72, 7200, 2, // 7200, v.29
  32. 0x08, 96, 96, 9600, 3, // 9600, v.29
  33. 0x06, 121, 121, 12000, 4, // 12000, V.33
  34. 0x02, 145, 145, 14400, 5, // 14400, V.33
  35. 0x0d, 73, 74, 7200, 2, // 7200, v.17
  36. 0x09, 97, 98, 9600, 3, // 9600, v.17
  37. 0x05, 121, 122, 12000, 4, // 12000, v.17
  38. 0x01, 145, 146, 14400, 5, // 14400, v.17  
  39. };
  41. WORD Cls1ScanTimes_normal[8] = {20,40,10,5,10,20,40,0};
  42. WORD Cls1ScanTimes_fine[8] =   {20,40,10,5,5,10,20,0};
  44. WORD Cls2ScanTimes_normal[8] = { 0, 5, 10, 10, 20, 20, 40, 40 };
  45. WORD Cls2ScanTimes_fine[8] = { 0, 5, 5, 10, 10, 20, 20, 40 };
  47. WORD  Cls2FaxParamBitRates[6] = { 2400, 4800, 7200, 9600, 12000, 14400 };
  49. char CCommPort::s_HexDigits[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
  51. //////////////////////////////////////////////////////////////////////
  52. // Construction/Destruction
  53. //////////////////////////////////////////////////////////////////////
  54. CCommPort::CCommPort()
  55. {
  56. m_hPort = NULL;
  57. m_bDSRFlowControl = true;
  58. m_bCTSFlowControl = true;
  59. m_bSoftFlowControl = true;
  61. m_BaudRate = CBR_19200;
  62. m_ByteSize = 8;
  63. m_Parity = NOPARITY;
  64. m_StopBits = ONESTOPBIT;
  66. ZeroMemory( &m_ReadOverlapped, sizeof(m_ReadOverlapped) );
  67. ZeroMemory( &m_WriteOverlapped, sizeof(m_WriteOverlapped) );
  68. ZeroMemory( &m_CommEventOverlapped, sizeof(m_CommEventOverlapped) );
  70. m_ReadOverlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  71. m_WriteOverlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  72. m_CommEventOverlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  74. InitLineParser();
  76. m_bWriteInProgress = false;
  78. memset( &m_dcb, 0, sizeof(m_dcb) );
  79. m_dcb.DCBlength = sizeof(m_dcb); 
  81. m_bDebugLog = false;
  82. m_pLogFile = NULL;
  84. }
  86. CCommPort::~CCommPort()
  87. {
  89. CloseHandle( m_ReadOverlapped.hEvent );
  90. CloseHandle( m_WriteOverlapped.hEvent );
  91. CloseHandle( m_CommEventOverlapped.hEvent );
  93. }
  96. //////////////////////////////////////////////////////////////////////
  97. // ConnectPort
  98. //////////////////////////////////////////////////////////////////////
  99. bool CCommPort::ConnectPort( string& sErr )
  100. {
  101. char szComDevice[16];
  103. wsprintf( szComDevice, "\\.\%s",  m_sPort.c_str() );
  104. m_hPort = CreateFile( szComDevice, GENERIC_READ | GENERIC_WRITE, 0, NULL, 
  105.   OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL );
  107. // see if this works before committing
  108. if( m_hPort == NULL || m_hPort == INVALID_HANDLE_VALUE )
  109. {
  110. if( GetLastError() == ERROR_ACCESS_DENIED )
  111. {
  112. // wait a second and try again
  113. Sleep( 1000 );
  114. m_hPort = CreateFile( szComDevice, GENERIC_READ | GENERIC_WRITE, 0, NULL, 
  115.   OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL );
  116. }
  117. }
  119. if( m_hPort != NULL && m_hPort != INVALID_HANDLE_VALUE )
  120. {
  121. PurgeComm( m_hPort, PURGE_RXCLEAR | PURGE_TXCLEAR );
  123. if( !GetCommState( m_hPort, &m_dcb ) )
  124. {
  125. sErr.assign( "Error in GetCommState" );
  126. CloseHandle( m_hPort );
  127. return false;
  128. }
  130. if( !SetupComm( m_hPort, 20000, 20000 ) )
  131. {
  132. sErr.assign( "Error in SetupComm" );
  133. CloseHandle( m_hPort );
  134. return false;
  135. }
  137. m_dcb.BaudRate = m_BaudRate;
  138. m_dcb.ByteSize=  m_ByteSize;
  139. m_dcb.fBinary = TRUE;
  140. m_dcb.Parity = m_Parity;
  141. m_dcb.StopBits = m_StopBits;
  143. m_dcb.fOutxCtsFlow = (m_bCTSFlowControl) ? TRUE : FALSE;
  144. m_dcb.fOutxDsrFlow = (m_bDSRFlowControl) ? TRUE : FALSE;
  146. m_dcb.fOutX = (m_bSoftFlowControl) ? 1 : 0;
  147. m_dcb.fInX = 0; // we shouldn't need flow control for receiving data
  148.                 // since we are using 20k buffers
  150. m_dcb.XonChar = XON;
  151. m_dcb.XoffChar = XOFF;
  153. // One of these two was causing a problem with Multitech ISI5634/8 multi-port modem card
  154. // m_dcb.fTXContinueOnXoff = TRUE;
  156. m_dcb.fRtsControl = RTS_CONTROL_ENABLE;
  157. m_dcb.fDtrControl = DTR_CONTROL_ENABLE;
  158. m_dcb.fAbortOnError = FALSE; // Make sure this is reset otherwise any 
  159.                              //line errors will cause io to terminate
  161. m_dcb.fErrorChar = FALSE;
  162. m_dcb.fParity = FALSE;
  163. // m_dcb.fDsrSensitivity = TRUE;
  165. m_dcb.fNull = FALSE;
  167. if ( !SetCommState( m_hPort, &m_dcb) ) 
  168. {
  169. sErr.assign( "Error in SetCommState" );
  170. CloseHandle( m_hPort );
  171. return false;
  172. }
  174. COMMTIMEOUTS cto;
  175. //cto.ReadIntervalTimeout = 10;
  176. //cto.ReadIntervalTimeout = (m_BaudRate / 10)
  177. cto.ReadIntervalTimeout = 2;
  178. cto.ReadTotalTimeoutMultiplier = 0;
  179. cto.ReadTotalTimeoutConstant = 0;
  180. cto.WriteTotalTimeoutMultiplier = 5;
  181. cto.WriteTotalTimeoutConstant = 5000;
  183. if( !SetCommTimeouts( m_hPort, &cto ) )
  184. {
  185. sErr.assign( "Error in SetCommTimeouts" );
  186. CloseHandle( m_hPort );
  187. return false;
  188. }
  190. COMSTAT cs = {0};
  191. DWORD dwErrs = 0;
  193. if( !ClearCommError( m_hPort, &dwErrs, &cs ) )
  194. {
  195. sErr.assign( "Error in ClearCommError" );
  196. CloseHandle( m_hPort );
  197. return false;
  198. }
  200. //DWORD dwMask = EV_CTS | EV_ERR | EV_DSR | EV_RLSD | EV_BREAK | EV_RING;
  201. DWORD dwMask = EV_ERR;
  203. if (!SetCommMask(m_hPort, dwMask))
  204. {
  205. sErr.assign( "Error in SetCommMask!" );
  206. CloseHandle( m_hPort );
  207. return false;
  208. }
  210. OpenDebugLog();
  212. DoWaitCommEventLoop();
  214. DoReadLoop();
  216. OnConnect(); //-- moved to OnWaitTimeout to let the read buffer flush
  218. return true;
  219. }
  220. else
  221. {
  222. // could not open port
  223. char szError[256];
  224. szError[0] = '';
  225. GetLastErrorText( szError, 255 );
  226. sErr.assign( szError );
  227. }
  229. return false;
  230. }
  233. //////////////////////////////////////////////////////////////////////
  234. // DisconnectPort
  235. //////////////////////////////////////////////////////////////////////
  236. void CCommPort::DisconnectPort( void )
  237. {
  239. PurgeComm( m_hPort, PURGE_RXABORT | PURGE_RXCLEAR | 
  240.                 PURGE_TXABORT | PURGE_TXCLEAR );
  242. CloseHandle( m_hPort );
  244. m_hPort = NULL;
  246. CloseDebugLog();
  247. }
  249. //////////////////////////////////////////////////////////////////////
  250. // DoRead
  251. //////////////////////////////////////////////////////////////////////
  252. bool CCommPort::DoRead( void )
  253. {
  254. BOOL bRet;
  256. m_BytesRead = 0;
  258. bRet = ReadFile( m_hPort, m_szReadBuff, READBUF_SIZE, &m_BytesRead, &m_ReadOverlapped );
  260. if( bRet )
  261. {
  262. return true;
  263. }
  264. else
  265. {
  266. DWORD  dwLastError = GetLastError();
  268. // LastError was ERROR_IO_PENDING, as expected.
  269. if (dwLastError != ERROR_IO_PENDING)
  270. {
  271. OutputDebugString("Unexpected error.n");
  272. }
  274. // Its possible for this error to occur if the 
  275. // service provider has closed the port.  Time to end.
  276. if (dwLastError == ERROR_INVALID_HANDLE)
  277. {
  278. OutputDebugString( "Likely that the Service Provider has closed the port.n");
  279. }
  281. return false;
  282. }
  283. }
  286. void CCommPort::FillWriteQueue( char* szChars, unsigned long nBytes, bool bCrLf )
  287. {
  288. bool bAddedCrLf = false;
  290. while( nBytes > 0 )
  291. {
  292. int nbuflen = MAX_WRITE;
  294. if( nbuflen > nBytes ) 
  295. {
  296. nbuflen = nBytes;
  297. }
  299. CWriteBuffer *buf = new CWriteBuffer;
  301. memcpy( buf->Buffer, szChars, nbuflen );
  302. buf->Bytes = nbuflen;
  304. if( bCrLf && (nbuflen < MAX_WRITE) )
  305. {
  306. // must be last one
  307. buf->Buffer[buf->Bytes++] = 'r';
  308. bAddedCrLf = true;
  309. }
  311. m_WriteQueue.push_back( buf );
  313. szChars += nbuflen;
  314. nBytes -= nbuflen;
  315. }
  317. if( bCrLf && !bAddedCrLf)
  318. {
  319. CWriteBuffer *buf = new CWriteBuffer;
  320. buf->Buffer[0] = 'r';
  321. buf->Bytes = 1;
  322. m_WriteQueue.push_back( buf );
  323. }
  324. }
  327. bool CCommPort::WritePacket( char* szChars, unsigned long nBytes )
  328. {
  329. m_WriteOverlapped.Offset = 0;
  330. m_WriteOverlapped.OffsetHigh = 0;
  333. if( WriteFile( m_hPort, szChars, nBytes, 
  334. &m_BytesWritten, &m_WriteOverlapped ) )
  335. {
  336. //char szMsg[80];
  337. //wsprintf( szMsg, "Wrote %d bytes 2n", m_BytesWritten );
  338. //OutputDebugString( szMsg );
  340. ResetEvent( m_WriteOverlapped.hEvent );
  342. OnWrite();
  344. if( m_bDebugLog )
  345. {
  346. WriteDebugLog( false );
  347. }
  348. }
  349. else
  350. {
  351. //char szMsg[80];
  352. //wsprintf( szMsg, "Queued up %d bytesn", nBytes );
  353. //OutputDebugString( szMsg );
  355. m_bWriteInProgress = true;
  357. DWORD  dwLastError = GetLastError();
  359. // LastError was ERROR_IO_PENDING, as expected.
  360. if (dwLastError != ERROR_IO_PENDING)
  361. {
  362. OutputDebugString("Unexpected error.n");
  363. }
  365. // Its possible for this error to occur if the 
  366. // service provider has closed the port.  Time to end.
  367. if (dwLastError == ERROR_INVALID_HANDLE)
  368. {
  369. OutputDebugString( "Likely that the Service Provider has closed the port.n");
  370. }
  372. return false;
  373. }
  375. return true;
  376. }
  378. //////////////////////////////////////////////////////////////////////
  379. // DoWrite
  380. //////////////////////////////////////////////////////////////////////
  381. bool CCommPort::DoWrite( char* szChars, unsigned long nBytes, bool bCrLf )
  382. {
  383. if( m_bWriteInProgress )
  384. {
  385. FillWriteQueue( szChars, nBytes, bCrLf );
  386. }
  387. else
  388. {
  389. if( nBytes > MAX_WRITE )
  390. {
  391. FillWriteQueue( szChars, nBytes, bCrLf );
  392. DoWriteLoop();
  393. }
  394. else
  395. {
  396. memcpy( m_szWriteBuff, szChars, nBytes );
  398. if( bCrLf )
  399. {
  400. m_szWriteBuff[nBytes++] = 'r';
  401. //m_szWriteBuff[nBytes++] = 'n';
  402. }
  404. if( WritePacket( m_szWriteBuff, nBytes ) )
  405. {
  406. //char szMsg[80];
  407. //wsprintf( szMsg, "Sent %d bytes 3n", nBytes  );
  408. //OutputDebugString( szMsg );
  409. }
  410. }
  411. }
  413. return true;
  414. }
  417. //////////////////////////////////////////////////////////////////////
  418. // DoRead
  419. //////////////////////////////////////////////////////////////////////
  420. bool CCommPort::DoWaitCommEvent( void )
  421. {
  422. BOOL bRet;
  424. m_BytesRead = 0;
  426. bRet = WaitCommEvent( m_hPort, &m_CommEvent, &m_CommEventOverlapped );
  428. if( bRet )
  429. {
  430. return true;
  431. }
  432. else
  433. {
  434. DWORD  dwLastError = GetLastError();
  436. // LastError was ERROR_IO_PENDING, as expected.
  437. if (dwLastError != ERROR_IO_PENDING)
  438. {
  439. OutputDebugString("Unexpected error.n");
  440. }
  442. // Its possible for this error to occur if the 
  443. // service provider has closed the port.  Time to end.
  444. if (dwLastError == ERROR_INVALID_HANDLE)
  445. {
  446. OutputDebugString( "Likely that the Service Provider has closed the port.n");
  447. }
  449. return false;
  450. }
  451. }
  454. //////////////////////////////////////////////////////////////////////
  455. // DoReadLoop
  456. //////////////////////////////////////////////////////////////////////
  457. void CCommPort::DoReadLoop( void )
  458. {
  459. int i;
  461. for( i = 0; i < 100; i++ )
  462. {
  463. if( m_hPort == NULL )
  464. break;
  466. if( DoRead() ) 
  467. {
  468. m_szReadBuff[m_BytesRead] = '';
  470. if( m_bDebugLog )
  471. {
  472. WriteDebugLog( true );
  473. }
  475. OnRead();
  476. }
  477. else
  478. {
  479. break;
  480. }
  481. }
  483. if( i == 100 )
  484. {
  485. OutputDebugString("DoRead loop executed 100 times.n");
  486. }
  487. }
  489. //////////////////////////////////////////////////////////////////////
  490. // DoWaitCommEventLoop
  491. //////////////////////////////////////////////////////////////////////
  492. void CCommPort::DoWaitCommEventLoop( void )
  493. {
  494. int i;
  496. for( i = 0; i < 100; i++ )
  497. {
  498. if( m_hPort == NULL )
  499. break;
  501. if( DoWaitCommEvent() )
  502. {
  503. OnCommEvent();
  504. }
  505. else
  506. {
  507. break;
  508. }
  509. }
  511. if( i == 100 )
  512. {
  513. OutputDebugString("WaitCommEvent loop executed 100 times.n");
  514. }
  515. }
  518. //////////////////////////////////////////////////////////////////////
  519. // DoWriteLoop
  520. //////////////////////////////////////////////////////////////////////
  521. void CCommPort::DoWriteLoop( void )
  522. {
  523. // char szMsg[80];
  524. int i;
  525. int nBytesToWrite;
  527. for( i = 0; i < 100; i++ )
  528. {
  529. if( m_hPort == NULL )
  530. break;
  532. if( m_WriteQueue.size() > 0 )
  533. {
  534. //wsprintf( szMsg, "DoWriteLoop(%d)n", i );
  535. //OutputDebugString( szMsg );
  538. deque<CWriteBuffer*>::iterator iter;
  540. iter = m_WriteQueue.begin();
  542. // CWriteBuffer* p = (*iter);
  544. m_WriteQueue.pop_front();
  546. memcpy( m_szWriteBuff, (*iter)->Buffer, (*iter)->Bytes );
  547.  
  548. nBytesToWrite = (*iter)->Bytes;
  550. delete (*iter);
  552. if( WritePacket( m_szWriteBuff, nBytesToWrite ) )
  553. {
  554. //wsprintf( szMsg, "Sent %d bytes 2n", (*iter)->Bytes  );
  555. //OutputDebugString( szMsg );
  556. }
  557. else
  558. {
  559. break;
  560. }
  562. if( i == 100 )
  563. {
  564. OutputDebugString("WriteEvent loop executed 100 times.n");
  565. }
  566. }
  567. else
  568. {
  569. break;
  571. }
  572. }
  573. }
  576. //////////////////////////////////////////////////////////////////////
  577. // ReadEventSignalled
  578. //////////////////////////////////////////////////////////////////////
  579. void CCommPort::ReadEventSignalled(void)
  580. {
  581. BOOL bRet;
  583. if( m_hPort == NULL )
  584. return;
  586. bRet = GetOverlappedResult( m_hPort, &m_ReadOverlapped, &m_BytesRead, FALSE );
  588. ResetEvent( m_ReadOverlapped.hEvent );
  590. if( bRet )
  591. {
  592. if(  m_BytesRead > 0 )
  593. {
  594. m_szReadBuff[m_BytesRead] = '';
  596. if( m_bDebugLog )
  597. {
  598. WriteDebugLog( true );
  599. }
  601. OnRead();
  602. }
  604. DoReadLoop();
  605. }
  606. else
  607. {
  608. DWORD dwLastError = GetLastError();
  610. // Its possible for this error to occur if the 
  611. // service provider has closed the port.  Time to end.
  612. if (dwLastError == ERROR_INVALID_HANDLE)
  613. {
  614. OutputDebugString("Likely that the Service Provider has closed the port.n");
  615. }
  617. OutputDebugString( "Unexpected GetOverlappedResult Read Error: " );
  618. }
  620. }
  622. //////////////////////////////////////////////////////////////////////
  623. // WaitCommEventSignalled
  624. //////////////////////////////////////////////////////////////////////
  625. void CCommPort::WaitCommEventSignalled(void)
  626. {
  627. BOOL bRet;
  628. DWORD dwBytes = 0;
  630. if( m_hPort == NULL )
  631. return;
  633. bRet = GetOverlappedResult( m_hPort, &m_CommEventOverlapped, &dwBytes, FALSE );
  635. ResetEvent( m_CommEventOverlapped.hEvent );
  637. if( bRet )
  638. {
  639. OnCommEvent();
  641. DoWaitCommEventLoop();
  642. }
  643. else
  644. {
  645. DWORD dwLastError = GetLastError();
  647. // Its possible for this error to occur if the 
  648. // service provider has closed the port.  Time to end.
  649. if (dwLastError == ERROR_INVALID_HANDLE)
  650. {
  651. OutputDebugString("Likely that the Service Provider has closed the port.n");
  652. }
  654. OutputDebugString( "Unexpected GetOverlappedResult Read Error: ");
  655. }
  656. }
  658. //////////////////////////////////////////////////////////////////////
  659. // OnWriteEvent
  660. //////////////////////////////////////////////////////////////////////
  661. void CCommPort::WriteEventSignalled(void)
  662. {
  663. BOOL bRet;
  665. if( m_hPort == NULL )
  666. return;
  668. bRet = GetOverlappedResult( m_hPort, &m_WriteOverlapped, &m_BytesWritten, FALSE );
  670. ResetEvent( m_WriteOverlapped.hEvent );
  672. if( bRet )
  673. {
  674. //DWORD dwErrs = 0;
  675. //COMSTAT stat;
  676. //ClearCommError( m_hPort, &dwErrs, &stat );
  678. //char szMsg[80];
  679. //wsprintf( szMsg, "Wrote %d bytes,n", m_BytesWritten);
  680. //OutputDebugString( szMsg );
  682. m_bWriteInProgress = false;
  684. OnWrite();
  686. if( m_bDebugLog )
  687. {
  688. WriteDebugLog( false );
  689. }
  691. DoWriteLoop();
  692. }
  693. else
  694. {
  695. DWORD dwLastError = GetLastError();
  697. // Its possible for this error to occur if the 
  698. // service provider has closed the port.  Time to end.
  699. if (dwLastError == ERROR_INVALID_HANDLE)
  700. {
  701. OutputDebugString("Likely that the Service Provider has closed the port.n");
  702. }
  704. OutputDebugString( "Unexpected GetOverlappedResult Read Error: " );
  705. }
  706. }
  709. //////////////////////////////////////////////////////////////////////
  710. // OnCommEvent
  711. //////////////////////////////////////////////////////////////////////
  712. void CCommPort::OnCommEvent(void)
  713. {
  714. if( m_CommEvent & EV_CTS )
  715. {
  716. OutputDebugString( "CCommPort::OnCommEvent: CTS changed staten" );
  717. }
  719. if( m_CommEvent & EV_ERR )
  720. {
  721. OutputDebugString( "CCommPort::OnCommEvent: Errorn" );
  722. }
  724. if( m_CommEvent & EV_DSR )
  725. {
  726. OutputDebugString( "CCommPort::OnCommEvent: DSR changed staten" );
  727. }
  729. if( m_CommEvent & EV_RLSD )
  730. {
  731. OutputDebugString( "CCommPort::OnCommEvent: RLSD changed staten" );
  732. }
  734. if( m_CommEvent & EV_BREAK )
  735. {
  736. OutputDebugString( "CCommPort::OnCommEvent: Break detectedn" );
  737. }
  738. }
  740. //////////////////////////////////////////////////////////////////////
  741. // OnConnect
  742. //////////////////////////////////////////////////////////////////////
  743. void CCommPort::OnConnect(void)
  744. {
  745. // OutputDebugString( "CCommPort::OnConnectn" );
  746. }
  748. //////////////////////////////////////////////////////////////////////
  749. // OnDisconnect - return true if no command sent
  750. //////////////////////////////////////////////////////////////////////
  751. bool CCommPort::OnDisconnect(void)
  752. {
  753. // OutputDebugString( "CCommPort::OnDisconnectn" );
  754. return true;
  755. }
  757. //////////////////////////////////////////////////////////////////////
  758. // OnRead
  759. //////////////////////////////////////////////////////////////////////
  760. void CCommPort::OnRead(void)
  761. {
  762. // OutputDebugString( "CCommPort::OnReadn" );
  763. }
  765. //////////////////////////////////////////////////////////////////////
  766. // OnReadLine
  767. //////////////////////////////////////////////////////////////////////
  768. void CCommPort::OnReadLine(void)
  769. {
  770. // OutputDebugString( "CModem::OnReadLinen" );
  771. }
  773. //////////////////////////////////////////////////////////////////////
  774. // OnWrite
  775. //////////////////////////////////////////////////////////////////////
  776. void CCommPort::OnWrite(void)
  777. {
  778. // OutputDebugString( "CCommPort::OnWriten" );
  779. }
  781. //////////////////////////////////////////////////////////////////////
  782. // SetCommParam
  783. //////////////////////////////////////////////////////////////////////
  784. void CCommPort::SetCommParam( DWORD BaudRate, BYTE ByteSize, BYTE Parity, BYTE StopBits )
  785. {
  786. m_BaudRate = BaudRate;
  787. m_ByteSize = ByteSize;
  788. m_Parity = Parity;
  789. m_StopBits = StopBits;
  790. }
  793. //////////////////////////////////////////////////////////////////////
  794. // SetFlowControl
  795. //////////////////////////////////////////////////////////////////////
  796. void CCommPort::SetFlowControl( bool bDSRFlowControl, bool bCTSFlowControl, bool bSoftFlowControl )
  797. {
  798. m_bDSRFlowControl = bDSRFlowControl;
  799. m_bCTSFlowControl = bCTSFlowControl;
  800. m_bSoftFlowControl = bSoftFlowControl;
  801. }
  805. //////////////////////////////////////////////////////////////////////
  806. // ParseIntoLines
  807. //////////////////////////////////////////////////////////////////////
  808. void CCommPort::ParseIntoLines(void)
  809. {
  810. DWORD i;
  812. for( i = 0; i < m_BytesRead; i++ )
  813. {
  814. if( m_bEolFlag )
  815. {
  816. if( (m_szReadBuff[i] != 'r') && (m_szReadBuff[i] != 'n') )
  817. {
  818. m_bEolFlag = false;
  819. }
  820. }
  822. if( !m_bEolFlag )
  823. {
  824. if( (m_szReadBuff[i] == 'r') || (m_szReadBuff[i] == 'n') )
  825. {
  826. m_bEolFlag = true;
  828. if( m_nLineBuffPtr > 0 )
  829. {
  830. m_szLineBuff[m_nLineBuffPtr] = '';
  831. OnReadLine();
  832. InitLineParser();
  833. }
  834. }
  835. else
  836. {
  837. if( m_nLineBuffPtr >= READBUF_SIZE )
  838. {
  839. OutputDebugString( "Line buffer overflow!n" );
  840. InitLineParser();
  841. }
  842. m_szLineBuff[m_nLineBuffPtr++] = m_szReadBuff[i];
  843. }
  844. }
  845. }
  846. }
  849. void CCommPort::EnableSoftFlowControl( bool bEnable )
  850. {
  851. if( m_bSoftFlowControl )
  852. {
  853. m_dcb.fOutX = (bEnable) ? 1 : 0;
  854. if( !SetCommState( m_hPort, &m_dcb) )
  855. {
  856. OutputDebugString( "Error in SetCommState!n" );
  857. }
  859. if( bEnable )
  860. {
  861. EscapeCommFunction( m_hPort, SETXON );
  862. }
  864. if ( bEnable )
  865. {
  866. //OutputDebugString( "Enabling software flow controln" );
  867. }
  868. else
  869. {
  870. //OutputDebugString( "Disabling software flow controln" );
  871. }
  872. }
  873. }
  875. void CCommPort::OpenDebugLog(void)
  876. {
  877. char szLogFile[MAX_PATH];
  879. if( !m_bDebugLog ) 
  880. {
  881. return;
  882. }
  884. wsprintf( szLogFile, "%sM_%s.LOG", m_sLogDir.c_str(), m_sPort.c_str() );
  886. m_pLogFile = fopen( szLogFile, "a" );
  888. }
  890. void CCommPort::WriteDebugLog( bool bRead )
  891. {
  892. DWORD dwTicks = GetTickCount();
  893. char szMsg[80];
  894. int nBytes;
  895. char* pData;
  896. int i;
  898. wsprintf( szMsg, "%11d%c", dwTicks, (bRead) ? '<' : '>' );
  899. memset( szMsg+12, ' ', sizeof(szMsg) - 12 );
  900. szMsg[78] = 'n';
  901. szMsg[79] = '';
  904. if( m_pLogFile )
  905. {
  906. if( bRead )
  907. {
  908. pData = m_szReadBuff;
  909. nBytes = m_BytesRead;
  910. }
  911. else
  912. {
  913. pData = m_szWriteBuff;
  914. nBytes = m_BytesWritten;
  915. }
  917. while( nBytes > 0 )
  918. {
  919. for( i = 0; i < 16; i++ )
  920. {
  921. if( i < nBytes )
  922. {
  923. szMsg[13+(i*3)] = s_HexDigits[(*pData & 0xf0) >> 4];
  924. szMsg[14+(i*3)] = s_HexDigits[(*pData & 0x0f)];
  925. szMsg[62+i] =  ( (*pData < 127) && (*pData > 31) ) ? *pData : '.';
  926. pData++;
  927. }
  928. else
  929. {
  930. szMsg[13+(i*3)] = ' ';
  931. szMsg[14+(i*3)] = ' ';
  932. szMsg[62+i] =  ' ';
  933. }
  935. }
  937. fputs( szMsg, m_pLogFile );
  938. nBytes -= 16;
  939. }
  940. }
  941. }
  944. void CCommPort::CloseDebugLog(void)
  945. {
  946. if( !m_bDebugLog )
  947. {
  948. return;
  949. }
  951. if( m_pLogFile )
  952. {
  953. fclose( m_pLogFile );
  954. m_pLogFile = NULL;
  955. m_bDebugLog = false;
  956. }
  957. }