Javacomm API sendet falsch?

Computer: Software & Programmierung Java
#1

Hallo,
an der FH habe ich ein Projekt am laufen, mit dem ich per GPS ein Fahrzeug über USB steuer. Da ich windows XP und Java verwende, habe ich mir die „Java communication API“ geholt, mit der ich die Verbindung zum Port aufbau.

Ich sende einen String (S motorID geschw -> S 0 18) an meinen Port, der per USB die Daten zu einer kleinen Platine (MiniBoard von qfix) leitet.

Aber irgendwie sendet er nicht die kompletten Daten (zumindest in 99% der Fälle). Das MiniBoard ist so programmiert, dass es zurückgibt, was es empfangen hat. Wenn es einen Fehler bei der Übertragung festgestellt hat (Falscher String, oder unkompletter String) dann sendet es ERROR zurück.
Ich habe festgestellt, sobald er einmal dann richtig die Daten empfangen hat, läuft das Programm ohne Probleme weiter… (Dahin bin ich erst 2 mal gekommen seit 2 Wochen)

Mit HyperTerminal kann ich auch die Strings komplett rübersenden.
Dafür muss ich aber in den Einstellungen unter ASCII-Konfiguration den Haken bei „Gesendete Zeilen enden mit Zeilenvorschub“ setzen. (Hat uns der Projektbetreuer gesagt, der auch das MiniBoard herstellt).

Kann mir jemand sagen, wie ich einen „Zeienlenvorschub“ in Java sende?
Wenn es das \n oder das \r ist, habe ich wohl schon alles ausprobiert.

Aber das, was mich wundert ist folgendes:
Am Donnerstag Abend habe ich das Senden der Strings versucht, und alles hat Tadellos geklappt (nach dem ich „Zünden“ gedrückt habe… dazu später).
Als ich es dann meinem Lehrer am Freitag morgen (ohne CodeÄnderung) zeigen wollte, lief es nicht mehr (von 9 - 14 Uhr). Trotz ununterbrochenem „Zünden“.

Dieses „Zünden“ ist bei mir eine Funktion, die so lange einen String sendet, bis 50 mal kein ERROR zurückgekommen ist.
Mir ist aufgefallen, dass wenn ich immer wieder das gleiche Signal sende, irgendwann mal das richtige am MiniBoard ankommt. Wenn dann einmal das richtige angekommen ist, kommen die nachfolgenden Strings fast immer auch richtig an.
Darum ist die „Zünden“ Methode da, die eine Variable von 50 runter zählt, und so lange den gleichen String sendet bis die Variable bei 0 ankommt. Falls ein ERROR zurückkommt, wird die Variable wieder auf 50 gesetzt.
Dadurch erreich ich, dass ich mir nahe zu sicher sein kann, dass die folgenden Strings auch richtig übertragen werden.

Was mir noch aufgefallen ist bei der Zurücksendung der empfangenen Daten (Antwort von MiniBoard an PC):
Wenn ich einen String sende z.B. S 0 18, dann sendet mir das MiniBoard manchmal zurück, dass ich nur „S 0 1“ oder auch manchmal " 0 18", oder auch „0 18 S“ gesendet Hätte… Kann das an einem Puffer liegen?

Fragen:

  • Wie sendet man einen Zeilenvorschub (außer \n oder \r)?
  • Kann es sein, dass ein Puffer, falsch ist, der dann unkomplette Daten überträgt?

Ich werde in ca. 1 Stunde hier mal den QuellCode von meiner Datei geben, die mit dem MiniBoard kommunizieren sollte.

Danke schon mal für die Hilfe

#2

So hier ist der angekündigte Code:

_import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.comm.CommPortIdentifier;
import javax.comm.SerialPort;
import javax.comm.SerialPortEvent;
import javax.comm.SerialPortEventListener;
import javax.comm.UnsupportedCommOperationException;
import javax.swing.JOptionPane;

