ModBusConnectionManager.java

package kernel.modbus;

import com.ghgande.j2mod.modbus.io.ModbusSerialTransaction;
import com.ghgande.j2mod.modbus.io.ModbusTransaction;
import com.ghgande.j2mod.modbus.msg.ModbusMessage;
import com.ghgande.j2mod.modbus.msg.ModbusRequest;
import com.ghgande.j2mod.modbus.msg.ModbusResponse;
import com.ghgande.j2mod.modbus.net.SerialConnection;
import exceptions.WrappedModbusException;
import org.jetbrains.annotations.Contract;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.DataInput;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.DataOutput;

public class ModBusConnectionManager implements ModbusConnector {

    private static final Logger log = LoggerFactory.getLogger(
            ModBusConnectionManager.class);

    private ModbusPortConfiguration desiredPortConfiguration;

    private PortShutdownThread portShutdownThread;

    private SerialConnection connection;

    private static final Integer recieveTimeOut = 4000;

    private static final Integer numberOfRetries = 1;

    @Override
    public ModbusPortConfiguration getPortConfiguration(){
        return this.desiredPortConfiguration;
    }

    @Override
    public void setPortConfiguration(
            ModbusPortConfiguration portConfiguration
    ){
        desiredPortConfiguration = portConfiguration;
    }

    @Override
    public Boolean isPortOpen(){
        if (connection == null){
            return Boolean.FALSE;
        } else {
            return connection.isOpen();
        }
    }

    @Override
    public void close(){
        connection.close();
        removeShutdownThread();
    }

    @Override
    public ModbusTransaction getTransactionForRequest(ModbusRequest request)
        throws WrappedModbusException, IllegalStateException {

        log.debug(
                "Creating transaction for request {}", request.getHexMessage()
        );

        if (!isPortOpen()){
            log.debug("Port {} is not open. Opening now", this);
            openConnection();
            log.debug("Port {} successfully opened", this);
        } else {
            log.debug("Port {} is open, using for connection", this);
        }
        connection.setTimeout(recieveTimeOut);

        ModbusSerialTransaction transaction = new ModbusSerialTransaction();
        transaction.setSerialConnection(connection);
        transaction.setRequest(request);
        transaction.setRetries(numberOfRetries);

        return transaction;
    }

    @Override
    public Float parseFloatFromResponse(ModbusMessage response) throws
            ClassCastException, IOException {
        ModbusResponse inputRegistersResponse = (ModbusResponse) response;
        ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream();
        DataOutput writer = new DataOutputStream(byteBuffer);
        log.debug(
                "Received response {}. Parsing to float",
                inputRegistersResponse.toString()
        );

        inputRegistersResponse.writeData(writer);

        byte[] dataToRead = processByteArray(byteBuffer.toByteArray());

        DataInput reader = new DataInputStream(
                new ByteArrayInputStream(dataToRead)
        );

        return reader.readFloat();

    }

    @Override
    public String parseStringFromResponse(ModbusMessage response) throws
            ClassCastException, IOException {
        ModbusResponse inputRegistersResponse = (ModbusResponse) response;

        ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream();
        DataOutput writer = new DataOutputStream(byteBuffer);
        log.debug(
                "Received response {}. Parsing to string",
                inputRegistersResponse.toString()
        );

        inputRegistersResponse.writeData(writer);

        DataInput reader = new DataInputStream(
                new ByteArrayInputStream(byteBuffer.toByteArray())
        );

        return reader.readLine();
    }

    private void openConnection() throws IllegalStateException,
            WrappedModbusException {
        assertPortClosed();
        assertHasPortConfiguration();

        connection = new SerialConnection(
                desiredPortConfiguration.getSerialParameters()
        );

        createShutdownThread();

        try {
            connection.open();
        } catch (Exception error){
            throw new WrappedModbusException(error);
        }
    }

    private void assertPortClosed() throws IllegalStateException {
        if (this.isPortOpen()){
            throw new IllegalStateException("MODBUS port is not open.");
        }
    }

    private void assertHasPortConfiguration() throws IllegalStateException {
        if (desiredPortConfiguration == null){
            throw new IllegalStateException(
                    "Attempted to open a port without configuration being set"
            );
        }
    }

    private void createShutdownThread(){
        portShutdownThread = new PortShutdownThread(connection);
        Runtime.getRuntime().addShutdownHook(portShutdownThread);
    }

    private void removeShutdownThread(){
        Runtime.getRuntime().removeShutdownHook(portShutdownThread);
    }

    @Contract(pure = true)
    private static byte[] processByteArray(byte[] inputBytes){
        byte[] outputBytes = new byte[inputBytes.length - 1];

        for (int index = 0; index < outputBytes.length; index++){
            outputBytes[index] = inputBytes[
                    inputBytes.length - 1 - index
            ];
        }

        return outputBytes;
    }

    private class PortShutdownThread extends Thread {
        private final Logger log = LoggerFactory.getLogger
                (PortShutdownThread.class);

        private final SerialConnection connection;

        public PortShutdownThread(SerialConnection connection){
            this.connection = connection;
        }

        @Override
        public void run(){
            log.info("Connection {} caught shutdown signal. Closing",
                    connection.toString());
            connection.close();
            log.info("MODBUS Connection {} successfully closed",
                    connection.toString());
        }
    }
}