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);
        } 
    }    
}