QlightRead package | ESS final project 1.22-beta

/home/ron/Desktop/Frontend/src/win_qextserialport.cpp

Go to the documentation of this file.
00001 
00020 #include <stdio.h>
00021 #include "win_qextserialport.h"
00022 
00047 Win_QextSerialPort::Win_QextSerialPort():QextSerialBase() {
00048     Win_Handle=INVALID_HANDLE_VALUE;
00049 }
00050 
00054 Win_QextSerialPort::Win_QextSerialPort(const Win_QextSerialPort& s):QextSerialBase(s.port) {
00055     Win_Handle=INVALID_HANDLE_VALUE;
00056     setOpenMode(s.openMode());
00057     lastErr=s.lastErr;
00058     port = s.port;
00059     Settings.FlowControl=s.Settings.FlowControl;
00060     Settings.Parity=s.Settings.Parity;
00061     Settings.DataBits=s.Settings.DataBits;
00062     Settings.StopBits=s.Settings.StopBits;
00063     Settings.BaudRate=s.Settings.BaudRate;
00064     Win_Handle=s.Win_Handle;
00065     memcpy(&Win_CommConfig, &s.Win_CommConfig, sizeof(COMMCONFIG));
00066     memcpy(&Win_CommTimeouts, &s.Win_CommTimeouts, sizeof(COMMTIMEOUTS));
00067 }
00068 
00075 Win_QextSerialPort::Win_QextSerialPort(const QString & name):QextSerialBase(name) {
00076     Win_Handle=INVALID_HANDLE_VALUE;
00077 }
00078 
00083 Win_QextSerialPort::Win_QextSerialPort(const PortSettings& settings) {
00084     Win_Handle=INVALID_HANDLE_VALUE;
00085     setBaudRate(settings.BaudRate);
00086     setDataBits(settings.DataBits);
00087     setStopBits(settings.StopBits);
00088     setParity(settings.Parity);
00089     setFlowControl(settings.FlowControl);
00090     setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
00091 }
00092 
00097 Win_QextSerialPort::Win_QextSerialPort(const QString & name, const PortSettings& settings) {
00098     Win_Handle=INVALID_HANDLE_VALUE;
00099     setPortName(name);
00100     setBaudRate(settings.BaudRate);
00101     setDataBits(settings.DataBits);
00102     setStopBits(settings.StopBits);
00103     setParity(settings.Parity);
00104     setFlowControl(settings.FlowControl);
00105     setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
00106 }
00107 
00112 Win_QextSerialPort::~Win_QextSerialPort() {
00113     if (isOpen()) {
00114         close();
00115     }
00116 }
00117 
00122 Win_QextSerialPort& Win_QextSerialPort::operator=(const Win_QextSerialPort& s) {
00123     setOpenMode(s.openMode());
00124     lastErr=s.lastErr;
00125     port = s.port;
00126     Settings.FlowControl=s.Settings.FlowControl;
00127     Settings.Parity=s.Settings.Parity;
00128     Settings.DataBits=s.Settings.DataBits;
00129     Settings.StopBits=s.Settings.StopBits;
00130     Settings.BaudRate=s.Settings.BaudRate;
00131     Win_Handle=s.Win_Handle;
00132     memcpy(&Win_CommConfig, &s.Win_CommConfig, sizeof(COMMCONFIG));
00133     memcpy(&Win_CommTimeouts, &s.Win_CommTimeouts, sizeof(COMMTIMEOUTS));
00134     return *this;
00135 }
00136 
00144 bool Win_QextSerialPort::open(OpenMode mode) {
00145     unsigned long confSize = sizeof(COMMCONFIG);
00146     Win_CommConfig.dwSize = confSize;
00147 
00148     LOCK_MUTEX();
00149     if (mode == QIODevice::NotOpen)
00150         return isOpen();
00151     if (!isOpen()) {
00152         /*open the port*/
00153         Win_Handle=CreateFileA(port.toAscii(), GENERIC_READ|GENERIC_WRITE,
00154                               FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
00155         if (Win_Handle!=INVALID_HANDLE_VALUE) {
00156             /*set open mode*/
00157             QIODevice::open(mode);
00158 
00159             /*configure port settings*/
00160             GetCommConfig(Win_Handle, &Win_CommConfig, &confSize);
00161             GetCommState(Win_Handle, &(Win_CommConfig.dcb));
00162 
00163             /*set up parameters*/
00164             Win_CommConfig.dcb.fBinary=TRUE;
00165             Win_CommConfig.dcb.fInX=FALSE;
00166             Win_CommConfig.dcb.fOutX=FALSE;
00167             Win_CommConfig.dcb.fAbortOnError=FALSE;
00168             Win_CommConfig.dcb.fNull=FALSE;
00169             setBaudRate(Settings.BaudRate);
00170             setDataBits(Settings.DataBits);
00171             setStopBits(Settings.StopBits);
00172             setParity(Settings.Parity);
00173             setFlowControl(Settings.FlowControl);
00174             setTimeout(Settings.Timeout_Sec, Settings.Timeout_Millisec);
00175             SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00176         }
00177     }
00178     UNLOCK_MUTEX();
00179     return isOpen();
00180 }
00181 
00187 void Win_QextSerialPort::close() {
00188     LOCK_MUTEX();
00189     CloseHandle(Win_Handle);
00190     QIODevice::close();
00191     UNLOCK_MUTEX();
00192 }
00193 
00199 void Win_QextSerialPort::flush() {
00200     LOCK_MUTEX();
00201     if (isOpen()) {
00202         FlushFileBuffers(Win_Handle);
00203     }
00204     UNLOCK_MUTEX();
00205 }
00206 
00214 qint64 Win_QextSerialPort::size() const {
00215     int availBytes;
00216     COMSTAT Win_ComStat;
00217     DWORD Win_ErrorMask=0;
00218     ClearCommError(Win_Handle, &Win_ErrorMask, &Win_ComStat);
00219     availBytes = Win_ComStat.cbInQue;
00220     return (qint64)availBytes;
00221 }
00222 
00229 qint64 Win_QextSerialPort::bytesAvailable() {
00230     LOCK_MUTEX();
00231     if (isOpen()) {
00232         DWORD Errors;
00233         COMSTAT Status;
00234         bool success=ClearCommError(Win_Handle, &Errors, &Status);
00235         translateError(Errors);
00236         if (success) {
00237             lastErr=E_NO_ERROR;
00238             UNLOCK_MUTEX();
00239             return Status.cbInQue + QIODevice::bytesAvailable();
00240         }
00241         UNLOCK_MUTEX();
00242         return (unsigned int)-1;
00243     }
00244     UNLOCK_MUTEX();
00245     return 0;
00246 }
00247 
00252 void Win_QextSerialPort::translateError(ulong error) {
00253     if (error&CE_BREAK) {
00254         lastErr=E_BREAK_CONDITION;
00255     }
00256     else if (error&CE_FRAME) {
00257         lastErr=E_FRAMING_ERROR;
00258     }
00259     else if (error&CE_IOE) {
00260         lastErr=E_IO_ERROR;
00261     }
00262     else if (error&CE_MODE) {
00263         lastErr=E_INVALID_FD;
00264     }
00265     else if (error&CE_OVERRUN) {
00266         lastErr=E_BUFFER_OVERRUN;
00267     }
00268     else if (error&CE_RXPARITY) {
00269         lastErr=E_RECEIVE_PARITY_ERROR;
00270     }
00271     else if (error&CE_RXOVER) {
00272         lastErr=E_RECEIVE_OVERFLOW;
00273     }
00274     else if (error&CE_TXFULL) {
00275         lastErr=E_TRANSMIT_OVERFLOW;
00276     }
00277 }
00278 
00288 qint64 Win_QextSerialPort::readData(char *data, qint64 maxSize)
00289 {
00290     LOCK_MUTEX();
00291     int retVal=0;
00292     COMSTAT Win_ComStat;
00293     DWORD Win_BytesRead=0;
00294     DWORD Win_ErrorMask=0;
00295     ClearCommError(Win_Handle, &Win_ErrorMask, &Win_ComStat);
00296     if (Win_ComStat.cbInQue &&
00297         (!ReadFile(Win_Handle, (void*)data, (DWORD)maxSize, &Win_BytesRead, NULL)
00298         || Win_BytesRead==0)) {
00299         lastErr=E_READ_FAILED;
00300         retVal=-1;
00301     }
00302     else {
00303         retVal=((int)Win_BytesRead);
00304     }
00305     UNLOCK_MUTEX();
00306 
00307     return retVal;
00308 }
00309 
00319 qint64 Win_QextSerialPort::writeData(const char *data, qint64 maxSize)
00320 {
00321     LOCK_MUTEX();
00322     int retVal=0;
00323     DWORD Win_BytesWritten;
00324     if (!WriteFile(Win_Handle, (void*)data, (DWORD)maxSize, &Win_BytesWritten, NULL)) {
00325         lastErr=E_WRITE_FAILED;
00326         retVal=-1;
00327     }
00328     else {
00329         retVal=((int)Win_BytesWritten);
00330     }
00331     UNLOCK_MUTEX();
00332 
00333     flush();
00334     return retVal;
00335 }
00336 
00343 void Win_QextSerialPort::ungetChar(char c) {
00344 
00345     /*meaningless on unbuffered sequential device - return error and print a warning*/
00346     TTY_WARNING("Win_QextSerialPort: ungetChar() called on an unbuffered sequential device - operation is meaningless");
00347 }
00348 
00358 void Win_QextSerialPort::setFlowControl(FlowType flow) {
00359     LOCK_MUTEX();
00360     if (Settings.FlowControl!=flow) {
00361         Settings.FlowControl=flow;
00362     }
00363     if (isOpen()) {
00364         switch(flow) {
00365 
00366             /*no flow control*/
00367             case FLOW_OFF:
00368                 Win_CommConfig.dcb.fOutxCtsFlow=FALSE;
00369                 Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE;
00370                 Win_CommConfig.dcb.fInX=FALSE;
00371                 Win_CommConfig.dcb.fOutX=FALSE;
00372                 SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00373                 break;
00374 
00375             /*software (XON/XOFF) flow control*/
00376             case FLOW_XONXOFF:
00377                 Win_CommConfig.dcb.fOutxCtsFlow=FALSE;
00378                 Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE;
00379                 Win_CommConfig.dcb.fInX=TRUE;
00380                 Win_CommConfig.dcb.fOutX=TRUE;
00381                 SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00382                 break;
00383 
00384             case FLOW_HARDWARE:
00385                 Win_CommConfig.dcb.fOutxCtsFlow=TRUE;
00386                 Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_HANDSHAKE;
00387                 Win_CommConfig.dcb.fInX=FALSE;
00388                 Win_CommConfig.dcb.fOutX=FALSE;
00389                 SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00390                 break;
00391         }
00392     }
00393     UNLOCK_MUTEX();
00394 }
00395 
00407 void Win_QextSerialPort::setParity(ParityType parity) {
00408     LOCK_MUTEX();
00409     if (Settings.Parity!=parity) {
00410         Settings.Parity=parity;
00411     }
00412     if (isOpen()) {
00413         Win_CommConfig.dcb.Parity=(unsigned char)parity;
00414         switch (parity) {
00415 
00416             /*space parity*/
00417             case PAR_SPACE:
00418                 if (Settings.DataBits==DATA_8) {
00419                     TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: Space parity with 8 data bits is not supported by POSIX systems.");
00420                 }
00421                 Win_CommConfig.dcb.fParity=TRUE;
00422                 break;
00423 
00424             /*mark parity - WINDOWS ONLY*/
00425             case PAR_MARK:
00426                 TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning:  Mark parity is not supported by POSIX systems");
00427                 Win_CommConfig.dcb.fParity=TRUE;
00428                 break;
00429 
00430             /*no parity*/
00431             case PAR_NONE:
00432                 Win_CommConfig.dcb.fParity=FALSE;
00433                 break;
00434 
00435             /*even parity*/
00436             case PAR_EVEN:
00437                 Win_CommConfig.dcb.fParity=TRUE;
00438                 break;
00439 
00440             /*odd parity*/
00441             case PAR_ODD:
00442                 Win_CommConfig.dcb.fParity=TRUE;
00443                 break;
00444         }
00445         SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00446     }
00447     UNLOCK_MUTEX();
00448 }
00449 
00470 void Win_QextSerialPort::setDataBits(DataBitsType dataBits) {
00471     LOCK_MUTEX();
00472     if (Settings.DataBits!=dataBits) {
00473         if ((Settings.StopBits==STOP_2 && dataBits==DATA_5) ||
00474             (Settings.StopBits==STOP_1_5 && dataBits!=DATA_5)) {
00475         }
00476         else {
00477             Settings.DataBits=dataBits;
00478         }
00479     }
00480     if (isOpen()) {
00481         switch(dataBits) {
00482 
00483             /*5 data bits*/
00484             case DATA_5:
00485                 if (Settings.StopBits==STOP_2) {
00486                     TTY_WARNING("Win_QextSerialPort: 5 Data bits cannot be used with 2 stop bits.");
00487                 }
00488                 else {
00489                     Win_CommConfig.dcb.ByteSize=5;
00490                     SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00491                 }
00492                 break;
00493 
00494             /*6 data bits*/
00495             case DATA_6:
00496                 if (Settings.StopBits==STOP_1_5) {
00497                     TTY_WARNING("Win_QextSerialPort: 6 Data bits cannot be used with 1.5 stop bits.");
00498                 }
00499                 else {
00500                     Win_CommConfig.dcb.ByteSize=6;
00501                     SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00502                 }
00503                 break;
00504 
00505             /*7 data bits*/
00506             case DATA_7:
00507                 if (Settings.StopBits==STOP_1_5) {
00508                     TTY_WARNING("Win_QextSerialPort: 7 Data bits cannot be used with 1.5 stop bits.");
00509                 }
00510                 else {
00511                     Win_CommConfig.dcb.ByteSize=7;
00512                     SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00513                 }
00514                 break;
00515 
00516             /*8 data bits*/
00517             case DATA_8:
00518                 if (Settings.StopBits==STOP_1_5) {
00519                     TTY_WARNING("Win_QextSerialPort: 8 Data bits cannot be used with 1.5 stop bits.");
00520                 }
00521                 else {
00522                     Win_CommConfig.dcb.ByteSize=8;
00523                     SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00524                 }
00525                 break;
00526         }
00527     }
00528     UNLOCK_MUTEX();
00529 }
00530 
00549 void Win_QextSerialPort::setStopBits(StopBitsType stopBits) {
00550     LOCK_MUTEX();
00551     if (Settings.StopBits!=stopBits) {
00552         if ((Settings.DataBits==DATA_5 && stopBits==STOP_2) ||
00553             (stopBits==STOP_1_5 && Settings.DataBits!=DATA_5)) {
00554         }
00555         else {
00556             Settings.StopBits=stopBits;
00557         }
00558     }
00559     if (isOpen()) {
00560         switch (stopBits) {
00561 
00562             /*one stop bit*/
00563             case STOP_1:
00564                 Win_CommConfig.dcb.StopBits=ONESTOPBIT;
00565                 SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00566                 break;
00567 
00568             /*1.5 stop bits*/
00569             case STOP_1_5:
00570                 TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: 1.5 stop bit operation is not supported by POSIX.");
00571                 if (Settings.DataBits!=DATA_5) {
00572                     TTY_WARNING("Win_QextSerialPort: 1.5 stop bits can only be used with 5 data bits");
00573                 }
00574                 else {
00575                     Win_CommConfig.dcb.StopBits=ONE5STOPBITS;
00576                     SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00577                 }
00578                 break;
00579 
00580             /*two stop bits*/
00581             case STOP_2:
00582                 if (Settings.DataBits==DATA_5) {
00583                     TTY_WARNING("Win_QextSerialPort: 2 stop bits cannot be used with 5 data bits");
00584                 }
00585                 else {
00586                     Win_CommConfig.dcb.StopBits=TWOSTOPBITS;
00587                     SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00588                 }
00589                 break;
00590         }
00591     }
00592     UNLOCK_MUTEX();
00593 }
00594 
00629 void Win_QextSerialPort::setBaudRate(BaudRateType baudRate) {
00630     LOCK_MUTEX();
00631     if (Settings.BaudRate!=baudRate) {
00632         switch (baudRate) {
00633             case BAUD50:
00634             case BAUD75:
00635             case BAUD134:
00636             case BAUD150:
00637             case BAUD200:
00638                 Settings.BaudRate=BAUD110;
00639                 break;
00640 
00641             case BAUD1800:
00642                 Settings.BaudRate=BAUD1200;
00643                 break;
00644 
00645             case BAUD76800:
00646                 Settings.BaudRate=BAUD57600;
00647                 break;
00648 
00649             default:
00650                 Settings.BaudRate=baudRate;
00651                 break;
00652         }
00653     }
00654     if (isOpen()) {
00655         switch (baudRate) {
00656 
00657             /*50 baud*/
00658             case BAUD50:
00659                 TTY_WARNING("Win_QextSerialPort: Windows does not support 50 baud operation.  Switching to 110 baud.");
00660                 Win_CommConfig.dcb.BaudRate=CBR_110;
00661                 break;
00662 
00663             /*75 baud*/
00664             case BAUD75:
00665                 TTY_WARNING("Win_QextSerialPort: Windows does not support 75 baud operation.  Switching to 110 baud.");
00666                 Win_CommConfig.dcb.BaudRate=CBR_110;
00667                 break;
00668 
00669             /*110 baud*/
00670             case BAUD110:
00671                 Win_CommConfig.dcb.BaudRate=CBR_110;
00672                 break;
00673 
00674             /*134.5 baud*/
00675             case BAUD134:
00676                 TTY_WARNING("Win_QextSerialPort: Windows does not support 134.5 baud operation.  Switching to 110 baud.");
00677                 Win_CommConfig.dcb.BaudRate=CBR_110;
00678                 break;
00679 
00680             /*150 baud*/
00681             case BAUD150:
00682                 TTY_WARNING("Win_QextSerialPort: Windows does not support 150 baud operation.  Switching to 110 baud.");
00683                 Win_CommConfig.dcb.BaudRate=CBR_110;
00684                 break;
00685 
00686             /*200 baud*/
00687             case BAUD200:
00688                 TTY_WARNING("Win_QextSerialPort: Windows does not support 200 baud operation.  Switching to 110 baud.");
00689                 Win_CommConfig.dcb.BaudRate=CBR_110;
00690                 break;
00691 
00692             /*300 baud*/
00693             case BAUD300:
00694                 Win_CommConfig.dcb.BaudRate=CBR_300;
00695                 break;
00696 
00697             /*600 baud*/
00698             case BAUD600:
00699                 Win_CommConfig.dcb.BaudRate=CBR_600;
00700                 break;
00701 
00702             /*1200 baud*/
00703             case BAUD1200:
00704                 Win_CommConfig.dcb.BaudRate=CBR_1200;
00705                 break;
00706 
00707             /*1800 baud*/
00708             case BAUD1800:
00709                 TTY_WARNING("Win_QextSerialPort: Windows does not support 1800 baud operation.  Switching to 1200 baud.");
00710                 Win_CommConfig.dcb.BaudRate=CBR_1200;
00711                 break;
00712 
00713             /*2400 baud*/
00714             case BAUD2400:
00715                 Win_CommConfig.dcb.BaudRate=CBR_2400;
00716                 break;
00717 
00718             /*4800 baud*/
00719             case BAUD4800:
00720                 Win_CommConfig.dcb.BaudRate=CBR_4800;
00721                 break;
00722 
00723             /*9600 baud*/
00724             case BAUD9600:
00725                 Win_CommConfig.dcb.BaudRate=CBR_9600;
00726                 break;
00727 
00728             /*14400 baud*/
00729             case BAUD14400:
00730                 TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 14400 baud operation.");
00731                 Win_CommConfig.dcb.BaudRate=CBR_14400;
00732                 break;
00733 
00734             /*19200 baud*/
00735             case BAUD19200:
00736                 Win_CommConfig.dcb.BaudRate=CBR_19200;
00737                 break;
00738 
00739             /*38400 baud*/
00740             case BAUD38400:
00741                 Win_CommConfig.dcb.BaudRate=CBR_38400;
00742                 break;
00743 
00744             /*56000 baud*/
00745             case BAUD56000:
00746                 TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 56000 baud operation.");
00747                 Win_CommConfig.dcb.BaudRate=CBR_56000;
00748                 break;
00749 
00750             /*57600 baud*/
00751             case BAUD57600:
00752                 Win_CommConfig.dcb.BaudRate=CBR_57600;
00753                 break;
00754 
00755             /*76800 baud*/
00756             case BAUD76800:
00757                 TTY_WARNING("Win_QextSerialPort: Windows does not support 76800 baud operation.  Switching to 57600 baud.");
00758                 Win_CommConfig.dcb.BaudRate=CBR_57600;
00759                 break;
00760 
00761             /*115200 baud*/
00762             case BAUD115200:
00763                 Win_CommConfig.dcb.BaudRate=CBR_115200;
00764                 break;
00765 
00766             /*128000 baud*/
00767             case BAUD128000:
00768                 TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 128000 baud operation.");
00769                 Win_CommConfig.dcb.BaudRate=CBR_128000;
00770                 break;
00771 
00772             /*256000 baud*/
00773             case BAUD256000:
00774                 TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 256000 baud operation.");
00775                 Win_CommConfig.dcb.BaudRate=CBR_256000;
00776                 break;
00777         }
00778         SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
00779     }
00780     UNLOCK_MUTEX();
00781 }
00782 
00788 void Win_QextSerialPort::setDtr(bool set) {
00789     LOCK_MUTEX();
00790     if (isOpen()) {
00791         if (set) {
00792             EscapeCommFunction(Win_Handle, SETDTR);
00793         }
00794         else {
00795             EscapeCommFunction(Win_Handle, CLRDTR);
00796         }
00797     }
00798     UNLOCK_MUTEX();
00799 }
00800 
00806 void Win_QextSerialPort::setRts(bool set) {
00807     LOCK_MUTEX();
00808     if (isOpen()) {
00809         if (set) {
00810             EscapeCommFunction(Win_Handle, SETRTS);
00811         }
00812         else {
00813             EscapeCommFunction(Win_Handle, CLRRTS);
00814         }
00815     }
00816     UNLOCK_MUTEX();
00817 }
00818 
00838 ulong Win_QextSerialPort::lineStatus(void) {
00839     unsigned long Status=0, Temp=0;
00840     LOCK_MUTEX();
00841     if (isOpen()) {
00842         GetCommModemStatus(Win_Handle, &Temp);
00843         if (Temp&MS_CTS_ON) {
00844             Status|=LS_CTS;
00845         }
00846         if (Temp&MS_DSR_ON) {
00847             Status|=LS_DSR;
00848         }
00849         if (Temp&MS_RING_ON) {
00850             Status|=LS_RI;
00851         }
00852         if (Temp&MS_RLSD_ON) {
00853             Status|=LS_DCD;
00854         }
00855     }
00856     UNLOCK_MUTEX();
00857     return Status;
00858 }
00859 
00864 void Win_QextSerialPort::setTimeout(ulong sec, ulong millisec) {
00865     LOCK_MUTEX();
00866     Settings.Timeout_Sec=sec;
00867     Settings.Timeout_Millisec=millisec;
00868     if(isOpen()) {
00869         Win_CommTimeouts.ReadIntervalTimeout = sec*1000+millisec;
00870         Win_CommTimeouts.ReadTotalTimeoutMultiplier = sec*1000+millisec;
00871         Win_CommTimeouts.ReadTotalTimeoutConstant = 0;
00872         Win_CommTimeouts.WriteTotalTimeoutMultiplier = sec*1000+millisec;
00873         Win_CommTimeouts.WriteTotalTimeoutConstant = 0;
00874         SetCommTimeouts(Win_Handle, &Win_CommTimeouts);
00875     }
00876     UNLOCK_MUTEX();
00877 }
 All Classes Files Functions Variables Defines