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 void
ser_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, "·¢ËÍʧ°Ü", NULL, NULL);
return -1;
}
FlushFileBuffers(m_hSeries);
return 0;
}
size_t raw_serial::rxqueue_count()
{
if ( !isOpened() ) return 0;
COMSTAT com_stat;
DWORD error;
DWORD r_len = 0;
if(ClearCommError(_serial_handle, &error, &com_stat) && error > 0)
{
PurgeComm(_serial_handle, PURGE_RXABORT | PURGE_RXCLEAR);
return 0;
}
return com_stat.cbInQue;
}
bool RS485::send(frame &frm){
DWORD dwBytesWrite=frm.getLength();
COMSTAT ComStat;
DWORD dwErrorFlags;
BOOL bWriteStat;
ClearCommError(hCom,&dwErrorFlags,&ComStat);
bWriteStat=WriteFile(hCom,frm.getFrame(),dwBytesWrite,& dwBytesWrite,NULL);
if(!bWriteStat)
{
std::cout<<"写串口失败"<<std::endl;
return false;
}
return true;
}
tInt32 Serial::cRawSerialDevice::BytesAvailable()
{
int bytesAvailable = 0;
#ifndef WIN32
ioctl(m_FileDescriptorSerial, FIONREAD, &bytesAvailable);
#else
DWORD status;
COMSTAT comStat;
ClearCommError((HWND)(m_hDevice),&status, &comStat);
bytesAvailable = (tInt32)comStat.cbInQue;
#endif
//std::cout << "Bytes available on FileDesc: " << FileDescriptorSerial << "\t Bytes: " << bytesAvailable << std::endl;
return bytesAvailable;
}
int read_comport(char *response)
{
char *prompt_pos = NULL;
int i;
#ifdef ALLEGRO_WINDOWS
DWORD bytes_read = 0;
DWORD errors;
COMSTAT stat;
int j;
response[0] = '\0';
ClearCommError(com_port, &errors, &stat);
if (stat.cbInQue > 0)
ReadFile(com_port, response, stat.cbInQue, &bytes_read, 0);
// Remove extraneous 0s
for (i = 0, j = 0; i < bytes_read; i++)
if (response[i] > 0)
response[j++] = response[i];
response[j] = 0;
#else
char c;
i = 0;
while((c = comm_port_test(com_port)) >= 0) // while the serial buffer is not empty, read comport
if (c > 0)
response[i++] = c;
response[i] = 0;
#endif
prompt_pos = strchr(response, '>');
if (prompt_pos != NULL)
{
#ifdef LOG_COMMS
write_comm_log("RX", response);
#endif
*prompt_pos = '\0'; // erase ">"
return PROMPT; // command prompt detected
}
else if (strlen(response) == 0) // if the string is empty,
return EMPTY;
else //otherwise,
{
#ifdef LOG_COMMS
write_comm_log("RX", response);
#endif
return DATA;
}
}
bool Serial::WriteData(char *buffer, unsigned int nbChar)
{
DWORD bytesSend;
//Try to write the buffer on the Serial port
if (!WriteFile(this->hSerial, (void *)buffer, nbChar, &bytesSend, 0))
{
//In case it don't work get comm error and return false
ClearCommError(this->hSerial, &this->errors, &this->status);
return false;
}
else
return true;
}
void CSerialPort::Flush()
{
DWORD comError = 0;
COMSTAT comStat;
if (!ClearCommError (_hSerial, &comError, &comStat)) {
//TRACE ("ERROR: ClearCommError(): %s", GetLastErrorString());
return;
}
if (!PurgeComm (_hSerial, PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR)) {
//TRACE ("ERROR: PurgeComm(): %s", GetLastErrorString());
return;
}
}
//-----------------------------------------------------------------------------
int ComPortThread::ReadCOMMBytes(void *pData, int length)
{
// Variables
COMSTAT ComStat;
DWORD dwLength;
DWORD dwErrorFlags;
// Try to read length bytes
ClearCommError(m_hComDev, &dwErrorFlags, &ComStat);
ReadFile(m_hComDev, pData, ((DWORD) length), &dwLength, NULL);
return dwLength;
} // end of ReadCOMMBytes
