Comunicación serial entre Java RXTX y Arduino

Question

Estoy tratando de comunicarme entre mi PC (Windows 7 usando Netbeans y RXTX) con un Arduino Pro, usando el puerto serie. Arduino está conectado a la PC con un cable FTDI.

El código está basado en Java SimpleRead.Java encontró here.

Actualmente el Arduino simplemente imprime una cadena cuando se inicia. Mi programa Java debe imprimir el número de bytes que se han leído y luego imprimir los contenidos. El programa Java funciona, más o menos ...

Si la cadena es larga (> 10 bytes o menos) la salida se romperá.

lo tanto, si en el Arduino imprimo

Serial.println("123456789123456789"); //20 bytes including '\r' and '\n' 

La salida de mi programa Java puede ser algo como:

Number of Bytes: 15 
1234567891234 
Number of Bytes: 5 
56789 

o

Number of Bytes: 12 
1234567891 
Number of Bytes: 8 
23456789 

estoy pensando que es una problema de tiempo, porque cuando paso manualmente el código usando el depurador, la cadena de resultados es siempre lo que debería ser: e cadena de 20 bytes.

He estado jugando con varias cosas, pero no he podido solucionar el problema.

Aquí es la parte del código que me está dando problemas:

static int baudrate = 9600, 
      dataBits = SerialPort.DATABITS_8, 
      stopBits = SerialPort.STOPBITS_1, 
      parity = SerialPort.PARITY_NONE;  

byte[] readBuffer = new byte[128]; 

... 
... 

public void serialEvent(SerialPortEvent event) 
{ 
    if (event.getEventType() == SerialPortEvent.DATA_AVAILABLE) { 

    try { 
     if (input.available() > 0) { 
      //Read the InputStream and return the number of bytes read 
      numBytes = input.read(readBuffer); 

      String result = new String(readBuffer,0,numBytes); 
      System.out.println("Number of Bytes: " + numBytes); 
      System.out.println(result); 
     } 
    } catch (IOException e) { 
     System.out.println("Data Available Exception"); 
    } 
} 

Answer 1

de datos en serie es sólo un flujo de datos. Dependiendo de cuándo lo lea y del almacenamiento en búfer que está sucediendo, solo una parte de los datos estará disponible cuando lo lea.

Dado que está utilizando datos orientados a la línea, lo que tendrá que hacer es almacenar los datos hasta que vea el terminador de línea y solo luego procese los datos.

Answer 2

No he usado Java RXTX, pero he jugado con Arduino y Processing y es muy fácil leer/escribir valores de Arduino. Este es un ejemplo de lectura que viene con Processing (Archivo> Ejemplos> Bibliotecas> Serie> SimpleRead)

/** 
* Simple Read 
* 
* Read data from the serial port and change the color of a rectangle 
* when a switch connected to a Wiring or Arduino board is pressed and released. 
* This example works with the Wiring/Arduino program that follows below. 
*/ 


import processing.serial.*; 

Serial myPort; // Create object from Serial class 
int val;  // Data received from the serial port 

void setup() 
{ 
    size(200, 200); 
    // I know that the first port in the serial list on my mac 
    // is always my FTDI adaptor, so I open Serial.list()[0]. 
    // On Windows machines, this generally opens COM1. 
    // Open whatever port is the one you're using. 
    String portName = Serial.list()[0]; 
    myPort = new Serial(this, portName, 9600); 
} 

void draw() 
{ 
    if (myPort.available() > 0) { // If data is available, 
    val = myPort.read();   // read it and store it in val 
    } 
    background(255);    // Set background to white 
    if (val == 0) {    // If the serial value is 0, 
    fill(0);     // set fill to black 
    } 
    else {      // If the serial value is not 0, 
    fill(204);     // set fill to light gray 
    } 
    rect(50, 50, 100, 100); 
} 



/* 

// Wiring/Arduino Code 
// Code for sensing a switch status and writing the value to the serial port. 

int switchPin = 4;      // Switch connected to pin 4 

void setup() { 
    pinMode(switchPin, INPUT);    // Set pin 0 as an input 
    Serial.begin(9600);     // Start serial communication at 9600 bps 
} 

void loop() { 
    if (digitalRead(switchPin) == HIGH) { // If switch is ON, 
    Serial.print(1, BYTE);    // send 1 to Processing 
    } else {        // If the switch is not ON, 
    Serial.print(0, BYTE);    // send 0 to Processing 
    } 
    delay(100);       // Wait 100 milliseconds 
} 

*/ 

Por lo que yo recuerdo, la transmisión THINGY que preparó en Arduino cuando usted instancia de serie es bastante importante. Si usa 9600 para enviar, por ejemplo, debe usar el mismo número para escuchar.

También es muy importante enviar su información como BYTE, de lo contrario, tendrá cosas como \ r o \ n en el camino.

Shorter versión, intente:

Serial.println(123456789123456789,BYTE); 

Cuanto más simple, mejor.

Answer 3

Creo que necesita utilizar patrones de diseño impulsados ​​por eventos para resolver este problema. Le recomiendo que visite: http://www.whatisarduino.org/bin/Tutorials/Java+Serial+API+and+Arduino