/**
* 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");
}
}
/** {@inheritDoc} */
public String RPC(String Name, String Method, String[] Args) {
// write to serial port and receive result
String Response;
String Arguments = "";
if (Args != null) {
int s = Args.length;
for (int i = 0; i < s; i++) {
Arguments = Arguments + " " + Args[i];
}
}
try {
to_mbed.println("/" + Name + "/" + Method + Arguments);
mbedSerialPort.notifyOnDataAvailable(false);
} catch (NullPointerException e) {
}
boolean valid = true;
try {
while (reader.ready() == false) {}
;
do {
Response = reader.readLine();
if (Response.length() >= 1) {
valid = Response.charAt(0) != '!';
}
} while (valid == false);
} catch (IOException e) {
System.err.println("IOException, error reading from port");
Response = "error";
}
mbedSerialPort.notifyOnDataAvailable(true);
return (Response);
}
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();
}
public static void main(String args[]) {
Display display = IntelliBrain.getLcdDisplay();
IBB ibb = new IBB();
try {
SerialPort comPort = IntelliBrain.getCom1();
// Serial Parameters
comPort.setSerialPortParams(
38400, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
InputStream inputStream = comPort.getInputStream();
OutputStream outputStream = comPort.getOutputStream();
// clear screen
display.print(0, "");
display.print(1, "");
// test the readLine routine
byte[] buf = new byte[128];
while (true) {
int len = readLine(inputStream, outputStream, display, true, buf, 128);
if (len == 0) continue;
switch (buf[0]) {
case 'B':
ibb.getVersion(outputStream, buf, len);
break;
case 'D':
ibb.setSpeed(outputStream, buf, len);
break;
case 'H':
ibb.sysBeep(outputStream, buf, len);
break;
case 'L':
ibb.setLedState(outputStream, buf, len);
break;
case 'N':
ibb.readProximitySensors(outputStream, buf, len);
break;
case 'O':
ibb.readLightSensors(outputStream, buf, len);
break;
case 'Z':
ibb.motorsOff(outputStream, buf, len);
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/*! 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));
}
/** Close the serial port. */
public void delete() {
// Close the serial port
try {
if (inputStream != null) inputStream.close();
outputStream.close();
} catch (IOException e) {
}
mbedSerialPort.removeEventListener();
mbedSerialPort.close();
mbedPort.close();
}
public int getValue() {
/*
* Get the current threshold.
*/
if ((port != null) && port.isReceiveThresholdEnabled()) {
this.value = port.getReceiveThreshold();
} else {
this.value = 0;
}
return this.value;
}
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;
}
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();
}
/**
* Ecriture sur le lien s�rie
*
* @param b
*/
@Override
public void write(final byte b[]) {
final String s = new String(b);
try {
final PrintWriter outputStream = new PrintWriter(serialPort.getOutputStream());
outputStream.write(s);
outputStream.close();
} catch (final Exception e) {
logger.error("Error while writing on serial port", e);
}
}
public void setValue(int val) {
/*
* Set the new threshold.
*/
if (port != null) {
if (val > 0) {
try {
port.enableReceiveThreshold(val);
} catch (UnsupportedCommOperationException ucoe) {
ucoe.printStackTrace();
}
} else {
port.disableReceiveThreshold();
}
}
this.showValue();
}
public void connectionclose() {
try {
is.close();
os.close();
dis.close();
dos.close();
sPort.close();
} catch (Exception e) {
System.out.println("close" + e);
}
}
public void write(byte[] data) {
try {
os = port.getOutputStream();
} catch (IOException e) {
System.err.println("IOException: " + e);
}
try {
os.write(data);
} catch (IOException e) {
System.err.println("IOException: " + e);
}
}
public void read(byte[] data) {
try {
is = port.getInputStream();
} catch (IOException e) {
System.err.println("IOException: " + e);
}
try {
is.read(data);
} catch (IOException e) {
System.err.println("IOException: " + e);
}
}
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);
}
}
/** Fermeture du lien s�rie */
@Override
public void close() {
running = false;
// fermeture du flux et port
try {
if (inputStream != null) {
inputStream.close();
}
if (serialPort != null) {
serialPort.close();
}
} catch (final IOException e) {
logger.error("Error closing COM port inputStream", 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();
}
public static void main(String args[]) {
// Command to turn of GPS
int[] turn_off = new int[8];
turn_off[0] = DLE;
turn_off[1] = Pid_Command_Packet;
turn_off[2] = 2; // Length of data
turn_off[3] = Cmnd_Turn_Off_Pwr;
turn_off[4] = 0;
turn_off[6] = DLE;
turn_off[7] = ETX;
calcChecksum(turn_off);
System.out.println("Turn off checksum: " + turn_off[5]);
// Command to ask GPS for time data.
int[] transfer_time = new int[8];
transfer_time[0] = DLE;
transfer_time[1] = Pid_Command_Packet;
transfer_time[2] = 2;
transfer_time[3] = Cmnd_Transfer_Time;
transfer_time[4] = 0;
transfer_time[6] = DLE;
transfer_time[7] = ETX;
calcChecksum(transfer_time);
System.out.println("Transfer time" + transfer_time[5]);
// Command to make a product request to the GPS.
int[] product_request = new int[6];
product_request[0] = DLE;
product_request[1] = Pid_Product_Rqst;
product_request[2] = 0;
product_request[4] = DLE;
product_request[5] = ETX;
calcChecksum(product_request);
System.out.println("Product request:" + product_request[5]);
// Command to ask GPS for position data
int[] transfer_position = new int[8];
transfer_position[0] = DLE;
transfer_position[1] = Pid_Command_Packet;
transfer_position[2] = 2;
transfer_position[3] = Cmnd_Transfer_Posn;
transfer_position[4] = 0;
transfer_position[6] = DLE;
transfer_position[7] = ETX;
calcChecksum(transfer_position);
// Command to ask the GPS to start transmitting PVT data
int[] start_PVT = new int[8];
start_PVT[0] = DLE;
start_PVT[1] = Pid_Command_Packet;
start_PVT[2] = 2;
start_PVT[3] = Cmnd_Start_Pvt_Data;
start_PVT[4] = 0;
start_PVT[6] = DLE;
start_PVT[7] = ETX;
calcChecksum(start_PVT);
// Acknowledge-packet.
int[] ack = new int[8];
ack[0] = DLE;
ack[1] = Pid_Ack_Byte;
ack[2] = 2;
ack[4] = 0;
ack[6] = DLE;
ack[7] = ETX;
SerialPort port;
BufferedInputStream input;
BufferedOutputStream output;
System.out.println("Using COM1.");
// Open port.
try {
port =
(SerialPort) CommPortIdentifier.getPortIdentifier("COM1").open("dk.itu.haas.GPS", 3000);
} catch (NoSuchPortException e) {
System.out.println("No such port!\n" + e.getMessage());
return;
} catch (PortInUseException e) {
System.out.println("Port already in use! (??!)\n" + e.getMessage());
return;
}
try {
input = new BufferedInputStream(port.getInputStream());
output = new BufferedOutputStream(port.getOutputStream());
} catch (IOException e) {
System.out.println("IOException... ");
return;
}
System.out.println("Sending:");
printPacket(turn_off);
sendPacket(output, turn_off);
/*
printPacket(transfer_position);
sendPacket(output, transfer_position);
*/
/*
printPacket(start_PVT);
sendPacket(output, start_PVT);
*/
/*
printPacket(product_request);
sendPacket(output, product_request);
*/
System.out.println("--");
int[] packet;
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
try {
while (input.available() > 0) {
packet = readPacket(input);
if (packet != null) {
System.out.println("Received:");
printPacket(packet);
// Send acknowledge.
ack[3] = packet[1];
calcChecksum(ack);
sendPacket(output, ack);
System.out.println("--");
} else {
System.out.println("No packet received.");
}
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
}
}
} catch (IOException e) {
System.out.println("IOError!");
return;
}
}
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();
}
}
public synchronized void shutdown() {
update.setUpdate(false);
try {
Thread.sleep(300);
} catch (InterruptedException e3) {
e3.printStackTrace();
}
try {
String s = write("restart\n");
logger.debug("[Khepera.shutdown()] restart(): " + s);
} catch (IOException e2) {
logger.error("[Khepera.shutdown()] IOException1!!", e2);
e2.printStackTrace();
}
// give signal:
this.setLED0("1");
this.setLED1("1");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setLED0("0");
this.setLED1("0");
try {
Thread.sleep(300);
} catch (InterruptedException e3) {
e3.printStackTrace();
}
bufferedKheperaAnswer.setUpdate(false);
try {
Thread.sleep(300);
} catch (InterruptedException e3) {
e3.printStackTrace();
}
com.removeEventListener();
try {
com.close();
} catch (RuntimeException e) {
logger.error("[Khepera.shutdown()] IOException1!!", e);
e.printStackTrace();
}
try {
out.close();
} catch (IOException e) {
logger.error("[Khepera.shutdown()] IOException2!!", e);
e.printStackTrace();
}
try {
in.close();
} catch (IOException e1) {
logger.error("[Khepera.shutdown()] IOException3!!", e1);
e1.printStackTrace();
}
out = null;
in = null;
logger.debug("[Khepera.shutdown()] ...khepera system halted!");
}
private void printPortStatus() {
System.out.println("baud rate: " + port.getBaudRate());
System.out.println("data bits: " + port.getDataBits());
System.out.println("stop bits: " + port.getStopBits());
System.out.println("parity: " + port.getParity());
}