Subversion Repositories Projects

Rev

Rev 158 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
158 KeyOz 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
}