comm.cpp

uart串口通信的控件和demo,用API 编写

}

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();
  }
}
//*xukaiming 2005.4.2日更改--------------------------------------start ----------//
/*
void __fastcall TThreadComm::SetFlowControl(TFlowControl Value)
{
  if (FFlowControl != Value)
  {
    FFlowControl = Value;
    UpdateDataControlBlockLock();
  }
}
*/
//*xukaiming 2005.4.2日更改--------------------------------------end ----------//

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.DCBlength          = sizeof(DCB);
    FDCB.fBinary            = 1;//win32s 只支持2进制
     //*xukaiming 2005.4.2日添加--------------------------------------start ----------//
    FDCB.fOutxCtsFlow       = FFlowOptions.Contains(foCTSFlow);
    FDCB.fOutxDsrFlow       = FFlowOptions.Contains(foDsrFlow);
    FDCB.fOutX              = FFlowOptions.Contains(foOutX);     //
    FDCB.fInX               = FFlowOptions.Contains(foInX);
    //foCTSFlow,foDsrFlow,foOutX,foInX
    FDCB.fOutxDsrFlow;       //
    
    FDCB.fDtrControl        = DTRControl;
    //FDCB.fDsrSensitivity    = ;

    FDCB.fTXContinueOnXoff;
    FDCB.fOutX;
    FDCB.fInX;
    FDCB.fErrorChar;
    FDCB.fNull;
    FDCB.fRtsControl        = RTSControl;
    FDCB.fAbortOnError;
    FDCB.fDummy2;
    FDCB.wReserved;
    FDCB.ErrorChar;       /* Error replacement char          */
    WORD wReserved1;      /* Fill for now.                   */
    //*xukaiming 2005.4.2日添加--------------------------------------end ----------//
    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     = WORD(FReadBufSize / 4); //1024;      //大于此数字传输Xon
    FDCB.XoffLim    = WORD(FReadBufSize / 4); //1024;//     //小雨此数字传输Xoff

//    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;   //2005.3.6   //? dive zero overflow
              CommTimeOuts.WriteTotalTimeoutConstant = 0 ;
  Result = SetCommTimeouts(FHandle, &CommTimeOuts) ;
  if (!Result)
    RaiseCommError(sCommTimeoutsErr, GetLastError());
}
//---------------------------------------------------------------------------
__fastcall TComm::TComm(TComponent* Owner):TThreadComm(Owner)
{
}

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



//*xukaiming 2005.4.2日添加--------------------------------------start ----------//


void __fastcall TThreadComm::SetDTRControl(TDTRControl value)
{
        if(FDTRControl != value) {

                FDTRControl = value;
                UpdateDataControlBlockLock();
        }
}
TDTRControl __fastcall TThreadComm::GetDTRControl()
{
        return FDTRControl;
}




void __fastcall TThreadComm::SetRTSControl(TRTSControl value)
{
        if(FRTSControl != value) {

                FRTSControl = value;
                UpdateDataControlBlockLock();
        }

}
TRTSControl __fastcall TThreadComm::GetRTSControl()
{
        return FRTSControl;
}   


void __fastcall TThreadComm::SetFlowControl(TFlowControl value)
{
        if(FFlowControl != value) {

                FFlowControl = value;
                UpdateDataControlBlockLock();
        }
}
TFlowControl __fastcall TThreadComm::GetFlowControl()
{
        return FFlowControl;
}
//*xukaiming 2005.4.2日添加--------------------------------------end ----------//

//*xukaiming 2005.4.3日添加--------------------------------------start ----------//

void __fastcall TThreadComm::SetDSRSensitivity(bool value)
{
        if(TDSRSensitivity != value) {
                TDSRSensitivity = value;
                UpdateDataControlBlockLock();
        }
}
bool __fastcall TThreadComm::GetDSRSensitivity()
{
        return TDSRSensitivity;
}


void __fastcall TThreadComm::SetFlowOptions(TFlowOptions value)
{
        if(FFlowOptions != value) {
                FFlowOptions = value;
                UpdateDataControlBlockLock();
        }
}
 //*xukaiming 2005.4.3日添加--------------------------------------end----------//