Java串口通信实战（六）：从JNI底层与串口库访问到Modbus标准化

public class HardwareRegisterReader {
    // 声明native方法，告诉Java这个方法在C代码里实现
    public native int readRegister(int address);
    
    static {
        // 加载我们编译好的动态库
        System.loadLibrary("hardware_reader");
    }
    
    public static void main(String[] args) {
        HardwareRegisterReader reader = new HardwareRegisterReader();
        
        // 读取地址0x1000的寄存器
        int registerAddr = 0x1000;
        int value = reader.readRegister(registerAddr);
        
        System.out.println("寄存器 0x" + Integer.toHexString(registerAddr) + " 的值: " + value);
    }
}

javac HardwareRegisterReader.java
javah -jni HardwareRegisterReader

#include "HardwareRegisterReader.h"
#include <stdio.h>
#include <stdlib.h>

// 假设这是设备的基地址
#define DEVICE_BASE_ADDR 0x1000

// 实现Java中声明的native方法
JNIEXPORT jint JNICALL Java_HardwareRegisterReader_readRegister
  (JNIEnv *env, jobject obj, jint address) {
    
    // 这里应该是真实的硬件访问代码
    // 为了演示，我们模拟一个读取过程
    printf("正在读取寄存器地址: 0x%x\n", address);
    
    // 模拟从硬件读取的数值
    int registerValue = (address - DEVICE_BASE_ADDR) + 100;
    
    printf("读取到的值: %d\n", registerValue);
    return registerValue;
}

gcc -shared -fPIC -o libhardware_reader.so \
    -I$JAVA_HOME/include -I$JAVA_HOME/include/linux \
    HardwareRegisterReader.c

gcc -shared -o hardware_reader.dll \
    -I"%JAVA_HOME%\include" -I"%JAVA_HOME%\include\win32" \
    HardwareRegisterReader.c

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

import com.fazecast.jSerialComm.SerialPort;

public class TemperatureSensorReader {
    public static void main(String[] args) {
        // 先看看系统有哪些串口
        SerialPort[] availablePorts = SerialPort.getCommPorts();
        System.out.println("发现串口设备:");
        for (int i = 0; i < availablePorts.length; i++) {
            System.out.println((i + 1) + ". " + availablePorts[i].getSystemPortName());
        }
        
        if (availablePorts.length == 0) {
            System.out.println("没有找到串口设备");
            return;
        }
        
        // 选择第一个串口（实际使用时根据具体情况选择）
        SerialPort sensorPort = availablePorts[0];
        
        // 配置串口参数（这些参数要和传感器手册一致）
        sensorPort.setBaudRate(9600);    // 波特率
        sensorPort.setNumDataBits(8);    // 数据位
        sensorPort.setNumStopBits(SerialPort.ONE_STOP_BIT);  // 停止位
        sensorPort.setParity(SerialPort.NO_PARITY);          // 校验位
        
        // 打开串口
        if (sensorPort.openPort()) {
            System.out.println("串口打开成功: " + sensorPort.getSystemPortName());
        } else {
            System.out.println("串口打开失败");
            return;
        }
        
        try {
            // 等待设备准备好
            Thread.sleep(1000);
            
            // 发送读取温度的命令（具体命令格式看传感器手册）
            String readCommand = "READ_TEMP\r\n";
            byte[] commandBytes = readCommand.getBytes();
            int bytesWritten = sensorPort.writeBytes(commandBytes, commandBytes.length);
            System.out.println("发送了 " + bytesWritten + " 字节的命令");
            
            // 等待响应
            Thread.sleep(500);
            
            // 读取传感器响应
            byte[] responseBuffer = new byte[256];
            int bytesRead = sensorPort.readBytes(responseBuffer, responseBuffer.length);
            
            if (bytesRead > 0) {
                String response = new String(responseBuffer, 0, bytesRead).trim();
                System.out.println("传感器响应: " + response);
                
                // 解析温度数据（假设返回格式是 "TEMP:25.6"）
                if (response.startsWith("TEMP:")) {
                    String tempStr = response.substring(5);
                    double temperature = Double.parseDouble(tempStr);
                    System.out.println("当前温度: " + temperature + "°C");
                }
            } else {
                System.out.println("没有收到传感器响应");
            }
            
        } catch (Exception e) {
            System.out.println("通信出错: " + e.getMessage());
        } finally {
            // 关闭串口
            sensorPort.closePort();
            System.out.println("串口已关闭");
        }
    }
}

import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import java.io.InputStream;
import java.io.OutputStream;

