Springboot串口通信+Rxtx库+JDK1.8+RS232协议

于 2024-07-24 15:14:48 发布
阅读量856 收藏 10
点赞数 16
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64468934/article/details/140662928
版权

注意：RXTX库发送和接受数据是通过InputStream和OutputStream来获取和发送数据的,并且RXTX库只适用于JDK1.8_2及以下的版本

1.POM文件的导入

<dependency>
   <groupId>com.fazecast</groupId>
    <artifactId>jSerialComm</artifactId>
    <version>2.10.5</version>
</dependency>


2.写一个实体类

@Component
@AllArgsConstructor
@NoArgsConstructor
@Data
public class SerialEntity {
    @ApiModelProperty(value = "端口名称")
    private String PortName = "COM9";
    @ApiModelProperty(value = "请求指令")
    private String powerOffCommand;
    private int BAUDRATE = 2400;
    private int DATALENGTH = 8;
    private int STOPBIT = 1;
    private String PARITY = "NONE"
@ApiModelProperty(name="过载故障")
private char Overloadwarning;
@ApiModelProperty(name="过温故障")
private char Overtemperature;
@ApiModelProperty(name="电池过低故障")
private char Batterylow;
@ApiModelProperty(name="省电模式名称")
private String Batterymode;
@ApiModelProperty(name="剩余电量")
private String BatteryVoltage;
}


3.common工具类

package com.ruoyi.equipment.serialportcommon;
public class common {
        public static String HEX_STRING = "0123456789ABCDEF";
        public static final String NONE = "无";
        public static final String ODD = "奇";
        public static final String EVEN = "偶";
        public static final String FORMAT_HEX="HEX";
    }
