Java Serial Port Question !

Question

Hello,
I am writing characters such as "open\r", "close\r" to the serial port of a PC from the Java program. This PC is connected to robot controller through the serial port.
Suppose, I am writing open\r to the serial port. After writing open\r, the controller immediately echos "open" back to the serial port, which my Java program can read & print. Then, approximately after 1 second, when the robot actually executes the open (Open Gripper) command, the controller sends "Done.>" this response. I want to monitor & read this response "Done.>" because I want to check controller's response ("Done.>") before sending next command.
1. Is it MUST to listen & read data at port at the time the data comes? Does the data gets lost if we don't read the data at the time it comes? For example, if data comes at 10000 millisecs, then is it MUST to start reading at 10000 or 10001? Would that data get lost if we start reading after say 3 seconds i.e. at 13000?
2. If some data ("Done") comes at the serial port from controller and the Java program does not read that and if suppose more data (".>")comes at the serial port after 1/2 second, then does the previous data("Done") gets erased?
3. My problem is --> the java program that I have written, can sometimes read & print controller's response --> "Done.>" and other times it does not find "Done.>"....That means the data --> "Done.>" is getting lost somewhere or Java program is not able to read it..The controller always sends "Done.>" when it excecutes "open" command.
Thank You !
Mayur
Below is the code I am using...
import java.io.*;
import java.util.*;
import javax.comm.*;
public class WriteReadEdit implements SerialPortEventListener {
CommPortIdentifier portId;
Enumeration portList;
OutputStream outputStream;
InputStream inputStream;
SerialPort serialPort;
public static void main(String[] args) {
          String command1 = "open\r";
          String command2 = "close\r";                    
          boolean EndCharacterQMark = false;
          WriteReadEdit readObject = new WriteReadEdit();
               readObject.Write(command1);
               try {
                    EndCharacterQMark = readObject.waitUntilDataComes();
                    System.out.println("EndCharacterQMark is: " + EndCharacterQMark);
               }     catch (IOException e) {}
                    if(EndCharacterQMark) {
                         EndCharacterQMark = false;
                         readObject.Write(command2);
                         try {
                              EndCharacterQMark = readObject.waitUntilDataComes();
                              System.out.println("EndCharacterQMark is: " + EndCharacterQMark);
                         }     catch (IOException e) {}
                    readObject.closePort();
synchronized boolean waitUntilDataComes() throws IOException {
     String total="";
     boolean EndCharQMark = false;
     StringBuffer inputBuffer = new StringBuffer();
     int newData = 0;
     while(true) {
                    if(!dataAvailable()) {
                         try {                              
                              wait();                              
                         }catch (InterruptedException e) {}
               try {
                    while (newData != -1) {                         
                         newData = inputStream.read();
                         inputBuffer.append((char)newData);
               }          catch (IOException ex) {
                         System.err.println(ex);
                    String dataAtPort = inputBuffer.toString();
                    for(int i = 0; i < dataAtPort.length(); i++) {                         
                              if(dataAtPort.indexOf("?")>1 || dataAtPort.indexOf(">")>1 ) {
                              EndCharQMark = true;
                              return EndCharQMark;
boolean dataAvailable() throws IOException {          
     return inputStream.available() > 0;
          void Write(String commandToSend) {
          String command = commandToSend;
          try {
                    outputStream.write(command.getBytes());                              
                    System.out.println("\nSuccessfully Written: " + command);
          } catch (IOException e) {System.out.println("IO Exception Occured: " + e);
void closePort() {
     serialPort.close();
     System.out.println("Port closed successfully.");
// Constructor()
public WriteReadEdit() {
          portList = CommPortIdentifier.getPortIdentifiers();
          while (portList.hasMoreElements()) {
          portId = (CommPortIdentifier) portList.nextElement();
                    if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
          if (portId.getName().equals("COM1")) {
          try {
          serialPort = (SerialPort) portId.open("writereadobjectApp", 2000);
               System.out.println("Opened the port for writing: " + portId.getName());
          } catch (PortInUseException e) {
          try {
               serialPort.setSerialPortParams(9600,
          SerialPort.DATABITS_8,
          SerialPort.STOPBITS_1,
          SerialPort.PARITY_NONE);
          } catch (UnsupportedCommOperationException e) {
                                        System.out.println("UnsupportedCommOperationException, Could not set the port: " + e);
                                   try {                                        
                                        outputStream = serialPort.getOutputStream();
                                        inputStream = serialPort.getInputStream();
                                   } catch (IOException e) {
                                   try {
                                        serialPort.addEventListener(this);
                                   } catch (TooManyListenersException e) {}
                                   serialPort.notifyOnDataAvailable(true);
synchronized public void serialEvent(SerialPortEvent event) {
     switch(event.getEventType()) {
     case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
     case SerialPortEvent.DATA_AVAILABLE:
     notifyAll();          
     break;

Answer 1

1. Usually there are buffers in the serial port controller. Apart from that, as long as the port is open, any data recieved will be added at the end of the InputStream of the comport so nothing will be lost.
2. Nope, see above. But there might just be some kind of limit there.
3. Download portmon http://www.sysinternals.com/ntw2k/freeware/portmon.shtml or any other prog that is able to monitor what's happening on you're serial port. This allows you to see if the response is really send by the robot.
You're code seem to me to be more complex then it needs to be. Check out javax.comm.CommPort.enableRecieveTimeout(int). Setting a timeout will cause the the read function to return when the timeout is passed or data is recieved. A timeout of of say 4sec whould make sure that when a reply is send, it is recieved and it's stops reading when it gets no reply.
In that case you could do with a sendMsg function wich dus not return until the correct response is recieved, or the timeout passed.
You migth consider putting all the communicatoin with the com port in a different Thread so the rest of the program runs on when that thread is listening to the port...
Hope this helps you a bit...