devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java实现R485串口通信和数据解析_java rs485

作者：羊村懒王 | 2024-03-27 18:30:16

赞

踩

java rs485

在对接之前，首先安装基础环境

一、安装基础环境，软件包地址

链接：https://pan.baidu.com/s/11VPQij60af8nFxwUErsnGA?pwd=5jm8 
提取码：5jm8

二、实现

1、pom.xml文件引入

  1. <dependency>
  2.     <groupId>org.rxtx</groupId>
  3.     <artifactId>rxtx</artifactId>
  4.     <version>2.1.7</version>
  5. </dependency>

2、创建监听类 MyLister.clss

  1. package com.example.springboot.util;
  2.  
  3. /**
  4.  * Demo class
  5.  *
  6.  * @author XDRS
  7.  * @date 2023/3/30 16:01
  8.  */
  9.  
  10. import gnu.io.SerialPortEvent;
  11. import gnu.io.SerialPortEventListener;
  12. import net.sf.json.JSONObject;
  13. import java.math.BigDecimal;
  14. import java.nio.ByteBuffer;
  15. import java.nio.charset.StandardCharsets;
  16. import java.util.Date;
  17.  
  18. public class MyLister implements SerialPortEventListener {
  19.  
  20.     @Override
  21.     public void serialEvent(SerialPortEvent arg0) {
  22.         try {
  23.             if (arg0.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
  24.                 SerialPortUtil serialPortUtil = SerialPortUtil.getSerialPortUtil();
  25.                 byte[] bytes = serialPortUtil.readFromPort(PortInit.serialPort);
  26.                 String needData = printHexString(bytes);
  27.                 boolean b = needData.contains("01 03");
  28.                 String[] strings = needData.split(" ");
  29.                 int xxxx = Integer.parseInt(strings[0] + "", 16);
  30.                 if (xxxx == 1 && b) {
  31.                     System.out.println(new Date() + "【字节数组转16进制字符串】：-----" + needData);
  32.                     int xss = Integer.parseInt(strings[4] + "", 16);
  33.                     double value = BigDecimal.valueOf(xss).divide(BigDecimal.valueOf(10)).setScale(1, BigDecimal.ROUND_DOWN).doubleValue();
  34.                     System.out.println(new Date() + "水位：-----" + value + "℃");
  35.                     int yss = Integer.parseInt(strings[6] + "", 16);
  36.                     double value2 = BigDecimal.valueOf(yss).setScale(1, BigDecimal.ROUND_DOWN).doubleValue();
  37.                     System.out.println(new Date() + "水位：-----" + value2 + "mm");
  38.                     // 写入数据库，按照api方式发送指定服务上
  39.                     String url = "http://192.168.0.17:8888/api/geological/demo/insert";
  40.                     JSONObject object = new JSONObject();
  41.                     object.put("instrumentName", "水位计");
  42.                     object.put("value", needData);
  43.                     object.put("instrumentUid", 1);
  44.                     object.put("analyseValue", value2);
  45.                     object.put("type", "普通采集");
  46.                     String toString = object.toString();
  47.                     String post = CommonUtil.doHttpPost(url, toString);
  48.                     if (post.equals("0")) {
  49.                         System.out.println("传输数据失败");
  50.                     } else {
  51.                         System.out.println("传输数据成功");
  52.                     }
  53.                 }
  54.             }
  55.         } catch (Exception e) {
  56.             e.printStackTrace();
  57.         }
  58.  
  59.  
  60.     }
  61.  
  62.     /**
  63.      * 字节数组转16进制字符串
  64.      *
  65.      * @param b 字节数组
  66.      * @return 16进制字符串
  67.      */
  68.     public static String printHexString(byte[] b) {
  69.         StringBuilder sbf = new StringBuilder();
  70.         for (byte value : b) {
  71.             String hex = Integer.toHexString(value & 0xFF);
  72.             if (hex.length() == 1) {
  73.                 hex = '0' + hex;
  74.             }
  75.             sbf.append(hex.toUpperCase()).append(" ");
  76.         }
  77.         return sbf.toString().trim();
  78.     }
  79.  
  80.     /**
  81.      * 十六进制字符串转byte[]
  82.      *
  83.      * @param hex 十六进制字符串
  84.      * @return byte[]
  85.      */
  86.     public static byte[] hexStr2Byte(String hex) {
  87.         if (hex == null) {
  88.             return new byte[]{};
  89.         }
  90.  
  91.         // 奇数位补0
  92. //        if (hex.length() % StaticConstant.TWO != 0) {
  93. //            hex = "0" + hex;
  94. //        }
  95.  
  96.         int length = hex.length();
  97.         ByteBuffer buffer = ByteBuffer.allocate(length / 2);
  98.         for (int i = 0; i < length; i++) {
  99.             String hexStr = hex.charAt(i) + "";
  100.             i++;
  101.             hexStr += hex.charAt(i);
  102.             byte b = (byte) Integer.parseInt(hexStr, 16);
  103.             buffer.put(b);
  104.         }
  105.         return buffer.array();
  106.     }
  107.  
  108.     /**
  109.      * 16进制转换成为string类型字符串
  110.      *
  111.      * @param s 待转换字符串
  112.      */
  113.     public static String hexStringToString(String s) {
  114.         if (s == null || "".equals(s)) {
  115.             return null;
  116.         }
  117.         s = s.replace(" ", "");
  118.         byte[] baKeyword = new byte[s.length() / 2];
  119.         for (int i = 0; i < baKeyword.length; i++) {
  120.             try {
  121.                 baKeyword[i] = (byte) (0xff & Integer.parseInt(s.substring(i * 2, i * 2 + 2), 16));
  122.             } catch (Exception e) {
  123.                 e.printStackTrace();
  124.             }
  125.         }
  126.         try {
  127.             s = new String(baKeyword, StandardCharsets.UTF_8);
  128.         } catch (Exception e1) {
  129.             e1.printStackTrace();
  130.         }
  131.         return s;
  132.     }
  133.  
  134. }

