/*-------------------------------------------------------------------------
| rxtx is a native interface to serial ports in java.
| Copyright 1997-2006 by Trent Jarvi taj@www.linux.org.uk.
|
| This library is free software; you can redistribute it and/or
| modify it under the terms of the GNU Library General Public
| License as published by the Free Software Foundation; either
| version 2 of the License, or (at your option) any later version.
|
| This library is distributed in the hope that it will be useful,
| but WITHOUT ANY WARRANTY; without even the implied warranty of
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
| Library General Public License for more details.
|
| You should have received a copy of the GNU Library General Public
| License along with this library; if not, write to the Free
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--------------------------------------------------------------------------*/
package gnu.io;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.util.TooManyListenersException;
import java.lang.Math;
/**
* An extension of gnu.io.SerialPort
* @see gnu.io.SerialPort
*/
final public class RXTXPort extends SerialPort
{
/* I had a report that some JRE's complain when MonitorThread
tries to access private variables
*/
protected final static boolean debug = false;
protected final static boolean debug_read = false;
protected final static boolean debug_read_results = false;
protected final static boolean debug_write = false;
protected final static boolean debug_events = false;
protected final static boolean debug_verbose = false;
private static Zystem z;
static
{
try {
z = new Zystem();
} catch ( Exception e ) {};
if(debug )
z.reportln( "RXTXPort {}");
System.loadLibrary( "rxtxSerial" );
Initialize();
}
/** Initialize the native library */
private native static void Initialize();
boolean MonitorThreadAlive=false;
/**
* Open the named port
* @param name the name of the device to open
* @throws PortInUseException
* @see gnu.io.SerialPort
*/
public RXTXPort( String name ) throws PortInUseException
{
if (debug)
z.reportln( "RXTXPort:RXTXPort("+name+") called");
/*
commapi/javadocs/API_users_guide.html specifies that whenever
an application tries to open a port in use by another application
the PortInUseException will be thrown
I know some didnt like it this way but I'm not sure how to avoid
it. We will just be writing to a bogus fd if we catch the
exeption
Trent
*/
// try {
fd = open( name );
this.name = name;
MonitorThreadLock = true;
monThread = new MonitorThread();
monThread.start();
waitForTheNativeCodeSilly();
MonitorThreadAlive=true;
// } catch ( PortInUseException e ){}
timeout = -1; /* default disabled timeout */
if (debug)
z.reportln( "RXTXPort:RXTXPort("+name+") returns with fd = " +
fd);
}
private native synchronized int open( String name )
throws PortInUseException;
/* dont close the file while accessing the fd */
int IOLocked = 0;
/** File descriptor */
private int fd = 0;
/** a pointer to the event info structure used to share information
between threads so write threads can send output buffer empty
from a pthread if need be.
long for 64 bit pointers.
*/
long eis = 0;
/** pid for lock files */
int pid = 0;
/** DSR flag **/
static boolean dsrFlag = false;
/** Output stream */
private final SerialOutputStream out = new SerialOutputStream();
/**
* get the OutputStream
* @return OutputStream
*/
public OutputStream getOutputStream()
{
if (debug)
z.reportln( "RXTXPort:getOutputStream() called and returning");
return out;
}
/** Input stream */
private final SerialInputStream in = new SerialInputStream();
/**
* get the InputStream
* @return InputStream
* @see java.io.InputStream
*/
public InputStream getInputStream()
{
if (debug)
z.reportln( "RXTXPort:getInputStream() called and returning");
return in;
}
/**
* Set the SerialPort parameters
* 1.5 stop bits requires 5 databits
* @param b baudrate
* @param d databits
* @param s stopbits
* @param p parity
* @throws UnsupportedCommOperationException
* @see gnu.io.UnsupportedCommOperationException
* If speed is not a predifined speed it is assumed to be
* the actual speed desired.
*/
private native int nativeGetParity( int fd );
private native int nativeGetFlowControlMode( int fd );
public synchronized void setSerialPortParams( int b, int d, int s,
int p )
throws UnsupportedCommOperationException
{
if (debug)
z.reportln( "RXTXPort:setSerialPortParams(" +
b + " " + d + " " + s + " " + p + ") called");
if ( nativeSetSerialPortParams( b, d, s, p ) )
throw new UnsupportedCommOperationException(
"Invalid Parameter" );
speed = b;
if( s== STOPBITS_1_5 ) dataBits = DATABITS_5;
else dataBits = d;
stopBits = s;
parity = p;
z.reportln( "RXTXPort:setSerialPortParams(" +
b + " " + d + " " + s + " " + p +
") returning");
}
/**
* Set the native serial port parameters
* If speed is not a predifined speed it is assumed to be
* the actual speed desired.
*/
private native boolean nativeSetSerialPortParams( int speed,
int dataBits, int stopBits, int parity )
throws UnsupportedCommOperationException;
/** Line speed in bits-per-second */
private int speed=9600;
/**
* @return int representing the baudrate
* This will not behave as expected with custom speeds
*/
public int getBaudRate()
{
if (debug)
z.reportln( "RXTXPort:getBaudRate() called and returning " + speed);
return speed;
}
/** Data bits port parameter */
private int dataBits=DATABITS_8;
/**
* @return int representing the databits
*/
public int getDataBits()
{
if (debug)
z.reportln( "RXTXPort:getDataBits() called and returning " + dataBits);
return dataBits;
}
/** Stop bits port parameter */
private int stopBits=SerialPort.STOPBITS_1;
/**
* @return int representing the stopbits
*/
public int getStopBits()
{
if (debug)
z.reportln( "RXTXPort:getStopBits() called and returning " + stopBits);
return stopBits;
}
/** Parity port parameter */
private int parity= SerialPort.PARITY_NONE;
/**
* @return int representing the parity
*/
public int getParity()
{
if (debug)
z.reportln( "RXTXPort:getParity() called and returning " + parity );
return parity;
}
/** Flow control */
private int flowmode = SerialPort.FLOWCONTROL_NONE;
/**
* @param flowcontrol FLOWCONTROL_NONE is default
* @see gnu.io.SerialPort#FLOWCONTROL_NONE
*/
public void setFlowControlMode( int flowcontrol )
{
if (debug)
z.reportln( "RXTXPort:setFlowControlMode( " + flowcontrol + " ) called");
if(monThreadisInterrupted)
{
if( debug_events )
z.reportln( "RXTXPort:setFlowControlMode MonThread is Interrupeted returning" );
return;
}
try {
setflowcontrol( flowcontrol );
}
catch( IOException e )
{
e.printStackTrace();
return;
}
flowmode=flowcontrol;
if (debug)
z.reportln( "RXTXPort:setFlowControlMode( " + flowcontrol + " ) returning");
}
/**
* @return int representing the flowmode
*/
public int getFlowControlMode()
{
if (debug)
z.reportln( "RXTXPort:getFlowControlMode() returning " + flowmode );
return flowmode;
}
native void setflowcontrol( int flowcontrol ) throws IOException;
/*
linux/drivers/char/n_hdlc.c? FIXME
taj@www.linux.org.uk
*/
/**
* Receive framing control
* @param f framming
* @throws UnsupportedCommOperationException
*/
public void enableReceiveFraming( int f )
throws UnsupportedCommOperationException
{
if (debug)
z.reportln( "RXTXPort:enableReceiveFramming() throwing exception");
throw new UnsupportedCommOperationException( "Not supported" );
}
/**
*/
public void disableReceiveFraming()
{
if (debug)
z.reportln( "RXTXPort:disableReceiveFramming() called and returning (noop)");
}
/**
* @returns true if framing is enabled
*/
public boolean isReceiveFramingEnabled()
{
if (debug)
z.reportln( "RXTXPort:isReceiveFrammingEnabled() called and returning " + false );
return false;
}
/**
* @return int representing the framing byte
*/
public int getReceiveFramingByte()
{
if (debug)
z.reportln( "RXTXPort:getReceiveFrammingByte() called and returning " + 0 );
return 0;
}
/** Receive timeout control */
private int timeout;
/**
* @return int the timeout
*/
public native int NativegetReceiveTimeout();
/**
* @return bloolean true if recieve timeout is enabled
*/
private native boolean NativeisReceiveTimeoutEnabled();
/**
* @param time
* @param threshold
* @param InputBuffer
*/
private native void NativeEnableReceiveTimeoutThreshold(int time,
int threshold,int InputBuffer);
/**
*/
public void disableReceiveTimeout()
{
if (debug)
z.reportln( "RXTXPort:disableReceiveTimeout() called");
timeout = -1;
NativeEnableReceiveTimeoutThreshold( timeout , threshold, InputBuffer );
if (debug)
z.reportln( "RXTXPort:disableReceiveTimeout() returning");
}
/**
* @param time
*/
public void enableReceiveTimeout( int time )
{
if (debug)
z.reportln( "RXTXPort:enableReceiveTimeout() called");
if( time >= 0 )
{
timeout = time;
NativeEnableReceiveTimeoutThreshold( time , threshold,
InputBuffer );
}
else
{
throw new IllegalArgumentException
(
"Unexpected negative timeout value"
);
}
if (debug)
z.reportln( "RXTXPort:enableReceiveTimeout() returning");
}
/**
* @return boolean true if recieve timeout is enabled
*/
public boolean isReceiveTimeoutEnabled()
{
if (debug)
z.reportln( "RXTXPort:isReceiveTimeoutEnabled() called and returning " + NativeisReceiveTimeoutEnabled() );
return( NativeisReceiveTimeoutEnabled() );
}
/**
* @return int the timeout
*/
public int getReceiveTimeout()
{
if (debug)
z.reportln( "RXTXPort:getReceiveTimeout() called and returning " + NativegetReceiveTimeout() );
return(NativegetReceiveTimeout( ));
}
/** Receive threshold control */
private int threshold = 0;
/**
* @param thresh threshold
*/
public void enableReceiveThreshold( int thresh )
{
if (debug)
z.reportln( "RXTXPort:enableReceiveThreshold( " + thresh + " ) called");
if(thresh >=0)
{
threshold=thresh;
NativeEnableReceiveTimeoutThreshold(timeout, threshold,
InputBuffer);
}
else /* invalid thresh */
{
throw new IllegalArgumentException
(
"Unexpected negative threshold value"
);
}
if (debug)
z.reportln( "RXTXPort:enableReceiveThreshold( " + thresh + " ) returned");
}
/**
*/
public void disableReceiveThreshold()
{
if (debug)
z.reportln( "RXTXPort:disableReceiveThreshold() called and returning");
enableReceiveThreshold(0);
}
/**
* @return int the recieve threshold
*/
public int getReceiveThreshold()
{
if (debug)
z.reportln( "RXTXPort:getReceiveThreshold() called and returning " + threshold);
return threshold;
}
/**
* @return boolean true if receive threshold is enabled
*/
public boolean isReceiveThresholdEnabled()
{
if (debug)
z.reportln( "RXTXPort:isReceiveThresholdEnable() called and returning" + (threshold > 0) );
return(threshold>0);
}
/** Input/output buffers */
/** FIXME I think this refers to
FOPEN(3)/SETBUF(3)/FREAD(3)/FCLOSE(3)
taj@www.linux.org.uk
These are native stubs...
*/
private int InputBuffer=0;
private int OutputBuffer=0;
/**
* @param size
*/
public void setInputBufferSize( int size )
{
if (debug)
z.reportln( "RXTXPort:setInputBufferSize( " +
size + ") called");
if( size < 0 )
throw new IllegalArgumentException
(
"Unexpected negative buffer size value"
);
else InputBuffer=size;
if (debug)
z.reportln( "RXTXPort:setInputBufferSize( " +
size + ") returning");
}
/**
*/
public int getInputBufferSize()
{
if (debug)
z.reportln( "RXTXPort:getInputBufferSize() called and returning " + InputBuffer );
return(InputBuffer);
}
/**
* @param size
*/
public void setOutputBufferSize( int size )
{
if (debug)
z.reportln( "RXTXPort:setOutputBufferSize( " +
size + ") called");
if( size < 0 )
throw new IllegalArgumentException
(
"Unexpected negative buffer size value"
);
else OutputBuffer=size;
if (debug)
z.reportln( "RXTXPort:setOutputBufferSize( " +
size + ") returned");
}
/**
* @return in the output buffer size
*/
public int getOutputBufferSize()
{
if (debug)
z.reportln( "RXTXPort:getOutputBufferSize() called and returning " + OutputBuffer );
return(OutputBuffer);
}
/* =================== cleaned messages to here */
/**
* Line status methods
*/
/**
* @returns true if DTR is set
*/
public native boolean isDTR();
/**
* @param state
*/
public native void setDTR( boolean state );
/**
* @param state
*/
public native void setRTS( boolean state );
private native void setDSR( boolean state );
/**
* @return boolean true if CTS is set
*/
public native boolean isCTS();
/**
* @return boolean true if DSR is set
*/
public native boolean isDSR();
/**
* @return boolean true if CD is set
*/
public native boolean isCD();
/**
* @return boolean true if RI is set
*/
public native boolean isRI();
/**
* @return boolean true if RTS is set
*/
public native boolean isRTS();
/**
* Write to the port
* @param duration
*/
public native void sendBreak( int duration );
protected native void writeByte( int b, boolean i ) throws IOException;
protected native void writeArray( byte b[], int off, int len, boolean i )
throws IOException;
protected native boolean nativeDrain( boolean i ) throws IOException;
/** RXTXPort read methods */
protected native int nativeavailable() throws IOException;
protected native int readByte() throws IOException;
protected native int readArray( byte b[], int off, int len )
throws IOException;
protected native int readTerminatedArray( byte b[], int off, int len, byte t[] )
throws IOException;
/** Serial Port Event listener */
private SerialPortEventListener SPEventListener;
/** Thread to monitor data */
private MonitorThread monThread;
/** Process SerialPortEvents */
native void eventLoop();
/**
* @return boolean true if monitor thread is interrupted
*/
boolean monThreadisInterrupted=true;
private native void interruptEventLoop( );
public boolean checkMonitorThread()
{
if (debug)
z.reportln( "RXTXPort:checkMonitorThread()");
if(monThread != null)
{
if ( debug )
z.reportln(
"monThreadisInterrupted = " +
monThreadisInterrupted );
return monThreadisInterrupted;
}
if ( debug )
z.reportln( "monThread is null " );
return(true);
}
/**
* @param event
* @param state
* @return boolean true if the port is closing
*/
public boolean sendEvent( int event, boolean state )
{
if (debug_events)
z.report( "RXTXPort:sendEvent(");
/* Let the native side know its time to die */
if ( fd == 0 || SPEventListener == null || monThread == null)
{
return(true);
}
switch( event )
{
case SerialPortEvent.DATA_AVAILABLE:
if( debug_events )
z.reportln( "DATA_AVAILABLE " +
monThread.Data + ")" );
break;
case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
if( debug_events )
z.reportln(
"OUTPUT_BUFFER_EMPTY " +
monThread.Output + ")" );
break;
case SerialPortEvent.CTS:
if( debug_events )
z.reportln( "CTS " +
monThread.CTS + ")" );
break;
case SerialPortEvent.DSR:
if( debug_events )
z.reportln( "DSR " +
monThread.Output + ")" );
break;
case SerialPortEvent.RI:
if( debug_events )
z.reportln( "RI " +
monThread.RI + ")" );
break;
case SerialPortEvent.CD:
if( debug_events )
z.reportln( "CD " +
monThread.CD + ")" );
break;
case SerialPortEvent.OE:
if( debug_events )
z.reportln( "OE " +
monThread.OE + ")" );
break;
case SerialPortEvent.PE:
if( debug_events )
z.reportln( "PE " +
monThread.PE + ")" );
break;
case SerialPortEvent.FE:
if( debug_events )
z.reportln( "FE " +
monThread.FE + ")" );
break;
case SerialPortEvent.BI:
if( debug_events )
z.reportln( "BI " +
monThread.BI + ")" );
break;
default:
if( debug_events )
z.reportln( "XXXXXXXXXXXXXX " +
event + ")" );
break;
}
if( debug_events && debug_verbose )
z.reportln( " checking flags " );
switch( event )
{
case SerialPortEvent.DATA_AVAILABLE:
if( monThread.Data ) break;
return(false);
case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
if( monThread.Output ) break;
return(false);
case SerialPortEvent.CTS:
if( monThread.CTS ) break;
return(false);
case SerialPortEvent.DSR:
if( monThread.DSR ) break;
return(false);
case SerialPortEvent.RI:
if( monThread.RI ) break;
return(false);
case SerialPortEvent.CD:
if( monThread.CD ) break;
return(false);
case SerialPortEvent.OE:
if( monThread.OE ) break;
return(false);
case SerialPortEvent.PE:
if( monThread.PE ) break;
return(false);
case SerialPortEvent.FE:
if( monThread.FE ) break;
return(false);
case SerialPortEvent.BI:
if( monThread.BI ) break;
return(false);
default:
System.err.println( "unknown event: " + event);
return(false);
}
if( debug_events && debug_verbose )
z.reportln( " getting event" );
SerialPortEvent e = new SerialPortEvent(this, event, !state,
state );
if( debug_events && debug_verbose )
z.reportln( " sending event" );
if(monThreadisInterrupted)
{
if( debug_events )
z.reportln( " sendEvent return" );
return(true);
}
if( SPEventListener != null )
{
SPEventListener.serialEvent( e );
}
if( debug_events && debug_verbose )
z.reportln( " sendEvent return" );
if (fd == 0 || SPEventListener == null || monThread == null)
{
return(true);
}
else
{
return(false);
}
}
/**
* Add an event listener
* @param lsnr SerialPortEventListener
* @throws TooManyListenersException
*/
boolean MonitorThreadLock = true;
public void addEventListener(
SerialPortEventListener lsnr ) throws TooManyListenersException
{
/* Don't let and notification requests happen until the
Eventloop is ready
*/
if (debug)
z.reportln( "RXTXPort:addEventListener()");
if( SPEventListener != null )
{
throw new TooManyListenersException();
}
SPEventListener = lsnr;
if( !MonitorThreadAlive )
{
MonitorThreadLock = true;
monThread = new MonitorThread();
monThread.start();
waitForTheNativeCodeSilly();
MonitorThreadAlive=true;
}
if (debug)
z.reportln( "RXTXPort:Interrupt=false");
}
/**
* Remove the serial port event listener
*/
public void removeEventListener()
{
if (debug)
z.reportln( "RXTXPort:removeEventListener() called");
waitForTheNativeCodeSilly();
//if( monThread != null && monThread.isAlive() )
if( monThreadisInterrupted == true )
{
z.reportln( " RXTXPort:removeEventListener() already interrupted");
monThread = null;
SPEventListener = null;
return;
}
else if( monThread != null && monThread.isAlive() )
{
if (debug)
z.reportln( " RXTXPort:Interrupt=true");
monThreadisInterrupted=true;
/*
Notify all threads in this PID that something is up
They will call back to see if its their thread
using isInterrupted().
*/
if (debug)
z.reportln( " RXTXPort:calling interruptEventLoop");
interruptEventLoop( );
if (debug)
z.reportln( " RXTXPort:calling monThread.join()");
try {
monThread.join(1000);
} catch (Exception ex) {
/* yikes */
ex.printStackTrace();
}
if (debug)
z.reportln( " RXTXPort:waiting on isAlive()");
while( monThread.isAlive() )
{
if ( debug )
z.reportln( " MonThread is still alive!");
try {
monThread.join(1000);
Thread.sleep( 1000 );
} catch( Exception e ){}
//monThread.stop();
}
}
if (debug)
z.reportln( " RXTXPort:calling gc()");
monThread = null;
SPEventListener = null;
MonitorThreadLock = false;
MonitorThreadAlive=false;
monThreadisInterrupted=true;
z.reportln( "RXTXPort:removeEventListener() returning");
}
/**
* Give the native code a chance to start listening to the hardware
* or should we say give the native code control of the issue.
*
* This is important for applications that flicker the Monitor
* thread while keeping the port open.
* In worst case test cases this loops once or twice every time.
*/
protected void waitForTheNativeCodeSilly()
{
while( MonitorThreadLock )
{
try {
Thread.sleep(5);
} catch( Exception e ) {}
}
}
/**
* @param enable
*/
private native void nativeSetEventFlag( int fd, int event,
boolean flag );
public void notifyOnDataAvailable( boolean enable )
{
if (debug)
z.reportln( "RXTXPort:notifyOnDataAvailable( " +
enable+" )");
waitForTheNativeCodeSilly();
MonitorThreadLock = true;
nativeSetEventFlag( fd, SerialPortEvent.DATA_AVAILABLE,
enable );
monThread.Data = enable;
MonitorThreadLock = false;
}
/**
* @param enable
*/
public void notifyOnOutputEmpty( boolean enable )
{
if (debug)
z.reportln( "RXTXPort:notifyOnOutputEmpty( " +
enable+" )");
waitForTheNativeCodeSilly();
MonitorThreadLock = true;
nativeSetEventFlag( fd, SerialPortEvent.OUTPUT_BUFFER_EMPTY,
enable );
monThread.Output = enable;
MonitorThreadLock = false;
}
/**
* @param enable
*/
public void notifyOnCTS( boolean enable )
{
if (debug)
z.reportln( "RXTXPort:notifyOnCTS( " +
enable+" )");
waitForTheNativeCodeSilly();
MonitorThreadLock = true;
nativeSetEventFlag( fd, SerialPortEvent.CTS, enable );
monThread.CTS = enable;
MonitorThreadLock = false;
}
/**
* @param enable
*/
public void notifyOnDSR( boolean enable )
{
if (debug)
z.reportln( "RXTXPort:notifyOnDSR( " +
enable+" )");
waitForTheNativeCodeSilly();
MonitorThreadLock = true;
nativeSetEventFlag( fd, SerialPortEvent.DSR, enable );
monThread.DSR = enable;
MonitorThreadLock = false;
}
/**
* @param enable
*/
public void notifyOnRingIndicator( boolean enable )
{
if (debug)
z.reportln( "RXTXPort:notifyOnRingIndicator( " +
enable+" )");
waitForTheNativeCodeSilly();
MonitorThreadLock = true;
nativeSetEventFlag( fd, SerialPortEvent.RI, enable );
monThread.RI = enable;
MonitorThreadLock = false;
}
/**
* @param enable
*/
public void notifyOnCarrierDetect( boolean enable )
{
if (debug)
z.reportln( "RXTXPort:notifyOnCarrierDetect( " +
enable+" )");
waitForTheNativeCodeSilly();
MonitorThreadLock = true;
nativeSetEventFlag( fd, SerialPortEvent.CD, enable );
monThread.CD = enable;
MonitorThreadLock = false;
}
/**
* @param enable
*/
public void notifyOnOverrunError( boolean enable )
{
if (debug)
z.reportln( "RXTXPort:notifyOnOverrunError( " +
enable+" )");
waitForTheNativeCodeSilly();
MonitorThreadLock = true;
nativeSetEventFlag( fd, SerialPortEvent.OE, enable );
monThread.OE = enable;
MonitorThreadLock = false;
}
/**
* @param enable
*/
public void notifyOnParityError( boolean enable )
{
if (debug)
z.reportln( "RXTXPort:notifyOnParityError( " +
enable+" )");
waitForTheNativeCodeSilly();
MonitorThreadLock = true;
nativeSetEventFlag( fd, SerialPortEvent.PE, enable );
monThread.PE = enable;
MonitorThreadLock = false;
}
/**
* @param enable
*/
public void notifyOnFramingError( boolean enable )
{
if (debug)
z.reportln( "RXTXPort:notifyOnFramingError( " +
enable+" )");
waitForTheNativeCodeSilly();
MonitorThreadLock = true;
nativeSetEventFlag( fd, SerialPortEvent.FE, enable );
monThread.FE = enable;
MonitorThreadLock = false;
}
/**
* @param enable
*/
public void notifyOnBreakInterrupt( boolean enable )
{
if (debug)
z.reportln( "RXTXPort:notifyOnBreakInterrupt( " +
enable+" )");
waitForTheNativeCodeSilly();
MonitorThreadLock = true;
nativeSetEventFlag( fd, SerialPortEvent.BI, enable );
monThread.BI = enable;
MonitorThreadLock = false;
}
/** Close the port */
private native void nativeClose( String name );
/**
*/
boolean closeLock = false;
public synchronized void close()
{
if (debug)
z.reportln( "RXTXPort:close( " + this.name + " )");
if( closeLock ) return;
closeLock = true;
while( IOLocked > 0 )
{
if( debug )
z.reportln("IO is locked " + IOLocked);
try {
Thread.sleep(500);
} catch( Exception e ) {}
}
if ( fd <= 0 )
{
z.reportln( "RXTXPort:close detected bad File Descriptor" );
return;
}
setDTR(false);
setDSR(false);
if (debug)
z.reportln( "RXTXPort:close( " + this.name + " ) setting monThreadisInterrupted");
if ( ! monThreadisInterrupted )
{
removeEventListener();
}
if (debug)
z.reportln( "RXTXPort:close( " + this.name + " ) calling nativeClose");
nativeClose( this.name );
if (debug)
z.reportln( "RXTXPort:close( " + this.name + " ) calling super.close");
super.close();
fd = 0;
closeLock = false;
if (debug)
z.reportln( "RXTXPort:close( " + this.name + " ) leaving");
}
/** Finalize the port */
protected void finalize()
{
if (debug)
z.reportln( "RXTXPort:finalize()");
if( fd > 0 )
{
if (debug)
z.reportln( "RXTXPort:calling close()");
close();
}
z.finalize();
}
/** Inner class for SerialOutputStream */
class SerialOutputStream extends OutputStream
{
/**
* @param b
* @throws IOException
*/
public void write( int b ) throws IOException
{
if (debug_write)
z.reportln( "RXTXPort:SerialOutputStream:write(int)");
if( speed == 0 ) return;
if ( monThreadisInterrupted == true )
{
return;
}
IOLocked++;
waitForTheNativeCodeSilly();
if ( fd == 0 )
{
IOLocked--;
throw new IOException();
}
try
{
writeByte( b, monThreadisInterrupted );
if (debug_write)
z.reportln( "Leaving RXTXPort:SerialOutputStream:write( int )");
}
catch( IOException e )
{
IOLocked--;
throw e;
}
IOLocked--;
}
/**
* @param b[]
* @throws IOException
*/
public void write( byte b[] ) throws IOException
{
if (debug_write)
{
z.reportln( "Entering RXTXPort:SerialOutputStream:write(" + b.length + ") "/* + new String(b)*/ );
}
if( speed == 0 ) return;
if ( monThreadisInterrupted == true )
{
return;
}
if ( fd == 0 ) throw new IOException();
IOLocked++;
waitForTheNativeCodeSilly();
try
{
writeArray( b, 0, b.length, monThreadisInterrupted );
if (debug_write)
z.reportln( "Leaving RXTXPort:SerialOutputStream:write(" +b.length +")");
}
catch( IOException e )
{
IOLocked--;
throw e;
}
IOLocked--;
}
/**
* @param b[]
* @param off
* @param len
* @throws IOException
*/
public void write( byte b[], int off, int len )
throws IOException
{
if( speed == 0 ) return;
if( off + len > b.length )
{
throw new IndexOutOfBoundsException(
"Invalid offset/length passed to read"
);
}
byte send[] = new byte[len];
System.arraycopy( b, off, send, 0, len );
if (debug_write)
{
z.reportln( "Entering RXTXPort:SerialOutputStream:write(" + send.length + " " + off + " " + len + " " +") " /*+ new String(send) */ );
}
if ( fd == 0 ) throw new IOException();
if ( monThreadisInterrupted == true )
{
return;
}
IOLocked++;
waitForTheNativeCodeSilly();
try
{
writeArray( send, 0, len, monThreadisInterrupted );
if( debug_write )
z.reportln( "Leaving RXTXPort:SerialOutputStream:write(" + send.length + " " + off + " " + len + " " +") " /*+ new String(send)*/ );
}
catch( IOException e )
{
IOLocked--;
throw e;
}
IOLocked--;
}
/**
*/
public void flush() throws IOException
{
if (debug)
z.reportln( "RXTXPort:SerialOutputStream:flush() enter");
if( speed == 0 ) return;
if ( fd == 0 ) throw new IOException();
if ( monThreadisInterrupted == true )
{
if (debug)
z.reportln( "RXTXPort:SerialOutputStream:flush() Leaving Interrupted");
return;
}
IOLocked++;
waitForTheNativeCodeSilly();
/*
this is probably good on all OS's but for now
just sendEvent from java on Sol
*/
try
{
if ( nativeDrain( monThreadisInterrupted ) )
sendEvent( SerialPortEvent.OUTPUT_BUFFER_EMPTY, true );
if (debug)
z.reportln( "RXTXPort:SerialOutputStream:flush() leave");
}
catch( IOException e )
{
IOLocked--;
throw e;
}
IOLocked--;
}
}
/** Inner class for SerialInputStream */
class SerialInputStream extends InputStream
{
/**
* @return int the int read
* @throws IOException
* @see java.io.InputStream
*
*timeout threshold Behavior
*------------------------------------------------------------------------
*0 0 blocks until 1 byte is available timeout > 0,
* threshold = 0, blocks until timeout occurs, returns -1
* on timeout
*>0 >0 blocks until timeout, returns - 1 on timeout, magnitude
* of threshold doesn't play a role.
*0 >0 Blocks until 1 byte, magnitude of threshold doesn't
* play a role
*/
public synchronized int read() throws IOException
{
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read() called");
if ( fd == 0 ) throw new IOException();
if ( monThreadisInterrupted )
{
z.reportln( "+++++++++ read() monThreadisInterrupted" );
}
IOLocked++;
if (debug_read_results)
z.reportln( "RXTXPort:SerialInputStream:read() L" );
waitForTheNativeCodeSilly();
if (debug_read_results)
z.reportln( "RXTXPort:SerialInputStream:read() N" );
try
{
int result = readByte();
if (debug_read_results)
//z.reportln( "RXTXPort:SerialInputStream:read() returns byte = " + result );
z.reportln( "RXTXPort:SerialInputStream:read() returns" );
return( result );
}
finally
{
IOLocked--;
}
}
/**
* @param b[]
* @return int number of bytes read
* @throws IOException
*
*timeout threshold Behavior
*------------------------------------------------------------------------
*0 0 blocks until 1 byte is available
*>0 0 blocks until timeout occurs, returns 0 on timeout
*>0 >0 blocks until timeout or reads threshold bytes,
returns 0 on timeout
*0 >0 blocks until reads threshold bytes
*/
public synchronized int read( byte b[] ) throws IOException
{
int result;
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read(" + b.length + ") called");
if ( monThreadisInterrupted == true )
{
return(0);
}
IOLocked++;
waitForTheNativeCodeSilly();
try
{
result = read( b, 0, b.length);
if (debug_read_results)
z.reportln( "RXTXPort:SerialInputStream:read() returned " + result + " bytes" );
return( result );
}
finally
{
IOLocked--;
}
}
/*
read(byte b[], int, int)
Documentation is at http://java.sun.com/products/jdk/1.2/docs/api/java/io/InputStream.html#read(byte[], int, int)
*/
/**
* @param b[]
* @param off
* @param len
* @return int number of bytes read
* @throws IOException
*
*timeout threshold Behavior
*------------------------------------------------------------------------
*0 0 blocks until 1 byte is available
*>0 0 blocks until timeout occurs, returns 0 on timeout
*>0 >0 blocks until timeout or reads threshold bytes,
returns 0 on timeout
*0 >0 blocks until either threshold # of bytes or len bytes,
whichever was lower.
*/
public synchronized int read( byte b[], int off, int len )
throws IOException
{
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read(" + b.length + " " + off + " " + len + ") called" /*+ new String(b) */ );
int result;
/*
* Some sanity checks
*/
if ( fd == 0 )
{
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read() fd == 0");
z.reportln("+++++++ IOException()\n");
throw new IOException();
}
if( b==null )
{
z.reportln("+++++++ NullPointerException()\n");
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read() b == 0");
throw new NullPointerException();
}
if( (off < 0) || (len < 0) || (off+len > b.length))
{
z.reportln("+++++++ IndexOutOfBoundsException()\n");
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read() off < 0 ..");
throw new IndexOutOfBoundsException();
}
/*
* Return immediately if len==0
*/
if( len==0 )
{
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read() off < 0 ..");
return 0;
}
/*
* See how many bytes we should read
*/
int Minimum = len;
if( threshold==0 )
{
/*
* If threshold is disabled, read should return as soon
* as data are available (up to the amount of available
* bytes in order to avoid blocking)
* Read may return earlier depending of the receive time
* out.
*/
int a = nativeavailable();
if( a == 0 )
Minimum = 1;
else
Minimum = Math.min( Minimum, a );
}
else
{
/*
* Threshold is enabled. Read should return when
* 'threshold' bytes have been received (or when the
* receive timeout expired)
*/
Minimum = Math.min(Minimum, threshold);
}
if ( monThreadisInterrupted == true )
{
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read() Interrupted");
return(0);
}
IOLocked++;
waitForTheNativeCodeSilly();
try
{
result = readArray( b, off, Minimum);
if (debug_read_results)
z.reportln( "RXTXPort:SerialInputStream:read(" + b.length + " " + off + " " + len + ") returned " + result + " bytes" /*+ new String(b) */);
return( result );
}
finally
{
IOLocked--;
}
}
/**
* @param b[]
* @param off
* @param len
* @param t[]
* @return int number of bytes read
* @throws IOException
We are trying to catch the terminator in the native code
Right now it is assumed that t[] is an array of 2 bytes.
if the read encounters the two bytes, it will return and the
array will contain the terminator. Otherwise read behavior should
be the same as read( b[], off, len ). Timeouts have not been well
tested.
*/
public synchronized int read( byte b[], int off, int len, byte t[] )
throws IOException
{
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read(" + b.length + " " + off + " " + len + ") called" /*+ new String(b) */ );
int result;
/*
* Some sanity checks
*/
if ( fd == 0 )
{
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read() fd == 0");
z.reportln("+++++++ IOException()\n");
throw new IOException();
}
if( b==null )
{
z.reportln("+++++++ NullPointerException()\n");
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read() b == 0");
throw new NullPointerException();
}
if( (off < 0) || (len < 0) || (off+len > b.length))
{
z.reportln("+++++++ IndexOutOfBoundsException()\n");
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read() off < 0 ..");
throw new IndexOutOfBoundsException();
}
/*
* Return immediately if len==0
*/
if( len==0 )
{
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read() off < 0 ..");
return 0;
}
/*
* See how many bytes we should read
*/
int Minimum = len;
if( threshold==0 )
{
/*
* If threshold is disabled, read should return as soon
* as data are available (up to the amount of available
* bytes in order to avoid blocking)
* Read may return earlier depending of the receive time
* out.
*/
int a = nativeavailable();
if( a == 0 )
Minimum = 1;
else
Minimum = Math.min( Minimum, a );
}
else
{
/*
* Threshold is enabled. Read should return when
* 'threshold' bytes have been received (or when the
* receive timeout expired)
*/
Minimum = Math.min(Minimum, threshold);
}
if ( monThreadisInterrupted == true )
{
if (debug_read)
z.reportln( "RXTXPort:SerialInputStream:read() Interrupted");
return(0);
}
IOLocked++;
waitForTheNativeCodeSilly();
try
{
result = readTerminatedArray( b, off, Minimum, t );
if (debug_read_results)
z.reportln( "RXTXPort:SerialInputStream:read(" + b.length + " " + off + " " + len + ") returned " + result + " bytes" /*+ new String(b) */);
return( result );
}
finally
{
IOLocked--;
}
}
/**
* @return int bytes available
* @throws IOException
*/
public synchronized int available() throws IOException
{
if ( monThreadisInterrupted == true )
{
return(0);
}
if ( debug_verbose )
z.reportln( "RXTXPort:available() called" );
IOLocked++;
try
{
int r = nativeavailable();
if ( debug_verbose )
z.reportln( "RXTXPort:available() returning " +
r );
return r;
}
finally
{
IOLocked--;
}
}
}
/**
*/
class MonitorThread extends Thread
{
/** Note: these have to be separate boolean flags because the
SerialPortEvent constants are NOT bit-flags, they are just
defined as integers from 1 to 10 -DPL */
private volatile boolean CTS=false;
private volatile boolean DSR=false;
private volatile boolean RI=false;
private volatile boolean CD=false;
private volatile boolean OE=false;
private volatile boolean PE=false;
private volatile boolean FE=false;
private volatile boolean BI=false;
private volatile boolean Data=false;
private volatile boolean Output=false;
MonitorThread()
{
if (debug)
z.reportln( "RXTXPort:MontitorThread:MonitorThread()");
}
/**
* run the thread and call the event loop.
*/
public void run()
{
if (debug)
z.reportln( "RXTXPort:MontitorThread:run()");
monThreadisInterrupted=false;
eventLoop();
if (debug)
z.reportln( "eventLoop() returned");
}
protected void finalize() throws Throwable
{
if (debug)
z.reportln( "RXTXPort:MonitorThread exiting");
}
}
/**
* A dummy method added so RXTX compiles on Kaffee
* @deprecated deprecated but used in Kaffe
*/
public void setRcvFifoTrigger(int trigger){};
/*------------------------ END OF CommAPI -----------------------------*/
private native static void nativeStaticSetSerialPortParams( String f,
int b, int d, int s, int p )
throws UnsupportedCommOperationException;
private native static boolean nativeStaticSetDSR( String port,
boolean flag )
throws UnsupportedCommOperationException;
private native static boolean nativeStaticSetDTR( String port,
boolean flag )
throws UnsupportedCommOperationException;
private native static boolean nativeStaticSetRTS( String port,
boolean flag )
throws UnsupportedCommOperationException;
private native static boolean nativeStaticIsDSR( String port )
throws UnsupportedCommOperationException;
private native static boolean nativeStaticIsDTR( String port )
throws UnsupportedCommOperationException;
private native static boolean nativeStaticIsRTS( String port )
throws UnsupportedCommOperationException;
private native static boolean nativeStaticIsCTS( String port )
throws UnsupportedCommOperationException;
private native static boolean nativeStaticIsCD( String port )
throws UnsupportedCommOperationException;
private native static boolean nativeStaticIsRI( String port )
throws UnsupportedCommOperationException;
private native static int nativeStaticGetBaudRate( String port )
throws UnsupportedCommOperationException;
private native static int nativeStaticGetDataBits( String port )
throws UnsupportedCommOperationException;
private native static int nativeStaticGetParity( String port )
throws UnsupportedCommOperationException;
private native static int nativeStaticGetStopBits( String port )
throws UnsupportedCommOperationException;
private native byte nativeGetParityErrorChar( )
throws UnsupportedCommOperationException;
private native boolean nativeSetParityErrorChar( byte b )
throws UnsupportedCommOperationException;
private native byte nativeGetEndOfInputChar( )
throws UnsupportedCommOperationException;
private native boolean nativeSetEndOfInputChar( byte b )
throws UnsupportedCommOperationException;
private native boolean nativeSetUartType(String type, boolean test)
throws UnsupportedCommOperationException;
native String nativeGetUartType()
throws UnsupportedCommOperationException;
private native boolean nativeSetBaudBase(int BaudBase)
throws UnsupportedCommOperationException;
private native int nativeGetBaudBase()
throws UnsupportedCommOperationException;
private native boolean nativeSetDivisor(int Divisor)
throws UnsupportedCommOperationException;
private native int nativeGetDivisor()
throws UnsupportedCommOperationException;
private native boolean nativeSetLowLatency()
throws UnsupportedCommOperationException;
private native boolean nativeGetLowLatency()
throws UnsupportedCommOperationException;
private native boolean nativeSetCallOutHangup(boolean NoHup)
throws UnsupportedCommOperationException;
private native boolean nativeGetCallOutHangup()
throws UnsupportedCommOperationException;
private native boolean nativeClearCommInput()
throws UnsupportedCommOperationException;
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* This is only accurate up to 38600 baud currently.
*
* @param port the name of the port thats been preopened
* @return BaudRate on success
* @throws UnsupportedCommOperationException;
* This will not behave as expected with custom speeds
*
*/
public static int staticGetBaudRate( String port )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln(
"RXTXPort:staticGetBaudRate( " + port + " )");
return(nativeStaticGetBaudRate( port ));
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* @param port the name of the port thats been preopened
* @return DataBits on success
* @throws UnsupportedCommOperationException;
*
*/
public static int staticGetDataBits( String port )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln(
"RXTXPort:staticGetDataBits( " + port + " )");
return(nativeStaticGetDataBits( port ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* @param port the name of the port thats been preopened
* @return Parity on success
* @throws UnsupportedCommOperationException;
*
*/
public static int staticGetParity( String port )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln(
"RXTXPort:staticGetParity( " + port + " )");
return( nativeStaticGetParity( port ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* @param port the name of the port thats been preopened
* @return StopBits on success
* @throws UnsupportedCommOperationException;
*
*/
public static int staticGetStopBits( String port )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln(
"RXTXPort:staticGetStopBits( " + port + " )");
return(nativeStaticGetStopBits( port ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* Set the SerialPort parameters
* 1.5 stop bits requires 5 databits
* @param f filename
* @param b baudrate
* @param d databits
* @param s stopbits
* @param p parity
*
* @throws UnsupportedCommOperationException
* @see gnu.io.UnsupportedCommOperationException
*/
public static void staticSetSerialPortParams( String f, int b, int d,
int s, int p )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln(
"RXTXPort:staticSetSerialPortParams( " +
f + " " + b + " " + d + " " + s + " " + p );
nativeStaticSetSerialPortParams( f, b, d, s, p );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* Open the port and set DSR. remove lockfile and do not close
* This is so some software can appear to set the DSR before 'opening'
* the port a second time later on.
*
* @return true on success
* @throws UnsupportedCommOperationException;
*
*/
public static boolean staticSetDSR( String port, boolean flag )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:staticSetDSR( " + port +
" " + flag );
return( nativeStaticSetDSR( port, flag ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* Open the port and set DTR. remove lockfile and do not close
* This is so some software can appear to set the DTR before 'opening'
* the port a second time later on.
*
* @return true on success
* @throws UnsupportedCommOperationException;
*
*/
public static boolean staticSetDTR( String port, boolean flag )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:staticSetDTR( " + port +
" " + flag );
return( nativeStaticSetDTR( port, flag ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* Open the port and set RTS. remove lockfile and do not close
* This is so some software can appear to set the RTS before 'opening'
* the port a second time later on.
*
* @return none
* @throws UnsupportedCommOperationException;
*
*/
public static boolean staticSetRTS( String port, boolean flag )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:staticSetRTS( " + port +
" " + flag );
return( nativeStaticSetRTS( port, flag ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* find the fd and return RTS without using a Java open() call
*
* @param String port
* @return boolean true if asserted
* @throws UnsupportedCommOperationException;
*
*/
public static boolean staticIsRTS( String port )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:staticIsRTS( " + port + " )" );
return( nativeStaticIsRTS( port ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* find the fd and return CD without using a Java open() call
*
* @param String port
* @return boolean true if asserted
* @throws UnsupportedCommOperationException;
*
*/
public static boolean staticIsCD( String port )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:staticIsCD( " + port + " )" );
return( nativeStaticIsCD( port ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* find the fd and return CTS without using a Java open() call
*
* @param String port
* @return boolean true if asserted
* @throws UnsupportedCommOperationException;
*
*/
public static boolean staticIsCTS( String port )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:staticIsCTS( " + port + " )" );
return( nativeStaticIsCTS( port ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* find the fd and return DSR without using a Java open() call
*
* @param String port
* @return boolean true if asserted
* @throws UnsupportedCommOperationException;
*
*/
public static boolean staticIsDSR( String port )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:staticIsDSR( " + port + " )" );
return( nativeStaticIsDSR( port ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* find the fd and return DTR without using a Java open() call
*
* @param String port
* @return boolean true if asserted
* @throws UnsupportedCommOperationException;
*
*/
public static boolean staticIsDTR( String port )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:staticIsDTR( " + port + " )" );
return( nativeStaticIsDTR( port ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
*
* find the fd and return RI without using a Java open() call
*
* @param String port
* @return boolean true if asserted
* @throws UnsupportedCommOperationException;
*
*/
public static boolean staticIsRI( String port )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:staticIsRI( " + port + " )" );
return( nativeStaticIsRI( port ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
* @return int the Parity Error Character
* @throws UnsupportedCommOperationException;
*
* Anyone know how to do this in Unix?
*/
public byte getParityErrorChar( )
throws UnsupportedCommOperationException
{
byte ret;
if ( debug )
z.reportln( "getParityErrorChar()" );
ret = nativeGetParityErrorChar();
if ( debug )
z.reportln( "getParityErrorChar() returns " +
ret );
return( ret );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
* @param b Parity Error Character
* @return boolean true on success
* @throws UnsupportedCommOperationException;
*
* Anyone know how to do this in Unix?
*/
public boolean setParityErrorChar( byte b )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "setParityErrorChar(" + b + ")" );
return( nativeSetParityErrorChar( b ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
* @return int the End of Input Character
* @throws UnsupportedCommOperationException;
*
* Anyone know how to do this in Unix?
*/
public byte getEndOfInputChar( )
throws UnsupportedCommOperationException
{
byte ret;
if ( debug )
z.reportln( "getEndOfInputChar()" );
ret = nativeGetEndOfInputChar();
if ( debug )
z.reportln( "getEndOfInputChar() returns " +
ret );
return( ret );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
* @param b End Of Input Character
* @return boolean true on success
* @throws UnsupportedCommOperationException;
*/
public boolean setEndOfInputChar( byte b )
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "setEndOfInputChar(" + b + ")" );
return( nativeSetEndOfInputChar( b ) );
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
* @param type String representation of the UART type which mayb
* be "none", "8250", "16450", "16550", "16550A", "16650", "16550V2"
* or "16750".
* @param test boolean flag to determin if the UART should be tested.
* @return boolean true on success
* @throws UnsupportedCommOperationException;
*/
public boolean setUARTType(String type, boolean test)
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:setUARTType()");
return nativeSetUartType(type, test);
}
/**
* Extension to CommAPI
* This is an extension to CommAPI. It may not be supported on
* all operating systems.
* @return type String representation of the UART type which mayb
* be "none", "8250", "16450", "16550", "16550A", "16650", "16550V2"
* or "16750".
* @throws UnsupportedCommOperationException;
*/
public String getUARTType() throws UnsupportedCommOperationException
{
return nativeGetUartType();
}
/**
* Extension to CommAPI. Set Baud Base to 38600 on Linux and W32
* before using.
* @param int BaudBase The clock frequency divided by 16. Default
* BaudBase is 115200.
* @return boolean true on success
* @throws UnsupportedCommOperationException, IOException
*/
public boolean setBaudBase(int BaudBase)
throws UnsupportedCommOperationException,
IOException
{
if ( debug )
z.reportln( "RXTXPort:setBaudBase()");
return nativeSetBaudBase(BaudBase);
}
/**
* Extension to CommAPI
* @return int BaudBase
* @throws UnsupportedCommOperationException, IOException
*/
public int getBaudBase() throws UnsupportedCommOperationException,
IOException
{
if ( debug )
z.reportln( "RXTXPort:getBaudBase()");
return nativeGetBaudBase();
}
/**
* Extension to CommAPI. Set Baud Base to 38600 on Linux and W32
* before using.
* @param int Divisor;
* @throws UnsupportedCommOperationException, IOException
*/
public boolean setDivisor(int Divisor)
throws UnsupportedCommOperationException, IOException
{
if ( debug )
z.reportln( "RXTXPort:setDivisor()");
return nativeSetDivisor(Divisor);
}
/**
* Extension to CommAPI
* @returns int Divisor;
* @throws UnsupportedCommOperationException, IOException
*/
public int getDivisor() throws UnsupportedCommOperationException,
IOException
{
if ( debug )
z.reportln( "RXTXPort:getDivisor()");
return nativeGetDivisor();
}
/**
* Extension to CommAPI
* returns boolean true on success
* @throws UnsupportedCommOperationException
*/
public boolean setLowLatency() throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:setLowLatency()");
return nativeSetLowLatency();
}
/**
* Extension to CommAPI
* returns boolean true on success
* @throws UnsupportedCommOperationException
*/
public boolean getLowLatency() throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:getLowLatency()");
return nativeGetLowLatency();
}
/**
* Extension to CommAPI
* returns boolean true on success
* @throws UnsupportedCommOperationException
*/
public boolean setCallOutHangup(boolean NoHup)
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:setCallOutHangup()");
return nativeSetCallOutHangup(NoHup);
}
/**
* Extension to CommAPI
* returns boolean true on success
* @throws UnsupportedCommOperationException
*/
public boolean getCallOutHangup()
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:getCallOutHangup()");
return nativeGetCallOutHangup();
}
/**
* Extension to CommAPI
* returns boolean true on success
* @throws UnsupportedCommOperationException
*/
public boolean clearCommInput()
throws UnsupportedCommOperationException
{
if ( debug )
z.reportln( "RXTXPort:clearCommInput()");
return nativeClearCommInput();
}
/*------------------------ END OF CommAPI Extensions -----------------------*/
}