Com порт OutputStream

Хм ... дайте пример записи. Очень странное поведение.

Проверь, правильно ли ты делаешь инициализацию порта.

((SerialPort)port).setSerialPortParams(9600,
 SerialPort.DATABITS_8,
 SerialPort.STOPBITS_1,
 SerialPort.PARITY_EVEN);
((SerialPort)port).setFlowControlMode(SerialPort.FLOWCONTROL_NONE);

Очень важно, что бы эти настройки совпадали с настройками устройства на другом конце.

Вот код! Параметры порта совпадают! Не знаю играет ли это роль пишу под ASP Linux.
Это стандартный пример SerialDemo только добавил функцию Write(short[], int) там как видите я сначала вывел массив потом положил в поток! Ловлю эту инфу на другой стороне а там происходят уже эти подмены! ХЗ в чем дело!

import javax.comm.*;
import java.io.*;
import java.awt.TextArea;
import java.awt.event.*;
import java.util.TooManyListenersException;

/**
 * A class that handles the details of a serial connection. Reads from one
 * TextArea and writes to a second TextArea.
 * Holds the state of the connection.
 */
public class SerialConnection implements SerialPortEventListener, 
					 CommPortOwnershipListener {
    private SerialDemo	       parent;    
    private SerialParameters   parameters;
    private OutputStream       os;
    private InputStream	       is;
    private StringBuffer       inputBuffer;
    private CommPortIdentifier portId;
    private SerialPort	       sPort;
    private boolean	       open;
    private int                nNeedToRead;
    
    JPUMAL1 m_L1;

    /**
     * Creates a SerialConnection object and initilizes variables passed in
     * as params.
     * @param parent A SerialDemo object.
     * @param parameters A SerialParameters object.
     * @param messageAreaOut The TextArea that messages that are to be sent out
     * of the serial port are entered into.
     * @param messageAreaIn The TextArea that messages comming into the serial
     * port are displayed on.
     */
    
    public SerialConnection(SerialDemo parent, SerialParameters parameters)
    {
	inputBuffer = new StringBuffer();
        this.parent = parent;
	this.parameters = parameters;	
	open = false;        
    }

    /**
     * Attempts to open a serial connection and streams using the parameters
     * in the SerialParameters object. If it is unsuccesfull at any step it
     * returns the port to a closed state, throws a
     * <code>SerialConnectionException</code>, and returns.
     * Gives a timeout of 30 seconds on the portOpen to allow other applications
     * to reliquish the port if have it open and no longer need it.
     */
    public void openConnection() throws SerialConnectionException 
    {
	// Obtain a CommPortIdentifier object for the port you want to open.
	try {
	    portId = 
		CommPortIdentifier.getPortIdentifier(parameters.getPortName());
	} catch (NoSuchPortException e) {
	    throw new SerialConnectionException(e.getMessage());
	} 

	// Open the port represented by the CommPortIdentifier object. Give
	// the open call a relatively long timeout of 30 seconds to allow
	// a different application to reliquish the port if the user
	// wants to.
	try {
	    sPort = (SerialPort) portId.open("SerialDemo", 30000);
	} catch (PortInUseException e) {
	    throw new SerialConnectionException(e.getMessage());
	} 

	// Set the parameters of the connection. If they won't set, close the
	// port before throwing an exception.
	try {
	    setConnectionParameters();
	} catch (SerialConnectionException e) {
	    sPort.close();

	    throw e;
	} 

	// Open the input and output streams for the connection. If they won't
	// open, close the port before throwing an exception.
	try {
	    os = sPort.getOutputStream();            
	    is = sPort.getInputStream();
	} catch (IOException e) {
	    sPort.close();

	    throw new SerialConnectionException("Error opening i/o streams");
	} 

	// Add this object as an event listener for the serial port.
	try {
	    sPort.addEventListener(this);
	} catch (TooManyListenersException e) {
	    sPort.close();

	    throw new SerialConnectionException("too many listeners added");
	} 

	// Set notifyOnDataAvailable to true to allow event driven input.
	sPort.notifyOnDataAvailable(true);

	// Set notifyOnBreakInterrup to allow event driven break handling.
	sPort.notifyOnBreakInterrupt(true);

	// Set receive timeout to allow breaking out of polling loop during
	// input handling.
	try {
	    sPort.enableReceiveTimeout(30);
	} catch (UnsupportedCommOperationException e) {}

	// Add ownership listener to allow ownership event handling.
	portId.addPortOwnershipListener(this);

	open = true;
    } 

    /**
     * Sets the connection parameters to the setting in the parameters object.
     * If set fails return the parameters object to origional settings and
     * throw exception.
     */
    public void setConnectionParameters() throws SerialConnectionException {

	// Save state of parameters before trying a set.
	int oldBaudRate = sPort.getBaudRate();
	int oldDatabits = sPort.getDataBits();
	int oldStopbits = sPort.getStopBits();
	int oldParity = sPort.getParity();
	int oldFlowControl = sPort.getFlowControlMode();
	
        // Set connection parameters, if set fails return parameters object
	// to original state.
	try {
	    sPort.setSerialPortParams(152000, 
				      parameters.getDatabits(), 
				      parameters.getStopbits(), 
				      parameters.getParity());            
	} catch (UnsupportedCommOperationException e)
        {} 
                
        try {
	    sPort.setSerialPortParams(parameters.getBaudRate(), 
				      parameters.getDatabits(), 
				      parameters.getStopbits(), 
				      parameters.getParity());            
	} catch (UnsupportedCommOperationException e) {
	    parameters.setBaudRate(oldBaudRate);
	    parameters.setDatabits(oldDatabits);
	    parameters.setStopbits(oldStopbits);
	    parameters.setParity(oldParity);

	    throw new SerialConnectionException("Unsupported parameter");
	} 

	// Set flow control.
	try {
	    sPort.setFlowControlMode(parameters.getFlowControlIn() 
				     | parameters.getFlowControlOut());
	} catch (UnsupportedCommOperationException e) {
	    throw new SerialConnectionException("Unsupported flow control");
	}     
    } 

    /**
     * Close the port and clean up associated elements.
     */
    public void closeConnection() {

	// If port is alread closed just return.
	if (!open) {
	    return;
	} 

	// Check to make sure sPort has reference to avoid a NPE.
	if (sPort != null) {
	    try {

		// close the i/o streams.
		os.close();
		is.close();
	    } catch (IOException e) {
		System.err.println(e);
	    } 

	    // Close the port.
	    sPort.close();

	    // Remove the ownership listener.
	    portId.removePortOwnershipListener(this);
	} 

	open = false;
    } 

    /**
     * Send a one second break signal.
     */
    /*public void sendBreak() {
	//sPort.sendBreak(1000);
    }*/
    
    /*
     * Send set of bytes to the port
     */
    
    public int Write(short[] pbtInfo, int nCount)
    {        
        try
        {
            byte[] pbt = new byte[nCount];
                        
            for(int i = 0; i < nCount; i++)
                pbt[i] = (byte)pbtInfo[i];
                
            System.out.print("Serial connection - write - ");
            for(int i = 2; i < nCount - 1; i++)            
                System.out.printf("%02x.",pbtInfo[i]);            
            
            System.out.println("");            
            
            FilterOutputStream fs = new FilterOutputStream( os );
            
            
            fs.write(pbt, 0, nCount);
        }
        catch (IOException e)
        {
            System.err.println(e);
	}
        
        return nCount;
    }
    
    /*
     * Getting bytes from port
     */
    
    public int Read(int nCount, short[] pbtBuff)
    {        
        byte []bdst = new byte[nCount];
        
        int nRes = 0;
        try
        {
            if( is.available() >= nCount ) 
            {
                nRes = is.read(bdst, 0, nCount);

                if( nRes > 0 )
                {                
                    for( int i = 0; i < nCount; i++)
                    {                    
                        pbtBuff[i] = (short)(bdst[i] & 0xFF);                 
                    }
                }
            }
        }
        catch(IOException e)
        {}
        
        return nRes;
    }
        
    /**
     * Reports the open status of the port.
     * @return true if port is open, false if port is closed.
     */
    
    public boolean isOpen() {
	return open;
    } 

    /**
     * Handles SerialPortEvents. The two types of SerialPortEvents that this
     * program is registered to listen for are DATA_AVAILABLE and BI. During
     * DATA_AVAILABLE the port buffer is read until it is drained, when no more
     * data is availble and 30ms has passed the method returns. When a BI
     * event occurs the words BREAK RECEIVED are written to the messageAreaIn.
     */
    public void serialEvent(SerialPortEvent e) {
	
	int	     newData = 0;

	// Determine type of event.
	switch (e.getEventType()) {

	// Read data until -1 is returned. If \r is received substitute
	// \n for correct newline handling.
	case SerialPortEvent.DATA_AVAILABLE:            
	    
            //if(m_L1 != null)
            //    m_L1.m_pRead.SetEvent();
	    break;

	// If break event append BREAK RECEIVED message.
	case SerialPortEvent.BI:
            break;
	}
    } 

    /**
     * Handles ownership events. If a PORT_OWNERSHIP_REQUESTED event is
     * received a dialog box is created asking the user if they are
     * willing to give up the port. No action is taken on other types
     * of ownership events.
     */
    public void ownershipChange(int type) {
	if (type == CommPortOwnershipListener.PORT_OWNERSHIP_REQUESTED) {
	    PortRequestedDialog prd = new PortRequestedDialog(parent);
	} 
    }    
}