comm.cpp

用bcb6.0修改了原来用delphi编的spcomm

} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::ReceiveError(DWORD EvtMask) 
{ 
    if ( FOnReceiveError != NULL) 
        FOnReceiveError( this, EvtMask ); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::ModemStateChange(DWORD ModemEvent) 
{ 
    if ( FOnModemStateChange != NULL ) 
        FOnModemStateChange( this, ModemEvent ); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::RequestHangup(void) 
{ 
    if ( FOnRequestHangup != NULL ) 
        FOnRequestHangup( this ); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::_SendDataEmpty(void) 
{ 
    if ( FOnSendDataEmpty != NULL ) 
        FOnSendDataEmpty( this ); 
} 
//--------------------------------------------------------------------------- 
/***************************************************************************/ 
//  TComm PRIVATE METHODS 
/***************************************************************************/ 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::CommWndProc(Messages::TMessage &msg) 
{ 
   switch( msg.Msg ) 
   { 
        case  PWM_GOTCOMMDATA: 
        { 
               ReceiveData( PChar(msg.LParam), msg.WParam ); 

               LocalFree( (LPARAM*)(msg.LParam) ); 

               break; 
        } 
        case  PWM_RECEIVEERROR: 
        { 
            ReceiveError( msg.LParam ); 
            break; 
        } 
        case PWM_MODEMSTATECHANGE: 
        { 
            ModemStateChange( msg.LParam ); 
            break; 
        } 
        case PWM_REQUESTHANGUP: 
        { 
            RequestHangup(); 
            break; 
        } 
        case PWM_SENDDATAEMPTY: 
        { 
            _SendDataEmpty(); 
            break; 
        } 
   } 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::_SetCommState(void) 
{ 
    DCB         dcb; 
    TCommProp   commprop; 
    DWORD       fdwEvtMask; 

    // Configure the comm settings. 
    // NOTE: Most Comm settings can be set through TAPI, but this means that 
    //       the CommFile will have to be passed to this component. 

    GetCommState( hCommFile, &dcb ); 
    GetCommProperties( hCommFile, &commprop ); 
    GetCommMask( hCommFile, &fdwEvtMask ); 

    // fAbortOnError is the only DCB dependancy in TapiComm. 
    // Can't guarentee that the SP will set this to what we expect. 
    // dcb.fAbortOnError = False; NOT VALID 

    dcb.BaudRate = FBaudRate; 
dcb.fBinary = 1;    // Specifies whether binary mode is enabled. 

    if (FParityCheck) 
        dcb.fBinary = dcb.fBinary  | 2;          // Enable parity check 

     // setup hardware flow control 

     if (FOutx_CtsFlow) 
        dcb.fBinary = dcb.fBinary  | 4; 

     if (FOutx_DsrFlow) 
        dcb.fBinary = dcb.fBinary  | 8; 

     if (FDtrControl == DtrEnable) 
        dcb.fBinary = dcb.fBinary  | 0x10; 
     else if (FDtrControl == DtrHandshake) 
          dcb.fBinary = dcb.fBinary  |0x20; 

     if (FDsrSensitivity) 
        dcb.fBinary = dcb.fBinary  | 0x40; 

     if (FTxContinueOnXoff) 
        dcb.fBinary = dcb.fBinary  | 0x80; 

     if (FOutx_XonXoffFlow) 
        dcb.fBinary = dcb.fBinary  | 0x100; 

     if (FInx_XonXoffFlow) 
        dcb.fBinary = dcb.fBinary  | 0x200; 

     if (FReplaceWhenParityError ) 
        dcb.fBinary = dcb.fBinary  | 0x400; 

     if (FIgnoreNullChar) 
        dcb.fBinary = dcb.fBinary  | 0x800; 

     if (FRtsControl == RtsEnable) 
        dcb.fBinary = dcb.fBinary  | 0x1000; 
     else if (FRtsControl == RtsHandshake) 
          dcb.fBinary = dcb.fBinary  | 0xd2000; 
     else if (FRtsControl == RtsTransmissionAvailable) 
          dcb.fBinary = dcb.fBinary  | 0x3000; 

     dcb.XonLim  = FXonLimit; 
     dcb.XoffLim = FXoffLimit; 

     dcb.ByteSize = FByteSize + 5; 
     dcb.Parity   = FParity; 
     dcb.StopBits = FStopBits; 

     dcb.XonChar = FXonChar; 
     dcb.XoffChar = FXoffChar; 
     dcb.ErrorChar = FReplacedChar; 

     SetCommState( hCommFile, &dcb ); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::_SetCommTimeout(void) 
{ 
     TCommTimeouts commtimeouts; 
     GetCommTimeouts( hCommFile, &commtimeouts ); 

     // The CommTimeout numbers will very likely change if you are 
     // coding to meet some kind of specification where 
     // you need to reply within a certain amount of time after 
     // recieving the last byte.  However,  If 1/4th of a second 
     // goes by between recieving two characters, its a good 
     // indication that the transmitting end has finished, even 
     // assuming a 1200 baud modem. 

     commtimeouts.ReadIntervalTimeout         = FReadIntervalTimeout; 
     commtimeouts.ReadTotalTimeoutMultiplier  = FReadTotalTimeoutMultiplier; 
     commtimeouts.ReadTotalTimeoutConstant    = FReadTotalTimeoutConstant; 
     commtimeouts.WriteTotalTimeoutMultiplier = FWriteTotalTimeoutMultiplier; 
     commtimeouts.WriteTotalTimeoutConstant   = FWriteTotalTimeoutConstant; 

     SetCommTimeouts( hCommFile, &commtimeouts ); 
} 
//---------------------------------------------------------------------------
void __fastcall TCommX::SetBaudRate(DWORD Rate) 
{ 
     if (Rate == FBaudRate) return; 

     FBaudRate = Rate; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetParityCheck(bool b) 
{ 
    if (b == FParityCheck) return; 

     FParityCheck = b; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetOutx_CtsFlow(bool b) 
{ 
    if (b == FOutx_CtsFlow) return; 

     FOutx_CtsFlow = b; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetOutx_DsrFlow(bool b) 
{ 
    if (b == FOutx_DsrFlow) return; 

     FOutx_DsrFlow = b; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetDtrControl(TDtrControl c) 
{ 
    if (c == FDtrControl) return; 

    FDtrControl = c; 

    if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetDsrSensitivity(bool b) 
{ 
     if (b == FDsrSensitivity) return; 

     FDsrSensitivity = b; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetTxContinueOnXoff(bool b) 
{ 
     if (b == FTxContinueOnXoff) return; 

     FTxContinueOnXoff = b; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetOutx_XonXoffFlow(bool b) 
{ 
     if (b == FOutx_XonXoffFlow) return; 

     FOutx_XonXoffFlow = b; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetInx_XonXoffFlow(bool b) 
{ 
     if (b == FInx_XonXoffFlow) return; 

     FInx_XonXoffFlow = b; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetReplaceWhenParityError(bool b) 
{ 
     if (b == FReplaceWhenParityError) return; 

     FReplaceWhenParityError = b; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetIgnoreNullChar(bool b) 
{ 
     if (b == FIgnoreNullChar) return; 

     FIgnoreNullChar = b; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetRtsControl(TRtsControl c) 
{ 
     if (c == FRtsControl) return; 

     FRtsControl = c; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetXonLimit(Word Limit) 
{ 
     if (Limit == FXonLimit) return; 

     FXonLimit = Limit; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetXoffLimit(Word Limit) 
{ 
     if (Limit == FXoffLimit) return; 

     FXoffLimit = Limit; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetByteSize(TByteSize Size) 
{ 
     if (Size == FByteSize) return; 

     FByteSize = Size; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetParity(TParity p) 
{ 
     if (p == FParity) return; 

     FParity = p; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetStopBits(TStopBits Bits) 
{ 
     if (Bits == FStopBits) return; 

     FStopBits = Bits; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetXonChar(char c) 
{ 
     if (c == FXonChar) return; 

     FXonChar = c; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetXoffChar(char c) 
{ 
     if (c == FXoffChar) return; 

     FXoffChar = c; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetReplacedChar(char c) 
{ 
     if (c == FReplacedChar) return; 

     FReplacedChar = c; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetReadIntervalTimeout(DWORD v) 
{ 
     if (v == FReadIntervalTimeout) return; 

     FReadIntervalTimeout = v; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetReadTotalTimeoutMultiplier(DWORD v) 
{ 
     if (v == FReadTotalTimeoutMultiplier) return; 

     FReadTotalTimeoutMultiplier = v; 

     if (hCommFile != NULL) 
        _SetCommState(); 
}
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetReadTotalTimeoutConstant(DWORD v) 
{ 
     if (v == FReadTotalTimeoutConstant) return; 

     FReadTotalTimeoutConstant = v; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetWriteTotalTimeoutMultiplier(DWORD v) 
{ 
     if (v == FWriteTotalTimeoutMultiplier) return; 

     FWriteTotalTimeoutMultiplier = v; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TCommX::SetWriteTotalTimeoutConstant(DWORD v) 
{ 
     if (v == FWriteTotalTimeoutConstant) return; 

     FWriteTotalTimeoutConstant = v; 

     if (hCommFile != NULL) 
        _SetCommState(); 
} 
//--------------------------------------------------------------------------- 
/**************************************************************************** 
    OVERLAPPED：保存串口异步通讯的信息。具体结构如下： 

    typedef struct _OVERLAPPED 
    { 
            DWORD Internal; 
            DWORD InternalHigh; 
            DWORD Offset; 
            DWORD OffsetHigh; 
            HANDLE hEvent; 
    } OVERLAPPED;