MOdbus 的 RTU连接报错

Question

我在开发Modbus的RTU连接时遇到在测试类里面走main方法没有任何问题，在我处理业务时候调取就报错
一下是我的代码

package com.crrcdt.zn.common.utils.Modbus;

import com.serotonin.modbus4j.BatchRead;
import com.serotonin.modbus4j.BatchResults;
import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.code.DataType;
import com.serotonin.modbus4j.exception.ErrorResponseException;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.locator.BaseLocator;
import com.serotonin.modbus4j.msg.WriteCoilRequest;
import com.serotonin.modbus4j.msg.WriteCoilResponse;

import java.util.ArrayList;
import java.util.Date;

public class Modbus4jUtils {
    /**
     * 工厂。
     */
    static ModbusFactory modbusFactory;

    static {
        if (modbusFactory == null) {
            modbusFactory = new ModbusFactory();
        }
    }

    /**
     * 获取master
     *
     * @return
     * @throws ModbusInitException
     */
    public static ModbusMaster getMaster() throws ModbusInitException {
//        IpParameters params = new IpParameters();
//        params.setHost(host);
//        params.setPort(port);
        //
        // modbusFactory.createRtuMaster(wapper); //RTU 协议
        // modbusFactory.createUdpMaster(params);//UDP 协议
        // modbusFactory.createAsciiMaster(wrapper);//ASCII 协议

//        ModbusMaster master = modbusFactory.createTcpMaster(params, false);// TCP 协议

        ModbusMaster master1 = modbusFactory.createRtuMaster(new SerialPortWrapperImpl());

        master1.init();

        return master1;
    }

    /**
     * 读取[01 Coil Status 0x]类型 开关数据
     *
     * @param slaveId slaveId
     * @param offset  位置
     * @return 读取值
     * @throws ModbusTransportException 异常
     * @throws ErrorResponseException   异常
     * @throws ModbusInitException      异常
     */
    public static Boolean readCoilStatus(ModbusMaster master, int slaveId, int offset)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        // 01 Coil Status
        BaseLocator<Boolean> loc = BaseLocator.coilStatus(slaveId, offset);
        Boolean value = master.getValue(loc);
        return value;
    }

    /**
     * 读取[02 Input Status 1x]类型 开关数据
     *
     * @param slaveId
     * @param offset
     * @return
     * @throws ModbusTransportException
     * @throws ErrorResponseException
     * @throws ModbusInitException
     */
    public static Boolean readInputStatus(ModbusMaster master, int slaveId, int offset) throws ModbusTransportException, ErrorResponseException {
        // 02 Input Status
        BaseLocator<Boolean> loc = BaseLocator.inputStatus(slaveId, offset);
        Boolean value = master.getValue(loc);
        return value;
    }

    /**
     * 读取[03 Holding Register类型 2x]模拟量数据
     *
     * @param slaveId  slave Id
     * @param offset   位置
     * @param dataType 数据类型,来自com.serotonin.modbus4j.code.DataType
     * @return
     * @throws ModbusTransportException 异常
     * @throws ErrorResponseException   异常
     * @throws ModbusInitException      异常
     */
    public static Number readHoldingRegister(ModbusMaster master, int slaveId, int offset, int dataType)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        // 03 Holding Register类型数据读取
        BaseLocator<Number> loc = BaseLocator.holdingRegister(slaveId, offset, dataType);
        Number value = master.getValue(loc);
        return value;
    }

    /**
     * 读取[04 Input Registers 3x]类型 模拟量数据
     *
     * @param slaveId  slaveId
     * @param offset   位置
     * @param dataType 数据类型,来自com.serotonin.modbus4j.code.DataType
     * @return 返回结果
     * @throws ModbusTransportException 异常
     * @throws ErrorResponseException   异常
     * @throws ModbusInitException      异常
     */
    public static Number readInputRegisters(ModbusMaster master, int slaveId, int offset, int dataType)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        // 04 Input Registers类型数据读取
        BaseLocator<Number> loc = BaseLocator.inputRegister(slaveId, offset, dataType);
        Number value = master.getValue(loc);
        return value;
    }

    /**
     * 批量读取使用方法
     *
     * @throws ModbusTransportException
     * @throws ErrorResponseException
     * @throws ModbusInitException
     */
    public static void batchRead(ModbusMaster master, ArrayList data) throws ModbusTransportException, ErrorResponseException, ModbusInitException {

        BatchRead<Integer> batch = new BatchRead<Integer>();

        batch.addLocator(0, BaseLocator.holdingRegister(1, 1, DataType.FOUR_BYTE_FLOAT));
        batch.addLocator(1, BaseLocator.inputStatus(1, 0));


        batch.setContiguousRequests(false);
        BatchResults<Integer> results = master.send(batch);
        System.out.println(results.getValue(0));
        System.out.println(results.getValue(1));
    }
    public static boolean writeCoilTest(ModbusMaster master, int slaveId, int offset, boolean value) {
        boolean values=false;
        try {
            WriteCoilRequest request = new WriteCoilRequest(slaveId, offset, value);
            WriteCoilResponse response = (WriteCoilResponse) master.send(request);

            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else
                System.out.println("功能码:1,写入"+value+"成功!");
            System.out.println(value+"结束"+new Date());
            values=true;
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
        return values;
    }

}

