serial.cpp

基于mips嵌入式非接触式IC卡读卡器程序源码

// Serial.cpp  

#include <stdio.h>              // printf
#include <fcntl.h>              // open
#include <string.h>             // bzero
#include <stdlib.h>             // exit
#include <sys/times.h>          // times
#include <sys/types.h>          // pid_t
#include <termios.h>            //termios, tcgetattr(), tcsetattr()
#include <unistd.h>
#include <sys/ioctl.h>
#include "Serial.h"

#define TIMEOUT_SEC(buflen,baud) (buflen*20/baud+2)
#define TIMEOUT_USEC 0

CSerial::CSerial()
{
	m_bOpened = false;
}

CSerial::~CSerial()
{
	Close();
}

void CSerial::ClearInputBuf()
{
	if( m_bOpened )
        {
            return;
        }
}

bool CSerial::Open( int nPort, int nBaud )
{         
	if( m_bOpened ) 
        {
            return true;
        }

	char szPort[20];
	struct termios termios_old, termios_new;
	sprintf( szPort, "/dev/ttyS%d", nPort );
        m_hIDComDev = open( szPort, O_RDWR/*| O_NOCTTY | O_NONBLOCK*/ );

        if ( -1==m_hIDComDev ){
            return false;
        }
        
        bzero(&termios_new, sizeof(termios_new));
        cfmakeraw(&termios_new);
        fcntl(m_hIDComDev, F_SETFL, 0);
        //baudrates
        cfsetispeed(&termios_new, B9600);  
        cfsetospeed(&termios_new, B9600);
        termios_new.c_cflag |= CLOCAL;   
        termios_new.c_cflag |= CREAD;  
        
       //flow control
        //termios_new.c_cflag &= ~CRTSCTS;  //no flow control
       //parity check
	termios_new.c_cflag &= ~PARENB;  //no parity check
        termios_new.c_iflag &= ~INPCK;
       //stop bits
        termios_new.c_cflag &= ~CSTOPB; //1 stop bits
       //data bits
        termios_new.c_cflag &= ~CSIZE;  
        termios_new.c_cflag |= CS8;
       //other attributions default
        termios_new.c_iflag &=~(ICANON | ECHO | ECHOE | ISIG);
        termios_new.c_oflag &= ~OPOST; 
        termios_new.c_cc[VMIN]  = 0;  
        termios_new.c_cc[VTIME] = 1;   //unit: (1/10)second

        tcflush(m_hIDComDev, TCIFLUSH);   
        if( tcsetattr(m_hIDComDev, TCSANOW, &termios_new)!= 0)
         {
            printf("open com error\n");
             }
        m_bOpened = true;

	return( m_bOpened );

}


bool CSerial::Close( void )
{
	close( m_hIDComDev );
	return( true );
}

bool CSerial::WriteCommByte( unsigned char ucByte )
{
/*	BOOL bWriteStat;
	DWORD dwBytesWritten;

	bWriteStat = WriteFile( m_hIDComDev, (LPSTR) &ucByte, 1, &dwBytesWritten, NULL );
*/	return( true );

}

int CSerial::SendData( const char *buffer, int size )
{
    int len = 0;

    len = write(m_hIDComDev, buffer, size); 
 //   tcflush(m_hIDComDev, TCOFLUSH);
    if(len == size) {
       return (len);
    }
    
    else{
       tcflush(m_hIDComDev, TCOFLUSH);
       return -1;
    }
 // CSerial:: Open( nPort, nBaud);
}

int CSerial::ReadDataWaiting( void )
{

	//if( !m_bOpened || m_hIDComDev == NULL ) return( 0 );

	/*char dwErrorFlags;
	COMSTAT ComStat;

	ClearCommError( m_hIDComDev, &dwErrorFlags, &ComStat );

	return( (int) ComStat.cbInQue );

        return 0;*/
}

int CSerial::ReadData( void *buffer, int limit )
{
	if( !m_bOpened || m_hIDComDev == 0 ) return( 0 );

        int readlen, fs_sel;
        fd_set fs_read;
        struct timeval tv_timeout;

        FD_ZERO(&fs_read);
        FD_SET(m_hIDComDev, &fs_read);
        tv_timeout.tv_sec = 1;//TIMEOUT_SEC(limit, B9600);
        tv_timeout.tv_usec =TIMEOUT_USEC;

        fs_sel = select(m_hIDComDev+1, &fs_read, NULL, NULL, &tv_timeout);
        if(!fs_sel){
            return(-1);
        }
          
        readlen = read(m_hIDComDev, buffer, limit);
        
        return (readlen);
}

int CSerial::WReadData(char *buffer, long int limit)
{
	if( !m_bOpened || m_hIDComDev == 0 ) return( 0 );
     /*   struct timeval tv_timeout;
        int fs_sel;
        fd_set fs_read;
        FD_ZERO(&fs_read);
        FD_SET(m_hIDComDev, &fs_read);
        tv_timeout.tv_sec =1;// TIMEOUT_SEC(limit, 9600);
        tv_timeout.tv_usec =TIMEOUT_USEC;

        fs_sel = select(m_hIDComDev+1, &fs_read, NULL, NULL, &tv_timeout);
        if(!fs_sel){
            return(-1);
        }*/
              
	int dwBytesRead;
	dwBytesRead = limit;
        read(m_hIDComDev, buffer, limit);
	return( dwBytesRead );
       
}