inputstream.available（）为0时总是

Question

我没有什么是发生在我的代码的想法。我没有得到任何错误，也没有回应。我正在将数据写入串行端口，并通过激活port.notifyOnDataAvailable(true);等待响应，但未触发此事件，并且inputstream.available（）始终返回0。什么可能是错误的？我在linux中使用RXTX。

EDIT

package testConn; 
import forms_helper.global_variables; 
import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.InputStreamReader; 
import java.io.OutputStream; 
import java.io.PrintStream; 
import java.io.UnsupportedEncodingException; 
import java.util.logging.Level; 
import java.util.logging.Logger; 
import javax.comm.*; 
import java.util.*; 
/** Check each port to see if it is open. **/ 
public class openPort implements SerialPortEventListener { 

    static Enumeration portList; 
    static CommPortIdentifier portId; 
    static String messageString; 
    public static SerialPort serialPort; 
    static OutputStream outputStream; 
    InputStream inputStream; 
    static boolean outputBufferEmptyFlag = false; 
    private BufferedReader is; 
    private PrintStream os; 

    public void open() { 
     Enumeration port_list = CommPortIdentifier.getPortIdentifiers(); 

     while (port_list.hasMoreElements()) { 
      // Get the list of ports 
      CommPortIdentifier port_id = (CommPortIdentifier) port_list.nextElement(); 
      if (port_id.getName().equals("/dev/ttyS1")) { 

       // Attempt to open it 
       try { 
        SerialPort port = (SerialPort) port_id.open("PortListOpen", 20000); 
        System.out.println("Opened successfully:"+port); 
        try { 
         int baudRate = 9600; // 
         port.setSerialPortParams(
           baudRate, 
           SerialPort.DATABITS_7, 
           SerialPort.STOPBITS_1, 
           SerialPort.PARITY_EVEN); 
         port.setDTR(true); 


         port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); 

         System.out.println("properties are set"); 
        } catch (UnsupportedCommOperationException e) { 
         System.out.println(e); 
        } 
        try { 
         //input = new SerialReader(in); 
         port.addEventListener(this); 
         System.out.println("listeners attached" + this); 
        } catch (TooManyListenersException e) { 
         System.out.println("too many listeners"); 
        } 
        port.notifyOnDataAvailable(true); 

        //port.notifyOnOutputEmpty(true); 
        //sendMessage(port,"@PL"); 
        //port.close(); 
        try { 
         is = new BufferedReader(new InputStreamReader(port.getInputStream())); 
        } catch (IOException e) { 
         System.err.println("Can't open input stream: write-only"); 
         is = null; 
        } 
        try { 
         os = new PrintStream(port.getOutputStream(), true); 
        } catch (IOException ex) { 
         Logger.getLogger(openPort.class.getName()).log(Level.SEVERE, null, ex); 
        } 

        try { 
         inputStream = port.getInputStream(); 
         System.out.println("inputstream" + inputStream.available()); 
         outputStream = (OutputStream) port.getOutputStream(); 
         os = new PrintStream(port.getOutputStream(), true, "US-ASCII"); 


        } catch (IOException e) { 
         System.out.println(e); 
        } 

        //set the created variables to global variables 
        global_variables.port = port; 
        global_variables.inputStream = inputStream; 
        System.out.println(inputStream); 
        System.out.println(outputStream); 
        global_variables.outputStream = outputStream; 
        global_variables.os = os; 
       } catch (PortInUseException pe) { 
        System.out.println("Open failed"); 
        String owner_name = port_id.getCurrentOwner(); 
        if (owner_name == null) { 
         System.out.println("Port Owned by unidentified app"); 
        } else // The owner name not returned correctly unless it is 
        // a Java program. 
        { 
         System.out.println(" " + owner_name); 
        } 
       } 
      } 
     } 
    } 

    public static void sendMessage(SerialPort port, String msg) { 
     if (port != null) { 
       System.out.println(msg); 
      try { 
       byte[] bytes = msg.getBytes("US-ASCII"); 
       try { 
        global_variables.outputStream.write(bytes); 
        System.out.println(bytes.length); 
        global_variables.outputStream.flush(); 
       } catch (IOException ex) { 
        Logger.getLogger(openPort.class.getName()).log(Level.SEVERE, null, ex); 
       } 
      } catch (UnsupportedEncodingException ex) { 
       Logger.getLogger(openPort.class.getName()).log(Level.SEVERE, null, ex); 
      } 
       System.out.println("Opened successfully:"+msg.getBytes()); 
       //global_variables.outputStream.write(msg.getBytes()); 
       //global_variables.outputStream.flush(); 
       //global_variables.os.print(msg); 
       System.out.println(global_variables.outputStream); 
       try { 
        Thread.sleep(2000); // Be sure data is xferred before closing 
        System.out.println("read called"); 
        //SimpleRead read = new SimpleRead(); 
        //int read = global_variables.inputStream.read(); 
        //System.out.println("read call ended"+read); 
       } catch (Exception e) { 
       } 

     } 
    } 

    public void serialEvent(SerialPortEvent event) { 
     System.out.println(event.getEventType()); 
     String line; 
       try { 
        line = is.readLine(); 
        if (line == null) { 
         System.out.println("EOF on serial port."); 
         System.exit(0); 
        } 
        os.println(line); 
       } catch (IOException ex) { 
        System.err.println("IO Error " + ex); 
       } 
     switch (event.getEventType()) { 
      /* 
      case SerialPortEvent.BI: 

      case SerialPortEvent.OE: 

      case SerialPortEvent.FE: 

      case SerialPortEvent.PE: 

      case SerialPortEvent.CD: 

      case SerialPortEvent.CTS: 

      case SerialPortEvent.DSR: 

      case SerialPortEvent.RI: 


      case SerialPortEvent.OUTPUT_BUFFER_EMPTY: 
      System.out.println("event.getEventType()"); 
      break; 
      * 
      */ 

      case SerialPortEvent.DATA_AVAILABLE: 
       System.out.println("inside event handler data available"); 
       byte[] readBuffer = new byte[20]; 


       try { 
        while (inputStream.available() > 0) { 
         int numBytes = inputStream.read(readBuffer); 
        } 
        System.out.print(new String(readBuffer)); 
        System.exit(1); 
       } catch (IOException e) { 
        System.out.println(e); 
       } 

       break; 
     } 
    } 
} // PortListOpen 

我正在打开上main方法的端口并在应用程序中的按钮点击事件发送消息。

Answer 1

.available()不能用于进程间通信（包括串口），s它只会检查当前进程中是否有可用的数据（在输入缓冲区中）。

在串行通信中，当您发送messaga，然后立即打电话available()你将主要得0为串行端口并没有针对任何数据回复。

的解决方案是使用一个单独的线程阻塞read()（与interrupt()结束它）：

Thread interrupt not ending blocking call on input stream read

Answer 2

要部分地回答你的问题。

从javadocs中

类 InputStream的可用方法总是返回0

http://download.oracle.com/javase/6/docs/api/java/io/InputStream.html#available（）

因此如预期的那部分的至少

Answer 3

通过使用你抑制你需要了解任何请求例外一个PrintStream /响应场景。

最有可能你还没有发出任何东西。