@PostConstruct public void connect() throws TooManyListenersException, NoSuchPortException { log.info("Connection PostConstruct callback: connecting ..."); serial = new NRSerialPort(serialPortProperties.getPortName(), serialPortProperties.getBaudRate()); serial.connect(); if (serial.isConnected()) { log.info("Connection opened!"); } else { throw new RuntimeException("Is not possible to open connection in " + serialPortProperties.getPortName() + " port"); } serial.addEventListener(this); serial.notifyOnDataAvailable(true); input = new BufferedReader(new InputStreamReader(serial.getInputStream())); }
@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 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; } }
private CommPortIdentifier getSerialPort() { if (port != null) { try { return CommPortIdentifier.getPortIdentifier(port); } catch (NoSuchPortException e) { e.printStackTrace(); } return null; } Enumeration<?> portEnum = CommPortIdentifier.getPortIdentifiers(); while (portEnum.hasMoreElements()) { CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement(); for (String portName : PORT_NAMES) { if (currPortId.getName().equals(portName)) { return currPortId; } } } return null; }
@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 void connect(String portName) throws NoSuchPortException { CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier(portName); 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(); // add event listeners serialPort.addEventListener(this); serialPort.notifyOnDataAvailable(true); } catch (Exception e) { System.err.println(e.toString()); } }
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); }
/** * 打开串口 * * @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(); } }
public void connect(String port, int baudRate, int timeout) throws IOException { scan(); try { connect(CommPortIdentifier.getPortIdentifier(port), baudRate, timeout); } catch (NoSuchPortException e) { throw new IOException("No such port", 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"); }
@Override public void updated(Dictionary<String, ?> config) throws ConfigurationException { if (config == null) { return; } serialPort = (String) config.get(CONFIG_KEY_SERIAL_PORT); if (connector != null) { connector.disconnect(); } try { connect(); } catch (RuntimeException e) { if (e.getCause() instanceof NoSuchPortException) { StringBuilder sb = new StringBuilder("Available ports are:\n"); Enumeration<?> portList = CommPortIdentifier.getPortIdentifiers(); while (portList.hasMoreElements()) { CommPortIdentifier id = (CommPortIdentifier) portList.nextElement(); if (id.getPortType() == CommPortIdentifier.PORT_SERIAL) { sb.append(id.getName() + "\n"); } } sb.deleteCharAt(sb.length() - 1); throw new ConfigurationException(CONFIG_KEY_SERIAL_PORT, "Serial port '" + serialPort + "' could not be opened. " + sb.toString()); } else { throw e; } } }
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); } }
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); }
@Override public void openConnection() { try { logger.debug("openConnection(): Connecting to IT-100 "); 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); setConnected(true); } catch (NoSuchPortException noSuchPortException) { logger.error("openConnection(): No Such Port Exception: {}", noSuchPortException.getMessage()); setConnected(false); } catch (PortInUseException portInUseException) { logger.error("openConnection(): Port in Use Exception: {}", portInUseException.getMessage()); setConnected(false); } catch (UnsupportedCommOperationException unsupportedCommOperationException) { logger.error("openConnection(): Unsupported Comm Operation Exception: {}", unsupportedCommOperationException.getMessage()); setConnected(false); } catch (UnsupportedEncodingException unsupportedEncodingException) { logger.error("openConnection(): Unsupported Encoding Exception: {}", unsupportedEncodingException.getMessage()); setConnected(false); } catch (IOException ioException) { logger.error("openConnection(): IO Exception: {}", ioException.getMessage()); setConnected(false); } }
@Override public void initialize() { // Get serial port number from config cm11aConfig = getThing().getConfiguration().as(Cm11aConfig.class); logger.trace("********* cm11a initialize started *********"); // Verify the configuration is valid if (!validateConfig(this.cm11aConfig)) { return; } // Initialize the X10 interface try { x10Interface = new X10Interface(cm11aConfig.serialPort, this); x10Interface.setDaemon(true); x10Interface.start(); x10Interface.addReceivedDataListener(this); logger.info("Initialized CM11A X10 interface on: {}", cm11aConfig.serialPort); } catch (NoSuchPortException e) { x10Interface = null; logger.error("No such port exists on this machine: {}", cm11aConfig.serialPort); updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, "No such port exists on this machine: " + cm11aConfig.serialPort); return; } updateStatus(ThingStatus.ONLINE); }
/** * * @param serialPort serial port device. e.g. /dev/ttyS0 * @throws NoSuchPortException * */ public X10Interface(String serialPort, Cm11aBridgeHandler bridgeHandler) throws NoSuchPortException { super(); logger.trace("**** Constructing X10Interface for serial port: {} *******", serialPort); portId = CommPortIdentifier.getPortIdentifier(serialPort); this.bridgeHandler = bridgeHandler; }
private void openPort() throws IOException, NoSuchPortException, PortInUseException, UnsupportedCommOperationException{ CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(port); CommPort commPort = portIdentifier.open("LightController",2000); if ( commPort instanceof SerialPort ) { serialPort = (SerialPort) commPort; serialPort.setSerialPortParams(baud,SerialPort.DATABITS_8,SerialPort.STOPBITS_1,SerialPort.PARITY_NONE); this.out = 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); // Clear received buffers connector.clearReceiveBuffer(); 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); } }
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; } }
void connect(String portName) throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException, IOException{ CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName); if (portIdentifier.isCurrentlyOwned()) { logger.warn("Error: Port is currently in use"); } else { CommPort commPort = portIdentifier.open(this.getClass().getName(), 2000); if (commPort instanceof SerialPort) { SerialPort serialPort = (SerialPort) commPort; serialPort.setSerialPortParams(1200, SerialPort.DATABITS_7, SerialPort.STOPBITS_2, SerialPort.PARITY_EVEN); serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_RTSCTS_IN | SerialPort.FLOWCONTROL_RTSCTS_OUT); serialPort.setDTR(true); logger.debug("Opening connection to " + portName); logger.debug("BaudRate: " + serialPort.getBaudRate()); logger.debug("STPB/DTB/PAR: " + serialPort.getStopBits() + " " + serialPort.getDataBits() + " " + serialPort.getParity()); logger.debug("FCM: " + serialPort.getFlowControlMode() + " should be: " + (SerialPort.FLOWCONTROL_RTSCTS_IN | SerialPort.FLOWCONTROL_RTSCTS_OUT)); logger.debug("CTS/CD/DTR/DSR/RTS: " + serialPort.isCTS() + " " + serialPort.isCD() + " " + serialPort.isDTR() + " " + serialPort.isDSR() + " " + serialPort.isRTS()); InputStream in = serialPort.getInputStream(); //OutputStream out = serialPort.getOutputStream(); reader = new CobasMiraSerialReader(in, serialPort); cobasMiraReader = new Thread(reader); cobasMiraReader.start(); logger.debug("Reader Thread ID: " + cobasMiraReader.getId() + " Priority: " + cobasMiraReader.getPriority() + " Name: " + cobasMiraReader.getName()); //serialPort.setDTR(true); //(new Thread(new SerialWriter(out))).start(); } else { logger.warn("Error: Only serial ports are handled by this example."); } } }
public void setControllerPort(String portName) throws NoSuchPortException { this.controllerPort = CommPortIdentifier.getPortIdentifier(portName); }
public PortRXTX(String portName, int rate, int databits, int stopbits, int parity) throws IOException, PortInUseException, UnsupportedCommOperationException, NoSuchPortException { super(portName, rate, databits, stopbits, parity); commPortId = CommPortIdentifier.getPortIdentifier(portName); }
/** * Sets up the test objects. * * @throws Exception * Any exception */ @Before public void setUp() throws Exception { this.connectionFactory=new RXTXCommPortConnectionFactory() { /** * This function returns the COMM port identifier object. * * @param portName * The port name * @return The port identifier object * @throws NoSuchPortException * In case no such port exists */ @Override protected CommPortIdentifier getPortIdentifier(String portName) throws NoSuchPortException { CommPortIdentifier commPortIdentifier=Mockito.mock(CommPortIdentifier.class); try { CommPort commPort=Mockito.mock(CommPort.class); Mockito.when(commPort.getInputStream()).thenReturn(new ByteArrayInputStream(new byte[0])); Mockito.when(commPort.getOutputStream()).thenReturn(new ByteArrayOutputStream()); Mockito.when(commPortIdentifier.open("fax4j",123)).thenReturn(commPort); } catch(Exception exception) { throw new RuntimeException(exception); } return commPortIdentifier; } }; Properties configuration=new Properties(); configuration.setProperty("org.fax4j.spi.comm.port.name","abc"); configuration.setProperty("org.fax4j.spi.comm.connection.factory.class.name",RXTXCommPortConnectionFactory.class.getName()); configuration.setProperty("org.fax4j.spi.comm.fax.modem.class.name",TestFaxModemAdapter.class.getName()); configuration.setProperty("org.fax4j.spi.comm.connection.timeout","123"); CommFaxClientSpi faxClientSpi=(CommFaxClientSpi)TestUtil.createFaxClientSpi(CommFaxClientSpi.class.getName(),configuration); this.connectionFactory.initialize(faxClientSpi); }
public SerialGirsClient(String portName, int baudRate) throws HarcHardwareException, IOException, NoSuchPortException, PortInUseException, UnsupportedCommOperationException { this(new LocalSerialPortBuffered(portName, baudRate)); }
public SerialGirsClient(String portName) throws HarcHardwareException, IOException, NoSuchPortException, PortInUseException, UnsupportedCommOperationException { this(new LocalSerialPortBuffered(portName)); }
public TcpGirsClient(String ipName, int portNumber) throws HarcHardwareException, IOException, NoSuchPortException, PortInUseException, UnsupportedCommOperationException { this(new TcpSocketPort(ipName, portNumber));//, defaultSerialTimeout, verbose, TcpSocketPort.ConnectionMode.keepAlive)); }
public static void main(String[] args) throws UnsupportedCommOperationException, PortInUseException, NoSuchPortException, InterruptedException, IOException { ArduinoInteraction a=new ArduinoInteraction(args); a.arduinoScreenPositiontoAngle(new int[]{50,50}, 100,100); a.flush(); a.close(); }
/** * {@inheritDoc} **/ @Override public void open() { logger.debug("open(): Opening Serial Connection"); 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(); setInput(serialPort.getInputStream()); setOutput(serialPort.getOutputStream()); getOutput().flush(); if (getInput().markSupported()) { getInput().reset(); } setReaderThread(new SerialReaderThread(getInput(), this)); getReaderThread().start(); setConnected(true); } catch (NoSuchPortException noSuchPortException) { logger.debug("open(): No Such Port Exception: {}", noSuchPortException.getMessage()); setConnected(false); } catch (PortInUseException portInUseException) { logger.debug("open(): Port in Use Exception: {}", portInUseException.getMessage()); setConnected(false); } catch (UnsupportedCommOperationException unsupportedCommOperationException) { logger.debug("open(): Unsupported Comm Operation Exception: {}", unsupportedCommOperationException.getMessage()); setConnected(false); } catch (UnsupportedEncodingException unsupportedEncodingException) { logger.debug("open(): Unsupported Encoding Exception: {}", unsupportedEncodingException.getMessage()); setConnected(false); } catch (IOException ioException) { logger.debug("open(): IO Exception: ", ioException.getMessage()); setConnected(false); } }