Comment écrire du code Java renvoyant une ligne de chaîne dans une variable de chaîne depuis Arduino?

Question

Comment puis-je faire le code Envoye série et de réception (RX/TX) ci-dessous fonctionnent comme un tampon jusqu'à ce que Définit un octet spécifique au tampon jusqu'à ce que avant d'appeler serialEvent() dans

http://processing.org/reference/libraries/serial/Serial_bufferUntil_.html

et ainsi que inString = (myPort.readString());

import gnu.io.CommPort; 
import gnu.io.CommPortIdentifier; 
import gnu.io.SerialPort; 
import gnu.io.SerialPortEvent; 
import gnu.io.SerialPortEventListener; 

import java.io.IOException; 
import java.io.InputStream; 
import java.io.OutputStream; 

/** 
* This version of the TwoWaySerialComm example makes use of the 
* SerialPortEventListener to avoid polling. 
* 
*/ 
public class TwoWaySerialComm 
{ 
    public TwoWaySerialComm() 
    { 
     super(); 
    } 

    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 serialPort = (SerialPort) commPort; 
       serialPort.setSerialPortParams(
        57600, 
        SerialPort.DATABITS_8, 
        SerialPort.STOPBITS_1, 
        SerialPort.PARITY_NONE); 

       InputStream in = serialPort.getInputStream(); 
       OutputStream out = serialPort.getOutputStream(); 

       (new Thread(new SerialWriter(out))).start(); 

       serialPort.addEventListener(new SerialReader(in)); 
       serialPort.notifyOnDataAvailable(true); 
      } 
      else 
      { 
       System.out.println("Error: Only serial ports are handled by this example."); 
      } 
     } 
    } 

    /** 
    * Handles the input coming from the serial port. A new line character 
    * is treated as the end of a block in this example. 
    */ 
    public static class SerialReader implements SerialPortEventListener 
    { 
     private InputStream in; 
     private byte[] buffer = new byte[1024]; 

     public SerialReader (InputStream in) 
     { 
      this.in = in; 
     } 

     public void serialEvent(SerialPortEvent arg0) { 
      int data; 

      try 
      { 
       int len = 0; 
       while ((data = in.read()) > -1) 
       { 
        if (data == '\n') { 
         break; 
        } 
        buffer[len++] = (byte) data; 
       } 
       System.out.print(new String(buffer,0,len)); 
      } 
      catch (IOException e) 
      { 
       e.printStackTrace(); 
       System.exit(-1); 
      } 
     } 
    } 

    /** */ 
    public static class SerialWriter implements Runnable 
    { 
     OutputStream out; 

     public SerialWriter (OutputStream out) 
     { 
      this.out = out; 
     } 

     public void run() 
     { 
      try 
      { 
       int c = 0; 
       while ((c = System.in.read()) > -1) 
       { 
        this.out.write(c); 
       } 
      } 
      catch (IOException e) 
      { 
       e.printStackTrace(); 
       System.exit(-1); 
      } 
     } 
    } 


    public static void main (String[] args) 
    { 
     try 
     { 
      (new TwoWaySerialComm()).connect("COM3"); 
     } 
     catch (Exception e) 
     { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
    } 
} 

Answer 1

a résolu le problème ....

package smartOfficeJava; 

import gnu.io.CommPort; 
import gnu.io.CommPortIdentifier; 
import gnu.io.SerialPort; 
import gnu.io.SerialPortEvent; 
import gnu.io.SerialPortEventListener; 

import java.io.IOException; 
import java.io.InputStream; 
import java.io.OutputStream; 

/** 
* This version of the TwoWaySerialComm example makes use of the 
* SerialPortEventListener to avoid polling. 
* 
*/ 
public class Arduino 
{ 
    OutputStream out; 
    SerialReader input; 
    public Arduino() 
    { 
     super(); 
    } 

    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 serialPort = (SerialPort) commPort; 
       serialPort.setSerialPortParams(9600,SerialPort.DATABITS_8,SerialPort.STOPBITS_1,SerialPort.PARITY_NONE); 

       InputStream in = serialPort.getInputStream(); 
       out = serialPort.getOutputStream(); 

