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

package at.acdp.urweb.fhpp;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

import com.digitalpetri.modbus.codec.Modbus;
import com.digitalpetri.modbus.master.ModbusTcpMaster;
import com.digitalpetri.modbus.master.ModbusTcpMasterConfig;
import com.digitalpetri.modbus.requests.*;
import com.digitalpetri.modbus.responses.ReadHoldingRegistersResponse;
import io.netty.util.ReferenceCountUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class FHMaster {
    public static int posfaktorNum=1;
    public static int posfaktorDiv=1;
    private ModbusTcpMaster master;



    public static void main(String[] args) {
        try {
            new FHMaster().start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private final Logger logger = LoggerFactory.getLogger(getClass());
    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
    private volatile boolean started = false;
    public FHMaster() {
    }

    public void start() throws InterruptedException {
        started = true;
        ModbusTcpMasterConfig config = new ModbusTcpMasterConfig.Builder("10.0.31.14")
                .setPort(502)
                .build();
        master = new ModbusTcpMaster(config);
        // var f=master.connect()
      //          .whenComplete((result, ex) -> bereitschaft(master))
      //          .whenComplete((result, ex) -> direktAuftrag(master,100));



        while(true) {
            Thread.sleep(1000);
            readStatus();
        }
    }

    private void sendRequests(ModbusTcpMaster master, List<ModbusRequest> reqs) {
        for(var req: reqs) {
            var future=master.sendRequest(req, 0);
            future.whenCompleteAsync((response, ex) -> {
                if (response != null) {
                    ReferenceCountUtil.release(response);
                }
                else {
                    logger.error("Completed exceptionally, message={}", ex.getMessage(), ex);
                }
            }, Modbus.sharedExecutor());
        }
    }

    void direktAuftrag(ModbusTcpMaster master, int pos) {
        byte ccon=0x0;
        ccon|=(1<<0); //Enable drive
        ccon|=(0<<1); //Stop
        ccon|=(1<<2); //Release Brake
        ccon|=(0<<3); //Reset fault
        ccon|=(0<<4); //Reserved
        ccon|=(0<<5); //lock software
        ccon|=(0<<6 | 1 <<7); //lock software
                            // 0,0 Satzselektion
                            // 1,0 Direktauftrag
                            // 0,1 Reserviert
                            // 1,1 Reserviert

        byte cpos=0x0;
        ccon|=(1<<0); // !Halt
        ccon|=(1<<1); // start fahrauftrag
        ccon|=(0<<2); // start homing
        ccon|=(0<<3); // jog pos
        ccon|=(0<<4); // jog neg
        ccon|=(0<<5); //  teach value
        ccon|=(0<<6); //  clear remaining pos.
        ccon|=(0<<7); //  Reserved

        byte cdir=0x0;
        cdir|=(1<<0); //absolute/relative
        cdir|= (1<<1| 1<<2); //absolute/relative
                                // 0,0 Positionsregelung
                                // 0,1 Kraftbetrieb
                                // 1,0 Geschwindigkeitsregelung
                                // 1,1 Reserviert
        cdir|=(1<<3);   // Function Number Kurvenscheibenfunktion (0=nein)
        cdir|=(1<<5);   // Function Group Kurvenscheibenfunktion (0=nein)
        cdir|=(1<<7);   // 0 = normal; 1=kurvenscheibenfunktion

        byte sbyte4=100; // Geschw, in % vom Basiswert (PNU540
        byte sbyte5= (byte)(pos& 0xff);
        byte sbyte6= (byte)(pos>>8 & 0xff);
        byte sbyte7= (byte)(pos>>16 & 0xff);
        byte sbyte8= (byte)(pos>>24 & 0xff);

        CompletableFuture<ReadHoldingRegistersResponse> f =
                master.sendRequest(new WriteMultipleRegistersRequest(0,4, new byte[]{
                        ccon,
                        cpos,
                        cdir,
                        sbyte4,
                        sbyte5,
                        sbyte6,
                        sbyte7,
                        sbyte8}), 0);
    }

    public CompletableFuture<Status> readStatus() {
        if(master==null)
            return null;
        CompletableFuture<ReadHoldingRegistersResponse> f =master.sendRequest(new ReadHoldingRegistersRequest(0,4), 0);

        CompletableFuture<Status> fc= f.thenApply((response) -> {
            if (response != null) {
                var bb=response.getRegisters();
                try {
                    byte[] bytes = new byte[bb.readableBytes()];
                    bb.readBytes(bytes);
                    Status s=new Status();
                    s.read(bytes);
                    return s;
                    // System.out.println(s.toString());
                    // System.out.println(ByteBufUtil.hexDump(bb));
                }
                catch (Exception e) {
                    e.printStackTrace();
                }
                ReferenceCountUtil.release(response);
            }
            else {
                logger.error("Completed exceptionally, message={}", "null");
            }
            return null;
        });
        return  fc;
    }

    private void bereitschaft(ModbusTcpMaster master) {
        List<ModbusRequest> blist = new ArrayList<>();
        blist.add(new WriteMultipleRegistersRequest(0,4, new byte[]{0x01,0,0,0,0,0,0,0}));
        blist.add(new WriteMultipleRegistersRequest(0,4, new byte[]{0x11,0,0,0,0,0,0,0}));
        blist.add(new WriteMultipleRegistersRequest(0,4, new byte[]{0x01,0,0,0,0,0,0,0}));
        sendRequests(master, blist);
    }

    public void stop() {
        started = false;
    }

}