//============================================================================
// Name        : LxSerial.cpp
// Author      : Eelko van Breda,www.dbl.tudelft.nl
// Version     : 0.1
// Copyright   : Copyright (c) 2008 LGPL
// Description : serial communicatin class linux
//============================================================================

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <poll.h>
#include <endian.h>

#include "shared_serial/LxSerial.h"


/*	constructor */
LxSerial::LxSerial()
{
	hPort 			= INVALID_DEVICE_HANDLE;
//	b_initialised 	= false;
	b_clear_echo	= false;
	b_hw_flow_control = false;
	b_socket = false;
}

/* return name of the port that was opened */
std::string& LxSerial::get_port_name()
{
	return s_port_name;
}

void LxSerial::set_port_type(LxSerial::PortType port_type)
{
	switch (port_type)
	{
		case RS232:
			b_rts 				= 	false;
			break;

		case RS485_FTDI:
			b_rts 				= 	false;
			break;

		case RS485_EXAR:
			b_rts 				= 	true;
			b_clear_echo 		= 	true;
			break;

		case RS485_SMSC:
			b_rts 				= 	false;
			b_clear_echo 		= 	true;
			break;
			
		case TCP:
			b_socket = true;
			b_rts = false;
			b_clear_echo = false;
			break;

		default:
			perror("LxSerial: no port type specified");
			break;
	}
}

/* open port */
bool LxSerial::port_open(const std::string& portname, LxSerial::PortType port_type)
{
	// Set port type
	set_port_type(port_type);
	
	if (b_socket)
	{
		int optval = 1;

		struct sockaddr_in addr;
		struct hostent *server;

		hPort = socket(AF_INET, SOCK_STREAM, 0);
		setsockopt(hPort, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof optval);

		bzero((char *) &addr, sizeof(addr));
		addr.sin_family = AF_INET;

		std::string host_name   = portname.substr(0, portname.find(':'));
		std::string port_number = portname.substr(portname.find(':')+1);

		server = gethostbyname(host_name.c_str());
		if (!server)
		{
			perror("unknown remote serial host name");
			return false;
		}

		bcopy((char *)server->h_addr, (char *)&addr.sin_addr.s_addr, server->h_length);
		addr.sin_port = htons(atoi(port_number.c_str()));

		if (connect(hPort,(struct sockaddr *) &addr,sizeof(addr)) < 0)
		{
			perror("error connecting to remote serial host");
			return false;
		}
	}
	else
	{
		// Open port
		hPort = open(portname.c_str(), O_RDWR | O_NOCTTY);//|O_NDELAY);						// open the serial device
																				// O_RDWR = open read an write
																				// The O_NOCTTY flag tells UNIX that this program doesn't want to be the "controlling terminal" for that 
																				// port. If you don't specify this then any input (such as keyboard abort signals and so forth) will affect 
																				// your process. Programs like getty(1M/8) use this feature when starting the login process, but normally a 
																				// user program does not want this behavior.
																				// The O_NDELAY flag tells UNIX that this program doesn't care what state the DCD signal line is in ­ 
																				// whether the other end of the port is up and running. If you do not specify this flag, your process will be 
																				// put to sleep until the DCD signal line is the space voltage.

		if (hPort < 0) {															//check if port opened correctly
			perror(" Could not open serial port, aborting");
			return false;
		}


		tcgetattr(hPort, &options); 									// get the current termios (com port options struct) from the kernel
		tcgetattr(hPort, &old_options); 								// get the current termios copy to restore on close

		cfsetispeed(&options, B115200);									// set incomming baudrate to standard 9600, this can be changed with the function set_speed()
		cfsetospeed(&options, B115200);									// set outgoing baudrate to standard 9600

																	// c_cflag Control Options
																	// |= (..) means enabled
																	// &= ~(..) means not enabled
		options.c_cflag |= (CLOCAL|CREAD|CS8); 								// CREAD = enanble receiver
																	// CLOCAL = Local Line, do not change owner of port
																	// CS8 = 8 databits
		options.c_cflag &= ~(CRTSCTS|PARENB|CSTOPB); 					// Disable HW flow control
																	// no paritybit, PARENB = paritybit
																	// 1 stop bit, CSTOPB = 2 stop bits (1 otherwise)
		if (b_hw_flow_control){
			options.c_cflag |= (CRTSCTS); 								// Enable HW flow control
		}

																	// c_lflag Line Options ( controls how input charackters are handeled by the serial driver
		options.c_lflag &= ~(ECHO|ECHONL|ECHOE|ICANON|ISIG|IEXTEN);
//	options.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
																	// ~(..) means not enabled
																	// ECHO echoing of input characters
																	// ECHOE echo erease character as BS-SP-BS
																	// ECHONL mimics echo but doesn't move to next line when it ends
																	// ICANON cononical input = line oriented input, else RAW
																	// ISIG ENABLE SIGINTR, SIGSUSP, SIGDSUSP and SIGQUIT signals
																	// IEXTERN = enable extended functions

																	// c_iflag Input Options
		options.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON|IXOFF);
//	options.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
																	// ~(..) means not enabled
																	// IGNBRK ignore break condition
																	// BRKINT send a SIGINT when a break condition is detected
																	// PARMRK Mark parity errors
																	// ISTRIP strip parity bits
																	// INLCR map new line to CR
																	// IGNCR ignore CR
																	// ICRNL map CR to new line
																	// IXON Enable software flow control (outgoing)
																	// IXOFF Enable software flow control (incomming)

																	// c_oflag output options
		options.c_oflag &= ~(OPOST);
																	// ~(..) means not enabled
																	// OPOST postprocess output (if not set RAW output)
																	// when OPOST is disabled all other other option bits of c-Oflag are ignored

																	// c_cc control character array (control caracter options and timeouts
																	// Timeout 0.005 sec for first byte, read minimum of 0 bytes
																	// timeouts are ignored in cononical input or when NDELAY option is set.
		options.c_cc[VMIN]     = 0; 									// VMIN Minimum number of characters to read
		options.c_cc[VTIME]    = WAIT_FOR_DATA_DSEC; 					// Time to wait for data (tenths of seconds)

//		fcntl(hPort, F_SETFL, FNDELAY); // don't wait for input when reading data

		if (b_rts){														// if we are using RS_485_EXAR type, we clear the RTS signal
			int msc = TIOCM_RTS;
			ioctl(hPort, TIOCMBIC, &msc);								// Clear RTS signal
			usleep(100);												// WAIT FOR SIGNAL TO BE CLEARD
		}



		if (tcsetattr(hPort,TCSANOW, &options)!=0){						// Set the new options for the port now
			perror("Error: Could not set serial port settings");
			return false;
		}

		usleep(100);													// additional wait for correct functionality
		tcflush(hPort, TCIOFLUSH);										// flush terminal data
	}

	// Save port name
	s_port_name = portname;

	return true;
}

