自学教程：C++ ClearCommError函数代码示例

int CSerial::ReadDataWaiting( void ){	if( !m_bOpened || m_hIDComDev == NULL ) return( 0 );	DWORD dwErrorFlags;	COMSTAT ComStat;	ClearCommError( m_hIDComDev, &dwErrorFlags, &ComStat );	return( (int) ComStat.cbInQue );}

/*----------------------------------------------------------------------------*/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;}

qint64 VirtualSerialDevice::bytesAvailable() const{    QMutexLocker locker(&lock);    if (!isOpen()) return 0;    qint64 avail = 0;    COMSTAT Status;    if (ClearCommError(d->portHandle, NULL, &Status)) {        avail = Status.cbInQue;    }    return avail + QIODevice::bytesAvailable();}

int	MySerial::Read(void *buffer,int len){	BOOL bReadStat;	DWORD r_len = 0;		ClearCommError(hCom,&dwErrorFlags,&ComStat);	while( ComStat.cbInQue == 0 )	{		ClearCommError(hCom,&dwErrorFlags,&ComStat);	}	bReadStat = ReadFile(hCom,buffer,len,&r_len,NULL);	PurgeComm(hCom, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);	if(!bReadStat)		return -1;	return r_len;}

qint64 QSerial::bytesAvailable() {	if (isOpen()) {		DWORD Errors;		COMSTAT Status;		bool success=ClearCommError(fh, &Errors, &Status);		if (success) {			return Status.cbInQue + QIODevice::bytesAvailable();		}		return (unsigned int)-1;	}	return 0;}

bool TestForBreak( void ){    DWORD       errors;    COMSTAT     comStat;    if( ClearCommError( hSerial, &errors, &comStat ) ) {        if( errors & CE_BREAK ) {            return TRUE;        }    }    return( FALSE );}

int fb_SerialGetRemaining( FB_FILE *handle,                           void *pvHandle, fb_off_t *pLength ){    W32_SERIAL_INFO *pInfo = (W32_SERIAL_INFO*) pvHandle;    DWORD dwErrors;    COMSTAT Status;    if( !ClearCommError( pInfo->hDevice, &dwErrors, &Status ) )        return fb_ErrorSetNum( FB_RTERROR_ILLEGALFUNCTIONCALL );    if( pLength )        *pLength = (long) Status.cbInQue;    return fb_ErrorSetNum( FB_RTERROR_OK );}

