JAVA使用RXTXcomm包操作串口数据流

最近对接下位机，对方没有使用modbus总线协议来对接，直接使用的操作流对接，找了一下java中使用RXTXcomm.jar比较方便，下面是包的使用方法
1、maven工程中引入依赖
可能这个包不在阿里的maven仓库中，下载下来包，手动加载到本地的maven仓库中即可

<dependency>
    <groupId>org.rxtx.RXTXcomm</groupId>
    <artifactId>RXTXcomm</artifactId>
    <version>4.6.1</version>
</dependency>

2、参数的配置类

package com.jndj.platform.common.generalcom;

import lombok.Data;

/**
 * 串口必要参数接收类
 * @author: yaohj
 * @date: 2020年7月14日
 */
@Data
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;
	}
}

3、com口的操作类（负责下发指令、接收数据）

package com.jndj.platform.common.generalcom;

import com.jndj.platform.envone.service.EnvTemHumService;
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.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.TooManyListenersException;

/**
 * 串口参数的配置 串口一般有如下参数可以在该串口打开以前进行配置： 包括串口号，波特率，输入/输出流控制，数据位数，停止位和奇偶校验。
 */
@Component
public class SerialPortCom3Utils implements SerialPortEventListener {
	private static final Logger logger = LoggerFactory.getLogger(SerialPortCom3Utils.class);
	// 检测系统中可用的通讯端口类
	private CommPortIdentifier commPortId;
	// 枚举类型
	private Enumeration<CommPortIdentifier> portList;
	// RS232串口
	private SerialPort serialPort;
	// 输入流
	private InputStream inputStream;
	// 输出流
	private OutputStream outputStream;
	// 保存串口返回信息
	private String data;
	// 保存串口返回信息十六进制
	private String dataHex;
	// -------------这里必须这样写，不可以使用注解注入---------------
	// 获取环境数据（温度、湿度、液位、CO2）
	private static EnvTemHumService envTemHumService;

	@Autowired
	public void setEnvTemHumService(EnvTemHumService envTemHumService) {
		SerialPortCom3Utils.envTemHumService = envTemHumService;
	}
    // ----------------------------
	/**
	 * 初始化串口
	 */
	@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 {
						// （应用程序名【随意命名】，阻塞时等待的毫秒数）
						serialPort = (SerialPort) commPortId.open(Object.class.getSimpleName(), 2000);
						// 设置串口监听
						serialPort.addEventListener(this);
						// 设置串口数据时间有效(可监听)
						serialPort.notifyOnDataAvailable(true);
						// 设置串口通讯参数:波特率，数据位，停止位,校验方式
						serialPort.setSerialPortParams(paramConfig.getBaudRate(), paramConfig.getDataBit(),
								paramConfig.getStopBit(), paramConfig.getCheckoutBit());
					} catch (PortInUseException e) {
						logger.info("端口被占用");
					} catch (TooManyListenersException e) {
						logger.info("监听器过多");
					} catch (UnsupportedCommOperationException e) {
						logger.info("不支持的COMM端口操作异常");
					}
					// 结束循环
					break;
				}
			}
		}
		// 若不存在该串口则抛出异常
		if (!isExsist) {
			logger.info("不存在该串口");
		}
	}

	/**
	 * 实现接口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;
		}
	}

	/**
	 * 读取串口返回信息
	 */
	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 = bytesToHexString(readBuffer);
				// 解析数据保存到数据库
				envTemHumService.insertTemHumData(dataHex, "1");
//				System.out.println("data:" + data);
//				System.out.println("dataHex:" + dataHex);// 读取后置空流对象
				inputStream.close();
				inputStream = null;
				break;
			}
		} catch (IOException e) {
			logger.info("读取串口数据时发生IO异常");
		}
	}

	/**
	 * 发送信息到串口
	 */
	public void sendComm(String data) {
		byte[] writerBuffer = null;
		try {
			writerBuffer = hexToByteArray(data);
		} catch (NumberFormatException e) {
			logger.info("命令格式错误");
		}
		try {
			outputStream = serialPort.getOutputStream();
			outputStream.write(writerBuffer);
			outputStream.flush();
		} catch (NullPointerException e) {
			logger.info("找不到串口");
		} catch (IOException e) {
			logger.info("发送信息到串口时发生IO异常");
		}
	}

	/**
	 * 关闭串口
	 */
	public void closeSerialPort() {
		if (serialPort != null) {
			serialPort.notifyOnDataAvailable(false);
			serialPort.removeEventListener();
			if (inputStream != null) {
				try {
					inputStream.close();
					inputStream = null;
				} catch (IOException e) {
					logger.info("关闭输入流时发生IO异常");
				}
			}
			if (outputStream != null) {
				try {
					outputStream.close();
					outputStream = null;
				} catch (IOException e) {
					logger.info("关闭输出流时发生IO异常");
				}
			}
			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
	 */
	public static byte hexToByte(String inHex) {
		return (byte) Integer.parseInt(inHex, 16);
	}

	/**
	 * hex字符串转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;
	}

	/**
	 * 数组转换成十六进制字符串
	 */
	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();
	}
}

