emscom.cpp

在LINUX环境下

#include "EMSCom.h"

//------------------------------------------------------------------------------
EmsCom::EmsCom()
{
	  // set default property values
  	m_PortHandle = INVALID_HANDLE_VALUE; // invalidate to start

#ifdef WIN32
	m_ComName = 'COM1';
#else
    	m_ComName = 'ttyS0';
#endif

  	m_BaudRate = 5760;
  	m_DataBits = 8;
  	m_StopBits = 0;
  	m_Parity = 2; //even

  	m_Inuse=false;
  	m_EndChar='';
  	m_IntervalOut=0;
}

//------------------------------------------------------------------------------
EMSCom::~EmsCom()
{
	ToCloseCom();
}

//------------------------------------------------------------------------------
int EmsCom::ToSetBaud(int _BaudRate)
{
	if(m_BaudRate!=_BaudRate)
	{
		m_BaudRate=_BaudRate;
		if(IsOpened())
			ToCloseCom();
		ToOpenCom();
	}
	return 0;
}
//------------------------------------------------------------------------------
int EmsCom::ToSetData(short int _DataBits)// Procedure to set the Data bits
{
	if(m_DataBits!=_DataBits)
	{
		m_DataBits=_DataBits;
		if(IsOpened())
			ToCloseCom();
		ToOpenCom();
	}
	return 0;
}
//------------------------------------------------------------------------------
int EmsCom::ToSetStop(short int _StopBits)// Procedure to set the stop bits
{
	if(m_StopBits!=_StopBits)
	{
		m_StopBits=_StopBits;
		if(IsOpened())
			ToCloseCom();
		ToOpenCom();
	}
	return 0;
}
//------------------------------------------------------------------------------
int EmsCom::ToSetParity(short int _Parity)//Procedure to set the Parity
{
	if(m_Parity!=_Parity)
	{
		m_Parity=_Parity;
		if(IsOpened())
			ToCloseCom();
		ToOpenCom();
	}
	return 0;
}

//----------------------------------------------------------------------
//Opens the COM port, returns True if ok
bool EmsCom::ToOpenCom(void)
{
	string _sTempComName;
	int _TempFileHandle;
  	termios _Opt;


	if(m_PortHandle!=INVALID_HANDLE_VALUE)
	   ToCloseCom();

#ifdef WIN32

#else

  	_sTempComName="/dev/"+m_ComName;
  	_TempFileHandle= open(_sTempComName.c_str(),  RDWR or NOCTTY or NDELAY);
	if (_TempFileHandle!-1)
	   	 m_PortHandle=_TempFileHandle
	else
		m_PortHandle=INVALID_HANDLE_VALUE;
	  
	if (m_PortHandle!=INVALID_HANDLE_VALUE)
	{
		tcgetattr(m_PortHandle, &_Opt);
		memset(_Opt,0,sizeof(_Opt));
		
   		 //tcflush(FPortHandle, TCIOFLUSH);
    		cfsetispeed(_Opt, m_BaudRate);
    		cfsetospeed(_Opt, m_BaudRate);
		switch(m_BaudRate)
		{
      			case 4800:
        			_Opt.c_cflag = B4800 or CS8 | CLOCAL | CREAD;
				break;
      			case 9600:
        			_Opt.c_cflag = B9600 or CS8 | CLOCAL | CREAD;
				break;
      			default:
        			_Opt.c_cflag = B19200 or CS8 | CLOCAL | CREAD;
		}
		
      		_Opt.c_iflag = 0;//INLCR;    
      		_Opt.c_oflag = 0;   
		_Opt.c_lflag = 0;//ICANON;    
		_Opt.c_cflag =_Opt.c_cflag &  (~CSIZE);    

		switch(m_DataBits)
		{
			case 7:
				_Opt.c_cflag = _Opt.c_cflag | CS7;
				break;
  	  		case 8:
				_Opt.c_cflag = _Opt.c_cflag | CS8;
				break;
			default:
				ToCloseCom();
		}
	}
	if (m_PortHandle!=INVALID_HANDLE_VALUE)
	{
		switch(m_Parity)
		{
			case  0:{
          			_Opt.c_cflag =_Opt.c_cflag &  (~PARENB);   // Clear parity enable
		      		_Opt.c_iflag =_Opt.c_iflag &  (~INPCK);     // Enable parity checking
		      		break;
			}
   			case 1:{
          			_Opt.c_cflag =_Opt.c_cflag | (PARODD | PARENB);  // 设置为奇效验*/
		      		_Opt.c_iflag =_Opt.c_iflag | (INPCK);             // Disnable parity checking
		      		break;
   			}
       		case 2:{
		          	_Opt.c_cflag =_Opt.c_cflag | PARENB;     // Enable parity
          			_Opt.c_cflag =_Opt.c_cflag & (~PARODD);   //转换为偶效验*/
          			_Opt.c_iflag =_Opt.c_iflag | INPCK;       //Disnable parity checking */
        			break;
       		}
			case 4:{
			      _Opt.c_cflag =_Opt.c_cflag & (~PARENB);
			      _Opt.c_cflag =_Opt.c_cflag & (~CSTOPB);
				break;
			}
			default:
				ToCloseCom();
		}
	}
				
	if (m_PortHandle!=INVALID_HANDLE_VALUE)
	{
		switch(m_StopBits)
		{
			case 0:
			{
  	  			_Opt.c_cflag =_Opt.c_cflag & (~CSTOPB);
				break;
			}
			case 2:
			{
  	  			_Opt.c_cflag =_Opt.c_cflag | CSTOPB;
				break;
			}
			default:
				ToCloseCom();
		}
	}

  //Set input parity option
	if (m_PortHandle!=INVALID_HANDLE_VALUE)
	{
    		if m_Parity<>0 then
		      _Opt.c_iflag =_Opt.c_iflag | INPCK;

		_Opt.c_cflag =_Opt.c_cflag | CREAD | CLOCAL;
	    	_Opt.c_cc[VTIME] = Char(0);
    		_Opt.c_cc[VMIN] = CHar(0);


    		tcflush(m_PortHandle, TCIOFLUSH);// Update the options and do it NOW
    		if(tcsetattr(m_PortHandle, TCSANOW,_Opt)!=0) 
			ToCloseCom();
		else
		     tcflush(m_PortHandle,TCIOFLUSH);
	}
#endif

	return (m_PortHandle!=INVALID_HANDLE_VALUE);
}


