class MonitorEpicsPVClass(ScannableMotionBase): def __init__(self, name, strPV, strUnit, strFormat): self.setName(name); self.setInputNames([]) self.setExtraNames([name]); self.Units=[strUnit] self.setOutputFormat([strFormat]) self.setLevel(3) self.cli=CAClient(strPV) def atScanStart(self): if not self.cli.isConfigured(): self.cli.configure() def getPosition(self): if self.cli.isConfigured(): return float(self.cli.caget()) else: self.cli.configure() return float(self.cli.caget()) def isBusy(self): return 0 def atScanEnd(self): if self.cli.isConfigured(): self.cli.clearup()
class WaveformCapturer(DetectorBase):
'''
read-only detector to capture a data array from specified PV
'''
def __init__(self, name, pvname):
'''
Constructor
'''
self.setName(name)
self.pv=pvname
self.caclient=CAClient(pvname)
self.pointNumber=0
def collectData(self):
#read-only waveform does not need to be triggered
pass
def getStatus(self):
#read-only waveform always available
return 0
def readout(self):
try:
if not self.caclient.isConfigured():
self.caclient.configure()
output=self.caclient.cagetArrayDouble()
self.caclient.clearup()
else:
output=self.caclient.cagetArrayDouble()
return self.writeDataToFile(output)
except Exception, err:
print "Error returning current position", err
raise Exception
class BimorphVoltage(ScannableMotionBase):
def __init__(self, name, pvName, unitstring, formatstring):
self.setName(name)
self.voltagePv = CAClient(pvName)
self.Units = [unitstring]
self.setOutputFormat([formatstring])
def getPosition(self):
try:
if self.voltagePv.isConfigured():
return float(self.voltagePv.caget())
else:
self.voltagePv.configure()
return float(self.voltagePv.caget())
except:
print "Error getting position"
def asynchronousMoveTo(self, new_position):
self.currentposition = new_position
try:
if self.voltagePv.isConfigured():
self.voltagePv.caput(new_position)
else:
self.voltagePv.configure()
self.voltagePv.caput(new_position)
self.voltagePv.clearup()
except:
print "Error in moveTo"
def isBusy(self):
return 0
def caget(pvstring):
'caget from Jython'
cli = CAClient(pvstring)
cli.configure()
out = cli.caget()
cli.clearup()
return out
class DisplayEpicsPVClass(ScannableBase):
"""Create PD to display single EPICS PV"""
def __init__(self, name, pvstring, unitstring, formatstring):
self.setName(name)
self.setInputNames([])
self.setExtraNames([name])
self.Units = [unitstring]
self.setOutputFormat([formatstring])
self.setLevel(3)
self.cli = CAClient(pvstring)
def atStart(self):
if not self.cli.isConfigured():
self.cli.configure()
def getPosition(self):
if self.cli.isConfigured():
return float(self.cli.caget())
else:
self.cli.configure()
return float(self.cli.caget())
self.cli.clearup()
def isBusy(self):
return 0
def atEnd(self):
if self.cli.isConfigured():
self.cli.clearup()
def caget(pvstring): 'caget from Jython' cli=CAClient(pvstring) cli.configure() out=cli.caget() cli.clearup() return out
class EpicsSetGetClass(ScannableMotionBase):
'''Create PD for single EPICS positioner'''
def __init__(self, name, pvinstring, pvoutstring, unitstring,
formatstring):
self.setName(name)
self.setInputNames([name])
self.Units = [unitstring]
self.setOutputFormat([formatstring])
self.setLevel(3)
self.incli = CAClient(pvinstring)
self.outcli = CAClient(pvoutstring)
def getPosition(self):
try:
self.outcli.configure()
output = float(self.outcli.caget())
self.outcli.clearup()
return output
except:
print "Error returning position"
return 0
def asynchronousMoveTo(self, new_position):
try:
self.incli.configure()
self.incli.caput(new_position)
self.incli.clearup()
except:
print "error moving to position"
def isBusy(self):
return 0
class DisplayEpicsPVClass(ScannableBase):
'''Create PD to display single EPICS PV'''
def __init__(self, name, pvstring, unitstring, formatstring):
self.setName(name)
self.setInputNames([])
self.setExtraNames([name])
self.Units = [unitstring]
self.setOutputFormat([formatstring])
self.setLevel(3)
self.cli = CAClient(pvstring)
def atStart(self):
if not self.cli.isConfigured():
self.cli.configure()
def getPosition(self):
if self.cli.isConfigured():
return float(self.cli.caget())
else:
self.cli.configure()
return float(self.cli.caget())
self.cli.clearup()
def isBusy(self):
return 0
def atEnd(self):
if self.cli.isConfigured():
self.cli.clearup()
class EnumPVScannable(ScannableMotionBase):
'''
support get and set a multiple values Enum PV. There is no wait or check on set a value to the PV.
Once instantiated the object must be configured first before use
'''
def __init__(self, name, pv):
'''
Constructor
'''
self.setName(name)
self.setInputNames([name])
self.pvcli = CAClient(pv)
self.availablePositions = []
self.pvcli.configure()
sleep(1)
self.availablePositions = self.pvcli.cagetLables()
def getPosition(self):
return self.pvcli.caget()
def asynchronousMoveTo(self, newpos):
if newpos in self.availablePositions:
self.pvcli.caput(self.availablePositions.index(newpos))
else:
raise Exception("Requested mode %s is not available in list %s" %
(newpos, self.availablePositions))
def isBusy(self):
return False
def toFormattedString(self):
return "%s: %s" % (self.getName(), self.getPosition())
def __del__(self):
self.pvcli.clearup()
def sample_stage_home():
if is_live():
print('Homing sample stage')
caClient = CAClient()
try:
caClient.configure()
caClient.caput('BL08I-EA-TABLE-01:HM:HMGRP', 'All', 1)
caClient.caput('BL08I-EA-TABLE-01:HM:HOME', 1, 30)
finally:
caClient.clearup()
else:
print('Homing sample stage (dummy)')
SampleX.getMotor().home()
SampleY.getMotor().home()
SampleX_coarse.getMotor().home()
SampleY_coarse.getMotor().home()
SampleX_fine.getMotor().home()
SampleY_fine.getMotor().home()
SampleX.waitWhileBusy()
SampleY.waitWhileBusy()
SampleX_coarse.waitWhileBusy()
SampleY_coarse.waitWhileBusy()
SampleX_fine.waitWhileBusy()
SampleY_fine.waitWhileBusy()
print('Finished homing sample stage')
class BimorphVoltage(ScannableMotionBase):
def __init__(self, name, pvVoltage, pvStatus, formatstring):
self.setName(name)
self.chVoltage = CAClient(pvVoltage)
self.chStatus = CAClient(pvStatus)
self.Units = ['V']
self.setOutputFormat([formatstring])
self.delay = 5
self.timeout = 30
def setDelay(self, newDelay):
self.delay = newDelay
def setTimeout(self, newTimeout):
self.timeout = newTimeout
def getPosition(self):
try:
if self.chVoltage.isConfigured():
return float(self.chVoltage.caget())
else:
self.chVoltage.configure()
return float(self.chVoltage.caget())
except:
print "Error getting position"
def asynchronousMoveTo(self, new_position):
self.currentposition = new_position
try:
if self.chVoltage.isConfigured():
# self.chVoltage.caput(new_position, self.timeout);
self.chVoltage.caput(new_position)
else:
self.chVoltage.configure()
# self.chVoltage.caput(new_position, self.timeout);
self.chVoltage.caput(new_position)
self.chVoltage.clearup()
except:
print "Error in moveTo"
sleep(self.delay)
def getStatus(self):
try:
if self.chStatus.isConfigured():
return int(float(self.chStatus.caget()))
else:
self.chStatus.configure()
return int(float(self.chStatus.caget()))
except:
print "Error getting status"
def isBusy(self):
if self.getStatus() == 1: #It's done
return False
else:
return True
def assignStruckChannel(channelNo, nameList, namespace): allNames = '' for name in nameList: namespace[name] = ScalerSubsetScannable(name,globals()['struck1'],[channelNo]) allNames += name + '/' allNames = allNames[:-1] print "ch%i: %s" % (channelNo, allNames) cac = CAClient(ScalerSubsetScannable.struckRootPv+'SCALER.NM%i' % channelNo) cac.configure() cac.caput(allNames) cac.clearup()
def restart_ioc():
if is_live():
print('Restarting the IOC')
caClient = CAClient()
try:
caClient.configure()
caClient.caput('BL08I-CS-RSTRT-01:PSC:RESTART', 1, 0)
finally:
caClient.clearup()
else:
print('Restarting the IOC (dummy mode)')
time.sleep(2)
print('IOC restarted')
class HexapodAxis(PseudoDevice):
'''scannable or pseudo device for an individual, single Hexapod axis, it takes 8 inputs in the following order:
1. the name string of this object
2. the PV string for input target value
3. the PV string for read-back value
4. the PV string that control or start the motion
5. the positional tolerance within which the motor is treated as in-position
6. the unit string used for the measurement, keyworded as 'unitstring'
7. the format string for the return data, keyworded as 'formatstring'
8. the hexapod controller instance
for example,
hpx=HexapodAxis('hpx', 'ME02P-MO-BASE-01:UCS_X','ME02P-MO-BASE-01:UCSXR', 'ME02P-MO-BASE-01:START.PROC', 0.01, 'mm', '%9.4f', hexapodController)
'''
def __init__(self, name, pvinstring, pvoutstring, pvctrlstring, tolerance=0.01, unitstring='mm', formatstring='%9.4f', controller=None):
self.setName(name);
self.setInputNames([name])
self.Units=[unitstring]
self.setOutputFormat([formatstring])
self.setLevel(3)
self.incli=CAClient(pvinstring)
self.outcli=CAClient(pvoutstring)
self.movecli=CAClient(pvctrlstring)
self.lastpos=0.0
self.currentpos=0.0
self.targetpos=0.0
self._tolerance=tolerance
self.controller=controller
def atScanStart(self):
if not self.incli.isConfigured():
self.incli.configure()
if not self.outcli.isConfigured():
self.outcli.configure()
if not self.movecli.isConfigured():
self.movecli.configure()
def atScanEnd(self):
if self.incli.isConfigured():
self.incli.clearup()
if self.outcli.isConfigured():
self.outcli.clearup()
if self.movecli.isConfigured():
self.movecli.clearup()
def rawGetPosition(self):
try:
if self.outcli.isConfigured():
self.currentpos=float(self.outcli.caget())
else:
self.outcli.configure()
self.currentpos=float(self.outcli.caget())
self.outcli.clearup()
return self.currentpos
except Exception, err:
print "Error returning current position" + err
return 0
class PositionCompareClass(ScannableMotionBase):
'''Create a position compare scannable with separate PV names for demand, target and readback positions.'''
def __init__(self, name, pvdemand, pvreadback, tolerance, unitstring,
formatstring):
''' constructor
@param name: name of this scannable
@param pvdemand: the PV name for the demand position
@param pvreadback: the PV name for the current position or readback
@param tolerance: the tolerance value within which the readback position is regarded as reached to the demand position
@param unitstring: the String value of the unit
@param formatstring: the format string for the returned value.
'''
self.setName(name)
self.setInputNames([name])
self.unit = unitstring
self.setOutputFormat([formatstring])
self.setLevel(3)
self.demand = CAClient(pvdemand)
self.readback = CAClient(pvreadback)
self._tolerance = tolerance
def setTolerance(self, tolerance):
self._tolerance = tolerance
def getTolerance(self):
return self._tolerance
def atScanStart(self):
if not self.demand.isConfigured():
self.demand.configure()
if not self.readback.isConfigured():
self.readback.configure()
def rawGetPosition(self):
'''read the magnet value
'''
try:
if not self.readback.isConfigured():
self.readback.configure()
output = float(self.readback.caget())
self.readback.clearup()
else:
output = float(self.readback.caget())
return output
except Exception, e:
print("Error returning Magnet value")
raise e
class SingleEpicsPositionerClass(ScannableBase):
'''Create PD for single EPICS positioner'''
def __init__(self, name, pvinstring, pvoutstring, pvstatestring,
pvstopstring, unitstring, formatstring):
self.setName(name)
self.setInputNames([name])
self.setExtraNames([name])
self.Units = [unitstring]
self.setOutputFormat([formatstring])
self.setLevel(3)
self.incli = CAClient(pvinstring)
self.outcli = CAClient(pvoutstring)
self.statecli = CAClient(pvstatestring)
self.stopcli = CAClient(pvstopstring)
def atStart(self):
if not self.incli.isConfigured():
self.incli.configure()
if not self.outcli.isConfigured():
self.outcli.configure()
if not self.statecli.isConfigured():
self.statecli.configure()
if not self.stopcli.isConfigured():
self.stopcli.configure()
def getPosition(self):
output = 99
try:
if self.outcli.isConfigured():
# if not isinstance(self.outcli.caget(),type(None)):
# print self.outcli.caget()
return float(self.outcli.caget())
else:
self.outcli.configure()
output = self.outcli.caget()
if output == None:
raise Exception, "null pointer exception in getPosition"
self.outcli.clearup()
return float(output)
except Exception, e:
print "error in getPosition", e.getMessage(), e, output
raise e
class SingleEpicsPositionerClass(ScannableBase):
"""Create PD for single EPICS positioner"""
def __init__(self, name, pvinstring, pvoutstring, pvstatestring, pvstopstring, unitstring, formatstring):
self.setName(name)
self.setInputNames([name])
self.setExtraNames([name])
self.Units = [unitstring]
self.setOutputFormat([formatstring])
self.setLevel(3)
self.incli = CAClient(pvinstring)
self.outcli = CAClient(pvoutstring)
self.statecli = CAClient(pvstatestring)
self.stopcli = CAClient(pvstopstring)
def atStart(self):
if not self.incli.isConfigured():
self.incli.configure()
if not self.outcli.isConfigured():
self.outcli.configure()
if not self.statecli.isConfigured():
self.statecli.configure()
if not self.stopcli.isConfigured():
self.stopcli.configure()
def getPosition(self):
output = 99
try:
if self.outcli.isConfigured():
# if not isinstance(self.outcli.caget(),type(None)):
# print self.outcli.caget()
return float(self.outcli.caget())
else:
self.outcli.configure()
output = self.outcli.caget()
if output == None:
raise Exception, "null pointer exception in getPosition"
self.outcli.clearup()
return float(output)
except Exception, e:
print "error in getPosition", e.getMessage(), e, output
raise e
class EpicsReadPvWritePvClass(ScannableMotionBase):
def __init__(self, name, pvSet, pvGet, formatstring):
self.setName(name)
self.setInputNames([name])
self.setOutputFormat([formatstring])
self.setLevel(6)
self.chIn = CAClient(pvSet)
self.chOut = CAClient(pvGet)
def atScanStart(self):
if not self.chIn.isConfigured():
self.chIn.configure()
if not self.chOut.isConfigured():
self.chOut.configure()
def atScanEnd(self):
if self.chIn.isConfigured():
self.chIn.clearup()
if self.chOut.isConfigured():
self.chOut.clearup()
def getPosition(self):
output = 0.0
try:
if not self.chOut.isConfigured():
self.chOut.configure()
output = float(self.chOut.caget())
return float(output)
except:
print "Error returning position"
return 0
def asynchronousMoveTo(self, newpos):
try:
if not self.chIn.isConfigured():
self.outcli.configure()
self.chIn.caput(newpos)
except:
print "error moving to position %f" % float(newpos)
def isBusy(self):
return False
class ScannableMotorEpicsPVClass(ScannableMotionBase): def __init__(self, name, strPV, strUnit, strFormat): self.setName(name); self.setInputNames([name]) self.setExtraNames([name]); self.Units=[strUnit] self.setOutputFormat([strFormat]) self.setLevel(3) self.incli=CAClient(strPV+'.VAL') self.outcli=CAClient(strPV+'.RBV') self.statecli=CAClient(strPV+'.DMOV') self.stopcli=CAClient(strPV+'.STOP') self.delayTime = 0; def setDelay(self, newDelay): self.delayTime = newDelay; def atScanStart(self): if not self.incli.isConfigured(): self.incli.configure() if not self.outcli.isConfigured(): self.outcli.configure() if not self.statecli.isConfigured(): self.statecli.configure() if not self.stopcli.isConfigured(): self.stopcli.configure() def getPosition(self): output = 99 try: if self.outcli.isConfigured(): return float(self.outcli.caget()) else: self.outcli.configure() output = self.outcli.caget() if output == None: raise Exception, "null pointer exception in getPosition" self.outcli.clearup() return float(output) except Exception,e : print "error in getPosition", e.getMessage(), e, e.class, output
class EpicsPvClass(object):
def __init__(self, strPV):
self.pv = CAClient(strPV)
self.pv.configure()
def caput(self, value):
if self.pv.isConfigured():
self.pv.caput(value)
else:
self.pv.configure()
self.pv.caput(value)
self.pv.clearup()
def caget(self):
if self.pv.isConfigured():
result = self.pv.caget()
else:
self.pv.configure()
result = self.pv.caget()
self.pv.clearup()
return result
class HexapodAxisStatus(object): '''Hexapod axis status class implementing position-compare algorithm with tolerance input. isBusy() method should be used to query the motion status of this axis.''' def __init__(self, name, pvinstring, pvoutstring, tolerance=0.01): self.name=name self.incli=CAClient(pvinstring) self.outcli=CAClient(pvoutstring) self.currentpos=0.0 self.targetpos=0.0 self._tolerance=tolerance def getCurrentPosition(self): try: if self.outcli.isConfigured(): self.currentpos=float(self.outcli.caget()) else: self.outcli.configure() self.currentpos=float(self.outcli.caget()) self.outcli.clearup() return self.currentpos except Exception, err: print "Error returning current position of " + self.name + err return 0
class EpicsDeviceClass(object):
def __init__(self, pv):
self.pv = pv
self.ch = CAClient(self.pv)
self.ch.configure()
def caput(self, value):
if self.ch.isConfigured():
self.ch.caput(value)
else:
self.ch.configure()
self.ch.caput(value)
self.ch.clearup()
def caget(self):
if self.ch.isConfigured():
result = self.ch.caget()
else:
self.ch.configure()
result = self.ch.caget()
self.ch.clearup()
return result
class HexapodAxisStatus(object):
'''Hexapod axis status class implementing position-compare algorithm with tolerance input. isBusy() method should be used to query the motion status of this axis.'''
def __init__(self, name, pvinstring, pvoutstring, tolerance=0.01):
self.name = name
self.incli = CAClient(pvinstring)
self.outcli = CAClient(pvoutstring)
self.currentpos = 0.0
self.targetpos = 0.0
self._tolerance = tolerance
def getCurrentPosition(self):
try:
if self.outcli.isConfigured():
self.currentpos = float(self.outcli.caget())
else:
self.outcli.configure()
self.currentpos = float(self.outcli.caget())
self.outcli.clearup()
return self.currentpos
except Exception, err:
print "Error returning current position of " + self.name + err
return 0
class DisplayEpicsPVClass(ScannableMotionBase):
'''Create PD to display single EPICS PV'''
def __init__(self, name, pvstring, unitstring, formatstring):
self.setName(name)
self.setInputNames([name])
self.Units = [unitstring]
self.setOutputFormat([formatstring])
self.setLevel(8)
self.outcli = CAClient(pvstring)
def getPosition(self):
self.outcli.configure()
output = float(self.outcli.caget())
output = self.getOutputFormat()[0] % output
self.outcli.clearup()
return float(output)
def asynchronousMoveTo(self, position):
return
def isBusy(self):
return 0
class SingleChannelBimorphClass(ScannableMotionBase):
'''Create PD for single EPICS Bimorph channel'''
def __init__(self, name, pvinstring, pvoutstring, pvstatestring,
unitstring, formatstring):
self.setName(name)
self.setInputNames([name])
# self.setExtraNames([name]);
self.Units = [unitstring]
self.setOutputFormat([formatstring])
self.setLevel(3)
self.incli = CAClient(pvinstring)
self.outcli = CAClient(pvoutstring)
self.statecli = CAClient(pvstatestring)
def atStart(self):
if not self.incli.isConfigured():
self.incli.configured()
if not self.outcli.isConfigured():
self.outcli.configured()
if not self.statecli.isConfigured():
self.statecli.configured()
def getPosition(self):
try:
if self.outcli.isConfigured():
output = float(self.outcli.caget())
else:
self.outcli.configure()
output = float(self.outcli.caget())
self.outcli.clearup()
return output
except:
print "Error returning position"
return 0
def asynchronousMoveTo(self, new_position):
try:
if self.incli.isConfigured():
self.incli.caput(new_position)
else:
self.incli.configure()
self.incli.caput(new_position)
self.incli.clearup()
except:
print "error moving to position"
def isBusy(self):
try:
if self.statecli.isConfigured():
self.status = self.statecli.caget()
else:
self.statecli.configure()
self.status = self.statecli.caget()
self.statecli.clearup()
return int(self.status)
except:
print "problem with isMoving string: " + self.status + ": Returning busy status"
return 1
class DetectorExposureScannable(ScannableMotionBase):
'''
a scannable to change exposure time of a given detector PV at each scan data point during scan process
'''
def __init__(self, name, pv):
'''
create a scannable for specified PV
'''
self.setName(name)
self.setInputNames(['exposure'])
self.pv = pv
self.cli = CAClient(pv)
self._busy = False
def atScanStart(self):
if not self.cli.isConfigured():
self.cli.configure()
def atScanEnd(self):
if self.cli.isConfigured():
self.cli.clearup()
def asynchronousMoveTo(self, new_pos):
try:
if not self.cli.isConfigured():
self.cli.configure()
self._busy = True
self.cli.caput(float(new_pos))
except:
raise
finally:
self._busy = False
def getPosition(self):
return float(self.cli.caget())
def isBusy(self):
return self._busy
class SingleEpicsPositionerClass(ScannableMotionBase):
'''Create PD for single EPICS positioner'''
def __init__(self, name, pvinstring, pvoutstring, pvstatestring,
pvstopstring, unitstring, formatstring):
self.setName(name)
self.setInputNames([name])
self.Units = [unitstring]
self.setOutputFormat([formatstring])
self.setLevel(3)
self.incli = CAClient(pvinstring)
self.outcli = CAClient(pvoutstring)
self.statecli = CAClient(pvstatestring)
self.stopcli = CAClient(pvstopstring)
def getPosition(self):
try:
self.outcli.configure()
output = float(self.outcli.caget())
self.outcli.clearup()
return output
except:
print "Error returning position"
return 0
def asynchronousMoveTo(self, new_position):
try:
self.incli.configure()
self.incli.caput(new_position)
self.incli.clearup()
except:
print "error moving to position"
def isBusy(self):
try:
self.statecli.configure()
self.status = self.statecli.caget()
self.statecli.clearup()
return not int(self.status)
except:
print "problem with isMoving string: " + self.status + ": Returning busy status"
return 1
def stop(self):
print "calling stop"
self.stopcli.configure()
self.stopcli.caput(1)
self.stopcli.clearup()
class GasRigClass(ScannableMotionBase):
'''Create a scannable for a gas injection rig'''
def __init__(self, name, rootPV):
self.setName(name);
self.setInputNames([name])
self.setLevel(3)
self.setsequencecli=CAClient(rootPV+SEQUENCE_CONTROL)
self.statecli=CAClient(rootPV+SEQUENCE_STATUS)
self.atpressurecli=CAClient(rootPV+AT_PRESSURE_PROC)
def getState(self):
try:
if not self.statecli.isConfigured():
self.statecli.configure()
output=int(self.statecli.caget())
self.statecli.clearup()
else:
output=int(self.statecli.caget())
return sequence[output]
except:
print "Error returning current state"
return 0
def setSequence(self,new_position):
try:
if not self.setsequencecli.isConfigured():
self.setsequencecli.configure()
self.setsequencecli.caput(new_position)
self.setsequencecli.clearup()
else:
self.setsequencecli.caput(new_position)
except:
print "error setting sequence"
def atPressure(self):
try:
if not self.atpressurecli.isConfigured():
self.atpressurecli.configure()
self.atpressurecli.caput(1)
self.atpressurecli.clearup()
else:
self.atpressurecli.caput(1)
except:
print "error setting at_pressure"
class SamplePressure(ScannableBase, MonitorListener):
"""
create a sannable to provide control of gas pressure in the sample.
It will reports to users when the system pressure is less than the sample pressure requested.
"""
def __init__(self, name, systempressure):
"""
Constructor
"""
self.setName(name)
self.setInputNames([name])
self.increment = 0.01
self.target = 0.0
self.lastTarget = 0.0
self.sampleP = 0.0
self.currentpressure = 0.0
self.pressureTolerance = 0.002
self.outcli = CAClient(CurrentPressure)
self.incli = CAClient(TargetPressure)
self.sysp = systempressure
self.initialiseTarget()
def atScanStart(self):
"""intialise parameters before scan"""
# TODOS check requested sample pressure can be reached
if not self.outcli.isConfigured():
self.outcli.configure()
if not self.incli.isConfigured():
self.incli.configure()
self.target = self.getPosition()
def atScanEnd(self):
"""clean up resources"""
if self.outcli.isConfigured():
self.outcli.clearup()
if self.incli.isConfigured():
self.incli.clearup()
def atPointStart(self):
pass
def atPointEnd(self):
pass
def getPosition(self):
"""
return the current gas pressure in sample
"""
try:
if not self.outcli.isConfigured():
self.outcli.configure()
output = float(self.outcli.caget())
self.outcli.clearup()
else:
output = float(self.outcli.caget())
return output
except:
print "Error returning current position"
return 0
def asynchronousMoveTo(self, new_position):
"""
move the sample pressure to the specified value asynchronously.
"""
try:
self.lastTarget = round(self.getLastTarget(), 3)
self.sampleP = round(self.getPosition(), 3)
self.target = round(float(new_position), 3)
thread.start_new_thread(self.setSamplePressure, (self.sampleP, self.target, self.increment))
except:
print "error moving sample pressure to (%s): %f" % (sys.exc_info()[0], float(new_position))
raise
def isBusy(self):
return abs(self.getPosition() - self.getTarget()) > self.getTolerance()
def stop(self):
"""
stop or abort pressure move in the sample.
"""
self.asynchronousMoveTo(self.getPosition())
if self.outcli.isConfigured():
self.outcli.clearup()
if self.incli.isConfigured():
self.incli.clearup()
def setSamplePressure(self, SampleP, target, increment):
# SET FINAL SAMPLE PRESSURE AND INCREMENTS
if SampleP < target:
SampleP = round(self.lastTarget + increment, 3) # increments in bar
if SampleP > target:
return
try:
if not self.incli.isConfigured():
self.incli.configure()
while SampleP <= target: # final sample pressure in bar
# interruptable()
self.incli.caput(SampleP)
# print "set sample pressure to "+str(SampleP)+", target is "+str(target)
sleep(5) # wait time in seconds
SampleP = round(SampleP + increment, 3)
# check if smaple pressure required greater the system pressure then exit
if self.sysp.getPosition() < target:
# TODOs recharge the system pressure here???
print "System pressure %f is less than the demanding sample pressure %f. Please abort this scan or re-charge the system pressure." % (
self.sysp.getPosition(),
target,
)
# if self.incli.isConfigured():
# self.incli.clearup()
except:
print "error moving to position"
elif SampleP > target:
SampleP = round(self.lastTarget - increment, 3) # increments in bar
if SampleP < target:
return
if SampleP < 0:
SampleP = 0
if target < 0:
raise Exception("Pressure cannot be negative.")
try:
if not self.incli.isConfigured():
self.incli.configure()
while SampleP >= target: # final sample pressure in bar
# interruptable()
self.incli.caput(SampleP)
# print "set sample pressure to "+str(SampleP)+", target is "+str(target)
sleep(5) # wait time in seconds
SampleP = round(SampleP - increment, 3)
if SampleP < 0:
self.incli.caput(0)
break
# if self.incli.isConfigured():
# self.incli.clearup()
except:
print "error moving to position"
else:
print "already at the sample pressure."
return
def setIncrement(self, value):
self.increment = value
def getIncrement(self):
return self.increment
def getTarget(self):
return self.target
def getLastTarget(self):
try:
if not self.incli.isConfigured():
self.incli.configure()
output = float(self.incli.caget())
self.incli.clearup()
else:
output = float(self.incli.caget())
return output
except:
print "Error returning target value"
return 0
def initialiseTarget(self):
self.lastTarget = self.getLastTarget()
def getTolerance(self):
return self.pressureTolerance
def setTolerance(self, value):
self.pressureTolerance = value
class TemperatureControllerClass(ScannableMotionBase):
def __init__(self, name, strTempSetPV, strTempSetReadBackPV, strTemp1GetPV,
strTemp2GetPV):
self.setName(name)
self.setInputNames([name])
self.setExtraNames(['T1', 'T2'])
self.setOutputFormat(["%6.3f", "%6.3f", "%6.3f"])
# self.Units=[strUnit];
self.setLevel(7)
# self.setOutputFormat(["%20.12f"]);
self.currentTemp = [0, 0]
self.demondTemp = 0
#Default delay is 10 minutes = 600 seconds
self.waitTime = 600
self.waitEnough = True
self.errorTolerance = 1
self.chSetTemp = CAClient(strTempSetPV)
self.chSetTemp.configure()
self.chSetTempRB = CAClient(strTempSetReadBackPV)
self.chSetTempRB.configure()
self.chGetTemp1 = CAClient(strTemp1GetPV)
self.chGetTemp1.configure()
self.chGetTemp2 = CAClient(strTemp2GetPV)
self.chGetTemp2.configure()
def setDelay(self, newWait):
self.waitTime = newWait
def setError(self, newError):
self.errorTolerance = newError
def setTemp(self, x):
self.demondTemp = x
if self.chSetTemp.isConfigured():
self.chSetTemp.caput(x)
else:
self.chSetTemp.configure()
self.chSetTemp.caput(x)
self.chSetTemp.clearup()
self.waitEnough = False
def getTemp(self):
if self.chSetTempRB.isConfigured():
p0 = self.chSetTempRB.caget()
else:
self.chSetTempRB.configure()
p0 = self.chSetTempRB.caget()
self.chSetTempRB.clearup()
if self.chGetTemp1.isConfigured():
p1 = self.chGetTemp1.caget()
else:
self.chGetTemp1.configure()
p1 = self.chGetTemp1.caget()
self.chGetTemp1.clearup()
if self.chGetTemp2.isConfigured():
p2 = self.chGetTemp2.caget()
else:
self.chGetTemp2.configure()
p2 = self.chGetTemp2.caget()
self.chGetTemp2.clearup()
self.demondTemp = float(float(p0))
self.currentTemp = [float(p1), float(p2)]
return [self.demondTemp, self.currentTemp[0], self.currentTemp[1]]
def waitTillReady(self):
if self.waitEnough:
return
#wait until T1 is ready
nToast = 3
while nToast > 0:
self.getTemp()
if math.fabs(self.currentTemp[0] -
self.demondTemp) > self.errorTolerance:
print 'T1 is not ready yet, wait...'
sleep(10)
else:
print 'T1 is checked and seems OK.'
sleep(10)
nToast -= 1
#Wait the waitTime for T2
print 'Wait ' + str(self.waitTime) + ' seconds for T2'
sleep(self.waitTime)
self.waitEnough = True
print 'T2 wake up'
def checkReady(self):
return self.waitEnough
#Pseudo Device Implementations
def atScanStart(self):
if not self.chSetTemp.isConfigured():
self.chSetTemp.configure()
if not self.chSetTempRB.isConfigured():
self.chSetTempRB.configure()
if not self.chGetTemp1.isConfigured():
self.chGetTemp1.configure()
if not self.chGetTemp2.isConfigured():
self.chGetTemp2.configure()
def atScanEnd(self):
if self.chSetTemp.isConfigured():
self.chSetTemp.clearup()
if self.chSetTempRB.isConfigured():
self.chSetTempRB.clearup()
if self.chGetTemp1.isConfigured():
self.chGetTemp1.clearup()
if self.chGetTemp2.isConfigured():
self.chGetTemp2.clearup()
def getPosition(self):
return self.getTemp()
def asynchronousMoveTo(self, newPos):
self.setTemp(newPos)
self.waitTillReady()
def isBusy(self):
if self.checkReady():
result = False
else:
result = True
return result
def toString(self):
ss = self.getName() + " [tem, tem1, tem2]: " + str(self.getPosition())
return ss
class PixisDetectorClass(DetectorBase):
def __init__(self, name, panelName, detectorName, initPV="BL06I-EA-PIXIS-01:CAM:Initialize"):
self.setName(name);
self.setInputNames([name]);
self.setExtraNames([]);
# self.Units=[strUnit];
self.setLevel(7);
self.panel = panelName;
self.detectorName=detectorName;
self.initPV=initPV;
self.detector=None;
self.fileName=None;
self.dataHolder = None;
self.ch=None;
self.exposureTime = 0
self.logScale = False;
self.alive=False;
self.connect();
def connect(self):
try:
self.ch=CAClient(self.initPV);
self.ch.configure();
self.detector =vars(gdamain)[self.detectorName];
print "PIXIS Camera is connected successfully."
except:
exceptionType, exception, traceback=sys.exc_info();
logger.dump("PIXIS Camera can not be connected ", exceptionType, exception, traceback)
#DetectorBase Implementation
def getCollectionTime(self):
self.exposureTime=self.detector.getCollectionTime();
return self.exposureTime;
def setCollectionTime(self, newExpos):
self.exposureTime = newExpos;
self.detector.setCollectionTime(self.exposureTime);
def prepareForCollection(self):
self.detector.prepareForCollection();
def endCollection(self):
self.detector.endCollection();
def collectData(self):
self.initialiseDetector(1);#To press the Initialize Detector button
self.detector.collectData();
return;
def readout(self):
# self.getMetadata();
nxDetectorReturn=self.detector.readout();
if isinstance(nxDetectorReturn, NXDetectorDataWithFilepathForSrs):
self.fileName=nxDetectorReturn.getFilepath();
else:
self.fileName=str(nxDetectorReturn);
# Trying to re-enable this results in the
errorWhenEnabled=""" See /uk.ac.gda.devices.peem/src/gda/device/detector/areadetector/AreaDetectorController.java:339
/dls/i06-1/data/2014/si9122-1/104163_PixisImage/pixis_000001.tif
2014-03-06 12:43:28,340 INFO [ScriptLogger] - PilatusDetectorPseudoDevice.readout(): File '/dls/i06-1/data/2014/si9122-1/104159_PixisImagepixis_000000.tif' does not exist!
2014-03-06 12:43:28,342 INFO [gda.jython.logger.RedirectableFileLogger] - | PilatusDetectorPseudoDevice.readout(): File '/dls/i06-1/data/2014/si9122-1/104159_PixisImagepixis_000000.tif' does not exist!
2014-03-06 12:43:28,353 INFO [gda.jython.logger.RedirectableFileLogger] - | ====================================================================================================
2014-03-06 12:43:28,355 ERROR [gda.scan.ScanBase] java.lang.Exception: during scan collection: DeviceException: Traceback (most recent call last):
File "/dls_sw/i06-1/software/gda_versions/gda_8.34b/workspace_git/gda-mt.git/configurations/mt-config/scripts/Diamond/Pixis/PixisDetector.py", line 93, in readout
raise Exception("No File Found Error");
"""
# if not self.fileExists(self.fileName, 100):
# logger.simpleLog( "PilatusDetectorPseudoDevice.readout(): File '" + self.fileName + "' does not exist!" );
# raise Exception("No File Found Error");
#
# self.createMetadataFiles( str(self.fileName) );
if self.alive:
self.display();
return self.fileName;
def getStatus(self):
return self.detector.getStatus();
def createsOwnFiles(self):
return True;
## Extra Implementation
def initialiseDetector(self, value=1):
# self.pv=GDAEpicsInterfaceReader.getPVFromSimplePVType(deviceName);
if self.ch.isConfigured():
self.ch.caput(value);
else:
self.ch.configure();
self.ch.caput(value);
self.ch.clearup();
def fileExists(self, fileName, numberOfTry):
result = False;
for i in range(numberOfTry):
if (not os.path.exists(fileName)) or (not os.path.isfile(fileName)):
print "File '%s' does not exist on try " % fileName + str(i+1);
logger.simpleLog( "PixisDetectorClass: File does not exist on try " + str(i+1) );
#check again:
sleep(1);
os.system("ls -la " + fileName);
else:
#To touch the file will change the timestamps on the directory, which in turn causes the client to refetch the file's attributes.
os.system("touch -c " + fileName);
#To check the file size non zero
fsize = os.stat(fileName)[stat.ST_SIZE];
print "File exists on try " + str(i+1) + " with size " + str(fsize);
logger.simpleLog( "Pixis Camera: File '" + fileName + "' exists on try " + str(i+1) + " with size " + str(fsize) );
sizePixis = 8388782L;
if fsize!=sizePixis:
print "Wrong file size: " + str(fsize);
logger.simpleLog( "PixisDetector: File '" + fileName + "' has wrong file size: " + str(fsize) );
sleep(1);
continue;
#The file seems exist with some content inside. Double check to make sure it's available
try:
#To touch the file will change the timestamps on the directory, which in turn causes the client to refetch the file's attributes.
os.system("touch -c " + fileName);
tf = open(fileName,"rb");
tf.close();
result = True;
break;
except:
print "There are something wrong on the file system !!!"
logger.simpleLog( "PixisDetectorClass: There are something wrong on the file system !!!");
return result;
def setAlive(self, newAlive=True):
self.alive = newAlive;
def setLogScale(self, newLogScale=True):
self.logScale = newLogScale;
def setPanel(self, newPanelName):
self.panel = newPanelName;
def singleShot(self, newExpos):
"""Shot single image with given exposure time""";
if self.getStatus() != Detector.IDLE:
print 'PIXIS detector not available, please try later';
return;
self.setCollectionTime(newExpos);
self.collectData();
while self.getStatus() != Detector.IDLE:
sleep(self.exposureTime/2);
return self.readout();
def display(self, fileName=None):
if fileName is None:
fileName = self.fileName;
self.dataHolder=dnp.io.load(fileName);
dataset = self.dataHolder[0];
if self.panel:
if self.logScale:
SDAPlotter.imagePlot(self.panel, DatasetUtils.lognorm(dataset)); #For RCP GUI
else:
SDAPlotter.imagePlot(self.panel, dataset); #For RCP GUI
else:
print "No panel set to display"
raise Exception("No panel_name set in %s. Set this or set %s.setAlive(False)" % (self.name,self.name));
class StripChart(MonitorListener):
'''
plot y dataset against x dataset for a fixed length, new data added push oldest data out in the datasets.
'''
def __init__(self, xpv, ypv, controlpv, numberofpointstoplot=1000,save=False):
'''
Constructor
'''
self.xpv=xpv
self.ypv=ypv
self.xcli=CAClient(xpv)
self.ycli=CAClient(ypv)
self.control=CAClient(controlpv)
self.x=array.array('d')
self.y=array.array('d')
self.plotsize=numberofpointstoplot
self.isSave=save
def start(self):
if not self.xcli.isConfigured():
self.xcli.configure()
if not self.ycli.isConfigured():
self.ycli.configure()
if not self.control.isConfigured():
self.control.configure()
self._first=True
self.xmonitor=self.xcli.camonitor(self)
self.ymonitor=self.ycli.camonitor(self)
self.control.caput(1)
def stop(self):
self.control.caput(0)
self.xcli.removeMonitor(self.xmonitor)
self.ycli.removeMonitor(self.ymonitor)
if self.xcli.isConfigured():
self.xcli.clearup()
if self.ycli.isConfigured():
self.ycli.clearup()
if self.control.isConfigured():
self.control.clearup()
def monitorChanged(self, mevent):
if self._first:
self._first=False
return
if str(mevent.getSource().getName()).trim()==self.xpv:
self.x.append(float(mevent.getDBR().getDoubleValue()[0]))
if str(mevent.getSource().getName()).trim()==self.ypv:
self.y.append(float(mevent.getDBR().getDoubleValue()[0]))
if self.x.count() == self.y.count():
if self.x.count() <= self.plotsize:
dnp.plot.line(self.x, self.y, "Plot")
else:
dnp.plot.plot(self.x[-self.plotsize:], self.y[-self.plotsize:], "Plot")
def writeData(self):
self.stop()
self.stattimestamp.removeMonitor(self.timemonitor)
self.stattotal.removeMonitor(self.countmonitor)
filename=nextDataFile()
print "saving data to %s, please wait..." % filename
#length=min(self.timedata.getData().size, self.countdata.getData().size)
timedataset=self.timedata.getData()
countdataset=self.countdata.getData()
dnp.plot.plot(timedataset, countdataset, "Plot")
outfile=open(filename,"w")
for time, count in zip(timedataset.getData().tolist(), countdataset.getData().tolist()):
outfile.write("%f\t%d\n"% (time, count))
outfile.close()
#dnp.io.save(filename, [timedataset, countdataset], format="text") # write 2 text fileseach with one dataset
print "collection completed."
class ScalerChannelMonitorEpicsPVClass(ScannableMotionBase):
def __init__(self, name, strPV, strCh, time):
self.setName(name);
self.setInputNames([])
self.setExtraNames([name]);
# self.Units=[strUnit]
# self.setOutputFormat(['%d'])
self.setLevel(3)
self.chTP=CAClient(strPV+'.TP')
self.chCNT=CAClient(strPV+'.CNT')
self.chFREQ=CAClient(strPV+'.FREQ')
self.chPRn=CAClient(strPV+'.PR' + strCh)
self.chSn=CAClient(strPV+'.S' + strCh)
def atScanStart(self):
if not self.chTP.isConfigured():
self.chTP.configure()
if not self.chCNT.isConfigured():
self.chCNT.configure()
if not self.chFREQ.isConfigured():
self.chFREQ.configure()
if not self.chPRn.isConfigured():
self.chPRn.configure()
if not self.chSn.isConfigured():
self.chSn.configure()
def getPresetTime(self):
#get time preset
if self.chTP.isConfigured():
self.tp = self.chTP.caget()
else:
self.chTP.configure()
self.tp = self.chTP.caget()
self.chTP.clearup()
return self.tp
def setPresetTime(self, float):
#get time preset
if self.chTP.isConfigured():
tp = self.chTP.caget()
else:
self.chTP.configure()
tp = self.chTP.caget()
self.chTP.clearup()
self.tp = self.getTP()
def getPosition(self):
self.tp = self.getPresetTime()
self.startCounting();
while self.isBusy():
Thread.sleep(tp);
self.startCounting();
while self.isBusy():
Thread.sleep(tp);
output = self.getCount();
return output;
def getCount(self):
if self.chSn.isConfigured():
output = self.chSn.caget()
else:
self.chSn.configure()
output = self.chSn.caget()
self.chSn.clearup()
return long(output)
def startCounting(self):
self.status = '1'
if self.chCNT.isConfigured():
self.chCNT.caput(self.stauts) ##start counting
else:
self.chCNT.configure()
self.chCNT.caput(self.stauts) ##start counting
self.chCNT.clearup()
def isBusy(self):
try:
if self.chCNT.isConfigured():
self.stauts = self.chCNT.caget()
else:
self.chCNT.configure()
self.stauts = self.chCNT.caget()
self.chCNT.clearup()
if self.stauts == '1': #still counting, busy
return 1
elif self.stauts == '0': # count finished. not busy
return 0
else: #strange condition, caget some wrong status
raise ScalerException("Wrong Scaler CNT")
return 1
except ScalerException, e:
print "error in ScalerChannelMonitorEpicsPVClass.isBusy()."
print e
print self.status
except Exception, e:
print "What ever exception raised in ScalerChannelMonitorEpicsPVClass.isBusy()."
print e
print self.status
class AlicatMassFlowController(ScannableMotionBase):
'''
scannable for set and get mass flow in a scannable way. It also provides method to query other mass flow properties.
'''
def __init__(self,name, rootPV, tolerance=0.01, formatstring="%.3f"):
'''
Constructor
'''
self.setName(name)
self.setInputNames([name])
self.setOutputFormat([formatstring])
self.setLevel(5)
self.currentflowcli=CAClient(rootPV+READ_MASS_FLOW)
self.setflowtargetcli=CAClient(rootPV+SET_MASS_FLOW_TARGET)
self.readflowtargetcli=CAClient(rootPV+READ_MASS_FLOW_TARGET)
self.currentgastypecli=CAClient(rootPV+READ_GAS_TYPE)
self.setfgastype1cli=CAClient(rootPV+SELECT_GAS_TYPE_1)
self.setfgastype2cli=CAClient(rootPV+SELECT_GAS_TYPE_2)
self.setgastypenumbercli=CAClient(rootPV+SET_GAS_TYPE_BY_NUMBER)
self.pressurecli=CAClient(rootPV+READ_PRESSURE_IN_BAR)
self.temperaturecli=CAClient(rootPV+READ_TEMPERATURE)
self.volumetricflowcli=CAClient(rootPV+READ_VOLUMETRIC_FLOW)
self.setproportionalgaincli=CAClient(rootPV+SET_PROPORTIONAL_GAIN)
self.readproportionalgaincli=CAClient(rootPV+READ_PROPORTIONAL_GAIN)
self.setderivativegaincli=CAClient(rootPV+SET_DERIVATIVE_GAIN)
self.readderivativegaincli=CAClient(rootPV+READ_DERIVATIVE_GAIN)
self.mytolerance=tolerance
def getTolerance(self):
return self.mytolerance
def setTolerance(self, value):
self.mytolerance=value
def getCurrentFlow(self):
try:
if not self.currentflowcli.isConfigured():
self.currentflowcli.configure()
output=float(self.currentflowcli.caget())
self.currentflowcli.clearup()
else:
output=float(self.currentflowcli.caget())
return output
except:
print "Error returning current flow value"
return 0
def setTarget(self, target):
try:
if not self.setflowtargetcli.isConfigured():
self.setflowtargetcli.configure()
self.setflowtargetcli.caput(target)
self.setflowtargetcli.clearup()
else:
self.setflowtargetcli.caput(target)
except:
print "error set to target flow value"
def getTarget(self):
try:
if not self.readflowtargetcli.isConfigured():
self.readflowtargetcli.configure()
output=float(self.currentflowcli.caget())
self.readflowtargetcli.clearup()
else:
output=float(self.readflowtargetcli.caget())
return output
except:
print "Error returning flow target value"
return 0
def getGasType(self):
#self.currentgastypecli does not work in EPICS
try:
if not self.setgastypenumbercli.isConfigured():
self.setgastypenumbercli.configure()
output=int(self.setgastypenumbercli.caget())
self.setgastypenumbercli.clearup()
else:
output=int(self.setgastypenumbercli.caget())
return gasTypes[output]
except:
print "Error returning current gas type"
return 0
def setGasType(self,name):
key=gasTypes.keys()[(gasTypes.values()).index(name)]
if int(key)>=0 or int(key) <16:
try:
if not self.setfgastype1cli.isConfigured():
self.setfgastype1cli.configure()
self.setfgastype1cli.caput(name)
self.setfgastype1cli.clearup()
else:
self.setfgastype1cli.caput(name)
except:
print "error set to gas type 1"
else:
try:
if not self.setfgastype2cli.isConfigured():
self.setfgastype2cli.configure()
self.setfgastype2cli.caput(name)
self.setfgastype2cli.clearup()
else:
self.setfgastype2cli.caput(name)
except:
print "error set to gas type 2"
def getPressure(self):
try:
if not self.pressurecli.isConfigured():
self.pressurecli.configure()
output=float(self.pressurecli.caget())
self.pressurecli.clearup()
else:
output=float(self.pressurecli.caget())
return output
except:
print "Error returning pressure"
return 0
def getTemperature(self):
try:
if not self.temperaturecli.isConfigured():
self.temperaturecli.configure()
output=float(self.temperaturecli.caget())
self.temperaturecli.clearup()
else:
output=float(self.temperaturecli.caget())
return output
except:
print "Error returning temperature"
return 0
def getVolumetricFlow(self):
try:
if not self.volumetricflowcli.isConfigured():
self.volumetricflowcli.configure()
output=float(self.volumetricflowcli.caget())
self.volumetricflowcli.clearup()
else:
output=float(self.volumetricflowcli.caget())
return output
except:
print "Error returning volumetric flow"
return 0
def getProportionalGain(self):
try:
if not self.readproportionalgaincli.isConfigured():
self.readproportionalgaincli.configure()
output=float(self.readproportionalgaincli.caget())
self.readproportionalgaincli.clearup()
else:
output=float(self.readproportionalgaincli.caget())
return output
except:
print "Error returning Proportional Gain"
return 0
def setProportionalGain(self, gain):
try:
if not self.setproportionalgaincli.isConfigured():
self.setproportionalgaincli.configure()
self.setproportionalgaincli.caput(gain)
self.setproportionalgaincli.clearup()
else:
self.setproportionalgaincli.caput(gain)
except:
print "error set to proportional gain"
def getDerivativeGain(self):
try:
if not self.readderivativegaincli.isConfigured():
self.readderivativegaincli.configure()
output=float(self.readderivativegaincli.caget())
self.readderivativegaincli.clearup()
else:
output=float(self.readderivativegaincli.caget())
return output
except:
print "Error returning Derivative Gain"
return 0
def setDerivativeGain(self, gain):
try:
if not self.setderivativegaincli.isConfigured():
self.setderivativegaincli.configure()
self.setderivativegaincli.caput(gain)
self.setderivativegaincli.clearup()
else:
self.setderivativegaincli.caput(gain)
except:
print "error set to derivative gain"
#### methods for scannable
def getPosition(self):
return self.getCurrentFlow()
def asynchronousMoveTo(self, posi):
self.setTarget(float(posi))
def isBusy(self):
return (abs(self.getPosition()-self.getTarget())>self.getTolerance())
def atScanStart(self):
pass
def atPointStart(self):
pass
def stop(self):
pass
def atPointEnd(self):
pass
def atScanEnd(self):
pass
def caput(pvstring,value): 'caput from Jython' cli=CAClient(pvstring) cli.configure() cli.caput(value) cli.clearup()
def cagetArray(pvstring): cli=CAClient(pvstring) cli.configure() out=cli.cagetArrayDouble() cli.clearup() return out
def caput_wait(pvstring, value, timeout=10): cli=CAClient(pvstring) cli.configure() cli.caput(timeout, value) cli.clearup()
class DetectorControlClass(ScannableMotionBase):
"""Create PD for single EPICS ETL detector"""
def __init__(self, name, pvinstring, pvoutstring, unitstring, formatstring):
self.setName(name)
self.setInputNames([name])
self.Units = [unitstring]
self.setOutputFormat([formatstring])
self.setLevel(3)
self.incli = CAClient(pvinstring)
self.outcli = CAClient(pvoutstring)
def atStart(self):
if not self.incli.isConfigured():
self.incli.configure()
if not self.outcli.isConfigured():
self.outcli.configure()
def getPosition(self):
try:
if not self.outcli.isConfigured():
self.outcli.configure()
output = float(self.outcli.caget())
self.outcli.clearup()
else:
output = float(self.outcli.caget())
return output
except:
print "Error returning current position"
return 0
def getTargetPosition(self):
try:
if not self.incli.isConfigured():
self.incli.configure()
target = float(self.incli.caget())
self.incli.clearup()
else:
target = float(self.incli.caget())
return target
except:
print "Error returning target position"
return 0
def asynchronousMoveTo(self, new_position):
try:
if not self.incli.isConfigured():
self.incli.configure()
self.incli.caput(new_position)
self.incli.clearup()
else:
self.incli.caput(new_position)
except:
print "error moving to position"
def isBusy(self):
return self.getPosition() != self.getTargetPosition()
def atEnd(self):
if self.incli.isConfigured():
self.incli.clearup()
if self.outcli.isConfigured():
self.outcli.clearup()
def toString(self):
return self.name + " : " + str(self.getPosition())
class PositionCompareMotorWithLimitsClass(ScannableMotionBase):
'''Create a scannable for a single motor'''
def __init__(self, name, pvinstring, pvoutstring, pvstopstring, tolerance, unitstring, formatstring, upperlimit, lowerlimit):
self.setName(name);
self.setInputNames([name])
self.Units=[unitstring]
self.setOutputFormat([formatstring])
self.setLevel(5)
self.incli=CAClient(pvinstring)
self.outcli=CAClient(pvoutstring)
self.stopcli=CAClient(pvstopstring)
self._tolerance=tolerance
self.setUpperGdaLimits(upperlimit)
self.setLowerGdaLimits(lowerlimit)
def setLowerGdaLimits(self, lowerlimit):
ScannableMotionBase.setLowerGdaLimits(lowerlimit)
def getLowerGdaLimits(self):
return ScannableMotionBase.getLowerGdaLimits()
def setUpperGdaLimits(self, upperlimit):
ScannableMotionBase.setUpperGdaLimits(upperlimit)
def getUpperGdaLimits(self):
return ScannableMotionBase.getUpperGdaLimits()
def setTolerance(self, tolerance):
self._tolerance=tolerance
def getTolerance(self):
return self._tolerance
def atScanStart(self):
if not self.incli.isConfigured():
self.incli.configure()
if not self.outcli.isConfigured():
self.outcli.configure()
if not self.stopcli.isConfigured():
self.stopcli.configure()
def rawGetPosition(self):
try:
if not self.outcli.isConfigured():
self.outcli.configure()
output=float(self.outcli.caget())
self.outcli.clearup()
else:
output=float(self.outcli.caget())
return output
except:
print "Error returning current position"
return 0
def getTargetPosition(self):
try:
if not self.incli.isConfigured():
self.incli.configure()
target=float(self.incli.caget())
self.incli.clearup()
else:
target=float(self.incli.caget())
return target
except:
print "Error returning target position"
return 0
def rawAsynchronousMoveTo(self,new_position):
try:
if not self.incli.isConfigured():
self.incli.configure()
self.incli.caput(new_position)
self.incli.clearup()
else:
self.incli.caput(new_position)
except:
print "error moving to position"
def rawIsBusy(self):
return ( not abs(self.rawGetPosition() - self.getTargetPosition()) < self._tolerance)
def atScanEnd(self):
if self.incli.isConfigured():
self.incli.clearup()
if self.outcli.isConfigured():
self.outcli.clearup()
if self.stopcli.isConfigured():
self.stopcli.clearup()
def stop(self):
if not self.stopcli.isConfigured():
self.stopcli.configure()
self.stopcli.caput(1)
self.stopcli.clearup()
else:
self.stopcli.caput(1)
def toString(self):
return self.name + " : " + str(self.getPosition())
class ScalerChannelEpicsPVClass(ScannableBase): def __init__(self, name, strChTP, strChCNT, strChSn): self.setName(name); self.setInputNames([]); self.setExtraNames([name]); # self.Units=[strUnit]; #self.setLevel(5); self.setOutputFormat(["%20.12f"]); self.chTP=CAClient(strChTP); self.chCNT=CAClient(strChCNT); self.chSn=CAClient(strChSn); self.tp = -1; # self.setTimePreset(time) def atStart(self): if not self.chTP.isConfigured(): self.chTP.configure() if not self.chCNT.isConfigured(): self.chCNT.configure() if not self.chSn.isConfigured(): self.chSn.configure() #Scannable Implementations def getPosition(self): return self.getCount(); def asynchronousMoveTo(self,newPos): self.setCollectionTime(newPos); self.collectData(); def isBusy(self): return self.getStatus() def atEnd(self): if self.chTP.isConfigured(): self.chTP.clearup() if self.chCNT.isConfigured(): self.chCNT.clearup() if self.chSn.isConfigured(): self.chSn.clearup() #Scaler 8512 implementations def getTimePreset(self): if self.chTP.isConfigured(): newtp = self.chTP.caget() else: self.chTP.configure() newtp = float(self.chTP.caget()) self.chTP.clearup() self.tp = newtp return self.tp #Set the Time Preset and start counting automatically def setTimePreset(self, newTime): self.tp = newTime newtp = newTime; if self.chTP.isConfigured(): tp = self.chTP.caput(newtp) else: self.chTP.configure() tp = self.chTP.caput(newtp) self.chTP.clearup() # Thread.sleep(1000) def getCount(self): if self.chSn.isConfigured(): output = self.chSn.caget() else: self.chSn.configure() output = self.chSn.caget() self.chSn.clearup() return float(output) #Detector implementations #Tells the detector to begin to collect a set of data, then returns immediately. #public void collectData() throws DeviceException; #Set the Time Preset and start counting automatically def collectData(self): #self.setTimePreset(self.tp) if self.chCNT.isConfigured(): tp = self.chCNT.caput(1) else: self.chCNT.configure() tp = self.chCNT.caput(1) self.chCNT.clearup() # Thread.sleep(1000) #Tells the detector how long to collect for during a call of the collectData() method. #public void setCollectionTime(double time) throws DeviceException; def setCollectionTime(self, newTime): self.setTimePreset(newTime) #Returns the latest data collected. #public Object readout() throws DeviceException; def getCollectionTime(self): nc=self.getTimePreset() return nc #Returns the current collecting state of the device. # return ACTIVE (1) if the detector has not finished the requested operation(s), # IDLE(0) if in an completely idle state and # STANDBY(2) if temporarily suspended. #public int getStatus() throws DeviceException; def getStatus(self): if self.chCNT.isConfigured(): self.stauts = self.chCNT.caget() else: self.chCNT.configure() self.stauts = self.chCNT.caget() self.chCNT.clearup() if self.stauts == '0': #still counting, Busy return 0 else: return 1
class FastEnergyScanClass:
def __init__(self):
self.startEnergy = CAClient(pvStartEnergy)
self.endEnergy = CAClient(pvEndEnergy)
self.scanTime = CAClient(pvScanTime)
self.numberOfPoints = CAClient(pvNumberOfPoints)
self.startButton = CAClient(pvStartButton)
self.status = CAClient(pvReadyState)
self.buildButton = CAClient(pvBuildButton)
self.elementCounter = CAClient(pvElementCounter)
self.channel01 = CAClient(pvDataChannel01)
self.channel02 = CAClient(pvDataChannel02)
self.channel03 = CAClient(pvDataChannel03)
self.channel04 = CAClient(pvDataChannel04)
self.energyPGM = CAClient(pvEnergyPGM)
self.energyIDGAP = CAClient(pvEnergyIDGAP)
self.scanReady01 = CAClient(pvScanReady01)
self.scanReady02 = CAClient(pvScanReady02)
self.scanReady03 = CAClient(pvScanReady03)
self.scanReady04 = CAClient(pvScanReady04)
self.scanStatus = 'Idle'
self.arrayHead = 0
self.se = 400
self.ee = 700
def atScanStart(self):
self.scanStatus = 'Idle'
self.arrayHead = 0
if not self.startEnergy.isConfigured():
self.startEnergy.configure()
if not self.endEnergy.isConfigured():
self.endEnergy.configure()
if not self.scanTime.isConfigured():
self.scanTime.configure()
if not self.numberOfPoints.isConfigured():
self.numberOfPoints.configure()
if not self.startButton.isConfigured():
self.startButton.configure()
if not self.buildButton.isConfigured():
self.buildButton.configure()
if not self.status.isConfigured():
self.status.configure()
if not self.elementCounter.isConfigured():
self.elementCounter.configure()
if not self.channel01.isConfigured():
self.channel01.configure()
if not self.channel02.isConfigured():
self.channel02.configure()
if not self.channel03.isConfigured():
self.channel03.configure()
if not self.channel04.isConfigured():
self.channel04.configure()
if not self.energyPGM.isConfigured():
self.energyPGM.configure()
if not self.energyIDGAP.isConfigured():
self.energyIDGAP.configure()
if not self.scanReady01.isConfigured():
self.scanReady01.configure()
if not self.scanReady02.isConfigured():
self.scanReady02.configure()
if not self.scanReady03.isConfigured():
self.scanReady03.configure()
if not self.scanReady04.isConfigured():
self.scanReady04.configure()
def atScanEnd(self):
self.scanStatus = 'Idle'
self.arrayHead = 0
if self.startEnergy.isConfigured():
self.startEnergy.clearup()
if self.endEnergy.isConfigured():
self.endEnergy.clearup()
if self.scanTime.isConfigured():
self.scanTime.clearup()
if self.numberOfPoints.isConfigured():
self.numberOfPoints.clearup()
if self.startButton.isConfigured():
self.startButton.clearup()
if self.buildButton.isConfigured():
self.buildButton.clearup()
if self.status.isConfigured():
self.status.clearup()
if self.elementCounter.isConfigured():
self.elementCounter.clearup()
if self.channel01.isConfigured():
self.channel01.clearup()
if self.channel02.isConfigured():
self.channel02.clearup()
if self.channel03.isConfigured():
self.channel03.clearup()
if self.channel04.isConfigured():
self.channel04.clearup()
if self.energyPGM.isConfigured():
self.energyPGM.clearup()
if self.energyIDGAP.isConfigured():
self.energyIDGAP.clearup()
if self.scanReady01.isConfigured():
self.scanReady01.clearup()
if self.scanReady02.isConfigured():
self.scanReady02.clearup()
if self.scanReady03.isConfigured():
self.scanReady03.clearup()
if self.scanReady04.isConfigured():
self.scanReady04.clearup()
#To check the PGM and ID motors are ready for the fast scan
def checkMotorReady(self):
c1 = int(float(self.scanReady01.caget()))
c2 = int(float(self.scanReady02.caget()))
c3 = int(float(self.scanReady03.caget()))
c4 = int(float(self.scanReady04.caget()))
return (c1 == 0 and c2 == 0 and c3 == 0 and c4 == 0)
def setEnergyRange(self, startEnergy, endEnergy):
self.se = startEnergy
self.ee = endEnergy
self.startEnergy.caput(startEnergy - 3)
self.endEnergy.caput(endEnergy + 3)
def setTime(self, scanTime, pointTime):
numberOfPoints = scanTime / pointTime
self.scanTime.caput(scanTime)
self.numberOfPoints.caput(numberOfPoints)
#trigger the fast scan
def start(self):
self.startButton.caput(1)
#trigger the fast scan
def build(self):
self.buildButton.caput('Busy') # click the build button
def isBuilt(self):
strStatus = self.getStatus()
if strStatus == 'Scan ready': #Finished building
return True
else:
return False
#Total 6 status from Epics, plus internal Idle status
## "Scan complete"
## "Scan aborted"
# "Moving PGM to midpoint"
# "Calculating parameters"
## "Moving IDD and PGM to start position"
## "Scan ready"
## "Starting scan move"
# "Scanning"
## "Scan complete"
# "Idle"
def getStatus(self):
newScanStatus = self.status.caget()
if newScanStatus != self.scanStatus: # scan status changed
self.scanStatus = newScanStatus
print self.scanStatus
return self.scanStatus
def isBusy(self):
strStatus = self.getStatus()
if strStatus == 'Scan complete':
print 'fast energy scan finished.'
return False
else:
return True
def isScanning(self):
strStatus = self.getStatus()
if strStatus == 'Scanning' or strStatus == 'Starting scan move':
return True
else:
return False
#To get the number of valid data from the waveform
def getDataNumbers(self):
strLength = self.elementCounter.caget()
return int(float(strLength))
def saveData(self):
numberOfPoints = self.getDataNumbers()
#self.printData(numberOfPoints);
self.saveSRSData(numberOfPoints)
def saveSRSData(self, numberOfPoints):
srsHeader = [
" &SRS\n", " SRSRUN=null,SRSDAT=null,SRSTIM=null,\n",
" SRSSTN='null',SRSPRJ='null ',SRSEXP='null ',\n",
" SRSTLE=' ',\n",
" SRSCN1=' ',SRSCN2=' ',SRSCN3=' ',\n",
" &END\n"
]
try:
runs = NumTracker("tmp")
nextNum = runs.getCurrentFileNumber()
#nextNum = runs.incrementNumber()
path = InterfaceProvider.getPathConstructor().createFromProperty(
"gda.data.scan.datawriter.datadir")
fileName = path + "/" + str(nextNum + 1) + ".dat"
print fileName
fh = open(fileName, 'w')
#SRS Header
for i in range(len(srsHeader)):
fh.write(srsHeader[i])
titleLine = '%(v1)s \t %(v2)s \t %(v3)s \t %(v4)s \t %(v5)s \t %(v6)s \n' % {
'v1': 'PGM Energy',
'v2': 'ID GAP Energy',
'v3': 'Channel 1',
'v4': 'Channel 2',
'v5': 'Channel 3',
'v6': 'Channel 4'
}
fh.write(titleLine)
arrayEnergyPGM = self.energyPGM.cagetArrayDouble()
arrayEnergyIDGAP = self.energyIDGAP.cagetArrayDouble()
arrayChannel01 = self.channel01.cagetArrayDouble()
arrayChannel02 = self.channel02.cagetArrayDouble()
arrayChannel03 = self.channel03.cagetArrayDouble()
arrayChannel04 = self.channel04.cagetArrayDouble()
for i in range(numberOfPoints):
if arrayEnergyPGM[i] < self.se:
continue
if arrayEnergyPGM[i] > self.ee:
continue
#print i, arrayEnergyPGM[i], arrayEnergyIDGAP[i], arrayChannel01[i], arrayChannel02[i], arrayChannel03[i], arrayChannel04[i];
newLine = '%(v1).8f \t %(v2).8f \t %(v3).8f \t %(v4).8f \t %(v5).8f \t %(v6).8f \n' % {
'v1': arrayEnergyPGM[i],
'v2': arrayEnergyIDGAP[i],
'v3': arrayChannel01[i],
'v4': arrayChannel02[i],
'v5': arrayChannel03[i],
'v6': arrayChannel04[i]
}
fh.write(newLine)
fh.close()
runs.incrementNumber()
except:
print "ERROR: Could not save data into file."
def printData(self, numberOfPoints):
arrayEnergyPGM = self.energyPGM.cagetArrayDouble()
arrayEnergyIDGAP = self.energyIDGAP.cagetArrayDouble()
arrayChannel01 = self.channel01.cagetArrayDouble()
arrayChannel02 = self.channel02.cagetArrayDouble()
arrayChannel03 = self.channel03.cagetArrayDouble()
arrayChannel04 = self.channel04.cagetArrayDouble()
for i in range(numberOfPoints):
print i, arrayEnergyPGM[i], arrayEnergyIDGAP[i], arrayChannel01[
i], arrayChannel02[i], arrayChannel03[i], arrayChannel04[i]
def plotWholeData(self, numberOfPoints):
arrayEnergyPGM = self.energyPGM.cagetArrayDouble()
arrayEnergyIDGAP = self.energyIDGAP.cagetArrayDouble()
arrayChannel01 = self.channel01.cagetArrayDouble()
arrayChannel02 = self.channel02.cagetArrayDouble()
arrayChannel03 = self.channel03.cagetArrayDouble()
arrayChannel04 = self.channel04.cagetArrayDouble()
dataSetPGM = dnp.array([numberOfPoints])
for i in range(numberOfPoints):
dataSetPGM.set(arrayEnergyPGM[i], i)
# Removed as won't work with RCP client. Talk to Mark Basham if need be.
# dvp=Plotter();
# dvp.plotOver("Fast Scan Panel", dataSetPGM.getIndexDataSet(), dataSetPGM);
def plotData(self):
newHead = self.getDataNumbers()
if self.arrayHead >= newHead:
print "No new data added for plotting"
return
self.arrayHead = newHead
#to get new data
arrayEnergyPGM = self.energyPGM.cagetArrayDouble()
arrayEnergyIDGAP = self.energyIDGAP.cagetArrayDouble()
arrayChannel01 = self.channel01.cagetArrayDouble()
arrayChannel02 = self.channel02.cagetArrayDouble()
arrayChannel03 = self.channel03.cagetArrayDouble()
arrayChannel04 = self.channel04.cagetArrayDouble()
dataSetEnergyPGM = dnp.zeros([newHead])
dataSetEnergyPGM.setName("PGM Energy")
dataSetEnergyIDGAP = dnp.zeros([newHead])
dataSetEnergyIDGAP.setName("ID Gap Energy")
dataSetChannel01 = dnp.zeros([newHead])
dataSetChannel01.setName("Channel 1")
dataSetChannel02 = dnp.zeros([newHead])
dataSetChannel02.setName("Channel 2")
dataSetChannel03 = dnp.zeros([newHead])
dataSetChannel03.setName("Channel 3")
dataSetChannel04 = dnp.zeros([newHead])
dataSetChannel04.setName("Channel 4")
for i in range(0, newHead):
#print i, arrayEnergyPGM[i], arrayEnergyIDGAP[i], arrayChannel01[i], arrayChannel02[i], arrayChannel03[i], arrayChannel04[i];
dataSetEnergyPGM[i] = arrayEnergyPGM[i]
dataSetEnergyIDGAP[i] = arrayEnergyIDGAP[i]
dataSetChannel01[i] = arrayChannel01[i]
dataSetChannel02[i] = arrayChannel02[i]
dataSetChannel03[i] = arrayChannel03[i]
dataSetChannel04[i] = arrayChannel04[i]
#print i, arrayEnergyPGM[i], arrayEnergyIDGAP[i], arrayChannel01[i], arrayChannel02[i], arrayChannel03[i], arrayChannel04[i];
dvp = Plotter()
indexDataSet = dataSetEnergyPGM.getIndexDataSet()
#dvp.plot("Data Vector", indexDataSet, [dataSetChannel01, dataSetChannel02, dataSetChannel03, dataSetChannel04]);
dvp.plot("Fast Scan Panel", dataSetEnergyPGM, [
dataSetChannel01, dataSetChannel02, dataSetChannel03,
dataSetChannel04
])
class EpicsPVWithMonitorListener(PseudoDevice, MonitorListener, Runnable): '''create a scannable that monitors the EPICS PV value changes and update its value passively. This value is used by a running thread to control the scan processing this object participates in. ''' def __init__(self, name, pvstring, unitstring, formatstring): self.setName(name) self.setInputNames([name]) self.Units=[unitstring] self.setOutputFormat([formatstring]) self.setLevel(5) self.outcli=CAClient(pvstring) self.currenttemp=float(self.rawGetPosition()) self.monitor=None self.thread=None self.runThread=False def atScanStart(self): '''prepare to start scan: creating channel, monitor, and start control thread''' if not self.outcli.isConfigured(): self.outcli.configure() self.monitor=self.outcli.camonitor(self) self.thread=Thread(self,"Thread: "+self.getName()) self.runThread=True self.thread.start() def atScanEnd(self): '''clean up after scan finished successfully: remove monitor, destroy channel, and stop control thread''' if self.outcli.isConfigured(): self.outcli.removeMonitor(self.monitor) self.monitor=None self.outcli.clearup() self.runThread=False self.thread=None def rawGetPosition(self): ''' return current position.''' output=0.0 if not self.outcli.isConfigured(): self.outcli.configure() output=float(self.outcli.caget()) self.outcli.clearup() else: output=float(self.outcli.caget()) return float(output) def rawAsynchronousMoveTo(self,position): '''Not implemented, this is only a monitoring object''' print "object " + self.getName()+" cannot be moved." return def rawIsBusy(self): '''monitoring object never busy''' return 0 def monitorChanged(self, mevent): self.currenttemp = float(mevent.getDBR().getDoubleValue()[0]) def run(self): # print "Thread: " + self.getName() + " started" while (self.runThread): if (JythonServerFacade.getInstance().getScanStatus() == JythonStatus.RUNNING and self.currenttemp >= float(MAXTEMP)): JythonServerFacade.getInstance().pauseCurrentScan() print "Scan paused as temperature " + self.getName() +" returns: "+str(self.currenttemp) elif (JythonServerFacade.getInstance().getScanStatus() == JythonStatus.PAUSED and self.currenttemp <= float(MINTEMP)): print "Scan resumed as temperature " + self.getName() +" returns: "+str(self.currenttemp) JythonServerFacade.getInstance().resumeCurrentScan() sleep(10) def stop(self): '''clean up after scan finished successfully: remove monitor, destroy channel, and stop control thread on emergence stop or unexpected crash. If required, can be used to manually clean up the object.''' if not self.monitor == None: self.outcli.removeMonitor(self.monitor) self.monitor=None if self.outcli.isConfigured(): self.outcli.clearup() if not self.thread == None: self.runThread=False self.thread=None
class AlicatPressureController(ScannableMotionBase):
'''
classdocs
'''
def __init__(self,name, rootPV, formatstring):
'''
Constructor
'''
self.setName(name);
self.setInputNames([name])
self.setOutputFormat([formatstring])
self.setLevel(3)
self.readmodecli=CAClient(rootPV+READ_MODE)
self.setmodecli=CAClient(rootPV+SET_MODE)
self.readpressurecli=CAClient(rootPV+READ_PRESSURE)
self.settargetcli=CAClient(rootPV+SET_TARGET)
self.readtargetcli=CAClient(rootPV+READ_TARGET)
self.setproportionalgaincli=CAClient(rootPV+SET_PROPORTIONAL_GAIN)
self.readproportionalgaincli=CAClient(rootPV+READ_PROPORTIONAL_GAIN)
self.setderivativegaincli=CAClient(rootPV+SET_DERIVATIVE_GAIN)
self.readderivativegaincli=CAClient(rootPV+READ_DERIVATIVE_GAIN)
def getMode(self):
try:
if not self.readmodecli.isConfigured():
self.readmodecli.configure()
output=int(self.readmodecli.caget())
self.readmodecli.clearup()
else:
output=int(self.readmodecli.caget())
return modes[output]
except:
print "Error returning current mode"
return 0
def setMode(self, mode):
try:
if not self.setmodecli.isConfigured():
self.setmodecli.configure()
self.setmodecli.caput(mode)
self.setmodecli.clearup()
else:
self.setmodecli.caput(mode)
except:
print "error set to mode"
def setTarget(self, target):
try:
if not self.settargetcli.isConfigured():
self.settargetcli.configure()
self.settargetcli.caput(target)
self.settargetcli.clearup()
else:
self.settargetcli.caput(target)
except:
print "error set to target flow value"
def getTarget(self):
try:
if not self.readtargetcli.isConfigured():
self.readtargetcli.configure()
output=float(self.readtargetcli.caget())
self.readtargetcli.clearup()
else:
output=float(self.readtargetcli.caget())
return output
except:
print "Error returning flow target value"
return 0
def getPressure(self):
try:
if not self.readpressurecli.isConfigured():
self.readpressurecli.configure()
output=float(self.readpressurecli.caget())
self.readpressurecli.clearup()
else:
output=float(self.readpressurecli.caget())
return output
except:
print "Error returning pressure"
return 0
def getProportionalGain(self):
try:
if not self.readproportionalgaincli.isConfigured():
self.readproportionalgaincli.configure()
output=float(self.readproportionalgaincli.caget())
self.readproportionalgaincli.clearup()
else:
output=float(self.readproportionalgaincli.caget())
return output
except:
print "Error returning Proportional Gain"
return 0
def setProportionalGain(self, gain):
try:
if not self.setproportionalgaincli.isConfigured():
self.setproportionalgaincli.configure()
self.setproportionalgaincli.caput(gain)
self.setproportionalgaincli.clearup()
else:
self.setproportionalgaincli.caput(gain)
except:
print "error set to proportional gain"
def getDerivativeGain(self):
try:
if not self.readderivativegaincli.isConfigured():
self.readderivativegaincli.configure()
output=float(self.readderivativegaincli.caget())
self.readderivativegaincli.clearup()
else:
output=float(self.readderivativegaincli.caget())
return output
except:
print "Error returning Derivative Gain"
return 0
def setDerivativeGain(self, gain):
try:
if not self.setderivativegaincli.isConfigured():
self.setderivativegaincli.configure()
self.setderivativegaincli.caput(gain)
self.setderivativegaincli.clearup()
else:
self.setderivativegaincli.caput(gain)
except:
print "error set to derivative gain"
#### methods for scannable
def atScanStart(self):
pass
def atPointStart(self):
pass
def getPosition(self):
pass
def asynchronousMoveTo(self, posi):
pass
def isBusy(self):
return False
def stop(self):
pass
def atPointEnd(self):
pass
def atScanEnd(self):
pass
class AlicatPressureController(ScannableMotionBase):
'''
construct a scannable for pressure control. It also provides access to other properties.
'''
def __init__(self,name, rootPV, tolerance=0.01, formatstring="%.3f"):
'''
Constructor
'''
self.setName(name)
self.setInputNames([name])
self.setOutputFormat([formatstring])
self.setLevel(3)
self.readmodecli=CAClient(rootPV+READ_MODE)
self.setmodecli=CAClient(rootPV+SET_MODE)
self.readpressurecli=CAClient(rootPV+READ_PRESSURE)
self.settargetcli=CAClient(rootPV+SET_TARGET)
self.readtargetcli=CAClient(rootPV+READ_TARGET)
self.setproportionalgaincli=CAClient(rootPV+SET_PROPORTIONAL_GAIN)
self.readproportionalgaincli=CAClient(rootPV+READ_PROPORTIONAL_GAIN)
self.setderivativegaincli=CAClient(rootPV+SET_DERIVATIVE_GAIN)
self.readderivativegaincli=CAClient(rootPV+READ_DERIVATIVE_GAIN)
self.mytolerance=tolerance
self.isConfigured=False
def configure(self):
if not self.isConfigured:
if not self.readmodecli.isConfigured():
self.readmodecli.configure()
if not self.setmodecli.isConfigured():
self.setmodecli.configure()
if not self.settargetcli.isConfigured():
self.settargetcli.configure()
if not self.readtargetcli.isConfigured():
self.readtargetcli.configure()
if not self.readpressurecli.isConfigured():
self.readpressurecli.configure()
self.isConfigured=True
def deconfigure(self):
if self.isConfigured:
if self.readmodecli.isConfigured():
self.readmodecli.clearup()
if self.setmodecli.isConfigured():
self.setmodecli.clearup()
if self.settargetcli.isConfigured():
self.settargetcli.clearup()
if self.readtargetcli.isConfigured():
self.readtargetcli.clearup()
if self.readpressurecli.isConfigured():
self.readpressurecli.clearup()
self.isConfigured=False
def getMode(self):
try:
if not self.readmodecli.isConfigured():
self.readmodecli.configure()
output=int(self.readmodecli.caget())
self.readmodecli.clearup()
else:
output=int(self.readmodecli.caget())
return modes[output]
except:
print "Error returning current mode"
return 0
def setMode(self, mode):
try:
if not self.setmodecli.isConfigured():
self.setmodecli.configure()
self.setmodecli.caput(mode)
self.setmodecli.clearup()
else:
self.setmodecli.caput(mode)
except:
print "error set to mode"
def setTarget(self, target):
try:
if not self.settargetcli.isConfigured():
self.settargetcli.configure()
self.settargetcli.caput(target)
self.settargetcli.clearup()
else:
self.settargetcli.caput(target)
except:
print "error set to target flow value"
def getTarget(self):
try:
if not self.settargetcli.isConfigured():
self.settargetcli.configure()
output=float(self.settargetcli.caget())
self.settargetcli.clearup()
else:
output=float(self.settargetcli.caget())
return output
except:
print "Error returning target value"
return 0
def getPressure(self):
try:
if not self.readpressurecli.isConfigured():
self.readpressurecli.configure()
output=float(self.readpressurecli.caget())
self.readpressurecli.clearup()
else:
output=float(self.readpressurecli.caget())
return output
except:
print "Error returning pressure"
return 0
def getProportionalGain(self):
try:
if not self.readproportionalgaincli.isConfigured():
self.readproportionalgaincli.configure()
output=float(self.readproportionalgaincli.caget())
self.readproportionalgaincli.clearup()
else:
output=float(self.readproportionalgaincli.caget())
return output
except:
print "Error returning Proportional Gain"
return 0
def setProportionalGain(self, gain):
try:
if not self.setproportionalgaincli.isConfigured():
self.setproportionalgaincli.configure()
self.setproportionalgaincli.caput(gain)
self.setproportionalgaincli.clearup()
else:
self.setproportionalgaincli.caput(gain)
except:
print "error set to proportional gain"
def getDerivativeGain(self):
try:
if not self.readderivativegaincli.isConfigured():
self.readderivativegaincli.configure()
output=float(self.readderivativegaincli.caget())
self.readderivativegaincli.clearup()
else:
output=float(self.readderivativegaincli.caget())
return output
except:
print "Error returning Derivative Gain"
return 0
def setDerivativeGain(self, gain):
try:
if not self.setderivativegaincli.isConfigured():
self.setderivativegaincli.configure()
self.setderivativegaincli.caput(gain)
self.setderivativegaincli.clearup()
else:
self.setderivativegaincli.caput(gain)
except:
print "error set to derivative gain"
def getTolerance(self):
return self.mytolerance
def setTolerance(self, value):
self.mytolerance=value
#### methods for scannable
def getPosition(self):
return self.getPressure()
def asynchronousMoveTo(self, posi):
self.setTarget(float(posi))
def moveTo(self, posi, sleepdelta=0.5):
self.asynchronousMoveTo(posi)
while self.isBusy():
sleep(sleepdelta)
def isBusy(self):
return (abs(float(self.getPosition())-float(self.getTarget()))>float(self.getTolerance()))
def atScanStart(self):
pass
def atPointStart(self):
pass
def stop(self):
pass
def atPointEnd(self):
pass
def atScanEnd(self):
pass
class GasRigClass(ScannableMotionBase):
'''Create a scannable for a gas injection rig'''
def __init__(self, name, rootPV):
self.setName(name);
self.setInputNames([name])
self.setLevel(5)
self.setsequencecli=CAClient(rootPV+SEQUENCE_CONTROL)
self.statecli=CAClient(rootPV+SEQUENCE_STATUS)
self.systemincli=CAClient(SystemTargetPressure)
self.sampleincli=CAClient(SampleTargetPressure)
def vacSample(self, samplePressure=dvpc):
print "Vacuum the sample ..."
samplePressure.setMode(0)
self.on()
increment=0.005
target=float(samplePressure.getPosition())-increment
try:
if not self.sampleincli.isConfigured():
self.sampleincli.configure()
while float(samplePressure.getPosition()) > target: # final sample pressure in bar
# interruptable()
self.sampleincli.caput(target)
target = target-increment # increments in bar
sleep(5.0) # wait time in seconds
if target<=0.0:
break
if self.sampleincli.isConfigured():
self.sampleincli.clearup()
except:
print "error moving to position"
samplePressure.moveTo(0.0)
print "sample is under vacuum now."
def vacSystem(self, systemPressure=bpr):
print "Vacuum the system ..."
systemPressure.setMode(0)
self.on()
increment=0.005
target=float(systemPressure.getPosition())-increment
try:
if not self.systemincli.isConfigured():
self.systemincli.configure()
while target > 0:
# interruptable()
self.systemincli.caput(target)
target = target-increment # increments in bar
sleep(5.0) # wait time in seconds
if self.systemincli.isConfigured():
self.systemincli.clearup()
except:
print "error moving to position"
systemPressure.moveTo(0.0)
print "system is under vacuum now."
def gasin(self, mfc=mfc1, flow=0.1, pressuretarget=1.0, systemPressure=bpr):
'''select gas flow control and set system pressure'''
print "inject gas %s into the system." % (mfc.getGasType())
mfc.asynchronousMoveTo(flow)
sleep(1)
systemPressure.moveTo(pressuretarget)
sleep(1)
mfc.asynchronousMoveTo(0)
print "The system reaches at target pressure %f" % (pressuretarget)
def complete(self,valve=ventvalve,systemPressure=bpr, samplePressure=sampleP):
print "complete this sample, vent the system"
self.off()
valve.on()
systemPressure.asynchronousMoveTo(0)
samplePressure.asynchronousMoveTo(0)
mfc1.asynchronousMoveTo(0)
mfc2.asynchronousMoveTo(0)
mfc3.asynchronousMoveTo(0)
def flushSystem(self,repeat, mfc=mfc1, flow=0.5, duration=60.0, isolation=isolationvalve, vent=ventvalve, systemPressure=bpr):
print "flushing the system for "+str(duration)+" seconds for "+ str(repeat)+ " times ..."
isolation.off()
vent.on()
for i in range(repeat):
mfc.asynchronousMoveTo(flow)
sleep(1)
systemPressure.moveTo(4)
sleep(1)
mfc.asynchronousMoveTo(0)
sleep(duration)
systemPressure.asynchronousMoveTo(0)
sleep(10.0)
print "flush system completed."
def getState(self):
try:
if not self.statecli.isConfigured():
self.statecli.configure()
output=int(self.statecli.caget())
self.statecli.clearup()
else:
output=int(self.statecli.caget())
return sequencestat[output]
except:
print "Error returning current state"
return 0
def setSequence(self,new_position):
try:
if not self.setsequencecli.isConfigured():
self.setsequencecli.configure()
self.setsequencecli.caput(new_position)
self.setsequencecli.clearup()
else:
self.setsequencecli.caput(new_position)
except:
print "error setting sequence"
def on(self):
self.setSequence(0)
def off(self):
self.setSequence(1)
def reset(self):
self.setSequence(2)
#### methods for scannable
def getPosition(self):
return self.getState()
def asynchronousMoveTo(self, new_position):
self.setSequence(float(new_position))
def isBusy(self):
return False
def atScanStart(self):
pass
def atPointStart(self):
pass
def stop(self):
pass
def atPointEnd(self):
pass
def atScanEnd(self):
pass
#gasrig=GasRigClass("gasrig", "BL11I-EA-GIR-01:")
def xgasin(self, mfc=mfc1, flow=0.1, pressuretarget=1.0, systemPressure=bpr, sleepdelta=1, sleepmove=0.5):
'''select gas flow control and set system pressure'''
print "xgasin: inject gas %s into the system." % (mfc.getGasType())
mfc.asynchronousMoveTo(flow)
#systemPressure.moveTo(pressuretarget)
sleep(sleepdelta)
systemPressure.moveTo(pressuretarget, sleepmove)
#mfc.asynchronousMoveTo(flow)
sleep(sleepdelta)
mfc.asynchronousMoveTo(0)
print "The system reaches at target pressure %f" % (pressuretarget)
del nt
#=====================Using EPICS caget() and caput to access PVs =========================================
from gda.epics import CAClient
#Create the Client
epicsClient = CAClient()
#Create the PV channels and use the caput and caget method directly
print epicsClient.caget("BL06I-AL-SLITS-01:X:CENTER.RBV")
epicsClient.caput("BL06I-AL-SLITS-01:X:CENTER", -0.55)
#Clear up the channels
epicsClient.clearup();
#==============================================================
#==============================================================
#==============================================================
#==============================================================
#==============================================================
#==============================================================
#==============================================================
class EPICSODQBPMClass(ScannableBase): '''PD for OD QBPM device Inputs: None Outputs: Range, C1, C2, C3, C4, X, Y self.set_range(value) - set gain 0 = highest calibration sequence: self.dark_current() save dark current at current gain (beam off) self.set_zero() calibrate zero x,y (beam on) self.setxy(xval, yval) calibrate gains to give position in mm (go to xval, yval; beam on) - NOT TESTED Additional methods: config() loads qbpm parameters''' # a=A1*(current4-A2) etc # X=GX*(a-b)/(a+b) etc # a,b,c,d=chan 4,2,1,3 def __init__(self, name, pvrootstring,help=None): self.setName(name); if help is not None: self.__doc__+='\nHelp specific to '+self.name+':\n'+help #[self.A1,self.A2,self.B1,self.B2,self.C1,self.C2,self.D1,self.D2,self.GX, self.GY]=xyparamvec self.pvrootstring=pvrootstring self.setInputNames([]) self.setExtraNames(['Range','C1','C2','C3','C4','X','Y']); #self.setReportingUnits([' ','uA','uA','uA','uA','mm','mm']) self.setOutputFormat(['%.0f','%.9f','%.9f','%.9f','%.9f','%.3f','%.3f']) self.setLevel(9) self.rangecli=CAClient(pvrootstring+':RANGE_MENU');self.rangecli.configure() self.c1cli=CAClient(pvrootstring+':PHD1:I');self.c1cli.configure() self.c2cli=CAClient(pvrootstring+':PHD2:I');self.c2cli.configure() self.c3cli=CAClient(pvrootstring+':PHD3:I');self.c3cli.configure() self.c4cli=CAClient(pvrootstring+':PHD4:I');self.c4cli.configure() self.xcli=CAClient(pvrootstring+':XPOS');self.xcli.configure() self.ycli=CAClient(pvrootstring+':YPOS');self.ycli.configure() self.IR1cli=CAClient(pvrootstring+':PHD1:I_R');self.IR1cli.configure() self.IR2cli=CAClient(pvrootstring+':PHD2:I_R');self.IR2cli.configure() self.IR3cli=CAClient(pvrootstring+':PHD3:I_R');self.IR3cli.configure() self.IR4cli=CAClient(pvrootstring+':PHD4:I_R');self.IR4cli.configure() def getPosition(self): self.rangestring=self.rangecli.caget() self.c1string=self.c1cli.caget() self.c2string=self.c2cli.caget() self.c3string=self.c3cli.caget() self.c4string=self.c4cli.caget() self.xstring=self.xcli.caget() self.ystring=self.ycli.caget() return [float(self.rangestring),float(self.c1string), float(self.c2string),float(self.c3string),float(self.c4string),float(self.xstring),float(self.ystring)] # def asynchronousMoveTo(self,new_position): # self.rangecli.caput(new_position) def isBusy(self): return 0 def set_params(self,params): [A1,A2,B1,B2,C1,C2,D1,D2,GX,GY]=params self.configcli=CAClient(self.pvrootstring+':A1_SP');self.configcli.configure(); self.configcli.caput(A1); self.configcli.clearup(); self.configcli=CAClient(self.pvrootstring+':A2_SP');self.configcli.configure(); self.configcli.caput(A2); self.configcli.clearup(); self.configcli=CAClient(self.pvrootstring+':B1_SP');self.configcli.configure(); self.configcli.caput(B1); self.configcli.clearup(); self.configcli=CAClient(self.pvrootstring+':B2_SP');self.configcli.configure(); self.configcli.caput(B2); self.configcli.clearup(); self.configcli=CAClient(self.pvrootstring+':C1_SP');self.configcli.configure(); self.configcli.caput(C1); self.configcli.clearup(); self.configcli=CAClient(self.pvrootstring+':C2_SP');self.configcli.configure(); self.configcli.caput(C2); self.configcli.clearup(); self.configcli=CAClient(self.pvrootstring+':D1_SP');self.configcli.configure(); self.configcli.caput(D1); self.configcli.clearup(); self.configcli=CAClient(self.pvrootstring+':D2_SP');self.configcli.configure(); self.configcli.caput(D2); self.configcli.clearup(); self.configcli=CAClient(self.pvrootstring+':GX_SP');self.configcli.configure(); self.configcli.caput(GX); self.configcli.clearup(); self.configcli=CAClient(self.pvrootstring+':GY_SP');self.configcli.configure(); self.configcli.caput(GY); self.configcli.clearup(); def get_params(self): self.configcli=CAClient(self.pvrootstring+':A1_SP');self.configcli.configure(); A1=float(self.configcli.caget());self.configcli.clearup() self.configcli=CAClient(self.pvrootstring+':A2_SP');self.configcli.configure(); A2=float(self.configcli.caget()); self.configcli.clearup() self.configcli=CAClient(self.pvrootstring+':B1_SP');self.configcli.configure(); B1=float(self.configcli.caget()); self.configcli.clearup() self.configcli=CAClient(self.pvrootstring+':B2_SP');self.configcli.configure(); B2=float(self.configcli.caget()); self.configcli.clearup() self.configcli=CAClient(self.pvrootstring+':C1_SP');self.configcli.configure(); C1=float(self.configcli.caget()); self.configcli.clearup() self.configcli=CAClient(self.pvrootstring+':C2_SP');self.configcli.configure(); C2=float(self.configcli.caget()); self.configcli.clearup() self.configcli=CAClient(self.pvrootstring+':D1_SP');self.configcli.configure(); D1=float(self.configcli.caget()); self.configcli.clearup() self.configcli=CAClient(self.pvrootstring+':D2_SP');self.configcli.configure(); D2=float(self.configcli.caget()); self.configcli.clearup() self.configcli=CAClient(self.pvrootstring+':GX_SP');self.configcli.configure(); GX=float(self.configcli.caget()); self.configcli.clearup() self.configcli=CAClient(self.pvrootstring+':GY_SP');self.configcli.configure(); GY=float(self.configcli.caget()); self.configcli.clearup() return [A1,A2,B1,B2,C1,C2,D1,D2,GX,GY] def get_rawcounts(self): self.IR1=float(self.IR1cli.caget()) self.IR2=float(self.IR2cli.caget()) self.IR3=float(self.IR3cli.caget()) self.IR4=float(self.IR4cli.caget()) return [self.IR1, self.IR2, self.IR3, self.IR4] def set_range(self, newrange): self.rangecli.caput(newrange) def factory_reset(self): params=[A1,A2,B1,B2,C1,C2,D1,D2,GX,GY]=[1,0,1,0,1,0,1,0,1,1] self.set_params(params) def dark_current(self): #offsets not persistent - do dark current with beam off [A1,A2,B1,B2,C1,C2,D1,D2,GX,GY]=self.get_params() self.configcli=CAClient(self.pvrootstring+':PHD4:I_R');self.configcli.configure(); A2=float(self.configcli.caget()); self.configcli.clearup() self.configcli=CAClient(self.pvrootstring+':PHD2:I_R');self.configcli.configure(); B2=float(self.configcli.caget()); self.configcli.clearup() self.configcli=CAClient(self.pvrootstring+':PHD1:I_R');self.configcli.configure(); C2=float(self.configcli.caget()); self.configcli.clearup() self.configcli=CAClient(self.pvrootstring+':PHD3:I_R');self.configcli.configure(); D2=float(self.configcli.caget()); self.configcli.clearup() self.set_params([A1,A2,B1,B2,C1,C2,D1,D2,GX,GY]) print 'new dark currents (i4,i2,i1,i3):', [A2, B2, C2, D2] def set_zero(self): #do with beam on [ic,ib,id,ia]=self.get_rawcounts() [A1,A2,B1,B2,C1,C2,D1,D2,GX,GY]=self.get_params() A1B1=A1*B1; C1D1=C1*D1; #get products A1_B1=(ib-B2)/(ia-A2); #calculate ratio X=0 C1_D1=(id-D2)/(ic-C2); #calculate ratio Y=0 #re-calc A1, B1 etc for zero X,Y but keep ratio at current value [A1, B1, C1, D1]=[sqrt(A1B1*A1_B1), sqrt(A1B1/A1_B1), sqrt(C1D1*C1_D1), sqrt(C1D1/C1_D1)] self.set_params([A1,A2,B1,B2,C1,C2,D1,D2,GX,GY]) def set_xy(self,x,y): #do with beam on [ic,ib,id,ia]=self.get_rawcounts() [A1,A2,B1,B2,C1,C2,D1,D2,GX,GY]=self.get_params() [a,b,c,d]=[A1*(ia-A2), B1*(ib-B2),C1*(ic-C2), D1*(id-D2)] [GX, GY]=[x*(a+b)/(a-b),y*(c+d)/(c-d)] #print [A1,A2,B1,B2,C1,C2,D1,D2,GX,GY] self.set_params([A1,A2,B1,B2,C1,C2,D1,D2,GX,GY])
class EpicsReadWriteEnum(ScannableMotionBase):
'''
class that creates an instance for a EPICS PV of Enum type.
'''
def __init__(self,
name,
inpvstring,
rbvpvstring,
formatstring,
positions={}):
'''
Constructor
'''
self.setName(name)
self.setInputNames([name])
self.setExtraNames([])
self.setOutputFormat([formatstring])
self.setLevel(5)
self.incli = CAClient(inpvstring)
self.rbvcli = CAClient(rbvpvstring)
self.positions = positions
def atScanStart(self):
if not self.incli.isConfigured():
self.incli.configure()
if not self.rbvcli.isConfigured():
self.rbvcli.configure()
def atPointStart(self):
pass
def rawGetPosition(self):
try:
if not self.rbvcli.isConfigured():
self.rbvcli.configure()
sleep(0.5) # there is no caput callback yet in EPIC
output = int(self.rbvcli.caget())
return self.positions[output]
except:
raise Exception("%s: Error get current position" % self.getName())
def rawAsynchronousMoveTo(self, new_position):
lKey = None
try:
if not self.incli.isConfigured():
self.incli.configure()
if isinstance(new_position, str):
lKey = [
key for key, value in self.positions.iteritems()
if value == new_position
][0]
elif isinstance(new_position, int):
lKey = int(new_position)
else:
raise Exception("Input must be String or Integer.")
if lKey is None or (lKey < 0 or lKey >= len(self.positions)):
raise Exception("Request position is not supported.")
self.incli.caput(lKey)
except:
raise Exception("%s: Error set position to '%s'" %
(self.getName(), self.positions[lKey]))
def isBusy(self):
return False
def atPointEnd(self):
pass
def atScanEnd(self):
if self.incli.isConfigured():
self.incli.clearup()
if self.rbvcli.isConfigured():
self.rbvcli.clearup()
def stop(self):
pass
def toFormattedString(self):
return self.name + " : " + self.getInputNames()[0] + " : " + str(
self.getPosition())
class GasRigValveClass(ScannableMotionBase):
'''Create a scannable for a gas injection rig'''
def __init__(self, name, rootPV):
self.setName(name);
self.setInputNames([name])
self.setLevel(5)
self.controlcli=CAClient(rootPV+VALVE_CONTROL)
self.statecli=CAClient(rootPV+VALVE_STATUS)
self.modecli=CAClient(rootPV+VALVE_MODE)
self.interlockscli=CAClient(rootPV+VALVE_INTERLOCKS)
self.operationscli=CAClient(rootPV+VALVE_OPERATIONS)
def getStatus(self):
try:
if not self.statecli.isConfigured():
self.statecli.configure()
output=int(self.statecli.caget())
self.statecli.clearup()
else:
output=int(self.statecli.caget())
return STATUS_SEQUENCE[output]
except:
print "Error returning current state"
return 0
def getMode(self):
try:
if not self.modecli.isConfigured():
self.modecli.configure()
output=int(self.modecli.caget())
self.modecli.clearup()
else:
output=int(self.modecli.caget())
return MODE_SEQUENCE[output]
except:
print "Error returning current state"
return 0
def getInterlocks(self):
try:
if not self.interlockscli.isConfigured():
self.interlockscli.configure()
output=int(self.interlockscli.caget())
self.interlockscli.clearup()
else:
output=int(self.interlockscli.caget())
return INTERLOCKS_SEQUENCE[output]
except:
print "Error returning current state"
return 0
def getOperations(self):
try:
if not self.operationscli.isConfigured():
self.operationscli.configure()
output=int(self.operationscli.caget())
self.operationscli.clearup()
else:
output=int(self.operationscli.caget())
return output
except:
print "Error returning current state"
return 0
def setControl(self,new_position):
try:
if not self.controlcli.isConfigured():
self.controlcli.configure()
self.controlcli.caput(new_position)
self.controlcli.clearup()
else:
self.controlcli.caput(new_position)
except:
print "error setting sequence"
def on(self):
self.setControl(0)
def off(self):
self.setControl(1)
def reset(self):
self.setControl(2)
#### methods for scannable
def getPosition(self):
return self.getStatus()
def asynchronousMoveTo(self, new_position):
self.setControl(float(new_position))
def isBusy(self):
return False
def atScanStart(self):
pass
def atPointStart(self):
pass
def stop(self):
pass
def atPointEnd(self):
pass
def atScanEnd(self):
pass
