class Modem(StandardDevice): def onStatusChange(self, value, **kw): #print "Modem Status Now is: ", value self._status = value #CONSTRUCTOR OF MODEM CLASS def __init__(self, pvName, mnemonic): StandardDevice.__init__(self, mnemonic) self.pvName = pvName self.modem = Device(pvName+':FONE:', ('discar.PROC','audio','numero','discar.VALA')) self._status = self.getStatus() self.modem.add_callback('discar.VALA',self.onStatusChange) def getStatus(self): return self.modem.get('discar.VALA') def getDiscar(self): return self.modem.get('discar.PROC') def setDiscar(self, discar): self.setStatus("1 - Aguardando Instrucoes") sleep(0.5) self.modem.put('discar.PROC', discar) def setAudio(self, audio): self.modem.put('audio',audio) def setNumero(self, numero): self.modem.put('numero',numero) def setStatus(self, status): self.modem.put('discar.VALA',status) def getStatusCode(self): return int(self._status[:2]) def waitCall(self): while self.getStatusCode() < 11: sleep(1)
class Modem(StandardDevice): def onStatusChange(self, value, **kw): #print "Modem Status Now is: ", value self._status = value #CONSTRUCTOR OF MODEM CLASS def __init__(self, pvName, mnemonic): StandardDevice.__init__(self, mnemonic) self.pvName = pvName self.modem = Device(pvName + ':FONE:', ('discar.PROC', 'audio', 'numero', 'discar.VALA')) self._status = self.getStatus() self.modem.add_callback('discar.VALA', self.onStatusChange) def getStatus(self): return self.modem.get('discar.VALA') def getDiscar(self): return self.modem.get('discar.PROC') def setDiscar(self, discar): self.setStatus("1 - Aguardando Instrucoes") sleep(0.5) self.modem.put('discar.PROC', discar) def setAudio(self, audio): self.modem.put('audio', audio) def setNumero(self, numero): self.modem.put('numero', numero) def setStatus(self, status): self.modem.put('discar.VALA', status) def getStatusCode(self): return int(self._status[:2]) def waitCall(self): while self.getStatusCode() < 11: sleep(1)
class Eurotherm2408(StandardDevice, IScannable): """ Class to control Eurotherm 2408 temperature controllers via EPICS. """ def __init__(self, pvName, mnemonic): """ **Constructor** See :class:`py4syn.epics.StandardDevice` Parameters ---------- pvName : `string` Power supply base naming of the PV (Process Variable) mnemonic : `string` Temperature controller mnemonic """ super().__init__(mnemonic) self.device = Device(pvName + ':', ['PV:RBV', 'SP','RR', 'RR:RBV', 'WSP:RBV', 'O' , 'O:RBV', 'MAN']) self.newTemp = Event() self.pvName = pvName def getValue(self): """ Returns the current measured temperature. Returns ------- `float` """ return self.device.get('PV:RBV') def getSP(self): """ Returns the current Set Point. Returns ------- `float """ time.sleep(0.5) return self.device.get('SP') def getTarget(self): """ Returns the current target temperature. Returns ------- `float` """ time.sleep(0.5) return self.device.get('WSP:RBV') def getRealPosition(self): """ Returns the same as :meth:`getValue`. See: :meth:`getValue` Returns ------- `float` """ return self.getValue() def getRampRate(self): """ Returns the defined ramp rate. Returns ------- `int` """ return self.device.get('RR:RBV') def getLowLimitValue(self): """ Returns the controller low limit temperature. Returns ------- `float` """ return 25.0 def getHighLimitValue(self): """ Returns the controller high limit temperature. Returns ------- `float` """ return 1000 def getRRHighLimitValue(self): return 25.0 def getRRLowLimitValue(self): return 1.0 def setRampRate(self, value): self.device.put('RR', value) def stop(self): '''Define SP to minimum temperature on maximum ramp rate''' self.setRampRate(self.getRRHighLimitValue) self.setValue(self.getLowLimitValue()) def hold(self): '''Set temperature to actual temperature''' actual_temp = self.getValue() self.setValue(actual_temp) def setValue(self, value, wait = False): if value < self.getLowLimitValue() or value > self.getHighLimitValue(): raise ValueError('Value exceeds limits') self.device.put('SP', value) if wait: self.wait() def getP(self): """ Return the current P value at the furnace Returns ------- `double` """ return self.device.get('P') def getI(self): """ Return the current I value at the furnace Returns ------- `double` """ return self.device.get('I') def getD(self): """ Return the current D value at the furnace Returns ------- `double` """ return self.device.get('D') def getPower(self): """ Return the current Power value at the furnace Returns ------- `double` """ return self.device.get('O:RBV') def setPower(self, value): """ Set Power value at the furnace Returns ------- `double` """ # it is necessary go to Manual mode to change power self.setManual() time.sleep(0.5) self.device.put('O', value) def setManual(self): """ Set furnance to Manual mode """ self.device.put('MAN', 1) def setAutomatic(self): """ Set furnance to Automatic mode """ self.device.put('MAN', 0) def reachTemp(self): if self.getValue() < self.getSP() + DELTA and \ self.getValue() > self.getSP() - DELTA: return True return False def wait(self): """ Blocks until the requested temperature is achieved. """ self.newTemp.clear() while not self.reachTemp(): ca.flush_io() self.newTemp.wait(5) self.newTemp.clear() def setVelocity(self, velo): """ Same as :meth:`setRampRate`. See: :meth:`setRampRate` Parameters ---------- r : `float` Ramp speed """ self.setRampRate(velo)
class Motor(IScannable, StandardDevice): """ Class to control motor devices via EPICS. Examples -------- >>> from py4syn.epics.MotorClass import Motor >>> >>> def createMotor(pvName="", mne=""): ... ... new_motor = '' ... ... try: ... new_motor = Motor(pvName, mne) ... print "Motor " + pvName + " created with success!" ... except Exception,e: ... print "Error: ",e ... ... return new_motor """ def onStatusChange(self, value, **kw): self._moving = not value def __init__(self, pvName, mnemonic): """ **Constructor** See :class:`py4syn.epics.StandardDevice` Parameters ---------- pvName : `string` Motor's base naming of the PV (Process Variable) mnemonic : `string` Motor's mnemonic """ StandardDevice.__init__(self, mnemonic) self.pvName = pvName self.pvType = PV(pvName+".RTYP", connection_timeout=3) if(self.pvType.status == None): raise Exception("Epics PV "+ pvName+" seems to be offline or not reachable") if(self.pvType.get()!= "motor"): raise Exception(pvName+" is not an Epics Motor") self.motor = Device(pvName+'.', ('RBV','VAL', 'DRBV', 'DVAL','RLV', 'RVAL', 'RRBV', 'STOP','MOVN','LLS','HLS','SSET','SUSE', 'SET','VELO','EGU','DMOV','STUP', 'DESC', 'BDST', 'HLM', 'LLM', 'DHLM', 'DLLM', 'VOF','FOF','OFF', 'DIR','LVIO')) self.motor.add_callback('DMOV',self.onStatusChange) self._moving = self.isMovingPV() self.motorDesc = self.getDescription() def __str__(self): return self.getMnemonic() + "("+self.pvName+")" def getDirection(self): """ Read the motor direction based on the `DIR` (User Direction) field of Motor Record Returns ------- `integer` .. note:: 0. Positive direction; 1. Negative direction. """ return self.motor.get('DIR') def isMovingPV(self): """ Check if a motor is moving or not from the PV Returns ------- `boolean` .. note:: - **True** -- Motor is moving; - **False** -- Motor is stopped. """ return (self.motor.get('DMOV') == 0) def isMoving(self): """ Check if a motor is moving or not based on the callback Returns ------- `boolean` .. note:: - **True** -- Motor is moving; - **False** -- Motor is stopped. """ return self._moving def isAtLowLimitSwitch(self): """ Check if a motor low limit switch is activated, based on the `LLS` (At Low Limit Switch) field of Motor Record Returns ------- `boolean` .. note:: - **True** -- Motor is at Low Limit; - **False** -- Motor is **NOT** at Low Limit. """ return self.motor.get('LLS') def isAtHighLimitSwitch(self): """ Check if a motor high limit switch is activated, based on the `HLS` (At High Limit Switch) field of Motor Record Returns ------- `boolean` .. note:: - **True** -- Motor is at High Limit; - **False** -- Motor is **NOT** at High Limit. """ return self.motor.get('HLS') def getDescription(self): """ Read the motor descrition based on the `DESC` field of Motor Record Returns ------- `string` """ return self.motor.get('DESC') def getHighLimitValue(self): """ Read the motor high limit based on the `HLM` (User High Limit) field of Motor Record Returns ------- `double` """ return self.motor.get('HLM') def getLowLimitValue(self): """ Read the motor low limit based on the `LLM` (User Low Limit) field of Motor Record Returns ------- `double` """ return self.motor.get('LLM') def getDialHighLimitValue(self): """ Read the motor dial high limit based on the `DHLM` (Dial High Limit) field of Motor Record Returns ------- `double` """ return self.motor.get('DHLM') def getDialLowLimitValue(self): """ Read the motor dial low limit based on the `DLLM` (Dial Low Limit) field of Motor Record Returns ------- `double` """ return self.motor.get('DLLM') def getBacklashDistanceValue(self): """ Read the motor backlash distance based on the `BDST` (Backlash Distance, `EGU`) field of Motor Record Returns ------- `double` """ return self.motor.get('BDST') def getVariableOffset(self): """ Read the motor variable offset based on the `VOF` (Variable Offset) field of Motor Record Returns ------- `integer` """ return self.motor.get('VOF') def getFreezeOffset(self): """ Read the motor freeze offset based on the `FOF` (Freeze Offset) field of Motor Record Returns ------- `integer` """ return self.motor.get('FOF') def getOffset(self): """ Read the motor offset based on the `OFF` (User Offset, `EGU`) field of Motor Record Returns ------- `string` """ return self.motor.get('OFF') def getRealPosition(self): """ Read the motor real position based on the `RBV` (User Readback Value) field of Motor Record Returns ------- `double` """ return self.motor.get('RBV') def getDialRealPosition(self): """ Read the motor DIAL real position based on the `DRBV` (Dial Readback Value) field of Motor Record Returns ------- `double` """ return self.motor.get('DRBV') def getDialPosition(self): """ Read the motor target DIAL position based on the `DVAL` (Dial Desired Value) field of Motor Record Returns ------- `double` """ return self.motor.get('DVAL') def getRawPosition(self): """ Read the motor RAW position based on the `RVAL` (Raw Desired Value) field of Motor Record Returns ------- `double` """ return self.motor.get('RVAL') def setRawPosition(self, position): """ Sets the motor RAW position based on the `RVAL` (Raw Desired Value) field of Motor Record Returns ------- `double` """ self._moving = True self.motor.put('RVAL', position) ca.poll(evt=0.05) def getRawRealPosition(self): """ Read the motor RAW real position based on the `RRBV` (Raw Readback Value) field of Motor Record Returns ------- `double` """ return self.motor.get('RRBV') def getPosition(self): """ Read the motor target position based on the `VAL` (User Desired Value) field of Motor Record Returns ------- `double` """ return self.motor.get('VAL') def getEGU(self): """ Read the motor engineering unit based on the `EGU` (Engineering Units) field of Motor Record Returns ------- `string` """ return self.motor.get('EGU') def getLVIO(self): """ Read the motor limit violation `LVIO` (Limit Violation) field of Motor Record Returns ------- `short` """ return self.motor.get('LVIO') def setEGU(self, unit): """ Set the motor engineering unit to the `EGU` (Engineering Units) field of Motor Record Parameters ---------- unit : `string` The desired engineering unit. .. note:: **Example:** "mm.", "deg." """ return self.motor.set('EGU', unit) def setHighLimitValue(self, val): """ Set the motor high limit based on the `HLM` (User High Limit) field of Motor Record Parameters ---------- val : `double` The desired value to set """ self.motor.put('HLM', val) def setLowLimitValue(self, val): """ Set the motor low limit based on the `LLM` (User Low Limit) field of Motor Record Parameters ---------- val : `double` The desired value to set """ self.motor.put('LLM', val) def setDialHighLimitValue(self, val): """ Set the motor dial high limit based on the `DHLM` (Dial High Limit) field of Motor Record Parameters ---------- val : `double` The desired value to set """ self.motor.put('DHLM', val) def setDialLowLimitValue(self, val): """ Set the motor dial low limit based on the `DLLM` (Dial Low Limit) field of Motor Record Parameters ---------- val : `double` The desired value to set """ self.motor.put('DLLM', val) def setSETMode(self): """ Put the motor in SET mode .. note:: Motor will **NOT** move until it is in in **USE mode** """ self.motor.put('SSET',1) def setUSEMode(self): """ Put the motor in **USE mode** """ self.motor.put('SUSE',1) def setVariableOffset(self, val): """ Set the motor variable offset based on the `VOF` (Variable Offset) field of Motor Record Parameters ---------- val : `integer` The desired value to set """ self.motor.put('VOF', val) def setFreezeOffset(self, val): """ Set the motor freeze offset based on the `FOF` (Freeze Offset) field of Motor Record Parameters ---------- val : `integer` The desired value to set """ self.motor.put('FOF', val) def setOffset(self, val): """ Set the motor offset based on the `OFF` (User Offset, `EGU`) field of Motor Record Parameters ---------- val : `double` The desired value to set """ self.motor.put('OFF', val) def setDialPosition(self, pos, waitComplete=False): """ Set the motor target DIAL position based on the `DVAL` (Dial Desired Value) field of Motor Record Parameters ---------- pos : `double` The desired position to set waitComplete : `boolean` (default is **False**) .. note:: If **True**, the function will wait until the movement finish to return, otherwise don't. """ if(self.getDialRealPosition() == pos): return self.motor.put('DVAL', pos) self._moving = True if(waitComplete): self.wait() def setAbsolutePosition(self, pos, waitComplete=False): """ Move the motor to an absolute position received by an input parameter Parameters ---------- pos : `double` The desired position to set waitComplete : `boolean` (default is **False**) .. note:: If **True**, the function will wait until the movement finish to return, otherwise don't. """ if(self.getRealPosition() == pos): return ret, msg = self.canPerformMovement(pos) if(not ret): raise Exception("Can't move motor "+self.motorDesc+" ("+self.pvName+") to desired position: "+str(pos)+ ", " + msg) self._moving = True self.motor.put('VAL',pos) ca.poll(evt=0.05) if(waitComplete): self.wait() def setRelativePosition(self, pos, waitComplete=False): """ Move the motor a distance, received by an input parameter, to a position relative to that current one Parameters ---------- pos : `double` The desired distance to move based on current position waitComplete : `boolean` (default is **False**) .. note: If **True**, the function will wait until the movement finish to return, otherwise don't. """ if(pos == 0): return ret, msg = self.canPerformMovement(self.getRealPosition()+pos) if(not ret): raise Exception("Can't move motor "+self.motorDesc+" ("+ self.pvName+") to desired position: "+ str(self.getRealPosition()+pos)+ ", " + msg) self.motor.put('RLV',pos) ca.poll(evt=0.05) self._moving = True if(waitComplete): self.wait() def setVelocity(self, velo): """ Set the motor velocity up based on the `VELO` (Velocity, EGU/s) field from Motor Record Parameters ---------- velo : `double` The desired velocity to set """ self.motor.put('VELO',velo) def setAcceleration(self, accl): """ Set the motor acceleration time based on the `ACCL` (Seconds to Velocity) field from Motor Record Parameters ---------- accl : `double` The desired acceleration to set """ self.motor.put('ACCL',accl) def setUpdateRequest(self,val): """ Set the motor update request flag based on the `STUP` (Status Update Request) field from Motor Record Parameters ---------- val : `integer` The desired value to set for the flag """ self.motor.put('STUP',val) def validateLimits(self): """ Verify if motor is in a valid position. In the case it has been reached the HIGH or LOW limit switch, an exception will be raised. """ message = "" if(self.isAtHighLimitSwitch()): message = 'Motor: '+self.motorDesc+' ('+self.pvName+') reached the HIGH limit switch.' elif(self.isAtLowLimitSwitch()): message = 'Motor: '+self.motorDesc+' ('+self.pvName+') reached the LOW limit switch.' if(message != ""): raise Exception(message) def canPerformMovement(self, target): """ Check if a movement to a given position is possible using the limit values and backlash distance Returns ------- `boolean` .. note:: - **True** -- Motor CAN perform the desired movement; - **False** -- Motor **CANNOT** perform the desired movement. """ # Moving to high limit if(target > self.getRealPosition()): if(self.isAtHighLimitSwitch()): return False, "Motor at high limit switch" # Moving to low limit else: if(self.isAtLowLimitSwitch()): return False, "Motor at low limit switch" if(self.getLVIO()==0): return True, "" return False, "Movement beyond soft limits" def canPerformMovementCalc(self, target): """ Check if a movement to a given position is possible using the limit values and backlash distance calculating the values Returns ------- `boolean` .. note:: - **True** -- Motor CAN perform the desired movement; - **False** -- Motor **CANNOT** perform the desired movement. """ if self.getHighLimitValue() == 0.0 and self.getLowLimitValue() == 0.0: return True backlashCalc = self.calculateBacklash(target) if(self.getDirection()==0): if(backlashCalc > 0): vFinal = target - backlashCalc else: vFinal = target + backlashCalc else: if(backlashCalc > 0): vFinal = target + backlashCalc else: vFinal = target - backlashCalc if(target > self.getRealPosition()): if(self.isAtHighLimitSwitch()): return False if vFinal <= self.getHighLimitValue(): return True # Moving to low limit else: if(self.isAtLowLimitSwitch()): return False if vFinal >= self.getLowLimitValue(): return True return False def calculateBacklash(self, target): """ Calculates the backlash distance of a given motor Returns ------- `double` """ # Positive Movement if(self.getDirection() == 0): if(self.getBacklashDistanceValue() > 0 and target < self.getRealPosition()) or (self.getBacklashDistanceValue() < 0 and target > self.getRealPosition()): return self.getBacklashDistanceValue() else: if(self.getBacklashDistanceValue() > 0 and target > self.getRealPosition()) or (self.getBacklashDistanceValue() < 0 and target < self.getRealPosition()): return self.getBacklashDistanceValue() return 0 def stop(self): """ Stop the motor """ self.motor.put('STOP',1) def wait(self): """ Wait until the motor movement finishes """ while(self._moving): ca.poll(evt=0.01) def getValue(self): """ Get the current position of the motor. See :class:`py4syn.epics.IScannable` Returns ------- `double` Read the current value (Motor Real Position) """ return self.getRealPosition() def setValue(self, v): """ Set the desired motor position. See :class:`py4syn.epics.IScannable` Parameters ---------- v : `double` The desired value (Absolute Position) to set """ self.setAbsolutePosition(v)
class OmronE5CK(StandardDevice, IScannable): """ Class to control Omron E5CK temperature controllers via EPICS. Examples -------- >>> from py4syn.epics.OmronE5CKClass import OmronE5CK >>> >>> def showTemperature(pv='', name=''): ... e5ck = OmronE5CK(pv, name) ... print('Temperature is: %d' % e5ck.getValue()) ... >>> def fastRaiseTemperature(e5ck, amount, rate=30): ... e5ck.setRate(rate) ... e5ck.setValue(e5ck.getValue() + amount) ... >>> def complexRamp(e5ck): ... e5ck.setRate(10) ... e5ck.setValue(200) ... e5ck.wait() ... e5ck.setRate(2) ... e5ck.setValue(220) ... e5ck.wait() ... sleep(500) ... e5ck.setRate(5) ... e5ck.setValue(100) ... e5ck.wait() ... e5ck.stop() ... >>> import py4syn >>> from py4syn.epics.ScalerClass import Scaler >>> from py4syn.utils.counter import createCounter >>> from py4syn.utils.scan import scan >>> >>> def temperatureScan(start, end, rate, pv='', counter='', channel=2): ... e5ck = OmronE5CK(pv, 'e5ck') ... py4syn.mtrDB['e5ck'] = e5ck ... c = Scaler(counter, channel, 'simcountable') ... createCounter('counter', c, channel) ... e5ck.setRate(rate) ... scan('e5ck', start, end, 10, 1) ... e5ck.stop() ... """ STATUS_IS_RUNNING = 1<<7 PROGRAM_LENGTH = 4 COMMAND_GET_STEP = '4010000' COMMAND_SET_TARGET = '5%02d%04d' TARGETS = (5, 8, 11, 14,) TIMES = (7, 10, 13, 16,) def __init__(self, pvName, mnemonic): """ **Constructor** See :class:`py4syn.epics.StandardDevice` Parameters ---------- pvName : `string` Power supply base naming of the PV (Process Variable) mnemonic : `string` Temperature controller mnemonic """ super().__init__(mnemonic) self.device = Device(pvName + ':', ['termopar', 'target', 'status', 'stepNum', 'programTable', 'programming', 'run', 'stop', 'advance', 'setPatternCount', 'timeScale', 'level1', 'reset', 'pause', 'sendCommand', 'pidtable', 'numPIDElements', 'paused', 'getP', 'getI', 'getD', 'power']) self.programmingDone = Event() self.newTemperature = Event() self.newStep = Event() self.device.add_callback('programming', self.onProgrammingChange) self.device.add_callback('termopar', self.onTemperatureChange) self.device.add_callback('stepNum', self.onStepChange) self.timeScaleCache = self.device.get('timeScale') self.pvName = pvName self.rate = 5 self.presetDone = False def __str__(self): return '%s (%s)' % (self.getMnemonic(), self.pvName) def isRunning(self): """ Returns true if the controller is in program mode. Whenever it is program mode, it is following a target temperature. Returns ------- `bool` """ v = self.device.get('status') r = not bool(int(v) & self.STATUS_IS_RUNNING) if not r: self.presetDone = False return r def isPaused(self): """ Returns true if the controller is paused (keep temperature). Returns ------- `bool` """ paused = self.device.get('paused') return paused def getValue(self): """ Returns the current measured temperature. Returns ------- `float` """ return self.device.get('termopar') def getTarget(self): """ Returns the current target temperature. If the device is running, the target temperature is the temperature the device is changing to. If the device is not running, the target temperature is ignored. Returns ------- `float` """ return self.device.get('target') def getRealPosition(self): """ Returns the same as :meth:`getValue`. See: :meth:`getValue` Returns ------- `float` """ return self.getValue() def getStepNumber(self): """ Helper method to get the current program step. Returns ------- `int` """ return self.device.get('stepNum') def getLowLimitValue(self): """ Returns the controller low limit temperature. Returns ------- `float` """ return 0.0 def getHighLimitValue(self): """ Returns the controller high limit temperature. Returns ------- `float` """ return 1300.0 def onProgrammingChange(self, value, **kwargs): """ Helper callback that tracks when the IOC finished programming the device. """ self.presetDone = False if value == 0: self.programmingDone.set() def onStepChange(self, value, **kwargs): """ Helper callback that indicates when a new program step has been reached """ self.newStep.set() def onTemperatureChange(self, value, **kwargs): """ Helper callback that indicates when the measured temperature has changed """ self.newTemperature.set() def stop(self): """ Stops executing the current temperature program and puts the device in idle state. In the idle state, the device will not try to set a target temperature. """ self.device.put('stop', 1) self.presetDone = False def run(self): """ Starts or resumes executing the current temperature program. """ self.device.put('run', 1) def advance(self): """ Helper method to skip the current program step and execute the next one. """ self.device.put('advance', 1) def pause(self): """ Pauses current ramp program. To resume program, use :meth:`run` See: :meth:`run` """ self.device.put('pause', 1) def sendCommand(self, command): """ Helper method to send a custom command to the controller. Parameters ---------- command : `str` The command to be send """ self.device.put('sendCommand', command.encode(), wait=True) def preset(self): """ Makes the controler enter a well defined known state. This method creates and runs an "empty" ramp program. The program simply mantains the current temperature forever, whatever that temperature is. This is mostly a helper function, to allow making complex temperature ramps starting from a known state and reusing the preset values. .. note:: Running a new program requires stopping the current program. While the program is stopped, the controller power generation drops to zero. Because of this power drop, this method may be slow to stabilize. """ self.stop() current = self.getValue() # Steps 0 and 2 are fake steps, steps 1 and 3 are the real ones. # The fake steps are used for synchronizing with the device. program = [self.PROGRAM_LENGTH] + self.PROGRAM_LENGTH*[current, 99] self.programmingDone.clear() self.device.put('setPatternCount', 9999) self.device.put('programTable', array(program)) ca.flush_io() self.programmingDone.wait(10) self.run() self.presetDone = True def program(self, programTable): """ Set a programTable to the furnace """ self.programmingDone.clear() self.device.put('programTable', array(programTable)) ca.flush_io() self.programmingDone.wait(10) def setPIDTable(self, pidTable): """ Set a PIDtable to the furnace """ self.device.put('pidtable', array(pidTable)) def getPIDTable(self): """ Return the current PID table at the furnace Returns ------- `array` """ pidTablePV = self.device.PV('pidtable') return pidTablePV.get() def getP(self): """ Return the current P value at the furnace Returns ------- `double` """ getPV = self.device.PV('getP') return getPV.get() def getI(self): """ Return the current I value at the furnace Returns ------- `double` """ getPV = self.device.PV('getI') return getPV.get() def getD(self): """ Return the current D value at the furnace Returns ------- `double` """ getPV = self.device.PV('getD') return getPV.get() def getPower(self): """ Return the current Power value at the furnace Returns ------- `double` """ getPV = self.device.PV('power') return getPV.get() def getNumPIDElements(self): """ Return the number of all parameters at a PID table Returns ------- `int` """ numPIDElementsPV = self.device.PV('numPIDElements') return numPIDElementsPV.get() def getTimeScale(self): """ Returns the time scale being used by the controller. The timescale can either be zero, for hours:minutes, or one, for minutes:seconds. Returns ------- `int` """ t = self.device.PV('timeScale') v = t.get() t.get_ctrlvars() if t.severity == 0: self.timeScaleCache = v return self.timeScaleCache def setTimeScale(self, minutes): """ Changes the time scale being used by the controller. The timescale can either be zero, for hours:minutes, or one, for minutes:seconds. This operation requires switching the controller operation mode to be successful, and then a reset is issued after it. The whole operation takes more than 5 seconds. Parameters ---------- minutes : `int` Set to 1 for minutes:seconds, or 0 for hours:minutes """ if minutes == self.getTimeScale() and self.device.PV('timeScale').severity == 0: return t = self.getValue() self.device.put('level1', 1) self.device.put('timeScale', minutes) self.device.put('reset', 1) def getStepNumberSync(self): """ Helper module to retrieve an up-to-date value for the current program step number. Similar to :meth:`getStepNumber`, but it doesn't rely on monitor value and instead does a synchronous caget() call. See: :meth:`getStepNumber` Returns ------- `int` """ self.device.put('stepNum.PROC', 0, wait=True) v = self.device.PV('stepNum').get(use_monitor=False) return int(v) def synchronizeStep(self, current): """ Helper method to set up a constant temperature right before running a ramp program. This method detects if a current ramp program is running or not. If it's not, then it doesn't do anything. If there is a ramp running, then it configures and advances to a "synchronization step", that is, a step where the temperature does not change. This step marks the beginning of the new ramp. The method returns the resulting step number Parameters ---------- current : `float` The temperature target for the synchronization step Returns ------- `int` """ # This method uses the advance() call to skip steps. Suprisingly, advancing # steps with E5CK is not trivial. The reason for this is that E5CK quickly # acknowledges the advance command, but delays to actually advance. Ignoring # this deficiency results in other commands issued later doing the wrong thing. # In particular, calling advance again later may silently fail. We work around # this by using a synchronous call to get the current step number and a busy # wait to check when the step was really changed. # # To make things worse, some component in EPICS seems to break serialization by # not respecting the order which PVs are updated, so it's not possible to # change the program using two separate PVs, like, for example, stepNumConfig # setStepTarget, which are implemented in E5CK's IOC. Because of that, a custom # PV was added in the IOC to support arbitrary commands sent in a serialized # way. This sendCommand procedure is what this method uses. step = self.getStepNumberSync() while step % 2 == 1: target = self.TARGETS[(step+1)%self.PROGRAM_LENGTH] self.sendCommand(self.COMMAND_SET_TARGET % (target, current)) self.advance() # E5CK is slow, so loop until it changes state. This is required: calling # advance twice in a row doesn't work. A state transition must happen first. old = step while old == step: step = self.getStepNumberSync() assert step % 2 == 0 return step def timeToValue(self, t): """ Helper method to convert between minutes to the format used by the controller. Parameters ---------- t : `float` The desired time, in minutes Returns ------- `float` """ if self.getTimeScale() == 0: minutes = int(t)%60 hours = int(t)//60 value = 100*hours + minutes if hours > 99: raise OverflowError('Ramp time is too large: %g' % t) else: minutes = int(t) if minutes > 99: raise OverflowError('Ramp time is too large with current settings: %g' % t) seconds = min(round((t-minutes)*60), 59) value = 100*minutes + seconds return value def setRate(self, r): """ Sets the ramp speed in degrees per minutes for use with :meth:`setValue`. This method does not send a command to the controller, it only stores the rate for the next ramps. See: :meth:`setValue` Parameters ---------- r : `float` Ramp speed in °C/min """ self.rate = r def setVelocity(self, velo): """ Same as :meth:`setRate`. See: :meth:`setRate` Parameters ---------- r : `float` Ramp speed in °C/min """ self.setRate(velo) def setValue(self, v): """ Changes the temperature to a new value. This method calls preset if it has not already been called first. The speed that the new temperature is reached is set with :meth:`setRate`. The default rate is 5 °C/minute. See: :meth:`setRate` Parameters ---------- v : `float` The target temperature in °C """ # This method depends on a program preset being loaded and the program being # in a synchronization step. Given the two precondition, this method simply # programs a ramp, a synchronization step after the ramp and advances to the # ramp step. if not self.presetDone: self.preset() # We accept float as input, but the controller is integer only v = round(v) current = self.getValue() minutes = abs(v-current)/self.rate time = self.timeToValue(minutes) step = self.synchronizeStep(current) self.waitStep = (step+2)%self.PROGRAM_LENGTH x = self.TARGETS[step+1] y = self.TIMES[step+1] z = self.TARGETS[self.waitStep] self.sendCommand(self.COMMAND_SET_TARGET % (x, v)) self.sendCommand(self.COMMAND_SET_TARGET % (y, time)) self.sendCommand(self.COMMAND_SET_TARGET % (z, v)) self.advance() self.valueTarget = v def wait(self): """ Blocks until the requested temperature is achieved. """ if not self.presetDone: return # Waiting is done in two steps. First step waits until the program reaches # the next synchronization step. Second step waits util the measured temperature # reaches the requested temperature self.newStep.clear() while self.getStepNumber() != self.waitStep: ca.flush_io() self.newStep.wait(60) self.newStep.clear() self.newTemperature.clear() while self.getValue() != self.valueTarget: ca.flush_io() # Safety timeout, temperature didn't change after a long time if not self.newTemperature.wait(120): return self.newTemperature.clear()
class Keithley6485(Keithley6514): """ Python class to help configuration and control the Keithley 6514 Electrometer. Keithley is an electrical instrument for measuring electric charge or electrical potential difference. This instrument is capable of measuring extremely low currents. E.g.: pico (10e-12), i.e.: 0,000 000 000 001. For more information, please, refer to: `Model 6514 System Electrometer Instruction Manual <http://www.tunl.duke.edu/documents/public/electronics/Keithley/keithley-6514-electrometer-manual.pdf>`_ """ def __init__(self, pvName, mnemonic, timeBased=False): """ **Constructor** To use this Keithley Class you must pass the PV (Process Variable) prefix. .. Note:: e.g.: SXS:K6514 Examples -------- >>> from KeithleyClass import * >>> name = Keithley('SOL:K6514', 'k1') """ Keithley6514.__init__(self, pvName, mnemonic) self.pvName = pvName self.timeBased = timeBased self.keithley = Device( pvName + ':', ('GetMed', 'SetMed', 'GetMedRank', 'SetMedRank', 'GetAver', 'SetAver', 'GetAverCoun', 'SetAverCoun', 'GetNPLC', 'SetNPLC', 'GetAutoZero', 'SetAutoZero', 'GetZeroCheck', 'SetZeroCheck', 'GetAverTCon', 'SetAverTCon', 'GetRange', 'SetRange', 'GetZeroCor', 'SetZeroCor', 'GetAutoCurrRange', 'SetAutoCurrRange' 'Count', 'ContinuesMode', 'CNT', 'OneMeasure')) self.pvMeasure = PV(pvName + ':' + 'Measure', auto_monitor=False) self._counting = self.isCountingPV() self.keithley.add_callback('CNT', self.onStatusChange) def getCurrentRange(self): """ Get the value of range. Default: Auto range. Returns ------- Value: Integer, i.e.: 0 (Undefined ZERO), 1 (Indefined UM), 2 (20 mA), 3 (2 mA), 4 (200 uA), 5 (20 uA), 6 (2 uA), 7 (200 nA), 8 (20 nA), 9 (2 nA), 10 (200 pA), 11 (20 pA). Examples -------- >>> name.getCurrentRange() >>> 11 """ return self.keithley.get('GetRange') def setCurrentRange(self, curange): """ Set the range. Parameters ---------- Value: Integer, i.e.: 0 (Undefined ZERO), 1 (Indefined UM), 2 (20 mA), 3 (2 mA), 4 (200 uA), 5 (20 uA), 6 (2 uA), 7 (200 nA), 8 (20 nA), 9 (2 nA), 10 (200 pA), 11 (20 pA). Examples -------- >>> name.setCurrentRange(5) """ if (curange < 0 or curange > 11): raise ValueError('Invalid number - It should be 0 to 11') self.keithley.put('SetRange', curange)
class Lauda(StandardDevice, IScannable): """ Class to control Lauda temperature controllers via EPICS. Examples -------- >>> from py4syn.epics.LaudaClass import Lauda >>> >>> def showTemperature(pv): ... lauda = Lauda(pv, 'lauda') ... print('Temperature is: %d' % lauda.getValue()) ... >>> def setTemperature(lauda, temperature): ... lauda.setValue(temperature) ... lauda.run() """ EPSILON = 0.1 def __init__(self, pvName, mnemonic): """ **Constructor** See :class:`py4syn.epics.StandardDevice` Parameters ---------- pvName : `string` Power supply base naming of the PV (Process Variable) mnemonic : `string` Temperature controller mnemonic """ super().__init__(mnemonic) self.pvName = pvName self.lauda = Device(pvName + ':', [ 'BLEVEL', 'BOVERTEMP', 'BPOWER', 'BSP', 'BSTATS', 'BTEMP', 'BTN', 'BTHERMOSTATS', 'WSP', 'WSTART', 'ETEMP', 'WPUMP', 'WSTOP', 'WTN' ]) self.newTemperature = Event() self.lauda.add_callback('BTEMP', self.onTemperatureChange) # Skip initial callback self.newTemperature.wait(1) def __str__(self): return '%s (%s)' % (self.getMnemonic(), self.pvName) def getValue(self): """ Returns the current measured temperature. Returns ------- `int` """ return self.lauda.get('BTEMP') def getRealPosition(self): """ Returns the same as :meth:`getValue`. See: :meth:`getValue` Returns ------- `int` """ return self.getValue() def onTemperatureChange(self, **kwargs): """ Helper callback that indicates when the measured temperature changed. """ self.newTemperature.set() def setVelocity(self, r): """ Dummy method setVelocity() Parameters ---------- r : `float` Ramp speed in °C/min """ pass def setValue(self, v): """ Changes the temperature to a new value. Parameters ---------- v : `int` The target temperature in °C """ self.lauda.put('WSP', v) self.run() self.requestedValue = v def wait(self): """ Blocks until the requested temperature is achieved. """ ca.flush_io() self.newTemperature.clear() while abs(self.getValue() - self.requestedValue) > self.EPSILON: # Give up after 60 seconds without an update if not self.newTemperature.wait(60): break self.newTemperature.clear() def getLowLimitValue(self): """ Returns the controller low limit temperature. Returns ------- `int` """ return -20 def getHighLimitValue(self): """ Returns the controller high limit temperature. Returns ------- `int` """ return 200 def run(self): """ Starts or resumes executing the current temperature program. """ self.lauda.put('WSTART', 1) def stop(self): """ Stops executing the current temperature program and puts the device in idle state. In the idle state, the device will not try to set a target temperature. """ self.lauda.put('WSTOP', 1) def setPumpSpeed(self, speed): """ Changes the pump speed. Parameters ---------- speed : `int` The requested pump speed, ranging from 1 to 8. """ if speed < 1 or speed > 8: raise ValueError('Invalid speed') self.lauda.put('WPUMP', speed) def getInternalTemp(self): """ Same as :meth:`getValue`. See :meth:`getValue` Returns ------- `int` """ return self.getValue() def getExternalTemp(self): """ Returns the device's external temperature. Returns ------- `int` """ return self.lauda.get('ETEMP') def getLevel(self): """ Returns the device's bath level. Returns ------- `int` """ return self.lauda.get('BLEVEL') def getSetPoint(self): """ Returns the current target temperature. Returns ------- `int` """ return self.lauda.get('BSP') def getPower(self): """ Returns the current device power. Returns ---------- `int` """ return self.lauda.get('BPOWER') def getOverTemp(self): """ Returns the maximum temperature software defined limit. Returns ---------- `int` """ return self.lauda.get('BOVERTEMP') def getTN(self): """ Returns ---------- `int` """ return self.lauda.get('BTN') def getStatus(self): """ Returns the device status word. Returns ---------- `int` """ return self.lauda.get('BSTATS') def getThermoStatus(self): """ Returns the device thermostat error word. Returns ---------- `int` """ return self.lauda.get('BTHERMOSTATS') def changeSetPoint(self, val): """ Same as :meth:`setValue`. See :meth:`setValue` Parameters ---------- val : `int` The requested temperature. """ self.setValue(val) def changePump(self, val): """ Same as :meth:`setPumpSpeed`. See :meth:`setPumpSpeed` Parameters ---------- val : `int` The requested pump speed. """ self.setPumpSpeed(val) def changeTN(self, val): self.lauda.put('WTN', val) def start(self): """ Same as :meth:`run`. See :meth:`run` """ self.run()
class LakeShore331(IScannable, StandardDevice): """ Python class to help configuration and control of LakeShore 331 devices via Hyppie over EPICS. Examples -------- >>> from py4syn.epics.LakeShore331 import LakeShore331 >>> ls331 = LakeShore331("DXAS:LS331", "ls331", channel=0) # Use 1 for Ch B >>> ls331.setValue(120) # 120 degrees Celsius """ def __init__(self, pvPrefix="", mnemonic="", channel=0): """ **Constructor** See :class:`py4syn.epics.StandardDevice` Parameters ---------- pvPrefix : `string` LakeShore331's device base naming of the PV (Process Variable); Like DXAS:LS331; mnemonic : `string` LakeShore331's mnemonic """ StandardDevice.__init__(self, mnemonic) self.lakeshore331 = Device( pvPrefix + ':', ('GetHEAT', 'GetHeaterRange', 'GetAPIDD', 'GetAPIDI', 'GetAPIDP', 'GetASetPoint', 'GetBPIDD', 'GetBPIDI', 'GetBPIDP', 'GetBSetPoint', 'GetCTempA', 'GetCTempB', 'GetKTempA', 'GetKTempB', 'SetHeaterRange', 'SetAPIDD', 'SetAPIDI', 'SetAPIDP', 'SetASetPoint', 'SetBPIDD', 'SetBPIDI', 'SetBPIDP', 'SetBSetPoint', 'GetCmode', 'SetCmode')) self.ls331_control = Device(pvPrefix + ':CONTROL:', ['SetAPID', 'SetBPID', 'Trigger']) if (channel == 1): self.ls331_channel = LakeShore_t.Channel_B else: # Default self.ls331_channel = LakeShore_t.Channel_A def getHeat(self): """ Heater output query Returns ------- Value: Float, e.g.: 0.001 Examples -------- >>> ls331.getHeat() >>> 51.530 """ return self.lakeshore331.get('GetHEAT') def getHeaterRange(self): """ Heater range command. Returns ------- Value: Float, e.g.: 0.001 Examples -------- >>> ls331.getHeaterRange() >>> 51.530 """ return self.lakeshore331.get('GetHeaterRange') def getAPIDD(self): """ Returns Value D of PID for channel A. Returns ------- Value: Integer, e.g.: 10 Examples -------- >>> ls331.getAPIDD() >>> 31 """ return self.lakeshore331.get('GetAPIDD') def getBPIDD(self): """ Returns Value D of PID for channel B. Returns ------- Value: Integer, e.g.: 10 Examples -------- >>> ls331.getBPIDD() >>> 32 """ return self.lakeshore331.get('GetBPIDD') def getAPIDI(self): """ Returns Value I of PID for channel A. Returns ------- Value: Integer, e.g.: 10 Examples -------- >>> ls331.getAPIDI() >>> 31 """ return self.lakeshore331.get('GetAPIDI') def getBPIDI(self): """ Returns Value I of PID for channel B. Returns ------- Value: Integer, e.g.: 10 Examples -------- >>> ls331.getBPIDI() >>> 32 """ return self.lakeshore331.get('GetBPIDI') def getAPIDP(self): """ Returns Value P of PID for channel A. Returns ------- Value: Integer, e.g.: 10 Examples -------- >>> ls331.getAPIDP() >>> 31 """ return self.lakeshore331.get('GetAPIDP') def getBPIDP(self): """ Returns Value P of PID for channel B. Returns ------- Value: Integer, e.g.: 10 Examples -------- >>> ls331.getBPIDP() >>> 32 """ return self.lakeshore331.get('GetBPIDP') def getASetPoint(self): """ Returns setpoint value for channel A. Returns ------- Value: float, e.g.: 0.001 Examples -------- >>> ls331.getASetPoint() >>> 67.87 """ return self.lakeshore331.get('SetASetPoint') def getBSetPoint(self): """ Returns setpoint value for channel B. Returns ------- Value: float, e.g.: 0.001 Examples -------- >>> ls331.getBSetPoint() >>> 67.87 """ return self.lakeshore331.get('GetBSetPoint') def getCTempA(self): """ Returns channel A temperature in Celsius degrees. Returns ------- Value: float, e.g.: 0.001 Examples -------- >>> ls331.getCTempA() >>> 32.56 """ return self.lakeshore331.get('GetCTempA') def getCTempB(self): """ Returns channel B temperature in Celsius degrees. Returns ------- Value: float, e.g.: 0.001 Examples -------- >>> ls331.getCTempB() >>> 32.56 """ return self.lakeshore331.get('GetCTempB') def getKTempA(self): """ Returns channel A temperature in Kelvin. Returns ------- Value: float, e.g.: 0.001 Examples -------- >>> ls331.getKTempA() >>> 32.56 """ return self.lakeshore331.get('GetKTempA') def getKTempB(self): """ Returns channel B temperature in Kelvin. Returns ------- Value: float, e.g.: 0.001 Examples -------- >>> ls331.getKTempB() >>> 32.56 """ return self.lakeshore331.get('GetKTempB') def setHeaterRange(self, heaterRange): """ Heater range command. Parameters ---------- heaterRange : `float` """ self.lakeshore331.put('SetHeaterRange', heaterRange, wait=True) def setASetPoint(self, setPoint): """ Set a setpoint value for channel A. Parameters ---------- setPoint : `float` """ self.lakeshore331.put('SetASetPoint', setPoint, wait=True) def setBSetPoint(self, setPoint): """ Set a setpoint value for channel B. Parameters ---------- setPoint : `float` """ self.lakeshore331.put('SetBSetPoint', setPoint, wait=True) def setAPIDD(self, pid_d): """ D parameter value of PID for channel A. Parameters ---------- pid_d : `integer` """ self.lakeshore331.put('SetAPIDD', pid_d, wait=True) def setBPIDD(self, pid_d): """ D parameter value of PID for channel B. Parameters ---------- pid_d : `integer` """ self.lakeshore331.put('SetBPIDD', pid_d, wait=True) def setAPIDI(self, pid_i): """ I parameter value of PID for channel A. Parameters ---------- pid_i : `integer` """ self.lakeshore331.put('SetAPIDI', pid_i, wait=True) def setBPIDI(self, pid_i): """ I parameter value of PID for channel B. Parameters ---------- pid_i : `integer` """ self.lakeshore331.put('SetBPIDI', pid_i, wait=True) def setAPIDP(self, pid_p): """ P parameter value of PID for channel A. Parameters ---------- pid_p : `integer` """ self.lakeshore331.put('SetAPIDP', pid_p, wait=True) def setBPIDP(self, pid_p): """ P parameter value of PID for channel B. Parameters ---------- pid_p : `integer` """ self.lakeshore331.put('SetBPIDP', pid_p, wait=True) # Get Control Loop Mode def getCMode(self): return self.lakeshore331.get('GetCmode') # Set CMode (Control Loop Mode) def setCMode(self, cmode): self.lakeshore331.put('SetCmode', cmode, wait=True) def setControlAPID(self, a_pid): """ PID for channel A. Parameters ---------- a_pid : `integer` """ self.ls331_control.put('SetAPID', a_pid, wait=True) def setControlBPID(self, b_pid): """ PID for channel B. Parameters ---------- b_pid : `integer` """ self.ls331_control.put('SetBPID', b_pid, wait=True) def setControlTrigger(self, trigger): """ Trigger. Parameters ---------- trigger : `integer` """ self.ls331_control.put('Trigger', trigger, wait=True) def getValue(self): """ Returns ... Returns ------- `float`, Temperature in Celsius degrees """ if (self.ls331_channel == LakeShore_t.Channel_A): return self.getCTempA() else: return self.getCTempB() def setValue(self, temperature): """ Sets ... Parameters ---------- temperature : `float`, Temperature in Celsius degrees """ if (self.ls331_channel == LakeShore_t.Channel_A): self.setASetPoint(temperature) else: self.setBSetPoint(temperature) def wait(self): """ Wait... """ sleep(0) def getLowLimitValue(self): """ Gets ... Returns ------- `float` """ # Mininum is 0 K... -272.15 .oC return -272.15 def getHighLimitValue(self): """ Gets ... Returns ------- `float` """ # Unsure about maximum... let's put 325 K... 51.85 .oC return 51.85
class Keithley6514(StandardDevice, ICountable): """ Python class to help configuration and control the Keithley 6514 Electrometer. Keithley is an electrical instrument for measuring electric charge or electrical potential difference. This instrument is capable of measuring extremely low currents. E.g.: pico (10e-12), i.e.: 0,000 000 000 001. For more information, please, refer to: `Model 6514 System Electrometer Instruction Manual <http://www.tunl.duke.edu/documents/public/electronics/Keithley/keithley-6514-electrometer-manual.pdf>`_ """ def onStatusChange(self, value, **kw): self._counting = (value == 1) def __init__(self, pvName, mnemonic, timeBased=False): """ **Constructor** To use this Keithley Class you must pass the PV (Process Variable) prefix. .. Note:: e.g.: SXS:K6514 Examples -------- >>> from KeithleyClass import * >>> name = Keithley('SOL:K6514', 'k1') """ StandardDevice.__init__(self, mnemonic) self.pvName = pvName self.timeBased = timeBased self.keithley = Device( pvName + ':', ('GetMed', 'SetMed', 'GetMedRank', 'SetMedRank', 'GetAver', 'SetAver', 'GetAverCoun', 'SetAverCoun', 'GetNPLC', 'SetNPLC', 'GetAutoZero', 'SetAutoZero', 'GetZeroCheck', 'SetZeroCheck', 'GetAverTCon', 'SetAverTCon', 'GetCurrRange', 'SetCurrRange', 'GetZeroCor', 'SetZeroCor', 'GetAutoCurrRange', 'SetAutoCurrRange' 'Count', 'ContinuesMode', 'CNT', 'OneMeasure')) self.pvMeasure = PV(pvName + ':' + 'Measure', auto_monitor=False) self._counting = self.isCountingPV() self.keithley.add_callback('CNT', self.onStatusChange) def isCountingPV(self): return (self.keithley.get('CNT') == 1) def isCounting(self): return self._counting def wait(self): while (self.isCounting()): ca.poll(0.00001) def getTriggerReading(self): """ Trigger and return reading(s). Returns ------- Value: Float, e.g.: -6.0173430000000003e-16. Examples -------- >>> name.getTriggerReading() >>> -1.0221850000000001e-15 """ return self.pvMeasure.get(use_monitor=False) #return self.keithley.get('Measure') def getCountNumberReading(self): """ Count the number of reading(s). Returns ------- Value: Integer, e.g.: 963. Examples -------- >>> name.CountNumberReading() >>> 161.0 """ return self.keithley.get('Count') def getStatusContinuesMode(self): """ Get the status of Continues Mode (enable/disable). Default: enable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getStatusContinuesMode() >>> True """ return bool(self.keithley.get('ContinuesMode')) def setStatusContinuesMode(self, cmode): """ Set enable/disable to continues mode. Let this enable if you want a continuing measuring. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.setStatusContinuesMode(0) """ if (cmode != 0 and cmode != 1): raise ValueError('Invalid number - It should be 0 or 1') self.keithley.put('ContinuesMode', cmode) def getAutoZeroing(self): """ Get the status of Auto Zero (enable/disable). Default: enable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getAutoZeroing() >>> True """ return bool(self.keithley.get('GetAutoZero')) def setAutoZeroing(self, autozero): """ Set enable/disable for Auto Zero. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.setAutoZeroing(1) """ if (autozero != 0 and autozero != 1): raise ValueError('Invalid number - It should be 0 or 1') self.keithley.put('SetAutoZero', autozero) def getMedianFilter(self): """ Get the status of Median Filter (enable/disable). Default: enable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getMedianFilter() >>> True """ return bool(self.keithley.get('GetMed')) def setMedianFilter(self, med): """ Set enable/disable for Median Filter. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.setMedianFilter(1) """ if (med != 0 and med != 1): raise ValueError('Invalid number - It should be 0 or 1') self.keithley.put('SetMed', med) def getMedianRank(self): """ Get the value of Median Rank, this number of sample readings are between 1 to 5. Default: 5. Returns ------- Value: Integer, i.e.: 1 to 5. Examples -------- >>> name.getMedianRank() >>> 5.0 """ return self.keithley.get('GetMedRank') def setMedianRank(self, medrank): """ Set the number of sample readings used for the median calculation. Parameters ---------- Value: Integer, i.e.: 1 to 5. Examples -------- >>> name.setMedianRank(3) """ if (medrank < 1 or medrank > 5): raise ValueError('Invalid number - It should be 1 to 5') self.keithley.put('SetMedRank', medrank) def getAverageDigitalFilter(self): """ Get the status of Digital Filter (enable/disable). Default: enable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getAverageDigitalFilter() >>> True """ return bool(self.keithley.get('GetAver')) def setAverageDigitalFilter(self, aver): """ Set enable/disable for Digital Filter. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.setAverageDigitalFilter(1) """ if (aver != 0 and aver != 1): raise ValueError('Invalid number - It should be 0 or 1') self.keithley.put('SetAver', aver) def getAverageCount(self): """ Get the number of filter count. Default: 10. Returns ------- Value: Integer, i.e.: 2 to 100. Examples -------- >>> name.getAverageCount() >>> 10.0 """ return self.keithley.get('GetAverCoun') def setAverageCount(self, avercoun): """ Set the number of filter count. Parameters ---------- Value: Integer, i.e.: 2 to 100. Examples -------- >>> name.setAverageCount(80) """ if (avercoun < 2 or avercoun > 100): raise ValueError('Invalid number - It should be 2 to 100') self.keithley.put('SetAverCoun', avercoun) def getIntegrationTime(self): """ Get the number of integration rate. Default: 1. Returns ------- Value: Float, i.e.: 0.01 to 10 (PLCs). Where 1 PLC for 60Hz is 16.67msec (1/60). Examples -------- >>> name.getIntegrationTime() >>> 1.0 """ return self.keithley.get('GetNPLC') def setIntegrationTime(self, nplc): """ Set the number of integration rate. Parameters ---------- Value: Float, i.e.: 0.01 to 10 (PLCs). Where 1 PLC for 60Hz is 16.67msec (1/60). Examples -------- >>> name.setIntegrationTime(0.01) """ if (nplc < 0.01 or nplc > 10): raise ValueError('Invalid number - It should be 0.01 to 10') self.keithley.put('SetNPLC', nplc) def getAverageTControl(self): """ Get the filter control. Default: REP. Returns ------- Value: String, i.e.: REP or MOV. Examples -------- >>> name.getAverageTControl() >>> 'REP' """ return self.keithley.get('GetAverTCon') def setAverageTControl(self, tcon): """ Set the filter control. Parameters ---------- Value: String, i.e.: 'REP' or 'MOV', where REP means 'Repeat' and MOV means 'Moving'. Examples -------- >>> name.setAverageTControl('MOV') """ if (tcon != 'REP' and tcon != 'MOV'): raise ValueError('Invalid name - It should be REP or MOV') self.keithley.put('SetAverTCon', bytes(tcon, 'ascii')) def getZeroCheck(self): """ Get the status of Zero Check (enable/disable). Default: disable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getZeroCheck() >>> False """ return bool(self.keithley.get('GetZeroCheck')) def setZeroCheck(self, check): """ Set enable/disable for Zero Check. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Returns ------- One value (1). Examples -------- >>> name.setZeroCheck(1) >>> 1 """ if (check != 0 and check != 1): raise ValueError('Invalid number - It should be 0 or 1') return self.keithley.put('SetZeroCheck', check) def getZeroCorrect(self): """ Get the status of Zero Correct (enable/disable). Default: disable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getZeroCorrect() >>> False """ return bool(self.keithley.get('GetZeroCor')) def setZeroCorrect(self, cor): """ Set enable/disable for Zero Correct. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Returns ------- One value (1). Examples -------- >>> name.setZeroCorrect(1) >>> 1 """ if (cor != 0 and cor != 1): raise ValueError('Invalid number - It should be 0 or 1') return self.keithley.put('SetZeroCor', cor) def getAutoCurrentRange(self): """ Get the status of Auto Current Range (enable/disable). Default: enable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getAutoCurrentRange() >>> True """ return bool(self.keithley.get('GetAutoCurrRange')) def setAutoCurrentRange(self, autorange): """ Set enable/disable for Auto Current Range. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Returns ------- One value (1). Examples -------- >>> name.setAutoCurrentRange(1) >>> 1 """ if (autorange != 0 and autorange != 1): raise ValueError('Invalid number - It should be 0 or 1') return self.keithley.put('SetAutoCurrRange', autorange) def getCurrentRange(self): """ Get the value of range. Default: Auto range. Returns ------- Value: Integer, i.e.: 0 (Undefined ZERO), 1 (Indefined UM), 2 (20 mA), 3 (2 mA), 4 (200 uA), 5 (20 uA), 6 (2 uA), 7 (200 nA), 8 (20 nA), 9 (2 nA), 10 (200 pA), 11 (20 pA). Examples -------- >>> name.getCurrentRange() >>> 11 """ return self.keithley.get('GetCurrRange') def setCurrentRange(self, curange): """ Set the range. Parameters ---------- Value: Integer, i.e.: 0 (Undefined ZERO), 1 (Indefined UM), 2 (20 mA), 3 (2 mA), 4 (200 uA), 5 (20 uA), 6 (2 uA), 7 (200 nA), 8 (20 nA), 9 (2 nA), 10 (200 pA), 11 (20 pA). Examples -------- >>> name.setCurrentRange(5) """ if (curange < 0 or curange > 11): raise ValueError('Invalid number - It should be 0 to 11') self.keithley.put('SetCurrRange', curange) def getValue(self, **kwargs): """ Get the current value of a countable device. Parameters ---------- kwargs : value Where needed informations can be passed, e.g. select which channel must be read. Returns ------- out : value Returns the current value of the device. Type of the value depends on device settings. """ return self.getTriggerReading() def setCountTime(self, time): """ Method to set the count time of a Keithley device. .. note:: Whenever the median filter is active, changing the count time results in the filter being reset, so the first measurement will take additional time to collect new data for the filter. The extra time is proportional to the median filter rank. After the first measurement, the following measurements will have the correct integration time. .. note:: Unlike scalers, the count time is only an approximation. The requested integration time will be split into multiple parts, which includes the analog integration time (varying between approximatelly 10ms to 50ms), the digital integration time (that averages a set of 2 to 100 analog integrations), and other operations unrelated to integration, like auto zero calibration (triples the integration time) and calculation times. When calling this method, the digital average filter will be activated if it's not already and the filter type will be set to repeat. See also: :meth:`setIntegrationTime`, :meth:`setAverageCount` Parameters ---------- time : value The target count time to be set. The allowed time range is 100ms to 15s (limited by software). Returns ------- out : None """ if (not self.timeBased): return if time < 0.1 or time > 15: raise ValueError('Invalid integration time: %g' % time) # Keithley timing model: # ---------------------- # # Keithley fundamental delay is the analog integration delay, which is the # time it takes to measure the current using the measurement hardware. # The integration delay can be configured to values in the range between # 166,7µs to 166,7ms (or 200µs to 200ms in 50Hz electricity grids). # On top of the analog integration delay, two delays are significant: # the digital filter delay, which works as a digital integrator (when configured # in "repeating" mode) and the auto zero setting, which performs continuous # device recalibration. The digital filter works by taking multiple analog # measurements, then averaging the result, so it multiplies the delay by the # repeat count. The auto zero setting always triples the integration time. # So, the basic initial timing model for the Keithley device is the following: # # (1) time = Azero*Rcount*Atime # # Where time is the final count time, Azero is 2,97 when auto zero is enabled, # or 0,95 when auto zero is disabled, Rcount is the digital average repeat count and # Atime is the analog integration time. For example, with auto zero enabled, # integration time of 33,33ms and a repeat count of 10,0, the total count time is # 990ms. # # Empirical tests with equation (1) were done by trying analog integration times # around 33,33ms and choosing a suitable repeat count. The region around 33,33ms # was chosen by chance and because it's inside the recommended integration range # (16,7ms to 166,7ms). # # The calculated repeat count is rounded to an integer and the analog integration # time is corrected back. For example, given an integration time of 0,5 seconds, # we set 33,67ms (close to 33,33ms) and repeat count 5, as calculated below: # # time = Azero*Rcount*Atime # 0,5 = 2,97*Rcount*0,03333 # Rcount = 5,0505... # Rcount,rounded = 5 # time = Azero*Rcount,rounded*Atime # 0,5 = 2,97*5*Atime # Atime = 33,67ms # # Using the above procedure to compare the modeled time and the real Keithley time # resulted in a line with factor and displacement errors: # # (2) time = Azero*Rcount*Atime*f + d # # The variable f represents an error proportional to the integration time, # while d represents a fixed delay. For example, f could be due to hardware # delays while integrating and computation overhead to calculate the # digital average. The delay d is due to "warm up" and "clean up" procedures, # in particular, due to device to computer communication. With a serial port # configuration, the factors were found to be the following: # # (2') time = Azero*Rcount*Atime*f' + d' # (3) f' = 1,09256, d' = 0,0427154 # # The serial port communication is significant and happens before and after the # acquisition. It takes 20,83ms for sending and receiving a measurement using the # serial port (20 bytes/960 bytes/s). This value needs to be removed from the # measured delay, since it's not part of the integration time. The resulting # equation is accurate enough for usage as the timing model for Keithley: # # (4) time = Azero*Rcount*Atime*1,09256 + 0,021882 # # Equation (4) can then be reversed and solved for Rcount and Atime: # # (5) Rcount = (time-0.021882)/(Azero*Atime*1,09256) # (6) Atime = (time-0.021882)/(Rcount*Atime*1,09256) # # The algorithm implemented calculates (5) assuming initially Atime == 33,33ms, # then rounds Rcount to an integer, calculates (6) with the resulting Rcount and # if results are not within proper bounds, it iterates a second time. # # Note: it is known that the first and second measurements after changing the # count time takes longer than usual to return a measurement. The timing becomes # more precise starting from the third measurement. When the median filter is # active, the first measurement takes much longer, because the median filter # buffer is cleaned and filled again. azero = 2.97 if self.getAutoZeroing() else 0.95 f = 1.09256 d = 0.021882 # Analog integration time initially equal to 33,33ms atime = 2 / 60 # Repeat count must be between 2 and 100 rcount = int((time - d) / (azero * atime * f)) rcount = max(rcount, 2) rcount = min(rcount, 100) # Then, solve for integration time atime = (time - d) / (azero * rcount * f) # If integration time is out of range, fix it and iterate one more time if atime < 0.1 / 60 or atime > 10 / 60: atime = max(atime, 0.1 / 60) atime = min(atime, 10 / 60) rcount = int((time - d) / (azero * atime * f)) rcount = max(rcount, 2) rcount = min(rcount, 100) atime = (time - d) / (azero * rcount * f) atime = max(atime, 0.1 / 60) atime = min(atime, 10 / 60) changed = False # Integration time must be rounded to 2 digits or Keithley will crash nplc = round(atime * 60, 2) if nplc != self.getIntegrationTime(): self.setIntegrationTime(nplc) changed = True if rcount != self.getAverageCount(): self.setAverageCount(rcount) changed = True if not self.getAverageDigitalFilter(): self.setAverageDigitalFilter(1) changed = True if self.getAverageTControl() != 'REP': self.setAverageTControl('REP') changed = True if changed: ca.poll(0.05) def setPresetValue(self, channel, val): """ Abstract method to set the preset count of a countable target device. Parameters ---------- channel : `int` The monitor channel number val : `int` The preset value Returns ------- out : None """ pass def startCount(self): """ Abstract method trigger a count in a counter """ if (not self.getStatusContinuesMode()): self._counting = True self.keithley.put("OneMeasure", 1) pass def stopCount(self): """ Abstract method stop a count in a counter """ if (not self.getStatusContinuesMode()): self.keithley.put("OneMeasure", 0) pass def canMonitor(self): """ Abstract method to check if the device can or cannot be used as monitor. Returns ------- out : `bool` """ return False def canStopCount(self): """ Abstract method to check if the device can or cannot stop the count and return values. Returns ------- out : `bool` """ return True
class Motor(IScannable, StandardDevice): """ Class to control motor devices via EPICS. Examples -------- >>> from py4syn.epics.MotorClass import Motor >>> >>> def createMotor(pvName="", mne=""): ... ... new_motor = '' ... ... try: ... new_motor = Motor(pvName, mne) ... print "Motor " + pvName + " created with success!" ... except Exception,e: ... print "Error: ",e ... ... return new_motor """ def onStatusChange(self, value, **kw): self._moving = not value def __init__(self, pvName, mnemonic): """ **Constructor** See :class:`py4syn.epics.StandardDevice` Parameters ---------- pvName : `string` Motor's base naming of the PV (Process Variable) mnemonic : `string` Motor's mnemonic """ StandardDevice.__init__(self, mnemonic) self.pvName = pvName self.pvType = PV(pvName + ".RTYP", connection_timeout=3) if (self.pvType.status is None): raise Exception("Epics PV " + pvName + " seems to be offline or not reachable") if (self.pvType.get() != "motor"): raise Exception(pvName + " is not an Epics Motor") self.motor = Device( pvName + '.', ('RBV', 'VAL', 'DRBV', 'DVAL', 'RLV', 'RVAL', 'RRBV', 'STOP', 'MOVN', 'LLS', 'HLS', 'SSET', 'SUSE', 'SET', 'VELO', 'EGU', 'DMOV', 'STUP', 'DESC', 'BDST', 'HLM', 'LLM', 'DHLM', 'DLLM', 'VOF', 'FOF', 'OFF', 'DIR', 'LVIO', 'HOMF', 'HOMR')) self.motor.add_callback('DMOV', self.onStatusChange) self._moving = self.isMovingPV() self.motorDesc = self.getDescription() def __str__(self): return self.getMnemonic() + "(" + self.pvName + ")" def getDirection(self): """ Read the motor direction based on the `DIR` (User Direction) field of Motor Record Returns ------- `integer` .. note:: 0. Positive direction; 1. Negative direction. """ return self.motor.get('DIR') def isMovingPV(self): """ Check if a motor is moving or not from the PV Returns ------- `boolean` .. note:: - **True** -- Motor is moving; - **False** -- Motor is stopped. """ return (self.motor.get('DMOV') == 0) def isMoving(self): """ Check if a motor is moving or not based on the callback Returns ------- `boolean` .. note:: - **True** -- Motor is moving; - **False** -- Motor is stopped. """ return self._moving def isAtLowLimitSwitch(self): """ Check if a motor low limit switch is activated, based on the `LLS` (At Low Limit Switch) field of Motor Record Returns ------- `boolean` .. note:: - **True** -- Motor is at Low Limit; - **False** -- Motor is **NOT** at Low Limit. """ return self.motor.get('LLS') def isAtHighLimitSwitch(self): """ Check if a motor high limit switch is activated, based on the `HLS` (At High Limit Switch) field of Motor Record Returns ------- `boolean` .. note:: - **True** -- Motor is at High Limit; - **False** -- Motor is **NOT** at High Limit. """ return self.motor.get('HLS') def getDescription(self): """ Read the motor descrition based on the `DESC` field of Motor Record Returns ------- `string` """ return self.motor.get('DESC') def getHighLimitValue(self): """ Read the motor high limit based on the `HLM` (User High Limit) field of Motor Record Returns ------- `double` """ return self.motor.get('HLM') def getLowLimitValue(self): """ Read the motor low limit based on the `LLM` (User Low Limit) field of Motor Record Returns ------- `double` """ return self.motor.get('LLM') def getDialHighLimitValue(self): """ Read the motor dial high limit based on the `DHLM` (Dial High Limit) field of Motor Record Returns ------- `double` """ return self.motor.get('DHLM') def getDialLowLimitValue(self): """ Read the motor dial low limit based on the `DLLM` (Dial Low Limit) field of Motor Record Returns ------- `double` """ return self.motor.get('DLLM') def getBacklashDistanceValue(self): """ Read the motor backlash distance based on the `BDST` (Backlash Distance, `EGU`) field of Motor Record Returns ------- `double` """ return self.motor.get('BDST') def getVariableOffset(self): """ Read the motor variable offset based on the `VOF` (Variable Offset) field of Motor Record Returns ------- `integer` """ return self.motor.get('VOF') def getFreezeOffset(self): """ Read the motor freeze offset based on the `FOF` (Freeze Offset) field of Motor Record Returns ------- `integer` """ return self.motor.get('FOF') def getOffset(self): """ Read the motor offset based on the `OFF` (User Offset, `EGU`) field of Motor Record Returns ------- `string` """ return self.motor.get('OFF') def getRealPosition(self): """ Read the motor real position based on the `RBV` (User Readback Value) field of Motor Record Returns ------- `double` """ return self.motor.get('RBV') def getDialRealPosition(self): """ Read the motor DIAL real position based on the `DRBV` (Dial Readback Value) field of Motor Record Returns ------- `double` """ return self.motor.get('DRBV') def getDialPosition(self): """ Read the motor target DIAL position based on the `DVAL` (Dial Desired Value) field of Motor Record Returns ------- `double` """ return self.motor.get('DVAL') def getRawPosition(self): """ Read the motor RAW position based on the `RVAL` (Raw Desired Value) field of Motor Record Returns ------- `double` """ return self.motor.get('RVAL') def setRawPosition(self, position): """ Sets the motor RAW position based on the `RVAL` (Raw Desired Value) field of Motor Record Returns ------- `double` """ self._moving = True self.motor.put('RVAL', position) ca.poll(evt=0.05) def getRawRealPosition(self): """ Read the motor RAW real position based on the `RRBV` (Raw Readback Value) field of Motor Record Returns ------- `double` """ return self.motor.get('RRBV') def getPosition(self): """ Read the motor target position based on the `VAL` (User Desired Value) field of Motor Record Returns ------- `double` """ return self.motor.get('VAL') def getEGU(self): """ Read the motor engineering unit based on the `EGU` (Engineering Units) field of Motor Record Returns ------- `string` """ return self.motor.get('EGU') def getLVIO(self): """ Read the motor limit violation `LVIO` (Limit Violation) field of Motor Record Returns ------- `short` """ return self.motor.get('LVIO') def setEGU(self, unit): """ Set the motor engineering unit to the `EGU` (Engineering Units) field of Motor Record Parameters ---------- unit : `string` The desired engineering unit. .. note:: **Example:** "mm.", "deg." """ return self.motor.set('EGU', unit) def setHighLimitValue(self, val): """ Set the motor high limit based on the `HLM` (User High Limit) field of Motor Record Parameters ---------- val : `double` The desired value to set """ self.motor.put('HLM', val) def setLowLimitValue(self, val): """ Set the motor low limit based on the `LLM` (User Low Limit) field of Motor Record Parameters ---------- val : `double` The desired value to set """ self.motor.put('LLM', val) def setDialHighLimitValue(self, val): """ Set the motor dial high limit based on the `DHLM` (Dial High Limit) field of Motor Record Parameters ---------- val : `double` The desired value to set """ self.motor.put('DHLM', val) def setDialLowLimitValue(self, val): """ Set the motor dial low limit based on the `DLLM` (Dial Low Limit) field of Motor Record Parameters ---------- val : `double` The desired value to set """ self.motor.put('DLLM', val) def setSETMode(self): """ Put the motor in SET mode .. note:: Motor will **NOT** move until it is in in **USE mode** """ self.motor.put('SSET', 1, wait=True) def getSETMode(self): """ Checks if the motor is in SET mode .. note:: Motor will **NOT** move until it is in in **USE mode** """ return self.motor.PV('SET').get(use_monitor=False) == 1 def setUSEMode(self): """ Put the motor in **USE mode** """ self.motor.put('SUSE', 1, wait=True) def setVariableOffset(self, val): """ Set the motor variable offset based on the `VOF` (Variable Offset) field of Motor Record Parameters ---------- val : `integer` The desired value to set """ self.motor.put('VOF', val) def setFreezeOffset(self, val): """ Set the motor freeze offset based on the `FOF` (Freeze Offset) field of Motor Record Parameters ---------- val : `integer` The desired value to set """ self.motor.put('FOF', val) def setOffset(self, val): """ Set the motor offset based on the `OFF` (User Offset, `EGU`) field of Motor Record Parameters ---------- val : `double` The desired value to set """ self.motor.put('OFF', val) def setDialPosition(self, pos, waitComplete=False): """ Set the motor target DIAL position based on the `DVAL` (Dial Desired Value) field of Motor Record Parameters ---------- pos : `double` The desired position to set waitComplete : `boolean` (default is **False**) .. note:: If **True**, the function will wait until the movement finish to return, otherwise don't. """ if (self.getDialRealPosition() == pos): return self.motor.put('DVAL', pos) self._moving = True if (waitComplete): self.wait() def setAbsolutePosition(self, pos, waitComplete=False): """ Move the motor to an absolute position received by an input parameter Parameters ---------- pos : `double` The desired position to set waitComplete : `boolean` (default is **False**) .. note:: If **True**, the function will wait until the movement finish to return, otherwise don't. """ if (self.getRealPosition() == pos): return ret, msg = self.canPerformMovement(pos) if (not ret): raise Exception("Can't move motor " + self.motorDesc + " (" + self.pvName + ") to desired position: " + str(pos) + ", " + msg) self._moving = True self.motor.put('VAL', pos) ca.poll(evt=0.05) if (waitComplete): self.wait() def setRelativePosition(self, pos, waitComplete=False): """ Move the motor a distance, received by an input parameter, to a position relative to that current one Parameters ---------- pos : `double` The desired distance to move based on current position waitComplete : `boolean` (default is **False**) .. note: If **True**, the function will wait until the movement finish to return, otherwise don't. """ target = self.getRealPosition() + pos self.setAbsolutePosition(target, waitComplete=waitComplete) def getVelocity(self): """ Get the motor velocity based on the `VELO` (Velocity, EGU/s) field from Motor Record Returns ------- `double` """ return self.motor.get('VELO') def setVelocity(self, velo): """ Set the motor velocity up based on the `VELO` (Velocity, EGU/s) field from Motor Record Parameters ---------- velo : `double` The desired velocity to set """ self.motor.put('VELO', velo) def getAcceleration(self): """ Get the motor acceleration time based on the `ACCL` (Seconds to Velocity) field from Motor Record Returns ------- `double` """ return self.motor.get('ACCL') def setAcceleration(self, accl): """ Set the motor acceleration time based on the `ACCL` (Seconds to Velocity) field from Motor Record Parameters ---------- accl : `double` The desired acceleration to set """ self.motor.put('ACCL', accl) def setUpdateRequest(self, val): """ Set the motor update request flag based on the `STUP` (Status Update Request) field from Motor Record Parameters ---------- val : `integer` The desired value to set for the flag """ self.motor.put('STUP', val) def validateLimits(self): """ Verify if motor is in a valid position. In the case it has been reached the HIGH or LOW limit switch, an exception will be raised. """ message = "" if (self.isAtHighLimitSwitch()): message = 'Motor: ' + self.motorDesc + ' (' + self.pvName + ') reached the HIGH limit switch.' elif (self.isAtLowLimitSwitch()): message = 'Motor: ' + self.motorDesc + ' (' + self.pvName + ') reached the LOW limit switch.' if (message != ""): raise Exception(message) def canPerformMovement(self, target): """ Check if a movement to a given position is possible using the limit values and backlash distance Returns ------- `boolean` .. note:: - **True** -- Motor CAN perform the desired movement; - **False** -- Motor **CANNOT** perform the desired movement. """ if self.getSETMode(): return True, "" # Moving to high limit if (target > self.getRealPosition()): if (self.isAtHighLimitSwitch()): return False, "Motor at hardware high limit switch" elif target > self.getHighLimitValue(): return False, "Target beyond value for software high limit." # Moving to low limit else: if (self.isAtLowLimitSwitch()): return False, "Motor at hardware low limit switch" elif target < self.getLowLimitValue(): return False, "Target beyond value for software low limit." return True, "" def canPerformMovementCalc(self, target): """ Check if a movement to a given position is possible using the limit values and backlash distance calculating the values Returns ------- `boolean` .. note:: - **True** -- Motor CAN perform the desired movement; - **False** -- Motor **CANNOT** perform the desired movement. """ if self.getSETMode(): return True if self.getHighLimitValue() == 0.0 and self.getLowLimitValue() == 0.0: return True backlashCalc = self.calculateBacklash(target) if (self.getDirection() == 0): if (backlashCalc > 0): vFinal = target - backlashCalc else: vFinal = target + backlashCalc else: if (backlashCalc > 0): vFinal = target + backlashCalc else: vFinal = target - backlashCalc if (target > self.getRealPosition()): if (self.isAtHighLimitSwitch()): return False if vFinal <= self.getHighLimitValue(): return True # Moving to low limit else: if (self.isAtLowLimitSwitch()): return False if vFinal >= self.getLowLimitValue(): return True return False def calculateBacklash(self, target): """ Calculates the backlash distance of a given motor Returns ------- `double` """ # Positive Movement if (self.getDirection() == 0): if (self.getBacklashDistanceValue() > 0 and target < self.getRealPosition()) or ( self.getBacklashDistanceValue() < 0 and target > self.getRealPosition()): return self.getBacklashDistanceValue() else: if (self.getBacklashDistanceValue() > 0 and target > self.getRealPosition()) or ( self.getBacklashDistanceValue() < 0 and target < self.getRealPosition()): return self.getBacklashDistanceValue() return 0 def stop(self): """ Stop the motor """ self.motor.put('STOP', 1) def wait(self): """ Wait until the motor movement finishes """ while (self._moving): ca.poll(evt=0.01) def getValue(self): """ Get the current position of the motor. See :class:`py4syn.epics.IScannable` Returns ------- `double` Read the current value (Motor Real Position) """ return self.getRealPosition() def setValue(self, v): """ Set the desired motor position. See :class:`py4syn.epics.IScannable` Parameters ---------- v : `double` The desired value (Absolute Position) to set """ self.setAbsolutePosition(v) def homeForward(self): """ Move the motor until it hits the forward limit switch or the software limit. """ self._moving = True self.motor.put('HOMF', 1) def homeReverse(self): """ Move the motor until it hits the reverse limit switch or the software limit. """ self._moving = True self.motor.put('HOMR', 1)
class LinkamCI94(StandardDevice, IScannable): """ Class to control Linkam CI94 temperature controllers via EPICS. Examples -------- >>> from py4syn.epics.LinkamCI94Class import LinkamCI94 >>> >>> def showTemperature(pv='', name=''): ... ci94 = LinkamCI94(pv, name) ... print('Temperature is: %d' % ci94.getValue()) ... >>> def fastRaiseTemperature(ci94, amount, rate=30): ... ci94.setRate(rate) ... ci94.setValue(ci94.getValue() + amount) ... >>> def complexRamp(ci94): ... ci94.setPumpSpeed(-1) ... ci94.setRate(10) ... ci94.setValue(200) ... ci94.wait() ... ci94.setRate(2) ... ci94.setValue(220) ... ci94.wait() ... sleep(500) ... ci94.setRate(5) ... ci94.setValue(100) ... ci94.wait() ... ci94.stop() ... >>> import py4syn >>> from py4syn.epics.ScalerClass import Scaler >>> from py4syn.utils.counter import createCounter >>> from py4syn.utils.scan import scan >>> >>> def temperatureScan(start, end, rate, pv='', counter='', channel=2): ... ci94 = LinkamCI94(pv, 'ci94') ... py4syn.mtrDB['ci94'] = ci94 ... c = Scaler(counter, channel, 'simcountable') ... createCounter('counter', c, channel) ... ci94.setRate(rate) ... scan('ci94', start, end, 10, 1) ... ci94.stop() ... """ STATUS_STOPPED = 0 PUMP_AUTOMATIC = 0 PUMP_MANUAL = 1 def __init__(self, pvName, mnemonic): """ **Constructor** See :class:`py4syn.epics.StandardDevice` Parameters ---------- pvName : `string` Power supply base naming of the PV (Process Variable) mnemonic : `string` Temperature controller mnemonic """ super().__init__(mnemonic) self.pvName = pvName self.linkam = Device(pvName + ':', ['setRate', 'setLimit', 'pending', 'temp', 'stop', 'setSpeed', 'pumpMode', 'status', 'start']) self.done = Event() self.newTemperature = Event() self.pending = bool(self.linkam.get('pending')) self.setRate(5) self.linkam.add_callback('pending', self.onPendingChange) self.linkam.add_callback('temp', self.onTemperatureChange) def __str__(self): return '%s (%s)' % (self.getMnemonic(), self.pvName) def isRunning(self): """ Returns true if the controller is in program mode. Whenever it is program mode, it is following a target temperature. Returns ------- `bool` """ v = self.linkam.get('status') return v != self.STATUS_STOPPED def getValue(self): """ Returns the current measured temperature. Returns ------- `float` """ return self.linkam.get('temp') def getRealPosition(self): """ Returns the same as :meth:`getValue`. See: :meth:`getValue` Returns ------- `float` """ return self.getValue() def onPendingChange(self, value, **kwargs): """ Helper callback that tracks when the IOC finished changing to a requested temperature. """ self.pending = bool(value) if not self.pending: self.done.set() def onTemperatureChange(self, **kwargs): """ Helper callback that indicates when the measured temperature changed. """ self.newTemperature.set() def setRate(self, r): """ Sets the ramp speed in degrees per minutes for use with :meth:`setValue`. See: :meth:`setValue` Parameters ---------- r : `float` Ramp speed in °C/min """ self.linkam.put('setRate', r) def setVelocity(self, velo): """ Same as :meth:`setRate`. See: :meth:`setRate` Parameters ---------- r : `float` Ramp speed in °C/min """ self.setRate(velo) def setValue(self, v): """ Changes the temperature to a new value. The speed that the new temperature is reached is set with :meth:`setRate`. The default rate is 5 °C/minute. See: :meth:`setRate` Parameters ---------- v : `float` The target temperature in °C """ self.done.clear() self.pending = True self.requestedValue = v self.linkam.put('setLimit', v) if not self.isRunning(): self.run() def wait(self): """ Blocks until the requested temperature is achieved. """ if not self.pending: return # Waiting is done in two steps. First step waits until the IOC deasserts # the pending flag to indicate a complete operation. Second step waits util the # measured temperature reaches the requested temperature. ca.flush_io() self.done.wait() self.newTemperature.clear() timeout = Timer(7) while self.getValue() != self.requestedValue and timeout.check(): self.newTemperature.wait(1) self.newTemperature.clear() def getLowLimitValue(self): """ Returns the controller low limit temperature. Returns ------- `float` """ return -196 def getHighLimitValue(self): """ Returns the controller high limit temperature. Returns ------- `float` """ return 1500 def run(self): """ Starts or resumes executing the current temperature program. """ self.linkam.put('start', 1) def stop(self): """ Stops executing the current temperature program, stops the nitrogen pump and puts the device in idle state. In the idle state, the device will not try to set a target temperature. """ self.setPumpSpeed(0) self.linkam.put('stop', 1) def setPumpSpeed(self, speed): """ Changes the nitrogen pump speed, or enables automatic pump speed control. .. note:: The Linkam front panel only has 5 LEDs to indicate speed, but internally it supports 30 different speed levels. Parameters ---------- speed : `int` The requested pump speed, ranging from 0 (pump off) to 30 (pump top speed), or -1 to enable automatic pump control. """ if speed < -1 or speed > 30: raise ValueError('Invalid speed') if speed == -1: self.linkam.put('pumpMode', self.PUMP_AUTOMATIC) return self.linkam.put('pumpMode', self.PUMP_MANUAL, wait=True) self.linkam.put('setSpeed', speed)
class Keithley6485(Keithley6514): """ Python class to help configuration and control the Keithley 6514 Electrometer. Keithley is an electrical instrument for measuring electric charge or electrical potential difference. This instrument is capable of measuring extremely low currents. E.g.: pico (10e-12), i.e.: 0,000 000 000 001. For more information, please, refer to: `Model 6514 System Electrometer Instruction Manual <http://www.tunl.duke.edu/documents/public/electronics/Keithley/keithley-6514-electrometer-manual.pdf>`_ """ def __init__(self, pvName, mnemonic, timeBased=False): """ **Constructor** To use this Keithley Class you must pass the PV (Process Variable) prefix. .. Note:: e.g.: SXS:K6514 Examples -------- >>> from KeithleyClass import * >>> name = Keithley('SOL:K6514', 'k1') """ StandardDevice.__init__(self, mnemonic) self.pvName = pvName self.timeBased = timeBased self.keithley = Device( pvName + ":", ( "GetMed", "SetMed", "GetMedRank", "SetMedRank", "GetAver", "SetAver", "GetAverCoun", "SetAverCoun", "GetNPLC", "SetNPLC", "GetAutoZero", "SetAutoZero", "GetZeroCheck", "SetZeroCheck", "GetAverTCon", "SetAverTCon", "GetRange", "SetRange", "GetZeroCor", "SetZeroCor", "GetAutoCurrRange", "SetAutoCurrRange" "Count", "ContinuesMode", "CNT", "OneMeasure", ), ) self.pvMeasure = PV(pvName + ":" + "Measure", auto_monitor=False) self._counting = self.isCountingPV() self.keithley.add_callback("CNT", self.onStatusChange) def getCurrentRange(self): """ Get the value of range. Default: Auto range. Returns ------- Value: Integer, i.e.: 0 (Undefined ZERO), 1 (Indefined UM), 2 (20 mA), 3 (2 mA), 4 (200 uA), 5 (20 uA), 6 (2 uA), 7 (200 nA), 8 (20 nA), 9 (2 nA), 10 (200 pA), 11 (20 pA). Examples -------- >>> name.getCurrentRange() >>> 11 """ return self.keithley.get("GetRange") def setCurrentRange(self, curange): """ Set the range. Parameters ---------- Value: Integer, i.e.: 0 (Undefined ZERO), 1 (Indefined UM), 2 (20 mA), 3 (2 mA), 4 (200 uA), 5 (20 uA), 6 (2 uA), 7 (200 nA), 8 (20 nA), 9 (2 nA), 10 (200 pA), 11 (20 pA). Examples -------- >>> name.setCurrentRange(5) """ if curange < 0 or curange > 11: raise ValueError("Invalid number - It should be 0 to 11") self.keithley.put("SetRange", curange)
class KepcoBOP(IScannable, StandardDevice): """ Class to control Kepco BOP GL power supplies via EPICS. Examples -------- >>> from py4syn.epics.KepcoBOPClass import KepcoBOP >>> >>> def configurePower(pv="", name="", voltage=5.0, currentLimit=1.0): ... bop = KepcoBOP(pv, name) ... bop.reset() ... bop.setCurrentLimits(currentLimit, currentLimit) ... bop.setVoltage(voltage) ... return bop ... >>> def smoothVoltageTransition(bop, initial=0.0, final=12.0, duration=2.0): ... bop.setRampWaveform(duration, final-initial, (initial+final)/2) ... bop.waveformStart() ... bop.waveformWait() ... >>> def noiseCurrent(bop): ... bop.reset() ... bop.setMode(KepcoBOP.MODE_CURRENT) ... bop.setVoltageLimits(20, 20) ... points = [random.uniform(-5, 5) for i in range(100)] ... bop.clearWaveform() ... bop.addWaveformPoints(points, [0.025]) ... bop.waveformStart() ... """ MODE_VOLTAGE = 'VOLTAGE' MODE_CURRENT = 'CURRENT' MAX_POINTS_SINGLE_DWELL = 5900 MAX_POINTS_FEW_DWELLS = 3933 MAX_POINTS_MANY_DWELLS = 2950 FEW_DWELLS_THRESHOLD = 126 MAX_POINTS_PER_ADD = 21 WAVEFORM_RUNNING_FLAG = 16384 MAX_VOLTAGE = 50 MAX_CURRENT = 20 MIN_DWELL = 0.000093 MAX_DWELL = 0.034 RANGE = ['GET', 'GET.PROC', 'SET', 'SET:LIMIT:POSITIVE', 'SET:LIMIT:NEGATIVE', 'SET:PROTECTION:POSITIVE', 'SET:PROTECTION:NEGATIVE', 'GET:LIMIT:POSITIVE', 'GET:LIMIT:POSITIVE.PROC', 'GET:LIMIT:NEGATIVE', 'GET:LIMIT:NEGATIVE.PROC', 'GET:PROTECTION:POSITIVE', 'GET:PROTECTION:POSITIVE.PROC', 'GET:PROTECTION:NEGATIVE', 'GET:PROTECTION:NEGATIVE.PROC'] PROGRAM = ['WAVEFORM:TYPE', 'WAVEFORM:PERIOD', 'WAVEFORM:AMPLITUDE', 'WAVEFORM:OFFSET', 'REPEAT', 'CLEAR', 'MARK:REPEAT'] PROGRAM_SUB = ['ADD', 'WAVEFORM:ADD:2ARGUMENTS', 'WAVEFORM:ADD:3ARGUMENTS', 'WAVEFORM:SET:ANGLE', 'WAVEFORM:START:ANGLE', 'WAVEFORM:STOP:ANGLE', 'START', 'STOP', 'ABORT', 'POINTS', 'POINTS.PROC'] WAVEFORM_PARAM1_LIMITS = { 'SQUARE': (0.02, 1000), 'RAMP+': (0.02, 532), 'RAMP-': (0.02, 532), 'SINE': (0.01, 443), 'LEVEL': (0.0005, 5), } def __init__(self, pvName, mnemonic): """ **Constructor** See :class:`py4syn.epics.StandardDevice` Parameters ---------- pvName : `string` Power supply base naming of the PV (Process Variable) mnemonic : `string` Power supply mnemonic """ super().__init__(mnemonic) self.pvName = pvName self.voltage = Device(pvName + ':VOLTAGE:', self.RANGE) self.current = Device(pvName + ':CURRENT:', self.RANGE) self.program = Device(pvName + ':PROGRAM:', self.PROGRAM) self.programVoltage = Device(pvName + ':PROGRAM:VOLTAGE:', self.PROGRAM_SUB) self.programCurrent = Device(pvName + ':PROGRAM:CURRENT:', self.PROGRAM_SUB) self.resetPV = PV(pvName + ':RESET') self.mode = Device(pvName + ':MODE:', ['SET', 'GET', 'GET.PROC']) self.operationFlag = Device(pvName + ':', ['GET:OPERATION:FLAG', 'GET:OPERATION:FLAG.PROC']) self.timePV = PV(pvName + ':PROGRAM:TIME:ADD') self.error = Device(pvName + ':', ['ERROR', 'ERROR.PROC', 'ERROR:TEXT']) self.defaults() # Operation mode (voltage x current) is cached, so get it immediatelly self.procAndGet(self.mode, 'GET') def procAndGet(self, device, pv): """ Helper method to synchronously execute a query in the device. """ device.put(pv + '.PROC', 0, wait=True) return device.PV(pv).get(use_monitor=False) def getError(self): """ Helper method to pop the last error from the device error queue. """ error = self.procAndGet(self.error, 'ERROR') text = self.error.PV('ERROR:TEXT').get(use_monitor=False) return error, text def checkError(self): """ Helper method to raise an exception if the device reports an error. """ error, text = self.getError() if error != 0: raise RuntimeError('Device returned error: %d, %s' % (error, text)) def defaults(self): """ Helper method to reset internal data. """ self.programPoints = 0 self.programTimes = [] self.blockStopCommand = False self.oneShotTime = 0 def setVoltage(self, voltage): """ Sets the voltage value. This method can only be used when in voltage mode. The voltage values must be within the power supply acceptable range and also within the configured limit values. See also: :meth:`setMode`, :meth:`setVoltageLimits` Parameters ---------- voltage : `float` The desired voltage value """ if self.cachedMode() != self.MODE_VOLTAGE: raise RuntimeError('Not in voltage mode') if abs(voltage) > self.MAX_VOLTAGE*1.01: raise ValueError('Voltage out of range: %g' % voltage) self.voltage.put('SET', voltage, wait=True) def setCurrent(self, current): """ Sets the current value. This method can only be used when in current mode. The current values must be within the power supply acceptable range and also within the configured limit values. See also: :meth:`setMode`, :meth:`setCurrentLimits` Parameters ---------- current : `float` The desired current value """ if self.cachedMode() != self.MODE_CURRENT: raise RuntimeError('Not in current mode') if abs(current) > self.MAX_CURRENT*1.01: raise ValueError('Current out of range: %g' % current) self.current.put('SET', current, wait=True) def getVoltage(self): """ Measures the voltage value. The measured value that is read back is known to have an error (less than 1%) and a delay (up to 320ms). Returns ------- `float` """ return self.procAndGet(self.voltage, 'GET') def getCurrent(self): """ Measures the current value. The measured value that is read back is known to have an error (less than 1%) and a delay (up to 320ms). Returns ------- `float` """ return self.procAndGet(self.current, 'GET') def setMode(self, mode): """ Changes the operating mode. Supported modes are voltage mode and current mode. In the voltage mode, the device tries to set a specific voltage, while staying within the current protection limits. In current mode, the device tries to set a specific current, while staying within the voltage protection limits. See also: :meth:`setCurrentLimits`, :meth:`setVoltageLimits` Parameters ---------- mode : {KepcoBOP.MODE_CURRENT, KepcoBOP.MODE_VOLTAGE} The desired mode """ self.mode.put('SET', mode, wait=True) # GET is used as the cached mode, so it needs to be updated too self.procAndGet(self.mode, 'GET') def cachedMode(self): """ Helper method to return cached operating mode """ return self.MODE_VOLTAGE if self.mode.get('GET') == 0 else self.MODE_CURRENT def setLimits(self, device, mode, negative=None, positive=None, maximum=1e100): """ Helper method that implements :meth:`setVoltageLimits` and :meth:`setCurrentLimits` """ pv = 'LIMIT' if self.cachedMode() == mode else 'PROTECTION' if not negative is None: if negative < 0: raise ValueError('Value must be absolute: %g' % negative) if negative > maximum: raise ValueError('Value out of range: %g (max: %g)' % (negative, maximum)) device.put('SET:%s:NEGATIVE' % pv, negative, wait=True) if not positive is None: if positive < 0: raise ValueError('Value must be absolute: %g' % positive) if positive > maximum: raise ValueError('Value out of range: %g (max: %g)' % (positive, maximum)) device.put('SET:%s:POSITIVE' % pv, positive, wait=True) def setVoltageLimits(self, negative=None, positive=None): """ Sets the negative and positive voltage limits allowed for operation. The specific limit type that is set depends on the operating mode. When in voltage mode, the limit set is a main channel limit: it defines the limits of the voltages that can be programmed by the user. When in current mode, the limit is a protection limit: it defines the voltage limits that the load may impose because of the requested current. When changing the operating modes, the set limits no longer apply: they must be set again for the new mode. See also: :meth:`setMode` Parameters ---------- negative : `float` The absolute value of the negative limit positive : `float` The absolute value of the positive limit """ self.setLimits(self.voltage, self.MODE_VOLTAGE, negative, positive, self.MAX_VOLTAGE) def setCurrentLimits(self, negative=None, positive=None): """ Sets the negative and positive current limits allowed for operation. The specific limit type that is set depends on the operating mode. When in current mode, the limit set is a main channel limit: it defines the limits of the current that can be programmed by the user. When in voltage mode, the limit is a protection limit: it defines the current limits that the load may impose because of the requested voltage. When changing the operating modes, the set limits no longer apply: they must be set again for the new mode. See also: :meth:`setMode` Parameters ---------- negative : `float` The absolute value of the negative limit positive : `float` The absolute value of the positive limit """ self.setLimits(self.current, self.MODE_CURRENT, negative, positive, self.MAX_CURRENT) def getLimits(self, device, mode): """ Helper method that implements :meth:`getVoltageLimits` and :meth: `getCurrentLimits` """ pv = 'LIMIT' if self.cachedMode() == mode else 'PROTECTION' negative = self.procAndGet(device, 'GET:%s:NEGATIVE' % pv) positive = self.procAndGet(device, 'GET:%s:POSITIVE' % pv) return negative, positive def getVoltageLimits(self): """ Gets the negative and positive voltage limits allowed for operation. The specific limit type that is read depends on the operating mode. When in voltage mode, the limit set is a main channel limit: it defines the limits of the voltages that can be programmed by the user. When in current mode, the limit is a protection limit: it defines the voltage limits that the load may impose because of the requested current. When changing the operating modes, the set limits no longer apply: they are different for the new mode. See also: :meth:`setMode` Returns ------- negative : `float` The absolute value of the negative limit positive : `float` The absolute value of the positive limit """ return self.getLimits(self.voltage, self.MODE_VOLTAGE) def getCurrentLimits(self): """ Gets the negative and positive current limits allowed for operation. The specific limit type that is read depends on the operating mode. When in current mode, the limit set is a main channel limit: it defines the limits of the current that can be programmed by the user. When in voltage mode, the limit is a protection limit: it defines the current limits that the load may impose because of the requested voltage. When changing the operating modes, the set limits no longer apply: they are different for the new mode. See also: :meth:`setMode` Returns ------- negative : `float` The absolute value of the negative limit positive : `float` The absolute value of the positive limit """ return self.getLimits(self.current, self.MODE_CURRENT) def reset(self): """ Resets the device to a known state. Possible reset states may vary with the device configuration, but generally will be a zero value output (either voltage or current) with low protection limits. The device error queue will be cleared. """ self.resetPV.put(0, wait=True) self.defaults() self.procAndGet(self.mode, 'GET') def clearWaveform(self): """ Clears the programmed waveform data. This is required when building a new waveform program. Waveform data can only be cleared while the program is not running. """ self.program.put('CLEAR', 0, wait=True) self.checkError() self.defaults() def getProgramLength(self): """ Helper method that returns the number of points in current waveform program. """ if self.cachedMode() == self.MODE_VOLTAGE: device = self.programVoltage else: device = self.programCurrent p = self.procAndGet(device, 'POINTS') self.checkError() return p def addWaveformPoints(self, points, times): """ Adds a set of points to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. It's the most flexible way, allowing arbitrary waveforms, but it's also the slowest one (a 10 second waveform may take at least 4 seconds just to upload the program). This method adds more points to the current waveform program. It does not overwrite the existing program. Adding points does not execute the program. The method :meth:`waveformStart` must be called. See also: :meth:`setWaveformPoints`, :meth:`addSineWaveform`, :meth:`addTriangleWaveform`, :meth:`addRampWaveform`, :meth:`addSquareWaveform`, :meth:`addLevelWaveform`, :meth:`waveformStart` .. note:: When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes. Parameters ---------- points : `array of floats` The array of points to be added to the program. The total number of allowed points may vary, depending on the times array. When the times array has exactly one element, the maximum number of points is 5900. When the times array has at most 126 distinct values, the maximum number of points is 3933. When the times array has more than 126 distinct values, the maximum number of points is 2950. times : `array of floats` The dwell times for each point. Either there must be one time entry for each point, or the array of times must contain exactly one element, which sets the time for all points. The allowed time range is [93e-6, 34e-3] (93µs to 34ms). """ x = min(times) if x < self.MIN_DWELL: raise ValueError('Minimum time out of range: %g (min: %g)' % (x, self.MIN_DWELL)) x = max(times) if x > self.MAX_DWELL: raise ValueError('Maximum time out of range: %g (max: %g)' % (x, self.MAX_DWELL)) p = self.programPoints + len(points) t = self.programTimes + times distinct = len(set(t)) if distinct > self.FEW_DWELLS_THRESHOLD: maxPoints = self.MAX_POINTS_MANY_DWELLS elif distinct > 1: maxPoints = self.MAX_POINTS_FEW_DWELLS else: maxPoints = self.MAX_POINTS_SINGLE_DWELL if p > maxPoints: raise ValueError('Requested waveform too large: %u (maximum is: %u)' % (p, maxPoints)) if self.cachedMode() == self.MODE_VOLTAGE: device = self.programVoltage else: device = self.programCurrent for i in range(0, len(points), self.MAX_POINTS_PER_ADD): l = array(points[i:i+self.MAX_POINTS_PER_ADD]) device.put('ADD', l, wait=True) for i in range(0, len(times), self.MAX_POINTS_PER_ADD): l = array(times[i:i+self.MAX_POINTS_PER_ADD]) self.timePV.put(l, wait=True) self.programPoints = p self.programTimes = t def setWaveformPoints(self, points, times): """ A shortcut to clearing the waveform program, adding waveform points and setting the repeat count to 1. See also: :meth:`clearWaveform`, :meth:`addWaveformPoints`, :meth:`setWaveformRepeat` Parameters ---------- points : `array of floats` Parameter passed to :meth:`addWaveformPoints` times : `array of floats` Parameter passed to :meth:`addWaveformPoints` """ self.clearWaveform() self.addWaveformPoints(points, times) self.setWaveformRepeat(1) self.checkError() def setWaveformAngle(self, start=0, stop=360): """ Helper method that configures start and stop angles for sine and triangle waveforms. """ if start < 0 or start > 359.99: raise ValueError('Start angle must be between 0 and 359.99') if stop < 0.01 or stop > 360: raise ValueError('Stop angle must be between 0.01 and 360') if self.cachedMode() == self.MODE_VOLTAGE: device = self.programVoltage else: device = self.programCurrent if device.get('WAVEFORM:START:ANGLE') != start: device.put('WAVEFORM:START:ANGLE', start, wait=True) if device.get('WAVEFORM:STOP:ANGLE') != stop: device.put('WAVEFORM:STOP:ANGLE', stop, wait=True) device.put('WAVEFORM:SET:ANGLE', 0, wait=True) self.checkError() def addWaveform(self, type, param1, param2, param3=None): """ Helper method that implements adding waveform segments. """ if type not in self.WAVEFORM_PARAM1_LIMITS: raise ValueError('Invalid waveform type: %s' % type) x, y = self.WAVEFORM_PARAM1_LIMITS[type] if param1 < x or param1 > y: raise ValueError('Frequency or period parameter out of range: %g ' '(interval: [%g, %g])' % (param1, x, y)) if self.cachedMode() == self.MODE_VOLTAGE: device = self.programVoltage maxValue = self.MAX_VOLTAGE else: device = self.programCurrent maxValue = self.MAX_CURRENT if param2 < 0 or param2 > 2*maxValue: raise ValueError('Amplitude out of range: %g (range: [%g, %g])' % (param2, 0, 2*maxValue)) if param3 is not None and abs(param3) > maxValue: raise ValueError('Offset out of range: %g (range: [%g, %g])' % (param3, -maxValue, maxValue)) self.program.put('WAVEFORM:TYPE', type, wait=True) self.program.put('WAVEFORM:PERIODORFREQUENCY', param1, wait=True) self.program.put('WAVEFORM:AMPLITUDE', param2, wait=True) if param3 is not None: self.program.put('WAVEFORM:OFFSET', param3, wait=True) device.put('WAVEFORM:ADD:3ARGUMENTS', 0, wait=True) else: device.put('WAVEFORM:ADD:2ARGUMENTS', 0, wait=True) self.checkError() l = self.getProgramLength() self.programPoints = l # Fake distinct dwell time for waveform self.programTimes += [0] def addSineWaveform(self, frequency, amplitude, offset, start=0, stop=360): """ Adds a sine wave to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type and it also consumes a lot of points, but it's faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device. Adding points does not execute the program. The method :meth:`waveformStart` must be called. See also: :meth:`waveformStart`, :meth:`setSineWaveform`, :meth:`addWaveformPoints`, :meth:`addTriangleWaveform`, :meth:`addRampWaveform`, :meth:`addSquareWaveform`, :meth:`addLevelWaveform` .. note:: When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes. Parameters ---------- frequency : `float` The sine wave frequency. The allowed range is 0.01Hz to 443Hz. The number of points used vary from 3840, for lower frequency waves to 24, for higher frequency waves. amplitude : `float` The sine wave peak to peak amplitude. The peak to peak amplitude cannot exceed the range defined by the configured operating device limits. offset : `float` The offset of the sine wave zero amplitude. The offset cannot exceed the configured device limits. start : `float` The starting angle for the sine wave, in degrees. Allowed range is [0.0, 359.99] stop : `float` The stop angle for the sine wave, in degrees. Allowed range is [0.01, 360.0] """ self.setWaveformAngle(start, stop) self.addWaveform('SINE', frequency, amplitude, offset) def setSineWaveform(self, frequency, amplitude, offset, start=0, stop=360): """ A shortcut to clearing the waveform program, adding sine waveform and setting the repeat count to 1. See also: :meth:`clearWaveform`, :meth:`addSineWaveform`, :meth:`setWaveformRepeat` Parameters ---------- frequency : `float` Parameter passed to :meth:`addSineWaveform` amplitude : `float` Parameter passed to :meth:`addSineWaveform` offset : `float` Parameter passed to :meth:`addSineWaveform` start : `float` Parameter passed to :meth:`addSineWaveform` stop : `float` Parameter passed to :meth:`addSineWaveform` """ self.clearWaveform() self.addSineWaveform(frequency, amplitude, offset, start, stop) self.setWaveformRepeat(1) def addTriangleWaveform(self, frequency, amplitude, offset, start=0, stop=360): """ Adds a triangle wave to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type and it also consumes a lot of points, but it's faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device. Adding points does not execute the program. The method :meth:`waveformStart` must be called. See also: :meth:`waveformStart`, :meth:`setTriangleWaveform`, :meth:`addWaveformPoints`, :meth:`addSineWaveform`, :meth:`addRampWaveform`, :meth:`addSquareWaveform`, :meth:`addLevelWaveform` .. note:: When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes. Parameters ---------- frequency : `float` The triangle wave frequency. The allowed range is 0.01Hz to 443Hz. The number of points used vary from 3840, for lower frequency waves to 24, for higher frequency waves. amplitude : `float` The triangle wave peak to peak amplitude. The peak to peak amplitude cannot exceed the range defined by the configured operating device limits. offset : `float` The offset of the triangle wave zero amplitude. The offset cannot exceed the configured device limits. start : `float` The starting angle for the triangle wave, in degrees. Allowed range is [0.0, 359.99] stop : `float` The stop angle for the triangle wave, in degrees. Allowed range is [0.01, 360.0] """ self.setWaveformAngle(start, stop) self.addWaveform('TRIANGLE', frequency, amplitude, offset) def setTriangleWaveform(self, frequency, amplitude, offset, start=0, stop=360): """ A shortcut to clearing the waveform program, adding triangle waveform and setting the repeat count to 1. See :meth:`clearWaveform`, :meth:`addTriangleWaveform`, :meth:`setWaveformRepeat` Parameters ---------- frequency : `float` Parameter passed to :meth:`addTriangleWaveform` amplitude : `float` Parameter passed to :meth:`addTriangleWaveform` offset : `float` Parameter passed to :meth:`addTriangleWaveform` start : `float` Parameter passed to :meth:`addTriangleWaveform` stop : `float` Parameter passed to :meth:`addTriangleWaveform` """ self.clearWaveform() self.addTriangleWaveform(frequency, amplitude, offset, start, stop) self.setWaveformRepeat(1) def addRampWaveform(self, length, height, offset): """ Adds a ramp wave to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type and it also consumes a lot of points, but it's faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device. Adding points does not execute the program. The method :meth:`waveformStart` must be called. See also: :meth:`waveformStart`, :meth:`setRampWaveform`, :meth:`addWaveformPoints`, :meth:`addSineWaveform`, :meth:`addTriangleWaveform`, :meth:`addSquareWaveform`, :meth:`addLevelWaveform` .. note:: When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes. Parameters ---------- length : `float` The ramp length. The allowed range is [1/532, 100] (1.88ms to 100s). The number of points used vary from 20, for smaller ramps, to 3840, for larger ramps. height : `float` The ramp height. The height can be positive or negative. It cannot exceed the range defined by the configured operating device limits. offset : `float` The offset of the ramp middle height. The offset cannot exceed the configured device limits. """ if height >= 0: type = 'RAMP+' else: type = 'RAMP-' height = -height self.addWaveform(type, 1.0/length, height, offset) def setRampWaveform(self, length, height, offset): """ A shortcut to clearing the waveform program, adding ramp waveform and setting the repeat count to 1. See also: :meth:`clearWaveform`, :meth:`addRampWaveform`, :meth:`setWaveformRepeat` Parameters ---------- length : `float` Parameter passed to :meth:`addRampWaveform` height : `float` Parameter passed to :meth:`addRampWaveform` offset : `float` Parameter passed to :meth:`addRampWaveform` """ self.clearWaveform() self.addRampWaveform(length, height, offset) self.setWaveformRepeat(1) def addSquareWaveform(self, frequency, amplitude, offset): """ Adds a square wave (constant 50% duty cycle, starts with positive excursion) to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type and it also consumes a lot of points, but it's faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device. Adding points does not execute the program. The method :meth:`waveformStart` must be called. See also: :meth:`waveformStart`, :meth:`setSquareWaveform`, :meth:`addWaveformPoints`, :meth:`addSineWaveform`, :meth:`addTriangleWaveform`, :meth:`addRampWaveform`, :meth:`addLevelWaveform` .. note:: When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes. Parameters ---------- frequency : `float` The square wave frequency. The allowed range is 0.02Hz to 1000Hz. The number of points used vary from 3840, for lower frequency waves to 10, for higher frequency waves. amplitude : `float` The square wave peak to peak amplitude. The peak to peak amplitude cannot exceed the range defined by the configured operating device limits. offset : `float` The offset of the square wave zero amplitude. The offset cannot exceed the configured device limits. """ self.addWaveform('SQUARE', frequency, amplitude, offset) def setSquareWaveform(self, frequency, amplitude, offset): """ A shortcut to clearing the waveform program, adding square waveform and setting the repeat count to 1. See also: :meth:`clearWaveform`, :meth:`addSquareWaveform`, :meth:`setWaveformRepeat` Parameters ---------- frequency : `float` Parameter passed to :meth:`addSquareWaveform` amplitude : `float` Parameter passed to :meth:`addSquareWaveform` offset : `float` Parameter passed to :meth:`addSquareWaveform` """ self.clearWaveform() self.addSquareWaveform(frequency, amplitude, offset) self.setWaveformRepeat(1) def addLevelWaveform(self, length, offset): """ Adds a fixed level wave to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type, but it's faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device. Adding points does not execute the program. The method :meth:`waveformStart` must be called. See also: :meth:`waveformStart`, :meth:`setLevelWaveform`, :meth:`addWaveformPoints`, :meth:`addSineWaveform`, :meth:`addRampWaveform`, :meth:`addTriangleWaveform`, :meth:`addSquareWaveform` .. note:: When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes. Parameters ---------- length : `float` The duration of the level waveform. The allowed range is 500µs to 5s. The number of points used is 60. offset : `float` The level offset. The offset cannot exceed the configured device limits. """ self.addWaveform('LEVEL', length, offset) def setLevelWaveform(self, length, offset): """ A shortcut to clearing the waveform program, adding a level waveform and setting the repeat count to 1. See also: :meth:`clearWaveform`, :meth:`addLevelWaveform`, :meth:`setWaveformRepeat` Parameters ---------- length : `float` Parameter passed to :meth:`addLevelWaveform` offset : `float` Parameter passed to :meth:`addLevelWaveform` """ self.clearWaveform() self.addLevelWaveform(length, offset) self.setWaveformRepeat(1) def setWaveformRepeat(self, repeat): """ Set the number of times the waveform program will run. By default, the program runs an indeterminate number of times, until it's explicitly stopped. This method is used to specify the number of times the waveform program will repeat. A waveform may also have separate one-shot part and repeatable part. Use the method :meth:`setWaveformRepeatMark` to separate them. See also: :meth:`setWaveformRepeatMark`, :meth:`waveformStop`, :meth:`waveformAbort` Parameters ---------- repeat : `int` Number of times the programmed waveform will run. A value of zero means run until explicitly stopped. """ if repeat < 0: raise ValueError('Negative repeat value: %d' % repeat) self.program.put('REPEAT', repeat, wait=True) self.checkError() # It's not reliable to call waveformStop with a finite repeat count # because calling immediatelly after the waveform program stops results # in an error and there's no atomic way to check and disable it, # so we just disallow using the stop command with finite repeat counts self.blockStopCommand = repeat > 0 def getWaveformRepeat(self): """ Gets the last requested waveform repeat count. See also: :meth:`setWaveformRepeat` Returns ------- `int` """ return self.program.get('REPEAT') def setWaveformRepeatMark(self, position=None): """ Separates the one-short part from the repeating part in the waveform program. By default, the whole waveform repeats, according to the repeat count. This method marks the separation point that allows the definition of an initial one-shot part of the wave. The part before the marked point will be the one-shot part and after the marked point will be the repeating part. See also: :meth:`setWaveformRepeat` Parameters ---------- position : `int` Desired position of the setWaveformRepeatMark, representing the point in the waveform that starts the repeating part. If unset, the current first free position in the waveform is set as the mark. """ if position is None: position = self.getProgramLength() elif position < 0: raise ValueError('Negative position: %d' % position) self.program.put('MARK:REPEAT', position, wait=True) self.checkError() def waveformStart(self): """ Executes a waveform program. The program must be already defined by using the waveform add methods. This methods triggers the execution and returns immediatelly. It does not wait for the complete waveform execution to finish. By default, the waveform will repeat until it is explicitly stopped, but this can be configured by the :meth:`setWaveformRepeat` method. To stop the waveform execution, the methods :meth:`waveformStop` and :meth:`waveformAbort` can be used. For a program with finite repeat count, it's possible to wait until the waveform finishes with :meth:`waveformWait`. See also: :meth:`addWaveformPoints`, :meth:`addSineWaveform`, :meth:`addTriangleWaveform`, :meth:`addRampWaveform`, :meth:`addSquareWaveform`, :meth:`addLevelWaveform`, :meth:`waveformStop`, :meth:`waveformAbort`, :meth:`waveformWait`, :meth:`isWaveformRunning` """ if self.cachedMode() == self.MODE_VOLTAGE: self.programVoltage.put('START', 0, wait=True) else: self.programCurrent.put('START', 0, wait=True) self.checkError() def waveformStop(self): """ Requests to stop a running waveform. The waveform will execute until the end and then will stop, without repeating the program again. The final output value will be the final point in the program. See also: :meth:`waveformAbort`, :meth:`waveformWait` .. note:: Because it's not possible to reliably stop a program with finite repeat count without potentially triggering an "already finished" error, this command is only enabled for stopping waveform programs with inifinite repeat count. For finite repeat counts, use :meth:`waveformAbort`, or :meth:`waveformWait` instead. """ if self.blockStopCommand: raise RuntimeError('Cannot use stop command with finite repeat counts') if self.cachedMode() == self.MODE_VOLTAGE: self.programVoltage.put('STOP', 0, wait=True) else: self.programCurrent.put('STOP', 0, wait=True) self.checkError() def waveformAbort(self): """ Immediatelly stops a running waveform. The final output value will be the value before running the waveform program. See also: :meth:`waveformStop`, :meth:`waveformWait` """ if self.cachedMode() == self.MODE_VOLTAGE: self.programVoltage.put('ABORT', 0, wait=True) else: self.programCurrent.put('ABORT', 0, wait=True) self.checkError() def getOperationFlag(self): """ Returns the real time value of the device operation condition register. The register contains a set of bits representing the following flags: "list running" (16384), "list complete" (4096), "sample complete" (2048), "constant current mode" (1024), "transient complete" (512)", "constant voltage mode" (256), "transient armed" (64), "waiting for trigger" (32). Refer to the Kepco BOP GL manual for specific details. The relevant flag used by the library is the "list running" flag, which indicates that theres a waveform program running. See also: :meth:`isWaveformRunning`, :meth:`waveformWait` Returns ------- `int` """ return self.procAndGet(self.operationFlag, 'GET:OPERATION:FLAG') def isWaveformRunning(self): """ Returns whether there's a running waveform program. See also: :meth:`getOperationFlag`, :meth:`waveformWait` Returns ------- `bool` """ return bool(self.getOperationFlag() & self.WAVEFORM_RUNNING_FLAG) def waveformWait(self): """ Waits until the whole waveform program finishes, including all repetitions. It's only possible to wait for waveform programs with finite repeat counts. .. note:: When using the Kepco power supply with a serial port, it's not possible to receive a notification from the device when the waveform finishes, so this method works by repeatedly polling the device requesting the operation flag. Because of this, the recommended way to use this method is first sleeping for as much time as possible to avoid the loop and only on the last second call this method. Example of a helper function that accomplishes this: Examples -------- >>> def runAndWait(bop, totalTime): ... bop.waveformStart() ... sleep(max(totalTime-1, 0)) ... bop.waveformWait() ... """ while self.isWaveformRunning(): poll(1e-2) def getValue(self): """ Returns either the readback voltage or the current, depending on operating mode. Returns ------- `float` """ if self.cachedMode() == self.MODE_VOLTAGE: return self.getVoltage() return self.getCurrent() def setValue(self, v): """ Sets either the current voltage or current, depending on operating mode. Parameters ---------- v : `float` Either voltage, or current to set, depending on operating mode. """ if self.cachedMode() == self.MODE_VOLTAGE: self.setVoltage(v) else: self.setCurrent(v) def wait(self): """ Does the same as :meth:`waveformWait`. """ self.waveformWait() def getLowLimitValue(self): """ Gets either the voltage or current low limit value, depending on operation mode. Returns ------- `float` """ if self.cachedMode() == self.MODE_VOLTAGE: return -self.getLimits(self.voltage, self.MODE_VOLTAGE)[0] return -self.getLimits(self.current, self.MODE_CURRENT)[0] def getHighLimitValue(self): """ Gets either the voltage or current high limit value, depending on operation mode. Returns ------- `float` """ if self.cachedMode() == self.MODE_VOLTAGE: return self.getLimits(self.voltage, self.MODE_VOLTAGE)[1] return self.getLimits(self.current, self.MODE_CURRENT)[1]
class Hexapode(IScannable, StandardDevice): def __init__(self, mnemonic, pvName, axis): super().__init__(mnemonic) self.hexapode = Device( pvName + ':', ('STATE#PANEL:SET', 'STATE#PANEL:GET', 'STATE#PANEL:BUTTON', 'MOVE#PARAM:CM', 'MOVE#PARAM:X', 'MOVE#PARAM:Y', 'MOVE#PARAM:Z', 'MOVE#PARAM:RX', 'MOVE#PARAM:RY', 'MOVE#PARAM:RZ', ':POSUSER:X', ':POSUSER:Y', ':POSUSER:Z', ':POSUSER:RX', ':POSUSER:RY', ':POSUSER:RZ', ':POSMACH:X', ':POSMACH:Y', ':POSMACH:Z', ':POSMACH:RX', ':POSMACH:RY', ':POSMACH:RZ', 'CFG#CS:1', 'CFG#CS:2', 'STATE#POSVALID?', 'CFG#CS?:1', 'CFG#CS?:2', 'CFG#CS?:3', 'CFG#CS?:4', 'CFG#CS?:5', 'CFG#CS?:6', 'CFG#CS?:7', 'CFG#CS?:8', 'CFG#CS?:9', 'CFG#CS?:10', 'CFG#CS?:11', 'CFG#CS?:12', 'CFG#CS?:13')) self.axis = axis self.axis_dic = {"X": 1, "Y": 2, "Z": 3, "RX": 4, "RY": 5, "RZ": 6} self.axis_number = self.axis_dic[self.axis] self.rbv = PV(pvName + ':' + 'POSUSER:'******'POSUSER:'******'POSUSER:'******'POSUSER:'******'POSUSER:'******'STATE#PANEL:SET', 11) self.hexapode.put('MOVE#PARAM:' + self.axis, self.pos) self.moving = True self.wait() def wait(self): while self.moving: pass self.stop() def stop(self): self.hexapode.put('STATE#PANEL:SET', 0) self.moving = False #------------------------------------------------------------------------------------------ def canPerformMovement(self, target): """ Check if a movement to a given position is possible using the limit values and backlash distance Returns ------- `boolean` .. note:: - **True** -- Motor CAN perform the desired movement; - **False** -- Motor **CANNOT** perform the desired movement. """ if (self.hexapode.get('STATE#POSVALID?') > 0): return False, "Out of SYMETRIE workspace." def getLimits(self, coord, axis=0): #32 and #33 #Coord: 0- Machine, 1- users #Axis: 0-All, 1-X, 2-Y, 3-Z, 4-RX, 5-RY, 6-RZ if (coord != 0 and coord != 1): raise ValueError( "Invalid value for coord argument. It should be 0 or 1") elif (axis < 0 or axis > 6): raise ValueError( "Invalid value for axis argument. It should be between 1 and 6" ) else: stateValue = 32 if (coord == 1): stateValue = 33 self.hexapode.put('STATE#PANEL:SET', stateValue) if (axis > 0): negLim = self.hexapode.get('CFG#CS?:' + str(2 * axis - 1)) posLim = self.hexapode.get('CFG#CS?:' + str(2 * axis)) return negLim, posLim else: negLimX = self.hexapode.get('CFG#CS?:1') posLimX = self.hexapode.get('CFG#CS?:2') negLimY = self.hexapode.get('CFG#CS?:3') posLimY = self.hexapode.get('CFG#CS?:4') negLimZ = self.hexapode.get('CFG#CS?:5') posLimZ = self.hexapode.get('CFG#CS?:6') negLimRX = self.hexapode.get('CFG#CS?:7') posLimRX = self.hexapode.get('CFG#CS?:8') negLimRY = self.hexapode.get('CFG#CS?:9') posLimRY = self.hexapode.get('CFG#CS?:10') negLimRZ = self.hexapode.get('CFG#CS?:11') posLimRZ = self.hexapode.get('CFG#CS?:12') enabledLimits = self.hexapode.get('CFG#CS?:13') return (negLimX, posLimX, negLimY, posLimY, negLimZ, posLimZ, negLimRX, posLimRX, negLimRY, posLimRY, negLimRZ, posLimRZ, enabledLimits) def getLowLimitValue(self): if (self.axis_number < 0 or self.axis_number > 6): raise ValueError( "Invalid value for axis argument. It should be between 1 and 6" ) else: stateValue = 33 self.hexapode.put('STATE#PANEL:SET', stateValue) if (self.axis_number > 0): negLim = self.hexapode.get('CFG#CS?:' + str(2 * self.axis_number - 1)) posLim = self.hexapode.get('CFG#CS?:' + str(2 * self.axis_number)) return negLim #, posLim else: print("Error getLowLimitValue") def getHighLimitValue(self): if (self.axis_number < 0 or self.axis_number > 6): raise ValueError( "Invalid value for axis argument. It should be between 1 and 6" ) else: stateValue = 33 self.hexapode.put('STATE#PANEL:SET', stateValue) if (self.axis_number > 0): negLim = self.hexapode.get('CFG#CS?:' + str(2 * self.axis_number - 1)) posLim = self.hexapode.get('CFG#CS?:' + str(2 * self.axis_number)) return posLim else: print("Error getHighLimitValue") def getDialLowLimitValue(self): if (self.axis_number < 0 or self.axis_number > 6): raise ValueError( "Invalid value for axis argument. It should be between 1 and 6" ) else: stateValue = 32 self.hexapode.put('STATE#PANEL:SET', stateValue) if (self.axis_number > 0): negLim = self.hexapode.get('CFG#CS?:' + str(2 * self.axis_number - 1)) return negLim else: print("Error getDialLowLimitValue") def getDialHighLimitValue(self): if (self.axis_number < 0 or self.axis_number > 6): raise ValueError( "Invalid value for axis argument. It should be between 1 and 6" ) else: stateValue = 32 self.hexapode.put('STATE#PANEL:SET', stateValue) if (self.axis_number > 0): posLim = self.hexapode.get('CFG#CS?:' + str(2 * self.axis_number)) return posLim else: print("Error getDialHLimit") #-------------------Motors----- def isMoving(self): return self.moving def getRealPosition(self): return self.getValue() def getDialRealPosition(self): return self.hexapode.get('POSMACH:' + self.axis) def validateLimits(self): return self.getLimits(0) def setRelativePosition(self, pos, waitComplete=False): target = self.getRealPosition() + pos self.setAbsolutePosition(target, waitComplete=waitComplete)
class KepcoBOP(IScannable, StandardDevice): """ Class to control Kepco BOP GL power supplies via EPICS. Examples -------- >>> from py4syn.epics.KepcoBOPClass import KepcoBOP >>> >>> def configurePower(pv="", name="", voltage=5.0, currentLimit=1.0): ... bop = KepcoBOP(pv, name) ... bop.reset() ... bop.setCurrentLimits(currentLimit, currentLimit) ... bop.setVoltage(voltage) ... return bop ... >>> def smoothVoltageTransition(bop, initial=0.0, final=12.0, duration=2.0): ... bop.setRampWaveform(duration, final-initial, (initial+final)/2) ... bop.waveformStart() ... bop.waveformWait() ... >>> def noiseCurrent(bop): ... bop.reset() ... bop.setMode(KepcoBOP.MODE_CURRENT) ... bop.setVoltageLimits(20, 20) ... points = [random.uniform(-5, 5) for i in range(100)] ... bop.clearWaveform() ... bop.addWaveformPoints(points, [0.025]) ... bop.waveformStart() ... """ MODE_VOLTAGE = 'VOLTAGE' MODE_CURRENT = 'CURRENT' MAX_POINTS_SINGLE_DWELL = 5900 MAX_POINTS_FEW_DWELLS = 3933 MAX_POINTS_MANY_DWELLS = 2950 FEW_DWELLS_THRESHOLD = 126 MAX_POINTS_PER_ADD = 21 WAVEFORM_RUNNING_FLAG = 16384 MAX_VOLTAGE = 50 MAX_CURRENT = 20 MIN_DWELL = 0.000093 MAX_DWELL = 0.034 RANGE = [ 'GET', 'GET.PROC', 'SET', 'SET:LIMIT:POSITIVE', 'SET:LIMIT:NEGATIVE', 'SET:PROTECTION:POSITIVE', 'SET:PROTECTION:NEGATIVE', 'GET:LIMIT:POSITIVE', 'GET:LIMIT:POSITIVE.PROC', 'GET:LIMIT:NEGATIVE', 'GET:LIMIT:NEGATIVE.PROC', 'GET:PROTECTION:POSITIVE', 'GET:PROTECTION:POSITIVE.PROC', 'GET:PROTECTION:NEGATIVE', 'GET:PROTECTION:NEGATIVE.PROC' ] PROGRAM = [ 'WAVEFORM:TYPE', 'WAVEFORM:PERIOD', 'WAVEFORM:AMPLITUDE', 'WAVEFORM:OFFSET', 'REPEAT', 'CLEAR', 'MARK:REPEAT' ] PROGRAM_SUB = [ 'ADD', 'WAVEFORM:ADD:2ARGUMENTS', 'WAVEFORM:ADD:3ARGUMENTS', 'WAVEFORM:SET:ANGLE', 'WAVEFORM:START:ANGLE', 'WAVEFORM:STOP:ANGLE', 'START', 'STOP', 'ABORT', 'POINTS', 'POINTS.PROC' ] WAVEFORM_PARAM1_LIMITS = { 'SQUARE': (0.02, 1000), 'RAMP+': (0.02, 532), 'RAMP-': (0.02, 532), 'SINE': (0.01, 443), 'LEVEL': (0.0005, 5), } def __init__(self, pvName, mnemonic): """ **Constructor** See :class:`py4syn.epics.StandardDevice` Parameters ---------- pvName : `string` Power supply base naming of the PV (Process Variable) mnemonic : `string` Power supply mnemonic """ super().__init__(mnemonic) self.pvName = pvName self.voltage = Device(pvName + ':VOLTAGE:', self.RANGE) self.current = Device(pvName + ':CURRENT:', self.RANGE) self.program = Device(pvName + ':PROGRAM:', self.PROGRAM) self.programVoltage = Device(pvName + ':PROGRAM:VOLTAGE:', self.PROGRAM_SUB) self.programCurrent = Device(pvName + ':PROGRAM:CURRENT:', self.PROGRAM_SUB) self.resetPV = PV(pvName + ':RESET') self.mode = Device(pvName + ':MODE:', ['SET', 'GET', 'GET.PROC']) self.operationFlag = Device( pvName + ':', ['GET:OPERATION:FLAG', 'GET:OPERATION:FLAG.PROC']) self.timePV = PV(pvName + ':PROGRAM:TIME:ADD') self.error = Device(pvName + ':', ['ERROR', 'ERROR.PROC', 'ERROR:TEXT']) self.defaults() # Operation mode (voltage x current) is cached, so get it immediatelly self.procAndGet(self.mode, 'GET') def procAndGet(self, device, pv): """ Helper method to synchronously execute a query in the device. """ device.put(pv + '.PROC', 0, wait=True) return device.PV(pv).get(use_monitor=False) def getError(self): """ Helper method to pop the last error from the device error queue. """ error = self.procAndGet(self.error, 'ERROR') text = self.error.PV('ERROR:TEXT').get(use_monitor=False) return error, text def checkError(self): """ Helper method to raise an exception if the device reports an error. """ error, text = self.getError() if error != 0: raise RuntimeError('Device returned error: %d, %s' % (error, text)) def defaults(self): """ Helper method to reset internal data. """ self.programPoints = 0 self.programTimes = [] self.blockStopCommand = False self.oneShotTime = 0 def setVoltage(self, voltage): """ Sets the voltage value. This method can only be used when in voltage mode. The voltage values must be within the power supply acceptable range and also within the configured limit values. See also: :meth:`setMode`, :meth:`setVoltageLimits` Parameters ---------- voltage : `float` The desired voltage value """ if self.cachedMode() != self.MODE_VOLTAGE: raise RuntimeError('Not in voltage mode') if abs(voltage) > self.MAX_VOLTAGE * 1.01: raise ValueError('Voltage out of range: %g' % voltage) self.voltage.put('SET', voltage, wait=True) def setCurrent(self, current): """ Sets the current value. This method can only be used when in current mode. The current values must be within the power supply acceptable range and also within the configured limit values. See also: :meth:`setMode`, :meth:`setCurrentLimits` Parameters ---------- current : `float` The desired current value """ if self.cachedMode() != self.MODE_CURRENT: raise RuntimeError('Not in current mode') if abs(current) > self.MAX_CURRENT * 1.01: raise ValueError('Current out of range: %g' % current) self.current.put('SET', current, wait=True) def getVoltage(self): """ Measures the voltage value. The measured value that is read back is known to have an error (less than 1%) and a delay (up to 320ms). Returns ------- `float` """ return self.procAndGet(self.voltage, 'GET') def getCurrent(self): """ Measures the current value. The measured value that is read back is known to have an error (less than 1%) and a delay (up to 320ms). Returns ------- `float` """ return self.procAndGet(self.current, 'GET') def setMode(self, mode): """ Changes the operating mode. Supported modes are voltage mode and current mode. In the voltage mode, the device tries to set a specific voltage, while staying within the current protection limits. In current mode, the device tries to set a specific current, while staying within the voltage protection limits. See also: :meth:`setCurrentLimits`, :meth:`setVoltageLimits` Parameters ---------- mode : {KepcoBOP.MODE_CURRENT, KepcoBOP.MODE_VOLTAGE} The desired mode """ self.mode.put('SET', mode, wait=True) # GET is used as the cached mode, so it needs to be updated too self.procAndGet(self.mode, 'GET') def cachedMode(self): """ Helper method to return cached operating mode """ return self.MODE_VOLTAGE if self.mode.get( 'GET') == 0 else self.MODE_CURRENT def setLimits(self, device, mode, negative=None, positive=None, maximum=1e100): """ Helper method that implements :meth:`setVoltageLimits` and :meth:`setCurrentLimits` """ pv = 'LIMIT' if self.cachedMode() == mode else 'PROTECTION' if not negative is None: if negative < 0: raise ValueError('Value must be absolute: %g' % negative) if negative > maximum: raise ValueError('Value out of range: %g (max: %g)' % (negative, maximum)) device.put('SET:%s:NEGATIVE' % pv, negative, wait=True) if not positive is None: if positive < 0: raise ValueError('Value must be absolute: %g' % positive) if positive > maximum: raise ValueError('Value out of range: %g (max: %g)' % (positive, maximum)) device.put('SET:%s:POSITIVE' % pv, positive, wait=True) def setVoltageLimits(self, negative=None, positive=None): """ Sets the negative and positive voltage limits allowed for operation. The specific limit type that is set depends on the operating mode. When in voltage mode, the limit set is a main channel limit: it defines the limits of the voltages that can be programmed by the user. When in current mode, the limit is a protection limit: it defines the voltage limits that the load may impose because of the requested current. When changing the operating modes, the set limits no longer apply: they must be set again for the new mode. See also: :meth:`setMode` Parameters ---------- negative : `float` The absolute value of the negative limit positive : `float` The absolute value of the positive limit """ self.setLimits(self.voltage, self.MODE_VOLTAGE, negative, positive, self.MAX_VOLTAGE) def setCurrentLimits(self, negative=None, positive=None): """ Sets the negative and positive current limits allowed for operation. The specific limit type that is set depends on the operating mode. When in current mode, the limit set is a main channel limit: it defines the limits of the current that can be programmed by the user. When in voltage mode, the limit is a protection limit: it defines the current limits that the load may impose because of the requested voltage. When changing the operating modes, the set limits no longer apply: they must be set again for the new mode. See also: :meth:`setMode` Parameters ---------- negative : `float` The absolute value of the negative limit positive : `float` The absolute value of the positive limit """ self.setLimits(self.current, self.MODE_CURRENT, negative, positive, self.MAX_CURRENT) def getLimits(self, device, mode): """ Helper method that implements :meth:`getVoltageLimits` and :meth: `getCurrentLimits` """ pv = 'LIMIT' if self.cachedMode() == mode else 'PROTECTION' negative = self.procAndGet(device, 'GET:%s:NEGATIVE' % pv) positive = self.procAndGet(device, 'GET:%s:POSITIVE' % pv) return negative, positive def getVoltageLimits(self): """ Gets the negative and positive voltage limits allowed for operation. The specific limit type that is read depends on the operating mode. When in voltage mode, the limit set is a main channel limit: it defines the limits of the voltages that can be programmed by the user. When in current mode, the limit is a protection limit: it defines the voltage limits that the load may impose because of the requested current. When changing the operating modes, the set limits no longer apply: they are different for the new mode. See also: :meth:`setMode` Returns ------- negative : `float` The absolute value of the negative limit positive : `float` The absolute value of the positive limit """ return self.getLimits(self.voltage, self.MODE_VOLTAGE) def getCurrentLimits(self): """ Gets the negative and positive current limits allowed for operation. The specific limit type that is read depends on the operating mode. When in current mode, the limit set is a main channel limit: it defines the limits of the current that can be programmed by the user. When in voltage mode, the limit is a protection limit: it defines the current limits that the load may impose because of the requested voltage. When changing the operating modes, the set limits no longer apply: they are different for the new mode. See also: :meth:`setMode` Returns ------- negative : `float` The absolute value of the negative limit positive : `float` The absolute value of the positive limit """ return self.getLimits(self.current, self.MODE_CURRENT) def reset(self): """ Resets the device to a known state. Possible reset states may vary with the device configuration, but generally will be a zero value output (either voltage or current) with low protection limits. The device error queue will be cleared. """ self.resetPV.put(0, wait=True) self.defaults() self.procAndGet(self.mode, 'GET') def clearWaveform(self): """ Clears the programmed waveform data. This is required when building a new waveform program. Waveform data can only be cleared while the program is not running. """ self.program.put('CLEAR', 0, wait=True) self.checkError() self.defaults() def getProgramLength(self): """ Helper method that returns the number of points in current waveform program. """ if self.cachedMode() == self.MODE_VOLTAGE: device = self.programVoltage else: device = self.programCurrent p = self.procAndGet(device, 'POINTS') self.checkError() return p def addWaveformPoints(self, points, times): """ Adds a set of points to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. It's the most flexible way, allowing arbitrary waveforms, but it's also the slowest one (a 10 second waveform may take at least 4 seconds just to upload the program). This method adds more points to the current waveform program. It does not overwrite the existing program. Adding points does not execute the program. The method :meth:`waveformStart` must be called. See also: :meth:`setWaveformPoints`, :meth:`addSineWaveform`, :meth:`addTriangleWaveform`, :meth:`addRampWaveform`, :meth:`addSquareWaveform`, :meth:`addLevelWaveform`, :meth:`waveformStart` .. note:: When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes. Parameters ---------- points : `array of floats` The array of points to be added to the program. The total number of allowed points may vary, depending on the times array. When the times array has exactly one element, the maximum number of points is 5900. When the times array has at most 126 distinct values, the maximum number of points is 3933. When the times array has more than 126 distinct values, the maximum number of points is 2950. times : `array of floats` The dwell times for each point. Either there must be one time entry for each point, or the array of times must contain exactly one element, which sets the time for all points. The allowed time range is [93e-6, 34e-3] (93µs to 34ms). """ x = min(times) if x < self.MIN_DWELL: raise ValueError('Minimum time out of range: %g (min: %g)' % (x, self.MIN_DWELL)) x = max(times) if x > self.MAX_DWELL: raise ValueError('Maximum time out of range: %g (max: %g)' % (x, self.MAX_DWELL)) p = self.programPoints + len(points) t = self.programTimes + times distinct = len(set(t)) if distinct > self.FEW_DWELLS_THRESHOLD: maxPoints = self.MAX_POINTS_MANY_DWELLS elif distinct > 1: maxPoints = self.MAX_POINTS_FEW_DWELLS else: maxPoints = self.MAX_POINTS_SINGLE_DWELL if p > maxPoints: raise ValueError( 'Requested waveform too large: %u (maximum is: %u)' % (p, maxPoints)) if self.cachedMode() == self.MODE_VOLTAGE: device = self.programVoltage else: device = self.programCurrent for i in range(0, len(points), self.MAX_POINTS_PER_ADD): l = array(points[i:i + self.MAX_POINTS_PER_ADD]) device.put('ADD', l, wait=True) for i in range(0, len(times), self.MAX_POINTS_PER_ADD): l = array(times[i:i + self.MAX_POINTS_PER_ADD]) self.timePV.put(l, wait=True) self.programPoints = p self.programTimes = t def setWaveformPoints(self, points, times): """ A shortcut to clearing the waveform program, adding waveform points and setting the repeat count to 1. See also: :meth:`clearWaveform`, :meth:`addWaveformPoints`, :meth:`setWaveformRepeat` Parameters ---------- points : `array of floats` Parameter passed to :meth:`addWaveformPoints` times : `array of floats` Parameter passed to :meth:`addWaveformPoints` """ self.clearWaveform() self.addWaveformPoints(points, times) self.setWaveformRepeat(1) self.checkError() def setWaveformAngle(self, start=0, stop=360): """ Helper method that configures start and stop angles for sine and triangle waveforms. """ if start < 0 or start > 359.99: raise ValueError('Start angle must be between 0 and 359.99') if stop < 0.01 or stop > 360: raise ValueError('Stop angle must be between 0.01 and 360') if self.cachedMode() == self.MODE_VOLTAGE: device = self.programVoltage else: device = self.programCurrent if device.get('WAVEFORM:START:ANGLE') != start: device.put('WAVEFORM:START:ANGLE', start, wait=True) if device.get('WAVEFORM:STOP:ANGLE') != stop: device.put('WAVEFORM:STOP:ANGLE', stop, wait=True) device.put('WAVEFORM:SET:ANGLE', 0, wait=True) self.checkError() def addWaveform(self, type, param1, param2, param3=None): """ Helper method that implements adding waveform segments. """ if type not in self.WAVEFORM_PARAM1_LIMITS: raise ValueError('Invalid waveform type: %s' % type) x, y = self.WAVEFORM_PARAM1_LIMITS[type] if param1 < x or param1 > y: raise ValueError('Frequency or period parameter out of range: %g ' '(interval: [%g, %g])' % (param1, x, y)) if self.cachedMode() == self.MODE_VOLTAGE: device = self.programVoltage maxValue = self.MAX_VOLTAGE else: device = self.programCurrent maxValue = self.MAX_CURRENT if param2 < 0 or param2 > 2 * maxValue: raise ValueError('Amplitude out of range: %g (range: [%g, %g])' % (param2, 0, 2 * maxValue)) if param3 is not None and abs(param3) > maxValue: raise ValueError('Offset out of range: %g (range: [%g, %g])' % (param3, -maxValue, maxValue)) self.program.put('WAVEFORM:TYPE', type, wait=True) self.program.put('WAVEFORM:PERIODORFREQUENCY', param1, wait=True) self.program.put('WAVEFORM:AMPLITUDE', param2, wait=True) if param3 is not None: self.program.put('WAVEFORM:OFFSET', param3, wait=True) device.put('WAVEFORM:ADD:3ARGUMENTS', 0, wait=True) else: device.put('WAVEFORM:ADD:2ARGUMENTS', 0, wait=True) self.checkError() l = self.getProgramLength() self.programPoints = l # Fake distinct dwell time for waveform self.programTimes += [0] def addSineWaveform(self, frequency, amplitude, offset, start=0, stop=360): """ Adds a sine wave to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type and it also consumes a lot of points, but it's faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device. Adding points does not execute the program. The method :meth:`waveformStart` must be called. See also: :meth:`waveformStart`, :meth:`setSineWaveform`, :meth:`addWaveformPoints`, :meth:`addTriangleWaveform`, :meth:`addRampWaveform`, :meth:`addSquareWaveform`, :meth:`addLevelWaveform` .. note:: When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes. Parameters ---------- frequency : `float` The sine wave frequency. The allowed range is 0.01Hz to 443Hz. The number of points used vary from 3840, for lower frequency waves to 24, for higher frequency waves. amplitude : `float` The sine wave peak to peak amplitude. The peak to peak amplitude cannot exceed the range defined by the configured operating device limits. offset : `float` The offset of the sine wave zero amplitude. The offset cannot exceed the configured device limits. start : `float` The starting angle for the sine wave, in degrees. Allowed range is [0.0, 359.99] stop : `float` The stop angle for the sine wave, in degrees. Allowed range is [0.01, 360.0] """ self.setWaveformAngle(start, stop) self.addWaveform('SINE', frequency, amplitude, offset) def setSineWaveform(self, frequency, amplitude, offset, start=0, stop=360): """ A shortcut to clearing the waveform program, adding sine waveform and setting the repeat count to 1. See also: :meth:`clearWaveform`, :meth:`addSineWaveform`, :meth:`setWaveformRepeat` Parameters ---------- frequency : `float` Parameter passed to :meth:`addSineWaveform` amplitude : `float` Parameter passed to :meth:`addSineWaveform` offset : `float` Parameter passed to :meth:`addSineWaveform` start : `float` Parameter passed to :meth:`addSineWaveform` stop : `float` Parameter passed to :meth:`addSineWaveform` """ self.clearWaveform() self.addSineWaveform(frequency, amplitude, offset, start, stop) self.setWaveformRepeat(1) def addTriangleWaveform(self, frequency, amplitude, offset, start=0, stop=360): """ Adds a triangle wave to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type and it also consumes a lot of points, but it's faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device. Adding points does not execute the program. The method :meth:`waveformStart` must be called. See also: :meth:`waveformStart`, :meth:`setTriangleWaveform`, :meth:`addWaveformPoints`, :meth:`addSineWaveform`, :meth:`addRampWaveform`, :meth:`addSquareWaveform`, :meth:`addLevelWaveform` .. note:: When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes. Parameters ---------- frequency : `float` The triangle wave frequency. The allowed range is 0.01Hz to 443Hz. The number of points used vary from 3840, for lower frequency waves to 24, for higher frequency waves. amplitude : `float` The triangle wave peak to peak amplitude. The peak to peak amplitude cannot exceed the range defined by the configured operating device limits. offset : `float` The offset of the triangle wave zero amplitude. The offset cannot exceed the configured device limits. start : `float` The starting angle for the triangle wave, in degrees. Allowed range is [0.0, 359.99] stop : `float` The stop angle for the triangle wave, in degrees. Allowed range is [0.01, 360.0] """ self.setWaveformAngle(start, stop) self.addWaveform('TRIANGLE', frequency, amplitude, offset) def setTriangleWaveform(self, frequency, amplitude, offset, start=0, stop=360): """ A shortcut to clearing the waveform program, adding triangle waveform and setting the repeat count to 1. See :meth:`clearWaveform`, :meth:`addTriangleWaveform`, :meth:`setWaveformRepeat` Parameters ---------- frequency : `float` Parameter passed to :meth:`addTriangleWaveform` amplitude : `float` Parameter passed to :meth:`addTriangleWaveform` offset : `float` Parameter passed to :meth:`addTriangleWaveform` start : `float` Parameter passed to :meth:`addTriangleWaveform` stop : `float` Parameter passed to :meth:`addTriangleWaveform` """ self.clearWaveform() self.addTriangleWaveform(frequency, amplitude, offset, start, stop) self.setWaveformRepeat(1) def addRampWaveform(self, length, height, offset): """ Adds a ramp wave to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type and it also consumes a lot of points, but it's faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device. Adding points does not execute the program. The method :meth:`waveformStart` must be called. See also: :meth:`waveformStart`, :meth:`setRampWaveform`, :meth:`addWaveformPoints`, :meth:`addSineWaveform`, :meth:`addTriangleWaveform`, :meth:`addSquareWaveform`, :meth:`addLevelWaveform` .. note:: When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes. Parameters ---------- length : `float` The ramp length. The allowed range is [1/532, 100] (1.88ms to 100s). The number of points used vary from 20, for smaller ramps, to 3840, for larger ramps. height : `float` The ramp height. The height can be positive or negative. It cannot exceed the range defined by the configured operating device limits. offset : `float` The offset of the ramp middle height. The offset cannot exceed the configured device limits. """ if height >= 0: type = 'RAMP+' else: type = 'RAMP-' height = -height self.addWaveform(type, 1.0 / length, height, offset) def setRampWaveform(self, length, height, offset): """ A shortcut to clearing the waveform program, adding ramp waveform and setting the repeat count to 1. See also: :meth:`clearWaveform`, :meth:`addRampWaveform`, :meth:`setWaveformRepeat` Parameters ---------- length : `float` Parameter passed to :meth:`addRampWaveform` height : `float` Parameter passed to :meth:`addRampWaveform` offset : `float` Parameter passed to :meth:`addRampWaveform` """ self.clearWaveform() self.addRampWaveform(length, height, offset) self.setWaveformRepeat(1) def addSquareWaveform(self, frequency, amplitude, offset): """ Adds a square wave (constant 50% duty cycle, starts with positive excursion) to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type and it also consumes a lot of points, but it's faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device. Adding points does not execute the program. The method :meth:`waveformStart` must be called. See also: :meth:`waveformStart`, :meth:`setSquareWaveform`, :meth:`addWaveformPoints`, :meth:`addSineWaveform`, :meth:`addTriangleWaveform`, :meth:`addRampWaveform`, :meth:`addLevelWaveform` .. note:: When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes. Parameters ---------- frequency : `float` The square wave frequency. The allowed range is 0.02Hz to 1000Hz. The number of points used vary from 3840, for lower frequency waves to 10, for higher frequency waves. amplitude : `float` The square wave peak to peak amplitude. The peak to peak amplitude cannot exceed the range defined by the configured operating device limits. offset : `float` The offset of the square wave zero amplitude. The offset cannot exceed the configured device limits. """ self.addWaveform('SQUARE', frequency, amplitude, offset) def setSquareWaveform(self, frequency, amplitude, offset): """ A shortcut to clearing the waveform program, adding square waveform and setting the repeat count to 1. See also: :meth:`clearWaveform`, :meth:`addSquareWaveform`, :meth:`setWaveformRepeat` Parameters ---------- frequency : `float` Parameter passed to :meth:`addSquareWaveform` amplitude : `float` Parameter passed to :meth:`addSquareWaveform` offset : `float` Parameter passed to :meth:`addSquareWaveform` """ self.clearWaveform() self.addSquareWaveform(frequency, amplitude, offset) self.setWaveformRepeat(1) def addLevelWaveform(self, length, offset): """ Adds a fixed level wave to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type, but it's faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device. Adding points does not execute the program. The method :meth:`waveformStart` must be called. See also: :meth:`waveformStart`, :meth:`setLevelWaveform`, :meth:`addWaveformPoints`, :meth:`addSineWaveform`, :meth:`addRampWaveform`, :meth:`addTriangleWaveform`, :meth:`addSquareWaveform` .. note:: When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes. Parameters ---------- length : `float` The duration of the level waveform. The allowed range is 500µs to 5s. The number of points used is 60. offset : `float` The level offset. The offset cannot exceed the configured device limits. """ self.addWaveform('LEVEL', length, offset) def setLevelWaveform(self, length, offset): """ A shortcut to clearing the waveform program, adding a level waveform and setting the repeat count to 1. See also: :meth:`clearWaveform`, :meth:`addLevelWaveform`, :meth:`setWaveformRepeat` Parameters ---------- length : `float` Parameter passed to :meth:`addLevelWaveform` offset : `float` Parameter passed to :meth:`addLevelWaveform` """ self.clearWaveform() self.addLevelWaveform(length, offset) self.setWaveformRepeat(1) def setWaveformRepeat(self, repeat): """ Set the number of times the waveform program will run. By default, the program runs an indeterminate number of times, until it's explicitly stopped. This method is used to specify the number of times the waveform program will repeat. A waveform may also have separate one-shot part and repeatable part. Use the method :meth:`setWaveformRepeatMark` to separate them. See also: :meth:`setWaveformRepeatMark`, :meth:`waveformStop`, :meth:`waveformAbort` Parameters ---------- repeat : `int` Number of times the programmed waveform will run. A value of zero means run until explicitly stopped. """ if repeat < 0: raise ValueError('Negative repeat value: %d' % repeat) self.program.put('REPEAT', repeat, wait=True) self.checkError() # It's not reliable to call waveformStop with a finite repeat count # because calling immediatelly after the waveform program stops results # in an error and there's no atomic way to check and disable it, # so we just disallow using the stop command with finite repeat counts self.blockStopCommand = repeat > 0 def getWaveformRepeat(self): """ Gets the last requested waveform repeat count. See also: :meth:`setWaveformRepeat` Returns ------- `int` """ return self.program.get('REPEAT') def setWaveformRepeatMark(self, position=None): """ Separates the one-short part from the repeating part in the waveform program. By default, the whole waveform repeats, according to the repeat count. This method marks the separation point that allows the definition of an initial one-shot part of the wave. The part before the marked point will be the one-shot part and after the marked point will be the repeating part. See also: :meth:`setWaveformRepeat` Parameters ---------- position : `int` Desired position of the setWaveformRepeatMark, representing the point in the waveform that starts the repeating part. If unset, the current first free position in the waveform is set as the mark. """ if position is None: position = self.getProgramLength() elif position < 0: raise ValueError('Negative position: %d' % position) self.program.put('MARK:REPEAT', position, wait=True) self.checkError() def waveformStart(self): """ Executes a waveform program. The program must be already defined by using the waveform add methods. This methods triggers the execution and returns immediatelly. It does not wait for the complete waveform execution to finish. By default, the waveform will repeat until it is explicitly stopped, but this can be configured by the :meth:`setWaveformRepeat` method. To stop the waveform execution, the methods :meth:`waveformStop` and :meth:`waveformAbort` can be used. For a program with finite repeat count, it's possible to wait until the waveform finishes with :meth:`waveformWait`. See also: :meth:`addWaveformPoints`, :meth:`addSineWaveform`, :meth:`addTriangleWaveform`, :meth:`addRampWaveform`, :meth:`addSquareWaveform`, :meth:`addLevelWaveform`, :meth:`waveformStop`, :meth:`waveformAbort`, :meth:`waveformWait`, :meth:`isWaveformRunning` """ if self.cachedMode() == self.MODE_VOLTAGE: self.programVoltage.put('START', 0, wait=True) else: self.programCurrent.put('START', 0, wait=True) self.checkError() def waveformStop(self): """ Requests to stop a running waveform. The waveform will execute until the end and then will stop, without repeating the program again. The final output value will be the final point in the program. See also: :meth:`waveformAbort`, :meth:`waveformWait` .. note:: Because it's not possible to reliably stop a program with finite repeat count without potentially triggering an "already finished" error, this command is only enabled for stopping waveform programs with inifinite repeat count. For finite repeat counts, use :meth:`waveformAbort`, or :meth:`waveformWait` instead. """ if self.blockStopCommand: raise RuntimeError( 'Cannot use stop command with finite repeat counts') if self.cachedMode() == self.MODE_VOLTAGE: self.programVoltage.put('STOP', 0, wait=True) else: self.programCurrent.put('STOP', 0, wait=True) self.checkError() def waveformAbort(self): """ Immediatelly stops a running waveform. The final output value will be the value before running the waveform program. See also: :meth:`waveformStop`, :meth:`waveformWait` """ if self.cachedMode() == self.MODE_VOLTAGE: self.programVoltage.put('ABORT', 0, wait=True) else: self.programCurrent.put('ABORT', 0, wait=True) self.checkError() def getOperationFlag(self): """ Returns the real time value of the device operation condition register. The register contains a set of bits representing the following flags: "list running" (16384), "list complete" (4096), "sample complete" (2048), "constant current mode" (1024), "transient complete" (512)", "constant voltage mode" (256), "transient armed" (64), "waiting for trigger" (32). Refer to the Kepco BOP GL manual for specific details. The relevant flag used by the library is the "list running" flag, which indicates that theres a waveform program running. See also: :meth:`isWaveformRunning`, :meth:`waveformWait` Returns ------- `int` """ return self.procAndGet(self.operationFlag, 'GET:OPERATION:FLAG') def isWaveformRunning(self): """ Returns whether there's a running waveform program. See also: :meth:`getOperationFlag`, :meth:`waveformWait` Returns ------- `bool` """ return bool(self.getOperationFlag() & self.WAVEFORM_RUNNING_FLAG) def waveformWait(self): """ Waits until the whole waveform program finishes, including all repetitions. It's only possible to wait for waveform programs with finite repeat counts. .. note:: When using the Kepco power supply with a serial port, it's not possible to receive a notification from the device when the waveform finishes, so this method works by repeatedly polling the device requesting the operation flag. Because of this, the recommended way to use this method is first sleeping for as much time as possible to avoid the loop and only on the last second call this method. Example of a helper function that accomplishes this: Examples -------- >>> def runAndWait(bop, totalTime): ... bop.waveformStart() ... sleep(max(totalTime-1, 0)) ... bop.waveformWait() ... """ while self.isWaveformRunning(): poll(1e-2) def getValue(self): """ Returns either the readback voltage or the current, depending on operating mode. Returns ------- `float` """ if self.cachedMode() == self.MODE_VOLTAGE: return self.getVoltage() return self.getCurrent() def setValue(self, v): """ Sets either the current voltage or current, depending on operating mode. Parameters ---------- v : `float` Either voltage, or current to set, depending on operating mode. """ if self.cachedMode() == self.MODE_VOLTAGE: self.setVoltage(v) else: self.setCurrent(v) def wait(self): """ Does the same as :meth:`waveformWait`. """ self.waveformWait() def getLowLimitValue(self): """ Gets either the voltage or current low limit value, depending on operation mode. Returns ------- `float` """ if self.cachedMode() == self.MODE_VOLTAGE: return -self.getLimits(self.voltage, self.MODE_VOLTAGE)[0] return -self.getLimits(self.current, self.MODE_CURRENT)[0] def getHighLimitValue(self): """ Gets either the voltage or current high limit value, depending on operation mode. Returns ------- `float` """ if self.cachedMode() == self.MODE_VOLTAGE: return self.getLimits(self.voltage, self.MODE_VOLTAGE)[1] return self.getLimits(self.current, self.MODE_CURRENT)[1]
class MercuryITC(IScannable, StandardDevice): """ Class to control MercuryITC temperature controllers via EPICS. """ def __init__(self, pvName, mnemonic): """ **Constructor** See :class:`py4syn.epics.StandardDevice` Parameters ---------- pvName : `string` Power supply base naming of the PV (Process Variable) mnemonic : `string` Temperature controller mnemonic """ super().__init__(mnemonic) self.device = Device(pvName + ':', ['READ_TEMP_LOOP_HSET', 'READ_TEMP_LOOP_TSET','READ_TEMP_SIG_TEMP', 'READ_RAMP_TEMP','READ_LEVEL_METER','READ_SAMPLE_FLOW','READ_SHIELD_FLOW', 'SET_RAMP_TEMP', 'SET_TEMP_LOOP_TSET']) self.newTemp = Event() self.pvName = pvName def getValue(self): """ Returns the current measured temperature. Returns ------- `float` """ return self.device.get('READ_TEMP_SIG_TEMP') def getSP(self): """ Returns the current Set Point. Returns ------- `float """ time.sleep(0.5) return self.device.get('SET_TEMP_LOOP_TSET') def getTarget(self): """ Returns the current target temperature. Returns ------- `float` """ time.sleep(0.5) return self.device.get('READ_TEMP_LOOP_TSET') def getRealPosition(self): """ Returns the same as :meth:`getValue`. See: :meth:`getValue` Returns ------- `float` """ return self.getValue() def getRampRate(self): """ Returns the defined ramp rate. Returns ------- `int` """ return self.device.get('READ_RAMP_TEMP') def getLowLimitValue(self): """ Returns the controller low limit temperature. Returns ------- `float` """ return 90 def getHighLimitValue(self): """ Returns the controller high limit temperature. Returns ------- `float` """ return 500 def getRRHighLimitValue(self): return 25.0 def getRRLowLimitValue(self): return 1.0 def setRampRate(self, value): self.device.put('SET_RAMP_TEMP', value) def stop(self): '''Define SP to minimum temperature on maximum ramp rate''' self.setRampRate(self.getRRHighlimitValue) self.setValue(self.getLowLimitValue()) def hold(self): '''Set temperature to actual temperature''' actual_temp = self.getValue() self.setValue(actual_temp) def setValue(self, value, wait = False): if value < self.getLowLimitValue() or value > self.getHighLimitValue(): raise ValueError('Value exceeds limits') self.device.put('SET_TEMP_LOOP_TSET ', value) if wait: self.wait() def getP(self): """ Return the current P value at the furnace Returns ------- `double` """ getPV = self.device.PV('P') return getPV.get() def getI(self): """ Return the current I value at the furnace Returns ------- `double` """ getPV = self.device.PV('I') return getPV.get() def getD(self): """ Return the current D value at the furnace Returns ------- `double` """ getPV = self.device.PV('D') return getPV.get() def getPower(self): """ Return the current Power value at the furnace Returns ------- `double` """ getPV = self.device.PV('READ_TEMP_LOOP_HSET') return getPV.get() def getLevelMeter(self): """ Return the current N2 Level Meter of the dewar Returns ------- `double` """ getPV = self.device.PV('READ_LEVEL_METER') return getPV.get() def reachTemp(self): if self.getValue() < self.getSP() + DELTA and \ self.getValue() > self.getSP() - DELTA: return True return False def wait(self): """ Blocks until the requested temperature is achieved. """ self.newTemp.clear() while not self.reachTemp(): ca.flush_io() self.newTemp.wait(5) self.newTemp.clear()
class OmronE5CK(StandardDevice, IScannable): """ Class to control Omron E5CK temperature controllers via EPICS. Examples -------- >>> from py4syn.epics.OmronE5CKClass import OmronE5CK >>> >>> def showTemperature(pv='', name=''): ... e5ck = OmronE5CK(pv, name) ... print('Temperature is: %d' % e5ck.getValue()) ... >>> def fastRaiseTemperature(e5ck, amount, rate=30): ... e5ck.setRate(rate) ... e5ck.setValue(e5ck.getValue() + amount) ... >>> def complexRamp(e5ck): ... e5ck.setRate(10) ... e5ck.setValue(200) ... e5ck.wait() ... e5ck.setRate(2) ... e5ck.setValue(220) ... e5ck.wait() ... sleep(500) ... e5ck.setRate(5) ... e5ck.setValue(100) ... e5ck.wait() ... e5ck.stop() ... >>> import py4syn >>> from py4syn.epics.ScalerClass import Scaler >>> from py4syn.utils.counter import createCounter >>> from py4syn.utils.scan import scan >>> >>> def temperatureScan(start, end, rate, pv='', counter='', channel=2): ... e5ck = OmronE5CK(pv, 'e5ck') ... py4syn.mtrDB['e5ck'] = e5ck ... c = Scaler(counter, channel, 'simcountable') ... createCounter('counter', c, channel) ... e5ck.setRate(rate) ... scan('e5ck', start, end, 10, 1) ... e5ck.stop() ... """ STATUS_IS_RUNNING = 1<<7 PROGRAM_LENGTH = 4 COMMAND_GET_STEP = '4010000' COMMAND_SET_TARGET = '5%02d%04d' TARGETS = (5, 8, 11, 14,) TIMES = (7, 10, 13, 16,) def __init__(self, pvName, mnemonic): """ **Constructor** See :class:`py4syn.epics.StandardDevice` Parameters ---------- pvName : `string` Power supply base naming of the PV (Process Variable) mnemonic : `string` Temperature controller mnemonic """ super().__init__(mnemonic) self.device = Device(pvName + ':', ['termopar', 'target', 'status', 'stepNum', 'programTable', 'programming', 'run', 'stop', 'advance', 'setPatternCount', 'timeScale', 'level1', 'reset', 'pause', 'sendCommand']) self.programmingDone = Event() self.newTemperature = Event() self.newStep = Event() self.device.add_callback('programming', self.onProgrammingChange) self.device.add_callback('termopar', self.onTemperatureChange) self.device.add_callback('stepNum', self.onStepChange) self.timeScaleCache = self.device.get('timeScale') self.pvName = pvName self.rate = 5 self.presetDone = False def __str__(self): return '%s (%s)' % (self.getMnemonic(), self.pvName) def isRunning(self): """ Returns true if the controller is in program mode. Whenever it is program mode, it is following a target temperature. Returns ------- `bool` """ v = self.device.get('status') r = not bool(int(v) & self.STATUS_IS_RUNNING) if not r: self.presetDone = False return r def getValue(self): """ Returns the current measured temperature. Returns ------- `float` """ return self.device.get('termopar') def getTarget(self): """ Returns the current target temperature. If the device is running, the target temperature is the temperature the device is changing to. If the device is not running, the target temperature is ignored. Returns ------- `float` """ return self.device.get('target') def getRealPosition(self): """ Returns the same as :meth:`getValue`. See: :meth:`getValue` Returns ------- `float` """ return self.getValue() def getStepNumber(self): """ Helper method to get the current program step. Returns ------- `int` """ return self.device.get('stepNum') def getLowLimitValue(self): """ Returns the controller low limit temperature. Returns ------- `float` """ return 0.0 def getHighLimitValue(self): """ Returns the controller high limit temperature. Returns ------- `float` """ return 1300.0 def onProgrammingChange(self, value, **kwargs): """ Helper callback that tracks when the IOC finished programming the device. """ self.presetDone = False if value == 0: self.programmingDone.set() def onStepChange(self, value, **kwargs): """ Helper callback that indicates when a new program step has been reached """ self.newStep.set() def onTemperatureChange(self, value, **kwargs): """ Helper callback that indicates when the measured temperature has changed """ self.newTemperature.set() def stop(self): """ Stops executing the current temperature program and puts the device in idle state. In the idle state, the device will not try to set a target temperature. """ self.device.put('stop', 1) self.presetDone = False def run(self): """ Starts or resumes executing the current temperature program. """ self.device.put('run', 1) def advance(self): """ Helper method to skip the current program step and execute the next one. """ self.device.put('advance', 1) def pause(self): """ Pauses current ramp program. To resume program, use :meth:`run` See: :meth:`run` """ self.device.put('pause', 1) def sendCommand(self, command): """ Helper method to send a custom command to the controller. Parameters ---------- command : `str` The command to be send """ self.device.put('sendCommand', command.encode(), wait=True) def preset(self): """ Makes the controler enter a well defined known state. This method creates and runs an "empty" ramp program. The program simply mantains the current temperature forever, whatever that temperature is. This is mostly a helper function, to allow making complex temperature ramps starting from a known state and reusing the preset values. .. note:: Running a new program requires stopping the current program. While the program is stopped, the controller power generation drops to zero. Because of this power drop, this method may be slow to stabilize. """ self.stop() current = self.getValue() # Steps 0 and 2 are fake steps, steps 1 and 3 are the real ones. # The fake steps are used for synchronizing with the device. program = [self.PROGRAM_LENGTH] + self.PROGRAM_LENGTH*[current, 99] self.programmingDone.clear() self.device.put('setPatternCount', 9999) self.device.put('programTable', array(program)) ca.flush_io() self.programmingDone.wait(10) self.run() self.presetDone = True def getTimeScale(self): """ Returns the time scale being used by the controller. The timescale can either be zero, for hours:minutes, or one, for minutes:seconds. Returns ------- `int` """ t = self.device.PV('timeScale') v = t.get() t.get_ctrlvars() if t.severity == 0: self.timeScaleCache = v return self.timeScaleCache def setTimeScale(self, minutes): """ Changes the time scale being used by the controller. The timescale can either be zero, for hours:minutes, or one, for minutes:seconds. This operation requires switching the controller operation mode to be successful, and then a reset is issued after it. The whole operation takes more than 5 seconds. Parameters ---------- minutes : `int` Set to 1 for minutes:seconds, or 0 for hours:minutes """ if minutes == self.getTimeScale() and self.device.PV('timeScale').severity == 0: return t = self.getValue() self.device.put('level1', 1) self.device.put('timeScale', minutes) self.device.put('reset', 1) def getStepNumberSync(self): """ Helper module to retrieve an up-to-date value for the current program step number. Similar to :meth:`getStepNumber`, but it doesn't rely on monitor value and instead does a synchronous caget() call. See: :meth:`getStepNumber` Returns ------- `int` """ self.device.put('stepNum.PROC', 0, wait=True) v = self.device.PV('stepNum').get(use_monitor=False) return int(v) def synchronizeStep(self, current): """ Helper method to set up a constant temperature right before running a ramp program. This method detects if a current ramp program is running or not. If it's not, then it doesn't do anything. If there is a ramp running, then it configures and advances to a "synchronization step", that is, a step where the temperature does not change. This step marks the beginning of the new ramp. The method returns the resulting step number Parameters ---------- current : `float` The temperature target for the synchronization step Returns ------- `int` """ # This method uses the advance() call to skip steps. Suprisingly, advancing # steps with E5CK is not trivial. The reason for this is that E5CK quickly # acknowledges the advance command, but delays to actually advance. Ignoring # this deficiency results in other commands issued later doing the wrong thing. # In particular, calling advance again later may silently fail. We work around # this by using a synchronous call to get the current step number and a busy # wait to check when the step was really changed. # # To make things worse, some component in EPICS seems to break serialization by # not respecting the order which PVs are updated, so it's not possible to # change the program using two separate PVs, like, for example, stepNumConfig # setStepTarget, which are implemented in E5CK's IOC. Because of that, a custom # PV was added in the IOC to support arbitrary commands sent in a serialized # way. This sendCommand procedure is what this method uses. step = self.getStepNumberSync() while step % 2 == 1: target = self.TARGETS[(step+1)%self.PROGRAM_LENGTH] self.sendCommand(self.COMMAND_SET_TARGET % (target, current)) self.advance() # E5CK is slow, so loop until it changes state. This is required: calling # advance twice in a row doesn't work. A state transition must happen first. old = step while old == step: step = self.getStepNumberSync() assert step % 2 == 0 return step def timeToValue(self, t): """ Helper method to convert between minutes to the format used by the controller. Parameters ---------- t : `float` The desired time, in minutes Returns ------- `float` """ if self.getTimeScale() == 0: minutes = int(t)%60 hours = int(t)//60 value = 100*hours + minutes if hours > 99: raise OverflowError('Ramp time is too large: %g' % rampTime) else: minutes = int(t) if minutes > 99: raise OverflowError('Ramp time is too large with current settings: %g' % t) seconds = min(round((t-minutes)*60), 59) value = 100*minutes + seconds return value def setRate(self, r): """ Sets the ramp speed in degrees per minutes for use with :meth:`setValue`. This method does not send a command to the controller, it only stores the rate for the next ramps. See: :meth:`setValue` Parameters ---------- r : `float` Ramp speed in °C/min """ self.rate = r def setValue(self, v): """ Changes the temperature to a new value. This method calls preset if it has not already been called first. The speed that the new temperature is reached is set with :meth:`setRate`. The default rate is 5 °C/minute. See: :meth:`setRate` Parameters ---------- v : `float` The target temperature in °C """ # This method depends on a program preset being loaded and the program being # in a synchronization step. Given the two precondition, this method simply # programs a ramp, a synchronization step after the ramp and advances to the # ramp step. if not self.presetDone: self.preset() # We accept float as input, but the controller is integer only v = round(v) current = self.getValue() minutes = abs(v-current)/self.rate time = self.timeToValue(minutes) step = self.synchronizeStep(current) self.waitStep = (step+2)%self.PROGRAM_LENGTH x = self.TARGETS[step+1] y = self.TIMES[step+1] z = self.TARGETS[self.waitStep] self.sendCommand(self.COMMAND_SET_TARGET % (x, v)) self.sendCommand(self.COMMAND_SET_TARGET % (y, time)) self.sendCommand(self.COMMAND_SET_TARGET % (z, v)) self.advance() self.valueTarget = v def wait(self): """ Blocks until the requested temperature is achieved. """ if not self.presetDone: return # Waiting is done in two steps. First step waits until the program reaches # the next synchronization step. Second step waits util the measured temperature # reaches the requested temperature self.newStep.clear() while self.getStepNumber() != self.waitStep: ca.flush_io() self.newStep.wait(60) self.newStep.clear() self.newTemperature.clear() while self.getValue() != self.valueTarget: ca.flush_io() # Safety timeout, temperature didn't change after a long time if not self.newTemperature.wait(120): return self.newTemperature.clear()
class Keithley6514(StandardDevice, ICountable): """ Python class to help configuration and control the Keithley 6514 Electrometer. Keithley is an electrical instrument for measuring electric charge or electrical potential difference. This instrument is capable of measuring extremely low currents. E.g.: pico (10e-12), i.e.: 0,000 000 000 001. For more information, please, refer to: `Model 6514 System Electrometer Instruction Manual <http://www.tunl.duke.edu/documents/public/electronics/Keithley/keithley-6514-electrometer-manual.pdf>`_ """ def onStatusChange(self, value, **kw): self._counting = (value == 1) def __init__(self, pvName, mnemonic, timeBased=False): """ **Constructor** To use this Keithley Class you must pass the PV (Process Variable) prefix. .. Note:: e.g.: SXS:K6514 Examples -------- >>> from KeithleyClass import * >>> name = Keithley('SOL:K6514', 'k1') """ StandardDevice.__init__(self, mnemonic) self.pvName = pvName self.timeBased = timeBased self.keithley = Device(pvName+':', ('GetMed','SetMed','GetMedRank','SetMedRank','GetAver', 'SetAver','GetAverCoun','SetAverCoun','GetNPLC','SetNPLC', 'GetAutoZero', 'SetAutoZero','GetZeroCheck','SetZeroCheck', 'GetAverTCon','SetAverTCon','GetCurrRange','SetCurrRange', 'GetZeroCor','SetZeroCor', 'GetAutoCurrRange','SetAutoCurrRange' 'Count','ContinuesMode', 'CNT', 'OneMeasure')) self.pvMeasure = PV(pvName+':'+'Measure', auto_monitor=False) self._counting = self.isCountingPV() self.keithley.add_callback('CNT', self.onStatusChange) def isCountingPV(self): return (self.keithley.get('CNT') == 1) def isCounting(self): return self._counting def wait(self): while(self.isCounting()): ca.poll(0.00001) def getTriggerReading(self): """ Trigger and return reading(s). Returns ------- Value: Float, e.g.: -6.0173430000000003e-16. Examples -------- >>> name.getTriggerReading() >>> -1.0221850000000001e-15 """ return self.pvMeasure.get(use_monitor=False) #return self.keithley.get('Measure') def getCountNumberReading(self): """ Count the number of reading(s). Returns ------- Value: Integer, e.g.: 963. Examples -------- >>> name.CountNumberReading() >>> 161.0 """ return self.keithley.get('Count') def getStatusContinuesMode(self): """ Get the status of Continues Mode (enable/disable). Default: enable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getStatusContinuesMode() >>> True """ return bool(self.keithley.get('ContinuesMode')) def setStatusContinuesMode(self, cmode): """ Set enable/disable to continues mode. Let this enable if you want a continuing measuring. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.setStatusContinuesMode(0) """ if(cmode != 0 and cmode != 1): raise ValueError('Invalid number - It should be 0 or 1') self.keithley.put('ContinuesMode', cmode) def getAutoZeroing(self): """ Get the status of Auto Zero (enable/disable). Default: enable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getAutoZeroing() >>> True """ return bool(self.keithley.get('GetAutoZero')) def setAutoZeroing(self, autozero): """ Set enable/disable for Auto Zero. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.setAutoZeroing(1) """ if(autozero != 0 and autozero != 1): raise ValueError('Invalid number - It should be 0 or 1') self.keithley.put('SetAutoZero', autozero) def getMedianFilter(self): """ Get the status of Median Filter (enable/disable). Default: enable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getMedianFilter() >>> True """ return bool(self.keithley.get('GetMed')) def setMedianFilter(self, med): """ Set enable/disable for Median Filter. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.setMedianFilter(1) """ if(med != 0 and med != 1): raise ValueError('Invalid number - It should be 0 or 1') self.keithley.put('SetMed', med) def getMedianRank(self): """ Get the value of Median Rank, this number of sample readings are between 1 to 5. Default: 5. Returns ------- Value: Integer, i.e.: 1 to 5. Examples -------- >>> name.getMedianRank() >>> 5.0 """ return self.keithley.get('GetMedRank') def setMedianRank(self, medrank): """ Set the number of sample readings used for the median calculation. Parameters ---------- Value: Integer, i.e.: 1 to 5. Examples -------- >>> name.setMedianRank(3) """ if (medrank < 1 or medrank > 5): raise ValueError('Invalid number - It should be 1 to 5') self.keithley.put('SetMedRank', medrank) def getAverageDigitalFilter(self): """ Get the status of Digital Filter (enable/disable). Default: enable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getAverageDigitalFilter() >>> True """ return bool(self.keithley.get('GetAver')) def setAverageDigitalFilter(self, aver): """ Set enable/disable for Digital Filter. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.setAverageDigitalFilter(1) """ if(aver != 0 and aver != 1): raise ValueError('Invalid number - It should be 0 or 1') self.keithley.put('SetAver', aver) def getAverageCount(self): """ Get the number of filter count. Default: 10. Returns ------- Value: Integer, i.e.: 2 to 100. Examples -------- >>> name.getAverageCount() >>> 10.0 """ return self.keithley.get('GetAverCoun') def setAverageCount(self, avercoun): """ Set the number of filter count. Parameters ---------- Value: Integer, i.e.: 2 to 100. Examples -------- >>> name.setAverageCount(80) """ if (avercoun < 2 or avercoun > 100): raise ValueError('Invalid number - It should be 2 to 100') self.keithley.put('SetAverCoun', avercoun) def getIntegrationTime(self): """ Get the number of integration rate. Default: 1. Returns ------- Value: Float, i.e.: 0.01 to 10 (PLCs). Where 1 PLC for 60Hz is 16.67msec (1/60). Examples -------- >>> name.getIntegrationTime() >>> 1.0 """ return self.keithley.get('GetNPLC') def setIntegrationTime(self, nplc): """ Set the number of integration rate. Parameters ---------- Value: Float, i.e.: 0.01 to 10 (PLCs). Where 1 PLC for 60Hz is 16.67msec (1/60). Examples -------- >>> name.setIntegrationTime(0.01) """ if (nplc < 0.01 or nplc > 10): raise ValueError('Invalid number - It should be 0.01 to 10') self.keithley.put('SetNPLC', nplc) def getAverageTControl(self): """ Get the filter control. Default: REP. Returns ------- Value: String, i.e.: REP or MOV. Examples -------- >>> name.getAverageTControl() >>> 'REP' """ return self.keithley.get('GetAverTCon') def setAverageTControl(self, tcon): """ Set the filter control. Parameters ---------- Value: String, i.e.: 'REP' or 'MOV', where REP means 'Repeat' and MOV means 'Moving'. Examples -------- >>> name.setAverageTControl('MOV') """ if (tcon != 'REP' and tcon != 'MOV'): raise ValueError('Invalid name - It should be REP or MOV') self.keithley.put('SetAverTCon', bytes(tcon, 'ascii')) def getZeroCheck(self): """ Get the status of Zero Check (enable/disable). Default: disable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getZeroCheck() >>> False """ return bool(self.keithley.get('GetZeroCheck')) def setZeroCheck(self, check): """ Set enable/disable for Zero Check. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Returns ------- One value (1). Examples -------- >>> name.setZeroCheck(1) >>> 1 """ if(check != 0 and check != 1): raise ValueError('Invalid number - It should be 0 or 1') return self.keithley.put('SetZeroCheck', check) def getZeroCorrect(self): """ Get the status of Zero Correct (enable/disable). Default: disable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getZeroCorrect() >>> False """ return bool(self.keithley.get('GetZeroCor')) def setZeroCorrect(self, cor): """ Set enable/disable for Zero Correct. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Returns ------- One value (1). Examples -------- >>> name.setZeroCorrect(1) >>> 1 """ if(cor != 0 and cor != 1): raise ValueError('Invalid number - It should be 0 or 1') return self.keithley.put('SetZeroCor', cor) def getAutoCurrentRange(self): """ Get the status of Auto Current Range (enable/disable). Default: enable. Returns ------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Examples -------- >>> name.getAutoCurrentRange() >>> True """ return bool(self.keithley.get('GetAutoCurrRange')) def setAutoCurrentRange(self, autorange): """ Set enable/disable for Auto Current Range. Parameters ---------- Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable). Returns ------- One value (1). Examples -------- >>> name.setAutoCurrentRange(1) >>> 1 """ if(autorange != 0 and autorange != 1): raise ValueError('Invalid number - It should be 0 or 1') return self.keithley.put('SetAutoCurrRange', autorange) def getCurrentRange(self): """ Get the value of range. Default: Auto range. Returns ------- Value: Integer, i.e.: 0 (Undefined ZERO), 1 (Indefined UM), 2 (20 mA), 3 (2 mA), 4 (200 uA), 5 (20 uA), 6 (2 uA), 7 (200 nA), 8 (20 nA), 9 (2 nA), 10 (200 pA), 11 (20 pA). Examples -------- >>> name.getCurrentRange() >>> 11 """ return self.keithley.get('GetCurrRange') def setCurrentRange(self, curange): """ Set the range. Parameters ---------- Value: Integer, i.e.: 0 (Undefined ZERO), 1 (Indefined UM), 2 (20 mA), 3 (2 mA), 4 (200 uA), 5 (20 uA), 6 (2 uA), 7 (200 nA), 8 (20 nA), 9 (2 nA), 10 (200 pA), 11 (20 pA). Examples -------- >>> name.setCurrentRange(5) """ if (curange < 0 or curange > 11): raise ValueError('Invalid number - It should be 0 to 11') self.keithley.put('SetCurrRange', curange) def getValue(self, **kwargs): """ Get the current value of a countable device. Parameters ---------- kwargs : value Where needed informations can be passed, e.g. select which channel must be read. Returns ------- out : value Returns the current value of the device. Type of the value depends on device settings. """ return self.getTriggerReading() def setCountTime(self, time): """ Method to set the count time of a Keithley device. .. note:: Whenever the median filter is active, changing the count time results in the filter being reset, so the first measurement will take additional time to collect new data for the filter. The extra time is proportional to the median filter rank. After the first measurement, the following measurements will have the correct integration time. .. note:: Unlike scalers, the count time is only an approximation. The requested integration time will be split into multiple parts, which includes the analog integration time (varying between approximatelly 10ms to 50ms), the digital integration time (that averages a set of 2 to 100 analog integrations), and other operations unrelated to integration, like auto zero calibration (triples the integration time) and calculation times. When calling this method, the digital average filter will be activated if it's not already and the filter type will be set to repeat. See also: :meth:`setIntegrationTime`, :meth:`setAverageCount` Parameters ---------- time : value The target count time to be set. The allowed time range is 100ms to 15s (limited by software). Returns ------- out : None """ if(not self.timeBased): return if time < 0.1 or time > 15: raise ValueError('Invalid integration time: %g' % time) # Keithley timing model: # ---------------------- # # Keithley fundamental delay is the analog integration delay, which is the # time it takes to measure the current using the measurement hardware. # The integration delay can be configured to values in the range between # 166,7µs to 166,7ms (or 200µs to 200ms in 50Hz electricity grids). # On top of the analog integration delay, two delays are significant: # the digital filter delay, which works as a digital integrator (when configured # in "repeating" mode) and the auto zero setting, which performs continuous # device recalibration. The digital filter works by taking multiple analog # measurements, then averaging the result, so it multiplies the delay by the # repeat count. The auto zero setting always triples the integration time. # So, the basic initial timing model for the Keithley device is the following: # # (1) time = Azero*Rcount*Atime # # Where time is the final count time, Azero is 2,97 when auto zero is enabled, # or 0,95 when auto zero is disabled, Rcount is the digital average repeat count and # Atime is the analog integration time. For example, with auto zero enabled, # integration time of 33,33ms and a repeat count of 10,0, the total count time is # 990ms. # # Empirical tests with equation (1) were done by trying analog integration times # around 33,33ms and choosing a suitable repeat count. The region around 33,33ms # was chosen by chance and because it's inside the recommended integration range # (16,7ms to 166,7ms). # # The calculated repeat count is rounded to an integer and the analog integration # time is corrected back. For example, given an integration time of 0,5 seconds, # we set 33,67ms (close to 33,33ms) and repeat count 5, as calculated below: # # time = Azero*Rcount*Atime # 0,5 = 2,97*Rcount*0,03333 # Rcount = 5,0505... # Rcount,rounded = 5 # time = Azero*Rcount,rounded*Atime # 0,5 = 2,97*5*Atime # Atime = 33,67ms # # Using the above procedure to compare the modeled time and the real Keithley time # resulted in a line with factor and displacement errors: # # (2) time = Azero*Rcount*Atime*f + d # # The variable f represents an error proportional to the integration time, # while d represents a fixed delay. For example, f could be due to hardware # delays while integrating and computation overhead to calculate the # digital average. The delay d is due to "warm up" and "clean up" procedures, # in particular, due to device to computer communication. With a serial port # configuration, the factors were found to be the following: # # (2') time = Azero*Rcount*Atime*f' + d' # (3) f' = 1,09256, d' = 0,0427154 # # The serial port communication is significant and happens before and after the # acquisition. It takes 20,83ms for sending and receiving a measurement using the # serial port (20 bytes/960 bytes/s). This value needs to be removed from the # measured delay, since it's not part of the integration time. The resulting # equation is accurate enough for usage as the timing model for Keithley: # # (4) time = Azero*Rcount*Atime*1,09256 + 0,021882 # # Equation (4) can then be reversed and solved for Rcount and Atime: # # (5) Rcount = (time-0.021882)/(Azero*Atime*1,09256) # (6) Atime = (time-0.021882)/(Rcount*Atime*1,09256) # # The algorithm implemented calculates (5) assuming initially Atime == 33,33ms, # then rounds Rcount to an integer, calculates (6) with the resulting Rcount and # if results are not within proper bounds, it iterates a second time. # # Note: it is known that the first and second measurements after changing the # count time takes longer than usual to return a measurement. The timing becomes # more precise starting from the third measurement. When the median filter is # active, the first measurement takes much longer, because the median filter # buffer is cleaned and filled again. azero = 2.97 if self.getAutoZeroing() else 0.95 f = 1.09256 d = 0.021882 # Analog integration time initially equal to 33,33ms atime = 2/60 # Repeat count must be between 2 and 100 rcount = int((time-d)/(azero*atime*f)) rcount = max(rcount, 2) rcount = min(rcount, 100) # Then, solve for integration time atime = (time-d)/(azero*rcount*f) # If integration time is out of range, fix it and iterate one more time if atime < 0.1/60 or atime > 10/60: atime = max(atime, 0.1/60) atime = min(atime, 10/60) rcount = int((time-d)/(azero*atime*f)) rcount = max(rcount, 2) rcount = min(rcount, 100) atime = (time-d)/(azero*rcount*f) atime = max(atime, 0.1/60) atime = min(atime, 10/60) changed = False # Integration time must be rounded to 2 digits or Keithley will crash nplc = round(atime*60, 2) if nplc != self.getIntegrationTime(): self.setIntegrationTime(nplc) changed = True if rcount != self.getAverageCount(): self.setAverageCount(rcount) changed = True if not self.getAverageDigitalFilter(): self.setAverageDigitalFilter(1) changed = True if self.getAverageTControl() != 'REP': self.setAverageTControl('REP') changed = True if changed: ca.poll(0.05) def setPresetValue(self, channel, val): """ Abstract method to set the preset count of a countable target device. Parameters ---------- channel : `int` The monitor channel number val : `int` The preset value Returns ------- out : None """ pass def startCount(self): """ Abstract method trigger a count in a counter """ if(not self.getStatusContinuesMode()): self._counting = True self.keithley.put("OneMeasure", 1) pass def stopCount(self): """ Abstract method stop a count in a counter """ if(not self.getStatusContinuesMode()): self.keithley.put("OneMeasure", 0) pass def canMonitor(self): """ Abstract method to check if the device can or cannot be used as monitor. Returns ------- out : `bool` """ return False def canStopCount(self): """ Abstract method to check if the device can or cannot stop the count and return values. Returns ------- out : `bool` """ return True