4.SerialUtil配置类
package com.zkyq.acss.comm;
import gnu.io.SerialPort;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
public class SerialUtil {
    /**
     * 转为 HEX
     * @param str
     * @return
     */
    public static String toHex(String str){
        StringBuffer sbf = new StringBuffer();
        byte[] b = str.getBytes(StandardCharsets.UTF_8);
        for (int i = 0; i < b.length; i++) {
            String hex = Integer.toHexString(b[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sbf.append(hex.toUpperCase() + "  ");
        }
        return sbf.toString().trim();
    }
    /**
     *
     * @param hex
     * @return
     */
    public static String toStr(String hex) {
        return new String(hexToByte(hex));
    }
    /**
     * 转 HEX 字节
     * @param hex
     * @return
     */
    public static byte[] hexToByte(String hex){
        hex = hex.toUpperCase().replace(" ","");
        ByteArrayOutputStream bao = new ByteArrayOutputStream(hex.length() / 2);
        // 将每2位16进制整数组装成一个字节
        for (int i = 0; i < hex.length(); i += 2) {
            bao.write((common.HEX_STRING.indexOf(hex.charAt(i)) << 4 | common.HEX_STRING.indexOf(hex.charAt(i + 1))));
        }
        return bao.toByteArray();
    }
    /**
     * 获取校验位配置
     * @param checkBit
     * @return
     */
    public static int getParity(String checkBit){
        if (common.NONE.equals(checkBit)){
            return SerialPort.PARITY_NONE;
        } else if (common.ODD.equals(checkBit)){
            return SerialPort.PARITY_ODD;
        } else if (common.EVEN.equals(checkBit)){
            return SerialPort.PARITY_EVEN;
        } else {
            return SerialPort.PARITY_NONE;
        }
    }
    /**
     * 读取数据
     * @param in
     * @return
     */
    public static byte[] readFromPort(InputStream in) {
        byte[] bytes = {};
        try {
            // 缓冲区大小为一个字节
            byte[] readBuffer = new byte[1];
            int bytesNum = in.read(readBuffer);
            while (bytesNum > 0) {
                bytes = concat(bytes, readBuffer);
                bytesNum = in.read(readBuffer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    in.close();
                    in = null;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bytes;
    }
    /**
     * 字节转换
     * @param format
     * @param b
     * @return
     */
    public static String printHexString(String format, byte[] b) {
        String result = new String(b);
        if (common.FORMAT_HEX.equals(format)){
            return SerialUtil.toHex(result);
        }
        return result;
    }
    /**
     * 合并数组
     *
     * @param firstArray  第一个数组
     * @param secondArray 第二个数组
     * @return 合并后的数组
     */
    public static byte[] concat(byte[] firstArray, byte[] secondArray) {
        if (firstArray == null || secondArray == null) {
            if (firstArray != null) {
                return firstArray;
            }
            if (secondArray != null) {
                return secondArray;
            }
            return null;
        }
        byte[] bytes = new byte[firstArray.length + secondArray.length];
        System.arraycopy(firstArray, 0, bytes, 0, firstArray.length);
        System.arraycopy(secondArray, 0, bytes, firstArray.length, secondArray.length);
        return bytes;
    }
}

5.RSConfig功能实现类

package com.zkyq.acss.config;
import com.zkyq.acss.comm.SerialUtil;
import com.zkyq.acss.entity.SerialEntity;
import gnu.io.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.TooManyListenersException;
import java.util.concurrent.ConcurrentHashMap;
/*
* 用于配置和管理RS-232（或其他串行通信接口）端口的连接。主要功能包括打开端口、关闭端口和发送数据
* */
@Slf4j
@Component
public class Rs232Config {
    // 定义一个常量，用于表示延迟时间，单位为毫秒
    /*  private static final int DELAY_TIME = 1000;*/
    // 使用Spring的@Autowired注解，自动装配SerialPortConfig的实例
    // 使用Spring的@Autowired注解，自动装配SerialEntity的实例
private SerialUtil serialUtil;
    /**
     * 缓存端口实例
     * 使用ConcurrentHashMap以支持并发访问
     */

    private Map<String, SerialPort> serialPortMap = new ConcurrentHashMap<>(16);
    public boolean closePort(SerialEntity serial) {
        // 从map中移除并获取对应的SerialPort实例
        SerialPort serialPort = serialPortMap.remove(serial.getPortName());
        if (null != serialPort) {
            // 关闭串口
            serialPort.close();
            System.out.println("关闭串口成功");
        }
        return false;
    }
    public boolean openPort(SerialEntity serial) {
        if (serial == null) {
            log.error(("serial is null"));
            return false;
        }
        String portName = serial.getPortName();
        System.out.println("端口号" + portName);
        CommPortIdentifier portIdentifier = null;
        SerialPort serialPort = null;
        int bitRate = 0, dataBit = 0, stopBit = 0, parity = 0;
        try {
            // 获取串口对应的CommPortIdentifier对象
            portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
            System.out.println("portIdentifier" + portIdentifier);
            // 打开串口，并获取SerialPort对象
            if (portIdentifier.isCurrentlyOwned()) {
                System.err.println("Error: Port is currently in use");
            } else {
                // 打开串口，并设置延迟时间为DELAY_TIME
                serialPort = (SerialPort) portIdentifier.open("", 1000);
                // 设置监听器生效，当有数据时通知
                // notifyOnDataAvailable(true) 表示当有数据到达串口时，会触发数据到达事件
                serialPort.notifyOnDataAvailable(true);
                // 从serial对象中获取串口参数（这里假设serial对象包含了这些参数）
                // 比特率
                bitRate = serial.getBAUDRATE();
                // 数据位
                dataBit = serial.getDATALENGTH();
                // 停止位
                stopBit = serial.getSTOPBIT();
                // 校验位，通过SerialUtil工具类转换为字符串表示
                parity = SerialUtil.getParity(serial.getPARITY());
                // 设置串口参数：比特率、数据位、停止位、奇偶校验位
                serialPort.setSerialPortParams(bitRate, dataBit, stopBit, parity);
            }
            // 注意：这里假设SerialPort.getParity()是存在的，实际上应该是直接传入int类型的校验位
            /*  System.out.println("是否获取到数据"+serial.getPARITY().toString());*/
        } catch (PortInUseException | NoSuchPortException e) {
            log.error("Open CommPortIdentifier {} Exception:", serial.getPortName(), e);
            return false;
        } catch (UnsupportedCommOperationException e) {
            log.error("Set SerialPortParams BitRate {} DataBit {} StopBit {} Parity {} Exception:", bitRate, dataBit, stopBit, parity, e);
            return false;
        }
        // 设置当前串口的输入输出流
        InputStream input;
        OutputStream output;
        try {
            input = serialPort.getInputStream();
            output = serialPort.getOutputStream();
        } catch (IOException e) {
            log.error("Get serialPort data stream exception:", e);
            return false;
        } catch (Exception e) {
            log.error("An error occurred while opening the port:", e);
            return false;
        }
        // 给当前串口添加一个监听器
        try {
            serialPort.addEventListener(new Serial232Listener(input, output, serial.getFormat()));
        } catch (TooManyListenersException e) {
            log.error("Get serialPort data stream exception:", e);
            return false;
        }
        serialPortMap.put(portName, serialPort);
        return true;
    }
    /**
     * 关闭端口
     *
     * @param portId 端口ID（但注意，在方法内部被硬编码为"COM5"）
     */
    public SerialEntity readData(String portId) {
        SerialEntity serial = new SerialEntity();
        SerialPort serialPort = serialPortMap.get(portId);;
        InputStream input;
        try {
            input = serialPort.getInputStream();
            System.out.println("input" + input);
            byte[] bytes = serialUtil.readFromPort(input);
            System.out.println("bytes: " + bytes );
     /*       char[] charArray = new char[bytes.length];*/
            System.out.println("bytes: " );
            // 创建一个StringBuilder来构建字符串，这比使用String连接更高效
            StringBuilder sb = new StringBuilder();
            for (byte b : bytes) {
                // 直接将字节转换为字符（假设是ASCII编码）
                char asciiChar = (char) b;
                sb.append(asciiChar);
            }
            // 将StringBuilder转换为String并打印
            String resultString = sb.toString();
            System.out.println("Received string: " + resultString); // 假设这会是"210.6"或其他有效的文本字符串
           /* String[] strArray = resultString.split("\\s+");*/
           char seven = resultString.charAt(7);
           char eight = resultString.charAt(8);
           char tweleve = resultString.charAt(12);
                serial.setBatterylow(seven);
                serial.setOverloadwarning(eight);
                serial.setOvertemperature(tweleve);
                System.out.println(serial.getBatterylow());
                System.out.println(serial.getOverloadwarning());
                System.out.println(serial.getOvertemperature());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return serial;
    }
    public SerialEntity readData1(String portId) {
        SerialEntity serial = new SerialEntity();
        SerialPort serialPort = serialPortMap.get(portId);;
        InputStream input;
        try {
            input = serialPort.getInputStream();
            System.out.println("input" + input);
            byte[] bytes = SerialUtil.readFromPort(input);
            System.out.println("bytes: " );
            // 创建一个StringBuilder来构建字符串，这比使用String连接更高效
            StringBuilder sb = new StringBuilder();
            for (byte b : bytes) {
                // 直接将字节转换为字符（假设是ASCII编码）
                char asciiChar = (char) b;
                sb.append(asciiChar);
            }
            // 将StringBuilder转换为String并打印
            String resultString = sb.toString();
            System.out.println("Received string: " + resultString); // 假设这会是"210.6"或其他有效的文本字符串
            String[] strArray = resultString.split("\\s+");
            // 检查数组长度以确保有足够的部分
            if (strArray.length > 1) {
                // 获取第二个部分（索引为1）
                String firstPart = strArray[2];
                serial.setBatteryVoltage(firstPart);
                System.out.println(serial.getBatteryVoltage());
            } else {
                System.out.println("Not enough parts in the string.");
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return serial;
    }
    public SerialEntity readData2(String portId) {
        SerialEntity serial = new SerialEntity();
        SerialPort serialPort = serialPortMap.get(portId);;
        InputStream input;
        try {
            input = serialPort.getInputStream();
            System.out.println("input" + input);
            byte[] bytes = SerialUtil.readFromPort(input);
            System.out.println("bytes: " );
            // 创建一个StringBuilder来构建字符串，这比使用String连接更高效
            StringBuilder sb = new StringBuilder();
            for (byte b : bytes) {
                // 直接将字节转换为字符（假设是ASCII编码）
                char asciiChar = (char) b;
                sb.append(asciiChar);
            }
            // 将StringBuilder转换为String并打印
            String resultString = sb.toString();
            System.out.println("Received string: " + resultString); // 假设这会是"210.6"或其他有效的文本字符串
            String[] strArray = resultString.split("\\s+");
            // 检查数组长度以确保有足够的部分
            if (strArray.length > 0) {
                // 获取第二个部分（索引为1）
                String firstPart = strArray[0];
                serial.setBatterymode(firstPart);
                System.out.println(serial.getBatterymode());
            } else {
                System.out.println("Not enough parts in the string.");
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return serial;
    }
    public boolean sendData(String portId, String message) {
        SerialPort serialPort = serialPortMap.get(portId);
        System.out.println("serialPort" + serialPort);
        if (null == serialPort){
            return false;
        }
        OutputStream output = null;
        try {
             byte[] bytes = message.getBytes(StandardCharsets.UTF_8);
            output = serialPort.getOutputStream();
            output.write(bytes);
            output.flush();
            return true;
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (null != output){
                try {
                    output.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

6.UpsManager逻辑处理类

package com.zkyq.acss.config;
import com.zkyq.acss.entity.SerialEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@Slf4j
@Component
public class UPSManager {
    // 使用Spring的自动装配特性注入Rs232Config的实例
    @Autowired
    private Rs232Config rs232Config;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    // 关闭UPS连接的端口，并发送关机命令
    public boolean closePort(SerialEntity serial) {
        try {
            if (rs232Config != null) {
                rs232Config.openPort(serial);
                boolean closeport = rs232Config.sendData(serial.getPortName(), serial.getPowerOffCommand());
                System.out.println("closeport" + closeport);
                boolean portclosed = rs232Config.closePort(serial);
                if (portclosed) {
                    System.out.println("已发送指令");
                }
            } else {
                System.out.println("rs232Config is null");
                return false;
            }
        } catch (RuntimeException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
    public boolean openPort(SerialEntity serial) {
        // 打开COM5端口（注意：这里假设portId参数未被使用）
        if (serial == null) {
            System.out.println("SerialEntity 对象为空，无法打开端口");
            return false;
        }
        if (rs232Config == null) {
            System.out.println("rs232Config 对象为空，无法操作端口" + rs232Config);
            return false;
        }
        boolean portOpened = rs232Config.openPort(serial);
        if (portOpened) {
            rs232Config.sendData(serial.getPortName(), serial.getPowerOffCommand());
            System.out.println("已发送指令");
        } else {
            System.out.println("端口未打开");
            return false;
        }
        rs232Config.closePort(serial);
        return true;
    }
    // 获取UPS的当前状态
    public SerialEntity CurrentStatus(SerialEntity serial) {
        SerialEntity SS = new SerialEntity();
        try{
            Thread.sleep(1200);
            rs232Config.openPort(serial);
            rs232Config.sendData(serial.getPortName(), serial.getPowerOffCommand());
            SS =  rs232Config.readData(serial.getPortName());
            rs232Config.closePort(serial);
        } catch (InterruptedException e) {
            System.out.println("线程被中断");
        }
        return SS;
    }
        public SerialEntity ReaminBatteryTime (SerialEntity serial) {
        SerialEntity SS = new SerialEntity();
            // 设置UPS电池剩余时间请求命令
            /*  statusRequestCommand = "F\r\n";*/
            try {
                Thread.sleep(500);
                rs232Config.openPort(serial);
                rs232Config.sendData(serial.getPortName(), serial.getPowerOffCommand());
                SS = rs232Config.readData1(serial.getPortName());
                rs232Config.closePort(serial);
                // 这里只是模拟了一个成功的请求，并返回true
            } catch (InterruptedException e) {
                System.out.println("线程被中断");
            }
            return SS;
        }
        public SerialEntity CurrentMode (SerialEntity serial){
             SerialEntity SS = new SerialEntity();
            // 设置UPS当前模式请求命令
            rs232Config.openPort(serial);
            rs232Config.sendData(serial.getPortName(), serial.getPowerOffCommand());
            SS = rs232Config.readData2(serial.getPortName());
            rs232Config.closePort(serial);
            // 这里只是模拟了一个成功的请求，并返回true
            return SS;
        }
        public boolean openPortAfterMinutes (SerialEntity serial){
            scheduler.schedule(() -> {
                try {
                    /* UPSManager upsManager = new UPSManager(); */
                    if (serial == null) {
                        System.out.println("SerialEntity 对象为空，无法打开端口");
                    }
                    if (rs232Config == null) {
                        System.out.println("rs232Config 对象为空，无法操作端口" + rs232Config);
                        // 注意：这里也不需要 return false
                    }
                    boolean portOpened = rs232Config.openPort(serial);
                    if (portOpened) {
                        rs232Config.sendData(serial.getPortName(), serial.getPowerOffCommand());
                        System.out.println("已发送指令");
                    } else {
                        System.out.println("端口未打开");
                        // 注意：这里也不需要 return false
                    }
                    rs232Config.closePort(serial);
                    // 注意：其他代码逻辑...
                    // 注意：这里不需要 return true，因为 Runnable 没有返回值
                } catch (Exception e) {
                    e.printStackTrace(); // 处理异常
                }
            }, serial.getMinutes(), TimeUnit.MINUTES);
            // 返回 true 表示操作已成功安排（但不一定已完成）
            return true;
        }
        public boolean closePortAfterMinutes (SerialEntity serial ){ // 假设你需要知道哪个端口需要被关闭
            scheduler.schedule(() -> {
                try {
                    /*  UPSManager upsManager = new UPSManager();*/
                    try {
                        if (rs232Config != null) {
                            rs232Config.openPort(serial);
                            boolean closeport = rs232Config.sendData(serial.getPortName(), serial.getPowerOffCommand());
                            System.out.println("closeport" + closeport);
                            boolean portclosed = rs232Config.closePort(serial);
                            if (portclosed) {
                                System.out.println("已发送指令");
                            }
                        } else {
                            System.out.println("rs232Config is null");
                        }
                    } catch (RuntimeException e) {
                        e.printStackTrace();
                    }
                    // 在 minutes 分钟后执行 closePort
                } catch (Exception e) {
                    e.printStackTrace(); // 处理异常
                }
            }, serial.getMinutes(), TimeUnit.MINUTES);
            // 返回 true 表示操作已成功安排（但不一定已完成）
            return true;
        }
}


7.RS232Controller请求处理类


package com.zkyq.acss.controller;
import com.zkyq.acss.config.UPSManager;
import com.zkyq.acss.entity.SerialEntity;
import com.zkyq.acss.util.ResponseObj;
import gnu.io.NoSuchPortException;
import io.swagger.annotations.Api;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.IOException;
/*它用于处理与RS-232串口通信相关的HTTP请求*/
@RestController
@RequestMapping("/UPS/RS232")
@Api(tags = "UPS接入企业端")
public class Rs232Controller {
    @Autowired
    UPSManager upsManager;
 /*   @Autowired
    TimeService timeService;*/
    /**
     * 监听端口
     *
     * @param
     */
    @PostMapping("/open")
    public ResponseObj open(@RequestBody SerialEntity serial) {
        return ResponseObj.success(upsManager.openPort(serial));
    }
    @PostMapping("/close")
    public ResponseObj close(@RequestBody SerialEntity serial) {
        /*    serialController.getSerialPortList();*/
        return ResponseObj.success(upsManager.closePort(serial));
    }
    @PostMapping("/CurrentStatus")
    public ResponseObj CurrentStatus(@RequestBody SerialEntity serial) throws IOException, NoSuchPortException {
        return ResponseObj.success(upsManager.CurrentStatus(serial));
    }
    @PostMapping("/ReaminBatteryTime")
    public ResponseObj ReaminBatteryTime(@RequestBody SerialEntity serial) {
        /* serialController.getSerialPortList();*/
        return ResponseObj.success(upsManager.ReaminBatteryTime(serial));
    }
    @PostMapping("/CurrentMode")
    public ResponseObj CurrentMode(@RequestBody SerialEntity serial) {
        return ResponseObj.success(upsManager.CurrentMode(serial));
    }
//设置几分钟后自动开启   
    @PostMapping("/time")
    public ResponseObj Time(@RequestBody SerialEntity serial) {
        return ResponseObj.success(upsManager.openPortAfterMinutes(serial));
    }
//设置几分钟后自动关闭
    @PostMapping("/time2")
    public ResponseObj Time2(@RequestBody SerialEntity serial) {
        return ResponseObj.success( upsManager.closePortAfterMinutes(serial));
    }
}

                        

李四岁
关注
  • 16
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springboot + rxtx 实现串口读写应用部分源码
03-19
Springboot + rxtx 实现串口读写应用部分源码
springboot mina 串口对接
08-26
springboot集成mina实现串口协议对接，包含断包、粘包处理。串口协议发送与接收是异步的，发送没有返回，只能通过监听获取。
SpringBoot 串口通讯
qq_28986503的博客
10-27 3770
一、开发环境介绍 系统环境:windows 10 专业版 64位 开发工具：IDEA JDK版本：jdk-8u201-windows-x64 （下载地址） SpringBoot版本：2.5.5 构建工具：gradle 一、所需依赖项 需将（rxtxParallel.dll、rxtxSerial.dll） 下载地址 动态链接库文件放入:C:\Program Files\Java\jdk1.8.0_201\bin 中才能进行串口通讯 二、虚拟串口以及串口测试工具 使用 Virtual Serial
SpringBoot项目串口通讯之jSerialComm
beiback的博客
03-13 1361
串口通讯
spring boot 整合mina 串口
03-24
找了很长时间网上没有一个详细整合的例子,现在已整合成功 放上来让大家参照,少走弯路,稍后会放出博客说明 使用idea 打开后可以直接使用的例子,很珍贵
SpringBoot接入RS-232串口通讯实现数据交互
最新发布
leen的博客
06-12 1211
本文给大家分享的是Java通信硬件RS-232串口，通过波特率、串口的方式去实现数据交互，从而实现一些预想的功能。
smslib+rxtx+comm的使用例子和相关总结
07-04
COMM库（在`comm2`和`comm3`的标签中提及）是Java的标准通信API，提供了串行和并行通信的接口。尽管RXTX是COMM API的一个替代，但某些情况下，直接使用COMM库可能更合适。例如，`comm3.0_u1_linux.zip`包含的是Linux...
jdk1.8.0-221 RS232，RS485 串口通讯调试JDK
02-28
标题中的“jdk1.8.0_221 RS232，RS485 串口通讯调试JDK”表明这是一个关于Java开发工具包（JDK）1.8.0_221版本，专注于解决与RS232和RS485串行通信相关的调试问题。RS232和RS485是两种常见的串行通信接口标准，广泛...
java使用Rxtx实现串口通信调试工具
08-26
Rxtx库通过封装底层操作系统的串口API，提供了一套与操作系统无关的接口，大大简化了串口通信程序的开发难度。使用Rxtx，开发者可以不必关心操作系统的差异，而把更多的精力放在业务逻辑的实现上。 实现一个基于...
SMSLIB+RXTX 短信猫开发模块及详细配置步骤
07-13
RXTX是Java的一个串行通信库，它提供了与操作系统底层串口通信的接口。在SMSLIB中，RXTX用于与短信猫（GSM调制解调器）进行物理连接，实现数据的收发。 **短信猫开发** 短信猫，即GSM调制解调器，是一种可以通过...
springboot多串口解析
05-31
java解析硬件接口数据信息
modbusHb：基于SpringBoot实现的modbus心跳通信
02-04
基于Spring Boot实现的modbus心跳通信 基于Spring Boot实现的modbus定时tcp通信，支持线程池，可从数据库动态设置ip，端口号及执行周期（执行周期需遵循cron表达） 本项目使用Spring Data Jpa + MySQL，具体依赖见pom.xml modbus协议基于jlibmodbus实现，感谢 例子：
Java使用开源Rxtx实现串口通讯 串口开发
04-13
Java使用开源Rxtx实现串口通讯 串口开发，里面包含实例，下载后按自己的要求进行修改即可（仅限对java有基础的人员）。
Spring-boot
03-16
Sprint Boot Spring Boot可以帮助您以最小的麻烦来创建Spring支持的生产级应用程序和服务。 它从Spring平台的角度出发，以便新老用户都能快速找到所需的信息。 您可以使用Spring Boot创建独立的Java应用程序，该应用程序可以使用java -jar或更传统的WAR部署来启动。 我们还提供了一个运行Spring脚本的命令行工具。 我们的主要目标是： 为所有Spring开发提供根本上更快且可广泛访问的入门经验 开箱即用，但是随着需求开始偏离默认值，您会很快摆脱困境 提供一系列大型项目共有的非功能性功能（例如，嵌入式服务器，安全性，指标，运行状况检查，外部化配置） 完全没有代码生成，也不需要XML配置 安装与入门 包括详细的以及全面的指南。 文档以 ， 和格式发布。 这是Java中完整的Spring Boot应用程序的快速摘要： import or
java JDK配置串口通信rxtx 及要用到的JAR（1/3）
11-22
java JDK配置串口通信rxtx 及要用到的JAR
Java Spring Boot实现物联网设备串口通信
热门推荐
qq_40018541的博客
03-30 1万+
本文实现了利用Java语言编写程序实现物联网设备串口通讯发送数据并且接口数据功能
Java springboot 串口 通信
wangh92
04-07 3905
基于win10 环境 Virtual Serial Port Driver Pro 开通两个虚拟串口 打开串口调试助手 代码逻辑 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http:
java串口接收和发送消息集成Springboot
somdip的博客
03-26 674
发送没有任何限制，但是你想在接收的时候，想在存有静态属性的方法里调用一下dao,service啥的，在依赖注入的时候（也就是@auwired），需要这么实现一下。（2）、将RXTXcomm.jar 包放到{JAVA_HOME}jdk目录\jre\lib\ext目录下即可。如： C:\Program Files\Java\jdk1.8.0_31\jre\lib\ext。初始化一个串口，并监听串口是否接收到数据。如： C:\Program Files\Java\jdk1.8.0_31\jre\bin。
springboot+rxtx
12-04
在Spring Boot中使用RXTX进行串口通信，可以按照以下步骤进行： 1. 添加RXTX依赖 在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.rxtx</groupId> <artifactId>rxtx</artifactId> <version>2.2</version> </dependency> ``` 2. 配置串口信息 在application.properties文件中添加以下配置信息： ```properties serial.port.name=COM1 # 串口名称 serial.port.baudrate=9600 # 波特率 serial.port.databits=8 # 数据位 serial.port.stopbits=1 # 停止位 serial.port.parity=0 # 校验位 ``` 3. 创建SerialPortService类 创建一个SerialPortService类，用于打开、关闭串口，发送和接收数据。代码如下： ```java @Service public class SerialPortService { private SerialPort serialPort; public void open(String portName, int baudRate, int dataBits, int stopBits, int parity) throws Exception { CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName); if (portIdentifier.isCurrentlyOwned()) { throw new Exception("Port is currently in use"); } else { CommPort commPort = portIdentifier.open(this.getClass().getName(), 2000); if (commPort instanceof SerialPort) { serialPort = (SerialPort) commPort; serialPort.setSerialPortParams(baudRate, dataBits, stopBits, parity); } else { throw new Exception("Only serial ports are supported"); } } } public void close() { if (serialPort != null) { serialPort.close(); } } public void send(String data) throws Exception { if (serialPort != null) { OutputStream outputStream = serialPort.getOutputStream(); outputStream.write(data.getBytes()); outputStream.flush(); } else { throw new Exception("Serial port is not open"); } } public String receive() throws Exception { if (serialPort != null) { InputStream inputStream = serialPort.getInputStream(); byte[] buffer = new byte[1024]; int len = inputStream.read(buffer); return new String(buffer, 0, len); } else { throw new Exception("Serial port is not open"); } } } ``` 4. 创建Controller类 创建一个Controller类，用于处理HTTP请求和WebSocket请求。代码如下： ```java @RestController public class SerialPortController { @Autowired private SerialPortService serialPortService; @GetMapping("/open") public String open() throws Exception { serialPortService.open( Environment.getProperty("serial.port.name"), Integer.parseInt(Environment.getProperty("serial.port.baudrate")), Integer.parseInt(Environment.getProperty("serial.port.databits")), Integer.parseInt(Environment.getProperty("serial.port.stopbits")), Integer.parseInt(Environment.getProperty("serial.port.parity")) ); return "Serial port is open"; } @GetMapping("/close") public String close() { serialPortService.close(); return "Serial port is closed"; } @GetMapping("/send") public String send(@RequestParam String data) throws Exception { serialPortService.send(data); return "Data is sent"; } @MessageMapping("/receive") @SendTo("/topic/receive") public String receive() throws Exception { return serialPortService.receive(); } } ``` 5. 创建WebSocket配置类 创建一个WebSocket配置类，用于配置WebSocket。代码如下： ```java @Configuration @EnableWebSocketMessageBroker public class WebSocketConfig implements WebSocketMessageBrokerConfigurer { @Override public void configureMessageBroker(MessageBrokerRegistry registry) { registry.enableSimpleBroker("/topic"); registry.setApplicationDestinationPrefixes("/app"); } @Override public void registerStompEndpoints(StompEndpointRegistry registry) { registry.addEndpoint("/ws").withSockJS(); } } ``` 6. 创建WebSocket客户端 创建一个WebSocket客户端，用于向服务器发送WebSocket请求和接收服务器的响应。代码如下： ```javascript var stompClient = null; function connect() { var socket = new SockJS('/ws'); stompClient = Stomp.over(socket); stompClient.connect({}, function (frame) { console.log('Connected: ' + frame); stompClient.subscribe('/topic/receive', function (message) { console.log('Received: ' + message.body); }); }); } function send() { var data = document.getElementById('data').value; stompClient.send('/app/send', {}, data); } ``` 7. 创建HTML页面 创建一个HTML页面，用于测试串口通信。代码如下： ```html <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>Serial Port Test</title> <script src="/webjars/sockjs-client/1.5.0/dist/sockjs.min.js"></script> <script src="/webjars/stomp-websocket/2.3.3/dist/stomp.min.js"></script> <script src="/js/app.js"></script> </head> <body onload="connect()"> <input type="text" id="data"> <button onclick="send()">Send</button> </body> </html> ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值