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

Java使用RXTX进行串口SerialPort通讯_java serialport

作者：繁依Fanyi0 | 2024-03-22 17:22:49

赞

踩

java serialport

RXTX简介 （https://www.jianshu.com/p/cb61f797ffc1

RXTX是一个提供串口和并口通信的开源java类库，由该项目发布的文件均遵循LGPL协议。
RXTX项目提供了Windows,Linux,Mac os X,Solaris操作系统下的兼容javax.comm串口通讯包API的实现，为其他开发人员在此类系统下开发串口应用提供了相当的方便。
RXTX的使用上与sun提供的comm.jar基本相同,编程时最明显的不同是要包含的包名由javax.comm.改成了gnu.io.

RxtxAPI 的核心是抽象的CommPort类(用于描述一个被底层系统支持的端口的抽象类，它包含一些高层的IO控制方法，这些方法对于所有不同的通讯端口来说是通用的)及其两个子类：SerialPort类和ParallePort类。其中，SerialPort类是用于串口通信的类，ParallePort类是用于并行口通信的类。CommPort类还提供了常规的通信模式和方法，例如:getInputStream( )方法和getOutputStream( )方法，专用于与端口上的设备进行通信。
然而，这些类的构造方法都被有意的设置为非公有的(non-public)。所以，不能直接构造对象，而是先通过静态的CommPortIdentifer.getPortIdentifiers()获得端口列表，再从这个端口列表中选择所需要的端口，并调用CommPortIdentifer对象的Open( )方法，这样，就能得到一个CommPort对象。当然，还要将这个CommPort对象的类型转换为某个非抽象的子类，表明是特定的通讯设备，该子类可以是SerialPort类和ParallePort类中的一个。下面将分别对CommPortIdentifier类，串口类SerialPort进行详细的介绍。

 

  1. 接口
  2.  
  3. CommDriver可负载设备（the loadable device）驱动程序接口的一部分
  4.  
  5. CommPortOwnershipListener传递各种通讯端口的所有权事件
  6.  
  7. ParallelPortEventListener传递并行端口事件
  8.  
  9. SerialPortEventListener传递串行端口事件
  10.  
  11. 类
  12.  
  13. CommPort通讯端口
  14.  
  15. CommPortIdentifier通讯端口管理
  16.  
  17. ParallelPort并行通讯端口
  18.  
  19. ParallelPortEvent并行端口事件
  20.  
  21. SerialPortRS-232串行通讯端口
  22.  
  23. SerialPortEvent 串行端口事件
  24.  
  25. 异常类
  26.  
  27. NoSuchPortException当驱动程序不能找到指定端口时抛出
  28.  
  29. PortInUseException当碰到指定端口正在使用中时抛出
  30.  
  31. UnsupportedCommOperationException驱动程序不允许指定操作时抛出
  32.  
  33. CommPortIdentifier类
  34.  
  35. 这个类主要用于对通信端口进行管理和设置，是对端口进行访问控制的核心类，主要包括以下方法：
  36.  
  37. addPortName(String,int, CommDriver) 添加端口名到端口列表里
  38.  
  39. addPortOwnershipListener(CommPortOwnershipListener)添加端口拥有的监听器
  40.  
  41. removePortOwnershipListener(CommPortOwnershipListener)移除端口拥有的监听器
  42.  
  43. getCurrentOwner()获取当前占有端口的对象或应用程序
  44.  
  45. getName()获取端口名称
  46.  
  47. getPortIdentifier(CommPort)获取指定打开的端口的CommPortIdentifier类型对象
  48.  
  49. getPortIdentifier(String)获取以参数命名的端口的CommPortIdentifier类型对象
  50.  
  51. getPortIdentifiers()获取系统中的端口列表
  52.  
  53. getPortType()获取端口的类型
  54.  
  55. isCurrentlyOwned()判断当前端口是否被占用
  56.  
  57. open(FileDescriptor)用文件描述的类型打开端口
  58.  
  59. open(String,int) 打开端口，两个参数：程序名称，延迟时间(毫秒数)
  60.  
  61. SerialPort类
  62.  
  63. 这个类用于描述一个RS-232串行通信端口的底层接口，它定义了串口通信所需的最小功能集。通过它，用户可以直接对串口进行读、写及设置工作。
  64.  
  65. SerialPort类中关于串口参数的静态成员变量说明:
  66.  
  67. DATABITS_5 数据位为5
  68.  
  69. DATABITS_6 数据位为6
  70.  
  71. DATABITS_7 数据位为7
  72.  
  73. DATABITS_8 数据位为8
  74.  
  75. PARITY_NONE 空格检验
  76.  
  77. PARITY_ODD 奇检验
  78.  
  79. PARITY_EVEN 偶检验
  80.  
  81. PARITY_MARK 标记检验
  82.  
  83. PARITY_SPACE 无检验
  84.  
  85. STOPBITS_1 停止位为1
  86.  
  87. STOPBITS_2 停止位为2
  88.  
  89. STOPBITS_1_5 停止位为1.5
  90.  
  91.  
  92.  
  93. SerialPort类中关于串口参数的方法说明:
  94.  
  95. getBaudRate()得到波特率
  96.  
  97. getParity()得到检验类型
  98.  
  99. getDataBits()得到数据位数
  100.  
  101. getStopBits()得到停止位数
  102.  
  103. setSerialPortParams(int,int, int, int) 设置串口参数依次为(波特率,数据位,停止位,奇偶检验)
  104.  
  105. SerialPort类中关于事件的静态成员变量说明：
  106.  
  107. BI Break interrupt 通讯中断
  108.  
  109. FE Framing error 帧错误
  110.  
  111. CD Carrier detect 载波侦听
  112.  
  113. OE Overrun error 溢位错误
  114.  
  115. CTS Clear to send 清除发送
  116.  
  117. PE Parity error 奇偶检验错误
  118.  
  119. DSR Data set ready 数据设备准备好
  120.  
  121. RI Ring indicator 响铃侦测
  122.  
  123. DATA_AVAILABLE 串口中的可用数据
  124.  
  125. OUTPUT_BUFFER_EMPTY 输出缓冲区已清空
  126.  
  127.  
  128.  
  129. SerialPort类中关于事件的方法说明：
  130.  
  131. isCD()是否有载波
  132.  
  133. isCTS()是否清除以传送
  134.  
  135. isDSR()数据是否备妥
  136.  
  137. isDTR()是否数据端备妥
  138.  
  139. isRI()是否响铃侦测
  140.  
  141. isRTS()是否要求传送
  142.  
  143. addEventListener(SerialPortEventListener)向SerialPort对象中添加串口事件监听器
  144.  
  145. removeEventListener()移除SerialPort对象中的串口事件监听器
  146.  
  147. notifyOnBreakInterrupt(boolean)设置中断事件true有效,false无效
  148.  
  149. notifyOnCarrierDetect(boolean)设置载波监听事件true有效,false无效
  150.  
  151. notifyOnCTS(boolean)设置清除发送事件true有效,false无效
  152.  
  153. notifyOnDataAvailable(boolean)设置串口有数据的事件true有效,false无效
  154.  
  155. notifyOnDSR(boolean)设置数据备妥事件true有效,false无效
  156.  
  157. notifyOnFramingError(boolean)设置发生错误事件true有效,false无效
  158.  
  159. notifyOnOutputEmpty(boolean)设置发送缓冲区为空事件true有效,false无效
  160.  
  161. notifyOnParityError(boolean)设置发生奇偶检验错误事件true有效,false无效
  162.  
  163. notifyOnRingIndicator(boolean)设置响铃侦测事件true有效,false无效
  164.  
  165. getEventType()得到发生的事件类型返回值为int型
  166.  
  167. sendBreak(int)设置中断过程的时间，参数为毫秒值
  168.  
  169. setRTS(boolean)设置或清除RTS位
  170.  
  171. setDTR(boolean)设置或清除DTR位
  172.  
  173. SerialPort中的其他常用方法说明：
  174.  
  175. close()关闭串口
  176.  
  177. getOutputStream()得到OutputStream类型的输出流
  178.  
  179. getInputStream()得到InputStream类型的输入流
  180.

