Kommunikation über Com liegt brach

Morgen Morgen,

habe ein kleines Problem und hoffe auf Hilfe. (Das Script hat ein 
bekannter von mir geschrieben da er mehr Ahnung von der Materie hat als 
ich. Ich versuche mich natürlich selber auch einzubringen da das Script 
ja auch für mich gedacht ist.)

Und zwar habe ich 2 Rechner:

Rechner 1 Com2
Rechner 2 Com2

Nun ein versuch:

Auf Rechner 1 ist das Script und auf Rechner 2 hypertrm aktiv. Sobald 
ich nun das Script ausführe erscheint im hypertrm 
„[10][02][03][10][03][00]“. Somit sendet das Script aufjedenfall.

Wenn ich nun auf Rechner 1 und Rechner 2 das Script laufen lasse, kommt 
leider nichts an. Was wohl bedeutet das das empfangen noch nicht richtig 
funktioniert. Könnte mir da vlt. jemand Helfen?

#------------------#

package tp;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.TooManyListenersException;

import gnu.io.*;

/**
 * COM2SchnittstellenTransfer
 * @author ABre
 * @version 1.0 1/27/2010*/
public class Com2PortTransfer implements Runnable{
    private Thread thread;
    private CommPortIdentifier com2PortIdentifier;
    private SerialPort com2;
    private int baud;
    private int dataBits;
    private int stopBits;
    private int parity;
    private OutputStream outputStream;
    private InputStream inputStream;

    public static void main(String[] args) {
        new Com2PortTransfer();
    }

    public Com2PortTransfer() {
        baud = 38400;
        dataBits = SerialPort.DATABITS_8;
        stopBits = SerialPort.STOPBITS_1;
        parity = SerialPort.PARITY_NONE;
        try {
            com2PortIdentifier = getSerialPortCom2();
        } catch (NoSuchPortException e) {
            System.err.println("Port COM2 nicht gefunden: " + 
e.getStackTrace());
        }
        thread = new Thread(this);
        thread.start();
    }

    @Override
    public void run(){
        System.out.println(portOpenNAddThings(baud, dataBits, stopBits, 
parity) ?
                "COM2 geöffnet, Parameter gesetzt." : "42");

        while (true){
        String anfrage = "[10][02][03][10][03][00]";
        System.out.println(sendeDaten(anfrage) ?
                "Daten gesendet: " + anfrage : "42");

        }
//      try {
//          Thread.sleep(2000);
//      } catch (InterruptedException e) {
//          e.printStackTrace();}
//
//      System.out.println(portSchliessen() ?
//              "COM2 geschlossen." : "Fehler: Schliessen COM2.");
    }

    /**
     *  @return Serielle Schnittstelle COM2*/
    @SuppressWarnings("unchecked")
    private CommPortIdentifier getSerialPortCom2() throws 
NoSuchPortException{
        Enumeration<CommPortIdentifier> ports = 
CommPortIdentifier.getPortIdentifiers();
        while (ports.hasMoreElements()){
            CommPortIdentifier ret = (CommPortIdentifier) 
ports.nextElement();
            if (ret.getName().equals("COM2")){
                return ret;
            }
        }
        throw new NoSuchPortException();
    }//getSerialPort

    /**
     * @param baud
     * @param dataBits
     * @param stopBits
     * @param parity
     * @return only TRUE COM2 geöffnet und Parameter gesetzt ELSE 
EXCEPTION*/
    private boolean portOpenNAddThings(int baud, int dataBits, int 
stopBits, int parity){
        try {
            com2 = (SerialPort) com2PortIdentifier.open("42", 1000);
        } catch (PortInUseException e) {
            System.err.println("COM2 wird schon benutzt: " + 
e.getStackTrace());
        }
        try {
            com2.setSerialPortParams(baud, dataBits, stopBits ,parity);
        } catch (UnsupportedCommOperationException e) {
            System.err.println("COM2 Parameter können nicht gesetzt 
werden: " + e.getStackTrace());
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();}
        try {
            outputStream = com2.getOutputStream();
            inputStream = com2.getInputStream();
        } catch (IOException e) {
            e.printStackTrace();}
        try {
            com2.addEventListener(new MyPortListener());
        } catch (TooManyListenersException e) {
            e.printStackTrace();}
        return true;
    }//portOeffnen

    /**
     * @return TRUE COM2 geschlossen ELSE FALSE*/
    private boolean portSchliessen(){
        if (com2 != null){
            com2.close();
            return true;
        }
        return false;
    }//portSchliessen

    /**
     * @param daten Daten als String
     * @return TRUE Daten gesendet*/
    private boolean sendeDaten(String daten){
        try {
            outputStream.write(daten.getBytes());
        } catch (IOException e) {
            e.printStackTrace();}
        return true;
    }

    /**
     * SerialPortEventListener*/
    private class MyPortListener implements SerialPortEventListener{

        @Override
        public void serialEvent(SerialPortEvent event) {
            if (event.getEventType() == SerialPortEvent.DATA_AVAILABLE){
                int temp;
                System.out.println("Daten verfügbar.");
                try {
                    while ((temp = inputStream.read()) != -1)
                        System.out.println((char) temp);
                } catch (IOException e) {
                    e.printStackTrace();}
            }
        }

    }//MyPortListener

}//Com2PortTransfer