Esempio n. 1
0
 /**
  * disable spinning
  *
  * @throws DeviceException
  */
 private void disable() throws DeviceException {
   try {
     controller.caput(enableChannel, 0, 5);
   } catch (Throwable e) {
     throw new DeviceException("disable failed. ", e);
   }
 }
 /**
  * @return range values
  * @throws DeviceException
  */
 public String getRangeValue() throws DeviceException {
   try {
     short test = controller.cagetEnum(chRangeRBV);
     return positions.get(test);
   } catch (Throwable th) {
     throw new DeviceException("failed to get position from " + chRangeRBV.getName(), th);
   }
 }
Esempio n. 3
0
 @Override
 public String getState() throws DeviceException {
   try {
     return positions.get(controller.cagetEnum(enableChannel));
   } catch (Throwable e) {
     throw new DeviceException("failed to get spin status ", e);
   }
 }
 @Override
 public String[] getPositions() throws DeviceException {
   try {
     return controller.cagetLabels(chRange);
   } catch (Exception e) {
     throw new DeviceException(getName() + " exception in getPositions", e);
   }
 }
Esempio n. 5
0
 @Override
 public void setSpeed(double value) throws DeviceException {
   try {
     controller.caput(speedChannel, value, 5);
   } catch (Throwable e) {
     throw new DeviceException("set speed failed. ", e);
   }
 }
Esempio n. 6
0
 @Override
 public double getSpeed() throws DeviceException {
   try {
     return controller.cagetDouble(speedChannel);
   } catch (Throwable e) {
     throw new DeviceException("failed to get spin status ", e);
   }
 }
Esempio n. 7
0
 /**
  * gets the available positions from this device.
  *
  * @return available positions
  * @throws DeviceException
  */
 public String[] getPositions() throws DeviceException {
   String[] positionLabels = new String[positions.size()];
   try {
     positionLabels = controller.cagetLabels(enableChannel);
   } catch (Exception e) {
     if (e instanceof RuntimeException) throw (RuntimeException) e;
     throw new DeviceException(getName() + " exception in getPositions", e);
   }
   return positionLabels;
 }
  public void setPassEnergy(Integer value, double timeout) throws Exception {
    int i = 0;
    for (Integer pes : passenergies) {
      if (value.equals(pes)) {
        EPICS_CONTROLLER.caputWait(getChannel(PASSENERGY), i, timeout);
        return;
      }
      i = i + 1;
    }

    throw new Exception("unknown pass energy");
  }
 /**
  * gets the available positions from this device.
  *
  * @return available positions
  * @throws DeviceException
  */
 public String[] getPassEnergies() throws DeviceException {
   String[] positionLabels = new String[0];
   try {
     positionLabels = EPICS_CONTROLLER.cagetLabels(getChannel(PASSENERGY));
   } catch (Exception e) {
     if (e instanceof RuntimeException) {
       throw (RuntimeException) e;
     }
     throw new DeviceException(" exception in getPositions", e);
   }
   return positionLabels;
 }
  /** Constructor */
  public EpicsQuadraCurrentAmplifier() {

    String[] myNames = new String[1];
    myNames[0] = getName();
    setInputNames(myNames);

    controller = EpicsController.getInstance();
    channelManager = new EpicsChannelManager(this);
    monitorCurrent1 = new CurrentMonitorListener();
    monitorCurrent2 = new CurrentMonitorListener();
    monitorCurrent3 = new CurrentMonitorListener();
    monitorCurrent4 = new CurrentMonitorListener();
  }
 public Channel getChannel(String pvPostFix) throws Exception {
   String fullPvName;
   if (pvProvider != null) {
     fullPvName = pvProvider.getPV(pvPostFix);
   } else {
     fullPvName = basePVName + pvPostFix;
   }
   Channel channel = channelMap.get(fullPvName);
   if (channel == null) {
     channel = EPICS_CONTROLLER.createChannel(fullPvName);
     channelMap.put(fullPvName, channel);
   }
   return channel;
 }
  @Override
  public void rawAsynchronousMoveTo(Object position) throws DeviceException {
    // find in the positionNames array the index of the string
    if (positions.contains(position.toString())) {
      int target = positions.indexOf(position.toString());
      try {
        controller.caput(chRange, target, channelManager);
        Thread.sleep(1000);
      } catch (Throwable th) {
        throw new DeviceException(
            chRange.getName() + " failed to moveTo " + position.toString(), th);
      }

      return;
    }
    // if get here then wrong position name supplied
    throw new DeviceException("Position called: " + position.toString() + " not found.");
  }
 public String getYUnits() throws Exception {
   return EPICS_CONTROLLER.cagetString(getChannel(YUNITS_RBV));
 }
 public double getExcitationEnergy() throws Exception {
   return EPICS_CONTROLLER.cagetDouble(getChannel(EXCITATIONENERGY_RBV));
 }
 public void setExcitationEnergy(Integer value) throws Exception {
   EPICS_CONTROLLER.caput(getChannel(EXCITATIONENERGY), value);
 }
 public double[] getExtIO() throws Exception {
   return EPICS_CONTROLLER.cagetDoubleArray(getChannel(EXTIODATA));
 }