bool	LxSerial::is_port_open()
{
	return hPort >= 0;
}

// speedcontrol */
bool	LxSerial::set_speed( LxSerial::PortSpeed baudrate )
{
	if (b_socket)
		return false;

	cfsetispeed(&options, baudrate);								//set incoming baud rate
	cfsetospeed(&options, baudrate);								//set outgoing baud rate

	if (tcsetattr(hPort,TCSANOW, &options)!=0){						// Set the new options for the port now
		perror("Error: Could not set serial port baudrate");
		return false;
	}
	usleep(100);													// additional wait for correct functionality
	tcflush(hPort, TCIOFLUSH);										// flush terminal data
	return true;
}

bool LxSerial::set_speed_int(const int baudrate)
{
	LxSerial::PortSpeed baud;
	// Baud rate conversion from index to real baud rate :(
	switch (baudrate)
	{
		case 4000000:	baud = S4000000;	break;
		case 3500000:	baud = S3500000;	break;
		case 3000000:	baud = S3000000;	break;
		case 2500000:	baud = S2500000;	break;
		case 2000000:	baud = S2000000;	break;
		case 1500000:	baud = S1500000;	break;
		case 1152000:	baud = S1152000;	break;
		case 1000000:	baud = S1000000;	break;
		case 921600:	baud = S921600;	break;
		case 576000:	baud = S576000;	break;
		case 500000:	baud = S500000;	break;
		case 460800:	baud = S460800;	break;
		case 230400:	baud = S230400;	break;
		case 115200:	baud = S115200;	break;
		case 57600:		baud = S57600;	break;
		case 38400:		baud = S38400;	break;
		case 19200:		baud = S19200;	break;
		case 9600:		baud = S9600;	break;
		case 4800:		baud = S4800;	break;
		case 2400:		baud = S2400;	break;
		case 1800:		baud = S1800;	break;
		case 1200:		baud = S1200;	break;
		case 600:		baud = S600;	break;
		case 300:		baud = S300;	break;
		case 200:		baud = S200;	break;
		case 150:		baud = S150;	break;
		case 134:		baud = S134;	break;
		case 110:		baud = S110;	break;
		case 75:		baud = S75;		break;
		case 50:		baud = S50;		break;
		default:
			printf("This is not a legal portspeed!\n");
			return false;
	}

	set_speed(baud);
	return true;
}

// clear echoed characters from input and detect collisions on write, use for EXAR RS485
void	LxSerial::set_clear_echo(bool clear)
{
	b_clear_echo = clear;
}

// close the serial port
bool	LxSerial::port_close()
{
	if (hPort==INVALID_DEVICE_HANDLE)
		return true;

	if (!b_socket)
	{
		if (tcsetattr(hPort,TCSANOW, &old_options)!=0) {				// restore the old port settings
			perror("Warning: Could not restore serial port settings.");
		}
	}

  	if(close(hPort) == -1) {										//close serial port
  		perror("Error: Could not close serial port.");
  		return false;
  	}
  	hPort = INVALID_DEVICE_HANDLE;
  	return true;
}