下面是测试类：

package com;


import com.crrcdt.zn.common.utils.Modbus.Modbus4jUtils;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.exception.ErrorResponseException;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;

public class MudbusTest {
    // 输入/输出流
//    private static InputStream inputStream;
//    private static OutputStream outputStream;
    public static void main(String[] args){
        //modbus rtu
        try {
            ModbusMaster master = Modbus4jUtils.getMaster();
//            while (true){
                System.out.println(Modbus4jUtils.readCoilStatus(master,1,0));
            Modbus4jUtils.writeCoilTest(master,1,0,true);
//                System.out.println(Modbus4jUtils.readHoldingRegister(master,1,16, DataType.FOUR_BYTE_FLOAT));
//            }
            master.destroy();

        } catch (ModbusInitException e) {
            e.printStackTrace();
        } catch (ModbusTransportException e) {
            e.printStackTrace();
        } catch (ErrorResponseException e) {
            e.printStackTrace();
        }

    }

}

下面是我调用

package com.crrcdt.zn.zngjx.modbus;


import com.crrcdt.zn.common.utils.Modbus.Modbus4jUtils;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.exception.ErrorResponseException;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;

//import  com.crrcdt.zn.common.utils.ModbusRTU;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;


public class ModbusRTUController {

    /**
     * 写入开门指令
     *
     * @param address
     *          地址
     * @param com
     *         连接的com口
     * @param slaveId
     *         连接的设备地址
     */

    public static boolean writeCoil(){
        boolean returns=false;
        //RTU传输方式
        try {
            ModbusMaster master = Modbus4jUtils.getMaster();
//            while (true){
            System.out.println("开门开始时间"+new Date());
//            System.out.println(Modbus4jUtils.readCoilStatus(master,1,0));
            returns= Modbus4jUtils.writeCoilTest(master,1,0,true);
//                System.out.println(Modbus4jUtils.readHoldingRegister(master,1,16, DataType.FOUR_BYTE_FLOAT));
//            }
            master.destroy();

        } catch (ModbusInitException e) {
            e.printStackTrace();
        }



        return returns;
    }

