コード例 #1
0
ファイル: serialPort.cpp プロジェクト: petejan/QueryLog
int serialPort::portMode(setType setting, char *set)
{
    switch (setting)
    {
        case CONFIG:
            strcpy(config, set);
            break;
        case EOSMODE:
            eosMode = *set;
            break;
        case CLEAR:
#ifdef __WIN32__
			SetCommBreak( handle );
			Sleep ( 300 ); // sleep 300 ms
			ClearCommBreak( handle );
			Sleep ( 50 ); // sleep 50 ms
#endif
#ifdef __linux__
			printf("serialPort::portMode break 300\n");
			tcsendbreak( handle, 300); // should send 300 ms break
			usleep(100000); // a bit of a guard after
			tcdrain( handle );
#endif
            break;
        case TIMEOUT:
            timeout = strtoul(set, NULL, 10) * 1000L;
            break;
        case PACING:
            pace = strtoul(set, NULL, 10) * 1000L;
            break;
    }

    return 0;
}
コード例 #2
0
int serialCommunicator::SerialBreak()
{

#if defined WIN32

    // Asio library doesn't support serial breaks on windows, so use win api
    boost::asio::deadline_timer timer(IO_service);

    // Set serial break
    SetCommBreak(newSerial->native_handle());

    // Wait for defined period
    timer.expires_from_now(boost::posix_time::milliseconds(serialBreakms));
    timer.wait();	// Blocks till the timer expires

    // Clear serial break
    ClearCommBreak(newSerial->native_handle());

#else
    // Otherwise send using the asio interface -NOTE this hasn't been tested yet.
    newSerial->send_break();
#endif

    return 1;
}
コード例 #3
0
ファイル: rs232int.cpp プロジェクト: bieli/avr_jokes
int RS232Interface::SetSerialBreak(int state)
{
	int result = E2ERR_OPENFAILED;

#ifdef	_WINDOWS
	if (hCom != INVALID_HANDLE_VALUE)
	{
		if (state)
			SetCommBreak(hCom);
		else
			ClearCommBreak(hCom);
		result = OK;
	}
#else
#ifdef	_LINUX_

#if defined(TIOCSBRK) && defined(TIOCCBRK) //check if available for compilation 
	if (state) 
		result = ioctl(fd,TIOCSBRK,0); 
	else 
		result = ioctl(fd,TIOCCBRK,0);
#else 
	UserDebug(UserApp1, "RS232Interface::SetSerialBreak Can't get IOCTL\n"); 
#endif 

#endif
#endif

	return result;
}
コード例 #4
0
ファイル: diag_tty.c プロジェクト: butljon/freediag
int diag_tty_break(struct diag_l0_device *dl0d, const int ms)
{
	HANDLE hd;
	long h;

	/*
	 * I'm going through this convoluted two-step conversion
	 * to avoid compiler warnings:
	 */

	h = get_osfhandle(dl0d->fd);
	hd = (HANDLE)h;

	if (tcdrain(dl0d->fd)) {
			fprintf(stderr, FLFMT "tcdrain returned %s.\n",
				FL, strerror(errno));
			return diag_iseterr(DIAG_ERR_GENERAL);
		}

	SetCommBreak(hd);
	diag_os_millisleep(ms);
	ClearCommBreak(hd);

	return 0;
}
コード例 #5
0
ファイル: diag_tty_win.c プロジェクト: remspoor/freediag
// diag_tty_break #1 : use Set / ClearCommBreak
// and return as soon as break is cleared.
// ret 0 if ok
int diag_tty_break(struct diag_l0_device *dl0d, const unsigned int ms) {
	LARGE_INTEGER qpc1, qpc2;	//for timing verification
	long real_t;	//"real" duration
	struct tty_int *wti = (struct tty_int *)dl0d->tty_int;
	int errval=0;

	if (wti->fd == INVALID_HANDLE_VALUE) {
		fprintf(stderr, FLFMT "Error. Is the port open ?\n", FL);
		return diag_iseterr(DIAG_ERR_GENERAL);
	}

	if (ms <= 1)
		return diag_iseterr(DIAG_ERR_GENERAL);

	QueryPerformanceCounter(&qpc1);
	errval = !SetCommBreak(wti->fd);
	QueryPerformanceCounter(&qpc2);
	//that call can take quite a while (6ms !!) on some setups (win7 + CH340 USB-Serial).
	//It's still impossible to know (from here) when exactly TXD goes low (beginning or end of the call)
	real_t=(long) (pf_conv * (qpc2.QuadPart-qpc1.QuadPart)) / 1000L;
	real_t = (long) ms - real_t;	//time remaining
	if (real_t <= 0) real_t = 0;
	diag_os_millisleep((unsigned int ) real_t);

	errval |= !ClearCommBreak(wti->fd);

	if (errval) {
		//if either of the calls failed
		fprintf(stderr, FLFMT "tty_break could not set/clear break!\n", FL);
		return diag_iseterr(DIAG_ERR_GENERAL);
	}

	return 0;
}
コード例 #6
0
int xbee_ser_break( xbee_serial_t *serial, int enabled)
{
	BOOL success;

	XBEE_SER_CHECK( serial);

	if (enabled)
	{
		success = SetCommBreak( serial->hCom);
	}
	else
	{
		success = ClearCommBreak( serial->hCom);
	}

	#ifdef XBEE_SERIAL_VERBOSE
		if (success == 0)
		{
			printf( "%s: {Set|Clear}CommBreak error %lu\n", __FUNCTION__,
					GetLastError());
		}
	#endif

	return success ? 0 : -EIO;
}
コード例 #7
0
ファイル: tucomm.c プロジェクト: mingpen/OpenNT
int far pascal zSetCommBreak( int pp1 )
{
    int r;

    SaveRegs();
    /*
    ** Log IN Parameters (No Create/Destroy Checking Yet!)
    */
    LogIn( (LPSTR)"APICALL:SetCommBreak int+",
        pp1 );

    /*
    ** Call the API!
    */
    RestoreRegs();
    GrovelDS();
    r = SetCommBreak(pp1);
    UnGrovelDS();
    SaveRegs();
    /*
    ** Log Return Code & OUT Parameters (No Create/Destroy Checking Yet!)
    */
    LogOut( (LPSTR)"APIRET:SetCommBreak int++",
        r, (short)0 );

    RestoreRegs();
    return( r );
}
コード例 #8
0
ファイル: asyncnt.c プロジェクト: klamonte/maximus
void com_break(int on)
{
  COMMHANDLE h=ComGetHandle(hcModem);

  if (on)
    SetCommBreak(h);
  else ClearCommBreak(h);
}
コード例 #9
0
ファイル: ccomport.cpp プロジェクト: fredcooke/secu3man
//уст. в указ. знач. линию TXD
//
bool CComPort::SetTXD(bool state)
{
 //TODO: maybe use of EscapeCommFunction() will be more suitable?
 if (state) 
  return SetCommBreak(m_hCom);
 else
  return ClearCommBreak(m_hCom);
}                
コード例 #10
0
ファイル: serport.cpp プロジェクト: JONA-GA/connector_pi
int wxSerialPort::SendBreak(int duration)
{
    if(duration <= 0) duration = 1;
    if(!SetCommBreak(fd)) return -1;
    // win32 Sleep parameter is ms
    Sleep(duration * 250);
    if(!ClearCommBreak(fd)) return -1;
    // no error
    return 0;
};
コード例 #11
0
void SerialPort::sendBreak()
{
#ifdef __WIN32__
    SetCommBreak(handle);
    ClearCommBreak(handle);
#endif
#if defined(__gnu_linux__) || (defined(__APPLE__) && defined(__MACH__))
    tcsendbreak(handle, 0);
#endif
}
コード例 #12
0
void CSerialPort::SetBreak()
{
  ASSERT(IsOpen());

  if (!SetCommBreak(m_hComm))
  {
    TRACE(_T("Failed in call to SetCommBreak\n"));
    AfxThrowSerialException();
  }
}
コード例 #13
0
// Transmit a continuous stream of zero bits for the given duration.  If the
// argument is 0, the transmission will last between 0.25 and 0.5 seconds.
// Otherwise, the duration specfies the number of seconds to send the zero bit
// stream.
void SerialPortImplWin32::sendBreak(const vpr::Int32 duration)
{
   DWORD flags;

   //Send a break for .5 seconds
   SetCommBreak(mHandle);
   Sleep(500);
   ClearCommBreak(mHandle);
   Sleep(35);
   ClearCommError(mHandle,&flags,NULL); //Clear the break error
}
コード例 #14
0
ファイル: serial_raw.cpp プロジェクト: hack477/bochs4wii
void serial_raw::set_break(int mode)
{
  BX_DEBUG (("set break %s", mode?"on":"off"));
#ifdef WIN32
  if (mode) {
    SetCommBreak(hCOM);
  } else {
    ClearCommBreak(hCOM);
  }
#endif
}
コード例 #15
0
ファイル: ndicapi_serial.c プロジェクト: Beastmaster/AIGS
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;
}
コード例 #16
0
ファイル: uwin16lk.c プロジェクト: RobMeades/PiSoftware
//-------------------------------------------------------------------
//  Description:
//     Send a break on the com port for "len" msec
//
//  portnum    - number 0 to MAX_PORTNUM-1.  This number is provided to
//                 indicate the symbolic port number.
//
void BreakCOM(int portnum)
{
   // start the reset pulse
   SetCommBreak(ComID[portnum]);

   // delay
   msDelay(2);

   // clear the reset pulse and return
   // PROGRAMMER'S NOTE: ClearCommBreak is returning 24:an undefined code
   ClearCommBreak(ComID[portnum]);

   // Win3.1 bug, close and then open port
   CloseCOM(portnum);
   OpenCOM(portnum,&port[0]);
}
コード例 #17
0
ファイル: ser-mingw.c プロジェクト: sergiodj/gdb-sergio
static int
ser_windows_send_break (struct serial *scb)
{
    HANDLE h = (HANDLE) _get_osfhandle (scb->fd);

    if (SetCommBreak (h) == 0)
        return -1;

    /* Delay for 250 milliseconds.  */
    Sleep (250);

    if (ClearCommBreak (h))
        return -1;

    return 0;
}
コード例 #18
0
/*****************************************************************

Routine:   SerialBreak()

Inputs:
	None.

Returns:
	int COMM_OK if successful

Description:
	This routine resets the COM PORT by sending a Serial Break to
	it.
*****************************************************************/
int Comm32Port::SerialBreak()
{
	if( m_hCommPort == INVALID_HANDLE_VALUE )
		return COMM_NOT_INITIALIZED;

	if (!SetCommBreak( m_hCommPort ))
		return COMM_ERROR_SETBREAK;

	Sleep( m_ulSerBreakDelay );

	if (!ClearCommBreak( m_hCommPort ))
		return COMM_ERROR_CLEARBREAK;

	return COMM_OK;

} /* SerialBreak */
コード例 #19
0
ファイル: diag_tty_win.c プロジェクト: shirou/freediag
// diag_tty_break #1 : use Set / ClearCommBreak
// and return as soon as break is cleared.
// ret 0 if ok
int diag_tty_break(struct diag_l0_device *dl0d, const unsigned int ms) {
    LARGE_INTEGER qpc1, qpc2;	//for timing verification
    static long correction=0;	//running average offset (us) to add to the timeout
    long real_t;	//"real" duration measured in us
    struct tty_int *wti = (struct tty_int *)dl0d->tty_int;
    int errval=0;

    if (wti->fd == INVALID_HANDLE_VALUE) {
        fprintf(stderr, FLFMT "Error. Is the port open ?\n", FL);
        return diag_iseterr(DIAG_ERR_GENERAL);
    }

    if ( (ms + correction/1000)<1)
        return diag_iseterr(DIAG_ERR_GENERAL);

    QueryPerformanceCounter(&qpc1);
    errval=!SetCommBreak(wti->fd);
    diag_os_millisleep(ms + correction/1000);
    QueryPerformanceCounter(&qpc2);
    errval += !ClearCommBreak(wti->fd);

    if (errval) {
        //if either of the calls failed
        fprintf(stderr, FLFMT "tty_break could not set/clear break!\n", FL);
        return diag_iseterr(DIAG_ERR_GENERAL);
    }
    real_t=(long) (pf_conv * (qpc2.QuadPart-qpc1.QuadPart));

    //now verify if it's within 1ms of the requested delay.
    real_t = real_t - (ms*1000);
    if (real_t < -3000) {
        diag_os_millisleep((unsigned int)(real_t / -1000));
    } else if ((real_t > -1000) && (real_t < 1000)) {
        //good enough:
        return 0;
    }
    //we're here if we were off by more than -3ms or +1ms.
    //correct by a fraction of the error.
    //diag_os_millisleep also does some self-correcting; we don't want to overdo it.
    correction = correction - (real_t / 3);
    //fprintf(stderr, FLFMT "tty_break off by %ldus, new correction=%ldus.\n",
    //	FL, real_t, correction);

    return 0;
}
コード例 #20
0
JNIEXPORT void JNICALL Java_gurux_io_NativeCode_setBreakState(JNIEnv* env, jclass clazz, jlong hComPort, jboolean value)
{
#if defined(_WIN32) || defined(_WIN64)
    if (value)
    {
        if (!SetCommBreak((HANDLE) hComPort))
        {
            ReportError(env, GetLastError());
        }
    }
    else
    {
        if (!ClearCommBreak((HANDLE) hComPort))
        {
            ReportError(env, GetLastError());
        }
    }
#else
    int status = 0;
    if (value)
    {
        int ret = ioctl(hComPort, TIOCSBRK, &status);
        if (ret < 0)
        {
            ReportError(env, "setBreakState failed.");
        }
    }
    else
    {
        int ret = ioctl(hComPort, TIOCCBRK, &status);
        if (ret < 0)
        {
            ReportError(env, "setBreakState failed.");
        }
    }
#endif
}
コード例 #21
0
ファイル: commlib.c プロジェクト: pakls/teraterm-ttssh2
void CommSendBreak(PComVar cv, int msec)
/* for only serial ports */
{
	MSG DummyMsg;

	if ( ! cv->Ready ) {
		return;
	}

	switch (cv->PortType) {
		case IdSerial:
			/* Set com port into a break state */
			SetCommBreak(cv->ComID);

			/* pause for 1 sec */
			if (SetTimer(cv->HWin, IdBreakTimer, msec, NULL) != 0) {
				GetMessage(&DummyMsg,cv->HWin,WM_TIMER,WM_TIMER);
			}

			/* Set com port into the nonbreak state */
			ClearCommBreak(cv->ComID);
			break;
	}
}
コード例 #22
0
ファイル: winser.c プロジェクト: NaldoDj/VeraCrypt
/*
 * Send serial special codes.
 */