public class com_abfrage {

static CommPortIdentifier port_ID;
public static OutputStream mini_port_out;
public static InputStream mini_port_ins;
public static SerialPort mini_port;
public static String mini_port_news = „“; //Mini-Board ausgabe
public static byte[] readBuffer = new byte[8];
public static String mini_board_port = „14“; //Port zum Mini-Board
public static boolean kalibrieren = true; //Die Motortreiber auf den Mittelwert setzen?

public static String c_grad = „130“;
public static boolean kompassfertig = false;
public static int zuendung = 200;

/**
* Die Datenübertragung an den com_port vorbereiten
*/
public com_abfrage() {
com_select();
com_connect();

System.out.println(„Fertig“);
}

/**
* Den Port zum Mini-board einrichten
*/
public void com_select() {
try{
port_ID = CommPortIdentifier.getPortIdentifier(„COM“+mini_board_port);
mini_port = (SerialPort) port_ID.open(„Motoren Steuerungstool“,2000); //Eigentümer des Ports sowie die maximale Wartezeit
}
catch(Exception exc){System.out.println(„Fehler :“+exc);}
}

/**
* Die Verbindung zum Mini-Board einrichten
* Baud: 115200
* Datenbits: 8
* Stopbit: 1
* Parität: nein
* Flusskontrolle: nein
*/
public void com_connect() {
try {
mini_port_ins = mini_port.getInputStream();

mini_port_out = new BufferedOutputStream(mini_port.getOutputStream());
mini_port.addEventListener(new recieve());
}
catch (Exception e) { System.out.println("Fehler: "+e);}

mini_port.notifyOnDataAvailable(true);

try {
mini_port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
mini_port.setSerialPortParams(115200, SerialPort.DATABITS_8, SerialPort.STOPBITS_1 , SerialPort.PARITY_NONE);}
catch (UnsupportedCommOperationException e) {}

if(kalibrieren == true)
{
zuenden();
}
}

/**
* Diese Methode sendet so oft einen String an das MiniBoard, bis die ERRORs beseitigt sind
* (Bei Tests ergab sich, dass hierfür idealerweise 1000 mal die Motortreiber angesprochen werden müssen)
*/
public static void zuenden()
{
//Fahrtregler auf 18 (standard) setzen
while(zuendung > 0)
{
transmit(„S 0 18“);
transmit(„S 1 18“);
zuendung–;
}
zuendung = 200;
}

/**
* Mit Hilfe dieser Methode wird der Kompass abgefragt
*/
public static boolean kompass_lesen()
{
//transmit(„C 0“);
do
{
System.out.println(„KompassWhileSchleife!“);
transmit(„C 0“);
}while(com_abfrage.kompassfertig == false);
com_abfrage.kompassfertig=false;

return true;

}

**/**
* Datenübertragung an das Mini-Board
* Der übergebene String wird an das Mini-Board gesendet
* @param command
*/
public static void transmit (String command)
{
try {
Thread.sleep(5);
} catch (InterruptedException ex) {
ex.printStackTrace();
}

PrintWriter mini_port_aus = new PrintWriter(mini_port_out);

mini_port_aus.println(command);

mini_port_aus.flush();
mini_port_aus.close();

}**

/**
* Daten vom Mini-Board empfangen
*/
public class recieve implements SerialPortEventListener{
public void serialEvent(SerialPortEvent event) {
if(event.getEventType()==SerialPortEvent.DATA_AVAILABLE){
readBuffer = new byte[8];
try {
while (mini_port_ins.available() > 0) {int numBytes = mini_port_ins.read(readBuffer);}
mini_port_news = new String(readBuffer);
System.out.println(mini_port_news);
boarfilter(mini_port_news);
gpsausgabePanel.ausgabe.append(mini_port_news);
}
catch (IOException e) {System.out.println("Fehler: "+e);}
}
}
}

/**
* Aus dem empfangen Text die Kompasseinstellung herausfiltern
* @param nachricht
*/
@SuppressWarnings(„static-access“)
void boarfilter(String nachricht)
{
boolean c_gefunden = false;
int c_position = 0;
int grad = 0;
String tempgrad = „“;

try{
for(int i = 0; i 4 && nachricht.charAt(i) == ‚C‘ && nachricht.charAt(i+1) == ’ ’ && (nachricht.charAt(i+2) == ‚1‘ || nachricht.charAt(i+2) == ‚2‘ || nachricht.charAt(i+2) == ‚3‘ || nachricht.charAt(i+2) == ‚4‘ || nachricht.charAt(i+2) == ‚5‘ || nachricht.charAt(i+2) == ‚6‘ || nachricht.charAt(i+2) == ‚7‘ || nachricht.charAt(i+2) == ‚8‘ || nachricht.charAt(i+2) == ‚9‘))
{
/*for(int j = 2; j

Dies ist nur die Datei, die an das MiniBoard sendet…
Die Mehode „transmit“ wird von außerhalb aber auch „zuenden“ aufgerufen.

Vielleicht fällt ja hier jemandem auf, was ich ändern könnte.

Kann man irgendwie den Puffer ändern, oder wenigstens einmal löschen?
Ich hab es mit .flush() versucht, aber ich weiß nicht, ob es klappt.

mfg, Kevin_