public int setUpBam() {
Enumeration<?> portIdentifiers = CommPortIdentifier.getPortIdentifiers();
CommPortIdentifier portId = null;
while (portIdentifiers.hasMoreElements()) {
CommPortIdentifier pid = (CommPortIdentifier) portIdentifiers.nextElement();
if (pid.getPortType() == CommPortIdentifier.PORT_SERIAL
&& pid.getName().equals(wantedPortName)) {
portId = pid;
System.out.println("Found port: " + pid.getName());
break;
}
}
try {
port = (SerialPort) portId.open("Driver", 10000);
} catch (PortInUseException e) {
System.err.println("Port already in use: " + e);
System.exit(1);
}
try {
port.setSerialPortParams(
57600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
} catch (UnsupportedCommOperationException e) {
System.err.println("Failed to set up port: " + e);
}
System.out.println("Port should be open now");
return 0;
}
/**
* This creates an mbed object for an mbed connected over Serial. <br>
* Using this class requires the Sun Communications API to be installed
*
* @param PortName The Serial Port mbed is connected to eg "COM5" on Windows.
* @param Baud The baud rate
*/
public SerialRPC(String PortName, int Baud) {
// open serial port
try {
mbedPortID = CommPortIdentifier.getPortIdentifier(PortName);
mbedPort = mbedPortID.open("mbed", 100000);
mbedSerialPort = (SerialPort) mbedPort;
mbedSerialPort.setSerialPortParams(
Baud, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
inputStream = new DataInputStream(mbedPort.getInputStream());
outputStream = new PrintStream(mbedPort.getOutputStream(), true);
reader = new BufferedReader(new InputStreamReader(inputStream));
to_mbed = new PrintWriter(outputStream, true);
mbedSerialPort.addEventListener(this);
// Important to set this regardless of whether interrupts are in use to keep the buffer clear
mbedSerialPort.notifyOnDataAvailable(true);
} catch (TooManyListenersException e) {
// Error adding event listener
System.out.println("Too many Event Listeners");
} catch (NoSuchPortException e) {
System.out.println("No Such Port");
} catch (PortInUseException e) {
System.out.println("Port Already In Use");
} catch (UnsupportedCommOperationException e) {
System.out.println("Unsupported Comm Operation");
} catch (IOException e) {
System.out.println("Serial Port IOException");
}
}
public SimpleRead() {
try {
/*
* open方法打开通讯端口
* ，
* 获得一个CommPort对象
* 。
* 它使程序独占端口
* 。
* 如果端口正被其他应用程序占用
* ，将使用
* CommPortOwnershipListener事件机制
* ，
* 传递一个PORT_OWNERSHIP_REQUESTED事件
* 。
* 每个端口都关联一个
* InputStream
* 何一个OutputStream
* 。
* 如果端口是用open方法打开的
* ，
* 那么任何的getInputStream都将返回相同的数据流对象
* ，
* 除非有close
* 被调用
* 。有两个参数
* ，
* 第一个为应用程序名
* ；
* 第二个参数是在端口打开时阻塞等待的毫秒数
* 。
*/
serialPort = (SerialPort) portId.open("packinglinesmanage", 2000);
} catch (PortInUseException e) {
}
try {
inputStream = serialPort.getInputStream(); /* 获取端口的输入流对象 */
} catch (IOException e) {
}
try {
serialPort.addEventListener(this); /* 注册一个SerialPortEventListener事件来监听串口事件 */
} catch (TooManyListenersException e) {
}
serialPort.notifyOnDataAvailable(true); /* 数据可用 */
try {
serialPort.setSerialPortParams(
9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); /*
* 设置串口初始化参数，
* 依次是波特率
* ，数据位
* ，停止位和校验
*/
} catch (UnsupportedCommOperationException e) {
}
readThread = new Thread(this);
readThread.start();
}
/*! This method initializes the input and output stream member
variables. It throws an exception if the COM port identifier
is not found.
*/
private void initSerial() throws Exception {
CommPortIdentifier portId =
CommPortIdentifier.getPortIdentifier(
comPort); // get the port ID for the port name received through command line
if (portId == null) {
throw new NullPointerException("no com port identifier");
}
serPort = (SerialPort) portId.open("Shake", 5000); // open the serial Port
outStream = serPort.getOutputStream(); // get output stream to the serial port
inStream = serPort.getInputStream(); // get input stram to the serial port
inBufReader = new BufferedReader(new InputStreamReader(inStream));
}
public Connection(String device, Dumper dumper)
throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException,
IOException {
this.device = device;
this.dumper = dumper;
this.portIdentifier = CommPortIdentifier.getPortIdentifier(this.device);
this.serialPort = (SerialPort) portIdentifier.open(this.getClass().getName(), 2000);
this.serialPort.setSerialPortParams(
57600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
this.inputStream = this.serialPort.getInputStream();
this.outputStream = this.serialPort.getOutputStream();
}
public void open()
throws NoSuchPortException, PortInUseException, IOException,
UnsupportedCommOperationException {
portId = CommPortIdentifier.getPortIdentifier(portName);
port = (SerialPort) portId.open(CLASS_NAME, 0);
in = port.getInputStream();
out = port.getOutputStream();
port.setFlowControlMode(SerialPort.FLOWCONTROL_RTSCTS_IN);
port.setFlowControlMode(SerialPort.FLOWCONTROL_RTSCTS_OUT);
printPortStatus();
port.setSerialPortParams(
19200, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
printPortStatus();
}
public void connection() {
try {
portId = CommPortIdentifier.getPortIdentifier("COM10");
sPort = (SerialPort) portId.open("COM10", 1000);
sPort.setSerialPortParams(9600, 8, 1, sPort.PARITY_NONE);
is = sPort.getInputStream();
os = sPort.getOutputStream();
dis = new DataInputStream(is);
dos = new DataOutputStream(os);
} catch (NoSuchPortException e) {
System.out.println("No Port\n" + e);
} catch (PortInUseException e) {
System.out.println("Port\n" + e);
} catch (UnsupportedCommOperationException e) {
System.out.println("Unsupported Problem\n" + e);
} catch (IOException e) {
System.out.println("IO Problem" + e);
} catch (Exception e) {
System.out.println("Unknown Problem" + e);
}
}
@Override
public void open() {
// r�cup�ration de l'identifiant du port
try {
logger.info("Liste des ports : " + CommPortIdentifier.getPortIdentifiers());
final Enumeration identifiers = CommPortIdentifier.getPortIdentifiers();
while (identifiers.hasMoreElements()) {
logger.info(((CommPortIdentifier) identifiers.nextElement()).getName());
}
portId = CommPortIdentifier.getPortIdentifier(connectionDescriptor.getPortName());
} catch (final NoSuchPortException e) {
throw new RuntimeException(
"Rs232Connector (" + connectionDescriptor.getPortName() + ") : " + e.toString());
}
// ouverture du port
try {
serialPort = (SerialPort) portId.open("driver", 2000);
} catch (final PortInUseException e) {
throw new RuntimeException(
"Rs232Connector (" + connectionDescriptor.getPortName() + ") : " + e.toString());
}
// param�trage du port
// hmmmmmmmmmmmm cf :
// http://forum.java.sun.com/thread.jspa?threadID=673793&start=15&tstart=0
boolean result = false;
while (!result) {
try {
serialPort.setSerialPortParams(
connectionDescriptor.getBaudRate(),
connectionDescriptor.getDataBits(),
connectionDescriptor.getStopBits(),
connectionDescriptor.getParity());
result = true;
} catch (final Exception ex) {
logger.error("Unable to set serial ports parameters", ex);
result = false;
try {
Thread.sleep(200);
} catch (final InterruptedException exc) {
logger.error("Error while sleeping", exc);
}
}
}
/** @todo : test */
// Suppression
try {
serialPort.enableReceiveTimeout(5000); // timeout de 1 ms
} catch (final UnsupportedCommOperationException ex) {
logger.warn(
"Warning : impossible to set timeout for port " + connectionDescriptor.getPortName(), ex);
}
try {
// inputStream = new BufferedReader(new
// InputStreamReader(serialPort.getInputStream()));
inputStream = serialPort.getInputStream();
} catch (final IOException e) {
serialPort.close();
throw new RuntimeException(
"Rs232Connector (" + connectionDescriptor.getPortName() + ") : " + e.toString());
}
try {
serialPort.addEventListener(
new SerialPortEventListener() {
@Override
public void serialEvent(final SerialPortEvent evt) {
if (evt.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
synchronized (bufferMonitor) {
if (writeIndex >= BUFFER_LENGTH - 1) {
flushBuffer();
}
try {
byte newData = 0;
while (newData != -1) {
newData = (byte) inputStream.read();
if (newData == -1) {
break;
}
if (writeIndex >= BUFFER_LENGTH - 1) {
flushBuffer();
}
buffer[writeIndex++] = newData;
}
} catch (final Exception exc) {
logger.error("Error reading input stream from serial port", exc);
}
bufferMonitor.notify();
}
}
}
});
serialPort.notifyOnDataAvailable(true);
serialPort.enableReceiveTimeout(20);
} catch (final TooManyListenersException exc) {
logger.error("", exc);
} catch (final UnsupportedCommOperationException exc) {
logger.error("", exc);
}
final Thread threadParse =
new Thread("Rs232Connector_" + connectionDescriptor.getPortName() + "_dispatch_thread") {
@Override
public void run() {
try {
parseThread();
} catch (final Exception e) {
logger.error("Error while parsing thread", e);
}
}
};
threadParse.start();
}
/**
* Opens a device for subsequent I/O.
*
* @param logicalDeviceName Parameter specifies the device name to open
* @param ec Callback event handler
* @throws JposException
*/
public void open(String logicalDeviceName, EventCallbacks ec) throws JposException {
// Check port opened
if ((state != JposConst.JPOS_S_CLOSED) && (port != null))
throw new JposException(
JposConst.JPOS_E_ILLEGAL, getErrorDescription(JposConst.JPOS_E_ILLEGAL));
powerNotify = JposConst.JPOS_PN_DISABLED;
powerState = JposConst.JPOS_PS_UNKNOWN;
// Read and check parameters
// if (!jposEntry.getProp("deviceBus").getValueAsString().equalsIgnoreCase("RS232"))
// throw new JposException(JposConst.JPOS_E_NOSERVICE,
// getErrorDescription(JposConst.JPOS_E_NOSERVICE));
portName = jposEntry.getProp("portName").getValueAsString();
int baudRate = Integer.valueOf(jposEntry.getProp("baudRate").getValueAsString());
// if (!(jposEntry.getProp("dataBits").getValueAsString().equalsIgnoreCase("8") &&
// jposEntry.getProp("stopBits").getValueAsString().equalsIgnoreCase("1") &&
// jposEntry.getProp("parity").getValueAsString().equalsIgnoreCase("None")))
// throw new JposException(JposConst.JPOS_E_NOSERVICE,
// getErrorDescription(JposConst.JPOS_E_NOSERVICE));
// Try find existen serial port
for (DeviceService value : deviceServices.keySet()) {
if (value.getPortName().equalsIgnoreCase(portName)) {
port = deviceServices.get(value);
break;
}
}
// Open port
if (port == null) {
try {
CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
CommPort commPort = portIdentifier.open("CASHCODE", DeviceTiming.NON_RESPONSE);
if (commPort instanceof SerialPort) {
port = ((SerialPort) commPort);
port.setSerialPortParams(
baudRate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
// Init timing
responseTime = System.currentTimeMillis();
executeTime = responseTime + DeviceTiming.BUS_RESET;
port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
port.setDTR(true);
port.setRTS(true);
port.setInputBufferSize(SIZE_BUFFER);
port.setOutputBufferSize(SIZE_BUFFER);
port.enableReceiveTimeout(DeviceTiming.INTER_BYTE);
} else
throw new JposException(
JposConst.JPOS_E_NOSERVICE, getErrorDescription(JposConst.JPOS_E_NOSERVICE));
} catch (Exception e) {
throw new JposException(
JposConst.JPOS_E_NOSERVICE, getErrorDescription(JposConst.JPOS_E_NOSERVICE), e);
}
}
// Streams
try {
is = port.getInputStream();
os = port.getOutputStream();
} catch (IOException e) {
throw new JposException(
JposConst.JPOS_E_FAILURE, getErrorDescription(JposConst.JPOS_E_FAILURE), e);
}
// Add reference to port
deviceServices.put(this, port);
// Set events callback handler
eventCallbacks = ec;
// Initialize device
try {
initialize();
state = JposConst.JPOS_S_IDLE;
} catch (JposException e) {
state = JposConst.JPOS_S_ERROR;
startInit(DeviceTiming.RESET_NON_RESPONSE);
}
}
private void initialize() {
// ==========================================
/*
* get System porperties:
*/
String operatingSystem = null;
Properties p = System.getProperties();
Enumeration e = p.elements();
while (e.hasMoreElements()) {
operatingSystem = e.nextElement().toString();
// System.out.println(operatingSystem);
if (operatingSystem.equals("Linux")) {
logger.debug("found " + operatingSystem + " Operating System");
comPort = "/dev/ttyS0";
break;
}
if (operatingSystem.equals("Windows XP")) {
logger.debug("found " + operatingSystem + " Operating System");
comPort = "COM1";
break;
}
// if(operatingSystem.equals("Linux") || operatingSystem.equals("Windows")) {
// logger.debug("found "+operatingSystem+" Operating System");
// break;
// }
}
// ===============end===========================
Enumeration pList = CommPortIdentifier.getPortIdentifiers();
// logger.debug("(Khepera) initializeeeee()...");
while (pList.hasMoreElements()) {
CommPortIdentifier cpi = (CommPortIdentifier) pList.nextElement();
if (cpi.getName().equals(comPort)) {
try {
com = null;
com = (SerialPort) cpi.open("KHEPERA_" + comPort, 1000);
try {
// ========================================
/* under Linux this block is crucial to setSerialPortParams()
* - i have no idea why...
*/
String s =
"default settings: "
+ com.getBaudRate()
+ " "
+ com.getDataBits()
+ " "
+ com.getParity()
+ " "
+ com.getStopBits();
System.out.println(s);
// ===============end=========================
com.setSerialPortParams(
57600, SerialPort.DATABITS_8, SerialPort.STOPBITS_2, SerialPort.PARITY_NONE);
System.out.println(
"Current settings: "
+ com.getBaudRate()
+ " "
+ com.getDataBits()
+ " "
+ com.getParity()
+ " "
+ com.getStopBits());
} catch (UnsupportedCommOperationException e1) {
logger.debug("(Khepera) UnsupportedCommOperation: " + e1);
e1.printStackTrace();
}
// try {
// com.setSerialPortParams(BAUDRATE,
// com.DATABITS_8,
// com.STOPBITS_2,
// com.PARITY_NONE);
// com.setFlowControlMode(com.FLOWCONTROL_NONE);
// } catch (UnsupportedCommOperationException e1) {
// logger.debug("(Khepera) UnsupportedCommOperation: "+e1);
// e1.printStackTrace();
// }
logger.debug("[Khepera.initialize()] established " + comPort);
out = null;
out = com.getOutputStream();
inStream = null;
inStream = com.getInputStream();
byte[] readBuffer2 = new byte[1000];
if (inStream.available() > 0) {
int numBytes2 = inStream.read(readBuffer2);
String result2 = new String(readBuffer2, 0, numBytes2);
logger.debug("result2: " + result2);
}
// in = null;
in = new BufferedReader(new InputStreamReader(inStream));
bufferedKheperaAnswer =
new BufferedKheperaAnswer(logger, inStream, this, writelock, debug, operatingSystem);
try {
com.addEventListener(bufferedKheperaAnswer);
com.notifyOnOutputEmpty(true);
com.notifyOnDataAvailable(true);
com.notifyOnOverrunError(true);
com.notifyOnBreakInterrupt(true);
com.notifyOnCarrierDetect(true);
com.notifyOnCTS(true);
com.notifyOnDSR(true);
com.notifyOnFramingError(true);
com.notifyOnParityError(true);
com.notifyOnRingIndicator(false);
} catch (TooManyListenersException e1) {
logger.debug(
"[Khepera.initialize()] can not add further eventListeners to serialPort object"
+ e);
e1.printStackTrace();
}
} catch (PortInUseException e2) {
logger.debug("[Khepera.initialize()] Port in use: " + e2);
e2.printStackTrace();
} catch (IOException e3) {
logger.debug(
"[Khepera.initialize()] IOException while initialising COMport: <"
+ comPort
+ ">"
+ e);
e3.printStackTrace();
}
break;
}
}
if (com == null)
logger.error(
"[Khepera.initialize()] unable to find specified COMport "
+ comPort
+ ". giving up! (the robot is not connected yet.)");
else {
logger.debug("[Khepera.initialize()] starting bufferedKheperaAnswer.start()");
bufferedKheperaAnswer.start();
if (debug) logger.debug("[Khepera.initialize()] initialize() finished");
update = new KheperaUpdateManager(this, logger, debug);
logger.debug("[Khepera.initialize()] starting KheperaUpdateManager update.start()");
update.start();
}
}