    public static boolean writeCoil1(){
        boolean returns=false;
        //RTU传输方式
        try {
            ModbusMaster master = Modbus4jUtils.getMaster();
//            while (true){
            System.out.println("关门开始时间"+new Date());
//            System.out.println(Modbus4jUtils.readCoilStatus(master,1,0));
            returns= Modbus4jUtils.writeCoilTest(master,1,0,false);
//                System.out.println(Modbus4jUtils.readHoldingRegister(master,1,16, DataType.FOUR_BYTE_FLOAT));
//            }
            master.destroy();

        } catch (ModbusInitException e) {
            e.printStackTrace();
        }

        return returns;
    }
    /**
     * 读入开门指令
     *
     * @param address
     *          地址
     * @param com
     *         连接的com口
     */
    public static boolean readCoil(){
        boolean returns=false;
        //RTU传输方式
        try {
            ModbusMaster master = Modbus4jUtils.getMaster();
//            while (true){
            System.out.println("读取开始时间"+new Date());
            returns=Modbus4jUtils.readCoilStatus(master,1,0);
//            returns= Modbus4jUtils.writeCoilTest(master,1,0,true);
//                System.out.println(Modbus4jUtils.readHoldingRegister(master,1,16, DataType.FOUR_BYTE_FLOAT));
//            }
            master.destroy();

        } catch (ModbusInitException e) {
            e.printStackTrace();
        } catch (ModbusTransportException e) {
            e.printStackTrace();
        } catch (ErrorResponseException e) {
            e.printStackTrace();
        }
        return returns;
    }

    /**
     * 读多个开门指令
     *
     * @param address
     *          地址
     * @param com
     *         连接的com口
     * @param len
     *         读取长度
     */
//    public boolean[] readCoillist(int address, String com,int len,int slaveId){
//        boolean[] returns=new boolean[len];
//        //RTU传输方式
//        ModbusMaster master =ModbusRTU.getRtuMaster(com);
//        try {
//            //初始化
//            //设置超时时间
//            master.setTimeout(50);
//            //设置重连次数
//            master.setRetries(1);
//            try {
//                master.init();
//            } catch (ModbusInitException e) {
//                e.printStackTrace();
//            }
//            //设置从站ID
////            int slaveId = 1;
//            //开关量读单个数据
//            returns=ModbusRTU.readCoilTest(master, slaveId, address, len);
//        }
//        finally {
//            master.destroy();
//        }
//        return returns;
//    }

    /**
     * 读取保持寄存器数据
     *
     * @param address
     *          地址
     * @param com
     *         连接的com口
     */
//    public static int readHoldingRegisters(int address, String com, int slaveId){
//        int i;
//        //RTU传输方式
//        ModbusMaster master =ModbusRTU.getRtuMaster(com);
//        try {
//            //初始化
//            //设置超时时间
//            master.setTimeout(50);
//            //设置重连次数
//            master.setRetries(100);
//            try {
//                master.init();
//            } catch (ModbusInitException e) {
//                e.printStackTrace();
//            }
//            //设置从站ID
////            int slaveId = 1;
//            //开关量读单个数据
//            short[] returns=ModbusRTU.readHoldingRegistersTest(master, slaveId, address, 1);
//             i=returns[0];
//        }
//        finally {
//            master.destroy();
//        }
//        return i;
//    }

    /**
     * 读取保持寄存器数据
     *  @param address
     *          地址
     * @param com
     * @param slaveId
     */
//    public List<Integer> readHoldingRegisterslist(int address, String com, List<Integer> slaveId){
//        List<Integer>returns=new ArrayList<>();
//        //RTU传输方式
//        ModbusMaster master =ModbusRTU.getRtuMaster(com);
//        try {
//            //初始化
//            //设置超时时间
//            master.setTimeout(50);
//            //设置重连次数
//            master.setRetries(100);
//            try {
//                master.init();
//            } catch (ModbusInitException e) {
//                e.printStackTrace();
//            }
//            //设置从站ID
////            int slaveId = 1;
//            for (int i:slaveId) {
//                //开关量读单个数据
//                short[] returns1 = ModbusRTU.readHoldingRegistersTest(master, i, address, 1);
//                if (returns1!=null&&returns1.length>0){
//                    returns.add((int) returns1[0]);
//                }
//
//            }
//
//        }
//        finally {
//            master.destroy();
//        }
//        return returns;
//    }
}

求大神帮忙！！！