//------------------------------------------------------------------------------
int  EmsCom::ToCloseCom(void)
{
	if (m_PortHandle!=INVALID_HANDLE_VALUE)
	{
	#ifdef WIN32
    		CloseHandle(m_PortHandle);
	#else
	    	__close(m_PortHandle);
	#endif

    	m_PortHandle = INVALID_HANDLE_VALUE;

	return 0;
}

//------------------------------------------------------------------------------
bool EmsCom::ToWriteCom(char *_pByteData,int _iLen)
{
	int _dwWriteLen=0; 

	if (m_PortHandle!=INVALID_HANDLE_VALUE)
	{
	#ifdef WIN32

	#else
		tcflush(m_PortHandle,TCIOFLUSH);
    		_dwWriteLen =__Write(m_PortHandle,_pByteData, _iLen);
	#endif
	}
	if(_dwWriteLen==_iLen)
	{
		sleep(3);
		return true;
	}
	return false;
}

//------------------------------------------------------------------------------
bool EmsCom::ToReadCom(char *_pByteData,int &_iLen)
{
	int _iReceiveLen=0;
	if (m_PortHandle!=INVALID_HANDLE_VALUE)
	{
	#ifdef WIN32

	#else
    		_iReceiveLen=__Read(m_PortHandle,_pByteData,1);
    		if(_iReceiveLen>0) 
      			_iLen=_iReceiveLen
    		else
      			_iLen=0;
	#endif
	}
	return (_iLen!=0);
}

//------------------------------------------------------------------------------
bool EmsCom::ToReadCom(string _strRead)
{
	unsigned int cbCharsAvailable, cbCharsRead;
	bool boo_FoundTerm;
	sBuffer: String;
  dwCurWaitTime,dwWaitTime:DWORD;
begin
	Result := '';
  { check boo_InUse in case of rentrancy }
	if not FInUse then
  begin
		FInUse := True;
		if FPortHandle <> INVALID_HANDLE_VALUE then
		begin
			{ if no terminator is defined, simply read any available data and return }
			if(Length(self.FEndChar)=0) and (self.FIntervalOut=0) then
			begin
{$IFDEF MSWINDOWS}
				cbCharsAvailable := GetInCount;
				if cbCharsAvailable > 0 then
				begin
					SetLength(sBuffer, cbCharsAvailable + 1); { allocate space }
					ReadFile(FPortHandle, PChar(sBuffer)^, cbCharsAvailable, cbCharsRead, nil);
					SetLength(sBuffer, cbCharsRead); { adjust length }
          Result := sBuffer;
				end;
{$ENDIF}
{$IFDEF LINUX}
        SetLength(sBuffer, 2); { allocate space }
        if(__Read(FPortHandle, PChar(sBuffer)^, 1)=1) then
        begin
          SetLength(sBuffer, 1); { adjust length }
          Result := sBuffer;
        end;
{$ENDIF}
			end else { a terminator is defined, so read port until terminator found or timed out }
	   	begin
		   	boo_FoundTerm := False;
        dwCurWaitTime:=0;
        if self.FIntervalOut<>0 then
          dwWaitTime:=self.FIntervalOut
        else
          dwWaitTime:=60000;//1 min
        Repeat
          {Application.ProcessMessages;}

{$IFDEF MSWINDOWS}
		   		cbCharsAvailable := GetInCount;
			   	if cbCharsAvailable > 0 then
          begin
            dwCurWaitTime:=0;
            SetLength(sBuffer, cbCharsAvailable + 1); { allocate space }
	   				ReadFile(FPortHandle, PChar(sBuffer)^, cbCharsAvailable, cbCharsRead, nil);
            if cbCharsAvailable<>cbCharsRead then
              cbCharsAvailable:=0;
          end;
{$ENDIF}
{$IFDEF LINUX}
          SetLength(sBuffer, 2); { allocate space }
          if(__Read(FPortHandle, PChar(sBuffer)^, 1)=1) then
          begin
            SetLength(sBuffer, 1); { adjust length }
            cbCharsAvailable:=1;
          end else
            cbCharsAvailable:=0;
  {$ENDIF}
          if cbCharsAvailable > 0 then
          begin
            Result := Result + copy(sBuffer,1,cbCharsAvailable);
            if Length(FEndChar) <> 0 then
            begin
              if (Pos(FEndChar, Result) <> 0) then
                boo_FoundTerm := True;
            end;
          end else begin
            dwCurWaitTime:=dwCurWaitTime+10;
            sleep(10);
          end;
        until ((dwCurWaitTime>=dwWaitTime) or boo_FoundTerm);
      end;
    end;
    FInUse := False;
	end;
end;