/**
* Set events mask. Required flags shall be sent to the input. Variables with prefix
* <b>"MASK_"</b>, shall be used as flags, for example <b>"MASK_RXCHAR"</b>. Sent parameter "mask"
* is additive value, so addition of flags is allowed. For example if messages about data receipt
* and CTS and DSR status changing shall be received, it is required to set the mask -
* <b>"MASK_RXCHAR | MASK_CTS | MASK_DSR"</b>
*
* @return If the operation is successfully completed, the method returns true, otherwise false
* @throws SerialPortException
*/
public boolean setEventsMask(int mask) throws SerialPortException {
checkPortOpened("setEventsMask()");
if (SerialNativeInterface.getOsType() == SerialNativeInterface.OS_LINUX
|| SerialNativeInterface.getOsType() == SerialNativeInterface.OS_SOLARIS
|| SerialNativeInterface.getOsType() == SerialNativeInterface.OS_MAC_OS_X) { // since 0.9.0
linuxMask = mask;
if (mask > 0) {
maskAssigned = true;
} else {
maskAssigned = false;
}
return true;
}
boolean returnValue = serialInterface.setEventsMask(portHandle, mask);
if (!returnValue) {
throw new SerialPortException(
portName, "setEventsMask()", SerialPortException.TYPE_CANT_SET_MASK);
}
if (mask > 0) {
maskAssigned = true;
} else {
maskAssigned = false;
}
return returnValue;
}
/**
* Create new EventListener Thread depending on the type of operating system
*
* @since 0.8
*/
private EventThread getNewEventThread() {
if (SerialNativeInterface.getOsType() == SerialNativeInterface.OS_LINUX
|| SerialNativeInterface.getOsType() == SerialNativeInterface.OS_SOLARIS
|| SerialNativeInterface.getOsType() == SerialNativeInterface.OS_MAC_OS_X) { // since 0.9.0
return new LinuxEventThread();
}
return new EventThread();
}
/**
* Getting events mask for the port
*
* @return Method returns events mask as int type variable. This variable is an additive value
* @throws SerialPortException
*/
public int getEventsMask() throws SerialPortException {
checkPortOpened("getEventsMask()");
if (SerialNativeInterface.getOsType() == SerialNativeInterface.OS_LINUX
|| SerialNativeInterface.getOsType() == SerialNativeInterface.OS_SOLARIS
|| SerialNativeInterface.getOsType() == SerialNativeInterface.OS_MAC_OS_X) { // since 0.9.0
return linuxMask;
}
return serialInterface.getEventsMask(portHandle);
}
/**
* Get state of RLSD line
*
* @return If line is active, method returns true, otherwise false
* @throws SerialPortException
*/
public boolean isRLSD() throws SerialPortException {
checkPortOpened("isRLSD()");
if (serialInterface.getLinesStatus(portHandle)[3] == 1) {
return true;
} else {
return false;
}
}
/**
* Close port. This method deletes event listener first, then closes the port
*
* @return If the operation is successfully completed, the method returns true, otherwise false
* @throws SerialPortException
*/
public boolean closePort() throws SerialPortException {
checkPortOpened("closePort()");
if (eventListenerAdded) {
removeEventListener();
}
boolean returnValue = serialInterface.closePort(portHandle);
if (returnValue) {
maskAssigned = false;
portOpened = false;
}
return returnValue;
}
/**
* Setting the parameters of port
*
* @param baudRate data transfer rate
* @param dataBits number of data bits
* @param stopBits number of stop bits
* @param parity parity
* @param setRTS initial state of RTS line(ON/OFF)
* @param setDTR initial state of DTR line(ON/OFF)
* @return If the operation is successfully completed, the method returns true, otherwise false
* @throws SerialPortException
* @since 0.8
*/
public boolean setParams(
int baudRate, int dataBits, int stopBits, int parity, boolean setRTS, boolean setDTR)
throws SerialPortException {
checkPortOpened("setParams()");
if (stopBits == 1) {
stopBits = 0;
} else if (stopBits == 3) {
stopBits = 1;
}
int flags = 0;
if (System.getProperty(SerialNativeInterface.PROPERTY_JSSC_IGNPAR) != null
|| System.getProperty(SerialNativeInterface.PROPERTY_JSSC_IGNPAR.toLowerCase()) != null) {
flags |= PARAMS_FLAG_IGNPAR;
}
if (System.getProperty(SerialNativeInterface.PROPERTY_JSSC_PARMRK) != null
|| System.getProperty(SerialNativeInterface.PROPERTY_JSSC_PARMRK.toLowerCase()) != null) {
flags |= PARAMS_FLAG_PARMRK;
}
return serialInterface.setParams(
portHandle, baudRate, dataBits, stopBits, parity, setRTS, setDTR, flags);
}
/**
* Port opening <br>
* <br>
* <b>Note: </b>If port busy <b>TYPE_PORT_BUSY</b> exception will be thrown. If port not found
* <b>TYPE_PORT_NOT_FOUND</b> exception will be thrown.
*
* @return If the operation is successfully completed, the method returns true
* @throws SerialPortException
*/
public boolean openPort() throws SerialPortException {
if (portOpened) {
throw new SerialPortException(
portName, "openPort()", SerialPortException.TYPE_PORT_ALREADY_OPENED);
}
if (portName != null) {
boolean useTIOCEXCL =
(System.getProperty(SerialNativeInterface.PROPERTY_JSSC_NO_TIOCEXCL) == null
&& System.getProperty(SerialNativeInterface.PROPERTY_JSSC_NO_TIOCEXCL.toLowerCase())
== null);
portHandle =
serialInterface.openPort(
portName,
useTIOCEXCL); // since 2.3.0 -> (if JSSC_NO_TIOCEXCL defined, exclusive lock for
// serial port will be disabled)
} else {
throw new SerialPortException(
portName,
"openPort()",
SerialPortException.TYPE_NULL_NOT_PERMITTED); // since 2.1.0 -> NULL port name fix
}
if (portHandle == SerialNativeInterface.ERR_PORT_BUSY) {
throw new SerialPortException(portName, "openPort()", SerialPortException.TYPE_PORT_BUSY);
} else if (portHandle == SerialNativeInterface.ERR_PORT_NOT_FOUND) {
throw new SerialPortException(
portName, "openPort()", SerialPortException.TYPE_PORT_NOT_FOUND);
} else if (portHandle == SerialNativeInterface.ERR_PERMISSION_DENIED) {
throw new SerialPortException(
portName, "openPort()", SerialPortException.TYPE_PERMISSION_DENIED);
} else if (portHandle == SerialNativeInterface.ERR_INCORRECT_SERIAL_PORT) {
throw new SerialPortException(
portName, "openPort()", SerialPortException.TYPE_INCORRECT_SERIAL_PORT);
}
portOpened = true;
return true;
}
/**
* Read byte array from port
*
* @param byteCount count of bytes for reading
* @return byte array with "byteCount" length
* @throws SerialPortException
*/
public byte[] readBytes(int byteCount) throws SerialPortException {
checkPortOpened("readBytes()");
return serialInterface.readBytes(portHandle, byteCount);
}
/**
* Getting lines status. Lines status is sent as 0 – OFF and 1 - ON
*
* @return Method returns the array containing information about lines in following order: <br>
* <b>element 0</b> - <b>CTS</b> line state</br> <br>
* <b>element 1</b> - <b>DSR</b> line state</br> <br>
* <b>element 2</b> - <b>RING</b> line state</br> <br>
* <b>element 3</b> - <b>RLSD</b> line state</br>
* @throws SerialPortException
*/
public int[] getLinesStatus() throws SerialPortException {
checkPortOpened("getLinesStatus()");
return serialInterface.getLinesStatus(portHandle);
}
private int[][] waitEvents() {
return serialInterface.waitEvents(portHandle);
}
/**
* Send Break singnal for setted duration
*
* @param duration duration of Break signal
* @return If the operation is successfully completed, the method returns true, otherwise false
* @throws SerialPortException
* @since 0.8
*/
public boolean sendBreak(int duration) throws SerialPortException {
checkPortOpened("sendBreak()");
return serialInterface.sendBreak(portHandle, duration);
}
/**
* Get flow control mode
*
* @return Mask of setted flow control mode
* @throws SerialPortException
* @since 0.8
*/
public int getFlowControlMode() throws SerialPortException {
checkPortOpened("getFlowControlMode()");
return serialInterface.getFlowControlMode(portHandle);
}
/**
* Set flow control mode. For required mode use variables with prefix <b>"FLOWCONTROL_"</b>.
* Example of hardware flow control mode(RTS/CTS): setFlowControlMode(FLOWCONTROL_RTSCTS_IN |
* FLOWCONTROL_RTSCTS_OUT);
*
* @return If the operation is successfully completed, the method returns true, otherwise false
* @throws SerialPortException
* @since 0.8
*/
public boolean setFlowControlMode(int mask) throws SerialPortException {
checkPortOpened("setFlowControlMode()");
return serialInterface.setFlowControlMode(portHandle, mask);
}
/**
* Get count of bytes in output buffer
*
* @return Count of bytes in output buffer or -1 if error occured
* @throws SerialPortException
* @since 0.8
*/
public int getOutputBufferBytesCount() throws SerialPortException {
checkPortOpened("getOutputBufferBytesCount()");
return serialInterface.getBuffersBytesCount(portHandle)[1];
}
/**
* Write byte array to port
*
* @return If the operation is successfully completed, the method returns true, otherwise false
* @throws SerialPortException
*/
public boolean writeBytes(byte[] buffer) throws SerialPortException {
checkPortOpened("writeBytes()");
return serialInterface.writeBytes(portHandle, buffer);
}
/**
* Change DTR line state. Set "true" for switching ON and "false" for switching OFF DTR line
*
* @return If the operation is successfully completed, the method returns true, otherwise false
* @throws SerialPortException
*/
public boolean setDTR(boolean enabled) throws SerialPortException {
checkPortOpened("setDTR()");
return serialInterface.setDTR(portHandle, enabled);
}
/**
* Purge of input and output buffer. Required flags shall be sent to the input. Variables with
* prefix <b>"PURGE_"</b>, for example <b>"PURGE_RXCLEAR"</b>. Sent parameter "flags" is additive
* value, so addition of flags is allowed. For example, if input or output buffer shall be purged,
* parameter <b>"PURGE_RXCLEAR | PURGE_TXCLEAR"</b>. <br>
* <b>Note: </b>some devices or drivers may not support this function
*
* @return If the operation is successfully completed, the method returns true, otherwise false.
* @throws SerialPortException
*/
public boolean purgePort(int flags) throws SerialPortException {
checkPortOpened("purgePort()");
return serialInterface.purgePort(portHandle, flags);
}
