com.serotonin.modbus4j.ModbusMaster Java Examples

public static ModbusMaster createMaster(String ip, int port) {
    ModbusMaster master = null;
    try {
        IpParameters ipParam = new IpParameters();
        ipParam.setHost(ip);
        ipParam.setPort(port);
        ipParam.setEncapsulated(false);
        master = ModbusFactoryInstance.getInstance()
                .createTcpMaster(ipParam, true);
        master.setTimeout(2000);
        master.setRetries(0);
        log.info("Starting Modbus master...");
        master.init();
        log.info("Modbus master started!");
        return master;
    } catch (ModbusInitException e) {
        log.info("Stopping Modbus master...");
        master.destroy();
        log.info("Modbus master stopped!");
    }
    return master;
}
 

/**
 * 获取 Value
 *
 * @param modbusMaster
 * @param pointInfo
 * @return
 * @throws ModbusTransportException
 * @throws ErrorResponseException
 * @throws ModbusInitException
 */
public String readValue(ModbusMaster modbusMaster, Map<String, AttributeInfo> pointInfo, String type) throws ModbusTransportException, ErrorResponseException, ModbusInitException {
    int slaveId = attribute(pointInfo, "slaveId");
    int functionCode = attribute(pointInfo, "functionCode");
    int offset = attribute(pointInfo, "offset");
    switch (functionCode) {
        case 1:
            BaseLocator<Boolean> coilLocator = BaseLocator.coilStatus(slaveId, offset);
            Boolean coilValue = modbusMaster.getValue(coilLocator);
            return String.valueOf(coilValue);
        case 2:
            BaseLocator<Boolean> inputLocator = BaseLocator.inputStatus(slaveId, offset);
            Boolean inputStatusValue = modbusMaster.getValue(inputLocator);
            return String.valueOf(inputStatusValue);
        case 3:
            BaseLocator<Number> holdingLocator = BaseLocator.holdingRegister(slaveId, offset, getValueType(type));
            Number holdingValue = modbusMaster.getValue(holdingLocator);
            return String.valueOf(holdingValue);
        case 4:
            BaseLocator<Number> inputRegister = BaseLocator.inputRegister(slaveId, offset, getValueType(type));
            Number inputRegisterValue = modbusMaster.getValue(inputRegister);
            return String.valueOf(inputRegisterValue);
        default:
            return "0";
    }
}
 

/**
 * 写 Value
 *
 * @param modbusMaster
 * @param pointInfo
 * @param type
 * @param value
 * @return
 * @throws ModbusTransportException
 * @throws ErrorResponseException
 */
public boolean writeValue(ModbusMaster modbusMaster, Map<String, AttributeInfo> pointInfo, String type, String value) throws ModbusTransportException, ErrorResponseException {
    int slaveId = attribute(pointInfo, "slaveId");
    int functionCode = attribute(pointInfo, "functionCode");
    int offset = attribute(pointInfo, "offset");
    switch (functionCode) {
        case 1:
            boolean coilValue = value(type, value);
            WriteCoilRequest coilRequest = new WriteCoilRequest(slaveId, offset, coilValue);
            WriteCoilResponse coilResponse = (WriteCoilResponse) modbusMaster.send(coilRequest);
            if (coilResponse.isException()) {
                return false;
            }
            return true;
        case 3:
            BaseLocator<Number> locator = BaseLocator.holdingRegister(slaveId, offset, getValueType(type));
            modbusMaster.setValue(locator, value(type, value));
            return true;
        default:
            return false;
    }
}
 

public static void writeRegisterTest(ModbusMaster master, int slaveId, int offset, int value) {
    try {
        WriteRegisterRequest request = new WriteRegisterRequest(slaveId, offset, value);
        WriteRegisterResponse response = (WriteRegisterResponse) master.send(request);

        if (response.isException())
            System.out.println("Exception response: message=" + response.getExceptionMessage());
        else
            System.out.println("Success");
    }
    catch (ModbusTransportException e) {
        e.printStackTrace();
    }
}
 

