comm.cpp

Borland c++ builder串口通讯源码示例程序

            else dwBytesReceive += dwLength;
        }
        else
        {
            ClearCommError(FHandle, &dwErrorFlags, &ComStat ) ;
        }
    }
    catch(...) { Unlock(); }
    Unlock();
    return dwBytesReceive ;
}

int __fastcall TThreadComm::InQueCount()
{
  COMSTAT ComStat;
  DWORD   Errors;
  int Result ;

  if (Enabled())
  {
    ClearCommError(FHandle, &Errors, &ComStat);
    Result = ComStat.cbInQue;
  } else Result = -1;
  return Result ;
}

int __fastcall TThreadComm::OutQueCount()
{
  COMSTAT ComStat;
  DWORD   Errors;
  int Result ;

  if (Enabled())
  {
    ClearCommError(FHandle, &Errors, &ComStat);
    Result = ComStat.cbOutQue;
  } else Result = -1;
  return Result ;
}

void __fastcall TThreadComm::PurgeIn()
{
  if (Enabled())
    PurgeComm(FHandle, PurgeRead);
}

void __fastcall TThreadComm::PurgeOut()
{
  if (Enabled())
    PurgeComm(FHandle, PurgeWrite);
}

void __fastcall TThreadComm::SetDeviceName(String Value)
{
  if ((!Enabled())&&(FDeviceName!=Value))
  {
//    CheckOpen();
    FDeviceName = Value;
  }
}

void __fastcall TThreadComm::SetMonitorEvents(TCommEventTypes Value)
{
    if ((!Enabled())&&(FMonitorEvents != Value))
    {
//    CheckOpen();
        FMonitorEvents = Value;
    }
}

void __fastcall TThreadComm::SetReadBufSize(WORD Value)
{
  if ((!Enabled())&&(FReadBufSize != Value))
  {
//    CheckOpen();
    FReadBufSize = Value;
  }
}

void __fastcall TThreadComm::SetWriteBufSize(WORD Value)
{
  if ((!Enabled())&&(FWriteBufSize != Value))
  {
//    CheckOpen();
    FWriteBufSize = Value;
  }
}

void __fastcall TThreadComm::SetSuspendTime(DWORD Value)
{
  if ((!Enabled())&&(FSuspendTime != Value))
  {
    FSuspendTime = Value;
  }
}

void __fastcall TThreadComm::SetBaudRate(TBaudRate Value)
{
  if (FBaudRate != Value)
  {
    FBaudRate = Value;
    UpdateDataControlBlockLock();
  }
}

void __fastcall TThreadComm::SetParity(TParity Value)
{
  if (FParity != Value)
  {
    FParity = Value;
    UpdateDataControlBlockLock();
  }
}

void __fastcall TThreadComm::SetStopBits(TStopBits Value)
{
  if (FStopBits != Value)
  {
    FStopBits = Value;
    UpdateDataControlBlockLock();
  }
}

void __fastcall TThreadComm::SetDataBits(TDataBits Value)
{
  if (FDataBits != Value)
  {
    FDataBits=Value;
    UpdateDataControlBlockLock();
  }
}

void __fastcall TThreadComm::SetOptions(TCommOptions Value)
{
  if (FOptions != Value)
  {
    FOptions = Value;
    UpdateDataControlBlockLock();
  }
}

void __fastcall TThreadComm::SetFlowControl(TFlowControl Value)
{
  if (FFlowControl != Value)
  {
    FFlowControl = Value;
    UpdateDataControlBlockLock();
  }
}

void __fastcall TThreadComm::HandleCommEvent(TObject *Sender, DWORD Status)
{
  COMSTAT ComStat;
  DWORD   Errors;

  ClearCommError(FHandle, &Errors, &ComStat);
  if ((Status & EV_BREAK) > 0)
    if (FOnBreak)  FOnBreak(this);

  if ((Status & EV_CTS) > 0)
    if (FOnCts)  FOnCts(this);

  if ((Status & EV_DSR) > 0)
    if (FOnDsr)  FOnDsr(this);

  if ((Status & EV_ERR) > 0)
    if (FOnError)  FOnError(this, Errors);

  if ((Status & EV_RING) > 0)
    if (FOnRing)  FOnRing(this);

  if ((Status & EV_RLSD) > 0)
    if (FOnRlsd)  FOnRlsd(this);

  if ((Status & EV_RXCHAR) > 0)
    if (ComStat.cbInQue > 0 )
      if (FOnRxChar) FOnRxChar(this, ComStat.cbInQue);

  if ((Status & EV_RXFLAG) > 0)
    if (FOnRxFlag)  FOnRxFlag(this);

  if ((Status & EV_TXEMPTY) > 0)
    if (FOnTxEmpty)  FOnTxEmpty(this);
  if (FCommStatEvent)  FCommStatEvent(this,Status , ComStat);
}

