java读串口数据

合集下载

java串口编程,java串口通信,监听者模式解析

java调用coms端口串口通信的方法。

首先需要下到串口驱动。

javacomm20-win32.zip去sun的主页应该有下的。

在这个驱动中有comm.jar，m.properties，win32com.dll这么3个重要的文件。

1、首先配置驱动，把m.properties，win32com.dll拷贝到你的jdk 中具体位置为C:\Program Files\Java\jdk1.6.0_06\bin然后配置windows系统环境变量，在path中加入C:\ProgramFiles\Java\jdk1.6.0_06\bin;打开你的java工程，配置user library,并导入comm.jar包。

2、现在就可以开始写代码了。

串口读写代码如下CommPortIdentifier portID =CommPortIdentifier.getPortIdentifier(com);//1，先拿到Identifier//其中com是String类型的，传入的是串口名com="COM1";SerialPort port = (SerialPort)portID.open("MyComm", 100000000);//2,打开串口//"MyComm"是串口名，100000000是串口过期时间（ms）。

port.setSerialPortParams(rate, databits,stopbit, parity);//3，设置串口属性//rate 波特率（默认9600），databits载波位（默认8），stopbit停止位（默认1），parity校验位（默认0无校验）port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);//4（可选）设置数据流控制模式，默认为无port.close();//关闭串口3、串口读入写出流。

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的扩展包(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串口读取源代码

{
portId=(CommPortIdentifier)portList.nextElement(); //获取系统中所有的通信端口
if(portId.getPortType()==CommPortIdentifier.PORT_PARALLEL) //用循环找出所需的端口
TextArea in_message=new TextArea();
TextField out_message=new TextField("上面的文本框显示接收到得数据");
R_Frame() //设置窗口和布局
{ super("串口接收数据");
{
R_Frame R_win =new R_Frame();
R_win.addWindowListener(new WindowAdapter()
{public void windowClosing(WindowEvent e)
{System.exit(0);}
}
class R_Frame extends Frame implements Runnable,ActionListener,SerialPortEventListener
{ static CommPortIdentifier portId;//检测系统中可用的通信端口
static Enumeration portList;//Enumeration为枚举型类，在java。util中
catch (UnsupportedCommOperationException e){}
byte[] readBuffer=new byte[20];
try
{

串口read函数

在许多编程语言中，都有用于读取串口数据的函数。

由于你并未指定具体的编程语言，我将提供一些常见语言的示例。

1. Python:在Python中，可以使用`pySerial`库来读取串口数据。

以下是一个简单的示例：```pythonimport serialser = serial.Serial('COM3', 9600) # replace 'COM3' with your port numberwhile True:if ser.in_waiting:line = ser.readline().decode('utf-8').rstrip()print(line)```2. C#:在C#中，可以使用`System.IO.Ports.SerialPort`类来读取串口数据。

以下是一个简单的示例：```csharpusing System.IO.Ports;SerialPort port = new SerialPort("COM3", 9600); // replace 'COM3' with your port numberport.Open();while (true){if (port.BytesToRead > 0){string data = port.ReadLine();Console.WriteLine(data);}}```3. Java:在Java中，可以使用`RXTX`库来读取串口数据。

以下是一个简单的示例：```javaimport gnu.io.*;import java.io.*;CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier("COM3"); // replace 'COM3' with your port numberSerialPort serialPort = (SerialPort) portIdentifier.open("MyOwnPort", 2000);serialPort.setSerialPortParams(9600, SerialPort.DA TABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);InputStream in = serialPort.getInputStream();BufferedReader br = new BufferedReader(new InputStreamReader(in));String line;while ((line = br.readLine()) != null) {System.out.println(line);}```请注意，上述代码中的`"COM3"`应替换为你的串口名称。

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串口通信

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========请输⼊你的串⼝：。

Javaspringboot串口通信

Javaspringboot串⼝通信基于win10 环境1. Virtual Serial Port Driver Pro 开通两个虚拟串⼝2. 打开串⼝调试助⼿3. 代码逻辑<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance" xsi:schemaLocation="/POM/4.0.0 https:///xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.2.10.RELEASE</version><relativePath/> </parent><groupId>com.example</groupId><artifactId>port</artifactId><version>0.0.1-SNAPSHOT</version><name>port</name><description>Demo Serial Port project for Spring Boot</description><properties><java.version>1.8</java.version><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><lombok.version>1.18.16</lombok.version><ng3.version>3.11</ng3.version><fastjson.version>1.2.75</fastjson.version></properties><dependencies><dependency><groupId>com.RXTXcomm</groupId><artifactId>RXTXcomm</artifactId><version>1.0.1</version><scope>system</scope><systemPath>${project.basedir}/src/main/resources/lib/RXTXcomm.jar</systemPath> </dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>${lombok.version}</version><scope>provided</scope></dependency><dependency><groupId>mons</groupId><artifactId>commons-lang3</artifactId><version>${ng3.version}</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>${fastjson.version}</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><configuration><source>1.8</source><target>1.8</target></configuration></plugin></plugins><resources><resource><directory>src/main/resources</directory><includes><include>**/*.*</include></includes><filtering>true</filtering></resource><resource><directory>src/main/lib</directory><targetPath>BOOT-INF/lib/</targetPath><includes><include>**/*.jar</include></includes></resource></resources></build></build></project>package com.example.port;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import javax.annotation.PreDestroy;@SpringBootApplicationpublic class PortApplication {public static void main(String[] args) {SpringApplication.run(PortApplication.class, args);}@PreDestroypublic void destory() {//关闭应⽤前关闭端⼝SerialPortUtil serialPortUtil = SerialPortUtil.getSerialPortUtil();serialPortUtil.removeListener(PortInit.serialPort, new MyLister());serialPortUtil.closePort(PortInit.serialPort);}}package com.example.port;import gnu.io.SerialPort;import org.springframework.beans.factory.annotation.Value;import org.springframework.boot.ApplicationArguments;import org.springframework.boot.ApplicationRunner;import ponent;import java.util.ArrayList;@Componentpublic class PortInit implements ApplicationRunner {public static SerialPort serialPort = null;@Value("${portname}")private String portname;@Overridepublic void run(ApplicationArguments args) {//TestA();//查看所有串⼝SerialPortUtil serialPortUtil = SerialPortUtil.getSerialPortUtil();ArrayList<String> port = serialPortUtil.findPort();System.out.println("发现全部串⼝：" + port);System.out.println("打开指定portname:" + portname);//打开该对应portname名字的串⼝PortInit.serialPort = serialPortUtil.openPort(portname, 9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);//给对应的serialPort添加监听器serialPortUtil.addListener(PortInit.serialPort, new MyLister());}}package com.example.port;/*** @author 7788* @version 1.0* @date 2021/4/6 上午 9:26* @location wuhan*/import gnu.io.*;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.slf4j.LoggerFactory;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.util.ArrayList;import java.util.Enumeration;import java.util.TooManyListenersException;public class SerialPortUtil {private static final Logger logger = LoggerFactory.getLogger(SerialPortUtil.class);private static SerialPortUtil serialPortUtil = null;static {//在该类被ClassLoader加载时就初始化⼀个SerialTool对象if (serialPortUtil == null) {serialPortUtil = new SerialPortUtil();}}//私有化SerialTool类的构造⽅法，不允许其他类⽣成SerialTool对象private SerialPortUtil() {}/*** 获取提供服务的SerialTool对象** @return serialPortUtil*/public static SerialPortUtil getSerialPortUtil() {if (serialPortUtil == null) {serialPortUtil = new SerialPortUtil();}return serialPortUtil;}/*** 查找所有可⽤端⼝** @return可⽤端⼝名称列表*/public ArrayList<String> findPort() {//获得当前所有可⽤串⼝Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();ArrayList<String> portNameList = new ArrayList<>();//将可⽤串⼝名添加到List并返回该Listwhile (portList.hasMoreElements()) {String portName = portList.nextElement().getName();portNameList.add(portName);}return portNameList;}/*** 打开串⼝** @param portName 端⼝名称* @param baudrate 波特率* @param databits 数据位* @param parity 校验位（奇偶位）* @param stopbits 停⽌位* @return串⼝对象* // * @throws SerialPortParameterFailure 设置串⼝参数失败* // * @throws NotASerialPort 端⼝指向设备不是串⼝类型* // * @throws NoSuchPort 没有该端⼝对应的串⼝设备* // * @throws PortInUse 端⼝已被占⽤*/public SerialPort openPort(String portName, int baudrate, int databits, int parity, int stopbits) { try {//通过端⼝名识别端⼝CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);//打开端⼝，并给端⼝名字和⼀个timeout（打开操作的超时时间）CommPort commPort = portIdentifier.open(portName, 2000);//判断是不是串⼝if (commPort instanceof SerialPort) {SerialPort serialPort = (SerialPort) commPort;try {//设置⼀下串⼝的波特率等参数serialPort.setSerialPortParams(baudrate, databits, stopbits, parity);} catch (UnsupportedCommOperationException e) {}System.out.println("Open " + portName + " sucessfully !");return serialPort;} else {logger.error("不是串⼝");}} catch (NoSuchPortException e1) {logger.error("没有找到端⼝");e1.printStackTrace();} catch (PortInUseException e2) {logger.error("端⼝被占⽤");e2.printStackTrace();}return null;}/*** 关闭串⼝** @param serialPort 待关闭的串⼝对象*/public void closePort(SerialPort serialPort) {if (serialPort != null) {serialPort.close();}}/*** 往串⼝发送数据** @param serialPort 串⼝对象* @param order 待发送数据* // * @throws SendDataToSerialPortFailure 向串⼝发送数据失败* // * @throws SerialPortOutputStreamCloseFailure 关闭串⼝对象的输出流出错 */public void sendToPort(SerialPort serialPort, byte[] order) {OutputStream out = null;try {out = serialPort.getOutputStream();out.write(order);out.flush();} catch (IOException e) {e.printStackTrace();} finally {try {if (out != null) {out.close();}} catch (IOException e) {e.printStackTrace();}}}/*** 从串⼝读取数据** @param serialPort 当前已建⽴连接的SerialPort对象* @return读取到的数据* // * @throws ReadDataFromSerialPortFailure 从串⼝读取数据时出错* // * @throws SerialPortInputStreamCloseFailure 关闭串⼝对象输⼊流出错*/public byte[] readFromPort(SerialPort serialPort) {InputStream in = null;byte[] bytes = null;try {in = serialPort.getInputStream();int bufflenth = in.available();while (bufflenth != 0) {bytes = new byte[bufflenth];in.read(bytes);bufflenth = in.available();}} catch (IOException e) {e.printStackTrace();} finally {} finally {try {if (in != null) {in.close();}} catch (IOException e) {e.printStackTrace();}}return bytes;}/*** 添加监听器** @param port 串⼝对象* @param listener 串⼝监听器* // * @throws TooManyListeners 监听类对象过多*/public void addListener(SerialPort port, SerialPortEventListener listener) {try {//给串⼝添加监听器port.addEventListener(listener);//设置当有数据到达时唤醒监听接收线程port.notifyOnDataAvailable(true);//设置当通信中断时唤醒中断线程port.notifyOnBreakInterrupt(true);} catch (TooManyListenersException e) {// throw new TooManyListeners();logger.error("太多监听器");e.printStackTrace();}}/*** 删除监听器** @param port 串⼝对象* @param listener 串⼝监听器* // * @throws TooManyListeners 监听类对象过多*/public void removeListener(SerialPort port, SerialPortEventListener listener) {//删除串⼝监听器port.removeEventListener();}}package com.example.port;import com.alibaba.fastjson.JSON;import com.example.port.ISO8583.ISO8583;import com.example.port.ISO8583.TransISO8583MessageUtil;import gnu.io.SerialPortEvent;import gnu.io.SerialPortEventListener;import lombok.SneakyThrows;import java.util.Date;/*** @author best*/public class MyLister implements SerialPortEventListener {@SneakyThrows@Overridepublic void serialEvent(SerialPortEvent arg0) {if (arg0.getEventType() == SerialPortEvent.DATA_AVAILABLE) {SerialPortUtil serialPortUtil = SerialPortUtil.getSerialPortUtil();byte[] bytes = serialPortUtil.readFromPort(PortInit.serialPort);String byteStr = new String(bytes, 0, bytes.length).trim();// System.out.println(new Date() + "【读到的字节数组】：-----" + byteStr);// ISO8583 aiISO8583DTO = (ISO8583) TransISO8583MessageUtil.unpackISO8583(ISO8583.class, byteStr); // System.out.println("UNPACK ISO8583: " + JSON.toJSONString(aiISO8583DTO));System.out.println("===========start===========");System.out.println(new Date() + "【读到的字节数组】：-----" + byteStr);String needData = printHexString(bytes);System.out.println(new Date() + "【字节数组转字符串】：-----" + needData);System.out.println(new Date() + "【16进制字符串转字符串】：" + hexStringToString(needData));System.out.println("===========end===========");// ISO8583 aiiso8583DTO = new ISO8583();//// aiiso8583DTO.setCardNo02(String.valueOf(System.currentTimeMillis()));// aiiso8583DTO.setTransProcCode03("123456");// aiiso8583DTO.setTransAmt04("000010000000");// aiiso8583DTO.setSysTrackNo11("888888");// aiiso8583DTO.setServiceInputModeCode22("100");// aiiso8583DTO.setServiceConditionCode25("66");// aiiso8583DTO.setCardAcceptorTerminalID41("08022206");// aiiso8583DTO.setCardAcceptorID42("000100000000005");// aiiso8583DTO.setAdditionalDataPrivate48("0000");// aiiso8583DTO.setCurrencyCode49("168");// aiiso8583DTO.setEWalletTransInfo58("53560118FFFFFFFFFFFF03104890100000006059FFFFFFFF0101000200000064020000080000032017122310225672FB4788000 // aiiso8583DTO.setFld60Domain60("41000006666");// aiiso8583DTO.setOriginalInfoDomain61("000666000181");// aiiso8583DTO.setFld63Domain63("0000000000000000");// String maxBitmap = "7020048000C1805B";// final String TPDU = "6000000000";// final String HEAD = "612200000000";// String sendMsg = TransISO8583MessageUtil.packISO8583(aiiso8583DTO, maxBitmap, TPDU, HEAD, "0300");//接收到消息后回复⼀个当前时间serialPortUtil.sendToPort(PortInit.serialPort, new Date().toString().getBytes());}}// 字节数组转字符串private String printHexString(byte[] b) {StringBuffer sbf = new StringBuffer();for (int i = 0; i < b.length; i++) {String hex = Integer.toHexString(b[i] & 0xFF);if (hex.length() == 1) {hex = '0' + hex;}sbf.append(hex.toUpperCase() + " ");}return sbf.toString().trim();}/*** 16进制转换成为string类型字符串** @param s* @return*/public static String hexStringToString(String s) {if (s == null || s.equals("")) {return null;}s = s.replace(" ", "");byte[] baKeyword = new byte[s.length() / 2];for (int i = 0; i < baKeyword.length; i++) {try {baKeyword[i] = (byte) (0xff & Integer.parseInt(s.substring(i * 2, i * 2 + 2), 16));} catch (Exception e) {e.printStackTrace();}}try {s = new String(baKeyword, "UTF-8");new String();} catch (Exception e1) {e1.printStackTrace();}return s;}}接下来启动项⽬就可以了，可以完善MyLister的功能对收到的消息进⾏处理，然后回复消息⽐如ISO8583的报⽂解析并http调⽤接⼝更新数据。

java 串口通信案例

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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目录。

串口写入和读取数据

串⼝写⼊和读取数据SerialPort类WriteComm 写串⼝函数DWORD CSerialPort::WriteComm(char *buf, DWORD dwLength){if(!IsOpen()){return0;}assert(buf != NULL);COMSTAT comStat;DWORD dwErrorFlags;if (!ClearCommError(m_hCom, &dwErrorFlags, &comStat) && dwErrorFlags > 0){PurgeComm(m_hCom, PURGE_TXABORT | PURGE_TXCLEAR);}OVERLAPPED osWrite;memset(&osWrite, 0, sizeof(OVERLAPPED));osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);BOOL bWriteStat = WriteFile(m_hCom, buf, dwLength, &dwLength, &osWrite);if(!bWriteStat){if(GetLastError() == ERROR_IO_PENDING){WaitForSingleObject(osWrite.hEvent, 2000);}else{dwLength = 0;}}return dwLength;}调⽤char buf[10]; //字符数组将字符串通过 strcpy 放⼊字符数组再向串⼝写⼊strcpy(buf,"1234");m_SerialPort.WriteComm(buf,4);MessageBox(_T("1234"));buf[0]=0x61; //将要发送的字符串或⼗六进制数据储存在char型字符数组中，利⽤WriteComm发送到串⼝m_SerialPort.WriteComm(buf,1);ReadCommDWORD CSerialPort::ReadComm(char *buf, DWORD dwLength){if(!IsOpen()){return0;}buf[0] = '\0';COMSTAT comStat;DWORD dwErrorFlags;if (!ClearCommError(m_hCom, &dwErrorFlags, &comStat) && dwErrorFlags > 0){PurgeComm(m_hCom, PURGE_RXABORT | PURGE_RXCLEAR);return0;}if(comStat.cbInQue == 0){return0;}DWORD dwBytesRead=0;BOOL bReadStat;dwBytesRead = min(dwLength - 1, (DWORD)comStat.cbInQue);OVERLAPPED osRead;memset(&osRead,0,sizeof(OVERLAPPED));osRead.hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);DWORD dwByteOfRead = 0;bReadStat = ReadFile(m_hCom, buf, dwBytesRead, &dwByteOfRead, &osRead);if(!bReadStat){if(GetLastError() == ERROR_IO_PENDING){WaitForSingleObject(osRead.hEvent, 2000);// GetOverlappedResult(m_hCom, &osRead, &dwByteOfRead, FALSE) ;}}// PurgeComm(m_hCom, PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR); ////清空串⼝的接收缓冲区,必要性不⼤,但有保证作⽤?清空的话如果⼤数据会丢失buf[dwByteOfRead] = '\0';return dwByteOfRead;}调⽤char *pBuf=new char[10]; //定义⼀个char型字符数组，动态分配内存 memset(pBuf,0,10);m_SerialPort.ReadComm(pBuf,10);。

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.打开串口：首先需要打开串口，通过设备文件或串口号来指定要打开的串口。

```c++#include <stdio.h>#include <fcntl.h>#include <termios.h>int openSerialPort(const char* portName)int fd = open(portName, O_RDWR ， O_NOCTTY);if (fd < 0)printf("Failed to open serial port\n");return -1;}//配置串口参数struct termios options;tcgetattr(fd, &options);cfsetispeed(&options, B9600);cfsetospeed(&options, B9600);options.c_cflag ，= (CLOCAL ， CREAD);tcsetattr(fd, TCSANOW, &options);return fd;}```2.读取串口数据：打开串口之后，可以通过读取文件描述符来读取串口数据。

```c++int readSerialData(int fd, unsigned char* buffer, int bufferSize)int bytesRead = read(fd, buffer, bufferSize);if (bytesRead < 0)printf("Failed to read serial data\n");}return bytesRead;}```3.解析串口数据：读取到的数据可能是原始的字节流，需要根据具体的协议和数据格式进行解析。

```c++void parseData(unsigned char* buffer, int bufferSize)//解析数据的逻辑}```4.循环读取数据：可以使用循环来不断读取串口数据，并进行解析和处理。

基于B／S结构的Java串口通信

基于B／S结构的Java串口通信【摘要】本文介绍的是数字粮库信息化软件系统的智能通风模块，系统建设了一个综合性多功能的粮库信息化管理网络平台。

平台系统基于B/S结构，实现在线业务处理、信息发布、智能控制的目的。

其中通风模块的通风状态检测，通过串口发送指令控制通风设备，接收串口指令显示通风设备状态。

系统在Java 程序中使用comm.jar开发包编程实现串口通信。

【关键词】智能通风;状态监控;Java串口通信引言Java由于具有开放性、平台无关性和面向对象等特性，使之成为一个理想的软件开发平台[1]。

因此智能通风[2]模块与下位机的通信方式选择RS232串口通信。

本文使用Java开发基于B/S结构的智能通风状态监控串口通信程序，具有很强的实用意义。

1.智能通风结构模式智能通风模块的物理结构为B/S（Browser/Server）模式，即浏览器/服务器模式，用户可联网通过Web浏览器访问系统，连接服务器对各通风设备进行监控维护。

服务器通过串口与通风设备进行通信，其流程如图1所示。

进入页面，发送状态查询数据帧查询通风设备状态。

若超过T0时间则提示响应失败。

在T0时间内设备有响应则分析返回数据帧显示各通风设备的状态。

用户点击通风设备图标，发送操作数据帧，在T0时间内通风设备进行响应，并返回数据。

如果通风设备操作成功则提示操作成功，否则提示操作失败。

若超过T0时间则提示响应失败。

图1 程序流程图2.通风设备通信协议智能通风通信协议[3]以帧为基本单元传输的，每帧由帧头、装置地址、报文命令码、报文长度、正文、累加和及结束符等组成。

每个域由一定字节组成。

其中读写寄存器的通信协议采用Modbus协议。

其命令帧格式如图2所示。

图2 读写寄存器帧数据格式3.智能通风设备监控智能通风设备监控模块如图3所示，通过选择仓号显示该仓号通风设备的状态，通风设备有通风窗、轴流风机、离心风机和空调等。

点击图中通风设备图标可控制设备的开关。

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串口通信编程教程_hao

Win32 串口编程（一）(2009-08-16 16:28:13)标签：串口重叠i/o 分类：Windows翻译自：ms-help://MS.MSDNQTR.v80.chs/MS.MSDN.v80/MS.WIN32COM.v10.en/dnfiles/html/msdn_s erial.htm老外写的文章，虽比较全面，但很啰嗦，不如看各个函数的文档来得快。

为方便以后查阅，列出本文涉及的主要函数如下：CreateFile、ReadFile、WriteFile、GetOverlappedResult、WaitForSingleObject SetCommMask、WaitCommEventClearCommError、GetCommModemStatus、EscapeCommFunctionGetCommState、BuildCommDCB、SetCommState、SetCommTimeouts此外，新浪的博客系统限制文章最大长度为40000字节，只好把这篇文章分成几部分了。

0 简介本文仅关注在Windows NT和95间兼容的API。

Windows 95支持Telephony API(TAPI)，但Windows NT 3.x不支持TAPI，所以本文不讨论它。

本文的示例程序MTTTY(Multithreaded TTY)使用了三个线程：一个进行内存管理的界面线程；控制所有写入操作的写入者线程；读取数据和处理端口状态改变的读取/状态线程。

示例采用了一些不同的堆来进行内存管理；还大量使用了同步方法来进行线程间通信。

1 打开端口使用CreateFile函数打开端口。

打开端口时有两种方法：重叠的和非重叠的。

下列代码片段以重叠方式打开端口：HANDLE hComm;hComm = CreateFile( gszPort,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,0);if (hComm == INV ALID_HANDLE_V ALUE)// error opening port; abortWin32 串口编程（二）(2009-08-16 16:39:32)标签：串口重叠i/o it 分类：Windows3 串口状态有两种获取通信端口状态的方法。

使用com0com0模拟串口通信，以及java的串口读写操作

使⽤com0com0模拟串⼝通信，以及java的串⼝读写操作⾸先放⼀下我这次使⽤的⼯具com0com0是windows内核模式下的虚拟串⼝驱动程序。

可以创建虚拟串⼝对来连接两个COM端⼝在这⾥简单的介绍⼀下com0com0的使⽤⽅法⾸先，下载com0com-3.0.0.0-i386-and-x64-unsigned，解压缩并安装接下来我们就可以使⽤setup command prompt来进⾏模拟串⼝对了在这⾥⾸先介绍两个命令install PortName=串⼝名1 PortName=串⼝名2新建两个虚拟串⼝，并连接为串⼝对list列出⽬前所有的虚拟串⼝如果跳出更新驱动的提⽰可以暂时⽆视，不影响后续的操作。

另⼀个⼯具setup具有图形化界⾯，可以查看⽬前的串⼝对接下来介绍java编程的时候需要⽤到的两个jar包RXTXcomm.jarserialPortIO.jar同时，在使⽤这两个jar包进⾏java编程之前，我们要将mfz-rxtx-2.2-20081207-win-x64压缩包下的两个dll⽂件放到C:\Windows\System32下然后，这⾥是⼀个简单的串⼝读写的例⼦import gnu.io.SerialPort;import serialPort.SerialTool;public class Read {public static void main(String[] args) throws Exception{// TODO Auto-generated method stub//以波特率115200打开串⼝COM12SerialPort serialPort = SerialTool.openPort("COM12", 115200);SerialTool.addListener(serialPort, new SerialListener(serialPort));}}import java.util.Scanner;import gnu.io.SerialPort;import serialPort.SerialTool;public class Write {public static void main(String[] args) throws Exception {Scanner scan = new Scanner(System.in);String temp;//以波特率115200打开串⼝COM11SerialPort serialPort = SerialTool.openPort("COM11", 115200);while(scan.hasNext()){temp=scan.nextLine();SerialTool.sendToPort(serialPort, temp.getBytes());}}}import javax.swing.JOptionPane;import gnu.io.SerialPort;import gnu.io.SerialPortEvent;import gnu.io.SerialPortEventListener;import serialPort.SerialTool;public class SerialListener implements SerialPortEventListener {public SerialPort serialPort;public SerialListener(SerialPort serialPort){this.serialPort=serialPort;}public void serialEvent(SerialPortEvent serialPortEvent) {switch (serialPortEvent.getEventType()) {case SerialPortEvent.BI: // 10 通讯中断System.out.println("与串⼝设备通讯中断");break;case SerialPortEvent.OE: // 7 溢位（溢出）错误case SerialPortEvent.FE: // 9 帧错误case SerialPortEvent.PE: // 8 奇偶校验错误case SerialPortEvent.CD: // 6 载波检测case SerialPortEvent.CTS: // 3 清除待发送数据case SerialPortEvent.DSR: // 4 待发送数据准备好了case SerialPortEvent.RI: // 5 振铃指⽰case SerialPortEvent.OUTPUT_BUFFER_EMPTY: // 2 输出缓冲区已清空break;case SerialPortEvent.DATA_AVAILABLE: // 1 串⼝存在可⽤数据//System.out.println("found data");byte[] data = null;try {if (serialPort == null) {System.out.println("串⼝对象为空！监听失败");}else {data = SerialTool.readFromPort(serialPort); //读取数据，存⼊字节数组//System.out.println(new String(data));JOptionPane.showInputDialog(new String(data));//String dataOriginal = new String(data); //将字节数组数据转换位为保存了原始数据的字符串 }} catch (Exception e) {System.exit(0);}break;}}}。

Java串口通信详解

Java串口通信详解序言说到开源，恐怕很少有人不挑大指称赞。

学生通过开源代码学到了知识，程序员通过开源类库获得了别人的成功经验及能够按时完成手头的工程，商家通过开源软件赚到了钱……，总之是皆大欢喜。

然而开源软件或类库的首要缺点就是大多缺乏详细的说明文档和使用的例子，或者就是软件代码随便你用，就是文档，例子和后期服务收钱。

这也难怪，毕竟就像某个著名NBA 球员说的那样：“我还要养家，所以千万美元以下的合同别找我谈，否则我宁可待业”。

是啊，支持开源的人也要养家，收点钱也不过分。

要想既不花钱又学到知识就只能借助网络和了，我只是想抛砖引玉，为开源事业做出点微薄共献，能为你的工程解决哪怕一个小问题，也就足够了。

虽然我的这个系列介绍的东西不是什么Web框架，也不是什么开源服务器，但是我相信，作为一个程序员，什么样的问题都会遇到。

有时候越是简单的问题反而越棘手；越是小的地方就越是找不到称手的家伙。

只要你不是整天只与“架构”、“构件”、“框架”打交道的话，相信我所说的东西你一定会用到。

1串口通信简介1.1常见的Java串口包1.2串口包的安装（Windows下）2串口API概览mPortmPortIdentifierm.SerialPort2.4串口API实例2.4.1列举出本机所有可用串口2.4.2串口参数的配置2.4.3串口的读写3串口通信的通用模式及其问题3.1事件监听模型3.2串口读数据的线程模型3.3第三种方法4结束语1串口通信简介嵌入式系统或传感器网络的很多应用和测试都需要通过PC机与嵌入式设备或传感器节点进行通信。

其中，最常用的接口就是RS-232串口和并口（鉴于USB接口的复杂性以及不需要很大的数据传输量，USB接口用在这里还是显得过于奢侈，况且目前除了SUN有一个支持USB 的包之外，我还没有看到其他直接支持USB的Java类库）。

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