关于串口接收数据出现“0A＝ 0D 0A”的问题？

Question

我在使用JAVA编程进行串口通讯时发现了一个问题——就是只要数据中存在0x0A时，在windows操作系统下0x0A前会多出一个0x0D；而在linux下0x0A前会多出一个0x0A，而且如果有0x0D这个数的话，系统会强行把0x0D变成0x0A，我试过用字符、字符串和字节的形式发送都不行。用DataOutputStream、OutputStream、OutputStreamWriter发送都不行。那位大虾帮帮忙解决一下，感激不尽！

Answer 1

我用的是
OutputStream out；
out = serialPort.getOutputStream();
out.Write（HexString）；
没什么问题啊
win xp系统没有linux环境

Answer 2

我专门发了03 10 03 10……这么一组数据收到的却是03 10 10 03 10 10，不知道为什么，有的说用二进制流发送就行，但OutputStream应该就是二进制流了

Answer 3

是linux下的，用Java程序接收的话就是03 10 10 03 10 10，若使用串口助手的话就是03 0D 0A 03 0D 0A,谁能帮帮我啊！

Answer 4

linux没有用过啊 
不过两边都设置号了是收发十六进制或者是字符串，应该就是一样的哦
在win xp下呢

Answer 5

package test;
import java.io.DataOutputStream;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.TooManyListenersException;import javax.comm.CommPortIdentifier;
import javax.comm.NoSuchPortException;
import javax.comm.PortInUseException;
import javax.comm.SerialPort;
import javax.comm.SerialPortEvent;
import javax.comm.SerialPortEventListener;
import javax.comm.UnsupportedCommOperationException;//静态方法只能访问静态变量，如果想访问非静态变量，只能通过声明对象来访问
//静态方法不属于类，在类内方法访问变量不需加对象，类外（例如静态的main函数）需要加对象public class Transceiver implements SerialPortEventListener { CommPortIdentifier portId;
private String str;
private InputStream inputStream;
private static byte[] data1={03,10,03,10,03,10};
private SerialPort serialPort; OutputStream outputStream;


String str1;// =new String(); public Transceiver(String com, int foc) {
// 构造函数 try {
portId = CommPortIdentifier.getPortIdentifier(com);
try {
serialPort = (SerialPort) portId.open("SimpleReadApp", 2000);
} catch (PortInUseException e) { } try {
serialPort.getFlowControlMode();
try {
serialPort.setFlowControlMode(0);
} catch (UnsupportedCommOperationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
inputStream = serialPort.getInputStream();
 outputStream = serialPort.getOutputStream();
} catch (IOException e) { }
try {
serialPort.addEventListener(this);// 进行端口监听 , 当事件发生自动调用
// serialEvent方法
} catch (TooManyListenersException e) {
}
serialPort.notifyOnDataAvailable(true);
try {
serialPort.setSerialPortParams(foc, SerialPort.DATABITS_8,
SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
} catch (UnsupportedCommOperationException e) { }
} catch (NoSuchPortException e) { }
}// 构造函数 public void writeport(byte[] buffer) { try { outputStream.write(buffer,0,buffer.length);

} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace(); } } // //////////////////////////////////////////////////////////////////// // 处理侦听到的串口事件
public void serialEvent(SerialPortEvent event) {
// System.out.println("接收数据...\r\n");
switch (event.getEventType()) {
case SerialPortEvent.BI:// 通讯中断.
case SerialPortEvent.OE:// 溢位错误.
case SerialPortEvent.FE:// 帧错误
case SerialPortEvent.PE:// 奇偶校验错.
case SerialPortEvent.CD:// 载波检测.
case SerialPortEvent.CTS:// 清除发送.
case SerialPortEvent.DSR:// 数据设备准备好
case SerialPortEvent.RI:// 振铃指示.
case SerialPortEvent.OUTPUT_BUFFER_EMPTY:// OUTPUT_BUFFER_EMPTY -
// 输出缓冲区已清空
break;
case SerialPortEvent.DATA_AVAILABLE:// DATA_AVAILABLE - 有数据到达
// float ch;
int ch;
short command; StringBuffer buf = new StringBuffer();
// 读数据
try {
InputStream input = serialPort.getInputStream(); while ((ch = input.read()) > 0) {
if (ch == 36)
break;
buf.append((char) ch); }
 input.read(data, 0, data.length);//若是用这个读的话就是03 10 10 03 10 10 93 10 10
str = buf.toString();
System.out.println(str);

}
} catch (IOException e) {
}
break;
}
} public void Close() {
serialPort.close(); }
 public static void main(String[] args) {
 Transceiver transceiver=new Transceiver("/dev/ttyS0",9600);  transceiver.writeport(data1);
 
 }
}

Answer 6