int		LxSerial::port_read(unsigned char* buffer, int numBytes) const
{
	int nBytesRead = read(hPort, buffer, numBytes);

	#ifdef __DBG__
	printf("read  ");
	for (int i=0;i<nBytesRead;i++)
		{ printf("%02X ",buffer[i]); }
	printf("(%d)\n",nBytesRead);
	#endif

	return nBytesRead;
}

int 	LxSerial::port_read(unsigned char* buffer, int numBytes, int seconds, int microseconds)
{
	// Init time variables (they are decreased by wait_for_input)
	int s = seconds;
	int us = microseconds;
	int nBytesRead = 0;
	while (nBytesRead < numBytes)
	{
		if( wait_for_input( &s, &us) )
		{
			int partialRead = read(hPort, buffer + nBytesRead, numBytes - nBytesRead); // Read data
			nBytesRead += partialRead;
		}
		else if (nBytesRead < 0)
		{
			#ifdef __DBG__
			printf("Read Timeout... \n");
			#endif
			return READ_ERROR;
		}
		else
			break;
	}

	#ifdef __DBG__
	printf("read  ");
	for (int i=0;i<nBytesRead;i++)
		{ printf("%02X ",buffer[i]); }
	printf("(%d)\n",nBytesRead);
	#endif

	return nBytesRead;
}

bool	LxSerial::wait_for_input(int *seconds, int *microseconds)
{
	fd_set readset;
	timeval timeout;
	timeout.tv_sec = *seconds;										// seconds
	timeout.tv_usec = *microseconds;									// microseconds
	FD_ZERO(&readset);     											// clear file discriptor
	FD_SET(hPort, &readset);										// set filediscripter for port
	int res = select(hPort+1, &readset, NULL, NULL, &timeout); 	// wait till readable data is in the buffer
	*seconds = timeout.tv_sec;
	*microseconds = timeout.tv_usec;
	return res == 1;
}

int		LxSerial::port_write(unsigned char* buffer, int numBytes)
{
	int msc = TIOCM_RTS;
	if (b_rts){														// control the RTS signal if needed
		ioctl(hPort, TIOCMBIS, &msc);								// before you write set RTS signal
		usleep(1000);												// wait until the RTS signal is high
	}

	int numBytesWritten = write(hPort, buffer, numBytes);			// write data

	if (numBytes != numBytesWritten){
		perror("Error while writing to serial port");
		assert(numBytes == numBytesWritten);
	}

	#ifdef __DBG__
	printf("write ");
	for (int i=0;i<numBytes;i++)
		{ printf("%02X ",buffer[i]); }
	printf("(%d)",numBytesWritten);
	printf("\n");
	#endif
	
	tcdrain(hPort);		  											// Wait till all the data in the buffer is transmitted

	if (b_rts){														// control the RTS signal if needed
		ioctl(hPort, TIOCMBIC, &msc);  								// Clear Ready To Send signal
	}

	if (b_clear_echo)
	{												// Read echo from line and detect collisions if neened
		unsigned char* echo_buffer = new unsigned char[numBytes];
		int nBytesRead = 0;
		int s = ECHO_WAIT_TIME_SEC;
		int us = ECHO_WAIT_TIME_USEC;
		while (nBytesRead < numBytesWritten)
		{
			if (wait_for_input(&s , &us))
				nBytesRead = read(hPort, echo_buffer + nBytesRead, numBytes - nBytesRead);		// Read back ECHO of sended data
			else
			{
				#ifdef __DBG__
				printf("echo read back timeout\n");
				#endif
				delete[] echo_buffer;
				return ECHO_TIMEOUT_ERROR;
			}
		}


		#ifdef __DBG__
		printf("echo  ");
		for (int i=0;i<nBytesRead;i++)
			{ printf("%02X ",buffer[i]); }
		printf("(%d)\n",nBytesRead);
		#endif

		if (nBytesRead!=numBytesWritten)
		{
			#ifdef __DBG__
			printf("Warning: nr. of characters echoed not correct\n");
			#endif
			delete[] echo_buffer;
			return READ_ERROR;
		}

		if (memcmp(buffer,echo_buffer, numBytes)!=0)
		{
			#ifdef __DBG__
			printf("collition detect\n");
			#endif
			usleep(COLLISION_WAIT_TIME_USEC);							//wait for a while
			tcflush(hPort, TCIFLUSH); 								//empty all data that was in read buffer but has not been read
			delete[] echo_buffer;
			return COLLISION_DETECT_ERROR;
		}
		delete[] echo_buffer;
	}

	return numBytesWritten;
}

void LxSerial::flush_buffer()
{
	tcflush(hPort, TCIOFLUSH);										// flush data buffer
}

LxSerial::~LxSerial()
{
	// Warn when you forgot to close the port before destruction.
	// We CANNOT call port_close() here, because port_close is a virtual function
	// and virtual functions cannot be called in constructors and destructors.
	if (hPort != INVALID_DEVICE_HANDLE)
		printf("[LxSerial] Warning: you didn't call port_close before calling the destructor.\n");
}