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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
winserial.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：12k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

winserial.cxx：源码内容
  1. /*
  2.  * winserial.cxx
  3.  *
  4.  * Miscellaneous implementation of classes for Win32
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: winserial.cxx,v $
  30.  * Revision 1.3  2000/03/20 17:55:05  robertj
  31.  * Fixed prolem with XON/XOFF under NT, thanks Damien Slee.
  32.  *
  33.  * Revision 1.2  1998/11/30 12:32:47  robertj
  34.  * Added missing copyright header.
  35.  *
  36.  */
  38. #include <ptlib.h>
  39. #include <ptlib/serchan.h>
  42. #define QUEUE_SIZE 2048
  45. ///////////////////////////////////////////////////////////////////////////////
  46. // PSerialChannel
  48. void PSerialChannel::Construct()
  49. {
  50.   commsResource = INVALID_HANDLE_VALUE;
  52.   char str[50];
  53.   strcpy(str, "com1");
  54.   GetProfileString("ports", str, "9600,n,8,1,x", &str[5], sizeof(str)-6);
  55.   str[4] = ':';
  56.   memset(&deviceControlBlock, 0, sizeof(deviceControlBlock));
  57.   deviceControlBlock.DCBlength = sizeof(deviceControlBlock);
  58.   BuildCommDCB(str, &deviceControlBlock);
  60.   // These values are not set by BuildCommDCB
  61.   deviceControlBlock.XoffChar = 19;
  62.   deviceControlBlock.XonChar = 17;
  63.   deviceControlBlock.XoffLim = (QUEUE_SIZE * 7)/8;  // upper limit before XOFF is sent to stop reception
  64.   deviceControlBlock.XonLim = (QUEUE_SIZE * 3)/4;   // lower limit before XON is sent to re-enabled reception
  65. }
  68. PString PSerialChannel::GetName() const
  69. {
  70.   return portName;
  71. }
  74. BOOL PSerialChannel::Read(void * buf, PINDEX len)
  75. {
  76.   lastReadCount = 0;
  78.   if (!IsOpen()) {
  79.     osError = EBADF;
  80.     lastError = NotOpen;
  81.     return FALSE;
  82.   }
  84.   COMMTIMEOUTS cto;
  85.   PAssertOS(GetCommTimeouts(commsResource, &cto));
  86.   cto.ReadIntervalTimeout = 0;
  87.   cto.ReadTotalTimeoutMultiplier = 0;
  88.   cto.ReadTotalTimeoutConstant = 0;
  89.   cto.ReadIntervalTimeout = MAXDWORD; // Immediate timeout
  90.   PAssertOS(SetCommTimeouts(commsResource, &cto));
  92.   DWORD eventMask;
  93.   PAssertOS(GetCommMask(commsResource, &eventMask));
  94.   if (eventMask != (EV_RXCHAR|EV_TXEMPTY))
  95.     PAssertOS(SetCommMask(commsResource, EV_RXCHAR|EV_TXEMPTY));
  97.   PWin32Overlapped overlap;
  98.   DWORD timeToGo = readTimeout.GetInterval();
  99.   DWORD bytesToGo = len;
  100.   char * bufferPtr = (char *)buf;
  102.   for (;;) {
  103.     DWORD readCount = 0;
  104.     if (!ReadFile(commsResource, bufferPtr, bytesToGo, &readCount, &overlap)) {
  105.       if (GetLastError() != ERROR_IO_PENDING)
  106.         return ConvertOSError(-2);
  107.       if (!GetOverlappedResult(commsResource, &overlap, &readCount, FALSE))
  108.         return ConvertOSError(-2);
  109.     }
  111.     bytesToGo -= readCount;
  112.     bufferPtr += readCount;
  113.     lastReadCount += readCount;
  114.     if (lastReadCount >= len || timeToGo == 0)
  115.       return lastReadCount > 0;
  117.     if (!WaitCommEvent(commsResource, &eventMask, &overlap)) {
  118.       if (GetLastError() != ERROR_IO_PENDING)
  119.         return ConvertOSError(-2);
  120.       if (WaitForSingleObject(overlap.hEvent, timeToGo) == WAIT_FAILED)
  121.         return ConvertOSError(-2);
  122.     }
  123.   }
  124. }
  127. BOOL PSerialChannel::Write(const void * buf, PINDEX len)
  128. {
  129.   lastWriteCount = 0;
  131.   if (!IsOpen()) {
  132.     osError = EBADF;
  133.     lastError = NotOpen;
  134.     return FALSE;
  135.   }
  137.   COMMTIMEOUTS cto;
  138.   PAssertOS(GetCommTimeouts(commsResource, &cto));
  139.   cto.WriteTotalTimeoutMultiplier = 0;
  140.   if (writeTimeout == PMaxTimeInterval)
  141.     cto.WriteTotalTimeoutConstant = 0;
  142.   else if (writeTimeout <= PTimeInterval(0))
  143.     cto.WriteTotalTimeoutConstant = 1;
  144.   else
  145.     cto.WriteTotalTimeoutConstant = writeTimeout.GetInterval();
  146.   PAssertOS(SetCommTimeouts(commsResource, &cto));
  148.   PWin32Overlapped overlap;
  149.   memset(&overlap, 0, sizeof(overlap));
  150.   overlap.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  151.   if (WriteFile(commsResource, buf, len, (LPDWORD)&lastWriteCount, &overlap)) {
  152.     CloseHandle(overlap.hEvent);
  153.     return lastWriteCount == len;
  154.   }
  156.   if (GetLastError() == ERROR_IO_PENDING)
  157.     if (GetOverlappedResult(commsResource,
  158.                                    &overlap, (LPDWORD)&lastWriteCount, TRUE)) {
  159.       CloseHandle(overlap.hEvent);
  160.       return lastWriteCount == len;
  161.     }
  163.   ConvertOSError(-2);
  164.   CloseHandle(overlap.hEvent);
  166.   return FALSE;
  167. }
  170. BOOL PSerialChannel::Close()
  171. {
  172.   if (!IsOpen()) {
  173.     osError = EBADF;
  174.     lastError = NotOpen;
  175.     return FALSE;
  176.   }
  178.   CloseHandle(commsResource);
  179.   commsResource = INVALID_HANDLE_VALUE;
  180.   os_handle = -1;
  181.   return ConvertOSError(-2);
  182. }
  185. BOOL PSerialChannel::SetCommsParam(DWORD speed, BYTE data, Parity parity,
  186.                      BYTE stop, FlowControl inputFlow, FlowControl outputFlow)
  187. {
  188.   if (speed > 0)
  189.     deviceControlBlock.BaudRate = speed;
  191.   if (data > 0)
  192.     deviceControlBlock.ByteSize = data;
  194.   switch (parity) {
  195.     case NoParity :
  196.       deviceControlBlock.Parity = NOPARITY;
  197.       break;
  198.     case OddParity :
  199.       deviceControlBlock.Parity = ODDPARITY;
  200.       break;
  201.     case EvenParity :
  202.       deviceControlBlock.Parity = EVENPARITY;
  203.       break;
  204.     case MarkParity :
  205.       deviceControlBlock.Parity = MARKPARITY;
  206.       break;
  207.     case SpaceParity :
  208.       deviceControlBlock.Parity = SPACEPARITY;
  209.       break;
  210.   }
  212.   switch (stop) {
  213.     case 1 :
  214.       deviceControlBlock.StopBits = ONESTOPBIT;
  215.       break;
  216.     case 2 :
  217.       deviceControlBlock.StopBits = TWOSTOPBITS;
  218.       break;
  219.   }
  221.   switch (inputFlow) {
  222.     case NoFlowControl :
  223.       deviceControlBlock.fRtsControl = RTS_CONTROL_DISABLE;
  224.       deviceControlBlock.fInX = FALSE;
  225.       break;
  226.     case XonXoff :
  227.       deviceControlBlock.fRtsControl = RTS_CONTROL_DISABLE;
  228.       deviceControlBlock.fInX = TRUE;
  229.       break;
  230.     case RtsCts :
  231.       deviceControlBlock.fRtsControl = RTS_CONTROL_HANDSHAKE;
  232.       deviceControlBlock.fInX = FALSE;
  233.       break;
  234.   }
  236.   switch (outputFlow) {
  237.     case NoFlowControl :
  238.       deviceControlBlock.fOutxCtsFlow = FALSE;
  239.       deviceControlBlock.fOutxDsrFlow = FALSE;
  240.       deviceControlBlock.fOutX = FALSE;
  241.       break;
  242.     case XonXoff :
  243.       deviceControlBlock.fOutxCtsFlow = FALSE;
  244.       deviceControlBlock.fOutxDsrFlow = FALSE;
  245.       deviceControlBlock.fOutX = TRUE;
  246.       break;
  247.     case RtsCts :
  248.       deviceControlBlock.fOutxCtsFlow = TRUE;
  249.       deviceControlBlock.fOutxDsrFlow = FALSE;
  250.       deviceControlBlock.fOutX = FALSE;
  251.       break;
  252.   }
  254.   if (IsOpen())
  255.    return ConvertOSError(SetCommState(commsResource,
  256.                                                 &deviceControlBlock) ? 0 : -2);
  258.   osError = EBADF;
  259.   lastError = NotOpen;
  260.   return FALSE;
  261. }
  264. BOOL PSerialChannel::Open(const PString & port, DWORD speed, BYTE data,
  265.                Parity parity, BYTE stop, FlowControl inputFlow, FlowControl outputFlow)
  266. {
  267.   Close();
  269.   portName = port;
  270.   if (portName.Find(PDIR_SEPARATOR) == P_MAX_INDEX)
  271.     portName = "\\.\" + port;
  272.   commsResource = CreateFile(portName,
  273.                              GENERIC_READ|GENERIC_WRITE,
  274.                              0,
  275.                              NULL,
  276.                              OPEN_EXISTING,
  277.                              FILE_FLAG_OVERLAPPED,
  278.                              NULL);
  279.   if (commsResource == INVALID_HANDLE_VALUE)
  280.     return ConvertOSError(-2);
  282.   os_handle = 0;
  284.   SetupComm(commsResource, QUEUE_SIZE, QUEUE_SIZE);
  286.   if (SetCommsParam(speed, data, parity, stop, inputFlow, outputFlow))
  287.     return TRUE;
  289.   ConvertOSError(-2);
  290.   CloseHandle(commsResource);
  291.   os_handle = -1;
  292.   return FALSE;
  293. }
  296. BOOL PSerialChannel::SetSpeed(DWORD speed)
  297. {
  298.   return SetCommsParam(speed,
  299.                   0, DefaultParity, 0, DefaultFlowControl, DefaultFlowControl);
  300. }
  303. DWORD PSerialChannel::GetSpeed() const
  304. {
  305.   return deviceControlBlock.BaudRate;
  306. }
  309. BOOL PSerialChannel::SetDataBits(BYTE data)
  310. {
  311.   return SetCommsParam(0,
  312.                data, DefaultParity, 0, DefaultFlowControl, DefaultFlowControl);
  313. }
  316. BYTE PSerialChannel::GetDataBits() const
  317. {
  318.   return deviceControlBlock.ByteSize;
  319. }
  322. BOOL PSerialChannel::SetParity(Parity parity)
  323. {
  324.   return SetCommsParam(0,0,parity,0,DefaultFlowControl,DefaultFlowControl);
  325. }
  328. PSerialChannel::Parity PSerialChannel::GetParity() const
  329. {
  330.   switch (deviceControlBlock.Parity) {
  331.     case ODDPARITY :
  332.       return OddParity;
  333.     case EVENPARITY :
  334.       return EvenParity;
  335.     case MARKPARITY :
  336.       return MarkParity;
  337.     case SPACEPARITY :
  338.       return SpaceParity;
  339.   }
  340.   return NoParity;
  341. }
  344. BOOL PSerialChannel::SetStopBits(BYTE stop)
  345. {
  346.   return SetCommsParam(0,
  347.                0, DefaultParity, stop, DefaultFlowControl, DefaultFlowControl);
  348. }
  351. BYTE PSerialChannel::GetStopBits() const
  352. {
  353.   return (BYTE)(deviceControlBlock.StopBits == ONESTOPBIT ? 1 : 2);
  354. }
  357. BOOL PSerialChannel::SetInputFlowControl(FlowControl flowControl)
  358. {
  359.   return SetCommsParam(0,0,DefaultParity,0,flowControl,DefaultFlowControl);
  360. }
  363. PSerialChannel::FlowControl PSerialChannel::GetInputFlowControl() const
  364. {
  365.   if (deviceControlBlock.fRtsControl == RTS_CONTROL_HANDSHAKE)
  366.     return RtsCts;
  367.   if (deviceControlBlock.fInX != 0)
  368.     return XonXoff;
  369.   return NoFlowControl;
  370. }
  373. BOOL PSerialChannel::SetOutputFlowControl(FlowControl flowControl)
  374. {
  375.   return SetCommsParam(0,0,DefaultParity,0,DefaultFlowControl,flowControl);
  376. }
  379. PSerialChannel::FlowControl PSerialChannel::GetOutputFlowControl() const
  380. {
  381.   if (deviceControlBlock.fOutxCtsFlow != 0)
  382.     return RtsCts;
  383.   if (deviceControlBlock.fOutX != 0)
  384.     return XonXoff;
  385.   return NoFlowControl;
  386. }
  389. void PSerialChannel::SetDTR(BOOL state)
  390. {
  391.   if (IsOpen())
  392.     PAssertOS(EscapeCommFunction(commsResource, state ? SETDTR : CLRDTR));
  393.   else {
  394.     osError = EBADF;
  395.     lastError = NotOpen;
  396.   }
  397. }
  400. void PSerialChannel::SetRTS(BOOL state)
  401. {
  402.   if (IsOpen())
  403.     PAssertOS(EscapeCommFunction(commsResource, state ? SETRTS : CLRRTS));
  404.   else {
  405.     osError = EBADF;
  406.     lastError = NotOpen;
  407.   }
  408. }
  411. void PSerialChannel::SetBreak(BOOL state)
  412. {
  413.   if (IsOpen())
  414.     if (state)
  415.       PAssertOS(SetCommBreak(commsResource));
  416.     else
  417.       PAssertOS(ClearCommBreak(commsResource));
  418.   else {
  419.     osError = EBADF;
  420.     lastError = NotOpen;
  421.   }
  422. }
  425. BOOL PSerialChannel::GetCTS()
  426. {
  427.   if (!IsOpen()) {
  428.     osError = EBADF;
  429.     lastError = NotOpen;
  430.     return FALSE;
  431.   }
  433.   DWORD stat;
  434.   PAssertOS(GetCommModemStatus(commsResource, &stat));
  435.   return (stat&MS_CTS_ON) != 0;
  436. }
  439. BOOL PSerialChannel::GetDSR()
  440. {
  441.   if (!IsOpen()) {
  442.     osError = EBADF;
  443.     lastError = NotOpen;
  444.     return FALSE;
  445.   }
  447.   DWORD stat;
  448.   PAssertOS(GetCommModemStatus(commsResource, &stat));
  449.   return (stat&MS_DSR_ON) != 0;
  450. }
  453. BOOL PSerialChannel::GetDCD()
  454. {
  455.   if (!IsOpen()) {
  456.     osError = EBADF;
  457.     lastError = NotOpen;
  458.     return FALSE;
  459.   }
  461.   DWORD stat;
  462.   PAssertOS(GetCommModemStatus(commsResource, &stat));
  463.   return (stat&MS_RLSD_ON) != 0;
  464. }
  467. BOOL PSerialChannel::GetRing()
  468. {
  469.   if (!IsOpen()) {
  470.     osError = EBADF;
  471.     lastError = NotOpen;
  472.     return FALSE;
  473.   }
  475.   DWORD stat;
  476.   PAssertOS(GetCommModemStatus(commsResource, &stat));
  477.   return (stat&MS_RING_ON) != 0;
  478. }
  481. PStringList PSerialChannel::GetPortNames()
  482. {
  483.   PStringList ports;
  484.   for (char p = 1; p <= 9; p++)
  485.     ports.AppendString(psprintf("\\.\COM%u", p));
  486.   return ports;
  487. }