package send;public class SerialBuffer
{
public String Content = "";
private String CurrentMsg;
private boolean available = false;
private int LengthNeeded = 2;
public boolean isTimeOut=false; public synchronized String getMsg(long timeOut)//获得所读取的前两个字符
{
while (Content.equals("")||Content==null)
{
try
{
wait(timeOut);
}catch(InterruptedException e){
e.printStackTrace();
}
if(Content.equals("")||Content==null)
{
isTimeOut=true;
Content="aa";
}
else
{
break;
}
}
CurrentMsg = Content.substring(0, LengthNeeded);
Content = Content.substring(LengthNeeded, Content.length());
notifyAll();
return CurrentMsg;
} public synchronized void putChar(int c)//得到串口读过来的数据存到字符变量中
{
String t="";
t=Integer.toHexString(c);
if(t.length()<2)
{
t="0"+t;
}
Content = Content.concat(t);
if (LengthNeeded < Content.length())
{
available = true;
}
notifyAll();
}
public synchronized void cleanBuff()
{
Content="";
notifyAll();
}public synchronized boolean getIsTimeOut()
{
notifyAll();
return isTimeOut;
}
}
package send;
import java.io.*;
import javax.comm.*;public class SerialBean
{
private String mess="";//从串口读过来的数据

private static String PortName;
private CommPortIdentifier portId;
private SerialPort serialPort;
private static OutputStream out;
private static InputStream in;

private String Content = "";
private String CurrentMsg;
private boolean available = false;
private int LengthNeeded = 2;

private ReadSerial rs;
private SerialBuffer sb;

public SerialBean(int PortID,int BaudRate)
{
Initialize(PortID,BaudRate);
}
public int Initialize(int PortID,int BaudRate)
{
PortName = "COM" + PortID;
int InitSuccess = 1;
int InitFail = -1;
try
{
portId = CommPortIdentifier.getPortIdentifier(PortName);
try
{
serialPort = (SerialPort)
portId.open("Serial_Communication", 2000);
} catch (PortInUseException e)
{
return InitFail;
}
try
{
in = serialPort.getInputStream();
out = serialPort.getOutputStream();
} catch (IOException e)
{
return InitFail;
}
try
{
serialPort.setSerialPortParams(BaudRate,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);
} catch (UnsupportedCommOperationException e)
{
return InitFail;
}
} catch (NoSuchPortException e){
return InitFail;
}
sb=new SerialBuffer();
rs=new ReadSerial(sb,in);
rs.start() ;
    return InitSuccess;
}
    
    public void wPort(String str)
    {
     try
     {
     out.write(StrToHex(str));
     }catch(IOException e){e.printStackTrace();}
    }
    public String rPort(long timeOut)
    {
mess=sb.getMsg(timeOut);
     return mess; 
    }
    public void clPort()
    {
     sb.cleanBuff();
    }
    public boolean isTimeOut()
    {
     return sb.getIsTimeOut();
    }
public static byte[] StrToHex(String hexstr)  //十六进制字符串转化为字节数组
    {
       byte[] b = new byte[hexstr.length() / 2];
       int j = 0;
       for (int i = 0; i < b.length; i++) {
        char c0 = hexstr.charAt(j++);
        char c1 = hexstr.charAt(j++);
        b[i] = (byte) ((parse(c0) << 4) | parse(c1));
       }
       return b;
     }
    private static int parse(char c)
    {
       if (c >= 'a')
        return (c - 'a' + 10) & 0x0f;
       if (c >= 'A')
        return (c - 'A' + 10) & 0x0f;
       return (c - '0') & 0x0f;
    }
}package send;import java.io.*;public class ReadSerial extends Thread//读取串口数据的线程
{
private SerialBuffer sb;
private InputStream in;
public ReadSerial(SerialBuffer sb, InputStream in)
{
this.sb = sb;
this.in =in;
}
public void run()
{
int c;
try
{
while(true)
{
c = in.read();
sb.putChar(c);
}
} catch (IOException e) {System.out.println("------------block----------");}
}
}

Answer 7

在public class ReadSerial extends Thread//读取串口数据的线程
加main

Answer 8

在windows下运行挺好的，没有多出来一切正常，但是在linux下还是不行啊

Answer 9

是windows和Linux下的回车换行的问题， 0D 0A是标准的回车换行符 

Answer 10

我没有用过linux啊
不知道他们区别都在哪里
在linux下估计你程序要变动一下了
根据你所要发送和接收的情况，过滤一下啊

Answer 11

是不是linux下的串口驱动有问题？

Answer 12

是不是linux下的串口驱动有问题？

Answer 13

应该以二进制形式打开，C语言为"rb+"，c++形式为ios::binary

Answer 14

这个是java自带的吧，0d，0a就是回车和换行符