public static void main(String[] args) throws Exception {
  	String commPortId = "COM1";
  	int baudRate = 9600;
  	int flowControlIn = 0;
int flowControlOut = 0; 
int dataBits = 8;
int stopBits = 2;
int parity = 0;
  	
  	TestSerialPortWrapper wrapper = new TestSerialPortWrapper(commPortId, baudRate, flowControlIn, flowControlOut, dataBits, stopBits, parity);

      ModbusMaster master = new ModbusFactory().createRtuMaster(wrapper);
      master.init();

      System.out.println(master.testSlaveNode(5));

      // Define the point locator.
      BaseLocator<Number> loc = BaseLocator.holdingRegister(1, 0, DataType.TWO_BYTE_INT_UNSIGNED);

      // Set the point value
      master.setValue(loc, 1800);

      // Get the point value
      System.out.println(master.getValue(loc));
  }
 

public static void main(String[] args) throws Exception {
    IpParameters params = new IpParameters();
    params.setHost("localhost");
    params.setPort(502);

    ModbusMaster master = new ModbusFactory().createTcpMaster(params, false);
    master.init();

    System.out.println(master.testSlaveNode(5));

    // Define the point locator.
    BaseLocator<Number> loc = BaseLocator.holdingRegister(1, 0, DataType.TWO_BYTE_INT_UNSIGNED);

    // Set the point value
    master.setValue(loc, 1800);

    // Get the point value
    System.out.println(master.getValue(loc));
}
 

public static void writeMaskRegisterTest(ModbusMaster master, int slaveId, int offset, int and, int or) {
    try {
        WriteMaskRegisterRequest request = new WriteMaskRegisterRequest(slaveId, offset, and, or);
        WriteMaskRegisterResponse response = (WriteMaskRegisterResponse) master.send(request);

        if (response.isException())
            System.out.println("Exception response: message=" + response.getExceptionMessage());
        else
            System.out.println("Success");
    }
    catch (ModbusTransportException e) {
        e.printStackTrace();
    }
}
 

public static void writeRegistersTest(ModbusMaster master, int slaveId, int start, short[] values) {
    try {
        WriteRegistersRequest request = new WriteRegistersRequest(slaveId, start, values);
        WriteRegistersResponse response = (WriteRegistersResponse) master.send(request);

        if (response.isException())
            System.out.println("Exception response: message=" + response.getExceptionMessage());
        else
            System.out.println("Success");
    }
    catch (ModbusTransportException e) {
        e.printStackTrace();
    }
}
 

public static void writeCoilsTest(ModbusMaster master, int slaveId, int start, boolean[] values) {
    try {
        WriteCoilsRequest request = new WriteCoilsRequest(slaveId, start, values);
        WriteCoilsResponse response = (WriteCoilsResponse) master.send(request);

        if (response.isException())
            System.out.println("Exception response: message=" + response.getExceptionMessage());
        else
            System.out.println("Success");
    }
    catch (ModbusTransportException e) {
        e.printStackTrace();
    }
}
 

public static void reportSlaveIdTest(ModbusMaster master, int slaveId) {
    try {
        ReportSlaveIdRequest request = new ReportSlaveIdRequest(slaveId);
        ReportSlaveIdResponse response = (ReportSlaveIdResponse) master.send(request);

        if (response.isException())
            System.out.println("Exception response: message=" + response.getExceptionMessage());
        else
            System.out.println(Arrays.toString(response.getData()));
    }
    catch (ModbusTransportException e) {
        e.printStackTrace();
    }
}
 

public static void readExceptionStatusTest(ModbusMaster master, int slaveId) {
    try {
        ReadExceptionStatusRequest request = new ReadExceptionStatusRequest(slaveId);
        ReadExceptionStatusResponse response = (ReadExceptionStatusResponse) master.send(request);

        if (response.isException())
            System.out.println("Exception response: message=" + response.getExceptionMessage());
        else
            System.out.println(response.getExceptionStatus());
    }
    catch (ModbusTransportException e) {
        e.printStackTrace();
    }
}
 

