@Override
public void connect(String portName) {
CommPortIdentifier portIdentifier;
try {
portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
CommPort commPort = portIdentifier.open("TigerControlPanel", 2000);
SerialPort serialPort = (SerialPort) commPort;
serialPort.setSerialPortParams(
2400, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
_sReader = new SerialReader(serialPort.getInputStream());
serialPort.addEventListener(_sReader);
serialPort.notifyOnDataAvailable(true);
_sWriter = new SerialWriter(serialPort.getOutputStream());
} catch (NoSuchPortException e) {
DialogManager.showDialog(
"Error de conexión", "No existe el puerto seleccionado", null, DialogType.ERROR);
} catch (PortInUseException e) {
DialogManager.showDialog(
"Error de conexión",
"El puerto seleccionado se encuentra en uso",
null,
DialogType.ERROR);
} catch (Exception e) {
DialogManager.showDialog(
"Error de conexión", "Se ha producido un error de conexión", null, DialogType.ERROR);
}
}
public void initialize() {
CommPortIdentifier portId = null;
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
// First, Find an instance of serial port as set in PORT_NAMES.
while (portEnum.hasMoreElements()) {
CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();
for (String portName : PORT_NAMES) {
if (currPortId.getName().equals(portName)) {
portId = currPortId;
break;
}
}
}
if (portId == null) {
System.out.println("Could not find COM port.");
return;
}
try {
serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT);
serialPort.setSerialPortParams(
DATA_RATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
// open the streams
input = new BufferedReader(new InputStreamReader(serialPort.getInputStream()));
output = serialPort.getOutputStream();
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
} catch (Exception e) {
System.err.println(e.toString());
}
}
/**
* Start modem command manager.
*
* @throws Exception the exception
*/
public void startModemCommandManager() throws Exception {
CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(this.commandPortName);
if (portIdentifier.isCurrentlyOwned()) {
logger.error("Serial port " + this.commandPortName + " is currently in use");
}
CommPort commPort = portIdentifier.open(this.getClass().getName(), 2000);
if (commPort instanceof SerialPort) {
modemComPort = (SerialPort) commPort;
modemComPort.setSerialPortParams(
9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
modemComPort.notifyOnDataAvailable(true);
commandInputStream = new DataInputStream(modemComPort.getInputStream());
serialCommandReader = new SerialCommandReader(commandInputStream, this);
modemComPort.addEventListener(serialCommandReader);
commandOutputStream = new DataOutputStream(modemComPort.getOutputStream());
this.sendCommandToModem(ATCommands.DISABLE_ECHO);
this.sendCommandToModem(ATCommands.DISABLE_DIAGNOSTIC);
this.sendCommandToModem(ATCommands.END_CALL);
this.sendCommandToModem(ATCommands.CHECK_PIN);
}
}
private void initSerial()
throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException,
IOException, TooManyListenersException {
serialPort = connectSerial(serialDeviceName);
serialPort.addEventListener(mavlinkServer);
serialPort.notifyOnDataAvailable(true);
}
/** Opens the Serial port with the baud and port_name given */
public boolean OpenSerial(int baud, String port) {
CommPortIdentifier portId = null;
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
while (portEnum.hasMoreElements()) {
CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();
if (currPortId.getName().equals(port)) {
portId = currPortId;
break;
}
}
if (portId == null) {
System.err.println("Can not open serial port");
return false;
}
try {
serialPort = (SerialPort) portId.open(this.getClass().getName(), 2000);
serialPort.setSerialPortParams(
baud, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
input = serialPort.getInputStream();
output = serialPort.getOutputStream();
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
Thread.sleep(1500);
} catch (Exception e) {
return false;
}
return true;
}
private void write(byte[] data) {
try {
if (m_out == null) {
m_PortIdPrinter =
CommPortIdentifier.getPortIdentifier(
m_sPortScale); // Tomamos el puerto
m_CommPortPrinter =
(SerialPort) m_PortIdPrinter.open("PORTID", 2000); // Abrimos el puerto
m_out = m_CommPortPrinter.getOutputStream(); // Tomamos el chorro de escritura
m_in = m_CommPortPrinter.getInputStream();
m_CommPortPrinter.addEventListener(this);
m_CommPortPrinter.notifyOnDataAvailable(true);
m_CommPortPrinter.setSerialPortParams(
4800,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_ODD); // Configuramos el puerto
}
m_out.write(data);
} catch (NoSuchPortException e) {
e.printStackTrace();
} catch (PortInUseException e) {
e.printStackTrace();
} catch (UnsupportedCommOperationException e) {
e.printStackTrace();
} catch (TooManyListenersException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void connect(final String commPort, final String commSpeed) {
try {
synchronized (_mutex) {
_comPortId = CommPortIdentifier.getPortIdentifier(commPort);
_serialPort = (SerialPort) _comPortId.open("ComPort", 2000);
_inputStream = _serialPort.getInputStream();
_outputStream = _serialPort.getOutputStream();
_serialPort.addEventListener(new MySerialCommPortEventListener());
_serialPort.notifyOnDataAvailable(true);
final int speed = Integer.parseInt(commSpeed);
_serialPort.setSerialPortParams(
speed, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
_connected = true;
Thread.sleep(3000);
notifyConnectionStatus(true);
_connectionThread.start();
}
} catch (Exception e) {
e
.printStackTrace(); // To change body of catch statement use File | Settings | File
// Templates.
}
}
private void initialize() throws Exception {
serialPort = (SerialPort) Util.getCOMMPort().open(this.getClass().getName(), TIME_OUT);
serialPort.setSerialPortParams(
DATA_RATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
input = new BufferedReader(new InputStreamReader(serialPort.getInputStream()));
output = serialPort.getOutputStream();
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
}
// starts the event listener that knows whenever data is available to be read
// pre: an open serial port
// post: an event listener for the serial port that knows when data is recieved
public void initListener() {
try {
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
} catch (TooManyListenersException e) {
logText = "Too many listeners. (" + e.toString() + ")";
System.out.println(logText + "\n");
}
}
private void initEventListenersAndIO() {
try {
input = serialPort.getInputStream();
output = serialPort.getOutputStream();
serialPort.addEventListener(new SerialRxEvent(input, deviceRx));
serialPort.notifyOnDataAvailable(true);
} catch (TooManyListenersException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public SerialPortToRobot(String fileName, SerialPortInfo portInfo)
throws PortInUseException, UnsupportedCommOperationException, TooManyListenersException,
IOException {
serialPortFileName = fileName;
identifier = SerialPorts.getPortIdentifier(serialPortFileName);
if (identifier == null)
throw new RuntimeException("Port identifier " + serialPortFileName + " not found");
serialPort = (SerialPort) identifier.open("RLPark", 2000);
serialPort.addEventListener(this);
serialPort.setFlowControlMode(portInfo.flowControl);
serialPort.setSerialPortParams(
portInfo.rate, portInfo.databits, portInfo.stopbits, portInfo.parity);
serialStreams = new SerialStreams(serialPort);
setNotifiers();
}
public void connect(String port) throws Exception {
initialiseRobot();
CommPortIdentifier cpi = (CommPortIdentifier) portMap.get(port);
CommPort cp = cpi.open(this.getClass().getName(), 2000);
serialPort = (SerialPort) cp;
// init is and os
is = serialPort.getInputStream();
os = serialPort.getOutputStream();
// add listeners
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
}
public SerialManager(SerialPortEventListener listener) {
// the next line is for Raspberry Pi and
// gets us into the while loop and was suggested here was suggested
// http://www.raspberrypi.org/phpBB3/viewtopic.php?f=81&t=32186
// System.setProperty("gnu.io.rxtx.SerialPorts", "/dev/ttyACM0");
System.setProperty("gnu.io.rxtx.SerialPorts", "/dev/ttyACM0");
CommPortIdentifier portId = null;
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
// First, Find an instance of serial port as set in PORT_NAMES.
while (portEnum.hasMoreElements()) {
CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();
System.out.println(currPortId.getName());
for (String portName : PORT_NAMES) {
if (currPortId.getName().equals(portName)) {
portId = currPortId;
break;
}
}
}
if (portId == null) {
System.out.println("Could not find COM port.");
return;
}
try {
// open serial port, and use class name for the appName.
serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT);
// set port parameters
serialPort.setSerialPortParams(
DATA_RATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
// open the streams
input = new BufferedReader(new InputStreamReader(serialPort.getInputStream()));
output = serialPort.getOutputStream();
ows = new OutputStreamWriter(output);
// add event listeners
serialPort.addEventListener(listener);
serialPort.notifyOnDataAvailable(true);
} catch (Exception e) {
System.err.println(e.toString());
}
}
@Override
protected CommunicationChannel connect() {
logger.info("Connecting to INT-RS module at {}", this.port);
try {
CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(this.port);
SerialPort serialPort = portIdentifier.open("org.openhab.binding.satel", 2000);
serialPort.setSerialPortParams(
19200, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
serialPort.enableReceiveTimeout(this.getTimeout());
// RXTX serial port library causes high CPU load
// Start event listener, which will just sleep and slow down event
// loop
serialPort.addEventListener(
new SerialPortEventListener() {
@Override
public void serialEvent(SerialPortEvent ev) {
try {
logger.trace("RXTX library CPU load workaround, sleep forever");
Thread.sleep(Long.MAX_VALUE);
} catch (InterruptedException e) {
}
}
});
serialPort.notifyOnDataAvailable(true);
logger.info("INT-RS module connected successfuly");
return new SerialCommunicationChannel(serialPort);
} catch (NoSuchPortException e) {
logger.error("Port {} does not exist", this.port);
} catch (PortInUseException e) {
logger.error("Port {} in use.", this.port);
} catch (UnsupportedCommOperationException e) {
logger.error("Unsupported comm operation on port {}.", this.port);
} catch (TooManyListenersException e) {
logger.error("Too many listeners on port {}.", this.port);
}
return null;
}
public void initialize() {
CommPortIdentifier portId = null;
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
// Encontra uma instância da porta serial definida em PORT_NAMES
while (portEnum.hasMoreElements()) {
CommPortIdentifier currentPortId = (CommPortIdentifier) portEnum.nextElement();
for (String portName : PORT_NAMES) {
if (currentPortId.getName().equals(portName)) {
portId = currentPortId;
break;
}
}
}
if (portId == null) {
System.out.println("Não foi possível encontrar uma porta COM");
return;
}
try {
// abre a porta serial e usa o nome da classe appName
serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT);
// define os parâmetros da porta
serialPort.setSerialPortParams(
DATA_RATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
// abre a transferência
input = new BufferedReader(new InputStreamReader(serialPort.getInputStream()));
output = serialPort.getOutputStream();
char ch = 1;
output.write(ch);
// adiciona ouvintes
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
} catch (Exception ex) {
System.err.println(ex.toString());
}
}
public void initialize() {
CommPortIdentifier portId = null;
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
// iterate through, looking for the port
while (portEnum.hasMoreElements()) {
CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();
for (String portName : PORT_NAMES) {
if (currPortId.getName().equals(portName)) {
portId = currPortId;
break;
}
}
}
if (portId == null) {
System.out.println("Could not find COM port.");
return;
}
try {
// open serial port, and use class name for the appName.
serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT);
// set port parameters
serialPort.setSerialPortParams(
DATA_RATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
// open the streams
input = serialPort.getInputStream();
output = serialPort.getOutputStream();
// add event listeners
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
} catch (Exception e) {
System.err.println(e.toString());
}
}
@Override
public void startPolling() {
if (!_usable || !_isQuestionSupported) {
return;
}
_votingStartTime = Calendar.getInstance().getTimeInMillis();
try {
_comPort = _comPortIdent.open(this.getClass().getName(), 2000);
if (_comPort instanceof SerialPort) {
_serialPort = (SerialPort) _comPort;
_serialPort.setSerialPortParams(
_baudrate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
InputStream in = _serialPort.getInputStream();
_serialReader = new SerialReader(in, _injectable, _votingStartTime);
_serialPort.addEventListener(_serialReader);
_serialPort.notifyOnDataAvailable(true);
}
} catch (PortInUseException e) {
reportToDelegate(e);
PLog.error("Port is alreay in use by " + e.currentOwner, e);
} catch (UnsupportedCommOperationException e) {
reportToDelegate(e);
PLog.error("Error on setting SerialPort params", e);
} catch (IOException e) {
reportToDelegate(e);
PLog.error("Error while getting Inputstream", e);
} catch (TooManyListenersException e) {
reportToDelegate(e);
PLog.error("Error trying to add new EventListener", e);
}
}
/**
* Opens the communication port.
*
* @throws Exception if an error occurs.
*/
public void open() throws Exception {
// If this is Linux then first of all we need to check that
// device file exists. Otherwise call to m_PortIdentifyer.open()
// method will crash JVM.
// It is ugly patch but it is too late...
if (SystemUtils.IS_OS_LINUX) {
File portDevFile = new File(m_Parameters.getPortName());
if (!portDevFile.exists()) {
throw new Exception(
"Modbus serial device " + m_Parameters.getPortName() + " doesn't exist!");
}
}
// 1. obtain a CommPortIdentifier instance
try {
m_PortIdentifyer = CommPortIdentifier.getPortIdentifier(m_Parameters.getPortName());
} catch (NoSuchPortException e) {
final String errMsg =
"Could not get port identifier, maybe insufficient permissions. " + e.getMessage();
logger.debug(errMsg);
throw new Exception(errMsg);
}
logger.trace("Got Port Identifier");
// 2. open the port, wait for given timeout
try {
m_SerialPort = (SerialPort) m_PortIdentifyer.open("Modbus Serial Master", 30000);
} catch (PortInUseException e) {
logger.debug("open port failed: " + e.getMessage());
throw new Exception(e.getMessage());
}
logger.trace("Got Serial Port");
// 3. set the parameters
try {
setConnectionParameters();
} catch (Exception e) {
// ensure it is closed
m_SerialPort.close();
logger.debug("parameter setup failed: " + e.getMessage());
throw e;
}
if (Modbus.SERIAL_ENCODING_ASCII.equals(m_Parameters.getEncoding())) {
m_Transport = new ModbusASCIITransport();
} else if (Modbus.SERIAL_ENCODING_RTU.equals(m_Parameters.getEncoding())) {
m_Transport = new ModbusRTUTransport();
setReceiveTimeout(m_Parameters.getReceiveTimeout()); // just here for the moment.
} else if (Modbus.SERIAL_ENCODING_BIN.equals(m_Parameters.getEncoding())) {
m_Transport = new ModbusBINTransport();
}
m_Transport.setEcho(m_Parameters.isEcho());
// Open the input and output streams for the connection. If they won't
// open, close the port before throwing an exception.
try {
m_SerialIn = m_SerialPort.getInputStream();
m_Transport.setCommPort(m_SerialPort);
// m_Transport.prepareStreams(m_SerialIn,
// m_SerialPort.getOutputStream());
} catch (IOException e) {
m_SerialPort.close();
logger.debug(e.getMessage());
throw new Exception("Error opening i/o streams");
}
logger.trace("i/o Streams prepared");
// Add this object as an event listener for the serial port.
try {
m_SerialPort.addEventListener(this);
} catch (TooManyListenersException e) {
m_SerialPort.close();
final String errMsg = "too many listeners added";
logger.debug("{}: {}", errMsg, e.getMessage());
throw new Exception(errMsg);
}
// Set notifyOnBreakInterrup to allow event driven break handling.
m_SerialPort.notifyOnBreakInterrupt(true);
m_Open = true;
} // open
/**
* Sends a string to the serial port of this device. The writing of the msg is executed
* synchronized, so it's guaranteed that the device doesn't get multiple messages concurrently.
*
* @param msg the string to send
* @return true, if the message has been transmitted successfully, otherwise false.
*/
synchronized boolean writeString(final String msg) {
logger.debug("Writing '{}' to serial port {}", msg, port);
final long earliestNextExecution = lastCommandTime + interval;
while (earliestNextExecution > System.currentTimeMillis()) {
try {
Thread.sleep(100);
} catch (InterruptedException ex) {
return false;
}
}
try {
final List<Boolean> listenerResult = new ArrayList<Boolean>();
serialPort.addEventListener(
new SerialPortEventListener() {
@Override
public void serialEvent(SerialPortEvent event) {
if (event.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
// we get here if data has been received
final StringBuilder sb = new StringBuilder();
final byte[] readBuffer = new byte[20];
try {
do {
// read data from serial device
while (inputStream.available() > 0) {
final int bytes = inputStream.read(readBuffer);
sb.append(new String(readBuffer, 0, bytes));
}
try {
// add wait states around reading the stream, so that interrupted
// transmissions are
// merged
Thread.sleep(100);
} catch (InterruptedException e) {
// ignore interruption
}
} while (inputStream.available() > 0);
final String result = sb.toString();
if (result.equals(msg)) {
listenerResult.add(true);
}
} catch (IOException e) {
logger.debug("Error receiving data on serial port {}: {}", port, e.getMessage());
}
}
}
});
serialPort.notifyOnDataAvailable(true);
outputStream.write(msg.getBytes());
outputStream.flush();
lastCommandTime = System.currentTimeMillis();
final long timeout = lastCommandTime + 1000;
while (listenerResult.isEmpty() && System.currentTimeMillis() < timeout) {
// Waiting for response
Thread.sleep(100);
}
return !listenerResult.isEmpty();
} catch (Exception e) {
logger.error("Error writing '{}' to serial port {}: {}", msg, port, e.getMessage());
} finally {
serialPort.removeEventListener();
}
return false;
}
public Serial(String iname, int irate,
char iparity, int idatabits, float istopbits)
throws SerialException {
//if (port != null) port.close();
//this.parent = parent;
//parent.attach(this);
this.rate = irate;
parity = SerialPort.PARITY_NONE;
if (iparity == 'E') parity = SerialPort.PARITY_EVEN;
if (iparity == 'O') parity = SerialPort.PARITY_ODD;
this.databits = idatabits;
stopbits = SerialPort.STOPBITS_1;
if (istopbits == 1.5f) stopbits = SerialPort.STOPBITS_1_5;
if (istopbits == 2) stopbits = SerialPort.STOPBITS_2;
try {
port = null;
Enumeration portList = CommPortIdentifier.getPortIdentifiers();
while (portList.hasMoreElements()) {
CommPortIdentifier portId =
(CommPortIdentifier) portList.nextElement();
if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
//System.out.println("found " + portId.getName());
if (portId.getName().equals(iname)) {
//System.out.println("looking for "+iname);
port = (SerialPort)portId.open("serial madness", 2000);
input = port.getInputStream();
output = port.getOutputStream();
port.setSerialPortParams(rate, databits, stopbits, parity);
port.addEventListener(this);
port.notifyOnDataAvailable(true);
//port.setFlowControlMode(SerialPort.FLOWCONTROL_XONXOFF_IN | SerialPort.FLOWCONTROL_XONXOFF_OUT);
//port.setFlowControlMode(SerialPort.FLOWCONTROL_RTSCTS_IN | SerialPort.FLOWCONTROL_RTSCTS_OUT);
port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
// System.out.println("[Serial]opening, ready to roll");
}
}
}
} catch (PortInUseException e) {
throw new SerialException(
I18n.format(
_("Serial port ''{0}'' already in use. Try quiting any programs that may be using it."),
iname
)
);
} catch (Exception e) {
throw new SerialException(
I18n.format(
_("Error opening serial port ''{0}''."),
iname
),
e
);
// //errorMessage("<init>", e);
// //exception = e;
// //e.printStackTrace();
}
if (port == null) {
System.out.println("Port is missing");
}
}
public void addSerialPortEventListener(SerialPortEventListener serialPortEventListener)
throws TooManyListenersException {
mSerialPort.addEventListener(serialPortEventListener);
}
/**
* Initialize this device and open the serial port
*
* @throws InitializationException if port can not be opened
*/
@SuppressWarnings("rawtypes")
public void initialize() throws InitializationException {
// parse ports and if the default port is found, initialized the reader
Enumeration portList = CommPortIdentifier.getPortIdentifiers();
while (portList.hasMoreElements()) {
CommPortIdentifier id = (CommPortIdentifier) portList.nextElement();
if (id.getPortType() == CommPortIdentifier.PORT_SERIAL) {
if (id.getName().equals(port)) {
logger.debug("Serial port '{}' has been found.", port);
portId = id;
}
}
}
if (portId != null) {
// initialize serial port
try {
serialPort = portId.open("openHAB", 2000);
} catch (PortInUseException e) {
throw new InitializationException(e);
}
try {
inputStream = serialPort.getInputStream();
} catch (IOException e) {
throw new InitializationException(e);
}
try {
serialPort.addEventListener(this);
} catch (TooManyListenersException e) {
throw new InitializationException(e);
}
// activate the DATA_AVAILABLE notifier
serialPort.notifyOnDataAvailable(true);
try {
// set port parameters
serialPort.setSerialPortParams(
baud, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
} catch (UnsupportedCommOperationException e) {
throw new InitializationException(e);
}
try {
// get the output stream
outputStream = serialPort.getOutputStream();
} catch (IOException e) {
throw new InitializationException(e);
}
} else {
StringBuilder sb = new StringBuilder();
portList = CommPortIdentifier.getPortIdentifiers();
while (portList.hasMoreElements()) {
CommPortIdentifier id = (CommPortIdentifier) portList.nextElement();
if (id.getPortType() == CommPortIdentifier.PORT_SERIAL) {
sb.append(id.getName() + "\n");
}
}
throw new InitializationException(
"Serial port '" + port + "' could not be found. Available ports are:\n" + sb.toString());
}
}
// open a serial connection to a device. We won't know it's the robot until
public int OpenPort(String portName) {
if (portOpened && portName.equals(recentPort)) return 0;
ClosePort();
Log("<font color='green'>Connecting to " + portName + "...</font>\n");
// find the port
try {
portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
} catch (Exception e) {
Log("<span style='color:red'>Ports could not be identified:" + e.getMessage() + "</span>\n");
e.printStackTrace();
return 1;
}
if (portIdentifier.isCurrentlyOwned()) {
Log(
"<span style='color:red'>Error: Another program is currently using this port."
+ "</span>\n");
return 2;
}
// open the port
try {
commPort = portIdentifier.open("DrawbotGUI", 2000);
} catch (Exception e) {
Log("Port could not be opened:" + e.getMessage() + NL);
e.printStackTrace();
return 3;
}
if ((commPort instanceof SerialPort) == false) {
Log("<span style='color:red'>Only serial ports are handled by this example." + "</span>\n");
return 4;
}
// set the port parameters (like baud rate)
serialPort = (SerialPort) commPort;
try {
serialPort.setSerialPortParams(
BAUD_RATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
} catch (Exception e) {
Log("<span style='color:red'>Port could not be configured:" + e.getMessage() + "</span>\n");
return 5;
}
try {
in = serialPort.getInputStream();
out = serialPort.getOutputStream();
} catch (Exception e) {
Log("<span style='color:red'>Streams could not be opened:" + e.getMessage() + "</span>\n");
return 6;
}
try {
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
} catch (TooManyListenersException e) {
Log("<span style='color:red'>Streams could not be opened:" + e.getMessage() + "</span>\n");
return 7;
}
Log("<span style='green'>Opened.</span>\n");
SetRecentPort(portName);
portOpened = true;
UpdateMenuBar();
return 0;
}