2、创建 PortInit.class

  1. package com.example.springboot.util;
  2. import gnu.io.SerialPort;
  3. import org.springframework.boot.ApplicationArguments;
  4. import org.springframework.boot.ApplicationRunner;
  5. import org.springframework.stereotype.Component;
  6.  
  7. import java.util.ArrayList;
  8.  
  9.  
  10. /**
  11.  * Demo class
  12.  *
  13.  * @author XDRS
  14.  * @date 2023/3/30 16:01
  15.  */
  16. @Component
  17. public class PortInit implements ApplicationRunner{
  18.  
  19.     public static SerialPort serialPort = null;
  20.  
  21.  
  22.     @Override
  23.     public void run(ApplicationArguments args) {
  24.         String portName = "COM1";
  25.         //TestA();
  26.         //查看所有串口
  27.         SerialPortUtil serialPortUtil = SerialPortUtil.getSerialPortUtil();
  28.         ArrayList<String> port = serialPortUtil.findPort();
  29.         System.out.println("发现全部串口：" + port);
  30.  
  31.         System.out.println("portName:" + portName);
  32.         //打开该对应portName名字的串口
  33.         PortInit.serialPort = serialPortUtil.openPort(portName, 9600, SerialPort.DATABITS_8, SerialPort.PARITY_NONE, SerialPort.PARITY_ODD);
  34.  
  35.         // 给对应的serialPort添加监听器
  36.         serialPortUtil.addListener(PortInit.serialPort, new MyLister());
  37.  
  38.     }
  39.  
  40. }