public static void main(String[] args) throws MqttException {
    /**
     * ModBusMaster主要读取类
     */
    ModbusMaster modbusMaster = ModbusUtil.createMaster("127.0.0.1", 502);

    final String serverUrl = "tcp://127.0.0.1:1883";
    final String clientId = "mqtt_client_id";
    final String deviceName = "mqtt_client_name";

    final MqttClient client = new MqttClient(serverUrl, clientId, null);
    client.connect();

    log.info("The device " + deviceName + " has been registered successfully!");

    Executors.newSingleThreadScheduledExecutor()
            .scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                try {
                    BatchResults<String> results = ModbusUtil.batchRead(modbusMaster, batch());
                    log.info("slave id 1 读取结果为: " + results);
                    client.publish("v1/devices/me/telemetry", new MqttMessage(String.valueOf(results).getBytes()));
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
    }, 1, 7, TimeUnit.SECONDS);

}
 

public static void writeCoilTest(ModbusMaster master, int slaveId, int offset, boolean value) {
    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("Success");
    }
    catch (ModbusTransportException e) {
        e.printStackTrace();
    }
}
 

public static void readInputRegistersTest(ModbusMaster master, int slaveId, int start, int len) {
    try {
        ReadInputRegistersRequest request = new ReadInputRegistersRequest(slaveId, start, len);
        ReadInputRegistersResponse response = (ReadInputRegistersResponse) master.send(request);

        if (response.isException())
            System.out.println("Exception response: message=" + response.getExceptionMessage());
        else
            System.out.println(Arrays.toString(response.getShortData()));
    }
    catch (ModbusTransportException e) {
        e.printStackTrace();
    }
}
 

public static void readHoldingRegistersTest(ModbusMaster master, int slaveId, int start, int len) {
    try {
        ReadHoldingRegistersRequest request = new ReadHoldingRegistersRequest(slaveId, start, len);
        ReadHoldingRegistersResponse response = (ReadHoldingRegistersResponse) master.send(request);

        if (response.isException())
            System.out.println("Exception response: message=" + response.getExceptionMessage());
        else
            System.out.println(Arrays.toString(response.getShortData()));
    }
    catch (ModbusTransportException e) {
        e.printStackTrace();
    }
}
 

public static void readDiscreteInputTest(ModbusMaster master, int slaveId, int start, int len) {
    try {
        ReadDiscreteInputsRequest request = new ReadDiscreteInputsRequest(slaveId, start, len);
        ReadDiscreteInputsResponse response = (ReadDiscreteInputsResponse) master.send(request);

        if (response.isException())
            System.out.println("Exception response: message=" + response.getExceptionMessage());
        else
            System.out.println(Arrays.toString(response.getBooleanData()));
    }
    catch (ModbusTransportException e) {
        e.printStackTrace();
    }
}
 

public static void readCoilTest(ModbusMaster master, int slaveId, int start, int len) {
    try {
        ReadCoilsRequest request = new ReadCoilsRequest(slaveId, start, len);
        ReadCoilsResponse response = (ReadCoilsResponse) master.send(request);

        if (response.isException())
            System.out.println("Exception response: message=" + response.getExceptionMessage());
        else
            System.out.println(Arrays.toString(response.getBooleanData()));
    }
    catch (ModbusTransportException e) {
        e.printStackTrace();
    }
}
 

/**
 * 获取 Modbus Master
 *
 * @param deviceId
 * @param driverInfo
 * @return
 * @throws ModbusInitException
 */
public ModbusMaster getMaster(Long deviceId, Map<String, AttributeInfo> driverInfo) throws ModbusInitException {
    log.debug("Modbus Tcp Connection Info {}", JSON.toJSONString(driverInfo));
    ModbusMaster modbusMaster = masterMap.get(deviceId);
    if (null == modbusMaster || !modbusMaster.isConnected()) {
        IpParameters params = new IpParameters();
        params.setHost(attribute(driverInfo, "host"));
        params.setPort(attribute(driverInfo, "port"));
        modbusMaster = modbusFactory.createTcpMaster(params, true);
        modbusMaster.init();
        masterMap.put(deviceId, modbusMaster);
    }
    return modbusMaster;
}
 

@Override
@SneakyThrows
public Boolean write(Map<String, AttributeInfo> driverInfo, Map<String, AttributeInfo> pointInfo, Device device, AttributeInfo value) {
    ModbusMaster modbusMaster = getMaster(device.getId(), driverInfo);
    return writeValue(modbusMaster, pointInfo, value.getType(), value.getValue());
}
 

