WebSVN - Projects - Blame - Rev 440 - /QMK-Groundstation/branches/libMK/SerialPort/posix

Rev	Author	Line No.	Line
158	KeyOz	1
		2	/*!
		3	\class Posix_QextSerialPort
		4	\version 1.0.0
		5	\author Stefan Sander
		6
		7	A cross-platform serial port class.
		8	This class encapsulates the POSIX portion of QextSerialPort. The user will be notified of errors
		9	and possible portability conflicts at run-time by default - this behavior can be turned off by
		10	defining _TTY_NOWARN_ (to turn off all warnings) or _TTY_NOWARN_PORT_ (to turn off portability
		11	warnings) in the project. Note that _TTY_NOWARN_ will also turn off portability warnings.
		12	*/
		13
		14	#include <stdio.h>
		15	#include "posix_qextserialport.h"
		16
		17	/*!
		18	\fn Posix_QextSerialPort::Posix_QextSerialPort()
		19	Default constructor. Note that the name of the device used by a QextSerialPort constructed with
		20	this constructor will be determined by #defined constants, or lack thereof - the default behavior
		21	is the same as _TTY_LINUX_. Possible naming conventions and their associated constants are:
		22
		23	\verbatim
		24
		25	Constant Used By Naming Convention
		26	---------- ------------- ------------------------
		27	_TTY_WIN_ Windows COM1, COM2
		28	_TTY_IRIX_ SGI/IRIX /dev/ttyf1, /dev/ttyf2
		29	_TTY_HPUX_ HP-UX /dev/tty1p0, /dev/tty2p0
		30	_TTY_SUN_ SunOS/Solaris /dev/ttya, /dev/ttyb
		31	_TTY_DIGITAL_ Digital UNIX /dev/tty01, /dev/tty02
		32	_TTY_FREEBSD_ FreeBSD /dev/ttyd0, /dev/ttyd1
		33	_TTY_LINUX_ Linux /dev/ttyS0, /dev/ttyS1
		34	<none> Linux /dev/ttyS0, /dev/ttyS1
		35	\endverbatim
		36
		37	This constructor assigns the device name to the name of the first port on the specified system.
		38	See the other constructors if you need to open a different port.
		39	*/
		40	Posix_QextSerialPort::Posix_QextSerialPort()
		41	: QextSerialBase()
		42	{
		43	Posix_File=new QFile();
		44	}
		45
		46	/*!
		47	\fn Posix_QextSerialPort::Posix_QextSerialPort(const Posix_QextSerialPort&)
		48	Copy constructor.
		49	*/
		50	Posix_QextSerialPort::Posix_QextSerialPort(const Posix_QextSerialPort& s)
		51	: QextSerialBase(s.port)
		52	{
		53	setOpenMode(s.openMode());
		54	port = s.port;
		55	Settings.BaudRate=s.Settings.BaudRate;
		56	Settings.DataBits=s.Settings.DataBits;
		57	Settings.Parity=s.Settings.Parity;
		58	Settings.StopBits=s.Settings.StopBits;
		59	Settings.FlowControl=s.Settings.FlowControl;
		60	lastErr=s.lastErr;
		61
		62	Posix_File=new QFile();
		63	Posix_File=s.Posix_File;
		64	memcpy(&Posix_Timeout, &s.Posix_Timeout, sizeof(struct timeval));
		65	memcpy(&Posix_Copy_Timeout, &s.Posix_Copy_Timeout, sizeof(struct timeval));
		66	memcpy(&Posix_CommConfig, &s.Posix_CommConfig, sizeof(struct termios));
		67	}
		68
		69	/*!
		70	\fn Posix_QextSerialPort::Posix_QextSerialPort(const QString & name)
		71	Constructs a serial port attached to the port specified by name.
		72	name is the name of the device, which is windowsystem-specific,
		73	e.g."COM1" or "/dev/ttyS0".
		74	*/
		75	Posix_QextSerialPort::Posix_QextSerialPort(const QString & name)
		76	: QextSerialBase(name)
		77	{
		78	Posix_File=new QFile();
		79	}
		80
		81	/*!
		82	\fn Posix_QextSerialPort::Posix_QextSerialPort(const PortSettings& settings)
		83	Constructs a port with default name and specified settings.
		84	*/
		85	Posix_QextSerialPort::Posix_QextSerialPort(const PortSettings& settings)
		86	: QextSerialBase()
		87	{
		88	setBaudRate(settings.BaudRate);
		89	setDataBits(settings.DataBits);
		90	setParity(settings.Parity);
		91	setStopBits(settings.StopBits);
		92	setFlowControl(settings.FlowControl);
		93
		94	Posix_File=new QFile();
		95	setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
		96	}
		97
		98	/*!
		99	\fn Posix_QextSerialPort::Posix_QextSerialPort(const QString & name, const PortSettings& settings)
		100	Constructs a port with specified name and settings.
		101	*/
		102	Posix_QextSerialPort::Posix_QextSerialPort(const QString & name, const PortSettings& settings)
		103	: QextSerialBase(name)
		104	{
		105	setBaudRate(settings.BaudRate);
		106	setDataBits(settings.DataBits);
		107	setParity(settings.Parity);
		108	setStopBits(settings.StopBits);
		109	setFlowControl(settings.FlowControl);
		110
		111	Posix_File=new QFile();
		112	setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
		113	}
		114
		115	/*!
		116	\fn Posix_QextSerialPort& Posix_QextSerialPort::operator=(const Posix_QextSerialPort& s)
		117	Override the = operator.
		118	*/
		119	Posix_QextSerialPort& Posix_QextSerialPort::operator=(const Posix_QextSerialPort& s)
		120	{
		121	setOpenMode(s.openMode());
		122	port = s.port;
		123	Settings.BaudRate=s.Settings.BaudRate;
		124	Settings.DataBits=s.Settings.DataBits;
		125	Settings.Parity=s.Settings.Parity;
		126	Settings.StopBits=s.Settings.StopBits;
		127	Settings.FlowControl=s.Settings.FlowControl;
		128	lastErr=s.lastErr;
		129
		130	Posix_File=s.Posix_File;
		131	memcpy(&Posix_Timeout, &(s.Posix_Timeout), sizeof(struct timeval));
		132	memcpy(&Posix_Copy_Timeout, &(s.Posix_Copy_Timeout), sizeof(struct timeval));
		133	memcpy(&Posix_CommConfig, &(s.Posix_CommConfig), sizeof(struct termios));
		134	return *this;
		135	}
		136
		137	/*!
		138	\fn Posix_QextSerialPort::~Posix_QextSerialPort()
		139	Standard destructor.
		140	*/
		141	Posix_QextSerialPort::~Posix_QextSerialPort()
		142	{
		143	if (isOpen()) {
		144	close();
		145	}
		146	Posix_File->close();
		147	delete Posix_File;
		148	}
		149
		150	/*!
		151	\fn void Posix_QextSerialPort::setBaudRate(BaudRateType baudRate)
		152	Sets the baud rate of the serial port. Note that not all rates are applicable on
		153	all platforms. The following table shows translations of the various baud rate
		154	constants on Windows(including NT/2000) and POSIX platforms. Speeds marked with an *
		155	are speeds that are usable on both Windows and POSIX.
		156
		157	\note
		158	BAUD76800 may not be supported on all POSIX systems. SGI/IRIX systems do not support
		159	BAUD1800.
		160
		161	\verbatim
		162
		163	RATE Windows Speed POSIX Speed
		164	----------- ------------- -----------
		165	BAUD50 110 50
		166	BAUD75 110 75
		167	*BAUD110 110 110
		168	BAUD134 110 134.5
		169	BAUD150 110 150
		170	BAUD200 110 200
		171	*BAUD300 300 300
		172	*BAUD600 600 600
		173	*BAUD1200 1200 1200
		174	BAUD1800 1200 1800
		175	*BAUD2400 2400 2400
		176	*BAUD4800 4800 4800
		177	*BAUD9600 9600 9600
		178	BAUD14400 14400 9600
		179	*BAUD19200 19200 19200
		180	*BAUD38400 38400 38400
		181	BAUD56000 56000 38400
		182	*BAUD57600 57600 57600
		183	BAUD76800 57600 76800
		184	*BAUD115200 115200 115200
		185	BAUD128000 128000 115200
		186	BAUD256000 256000 115200
		187	\endverbatim
		188	*/
		189	void Posix_QextSerialPort::setBaudRate(BaudRateType baudRate)
		190	{
		191	LOCK_MUTEX();
		192	if (Settings.BaudRate!=baudRate) {
		193	switch (baudRate) {
		194	case BAUD14400:
		195	Settings.BaudRate=BAUD9600;
		196	break;
		197
		198	case BAUD56000:
		199	Settings.BaudRate=BAUD38400;
		200	break;
		201
		202	case BAUD76800:
		203
		204	#ifndef B76800
		205	Settings.BaudRate=BAUD57600;
		206	#else
		207	Settings.BaudRate=baudRate;
		208	#endif
		209	break;
		210
		211	case BAUD128000:
		212	case BAUD256000:
		213	Settings.BaudRate=BAUD115200;
		214	break;
		215
		216	default:
		217	Settings.BaudRate=baudRate;
		218	break;
		219	}
		220	}
		221	if (isOpen()) {
		222	switch (baudRate) {
		223
		224	/50 baud/
		225	case BAUD50:
		226	TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 50 baud operation.");
		227	#ifdef CBAUD
		228	Posix_CommConfig.c_cflag&=(~CBAUD);
		229	Posix_CommConfig.c_cflag\|=B50;
		230	#else
		231	cfsetispeed(&Posix_CommConfig, B50);
		232	cfsetospeed(&Posix_CommConfig, B50);
		233	#endif
		234	break;
		235
		236	/75 baud/
		237	case BAUD75:
		238	TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 75 baud operation.");
		239	#ifdef CBAUD
		240	Posix_CommConfig.c_cflag&=(~CBAUD);
		241	Posix_CommConfig.c_cflag\|=B75;
		242	#else
		243	cfsetispeed(&Posix_CommConfig, B75);
		244	cfsetospeed(&Posix_CommConfig, B75);
		245	#endif
		246	break;
		247
		248	/110 baud/
		249	case BAUD110:
		250	#ifdef CBAUD
		251	Posix_CommConfig.c_cflag&=(~CBAUD);
		252	Posix_CommConfig.c_cflag\|=B110;
		253	#else
		254	cfsetispeed(&Posix_CommConfig, B110);
		255	cfsetospeed(&Posix_CommConfig, B110);
		256	#endif
		257	break;
		258
		259	/134.5 baud/
		260	case BAUD134:
		261	TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 134.5 baud operation.");
		262	#ifdef CBAUD
		263	Posix_CommConfig.c_cflag&=(~CBAUD);
		264	Posix_CommConfig.c_cflag\|=B134;
		265	#else
		266	cfsetispeed(&Posix_CommConfig, B134);
		267	cfsetospeed(&Posix_CommConfig, B134);
		268	#endif
		269	break;
		270
		271	/150 baud/
		272	case BAUD150:
		273	TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 150 baud operation.");
		274	#ifdef CBAUD
		275	Posix_CommConfig.c_cflag&=(~CBAUD);
		276	Posix_CommConfig.c_cflag\|=B150;
		277	#else
		278	cfsetispeed(&Posix_CommConfig, B150);
		279	cfsetospeed(&Posix_CommConfig, B150);
		280	#endif
		281	break;
		282
		283	/200 baud/
		284	case BAUD200:
		285	TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 200 baud operation.");
		286	#ifdef CBAUD
		287	Posix_CommConfig.c_cflag&=(~CBAUD);
		288	Posix_CommConfig.c_cflag\|=B200;
		289	#else
		290	cfsetispeed(&Posix_CommConfig, B200);
		291	cfsetospeed(&Posix_CommConfig, B200);
		292	#endif
		293	break;
		294
		295	/300 baud/
		296	case BAUD300:
		297	#ifdef CBAUD
		298	Posix_CommConfig.c_cflag&=(~CBAUD);
		299	Posix_CommConfig.c_cflag\|=B300;
		300	#else
		301	cfsetispeed(&Posix_CommConfig, B300);
		302	cfsetospeed(&Posix_CommConfig, B300);
		303	#endif
		304	break;
		305
		306	/600 baud/
		307	case BAUD600:
		308	#ifdef CBAUD
		309	Posix_CommConfig.c_cflag&=(~CBAUD);
		310	Posix_CommConfig.c_cflag\|=B600;
		311	#else
		312	cfsetispeed(&Posix_CommConfig, B600);
		313	cfsetospeed(&Posix_CommConfig, B600);
		314	#endif
		315	break;
		316
		317	/1200 baud/
		318	case BAUD1200:
		319	#ifdef CBAUD
		320	Posix_CommConfig.c_cflag&=(~CBAUD);
		321	Posix_CommConfig.c_cflag\|=B1200;
		322	#else
		323	cfsetispeed(&Posix_CommConfig, B1200);
		324	cfsetospeed(&Posix_CommConfig, B1200);
		325	#endif
		326	break;
		327
		328	/1800 baud/
		329	case BAUD1800:
		330	TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows and IRIX do not support 1800 baud operation.");
		331	#ifdef CBAUD
		332	Posix_CommConfig.c_cflag&=(~CBAUD);
		333	Posix_CommConfig.c_cflag\|=B1800;
		334	#else
		335	cfsetispeed(&Posix_CommConfig, B1800);
		336	cfsetospeed(&Posix_CommConfig, B1800);
		337	#endif
		338	break;
		339
		340	/2400 baud/
		341	case BAUD2400:
		342	#ifdef CBAUD
		343	Posix_CommConfig.c_cflag&=(~CBAUD);
		344	Posix_CommConfig.c_cflag\|=B2400;
		345	#else
		346	cfsetispeed(&Posix_CommConfig, B2400);
		347	cfsetospeed(&Posix_CommConfig, B2400);
		348	#endif
		349	break;
		350
		351	/4800 baud/
		352	case BAUD4800:
		353	#ifdef CBAUD
		354	Posix_CommConfig.c_cflag&=(~CBAUD);
		355	Posix_CommConfig.c_cflag\|=B4800;
		356	#else
		357	cfsetispeed(&Posix_CommConfig, B4800);
		358	cfsetospeed(&Posix_CommConfig, B4800);
		359	#endif
		360	break;
		361
		362	/9600 baud/
		363	case BAUD9600:
		364	#ifdef CBAUD
		365	Posix_CommConfig.c_cflag&=(~CBAUD);
		366	Posix_CommConfig.c_cflag\|=B9600;
		367	#else
		368	cfsetispeed(&Posix_CommConfig, B9600);
		369	cfsetospeed(&Posix_CommConfig, B9600);
		370	#endif
		371	break;
		372
		373	/14400 baud/
		374	case BAUD14400:
		375	TTY_WARNING("Posix_QextSerialPort: POSIX does not support 14400 baud operation. Switching to 9600 baud.");
		376	#ifdef CBAUD
		377	Posix_CommConfig.c_cflag&=(~CBAUD);
		378	Posix_CommConfig.c_cflag\|=B9600;
		379	#else
		380	cfsetispeed(&Posix_CommConfig, B9600);
		381	cfsetospeed(&Posix_CommConfig, B9600);
		382	#endif
		383	break;
		384
		385	/19200 baud/
		386	case BAUD19200:
		387	#ifdef CBAUD
		388	Posix_CommConfig.c_cflag&=(~CBAUD);
		389	Posix_CommConfig.c_cflag\|=B19200;
		390	#else
		391	cfsetispeed(&Posix_CommConfig, B19200);
		392	cfsetospeed(&Posix_CommConfig, B19200);
		393	#endif
		394	break;
		395
		396	/38400 baud/
		397	case BAUD38400:
		398	#ifdef CBAUD
		399	Posix_CommConfig.c_cflag&=(~CBAUD);
		400	Posix_CommConfig.c_cflag\|=B38400;
		401	#else
		402	cfsetispeed(&Posix_CommConfig, B38400);
		403	cfsetospeed(&Posix_CommConfig, B38400);
		404	#endif
		405	break;
		406
		407	/56000 baud/
		408	case BAUD56000:
		409	TTY_WARNING("Posix_QextSerialPort: POSIX does not support 56000 baud operation. Switching to 38400 baud.");
		410	#ifdef CBAUD
		411	Posix_CommConfig.c_cflag&=(~CBAUD);
		412	Posix_CommConfig.c_cflag\|=B38400;
		413	#else
		414	cfsetispeed(&Posix_CommConfig, B38400);
		415	cfsetospeed(&Posix_CommConfig, B38400);
		416	#endif
		417	break;
		418
		419	/57600 baud/
		420	case BAUD57600:
		421	#ifdef CBAUD
		422	Posix_CommConfig.c_cflag&=(~CBAUD);
		423	Posix_CommConfig.c_cflag\|=B57600;
		424	#else
		425	cfsetispeed(&Posix_CommConfig, B57600);
		426	cfsetospeed(&Posix_CommConfig, B57600);
		427	#endif
		428	break;
		429
		430	/76800 baud/
		431	case BAUD76800:
		432	TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows and some POSIX systems do not support 76800 baud operation.");
		433	#ifdef CBAUD
		434	Posix_CommConfig.c_cflag&=(~CBAUD);
		435
		436	#ifdef B76800
		437	Posix_CommConfig.c_cflag\|=B76800;
		438	#else
		439	TTY_WARNING("Posix_QextSerialPort: Posix_QextSerialPort was compiled without 76800 baud support. Switching to 57600 baud.");
		440	Posix_CommConfig.c_cflag\|=B57600;
		441	#endif //B76800
		442	#else //CBAUD
		443	#ifdef B76800
		444	cfsetispeed(&Posix_CommConfig, B76800);
		445	cfsetospeed(&Posix_CommConfig, B76800);
		446	#else
		447	TTY_WARNING("Posix_QextSerialPort: Posix_QextSerialPort was compiled without 76800 baud support. Switching to 57600 baud.");
		448	cfsetispeed(&Posix_CommConfig, B57600);
		449	cfsetospeed(&Posix_CommConfig, B57600);
		450	#endif //B76800
		451	#endif //CBAUD
		452	break;
		453
		454	/115200 baud/
		455	case BAUD115200:
		456	#ifdef CBAUD
		457	Posix_CommConfig.c_cflag&=(~CBAUD);
		458	Posix_CommConfig.c_cflag\|=B115200;
		459	#else
		460	cfsetispeed(&Posix_CommConfig, B115200);
		461	cfsetospeed(&Posix_CommConfig, B115200);
		462	#endif
		463	break;
		464
		465	/128000 baud/
		466	case BAUD128000:
		467	TTY_WARNING("Posix_QextSerialPort: POSIX does not support 128000 baud operation. Switching to 115200 baud.");
		468	#ifdef CBAUD
		469	Posix_CommConfig.c_cflag&=(~CBAUD);
		470	Posix_CommConfig.c_cflag\|=B115200;
		471	#else
		472	cfsetispeed(&Posix_CommConfig, B115200);
		473	cfsetospeed(&Posix_CommConfig, B115200);
		474	#endif
		475	break;
		476
		477	/256000 baud/
		478	case BAUD256000:
		479	TTY_WARNING("Posix_QextSerialPort: POSIX does not support 256000 baud operation. Switching to 115200 baud.");
		480	#ifdef CBAUD
		481	Posix_CommConfig.c_cflag&=(~CBAUD);
		482	Posix_CommConfig.c_cflag\|=B115200;
		483	#else
		484	cfsetispeed(&Posix_CommConfig, B115200);
		485	cfsetospeed(&Posix_CommConfig, B115200);
		486	#endif
		487	break;
		488	}
		489	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		490	}
		491	UNLOCK_MUTEX();
		492	}
		493
		494	/*!
		495	\fn void Posix_QextSerialPort::setDataBits(DataBitsType dataBits)
		496	Sets the number of data bits used by the serial port. Possible values of dataBits are:
		497	\verbatim
		498	DATA_5 5 data bits
		499	DATA_6 6 data bits
		500	DATA_7 7 data bits
		501	DATA_8 8 data bits
		502	\endverbatim
		503
		504	\note
		505	This function is subject to the following restrictions:
		506	\par
		507	5 data bits cannot be used with 2 stop bits.
		508	\par
		509	8 data bits cannot be used with space parity on POSIX systems.
		510
		511	*/
		512	void Posix_QextSerialPort::setDataBits(DataBitsType dataBits)
		513	{
		514	LOCK_MUTEX();
		515	if (Settings.DataBits!=dataBits) {
		516	if ((Settings.StopBits==STOP_2 && dataBits==DATA_5) \|\|
		517	(Settings.StopBits==STOP_1_5 && dataBits!=DATA_5) \|\|
		518	(Settings.Parity==PAR_SPACE && dataBits==DATA_8)) {
		519	}
		520	else {
		521	Settings.DataBits=dataBits;
		522	}
		523	}
		524	if (isOpen()) {
		525	switch(dataBits) {
		526
		527	/5 data bits/
		528	case DATA_5:
		529	if (Settings.StopBits==STOP_2) {
		530	TTY_WARNING("Posix_QextSerialPort: 5 Data bits cannot be used with 2 stop bits.");
		531	}
		532	else {
		533	Settings.DataBits=dataBits;
		534	Posix_CommConfig.c_cflag&=(~CSIZE);
		535	Posix_CommConfig.c_cflag\|=CS5;
		536	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		537	}
		538	break;
		539
		540	/6 data bits/
		541	case DATA_6:
		542	if (Settings.StopBits==STOP_1_5) {
		543	TTY_WARNING("Posix_QextSerialPort: 6 Data bits cannot be used with 1.5 stop bits.");
		544	}
		545	else {
		546	Settings.DataBits=dataBits;
		547	Posix_CommConfig.c_cflag&=(~CSIZE);
		548	Posix_CommConfig.c_cflag\|=CS6;
		549	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		550	}
		551	break;
		552
		553	/7 data bits/
		554	case DATA_7:
		555	if (Settings.StopBits==STOP_1_5) {
		556	TTY_WARNING("Posix_QextSerialPort: 7 Data bits cannot be used with 1.5 stop bits.");
		557	}
		558	else {
		559	Settings.DataBits=dataBits;
		560	Posix_CommConfig.c_cflag&=(~CSIZE);
		561	Posix_CommConfig.c_cflag\|=CS7;
		562	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		563	}
		564	break;
		565
		566	/8 data bits/
		567	case DATA_8:
		568	if (Settings.StopBits==STOP_1_5) {
		569	TTY_WARNING("Posix_QextSerialPort: 8 Data bits cannot be used with 1.5 stop bits.");
		570	}
		571	else {
		572	Settings.DataBits=dataBits;
		573	Posix_CommConfig.c_cflag&=(~CSIZE);
		574	Posix_CommConfig.c_cflag\|=CS8;
		575	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		576	}
		577	break;
		578	}
		579	}
		580	UNLOCK_MUTEX();
		581	}
		582
		583	/*!
		584	\fn void Posix_QextSerialPort::setParity(ParityType parity)
		585	Sets the parity associated with the serial port. The possible values of parity are:
		586	\verbatim
		587	PAR_SPACE Space Parity
		588	PAR_MARK Mark Parity
		589	PAR_NONE No Parity
		590	PAR_EVEN Even Parity
		591	PAR_ODD Odd Parity
		592	\endverbatim
		593
		594	\note
		595	This function is subject to the following limitations:
		596	\par
		597	POSIX systems do not support mark parity.
		598	\par
		599	POSIX systems support space parity only if tricked into doing so, and only with
		600	fewer than 8 data bits. Use space parity very carefully with POSIX systems.
		601
		602	*/
		603	void Posix_QextSerialPort::setParity(ParityType parity)
		604	{
		605	LOCK_MUTEX();
		606	if (Settings.Parity!=parity) {
		607	if (parity==PAR_MARK \|\| (parity==PAR_SPACE && Settings.DataBits==DATA_8)) {
		608	}
		609	else {
		610	Settings.Parity=parity;
		611	}
		612	}
		613	if (isOpen()) {
		614	switch (parity) {
		615
		616	/space parity/
		617	case PAR_SPACE:
		618	if (Settings.DataBits==DATA_8) {
		619	TTY_PORTABILITY_WARNING("Posix_QextSerialPort: Space parity is only supported in POSIX with 7 or fewer data bits");
		620	}
		621	else {
		622
		623	/space parity not directly supported - add an extra data bit to simulate it/
		624	Posix_CommConfig.c_cflag&=~(PARENB\|CSIZE);
		625	switch(Settings.DataBits) {
		626	case DATA_5:
		627	Settings.DataBits=DATA_6;
		628	Posix_CommConfig.c_cflag\|=CS6;
		629	break;
		630
		631	case DATA_6:
		632	Settings.DataBits=DATA_7;
		633	Posix_CommConfig.c_cflag\|=CS7;
		634	break;
		635
		636	case DATA_7:
		637	Settings.DataBits=DATA_8;
		638	Posix_CommConfig.c_cflag\|=CS8;
		639	break;
		640
		641	case DATA_8:
		642	break;
		643	}
		644	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		645	}
		646	break;
		647
		648	/mark parity - WINDOWS ONLY/
		649	case PAR_MARK:
		650	TTY_WARNING("Posix_QextSerialPort: Mark parity is not supported by POSIX.");
		651	break;
		652
		653	/no parity/
		654	case PAR_NONE:
		655	Posix_CommConfig.c_cflag&=(~PARENB);
		656	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		657	break;
		658
		659	/even parity/
		660	case PAR_EVEN:
		661	Posix_CommConfig.c_cflag&=(~PARODD);
		662	Posix_CommConfig.c_cflag\|=PARENB;
		663	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		664	break;
		665
		666	/odd parity/
		667	case PAR_ODD:
		668	Posix_CommConfig.c_cflag\|=(PARENB\|PARODD);
		669	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		670	break;
		671	}
		672	}
		673	UNLOCK_MUTEX();
		674	}
		675
		676	/*!
		677	\fn void Posix_QextSerialPort::setStopBits(StopBitsType stopBits)
		678	Sets the number of stop bits used by the serial port. Possible values of stopBits are:
		679	\verbatim
		680	STOP_1 1 stop bit
		681	STOP_1_5 1.5 stop bits
		682	STOP_2 2 stop bits
		683	\endverbatim
		684	\note
		685	This function is subject to the following restrictions:
		686	\par
		687	2 stop bits cannot be used with 5 data bits.
		688	\par
		689	POSIX does not support 1.5 stop bits.
		690
		691	*/
		692	void Posix_QextSerialPort::setStopBits(StopBitsType stopBits)
		693	{
		694	LOCK_MUTEX();
		695	if (Settings.StopBits!=stopBits) {
		696	if ((Settings.DataBits==DATA_5 && stopBits==STOP_2) \|\| stopBits==STOP_1_5) {}
		697	else {
		698	Settings.StopBits=stopBits;
		699	}
		700	}
		701	if (isOpen()) {
		702	switch (stopBits) {
		703
		704	/one stop bit/
		705	case STOP_1:
		706	Settings.StopBits=stopBits;
		707	Posix_CommConfig.c_cflag&=(~CSTOPB);
		708	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		709	break;
		710
		711	/1.5 stop bits/
		712	case STOP_1_5:
		713	TTY_WARNING("Posix_QextSerialPort: 1.5 stop bit operation is not supported by POSIX.");
		714	break;
		715
		716	/two stop bits/
		717	case STOP_2:
		718	if (Settings.DataBits==DATA_5) {
		719	TTY_WARNING("Posix_QextSerialPort: 2 stop bits cannot be used with 5 data bits");
		720	}
		721	else {
		722	Settings.StopBits=stopBits;
		723	Posix_CommConfig.c_cflag\|=CSTOPB;
		724	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		725	}
		726	break;
		727	}
		728	}
		729	UNLOCK_MUTEX();
		730	}
		731
		732	/*!
		733	\fn void Posix_QextSerialPort::setFlowControl(FlowType flow)
		734	Sets the flow control used by the port. Possible values of flow are:
		735	\verbatim
		736	FLOW_OFF No flow control
		737	FLOW_HARDWARE Hardware (RTS/CTS) flow control
		738	FLOW_XONXOFF Software (XON/XOFF) flow control
		739	\endverbatim
		740	\note
		741	FLOW_HARDWARE may not be supported on all versions of UNIX. In cases where it is
		742	unsupported, FLOW_HARDWARE is the same as FLOW_OFF.
		743
		744	*/
		745	void Posix_QextSerialPort::setFlowControl(FlowType flow)
		746	{
		747	LOCK_MUTEX();
		748	if (Settings.FlowControl!=flow) {
		749	Settings.FlowControl=flow;
		750	}
		751	if (isOpen()) {
		752	switch(flow) {
		753
		754	/no flow control/
		755	case FLOW_OFF:
		756	Posix_CommConfig.c_cflag&=(~CRTSCTS);
		757	Posix_CommConfig.c_iflag&=(~(IXON\|IXOFF\|IXANY));
		758	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		759	break;
		760
		761	/software (XON/XOFF) flow control/
		762	case FLOW_XONXOFF:
		763	Posix_CommConfig.c_cflag&=(~CRTSCTS);
		764	Posix_CommConfig.c_iflag\|=(IXON\|IXOFF\|IXANY);
		765	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		766	break;
		767
		768	case FLOW_HARDWARE:
		769	Posix_CommConfig.c_cflag\|=CRTSCTS;
		770	Posix_CommConfig.c_iflag&=(~(IXON\|IXOFF\|IXANY));
		771	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		772	break;
		773	}
		774	}
		775	UNLOCK_MUTEX();
		776	}
		777
		778	/*!
		779	\fn void Posix_QextSerialPort::setTimeout(ulong sec, ulong millisec);
		780	Sets the read and write timeouts for the port to sec seconds and millisec milliseconds.
		781	Note that this is a per-character timeout, i.e. the port will wait this long for each
		782	individual character, not for the whole read operation. This timeout also applies to the
		783	bytesWaiting() function.
		784
		785	\note
		786	POSIX does not support millisecond-level control for I/O timeout values. Any
		787	timeout set using this function will be set to the next lowest tenth of a second for
		788	the purposes of detecting read or write timeouts. For example a timeout of 550 milliseconds
		789	will be seen by the class as a timeout of 500 milliseconds for the purposes of reading and
		790	writing the port. However millisecond-level control is allowed by the select() system call,
		791	so for example a 550-millisecond timeout will be seen as 550 milliseconds on POSIX systems for
		792	the purpose of detecting available bytes in the read buffer.
		793
		794	*/
		795	void Posix_QextSerialPort::setTimeout(ulong sec, ulong millisec)
		796	{
		797	LOCK_MUTEX();
		798	Settings.Timeout_Sec=sec;
		799	Settings.Timeout_Millisec=millisec;
		800	Posix_Copy_Timeout.tv_sec=sec;
		801	Posix_Copy_Timeout.tv_usec=millisec;
		802	if (isOpen()) {
		803	tcgetattr(Posix_File->handle(), &Posix_CommConfig);
		804	Posix_CommConfig.c_cc[VTIME]=sec*10+millisec/100;
		805	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		806	}
		807	UNLOCK_MUTEX();
		808	}
		809
		810	/*!
		811	\fn bool Posix_QextSerialPort::open(OpenMode mode)
		812	Opens the serial port associated to this class.
		813	This function has no effect if the port associated with the class is already open.
		814	The port is also configured to the current settings, as stored in the Settings structure.
		815	*/
		816	bool Posix_QextSerialPort::open(OpenMode mode)
		817	{
		818	LOCK_MUTEX();
		819	if (mode == QIODevice::NotOpen)
		820	return isOpen();
		821	if (!isOpen()) {
		822	/open the port/
		823	Posix_File->setFileName(port);
		824	if (Posix_File->open(QIODevice::ReadWrite\|QIODevice::Unbuffered)) {
		825	/set open mode/
		826	QIODevice::open(mode);
		827
		828	/configure port settings/
		829	tcgetattr(Posix_File->handle(), &Posix_CommConfig);
		830
		831	/set up other port settings/
		832	Posix_CommConfig.c_cflag\|=CREAD\|CLOCAL;
		833	Posix_CommConfig.c_lflag&=(~(ICANON\|ECHO\|ECHOE\|ECHOK\|ECHONL\|ISIG));
		834	Posix_CommConfig.c_iflag&=(~(INPCK\|IGNPAR\|PARMRK\|ISTRIP\|ICRNL\|IXANY));
		835	Posix_CommConfig.c_oflag&=(~OPOST);
		836	Posix_CommConfig.c_cc[VMIN]=0;
		837	Posix_CommConfig.c_cc[VINTR] = _POSIX_VDISABLE;
		838	Posix_CommConfig.c_cc[VQUIT] = _POSIX_VDISABLE;
		839	Posix_CommConfig.c_cc[VSTART] = _POSIX_VDISABLE;
		840	Posix_CommConfig.c_cc[VSTOP] = _POSIX_VDISABLE;
		841	Posix_CommConfig.c_cc[VSUSP] = _POSIX_VDISABLE;
		842	setBaudRate(Settings.BaudRate);
		843	setDataBits(Settings.DataBits);
		844	setParity(Settings.Parity);
		845	setStopBits(Settings.StopBits);
		846	setFlowControl(Settings.FlowControl);
		847	setTimeout(Settings.Timeout_Sec, Settings.Timeout_Millisec);
		848	tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
		849	} else {
		850	}
		851	}
		852	UNLOCK_MUTEX();
		853	return isOpen();
		854	}
		855
		856	/*!
		857	\fn void Posix_QextSerialPort::close()
		858	Closes a serial port. This function has no effect if the serial port associated with the class
		859	is not currently open.
		860	*/
		861	void Posix_QextSerialPort::close()
		862	{
		863	LOCK_MUTEX();
		864	Posix_File->close();
		865	QIODevice::close();
		866	UNLOCK_MUTEX();
		867	}
		868
		869	/*!
		870	\fn void Posix_QextSerialPort::flush()
		871	Flushes all pending I/O to the serial port. This function has no effect if the serial port
		872	associated with the class is not currently open.
		873	*/
		874	void Posix_QextSerialPort::flush()
		875	{
		876	LOCK_MUTEX();
		877	if (isOpen()) {
		878	Posix_File->flush();
		879	}
		880	UNLOCK_MUTEX();
		881	}
		882
		883	/*!
		884	\fn qint64 Posix_QextSerialPort::size() const
		885	This function will return the number of bytes waiting in the receive queue of the serial port.
		886	It is included primarily to provide a complete QIODevice interface, and will not record errors
		887	in the lastErr member (because it is const). This function is also not thread-safe - in
		888	multithreading situations, use Posix_QextSerialPort::bytesWaiting() instead.
		889	*/
		890	qint64 Posix_QextSerialPort::size() const
		891	{
		892	int numBytes;
		893	if (ioctl(Posix_File->handle(), FIONREAD, &numBytes)<0) {
		894	numBytes=0;
		895	}
		896	return (qint64)numBytes;
		897	}
		898
		899	/*!
		900	\fn qint64 Posix_QextSerialPort::bytesAvailable()
		901	Returns the number of bytes waiting in the port's receive queue. This function will return 0 if
		902	the port is not currently open, or -1 on error. Error information can be retrieved by calling
		903	Posix_QextSerialPort::getLastError().
		904	*/
		905	qint64 Posix_QextSerialPort::bytesAvailable()
		906	{
		907	LOCK_MUTEX();
		908	if (isOpen()) {
		909	int bytesQueued;
		910	fd_set fileSet;
		911	FD_ZERO(&fileSet);
		912	FD_SET(Posix_File->handle(), &fileSet);
		913
		914	/*on Linux systems the Posix_Timeout structure will be altered by the select() call.
		915	Make sure we use the right timeout values*/
		916	//memcpy(&Posix_Timeout, &Posix_Copy_Timeout, sizeof(struct timeval));
		917	Posix_Timeout = Posix_Copy_Timeout;
		918	int n=select(Posix_File->handle()+1, &fileSet, NULL, &fileSet, &Posix_Timeout);
		919	if (!n) {
		920	lastErr=E_PORT_TIMEOUT;
		921	UNLOCK_MUTEX();
		922	return -1;
		923	}
		924	if (n==-1 \|\| ioctl(Posix_File->handle(), FIONREAD, &bytesQueued)==-1) {
		925	translateError(errno);
		926	UNLOCK_MUTEX();
		927	return -1;
		928	}
		929	lastErr=E_NO_ERROR;
		930	UNLOCK_MUTEX();
		931	return bytesQueued + QIODevice::bytesAvailable();
		932	}
		933	UNLOCK_MUTEX();
		934	return 0;
		935	}
		936
		937	/*!
		938	\fn void Posix_QextSerialPort::ungetChar(char)
		939	This function is included to implement the full QIODevice interface, and currently has no
		940	purpose within this class. This function is meaningless on an unbuffered device and currently
		941	only prints a warning message to that effect.
		942	*/
		943	void Posix_QextSerialPort::ungetChar(char)
		944	{
		945	/meaningless on unbuffered sequential device - return error and print a warning/
		946	TTY_WARNING("Posix_QextSerialPort: ungetChar() called on an unbuffered sequential device - operation is meaningless");
		947	}
		948
		949	/*!
		950	\fn void Posix_QextSerialPort::translateError(ulong error)
		951	Translates a system-specific error code to a QextSerialPort error code. Used internally.
		952	*/
		953	void Posix_QextSerialPort::translateError(ulong error)
		954	{
		955	switch (error) {
		956	case EBADF:
		957	case ENOTTY:
		958	lastErr=E_INVALID_FD;
		959	break;
		960
		961	case EINTR:
		962	lastErr=E_CAUGHT_NON_BLOCKED_SIGNAL;
		963	break;
		964
		965	case ENOMEM:
		966	lastErr=E_NO_MEMORY;
		967	break;
		968	}
		969	}
		970
		971	/*!
		972	\fn void Posix_QextSerialPort::setDtr(bool set)
		973	Sets DTR line to the requested state (high by default). This function will have no effect if
		974	the port associated with the class is not currently open.
		975	*/
		976	void Posix_QextSerialPort::setDtr(bool set)
		977	{
		978	LOCK_MUTEX();
		979	if (isOpen()) {
		980	int status;
		981	ioctl(Posix_File->handle(), TIOCMGET, &status);
		982	if (set) {
		983	status\|=TIOCM_DTR;
		984	}
		985	else {
		986	status&=~TIOCM_DTR;
		987	}
		988	ioctl(Posix_File->handle(), TIOCMSET, &status);
		989	}
		990	UNLOCK_MUTEX();
		991	}
		992
		993	/*!
		994	\fn void Posix_QextSerialPort::setRts(bool set)
		995	Sets RTS line to the requested state (high by default). This function will have no effect if
		996	the port associated with the class is not currently open.
		997	*/
		998	void Posix_QextSerialPort::setRts(bool set)
		999	{
		1000	LOCK_MUTEX();
		1001	if (isOpen()) {
		1002	int status;
		1003	ioctl(Posix_File->handle(), TIOCMGET, &status);
		1004	if (set) {
		1005	status\|=TIOCM_RTS;
		1006	}
		1007	else {
		1008	status&=~TIOCM_RTS;
		1009	}
		1010	ioctl(Posix_File->handle(), TIOCMSET, &status);
		1011	}
		1012	UNLOCK_MUTEX();
		1013	}
		1014
		1015	/*!
		1016	\fn unsigned long Posix_QextSerialPort::lineStatus()
		1017	returns the line status as stored by the port function. This function will retrieve the states
		1018	of the following lines: DCD, CTS, DSR, and RI. On POSIX systems, the following additional lines
		1019	can be monitored: DTR, RTS, Secondary TXD, and Secondary RXD. The value returned is an unsigned
		1020	long with specific bits indicating which lines are high. The following constants should be used
		1021	to examine the states of individual lines:
		1022
		1023	\verbatim
		1024	Mask Line
		1025	------ ----
		1026	LS_CTS CTS
		1027	LS_DSR DSR
		1028	LS_DCD DCD
		1029	LS_RI RI
		1030	LS_RTS RTS (POSIX only)
		1031	LS_DTR DTR (POSIX only)
		1032	LS_ST Secondary TXD (POSIX only)
		1033	LS_SR Secondary RXD (POSIX only)
		1034	\endverbatim
		1035
		1036	This function will return 0 if the port associated with the class is not currently open.
		1037	*/
		1038	unsigned long Posix_QextSerialPort::lineStatus()
		1039	{
		1040	unsigned long Status=0, Temp=0;
		1041	LOCK_MUTEX();
		1042	if (isOpen()) {
		1043	ioctl(Posix_File->handle(), TIOCMGET, &Temp);
		1044	if (Temp&TIOCM_CTS) {
		1045	Status\|=LS_CTS;
		1046	}
		1047	if (Temp&TIOCM_DSR) {
		1048	Status\|=LS_DSR;
		1049	}
		1050	if (Temp&TIOCM_RI) {
		1051	Status\|=LS_RI;
		1052	}
		1053	if (Temp&TIOCM_CD) {
		1054	Status\|=LS_DCD;
		1055	}
		1056	if (Temp&TIOCM_DTR) {
		1057	Status\|=LS_DTR;
		1058	}
		1059	if (Temp&TIOCM_RTS) {
		1060	Status\|=LS_RTS;
		1061	}
		1062	if (Temp&TIOCM_ST) {
		1063	Status\|=LS_ST;
		1064	}
		1065	if (Temp&TIOCM_SR) {
		1066	Status\|=LS_SR;
		1067	}
		1068	}
		1069	UNLOCK_MUTEX();
		1070	return Status;
		1071	}
		1072
		1073	/*!
		1074	\fn qint64 Posix_QextSerialPort::readData(char * data, qint64 maxSize)
		1075	Reads a block of data from the serial port. This function will read at most maxSize bytes from
		1076	the serial port and place them in the buffer pointed to by data. Return value is the number of
		1077	bytes actually read, or -1 on error.
		1078
		1079	\warning before calling this function ensure that serial port associated with this class
		1080	is currently open (use isOpen() function to check if port is open).
		1081	*/
		1082	qint64 Posix_QextSerialPort::readData(char * data, qint64 maxSize)
		1083	{
		1084	LOCK_MUTEX();
		1085	int retVal=0;
		1086	retVal=Posix_File->read(data, maxSize);
		1087	if (retVal==-1)
		1088	lastErr=E_READ_FAILED;
		1089	UNLOCK_MUTEX();
		1090
		1091	return retVal;
		1092	}
		1093
		1094	/*!
		1095	\fn qint64 Posix_QextSerialPort::writeData(const char * data, qint64 maxSize)
		1096	Writes a block of data to the serial port. This function will write maxSize bytes
		1097	from the buffer pointed to by data to the serial port. Return value is the number
		1098	of bytes actually written, or -1 on error.
		1099
		1100	\warning before calling this function ensure that serial port associated with this class
		1101	is currently open (use isOpen() function to check if port is open).
		1102	*/
		1103	qint64 Posix_QextSerialPort::writeData(const char * data, qint64 maxSize)
		1104	{
		1105	LOCK_MUTEX();
		1106	int retVal=0;
		1107	retVal=Posix_File->write(data, maxSize);
		1108	if (retVal==-1)
		1109	lastErr=E_WRITE_FAILED;
		1110	UNLOCK_MUTEX();
		1111
		1112	flush();
		1113	return retVal;
		1114	}

Subversion Repositories Projects

(root)/QMK-Groundstation/branches/libMK/SerialPort/posix_qextserialport.cpp - Rev 440