3、创建 SerialPortUtil.class

  1. package com.example.springboot.util;
  2.  
  3. import gnu.io.*;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6.  
  7. import java.io.IOException;
  8. import java.io.InputStream;
  9. import java.io.OutputStream;
  10. import java.util.ArrayList;
  11. import java.util.Enumeration;
  12. import java.util.TooManyListenersException;
  13.  
  14. /**
  15.  * Demo class
  16.  *
  17.  * @author XDRS
  18.  * @date 2023/3/30 16:00
  19.  */
  20. public class SerialPortUtil {
  21.  
  22.     private static final Logger logger = LoggerFactory.getLogger(SerialPortUtil.class);
  23.  
  24.     private static SerialPortUtil serialPortUtil = null;
  25.  
  26.     static {
  27.         // 在该类被ClassLoader加载时就初始化一个SerialTool对象
  28.         if (serialPortUtil == null) {
  29.             serialPortUtil = new SerialPortUtil();
  30.         }
  31.     }
  32.  
  33.     // 私有化SerialTool类的构造方法，不允许其他类生成SerialTool对象
  34.     private SerialPortUtil() {
  35.     }
  36.  
  37.     /**
  38.      * 获取提供服务的SerialTool对象
  39.      *
  40.      * @return serialPortUtil
  41.      */
  42.     public static SerialPortUtil getSerialPortUtil() {
  43.         if (serialPortUtil == null) {
  44.             serialPortUtil = new SerialPortUtil();
  45.         }
  46.         return serialPortUtil;
  47.     }
  48.  
  49.     /**
  50.      * 查找所有可用端口
  51.      *
  52.      * @return 可用端口名称列表
  53.      */
  54.     public ArrayList<String> findPort() {
  55.         //获得当前所有可用串口
  56.         Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();
  57.         ArrayList<String> portNameList = new ArrayList<>();
  58.         //将可用串口名添加到List并返回该List
  59.         while (portList.hasMoreElements()) {
  60.             String portName = portList.nextElement().getName();
  61.             portNameList.add(portName);
  62.         }
  63.         return portNameList;
  64.     }
  65.  
  66.     /**
  67.      * 打开串口
  68.      *
  69.      * @param portName 端口名称
  70.      * @param baudrate 波特率  19200
  71.      * @param databits 数据位  8
  72.      * @param parity   校验位（奇偶位）  NONE ：0
  73.      * @param stopbits 停止位 1
  74.      * @return 串口对象
  75.      * //     * @throws SerialPortParameterFailure 设置串口参数失败
  76.      * //     * @throws NotASerialPort             端口指向设备不是串口类型
  77.      * //     * @throws NoSuchPort                 没有该端口对应的串口设备
  78.      * //     * @throws PortInUse                  端口已被占用
  79.      */
  80.     public SerialPort openPort(String portName, int baudrate, int databits, int parity, int stopbits) {
  81.         try {
  82.             //通过端口名识别端口
  83.             CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
  84.  
  85.             //打开端口，并给端口名字和一个timeout（打开操作的超时时间）
  86.             CommPort commPort = portIdentifier.open(portName, 2000);
  87.  
  88.             //判断是不是串口
  89.             if (commPort instanceof SerialPort) {
  90.  
  91.                 SerialPort serialPort = (SerialPort) commPort;
  92.                 try {
  93.                     //设置一下串口的波特率等参数
  94.                     serialPort.setSerialPortParams(baudrate, databits, stopbits, parity);
  95.                 } catch (UnsupportedCommOperationException e) {
  96.                 }
  97.                 System.out.println("Open " + portName + " sucessfully !");
  98.  
  99.                 return serialPort;
  100.             } else {
  101.                 logger.error("不是串口");
  102.             }
  103.         } catch (NoSuchPortException e1) {
  104.             logger.error("没有找到端口");
  105.             e1.printStackTrace();
  106.         } catch (PortInUseException e2) {
  107.             logger.error("端口被占用");
  108.             e2.printStackTrace();
  109.         }
  110.         return null;
  111.     }
  112.  
  113.     /**
  114.      * 关闭串口
  115.      *
  116.      * @param serialPort 待关闭的串口对象
  117.      */
  118.     public void closePort(SerialPort serialPort) {
  119.         if (serialPort != null) {
  120.             serialPort.close();
  121.         }
  122.     }
  123.  
  124.     /**
  125.      * 往串口发送数据
  126.      *
  127.      * @param serialPort 串口对象
  128.      * @param order      待发送数据
  129.      *                   //       * @throws SendDataToSerialPortFailure        向串口发送数据失败
  130.      *                   //       * @throws SerialPortOutputStreamCloseFailure 关闭串口对象的输出流出错
  131.      */
  132.     public void sendToPort(SerialPort serialPort, byte[] order) {
  133.         OutputStream out = null;
  134.         try {
  135.             out = serialPort.getOutputStream();
  136.             out.write(order);
  137.             out.flush();
  138.         } catch (IOException e) {
  139.             e.printStackTrace();
  140.         } finally {
  141.             try {
  142.                 if (out != null) {
  143.                     out.close();
  144.                 }
  145.             } catch (IOException e) {
  146.                 e.printStackTrace();
  147.             }
  148.         }
  149.     }
  150.  
  151.     /**
  152.      * 从串口读取数据
  153.      *
  154.      * @param serialPort 当前已建立连接的SerialPort对象
  155.      * @return 读取到的数据
  156.      * //     * @throws ReadDataFromSerialPortFailure     从串口读取数据时出错
  157.      * //     * @throws SerialPortInputStreamCloseFailure 关闭串口对象输入流出错
  158.      */
  159.     public byte[] readFromPort(SerialPort serialPort) {
  160.  
  161.         InputStream in = null;
  162.         byte[] bytes = null;
  163.  
  164.         try {
  165.             in = serialPort.getInputStream();
  166.             int bufflenth = in.available();
  167.  
  168.             while (bufflenth != 0) {
  169.                 bytes = new byte[bufflenth];
  170.                 in.read(bytes);
  171.                 bufflenth = in.available();
  172.             }
  173.         } catch (IOException e) {
  174.             e.printStackTrace();
  175.         } finally {
  176.             try {
  177.                 if (in != null) {
  178.                     in.close();
  179.                 }
  180.             } catch (IOException e) {
  181.                 e.printStackTrace();
  182.             }
  183.         }
  184.         return bytes;
  185.     }
  186.  
  187.  
  188.     /**
  189.      * 添加监听器
  190.      *
  191.      * @param port     串口对象
  192.      * @param listener 串口监听器
  193.      *                 //     * @throws TooManyListeners 监听类对象过多
  194.      */
  195.     public void addListener(SerialPort port, SerialPortEventListener listener) {
  196.  
  197.         try {
  198.             //给串口添加监听器
  199.             port.addEventListener(listener);
  200.             //设置当有数据到达时唤醒监听接收线程
  201.             port.notifyOnDataAvailable(true);
  202.             //设置当通信中断时唤醒中断线程
  203.             port.notifyOnBreakInterrupt(true);
  204.         } catch (TooManyListenersException e) {
  205. //            throw new TooManyListeners();
  206.             logger.error("太多监听器");
  207.             e.printStackTrace();
  208.         }
  209.     }
  210.  
  211.     /**
  212.      * 删除监听器
  213.      *
  214.      * @param port     串口对象
  215.      * @param listener 串口监听器
  216.      *                 //     * @throws TooManyListeners 监听类对象过多
  217.      */
  218.     public void removeListener(SerialPort port, SerialPortEventListener listener) {
  219.         //删除串口监听器
  220.         port.removeEventListener();
  221.     }
  222.  
  223.     /**
  224.      * 设置串口的Listener
  225.      *
  226.      * @param serialPort
  227.      * @param listener
  228.      * @author mar
  229.      * @date 2021/8/20 11:04
  230.      */
  231.     public static void setListenerToSerialPort(SerialPort serialPort, SerialPortEventListener listener) {
  232.         try {
  233.             //给串口添加事件监听
  234.             serialPort.addEventListener(listener);
  235.         } catch (TooManyListenersException e) {
  236.             e.printStackTrace();
  237.         }
  238.         //串口有数据监听
  239.         serialPort.notifyOnDataAvailable(true);
  240.         //中断事件监听
  241.         serialPort.notifyOnBreakInterrupt(true);
  242.     }
  243. }

