Context Navigation

source: trunk/shared_serial/src/LxSerial.cpp @ 11

Last change on this file since 11 was 8, checked in by wcaarls, 12 years ago
Imported shared_serial at revision 990
File size: 13.8 KB

Rev	Line
[8]	1	//============================================================================
	2	// Name : LxSerial.cpp
	3	// Author : Eelko van Breda,www.dbl.tudelft.nl
	4	// Version : 0.1
	5	// Copyright : Copyright (c) 2008 LGPL
	6	// Description : serial communicatin class linux
	7	//============================================================================
	8
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <unistd.h>
	12	#include <string.h>
	13	#include <sys/types.h>
	14	#include <sys/socket.h>
	15	#include <netinet/in.h>
	16	#include <netdb.h>
	17	#include <poll.h>
	18	#include <endian.h>
	19
	20	#include "shared_serial/LxSerial.h"
	21
	22
	23	/* constructor */
	24	LxSerial::LxSerial()
	25	{
	26	hPort = INVALID_DEVICE_HANDLE;
	27	// b_initialised = false;
	28	b_clear_echo = false;
	29	b_hw_flow_control = false;
	30	b_socket = false;
	31	}
	32
	33	/* return name of the port that was opened */
	34	std::string& LxSerial::get_port_name()
	35	{
	36	return s_port_name;
	37	}
	38
	39	void LxSerial::set_port_type(LxSerial::PortType port_type)
	40	{
	41	switch (port_type)
	42	{
	43	case RS232:
	44	b_rts = false;
	45	break;
	46
	47	case RS485_FTDI:
	48	b_rts = false;
	49	break;
	50
	51	case RS485_EXAR:
	52	b_rts = true;
	53	b_clear_echo = true;
	54	break;
	55
	56	case RS485_SMSC:
	57	b_rts = false;
	58	b_clear_echo = true;
	59	break;
	60
	61	case TCP:
	62	b_socket = true;
	63	b_rts = false;
	64	b_clear_echo = false;
	65	break;
	66
	67	default:
	68	perror("LxSerial: no port type specified");
	69	break;
	70	}
	71	}
	72
	73	/* open port */
	74	bool LxSerial::port_open(const std::string& portname, LxSerial::PortType port_type)
	75	{
	76	// Set port type
	77	set_port_type(port_type);
	78
	79	if (b_socket)
	80	{
	81	int optval = 1;
	82
	83	struct sockaddr_in addr;
	84	struct hostent *server;
	85
	86	hPort = socket(AF_INET, SOCK_STREAM, 0);
	87	setsockopt(hPort, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof optval);
	88
	89	bzero((char *) &addr, sizeof(addr));
	90	addr.sin_family = AF_INET;
	91
	92	std::string host_name = portname.substr(0, portname.find(':'));
	93	std::string port_number = portname.substr(portname.find(':')+1);
	94
	95	server = gethostbyname(host_name.c_str());
	96	if (!server)
	97	{
	98	perror("unknown remote serial host name");
	99	return false;
	100	}
	101
	102	bcopy((char )server->h_addr, (char )&addr.sin_addr.s_addr, server->h_length);
	103	addr.sin_port = htons(atoi(port_number.c_str()));
	104
	105	if (connect(hPort,(struct sockaddr *) &addr,sizeof(addr)) < 0)
	106	{
	107	perror("error connecting to remote serial host");
	108	return false;
	109	}
	110	}
	111	else
	112	{
	113	// Open port
	114	hPort = open(portname.c_str(), O_RDWR \| O_NOCTTY);//\|O_NDELAY); // open the serial device
	115	// O_RDWR = open read an write
	116	// TheÂ O_NOCTTYÂ flagÂ tellsÂ UNIXÂ thatÂ thisÂ programÂ doesn'tÂ wantÂ toÂ beÂ theÂ "controllingÂ terminal"Â forÂ thatÂ
	117	// port.Â IfÂ youÂ don'tÂ specifyÂ thisÂ thenÂ anyÂ inputÂ (suchÂ asÂ keyboardÂ abortÂ signalsÂ andÂ soÂ forth)Â willÂ affectÂ
	118	// yourÂ process.Â ProgramsÂ likeÂ getty(1M/8)Â useÂ thisÂ featureÂ whenÂ startingÂ theÂ loginÂ process,Â butÂ normallyÂ aÂ
	119	// userÂ programÂ doesÂ notÂ wantÂ thisÂ behavior.
	120	// TheÂ O_NDELAYÂ flagÂ tellsÂ UNIXÂ thatÂ thisÂ programÂ doesn'tÂ careÂ whatÂ stateÂ theÂ DCDÂ signalÂ lineÂ isÂ inÂ ÂÂ
	121	// whetherÂ theÂ otherÂ endÂ ofÂ theÂ portÂ isÂ upÂ andÂ running.Â IfÂ youÂ doÂ notÂ specifyÂ thisÂ flag,Â yourÂ processÂ willÂ beÂ
	122	// putÂ toÂ sleepÂ untilÂ theÂ DCDÂ signalÂ lineÂ isÂ theÂ spaceÂ voltage.
	123
	124	if (hPort < 0) { //check if port opened correctly
	125	perror(" Could not open serial port, aborting");
	126	return false;
	127	}
	128
	129
	130	tcgetattr(hPort, &options); // get the current termios (com port options struct) from the kernel
	131	tcgetattr(hPort, &old_options); // get the current termios copy to restore on close
	132
	133	cfsetispeed(&options, B115200); // set incomming baudrate to standard 9600, this can be changed with the function set_speed()
	134	cfsetospeed(&options, B115200); // set outgoing baudrate to standard 9600
	135
	136	// c_cflag Control Options
	137	// \|= (..) means enabled
	138	// &= ~(..) means not enabled
	139	options.c_cflag \|= (CLOCAL\|CREAD\|CS8); // CREAD = enanble receiver
	140	// CLOCAL = Local Line, do not change owner of port
	141	// CS8 = 8 databits
	142	options.c_cflag &= ~(CRTSCTS\|PARENB\|CSTOPB); // Disable HW flow control
	143	// no paritybit, PARENB = paritybit
	144	// 1 stop bit, CSTOPB = 2 stop bits (1 otherwise)
	145	if (b_hw_flow_control){
	146	options.c_cflag \|= (CRTSCTS); // Enable HW flow control
	147	}
	148
	149	// c_lflag Line Options ( controls how input charackters are handeled by the serial driver
	150	options.c_lflag &= ~(ECHO\|ECHONL\|ECHOE\|ICANON\|ISIG\|IEXTEN);
	151	// options.c_lflag &= ~(ECHO\|ECHONL\|ICANON\|ISIG\|IEXTEN);
	152	// ~(..) means not enabled
	153	// ECHO echoing of input characters
	154	// ECHOE echo erease character as BS-SP-BS
	155	// ECHONL mimics echo but doesn't move to next line when it ends
	156	// ICANON cononical input = line oriented input, else RAW
	157	// ISIG ENABLE SIGINTR, SIGSUSP, SIGDSUSP and SIGQUIT signals
	158	// IEXTERN = enable extended functions
	159
	160	// c_iflag Input Options
	161	options.c_iflag &= ~(IGNBRK\|BRKINT\|PARMRK\|ISTRIP\|INLCR\|IGNCR\|ICRNL\|IXON\|IXOFF);
	162	// options.c_iflag &= ~(IGNBRK\|BRKINT\|PARMRK\|ISTRIP\|INLCR\|IGNCR\|ICRNL\|IXON);
	163	// ~(..) means not enabled
	164	// IGNBRK ignore break condition
	165	// BRKINT send a SIGINT when a break condition is detected
	166	// PARMRK Mark parity errors
	167	// ISTRIP strip parity bits
	168	// INLCR map new line to CR
	169	// IGNCR ignore CR
	170	// ICRNL map CR to new line
	171	// IXON Enable software flow control (outgoing)
	172	// IXOFF Enable software flow control (incomming)
	173
	174	// c_oflag output options
	175	options.c_oflag &= ~(OPOST);
	176	// ~(..) means not enabled
	177	// OPOST postprocess output (if not set RAW output)
	178	// when OPOST is disabled all other other option bits of c-Oflag are ignored
	179
	180	// c_cc control character array (control caracter options and timeouts
	181	// Timeout 0.005 sec for first byte, read minimum of 0 bytes
	182	// timeouts are ignored in cononical input or when NDELAY option is set.
	183	options.c_cc[VMIN] = 0; // VMIN Minimum number of characters to read
	184	options.c_cc[VTIME] = WAIT_FOR_DATA_DSEC; // Time to wait for data (tenths of seconds)
	185
	186	// fcntl(hPort, F_SETFL, FNDELAY); // don't wait for input when reading data
	187
	188	if (b_rts){ // if we are using RS_485_EXAR type, we clear the RTS signal
	189	int msc = TIOCM_RTS;
	190	ioctl(hPort, TIOCMBIC, &msc); // Clear RTS signal
	191	usleep(100); // WAIT FOR SIGNAL TO BE CLEARD
	192	}
	193
	194
	195
	196	if (tcsetattr(hPort,TCSANOW, &options)!=0){ // Set the new options for the port now
	197	perror("Error: Could not set serial port settings");
	198	return false;
	199	}
	200
	201	usleep(100); // additional wait for correct functionality
	202	tcflush(hPort, TCIOFLUSH); // flush terminal data
	203	}
	204
	205	// Save port name
	206	s_port_name = portname;
	207
	208	return true;
	209	}
	210
	211	bool LxSerial::is_port_open()
	212	{
	213	return hPort >= 0;
	214	}
	215
	216	// speedcontrol */
	217	bool LxSerial::set_speed( LxSerial::PortSpeed baudrate )
	218	{
	219	if (b_socket)
	220	return false;
	221
	222	cfsetispeed(&options, baudrate); //set incoming baud rate
	223	cfsetospeed(&options, baudrate); //set outgoing baud rate
	224
	225	if (tcsetattr(hPort,TCSANOW, &options)!=0){ // Set the new options for the port now
	226	perror("Error: Could not set serial port baudrate");
	227	return false;
	228	}
	229	usleep(100); // additional wait for correct functionality
	230	tcflush(hPort, TCIOFLUSH); // flush terminal data
	231	return true;
	232	}
	233
	234	bool LxSerial::set_speed_int(const int baudrate)
	235	{
	236	LxSerial::PortSpeed baud;
	237	// Baud rate conversion from index to real baud rate :(
	238	switch (baudrate)
	239	{
	240	case 4000000: baud = S4000000; break;
	241	case 3500000: baud = S3500000; break;
	242	case 3000000: baud = S3000000; break;
	243	case 2500000: baud = S2500000; break;
	244	case 2000000: baud = S2000000; break;
	245	case 1500000: baud = S1500000; break;
	246	case 1152000: baud = S1152000; break;
	247	case 1000000: baud = S1000000; break;
	248	case 921600: baud = S921600; break;
	249	case 576000: baud = S576000; break;
	250	case 500000: baud = S500000; break;
	251	case 460800: baud = S460800; break;
	252	case 230400: baud = S230400; break;
	253	case 115200: baud = S115200; break;
	254	case 57600: baud = S57600; break;
	255	case 38400: baud = S38400; break;
	256	case 19200: baud = S19200; break;
	257	case 9600: baud = S9600; break;
	258	case 4800: baud = S4800; break;
	259	case 2400: baud = S2400; break;
	260	case 1800: baud = S1800; break;
	261	case 1200: baud = S1200; break;
	262	case 600: baud = S600; break;
	263	case 300: baud = S300; break;
	264	case 200: baud = S200; break;
	265	case 150: baud = S150; break;
	266	case 134: baud = S134; break;
	267	case 110: baud = S110; break;
	268	case 75: baud = S75; break;
	269	case 50: baud = S50; break;
	270	default:
	271	printf("This is not a legal portspeed!\n");
	272	return false;
	273	}
	274
	275	set_speed(baud);
	276	return true;
	277	}
	278
	279	// clear echoed characters from input and detect collisions on write, use for EXAR RS485
	280	void LxSerial::set_clear_echo(bool clear)
	281	{
	282	b_clear_echo = clear;
	283	}
	284
	285	// close the serial port
	286	bool LxSerial::port_close()
	287	{
	288	if (hPort==INVALID_DEVICE_HANDLE)
	289	return true;
	290
	291	if (!b_socket)
	292	{
	293	if (tcsetattr(hPort,TCSANOW, &old_options)!=0) { // restore the old port settings
	294	perror("Warning: Could not restore serial port settings.");
	295	}
	296	}
	297
	298	if(close(hPort) == -1) { //close serial port
	299	perror("Error: Could not close serial port.");
	300	return false;
	301	}
	302	hPort = INVALID_DEVICE_HANDLE;
	303	return true;
	304	}
	305
	306	int LxSerial::port_read(unsigned char* buffer, int numBytes) const
	307	{
	308	int nBytesRead = read(hPort, buffer, numBytes);
	309
	310	#ifdef __DBG__
	311	printf("read ");
	312	for (int i=0;i<nBytesRead;i++)
	313	{ printf("%02X ",buffer[i]); }
	314	printf("(%d)\n",nBytesRead);
	315	#endif
	316
	317	return nBytesRead;
	318	}
	319
	320	int LxSerial::port_read(unsigned char* buffer, int numBytes, int seconds, int microseconds)
	321	{
	322	// Init time variables (they are decreased by wait_for_input)
	323	int s = seconds;
	324	int us = microseconds;
	325	int nBytesRead = 0;
	326	while (nBytesRead < numBytes)
	327	{
	328	if( wait_for_input( &s, &us) )
	329	{
	330	int partialRead = read(hPort, buffer + nBytesRead, numBytes - nBytesRead); // Read data
	331	nBytesRead += partialRead;
	332	}
	333	else if (nBytesRead < 0)
	334	{
	335	#ifdef __DBG__
	336	printf("Read Timeout... \n");
	337	#endif
	338	return READ_ERROR;
	339	}
	340	else
	341	break;
	342	}
	343
	344	#ifdef __DBG__
	345	printf("read ");
	346	for (int i=0;i<nBytesRead;i++)
	347	{ printf("%02X ",buffer[i]); }
	348	printf("(%d)\n",nBytesRead);
	349	#endif
	350
	351	return nBytesRead;
	352	}
	353
	354	bool LxSerial::wait_for_input(int seconds, int microseconds)
	355	{
	356	fd_set readset;
	357	timeval timeout;
	358	timeout.tv_sec = *seconds; // seconds
	359	timeout.tv_usec = *microseconds; // microseconds
	360	FD_ZERO(&readset); // clear file discriptor
	361	FD_SET(hPort, &readset); // set filediscripter for port
	362	int res = select(hPort+1, &readset, NULL, NULL, &timeout); // wait till readable data is in the buffer
	363	*seconds = timeout.tv_sec;
	364	*microseconds = timeout.tv_usec;
	365	return res == 1;
	366	}
	367
	368	int LxSerial::port_write(unsigned char* buffer, int numBytes)
	369	{
	370	int msc = TIOCM_RTS;
	371	if (b_rts){ // control the RTS signal if needed
	372	ioctl(hPort, TIOCMBIS, &msc); // before you write set RTS signal
	373	usleep(1000); // wait until the RTS signal is high
	374	}
	375
	376	int numBytesWritten = write(hPort, buffer, numBytes); // write data
	377
	378	if (numBytes != numBytesWritten){
	379	perror("Error while writing to serial port");
	380	assert(numBytes == numBytesWritten);
	381	}
	382
	383	#ifdef __DBG__
	384	printf("write ");
	385	for (int i=0;i<numBytes;i++)
	386	{ printf("%02X ",buffer[i]); }
	387	printf("(%d)",numBytesWritten);
	388	printf("\n");
	389	#endif
	390
	391	tcdrain(hPort); // Wait till all the data in the buffer is transmitted
	392
	393	if (b_rts){ // control the RTS signal if needed
	394	ioctl(hPort, TIOCMBIC, &msc); // Clear Ready To Send signal
	395	}
	396
	397	if (b_clear_echo)
	398	{ // Read echo from line and detect collisions if neened
	399	unsigned char* echo_buffer = new unsigned char[numBytes];
	400	int nBytesRead = 0;
	401	int s = ECHO_WAIT_TIME_SEC;
	402	int us = ECHO_WAIT_TIME_USEC;
	403	while (nBytesRead < numBytesWritten)
	404	{
	405	if (wait_for_input(&s , &us))
	406	nBytesRead = read(hPort, echo_buffer + nBytesRead, numBytes - nBytesRead); // Read back ECHO of sended data
	407	else
	408	{
	409	#ifdef __DBG__
	410	printf("echo read back timeout\n");
	411	#endif
	412	delete[] echo_buffer;
	413	return ECHO_TIMEOUT_ERROR;
	414	}
	415	}
	416
	417
	418	#ifdef __DBG__
	419	printf("echo ");
	420	for (int i=0;i<nBytesRead;i++)
	421	{ printf("%02X ",buffer[i]); }
	422	printf("(%d)\n",nBytesRead);
	423	#endif
	424
	425	if (nBytesRead!=numBytesWritten)
	426	{
	427	#ifdef __DBG__
	428	printf("Warning: nr. of characters echoed not correct\n");
	429	#endif
	430	delete[] echo_buffer;
	431	return READ_ERROR;
	432	}
	433
	434	if (memcmp(buffer,echo_buffer, numBytes)!=0)
	435	{
	436	#ifdef __DBG__
	437	printf("collition detect\n");
	438	#endif
	439	usleep(COLLISION_WAIT_TIME_USEC); //wait for a while
	440	tcflush(hPort, TCIFLUSH); //empty all data that was in read buffer but has not been read
	441	delete[] echo_buffer;
	442	return COLLISION_DETECT_ERROR;
	443	}
	444	delete[] echo_buffer;
	445	}
	446
	447	return numBytesWritten;
	448	}
	449
	450	void LxSerial::flush_buffer()
	451	{
	452	tcflush(hPort, TCIOFLUSH); // flush data buffer
	453	}
	454
	455	LxSerial::~LxSerial()
	456	{
	457	// Warn when you forgot to close the port before destruction.
	458	// We CANNOT call port_close() here, because port_close is a virtual function
	459	// and virtual functions cannot be called in constructors and destructors.
	460	if (hPort != INVALID_DEVICE_HANDLE)
	461	printf("[LxSerial] Warning: you didn't call port_close before calling the destructor.\n");
	462	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: