Java Comm API Issue

Question

J'ai réussi à installer et tester l'API Java Comm. Je pourrais envoyer et recevoir des données via le port série. Mais le problème est qu'il y a 19 espaces supplémentaires avant chaque personnage. Lorsque j'ai essayé d'utiliser hyper terminal, les espaces supplémentaires n'étaient pas là.

Par exemple:

+ CENG: 0, "0021,37,99,404,46,36,0000,05,05,77,255"

est attendue. Mais le programme Java, il génère des espaces avant chaque charector

   +   E   N 

Le code est:

import java.io.*; 
import java.util.*; 
import javax.comm.*; 

public class SimpleRead implements Runnable, SerialPortEventListener 
{ 
    static CommPortIdentifier portId; 
    static Enumeration portList; 

    InputStream inputStream; 
    SerialPort serialPort; 
    Thread readThread; 

    public static void main(String[] args) throws Exception 
    { 
     portList = CommPortIdentifier.getPortIdentifiers(); 
     System.out.println("SimpleRead Started."); 
     while (portList.hasMoreElements()) 
      { 
       portId = (CommPortIdentifier) portList.nextElement(); 
       if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) 
        { 
         System.out.println ("Found " + portId.getName()); 
         if (portId.getName().equals("COM5")) 
          { 
           OutputStream outputStream; 
           SerialPort writePort = (SerialPort) portId.open("SimpleWriteApp", 2000); 
           writePort.setSerialPortParams(2400, 
                   SerialPort.DATABITS_8, 
                   SerialPort.STOPBITS_1, 
                   SerialPort.PARITY_NONE); 
           outputStream = writePort.getOutputStream(); 
           outputStream.write("AT+CENG=2".getBytes()); 
           writePort.close(); 
           SimpleRead reader = new SimpleRead(); 
          } 
        } 
      } 
    } 

    public SimpleRead() 
    { 
     try 
      { 
       serialPort = (SerialPort) portId.open("SimpleReadApp", 2000); 
      } 
     catch (PortInUseException e) 
      { 
       e.printStackTrace(); 
      } 
     try 
      { 
       inputStream = serialPort.getInputStream(); 
      } 
     catch (IOException e) 
      { 
       e.printStackTrace(); 
      } 
     try 
      { 
       serialPort.addEventListener(this); 
      } 
     catch (TooManyListenersException e) 
      { 
       e.printStackTrace(); 
      } 
     serialPort.notifyOnDataAvailable(true); 
     try 
      { 
       serialPort.setSerialPortParams(2400, SerialPort.DATABITS_8, 
               SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); 
      } 
     catch (UnsupportedCommOperationException e) 
      { 
       e.printStackTrace(); 
      } 
     readThread = new Thread(this); 
     readThread.start(); 
    } 

    public void run() 
    { 
     try 
      { 
       Thread.sleep(20000); 
      } 
     catch (InterruptedException e) 
      { 
       e.printStackTrace(); 
      } 
    } 

    public void serialEvent(SerialPortEvent event) 
    { 
     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: 
       break; 
      case SerialPortEvent.DATA_AVAILABLE: 
       byte[] readBuffer = new byte[20]; 

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

Answer 1

Dans votre code, vous avez (gestion des exceptions retirée à des fins d'exemple):

byte[] readBuffer = new byte[20]; 

while (inputStream.available() > 0) 
{ 
    int numBytes = inputStream.read(readBuffer); 
} 

System.out.print(new String(readBuffer)); 

Vous avez un tampon de 20 octets et vous construisez un String à partir de tous les 20 octets, peu importe la quantité de données que vous lisez. En Java, un String peut contenir des valeurs nulles, et donc votre chaîne se termine par un caractère suivi de 19 valeurs NULL. Ensuite, lorsque vous l'imprimez, votre console affiche des espaces au lieu de null.

Deux choses à noter. D'abord, ce que vous essayez de faire avec cette boucle n'est pas vraiment clair. Vous lisez à plusieurs reprises dans le même tampon de 20 octets, peu importe le nombre d'octets qui restent sur le flux (par exemple, s'il y a 400 octets à lire, au maximum readBuffer se retrouve avec les 20 derniers). Deuxièmement, pour résoudre le problème de chaîne que je viens de décrire, vous voulez utiliser uniquement les octets que vous avez réellement lus à partir de readBuffer, c'est-à-dire les premiers numBytes octets du tampon. Troisièmement, vous devez toujours spécifier un codage de caractères lors de la construction d'un String à partir d'octets bruts. Pour vos données, il semble que us-ascii est approprié.

donc quelque chose comme ça, par exemple:

byte[] readBuffer = new byte[20]; 

while (inputStream.available() > 0) { 
    int numBytes = inputStream.read(readBuffer); 
    System.out.print(new String(readBuffer, 0, numBytes, "us-ascii")); 
}