@Override
@SneakyThrows
public String read(Map<String, AttributeInfo> driverInfo, Map<String, AttributeInfo> pointInfo, Device device, Point point) {
    ModbusMaster modbusMaster = getMaster(device.getId(), driverInfo);
    return readValue(modbusMaster, pointInfo, point.getType());
}
 

public static void main(String[] args) throws Exception {

    	String commPortId = "COM1";
    	int baudRate = 9600;
    	int flowControlIn = 0;
		int flowControlOut = 0; 
		int dataBits = 8;
		int stopBits = 2;
		int parity = 0;
    	
    	TestSerialPortWrapper wrapper = new TestSerialPortWrapper(commPortId, baudRate, flowControlIn, flowControlOut, dataBits, stopBits, parity);
        
        IpParameters ipParameters = new IpParameters();
        ipParameters.setHost("localhost");

        ModbusFactory modbusFactory = new ModbusFactory();

        // ModbusMaster master = modbusFactory.createRtuMaster(wrapper, false);
        // ModbusMaster master = modbusFactory.createAsciiMaster(wrapper);
        ModbusMaster master = modbusFactory.createTcpMaster(ipParameters, false);
        // ModbusMaster master = modbusFactory.createUdpMaster(ipParameters);

        try {
            master.init();
            int slaveId = 241;

            // readCoilTest(master, slaveId, 98, 200);
            // readCoilTest(master, slaveId, 99, 200);
            // readDiscreteInputTest(master, slaveId, 100, 2);
            // readDiscreteInputTest(master, slaveId, 449, 72);
            // readHoldingRegistersTest(master, slaveId, 9, 125);
            // readHoldingRegistersTest(master, slaveId, 9, 120);
            // readInputRegistersTest(master, slaveId, 0, 1);
            // readInputRegistersTest(master, slaveId, 14, 8);
            // writeCoilTest(master, slaveId, 1, true);
            // writeCoilTest(master, slaveId, 110, true);
            // writeRegisterTest(master, slaveId, 1, 1);
            // writeRegisterTest(master, slaveId, 14, 12345);
            // readExceptionStatusTest(master, slaveId);
            // reportSlaveIdTest(master, slaveId);
            // writeCoilsTest(master, slaveId, 50, new boolean[] {true, false, false, true, false});
            // writeCoilsTest(master, slaveId, 115, new boolean[] {true, false, false, true, false});
            // writeRegistersTest(master, slaveId, 300, new short[] {1, 10, 100, 1000, 10000, (short)65535});
            // writeRegistersTest(master, slaveId, 21, new short[] {1, 10, 100, 1000, 10000, (short)65535});
            // writeMaskRegisterTest(master, slaveId, 26, 0xf2, 0x25);

            // readCoilTest(master, slaveId, 9, 5);
            // readCoilTest(master, slaveId, 10, 5);
            // readDiscreteInputTest(master, slaveId, 10, 6);
            // readDiscreteInputTest(master, slaveId, 10, 5);
            // readHoldingRegistersTest(master, slaveId, 9, 7);
            // readHoldingRegistersTest(master, slaveId, 10, 5);
            // readInputRegistersTest(master, slaveId, 0, 1);
            // readInputRegistersTest(master, slaveId, 10, 5);
            // writeCoilTest(master, slaveId, 8, true);
            // writeCoilTest(master, slaveId, 11, true);
            // writeRegisterTest(master, slaveId, 1, 1);
            // writeRegisterTest(master, slaveId, 14, 12345);
            // readExceptionStatusTest(master, slaveId);
            // reportSlaveIdTest(master, slaveId);
            // writeCoilsTest(master, slaveId, 11, new boolean[] {false, true, false, false, true});
            // writeCoilsTest(master, slaveId, 10, new boolean[] {false, true, false, false, true});
            // writeRegistersTest(master, slaveId, 11, new short[] {(short)65535, 1000, 100, 10, 1});
            // writeRegistersTest(master, slaveId, 10, new short[] {(short)65535, 1000, 100, 10, 1});
            // writeMaskRegisterTest(master, slaveId, 9, 0xf2, 0x25);
            // writeMaskRegisterTest(master, slaveId, 10, 0xf2, 0x25);

            // Automatic WriteMaskRegister failover test
            // ModbusLocator locator = new ModbusLocator(slaveId, RegisterRange.HOLDING_REGISTER, 15, (byte)2);
            // System.out.println(master.getValue(locator));
            // master.setValue(locator, true);
            // System.out.println(master.getValue(locator));
            // master.setValue(locator, false);
            // System.out.println(master.getValue(locator));

            // BatchRead<String> batch = new BatchRead<String>();
            // batch.addLocator("hr1", new ModbusLocator(31, RegisterRange.HOLDING_REGISTER, 80,
            // DataType.TWO_BYTE_BCD));
            // batch.addLocator("hr2", new ModbusLocator(31, RegisterRange.HOLDING_REGISTER, 81,
            // DataType.FOUR_BYTE_BCD));
            // BatchResults<String> results = master.send(batch);
            // System.out.println(results.getValue("hr1"));
            // System.out.println(results.getValue("hr2"));

            BaseLocator<Number> locator = BaseLocator.holdingRegister(slaveId, 50, DataType.EIGHT_BYTE_INT_UNSIGNED);
            master.setValue(locator, 10000000);
            System.out.println(master.getValue(locator));
        }
        finally {
            master.destroy();
        }
    }
 