static void serial_special(Backend *be, SessionSpecialCode code, int arg)
{
    Serial *serial = container_of(be, Serial, backend);

    if (serial->port && code == SS_BRK) {
        logevent(serial->logctx, "Starting serial break at user request");
	SetCommBreak(serial->port);
	/*
	 * To send a serial break on Windows, we call SetCommBreak
	 * to begin the break, then wait a bit, and then call
	 * ClearCommBreak to finish it. Hence, I must use timing.c
	 * to arrange a callback when it's time to do the latter.
	 * 
	 * SUS says that a default break length must be between 1/4
	 * and 1/2 second. FreeBSD apparently goes with 2/5 second,
	 * and so will I. 
	 */
	serial->clearbreak_time =
	    schedule_timer(TICKSPERSEC * 2 / 5, serbreak_timer, serial);
	serial->break_in_progress = true;
    }

    return;
}
コード例 #23
0
ファイル: winser.c プロジェクト: rdebath/sgt
/*
 * Send serial special codes.
 */
static void serial_special(void *handle, Telnet_Special code)
{
    Serial serial = (Serial) handle;

    if (serial->port && code == TS_BRK) {
	logevent(serial->frontend, "Starting serial break at user request");
	SetCommBreak(serial->port);
	/*
	 * To send a serial break on Windows, we call SetCommBreak
	 * to begin the break, then wait a bit, and then call
	 * ClearCommBreak to finish it. Hence, I must use timing.c
	 * to arrange a callback when it's time to do the latter.
	 * 
	 * SUS says that a default break length must be between 1/4
	 * and 1/2 second. FreeBSD apparently goes with 2/5 second,
	 * and so will I. 
	 */
	serial->clearbreak_time =
	    schedule_timer(TICKSPERSEC * 2 / 5, serbreak_timer, serial);
	serial->break_in_progress = TRUE;
    }

    return;
}
コード例 #24
0
ファイル: deveia.c プロジェクト: BGCX261/znos-git
//
// write on ctl file. modify the settings for
// the underlying port.
//
static void
wrctl(int port, char *cmd)
{
	DCB dcb;
	int nf, n,  i;
	char *f[16];
	HANDLE comfh = eia[port].comfh;
	DWORD  flag, opt;
	BOOL   rslt;
	int chg;

	// get the current settings for the port
	if(!GetCommState(comfh, &dcb))
		oserror();

	chg = 0;
	nf = tokenize(cmd, f, nelem(f));
	for(i = 0; i < nf; i++){
		if(strcmp(f[i], "break") == 0){
			if(!SetCommBreak(comfh))
				oserror();
			SleepEx((DWORD)300, FALSE);
			if(!ClearCommBreak(comfh))
				oserror();
			continue;
		}

		n = atoi(f[i]+1);
		switch(*f[i]) {
		case 'B':
		case 'b':	// set the baud rate
			if(n < 110)
				error(Ebadarg);
			dcb.BaudRate = n;
			chg = 1;
			break;
		case 'C':
		case 'c':
			/* dcd */
			break;
		case 'D':
		case 'd':  // set DTR
			opt = n ? SETDTR : CLRDTR;
			if(!EscapeCommFunction(comfh, opt))
				oserror();
			break;
		case 'E':
		case 'e':
			/* dsr */
			break;
		case 'F':
		case 'f':	// flush any untransmitted data
			if(!PurgeComm(comfh, PURGE_TXCLEAR)) 
				oserror();
			break;
		case 'H':
		case 'h':
			/* hangup */
			/* TO DO: close handle */
			break;
		case 'I':
		case 'i':
			/* fifo: nothing to do */
			break;
		case 'K':
		case 'k':
			/* send a break */
			if(!SetCommBreak(comfh))
				oserror();
			SleepEx((DWORD)300, FALSE);
			if(!ClearCommBreak(comfh))
				oserror();
			break;
		case 'L':
		case 'l':	// set bits per byte 
			flag = stof(size, f[0]+1);
			if(flag == BAD)
				error(Ebadarg);
			dcb.ByteSize = (BYTE)flag;
			chg = 1;
			break;
		case 'M':
		case 'm':	// set CTS (modem control)
			dcb.fOutxCtsFlow = (n!=0);
			chg = 1;
			break;
		case 'N':
		case 'n':
			/* don't block on output */
			break;
		case 'P':
		case 'p':	// set parity -- even or odd
			flag = stof(parity, f[0]+1);
			if(flag==BAD)
				error(Ebadarg);
			dcb.Parity = (BYTE)flag;
			chg = 1;
			break;
		case 'Q':
		case 'q':
			/* set i/o queue limits */
			break;
		case 'R':
		case 'r':	// set RTS
			opt = n ? SETRTS : CLRRTS;
			if(!EscapeCommFunction(comfh, opt))
				oserror();
			break;
		case 'S':
		case 's':	// set stop bits -- valid: 1 or 2 (win32 allows 1.5??)
			flag = stof(stopbits, f[0]+1);
			if(flag==BAD)
				error(Ebadarg);
			dcb.StopBits = flag;
			chg = 1;
			break;
		case 'T':
		case 't':
			break;
		case 'W':
		case 'w':
			/* set uart timer */
			break;
		case 'X':
		case 'x':	// xon/xoff
			opt = n ? SETXON : SETXOFF;
			if(!EscapeCommFunction(comfh, opt))
				oserror();
			break;
		default:
			/* ignore */
			break;
		}
	}

	if(!chg)
		return;
	// make the changes on the underlying port, but flush
	// outgoing chars down the port before
	osenter();
	rslt = FlushFileBuffers(comfh);
	if(rslt)
		rslt = SetCommState(comfh, &dcb);
	osleave();
	if(!rslt)
		oserror();
	eia[port].restore = 1;
	eia[port].dcb = dcb;
}
コード例 #25
0
void CDirectSerial::setBreak (bool value) {
	if (value) SetCommBreak (hCom);
	else ClearCommBreak (hCom);
}
コード例 #26
0
ファイル: i_win32_com.c プロジェクト: nbeaver/mx-trunk
MX_EXPORT mx_status_type
mxi_win32com_send_break( MX_RS232 *rs232 )
{
	static const char fname[] = "mxi_win32com_send_break()";

	MX_WIN32COM *win32com;
	BOOL win32_status;
	mx_status_type status;

	MX_DEBUG( 2,("%s invoked.",fname));

	status = mxi_win32com_get_pointers( rs232, &win32com, fname );

	if ( status.code != MXE_SUCCESS )
		return status;

	if ( win32com->handle == INVALID_HANDLE_VALUE ) {
		return mx_error( MXE_ILLEGAL_ARGUMENT, fname,
		"Win32 COM port device '%s' is not open.",
		rs232->record->name );
	}

	/* Turn the break signal on. */

	win32_status = SetCommBreak( win32com->handle );

	if ( win32_status == 0 ) {
		DWORD last_error_code;
		TCHAR message_buffer[MXU_ERROR_MESSAGE_LENGTH - 120];

		last_error_code = GetLastError();

		mx_win32_error_message( last_error_code,
			message_buffer, sizeof(message_buffer) );

		return mx_error( MXE_INTERFACE_IO_ERROR, fname,
		"Attempt to send a Break signal for '%s' failed.  "
			"Win32 error code = %ld, error message = '%s'",
			win32com->filename, last_error_code, message_buffer );
	}

	/* Leave the break signal on for about 0.5 seconds. */

	Sleep(500);

	/* Turn the break signal off. */
		
	win32_status = ClearCommBreak( win32com->handle );

	if ( win32_status == 0 ) {
		DWORD last_error_code;
		TCHAR message_buffer[MXU_ERROR_MESSAGE_LENGTH - 120];

		last_error_code = GetLastError();

		mx_win32_error_message( last_error_code,
			message_buffer, sizeof(message_buffer) );

		return mx_error( MXE_INTERFACE_IO_ERROR, fname,
		"Attempt to stop a Break signal for '%s' failed.  "
			"Win32 error code = %ld, error message = '%s'",
			win32com->filename, last_error_code, message_buffer );
	}

	return MX_SUCCESSFUL_RESULT;
}