1.打开串口再打开串口的同时添加监听,要不然接收不到响应.
package com.gq.cswl.serialporttool;
import com.alibaba.nacos.shaded.io.grpc.netty.shaded.io.netty.util.internal.StringUtil;
import com.gq.common.core.exception.CustomException;
import com.gq.common.core.utils.CRCUtils;
import gnu.io.CommPortIdentifier;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.TooManyListenersException;
/**
* 串口参数的配置 串口一般有如下参数可以在该串口打开以前进行配置： 包括串口号，波特率，输入/输出流控制，数据位数，停止位和奇偶校验。
*/
// 注：串口操作类一定要继承SerialPortEventListener
@Component
public class SerialPortUtils implements SerialPortEventListener {
private static final Logger logger = LoggerFactory.getLogger(SerialPortUtils.class);
// 检测系统中可用的通讯端口类
private CommPortIdentifier commPortId;
// 枚举类型
private Enumeration<CommPortIdentifier> portList;
// RS232串口
public static SerialPort serialPort;
// 输入流
private InputStream inputStream;
// 输出流
private OutputStream outputStream;
// 保存串口返回信息
private String data;
// 保存串口返回信息十六进制
private String dataHex;
/**
* 初始化串口
* @Description: TODO
* @param: paramConfig 存放串口连接必要参数的对象（会在下方给出类代码）
* @return: void
* @throws
*/
@SuppressWarnings("unchecked")
public void init(ParamConfig paramConfig) {
// 获取系统中所有的通讯端口
portList = CommPortIdentifier.getPortIdentifiers();
// 记录是否含有指定串口
boolean isExsist = false;
// 循环通讯端口
while (portList.hasMoreElements()) {
commPortId = portList.nextElement();
// 判断是否是串口
if (commPortId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
// 比较串口名称是否是指定串口
if (paramConfig.getSerialNumber().equals(commPortId.getName())) {
// 串口存在
isExsist = true;
// 打开串口
try {
// open:（应用程序名【随意命名】，阻塞时等待的毫秒数）
serialPort = (SerialPort) commPortId.open(Object.class.getSimpleName(), 2000);
// 设置串口监听
serialPort.addEventListener(this);
// 设置串口数据时间有效(可监听)
serialPort.notifyOnDataAvailable(true);
// 设置串口通讯参数:波特率，数据位，停止位,校验方式
serialPort.setSerialPortParams(paramConfig.getBaudRate(), paramConfig.getDataBit(),
paramConfig.getStopBit(), paramConfig.getCheckoutBit());
logger.info("打开串口:"+serialPort.getName()+"成功");
} catch (Exception e) {
logger.error(e.getMessage());
}
// 结束循环
break;
}
}
}
// 若不存在该串口则抛出异常
if (!isExsist) {
logger.error("串口不存在");
}
}
/**
* 实现接口SerialPortEventListener中的方法 读取从串口中接收的数据
*/
@Override
public void serialEvent(SerialPortEvent event) {
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: // 输出缓冲区已清空
break;
case SerialPortEvent.DATA_AVAILABLE: // 有数据到达
// 调用读取数据的方法
readComm();
break;
default:
break;
}
}
/**
* 读取串口返回信息
* @return: void
*/
public void readComm() {
try {
inputStream = serialPort.getInputStream();
// 通过输入流对象的available方法获取数组字节长度
byte[] readBuffer = new byte[inputStream.available()];
// 从线路上读取数据流
int len = 0;
while ((len = inputStream.read(readBuffer)) != -1) {
//获取串口返回数据
data = new String(readBuffer, 0, len).trim();
//转为十六进制数据
dataHex = CRCUtils.bytesToHexString(readBuffer);
System.out.println("data:" + data);
System.out.println("dataHex:" + dataHex);// 读取后置空流对象
inputStream.close();
inputStream = null;
break;
}
} catch (IOException e) {
logger.error("未读取到数据");
}
}
/**
* 发送信息到串口
* @param: data
* @return: void
* @throws
*/
public void sendComm(String data) {
byte[] writerBuffer = null;
try {
writerBuffer = hexToByteArray(data);
outputStream = serialPort.getOutputStream();
outputStream.write(writerBuffer);
outputStream.flush();
} catch (Exception e) {
logger.error("发送消息失败"+e.getMessage());
}
}
/**
* 关闭串口
* @Description: 关闭串口
* @param:
* @return: void
* @throws
*/
public void closeSerialPort() {
if (serialPort != null) {
serialPort.notifyOnDataAvailable(false);
serialPort.removeEventListener();
if (inputStream != null) {
try {
inputStream.close();
inputStream = null;
} catch (IOException e) {
logger.error("输入流关闭串口错误");
}
}
if (outputStream != null) {
try {
outputStream.close();
outputStream = null;
} catch (IOException e) {
logger.error("输出流关闭串口错误");
}
}
serialPort.close();
serialPort = null;
}
}
/**
* 十六进制串口返回值获取
*/
public String getDataHex() {
String result = dataHex;
// 置空执行结果
dataHex = null;
// 返回执行结果
return result;
}
/**
* 串口返回值获取
*/
public String getData() {
String result = data;
// 置空执行结果
data = null;
// 返回执行结果
return result;
}
/**
* Hex字符串转byte
* @param inHex 待转换的Hex字符串
* @return 转换后的byte
*/
public static byte hexToByte(String inHex) {
return (byte) Integer.parseInt(inHex, 16);
}
/**
* hex字符串转byte数组
* @param inHex 待转换的Hex字符串
* @return 转换后的byte数组结果
*/
public static byte[] hexToByteArray(String inHex) {
int hexlen = inHex.length();
byte[] result;
if (hexlen % 2 == 1) {
// 奇数
hexlen++;
result = new byte[(hexlen / 2)];
inHex = "0" + inHex;
} else {
// 偶数
result = new byte[(hexlen / 2)];
}
int j = 0;
for (int i = 0; i < hexlen; i += 2) {
result[j] = hexToByte(inHex.substring(i, i + 2));
j++;
}
return result;
}
/**
* 数组转换成十六进制字符串
* @param bArray
* @return HexString
*/
public static final String bytesToHexString(byte[] bArray) {
StringBuffer sb = new StringBuffer(bArray.length);
String sTemp;
for (int i = 0; i < bArray.length; i++) {
sTemp = Integer.toHexString(0xFF & bArray[i]);
if (sTemp.length() < 2) {
sb.append(0);
sb.append(sTemp.toUpperCase());
}
}
return sb.toString();
}
}package com.gq.cswl.serialporttool;
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;
}
public String getSerialNumber() {
return serialNumber;
}
public void setSerialNumber(String serialNumber) {
this.serialNumber = serialNumber;
}
public int getBaudRate() {
return baudRate;
}
public void setBaudRate(int baudRate) {
this.baudRate = baudRate;
}
public int getCheckoutBit() {
return checkoutBit;
}
public void setCheckoutBit(int checkoutBit) {
this.checkoutBit = checkoutBit;
}
public int getDataBit() {
return dataBit;
}
public void setDataBit(int dataBit) {
this.dataBit = dataBit;
}
public int getStopBit() {
return stopBit;
}
public void setStopBit(int stopBit) {
this.stopBit = stopBit;
}
}3.数据转换工具类
package com.gq.common.core.utils;
import static com.gq.common.core.utils.BytesToHexUtil.bytesToHexString;
/**
* crc
*
* @ClassName com.gq.common.core.utils.CRCUtils
* @Author g
* @Version V1.0 Created on ：2023/1/4 14:54
**/
public class CRCUtils {
/**
* 异或校验，数据帧校验字节
* @param sHex 16进制指令字符串，不带空格、不带0x、不带逗号的16进制Str,如:06EEF7F1
* @return 原指令str+
*/
public static byte[] getSendDataBytes(String sHex) {
//16进制表示的字符串转换为字节数组
byte[] bOutArray = hexStrToByteArray(sHex);
//byte[] bOutArray = FuncUtil.String2Byte(sHex);
byte[] sendCmd = new byte[bOutArray.length + 1];
System.arraycopy(bOutArray, 0, sendCmd, 0, bOutArray.length);
sendCmd[bOutArray.length] = getXor(bOutArray);
return sendCmd;
}
/**
* 异或
* @param datas
* @return
*/
public static byte getXor(byte[] datas) {
byte temp = datas[0];
for(int i = 1; i < datas.length; ++i) {
temp ^= datas[i];
}
return temp;
}
/**
* 16进制Str转byte[]
*
* @param hexStr 不带空格、不带0x、不带逗号的16进制Str,如:06EEF7F1
* @return byteArray
*/
public static byte[] hexStrToByteArray(String hexStr){
byte[] byteArray = new byte[hexStr.length() / 2];
for (int i = 0; i < byteArray.length; i++){
String subStr = hexStr.substring(2 * i, 2 * i + 2);
byteArray[i] = ((byte) Integer.parseInt(subStr, 16));
}
return byteArray;
}
/**
* byte数组转十六进制字符串
* @param bytes
* @return
*/
public static String bytesToHexString(byte[] bytes) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < bytes.length; i++) {
String hex = Integer.toHexString(0xFF & bytes[i]);
if (hex.length() == 1) {
sb.append('0');
}
sb.append(hex);
}
return sb.toString();
}
//
public static void main(String[] args) {
byte[] bytes = getSendDataBytes("BD000900");
//BD 00 09 00 B4
String s = bytesToHexString(bytes);
System.out.println(s);
}
}来自大神的
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
