1 | /*! |
---|
2 | \class Win_QextSerialPort |
---|
3 | \version 1.0.0 |
---|
4 | \author Stefan Sander |
---|
5 | |
---|
6 | A cross-platform serial port class. |
---|
7 | This class encapsulates the Windows portion of QextSerialPort. The user will be notified of |
---|
8 | errors and possible portability conflicts at run-time by default - this behavior can be turned |
---|
9 | off by defining _TTY_NOWARN_ (to turn off all warnings) or _TTY_NOWARN_PORT_ (to turn off |
---|
10 | portability warnings) in the project. Note that defining _TTY_NOWARN_ also defines |
---|
11 | _TTY_NOWARN_PORT_. |
---|
12 | |
---|
13 | \note |
---|
14 | On Windows NT/2000/XP this class uses Win32 serial port functions by default. The user may |
---|
15 | select POSIX behavior under NT, 2000, or XP ONLY by defining _TTY_POSIX_ in the project. I can |
---|
16 | make no guarantees as to the quality of POSIX support under NT/2000 however. |
---|
17 | |
---|
18 | */ |
---|
19 | |
---|
20 | #include <stdio.h> |
---|
21 | #include "win_qextserialport.h" |
---|
22 | |
---|
23 | /*! |
---|
24 | \fn Win_QextSerialPort::Win_QextSerialPort() |
---|
25 | Default constructor. Note that the name of the device used by a Win_QextSerialPort constructed |
---|
26 | with this constructor will be determined by #defined constants, or lack thereof - the default |
---|
27 | behavior is the same as _TTY_LINUX_. Possible naming conventions and their associated constants |
---|
28 | are: |
---|
29 | |
---|
30 | \verbatim |
---|
31 | |
---|
32 | Constant Used By Naming Convention |
---|
33 | ---------- ------------- ------------------------ |
---|
34 | _TTY_WIN_ Windows COM1, COM2 |
---|
35 | _TTY_IRIX_ SGI/IRIX /dev/ttyf1, /dev/ttyf2 |
---|
36 | _TTY_HPUX_ HP-UX /dev/tty1p0, /dev/tty2p0 |
---|
37 | _TTY_SUN_ SunOS/Solaris /dev/ttya, /dev/ttyb |
---|
38 | _TTY_DIGITAL_ Digital UNIX /dev/tty01, /dev/tty02 |
---|
39 | _TTY_FREEBSD_ FreeBSD /dev/ttyd0, /dev/ttyd1 |
---|
40 | _TTY_LINUX_ Linux /dev/ttyS0, /dev/ttyS1 |
---|
41 | <none> Linux /dev/ttyS0, /dev/ttyS1 |
---|
42 | \endverbatim |
---|
43 | |
---|
44 | This constructor associates the object with the first port on the system, e.g. COM1 for Windows |
---|
45 | platforms. See the other constructor if you need a port other than the first. |
---|
46 | */ |
---|
47 | Win_QextSerialPort::Win_QextSerialPort():QextSerialBase() { |
---|
48 | Win_Handle=INVALID_HANDLE_VALUE; |
---|
49 | } |
---|
50 | |
---|
51 | /*!Win_QextSerialPort::Win_QextSerialPort(const Win_QextSerialPort&) |
---|
52 | Copy constructor. |
---|
53 | */ |
---|
54 | Win_QextSerialPort::Win_QextSerialPort(const Win_QextSerialPort& s):QextSerialBase(s.port) { |
---|
55 | Win_Handle=INVALID_HANDLE_VALUE; |
---|
56 | setOpenMode(s.openMode()); |
---|
57 | lastErr=s.lastErr; |
---|
58 | port = s.port; |
---|
59 | Settings.FlowControl=s.Settings.FlowControl; |
---|
60 | Settings.Parity=s.Settings.Parity; |
---|
61 | Settings.DataBits=s.Settings.DataBits; |
---|
62 | Settings.StopBits=s.Settings.StopBits; |
---|
63 | Settings.BaudRate=s.Settings.BaudRate; |
---|
64 | Win_Handle=s.Win_Handle; |
---|
65 | memcpy(&Win_CommConfig, &s.Win_CommConfig, sizeof(COMMCONFIG)); |
---|
66 | memcpy(&Win_CommTimeouts, &s.Win_CommTimeouts, sizeof(COMMTIMEOUTS)); |
---|
67 | } |
---|
68 | |
---|
69 | /*! |
---|
70 | \fn Win_QextSerialPort::Win_QextSerialPort(const QString & name) |
---|
71 | Constructs a serial port attached to the port specified by devName. |
---|
72 | devName is the name of the device, which is windowsystem-specific, |
---|
73 | e.g."COM2" or "/dev/ttyS0". |
---|
74 | */ |
---|
75 | Win_QextSerialPort::Win_QextSerialPort(const QString & name):QextSerialBase(name) { |
---|
76 | Win_Handle=INVALID_HANDLE_VALUE; |
---|
77 | } |
---|
78 | |
---|
79 | /*! |
---|
80 | \fn Win_QextSerialPort::Win_QextSerialPort(const PortSettings& settings) |
---|
81 | Constructs a port with default name and specified settings. |
---|
82 | */ |
---|
83 | Win_QextSerialPort::Win_QextSerialPort(const PortSettings& settings) { |
---|
84 | Win_Handle=INVALID_HANDLE_VALUE; |
---|
85 | setBaudRate(settings.BaudRate); |
---|
86 | setDataBits(settings.DataBits); |
---|
87 | setStopBits(settings.StopBits); |
---|
88 | setParity(settings.Parity); |
---|
89 | setFlowControl(settings.FlowControl); |
---|
90 | setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec); |
---|
91 | } |
---|
92 | |
---|
93 | /*! |
---|
94 | \fn Win_QextSerialPort::Win_QextSerialPort(const QString & name, const PortSettings& settings) |
---|
95 | Constructs a port with specified name and settings. |
---|
96 | */ |
---|
97 | Win_QextSerialPort::Win_QextSerialPort(const QString & name, const PortSettings& settings) { |
---|
98 | Win_Handle=INVALID_HANDLE_VALUE; |
---|
99 | setPortName(name); |
---|
100 | setBaudRate(settings.BaudRate); |
---|
101 | setDataBits(settings.DataBits); |
---|
102 | setStopBits(settings.StopBits); |
---|
103 | setParity(settings.Parity); |
---|
104 | setFlowControl(settings.FlowControl); |
---|
105 | setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec); |
---|
106 | } |
---|
107 | |
---|
108 | /*! |
---|
109 | \fn Win_QextSerialPort::~Win_QextSerialPort() |
---|
110 | Standard destructor. |
---|
111 | */ |
---|
112 | Win_QextSerialPort::~Win_QextSerialPort() { |
---|
113 | if (isOpen()) { |
---|
114 | close(); |
---|
115 | } |
---|
116 | } |
---|
117 | |
---|
118 | /*! |
---|
119 | \fn Win_QextSerialPort& Win_QextSerialPort::operator=(const Win_QextSerialPort& s) |
---|
120 | overrides the = operator |
---|
121 | */ |
---|
122 | Win_QextSerialPort& Win_QextSerialPort::operator=(const Win_QextSerialPort& s) { |
---|
123 | setOpenMode(s.openMode()); |
---|
124 | lastErr=s.lastErr; |
---|
125 | port = s.port; |
---|
126 | Settings.FlowControl=s.Settings.FlowControl; |
---|
127 | Settings.Parity=s.Settings.Parity; |
---|
128 | Settings.DataBits=s.Settings.DataBits; |
---|
129 | Settings.StopBits=s.Settings.StopBits; |
---|
130 | Settings.BaudRate=s.Settings.BaudRate; |
---|
131 | Win_Handle=s.Win_Handle; |
---|
132 | memcpy(&Win_CommConfig, &s.Win_CommConfig, sizeof(COMMCONFIG)); |
---|
133 | memcpy(&Win_CommTimeouts, &s.Win_CommTimeouts, sizeof(COMMTIMEOUTS)); |
---|
134 | return *this; |
---|
135 | } |
---|
136 | |
---|
137 | /*! |
---|
138 | \fn bool Win_QextSerialPort::open(OpenMode mode) |
---|
139 | Opens a serial port. Note that this function does not specify which device to open. If you need |
---|
140 | to open a device by name, see Win_QextSerialPort::open(const char*). This function has no effect |
---|
141 | if the port associated with the class is already open. The port is also configured to the current |
---|
142 | settings, as stored in the Settings structure. |
---|
143 | */ |
---|
144 | bool Win_QextSerialPort::open(OpenMode mode) { |
---|
145 | unsigned long confSize = sizeof(COMMCONFIG); |
---|
146 | Win_CommConfig.dwSize = confSize; |
---|
147 | |
---|
148 | LOCK_MUTEX(); |
---|
149 | if (mode == QIODevice::NotOpen) |
---|
150 | return isOpen(); |
---|
151 | if (!isOpen()) { |
---|
152 | /*open the port*/ |
---|
153 | Win_Handle=CreateFileA(port.toAscii(), GENERIC_READ|GENERIC_WRITE, |
---|
154 | FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL); |
---|
155 | if (Win_Handle!=INVALID_HANDLE_VALUE) { |
---|
156 | /*set open mode*/ |
---|
157 | QIODevice::open(mode); |
---|
158 | |
---|
159 | /*configure port settings*/ |
---|
160 | GetCommConfig(Win_Handle, &Win_CommConfig, &confSize); |
---|
161 | GetCommState(Win_Handle, &(Win_CommConfig.dcb)); |
---|
162 | |
---|
163 | /*set up parameters*/ |
---|
164 | Win_CommConfig.dcb.fBinary=TRUE; |
---|
165 | Win_CommConfig.dcb.fInX=FALSE; |
---|
166 | Win_CommConfig.dcb.fOutX=FALSE; |
---|
167 | Win_CommConfig.dcb.fAbortOnError=FALSE; |
---|
168 | Win_CommConfig.dcb.fNull=FALSE; |
---|
169 | setBaudRate(Settings.BaudRate); |
---|
170 | setDataBits(Settings.DataBits); |
---|
171 | setStopBits(Settings.StopBits); |
---|
172 | setParity(Settings.Parity); |
---|
173 | setFlowControl(Settings.FlowControl); |
---|
174 | setTimeout(Settings.Timeout_Sec, Settings.Timeout_Millisec); |
---|
175 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
176 | } |
---|
177 | } |
---|
178 | UNLOCK_MUTEX(); |
---|
179 | return isOpen(); |
---|
180 | } |
---|
181 | |
---|
182 | /*! |
---|
183 | \fn void Win_QextSerialPort::close() |
---|
184 | Closes a serial port. This function has no effect if the serial port associated with the class |
---|
185 | is not currently open. |
---|
186 | */ |
---|
187 | void Win_QextSerialPort::close() { |
---|
188 | LOCK_MUTEX(); |
---|
189 | CloseHandle(Win_Handle); |
---|
190 | QIODevice::close(); |
---|
191 | UNLOCK_MUTEX(); |
---|
192 | } |
---|
193 | |
---|
194 | /*! |
---|
195 | \fn void Win_QextSerialPort::flush() |
---|
196 | Flushes all pending I/O to the serial port. This function has no effect if the serial port |
---|
197 | associated with the class is not currently open. |
---|
198 | */ |
---|
199 | void Win_QextSerialPort::flush() { |
---|
200 | LOCK_MUTEX(); |
---|
201 | if (isOpen()) { |
---|
202 | FlushFileBuffers(Win_Handle); |
---|
203 | } |
---|
204 | UNLOCK_MUTEX(); |
---|
205 | } |
---|
206 | |
---|
207 | /*! |
---|
208 | \fn qint64 Win_QextSerialPort::size() const |
---|
209 | This function will return the number of bytes waiting in the receive queue of the serial port. |
---|
210 | It is included primarily to provide a complete QIODevice interface, and will not record errors |
---|
211 | in the lastErr member (because it is const). This function is also not thread-safe - in |
---|
212 | multithreading situations, use Win_QextSerialPort::bytesAvailable() instead. |
---|
213 | */ |
---|
214 | qint64 Win_QextSerialPort::size() const { |
---|
215 | int availBytes; |
---|
216 | COMSTAT Win_ComStat; |
---|
217 | DWORD Win_ErrorMask=0; |
---|
218 | ClearCommError(Win_Handle, &Win_ErrorMask, &Win_ComStat); |
---|
219 | availBytes = Win_ComStat.cbInQue; |
---|
220 | return (qint64)availBytes; |
---|
221 | } |
---|
222 | |
---|
223 | /*! |
---|
224 | \fn qint64 Win_QextSerialPort::bytesAvailable() |
---|
225 | Returns the number of bytes waiting in the port's receive queue. This function will return 0 if |
---|
226 | the port is not currently open, or -1 on error. Error information can be retrieved by calling |
---|
227 | Win_QextSerialPort::getLastError(). |
---|
228 | */ |
---|
229 | qint64 Win_QextSerialPort::bytesAvailable() { |
---|
230 | LOCK_MUTEX(); |
---|
231 | if (isOpen()) { |
---|
232 | DWORD Errors; |
---|
233 | COMSTAT Status; |
---|
234 | bool success=ClearCommError(Win_Handle, &Errors, &Status); |
---|
235 | translateError(Errors); |
---|
236 | if (success) { |
---|
237 | lastErr=E_NO_ERROR; |
---|
238 | UNLOCK_MUTEX(); |
---|
239 | return Status.cbInQue + QIODevice::bytesAvailable(); |
---|
240 | } |
---|
241 | UNLOCK_MUTEX(); |
---|
242 | return (unsigned int)-1; |
---|
243 | } |
---|
244 | UNLOCK_MUTEX(); |
---|
245 | return 0; |
---|
246 | } |
---|
247 | |
---|
248 | /*! |
---|
249 | \fn void Win_QextSerialPort::translateError(ulong error) |
---|
250 | Translates a system-specific error code to a QextSerialPort error code. Used internally. |
---|
251 | */ |
---|
252 | void Win_QextSerialPort::translateError(ulong error) { |
---|
253 | if (error&CE_BREAK) { |
---|
254 | lastErr=E_BREAK_CONDITION; |
---|
255 | } |
---|
256 | else if (error&CE_FRAME) { |
---|
257 | lastErr=E_FRAMING_ERROR; |
---|
258 | } |
---|
259 | else if (error&CE_IOE) { |
---|
260 | lastErr=E_IO_ERROR; |
---|
261 | } |
---|
262 | else if (error&CE_MODE) { |
---|
263 | lastErr=E_INVALID_FD; |
---|
264 | } |
---|
265 | else if (error&CE_OVERRUN) { |
---|
266 | lastErr=E_BUFFER_OVERRUN; |
---|
267 | } |
---|
268 | else if (error&CE_RXPARITY) { |
---|
269 | lastErr=E_RECEIVE_PARITY_ERROR; |
---|
270 | } |
---|
271 | else if (error&CE_RXOVER) { |
---|
272 | lastErr=E_RECEIVE_OVERFLOW; |
---|
273 | } |
---|
274 | else if (error&CE_TXFULL) { |
---|
275 | lastErr=E_TRANSMIT_OVERFLOW; |
---|
276 | } |
---|
277 | } |
---|
278 | |
---|
279 | /*! |
---|
280 | \fn qint64 Win_QextSerialPort::readData(char *data, qint64 maxSize) |
---|
281 | Reads a block of data from the serial port. This function will read at most maxlen bytes from |
---|
282 | the serial port and place them in the buffer pointed to by data. Return value is the number of |
---|
283 | bytes actually read, or -1 on error. |
---|
284 | |
---|
285 | \warning before calling this function ensure that serial port associated with this class |
---|
286 | is currently open (use isOpen() function to check if port is open). |
---|
287 | */ |
---|
288 | qint64 Win_QextSerialPort::readData(char *data, qint64 maxSize) |
---|
289 | { |
---|
290 | LOCK_MUTEX(); |
---|
291 | int retVal=0; |
---|
292 | COMSTAT Win_ComStat; |
---|
293 | DWORD Win_BytesRead=0; |
---|
294 | DWORD Win_ErrorMask=0; |
---|
295 | ClearCommError(Win_Handle, &Win_ErrorMask, &Win_ComStat); |
---|
296 | if (Win_ComStat.cbInQue && |
---|
297 | (!ReadFile(Win_Handle, (void*)data, (DWORD)maxSize, &Win_BytesRead, NULL) |
---|
298 | || Win_BytesRead==0)) { |
---|
299 | lastErr=E_READ_FAILED; |
---|
300 | retVal=-1; |
---|
301 | } |
---|
302 | else { |
---|
303 | retVal=((int)Win_BytesRead); |
---|
304 | } |
---|
305 | UNLOCK_MUTEX(); |
---|
306 | |
---|
307 | return retVal; |
---|
308 | } |
---|
309 | |
---|
310 | /*! |
---|
311 | \fn qint64 Win_QextSerialPort::writeData(const char *data, qint64 maxSize) |
---|
312 | Writes a block of data to the serial port. This function will write len bytes |
---|
313 | from the buffer pointed to by data to the serial port. Return value is the number |
---|
314 | of bytes actually written, or -1 on error. |
---|
315 | |
---|
316 | \warning before calling this function ensure that serial port associated with this class |
---|
317 | is currently open (use isOpen() function to check if port is open). |
---|
318 | */ |
---|
319 | qint64 Win_QextSerialPort::writeData(const char *data, qint64 maxSize) |
---|
320 | { |
---|
321 | LOCK_MUTEX(); |
---|
322 | int retVal=0; |
---|
323 | DWORD Win_BytesWritten; |
---|
324 | if (!WriteFile(Win_Handle, (void*)data, (DWORD)maxSize, &Win_BytesWritten, NULL)) { |
---|
325 | lastErr=E_WRITE_FAILED; |
---|
326 | retVal=-1; |
---|
327 | } |
---|
328 | else { |
---|
329 | retVal=((int)Win_BytesWritten); |
---|
330 | } |
---|
331 | UNLOCK_MUTEX(); |
---|
332 | |
---|
333 | flush(); |
---|
334 | return retVal; |
---|
335 | } |
---|
336 | |
---|
337 | /*! |
---|
338 | \fn void Win_QextSerialPort::ungetChar(char c) |
---|
339 | This function is included to implement the full QIODevice interface, and currently has no |
---|
340 | purpose within this class. This function is meaningless on an unbuffered device and currently |
---|
341 | only prints a warning message to that effect. |
---|
342 | */ |
---|
343 | void Win_QextSerialPort::ungetChar(char c) { |
---|
344 | |
---|
345 | /*meaningless on unbuffered sequential device - return error and print a warning*/ |
---|
346 | TTY_WARNING("Win_QextSerialPort: ungetChar() called on an unbuffered sequential device - operation is meaningless"); |
---|
347 | } |
---|
348 | |
---|
349 | /*! |
---|
350 | \fn void Win_QextSerialPort::setFlowControl(FlowType flow) |
---|
351 | Sets the flow control used by the port. Possible values of flow are: |
---|
352 | \verbatim |
---|
353 | FLOW_OFF No flow control |
---|
354 | FLOW_HARDWARE Hardware (RTS/CTS) flow control |
---|
355 | FLOW_XONXOFF Software (XON/XOFF) flow control |
---|
356 | \endverbatim |
---|
357 | */ |
---|
358 | void Win_QextSerialPort::setFlowControl(FlowType flow) { |
---|
359 | LOCK_MUTEX(); |
---|
360 | if (Settings.FlowControl!=flow) { |
---|
361 | Settings.FlowControl=flow; |
---|
362 | } |
---|
363 | if (isOpen()) { |
---|
364 | switch(flow) { |
---|
365 | |
---|
366 | /*no flow control*/ |
---|
367 | case FLOW_OFF: |
---|
368 | Win_CommConfig.dcb.fOutxCtsFlow=FALSE; |
---|
369 | Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE; |
---|
370 | Win_CommConfig.dcb.fInX=FALSE; |
---|
371 | Win_CommConfig.dcb.fOutX=FALSE; |
---|
372 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
373 | break; |
---|
374 | |
---|
375 | /*software (XON/XOFF) flow control*/ |
---|
376 | case FLOW_XONXOFF: |
---|
377 | Win_CommConfig.dcb.fOutxCtsFlow=FALSE; |
---|
378 | Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE; |
---|
379 | Win_CommConfig.dcb.fInX=TRUE; |
---|
380 | Win_CommConfig.dcb.fOutX=TRUE; |
---|
381 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
382 | break; |
---|
383 | |
---|
384 | case FLOW_HARDWARE: |
---|
385 | Win_CommConfig.dcb.fOutxCtsFlow=TRUE; |
---|
386 | Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_HANDSHAKE; |
---|
387 | Win_CommConfig.dcb.fInX=FALSE; |
---|
388 | Win_CommConfig.dcb.fOutX=FALSE; |
---|
389 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
390 | break; |
---|
391 | } |
---|
392 | } |
---|
393 | UNLOCK_MUTEX(); |
---|
394 | } |
---|
395 | |
---|
396 | /*! |
---|
397 | \fn void Win_QextSerialPort::setParity(ParityType parity) |
---|
398 | Sets the parity associated with the serial port. The possible values of parity are: |
---|
399 | \verbatim |
---|
400 | PAR_SPACE Space Parity |
---|
401 | PAR_MARK Mark Parity |
---|
402 | PAR_NONE No Parity |
---|
403 | PAR_EVEN Even Parity |
---|
404 | PAR_ODD Odd Parity |
---|
405 | \endverbatim |
---|
406 | */ |
---|
407 | void Win_QextSerialPort::setParity(ParityType parity) { |
---|
408 | LOCK_MUTEX(); |
---|
409 | if (Settings.Parity!=parity) { |
---|
410 | Settings.Parity=parity; |
---|
411 | } |
---|
412 | if (isOpen()) { |
---|
413 | Win_CommConfig.dcb.Parity=(unsigned char)parity; |
---|
414 | switch (parity) { |
---|
415 | |
---|
416 | /*space parity*/ |
---|
417 | case PAR_SPACE: |
---|
418 | if (Settings.DataBits==DATA_8) { |
---|
419 | TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: Space parity with 8 data bits is not supported by POSIX systems."); |
---|
420 | } |
---|
421 | Win_CommConfig.dcb.fParity=TRUE; |
---|
422 | break; |
---|
423 | |
---|
424 | /*mark parity - WINDOWS ONLY*/ |
---|
425 | case PAR_MARK: |
---|
426 | TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: Mark parity is not supported by POSIX systems"); |
---|
427 | Win_CommConfig.dcb.fParity=TRUE; |
---|
428 | break; |
---|
429 | |
---|
430 | /*no parity*/ |
---|
431 | case PAR_NONE: |
---|
432 | Win_CommConfig.dcb.fParity=FALSE; |
---|
433 | break; |
---|
434 | |
---|
435 | /*even parity*/ |
---|
436 | case PAR_EVEN: |
---|
437 | Win_CommConfig.dcb.fParity=TRUE; |
---|
438 | break; |
---|
439 | |
---|
440 | /*odd parity*/ |
---|
441 | case PAR_ODD: |
---|
442 | Win_CommConfig.dcb.fParity=TRUE; |
---|
443 | break; |
---|
444 | } |
---|
445 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
446 | } |
---|
447 | UNLOCK_MUTEX(); |
---|
448 | } |
---|
449 | |
---|
450 | /*! |
---|
451 | \fn void Win_QextSerialPort::setDataBits(DataBitsType dataBits) |
---|
452 | Sets the number of data bits used by the serial port. Possible values of dataBits are: |
---|
453 | \verbatim |
---|
454 | DATA_5 5 data bits |
---|
455 | DATA_6 6 data bits |
---|
456 | DATA_7 7 data bits |
---|
457 | DATA_8 8 data bits |
---|
458 | \endverbatim |
---|
459 | |
---|
460 | \note |
---|
461 | This function is subject to the following restrictions: |
---|
462 | \par |
---|
463 | 5 data bits cannot be used with 2 stop bits. |
---|
464 | \par |
---|
465 | 1.5 stop bits can only be used with 5 data bits. |
---|
466 | \par |
---|
467 | 8 data bits cannot be used with space parity on POSIX systems. |
---|
468 | |
---|
469 | */ |
---|
470 | void Win_QextSerialPort::setDataBits(DataBitsType dataBits) { |
---|
471 | LOCK_MUTEX(); |
---|
472 | if (Settings.DataBits!=dataBits) { |
---|
473 | if ((Settings.StopBits==STOP_2 && dataBits==DATA_5) || |
---|
474 | (Settings.StopBits==STOP_1_5 && dataBits!=DATA_5)) { |
---|
475 | } |
---|
476 | else { |
---|
477 | Settings.DataBits=dataBits; |
---|
478 | } |
---|
479 | } |
---|
480 | if (isOpen()) { |
---|
481 | switch(dataBits) { |
---|
482 | |
---|
483 | /*5 data bits*/ |
---|
484 | case DATA_5: |
---|
485 | if (Settings.StopBits==STOP_2) { |
---|
486 | TTY_WARNING("Win_QextSerialPort: 5 Data bits cannot be used with 2 stop bits."); |
---|
487 | } |
---|
488 | else { |
---|
489 | Win_CommConfig.dcb.ByteSize=5; |
---|
490 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
491 | } |
---|
492 | break; |
---|
493 | |
---|
494 | /*6 data bits*/ |
---|
495 | case DATA_6: |
---|
496 | if (Settings.StopBits==STOP_1_5) { |
---|
497 | TTY_WARNING("Win_QextSerialPort: 6 Data bits cannot be used with 1.5 stop bits."); |
---|
498 | } |
---|
499 | else { |
---|
500 | Win_CommConfig.dcb.ByteSize=6; |
---|
501 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
502 | } |
---|
503 | break; |
---|
504 | |
---|
505 | /*7 data bits*/ |
---|
506 | case DATA_7: |
---|
507 | if (Settings.StopBits==STOP_1_5) { |
---|
508 | TTY_WARNING("Win_QextSerialPort: 7 Data bits cannot be used with 1.5 stop bits."); |
---|
509 | } |
---|
510 | else { |
---|
511 | Win_CommConfig.dcb.ByteSize=7; |
---|
512 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
513 | } |
---|
514 | break; |
---|
515 | |
---|
516 | /*8 data bits*/ |
---|
517 | case DATA_8: |
---|
518 | if (Settings.StopBits==STOP_1_5) { |
---|
519 | TTY_WARNING("Win_QextSerialPort: 8 Data bits cannot be used with 1.5 stop bits."); |
---|
520 | } |
---|
521 | else { |
---|
522 | Win_CommConfig.dcb.ByteSize=8; |
---|
523 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
524 | } |
---|
525 | break; |
---|
526 | } |
---|
527 | } |
---|
528 | UNLOCK_MUTEX(); |
---|
529 | } |
---|
530 | |
---|
531 | /*! |
---|
532 | \fn void Win_QextSerialPort::setStopBits(StopBitsType stopBits) |
---|
533 | Sets the number of stop bits used by the serial port. Possible values of stopBits are: |
---|
534 | \verbatim |
---|
535 | STOP_1 1 stop bit |
---|
536 | STOP_1_5 1.5 stop bits |
---|
537 | STOP_2 2 stop bits |
---|
538 | \endverbatim |
---|
539 | |
---|
540 | \note |
---|
541 | This function is subject to the following restrictions: |
---|
542 | \par |
---|
543 | 2 stop bits cannot be used with 5 data bits. |
---|
544 | \par |
---|
545 | 1.5 stop bits cannot be used with 6 or more data bits. |
---|
546 | \par |
---|
547 | POSIX does not support 1.5 stop bits. |
---|
548 | */ |
---|
549 | void Win_QextSerialPort::setStopBits(StopBitsType stopBits) { |
---|
550 | LOCK_MUTEX(); |
---|
551 | if (Settings.StopBits!=stopBits) { |
---|
552 | if ((Settings.DataBits==DATA_5 && stopBits==STOP_2) || |
---|
553 | (stopBits==STOP_1_5 && Settings.DataBits!=DATA_5)) { |
---|
554 | } |
---|
555 | else { |
---|
556 | Settings.StopBits=stopBits; |
---|
557 | } |
---|
558 | } |
---|
559 | if (isOpen()) { |
---|
560 | switch (stopBits) { |
---|
561 | |
---|
562 | /*one stop bit*/ |
---|
563 | case STOP_1: |
---|
564 | Win_CommConfig.dcb.StopBits=ONESTOPBIT; |
---|
565 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
566 | break; |
---|
567 | |
---|
568 | /*1.5 stop bits*/ |
---|
569 | case STOP_1_5: |
---|
570 | TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: 1.5 stop bit operation is not supported by POSIX."); |
---|
571 | if (Settings.DataBits!=DATA_5) { |
---|
572 | TTY_WARNING("Win_QextSerialPort: 1.5 stop bits can only be used with 5 data bits"); |
---|
573 | } |
---|
574 | else { |
---|
575 | Win_CommConfig.dcb.StopBits=ONE5STOPBITS; |
---|
576 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
577 | } |
---|
578 | break; |
---|
579 | |
---|
580 | /*two stop bits*/ |
---|
581 | case STOP_2: |
---|
582 | if (Settings.DataBits==DATA_5) { |
---|
583 | TTY_WARNING("Win_QextSerialPort: 2 stop bits cannot be used with 5 data bits"); |
---|
584 | } |
---|
585 | else { |
---|
586 | Win_CommConfig.dcb.StopBits=TWOSTOPBITS; |
---|
587 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
588 | } |
---|
589 | break; |
---|
590 | } |
---|
591 | } |
---|
592 | UNLOCK_MUTEX(); |
---|
593 | } |
---|
594 | |
---|
595 | /*! |
---|
596 | \fn void Win_QextSerialPort::setBaudRate(BaudRateType baudRate) |
---|
597 | Sets the baud rate of the serial port. Note that not all rates are applicable on |
---|
598 | all platforms. The following table shows translations of the various baud rate |
---|
599 | constants on Windows(including NT/2000) and POSIX platforms. Speeds marked with an * |
---|
600 | are speeds that are usable on both Windows and POSIX. |
---|
601 | \verbatim |
---|
602 | |
---|
603 | RATE Windows Speed POSIX Speed |
---|
604 | ----------- ------------- ----------- |
---|
605 | BAUD50 110 50 |
---|
606 | BAUD75 110 75 |
---|
607 | *BAUD110 110 110 |
---|
608 | BAUD134 110 134.5 |
---|
609 | BAUD150 110 150 |
---|
610 | BAUD200 110 200 |
---|
611 | *BAUD300 300 300 |
---|
612 | *BAUD600 600 600 |
---|
613 | *BAUD1200 1200 1200 |
---|
614 | BAUD1800 1200 1800 |
---|
615 | *BAUD2400 2400 2400 |
---|
616 | *BAUD4800 4800 4800 |
---|
617 | *BAUD9600 9600 9600 |
---|
618 | BAUD14400 14400 9600 |
---|
619 | *BAUD19200 19200 19200 |
---|
620 | *BAUD38400 38400 38400 |
---|
621 | BAUD56000 56000 38400 |
---|
622 | *BAUD57600 57600 57600 |
---|
623 | BAUD76800 57600 76800 |
---|
624 | *BAUD115200 115200 115200 |
---|
625 | BAUD128000 128000 115200 |
---|
626 | BAUD256000 256000 115200 |
---|
627 | \endverbatim |
---|
628 | */ |
---|
629 | void Win_QextSerialPort::setBaudRate(BaudRateType baudRate) { |
---|
630 | LOCK_MUTEX(); |
---|
631 | if (Settings.BaudRate!=baudRate) { |
---|
632 | switch (baudRate) { |
---|
633 | case BAUD50: |
---|
634 | case BAUD75: |
---|
635 | case BAUD134: |
---|
636 | case BAUD150: |
---|
637 | case BAUD200: |
---|
638 | Settings.BaudRate=BAUD110; |
---|
639 | break; |
---|
640 | |
---|
641 | case BAUD1800: |
---|
642 | Settings.BaudRate=BAUD1200; |
---|
643 | break; |
---|
644 | |
---|
645 | case BAUD76800: |
---|
646 | Settings.BaudRate=BAUD57600; |
---|
647 | break; |
---|
648 | |
---|
649 | default: |
---|
650 | Settings.BaudRate=baudRate; |
---|
651 | break; |
---|
652 | } |
---|
653 | } |
---|
654 | if (isOpen()) { |
---|
655 | switch (baudRate) { |
---|
656 | |
---|
657 | /*50 baud*/ |
---|
658 | case BAUD50: |
---|
659 | TTY_WARNING("Win_QextSerialPort: Windows does not support 50 baud operation. Switching to 110 baud."); |
---|
660 | Win_CommConfig.dcb.BaudRate=CBR_110; |
---|
661 | break; |
---|
662 | |
---|
663 | /*75 baud*/ |
---|
664 | case BAUD75: |
---|
665 | TTY_WARNING("Win_QextSerialPort: Windows does not support 75 baud operation. Switching to 110 baud."); |
---|
666 | Win_CommConfig.dcb.BaudRate=CBR_110; |
---|
667 | break; |
---|
668 | |
---|
669 | /*110 baud*/ |
---|
670 | case BAUD110: |
---|
671 | Win_CommConfig.dcb.BaudRate=CBR_110; |
---|
672 | break; |
---|
673 | |
---|
674 | /*134.5 baud*/ |
---|
675 | case BAUD134: |
---|
676 | TTY_WARNING("Win_QextSerialPort: Windows does not support 134.5 baud operation. Switching to 110 baud."); |
---|
677 | Win_CommConfig.dcb.BaudRate=CBR_110; |
---|
678 | break; |
---|
679 | |
---|
680 | /*150 baud*/ |
---|
681 | case BAUD150: |
---|
682 | TTY_WARNING("Win_QextSerialPort: Windows does not support 150 baud operation. Switching to 110 baud."); |
---|
683 | Win_CommConfig.dcb.BaudRate=CBR_110; |
---|
684 | break; |
---|
685 | |
---|
686 | /*200 baud*/ |
---|
687 | case BAUD200: |
---|
688 | TTY_WARNING("Win_QextSerialPort: Windows does not support 200 baud operation. Switching to 110 baud."); |
---|
689 | Win_CommConfig.dcb.BaudRate=CBR_110; |
---|
690 | break; |
---|
691 | |
---|
692 | /*300 baud*/ |
---|
693 | case BAUD300: |
---|
694 | Win_CommConfig.dcb.BaudRate=CBR_300; |
---|
695 | break; |
---|
696 | |
---|
697 | /*600 baud*/ |
---|
698 | case BAUD600: |
---|
699 | Win_CommConfig.dcb.BaudRate=CBR_600; |
---|
700 | break; |
---|
701 | |
---|
702 | /*1200 baud*/ |
---|
703 | case BAUD1200: |
---|
704 | Win_CommConfig.dcb.BaudRate=CBR_1200; |
---|
705 | break; |
---|
706 | |
---|
707 | /*1800 baud*/ |
---|
708 | case BAUD1800: |
---|
709 | TTY_WARNING("Win_QextSerialPort: Windows does not support 1800 baud operation. Switching to 1200 baud."); |
---|
710 | Win_CommConfig.dcb.BaudRate=CBR_1200; |
---|
711 | break; |
---|
712 | |
---|
713 | /*2400 baud*/ |
---|
714 | case BAUD2400: |
---|
715 | Win_CommConfig.dcb.BaudRate=CBR_2400; |
---|
716 | break; |
---|
717 | |
---|
718 | /*4800 baud*/ |
---|
719 | case BAUD4800: |
---|
720 | Win_CommConfig.dcb.BaudRate=CBR_4800; |
---|
721 | break; |
---|
722 | |
---|
723 | /*9600 baud*/ |
---|
724 | case BAUD9600: |
---|
725 | Win_CommConfig.dcb.BaudRate=CBR_9600; |
---|
726 | break; |
---|
727 | |
---|
728 | /*14400 baud*/ |
---|
729 | case BAUD14400: |
---|
730 | TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 14400 baud operation."); |
---|
731 | Win_CommConfig.dcb.BaudRate=CBR_14400; |
---|
732 | break; |
---|
733 | |
---|
734 | /*19200 baud*/ |
---|
735 | case BAUD19200: |
---|
736 | Win_CommConfig.dcb.BaudRate=CBR_19200; |
---|
737 | break; |
---|
738 | |
---|
739 | /*38400 baud*/ |
---|
740 | case BAUD38400: |
---|
741 | Win_CommConfig.dcb.BaudRate=CBR_38400; |
---|
742 | break; |
---|
743 | |
---|
744 | /*56000 baud*/ |
---|
745 | case BAUD56000: |
---|
746 | TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 56000 baud operation."); |
---|
747 | Win_CommConfig.dcb.BaudRate=CBR_56000; |
---|
748 | break; |
---|
749 | |
---|
750 | /*57600 baud*/ |
---|
751 | case BAUD57600: |
---|
752 | Win_CommConfig.dcb.BaudRate=CBR_57600; |
---|
753 | break; |
---|
754 | |
---|
755 | /*76800 baud*/ |
---|
756 | case BAUD76800: |
---|
757 | TTY_WARNING("Win_QextSerialPort: Windows does not support 76800 baud operation. Switching to 57600 baud."); |
---|
758 | Win_CommConfig.dcb.BaudRate=CBR_57600; |
---|
759 | break; |
---|
760 | |
---|
761 | /*115200 baud*/ |
---|
762 | case BAUD115200: |
---|
763 | Win_CommConfig.dcb.BaudRate=CBR_115200; |
---|
764 | break; |
---|
765 | |
---|
766 | /*128000 baud*/ |
---|
767 | case BAUD128000: |
---|
768 | TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 128000 baud operation."); |
---|
769 | Win_CommConfig.dcb.BaudRate=CBR_128000; |
---|
770 | break; |
---|
771 | |
---|
772 | /*256000 baud*/ |
---|
773 | case BAUD256000: |
---|
774 | TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 256000 baud operation."); |
---|
775 | Win_CommConfig.dcb.BaudRate=CBR_256000; |
---|
776 | break; |
---|
777 | } |
---|
778 | SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG)); |
---|
779 | } |
---|
780 | UNLOCK_MUTEX(); |
---|
781 | } |
---|
782 | |
---|
783 | /*! |
---|
784 | \fn void Win_QextSerialPort::setDtr(bool set) |
---|
785 | Sets DTR line to the requested state (high by default). This function will have no effect if |
---|
786 | the port associated with the class is not currently open. |
---|
787 | */ |
---|
788 | void Win_QextSerialPort::setDtr(bool set) { |
---|
789 | LOCK_MUTEX(); |
---|
790 | if (isOpen()) { |
---|
791 | if (set) { |
---|
792 | EscapeCommFunction(Win_Handle, SETDTR); |
---|
793 | } |
---|
794 | else { |
---|
795 | EscapeCommFunction(Win_Handle, CLRDTR); |
---|
796 | } |
---|
797 | } |
---|
798 | UNLOCK_MUTEX(); |
---|
799 | } |
---|
800 | |
---|
801 | /*! |
---|
802 | \fn void Win_QextSerialPort::setRts(bool set) |
---|
803 | Sets RTS line to the requested state (high by default). This function will have no effect if |
---|
804 | the port associated with the class is not currently open. |
---|
805 | */ |
---|
806 | void Win_QextSerialPort::setRts(bool set) { |
---|
807 | LOCK_MUTEX(); |
---|
808 | if (isOpen()) { |
---|
809 | if (set) { |
---|
810 | EscapeCommFunction(Win_Handle, SETRTS); |
---|
811 | } |
---|
812 | else { |
---|
813 | EscapeCommFunction(Win_Handle, CLRRTS); |
---|
814 | } |
---|
815 | } |
---|
816 | UNLOCK_MUTEX(); |
---|
817 | } |
---|
818 | |
---|
819 | /*! |
---|
820 | \fn ulong Win_QextSerialPort::lineStatus(void) |
---|
821 | returns the line status as stored by the port function. This function will retrieve the states |
---|
822 | of the following lines: DCD, CTS, DSR, and RI. On POSIX systems, the following additional lines |
---|
823 | can be monitored: DTR, RTS, Secondary TXD, and Secondary RXD. The value returned is an unsigned |
---|
824 | long with specific bits indicating which lines are high. The following constants should be used |
---|
825 | to examine the states of individual lines: |
---|
826 | |
---|
827 | \verbatim |
---|
828 | Mask Line |
---|
829 | ------ ---- |
---|
830 | LS_CTS CTS |
---|
831 | LS_DSR DSR |
---|
832 | LS_DCD DCD |
---|
833 | LS_RI RI |
---|
834 | \endverbatim |
---|
835 | |
---|
836 | This function will return 0 if the port associated with the class is not currently open. |
---|
837 | */ |
---|
838 | ulong Win_QextSerialPort::lineStatus(void) { |
---|
839 | unsigned long Status=0, Temp=0; |
---|
840 | LOCK_MUTEX(); |
---|
841 | if (isOpen()) { |
---|
842 | GetCommModemStatus(Win_Handle, &Temp); |
---|
843 | if (Temp&MS_CTS_ON) { |
---|
844 | Status|=LS_CTS; |
---|
845 | } |
---|
846 | if (Temp&MS_DSR_ON) { |
---|
847 | Status|=LS_DSR; |
---|
848 | } |
---|
849 | if (Temp&MS_RING_ON) { |
---|
850 | Status|=LS_RI; |
---|
851 | } |
---|
852 | if (Temp&MS_RLSD_ON) { |
---|
853 | Status|=LS_DCD; |
---|
854 | } |
---|
855 | } |
---|
856 | UNLOCK_MUTEX(); |
---|
857 | return Status; |
---|
858 | } |
---|
859 | |
---|
860 | /*! |
---|
861 | \fn void Win_QextSerialPort::setTimeout(ulong sec, ulong millisec); |
---|
862 | Sets the read and write timeouts for the port to sec seconds and millisec milliseconds. |
---|
863 | */ |
---|
864 | void Win_QextSerialPort::setTimeout(ulong sec, ulong millisec) { |
---|
865 | LOCK_MUTEX(); |
---|
866 | Settings.Timeout_Sec=sec; |
---|
867 | Settings.Timeout_Millisec=millisec; |
---|
868 | if(isOpen()) { |
---|
869 | Win_CommTimeouts.ReadIntervalTimeout = sec*1000+millisec; |
---|
870 | Win_CommTimeouts.ReadTotalTimeoutMultiplier = sec*1000+millisec; |
---|
871 | Win_CommTimeouts.ReadTotalTimeoutConstant = 0; |
---|
872 | Win_CommTimeouts.WriteTotalTimeoutMultiplier = sec*1000+millisec; |
---|
873 | Win_CommTimeouts.WriteTotalTimeoutConstant = 0; |
---|
874 | SetCommTimeouts(Win_Handle, &Win_CommTimeouts); |
---|
875 | } |
---|
876 | UNLOCK_MUTEX(); |
---|
877 | } |
---|