       //(new Thread(new SerialWriter(out))).start(); 
       input = new SerialReader(in); 
       serialPort.addEventListener(input); 
       serialPort.notifyOnDataAvailable(true); 
       Thread.sleep(3000); 
       out.write("yes".getBytes()); 

      } 
      else 
      { 
       System.out.println("Error: Only serial ports are handled by this example."); 
      } 
     }  
    } 

    /** 
    * Handles the input coming from the serial port. A new line character 
    * is treated as the end of a block in this example. 
    */ 
    public static class SerialReader implements SerialPortEventListener 
    { 
     private InputStream in; 
     private byte[] buffer = new byte[1024]; 
     String buffer_string; 
     public SerialReader (InputStream in) 
     { 
      this.in = in; 
     } 

     public void serialEvent(SerialPortEvent arg0) { 
      int data; 

      try 
      { 
       int len = 0; 
       while ((data = in.read()) > -1) 
       { 
        if (data == '\n') { 
         break; 
        } 
        buffer[len++] = (byte) data; 
       } 
       //System.out.print(new String(buffer,0,len)); 
       buffer_string = new String(buffer,0,len); 
      } 
      catch (IOException e) 
      { 
       e.printStackTrace(); 
       System.exit(-1); 
      }    
     } 

    } 

    /** 
    public static class SerialWriter implements Runnable 
    { 
     OutputStream out; 

     public SerialWriter (OutputStream out) 
     { 
      this.out = out; 
     } 

     public void run() 
     { 
      try 
      {     
       int c = 0; 
       while ((c = System.in.read()) > -1) 
       { 
        this.out.write(c); 
       }     
      } 
      catch (IOException e) 
      { 
       e.printStackTrace(); 
       System.exit(-1); 
      }    
     } 
    }*/ 

    public String getSensor(){ 
     try 
     {     
       this.out.write("yes".getBytes());    
     } 
     catch (IOException e) 
     { 
      e.printStackTrace(); 
     } 
     try { 
     Thread.sleep(3000); 
    } catch (InterruptedException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
     return (input.buffer_string).trim(); 

    } 

    public static void main (String[] args) 
    { 
     Arduino test; 
     try 
     { 
      test = new Arduino(); 
      test.connect("COM3"); 
      System.out.println(test.getSensor()); 
      System.out.println(test.getSensor()); 
      System.out.println(test.getSensor()); 
     } 
     catch (Exception e) 
     { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
    } 


} 

Answer 2

import gnu.io.CommPort; 
    import gnu.io.CommPortIdentifier; 
    import gnu.io.SerialPort; 

    import java.io.InputStream; 
    import java.io.OutputStream; 

    public class SerialComm 
    { 
    OutputStream out; 

    InputStream in; 
    public SerialComm() 
    { 
     super(); 
    } 

    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 serialPort = (SerialPort) commPort; 
       serialPort.setSerialPortParams(9600,SerialPort.DATABITS_8,SerialPort.STOPBITS_1,SerialPort.PARITY_NONE); 
       serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); 

       out=serialPort.getOutputStream(); 

       byte[] Data=hexStringToByteArray("010403e80001b1ba"); 
       out.write(Data, 0, Data.length); 

       Thread.sleep(500); 


       in=serialPort.getInputStream(); 

       byte[] readbuff=new byte[1024]; 
       int num=0; 
       while(in.available()>0) 
       { 
        num=in.read(readbuff); 
       } 

       System.out.println(ByteToHex(readbuff,num)); 

      } 
      else 
      { 
       System.out.println("Error: Only serial ports are handled by this example."); 
      } 
     }  
    } 



    public String ByteToHex(byte[] b,int len) throws Exception 
    { 

     String result=""; 

     for (int i=0;i<len;i++) 
     { 
      result+=Integer.toString((b[i]& 0xff)+0x100, 16).substring(1); 
     } 
     return result; 
    } 



    public byte[] hexStringToByteArray(String s) { 
     int len = s.length(); 
     byte[] data = new byte[len/2]; 
     for (int i = 0; i < len; i += 2) { 
      data[i/2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)+ Character.digit(s.charAt(i+1), 16)); 
     } 
     return data; 
    } 



    public static void main (String[] args) 
    { 
     SerialComm test; 
     try 
     { 
      test = new SerialComm(); 
      test.connect("/dev/ttyUSB0"); 

     } 
     catch (Exception e) 
     { 

      e.printStackTrace(); 
     } 
    } 
}