public class VGScientaController implements Configurable {
  private static final Logger logger = LoggerFactory.getLogger(VGScientaController.class);

  // Values internal to the object for Channel Access
  private final EpicsController EPICS_CONTROLLER = EpicsController.getInstance();
  private String basePVName = null;
  private IPVProvider pvProvider;
  public static final String LENSMODE = "LENS_MODE";
  public static final String LENSMODE_RBV = "LENS_MODE_RBV";
  public static final String ACQMODE = "ACQ_MODE";
  public static final String ACQMODE_RBV = "ACQ_MODE_RBV";
  public static final String ENERGYMODE = "ENERGY_MODE";
  public static final String ENERGYMODE_RBV = "ENERGY_MODE_RBV";
  public static final String DETECTORMODE = "DETECTOR_MODE";
  public static final String DETECTORMODE_RBV = "DETECTOR_MODE_RBV";
  public static final String ELEMENTSET = "ELEMENT_SET";
  public static final String ELEMENTSET_RBV = "ELEMENT_SET_RBV";
  public static final String PASSENERGY = "PASS_ENERGY";
  public static final String PASSENERGY_RBV = "PASS_ENERGY_RBV";
  public static final String STARTENERGY = "LOW_ENERGY";
  public static final String STARTENERGY_RBV = "LOW_ENERGY_RBV";
  public static final String CENTREENERGY = "CENTRE_ENERGY";
  public static final String CENTREENERGY_RBV = "CENTRE_ENERGY_RBV";
  public static final String ENDENERGY = "HIGH_ENERGY";
  public static final String ENDENERGY_RBV = "HIGH_ENERGY_RBV";
  public static final String ENERGYSTEP = "STEP_SIZE";
  public static final String ENERGYSTEP_RBV = "STEP_SIZE_RBV";
  public static final String FRAMES = "FRAMES";
  public static final String FRAMES_RBV = "FRAMES_RBV";
  public static final String STEPTIME = "STEP_TIME";
  public static final String SLICE = "SLICES";
  public static final String SLICE_RBV = "SLICES_RBV";
  public static final String INTERATIONS = "NumExposures";
  public static final String ZERO_SUPPLIES = "ZERO_SUPPLIES";
  public static final String TOTALPOINTS = "TOTAL_POINTS_RBV";
  public static final String TOTALLEADPOINTS = "TOTAL_LEAD_POINTS_RBV";
  public static final String TOTALDATAPOINTS = "TOTAL_DATA_POINTS_RBV";
  public static final String CURRENTPOINT = "CURRENT_CHANNEL_RBV";
  public static final String SPECTRUMDATA = "INT_SPECTRUM";
  public static final String IMAGEDATA = "IMAGE";
  public static final String EXTIODATA = "EXTIO";
  public static final String EXCITATIONENERGY = "EXCITATION_ENERGY";
  public static final String EXCITATIONENERGY_RBV = "EXCITATION_ENERGY_RBV";
  public static final String XUNITS_RBV = "X_UNITS_RBV";
  public static final String YUNITS_RBV = "Y_UNITS_RBV";

  /** Map that stores the channel against the PV name */
  private Map<String, Channel> channelMap = new HashMap<String, Channel>();

  private Vector<Integer> passenergies = new Vector<Integer>(7);

  public Channel getChannel(String pvPostFix) throws Exception {
    String fullPvName;
    if (pvProvider != null) {
      fullPvName = pvProvider.getPV(pvPostFix);
    } else {
      fullPvName = basePVName + pvPostFix;
    }
    Channel channel = channelMap.get(fullPvName);
    if (channel == null) {
      channel = EPICS_CONTROLLER.createChannel(fullPvName);
      channelMap.put(fullPvName, channel);
    }
    return channel;
  }

  public String getBasePVName() {
    return basePVName;
  }

  public void setBasePVName(String basePVName) {
    this.basePVName = basePVName;
  }