public static void main(String[] args) throws Exception {

    	String commPortId = "COM1";
    	int baudRate = 9600;
    	int flowControlIn = 0;
		int flowControlOut = 0; 
		int dataBits = 8;
		int stopBits = 2;
		int parity = 0;
    	
    	TestSerialPortWrapper wrapper = new TestSerialPortWrapper(commPortId, baudRate, flowControlIn, flowControlOut, dataBits, stopBits, parity);
        ModbusMaster master = new ModbusFactory().createRtuMaster(wrapper);
        master.setTimeout(200);
        master.setRetries(1);
        master.init();

        for (int i = 1; i < 5; i++) {
            long start = System.currentTimeMillis();
            System.out.print("Testing " + i + "... ");
            System.out.println(master.testSlaveNode(i));
            System.out.println("Time: " + (System.currentTimeMillis() - start));
        }

        // try {
        // System.out.println(master.send(new ReadHoldingRegistersRequest(1, 0, 1)));
        // }
        // catch (Exception e) {
        // e.printStackTrace();
        // }

        // try {
        // // ReadCoilsRequest request = new ReadCoilsRequest(2, 65534, 1);
        // ReadHoldingRegistersResponse response = (ReadHoldingRegistersResponse) master
        // .send(new ReadHoldingRegistersRequest(2, 0, 1));
        // System.out.println(response);
        // }
        // catch (Exception e) {
        // e.printStackTrace();
        // }

        // System.out.println(master.scanForSlaveNodes());

        master.destroy();
    }
 

public static void main(String[] args) {
    BatchRead<Integer> batch;
    int index;
    boolean contiguous = true;

    ModbusMaster master = new ModbusFactory().createUdpMaster(null);
    master.setMaxReadBitCount(100);
    master.setMaxReadRegisterCount(11);

    batch = new BatchRead<Integer>();
    index = 0;
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 0, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 50, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 100, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 150, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 200, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 250, DataType.CHAR, 50));
    batch.setContiguousRequests(contiguous);
    batch.getReadFunctionGroups(master);

    batch = new BatchRead<Integer>();
    index = 0;
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 0, DataType.CHAR, 49));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 50, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 100, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 150, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 200, DataType.CHAR, 49));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 250, DataType.CHAR, 50));
    batch.setContiguousRequests(contiguous);
    batch.getReadFunctionGroups(master);

    batch = new BatchRead<Integer>();
    index = 0;
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 0, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 50, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 100, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 100, DataType.CHAR, 25));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 150, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 200, DataType.CHAR, 50));
    batch.addLocator(index++, new StringLocator(1, RegisterRange.HOLDING_REGISTER, 250, DataType.CHAR, 50));
    batch.setContiguousRequests(contiguous);
    batch.getReadFunctionGroups(master);
}
 

