java读取串口数据

最新推荐文章于 2024-05-23 16:38:42 发布
最新推荐文章于 2024-05-23 16:38:42 发布
阅读量4.8k 收藏 22
点赞数 2
分类专栏： java 文章标签： java 开发语言
原文链接：https://juejin.cn/post/7088220527122186253
版权

            项目中， 需要用到通过串口读取扫码枪扫描出来的内容。在网上找了很多资料，都不是很理想。直到找到Java实现串口通信 - 掘金的内容，怕以后找不到，记录一下。方便以后查询。

环境准备

1、硬件环境准备，这里我用到的是霍尼韦尔的1900C扫码枪。需要安装扫码枪的驱动，并且需要将USB模拟串口输出。

代码配置

1、首选通过maven配置依赖包，如下图:
 

  <!-- 串口内容读取 -->
        <dependency>
            <groupId>org.bidib.jbidib.org.qbang.rxtx</groupId>
            <artifactId>rxtxcomm</artifactId>
            <version>2.2</version>
        </dependency>

然后，将制定的两个文件

 放到对应的目录里面，

文件下载地址为:

链接：https://pan.baidu.com/s/1YBsxGLJKEVEKNiepweF5Aw?pwd=1234 
提取码：1234

然后就是测试代码:

创建文件:

PortInit.java

package com.zy.autologin.autologin.pojo.vo;/**
 * 一些声明信息
 * Description:
 * date: 2022/8/18 14:23
 *
 * @author CL
 * @version
 * @company zt
 */

import com.zy.autologin.autologin.service.impl.MyLister;
import com.zy.autologin.autologin.unitl.SerialPortUtil;
import gnu.io.SerialPort;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

import java.util.ArrayList;

/**
 * ClassName: PortInit 
 * Description: //  TODO
 * date: 2022/8/18 14:23
 * @author: CL
 * @group: zy
 */
@Component
public class PortInit  implements ApplicationRunner {
    public static SerialPort serialPort = null;

    @Override
    public void run(ApplicationArguments args)
    {
        String portName = "COM3";
        //查看所有串口
        SerialPortUtil serialPortUtil = SerialPortUtil.getSerialPortUtil();
        ArrayList<String> port = serialPortUtil.findPort();
        System.out.println("发现全部串口：" + port);
        System.out.println("打开指定portName:" + portName);
        //打开该对应portName名字的串口
        PortInit.serialPort = serialPortUtil.openPort(
                portName,
                9600,
                SerialPort.DATABITS_8,
                SerialPort.PARITY_NONE,
                SerialPort.PARITY_ODD);
        //给对应的serialPort添加监听器
        serialPortUtil.addListener(PortInit.serialPort, new MyLister());
    }

}

创建

MyLister.java
package com.zy.autologin.autologin.service.impl;/**
 * 一些声明信息
 * Description:
 * date: 2022/8/18 14:34
 *
 * @author CL
 * @version
 * @company zt
 */

import com.zy.autologin.autologin.pojo.vo.PortInit;
import com.zy.autologin.autologin.unitl.SerialPortUtil;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.Date;

/**
 * ClassName: MyLister 
 * Description: //  TODO
 * date: 2022/8/18 14:34
 * @author: CL
 * @group: zy
 */
@Service
@Slf4j
public class MyLister implements SerialPortEventListener {
    @Override
    public void serialEvent(SerialPortEvent event)
    {
        switch (event.getEventType())
        {
            //串口存在有效数据
            case SerialPortEvent.DATA_AVAILABLE:
                byte[] bytes = SerialPortUtil.getSerialPortUtil().readFromPort(PortInit.serialPort);
                String byteStr = new String(bytes, 0, bytes.length).trim();
                System.out.println("===========start===========");
                System.out.println(new Date() + "【读到的字符串】：-----" + byteStr);
                System.out.println(new Date() + "【字节数组转16进制字符串】：-----" + printHexString(bytes));
                System.out.println("===========end===========");
                break;
            // 2.输出缓冲区已清空
            case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
                log.error("输出缓冲区已清空");
                break;
            // 3.清除待发送数据
            case SerialPortEvent.CTS:
                log.error("清除待发送数据");
                break;
            // 4.待发送数据准备好了
            case SerialPortEvent.DSR:
                log.error("待发送数据准备好了");
                break;
            // 10.通讯中断
            case SerialPortEvent.BI:
                log.error("与串口设备通讯中断");
                break;
            default:
                break;
        }
    }

    /**
     * 字节数组转16进制字符串
     *
     * @param b 字节数组
     * @return 16进制字符串
     */
    public static String printHexString(byte[] b)
    {
        StringBuilder sbf = new StringBuilder();
        for (byte value : b)
        {
            String hex = Integer.toHexString(value & 0xFF);
            if (hex.length() == 1)
            {
                hex = '0' + hex;
            }
            sbf.append(hex.toUpperCase()).append(" ");
        }
        return sbf.toString().trim();
    }

