RXTX comment la lecture de port com

Salut j'ai quelque chose comme ceci

package compot;

import java.util.Enumeration;
import gnu.io.*;


public class core {

    private static SerialPort p;

    /**
     * @param args
     */
    public static void main(String[] args) 
    {
        Enumeration ports = CommPortIdentifier.getPortIdentifiers();
        System.out.println("start");
        while(ports.hasMoreElements())
        {
            CommPortIdentifier port = (CommPortIdentifier) ports.nextElement();
            System.out.print(port.getName() + " -> " + port.getCurrentOwner() + " -> ");
            switch(port.getPortType())
            {
                case CommPortIdentifier.PORT_PARALLEL:
                    System.out.println("parell");
                break;
                case CommPortIdentifier.PORT_SERIAL:
                    //System.out.println("serial");
                try {
                    p = (SerialPort) port.open("core", 1000);
                    int baudRate = 57600; //57600bps
                    p.setSerialPortParams(
                            baudRate,
                            SerialPort.DATABITS_8,
                            SerialPort.STOPBITS_1,
                            SerialPort.PARITY_NONE);
                } catch (PortInUseException e) {
                    System.out.println(e.getMessage());
                } catch (UnsupportedCommOperationException e) {
                    System.out.println(e.getMessage());
                }
                break;
            }
        }
        System.out.println("stop");
    }
}

Mais je ne sais pas comment lire de port ?? J'ai lu ce tutoriel mais je ne sais pas ce que "l'application Démo" qu'ils signifient ??

MODIFIER

OutputStream outStream = p.getOutputStream();
                    InputStream inStream = p.getInputStream();

                    BufferedReader in = new BufferedReader( new InputStreamReader(inStream));
                    String inputLine;

                    while ((inputLine = in.readLine()) != null) 
                        System.out.println(inputLine);
                    in.close();

J'ai ajouter ce code, mais j'en attente de la

Stable De La Bibliothèque
========================================= Natif lib Version =
RXTX-2.1-7 Java lib Version = RXTX-2.1-7 start /dev/ttyUSB3 -> null
-> sous-jacentes flux d'entrée retourné zéro octets arrêter

Un suivi à venir? Aucune réaction? :p
J'ai modifier ma question
Cela pourrait être un problème avec le contrôle de flux. vous pouvez le régler sur le port avec port.setFlowControl() la méthode. Cependant, il est impossible pour moi de le dire, qui contrôle de flux que vous devez utiliser. Peut-être commencer à lire des choses sur les ports série en général: tldp.org/HOWTO/Serial-HOWTO-4.html Et je suggère la lecture de l'inputstream octet-sage ligne pas-sage. Mais cela dépend de l'appareil que vous êtes en train d'essayer de communiquer avec.
Im en utilisant TTL RS232 convertisseur, mais wht im obtenir ttyUSB0 pas ttyS0 ?? Mais lorsque j'insère une clef usb il ne marche pas le voir

InformationsquelleAutor skowron-line | 2011-07-20

java rxtx

6

Est-ce votre code? De quoi êtes-vous en train d'essayer de faire là? :p

Afin de les lire à partir d'un SerialPort, vous devez déclarer ce port:
```
CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier("/dev/tty/USB0"); //on unix based system
```
Puis ouvrir une connexion sur ce port:
```
SerialPort serialPort = (SerialPort) portIdentifier.open("NameOfConnection-whatever", 0);
```
Prochaine étape consisterait à définir les paramètres de ce port (si nécessaire):
```
serialPort.setSerialPortParams(38400, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
```
C'est ma config - le votre, peut varier en conséquence 🙂

Vous êtes maintenant prêt à lire des données sur ce port!
Pour obtenir les données, vous avez besoin pour obtenir le serialPorts inputstream et lire à partir de:
```
InputStream inputStream = serialPort.getInputStream();
while (active) {
        try {
            byte[] buffer = new byte[22];
            while ((buffer[0] = (byte) inputStream.read()) != 'R') {
            }
            int i = 1;
            while (i < 22) {
                if (!active) {
                    break;
                }
                buffer[i++] = (byte) inputStream.read();
            }
            //do with the buffer whatever you want!
        } catch (IOException ex) {
            logger.error(ex.getMessage(), ex);
        }
}
```
Ce que je suis en train de faire ici est de la lecture de l'inputstream en utilisant son read() méthode. Cela va bloquer jusqu'à ce que les données sont disponibles ou renvoie -1 si la fin du flux est atteinte. Dans cet exemple, je vais attendre que je reçois un " R " à caractère de lire la suite 22 octets en mémoire. Et voilà comment lire les données.
1. Obtenir le serialPorts inputstream
2. utilisation .méthode read ()
3. avons tous à l'intérieur d'une boucle et de sortie de la boucle en cas d'annulation (dans mon cas, le active peut être définie à false par une autre méthode et donc la fin du processus de lecture.
espère que cette aide

InformationsquelleAutor chzbrgla
2

Essayez d'utiliser
```
if (socketReader.ready()) {
}
```
afin que le support ne répond que quand il y a quelque chose à lire dans la mémoire Tampon de Flux
si l'Exception ne Se produit jamais.

InformationsquelleAutor Saran
0

Quelque chose comme ceci dans votre bloc try:
```
OutputStream outStream = p.getOutputStream();
InputStream inStream = p.getInputStream();
```
- Donc, qu'est-ce que p = (SerialPort) port.open("core", 1000); ce pour cette première partie "core" besoin d' ??
- le serialport de connexion est appelé "core" et les délais d'attente après 1000ms lorsque le propriétaire actuel n'a pas communiqué de la connexion à l'intérieur de l'époque.. il n'ont pas de processus à l'aide de ce port de toute façon
- Ce nom permettra d'identifier le propriétaire du port. Il suffit d'utiliser votre nom de l'application. Plus d'infos: lien
InformationsquelleAutor Patrik

Vous devez vous connecter pour publier un commentaire.