private void baudTextActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_baudTextActionPerformed try { int rate; port.setSerialPortParams( rate = Integer.parseInt(baudText.getText()), port.getDataBits(), port.getStopBits(), port.getParity()); textPane.append("\nset baud rate to " + baudText.getText() + "\n\n"); baudRate = rate; prefs.putInt("baudRate", baudRate); } catch (UnsupportedCommOperationException ex) { log.warning(ex.toString()); textPane.append("\n*** could not set baud rate : " + ex + "\n\n"); } }
@Override public void open() { try{ CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName); if (portIdentifier.isCurrentlyOwned()) System.out.println("Error: Port is currently in use"); else { CommPort port = portIdentifier.open(this.getClass().getName(), getTimeout());//for now class name if (port instanceof SerialPort){ serial = (SerialPort) port; serial.setSerialPortParams(baudrate, SerialPort.DATABITS_8 , SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); serial.enableReceiveTimeout(timeout); this.in = serial.getInputStream(); this.out = serial.getOutputStream(); isOpened = true; } else System.out.println("Error: Only serial ports are handled"); } } catch (PortInUseException | UnsupportedCommOperationException | NoSuchPortException | IOException e) { if(serial != null) serial.close(); serial = null; e.printStackTrace(); } }
public void open() throws PortInUseException, UnsupportedCommOperationException, TooManyListenersException, IOException { if (open) { log.info(commId.getName() + " already open, skipping"); return; } log.info("Opening port " + commId.getName()); buffer = new ByteBuffer(); port = (SerialPort)commId.open("TimerInterface-"+commId.getName(), 30000); port.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); port.addEventListener(this); port.notifyOnDataAvailable(true); port.enableReceiveTimeout(30); os = port.getOutputStream(); is = port.getInputStream(); open = true; }
public static FMilaSerialPort getPort(int speed, String port) throws IOException { SerialPort serialPort; try { CommPortIdentifier comm = CommPortIdentifier.getPortIdentifier(port); if (comm.isCurrentlyOwned()) { throw new IOException("StationInUseError"); } serialPort = comm.open("4mila", 2000); serialPort.setSerialPortParams(speed, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); serialPort.disableReceiveTimeout(); serialPort.disableReceiveFraming(); serialPort.disableReceiveThreshold(); serialPort.notifyOnDataAvailable(true); serialPort.notifyOnOutputEmpty(true); } catch (PortInUseException | UnsupportedCommOperationException | NoSuchPortException e) { throw new IOException(e.getMessage(), e); } return new RXTXSerialPort(serialPort); }
@Override public LinkDelegate newLink(SerialLinkConfig config) throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException, IOException { CommPortIdentifier portIdentifier = CommPortIdentifier .getPortIdentifier(config.getPort()); checkState(!portIdentifier.isCurrentlyOwned(), "Port %s is currently in use", config.getPort()); final SerialPort serialPort = serialPort(config, portIdentifier); StreamConnection connection = new StreamConnection( serialPort.getInputStream(), serialPort.getOutputStream(), config.getProto()); ConnectionBasedLink connectionBasedLink = new ConnectionBasedLink( connection, config.getProto()); @SuppressWarnings("resource") Link link = config.isQos() ? new QosLink(connectionBasedLink) : connectionBasedLink; waitForArdulink(config, connectionBasedLink); return new LinkDelegate(link) { @Override public void close() throws IOException { super.close(); serialPort.close(); } }; }
@Override synchronized protected void openPort() throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException { if (port != null) return; log.info("Opening port: " + portName); CommPortIdentifier ident = CommPortIdentifier.getPortIdentifier(portName); port = ident.open("ModbusRtuClient on " + portName, 2000); port.setOutputBufferSize(buffer.length); port.setInputBufferSize(buffer.length); try { port.setSerialPortParams(baudRate, dataBits, stopBits, parity); port.enableReceiveTimeout(timeout); port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); } catch (UnsupportedCommOperationException e) { close(); throw e; } log.info("Port opened: " + port.getName()); }
@Override public void connect(String device) throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException, IOException { CommPortIdentifier portIdentifier = CommPortIdentifier .getPortIdentifier(device); CommPort commPort = portIdentifier .open(this.getClass().getName(), 2000); serialPort = (SerialPort) commPort; serialPort.setSerialPortParams(38400, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); serialPort.enableReceiveThreshold(1); serialPort.disableReceiveTimeout(); in = serialPort.getInputStream(); out = serialPort.getOutputStream(); out.flush(); if (in.markSupported()) { in.reset(); } readerThread = new SerialReader(in); readerThread.start(); }
/** * {@inheritDoc} **/ public void open() { try { CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(serialPortName); CommPort commPort = portIdentifier.open(this.getClass().getName(), 2000); serialPort = (SerialPort) commPort; serialPort.setSerialPortParams(baudRate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); serialPort.enableReceiveThreshold(1); serialPort.disableReceiveTimeout(); serialOutput = new OutputStreamWriter(serialPort.getOutputStream(), "US-ASCII"); serialInput = new BufferedReader(new InputStreamReader(serialPort.getInputStream())); setSerialEventHandler(this); connected = true; } catch (NoSuchPortException noSuchPortException) { logger.error("open(): No Such Port Exception: ", noSuchPortException); connected = false; } catch (PortInUseException portInUseException) { logger.error("open(): Port in Use Exception: ", portInUseException); connected = false; } catch (UnsupportedCommOperationException unsupportedCommOperationException) { logger.error("open(): Unsupported Comm Operation Exception: ", unsupportedCommOperationException); connected = false; } catch (UnsupportedEncodingException unsupportedEncodingException) { logger.error("open(): Unsupported Encoding Exception: ", unsupportedEncodingException); connected = false; } catch (IOException ioException) { logger.error("open(): IO Exception: ", ioException); connected = false; } }
public void openSerial(String serialPortName, int speed) throws PortInUseException, IOException, UnsupportedCommOperationException, TooManyListenersException { CommPortIdentifier commPortIdentifier = findPort(serialPortName); // initalize serial port serialPort = (SerialPort) commPortIdentifier.open("Arduino", 2000); inputStream = serialPort.getInputStream(); serialPort.addEventListener(this); // activate the DATA_AVAILABLE notifier serialPort.notifyOnDataAvailable(true); serialPort.setSerialPortParams(speed, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); }
/** * Versucht den seriellen Port zu �ffnen. Klappt nur, wenn er noch nicht von einer anderen Anwendung benutzt wird. Der jeweilige * Port wird mit �bergeben. UNter Windows ist die Schreibweise "COM8" zum Beispeil unter Linux "dev/tts0" * @param portName * @return * @throws PortInUseException * @throws IOException * @throws UnsupportedCommOperationException */ public boolean oeffneSerialPort(String portName) throws PortInUseException, IOException, UnsupportedCommOperationException { Boolean foundPort = false; if (serialPortGeoeffnet != false) { System.out.println("Serialport bereits ge�ffnet"); schliesseSerialPort(); return false; } System.out.println("�ffne Serialport"); enumComm = CommPortIdentifier.getPortIdentifiers(); while(enumComm.hasMoreElements()) { serialPortId = (CommPortIdentifier) enumComm.nextElement(); System.out.println("SerialportIDs:" + serialPortId.getName()); if (portName.contentEquals(serialPortId.getName())) { foundPort = true; break; } } if (foundPort != true) { System.out.println("Serialport nicht gefunden: " + portName); return false; } serialPort = (SerialPort) serialPortId.open("�ffnen und Senden", 500); outputStream = serialPort.getOutputStream(); inputStream = serialPort.getInputStream(); serialPort.notifyOnDataAvailable(true); serialPort.setSerialPortParams(baudrate, dataBits, stopBits, parity); serialPortGeoeffnet = true; return true; }
/** * Write contents of stream inputStream to serial port * * @param stream * @throws IOException * @throws UnsupportedCommOperationException * @throws PortInUseException */ public void write(InputStream inputStream) throws IOException, UnsupportedCommOperationException, PortInUseException { SerialPort serialPort = initSerialPort(getPortIdentifier(deviceName)); OutputStream serialOut = serialPort.getOutputStream(); writeTo(inputStream, serialOut); serialOut.close(); serialPort.close(); }
public void write(String rawString) throws UnsupportedCommOperationException, PortInUseException, IOException { SerialPort serialPort = initSerialPort(getPortIdentifier(deviceName)); OutputStream serialOut = serialPort.getOutputStream(); writeTo(rawString, serialOut); serialOut.close(); serialPort.close(); }
/** * Sets the speed for the serial port. * @param speed the speed to set (e.g. 4800, 9600, 19200, 38400, ...) */ public void setSerialPortSpeed(int speed) throws IOException { try { serial_port_.setSerialPortParams(speed, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); } catch(UnsupportedCommOperationException e) { e.printStackTrace(); throw new IOException(e.getMessage()); } }
/** * Sets the serial port parameters to 57600bps-8N1 */ private void setSerialPortParameters() throws IOException { int baudRate = 57600; // 57600bps try { // Set serial port to 57600bps-8N1..my favourite serialPort.setSerialPortParams( baudRate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); //serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_RTSCTS_IN); } catch (UnsupportedCommOperationException ex) { throw new IOException("Unsupported serial port parameter"); } }
@Override public SmartMeterReading read(String device) throws PortInUseException, IOException, UnsupportedCommOperationException { BigDecimal READING_POWER = new BigDecimal(new Random().nextInt(5000)); READING_TOTAL = READING_TOTAL.add(READING_POWER.divide(new BigDecimal(WATT_TO_WATTHOURS), 2, BigDecimal.ROUND_DOWN)); READING_ONE = READING_TOTAL; SmartMeterReading smartMeterReading = new SmartMeterReading(); smartMeterReading.meterTotal = new Meter(READING_TOTAL, "WH"); smartMeterReading.meterOne = new Meter(READING_ONE, "WH"); smartMeterReading.meterTwo = new Meter(READING_TWO, "WH"); smartMeterReading.power = new Meter(READING_POWER, "W"); smartMeterReading.complete = true; log.debug(smartMeterReading.toString()); return smartMeterReading; }
public synchronized void setBaudRate(int baudRate) throws IOException { NDC.push("setBaudRate(" + baudRate + ")"); try { if(!isPortOpen()) throw new IOException(null, new IllegalStateException("Port Not Open")); try { // set baud rate serialPort.setSerialPortParams(baudRate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); logger.debug("Set baudRate=" + baudRate); } catch(UnsupportedCommOperationException ex) { throw new IOException("Failed to set baud rate: ", ex); } } finally { NDC.pop(); } }
@Override public void connect(String device) throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException, IOException { CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(device); CommPort commPort = portIdentifier.open(this.getClass().getName(), 2000); serialPort = (SerialPort) commPort; serialPort.setSerialPortParams(38400, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); serialPort.enableReceiveThreshold(1); serialPort.disableReceiveTimeout(); in = serialPort.getInputStream(); out = serialPort.getOutputStream(); out.flush(); if (in.markSupported()) { in.reset(); } readerThread = new SerialReader(in); readerThread.start(); }
public SerialRXTXComm(CommPortIdentifier portIdentifier, Layer3Base layer3) throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException, IOException, TooManyListenersException{ if (portIdentifier.isCurrentlyOwned()) { throw new IOException("Port is currently in use"); } else { CommPort commPort = portIdentifier.open(this.getClass().getName(), TIME_OUT); if (commPort instanceof SerialPort) { SerialPort serialPort = (SerialPort) commPort; serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); inStream = serialPort.getInputStream(); outStream = serialPort.getOutputStream(); new SerialReceiver().start(); /*serialPort.addEventListener(this); serialPort.notifyOnDataAvailable(true);*/ } else { throw new IOException("This is not a serial port!."); } } this.layer2 = new Layer2Serial(this, layer3); }
public SerialTransport(String serialPortName) throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException { CommPortIdentifier usablePort = CommPortIdentifier.getPortIdentifier(serialPortName); commPort = (SerialPort)usablePort.open("SerialTransport", 0); commPort.setSerialPortParams(115200, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); commPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); commPort.setDTR(true); commPort.setRTS(true); commPort.setEndOfInputChar((byte)0x0D); }
/** * Tries to establish a serial connection with the given portId and baudRate and set the _serialOutputStream. * If the connection could be established, _open is set to true. * @param portId a CommPortIdentifier-object, used for identifying and connecting to a port. * @param baudRate This has to match the settings in the arduino-code. Recommended value: 256000. * @throws PortInUseException, IllegalArgumentException * @throws IllegalStateException if there is already a connection active */ public synchronized void open(CommPortIdentifier portId, int baudRate) throws PortInUseException { if (_open) throw new IllegalStateException("This SerialConnection is already opened."); try { _serialPort = (SerialPort) portId.open(_APPNAME, _TIME_OUT); //throws PortInUse _serialPort.setSerialPortParams(baudRate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); _serialOutputStream = new BufferedOutputStream(_serialPort.getOutputStream()); _open = true; ShutdownHandler.getInstance().addShutdownListener(this); DebugConsole.print("SerialConnection", "open", "Connecting successful!"); } catch (UnsupportedCommOperationException | IOException ex) { DebugConsole.print("SerialConnection", "open", ex.toString()); throw new IllegalArgumentException(ex); } }
/** * 打开串口 * * @param portName * 端口名称 * @param baudrate * 波特率 * @return 串口对象 * @throws SerialPortParameterFailure * 设置串口参数失败 * @throws NotASerialPort * 端口指向设备不是串口类型 * @throws NoSuchPort * 没有该端口对应的串口设备 * @throws PortInUse * 端口已被占用 */ public static final SerialPort openPort(String portName, int baudrate) throws SerialPortParameterFailure, NotASerialPort, NoSuchPort, PortInUse { try { // 通过端口名识别端口 CommPortIdentifier portIdentifier = CommPortIdentifier .getPortIdentifier(portName); // 打开端口,并给端口名字和一个timeout(打开操作的超时时间) CommPort commPort = portIdentifier.open(portName, 2000); // 判断是不是串口 if (commPort instanceof SerialPort) { SerialPort serialPort = (SerialPort) commPort; try { // 设置一下串口的波特率等参数 serialPort.setSerialPortParams(baudrate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); } catch (UnsupportedCommOperationException e) { throw new SerialPortParameterFailure(); } return serialPort; } else { // 不是串口 throw new NotASerialPort(); } } catch (NoSuchPortException e1) { throw new NoSuchPort(); } catch (PortInUseException e2) { throw new PortInUse(); } }
/** * set the baud rate used for communication; if the connection is * already established, the baud rate will be changed on the fly * * @param baudRate the new baud rate * @throws UnsupportedCommOperationException */ public void setBaudRate(int baudRate) throws UnsupportedCommOperationException { this.baudRate= baudRate; if (isConnected()) { port.setSerialPortParams( baudRate, dataBits, stopBits, paritiyFlags); } }
private void baudTextActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_baudTextActionPerformed try { streamer.setBaudRate(Integer.parseInt(baudText.getText())); } catch (UnsupportedCommOperationException ex) { logString("*** cannot set baud rate : " + ex + "\n"); } }
public synchronized void setBaudRate(int baudRate) throws UnsupportedCommOperationException { if (isOpen()) { serialPort.setSerialPortParams(baudRate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); } }
public synchronized void setHardwareFlowControl(boolean flowControlFlag) throws UnsupportedCommOperationException { if (isOpen()) { if (flowControlFlag) { serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_RTSCTS_OUT | SerialPort.FLOWCONTROL_RTSCTS_IN); serialPort.setRTS(true); log.info("Set HW flow control on!"); } else { serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); log.info("Set HW flow control off!"); } } }
@Override public void setReadTimeout(int millis) { timeout = millis; if(serial != null){ try { serial.enableReceiveTimeout(millis); } catch (UnsupportedCommOperationException e) { } } }
public SerialPortRTSPulseGenerator(String port) { if ((System.getProperty("os.name").toLowerCase().indexOf("linux") != -1)) { System.setProperty("gnu.io.rxtx.SerialPorts", port); } try { this.identifier = CommPortIdentifier.getPortIdentifier(port); CommPort commPort = identifier.open(getClass().getSimpleName(), OPEN_TIMEOUT); if(commPort instanceof SerialPort) { serial = (SerialPort) commPort; serial.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); } else { throw new IOException("Port is not a serial port"); } } catch (NoSuchPortException | PortInUseException | IOException | UnsupportedCommOperationException e) { throw new RuntimeException(e); } }
private void startRS232Com() throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException, IOException, TooManyListenersException { // get the port identifer String portName = comListStr[comList.getSelectedIndex()]; portIdentifier = CommPortIdentifier.getPortIdentifier(portName); if (portIdentifier.isCurrentlyOwned()) { System.out.println("Error: Port is currently in use"); } else { // Wait for 2ms when the COM is Busy String baudrate = baudrateListStr[baudrateList.getSelectedIndex()]; CommPort comPort = portIdentifier.open(this.getClass().getName(), 2000); if (comPort instanceof SerialPort) { serialPort = (SerialPort) comPort; // set the notify on data available // serialPort.addEventListener(this); // use state machine here // so do not use the interrupt now // first time must open this notify //serialPort.notifyOnDataAvailable(true); // set params serialPort.setSerialPortParams( Integer.parseInt(baudrate), SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); // Do not use flow control serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); // set the out/in stream serialIn = serialPort.getInputStream(); serialOut = serialPort.getOutputStream(); // initialize the read thread here // do not need initialize the thread here // first time do not initialize this thread if(null == serialReadThread){ serialReadThread = new Thread(new SerialReader(serialIn)); // start the thread serialReadThread.start(); } } else { System.out.println( "Error: Only serial ports are handled by this example."); } } }
public Com(String str, App a) throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException, TooManyListenersException{ this.app=a; this.name=str; CommPortIdentifier id=CommPortIdentifier.getPortIdentifier(str); this.port = (SerialPort) id.open("Gomoku", timeout); // this.port.setSerialPortParams(baudrate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); this.port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); this.listen(); }
private void preparePort() throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException, TooManyListenersException{ this.comPort=new Com(selectedCom, this); this.status=AppStatus.READY; this.menu.setVisible(false); this.startGame.setVisible(true); this.displayMessage("Procure um jogo clicando no botao abaixo ou aguarde um convite"); }
@SuppressWarnings("unchecked") public void openSerialPort(String port, String appName, int timeout, int baudRate, int dataBits, int stopBits, int parity, int flowControl) throws PortInUseException, UnsupportedCommOperationException, TooManyListenersException, IOException, XBeeException { // Apparently you can't query for a specific port, but instead must iterate Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers(); CommPortIdentifier portId = null; boolean found = false; while (portList.hasMoreElements()) { portId = portList.nextElement(); if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) { //log.debug("Found port: " + portId.getName()); if (portId.getName().equals(port)) { //log.debug("Using Port: " + portId.getName()); found = true; break; } } } if (!found) { throw new XBeeException("Could not find port: " + port); } serialPort = (SerialPort) portId.open(appName, timeout); serialPort.setSerialPortParams(baudRate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); // activate the DATA_AVAILABLE notifier serialPort.notifyOnDataAvailable(true); // activate the OUTPUT_BUFFER_EMPTY notifier //serialPort.notifyOnOutputEmpty(true); serialPort.addEventListener(this); inputStream = serialPort.getInputStream(); outputStream = new BufferedOutputStream(serialPort.getOutputStream()); }
private void connect() throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException, IOException, InterruptedException, ConfigurationException { logger.info("Connecting to RFXCOM [serialPort='{}' ].", new Object[] { serialPort }); connector.addEventListener(eventLister); connector.connect(serialPort); logger.debug("Reset controller"); connector.sendMessage(RFXComMessageFactory.CMD_RESET); // controller does not response immediately after reset, // so wait a while Thread.sleep(1000); if (setMode != null) { try { logger.debug("Set mode: {}", DatatypeConverter.printHexBinary(setMode)); } catch (IllegalArgumentException e) { throw new ConfigurationException("setMode", e.getMessage()); } connector.sendMessage(setMode); } else { connector.sendMessage(RFXComMessageFactory.CMD_STATUS); } }
/** * Describe <code>setReceiveThreshold</code> method here. * * @param th an <code>int</code> value */ public void setReceiveThreshold(int th) { try { m_CommPort.enableReceiveThreshold(th); /* chars */ } catch (UnsupportedCommOperationException e) { logger.error("Failed to setReceiveThreshold: {}", e.getMessage()); } }
/** * Describe <code>setReceiveTimeout</code> method here. * * @param ms an <code>int</code> value */ public void setReceiveTimeout(int ms) { try { m_CommPort.enableReceiveTimeout(ms); /* milliseconds */ } catch (UnsupportedCommOperationException e) { logger.error("Failed to setReceiveTimeout: {}", e.getMessage()); } }
private void connectSerial() throws Exception { logger.debug("Initializing serial port {}", serialPortName); try { CommPortIdentifier portIdentifier = CommPortIdentifier .getPortIdentifier(serialPortName); CommPort commPort = portIdentifier .open(this.getClass().getName(), 2000); serialPort = (SerialPort) commPort; try { serialPort.setSerialPortParams(4800, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); serialPort.enableReceiveThreshold(1); serialPort.disableReceiveTimeout(); } catch (UnsupportedCommOperationException unimportant) { // We might have a perfectly usable PTY even if above operations are unsupported }; inStream = new DataInputStream(serialPort.getInputStream()); outStream = serialPort.getOutputStream(); outStream.flush(); if (inStream.markSupported()) { inStream.reset(); } logger.debug("Starting DataListener for {}", PrimareSerialConnector.this.toString()); dataListener = new DataListener(); dataListener.start(); logger.debug("Starting DataListener for {}", PrimareSerialConnector.this.toString()); sendInitMessages(); } catch (NoSuchPortException e) { logger.error("No such port: {}",serialPortName); Enumeration portList = CommPortIdentifier.getPortIdentifiers(); if (portList.hasMoreElements()) { StringBuilder sb = new StringBuilder(); while(portList.hasMoreElements()){ CommPortIdentifier portId = (CommPortIdentifier) portList.nextElement(); sb.append(String.format("%s ",portId.getName())); } logger.error("The following communications ports are available: {}", sb.toString().trim()); } else { logger.error("There are no communications ports available"); } logger.error("You may consider OpenHAB startup parameter [ -Dgnu.io.rxtx.SerialPorts={} ]", serialPortName); throw e; } }
private void setupGenericSerialPort() throws IOException { String newPort = this.genericSerialSenderBean.getPortName(); if (rawIrSender != null && (newPort == null || newPort.equals(portName))) return; if (rawIrSender != null) rawIrSender.close(); rawIrSender = null; //genericSerialSenderBean.setVerbose(properties.getVerbose()); close(); try { rawIrSender = new IrGenericSerial(genericSerialSenderBean.getPortName(), genericSerialSenderBean.getBaud(), genericSerialSenderBean.getDataSize(), genericSerialSenderBean.getStopBits(), genericSerialSenderBean.getParity(), genericSerialSenderBean.getFlowControl(), properties.getSendingTimeout(), properties.getVerbose()); rawIrSender.setCommand(genericSerialSenderBean.getCommand()); rawIrSender.setRaw(genericSerialSenderBean.getRaw()); rawIrSender.setSeparator(genericSerialSenderBean.getSeparator()); rawIrSender.setUseSigns(genericSerialSenderBean.getUseSigns()); rawIrSender.setLineEnding(genericSerialSenderBean.getLineEnding()); } catch (NoSuchPortException | PortInUseException | UnsupportedCommOperationException | IOException ex) { // Should not happen guiUtils.error(ex); } portName = genericSerialSenderBean.getPortName(); genericSerialSenderBean.setHardware(rawIrSender); }