使用串口设备在两台服务器间传输数据

之前的项目用的是mqtt的方式在两台服务器之间传输数据，现在由于业务要求，两台服务器之间无法直接进行通信，所以采购了一个串口设备，将之前的mqtt发送数据的方式改成串口之间传输。项目是做定位的，对实时性要求比较高。

1.引入pom依赖，刚开始使用的是rxtx包，但是这个依赖加载后还需要两个dll文件，后来换成了purejavacomm，作用是一样的，代码都不用变动。

        <!--调用串口发送数据-->
<!--        <dependency>
            <groupId>org.rxtx</groupId>
            <artifactId>rxtx</artifactId>
            <version>2.1.7</version>
        </dependency>-->
        <dependency>
            <groupId>com.github.purejavacomm</groupId>
            <artifactId>purejavacomm</artifactId>
            <version>1.0.1.RELEASE</version>
        </dependency>

2.数据发送的一个工具类，操作流程打开串口，发送数据，关闭串口，因为业务原因可以调整串口一直打开不关闭

@Slf4j
@Component
public class CommunicationUtils {

    public static void send(byte[] instruct, String comNo) {
        SerialPort mSerialport = null;
        try {
            //打开串口
            mSerialport = openPort(comNo, 2000000);
            // 发送数据
            sendToPort(mSerialport, instruct);
            //关闭串口 
            SerialPortManager.closePort(mSerialport);
        } catch (PortInUseException e) {
            log.error("串口:" + comNo + " 打开异常");
            log.error(e.getMessage());
        }
        System.out.println("*****************");

    }


    /**
     * 查找所有可用端口
     * @return 可用端口名称列表
     */
    public static final List<String> findPorts() {
        // 获得所有可用的串口设备
        Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();
        List<String> portNameList = new ArrayList<String>();
        // 将可用串口添加到List并返回
        while (portList.hasMoreElements()) {
            String portName = portList.nextElement().getName();
            portNameList.add(portName);
        }
        return portNameList;
    }

    /**
     * 打开串口
     * @param portName 端口名称
     * @param baudrate 波特率
     * @return 串口对象
     */
    public static final SerialPort openPort(String portName, int baudrate) throws PortInUseException {
        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, SerialPort.DATABITS_8, SerialPort.STOPBITS_1,
                            SerialPort.PARITY_NONE);
                } catch (UnsupportedCommOperationException e) {
                    e.printStackTrace();
                }
                return serialPort;
            }
        } catch (NoSuchPortException e1) {
            e1.printStackTrace();
        }
        return null;
    }

    /**
     * 关闭串口
     *
     * @param
     *
     */
    public static void closePort(SerialPort serialPort) {
        if (serialPort != null) {
            serialPort.close();
        }
    }

    /**
     * 往串口发送数据
     *
     * @param serialPort 串口对象
     * @param order 待发送数据
     */
    public static 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();
                    out = null;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }



}

3.字符串压缩工具类，数据量大的情况下通过串口发送数据，上位机接收的时候是一段一段的，正好通过解压缩的操作传过去，避免了上位机再去等待接收数据流 

public class ZipStrUtil {

    /**
     * 字符串的压缩
     * @param str 待压缩的字符串
     * @return    返回压缩后的byte[]
     * @throws IOException
     */
      public static byte[] compress(String str) throws IOException {
          ByteArrayOutputStream out = new ByteArrayOutputStream();
          DeflaterOutputStream gzip = new DeflaterOutputStream(out);
          gzip.write(str.getBytes());
          gzip.close();
          return out.toByteArray();
      }


      /**
     * 字符串的解压
     * @param compressed 对byte[]解压
     * @return    返回解压缩后的字符串
     * @throws IOException
     */

