635 lines
28 KiB
Java
Executable File
635 lines
28 KiB
Java
Executable File
/*
|
|
* Copyright (c) 2014 Paul Scherrer Institute. All rights reserved.
|
|
*/
|
|
import ch.psi.pshell.device.*;
|
|
import ch.psi.pshell.epics.*;
|
|
import ch.psi.utils.BitMask;
|
|
import java.io.IOException;
|
|
|
|
/**
|
|
*/
|
|
public class PowerSupply extends DeviceBase implements BitMask {
|
|
|
|
public final ChannelDouble moduleVoltageRamp, moduleCurrentRamp,
|
|
|
|
moduleTemperature, modulePower5, modulePower12, modulePower12N, moduleVoltageRampRb,
|
|
moduleCurrentRampRb, moduleVoltageMax, moduleCurrentMax,channelActualVoltage,channelActualCurrent;
|
|
|
|
public final ChannelInteger moduleRestartDelay, moduleAdcSamples, moduleDigFilter, moduleIlkCommand,
|
|
moduleEvMaskSet, moduleEvMaskClr, moduleChMaskSet, moduleChMaskClr,
|
|
|
|
moduleFirmware, moduleSerial, modulePlacedChannels, moduleNoChannels,moduleRestartDelayRb,
|
|
moduleCommandRb, moduleEvMaskRb, moduleChMaskRb, moduleIlkCommandRb,moduleStatus,
|
|
moduleIlkStatus, moduleEvStatus, moduleChStatus, moduleAdcSamplesRb, moduleDigFilterRb;
|
|
public final ChannelString moduleCommand;
|
|
|
|
public final ChannelDouble channelVoltageNominalSetpoint, channelCurrentNominalSetpoint, channelDesiredVoltageSetpoint,
|
|
channelVoltageIlkMax, channelVoltageIlkMin, channelDesiredCurrentSetpoint,
|
|
channelCurrentIlkMax, channelCurrentIlkMin,
|
|
|
|
channelVoltageMax, channelCurrentMax, channelVoltageNominalReadback,channelCurrentNominalReadback,
|
|
channelDesiredVoltageReadback,channelDesiredCurrentReadback,channelVoltageIlkMaxReadback,
|
|
channelVoltageIlkMinReadback, channelCurrentIlkMaxReadback,channelCurrentIlkMinReadback;
|
|
|
|
public final ChannelInteger channelEvMaskSet, channelEvMaskClr,
|
|
|
|
channelCommandReadback, channelEventMaskReadback, channelStatus, channelEvents;
|
|
public final ChannelString channelCommand;
|
|
|
|
|
|
public final String prefix;
|
|
|
|
|
|
public PowerSupply(String name, String prefix) {
|
|
super(name);
|
|
this.prefix=prefix;
|
|
|
|
moduleVoltageRamp = new ChannelDouble(name + " moduleVoltageRamp", prefix + ":RAMP:2");
|
|
moduleCurrentRamp = new ChannelDouble(name + " moduleCurrentRamp", prefix + ":IRAMP:2");
|
|
|
|
moduleTemperature = new ChannelDouble(name + " moduleTemperature", prefix + ":TMPE:2", RegisterAccessType.Read);
|
|
modulePower5 = new ChannelDouble(name + " modulePower5", prefix + ":VP5:2", RegisterAccessType.Read);
|
|
modulePower12 = new ChannelDouble(name + " modulePower12", prefix + ":VP12:2", RegisterAccessType.Read);
|
|
modulePower12N = new ChannelDouble(name + " modulePower12N", prefix + ":VN12:2", RegisterAccessType.Read);
|
|
moduleVoltageRampRb = new ChannelDouble(name + " moduleVoltageRampRb", prefix + ":RAMPRB:2", RegisterAccessType.Read);
|
|
moduleCurrentRampRb = new ChannelDouble(name + " moduleCurrentRampRb", prefix + ":IRAMPRB:2", RegisterAccessType.Read);
|
|
moduleVoltageMax = new ChannelDouble(name + " moduleVoltageMax", prefix + ":VMAX:2", RegisterAccessType.Read);
|
|
moduleCurrentMax = new ChannelDouble(name + " moduleCurrentMax", prefix + ":IMAX:2", RegisterAccessType.Read);
|
|
channelActualVoltage = new ChannelDouble(name + " channelActualVoltage", prefix + ":IST:2", RegisterAccessType.Read);
|
|
channelActualCurrent = new ChannelDouble(name + " channelActualCurrent", prefix + ":STR:1", RegisterAccessType.Read);
|
|
|
|
moduleRestartDelay = new ChannelInteger(name + " moduleRestartDelay", prefix + ":RTAR:2");
|
|
moduleAdcSamples = new ChannelInteger(name + " moduleAdcSamples", prefix + ":NADC:2");
|
|
moduleDigFilter = new ChannelInteger(name + " moduleDigFilter", prefix + ":NDF:2");
|
|
moduleIlkCommand = new ChannelInteger(name + " moduleIlkCommand", prefix + ":ICOM:2");
|
|
moduleEvMaskSet = new ChannelInteger(name + " moduleEvMaskSet", prefix + ":MMEMSKSET:2");
|
|
moduleEvMaskClr = new ChannelInteger(name + " moduleEvMaskClr", prefix + ":MMEMSKCLR:2");
|
|
moduleChMaskSet = new ChannelInteger(name + " moduleChMaskSet", prefix + ":MCEMSKSET:2");
|
|
moduleChMaskClr = new ChannelInteger(name + " moduleChMaskClr", prefix + ":MCEMSKCLR:2");
|
|
|
|
moduleFirmware = new ChannelInteger(name + " moduleFirmware", prefix + ":FWNR:1", RegisterAccessType.Read);
|
|
moduleSerial = new ChannelInteger(name + " moduleSerial", prefix + ":SRNR:1", RegisterAccessType.Read);
|
|
modulePlacedChannels = new ChannelInteger(name + " modulePlacedChannels", prefix + ":PLCH:1", RegisterAccessType.Read);
|
|
moduleNoChannels = new ChannelInteger(name + " moduleNoChannels", prefix + ":NRCH:2", RegisterAccessType.Read);
|
|
moduleRestartDelayRb = new ChannelInteger(name + " moduleRestartDelayRb", prefix + ":RTARRB:2", RegisterAccessType.Read);
|
|
moduleCommandRb = new ChannelInteger(name + " moduleCommandRb", prefix + ":COMXRB:1", RegisterAccessType.Read);
|
|
moduleEvMaskRb = new ChannelInteger(name + " moduleEvMaskRb", prefix + ":MMEMSKRB:1", RegisterAccessType.Read);
|
|
moduleChMaskRb = new ChannelInteger(name + " moduleChMaskRb", prefix + ":MCEMSKRB:1", RegisterAccessType.Read);
|
|
moduleIlkCommandRb = new ChannelInteger(name + " moduleIlkCommandRb", prefix + ":ICOMRB:1", RegisterAccessType.Read);
|
|
moduleStatus = new ChannelInteger(name + " moduleStatus", prefix + ":STAX:1", RegisterAccessType.Read);
|
|
moduleIlkStatus = new ChannelInteger(name + " moduleIlkStatus", prefix + ":STA1:1", RegisterAccessType.Read);
|
|
moduleEvStatus = new ChannelInteger(name + " moduleEvStatus", prefix + ":MMESTA:1", RegisterAccessType.Read);
|
|
moduleChStatus = new ChannelInteger(name + " moduleChStatus", prefix + ":MCESTA:1", RegisterAccessType.Read);
|
|
moduleAdcSamplesRb = new ChannelInteger(name + " moduleAdcSamplesRb", prefix + ":NADCRB:1", RegisterAccessType.Read);
|
|
moduleDigFilterRb= new ChannelInteger(name + " moduleDigFilterRb", prefix + ":NDFRB:2", RegisterAccessType.Read);
|
|
|
|
moduleCommand = new ChannelString(name + " moduleCommand", prefix + ":COMX:2");
|
|
|
|
channelVoltageNominalSetpoint = new ChannelDouble(name + " channelVoltageNominalSetpoint", prefix + ":VNOM:2");
|
|
channelCurrentNominalSetpoint = new ChannelDouble(name + " channelCurrentNominalSetpoint", prefix + ":INOM:2");
|
|
channelDesiredVoltageSetpoint = new ChannelDouble(name + " channelDesiredVoltageSetpoint", prefix + ":SOL:2");
|
|
channelVoltageIlkMax = new ChannelDouble(name + " channelVoltageIlkMax", prefix + ":VIMX:2");
|
|
channelVoltageIlkMin = new ChannelDouble(name + " channelVoltageIlkMin", prefix + ":VIMN:2");
|
|
channelDesiredCurrentSetpoint = new ChannelDouble(name + " channelDesiredCurrentSetpoint", prefix + ":STRR:2");
|
|
channelCurrentIlkMax = new ChannelDouble(name + " channelCurrentIlkMax", prefix + ":IIMX:2");
|
|
channelCurrentIlkMin = new ChannelDouble(name + " channelCurrentIlkMin", prefix + ":IIMN:2");
|
|
|
|
channelVoltageMax = new ChannelDouble(name + " channelVoltageMax", prefix + ":VSMX:2", RegisterAccessType.Read);
|
|
channelCurrentMax = new ChannelDouble(name + " channelCurrentMax", prefix + ":ISMX:2", RegisterAccessType.Read);
|
|
channelVoltageNominalReadback = new ChannelDouble(name + " channelVoltageNominalReadback", prefix + ":VNOMRB:2", RegisterAccessType.Read);
|
|
channelCurrentNominalReadback = new ChannelDouble(name + " channelCurrentNominalReadback", prefix + ":INOMRB:2", RegisterAccessType.Read);
|
|
channelDesiredVoltageReadback = new ChannelDouble(name + " channelDesiredVoltageReadback", prefix + ":SOLRB:2", RegisterAccessType.Read);
|
|
channelDesiredCurrentReadback = new ChannelDouble(name + " channelDesiredCurrentReadback", prefix + ":STRRRB:2", RegisterAccessType.Read);
|
|
channelVoltageIlkMaxReadback = new ChannelDouble(name + " channelVoltageIlkMaxReadback", prefix + ":VIMXRB:2", RegisterAccessType.Read);
|
|
channelVoltageIlkMinReadback = new ChannelDouble(name + " channelVoltageIlkMinReadback", prefix + ":VIMNRB:2", RegisterAccessType.Read);
|
|
channelCurrentIlkMaxReadback = new ChannelDouble(name + " channelCurrentIlkMaxReadback", prefix + ":IIMXRB:2", RegisterAccessType.Read);
|
|
channelCurrentIlkMinReadback = new ChannelDouble(name + " channelCurrentIlkMinReadback", prefix + ":IIMNRB:2", RegisterAccessType.Read);
|
|
|
|
channelEvMaskSet = new ChannelInteger(name + " channelEvMaskSet", prefix + ":CEMSKSET:2");
|
|
channelEvMaskClr = new ChannelInteger(name + " channelEvMaskClr", prefix + ":CEMSKCLR:2");
|
|
|
|
channelCommandReadback = new ChannelInteger(name + " channelCommandReadback", prefix + ":COMRB:1", RegisterAccessType.Read);
|
|
channelEventMaskReadback = new ChannelInteger(name + " channelEventMaskReadback", prefix + ":CEMSKRB:1", RegisterAccessType.Read);
|
|
channelStatus = new ChannelInteger(name + " channelStatus", prefix + ":STA:1", RegisterAccessType.Read);
|
|
channelEvents = new ChannelInteger(name + " channelEvents", prefix + ":CESTA:1", RegisterAccessType.Read);
|
|
|
|
|
|
channelCommand = new ChannelString(name + " channelCommand", prefix + ":COM:2");
|
|
|
|
|
|
setChildren(new Device[]{moduleVoltageRamp, moduleCurrentRamp,
|
|
moduleTemperature, modulePower5, modulePower12, modulePower12N, moduleVoltageRampRb,
|
|
moduleCurrentRampRb, moduleVoltageMax, moduleCurrentMax,channelActualVoltage,channelActualCurrent,
|
|
moduleRestartDelay, moduleAdcSamples, moduleDigFilter, moduleIlkCommand,
|
|
moduleEvMaskSet, moduleEvMaskClr, moduleChMaskSet, moduleChMaskClr,
|
|
moduleFirmware, moduleSerial, modulePlacedChannels, moduleNoChannels,moduleRestartDelayRb,
|
|
moduleCommandRb, moduleEvMaskRb, moduleChMaskRb, moduleIlkCommandRb,moduleStatus,
|
|
moduleIlkStatus, moduleEvStatus, moduleChStatus, moduleAdcSamplesRb, moduleDigFilterRb,
|
|
moduleCommand,
|
|
channelVoltageNominalSetpoint, channelCurrentNominalSetpoint, channelDesiredVoltageSetpoint,
|
|
channelVoltageIlkMax, channelVoltageIlkMin, channelDesiredCurrentSetpoint,
|
|
channelCurrentIlkMax, channelCurrentIlkMin,
|
|
channelVoltageMax, channelCurrentMax, channelVoltageNominalReadback,channelCurrentNominalReadback,
|
|
channelDesiredVoltageReadback,channelDesiredCurrentReadback,channelVoltageIlkMaxReadback,
|
|
channelVoltageIlkMinReadback, channelCurrentIlkMaxReadback,channelCurrentIlkMinReadback,
|
|
channelEvMaskSet, channelEvMaskClr,
|
|
channelCommandReadback, channelEventMaskReadback, channelStatus, channelEvents,
|
|
channelCommand }
|
|
);
|
|
|
|
}
|
|
|
|
@Override
|
|
protected void doUpdate() throws InterruptedException, IOException {
|
|
super.doUpdate();
|
|
try {
|
|
|
|
channelActualVoltage.update();
|
|
channelActualCurrent.update();
|
|
setCache(new double[]{channelActualVoltage.getValue(), channelActualCurrent.getValue()});
|
|
} catch (Exception ex) {
|
|
throw new DeviceException(ex);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void doSetMonitored(boolean value) {
|
|
super.doSetMonitored(value);
|
|
for (Device dev: getChildren()){
|
|
dev.setMonitored(value);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
String toHexString(Integer value){
|
|
return String.format("0x%04X",value);
|
|
}
|
|
|
|
public String getFirmware() throws InterruptedException, IOException {
|
|
//return toHexString(moduleFirmware.getValue());
|
|
int value = moduleFirmware.getValue();
|
|
return String.valueOf((value&0xFF0000)>>16) + "." + String.valueOf((value&0xFF00)>>8) + String.valueOf((value&0xFF));
|
|
}
|
|
|
|
public String getSerial() throws InterruptedException, IOException {
|
|
//return toHexString(moduleSerial.getValue());
|
|
return String.valueOf(moduleSerial.getValue());
|
|
}
|
|
|
|
public Integer getNumberOfChannels() throws InterruptedException, IOException {
|
|
return moduleNoChannels.getValue();
|
|
}
|
|
|
|
public Integer getPlacedChannels() throws InterruptedException, IOException {
|
|
return modulePlacedChannels.getValue();
|
|
}
|
|
|
|
public Double getTemperature() throws InterruptedException, IOException {
|
|
return moduleTemperature.getValue();
|
|
}
|
|
|
|
public Double getPower5() throws InterruptedException, IOException {
|
|
return modulePower5.getValue();
|
|
}
|
|
|
|
public Double getPower12() throws InterruptedException, IOException {
|
|
return modulePower12.getValue();
|
|
}
|
|
|
|
public Double getPower12N() throws InterruptedException, IOException {
|
|
return modulePower12N.getValue();
|
|
}
|
|
|
|
public Double getVoltageRampReadback() throws InterruptedException, IOException {
|
|
return moduleVoltageRampRb.getValue();
|
|
}
|
|
|
|
public Double getCurrentRampReadback() throws InterruptedException, IOException {
|
|
return moduleCurrentRampRb.getValue();
|
|
}
|
|
|
|
public Double getCurrentMax() throws InterruptedException, IOException {
|
|
return moduleCurrentMax.getValue();
|
|
}
|
|
|
|
public Double getVoltageMax() throws InterruptedException, IOException {
|
|
return moduleVoltageMax.getValue();
|
|
}
|
|
|
|
public Integer getRestartDelayReadback() throws InterruptedException, IOException {
|
|
return moduleRestartDelayRb.getValue();
|
|
}
|
|
|
|
public Integer getAdcSamplesReadback() throws InterruptedException, IOException {
|
|
return moduleAdcSamplesRb.getValue();
|
|
}
|
|
|
|
public Integer getDigFilterReadback() throws InterruptedException, IOException {
|
|
return moduleDigFilterRb.getValue();
|
|
}
|
|
|
|
public int getModuleControl() throws InterruptedException, IOException {
|
|
return moduleCommandRb.getValue();
|
|
}
|
|
|
|
public String getModuleControlStr() throws InterruptedException, IOException {
|
|
return toHexString(getModuleControl());
|
|
}
|
|
|
|
public int getEventMask() throws InterruptedException, IOException {
|
|
return moduleEvMaskRb.getValue();
|
|
}
|
|
|
|
public String getEventMaskStr() throws InterruptedException, IOException {
|
|
return toHexString(getEventMask());
|
|
}
|
|
|
|
public int getEventChannelMask() throws InterruptedException, IOException {
|
|
return moduleChMaskRb.getValue();
|
|
}
|
|
|
|
public String getEventChannelMaskStr() throws InterruptedException, IOException {
|
|
return toHexString(getEventChannelMask());
|
|
}
|
|
|
|
public int getChannelIlkCommand() throws InterruptedException, IOException {
|
|
return moduleIlkCommandRb.getValue();
|
|
}
|
|
|
|
public String getChannelIlkCommandStr() throws InterruptedException, IOException {
|
|
return toHexString(getChannelIlkCommand());
|
|
}
|
|
|
|
public static class ModuleStatus {
|
|
|
|
int mask;
|
|
boolean fineAdjAct;
|
|
boolean ilkOutActive;
|
|
boolean moduleIsOff;
|
|
boolean needService;
|
|
boolean inputError;
|
|
boolean inSpecialMode;
|
|
boolean commandComplete;
|
|
boolean noModuleErr;
|
|
boolean noChanRamping;
|
|
boolean saftyLoopOk;
|
|
boolean eventActive;
|
|
boolean moduleStateOk;
|
|
boolean powerSupplyOk;
|
|
boolean temperatureOk;
|
|
boolean killEnabled;
|
|
}
|
|
|
|
public ModuleStatus getStatus(int mask) throws InterruptedException, IOException {
|
|
ModuleStatus ret = new ModuleStatus();
|
|
ret.mask = mask;
|
|
ret.fineAdjAct = ((mask & BIT0) != 0);
|
|
ret.ilkOutActive = ((mask & BIT1) != 0);
|
|
ret.moduleIsOff = ((mask & BIT2) != 0);
|
|
ret.needService = ((mask & BIT4) != 0);
|
|
ret.inputError = ((mask & BIT5) != 0);
|
|
ret.inSpecialMode = ((mask & BIT6) != 0);
|
|
ret.commandComplete = ((mask & BIT7) != 0);
|
|
ret.noModuleErr = ((mask & BIT8) != 0);
|
|
ret.noChanRamping = ((mask & BIT9) != 0);
|
|
ret.saftyLoopOk = ((mask & BIT10) != 0);
|
|
ret.eventActive = ((mask & BIT11) != 0);
|
|
ret.moduleStateOk = ((mask & BIT12) != 0);
|
|
ret.powerSupplyOk = ((mask & BIT13) != 0);
|
|
ret.temperatureOk = ((mask & BIT14) != 0);
|
|
ret.killEnabled = ((mask & BIT15) != 0);
|
|
return ret;
|
|
}
|
|
|
|
public ModuleStatus getStatus() throws InterruptedException, IOException {
|
|
Integer mask = moduleStatus.getValue();
|
|
return getStatus(mask);
|
|
}
|
|
public static class ModuleEventStatus {
|
|
|
|
int mask;
|
|
boolean restarted;
|
|
boolean needService;
|
|
boolean inputError;
|
|
boolean saftyLoopOpen;
|
|
boolean noGood;
|
|
boolean tGreater55C;
|
|
|
|
}
|
|
|
|
public ModuleEventStatus getEventStatus() throws InterruptedException, IOException {
|
|
Integer mask = moduleEvStatus.getValue();
|
|
ModuleEventStatus ret = new ModuleEventStatus();
|
|
ret.mask = mask;
|
|
ret.restarted = ((mask & BIT1) != 0);
|
|
ret.needService = ((mask & BIT4) != 0);
|
|
ret.inputError = ((mask & BIT5) != 0);
|
|
ret.saftyLoopOpen = ((mask & BIT10) != 0);
|
|
ret.noGood = ((mask & BIT13) != 0);
|
|
ret.tGreater55C = ((mask & BIT14) != 0);
|
|
return ret;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//Public Interface - Module config
|
|
////////////////////////////////////////////////////////////////////////////
|
|
public Double getVoltageRampSetpoint() throws InterruptedException, IOException {
|
|
return moduleVoltageRamp.getValue();
|
|
}
|
|
|
|
public Double getCurrentRampSetpoint() throws InterruptedException, IOException {
|
|
return moduleCurrentRamp.getValue();
|
|
}
|
|
|
|
public Integer getAdcSamplesSetpoint() throws InterruptedException, IOException {
|
|
return moduleAdcSamples.getValue();
|
|
}
|
|
|
|
public void setAdcSamplesSetpoint(Integer value) throws InterruptedException, IOException {
|
|
moduleAdcSamples.write(value);
|
|
}
|
|
|
|
public Integer getDigFilterSetpoint() throws InterruptedException, IOException {
|
|
return moduleDigFilter.getValue();
|
|
}
|
|
|
|
public void setDigFilterSetpoint(Integer value) throws InterruptedException, IOException {
|
|
moduleDigFilter.write(value);
|
|
}
|
|
|
|
public Integer getRestartDelaySetpoint() throws InterruptedException, IOException {
|
|
return moduleRestartDelay.getValue();
|
|
}
|
|
|
|
public void setRestartDelaySetpoint(Integer value) throws InterruptedException, IOException {
|
|
moduleRestartDelay.write(value);
|
|
}
|
|
|
|
public void setVoltageRampSetpoint(Double value) throws InterruptedException, IOException {
|
|
moduleVoltageRamp.write(value);
|
|
}
|
|
|
|
public void setCurrentRampSetpoint(Double value) throws InterruptedException, IOException {
|
|
moduleCurrentRamp.write(value);
|
|
}
|
|
|
|
public enum ModuleCommand {
|
|
|
|
SAVE,
|
|
RECALL,
|
|
STP_ON,
|
|
STP_OFF,
|
|
AON_ON,
|
|
AON_OFF,
|
|
ADJ_ON,
|
|
ADJ_OFF,
|
|
KIL_ON,
|
|
KIL_OFF,
|
|
CLEAR
|
|
}
|
|
|
|
public void setModuleCommand(ModuleCommand cmd) throws InterruptedException, IOException {
|
|
moduleCommand.write(cmd.toString().replaceAll("_", " "));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//Public Interface - Channel Readback
|
|
////////////////////////////////////////////////////////////////////////////
|
|
public static class ChannelStatus {
|
|
|
|
int mask;
|
|
boolean inputDataErr;
|
|
boolean isOn;
|
|
boolean isRamping;
|
|
boolean isEmergencyOff;
|
|
boolean isIControlled;
|
|
boolean isVControlled;
|
|
boolean iOutOfBounds;
|
|
boolean vOutOfBounds;
|
|
boolean isExtInhibit;
|
|
boolean isTripSet;
|
|
boolean hwILimExc;
|
|
boolean hwVLimExc;
|
|
|
|
String getMessageStatus() {
|
|
if (!isOn) {
|
|
return "Off";
|
|
}
|
|
if (isRamping) {
|
|
return "Ramping";
|
|
}
|
|
if (isEmergencyOff) {
|
|
return "Emergency";
|
|
}
|
|
if (vOutOfBounds || iOutOfBounds) {
|
|
return "Out of Bounds";
|
|
}
|
|
if (hwILimExc || hwILimExc) {
|
|
return "Lim Exc";
|
|
}
|
|
if (isExtInhibit) {
|
|
return "Ext Inhibit";
|
|
}
|
|
if (isRamping) {
|
|
return "Ramping";
|
|
}
|
|
if (isVControlled) {
|
|
return "Voltage Control";
|
|
}
|
|
if (isIControlled) {
|
|
return "Current Control";
|
|
}
|
|
if (inputDataErr) {
|
|
return "Input Data Error";
|
|
}
|
|
return "Unknown";
|
|
}
|
|
}
|
|
|
|
public static ChannelStatus getChannelStatus(int mask) throws InterruptedException, IOException {
|
|
ChannelStatus ret = new ChannelStatus();
|
|
ret.mask = mask;
|
|
ret.inputDataErr = ((mask & BIT2) != 0);
|
|
ret.isOn = ((mask & BIT3) != 0);
|
|
ret.isRamping = ((mask & BIT4) != 0);
|
|
ret.isEmergencyOff = ((mask & BIT5) != 0);
|
|
ret.isIControlled = ((mask & BIT6) != 0);
|
|
ret.isVControlled = ((mask & BIT7) != 0);
|
|
ret.iOutOfBounds = ((mask & BIT10) != 0);
|
|
ret.vOutOfBounds = ((mask & BIT11) != 0);
|
|
ret.isExtInhibit = ((mask & BIT12) != 0);
|
|
ret.isTripSet = ((mask & BIT13) != 0);
|
|
ret.hwILimExc = ((mask & BIT14) != 0);
|
|
ret.hwVLimExc = ((mask & BIT15) != 0);
|
|
return ret;
|
|
}
|
|
|
|
|
|
public ChannelStatus getChannelStatus() throws InterruptedException, IOException {
|
|
Integer mask = channelStatus.getValue();
|
|
return getChannelStatus(mask);
|
|
}
|
|
|
|
public ChannelStatus getChannelEventStatus() throws InterruptedException, IOException {
|
|
Integer mask = channelEvents.getValue();
|
|
ChannelStatus ret = new ChannelStatus();
|
|
ret.mask = mask;
|
|
ret.inputDataErr = ((mask & BIT2) != 0);
|
|
ret.isOn = ((mask & BIT3) != 0);
|
|
ret.isRamping = ((mask & BIT4) != 0);
|
|
ret.isEmergencyOff = ((mask & BIT5) != 0);
|
|
ret.isIControlled = ((mask & BIT6) != 0);
|
|
ret.isVControlled = ((mask & BIT7) != 0);
|
|
ret.iOutOfBounds = ((mask & BIT10) != 0);
|
|
ret.vOutOfBounds = ((mask & BIT11) != 0);
|
|
ret.isExtInhibit = ((mask & BIT12) != 0);
|
|
ret.isTripSet = ((mask & BIT13) != 0);
|
|
ret.hwILimExc = ((mask & BIT14) != 0);
|
|
ret.hwVLimExc = ((mask & BIT15) != 0);
|
|
return ret;
|
|
}
|
|
|
|
public int getChannelEventMask() throws InterruptedException, IOException {
|
|
return channelEventMaskReadback.getValue();
|
|
}
|
|
|
|
public Double getChannelVoltageMax() throws InterruptedException, IOException {
|
|
return channelVoltageMax.getValue();
|
|
}
|
|
|
|
public Double getChannelVoltageNominalReadback() throws InterruptedException, IOException {
|
|
return channelVoltageNominalReadback.getValue();
|
|
}
|
|
|
|
public Double getChannelActualVoltage() throws InterruptedException, IOException {
|
|
return channelActualVoltage.getValue();
|
|
}
|
|
|
|
public Double getChannelCurrentMax() throws InterruptedException, IOException {
|
|
return channelCurrentMax.getValue();
|
|
}
|
|
|
|
public Double getChannelActualCurrent() throws InterruptedException, IOException {
|
|
return channelActualCurrent.getValue();
|
|
}
|
|
|
|
public Double getChannelCurrentNominalReadback() throws InterruptedException, IOException {
|
|
return channelCurrentNominalReadback.getValue();
|
|
}
|
|
|
|
public Double getChannelDesiredVoltageReadback() throws InterruptedException, IOException {
|
|
return channelDesiredVoltageReadback.getValue();
|
|
}
|
|
|
|
public Double getChannelDesiredCurrentReadback() throws InterruptedException, IOException {
|
|
return channelDesiredCurrentReadback.getValue();
|
|
}
|
|
|
|
public Double getChannelVoltageIlkMaxReadback() throws InterruptedException, IOException {
|
|
return channelVoltageIlkMaxReadback.getValue();
|
|
}
|
|
|
|
public Double getChannelVoltageIlkMinReadback() throws InterruptedException, IOException {
|
|
return channelVoltageIlkMinReadback.getValue();
|
|
}
|
|
|
|
public Double getChannelCurrentIlkMaxReadback() throws InterruptedException, IOException {
|
|
return channelCurrentIlkMaxReadback.getValue();
|
|
}
|
|
|
|
public Double getChannelCurrentIlkMinReadback() throws InterruptedException, IOException {
|
|
return channelCurrentIlkMinReadback.getValue();
|
|
}
|
|
|
|
public int getChannelControlReadback() throws InterruptedException, IOException {
|
|
return channelCommandReadback.getValue();
|
|
}
|
|
|
|
public String getChannelControlReadbackStr() throws InterruptedException, IOException {
|
|
return toHexString(getModuleControl());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//Public Interface - Channel Config
|
|
////////////////////////////////////////////////////////////////////////////
|
|
public Double getChannelDesiredVoltage() throws InterruptedException, IOException {
|
|
return channelDesiredVoltageSetpoint.getValue();
|
|
}
|
|
|
|
public Double getChannelDesiredCurrent() throws InterruptedException, IOException {
|
|
return channelDesiredCurrentSetpoint.getValue();
|
|
}
|
|
|
|
public void setChannelDesiredVoltage(Double value) throws InterruptedException, IOException {
|
|
channelDesiredVoltageSetpoint.write(value);
|
|
}
|
|
|
|
public void setChannelDesiredCurrent(Double value) throws InterruptedException, IOException {
|
|
channelDesiredCurrentSetpoint.write(value);
|
|
}
|
|
|
|
public Double getChannelVoltageIlkMax() throws InterruptedException, IOException {
|
|
return channelVoltageIlkMax.getValue();
|
|
}
|
|
|
|
public Double getChannelVoltageIlkMin() throws InterruptedException, IOException {
|
|
return channelVoltageIlkMin.getValue();
|
|
}
|
|
|
|
public Double getChannelCurrentIlkMax() throws InterruptedException, IOException {
|
|
return channelCurrentIlkMax.getValue();
|
|
}
|
|
|
|
public Double getChannelCurrentIlkMin() throws InterruptedException, IOException {
|
|
return channelCurrentIlkMin.getValue();
|
|
}
|
|
|
|
public void setChannelVoltageIlkMax(Double value) throws InterruptedException, IOException {
|
|
channelVoltageIlkMax.write(value);
|
|
}
|
|
|
|
public void setChannelVoltageIlkMin(Double value) throws InterruptedException, IOException {
|
|
channelVoltageIlkMin.write(value);
|
|
}
|
|
|
|
public void setChannelCurrentIlkMax(Double value) throws InterruptedException, IOException {
|
|
channelCurrentIlkMax.write(value);
|
|
}
|
|
|
|
public void setChannelCurrentIlkMin(Double value) throws InterruptedException, IOException {
|
|
channelCurrentIlkMin.write(value);
|
|
}
|
|
|
|
public Double getChannelVoltageNominal() throws InterruptedException, IOException {
|
|
return channelVoltageNominalSetpoint.getValue();
|
|
}
|
|
|
|
public Double getChannelCurrentNominal() throws InterruptedException, IOException {
|
|
return channelCurrentNominalSetpoint.getValue();
|
|
}
|
|
|
|
public void setChannelVoltageNominal(Double value) throws InterruptedException, IOException {
|
|
channelVoltageNominalSetpoint.write(value);
|
|
}
|
|
|
|
public void setChannelCurrentNominal(Double value) throws InterruptedException, IOException {
|
|
channelCurrentNominalSetpoint.write(value);
|
|
}
|
|
|
|
public enum ChannelCommand {
|
|
ON,
|
|
OFF,
|
|
EMCY_ON,
|
|
EMCY_OFF,
|
|
AVBND_ON,
|
|
AVBND_OFF,
|
|
AIBND_ON,
|
|
AIBND_OFF
|
|
}
|
|
|
|
public void setChannelCommand(ChannelCommand cmd) throws InterruptedException, IOException {
|
|
channelCommand.write(cmd.toString().replaceAll("_", " "));
|
|
}
|
|
}
|