4、处理业务、初始化串口操作类的service

package com.jndj.platform.envone.service.impl;

import com.jndj.platform.common.generalcom.*;
import com.jndj.platform.common.util.ConvertDataUtils;
import com.jndj.platform.common.util.DateUtils;
import com.jndj.platform.envone.mapper.EnvoneMapper;
import com.jndj.platform.envone.service.EnvTemHumService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author yaohj
 * @date 2020/7/7
 * 获取环境数据（温度、湿度、液位、CO2）
 */
@Service("envTemHumService")
public class EnvTemHumServiceImpl implements EnvTemHumService {

    @Resource
    private EnvoneMapper envoneMapper;

    // 串口操作类对象
    private SerialPortCom3Utils serialPortCom3;

    EnvTemHumServiceImpl() {
        // 实例化串口操作类对象
        serialPortCom3 = new SerialPortCom3Utils();

        // 初始化设置,打开串口，开始监听读取串口数据
        try {
            // 创建串口必要参数接收类并赋值，赋值串口号，波特率，校验位，数据位，停止位
            serialPortCom3.init(new ParamConfig(SerialTemHumConst.COMM_PORT_COM3, SerialTemHumConst.BAUD_RATE,
                    SerialTemHumConst.PARITY, SerialTemHumConst.DATA_BITS, SerialTemHumConst.STOP_BITS));
        } catch (Exception e) {
            e.printStackTrace();
            serialPortCom3.closeSerialPort();
        }
    }

    /**
     * 查询环境数据（温度、湿度、液位、CO2），保存到数据库中
     */
    @Override
    public void searchTemHumData() {
        try {
            // 下发取数指令
            serialPortCom3.sendComm(SerialTemHumConst.READ_ENV_COMMAND);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 解析环境数据（温度、湿度、液位、CO2），保存到数据库中
     */
    @Override
    public void insertTemHumData(String dataHex, String monitor_id) {
        // 插入数据列表
        List<Map<String, Object>> temHumList = new ArrayList<Map<String, Object>>();
        // 每次调度插入数据库的时间要一样的
        String add_time = DateUtils.getCurrDateTimeStamp();
        String AddTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(Long.valueOf(add_time) * 1000));
        // 温度
        Map<String, Object> temHumMap = new HashMap<String, Object>();
        temHumMap.put("monitor_id", monitor_id);
        temHumMap.put("value_type", 1); // 温度
        temHumMap.put("d_value",
                ConvertWendu(ConvertElectricCurrent(ConvertDataUtils.hexToDec(dataHex.substring(10, 12)))));
        temHumMap.put("add_time", add_time);
        temHumMap.put("AddTime", AddTime);
        temHumList.add(temHumMap);

        if (temHumList != null && temHumList.size() > 0) {
            //插入环境数据
            envoneMapper.insertEnvData(temHumList);
        }
    }

    /**
     * 电流转换
     * @param dbValue
     */
    private static double ConvertElectricCurrent(int dbValue) {
        return (((double) dbValue / 32768) * 4.096) / 150;
    }

    /**
     * 温度
     * @param dbValue
     */
    private static double ConvertWendu(double dbValue) {
        return (dbValue * 1000) * 6.25 - 45;
    }

    /**
     * 湿度
     * @param dbValue
     */
    private static double ConvertShidu(double dbValue) {
        return (dbValue * 1000) * 6.25 - 25;
    }

    /**
     * 液位
     * @param dbValue
     */
    private static double ConvertLevel(double dbValue) {
        return (dbValue * 1000) * 0.3125 - 1.35;
    }

    /**
     * CO2
     * @param dbValue
     */
    private static double ConvertCarbonDioxide(double dbValue) {
        return (dbValue * 1000) * 125 - 500;
    }
}

5、使用注解定时调度发送指令

    /**
     * 定时查询环境数据（温度），保存到数据库中(十分钟调度一次)
     */
    @Scheduled(initialDelay = 600000, fixedRate = 600000)
    public void searchTemHumData() {
        logger.info("####定时查询环境数据(温度) - 定时任务执行时间："+ dateFormat.format(new Date()));
        envTemHumService.searchTemHumData();
    }

OK，以上是全部代码，拒绝代码上传不全的情况发生。