/**
* 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);
}
}
/** Establish the connection with the device connected to the serial port. */
public void setupSerialPort() {
try {
// If port already open, close it.
if (serialPort != null) {
serialPort.close();
serialPort = null;
}
// Initialize serial port attributes.
log.info("Fetching communication port {}", getTanitaCommPort());
CommPortIdentifier wPortId = CommPortIdentifier.getPortIdentifier(getTanitaCommPort());
log.info("Opening communication port {}", getTanitaCommPort());
serialPort = (SerialPort) wPortId.open(portOwnerName, 2000);
// Make sure the port is "Clear To Send"
serialPort.setSerialPortParams(baudeRate, dataLength, stopBit, parity);
bufferedReader = new BufferedReader(new InputStreamReader(serialPort.getInputStream()));
portIsAvailable = checkIfPortIsAvailable();
} catch (Exception wCouldNotAccessSerialPort) {
portIsAvailable = false;
log.warn("Could not access the specified serial port.");
}
}
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();
}
}
public TestSer(String port) {
try {
portId = CommPortIdentifier.getPortIdentifier(port);
serialPort = (SerialPort) portId.open("TestSer", 2000);
is = serialPort.getInputStream();
os = serialPort.getOutputStream();
/*
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
*/
serialPort.setSerialPortParams(
115200, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
serialPort.setFlowControlMode(
SerialPort.FLOWCONTROL_RTSCTS_OUT | SerialPort.FLOWCONTROL_RTSCTS_IN);
serialPort.enableReceiveTimeout(TIMEOUT);
// serialPort.enableReceiveThreshold(4);
} catch (Exception e) {
System.out.println(e.getMessage());
System.exit(-1);
}
}
/**
* Initialize this device and open the serial port.
*
* @throws InitializationException if port can not be opened
*/
void initialize() throws InitializationException {
try {
// parse ports and if the default port is found, initialized the reader
portId = CommPortIdentifier.getPortIdentifier(port);
// initialize serial port
serialPort = portId.open("openHAB", 2000);
// set port parameters
serialPort.setSerialPortParams(baud, databits, stopbit, parity);
inputStream = serialPort.getInputStream();
outputStream = serialPort.getOutputStream();
} catch (UnsupportedCommOperationException e) {
throw new InitializationException(e);
} catch (IOException e) {
throw new InitializationException(e);
} catch (PortInUseException e) {
throw new InitializationException(e);
} catch (NoSuchPortException e) {
// enumerate the port identifiers in the exception to be helpful
final StringBuilder sb = new StringBuilder();
@SuppressWarnings("unchecked")
Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();
while (portList.hasMoreElements()) {
final CommPortIdentifier id = 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());
}
}
@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.
}
}
public void open() throws IOException {
try {
if (portName != null) {
portId = CommPortIdentifier.getPortIdentifier(portName);
}
if (portId == null) {
throw new IOException("Invalid port " + portName);
}
serialPort = (SerialPort) portId.open(portId.getName(), baudRate);
if (portId == null) {
throw new IOException("Invalid port " + portName);
}
serialPort.setSerialPortParams(
baudRate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
serialPort.notifyOnOutputEmpty(true);
outputStream = serialPort.getOutputStream();
inputStream = serialPort.getInputStream();
Logger.getLogger(SerialDevice.class.getName())
.log(Level.INFO, "Connection Stabilished with {0}", serialPort.getName());
} catch (Exception e) {
e.printStackTrace();
Logger.getLogger(SerialDevice.class.getName())
.log(Level.SEVERE, "Could not init the device on " + serialPort.getName(), e);
serialPort.close();
}
}
/**
* Gets the serial port on the given port name. Throws an {@link IOException} if it does not
* succeed in doing so.
*
* @param portName The port name.
* @return The port.
* @throws IOException If the port could not be opened.
*/
private final SerialPort getSerialPort(final String portName) throws IOException {
try {
final CommPortIdentifier identifier = CommPortIdentifier.getPortIdentifier(portName);
if (identifier.isCurrentlyOwned()) {
throw new IOException(
"The port specified ["
+ portName
+ "] is already in use by ["
+ identifier.getCurrentOwner()
+ "] !");
}
final CommPort rawPort = identifier.open("DOM_SER_DRV", 2000);
if (rawPort instanceof SerialPort) {
final SerialPort port = (SerialPort) rawPort;
port.setSerialPortParams(
BAUDRATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
return port;
} else {
throw new IOException("Port [" + portName + "] is not a serial port !");
}
} catch (NoSuchPortException e) {
throw new IOException("The port specified [" + portName + "] does not exist !", e);
} catch (PortInUseException e) {
throw new IOException("The port specified [" + portName + "] is already in use !");
} catch (UnsupportedCommOperationException e) {
throw new IOException("Unsupported comm operation when setting the serial parameters !", e);
}
}
@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 static void main(String[] args)
throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException,
IOException, ParseException {
if (args.length != 2) {
System.err.println("Usage: <prog> portDevice hexfile.hex");
System.exit(1);
}
STM32BootLoader me = new STM32BootLoader();
CommPortIdentifier comident = CommPortIdentifier.getPortIdentifier(args[0]);
SerialPort sp = (SerialPort) comident.open("STM32BootLoader", 200);
sp.setSerialPortParams(
57600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_EVEN);
sp.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
// Setup serial port and reply timeout. Found that such a long timeout
// IS necessary.
me.setSerialPort(sp, 5000);
try {
File f = new File(args[1]);
byte[] image = HexFileParser.parseFile(f);
me.program(image, false, 0);
} finally {
me.close();
}
}
private void init() {
try {
if (m_out == null) {
m_PortIdPrinter = CommPortIdentifier.getPortIdentifier(m_sPort); // Tomamos el puerto
m_CommPortPrinter = m_PortIdPrinter.open("PORTID", 2000); // Abrimos el puerto
m_out = m_CommPortPrinter.getOutputStream(); // Tomamos el chorro de escritura
if (m_PortIdPrinter.getPortType() == CommPortIdentifier.PORT_SERIAL) {
((SerialPort) m_CommPortPrinter)
.setSerialPortParams(
9600,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE); // Configuramos el puerto
} else if (m_PortIdPrinter.getPortType() == CommPortIdentifier.PORT_PARALLEL) {
((ParallelPort) m_CommPortPrinter).setMode(1);
}
}
} catch (Exception e) {
m_PortIdPrinter = null;
m_CommPortPrinter = null;
m_out = null;
m_in = null;
// } catch (NoSuchPortException e) {
// } catch (PortInUseException e) {
// } catch (UnsupportedCommOperationException e) {
// } catch (IOException e) {
}
}
public String openPort(String portName, String appName) {
// open the port, check ability to set moderators
try {
// get and open the primary port
CommPortIdentifier portID = CommPortIdentifier.getPortIdentifier(portName);
try {
activeSerialPort = (SerialPort) portID.open(appName, 2000); // name of program, msec to wait
} catch (PortInUseException p) {
return handlePortBusy(p, portName, log);
}
// try to set it for communication via SerialDriver
try {
activeSerialPort.setSerialPortParams(
9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
} catch (gnu.io.UnsupportedCommOperationException e) {
log.error("Cannot set serial parameters on port " + portName + ": " + e.getMessage());
return "Cannot set serial parameters on port " + portName + ": " + e.getMessage();
}
// set RTS high, DTR high
activeSerialPort.setRTS(true); // not connected in some serial ports and adapters
activeSerialPort.setDTR(true); // pin 1 in DIN8; on main connector, this is DTR
// disable flow control; hardware lines used for signaling, XON/XOFF might appear in data
activeSerialPort.setFlowControlMode(0);
activeSerialPort.enableReceiveTimeout(50); // 50 mSec timeout before sending chars
// set timeout
// activeSerialPort.enableReceiveTimeout(1000);
log.debug(
"Serial timeout was observed as: "
+ activeSerialPort.getReceiveTimeout()
+ " "
+ activeSerialPort.isReceiveTimeoutEnabled());
// get and save stream
serialStream = activeSerialPort.getInputStream();
// purge contents, if any
purgeStream(serialStream);
// report status
if (log.isInfoEnabled()) {
log.info(
"Wangrow " + portName + " port opened at " + activeSerialPort.getBaudRate() + " baud");
}
opened = true;
} catch (gnu.io.NoSuchPortException p) {
return handlePortNotFound(p, portName, log);
} catch (Exception ex) {
log.error("Unexpected exception while opening port " + portName + " trace follows: " + ex);
ex.printStackTrace();
return "Unexpected error while opening port " + portName + ": " + ex;
}
return null; // indicates OK return
}
public HittPolling(String comport, int baudrate) {
_baudrate = baudrate;
try {
CommPortIdentifier com = CommPortIdentifier.getPortIdentifier(comport);
_comPortIdent = com;
_usable = true;
} catch (NoSuchPortException e) {
_usable = false;
PLog.error("There is no COM-Port called: " + comport, e);
}
}
public static SerialPort openPortByName(String name, int baudRate) {
SerialPort port = null;
try {
CommPortIdentifier identifier = CommPortIdentifier.getPortIdentifier(name);
port = (SerialPort) identifier.open("SerialPort", 2000);
port.setSerialPortParams(
baudRate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
} catch (PortInUseException | NoSuchPortException | UnsupportedCommOperationException ex) {
ErrorDialog dialog = new ErrorDialog(null, true, ex.getMessage());
ComponentPosition.centerFrame(dialog);
dialog.setVisible(true);
}
return port;
}
@Override
public List<String> getComPortAvailable() {
final List<String> ret = new ArrayList<String>();
for (final String comPortId : commPorstIds) {
try {
CommPortIdentifier.getPortIdentifier(comPortId);
ret.add(comPortId);
} catch (Exception e) {
System.out.println(comPortId + " unavailable");
}
}
return ret;
}
@SuppressWarnings("unchecked")
public SerialTransmitController(String port, String rts_or_dtr) throws Exception {
CommPortIdentifier pi = null;
try {
pi = CommPortIdentifier.getPortIdentifier(port);
} catch (NoSuchPortException nspe) {
String port_names = "";
boolean comma = false;
Enumeration<CommPortIdentifier> ports = CommPortIdentifier.getPortIdentifiers();
while (ports.hasMoreElements()) {
CommPortIdentifier portIdentifier = ports.nextElement();
if (comma) port_names += ",";
port_names += portIdentifier.getName();
comma = true;
}
throw new IOException(
String.format("Port %s is not valid (valid ports are %s)", port, port_names));
}
CommPort ptt_comm_port = null;
try {
ptt_comm_port = pi.open(this.getClass().getName(), 1000);
} catch (PortInUseException piue) {
throw new IOException(String.format("Port %s is in use", port));
}
if (ptt_comm_port instanceof SerialPort) {
ptt_serial_port = (SerialPort) ptt_comm_port;
// serialPort.setSerialPortParams(57600,SerialPort.DATABITS_8,
// SerialPort.STOPBITS_1,SerialPort.PARITY_NONE);
} else {
System.err.println("5");
throw new IOException(String.format("Port %s is not a serial port", port));
}
ptt_serial_port.setRTS(false);
ptt_serial_port.setDTR(false);
System.err.println("Opened a PTT port: " + port);
if (rts_or_dtr.equalsIgnoreCase("RTS")) {
rts = true;
return;
}
if (rts_or_dtr.equalsIgnoreCase("DTR")) {
dtr = true;
return;
}
throw new IOException(String.format("Signal %s is not valid (must be RTS or DTR)", rts_or_dtr));
}
/**
* This constructs a SonarPingModel
*
* @param comPortName port which the sensor is pluged in
*/
SonarPingModel(String comPortName) {
try {
// Identifying the port
this.basicPort = CommPortIdentifier.getPortIdentifier(comPortName);
this.port = (SerialPort) this.basicPort.open("", 1);
// Port Settings
port.setSerialPortParams(
9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
// Input and Output Streams to write to the port
output = port.getOutputStream();
input = new BufferedReader(new InputStreamReader(this.port.getInputStream()));
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Start call.
*
* @throws Exception the exception
*/
public void startCall() throws Exception {
CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(this.streamPortName);
if (portIdentifier.isCurrentlyOwned()) {
logger.error("Serial port " + this.streamPortName + " is currently in use");
}
CommPort commPort = portIdentifier.open(this.getClass().getName(), 2000);
if (commPort instanceof SerialPort) {
voiceStreamCommPort = (SerialPort) commPort;
voiceStreamCommPort.setSerialPortParams(
230400, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
voiceInputStream = new DataInputStream(voiceStreamCommPort.getInputStream());
voiceOutputStream = new DataOutputStream(voiceStreamCommPort.getOutputStream());
serialVoiceReader = new SerialVoiceReader(voiceInputStream, af);
serialVoiceWriter = new SerialVoiceWriter(voiceOutputStream, af, playMessage);
(new Thread(serialVoiceReader, "VoiceReader")).start();
(new Thread(serialVoiceWriter, "VoiceWriter")).start();
}
}
/** @param data */
@Override
protected void internalWrite(byte[] data) {
try {
if (m_out == null) {
m_PortIdPrinter =
CommPortIdentifier.getPortIdentifier(
m_sPortPrinter); // Tomamos el puerto
m_CommPortPrinter = m_PortIdPrinter.open("PORTID", 2000); // Abrimos el puerto
m_out = m_CommPortPrinter.getOutputStream(); // Tomamos el chorro de escritura
if (m_PortIdPrinter.getPortType() == CommPortIdentifier.PORT_SERIAL) {
((SerialPort) m_CommPortPrinter)
.setSerialPortParams(
9600,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE); // Configuramos el puerto
((SerialPort) m_CommPortPrinter)
.setFlowControlMode(
SerialPort
.FLOWCONTROL_RTSCTS_IN); // this line prevents the printer tmu220 to stop
// printing after +-18 lines printed
// this line prevents the printer tmu220 to stop printing after +-18 lines printed. Bug
// 8324
// But if added a regression error appears. Bug 9417, Better to keep it commented.
// ((SerialPort)m_CommPortPrinter).setFlowControlMode(SerialPort.FLOWCONTROL_RTSCTS_IN);
// Not needed to set parallel properties
// } else if (m_PortIdPrinter.getPortType() ==
// CommPortIdentifier.PORT_PARALLEL) {
// ((ParallelPort)m_CommPortPrinter).setMode(1);
}
}
m_out.write(data);
// JG 16 May 12 use multicatch
} catch (NoSuchPortException
| PortInUseException
| UnsupportedCommOperationException
| IOException e) {
System.err.println(e);
}
}
public static void readFromArduino() throws Exception {
// for linux
// CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier("/dev/ttyACM3");
// for windows
CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier("COM5");
// CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier("COM4");
SerialPort port = (SerialPort) portId.open("serial talk", 4000);
input = port.getInputStream();
port.setSerialPortParams(
9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
while (true) {
if (input.available() > 0) {
System.out.print((char) (input.read()));
}
}
}
@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 CardReader(String portName)
throws IOException, PortInUseException, UnsupportedCommOperationException,
NoSuchPortException {
CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
if (portIdentifier.isCurrentlyOwned()) {
System.out.println("Error: Port is currently in use");
} else {
int timeout = 2000;
CommPort commPort = portIdentifier.open(this.getClass().getName(), timeout);
if (commPort instanceof SerialPort) {
SerialPort serialPort = (SerialPort) commPort;
serialPort.setSerialPortParams(
9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
in = serialPort.getInputStream();
} else {
System.out.println("Error: Only serial ports are handled by this example.");
}
}
}
/** @see com.svhelloworld.knotlog.engine.sources.StreamedSource#open() */
@Override
public InputStream open() {
try {
// make sure the specified port is available
CommPortIdentifier identifier = CommPortIdentifier.getPortIdentifier(config.getName());
if (identifier.isCurrentlyOwned()) {
throw new SerialPortOccupiedException(
config.getName() + " port is currently opened by another application");
}
// open up the port
CommPort port = identifier.open(getOwnerName(), PORT_TIMEOUT);
if (port instanceof SerialPort) {
// configure serial port
serialPort = (SerialPort) port;
serialPort.setSerialPortParams(
config.getBaudRate(),
config.getDataBits().getRXTXConstant(),
config.getStopBit().getRXTXConstant(),
config.getParity().getRXTXConstant());
/*
* the following 2 lines fix the exception:
* "IOException: Underlying input stream returned zero bytes"
* that is thrown when we read from the InputStream.
*/
serialPort.enableReceiveTimeout(PORT_TIMEOUT);
serialPort.enableReceiveThreshold(0);
InputStream is = serialPort.getInputStream();
return is;
}
// not a serial port
throw new SerialPortException("must operate against a serial port");
} catch (PortInUseException e) {
throw new SerialPortOccupiedException(e.getMessage(), e);
} catch (Exception e) {
throw new SerialPortException(e.getMessage(), e);
}
}
private SerialPort connectSerial(String portName)
throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException {
SerialPort serialPort = null;
CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
if (portIdentifier.isCurrentlyOwned()) {
System.out.println("Error: Port is currently in use");
} else {
CommPort commPort = portIdentifier.open(this.getClass().getName(), 2000);
if (commPort instanceof SerialPort) {
serialPort = (SerialPort) commPort;
serialPort.setSerialPortParams(
57600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
// serialPort.setSerialPortParams(115200, SerialPort.DATABITS_8,
// SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
} else {
System.out.println("Error: Only serial ports are handled by this example.");
}
}
return serialPort;
}
void connect(String portName) throws Exception {
CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
if (portIdentifier.isCurrentlyOwned()) {
System.out.println("Error: Port is currently in use");
} else {
CommPort commPort = portIdentifier.open(this.getClass().getName(), 2000);
if (commPort instanceof SerialPort) {
SerialPort mSerialPort = (SerialPort) commPort;
mSerialPort.setSerialPortParams(
57600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
InputStream mIn = mSerialPort.getInputStream();
OutputStream mOut = mSerialPort.getOutputStream();
(new Thread(new SerialReader(mIn))).start();
(new Thread(new SerialWriter(mOut))).start();
} else {
System.out.println("Error: Only serial ports are handled by this example.");
}
}
}
/** 通过串口向单片机写入数据 */
public boolean portWrite() {
boolean notFinished = true;
try {
// get port ID
CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier(this.portName);
// open port(port holder, timeout),打开端口（串口所有者，超时等待时间:ms）
try {
this.sPort = (SerialPort) portId.open("可爱的皮卡丘", this.timeout);
// set port(BaudRate,Databits,Stopbits,Parity),设置串口（波特率，数据位，停止位，校验位）
try {
this.sPort.setSerialPortParams(
9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
} catch (UnsupportedCommOperationException e) {
e.printStackTrace();
}
// 写入数据
OutputStream OS = null;
try {
OS = new BufferedOutputStream(sPort.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
// 选择操作
System.out.println("选择一下操作： 静止按1； 前进按2； 后退按3; 结束操作按4.");
int command = s.nextInt();
switch (command) {
case 1:
try {
OS.write(this.stop);
} catch (IOException e) {
e.printStackTrace();
}
break;
case 2:
try {
OS.write(this.forward);
} catch (IOException e) {
e.printStackTrace();
}
break;
case 3:
try {
OS.write(this.backward);
} catch (IOException e) {
e.printStackTrace();
}
break;
case 4:
notFinished = false;
break;
}
try {
OS.close();
} catch (IOException e) {
e.printStackTrace();
}
this.sPort.close();
} catch (PortInUseException e) {
e.printStackTrace();
}
} catch (NoSuchPortException e) {
e.printStackTrace();
}
return notFinished;
}
public synchronized String openPort(String portName, String appName) {
// open the port, check ability to set moderators
try {
// get and open the primary port
CommPortIdentifier portID = CommPortIdentifier.getPortIdentifier(portName);
try {
activeSerialPort = (SerialPort) portID.open(appName, 2000); // name of program, msec to wait
} catch (PortInUseException p) {
handlePortBusy(p, portName);
return "Port " + p + " in use already";
}
// try to set it for communication via SerialDriver
try {
// Doc says 7 bits, but 8 seems needed
activeSerialPort.setSerialPortParams(
38400, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
} catch (gnu.io.UnsupportedCommOperationException e) {
log.error("Cannot set serial parameters on port " + portName + ": " + e.getMessage());
return "Cannot set serial parameters on port " + portName + ": " + e.getMessage();
}
// set RTS high, DTR high
activeSerialPort.setRTS(true); // not connected in some serial ports and adapters
activeSerialPort.setDTR(true); // pin 1 in DIN8; on main connector, this is DTR
// disable flow control; hardware lines used for signaling, XON/XOFF might appear in data
activeSerialPort.setFlowControlMode(0);
// set timeout
log.debug(
"Serial timeout was observed as: "
+ activeSerialPort.getReceiveTimeout()
+ " "
+ activeSerialPort.isReceiveTimeoutEnabled());
// get and save stream
serialStream = new DataInputStream(activeSerialPort.getInputStream());
ostream = activeSerialPort.getOutputStream();
// make less verbose
sendBytes(new byte[] {(byte) 'L', (byte) '-', 10, 13});
// purge contents, if any
int count = serialStream.available();
log.debug("input stream shows " + count + " bytes available");
while (count > 0) {
serialStream.skip(count);
count = serialStream.available();
}
// report status?
if (log.isInfoEnabled()) {
log.info(
portName
+ " port opened at "
+ activeSerialPort.getBaudRate()
+ " baud, sees "
+ " DTR: "
+ activeSerialPort.isDTR()
+ " RTS: "
+ activeSerialPort.isRTS()
+ " DSR: "
+ activeSerialPort.isDSR()
+ " CTS: "
+ activeSerialPort.isCTS()
+ " CD: "
+ activeSerialPort.isCD());
}
} catch (java.io.IOException ex) {
log.error("IO error while opening port " + portName, ex);
return "IO error while opening port " + portName + ": " + ex;
} catch (gnu.io.UnsupportedCommOperationException ex) {
log.error("Unsupported communications operation while opening port " + portName, ex);
return "Unsupported communications operation while opening port " + portName + ": " + ex;
} catch (gnu.io.NoSuchPortException ex) {
log.error("No such port: " + portName, ex);
return "No such port: " + portName + ": " + ex;
}
return null; // indicates OK return
}
/**
* Opens the Operation System Serial Port
*
* <p>This method opens the port and set Serial Port parameters according to the DSMR
* specification. Since the specification is clear about these parameters there are not
* configurable.
*
* <p>If there are problem while opening the port, it is the responsibility of the calling method
* to handle this situation (and for example close the port again).
*
* <p>Opening an already open port is harmless. The method will return immediately
*
* @return true if opening was successful (or port was already open), false otherwise
*/
private boolean open() {
synchronized (portLock) {
// Sanity check
if (portState != PortState.CLOSED) {
return true;
}
try {
// Opening Operating System Serial Port
logger.debug("Creating CommPortIdentifier");
CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
logger.debug("Opening CommPortIdentifier");
CommPort commPort = portIdentifier.open("org.openhab.binding.dsmr", readTimeoutMSec);
logger.debug("Configure serial port");
serialPort = (SerialPort) commPort;
serialPort.enableReceiveThreshold(1);
serialPort.enableReceiveTimeout(readTimeoutMSec);
// Configure Serial Port based on specified port speed
logger.debug("Configure serial port speed " + portSpeed);
switch (portSpeed) {
case LOW_SPEED:
serialPort.setSerialPortParams(
9600, SerialPort.DATABITS_7, SerialPort.STOPBITS_1, SerialPort.PARITY_EVEN);
serialPort.setDTR(false);
serialPort.setRTS(true);
break;
case HIGH_SPEED:
serialPort.setSerialPortParams(
115200, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
break;
default:
logger.error("Invalid speed, closing port");
return false;
}
} catch (NoSuchPortException nspe) {
logger.error("Could not open port: " + portName, nspe);
return false;
} catch (PortInUseException piue) {
logger.error("Port already in use: " + portName, piue);
return false;
} catch (UnsupportedCommOperationException ucoe) {
logger.error("Port is not suitable: " + portName, ucoe);
return false;
}
// SerialPort is ready, open the reader
logger.info("SerialPort opened successful");
try {
bis = new BufferedInputStream(serialPort.getInputStream());
} catch (IOException ioe) {
logger.error("Failed to get inputstream for serialPort. Closing port", ioe);
return false;
}
logger.info("DSMR Port opened successful");
return true;
}
}
public String openPort(String portName, String appName) {
// open the port in XPressNet mode, check ability to set moderators
try {
// get and open the primary port
CommPortIdentifier portID = CommPortIdentifier.getPortIdentifier(portName);
try {
activeSerialPort = (SerialPort) portID.open(appName, 2000); // name of program, msec to wait
} catch (PortInUseException p) {
return handlePortBusy(p, portName, log);
}
// try to set it for XNet
try {
setSerialPort();
} catch (gnu.io.UnsupportedCommOperationException e) {
log.error("Cannot set serial parameters on port " + portName + ": " + e.getMessage());
return "Cannot set serial parameters on port " + portName + ": " + e.getMessage();
}
// set timeout
try {
activeSerialPort.enableReceiveTimeout(10);
log.debug(
"Serial timeout was observed as: "
+ activeSerialPort.getReceiveTimeout()
+ " "
+ activeSerialPort.isReceiveTimeoutEnabled());
} catch (Exception et) {
log.info("failed to set serial timeout: " + et);
}
// get and save stream
serialStream = activeSerialPort.getInputStream();
// purge contents, if any
purgeStream(serialStream);
// report status?
if (log.isInfoEnabled()) {
// report now
log.info(
portName
+ " port opened at "
+ activeSerialPort.getBaudRate()
+ " baud with"
+ " DTR: "
+ activeSerialPort.isDTR()
+ " RTS: "
+ activeSerialPort.isRTS()
+ " DSR: "
+ activeSerialPort.isDSR()
+ " CTS: "
+ activeSerialPort.isCTS()
+ " CD: "
+ activeSerialPort.isCD());
}
if (log.isDebugEnabled()) {
// report additional status
log.debug(
" port flow control shows "
+ (activeSerialPort.getFlowControlMode() == SerialPort.FLOWCONTROL_RTSCTS_OUT
? "hardware flow control"
: "no flow control"));
}
// arrange to notify later
activeSerialPort.addEventListener(
new SerialPortEventListener() {
public void serialEvent(SerialPortEvent e) {
int type = e.getEventType();
switch (type) {
case SerialPortEvent.DATA_AVAILABLE:
if (log.isDebugEnabled()) {
log.debug("SerialEvent: DATA_AVAILABLE is " + e.getNewValue());
}
return;
case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
if (log.isDebugEnabled()) {
log.debug("SerialEvent: OUTPUT_BUFFER_EMPTY is " + e.getNewValue());
}
setOutputBufferEmpty(true);
return;
case SerialPortEvent.CTS:
if (log.isDebugEnabled()) {
log.debug("SerialEvent: CTS is " + e.getNewValue());
}
return;
case SerialPortEvent.DSR:
if (log.isDebugEnabled()) {
log.debug("SerialEvent: DSR is " + e.getNewValue());
}
return;
case SerialPortEvent.RI:
if (log.isDebugEnabled()) {
log.debug("SerialEvent: RI is " + e.getNewValue());
}
return;
case SerialPortEvent.CD:
if (log.isDebugEnabled()) {
log.debug("SerialEvent: CD is " + e.getNewValue());
}
return;
case SerialPortEvent.OE:
if (log.isDebugEnabled()) {
log.debug("SerialEvent: OE (overrun error) is " + e.getNewValue());
}
return;
case SerialPortEvent.PE:
if (log.isDebugEnabled()) {
log.debug("SerialEvent: PE (parity error) is " + e.getNewValue());
}
return;
case SerialPortEvent.FE:
if (log.isDebugEnabled()) {
log.debug("SerialEvent: FE (framing error) is " + e.getNewValue());
}
return;
case SerialPortEvent.BI:
if (log.isDebugEnabled()) {
log.debug("SerialEvent: BI (break interrupt) is " + e.getNewValue());
}
return;
default:
if (log.isDebugEnabled()) {
log.debug(
"SerialEvent of unknown type: " + type + " value: " + e.getNewValue());
}
return;
}
}
});
try {
activeSerialPort.notifyOnFramingError(true);
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("Could not notifyOnFramingError: " + e);
}
}
try {
activeSerialPort.notifyOnBreakInterrupt(true);
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("Could not notifyOnBreakInterrupt: " + e);
}
}
try {
activeSerialPort.notifyOnParityError(true);
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("Could not notifyOnParityError: " + e);
}
}
try {
activeSerialPort.notifyOnOutputEmpty(true);
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("Could not notifyOnOutputEmpty: " + e);
}
}
try {
activeSerialPort.notifyOnOverrunError(true);
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("Could not notifyOnOverrunError: " + e);
}
}
opened = true;
} catch (gnu.io.NoSuchPortException p) {
return handlePortNotFound(p, portName, log);
} catch (IOException ioe) {
log.error("IOException exception while opening port " + portName + " trace follows: " + ioe);
ioe.printStackTrace();
return "IO exception while opening port " + portName + ": " + ioe;
} catch (java.util.TooManyListenersException tmle) {
log.error(
"TooManyListenersException while opening port " + portName + " trace follows: " + tmle);
tmle.printStackTrace();
return "Too Many Listeners exception while opening port " + portName + ": " + tmle;
}
return null; // normal operation
}
public SerialConnection(String portName) throws NoSuchPortException, PortInUseException {
mCommPortIdentifier = CommPortIdentifier.getPortIdentifier(portName);
mSerialPort = (SerialPort) mCommPortIdentifier.open(mFileDescriptor, 2000);
}