public static void main(String[] args) throws Exception {
    IpParameters ipParameters = new IpParameters();
    ipParameters.setHost("localhost");
    // ipParameters.setHost("99.247.60.96");
    // ipParameters.setHost("193.109.41.121");
    //ipParameters.setHost("141.211.194.29");
    ipParameters.setPort(502);

    ModbusFactory modbusFactory = new ModbusFactory();
    // ModbusMaster master = modbusFactory.createTcpMaster(ipParameters, true);
    ModbusMaster master = modbusFactory.createTcpMaster(ipParameters, false);
    master.setTimeout(4000);
    master.setRetries(1);

    BatchRead<Integer> batch = new BatchRead<Integer>();
    //        batch.addLocator(0, new ModbusLocator(1, RegisterRange.COIL_STATUS, 2048, DataType.BINARY));
    //        batch.addLocator(1, new ModbusLocator(1, RegisterRange.COIL_STATUS, 2049, DataType.BINARY));
    //        batch.addLocator(2, new ModbusLocator(1, RegisterRange.COIL_STATUS, 2050, DataType.BINARY));
    //        batch.addLocator(3, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3584, DataType.BINARY));
    //        batch.addLocator(4, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3585, DataType.BINARY));
    //        batch.addLocator(5, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3648, DataType.BINARY));
    //        batch.addLocator(6, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3649, DataType.BINARY));
    //        batch.addLocator(7, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3650, DataType.BINARY));
    //        batch.addLocator(8, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3651, DataType.BINARY));
    //        batch.addLocator(9, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3652, DataType.BINARY));
    //        batch.addLocator(10, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3653, DataType.BINARY));
    //        batch.addLocator(11, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3654, DataType.BINARY));
    //        batch.addLocator(12, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3661, DataType.BINARY));
    //        batch.addLocator(13, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3662, DataType.BINARY));
    //        batch.addLocator(15, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3665, DataType.BINARY));
    //        batch.addLocator(16, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3668, DataType.BINARY));
    //        batch.addLocator(18, new ModbusLocator(1, RegisterRange.COIL_STATUS, 3969, DataType.BINARY));

    batch.addLocator(0, BaseLocator.holdingRegister(5, 80, DataType.TWO_BYTE_INT_SIGNED));
    batch.addLocator(1, BaseLocator.holdingRegister(5, 202, DataType.EIGHT_BYTE_INT_SIGNED));

    try {
        master.init();

        while (true) {
            batch.setContiguousRequests(false);
            BatchResults<Integer> results = master.send(batch);
            System.out.println(results.getValue(0));
            System.out.println(results.getValue(1));

            Thread.sleep(2000);
        }
    }
    catch (ErrorResponseException e) {
        System.out.println(e.getErrorResponse().getExceptionMessage());
    }
    finally {
        master.destroy();
    }
}
 