int wxSerialPort::Ioctl(int cmd,void* args){    COMSTAT comstat;    DWORD errors;    int result = 0;    bool brk;    switch(cmd) {    case CTB_RESET:	   return SendBreak(0);    case CTB_SER_GETEINFO:	   if(ClearCommError(fd,&errors,&comstat)) {		  // actualize the last events		  if(errors & CE_BREAK) einfo.brk++;		  if(errors & CE_FRAME) einfo.frame++;		  if(errors & CE_OVERRUN) einfo.overrun++;		  if(errors & CE_RXPARITY) einfo.parity++;		  *(wxSerialPort_EINFO*)args = einfo;		  return 0;	   }    case CTB_SER_GETBRK:	   if(ClearCommError(fd,&errors,&comstat)) {		  if(errors & CE_BREAK) result = 1;		  einfo.brk += result;		  *(int*)args = result;		  return 0;	   }	   break;    case CTB_SER_GETFRM:	   if(ClearCommError(fd,&errors,&comstat)) {		  if(errors & CE_FRAME) result = 1;		  einfo.frame += result;		  *(int*)args = result;		  return 0;	   }    case CTB_SER_GETOVR:	   if(ClearCommError(fd,&errors,&comstat)) {		  if(errors & CE_OVERRUN) result = 1;		  einfo.overrun += result;		  *(int*)args = result;		  return 0;	   }	   break;    case CTB_SER_GETPAR:	   if(ClearCommError(fd,&errors,&comstat)) {		  if(errors & CE_RXPARITY) result = 1;		  einfo.parity += result;		  *(int*)args = result;		  return 0;	   }	   break;    case CTB_SER_GETINQUE:	   if(ClearCommError(fd,&errors,&comstat)) {		  *(int*)args = (int)comstat.cbInQue;		  return 0;	   }	   break;    }    // error or unknown command    return -1;};

int Send(const char * cmd)	{	LOG(ARDUINO_MSG_VERBOSE,"Arduino::SendMsg - msg [%s]",cmd);	write_lock.Lock();	DWORD dwwritten = 0; 	int len = strlen(cmd);	char buf[256];	if(len>256)	{		write_lock.Unlock();		LOG(ERR,"Arduino::Send: Msg too long!");		return -1;	}#ifndef USBCAN_PROTOCOL	// surround message with {}	sprintf_s(buf,256,"{%s}/r",cmd);	len += 3;	// {}/r#else	sprintf_s(buf,256,"%s/r",cmd);	len += 1;	// /r#endif	if  ( (dwwritten=blockingWrite(buf, len )) == -1)		{		LOG(ERR,"Arduino::SendMsg - Blocking write failed ! /n");		write_lock.Unlock();		return -1;		}	if (dwwritten != len)		{		write_lock.Unlock();		LOG(ERR,"Arduino::SendMsg - Write didn't finish (%d out of %d bytes sent)/n", dwwritten,len);		DWORD   dwErrors;		COMSTAT comStat;		ClearCommError(hCommPort, &dwErrors, &comStat);		LOG(ERR,"Arduino::SendMsg - ClearCommError: Error flags: 0x%x, bytes in output queue: %d/n", dwErrors, comStat.cbOutQue);				return -1;		}	write_lock.Unlock();#ifndef USBCAN_PROTOCOL	LOG(ARDUINO_MSG_VERBOSE,"Arduino::SendMsg - completed succefully: %d written (%d bytes original)",dwwritten,dwwritten-3);	return dwwritten-3;#else	LOG(ARDUINO_MSG_VERBOSE,"Arduino::SendMsg - completed succefully: %d written (%d bytes original)",dwwritten,dwwritten-1);	return dwwritten-1;#endif}

int SerialPortWrite(char *szBuffer, int count){	// TODO: Add your control notification handler code here#if 0	DWORD wCount = 0;	WriteFile(hCom, szBuffer, count, &wCount, NULL);//发送数据	return (int)wCount;#else	//char buffer[1024];	//DWORD dwBytesWritten = 1024;	DWORD dwErrorFlags;	COMSTAT ComStat;	OVERLAPPED m_osWrite;	BOOL bWriteStat;	DWORD dwRealSend = 0;	strcat(szBuffer, "/r/n");	count = count + 2;		ZeroMemory(&m_osWrite, sizeof(m_osWrite));	if (m_osWrite.hEvent != NULL)	{		ResetEvent(m_osWrite.hEvent);		m_osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);	}	if (ClearCommError(hCom, &dwErrorFlags, NULL))	{		PurgeComm(hCom, PURGE_TXABORT | PURGE_TXCLEAR);		bWriteStat = WriteFile(hCom, szBuffer, count, &dwRealSend, &m_osWrite);		if (!bWriteStat)		{			if (GetLastError() == ERROR_IO_PENDING)			{				while (!GetOverlappedResult(hCom, &m_osWrite, &dwRealSend, FALSE))				{					if (GetLastError() == ERROR_IO_INCOMPLETE)					{						//cout<<"写未完成，继续!"<     						continue;					}				}				//WaitForSingleObject(m_osWrite.hEvent, 1000);				//GetOverlappedResult(hCom, &m_osWrite, (DWORD*)(&count), TRUE);				return count;			}			return 0;		}	}	return count;#endif}

void CheckReadyToWrite(UART_PORT port){    COMSTAT	comstat;    DWORD	errors;    if(ClearCommError(UARTHandle[port], &errors, &comstat))    {        if(comstat.fCtsHold==0 && comstat.fXoffHold==0 && comstat.fXoffSent==0)        {            			UART_sendilm(port, MSG_ID_UART_READY_TO_WRITE_IND);            breadytowrite[port] = FALSE;        }    }            }

void CheckReadyToRead(UART_PORT port){    COMSTAT	comstat;    DWORD	errors;    if(ClearCommError(UARTHandle[port], &errors, &comstat))    {        if(comstat.cbInQue)                {            UART_sendilm(port, MSG_ID_UART_READY_TO_READ_IND);            breadytoread[port] = FALSE;        }    }        }

int ndiSerialBreak(HANDLE serial_port){  DWORD dumb;  ClearCommError(serial_port,&dumb,NULL);       /* clear error */  PurgeComm(serial_port,PURGE_TXCLEAR|PURGE_RXCLEAR); /* clear buffers */  SetCommBreak(serial_port);  Sleep(300);                            /* hold break for 0.3 seconds */   ClearCommBreak(serial_port);  return 0;}

JNIEXPORT jint JNICALL Java_com_fazecast_jSerialComm_SerialPort_bytesAvailable(JNIEnv *env, jobject obj, jlong serialPortFD){	HANDLE serialPortHandle = (HANDLE)serialPortFD;	if (serialPortHandle == INVALID_HANDLE_VALUE)		return -1;	COMSTAT commInfo;	if (!ClearCommError(serialPortHandle, NULL, &commInfo))		return -1;	DWORD numBytesAvailable = commInfo.cbInQue;	return (jint)numBytesAvailable;}

int xbee_ser_rx_used( xbee_serial_t *serial){	COMSTAT	stat;	XBEE_SER_CHECK( serial);	if (ClearCommError( serial->hCom, NULL, &stat))	{		return (int) stat.cbInQue;	}	return 0;}

// Returns the number of bytes in the transmission queue.int JHCommBase::BytesInTxQueue(){	COMSTAT cs;	DWORD er;	if (hPort != INVALID_HANDLE_VALUE)	{		if (ClearCommError(hPort, &er, &cs))		{			return cs.cbOutQue;		}	}	return -1;}

/*----------------------------------------------------------------------------*/unsigned serial_rxlen(int fd){  HANDLE h;  DWORD err;  COMSTAT stat;  h = get_h(fd);  if(h)  {    ClearCommError(h, &err, &stat);    return stat.cbInQue;  }  return 0;}

void CDirectSerial::CheckErrors() {		DWORD errors=0;	// check for errors	if (ClearCommError (hCom, &errors, NULL))		if (errors & (CE_BREAK | CE_FRAME | CE_RXPARITY)) {			Bit8u errreg = 0;			if (errors & CE_BREAK) errreg |= LSR_RX_BREAK_MASK;			if (errors & CE_FRAME) errreg |= LSR_FRAMING_ERROR_MASK;			if (errors & CE_RXPARITY) errreg |= LSR_PARITY_ERROR_MASK;			receiveError (errreg);		}}

static voidser_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except){    struct ser_windows_state *state;    COMSTAT status;    DWORD errors;    HANDLE h = (HANDLE) _get_osfhandle (scb->fd);    state = scb->state;    *except = state->except_event;    *read = state->ov.hEvent;    if (state->in_progress)        return;    /* Reset the mask - we are only interested in any characters which       arrive after this point, not characters which might have arrived       and already been read.  */    /* This really, really shouldn't be necessary - just the second one.       But otherwise an internal flag for EV_RXCHAR does not get       cleared, and we get a duplicated event, if the last batch       of characters included at least two arriving close together.  */    if (!SetCommMask (h, 0))        warning (_("ser_windows_wait_handle: reseting mask failed"));    if (!SetCommMask (h, EV_RXCHAR))        warning (_("ser_windows_wait_handle: reseting mask failed (2)"));    /* There's a potential race condition here; we must check cbInQue       and not wait if that's nonzero.  */    ClearCommError (h, &errors, &status);    if (status.cbInQue > 0)    {        SetEvent (state->ov.hEvent);        return;    }    state->in_progress = 1;    ResetEvent (state->ov.hEvent);    state->lastCommMask = -2;    if (WaitCommEvent (h, &state->lastCommMask, &state->ov))    {        gdb_assert (state->lastCommMask & EV_RXCHAR);        SetEvent (state->ov.hEvent);    }    else        gdb_assert (GetLastError () == ERROR_IO_PENDING);}

int CSeries::SerRead(BYTE *pszBuf, int RecvCnt, int TimeOut){	BOOL        fReadStat;	DWORD       OldCount,Count,dwReaded, dwError;	DWORD       dwErrorFlags;	COMSTAT		ComStat;	DWORD		i=0;	OldCount=GetTickCount();	while (1)	{		ClearCommError(m_CommPort, &dwErrorFlags, &ComStat);		fReadStat = ReadFile(m_CommPort, pszBuf+i, RecvCnt-i,			&dwReaded, NULL);		if (!fReadStat)		{			dwError = GetLastError();			// some other error occurred			ClearCommError(m_CommPort, &dwErrorFlags, &ComStat);			return -1;		}		if(dwReaded ==0)		{			Count=GetTickCount();			if(Count-OldCount>=(unsigned long)TimeOut) //修改:timeout为int型 ，强制转换为UL				return -2;			Sleep(10);		}		else		{			i += dwReaded;				if (i >= (unsigned long)RecvCnt)//修改:timeout为int型 ，强制转换为UL				return 0;		}	} }

//............................................................................int comRead(unsigned char *buf, size_t size) {    DWORD n;    if (!ReadFile(l_com, buf, (DWORD)size, &n, NULL)) {        printf("*** Reading serial port failed; GetLastError=%ld/n",               GetLastError());        DWORD errors;        COMSTAT comstat;        ClearCommError(l_com, &errors, &comstat);    }    if (_kbhit()) {        return -1;                                                // terminate    }    return (int)n;}

VALUE bytesAvailableIO(VALUE self){    PortDescriptor *port = NULL;    Data_Get_Struct(self, PortDescriptor, port);    DWORD   Errors;    COMSTAT Status;    if (ClearCommError(port->fd, &Errors, &Status))    {        return INT2FIX(Status.cbInQue);    }    return INT2FIX(0);}

int Camera::sendCommand(const unsigned char* cmd, int cmdLen){	COMSTAT ComStat;	DWORD dwErrorFlag;	ClearCommError(m_hSeries, &dwErrorFlag, &ComStat);	DWORD nWrite;	if(!WriteFile(m_hSeries, cmd, cmdLen, &nWrite, NULL))	{		::MessageBoxA(NULL, "
C++ ClearCondition函数代码示例
C++ ClearCharmInfoFlags函数代码示例