    /**
     * 16进制字符串转字节数组
     *
     * @param hex 16进制字符串
     * @return 字节数组
     */
    public static byte[] hex2byte(String hex)
    {
        if (!isHexString(hex))
        {
            return null;
        }
        char[] arr = hex.toCharArray();
        byte[] b = new byte[hex.length() / 2];
        for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++)
        {
            String swap = "" + arr[i++] + arr[i];
            int byteint = Integer.parseInt(swap, 16) & 0xFF;
            b[j] = new Integer(byteint).byteValue();
        }
        return b;
    }

    /**
     * 校验是否是16进制字符串
     *
     * @param hex
     * @return
     */
    public static boolean isHexString(String hex)
    {
        if (hex == null || hex.length() % 2 != 0)
        {
            return false;
        }
        for (int i = 0; i < hex.length(); i++)
        {
            char c = hex.charAt(i);
            if (!isHexChar(c))
            {
                return false;
            }
        }
        return true;
    }

    /**
     * 校验是否是16进制字符
     *
     * @param c
     * @return
     */
    private static boolean isHexChar(char c)
    {
        return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
    }

}

创建

SerialPortUtil.java
package com.zy.autologin.autologin.unitl;/**
 * 一些声明信息
 * Description:
 * date: 2022/8/18 14:27
 *
 * @author CL
 * @version
 * @company zt
 */

import gnu.io.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

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

/**
 * ClassName: SerialPortUtil 
 * Description: //  TODO
 * date: 2022/8/18 14:27
 * @author: CL
 * @group: zy
 */
@Service
@Slf4j
public class SerialPortUtil {
//    private static final Logger logger = LoggerFactory.getLogger(SerialPortUtil.class);

    private static SerialPortUtil serialPortUtil = null;

    static
    {
        //在该类被ClassLoader加载时就初始化一个SerialTool对象
        serialPortUtil = new SerialPortUtil();
    }

    //私有化SerialTool类的构造方法，不允许其他类生成SerialTool对象
    private SerialPortUtil()
    {
    }

    /**
     * 获取提供服务的SerialTool对象
     *
     * @return serialPortUtil
     */
    public static SerialPortUtil getSerialPortUtil()
    {
        if (serialPortUtil == null)
        {
            serialPortUtil = new SerialPortUtil();
        }
        return serialPortUtil;
    }

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

    /**
     * 打开串口
     *
     * @param portName 端口名称
     * @param baudrate 波特率  19200
     * @param databits 数据位  8
     * @param parity   校验位（奇偶位）  NONE ：0
     * @param stopbits 停止位 1
     * @return 串口对象
     * //     * @throws SerialPortParameterFailure 设置串口参数失败
     * //     * @throws NotASerialPort             端口指向设备不是串口类型
     * //     * @throws NoSuchPort                 没有该端口对应的串口设备
     * //     * @throws PortInUse                  端口已被占用
     */
    public SerialPort openPort(String portName, int baudrate, int databits, int parity, int stopbits)
    {
        try
        {
            //通过端口名识别端口
            CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
            //打开端口，并给端口名字和一个timeout（打开操作的超时时间）
            CommPort commPort = portIdentifier.open(portName, 2000);
            //判断是不是串口
            if (commPort instanceof SerialPort)
            {
                SerialPort serialPort = (SerialPort) commPort;
                //设置一下串口的波特率等参数
                serialPort.setSerialPortParams(baudrate, databits, stopbits, parity);
                System.out.println("Open " + portName + " sucessfully !");
                return serialPort;
            }
            else
            {
                log.error("不是串口");
            }
        }
        catch (NoSuchPortException e1)
        {
            log.error("没有找到端口");
            e1.printStackTrace();
        }
        catch (PortInUseException e2)
        {
            log.error("端口被占用");
            e2.printStackTrace();
        }
        catch (UnsupportedCommOperationException e)
        {
            e.printStackTrace();
        }
        return null;
    }

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

