TDKLambdaPowerSupply.java

package devices;

import exceptions.ResponseNotOKException;
import kernel.serial_ports.PortCommunicator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TDKLambdaPowerSupply extends AbstractRS232Device
        implements PowerSupply {

    private static final Lock portCommunicatorLock = new ReentrantLock();

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

    private final int deviceAddress;

    public TDKLambdaPowerSupply(
            PortCommunicator portCommunicator,
            int deviceAddress
    ) throws IOException {
        super(portCommunicator);
        this.deviceAddress = deviceAddress;
        this.startDevice();
    }

    @Override public int getDeviceAddress(){
        return this.deviceAddress;
    }

    @Override public Double getVoltage() throws IOException {
        return this.writeWithDoubleResponse(GET_VOLTAGE_COMMAND);
    }

    @Override public Double getMeasuredVoltage() throws IOException {
        return this.writeWithDoubleResponse(GET_MEASURED_VOLTAGE_COMMAND);
    }

    @Override public void setVoltage(double newVoltage) throws IOException {
        String commandToWrite = String.format(
            PowerSupply.SET_VOLTAGE_COMMAND, newVoltage
        );
        this.writeWithOKResponse(commandToWrite);
    }

    @Override public void reset() throws IOException {
        this.writeWithOKResponse(RESET_COMMAND);
    }

    @Override public Double getCurrent() throws IOException {
        return this.writeWithDoubleResponse(GET_CURRENT_COMMAND);
    }

    @Override public void setCurrent(double newCurrent) throws IOException {
        String commandToWrite = String.format(
            PowerSupply.SET_CURRENT_COMMAND, newCurrent
        );

        this.writeWithOKResponse(commandToWrite);
    }

    @Override public void outputOff() throws IOException {
        String commandToWrite = String.format(
            PowerSupply.SET_OUTPUT_COMMAND, PowerSupply.OFF
        );

        this.writeWithOKResponse(commandToWrite);
    }

    @Override public void outputOn() throws IOException {
        String command = String.format(
            PowerSupply.SET_OUTPUT_COMMAND, PowerSupply.ON
        );

        this.writeWithOKResponse(command);
    }

    private void startDevice() throws IOException {
        String commandToWrite = String.format(GET_ADDRESS_COMMAND,
                deviceAddress);

        this.writeWithOKResponse(commandToWrite);
    }

    private Double writeWithDoubleResponse(String commandToWrite) throws
            IOException {
        portCommunicatorLock.lock();

        this.write(commandToWrite);
        log.debug("Writing command {} to power supply.", commandToWrite);
        String response = this.read();
        log.debug("Received response {} from power supply", response);

        portCommunicatorLock.unlock();

        return Double.parseDouble(response);
    }

    private void writeWithOKResponse(String commandToWrite) throws
            IOException {
        portCommunicatorLock.lock();

        this.write(commandToWrite);
        log.debug(
                String.format(
                        "Writing command %s to power supply",
                        commandToWrite
                )
        );
        String response = this.read();
        log.debug(
                String.format(
                        "Received response %s from power supply",
                        response
                )
        );

        if (!response.equals(PowerSupply.OK_RESPONSE)){
            throw new ResponseNotOKException("Did not receive response of " +
                String.format("%s", PowerSupply.OK_RESPONSE));
        }

        portCommunicatorLock.unlock();
    }
}