int RCX_open(int type, char *portname){ //Opens the connections to the RCX via tower on serial or usb port. //type 1: serial port, type 2: USB port //portname for serial port is "COM1" for example //portname for USB port is "\\\\.\\LEGOTOWER1" for example //returns 0 if failed, 1 if successful if (type==1){//open serial port RCX_port = CreateFileA("COM6", GENERIC_READ | GENERIC_WRITE, 0, 0, CREATE_NEW, FILE_FLAG_WRITE_THROUGH, 0); if (RCX_port == INVALID_HANDLE_VALUE) return(0); //set data protocol format GetCommState(RCX_port,&dcb); FillMemory(&dcb, sizeof(dcb), 0); dcb.DCBlength = sizeof(dcb); dcb.BaudRate=CBR_2400; dcb.fBinary=1; dcb.fParity=1; dcb.fDtrControl=DTR_CONTROL_ENABLE; dcb.fRtsControl=RTS_CONTROL_ENABLE; dcb.ByteSize=8; dcb.Parity=ODDPARITY; dcb.StopBits=ONESTOPBIT; if (!SetCommState(RCX_port, &dcb)){ RCX_close(); return(0); } GetCommTimeouts(RCX_port,&tout); tout.ReadIntervalTimeout=250; tout.ReadTotalTimeoutConstant=10; tout.ReadTotalTimeoutMultiplier=10; tout.WriteTotalTimeoutConstant=10; tout.WriteTotalTimeoutMultiplier=10; SetCommTimeouts(RCX_port,&tout); SetupComm(RCX_port,65536,65536); } else { //type 2: open USB port RCX_port = CreateFileA(portname, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING, 0); if (RCX_port == INVALID_HANDLE_VALUE) return(0); GetCommTimeouts(RCX_port,&tout); tout.ReadIntervalTimeout=250; tout.ReadTotalTimeoutConstant=10; tout.ReadTotalTimeoutMultiplier=10; tout.WriteTotalTimeoutConstant=10; tout.WriteTotalTimeoutMultiplier=10; SetCommTimeouts(RCX_port,&tout); } return(1); }
int SerialPortImpl::pollImpl(char* buffer, std::size_t size, const Poco::Timespan& timeout) { COMMTIMEOUTS prevCTO; if (!GetCommTimeouts(_handle, &prevCTO)) { throw Poco::IOException("error getting serial port timeouts"); } COMMTIMEOUTS cto; cto.ReadIntervalTimeout = CHARACTER_TIMEOUT; cto.ReadTotalTimeoutConstant = static_cast<DWORD>(timeout.totalMilliseconds()); cto.ReadTotalTimeoutMultiplier = 0; cto.WriteTotalTimeoutConstant = MAXDWORD; cto.WriteTotalTimeoutMultiplier = 0; if (!SetCommTimeouts(_handle, &cto)) { throw Poco::IOException("error setting serial port timeouts on serial port"); } try { DWORD bytesRead = 0; if (!ReadFile(_handle, buffer, size, &bytesRead, NULL)) { throw Poco::IOException("failed to read from serial port"); } SetCommTimeouts(_handle, &prevCTO); return (bytesRead == 0) ? -1 : bytesRead; } catch (...) { SetCommTimeouts(_handle, &prevCTO); throw; } }
/** * @brief This function initializes the serial port for both directions (reading/writing) with fixed parameters: * \n baud=38400, parity=N, data=8, stop=1 * @param *serialPort is a pointer to the name of the serial port * @return TRUE if success, FALSE in case of error. */ BOOL initSerial(CHAR *serialPort) { COMMTIMEOUTS timeouts; int rc; DCB dcbStruct; CHAR msgTextBuf[256]; // open the comm port. comPort = CreateFile(serialPort, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, NULL); if (comPort == INVALID_HANDLE_VALUE) { printf("Unable to open %s. \n", serialPort); return FALSE; } // get the current DCB, and adjust a few bits to our liking. memset(&dcbStruct, 0, sizeof(dcbStruct)); dcbStruct.DCBlength = sizeof(dcbStruct); // printf("dcbStruct.DCBlength(): %ld \n", dcbStruct.DCBlength); rc = GetCommState(comPort, &dcbStruct); if (rc == 0) { printf("\nGetCommState(): "); printf(getLastErrorText(msgTextBuf, sizeof(msgTextBuf))); return FALSE; } // http://msdn.microsoft.com/en-us/library/windows/desktop/aa363143(v=vs.85).aspx BuildCommDCB("baud=38400 parity=N data=8 stop=1", &dcbStruct); rc = SetCommState(comPort, &dcbStruct); // If the function fails, the return value is zero. if (rc == 0) { printf("\nSetCommState(): "); printf(getLastErrorText(msgTextBuf, sizeof(msgTextBuf))); return FALSE; } // Retrieve the timeout parameters for all read and write operations on the port. GetCommTimeouts (comPort, &timeouts); timeouts.ReadIntervalTimeout = 250; timeouts.ReadTotalTimeoutMultiplier = 1; timeouts.ReadTotalTimeoutConstant = 500; timeouts.WriteTotalTimeoutMultiplier = 1; timeouts.WriteTotalTimeoutConstant = 2500; rc = SetCommTimeouts(comPort, &timeouts); // If the function fails, the return value is zero. if (rc == 0) { printf("\nSetCommTimeouts(): "); printf(getLastErrorText(msgTextBuf, sizeof(msgTextBuf))); return FALSE; } return TRUE; }
int serialGetC(HANDLE fd, uint8_t* c, int timeout) { COMMTIMEOUTS timeouts; unsigned long res; COMSTAT comStat; DWORD errors; if(!ClearCommError(fd, &errors, &comStat)) { printErr("could not reset comm errors", GetLastError()); return -1; } if(!GetCommTimeouts(fd, &timeouts)) { printErr("error getting comm timeouts", GetLastError()); return -1; } timeouts.ReadIntervalTimeout = timeout; timeouts.ReadTotalTimeoutConstant = timeout; timeouts.ReadTotalTimeoutMultiplier = 10; if(!SetCommTimeouts(fd, &timeouts)) { printErr("error setting comm timeouts", GetLastError()); return -1; } if(!ReadFile(fd, c, 1, &res, NULL)) { printErr("error reading from serial port", GetLastError()); return -1; } if(res != 1) return -1; return *c; }
/** open a serial port */ static HANDLE openPort(const char *port,int baud) { HANDLE h; DCB dcb; COMMTIMEOUTS tmo; int status; /* open the port */ h = CreateFile( port, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0); if (h == INVALID_HANDLE_VALUE) { /* quit on error */ return h; } /* read current configuration */ status = GetCommState(h,&dcb); if (status == 0) { CloseHandle(h); return INVALID_HANDLE_VALUE; } /* set the baud rate and other parameters */ dcb.BaudRate = baud; dcb.ByteSize = 8; dcb.Parity = NOPARITY; dcb.StopBits = ONESTOPBIT; /* set configuration */ status = SetCommState(h, &dcb); if (status == 0) { CloseHandle(h); return INVALID_HANDLE_VALUE; } /* read timeout configuration */ status = GetCommTimeouts(h,&tmo); if (status == 0) { CloseHandle(h); return INVALID_HANDLE_VALUE; } /* set to indefinite blocking */ tmo.ReadIntervalTimeout = 0; tmo.ReadTotalTimeoutConstant = 0; tmo.ReadTotalTimeoutMultiplier = 0; status = SetCommTimeouts(h,&tmo); if (status == 0) { CloseHandle(h); return INVALID_HANDLE_VALUE; } return h; }
virtual bool setTimeout (int iTotalReadTimeout) { if (INVALID_HANDLE_VALUE == hComm) return (TRUE); if (!GetCommTimeouts(this->hComm, &timeouts_alt)) { this->close (); MessageBox (NULL, "could not open comport!\nGetCommTimeouts()", NULL, NULL); return (FALSE); } COMMTIMEOUTS timeouts; timeouts.ReadIntervalTimeout = MAXDWORD ; timeouts.ReadTotalTimeoutMultiplier = MAXDWORD ; timeouts.ReadTotalTimeoutConstant = (DWORD) iTotalReadTimeout; timeouts.WriteTotalTimeoutMultiplier = 1000; timeouts.WriteTotalTimeoutConstant = 1000; if (!SetCommTimeouts(hComm, &timeouts)) return (FALSE); return(TRUE); }
/**************************************************************************** * DESCRIPTION: Initializes the RS485 hardware and variables, and starts in * receive mode. * RETURN: none * ALGORITHM: none * NOTES: none *****************************************************************************/ void RS485_Initialize( void) { RS485_Handle = CreateFile(RS485_Port_Name, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, /*FILE_FLAG_OVERLAPPED */ 0, 0); if (RS485_Handle == INVALID_HANDLE_VALUE) { fprintf(stderr, "Unable to open %s\n", RS485_Port_Name); RS485_Print_Error(); exit(1); } if (!GetCommTimeouts(RS485_Handle, &RS485_Timeouts)) { RS485_Print_Error(); } RS485_Configure_Status(); #if PRINT_ENABLED fprintf(stderr, "RS485 Interface: %s\n", RS485_Port_Name); #endif atexit(RS485_Cleanup); return; }
HANDLE IO::openComm() { h = CreateFile(TEXT("COM3"), FILE_SHARE_READ | FILE_SHARE_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0); if (INVALID_HANDLE_VALUE == h) { int err = GetLastError(); return h; } COMMTIMEOUTS timeouts; GetCommTimeouts(h, &timeouts); timeouts.ReadIntervalTimeout = 0; timeouts.ReadTotalTimeoutMultiplier = 0; timeouts.ReadTotalTimeoutConstant = 0; timeouts.WriteTotalTimeoutMultiplier = 0; timeouts.WriteTotalTimeoutConstant = 0; SetCommTimeouts(h, &timeouts); //设置串口配置信息 DCB dcb; if (!GetCommState(h, &dcb)) { cout << "GetCommState() failed" << endl; CloseHandle(h); return INVALID_HANDLE_VALUE; } int nBaud = 57600; dcb.DCBlength = sizeof(DCB); dcb.BaudRate = nBaud;//波特率为9600 dcb.Parity = 0;//校验方式为无校验 dcb.ByteSize = 8;//数据位为8位 dcb.StopBits = ONESTOPBIT;//停止位为1位 if (!SetCommState(h, &dcb)) { cout << "SetCommState() failed" << endl; CloseHandle(h); return INVALID_HANDLE_VALUE; } //设置读写缓冲区大小 static const int g_nZhenMax = 16;//32768; if (!SetupComm(h, g_nZhenMax, g_nZhenMax)) { cout << "SetupComm() failed" << endl; CloseHandle(h); return INVALID_HANDLE_VALUE; } //清空缓冲 PurgeComm(h, PURGE_RXCLEAR | PURGE_TXCLEAR); //清除错误 DWORD dwError; COMSTAT cs; if (!ClearCommError(h, &dwError, &cs)) { cout << "ClearCommError() failed" << endl; CloseHandle(h); return INVALID_HANDLE_VALUE; } return h; }
bool CSerialLine::SetMultiplierTimeOuts( unsigned int aReadTimeOut, unsigned int aWriteTimeOut )const { TRACE_FUN( Routine, "CSerialLine::SetMultiplyTimeOuts" ); bool ret( false ); if( isOpen() ) { #ifdef __WIN32__ COMMTIMEOUTS commTimeOuts; if( GetCommTimeouts( _hFile, &commTimeOuts ) ) { TraceRoutine << "commTimeOuts.ReadTotalTimeoutMultiplier: " << commTimeOuts.ReadTotalTimeoutMultiplier << std::endl; TraceRoutine << "commTimeOuts.WriteTotalTimeoutMultiplier: " << commTimeOuts.WriteTotalTimeoutMultiplier << std::endl; commTimeOuts.ReadTotalTimeoutMultiplier = aReadTimeOut; commTimeOuts.WriteTotalTimeoutMultiplier = aWriteTimeOut; ret = SetCommTimeouts( _hFile, &commTimeOuts ); } #endif } return ret; }
// configure serial port bool sconfig(char* fmt) { DCB dcb; COMMTIMEOUTS cmt; // clear dcb memset(&dcb,0,sizeof(DCB)); dcb.DCBlength=sizeof(DCB); // configure serial parameters if(!BuildCommDCB(fmt,&dcb)) return false; dcb.fOutxCtsFlow=0; dcb.fOutxDsrFlow=0; dcb.fDtrControl=0; dcb.fOutX=0; dcb.fInX=0; dcb.fRtsControl=0; if(!SetCommState(h_serial,&dcb)) return false; // configure buffers if(!SetupComm(h_serial,1024,1024)) return false; // configure timeouts GetCommTimeouts(h_serial,&cmt); memcpy(&restore,&cmt,sizeof(cmt)); cmt.ReadIntervalTimeout=100; cmt.ReadTotalTimeoutMultiplier=100; cmt.ReadTotalTimeoutConstant=100; cmt.WriteTotalTimeoutConstant=100; cmt.WriteTotalTimeoutMultiplier=100; if(!SetCommTimeouts(h_serial,&cmt)) return false; return true; }
/************************************************************************** * -Name: win_InitSerial ( port, settings ) * * -Description: This routine initializes the communications port. * * -Arguments: GIZ_PORT porttoopen - communications port to be used * GIZ_PORT_COM1 - for communications port 1 * GIZ_PORT_COM2 - for communications port 2 * short portsettings - communications port parameters * modes are OR'd together to achieve comm port settings. * Default: GIZBAUD_9600 | GIZNONE | GIZONESTOPBIT | GIZEIGHTBITS. * * baud rates : GIZBAUD_300, GIZBAUD_600, GIZBAUD_1200, * GIZBAUD_2400, GIZBAUD_4800, GIZBAUD_9600 * * -Notes: Gizzmo must have comm port settings of no parity (GIZNONE), * 1 stop bit (GIZONESTOPBITS), and 8 data bits (GIZEIGHTBITS). * The baud rate is the only settings that can currently * be varied. To do this, please review the programmers' * guide on changing the baud rate. * * -Returns : 0 if comm port setup okay *************************************************************************/ long win_InitSerial ( int port ) { long err; DWORD start,current; char aBuf[16]; DWORD bytesRead; if((err = setup_dcb( (GIZ_PORT)(port-1), 0, (short)LINES_LOW))!=0) return err; SISetLinesLow(); while ((current-start) < PowerOnTimeDelay) current = GetTickCount(); // PowerOnTime delay before launch to let calibrator wake up and stabilize /* create timeout data structure */ GetCommTimeouts(PortID,&TimeOutData); TimeOutData.ReadIntervalTimeout = 2500;// millisecs between characters TimeOutData.ReadTotalTimeoutMultiplier = 250; // millisec multiplier by number of characters TimeOutData.ReadTotalTimeoutConstant = 2500; // 2.5 sec + nchar * 250 msec total time out(about 3secs); TimeOutData.WriteTotalTimeoutMultiplier = 250; TimeOutData.WriteTotalTimeoutConstant = 250; SetCommTimeouts(PortID,&TimeOutData); start = GetTickCount(); current = GetTickCount(); SISetLinesHigh(); while ((current-start) < PowerOnTimeDelay) current = GetTickCount(); // PowerOnTime delay before launch to let calibrator wake up and stabilize ReadFile( PortID, // handle of file to read aBuf, // address of buffer that receives data 1, // number of bytes to read: the count byte and the command byte &bytesRead, // address of number of bytes read NULL // address of structure for data ); return (err); }
ComPort::ComPort(wchar_t *portName, unsigned int baund) { hCOM = CreateFileW(portName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); if(hCOM == INVALID_HANDLE_VALUE) throw std::runtime_error ("Unable to open port "); DCB dcb={0}; COMMTIMEOUTS CommTimeouts; dcb.DCBlength = sizeof(DCB); GetCommState(hCOM, &dcb); dcb.BaudRate = CBR_115200; dcb.ByteSize = 8; dcb.Parity = NOPARITY; dcb.StopBits = ONESTOPBIT; SetCommState(hCOM, &dcb); GetCommTimeouts(hCOM,&CommTimeouts); CommTimeouts.ReadIntervalTimeout = 100; CommTimeouts.ReadTotalTimeoutMultiplier = 1; CommTimeouts.ReadTotalTimeoutConstant = 100; CommTimeouts.WriteTotalTimeoutMultiplier = 0; CommTimeouts.WriteTotalTimeoutConstant = 0; SetCommTimeouts(hCOM,&CommTimeouts); FlushFileBuffers(hCOM); DWORD Errors; COMSTAT ComState; ClearCommError(hCOM, &Errors, &ComState); }
//--------------------------------------------------------------------------- void __fastcall TCommThread::Open() { if(Connected==false) { //Open device DeviceHandle=CreateFile( DeviceName.c_str(), GENERIC_READ|GENERIC_WRITE, FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_TEMPORARY|FILE_FLAG_DELETE_ON_CLOSE, NULL ); if(DeviceHandle!=INVALID_HANDLE_VALUE) { //Make backup and set DCB of open device GetCommState(DeviceHandle,&OriginalDCB); SetCommState(DeviceHandle,&MyDCB); //Make backup and set COMMTIMEOUTS of open device GetCommTimeouts(DeviceHandle,&OriginalTimeouts); SetCommTimeouts(DeviceHandle,&MyTimeouts); SetupComm(DeviceHandle,1024*ReceiveQueue,1024*TransmitQueue); //Resume Thread if(this->Suspended) Resume(); Connected=true; }//if }//if }
static SERIALPORT *serial_open(const char *device){ HANDLE fh; DCB dcb={sizeof(DCB)}; COMMTIMEOUTS timeouts; SERIALPORT *port; fh = CreateFile(device,GENERIC_READ|GENERIC_WRITE,0,NULL, OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL); if (!fh) return NULL; port = malloc(sizeof(SERIALPORT)); ZeroMemory(port, sizeof(SERIALPORT)); port->fh = fh; /* save current port settings */ GetCommState(fh,&port->dcb_save); GetCommTimeouts(fh,&port->timeouts_save); dcb.DCBlength=sizeof(DCB); BuildCommDCB("96,n,8,1",&dcb); SetCommState(fh,&dcb); ZeroMemory(&timeouts,sizeof(timeouts)); timeouts.ReadTotalTimeoutConstant=1; timeouts.WriteTotalTimeoutConstant=1; SetCommTimeouts(fh,&timeouts); serial_flush(port); return port; }
BOOL CPSerialPort::OpenPort(LPCTSTR Port,int BaudRate,int StopBits,int Parity,int DataBits,LPDataArriveProc proc,DWORD userdata) { m_lpDataArriveProc=proc; m_dwUserData=userdata; if(m_hComm==INVALID_HANDLE_VALUE) { m_hComm=CreateFile(Port,GENERIC_READ|GENERIC_WRITE,0,0,OPEN_EXISTING,0,0); if(m_hComm==INVALID_HANDLE_VALUE ) { // AfxMessageBox(_T("ERROR 104:无法打开端口!请检查是否已被占用。")); return FALSE; } GetCommState(m_hComm,&dcb); dcb.BaudRate=BaudRate; dcb.ByteSize=DataBits; dcb.Parity=Parity; dcb.StopBits=StopBits; dcb.fParity=FALSE; dcb.fBinary=TRUE; dcb.fDtrControl=0; dcb.fRtsControl=0; dcb.fOutX=dcb.fInX=dcb.fTXContinueOnXoff=0; //设置状态参数 SetCommMask(m_hComm,EV_RXCHAR); SetupComm(m_hComm,1024,1024); if(!SetCommState(m_hComm,&dcb)) { AfxMessageBox(_T("ERROR 105:无法按当前参数配置端口,请检查参数!")); PurgeComm(m_hComm,PURGE_TXCLEAR|PURGE_RXCLEAR); ClosePort(); return FALSE; } //设置超时参数 GetCommTimeouts(m_hComm,&CommTimeOuts); CommTimeOuts.ReadIntervalTimeout=100; CommTimeOuts.ReadTotalTimeoutMultiplier=1; CommTimeOuts.ReadTotalTimeoutConstant=100; CommTimeOuts.WriteTotalTimeoutMultiplier=1; CommTimeOuts.WriteTotalTimeoutConstant=100; if(!SetCommTimeouts(m_hComm,&CommTimeOuts)) { AfxMessageBox(_T("ERROR 106:无法设置超时参数!")); PurgeComm(m_hComm,PURGE_TXCLEAR|PURGE_RXCLEAR); ClosePort(); return FALSE; } PurgeComm(m_hComm,PURGE_TXCLEAR|PURGE_RXCLEAR); Activate(); return TRUE; } return TRUE; }
//------------------------------------------------------------------------- // Initialize TRK connection over a serial port. // Returns success. bool metrotrk_t::init(int port) { sseq = 0; if ( port == DEBUGGER_PORT_NUMBER ) { int p = find_smartphone_port(); if ( p > 0 ) { port = p; msg("Using COM%d: to communicate with the smartphone...\n", port); } else { warning("Could not autodetect the smartphone port.\n" "Please specify it manually in the process options"); } } char name[32]; qsnprintf(name, sizeof(name), "\\\\.\\COM%d", port); qstring friendly_name; if ( !is_serial_port_present(port, &friendly_name) ) { if ( askyn_c(0, "HIDECANCEL\n" "Serial port COM%d seems to be unavailable. Do you want to proceed?", port ) <= 0 ) { SetLastError(ERROR_DEVICE_NOT_CONNECTED); return false; } } msg("Opening serial port %s: (%s)...\n", &name[4], friendly_name.c_str()); // port exists, open it hp = CreateFile(name, GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0); if ( hp == INVALID_HANDLE_VALUE ) return false; DCB dcb; memset(&dcb, 0, sizeof(dcb)); dcb.DCBlength = sizeof(dcb); dcb.BaudRate = CBR_115200; dcb.fBinary = true; dcb.ByteSize = 8; dcb.Parity = NOPARITY; dcb.StopBits = ONESTOPBIT; if ( !SetCommState(hp, &dcb) ) { CloseHandle(hp); return false; } GetCommTimeouts(hp, &ct); return true; }
void CSerialPort::GetTimeouts(COMMTIMEOUTS& timeouts) { ASSERT(IsOpen()); if (!GetCommTimeouts(m_hComm, &timeouts)) { TRACE(_T("Failed in call to GetCommTimeouts\n")); AfxThrowSerialException(); } }
vpr::Uint32 SerialPortImplWin32::read_i(void* buffer, const vpr::Uint32 length, const vpr::Interval& timeout) { unsigned long bytes; // Shouldn't be setting this every read, but don't have any other way of // specifying the timeout. if ( vpr::Interval::NoTimeout != timeout ) { COMMTIMEOUTS t; GetCommTimeouts(mHandle, &t); t.ReadTotalTimeoutConstant = (int)timeout.msec(); SetCommTimeouts(mHandle, &t); } if ( ! ReadFile(mHandle, buffer, length, &bytes, NULL) ) { std::stringstream msg_stream; msg_stream << "Failed to read from serial port " << mName << ": " << getErrorMessageWithCode(GetLastError()); throw IOException(msg_stream.str(), VPR_LOCATION); } //Now set the timeout back if ( vpr::Interval::NoTimeout != timeout ) { COMMTIMEOUTS t; GetCommTimeouts(mHandle, &t); t.ReadTotalTimeoutConstant = (int)mCurrentTimeout*100; SetCommTimeouts(mHandle, &t); } // XXX: Does reading 0 bytes really indicate a timeout? if ( bytes == 0 ) { std::stringstream msg_stream; msg_stream << "Timeout while attempting to read from serial port " << mName; throw TimeoutException(msg_stream.str(), VPR_LOCATION); } return bytes; }
static void set_timeout(urg_serial_t *serial, int timeout) { COMMTIMEOUTS timeouts; GetCommTimeouts(serial->hCom, &timeouts); timeouts.ReadIntervalTimeout = (timeout == 0) ? MAXDWORD : 0; timeouts.ReadTotalTimeoutConstant = timeout; timeouts.ReadTotalTimeoutMultiplier = 0; SetCommTimeouts(serial->hCom, &timeouts); }
/*----------------------------------------------------------------------------*/ int serial_read(int fd, void *buffer, unsigned size, unsigned timeout) { HANDLE h; COMMTIMEOUTS ct; int received = 0; h = get_h(fd); if(!h) return 0; if(!GetCommTimeouts(h,&ct)) { err_trace(__FILE__, __LINE__); return 0; } ct.ReadIntervalTimeout = MAXDWORD; ct.ReadTotalTimeoutMultiplier = MAXDWORD; ct.ReadTotalTimeoutConstant = timeout; if(!SetCommTimeouts(h,&ct)) { err_trace(__FILE__, __LINE__); return 0; } if(!ReadFile(h, buffer, size, (DWORD *)&received, NULL)) { DWORD Err; err_trace(__FILE__, __LINE__); ClearCommBreak(h); ClearCommError(h, &Err, NULL); return 0; } #ifdef DEBUG if(!received) { // err_trace(__FILE__, __LINE__); // TRACE("%s:%d: Timeout reached. Timeout: %u\n", __FILE__, __LINE__, timeout ); } else { int i; fprintf(stderr, "rx: "); for(i = 0; i < received; i++) fprintf(stderr, "%02x ", (unsigned)((char *)buffer)[i] & 0xff); fprintf(stderr, "\n"); } #endif return received; }
BOOL CECGDlg::OpenPort(LPCTSTR Port, int BaudRate, int DataBits, int Parity, int StopBits, HANDLE &hComm) { DCB dcb; BOOL ret; COMMTIMEOUTS CommTimeOuts; hComm = CreateFile(Port, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0); if(hComm == INVALID_HANDLE_VALUE) { UpdateStatus(L"Unable to open the serial port or the serial port has already been opened! Please check if the port is already in use", ADDSTR2STATUS); return FALSE; } dcb.DCBlength = sizeof (dcb); ret = GetCommState(hComm, &dcb); if( !ret) { UpdateStatus(L"Unable to get Comm. State", ADDSTR2STATUS); ClosePort(hComm); return FALSE; } dcb.BaudRate = BaudRate; dcb.fParity = FALSE; // Parity check disabled dcb.fNull = FALSE; dcb.ByteSize = DataBits; dcb.Parity = Parity; dcb.StopBits = StopBits; ret = SetCommState(hComm, &dcb); if( !ret ) { UpdateStatus(L"Unable to configure serial port. Please check the port configuration! Serial port is closed", ADDSTR2STATUS); ClosePort(hComm); return FALSE; } GetCommTimeouts(hComm, &CommTimeOuts); CommTimeOuts.ReadIntervalTimeout = 100; // Max text receiving interval CommTimeOuts.ReadTotalTimeoutMultiplier = 1; CommTimeOuts.ReadTotalTimeoutConstant = 100; // Number of timeouts for reading data CommTimeOuts.WriteTotalTimeoutMultiplier = 0; CommTimeOuts.WriteTotalTimeoutConstant = 0; ret = SetCommTimeouts(hComm, &CommTimeOuts); if ( !ret ) { UpdateStatus(L"Unable to set timeout parameter! Serial port is closed!", ADDSTR2STATUS); ClosePort(hComm); return FALSE; } PurgeComm(hComm, PURGE_TXCLEAR | PURGE_RXCLEAR); return TRUE; }
bool Serial::Open() { if (_file) return false; std::wstring path = L"\\\\.\\"; path += GetPortName(); HANDLE file = CreateFile(path.c_str(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, 0, nullptr); if (!file || file == INVALID_HANDLE_VALUE) { AfxMessageBox(L"CreateFile failed"); return false; } DCB dcb; ::memset(&dcb, 0, sizeof dcb); dcb.fBinary = true; dcb.BaudRate = UsbSpeed; dcb.ByteSize = 8; if (!SetCommState(file, &dcb)) { AfxMessageBox(L"SetCommState failed"); return false; } COMMTIMEOUTS timeouts; if (!GetCommTimeouts(file, &timeouts)) { AfxMessageBox(L"GetCommTimeouts failed"); return false; } //timeouts.ReadIntervalTimeout = 5; //timeouts.ReadTotalTimeoutConstant = 5; //timeouts.ReadTotalTimeoutMultiplier = 10; timeouts.ReadIntervalTimeout = 1; timeouts.ReadTotalTimeoutConstant = 1; timeouts.ReadTotalTimeoutMultiplier = 1; if (!SetCommTimeouts(file, &timeouts)) { AfxMessageBox(L"SetCommTimeouts failed"); return false; } _file = file; _abort = false; _thread = std::thread(&Serial::Go, this); return true; }
DWORD __stdcall ConfigSerialPort(HANDLE h, DWORD dwBaudRate, DWORD dwTimeOutInSec) { if (!SetupComm(h, 1024, 1024)) { return ::GetLastError(); } DCB dcbConfig; if (GetCommState(h, &dcbConfig)) /* Configuring Serial Port Settings */ { dcbConfig.BaudRate = dwBaudRate; dcbConfig.ByteSize = 8; dcbConfig.Parity = NOPARITY; dcbConfig.StopBits = ONESTOPBIT; dcbConfig.fBinary = TRUE; dcbConfig.fParity = TRUE; } else { return ::GetLastError(); } if (!SetCommState(h, &dcbConfig)) { return ::GetLastError(); } COMMTIMEOUTS commTimeout; if (GetCommTimeouts(h, &commTimeout)) /* Configuring Read & Write Time Outs */ { commTimeout.ReadIntervalTimeout = 1000 * dwTimeOutInSec; commTimeout.ReadTotalTimeoutConstant = 1000 * dwTimeOutInSec; commTimeout.ReadTotalTimeoutMultiplier = 0; commTimeout.WriteTotalTimeoutConstant = 1000 * dwTimeOutInSec; commTimeout.WriteTotalTimeoutMultiplier = 0; } else { return ::GetLastError(); } if (SetCommTimeouts(h, &commTimeout)) { return ERROR_SUCCESS; } else { return ::GetLastError(); } }
/* device control settings */ unsigned int term_set_control ( unsigned int baud, unsigned char databits, unsigned char stopbits, unsigned char parity, unsigned char handshake ) { /* todo: - error checking - handshake - parity - stopbits - let the user configure timeouts ? */ COMMCONFIG lpCC; COMMTIMEOUTS timeouts; if ( !hCom ) { printf ( "%s: COM port was not open!\n", __FUNCTION__ ); return RXE_FAIL; } GetCommTimeouts ( hCom, &timeouts ); // TODO timeouts.ReadIntervalTimeout = 1; timeouts.ReadTotalTimeoutMultiplier = 0; timeouts.ReadTotalTimeoutConstant = 10; timeouts.WriteTotalTimeoutMultiplier = 0; timeouts.WriteTotalTimeoutConstant = 10; if ( !SetCommTimeouts ( hCom, &timeouts ) ) { printf ( "%s: setting timeouts didn't work!\n", __FUNCTION__ ); return RXE_FAIL; } GetCommState ( hCom, &lpCC.dcb ); lpCC.dcb.BaudRate = baud ? baud: CBR_115200; lpCC.dcb.ByteSize = databits; lpCC.dcb.StopBits = ONESTOPBIT; lpCC.dcb.Parity = NOPARITY; lpCC.dcb.fDtrControl = DTR_CONTROL_DISABLE; lpCC.dcb.fRtsControl = RTS_CONTROL_DISABLE; SetCommState ( hCom, &lpCC.dcb ); return RXE_OK; }
// Set Rx Timeout in ms // Timeout: Rx receive timeout in ms // return: last set Rx timeout or -1 on error int ComPort::SetRxTimeout(int Timeout) { COMMTIMEOUTS CommTimeouts; int result; DWORD dwError; if (hPort == INVALID_HANDLE_VALUE) return -1; GetCommTimeouts(hPort, &CommTimeouts); result = CommTimeouts.ReadTotalTimeoutConstant; // Change the COMMTIMEOUTS structure settings. CommTimeouts.ReadIntervalTimeout = MAXDWORD; // JMW 20070515 if (Timeout == 0) { // no total timeouts used CommTimeouts.ReadTotalTimeoutMultiplier = 0; CommTimeouts.ReadTotalTimeoutConstant = 0; } else { // only total timeout used CommTimeouts.ReadTotalTimeoutMultiplier = MAXDWORD; CommTimeouts.ReadTotalTimeoutConstant = Timeout; } CommTimeouts.WriteTotalTimeoutMultiplier = 10; CommTimeouts.WriteTotalTimeoutConstant = 1000; // Set the time-out parameters // for all read and write // operations on the port. if (!SetCommTimeouts(hPort, &CommTimeouts)) { // Could not create the read thread. CloseHandle(hPort); hPort = INVALID_HANDLE_VALUE; #if (WINDOWSPC>0) || NEWCOMM // 091206 Sleep(2000); // needed for windows bug #endif ComPort_StatusMessage(MB_OK, TEXT("Error"), TEXT("%s %s"), // LKTOKEN _@M760_ = "Unable to Set Serial Port Timers" gettext(TEXT("_@M760_")), sPortName); dwError = GetLastError(); return -1; } return result; }
EXPORT int serial_comm_set_settings(void *handle, SERIAL_COM_SETTINGS * settings) { BOOL port_ready; DCB comm_state; COMMTIMEOUTS timeouts; if(handle == NULL) return RESULT_FAILURE; port_ready = SetupComm(handle, settings->InputBufferSize, settings->OutputBufferSize); if(!port_ready) return RESULT_FAILURE; port_ready = GetCommState(handle, &comm_state); if(!port_ready) return RESULT_FAILURE; comm_state.BaudRate = settings->Baud; comm_state.ByteSize = settings->ByteSize; comm_state.Parity = settings->Parity; comm_state.StopBits = settings->StopBits; comm_state.fAbortOnError = settings->AbortOnError; port_ready = SetCommState(handle, &comm_state); if(!port_ready) return RESULT_FAILURE; port_ready = GetCommTimeouts (handle, &timeouts); if(!port_ready) return RESULT_FAILURE; timeouts.ReadIntervalTimeout = settings->ReadIntervalTimeout; timeouts.ReadTotalTimeoutConstant = settings->ReadTotalTimeoutConstant; timeouts.ReadTotalTimeoutMultiplier = settings->ReadTotalTimeoutMultiplier; timeouts.WriteTotalTimeoutConstant = settings->WriteTotalTimeoutConstant; timeouts.WriteTotalTimeoutMultiplier = settings->WriteTotalTimeoutMulitplier; port_ready = SetCommTimeouts (handle, &timeouts); if(!port_ready) return RESULT_FAILURE; return RESULT_SUCCESS; }
void win_SetTimeOut(double dataInSecs) { GetCommTimeouts(PortID,&TimeOutData); TimeOutData.ReadTotalTimeoutConstant = short(dataInSecs * 1000) + 500; // 2.5 sec + nchar * 250 msec total time out(about 3secs); SetCommTimeouts(PortID,&TimeOutData); }
/* Open the communication channel */ void SerialPort::openChannel() { char comName[] = "COMx"; COMMTIMEOUTS comTimeouts; /* Check if channel already open */ if( channelOpen ) throw new ErrorMsg( "Channel already open! Cannot open port twice." ); /* Generate COM filename and attempt open */ comName[3] = '0' + portNumber; serialHandle = CreateFile( comName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); /* Print error and return if failed opening port */ if( serialHandle == INVALID_HANDLE_VALUE ) throw new ErrorMsg( "Error opening COM port!" ); channelOpen = true; /* Store old COM port settings */ if( !GetCommTimeouts( serialHandle, &oldComTimeouts ) ) throw new ErrorMsg( "Error reading COM port settings!" ); /* Get another copy of the COM settings, and change them */ if( !GetCommTimeouts( serialHandle, &comTimeouts ) ) throw new ErrorMsg( "Error reading COM port settings!" ); comTimeouts.ReadIntervalTimeout = MAXDWORD; comTimeouts.ReadTotalTimeoutConstant = 0; comTimeouts.ReadTotalTimeoutMultiplier = 0; /* Apply new settings */ if( !SetCommTimeouts( serialHandle, &comTimeouts ) ) throw new ErrorMsg( "Error changing COM port settings!" ); }
void CUartChannel::SetupTimesout(void) { COMMTIMEOUTS CommTimeOuts ; if(this->IsOpened() == FALSE) return; if (!GetCommTimeouts(this->m_Hcomm,&CommTimeOuts)) return; CommTimeOuts.ReadIntervalTimeout = 20;//MAXDWORD;//0xFFFFFFFF ; CommTimeOuts.ReadTotalTimeoutMultiplier = 10;//MAXDWORD;//0 ; CommTimeOuts.ReadTotalTimeoutConstant = 100;//MAXDWORD-1;//1000 ; CommTimeOuts.WriteTotalTimeoutMultiplier = 10;//2*CBR_9600/DBUG_BAUD ; CommTimeOuts.WriteTotalTimeoutConstant = 100 ; SetCommTimeouts(this->m_Hcomm, &CommTimeOuts); }
__bool CSerialPort::write_timeout(DWORD TotalTimeouts) { COMMTIMEOUTS tout; if(INVALID_HANDLE_VALUE == m_hFile){ SetLastError(ERROR_INVALID_HANDLE); return __false; } if(!GetCommTimeouts(m_hFile, &tout)){ return __false; } tout.WriteTotalTimeoutConstant = TotalTimeouts; if( !SetCommTimeouts(m_hFile, &tout)){ return __false; } return __true; }