    /**
     * 往串口发送数据
     *
     * @param serialPort 串口对象
     * @param order      待发送数据
     *                   //       * @throws SendDataToSerialPortFailure        向串口发送数据失败
     *                   //       * @throws SerialPortOutputStreamCloseFailure 关闭串口对象的输出流出错
     */
    public 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();
                }
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }

    /**
     * 从串口读取数据
     *
     * @param serialPort 当前已建立连接的SerialPort对象
     * @return 读取到的数据
     * //     * @throws ReadDataFromSerialPortFailure     从串口读取数据时出错
     * //     * @throws SerialPortInputStreamCloseFailure 关闭串口对象输入流出错
     */
    public byte[] readFromPort(SerialPort serialPort)
    {
        InputStream in = null;
        byte[] bytes = null;
        try
        {
            Thread.sleep(500);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        try
        {
            in = serialPort.getInputStream();
            // 获取buffer里的数据长度
            int bufflenth = in.available();
            while (bufflenth != 0)
            {
                // 初始化byte数组为buffer中数据的长度
                bytes = new byte[bufflenth];
                in.read(bytes);
                bufflenth = in.available();
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            try
            {
                if (in != null)
                {
                    in.close();
                }
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
        return bytes;
    }


    /**
     * 添加监听器
     *
     * @param port     串口对象
     * @param listener 串口监听器
     *                 //     * @throws TooManyListeners 监听类对象过多
     */
    public void addListener(SerialPort port, SerialPortEventListener listener)
    {
        try
        {
            //给串口添加监听器
            port.addEventListener(listener);
            //设置当有数据到达时唤醒监听接收线程
            port.notifyOnDataAvailable(true);
            //设置当通信中断时唤醒中断线程
            port.notifyOnBreakInterrupt(true);
        }
        catch (TooManyListenersException e)
        {
            log.error("太多监听器");
            e.printStackTrace();
        }
    }

    /**
     * 删除监听器
     *
     * @param port     串口对象
     * @param listener 串口监听器
     *                 //     * @throws TooManyListeners 监听类对象过多
     */
    public void removeListener(SerialPort port, SerialPortEventListener listener)
    {
        //删除串口监听器
        port.removeEventListener();
    }

    /**
     * 设置串口的Listener
     *
     * @param serialPort
     * @param listener
     * @author mar
     * @date 2021/8/20 11:04
     */
    public static void setListenerToSerialPort(SerialPort serialPort, SerialPortEventListener listener)
    {
        try
        {
            //给串口添加事件监听
            serialPort.addEventListener(listener);
        }
        catch (TooManyListenersException e)
        {
            e.printStackTrace();
        }
        //串口有数据监听
        serialPort.notifyOnDataAvailable(true);
        //中断事件监听
        serialPort.notifyOnBreakInterrupt(true);
    }
}

然后启动测试，使用扫码枪测试就好

以上文章内容来自:Java实现串口通信 - 掘金

吃小狗的骨头
关注
  • 2
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
java 串口数据读取_java读取串口数据
weixin_32099979的博客
02-20 1031
packagecompackage;importjava.io.InputStream;importjava.util.Enumeration;importjavax.comm.CommPortIdentifier;importjavax.comm.SerialPort;importjavax.comm.SerialPortEvent;importjavax.comm.SerialP...
读取串口数据，java写的
09-13
eclipse idea 导入可以直接使用，读取串口代码，已经封装好，亲测可用。
java程序读取并控制串口设备
左直拳的马桶_日用桶
01-31 1501
监听串口，接收它们发过来的数据，进行处理。
Java读取串口及端口调试
最新发布
m0_46401054的博客
05-23 836
本篇主要讲述使用Java对串口进行读取和发送操作，串口调试的方法以及软件。
java读写串口数据
weixin_39827856的博客
07-24 593
支持Java串口通信操作的jar包，java.comm比较老，而且不支持64位系统，推荐使用Rxtx这个jar包（32位/64位均支持）。* 串口参数的配置 串口一般有如下参数可以在该串口打开以前进行配置： 包括串口号，波特率，输入/输出流控制，数据位数，停止位和奇偶校验。// 读取后置空流对象。当执行main方法中的代码且未执行关闭串口时，程序将一直处于开启状态，自动监听，接收读取来自串口的数据。// 关闭串口（注意：如果需要接收串口返回数据的，请不要执行这句，保持串口监听状态）
java 读取串口数据（绝对可使用）
01-20
JAVA 读取串口数据，推荐使用串口调试工具先测试成功在使用。
java usb串口_安卓开发-安卓串口转USB-小白入门
weixin_39606118的博客
02-21 290
1.新建一个安卓项目。 2.引入jar包：CH34xUARTDriver.jar(下载后直接拖入项目的libs下就可以了) 3.右键点击jar包，导入项目中(到时会弹出一个框，直接点ok就可以了) 4.检查libs文件是否与图片一致 5.可以开始写入你的代码了。在MainActivity中就可以调用串口代码了。//初始化，并判断手机是否支持MyApp.driver = new CH34xUARTD...
java串口读取数据（转载）
蜗牛
09-25 9145
 如何用Java语言向串口读写数据 串口, RS-232-C(又称EIA RS-232-C，以下简称RS232)是在1970年由美国电子工业协会(EIA)联合贝尔系统、调制解调器厂家及计算机终端生产厂家共同制定的用于串行通讯的标准。RS232是一个全双工的通讯协议，它可以同时进行数据接收和发送的工作。串口是计算机上一种非常通用设备通信的协议。以前，大多数计算机包含两个基于RS232的串口。
JAVA串口采集传感器数据
03-05
5. **读写数据**：使用`InputStream`和`OutputStream`进行串口数据的读取和写入。 ```java InputStream in = serialPort.getInputStream(); OutputStream out = serialPort.getOutputStream(); byte[] buffer ...
Java读取串口数据并可在网页上调用
11-19
在本项目中，我们探讨的是如何使用Java读取串口数据，并将这些数据实时地在网页上展示出来，实现动态控制。下面我们将详细讲解相关的Java串口编程知识以及网页调用的实现。 1. **Java串口编程**： - **Java COMM ...
java读取pc串口数据
10-23
本文将深入探讨如何使用Java读取PC串口数据，发送数据，以及如何将这些数据存储到MySQL数据库中，进行进一步的绘图和数据分析。 1. **Java串口通信库** 在Java中，标准库并不直接支持串口通信。但我们可以使用第三...
JAVA串口的例子，有窗口，实现读写
03-13
自己写的JAVA串口的例子，有窗口，实现读写，已经调试通过
java写的一个可以通过串口进行收发信息的工具V1.0
07-04
自己写的，可以通过串口进行收发数据，这个是第一个版本，后续会继续增加功能，敬请期待，希望各位大哥帮忙提提意见以及需求
java读取接码枪数据后台自动获取usb设备数据
10-20
自动获取扫码枪数据，可自定义将扫码枪扫入数据写入数据库，和文件，可同时进行多个存储操作，附带项目使用教程，附带扫码枪模拟工具
JAVA netty 获取串口数据并且下发数据
03-19
在标题中提到的“JAVA Netty 获取串口数据并且下发数据”，这意味着我们将探讨如何利用Netty来处理串行通信，特别是在与传感器交互的场景下。 串口通信，通常指的是通过串行端口进行的数据交换，广泛应用于工业自动...
JAVA串口助手接收数据并解析数据存入MySQL数据库中
01-23
这些库提供了读取和写入串口数据的方法。 2. **Java串口编程** 使用RXTX库为例，我们需要先在项目中添加依赖，然后创建一个`CommPortIdentifier`对象来识别可用的串口。获取串口后，通过`SerialPort`接口建立连接...
java从串口读取固定数据_java 串口编程—-设置缓冲屈来读取串口数据 | 学步园...
weixin_42353715的博客
02-24 163
package test;import java.io.InputStream;import java.io.OutputStream;import javax.comm.CommPortIdentifier;import javax.comm.SerialPort;//串口操作主类public class SerialBean {static String portName;CommPortId...
Java在后台获取USB二维码扫描枪扫描的内容
LTtx1的博客
01-10 5005
Java在后台获取USB二维码扫描枪扫描的内容
从Java中的串口读取文件
p15097962069的博客
11-30 359
我是java技术的初学者，我必须从端口读取文件。 首先，我将“FLASH”写入输出流然后我将从目标设备获得响应作为“FLASH_OK”，在获得FLASH_OK作为响应之后再次我必须写出我想要的文
Java读取串口字符串数据
05-31
要在Java中读取串口字符串数据，需要使用Java串口通信API。以下是一个简单的示例代码，演示如何使用Java串口通信API读取串口字符串数据： ``` import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.OutputStream; import java.util.Enumeration; import gnu.io.CommPortIdentifier; import gnu.io.SerialPort; public class SerialTest { public static void main(String[] args) { // 获取所有可用串口 Enumeration portList = CommPortIdentifier.getPortIdentifiers(); while (portList.hasMoreElements()) { CommPortIdentifier portId = (CommPortIdentifier) portList.nextElement(); if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) { System.out.println("发现可用串口：" + portId.getName()); } } // 打开串口 try { String portName = "/dev/ttyUSB0"; // 更改为你的串口名称 CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName); SerialPort serialPort = (SerialPort) portIdentifier.open("SerialTest", 2000); serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); // 获取输入输出流 BufferedReader input = new BufferedReader(new InputStreamReader(serialPort.getInputStream())); OutputStream output = serialPort.getOutputStream(); // 读取串口数据 while (true) { String inputLine = input.readLine(); System.out.println("收到数据：" + inputLine); } } catch (Exception e) { System.err.println(e.toString()); } } } ``` 在以上代码中，我们使用了Java串口通信API中的`CommPortIdentifier`、`SerialPort`、`BufferedReader`和`OutputStream`等类。我们首先获取所有可用的串口，然后打开指定的串口，并设置串口参数。接着，我们获取输入输出流，使用`BufferedReader`读取串口数据。在读取到数据时，我们将其打印出来。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值