  public void setLensMode(String value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(LENSMODE), value);
  }

  public void setLensMode(String value, double timeout) throws Exception {
    EPICS_CONTROLLER.caputWait(getChannel(LENSMODE), value, timeout);
  }

  public String getLensMode() throws Exception {
    return EPICS_CONTROLLER.cagetString(getChannel(LENSMODE_RBV));
  }

  public void setAcquisitionMode(String value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(ACQMODE), value);
  }

  public void setAcquisitionMode(String value, double timeout) throws Exception {
    EPICS_CONTROLLER.caputWait(getChannel(ACQMODE), value, timeout);
  }

  public String getAcquisitionMode() throws Exception {
    return EPICS_CONTROLLER.cagetString(getChannel(ACQMODE_RBV));
  }

  public void setEnergyMode(String value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(ENERGYMODE), value);
  }

  public void setEnergyMode(String value, double timeout) throws Exception {
    EPICS_CONTROLLER.caputWait(getChannel(ENERGYMODE), value, timeout);
  }

  public String getEnergyMode() throws Exception {
    return EPICS_CONTROLLER.cagetString(getChannel(ENERGYMODE_RBV));
  }

  public void setDetectorMode(String value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(DETECTORMODE), value);
  }

  public void setDetectorMode(String value, double timeout) throws Exception {
    EPICS_CONTROLLER.caputWait(getChannel(DETECTORMODE), value, timeout);
  }

  public String getDetectorMode() throws Exception {
    return EPICS_CONTROLLER.cagetString(getChannel(DETECTORMODE_RBV));
  }

  public void setElement(String value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(ELEMENTSET), value);
  }

  public String getElement() throws Exception {
    return EPICS_CONTROLLER.cagetString(getChannel(ELEMENTSET_RBV));
  }

  public void setPassEnergy(Integer value) throws Exception {
    int i = 0;
    for (Integer pes : passenergies) {
      if (value.equals(pes)) {
        EPICS_CONTROLLER.caput(getChannel(PASSENERGY), i);
        return;
      }
      i = i + 1;
    }

    throw new Exception("unknown pass energy");
  }

  public void setPassEnergy(Integer value, double timeout) throws Exception {
    int i = 0;
    for (Integer pes : passenergies) {
      if (value.equals(pes)) {
        EPICS_CONTROLLER.caputWait(getChannel(PASSENERGY), i, timeout);
        return;
      }
      i = i + 1;
    }

    throw new Exception("unknown pass energy");
  }

  public Integer getPassEnergy() throws Exception {
    return passenergies.get(EPICS_CONTROLLER.cagetInt(getChannel(PASSENERGY_RBV)));
  }

  /**
   * gets the available positions from this device.
   *
   * @return available positions
   * @throws DeviceException
   */
  public String[] getPassEnergies() throws DeviceException {
    String[] positionLabels = new String[0];
    try {
      positionLabels = EPICS_CONTROLLER.cagetLabels(getChannel(PASSENERGY));
    } catch (Exception e) {
      if (e instanceof RuntimeException) {
        throw (RuntimeException) e;
      }
      throw new DeviceException(" exception in getPositions", e);
    }
    return positionLabels;
  }

  @Override
  public void configure() {
    try {
      String[] position = getPassEnergies();
      for (int i = 0; i < position.length; i++) {
        if (position[i] != null || position[i] != "") {
          passenergies.add(Integer.valueOf(position[i]));
        }
      }
    } catch (Exception e) {
      logger.error("cannot fill passenergy array, setting and getting passenergy will fail");
    }
  }

  public void setStartEnergy(Double value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(STARTENERGY), value);
  }

  public void setStartEnergy(Double value, double timeout) throws Exception {
    EPICS_CONTROLLER.caputWait(getChannel(STARTENERGY), value, timeout);
  }

  public Double getStartEnergy() throws Exception {
    return EPICS_CONTROLLER.cagetDouble(getChannel(STARTENERGY_RBV));
  }

  public void setCentreEnergy(Double value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(CENTREENERGY), value);
  }

  public void setCentreEnergy(Double value, double timeout) throws Exception {
    EPICS_CONTROLLER.caputWait(getChannel(CENTREENERGY), value, timeout);
  }

  public Double getCentreEnergy() throws Exception {
    return EPICS_CONTROLLER.cagetDouble(getChannel(CENTREENERGY_RBV));
  }

  public void setEndEnergy(Double value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(ENDENERGY), value);
  }

  public void setEndEnergy(Double value, double timeout) throws Exception {
    EPICS_CONTROLLER.caputWait(getChannel(ENDENERGY), value, timeout);
  }

  public Double getEndEnergy() throws Exception {
    return EPICS_CONTROLLER.cagetDouble(getChannel(ENDENERGY_RBV));
  }

  public void setEnergyStep(Double value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(ENERGYSTEP), value);
  }

  public void setEnergyStep(Double value, double timeout) throws Exception {
    EPICS_CONTROLLER.caputWait(getChannel(ENERGYSTEP), value, timeout);
  }

  public Double getEnergyStep() throws Exception {
    return EPICS_CONTROLLER.cagetDouble(getChannel(ENERGYSTEP_RBV));
  }

  public void setFrames(Integer value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(FRAMES), value);
  }

  public Integer getFrames() throws Exception {
    return EPICS_CONTROLLER.cagetInt(getChannel(FRAMES_RBV));
  }

  public void setStepTime(Double value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(STEPTIME), value);
  }

  public void setStepTime(Double value, double timeout) throws Exception {
    EPICS_CONTROLLER.caputWait(getChannel(STEPTIME), value, timeout);
  }

  public void setSlice(Integer value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(SLICE), value);
  }

  public void setSlice(Integer value, double timeout) throws Exception {
    EPICS_CONTROLLER.caputWait(getChannel(SLICE), value, timeout);
  }

  public Integer getSlice() throws Exception {
    return EPICS_CONTROLLER.cagetInt(getChannel(SLICE_RBV));
  }

  public Integer getTotalSteps() throws Exception {
    return EPICS_CONTROLLER.cagetInt(getChannel(TOTALPOINTS));
  }

  public Integer getTotalLeadPoints() throws Exception {
    return EPICS_CONTROLLER.cagetInt(getChannel(TOTALLEADPOINTS));
  }

  public Integer getTotalDataPoints() throws Exception {
    return EPICS_CONTROLLER.cagetInt(getChannel(TOTALDATAPOINTS));
  }

  public Integer getCurrentPoint() throws Exception {
    return EPICS_CONTROLLER.cagetInt(getChannel(CURRENTPOINT));
  }

  public void zeroSupplies() throws Exception {
    EPICS_CONTROLLER.caput(getChannel(ZERO_SUPPLIES), 1);
  }

  public double[] getSpectrum() throws Exception {
    return EPICS_CONTROLLER.cagetDoubleArray(getChannel(SPECTRUMDATA));
  }

  public double[] getImage() throws Exception {
    return EPICS_CONTROLLER.cagetDoubleArray(getChannel(IMAGEDATA));
  }

  public double[] getExtIO() throws Exception {
    return EPICS_CONTROLLER.cagetDoubleArray(getChannel(EXTIODATA));
  }

  public void setExcitationEnergy(Integer value) throws Exception {
    EPICS_CONTROLLER.caput(getChannel(EXCITATIONENERGY), value);
  }

  public double getExcitationEnergy() throws Exception {
    return EPICS_CONTROLLER.cagetDouble(getChannel(EXCITATIONENERGY_RBV));
  }

  public String getXUnits() throws Exception {
    return EPICS_CONTROLLER.cagetString(getChannel(XUNITS_RBV));
  }

  public String getYUnits() throws Exception {
    return EPICS_CONTROLLER.cagetString(getChannel(YUNITS_RBV));
  }
}
 public void setSlice(Integer value) throws Exception {
   EPICS_CONTROLLER.caput(getChannel(SLICE), value);
 }
 public void setStepTime(Double value) throws Exception {
   EPICS_CONTROLLER.caput(getChannel(STEPTIME), value);
 }
 public Integer getTotalDataPoints() throws Exception {
   return EPICS_CONTROLLER.cagetInt(getChannel(TOTALDATAPOINTS));
 }
 public Integer getTotalSteps() throws Exception {
   return EPICS_CONTROLLER.cagetInt(getChannel(TOTALPOINTS));
 }
 public Integer getSlice() throws Exception {
   return EPICS_CONTROLLER.cagetInt(getChannel(SLICE_RBV));
 }
 public void setSlice(Integer value, double timeout) throws Exception {
   EPICS_CONTROLLER.caputWait(getChannel(SLICE), value, timeout);
 }
 public Integer getFrames() throws Exception {
   return EPICS_CONTROLLER.cagetInt(getChannel(FRAMES_RBV));
 }
 public double[] getImage() throws Exception {
   return EPICS_CONTROLLER.cagetDoubleArray(getChannel(IMAGEDATA));
 }
 public void setStepTime(Double value, double timeout) throws Exception {
   EPICS_CONTROLLER.caputWait(getChannel(STEPTIME), value, timeout);
 }
 public Integer getCurrentPoint() throws Exception {
   return EPICS_CONTROLLER.cagetInt(getChannel(CURRENTPOINT));
 }
 public double[] getSpectrum() throws Exception {
   return EPICS_CONTROLLER.cagetDoubleArray(getChannel(SPECTRUMDATA));
 }
Esempio n. 29
0
 /** Constructor */
 public Spin() {
   controller = EpicsController.getInstance();
   channelManager = new EpicsChannelManager(this);
   sml = new StateMonitorListener();
 }
 public void zeroSupplies() throws Exception {
   EPICS_CONTROLLER.caput(getChannel(ZERO_SUPPLIES), 1);
 }