modbus master

src/main/java/at/acdp/urweb/fhpp/FHMaster.java

@@ -0,0 +1,117 @@
+
+
+package at.acdp.urweb.fhpp;
+
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import com.digitalpetri.modbus.codec.Modbus;
+import com.digitalpetri.modbus.master.ModbusTcpMaster;
+import com.digitalpetri.modbus.master.ModbusTcpMasterConfig;
+import com.digitalpetri.modbus.requests.ReadHoldingRegistersRequest;
+import com.digitalpetri.modbus.requests.WriteMultipleRegistersRequest;
+import com.digitalpetri.modbus.requests.WriteSingleRegisterRequest;
+import com.digitalpetri.modbus.responses.ReadHoldingRegistersResponse;
+import io.netty.buffer.ByteBuf;
+import io.netty.util.ReferenceCountUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class FHMaster {
+
+    public static void main(String[] args) {
+        new FHMaster(100, 100).start();
+    }
+
+    private final Logger logger = LoggerFactory.getLogger(getClass());
+
+    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+
+    private final List<ModbusTcpMaster> masters = new CopyOnWriteArrayList<>();
+    private volatile boolean started = false;
+
+    private final int nMasters;
+    private final int nRequests;
+
+    public FHMaster(int nMasters, int nRequests) {
+        this.nMasters = nMasters;
+        this.nRequests = nRequests;
+    }
+
+    public void start() {
+        started = true;
+
+        ModbusTcpMasterConfig config = new ModbusTcpMasterConfig.Builder("10.0.31.14")
+                .setPort(502)
+                .build();
+
+        new Thread(() -> {
+            while (started) {
+                try {
+                    Thread.sleep(5000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+
+                double mean = 0.0;
+                double oneMinute = 0.0;
+
+                for (ModbusTcpMaster master : masters) {
+                    mean += master.getResponseTimer().getMeanRate();
+                    oneMinute += master.getResponseTimer().getOneMinuteRate();
+                }
+
+                logger.info("Mean rate={}, 1m rate={}", mean, oneMinute);
+            }
+        }).start();
+
+        ModbusTcpMaster master = new ModbusTcpMaster(config);
+        master.connect();
+        sendAndReceive(master);
+
+    }
+
+    private void sendAndReceive(ModbusTcpMaster master) {
+        if (!started) return;
+
+        CompletableFuture<ReadHoldingRegistersResponse> future =
+        master.sendRequest(new ReadHoldingRegistersRequest(0,4), 0);
+        //master.sendRequest(new WriteMultipleRegistersRequest(0,4, new byte[]{0x01,0,0,0,0,0,0,0}), 0);
+
+        //master.sendRequest(new ReadWriteMultipleRegisters(0, 4), 0);
+
+
+        future.whenCompleteAsync((response, ex) -> {
+            if (response != null) {
+                ReferenceCountUtil.release(response);
+                try {
+
+
+                    var reg = response.getRegisters();
+                    byte[] bytes = new byte[reg.readableBytes()];
+                    System.out.println(String.format("%02X", bytes));
+                }
+                catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+                else {
+                logger.error("Completed exceptionally, message={}", ex.getMessage(), ex);
+            }
+            scheduler.schedule(() -> sendAndReceive(master), 1, TimeUnit.SECONDS);
+        }, Modbus.sharedExecutor());
+    }
+
+    public void stop() {
+        started = false;
+        masters.forEach(ModbusTcpMaster::disconnect);
+        masters.clear();
+    }
+
+}