4、创建 CommonUtil.class

  1. package com.example.springboot.util;
  2. import net.sf.json.JSONObject;
  3. import org.apache.commons.io.IOUtils;
  4.  
  5. import java.io.BufferedReader;
  6. import java.io.DataInputStream;
  7. import java.io.DataOutputStream;
  8. import java.io.InputStream;
  9. import java.io.InputStreamReader;
  10. import java.io.OutputStream;
  11. import java.net.ConnectException;
  12. import java.net.HttpURLConnection;
  13. import java.net.URL;
  14. import java.net.URLConnection;
  15. import java.util.List;
  16. import java.util.Map;
  17.  
  18. import javax.net.ssl.HttpsURLConnection;
  19. import javax.net.ssl.SSLContext;
  20. import javax.net.ssl.SSLSocketFactory;
  21. import javax.net.ssl.TrustManager;
  22.  
  23. public class CommonUtil {
  24.  
  25.     /**
  26.      * TODO 获取http访问后的json串
  27.      * @param urlPath
  28.      * @return
  29.      */
  30.     public static String getJSONContent(String urlPath) {
  31.         String jsonString = "";
  32.         // 访问路径
  33.         try {
  34.             // 创建HTTP连接
  35.             URL url = new URL(urlPath);
  36.             HttpURLConnection connection = (HttpURLConnection) url
  37.                     .openConnection();
  38.             // 设置连接超时时间
  39.             connection.setConnectTimeout(5000);
  40.             connection.setRequestMethod("GET");
  41.             connection.setDoInput(true);
  42.             // 获取相应代码，判断是否响应结束
  43.             int code = connection.getResponseCode();
  44.             if (code == 200) {
  45.                 InputStream is = connection.getInputStream();
  46.                 DataInputStream indata = new DataInputStream(is);
  47.                 String ret = "";
  48.  
  49.                 while (ret != null) {
  50.                     ret = indata.readLine();
  51.                     if (ret != null && !ret.trim().equals("")) {
  52.                         jsonString = jsonString
  53.                                 + new String(ret.getBytes("ISO-8859-1"), "UTF-8");
  54.                     }
  55.                 }
  56.                 connection.disconnect();
  57.             }
  58.         } catch (Exception e) {
  59.             e.printStackTrace();
  60.         }
  61.         return jsonString;
  62.     }
  63.  
  64.     /**
  65.      * 发送Http post请求
  66.      *
  67.      * @param xmlInfo
  68.      *            json转化成的字符串
  69.      * @param URL
  70.      *            请求url
  71.      * @return 返回信息
  72.      */
  73.     public static String doHttpPost(String URL,String xmlInfo ) {
  74.         System.out.println("发起的数据:" + xmlInfo);
  75.         byte[] xmlData = xmlInfo.getBytes();
  76.         InputStream instr = null;
  77.         try {
  78.             URL url = new URL(URL);
  79.             URLConnection urlCon = url.openConnection();
  80.             urlCon.setDoOutput(true);
  81.             urlCon.setDoInput(true);
  82.             urlCon.setUseCaches(false);
  83.             urlCon.setRequestProperty("content-Type", "application/json");
  84.             urlCon.setRequestProperty("charset", "utf-8");
  85.             urlCon.setRequestProperty("Content-length",
  86.                     String.valueOf(xmlData.length));
  87.             System.out.println(String.valueOf(xmlData.length));
  88.             DataOutputStream printout = new DataOutputStream(
  89.                     urlCon.getOutputStream());
  90.             printout.write(xmlData);
  91.             printout.flush();
  92.             printout.close();
  93.             instr = urlCon.getInputStream();
  94.             byte[] bis = IOUtils.toByteArray(instr);
  95.             String ResponseString = new String(bis, "UTF-8");
  96.             if ((ResponseString == null) || ("".equals(ResponseString.trim()))) {
  97.                 System.out.println("返回空");
  98.             }
  99.             System.out.println("返回数据为:" + ResponseString);
  100.             return ResponseString;
  101.  
  102.         } catch (Exception e) {
  103.             e.printStackTrace();
  104.             return "0";
  105.         } finally {
  106.             try {
  107.                 instr.close();
  108.  
  109.             } catch (Exception ex) {
  110.                 ex.printStackTrace();
  111.                 return "0";
  112.             }
  113.         }
  114.     }
  115.  
  116.     /**
  117.      * 向指定URL发送GET方法的请求
  118.      *
  119.      * @param url
  120.      *            发送请求的URL
  121.      * @param param
  122.      *            请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
  123.      * @return URL 所代表远程资源的响应结果
  124.      */
  125.     public static String sendGet(String url, String param) {
  126.         String result = "";
  127.         BufferedReader in = null;
  128.         try {
  129.             String urlNameString = url + "?" + param;
  130.             URL realUrl = new URL(urlNameString);
  131.  
  132.             // 打开和URL之间的连接
  133.             URLConnection connection = realUrl.openConnection();
  134.             // 设置通用的请求属性
  135.             connection.setRequestProperty("accept", "*/*");
  136.             connection.setRequestProperty("connection", "Keep-Alive");
  137.             connection.setRequestProperty("Accept-Charset", "utf-8");
  138.             connection.setRequestProperty("contentType", "utf-8");
  139.             connection.setRequestProperty("user-agent",
  140.                     "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
  141.             // 建立实际的连接
  142.             connection.connect();
  143.             // 获取所有响应头字段
  144.             Map<String, List<String>> map = connection.getHeaderFields();
  145.             // 遍历所有的响应头字段
  146.             for (String key : map.keySet()) {
  147.                 System.out.println(key + "--->" + map.get(key));
  148.             }
  149.             // 定义 BufferedReader输入流来读取URL的响应
  150.             in = new BufferedReader(new InputStreamReader(
  151.                     connection.getInputStream()));
  152.             String line;
  153.             while ((line = in.readLine()) != null) {
  154.                 result += line;
  155.             }
  156.         } catch (Exception e) {
  157.             System.out.println("发送GET请求出现异常！" + e);
  158.             e.printStackTrace();
  159.         }
  160.         // 使用finally块来关闭输入流
  161.         finally {
  162.             try {
  163.                 if (in != null) {
  164.                     in.close();
  165.                 }
  166.             } catch (Exception e2) {
  167.                 e2.printStackTrace();
  168.             }
  169.         }
  170.         return result;
  171.     }
  172.  
  173.     public static JSONObject sendGet(String url) {
  174.         JSONObject jsonObject = null;
  175.         BufferedReader in = null;
  176.  
  177.         try {
  178.             URL url2 = new URL(url);
  179.             // 打开和URL之间的连接
  180.             URLConnection connection = url2.openConnection();
  181.             // 设置通用的请求属性
  182.             connection.setRequestProperty("accept", "*/*");
  183.             connection.setRequestProperty("connection", "Keep-Alive");
  184.             connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
  185.             connection.setConnectTimeout(5000);
  186.             connection.setReadTimeout(5000);
  187.             // 建立实际的连接
  188.             connection.connect();
  189.             // 定义 BufferedReader输入流来读取URL的响应
  190.             in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
  191.             StringBuffer sb = new StringBuffer();
  192.             String line;
  193.             while ((line = in.readLine()) != null) {
  194.                 sb.append(line);
  195.             }
  196.             //jsonObject = new JSONObject(sb.toString());
  197.             jsonObject = new JSONObject().fromObject(sb);
  198.             return jsonObject;
  199.  
  200.         } catch (Exception e) {
  201.             e.printStackTrace();
  202.         }
  203.  
  204.         // 使用finally块来关闭输入流
  205.         finally {
  206.             try {
  207.                 if (in != null) {
  208.                     in.close();
  209.                 }
  210.             } catch (Exception e2) {
  211.                 e2.printStackTrace();
  212.             }
  213.         }
  214.  
  215.         return null;
  216.     }
  217. }

5、创建demo.class

  1. package com.example.springboot.controller;
  2.  
  3. import com.example.springboot.util.PortInit;
  4. import com.example.springboot.util.SerialPortUtil;
  5. import gnu.io.SerialPort;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.scheduling.annotation.Scheduled;
  8. import org.springframework.web.bind.annotation.GetMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  10.  
  11. import java.nio.ByteBuffer;
  12.  
  13. /**
  14.  * Demo class
  15.  *
  16.  * @author XDRS
  17.  * @date 2023/3/30 15:50
  18.  */
  19. @RestController
  20. public class Demo {
  21.  
  22.  
  23.     @GetMapping
  24.     public void test() {
  25.         SerialPortUtil serialPortUtil = SerialPortUtil.getSerialPortUtil();
  26.         byte[] HEX = hexStr2Byte("000300040002841B");
  27.         serialPortUtil.sendToPort(PortInit.serialPort, HEX);
  28.         System.out.println(111111111);
  29.     }
  30.  
  31.     /**
  32.      * 定时任务，间隔5分钟采集一次数据
  33.      */
  34.     @Scheduled(cron = "0 0/5 * * * ?")
  35.     public void send() {
  36.         System.out.println("send ok");
  37.         SerialPortUtil serialPortUtil = SerialPortUtil.getSerialPortUtil();
  38.         byte[] HEX = hexStr2Byte("000300040002841B");
  39.         serialPortUtil.sendToPort(PortInit.serialPort, HEX);
  40.  
  41.     }
  42.     /**
  43.      * 十六进制字符串转byte[]
  44.      *
  45.      * @param hex 十六进制字符串
  46.      * @return byte[]
  47.      */
  48.     public static byte[] hexStr2Byte(String hex) {
  49.         if (hex == null) {
  50.             return new byte[]{};
  51.         }
  52.  
  53.         // 奇数位补0
  54.         if (hex.length() % 2 != 0) {
  55.             hex = "0" + hex;
  56.         }
  57.  
  58.         int length = hex.length();
  59.         ByteBuffer buffer = ByteBuffer.allocate(length / 2);
  60.         for (int i = 0; i < length; i++) {
  61.             String hexStr = hex.charAt(i) + "";
  62.             i++;
  63.             hexStr += hex.charAt(i);
  64.             byte b = (byte) Integer.parseInt(hexStr, 16);
  65.             buffer.put(b);
  66.         }
  67.         return buffer.array();
  68.     }
  69. }

6、开启@EnableScheduling注解

 7、最后

  1. @SpringBootApplication
  2. @EnableScheduling
  3. public class SpringbootApplication {
  4.  
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(SpringbootApplication.class, args);
  7.     }
  8.  
  9.     @PreDestroy
  10.     public void destory() {
  11.         //关闭应用前 关闭端口
  12.         SerialPortUtil serialPortUtil = SerialPortUtil.getSerialPortUtil();
  13.         serialPortUtil.removeListener(PortInit.serialPort, new MyLister());
  14.         serialPortUtil.closePort(PortInit.serialPort);
  15.  
  16.     }
  17.  
  18. }

以上完结，希望大家多多提出宝贵意见，一起完善，感谢~！！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/326206
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号