serialport.cpp

用一个开源码ASCII ENCODE,DECODE,来发送ASCII短信

#include "SerialPort.h"
#include <iostream>
#include <sys/ioctl.h>

using namespace std ;
using namespace SerialPorts ;

int SerialPort::open(char * devicename) {
	
	this->fd = ::open(devicename, O_RDWR | O_NOCTTY | O_NDELAY);
	
	if (this->fd == -1) {
		/*
		 * Could not open the port.
		 */
		//printf("open_port: Unable to open %s\n", serialPort);
		this->state = -1;
	} else {
		/*
		 * Restore blocking behaviour of the port, as we opened it with O_NDELAY
		 */
		struct termios options;
		
		/* Get Current Settings of the fileDescriptor */
		if ( tcgetattr(this->fd, &options) != 0 ){
			this->state = -1;
			return this->state;
		}
		options.c_cflag |= (CLOCAL | CREAD);
		options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
		if ( tcsetattr(this->fd, TCSANOW, &options) != 0 ) {
			this->state = -1;
			return this->state;
		}
	  	fcntl(fd, F_SETFL, 0);
		this->state = 1;
	}
	return this->state;
}

int SerialPort::close(void) {
	this->state = -1;
	return ::close(this->fd);
}

int SerialPort::status() {
	return this->state;
}

int SerialPort::write(char * data, int lenght) {
//	cout << "Size van data is : " << sizeof(data) << endl;
//	cout << "Size van data is : " << sizeof(data) << endl;
//	cout << "String is : " << data << endl;
	return ::write(this->fd, data, lenght);
}
char SerialPort::readChar() {
	char character = '\0';
	char * character_ptr;
	int bytesRecv;
	
	character_ptr = &character;
	bytesRecv = read(this->fd, character_ptr, sizeof(character));
	if ( bytesRecv == sizeof(character) ){
		return character;
	}
	return 0;
}

char * SerialPort::readBytes(int bytes) {
	char * buffer =  (char *) malloc(bytes);
	int bytesRead;
	bytesRead = ::read(this->fd, buffer, bytes);
	if ( bytesRead != bytes ) {
		cout << "OOPS bytes <> bytes_wait" << endl;
	}
	return buffer;
}

int SerialPort::dataWaiting() {
	int bytes;

    ioctl(this->fd, FIONREAD, &bytes);
	return bytes;
}

enum BaudRateEnum SerialPort::setBaudRate( enum BaudRateEnum baud) {
	if ( ! this->state ) {
		this->baud = BAUD_ERR;
		return this->baud;
	}

    switch ( baud ) {
	    case BAUD_50:
	    case BAUD_75:   
	    case BAUD_110:  
	    case BAUD_134:  
	    case BAUD_150:  
	    case BAUD_200:  
	    case BAUD_300:  
	    case BAUD_600:  
	    case BAUD_1200: 
	    case BAUD_1800: 
	    case BAUD_2400: 
	    case BAUD_4800: 
	    case BAUD_9600: 
	    case BAUD_19200:
	    case BAUD_38400:
	    case BAUD_57600:
	    case BAUD_115200:
    
		   	struct termios options;
			
			/* Get Current Settings of the fileDescriptor */
			if ( tcgetattr(this->fd, &options) != 0 ){
				this->state = -1; 
			}
			
			/* Set port speed to xxx baud */
			if ( cfsetispeed(&options, baud) != 0 ){
				this->state = -1;
			}
		    if ( cfsetospeed(&options, baud) != 0 ){
				this->state = -1;
			}
			if ( this->state == -1 ) {
				this->baud = BAUD_ERR;
			} else {
				this->baud = baud;
			}
			return this->baud;
		    break ;
    
	    default:
    	    this->baud = BAUD_ERR;
        	return this->baud;
        	break;
    };//switch
}

enum CharSizeEnum SerialPort::setCharSize( enum CharSizeEnum charsize) {
	if ( ! this->state ) {
		this->charsize = CHAR_SIZE_ERR;
		return this->charsize;
	}
	
	struct termios options;
	if ( tcgetattr(this->fd, &options) != 0 ) {
		this->state = -1;
		this->charsize = CHAR_SIZE_ERR;
		return this->charsize;
	}
	