public static void main(String[] args) throws Exception {
    IpParameters ipParameters = new IpParameters();
    // ipParameters.setHost("99.247.60.96");
    // ipParameters.setHost("193.109.41.121");
    //      ipParameters.setHost("10.241.224.195");
    ipParameters.setHost("172.19.40.10");
    ipParameters.setPort(502);
    ipParameters.setEncapsulated(false);

    ModbusFactory modbusFactory = new ModbusFactory();
    // ModbusMaster master = modbusFactory.createTcpMaster(ipParameters, true);
    ModbusMaster master = modbusFactory.createTcpMaster(ipParameters, false);
    master.setTimeout(8000);
    master.setRetries(0);
    master.init();

    //        for (int i = 1; i < 5; i++) {
    //            System.out.print("Testing " + i + "... ");
    //            System.out.println(master.testSlaveNode(i));
    //        }

    NumericLocator el = new NumericLocator(1, RegisterRange.HOLDING_REGISTER, 22, DataType.FOUR_BYTE_FLOAT);
    NumericLocator fjk = new NumericLocator(1, RegisterRange.HOLDING_REGISTER, 36, DataType.FOUR_BYTE_FLOAT);

    for (int i = 0; i < 3; i++) {
        try {
            System.out.println("el: " + master.getValue(el));
            System.out.println("fjk: " + master.getValue(fjk));
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    // try {
    // // ReadCoilsRequest request = new ReadCoilsRequest(2, 65534, 1);
    // ReadHoldingRegistersResponse response = (ReadHoldingRegistersResponse) master
    // .send(new ReadHoldingRegistersRequest(2, 0, 1));
    // System.out.println(response);
    // }
    // catch (Exception e) {
    // e.printStackTrace();
    // }

    // System.out.println(master.scanForSlaveNodes());

    master.destroy();
}
 

public static void main(String[] args) throws Exception {
    IpParameters tcpParameters = new IpParameters();
    tcpParameters.setHost("localhost");

    ModbusFactory modbusFactory = new ModbusFactory();
    ModbusMaster master = modbusFactory.createTcpMaster(tcpParameters, true);

    try {
        BatchRead<String> batchRead = new BatchRead<String>();
        int slaveId = 31;
        batchRead.addLocator("00011 sb true", BaseLocator.coilStatus(slaveId, 10));
        batchRead.addLocator("00012 sb false", BaseLocator.coilStatus(slaveId, 11));
        batchRead.addLocator("00013 sb true", BaseLocator.coilStatus(slaveId, 12));
        batchRead.addLocator("00014 sb true", BaseLocator.coilStatus(slaveId, 13));

        batchRead.addLocator("10011 sb false", BaseLocator.inputStatus(slaveId, 10));
        batchRead.addLocator("10012 sb false", BaseLocator.inputStatus(slaveId, 11));
        batchRead.addLocator("10013 sb true", BaseLocator.inputStatus(slaveId, 12));
        batchRead.addLocator("10014 sb false", BaseLocator.inputStatus(slaveId, 13));

        batchRead.addLocator("40016-0 sb true", BaseLocator.holdingRegisterBit(slaveId, 40016, 0));
        batchRead.addLocator("40016-1 sb false", BaseLocator.holdingRegisterBit(slaveId, 40016, 1));
        batchRead.addLocator("40016-2 sb false", BaseLocator.holdingRegisterBit(slaveId, 40016, 2));
        batchRead.addLocator("40016-3 sb true", BaseLocator.holdingRegisterBit(slaveId, 40016, 3));
        batchRead.addLocator("40016-4 sb false", BaseLocator.holdingRegisterBit(slaveId, 40016, 4));
        batchRead.addLocator("40016-5 sb false", BaseLocator.holdingRegisterBit(slaveId, 40016, 5));
        batchRead.addLocator("40016-6 sb false", BaseLocator.holdingRegisterBit(slaveId, 40016, 6));
        batchRead.addLocator("40016-7 sb true", BaseLocator.holdingRegisterBit(slaveId, 40016, 7));
        batchRead.addLocator("40016-8 sb true", BaseLocator.holdingRegisterBit(slaveId, 40016, 8));
        batchRead.addLocator("40016-9 sb false", BaseLocator.holdingRegisterBit(slaveId, 40016, 9));
        batchRead.addLocator("40016-a sb false", BaseLocator.holdingRegisterBit(slaveId, 40016, 10));
        batchRead.addLocator("40016-b sb false", BaseLocator.holdingRegisterBit(slaveId, 40016, 11));
        batchRead.addLocator("40016-c sb false", BaseLocator.holdingRegisterBit(slaveId, 40016, 12));
        batchRead.addLocator("40016-d sb false", BaseLocator.holdingRegisterBit(slaveId, 40016, 13));
        batchRead.addLocator("40016-e sb true", BaseLocator.holdingRegisterBit(slaveId, 40016, 14));
        batchRead.addLocator("40016-f sb false", BaseLocator.holdingRegisterBit(slaveId, 40016, 15));

        batchRead.addLocator("30016-0 sb true", BaseLocator.inputRegisterBit(slaveId, 30016, 0));
        batchRead.addLocator("30016-1 sb false", BaseLocator.inputRegisterBit(slaveId, 30016, 1));
        batchRead.addLocator("30016-2 sb false", BaseLocator.inputRegisterBit(slaveId, 30016, 2));
        batchRead.addLocator("30016-3 sb false", BaseLocator.inputRegisterBit(slaveId, 30016, 3));
        batchRead.addLocator("30016-4 sb false", BaseLocator.inputRegisterBit(slaveId, 30016, 4));
        batchRead.addLocator("30016-5 sb false", BaseLocator.inputRegisterBit(slaveId, 30016, 5));
        batchRead.addLocator("30016-6 sb false", BaseLocator.inputRegisterBit(slaveId, 30016, 6));
        batchRead.addLocator("30016-7 sb true", BaseLocator.inputRegisterBit(slaveId, 30016, 7));
        batchRead.addLocator("30016-8 sb true", BaseLocator.inputRegisterBit(slaveId, 30016, 8));
        batchRead.addLocator("30016-9 sb false", BaseLocator.inputRegisterBit(slaveId, 30016, 9));
        batchRead.addLocator("30016-a sb false", BaseLocator.inputRegisterBit(slaveId, 30016, 10));
        batchRead.addLocator("30016-b sb false", BaseLocator.inputRegisterBit(slaveId, 30016, 11));
        batchRead.addLocator("30016-c sb false", BaseLocator.inputRegisterBit(slaveId, 30016, 12));
        batchRead.addLocator("30016-d sb false", BaseLocator.inputRegisterBit(slaveId, 30016, 13));
        batchRead.addLocator("30016-e sb false", BaseLocator.inputRegisterBit(slaveId, 30016, 14));
        batchRead.addLocator("30016-f sb true", BaseLocator.inputRegisterBit(slaveId, 30016, 15));

        batchRead.addLocator("40017 sb -1968",
                BaseLocator.holdingRegister(slaveId, 40017, DataType.TWO_BYTE_INT_SIGNED));
        batchRead.addLocator("40018 sb -123456789",
                BaseLocator.holdingRegister(slaveId, 40018, DataType.FOUR_BYTE_INT_SIGNED));
        batchRead.addLocator("40020 sb -123456789",
                BaseLocator.holdingRegister(slaveId, 40020, DataType.FOUR_BYTE_INT_SIGNED_SWAPPED));
        batchRead.addLocator("40022 sb 1968.1968",
                BaseLocator.holdingRegister(slaveId, 40022, DataType.FOUR_BYTE_FLOAT));
        batchRead.addLocator("40024 sb -123456789",
                BaseLocator.holdingRegister(slaveId, 40024, DataType.EIGHT_BYTE_INT_SIGNED));
        batchRead.addLocator("40028 sb -123456789",
                BaseLocator.holdingRegister(slaveId, 40028, DataType.EIGHT_BYTE_INT_SIGNED_SWAPPED));
        batchRead.addLocator("40032 sb 1968.1968",
                BaseLocator.holdingRegister(slaveId, 40032, DataType.EIGHT_BYTE_FLOAT));

        batchRead.addLocator("30017 sb -1968 tc",
                BaseLocator.inputRegister(slaveId, 30017, DataType.TWO_BYTE_INT_UNSIGNED));
        batchRead.addLocator("30018 sb -123456789 tc",
                BaseLocator.inputRegister(slaveId, 30018, DataType.FOUR_BYTE_INT_UNSIGNED));
        batchRead.addLocator("30020 sb -123456789 tc",
                BaseLocator.inputRegister(slaveId, 30020, DataType.FOUR_BYTE_INT_UNSIGNED_SWAPPED));
        batchRead.addLocator("30022 sb 1968.1968",
                BaseLocator.inputRegister(slaveId, 30022, DataType.FOUR_BYTE_FLOAT_SWAPPED));
        batchRead.addLocator("30024 sb -123456789 tc",
                BaseLocator.inputRegister(slaveId, 30024, DataType.EIGHT_BYTE_INT_UNSIGNED));
        batchRead.addLocator("30028 sb -123456789 tc",
                BaseLocator.inputRegister(slaveId, 30028, DataType.EIGHT_BYTE_INT_UNSIGNED_SWAPPED));
        batchRead.addLocator("30032 sb 1968.1968",
                BaseLocator.inputRegister(slaveId, 30032, DataType.EIGHT_BYTE_FLOAT_SWAPPED));

        master.init();

        BatchResults<String> results = master.send(batchRead);

        System.out.println(results);
    }
    finally {
        master.destroy();
    }
}