Java接收串口数据

合集下载

java读写串口数据你了解多少

java读写串⼝数据你了解多少⽬录1.导⼊⽀持java串⼝通信的jar包：2.编写代码操作串⼝：总结最近接触到了串⼝及其读写，在此记录java进⾏串⼝读写的过程。

1.导⼊⽀持java串⼝通信的jar包：在maven项⽬的pom.xml中添加RXTXcomm的依赖或者下载RXTXcomm.jar并导⼊到项⽬中。

⽀持Java串⼝通信操作的jar包，m⽐较⽼，⽽且不⽀持64位系统，推荐使⽤Rxtx这个jar包（32位/64位均⽀持）。

下载地址：注意：运⾏过程中抛出ng.UnsatisfiedLinkError错误或gnu.io下的类找不到时，将rxtx解压包中的rxtxParallel.dll，rxtxSerial.dll 这两个⽂件复制到C:\Windows\System32 ⽬录下可解决该错误。

2.编写代码操作串⼝：串⼝必要参数类：包含连接串⼝所必须的参数，⽅便在调⽤串⼝时设置和传递串⼝参数/*** 串⼝必要参数接收类* @author: LinWenLi* @date: 2018年7⽉21⽇下午4:30:40*/public class ParamConfig {private String serialNumber;// 串⼝号private int baudRate; // 波特率private int checkoutBit; // 校验位private int dataBit; // 数据位private int stopBit; // 停⽌位public ParamConfig() {}/*** 构造⽅法* @param serialNumber 串⼝号* @param baudRate 波特率* @param checkoutBit 校验位* @param dataBit 数据位* @param stopBit 停⽌位*/public ParamConfig(String serialNumber, int baudRate, int checkoutBit, int dataBit, int stopBit) {this.serialNumber = serialNumber;this.baudRate = baudRate;this.checkoutBit = checkoutBit;this.dataBit = dataBit;this.stopBit = stopBit;}getter()...setter()...}串⼝操作类：（其中包含的CustomException是⾃定义异常类，仅⽤于抛出异常原因。

java调用第三方接收数据的方法流程

java调用第三方接收数据的方法流程
Java调用第三方接收数据的方法流程通常包括以下几个步骤：
1. 确定第三方服务的API：首先需要确定要使用的第三方服务的API，包括该服务提供的各种方法、参数以及返回值等。

通常这些信息都可以在第三方服务的官方文档中找到。

2. 引入第三方库：在Java项目中引入第三方库，以便能够调用该服务的API。

通常情况下，这些库可以通过Maven或Gradle等构建工具进行管理。

3. 创建客户端对象：根据第三方服务的API文档，创建客户端对象。

通常
情况下，客户端对象是用于与第三方服务进行通信的。

4. 调用API方法：使用客户端对象调用第三方服务的API方法，并传入必
要的参数。

这些参数通常在API文档中有详细说明。

5. 处理返回结果：根据API方法的返回值，处理返回结果。

通常情况下，
返回值会包含所需的数据或状态信息。

6. 异常处理：在调用API方法时，需要进行异常处理。

例如，网络错误、
参数错误等情况可能会抛出异常，需要进行捕获和处理。

7. 关闭客户端对象：在完成数据接收后，需要关闭客户端对象，释放资源。

以上是Java调用第三方接收数据的方法流程，具体实现方式可能会因第三
方服务的不同而有所差异。

建议参考第三方服务的官方文档进行具体实现。

一个Java读取串口值的类

一个Java读取串口值的类这是一个通过JAVA的扩展包(m)从串口读取值的类，本类库(m)主要包括：SerialBean.java (与其他应用程序的接口),SerialBuffer.java (用来保存从串口所接收数据的缓冲区),ReadSerial.java (从串口读取数据的程序)。

整个类的设计思路大概就是：实现一个线程一直在监听串口中是否有数据传送过来，如果有的话开始拍照，并取得照片后，直接打印出来。

因为涉及到商业秘密，所以拍照函数和取得照片函数采用的是空函数，请见谅!若要运行此函数必须下载该扩展包，并加载到你的CLASSPATH下。

当然，你若要测试并运行此类的话。

可能要花费不少的精力。

如果你只有一台机器，你可以利用一条RS-232电缆将COM1和COM2连接起来，在COM1上运行SerialExample，在COM2上运行Windows提供的超级终端程序。

如果你有两台机器的话，你可以利用一条RS-232电缆将两台机器的COM1(或者是COM2)连接起来，在一端运行例程，另外一端运行Windows提供的超级终端程序。

该类有相当详细的注释。

我想应该不难理解吧!import java.io.*;import java.awt.*;import java.awt.print.*;import javax.print.*;import m.*; //这是一个Java扩展类库，并不包括在标准的Java SDK当中。

//如果你尚未安装这个扩展类那么你需要到sun公司的Java站点下载这个类库class SuanKou implements Runnable{private java.io.FileOutputStream fos=null;private Thread th=null;private long shiJian=500;//设置间隔的时间//private int duanKou=1;//设置端口号private String Msg = null;private SerialBean SB=null;private int isSucces=-1;//构造函数public SuanKou(long sj,int dk) {System.out.println("构造函数");try{fos=new java.io.FileOutputStream("c:\\log.txt");this.shiJian=sj;//设定监听端口的时间//this.duanKou=dk;//端口号SB = new SerialBean(dk);//创建一个接口对象，参数为端口号isSucces = SB.Initialize();//初使化所指定的串口并返回初始化结果。

java串口通信

javaCommunications API 简介 (1)利用Java实现串口(Comm)全双工通(应广大读者要求,已做修改,附件有代码) (3)主题：JA V A操作串口有感 (5)windows中java实现的串口通信 (11)Java串口通信-01 (18)Java串口通信-2 (19)笔记本电脑没有com端口 (28)如何把com3接口改为com1接口?com1,com3在结构上和用途上有差别吗? (29)javaCommunications API 简介Java提供了CommunicationAPI(包含于包中)用于通过与机器无关的方式，控制各种外部设备。

Communications API，是标准的Java的扩展部分，它在JavaAPI中是没有附带的。

因此，必须先在SUN公司网站的Java站点()上下载这个扩展类库。

1.1Communications API 简介Communications API 的核心是抽象的CommPort类及其两个子类：SerialPort类和ParallePort类。

其中，SerialPort类是用于串口通信的类，ParallePort类是用于并行口通信的类。

CommPort类还提供了常规的通信模式和方法，例如:getInputStream( )方法和getOutputStream( )方法，专用于与端口上的设备进行通信。

然而，这些类的构造方法都被有意的设置为非公有的(non-public)。

所以，不能直接构造对象，而是先通过静态的CommPortIdentifer.getPortIdentifiers()获得端口列表；再从这个端口列表中选择所需要的端口，并调用CommPortIdentifer对象的Open( )方法，这样，就能得到一个CommPort对象。

当然，还要将这个CommPort对象的类型转换为某个非抽象的子类，表明是特定的通讯设备。

该子类可以是SerialPort类和ParallePort类中的一个。

Java 串口通讯 RS232

通过comm.jar等配置如果用applet应用程序的话，下面这个函数是可以取到串口的，但是如果通过web应用程序（或者通过jsp调用）却取不到串口，而且也不会抛出异常，感觉很奇怪，特来请教！CommPortIdentifier.getPortIdentifiers();同时目标机器的java运行环境也需要把w32comm.dll, comm.jar xxx.proper等放到相应的目录就是用ibm的包而不用sun的comm包：ibm-javacomm-win32-x86.zip只需要把comm驱动包这个类的装载更新一下即/serialcomm.htm利用Java实现串口全双工通讯一个嵌入式系统通常需要通过串口与其主控系统进行全双工通讯，譬如一个流水线控制系统需要不断的接受从主控系统发送来的查询和控制信息，并将执行结果或查询结果发送回主控系统。

本文介绍了一个简单的通过串口实现全双工通讯的Java类库，该类库大大的简化了对串口进行操作的过程。

本类库主要包括：SerialBean.java (与其他应用程序的接口), SerialBuffer.java(用来保存从串口所接收数据的缓冲区), ReadSerial.java (从串口读取数据的程序)。

另外本类库还提供了一个例程SerialExample.java 作为示范。

在下面的内容中将逐一对这几个部分进行详细介绍。

1. SerialBeanSerialBean是本类库与其他应用程序的接口。

该类库中定义了SerialBean的构造方法以及初始化串口，从串口读取数据，往串口写入数据以及关闭串口的函数。

具体介绍如下：本函数构造一个指向特定串口的SerialBean，该串口由参数PortID所指定。

PortID = 1 表示COM1，PortID = 2 表示COM2，由此类推。

本函数初始化所指定的串口并返回初始化结果。

如果初始化成功返回1，否则返回-1。

Java串口通信——RXTX

Java串⼝通信——RXTX1.前期准备 a.配置 RXTX 2）拷贝动态库到对应的jdk⽬录下 ·Windows平台拷贝 rxtxSerial.dll ---> <JAVA_HOME>\jre\bin 拷贝 rxtxParallel.dll ---> <JAVA_HOME>\jre\bin ·Linux平台拷贝 librxtxSerial.so ---> <JAVA_HOME>/jre/lib/i386/ 拷贝 librxtxParallel.so ---> <JAVA_HOME>/jre/lib/i386/ 3）在⼯程根⽬录下创建 lib ⽂件夹（与src平级），将 RXTXcomm.jar 放⼊该⽂件夹中 4）在 pom.xml 中引⼊本地 jar 包依赖<dependencies>......<dependency><groupId>gnu.io</groupId><artifactId>RXTXcomm</artifactId><scope>system</scope><systemPath>${project.basedir}/lib/RXTXcomm.jar</systemPath></dependency></dependencies> b.安装虚拟串⼝驱动：vspd （收费，有破解版） c.安装串⼝调试⼯具：Serial Port Utility （免费）2.使⽤ a.新建串⼝VO类public class SerialVo {/*** 串⼝名称(COM0、COM1、COM2等等)*/private String serialPortName;/*** 波特率* 默认：115200*/private int baudRate;/*** 数据位默认8位* 可以设置的值：SerialPort.DATABITS_5、SerialPort.DATABITS_6、SerialPort.DATABITS_7、SerialPort.DATABITS_8* 默认：SerialPort.DATABITS_8*/private int dataBits;/*** 停⽌位* 可以设置的值：SerialPort.STOPBITS_1、SerialPort.STOPBITS_2、SerialPort.STOPBITS_1_5* 默认：SerialPort.STOPBITS_1*/private int stopBits;/*** 校验位* 可以设置的值：SerialPort.PARITY_NONE、SerialPort.PARITY_ODD、SerialPort.PARITY_EVEN、SerialPort.PARITY_MARK、SerialPort.PARITY_SPACE * 默认：SerialPort.PARITY_NONE*/private int parity;public SerialVo(String serialPortName) {this.serialPortName = serialPortName;this.baudRate = 115200;this.dataBits = SerialPort.DATABITS_8;this.stopBits = SerialPort.STOPBITS_1;this.parity = SerialPort.PARITY_NONE;}public SerialVo(String serialPortName, int baudRate) {this.serialPortName = serialPortName;this.baudRate = baudRate;this.dataBits = SerialPort.DATABITS_8;this.stopBits = SerialPort.STOPBITS_1;this.parity = SerialPort.PARITY_NONE;}public String getSerialPortName() {return serialPortName;}public void setSerialPortName(String serialPortName) {this.serialPortName = serialPortName;}public int getBaudRate() {return baudRate;}public void setBaudRate(int baudRate) {this.baudRate = baudRate;}public int getDataBits() {return dataBits;}public void setDataBits(int dataBits) {this.dataBits = dataBits;}public int getStopBits() {return stopBits;}public void setStopBits(int stopBits) {this.stopBits = stopBits;}public int getParity() {return parity;}public void setParity(int parity) {this.parity = parity;}} b.新建串⼝⼯具类public class SerialUtil {/*** 获得系统可⽤的端⼝名称列表(COM0、COM1、COM2等等)*/public static List<String> getSerialPortList() {List<String> systemPorts = new ArrayList<>();//获得系统可⽤的端⼝Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();while (portList.hasMoreElements()) {String portName = portList.nextElement().getName();//获得端⼝的名字systemPorts.add(portName);}return systemPorts;}/*** 打开串⼝*/public static SerialPort openSerialPort(SerialVo serialVo, int timeout) throws Exception {//通过端⼝名称得到端⼝CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(serialVo.getSerialPortName());//打开端⼝，（⾃定义名字，打开超时时间）CommPort commPort = portIdentifier.open(serialVo.getSerialPortName(), timeout);//判断是不是串⼝if (commPort instanceof SerialPort) {SerialPort serialPort = (SerialPort) commPort;//设置串⼝参数（波特率，数据位8，停⽌位1，校验位⽆）serialPort.setSerialPortParams(serialVo.getBaudRate(), serialVo.getDataBits(), serialVo.getStopBits(), serialVo.getParity()); System.out.println("开启串⼝成功，串⼝名称：" + serialVo.getSerialPortName());return serialPort;} else {//是其他类型的端⼝throw new NoSuchPortException();}}/*** 关闭串⼝*/public static void closeSerialPort(SerialPort serialPort) {if (serialPort != null) {serialPort.close();System.out.println("关闭了串⼝：" + serialPort.getName());}}/*** 向串⼝发送数据*/public static void sendData(SerialPort serialPort, byte[] data) {OutputStream os = null;try {//获得串⼝的输出流os = serialPort.getOutputStream();os.write(data);os.flush();} catch (IOException e) {e.printStackTrace();} finally {try {if (os != null) {os.close();}} catch (IOException e) {e.printStackTrace();}}}/*** 从串⼝读取数据*/public static byte[] readData(SerialPort serialPort) {InputStream is = null;byte[] bytes = null;try {//获得串⼝的输⼊流is = serialPort.getInputStream();//获得数据长度int bufflenth = is.available();while (bufflenth != 0) {//初始化byte数组bytes = new byte[bufflenth];is.read(bytes);bufflenth = is.available();}} catch (IOException e) {e.printStackTrace();} finally {try {if (is != null) {is.close();}} catch (IOException e) {e.printStackTrace();}}return bytes;}/*** 给串⼝设置监听*/public static void setListenerToSerialPort(SerialPort serialPort, SerialPortEventListener listener) throws Exception {//给串⼝添加事件监听serialPort.addEventListener(listener);//串⼝有数据监听serialPort.notifyOnDataAvailable(true);//中断事件监听serialPort.notifyOnBreakInterrupt(true);}}3.调试 a.新建测试类public class App {//防⽌被GC回收private static SerialVo serialVo;public static void main( String[] args ) {//获得系统可⽤的端⼝名称List<String> portList = SerialUtil.getSerialPortList();System.out.println(portList);try {serialVo = new SerialVo("COM2");final SerialPort serialPort = SerialUtil.openSerialPort(serialVo, 115200);//启动⼀个线程每2s向串⼝发送数据，发送1000次hellonew Thread(() -> {int i = 1;while (i < 1000) {String s = "hello " + i++;byte[] bytes = s.getBytes();SerialUtil.sendData(serialPort, bytes);//发送数据try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}}).start();//设置串⼝的listenerSerialUtil.setListenerToSerialPort(serialPort, event -> {//数据通知if (event.getEventType() == SerialPortEvent.DATA_AVAILABLE) {byte[] bytes = SerialUtil.readData(serialPort);System.out.println("收到的数据长度：" + bytes.length);System.out.println("收到的数据：" + new String(bytes));}});} catch (Exception e) {e.printStackTrace();}}} b.使⽤ vspd 添加两个虚拟串⼝ COM2 和 COM3 c.使⽤ Serial Port Utility 测试串⼝的收发 d.注意：vspd 添加的虚拟串⼝为 COM2 和 COM3，Java代码中连接的是 COM2，则 Serial Port Utility 需连接 COM3。

java串口通信

java串⼝通信java串⼝通信，由于没有相应的串⼝硬件，选了⼀款windows串⼝虚拟机机器1. 准备串⼝模拟器Launch Virtual Serial Port Driver模拟两对四个串⼝，COM1发送数据给COM2，COM3发送数据给COM4java包<dependency><groupId>com.fazecast</groupId><artifactId>jSerialComm</artifactId><version>[2.0.0,3.0.0)</version></dependency>2. java源代码mport com.fazecast.jSerialComm.SerialPort;import com.fazecast.jSerialComm.SerialPortDataListener;import com.fazecast.jSerialComm.SerialPortEvent;import java.io.BufferedReader;import java.io.InputStreamReader;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;/*** @Classname ComTest* @Description com串⼝通信* @Date 2021/9/4 10:44* @Created by huangsm*/public class ComTest {/*** <com名称,SerialPort>串⼝通信map，存储串⼝名称与串⼝信息*/private Map<String, SerialPort> comMap = new HashMap<>();/*** com⼝列表*/private List<String> comList = new ArrayList<>();public ComTest() {//将所有的串⼝信息放⼊comlist,comMap中SerialPort[] commPorts = SerialPort.getCommPorts();for (SerialPort commPort : commPorts) {comList.add(commPort.getSystemPortName());comMap.put(commPort.getSystemPortName(), commPort);//监听所有串⼝通信的数据commPort.openPort();commPort.addDataListener(new SerialPortDataListener() {@Overridepublic int getListeningEvents() {return SerialPort.LISTENING_EVENT_DATA_RECEIVED;}@Overridepublic void serialEvent(SerialPortEvent serialPortEvent) {byte[] newData = serialPortEvent.getReceivedData();System.err.println(String.format("串⼝%s接收到数据⼤⼩：%s,串⼝数据内容:%s",serialPortEvent.getSerialPort().getSystemPortName(),newData.length,new String(newData))); }});}}public static void main(String[] args) throws Exception {ComTest comTest = new ComTest();List<String> comList = List;Map<String, SerialPort> comMap = Map;BufferedReader systemIn = new BufferedReader(new InputStreamReader(System.in));while (true) {System.out.println("你的可以通信的串⼝列表");for (String comName : comList) {System.out.println("========" + comName + "========"); }System.out.println("请输⼊你的串⼝：");String com = systemIn.readLine();if(!comList.contains(com)){System.out.println("输⼊的串⼝不正确：");continue;}System.out.println("输⼊你要发送的消息：");String msg = systemIn.readLine();SerialPort serialPort = comMap.get(com);serialPort.writeBytes(msg.getBytes(),msg.getBytes().length);//这⾥是让串⼝先接收到数据再重新发送数据Thread.sleep(1000);}}}3. 运⾏结果你的可以通信的串⼝列表========COM1================COM2================COM3================COM4========请输⼊你的串⼝：COM3输⼊你要发送的消息：137912037串⼝COM4接收到数据⼤⼩：9,串⼝数据内容:137912037你的可以通信的串⼝列表========COM1================COM2================COM3================COM4========请输⼊你的串⼝：。

java 虚拟串口远程通信原理

Java虚拟串口远程通信的原理是通过模拟串口通信的方式，在网络上实现两个或多个Java 应用程序之间的数据传输。

一般来说，虚拟串口远程通信的原理包括以下几个关键步骤：
1.创建虚拟串口：使用Java提供的串口库，创建一个虚拟串口对象。

这个虚拟串口可以
在本地计算机上运行，并模拟真实的串口行为。

2.建立网络连接：使用网络协议（如TCP/IP）在两个或多个Java应用程序之间建立网络
连接。

其中，一个应用程序充当服务器端，另一个或多个应用程序充当客户端。

3.串口数据传输：将要传输的数据通过虚拟串口对象进行读取和写入操作。

对于服务器端，
可以从虚拟串口读取数据并通过网络发送给客户端。

对于客户端，可以从网络接收数据并通过虚拟串口写入。

4.数据处理：接收方（服务器端或客户端）从虚拟串口中读取到数据后，可以进行必要的
数据处理操作。

例如，解析数据、执行特定的指令或操作等。

需要注意的是，虚拟串口远程通信需要保证网络的稳定性和可靠性。

由于网络延迟和不确定性，可能会影响数据传输的实时性和准确性。

因此，在设计虚拟串口远程通信系统时，需要考虑数据传输的可靠性，并采取相应的措施来处理数据丢失、重传等问题。

总结起来，Java虚拟串口远程通信的原理是通过模拟串口通信，在网络上实现两个或多个Java应用程序之间的数据传输。

它涉及到创建虚拟串口对象、建立网络连接、串口数据传输和数据处理等步骤。

java 串口通信案例

java 串口通信案例Java串口通信是指使用Java编程语言实现与串口设备之间的数据通信。

串口通信在很多应用场景中都有广泛的应用，比如物联网、工业自动化、智能家居等领域。

本文将列举十个以Java串口通信为题的案例，介绍其实现方法和应用场景。

1. 串口读取数据通过Java编程语言实现串口读取数据的功能，可以使用Java的串口通信库，如RXTX、JavaComm等。

首先需要打开串口，并设置串口参数，然后通过监听串口数据的方式实时读取串口传入的数据。

这个案例适用于需要实时监控串口设备数据的应用场景，比如环境监测。

2. 串口发送数据通过Java编程语言实现串口发送数据的功能，可以使用Java的串口通信库。

首先需要打开串口，并设置串口参数，然后通过写入数据的方式将数据发送到串口设备。

这个案例适用于需要向串口设备发送指令或数据的应用场景，比如控制外部设备。

3. 串口数据解析通过Java编程语言实现串口数据解析的功能，可以将从串口读取的原始数据进行解析，提取出有用的信息。

可以根据数据格式进行解析，比如按照特定的协议解析数据。

这个案例适用于需要对串口设备传输的数据进行处理和分析的应用场景。

4. 串口数据存储通过Java编程语言实现串口数据存储的功能，可以将从串口读取的数据保存到本地文件或数据库中。

可以根据需求选择适当的存储方式，比如文本文件、二进制文件或数据库。

这个案例适用于需要对串口设备传输的数据进行长期存储和分析的应用场景。

5. 串口数据转发通过Java编程语言实现串口数据转发的功能，可以将从一个串口读取的数据转发到另一个串口。

可以实现串口设备之间的数据交互，比如串口设备之间的数据通信或设备之间的数据同步。

这个案例适用于需要多个串口设备之间进行数据交互的应用场景。

6. 串口数据监控通过Java编程语言实现串口数据监控的功能，可以监控串口设备的状态和传输数据。

可以实时显示串口设备的连接状态、波特率、数据位、停止位等信息，并实时显示串口传输的数据。

串口通讯-Java(Rxtx)

基于无线传感定位系统的通信软件一、运行环境：Windows操作系统下运行，由于作品是基于java虚拟机的，所以需要安装jvm 该作品是属于基于硬件的通信软件，所以在对数据的接收上要求无线传感器支持，这个软件主要任务是对无线传感器发送来的数据进行准确，形象的整理和分析。

二、开发环境：软件开发环境是在eclipse这个平台上，基于java的RXTX串口通信技术完成的。

三、功能说明：1、各类结点数据的接受处理和统计；2、界面面板缩进的控制；3、温度数据湿度数据的对比图像；4、图像的缩放功能。

5、室内平面图的上传和缩放以及定位。

6、节点位置信息处理，显示在相对位置图上，每个节点要能够通过颜色反映出节点周围的温度状况。

7、数据的发送功能，我及时的向底层硬件发送数据帧，实现软硬件的实时联系和交互。

8、常用信息的设置功能，比如室温，串口属性信息，数据接受格式等四、作品整体效果展示温湿度曲线显示、控制和对比结点位置信息和温度信息的图像反映五、操作以及功能说明：1、串口设置：要针对电脑接入串口时的属性，和底层数据发送帧的格式在如下面板中设置。

2、常用命令的设置，设置这些向底层发出请求的命令，可以灵活的控制我们所需要的数据，比如我们可以选择请求结点的温度信息，请求结点的湿度信息，或者是位置信息等等。

3、温湿度曲线的控制，设置好之后，点击ok，点击开始按钮，便会接受到底层硬件发来的数据，但是我们的硬件可能是很多个结点，如果都反映在图像上，可能略显混乱，所以我们可以在结点数据面板中控制哪个结点的显示状况。

4、结点位置信息的查看，下面的截图反映了结点的位置信息，大的圆圈是参考结点的位置和温度信息的反映，从内向外温度不断的接近室温，颜色越深的部分表示温度越高，小的绿园是我们要定位的盲几点的位置信息的反映，随着盲几点的实际位置信息的变化，图像中会做出准确的变化。

，5、盲结点和参考结点相关参数的设定，我们选中单选框，信息会出现在文本框中，设置好后，点击update,发送到底层。

java串口通信

小技巧：如何辨别TXD和RXD端口？搞电子的人手边应该常备一个电表，用来测测电压，电阻什么的会很有用。

你只要分别测一下RS232端口的2--5或3--5针脚之间的电压，通常TXD针脚与GND之间会有3~15V左右的负电压，表示它是TXD针脚。

安装JavaCommunicationsAPISun的J2SE中并没有直接提供以上提到的任何一种串行通讯协议的开发包，而是以独立的jar包形式发布在网站上(从这里下载)----即comm.jar，称之为Javatm CommunicationsAPI，它是J2SE的标准扩展。

comm.jar并不是最近才有，早在1998年时，sun就已经发布了这个开发包。

comm.jar分别提供了对常用的RS232串行端口和IEEE1284并行端口通讯的支持。

目前sun发布的comm.jar只有Windows和Solaris平台两个版本，如果你需要Linux平台下的，可以在/~kevinh/linuxcomm.html找到。

在使用comm.jar之前，必须知道如何安装它。

这也是困扰许多初学javaRS232通讯者的一个难题。

如果我们电脑上安装了JDK,它将同时为我们安装一份JRE(Java RuntimeEntironment)，通常我们运行程序时都是以JRE来运行的。

所以以下的安装适用于JRE。

如果你是用JDK来运行程序的，请将相应的改成。

下载了comm.jar开发包后，与之一起的还有两个重要的文件，win32com.dll和m.properties。

comm.jar提供了通讯用的javaAPI，而win32com.dll提供了供comm.jar调用的本地驱动接口。

而m.properties是这个驱动的类配置文件。

首先将comm.jar复制到\lib\ext目录。

再将win21com.dll复制到你的RS232应用程序运行的目录，即user.dir。

然后将m.properties复制到\lib目录。

串口接收数据流程

串口接收数据流程
串口接收数据流程是指从串口接收数据时的一系列步骤。

其流程可分为如下步骤：
1.串口初始化：首先需要初始化串口，即设置串口的波特率、校验位、数据位、停止
位等参数。

2.等待数据：接下来程序需要等待请求数据到来，可通过串口中断来实现。

3.接收数据：当有数据到达时，串口会触发相应中断，程序会在中断处理函数中接收
数据。

一般每次只接收一个字节。

4.数据处理：接收到的数据需要进行相应处理，包括校验、解码等等。

5.数据存储：处理完数据后，将其存储到相应的存储器中，如内存、缓冲区等。

6.数据通知：当数据存储完毕后，程序需要通过相关标志位或事件通知上层处理程序，让其进行相应的处理。

上述步骤是常见的串口接收数据流程，具体实现可参考如下代码：
```c
#include <stdio.h>
#include <string.h>
#include <Windows.h>
#define PORT "COM1"
上述代码主要实现了串口的初始化、等待数据、接收数据等操作，可供参考。

总结来说，串口接收数据流程包括初始化、等待数据、接收数据、数据处理、数据存储和数据通
知等步骤。

Java串口通信RXTX实现方案

Java串口通信 RXTX 实现方案1.背景介绍由于第一次用Java与硬件通信，网上查了许多资料，在这进行整理，便于以后学习。

本人串口测试是USB串口设备连接电脑，在设备管理器中找到端口名称（也可以通过一些虚拟串口工具模拟）。

下面主要简述获取串口消息返回值的一些问题，在最下面已经附上完整代码。

2.准备工作RXTX包：mfz-rxtx-2.2-20081207-win-x64.zip，解压，RXTXcomm.jar加入项目依赖库里，rxtxParallel.dll和rxtxSerial.dll放入jdk的bin目录下（我使用的jdk1.8）1.RXTX工具类编写编写基础方法：获取可用端口名，开启端口，发送命令，接受命令，关闭端口import gnu.io.*;import javax.sound.midi.SoundbankResource;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.io.UnsupportedEncodingException;import java.util.ArrayList;import java.util.Enumeration;import java.util.List;import java.util.TooManyListenersException;import static com.why.rxtx.utill.HexadecimalUtil.get16NumAdd0;import static com.why.rxtx.utill.HexadecimalUtil.hexStringToByteArray;import static com.why.rxtx.utill.OrderUtil.retuenLogOrder;import static com.why.rxtx.utill.OrderUtil.send;/*** 使用rxtx连接串口工具类*/public class RXTXUtil {private static final String DEMONAME = "串口测试";/*** 检测系统中可用的端口*/private CommPortIdentifier portId;/*** 获得系统可用的端口名称列表*/private static Enumeration<CommPortIdentifier> portList;/*** 输入流*/private static InputStream inputStream;/*** RS-232的串行口*/private static SerialPort serialPort;/*** 返回结果*/private static String res=null;/*** 获得系统可用的端口名称列表*@return可用端口名称列表*/@SuppressWarnings("unchecked")public static void getSystemPort(){List<String> systemPorts =new ArrayList<>();//获得系统可用的端口portList = CommPortIdentifier.getPortIdentifiers();while(portList.hasMoreElements()) {String portName= portList.nextElement().getName();//获得端口的名字 systemPorts.add(portName);}}/*** 开启串口*@param serialPortName 串口名称*@param baudRate 波特率*@return串口对象*/public static void openSerialPort(String serialPortName,int baudRate) {try {//通过端口名称得到端口CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(serialPortName);//打开端口，（自定义名字，打开超时时间）CommPort commPort = portIdentifier.open(serialPortName, 5000);//判断是不是串口if (commPort instanceof SerialPort) {serialPort= (SerialPort) commPort;//设置串口参数（波特率，数据位8，停止位1，校验位无） serialPort.setSerialPortParams(baudRate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);// System.out.println("开启串口成功，串口名称："+serialPortName); }else {//是其他类型的端口throw new NoSuchPortException();}}catch (NoSuchPortException e) {e.printStackTrace();}catch (PortInUseException e) {e.printStackTrace();}catch (UnsupportedCommOperationException e) {e.printStackTrace();}}/*** 向串口发送数据*@param order 发送的命令*/public static void sendData( String order) {//16进制表示的字符串转换为字节数组byte[] data =hexStringToByteArray(order);OutputStream os=null;try {os= serialPort.getOutputStream();//获得串口的输出流 os.write(data);os.flush();}catch (IOException e) {e.printStackTrace();}finally {//关闭流操作try {if (os !=null) {os.close();os=null;}}catch (IOException e) {e.printStackTrace();}}}/*** 从串口读取数据*@return读取的数据*/public static String readData() {//保存串口返回信息StringBuffer res=new StringBuffer(40);InputStream is=null;byte[] bytes =null;try {is= serialPort.getInputStream();//获得串口的输入流int bufflenth = is.available();//获得数据长度while (bufflenth != 0) {bytes=new byte[bufflenth];//初始化byte数组 is.read(bytes); bufflenth= is.available();}if(bytes!=null) {for (int i = 0; i < bytes.length; i++) {//转换成16进制数（FF）res.append(get16NumAdd0((bytes[i]&0xff)+"",2));}}System.out.println("res: "+res.toString());}catch (IOException e) {e.printStackTrace();}finally {try {if (is !=null) {is.close();is=null;}}catch(IOException e) {e.printStackTrace();}}return res.toString();}/*** 关闭串口**/public static void closeSerialPort() {if(serialPort !=null) {serialPort.close();//System.out.println("关闭了串口："+serialPort.getName());2.编写测试代码/*** 串口命令执行*@param order 命令*@param portName 端口名*@param baudRate 波特率*@return*@throws UnsupportedEncodingException*/public synchronized static String executeOrder(String order,String portName,int baudRate) {String str="";if (serialPort==null) {openSerialPort(portName, baudRate);}//发送消息 sendData(order);//接收消息String str=readData();return res;}很遗憾上面代码输入命令，端口号等等后，返回结果一直是null, 突然间发现和以前写读写io流还是有一定区别的。

串口接收数据包(协议带帧头帧尾且帧头帧尾都为两个字节)的编程实现方法

串口接收数据包(协议带帧头帧尾且帧头帧尾都为两个字节)的编程实现方法要实现串口接收带有帧头和帧尾的数据包，可以按照以下步骤进行编程：1. 配置串口通信参数：设置串口的波特率、数据位、停止位和奇偶校验位等参数。

2. 初始化接收缓冲区：创建一个缓冲区用于存储接收到的数据包。

3. 等待接收数据：通过串口的接收中断或者轮询方式等待接收数据。

当接收到数据时，将数据保存到接收缓冲区中。

4. 解析数据包：从接收缓冲区中读取数据，并根据帧头和帧尾进行解析。

可以使用状态机或者字符串匹配等方法，找到完整的数据包。

5. 处理数据：对解析得到的完整数据包进行处理。

根据协议的要求，可以提取或者操作数据包的各个字段。

下面是一个示例代码，利用状态机实现串口接收带有帧头和帧尾的数据包解析：```c#define FRAME_HEAD1 0xAA#define FRAME_HEAD2 0xBB#define FRAME_TAIL1 0xCC#define FRAME_TAIL2 0xDD#define BUFFER_SIZE 100enum State {STATE_IDLE,STATE_HEAD1,STATE_HEAD2,STATE_DATA,STATE_TAIL1,STATE_TAIL2};unsigned char buffer[BUFFER_SIZE];unsigned int bufferIndex = 0;enum State currentState = STATE_IDLE;void processPacket(unsigned char *packet, unsigned int length) { // 处理接收到的完整数据包// ...}void receiveData(unsigned char data) {switch(currentState) {case STATE_IDLE:if(data == FRAME_HEAD1) {currentState = STATE_HEAD1;}break;case STATE_HEAD1:if(data == FRAME_HEAD2) {currentState = STATE_HEAD2;} else {currentState = STATE_IDLE; // 未匹配到帧头，返回初始状态}break;case STATE_HEAD2:buffer[bufferIndex++] = data;currentState = STATE_DATA;break;case STATE_DATA:buffer[bufferIndex++] = data;if(data == FRAME_TAIL1) {currentState = STATE_TAIL1;}break;case STATE_TAIL1:if(data == FRAME_TAIL2) {currentState = STATE_TAIL2;} else {currentState = STATE_DATA; // 未匹配到帧尾，返回数据状态}break;case STATE_TAIL2:processPacket(buffer, bufferIndex); // 处理完整数据包bufferIndex = 0; // 重置缓冲区索引currentState = STATE_IDLE;break;}}void receiveSerialData() {if(Serial.available()) {unsigned char data = Serial.read();receiveData(data);}}void setup() {Serial.begin(9600);}void loop() {receiveSerialData();}```以上是一个简单的示例代码，根据实际需求可能需要进行适当修改。

java jssc串口例子

java jssc串口例子Java JSSC（Java Simple Serial Connector）是一个用于串口通信的Java 库。

下面是一个简单的Java JSSC串口通信示例：```javaimport ;import ;import ;import ;public class SerialPortExample implements SerialPortEventListener { private SerialPort serialPort;public SerialPortExample(String portName) {serialPort = new SerialPort(portName);try {();(_9600, _8, _1, _NONE);(this);} catch (SerialPortException e) {();}}public void serialEvent(SerialPortEvent event) { if (()) {try {int available = ();if (available > 0) {byte[] bytes = new byte[available];(bytes, );("Received data: " + new String(bytes)); }} catch (SerialPortException e) {();}}}public static void main(String[] args) {String portName = "COM1"; // 串口名称，根据实际情况修改new SerialPortExample(portName);}}```该示例程序使用JSSC库打开一个串口，并设置串口参数（波特率、数据位、停止位和校验位）。

然后，它添加了一个`SerialPortEventListener`，以便在接收到数据时执行相应的操作。

Java实现串口通信

这是用Java编写的实现串口通信的程序源代码。

至于支持串口通信的comm.jar 包，请各位从sun或别的网站处下载！这里只提供源码让大家参考。

gui.java算是一个框架；panel.java是面板，相当于前台；SerialCommunication.java是一个JavaBean，相当于后台。

面板视图如下：从串口中读入信息的机制如下：后台监测到有信息读入到缓存，就读取之，用一个字符串变量储存，并置“有新信息读入”的标识（相当于一个开关）为真。

面板有一个计时器监听器，用轮询的方式查询后台的“有新信息读入”的标识是否为真，若为真则马上读入到前台，显示到文本框上，并置“有新信息读入”的标识为假（顺手关门）。

gui.java:import java.awt.*;import javax.swing.*;public class gui{public static void main(String[] args){JFrame frame=new JFrame("密谈");frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.getContentPane().add(new panel());frame.pack();frame.setVisible(true);frame.setResizable(false);}}panel.java：import java.awt.*;import java.awt.event.*;import javax.swing.*;public class panel extends JPanel{String SB;JTextArea show;JTextField text;JButton submit,connect,stop;SerialCommunication port;Timer timer;JPanel write;JPanel read;public panel(){SB=new String("");port=new SerialCommunication(1);timer=new Timer(100,new timeListener());show=new JTextArea(20,25);show.setLineWrap(true);show.setAutoscrolls(true);text=new JTextField("",25);submit=new JButton("提交");connect=new JButton("连接");stop=new JButton("断开");write=new JPanel();read=new JPanel();setLayout(new BoxLayout(this,BoxLayout.Y_AXIS));submit.addActionListener(new submitListener());connect.addActionListener(new connectListener());stop.addActionListener(new stopListener());write.setPreferredSize(new Dimension(300,70));write.add(text);write.add(connect);write.add(submit);write.add(stop);write.setBackground(Color.CYAN);read.setPreferredSize(new Dimension(300,375));read.setBackground(Color.yellow);read.add(show);add(read);add(write);}private class submitListener implements ActionListener {//提交按钮的监听器public void actionPerformed(ActionEvent event){String s=text.getText();port.write(s);SB=new String(port.readBuffer());show.append(SB);System.out.println("提交！");}}private class connectListener implements ActionListener {//连接按钮的监听器public void actionPerformed(ActionEvent event){port.open();timer.start();System.out.println("连接！");}}private class stopListener implements ActionListener{//断开按钮的监听器public void actionPerformed(ActionEvent event){port.close();timer.stop();System.out.println("断开！");}}private class timeListener implements ActionListener {//timer的监听器，用作轮询后台public void actionPerformed(ActionEvent event){if(port.dataComes()){SB=new String(port.readBuffer());port.dataHadRead();show.append(SB);repaint();System.out.println("读到数据！");}}}}SerialCommunication.java:import java.util.*;import java.io.*;import m.*;import mPortIdentifier;import java.awt.*;import m.SerialPortEvent.*;import m.SerialPortEventListener.*;public class SerialCommunication{String portName;CommPortIdentifier portId;InputStream inputStream;OutputStream outputStream;SerialPort serialPort;StringBuffer buffer;//串口读入缓存boolean recieve;//有新数据读入的标识public SerialCommunication(int n){//创建一个名字为"COM"+n 的串口通信对象buffer=new StringBuffer("");Enumeration portList=CommPortIdentifier.getPortIdentifiers();while (portList.hasMoreElements()){portId = (CommPortIdentifier)portList.nextElement();if (portId.getPortType()==CommPortIdentifier.PORT_SERIAL){if(portId.getName().equals("COM"+n)){portName="COM"+n;break;}}else{System.out.println("找不到串口！");}}}public void open(){//打开串口以及输入输出流recieve=false;try{serialPort=(SerialPort)portId.open("Serial Communication", 2000);}catch(PortInUseException e){System.out.println("端口正被占用！");}try{serialPort.setSerialPortParams(9600,SerialPort.DA TABITS_8,SerialPort.STOPBITS_1,SerialPort.PARITY_NONE);} catch(UnsupportedCommOperationException e){System.out.println("不支持通信");}try{outputStream=serialPort.getOutputStream();inputStream=serialPort.getInputStream();}catch(IOException e){System.out.println("无法初始化输入输出流！");}try{serialPort.addEventListener(new serialPortListener());}catch (TooManyListenersException e) {System.out.println("监听器太多了！");}serialPort.notifyOnDataAvailable(true);}public void write(String s){//将参数字符串s转换成字节，并将此字节流写入到outputStream中buffer=new StringBuffer("SEND:"+s+"\n");try{outputStream.write(s.getBytes());}catch(IOException e){System.out.println("往串口写入数据时发生错误！");} }public void close(){try{outputStream.close();inputStream.close();}catch(IOException e){System.out.println("输入输出流关闭失败！");}serialPort.close();}public class serialPortListener implements SerialPortEventListener{//监听是否有新数据读入的监听器public void serialEvent(SerialPortEvent event){if(event.getEventType()==SerialPortEvent.DATA_A V AILABLE){//若有新数据传来，则将其转换成字符串，并加进缓存String readResult;byte[] readBuffer=new byte[20];try{while(inputStream.available()>0)inputStream.read(readBuffer);}catch(IOException e){System.out.println(e);System.out.println("从串口读取数据时发生错误！");readResult="";}readResult=new String(readBuffer);buffer=new StringBuffer("RECIEVE:"+readResult+"\n");recieve=true;//然后置新数据读入标识为真}}}public StringBuffer readBuffer()//返回缓存所存储的字符串{System.out.println(buffer);return(buffer);}public boolean dataComes()//判断串口是否有新数据读入{return(recieve);}public void dataHadRead()//此方法可以让外部的应用程序在读取一次数据后置标识为假{recieve=false;}}。

java 判断串口接收完成一帧数据的解析思路

java 判断串口接收完成一帧数据的解析思路判断串口接收完成一帧数据的解析思路可以分为以下几个步骤：
1. 确定帧的起始标志：在串口通信协议中，一帧数据通常会以特定的起始标志开始，例如一个字节的特定数值。

通过读取串口接收缓冲区中的数据，可以判断是否接收到了起始标志。

2. 确定帧的长度：根据协议规定，一帧数据的长度可能是固定的，也可能是可变的。

根据协议规定的长度字段或其他规则，可以确定当前接收到的数据的长度。

3. 判断数据完整性：如果帧的长度是固定的，那么可以直接根据长度判断数据的完整性；如果帧的长度是可变的，那么可以通过读取串口接收缓冲区中的数据，判断是否接收到了完整的帧。

4. 解析数据：根据协议规定的数据格式，对接收到的完整帧数据进行解析。

可以根据协议规定的字段长度、数据类型等进行解析，并将解析后的数据存储或进行相应的处理。

需要注意的是，在进行串口接收数据时，可能存在以下情况需要处理：
- 数据丢失：由于串口通信的特性，可能导致部分数据丢失。

可以使用缓冲区来保存接收到的数据，并在接收完成后进行处理。

- 数据粘连：多个帧的数据可能会连在一起，形成数据粘连的情况。

可以通过判断帧的起始标志来分割不同的帧。

以上是一种常见的判断串口接收完成一帧数据的解析思路，具体的实现方式会根据协议规定和实际需求有所差异。

可以根据具体的情况进行相应的调整和修改。

使用java的rxtx类解决串口通讯的具体操作步骤

使用Java的RXTX类库进行串口通讯的基本步骤如下：1. 导入RXTX类库：在Java项目中，需要导入RXTX类库，以便使用串口通讯功能。

可以从RXTX官方网站下载适合您的操作系统的类库，并将其添加到Java项目中。

2. 打开串口连接：使用RXTX类库中的SerialPort类打开串口连接。

您需要指定串口的端口号以及波特率等参数。

例如：```javaSerialPort serialPort = new SerialPort("COM1");serialPort.openPort();serialPort.setParams(SerialPort.BAUDRATE_9600,SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);```3. 发送数据：使用RXTX类库中的write()方法发送数据。

例如：```javabyte[] data = {0x01, 0x02, 0x03};serialPort.write(data, data.length);```4. 接收数据：使用RXTX类库中的read()方法接收数据。

例如：```javabyte[] buffer = new byte[1024];int length = serialPort.read(buffer, buffer.length);```5. 关闭串口连接：使用RXTX类库中的closePort()方法关闭串口连接。

例如：```javaserialPort.closePort();```以上是使用Java的RXTX类库进行串口通讯的基本步骤。

您可以根据实际需求进行相应的修改和扩展。

java实现tcp连接的接收数据方法

java实现tcp连接的接收数据方法Java是一种广泛应用的编程语言，它提供了丰富的库和框架，使得开发者可以轻松地实现各种功能。

在网络编程中，TCP连接是一种常见的通信方式。

本文将介绍如何使用Java实现TCP连接的接收数据方法。

在Java中，可以使用包中的Socket类来创建TCP连接。

要接收数据，需要先创建一个服务器端的Socket对象，并指定要监听的端口号。

例如，可以使用以下代码创建一个服务器端的Socket对象：```javaint port = 8888; // 监听的端口号ServerSocket serverSocket = new ServerSocket(port);```接下来，可以使用serverSocket对象的accept()方法接收客户端的连接请求，并返回一个Socket对象，该对象可以用于与客户端进行通信。

例如，可以使用以下代码接收客户端的连接并打印相关信息：```javaSocket clientSocket = serverSocket.accept();System.out.println("接收到来自" +clientSocket.getInetAddress() + " 的连接");```接收数据需要使用Socket对象的InputStream对象。

可以通过调用Socket对象的getInputStream()方法获取InputStream对象。

例如，可以使用以下代码获取InputStream对象：```javaInputStream inputStream = clientSocket.getInputStream();```接下来，可以使用InputStream对象的read()方法从输入流中读取数据。

read()方法会阻塞程序的执行，直到有数据可读取。

例如，可以使用以下代码读取数据并打印：```javabyte[] buffer = new byte[1024];int length = inputStream.read(buffer);String data = new String(buffer, 0, length);System.out.println("接收到数据：" + data);```需要注意的是，read()方法返回的是读取的字节数，而不是读取的数据内容。

串口接收数据包(协议带帧头帧尾且帧头帧尾都为两个字节)的编程实现方法

串口接收数据包(协议带帧头帧尾且帧头帧尾都为两个字节)的编程实现方法摘要：1.串口接收数据包的概述2.协议帧头帧尾的设计原则3.编程实现方法4.数据包接收的实战应用5.总结与展望正文：【1.串口接收数据包的概述】串口通信是基于串行通信协议的一种数据传输方式。

在实际应用中，常常需要接收数据包，而这些数据包往往带有协议，以便于识别和解析。

本文将针对带帧头帧尾的数据包接收进行讨论，具体涉及帧头帧尾的设计原则、编程实现方法以及实战应用。

【2.协议帧头帧尾的设计原则】在设计带帧头帧尾的数据协议时，需要遵循以下原则：- 帧头帧尾长度固定：便于接收端识别和解析。

- 帧头帧尾内容独特：避免与其他数据混淆。

- 帧头帧尾包含同步字段和数据长度字段：便于同步和数据解析。

【3.编程实现方法】接收带帧头帧尾的数据包，可以采用以下编程实现方法：- 初始化串口通信参数：如波特率、数据位、停止位等。

- 设置接收中断：在中断服务程序中处理接收到的数据。

- 解析帧头帧尾：根据协议解析同步字段和数据长度字段。

- 存储和处理数据：将解析后的数据存储并作相应处理。

【4.数据包接收的实战应用】在实际应用中，可以结合具体需求进行数据包接收的实战应用，例如：- 对接收到的数据包进行校验和检查，确保数据完整性。

- 根据数据包类型进行不同处理，如执行特定功能或发送响应。

- 实现多帧数据包的连续接收，并进行拼接处理。

【5.总结与展望】通过以上讨论，我们可以得知，在串口接收带帧头帧尾的数据包时，需要遵循一定的协议设计原则，并采用合适的编程方法实现。

在实际应用中，还需要根据具体需求进行优化和调整。

展望未来，随着通信技术的不断发展，我们有理由相信，更加高效、便捷的数据传输方式将不断涌现，为我们的生活和工作带来更多便利。

【注意】在实际编程过程中，还需要注意以下几点：- 根据实际硬件平台和通信需求，合理选择串口通信库和编程语言。

- 考虑数据包接收的实时性和稳定性，避免长时间等待或阻塞。

Java接收串口数据

java读写串口数据你了解多少

java调用第三方接收数据的方法流程

一个Java读取串口值的类

java串口通信

Java 串口通讯 RS232

Java串口通信——RXTX

java串口通信

java 虚拟串口 远程通信原理

java 串口通信案例

串口通讯-Java(Rxtx)

java串口通信

串口接收数据流程

Java串口通信RXTX实现方案

串口接收数据包(协议带帧头帧尾且帧头帧尾都为两个字节)的编程实现方法

java jssc串口例子

Java实现串口通信

java 判断串口接收完成一帧数据的解析思路

使用java的rxtx类解决串口通讯的具体操作步骤

java实现tcp连接的接收数据方法

串口接收数据包(协议带帧头帧尾且帧头帧尾都为两个字节)的编程实现方法

java 虚拟串口远程通信原理