      public static String decompress(byte[] compressed) throws IOException {
          ByteArrayInputStream in = new ByteArrayInputStream(compressed);
          InflaterInputStream inflater = new InflaterInputStream(in);
          ByteArrayOutputStream out = new ByteArrayOutputStream();
          byte[] buffer = new byte[1024];
          int len;
          while ((len = inflater.read(buffer)) > 0) {
              out.write(buffer, 0, len);
          }
          out.close();
          return out.toString();
      }


  }

4.上位机代码 同样的先导入依赖，还有解压缩的工具类。以下是接收读取串口数据代码

@Component
public class SerialPortUtils implements SerialPortEventListener {
    // 检测系统中可用的通讯端口类
    private CommPortIdentifier commPortId;
    // 枚举类型
    private Enumeration<CommPortIdentifier> portList;
    // RS232串口
    private SerialPort serialPort;
    // 输入流
    private InputStream inputStream;
    // 输出流
    private OutputStream outputStream;
    // 保存串口返回信息
    private String data;
    // 保存串口返回信息十六进制
    private String dataHex;

    /**
     * 初始化串口
     *
     * @throws
     * @Author yyj
     * @param: paramConfig  存放串口连接必要参数的对象（会在下方给出类代码）
     * @return: void
     */
    @SuppressWarnings("unchecked")
    public void init( ) {
        // 获取系统中所有的通讯端口
        portList = CommPortIdentifier.getPortIdentifiers();
        // 记录是否含有指定串口
        boolean isExsist = false;
        // 循环通讯端口
        while (portList.hasMoreElements()) {
            commPortId = portList.nextElement();
            // 判断是否是串口
            if (commPortId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
                // 比较串口名称是否是指定串口
                if ("COM6".equals(commPortId.getName())) {
                    // 串口存在
                    isExsist = true;
                    // 打开串口
                    try {
                        // open:（应用程序名【随意命名】，阻塞时等待的毫秒数）
                        serialPort = (SerialPort) commPortId.open(Object.class.getSimpleName(), 2000);
                        // 设置串口监听
                        serialPort.addEventListener(this);
                        // 设置串口数据时间有效(可监听)
                        serialPort.notifyOnDataAvailable(true);
                        // 设置串口通讯参数:波特率，数据位，停止位,校验方式
                        serialPort.setSerialPortParams(2000000, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
                        serialPort.setOutputBufferSize(8192);
                        // 设置串口读缓冲区大小
                        serialPort.setInputBufferSize(8192);
                    } catch (PortInUseException e) {
                        e.printStackTrace();
                    } catch (TooManyListenersException e) {
                        e.printStackTrace();
                    } catch (UnsupportedCommOperationException e) {
                        e.printStackTrace();
                    }
                    // 结束循环
                    break;
                }
            }
        }
        // 若不存在该串口则抛出异常
        if (!isExsist) {
            new NoSuchPortException();

        }
    }

    /**
     * 实现接口SerialPortEventListener中的方法 读取从串口中接收的数据
     */
    @Override
    public void serialEvent(SerialPortEvent event) {
        switch (event.getEventType()) {
            case SerialPortEvent.BI: // 通讯中断
                System.out.println("event = 通讯中断");
                break;
            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;
        }
    }

    /**
     * 读取串口返回信息
     *
     * @author Jarvis
     * @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) {
                //获取串口返回数据
                System.out.println("解压后：++++++++++++++"+ ZipStrUtil.decompress(readBuffer));
                inputStream.close();
                inputStream = null;
                break;
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 关闭串口
     *
     * @throws
     * @author Jarvis
     * @Description: 关闭串口
     * @param:
     * @return: void
     */
    public void closeSerialPort() {
        if (serialPort != null) {
            serialPort.notifyOnDataAvailable(false);
            serialPort.removeEventListener();
            if (inputStream != null) {
                try {
                    inputStream.close();
                    inputStream = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outputStream != null) {
                try {
                    outputStream.close();
                    outputStream = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            serialPort.close();
            serialPort = null;
        }
    }
}