bool __fastcall TThreadComm::GetModemState(int Index)
{
  DWORD Flag, State;
  bool Result ;

  switch  (Index)
  {
    case 1:  State = MS_CTS_ON;   break;
    case 2:  State = MS_DSR_ON;   break;
    case 3:  State = MS_RING_ON;  break;
    case 4:  State = MS_RLSD_ON;  break;
    default: State = 0;           break;
  }
  Result = false;
  if (Enabled())
    if (GetCommModemStatus(FHandle, &Flag))
      Result = ((Flag & State) > 0);
  return Result ;
}

bool __fastcall TThreadComm::GetComState(int Index)
{
  COMSTAT       ComStat;
  DWORD         Errors;
  bool          Result;

  if (Enabled())
  {
    ClearCommError(FHandle, &Errors, &ComStat);
  }
  switch (Index)
  {
    case 1:  Result = ComStat.fCtsHold;  break;
    case 2:  Result = ComStat.fDsrHold;  break;
    case 3:  Result = ComStat.fRlsdHold;  break;
    case 4:  Result = ComStat.fXoffHold; break;
    case 5:  Result = ComStat.fXoffSent; break;
    default: Result = ComStat.fCtsHold;  break;
  }
  return Result ;
}

void __fastcall TThreadComm::UpdateDataControlBlock()
{
bool Result ;
  if (Enabled())
  {
    SetupComm( FHandle, FReadBufSize, FWriteBufSize ) ;
    GetCommState(FHandle, &FDCB);

    FDCB.BaudRate = CommBaudRates[FBaudRate];
    FDCB.Parity = CommParity[FParity];
    FDCB.StopBits = CommStopBits[FStopBits];
    FDCB.ByteSize = CommDataBits[FDataBits];
    FDCB.XonChar = FEventChars->XOnChar;
    FDCB.XoffChar = FEventChars->XOffChar;
    FDCB.ErrorChar = FEventChars->ErrorChar;
    FDCB.EofChar = FEventChars->EofChar;
    FDCB.EvtChar = FEventChars->EvtChar;
    FDCB.XonLim = 1024;//WORD(FReadBufSize / 4);
    FDCB.XoffLim = 1024; //WORD(FReadBufSize / 4);

//    InitHandshaking(FDCB);

    FDCB.fParity = FOptions.Contains(coParityCheck);
    FDCB.fDsrSensitivity = FOptions.Contains(coDsrSensitivity) ;
    FDCB.fTXContinueOnXoff = FOptions.Contains(coIgnoreXOff) ;
    FDCB.fErrorChar = FOptions.Contains(coErrorChar);
    FDCB.fNull = FOptions.Contains(coNullStrip) ;

    Result = SetCommState(FHandle, &FDCB) ;
        if (!Result)
          RaiseCommError(sUpdateDCBErr, GetLastError());
  }
}

void __fastcall TThreadComm::UpdateDataControlBlockLock()
{
    Lock();
    UpdateDataControlBlock();
    Unlock();
}

void __fastcall TThreadComm::EscapeComm(int Flag)
{
  bool Escaped;

  if (Enabled())
  {
    Lock();
    Escaped = EscapeCommFunction(FHandle, Flag);
    Unlock();
    if (!Escaped)
      RaiseCommError(sEscFuncError, GetLastError());
  } else RaiseCommError(sPortNotOpen, -1);
}

void __fastcall TThreadComm::SetDTRState(bool State)
{
  int DTR[] = {CLRDTR, SETDTR};
  EscapeComm(DTR[State]);
}

void __fastcall TThreadComm::SetRTSState(bool State)
{
  int RTS[]= { CLRRTS, SETRTS};
  EscapeComm(RTS[State]);
}

void __fastcall TThreadComm::SetBREAKState(bool State)
{
  int BREAK[] = { CLRBREAK, SETBREAK };

  EscapeComm(BREAK[State]);
  if (Enabled())
  {
    Lock();
    PurgeComm(FHandle, PurgeReadWrite);
    Unlock();
  }
}

void __fastcall TThreadComm::SetXONState(bool State)
{
  int XON[] = { SETXOFF, SETXON };
  EscapeComm(XON[State]);
}

void __fastcall TThreadComm::UpdateCommTimeouts()
{
  COMMTIMEOUTS CommTimeOuts;
  bool Result ;

	      CommTimeOuts.ReadIntervalTimeout = 0xFFFFFFFF ;
    	  CommTimeOuts.ReadTotalTimeoutMultiplier = 0 ;
	      CommTimeOuts.ReadTotalTimeoutConstant = 1000 ;
	      CommTimeOuts.WriteTotalTimeoutMultiplier = 2*CBR_9600/FBaudRate ;
    	  CommTimeOuts.WriteTotalTimeoutConstant = 0 ;
  Result = SetCommTimeouts(FHandle, &CommTimeOuts) ;
  if (!Result)
    RaiseCommError(sCommTimeoutsErr, GetLastError());
}

//---------------------------------------------------------------------------
namespace Comm
{
    void __fastcall PACKAGE Register()
    {
        TComponentClass classes[1] = {__classid(TComm)};
        RegisterComponents("Samples", classes, 0);
    }
}
//---------------------------------------------------------------------------