准备工作

  • RXTX包：rxtx-2.2pre2-bins.zip
  • 串口虚拟工具：vspd.exe
  • 串口调试工具：amcktszs_v2.4.0.0.exe

安装RXTX包

解压rxtx-2.2pre2-bins.zip，将RXTXcomm.jar加入项目依赖库里，对应操作的系统的rxtxSerial.dll和rxtxParallel.dll文件放入jdk的bin目录下

 

  1. 前提条件：maven已经加入环境变量中
  2. mvn install:install-file -DgroupId=gnu.io -DartifactId=RXTXcomm -Dversion=1.0 -Dpackaging=jar -Dfile=E:\Work\Yotrio\libs\RXTXcomm.jar

工具创建一对虚拟串口

Image.png

打开串口调试工具，配置串口参数

Image [2].png

样例Demo

封装串口读写工具类

 

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

整合websocket获取并推送给前台页面实时显示

 

  1. @ServerEndpoint(value = "/websocket") //接受websocket请求路径
  2. @Component
  3. public class PoundWebSocket {
  4.     private Logger logger = LoggerFactory.getLogger(this.getClass());
  5.  
  6.     /**
  7.      * 保存所有在线socket连接
  8.      */
  9.     private static Map<String, PoundWebSocket> webSocketMap = new LinkedHashMap<>();
  10.  
  11.     /**
  12.      * 记录当前在线数目
  13.      */
  14.     private static int count = 0;
  15.  
  16.     /**
  17.      * 当前连接（每个websocket连入都会创建一个MyWebSocket实例
  18.      */
  19.     private Session session;
  20.  
  21.     /**
  22.      * 创建监听串口
  23.      */
  24.     private static SerialPort serialPort = null;
  25.  
  26.     /**
  27.      * 创建监听器
  28.      */
  29.     private static SerialPortEventListener serialPortEventListener = null;
  30.  
  31.     /**
  32.      * 监听串口
  33.      */
  34.     private static String PORT_NAME;
  35.  
  36.     /**
  37.      * 监听串口波特率
  38.      */
  39.     private static int BAUD_RATE;
  40.  
  41.     /**
  42.      * 数据位
  43.      */
  44.     private static int DATA_BITS;
  45.  
  46.     /**
  47.      * 停止位
  48.      */
  49.     private static int STOP_BITS;
  50.  
  51.     /**
  52.      * 奇偶位
  53.      */
  54.     private static int PARITY;
  55.  
  56.     /**
  57.      * 地磅型号
  58.      */
  59.     private static String MODEL;
  60.  
  61.     private static IPoundInfoService poundInfoService;
  62.  
  63.     private static ApplicationContext applicationContext;
  64.  
  65.     public static void setApplicationContext(ApplicationContext applicationContext) {
  66.         PoundWebSocket.applicationContext = applicationContext;
  67.     }
  68.  
  69.     private static StringBuffer stringBuffer = new StringBuffer();
  70.  
  71.     /**
  72.      * 处理连接建立
  73.      *
  74.      * @param session
  75.      */
  76.     @OnOpen
  77.     public void onOpen(Session session) {
  78.         if (poundInfoService == null) {
  79.             poundInfoService = applicationContext.getBean(IPoundInfoService.class);
  80.         }
  81.         //获取地磅信息
  82.         PoundInfo poundInfo = poundInfoService.findOne();
  83.         PORT_NAME = poundInfo.getSerialPort();
  84.         BAUD_RATE = poundInfo.getBaudRate();
  85.         MODEL = poundInfo.getModel();
  86.         DATA_BITS = poundInfo.getDataBits() != null ? poundInfo.getDataBits() : SerialPort.DATABITS_8;
  87.         STOP_BITS = poundInfo.getStopBits() != null ? poundInfo.getStopBits() : SerialPort.STOPBITS_1;
  88.         PARITY = poundInfo.getParity() != null ? poundInfo.getParity() : SerialPort.PARITY_NONE;
  89.  
  90.         this.session = session;
  91.         webSocketMap.put(session.getId(), this);
  92.         addCount();
  93. //        logger.info("新的连接加入：{}", session.getId());
  94.         try {
  95.             //确保串口已被关闭，未关闭会导致重新监听串口失败
  96.             if (serialPort != null) {
  97.                 SerialPortUtil.closePort(serialPort);
  98.                 serialPort = null;
  99.             }
  100.             //创建串口 COM5位串口名称 9600波特率
  101.             if (serialPort == null && StringUtils.isNotEmpty(PORT_NAME) && StringUtils.isNotEmpty(MODEL)) {
  102.                 serialPort = SerialPortUtil.openPort(PORT_NAME, BAUD_RATE, DATA_BITS, PARITY, STOP_BITS);
  103. //                logger.info("创建串口：{}", serialPort);
  104.                 //设置串口监听
  105.                 SerialPortUtil.addListener(serialPort, new SerialPortEventListener() {
  106.  
  107.                     @Override
  108.                     public void serialEvent(SerialPortEvent serialPortEvent) {
  109.                         if (serialPortEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
  110.                             try {
  111.                                 //读取串口数据
  112.                                 byte[] bytes = SerialPortUtil.readFromPort(serialPort);
  113.  
  114.                                 //根据型号解析字符串
  115.                                 switch (MODEL) {
  116.                                     case PoundConstant.MODEL_XK_3190:
  117.                                         parsingString1(bytes);
  118.                                         break;
  119.                                     case PoundConstant.MODEL_XK_3190_10:
  120.                                         parsingString2(bytes);
  121.                                         break;
  122.                                     case PoundConstant.MODEL_D_2008:
  123.                                         parsingString1(bytes);
  124.                                         break;
  125.                                     case PoundConstant.MODEL_DK_3230_D_6:
  126.                                         parsingString3(bytes);
  127.                                         break;
  128.                                     case PoundConstant.MODEL_D_2009_F:
  129.                                         parsingString4(bytes);
  130.                                         break;
  131.                                     default:
  132.                                         String value = String.valueOf(Integer.valueOf(new String(bytes, "GB2312")) - RandomUtil.randomInt(1000, 10000));
  133.                                         sendMessageToAll(value);
  134.                                 }
  135.  
  136. //                                System.out.println("收到的数据：" + new String(bytes, "GB2312") + "----" + new Date());
  137.  
  138.                             } catch (ReadDataFromSerialPortFailure readDataFromSerialPortFailure) {
  139.                                 logger.error(readDataFromSerialPortFailure.toString());
  140.                             } catch (SerialPortInputStreamCloseFailure serialPortInputStreamCloseFailure) {
  141.                                 logger.error(serialPortInputStreamCloseFailure.toString());
  142.                             } catch (UnsupportedEncodingException e) {
  143.                                 logger.error(e.toString());
  144.                             } catch (IOException e) {
  145.                                 logger.error(e.toString());
  146.                             }
  147.                         }
  148.                     }
  149.                 });
  150.             }
  151.         } catch (SerialPortParameterFailure serialPortParameterFailure) {
  152.             logger.error(serialPortParameterFailure.toString());
  153.         } catch (NotASerialPort notASerialPort) {
  154.             logger.error(notASerialPort.toString());
  155.         } catch (NoSuchPort noSuchPort) {
  156.             logger.error(noSuchPort.toString());
  157.         } catch (PortInUse portInUse) {
  158.             logger.error(portInUse.toString());
  159.         } catch (TooManyListeners tooManyListeners) {
  160.             logger.error(tooManyListeners.toString());
  161.         }
  162.     }
  163.  
  164.     /**
  165.      * 解析字符串 方法1
  166.      *
  167.      * @param bytes 获取的字节码
  168.      */
  169.     private void parsingString1(byte[] bytes) {
  170.         StringBuffer sb = new StringBuffer();
  171.         //将ASCII码转成字符串
  172.         for (int i = 0; i < bytes.length; i++) {
  173.             sb.append((char) Integer.parseInt(String.valueOf(bytes[i])));
  174.         }
  175.  
  176.         //解析字符串
  177.         String[] strs = sb.toString().trim().split("\\+");
  178.         int weight = 0;
  179.         for (int j = 0; j < strs.length; j++) {
  180.             if (strs[j].trim().length() >= 6) {
  181.                 weight = Integer.parseInt(strs[j].trim().substring(0, 6));
  182.                 //发送数据
  183.                 sendMessageToAll(String.valueOf(weight));
  184.                 break;
  185.             }
  186.         }
  187.     }
  188.  
  189.     /**
  190.      * 解析字符串 方法2
  191.      *
  192.      * @param bytes 获取的字节码
  193.      */
  194.     private void parsingString2(byte[] bytes) {
  195.         StringBuffer sb = new StringBuffer();
  196.         //将ASCII码转成字符串
  197.         for (int i = 0; i < bytes.length; i++) {
  198.             sb.append((char) Integer.parseInt(String.valueOf(bytes[i])));
  199.         }
  200.         //解析字符串
  201.         String[] strs = sb.toString().trim().split("\\+");
  202.         double weight = 0;
  203.         for (int j = 0; j < strs.length; j++) {
  204.             if (strs[j].trim().length() >= 6) {
  205.                 weight = Double.parseDouble(strs[j].trim().substring(0, 6)) / 10;
  206.                 //发送数据
  207.                 sendMessageToAll(String.valueOf(weight));
  208.                 break;
  209.             }
  210.         }
  211.     }
  212.  
  213.     /**
  214.      * 解析字符串 方法3
  215.      *
  216.      * @param bytes 获取的字节码
  217.      */
  218.     private void parsingString3(byte[] bytes) {
  219.         StringBuffer sb = new StringBuffer();
  220.         //将ASCII码转成字符串
  221.         for (int i = 0; i < bytes.length; i++) {
  222.             sb.append((char) Integer.parseInt(String.valueOf(bytes[i])));
  223.         }
  224.  
  225. //        logger.info("sb:" + sb.toString());
  226.         sb.reverse();
  227.  
  228.         //解析字符串
  229.         String[] strs = sb.toString().trim().split("\\=");
  230.         double weight = 0;
  231.         for (int j = 0; j < strs.length; j++) {
  232.             if (strs[j].trim().length() >= 6) {
  233.                 weight = Double.parseDouble(strs[j].trim());
  234.                 //发送数据
  235.                 sendMessageToAll(String.valueOf(weight));
  236.                 break;
  237.             }
  238.         }
  239.     }
  240.  
  241.     /**
  242.      * 解析字符串 方法3
  243.      *
  244.      * @param bytes 获取的字节码
  245.      */
  246.     private void parsingString4(byte[] bytes) {
  247.         StringBuffer sb = new StringBuffer();
  248.         //将ASCII码转成字符串
  249.         for (int i = 0; i < bytes.length; i++) {
  250.             sb.append((char) Integer.parseInt(String.valueOf(bytes[i])));
  251.         }
  252.  
  253. //        logger.info("sb:" + sb.reverse());
  254.         //字符串反转
  255.         sb.reverse();
  256.  
  257.         //解析字符串
  258.         String[] strs = sb.toString().trim().split("\\=");
  259.         int weight = 0;
  260.         for (int j = 0; j < strs.length; j++) {
  261.             if (strs[j].trim().length() >= 6) {
  262.                 weight = Integer.parseInt(strs[j].trim().substring(0, 6));
  263.                 //发送数据
  264.                 sendMessageToAll(String.valueOf(weight));
  265.                 break;
  266.             }
  267.         }
  268.     }
  269.  
  270.     /**
  271.      * 接受消息
  272.      *
  273.      * @param message
  274.      * @param session
  275.      */
  276.     @OnMessage
  277.     public void onMessage(String message, Session session) {
  278.         logger.info("收到客户端{}消息：{}", session.getId(), message);
  279.         try {
  280.             this.sendMessage(message);
  281.         } catch (Exception e) {
  282.             logger.error(e.toString());
  283.         }
  284.     }
  285.  
  286.     /**
  287.      * 处理错误
  288.      *
  289.      * @param error
  290.      * @param session
  291.      */
  292.     @OnError
  293.     public void onError(Throwable error, Session session) {
  294.         logger.info("发生错误{},{}", session.getId(), error.getMessage());
  295.     }
  296.  
  297.     /**
  298.      * 处理连接关闭
  299.      */
  300.     @OnClose
  301.     public void onClose() {
  302.         webSocketMap.remove(this.session.getId());
  303.         reduceCount();
  304.         logger.info("连接关闭:{}", this.session.getId());
  305.  
  306.         //连接关闭后关闭串口，下一次打开连接重新监听串口
  307.         if (serialPort != null) {
  308.             SerialPortUtil.closePort(serialPort);
  309.             serialPort = null;
  310.         }
  311.     }
  312.  
  313.     /**
  314.      * 群发消息
  315.      *
  316.      * @param message
  317.      */
  318.     public void sendMessageToAll(String message) {
  319.         for (int i = 0; i < webSocketMap.size(); i++) {
  320.             try {
  321. //                logger.info("session:id=" + session.getId());
  322.                 this.session.getBasicRemote().sendText(message);
  323.             } catch (IOException e) {
  324.                 logger.error(e.getMessage());
  325.             }
  326.         }
  327.     }
  328.  
  329.     /**
  330.      * 发送消息
  331.      *
  332.      * @param message
  333.      * @throws IOException
  334.      */
  335.     public void sendMessage(String message) throws IOException {
  336. //        logger.info("session:id=" + session.getId());
  337.         this.session.getBasicRemote().sendText(message);
  338.     }
  339.  
  340.     //广播消息
  341.     public static void broadcast() {
  342.         PoundWebSocket.webSocketMap.forEach((k, v) -> {
  343.             try {
  344.                 v.sendMessage("这是一条测试广播");
  345.             } catch (Exception e) {
  346.             }
  347.         });
  348.     }
  349.  
  350.     //获取在线连接数目
  351.     public static int getCount() {
  352.         return count;
  353.     }
  354.  
  355.     //操作count，使用synchronized确保线程安全
  356.     public static synchronized void addCount() {
  357.         PoundWebSocket.count++;
  358.     }
  359.  
  360.     public static synchronized void reduceCount() {
  361.         PoundWebSocket.count--;
  362.     }
  363. }

 



作者：小土豆哥哥
链接：https://www.jianshu.com/p/cb61f797ffc1
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

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

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

  

闽ICP备14008679号