	switch ( charsize ) {
		case CHAR_SIZE_5:
        case CHAR_SIZE_6:
        case CHAR_SIZE_7:
        case CHAR_SIZE_8:
        
        	if( charsize == CHAR_SIZE_8 ) {
            	options.c_iflag &= ~ISTRIP ; // clear the ISTRIP flag.
        	} else {
            	options.c_iflag |= ISTRIP ;  // set the ISTRIP flag.
        	}
        	options.c_cflag &= ~CSIZE;
        	options.c_cflag |= charsize;
        	
        	if ( tcsetattr(this->fd, TCSANOW, &options) != 0 ){
				this->state = -1;
				this->charsize = CHAR_SIZE_ERR;
			} else {
				this->charsize = charsize;
			}
			return this->charsize;
        	break ;
        	
        default:
        	this->charsize = CHAR_SIZE_ERR;
        	return this->charsize;
        	break;
	}//switch
}

enum ParityEnum SerialPort::setParity( enum ParityEnum parity) {
	if ( ! this->state ) {
		this->parity = PARITY_ERR;
		return this->parity;
	}
	
	struct termios options ;
	if ( tcgetattr(this->fd, &options) != 0 ) {
		this->state = -1;
		this->parity = PARITY_ERR;
		return this->parity;
	}

    switch ( parity ) {
	    case PARITY_EVEN:
	        options.c_cflag |= PARENB ;
	        options.c_cflag &= ~PARODD ;
	        break ;
	    case PARITY_ODD:
	        options.c_cflag |= PARENB ;
	        options.c_cflag |= PARODD ;
	        break ;
	    case PARITY_NONE:
	        options.c_cflag &= ~PARENB ;
	        break ;
	    default:
			this->parity = PARITY_ERR;
			return this->parity;
	}

	if ( tcsetattr(this->fd, TCSANOW, &options) != 0 ){
		this->state = -1;
		this->parity = PARITY_ERR;
	} else {
		this->parity = parity;
	}
	return this->parity;
}

int SerialPort::setStopBits(int stopbits) {
	if ( ! this->state ) {
		this->stopbits = -1;
		return this->parity;
	}
	
	struct termios options ;
	if ( tcgetattr(this->fd, &options) != 0 ) {
		this->state = -1;
		this->stopbits = -1;
		return this->parity;
	}
	switch ( stopbits ) {
		case 1:
			options.c_cflag &= ~CSTOPB ;
			break;
		case 2:
			options.c_cflag |= CSTOPB ;
			break;
		default:
			this->stopbits = -1;
			return this->stopbits;
			break;
	}
	
	if ( tcsetattr(this->fd, TCSANOW, &options) != 0 ){
		this->state = -1;
		this->stopbits = -1;
		return this->stopbits;
	}
	this->stopbits = stopbits;
	return this->stopbits;
}

enum FlowControlEnum SerialPort::setFlowControl( enum FlowControlEnum flowctrl) {
	if ( ! this->state ) {
		this->flowctrl = FLOW_CONTROL_ERR;
		return this->flowctrl;
	}
	
	struct termios options ;
	if ( tcgetattr(this->fd, &options) != 0 ) {
		this->state = -1;
		this->flowctrl = FLOW_CONTROL_ERR;
		return this->flowctrl; 
	}
	
	switch ( flowctrl ) {
		case FLOW_CONTROL_HARD:
			options.c_iflag &= ~ (IXON|IXOFF);
        	options.c_cflag |= CRTSCTS;
			options.c_cc[VSTART] = _POSIX_VDISABLE;
        	options.c_cc[VSTOP] = _POSIX_VDISABLE;
        	break;
		case FLOW_CONTROL_SOFT:
			options.c_iflag |= IXON|IXOFF;
			options.c_cflag &= ~CRTSCTS;
			options.c_cc[VSTART] = CTRL_Q ; // 0x11 (021) ^q
			options.c_cc[VSTOP]  = CTRL_S ; // 0x13 (023) ^s
			break;
		case FLOW_CONTROL_NONE:
			options.c_iflag &= ~(IXON|IXOFF);
			options.c_cflag &= ~CRTSCTS;
			break;
		default:
			this->flowctrl = FLOW_CONTROL_ERR;
			return this->flowctrl;
			break;
	}
	
	if ( tcsetattr(this->fd, TCSANOW, &options) != 0 ){
		this->state = -1;
		this->flowctrl = FLOW_CONTROL_ERR;
		return this->flowctrl;
	}
	this->flowctrl = flowctrl;
	return this->flowctrl;
}