public class RXTXExample {
    public static void main(String[] args) throws Exception {
        // 获取指定串口
        CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier("COM3");
        SerialPort serialPort = (SerialPort) portId.open("MyApp", 2000);
        
        // 设置参数
        serialPort.setSerialPortParams(9600, 
            SerialPort.DATABITS_8, 
            SerialPort.STOPBITS_1, 
            SerialPort.PARITY_NONE);
        
        // 获取输入输出流
        InputStream input = serialPort.getInputStream();
        OutputStream output = serialPort.getOutputStream();
        
        // 发送数据
        output.write("READ_DATA\r\n".getBytes());
        
        // 读取响应
        byte[] buffer = new byte[1024];
        int length = input.read(buffer);
        System.out.println("收到: " + new String(buffer, 0, length));
        
        // 关闭连接
        serialPort.close();
    }
}

<dependency>
    <groupId>com.intelligt.modbus</groupId>
    <artifactId>jlibmodbus</artifactId>
    <version>1.2.8.1</version>
</dependency>

import com.intelligt.modbus.jlibmodbus.Modbus;
import com.intelligt.modbus.jlibmodbus.ModbusMaster;
import com.intelligt.modbus.jlibmodbus.ModbusMasterFactory;
import com.intelligt.modbus.jlibmodbus.exception.ModbusIOException;
import com.intelligt.modbus.jlibmodbus.exception.ModbusNumberException;
import com.intelligt.modbus.jlibmodbus.exception.ModbusProtocolException;
import com.intelligt.modbus.jlibmodbus.tcp.TcpParameters;
import java.net.InetAddress;

public class FrequencyConverterReader {
    public static void main(String[] args) {
        try {
            // 配置变频器的网络参数
            TcpParameters tcpParams = new TcpParameters();
            InetAddress deviceIP = InetAddress.getByName("192.168.1.100"); // 变频器IP
            tcpParams.setHost(deviceIP);
            tcpParams.setPort(Modbus.TCP_PORT); // 默认502端口

            // 创建Modbus主站
            ModbusMaster master = ModbusMasterFactory.createModbusMasterTCP(tcpParams);
            master.connect();
            System.out.println("已连接到变频器: " + deviceIP.getHostAddress());

            // 变频器的从站地址（通常在设备参数中设置）
            int slaveId = 1;
            
            try {
                // 读取变频器状态寄存器（假设地址从40001开始，读取10个寄存器）
                int startAddr = 0;    // Modbus地址40001对应内部地址0
                int quantity = 10;    // 读取10个寄存器
                
                int[] registers = master.readHoldingRegisters(slaveId, startAddr, quantity);
                
                System.out.println("变频器运行数据:");
                System.out.println("运行频率: " + (registers[0] / 100.0) + " Hz");  // 假设频率数据在第一个寄存器，需要除以100
                System.out.println("输出电流: " + (registers[1] / 100.0) + " A");   // 电流数据在第二个寄存器
                System.out.println("输出电压: " + registers[2] + " V");              // 电压数据在第三个寄存器
                System.out.println("运行状态: " + (registers[3] == 1 ? "运行" : "停止")); // 状态位
                
                // 显示所有寄存器的原始数据
                for (int i = 0; i < registers.length; i++) {
                    System.out.println("寄存器[4000" + (i + 1) + "] = " + registers[i]);
                }
                
            } catch (ModbusProtocolException | ModbusNumberException | ModbusIOException e) {
                System.err.println("读取变频器数据失败: " + e.getMessage());
            }

            // 断开连接
            master.disconnect();
            System.out.println("已断开连接");
            
        } catch (Exception e) {
            System.err.println("连接变频器失败: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

import com.intelligt.modbus.jlibmodbus.ModbusMaster;
import com.intelligt.modbus.jlibmodbus.ModbusMasterFactory;
import com.intelligt.modbus.jlibmodbus.serial.SerialParameters;

public class ModbusRTUExample {
    public static void main(String[] args) {
        try {
            // 配置串口参数
            SerialParameters serialParams = new SerialParameters();
            serialParams.setDevice("COM3");        // 串口名称
            serialParams.setBaudRate(9600);       // 波特率
            serialParams.setDataBits(8);          // 数据位
            serialParams.setParity(SerialParameters.PARITY_NONE); // 校验位
            serialParams.setStopBits(1);          // 停止位
            
            // 创建Modbus RTU主站
            ModbusMaster master = ModbusMasterFactory.createModbusMasterRTU(serialParams);
            master.connect();
            
            // 读取从站1的保持寄存器
            int[] data = master.readHoldingRegisters(1, 0, 5);
            
            for (int i = 0; i < data.length; i++) {
                System.out.println("寄存器 " + i + ": " + data[i]);
            }
            
            master.disconnect();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}