PVCiPressureGauge.java

package devices;

import com.ghgande.j2mod.modbus.ModbusException;
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.ReadWriteMultipleRequest;
import exceptions.WrappedModbusException;
import kernel.modbus.ModbusConnector;
import org.jetbrains.annotations.Contract;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;

public class PVCiPressureGauge implements PressureGauge {

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

    private static final Integer gaugePressureAddress = 154;

    private static final Integer gaugePressureWordsToRead = 2;

    private static final Integer unitIDAddress = 0;

    private static final Integer unitIDNumberofWords = 2;
    
    private final Integer address;

    private final ModbusConnector connection;

    public PVCiPressureGauge(Integer address, ModbusConnector connection)
            throws IOException {
        this.address = address;
        this.connection = connection;
        log.debug(
                "Created PVCi pressure gauge with address {} and conn {}",
                address, connection);

        try {
            this.checkUnitID();
        } catch (Exception error){
            throw new IOException(error);
        }
    }

    @Override
    public Float getPressure() throws WrappedModbusException,
            ModbusException, IOException {
        log.debug("Method to get pressure was called");

        ModbusRequest pressureRequest = getReadRegisterRequest(
                gaugePressureAddress, gaugePressureWordsToRead
        );
        ModbusTransaction transaction = connection.getTransactionForRequest(
                pressureRequest);
        log.debug(
                "PVCi Pressure gauge {} executing transaction {}",
                this.toString(), transaction.toString());
        transaction.execute();
        ModbusMessage response = transaction.getResponse();
        log.debug(
                "Received response {} from transaction {}",
                response.getHexMessage(), transaction.toString());

        return connection.parseFloatFromResponse(response);
    }

    @Contract("_, _ -> !null")
    private ReadWriteMultipleRequest getReadRegisterRequest(
            Integer registerNumber, Integer numberofWordsToRead){
        ReadWriteMultipleRequest request = new
                ReadWriteMultipleRequest();

        request.setReadReference(registerNumber);
        request.setReadWordCount(numberofWordsToRead);
        request.setWriteReference(0);
        request.setWriteWordCount(0);

        request.setUnitID(address);
        request.setHeadless();

        return request;
    }

    private void checkUnitID() throws WrappedModbusException,
            ModbusException, IOException {
        ModbusRequest request = getReadRegisterRequest(
            unitIDAddress, unitIDNumberofWords
        );

        ModbusTransaction transaction = connection.getTransactionForRequest(
                request);

        log.info("Checking for device. Attempting to read unit ID using " +
                "transaction {}", transaction);

        transaction.execute();

        log.info("Check Unit ID transaction successfully completed");

        ModbusMessage response = transaction.getResponse();

        log.debug("Received response {} from transaction {}",
                response.getHexMessage(), transaction.toString());

        if (connection.parseStringFromResponse(response) == null){
            throw new IOException(
                    "Unable to create pressure gauge. No response from unit"
            );
        }
    }
}