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 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 ADMonoImagePanel(wx.Panel): """Image Panel for monochromatic Area Detector""" ad_attrs = ('image1:ArrayData', 'image1:ArraySize0_RBV', 'image1:ArraySize1_RBV', 'cam1:ArrayCounter_RBV') def __init__(self, parent, prefix=None, writer=None, motion_writer=None, draw_objects=None, rot90=0, thumbnail=None, contrast_level=0, size=(600, 600), **kws): super(ADMonoImagePanel, self).__init__(parent, -1, size=size) self.drawing = False self.adcam = None self.image_id = -1 self.x = self.y = 0 self.writer = writer self.motion_writer = motion_writer self.thumbnail = thumbnail self.thumbmode = 'click' self.scale = 0.8 self.colormap = None self.contrast_levels = [contrast_level, 100.0-contrast_level] self.rot90 = rot90 self.flipv = False self.fliph = False self.image = None self.bitmap_size = (2, 2) self.data = np.arange(25).reshape(5, 5) self.panel_size = self.GetSize() self.draw_objects = None self.SetBackgroundColour("#E4E4E4") self.SetBackgroundStyle(wx.BG_STYLE_PAINT) self.Bind(wx.EVT_SIZE, self.onSize) self.Bind(wx.EVT_PAINT, self.onPaint) if self.motion_writer is not None: self.Bind(wx.EVT_MOTION, self.onMotion) self.Bind(wx.EVT_LEFT_DOWN, self.onLeftDown) self.Bind(wx.EVT_RIGHT_DOWN, self.onRightDown) self.build_popupmenu() self.connect_pvs(prefix) self.restart_fps_counter() def restart_fps_counter(self, nsamples=100): self.capture_times = deque([], maxlen=nsamples) if self.writer is not None: self.writer("") def connect_pvs(self, prefix): self.adcam = Device(prefix, delim='', attrs=self.ad_attrs) self.adcam.add_callback('cam1:ArrayCounter_RBV', self.onNewImage) def GetImageSize(self): return (self.adcam.get('image1:ArraySize0_RBV'), self.adcam.get('image1:ArraySize1_RBV')) def onMotion(self, evt=None): """report motion events within image""" if self.motion_writer is None and self.thumbnail is None: return if self.thumbmode == 'live': self.show_thumbnail(evt.GetX(), evt.GetY()) def show_thumbnail(self, evt_x, evt_y): img_w, img_h = self.bitmap_size if self.rot90 in (1, 3): img_w, img_h = img_h, img_w pan_w, pan_h = self.panel_size pad_w, pad_h = (pan_w-img_w)/2.0, (pan_h-img_h)/2.0 x = int(0.5 + (evt_x - pad_w)/self.scale) y = int(0.5 + (evt_y - pad_h)/self.scale) if self.rot90 in (1, 3): x, y = y, x self.x, self.y = x, y dh, dw = self.data.shape if y > -1 and y < dh and x > -1 and x < dw: self.motion_writer(PIXEL_FMT %(x, y, self.data[y, x])) if self.thumbnail is not None: self.thumbnail.xcen = x self.thumbnail.ycen = y self.thumbnail.Refresh() else: self.motion_writer('') def build_popupmenu(self): self.popup_menu = popup = wx.Menu() MenuItem(self, popup, 'Follow Cursor for Thumbnail', '', self.thumb_motion_mode) MenuItem(self, popup, 'Left Click to Show Thumbnail', '', self.thumb_click_mode) def thumb_motion_mode(self, evt=None): self.thumbmode = 'live' def thumb_click_mode(self, evt=None): self.thumbmode = 'click' def onLeftDown(self, evt=None): if self.thumbmode == 'click': self.show_thumbnail(evt.GetX(), evt.GetY()) def onRightDown(self, evt=None): wx.CallAfter(self.PopupMenu, self.popup_menu, evt.GetPosition()) @DelayedEpicsCallback def onNewImage(self, pvname=None, value=None, **kws): if value > self.image_id and not self.drawing: self.drawing = True self.image_id = value self.Refresh() self.drawing = False def GrabNumpyImage(self): """get raw image data, as numpy ndarray, correctly shaped""" if True: data = self.adcam.PV('image1:ArrayData').get() else: # except: data = None if data is not None: w, h = self.GetImageSize() data = data.reshape((h, w)) if self.flipv: data = data[::-1, :] if self.fliph: data = data[:, ::-1] if self.rot90 == 1: data = data.transpose() elif self.rot90 == 2: data = data[::-1, ::-1] elif self.rot90 == 3: data = data[::-1, ::-1].transpose() poll() return data def GrabWxImage(self): """get wx Image: - scaled in size - color table applied - flipped and/or rotated - contrast levels set """ data = self.GrabNumpyImage() if data is None: return self.capture_times.append(time.time()) self.data = data jmin, jmax = np.percentile(data, self.contrast_levels) if self.thumbnail is not None: self.thumbnail.contrast_levels = self.contrast_levels self.thumbnail.colormap = self.colormap data = (np.clip(data, jmin, jmax) - jmin)/(jmax+0.001) h, w = data.shape # self.GetImageSize() if callable(self.colormap): data = self.colormap(data) if data.shape[2] == 4: # with alpha channel image = wx.Image(w, h, (data[:,:,:3]*255.).astype('uint8'), (data[:,:,3]*255.).astype('uint8')) else: image = wx.Image(w, h, (data*255.).astype('uint8')) else: rgb = np.zeros((h, w, 3), dtype='float') rgb[:, :, 0] = rgb[:, :, 1] = rgb[:, :, 2] = data image = wx.Image(w, h, (rgb*255.).astype('uint8')) return image.Scale(int(self.scale*w), int(self.scale*h)) def onSize(self, evt=None): if evt is not None: fh, fw = evt.GetSize() else: fh, fw = self.GetSize() h, w = self.GetImageSize() if self.rot90 in (1, 3): w, h = h, w self.scale = max(0.10, min(0.98*fw/(w+0.1), 0.98*fh/(h+0.1))) wx.CallAfter(self.Refresh) def onPaint(self, event): image = self.GrabWxImage() if image is None: return if len(self.capture_times) > 2 and self.writer is not None: ct = self.capture_times fps = (len(ct)-1) / (ct[-1]-ct[0]) self.writer("Image %d: %.1f fps" % (self.image_id, fps)) bitmap = wx.Bitmap(image) self.full_size = image.GetSize() bmp_w, bmp_h = self.bitmap_size = bitmap.GetSize() pan_w, pan_h = self.panel_size = self.GetSize() pad_w, pad_h = int(1+(pan_w-bmp_w)/2.0), int(1+(pan_h-bmp_h)/2.0) dc = wx.AutoBufferedPaintDC(self) dc.Clear() dc.DrawBitmap(bitmap, pad_w, pad_h, useMask=True) x, y = self.x, self.y dh, dw = self.data.shape if y > -1 and y < dh and x > -1 and x < dw: self.motion_writer(PIXEL_FMT %(x, y, self.data[y, x])) if self.thumbnail is not None: self.thumbnail.data = self.data self.thumbnail.Refresh() def __draw_objects(self, dc, img_w, img_h, pad_w, pad_h): dc.SetBrush(wx.Brush('Black', wx.BRUSHSTYLE_TRANSPARENT)) if self.draw_objects is not None: for obj in self.draw_objects: shape = obj.get('shape', None) color = obj.get('color', None) if color is None: color = obj.get('colour', 'Black') color = wx.Colour(*color) width = obj.get('width', 1.0) style = obj.get('style', wx.SOLID) args = obj.get('args', [0, 0, 0, 0]) kws = obj.get('kws', {}) method = getattr(dc, 'Draw%s' % (shape.title()), None) if shape.title() == 'Line': margs = [pad_w + args[0]*img_w, pad_h + args[1]*img_h, pad_w + args[2]*img_w, pad_h + args[3]*img_h] elif shape.title() == 'Circle': margs = [pad_w + args[0]*img_w, pad_h + args[1]*img_h, args[2]*img_w] if method is not None: dc.SetPen(wx.Pen(color, width, style)) method(*margs, **kws)
class ADMonoImagePanel(wx.Panel): """Image Panel for monochromatic Area Detector""" ad_attrs = ('image1:ArrayData', 'image1:ArraySize0_RBV', 'image1:ArraySize1_RBV', 'cam1:ArrayCounter_RBV') def __init__(self, parent, prefix=None, writer=None, draw_objects=None, rot90=0, contrast_level=0, size=(600, 600), **kws): super(ADMonoImagePanel, self).__init__(parent, -1, size=size) self.drawing = False self.adcam = None self.image_id = -1 self.writer = writer self.scale = 0.8 self.colormap = None self.contrast_levels = [contrast_level, 100.0-contrast_level] self.rot90 = rot90 self.flipv = False self.fliph = False self.image = None self.draw_objects = None self.SetBackgroundColour("#E4E4E4") self.SetBackgroundStyle(wx.BG_STYLE_PAINT) self.Bind(wx.EVT_SIZE, self.onSize) self.Bind(wx.EVT_PAINT, self.onPaint) self.connect_pvs(prefix) self.restart_fps_counter() def restart_fps_counter(self, nsamples=100): self.capture_times = deque([], maxlen=nsamples) if self.writer is not None: self.writer("") def connect_pvs(self, prefix): prefix = fix_ad_prefix(prefix) self.adcam = Device(prefix, delim='', attrs=self.ad_attrs) self.adcam.add_callback('cam1:ArrayCounter_RBV', self.onNewImage) def GetImageSize(self): return (self.adcam.get('image1:ArraySize0_RBV'), self.adcam.get('image1:ArraySize1_RBV')) @DelayedEpicsCallback def onNewImage(self, pvname=None, value=None, **kws): if value > self.image_id and not self.drawing: self.drawing = True self.image_id = value self.Refresh() self.drawing = False def GrabNumpyImage(self): """get raw image data, as numpy ndarray, correctly shaped""" try: data = self.adcam.PV('image1:ArrayData').get() except: data = None if data is not None: w, h = self.GetImageSize() data = data.reshape((h, w)) poll() return data def GrabWxImage(self): """get wx Image: - scaled in size - color table applied - flipped and/or rotated - contrast levels set """ data = self.GrabNumpyImage() if data is None: return self.capture_times.append(time.time()) jmin, jmax = np.percentile(data, self.contrast_levels) data = (np.clip(data, jmin, jmax) - jmin)/(jmax+0.001) w, h = self.GetImageSize() if callable(self.colormap): data = self.colormap(data) if data.shape[2] == 4: # with alpha channel image = wx.Image(w, h, (data[:,:,:3]*255.).astype('uint8'), (data[:,:,3]*255.).astype('uint8')) else: image = wx.Image(w, h, (data*255.).astype('uint8')) else: rgb = np.zeros((h, w, 3), dtype='float') rgb[:, :, 0] = rgb[:, :, 1] = rgb[:, :, 2] = data image = wx.Image(w, h, (rgb*255.).astype('uint8')) if self.flipv: image = image.Mirror(False) if self.fliph: image = image.Mirror(True) if self.rot90 != 0: for i in range(self.rot90): image = image.Rotate90(True) w, h = h, w return image.Scale(int(self.scale*w), int(self.scale*h)) def onSize(self, evt=None): if evt is not None: fh, fw = evt.GetSize() else: fh, fw = self.GetSize() w, h = self.GetImageSize() self.scale = max(0.10, min(fw/(w+5.0), fh/(h+5.0))) def onPaint(self, event): image = self.GrabWxImage() if image is not None: if len(self.capture_times) > 2 and self.writer is not None: ct = self.capture_times fps = (len(ct)-1) / (ct[-1]-ct[0]) self.writer("Image %d: %.1f fps" % (self.image_id, fps)) bitmap = wx.Bitmap(image) bmp_w, bmp_h = bitmap.GetSize() pan_w, pan_h = self.GetSize() pad_w, pad_h = int(1+(pan_w-bmp_w)/2.0), int(1+(pan_h-bmp_h)/2.0) dc = wx.AutoBufferedPaintDC(self) dc.Clear() dc.DrawBitmap(bitmap, pad_w, pad_h, useMask=True) # self.__draw_objects(dc, img_w, img_h, pad_w, pad_h) def __draw_objects(self, dc, img_w, img_h, pad_w, pad_h): dc.SetBrush(wx.Brush('Black', wx.BRUSHSTYLE_TRANSPARENT)) if self.draw_objects is not None: for obj in self.draw_objects: shape = obj.get('shape', None) color = obj.get('color', None) if color is None: color = obj.get('colour', 'Black') color = wx.Colour(*color) width = obj.get('width', 1.0) style = obj.get('style', wx.SOLID) args = obj.get('args', [0, 0, 0, 0]) kws = obj.get('kws', {}) method = getattr(dc, 'Draw%s' % (shape.title()), None) if shape.title() == 'Line': margs = [pad_w + args[0]*img_w, pad_h + args[1]*img_h, pad_w + args[2]*img_w, pad_h + args[3]*img_h] elif shape.title() == 'Circle': margs = [pad_w + args[0]*img_w, pad_h + args[1]*img_h, args[2]*img_w] if method is not None: dc.SetPen(wx.Pen(color, width, style)) method(*margs, **kws)
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 ADMonoImagePanel(wx.Panel): """Image Panel for monochromatic Area Detector""" ad_attrs = ('image1:ArrayData', 'image1:ArraySize0_RBV', 'image1:ArraySize1_RBV', 'cam1:ArrayCounter_RBV') def __init__(self, parent, prefix=None, writer=None, motion_writer=None, draw_objects=None, rot90=0, thumbnail=None, contrast_level=0, size=(600, 600), **kws): super(ADMonoImagePanel, self).__init__(parent, -1, size=size) self.drawing = False self.adcam = None self.image_id = -1 self.x = self.y = 0 self.writer = writer self.motion_writer = motion_writer self.thumbnail = thumbnail self.thumbmode = 'click' self.scale = 0.8 self.colormap = None self.contrast_levels = [contrast_level, 100.0 - contrast_level] self.rot90 = rot90 self.flipv = False self.fliph = False self.image = None self.bitmap_size = (2, 2) self.data = np.arange(25).reshape(5, 5) self.panel_size = self.GetSize() self.draw_objects = None self.SetBackgroundColour("#E4E4E4") self.SetBackgroundStyle(wx.BG_STYLE_PAINT) self.Bind(wx.EVT_SIZE, self.onSize) self.Bind(wx.EVT_PAINT, self.onPaint) if self.motion_writer is not None: self.Bind(wx.EVT_MOTION, self.onMotion) self.Bind(wx.EVT_LEFT_DOWN, self.onLeftDown) self.Bind(wx.EVT_RIGHT_DOWN, self.onRightDown) self.build_popupmenu() self.connect_pvs(prefix) self.restart_fps_counter() def restart_fps_counter(self, nsamples=100): self.capture_times = deque([], maxlen=nsamples) if self.writer is not None: self.writer("") def connect_pvs(self, prefix): self.adcam = Device(prefix, delim='', attrs=self.ad_attrs) self.adcam.add_callback('cam1:ArrayCounter_RBV', self.onNewImage) def GetImageSize(self): return (self.adcam.get('image1:ArraySize0_RBV'), self.adcam.get('image1:ArraySize1_RBV')) def onMotion(self, evt=None): """report motion events within image""" if self.motion_writer is None and self.thumbnail is None: return if self.thumbmode == 'live': self.show_thumbnail(evt.GetX(), evt.GetY()) def show_thumbnail(self, evt_x, evt_y): img_w, img_h = self.bitmap_size if self.rot90 in (1, 3): img_w, img_h = img_h, img_w pan_w, pan_h = self.panel_size pad_w, pad_h = (pan_w - img_w) / 2.0, (pan_h - img_h) / 2.0 x = int(0.5 + (evt_x - pad_w) / self.scale) y = int(0.5 + (evt_y - pad_h) / self.scale) if self.rot90 in (1, 3): x, y = y, x self.x, self.y = x, y dh, dw = self.data.shape if y > -1 and y < dh and x > -1 and x < dw: self.motion_writer(PIXEL_FMT % (x, y, self.data[y, x])) if self.thumbnail is not None: self.thumbnail.xcen = x self.thumbnail.ycen = y self.thumbnail.Refresh() else: self.motion_writer('') def build_popupmenu(self): self.popup_menu = popup = wx.Menu() MenuItem(self, popup, 'Follow Cursor for Thumbnail', '', self.thumb_motion_mode) MenuItem(self, popup, 'Left Click to Show Thumbnail', '', self.thumb_click_mode) def thumb_motion_mode(self, evt=None): self.thumbmode = 'live' def thumb_click_mode(self, evt=None): self.thumbmode = 'click' def onLeftDown(self, evt=None): if self.thumbmode == 'click': self.show_thumbnail(evt.GetX(), evt.GetY()) def onRightDown(self, evt=None): wx.CallAfter(self.PopupMenu, self.popup_menu, evt.GetPosition()) @DelayedEpicsCallback def onNewImage(self, pvname=None, value=None, **kws): if value > self.image_id and not self.drawing: self.drawing = True self.image_id = value self.Refresh() self.drawing = False def GrabNumpyImage(self): """get raw image data, as numpy ndarray, correctly shaped""" if True: data = self.adcam.PV('image1:ArrayData').get() else: # except: data = None if data is not None: w, h = self.GetImageSize() data = data.reshape((h, w)) if self.flipv: data = data[::-1, :] if self.fliph: data = data[:, ::-1] if self.rot90 == 1: data = data.transpose() elif self.rot90 == 2: data = data[::-1, ::-1] elif self.rot90 == 3: data = data[::-1, ::-1].transpose() poll() return data def GrabWxImage(self): """get wx Image: - scaled in size - color table applied - flipped and/or rotated - contrast levels set """ data = self.GrabNumpyImage() if data is None: return self.capture_times.append(time.time()) self.data = data jmin, jmax = np.percentile(data, self.contrast_levels) if self.thumbnail is not None: self.thumbnail.contrast_levels = self.contrast_levels self.thumbnail.colormap = self.colormap data = (np.clip(data, jmin, jmax) - jmin) / (jmax + 0.001) h, w = data.shape # self.GetImageSize() if callable(self.colormap): data = self.colormap(data) if data.shape[2] == 4: # with alpha channel image = wx.Image(w, h, (data[:, :, :3] * 255.).astype('uint8'), (data[:, :, 3] * 255.).astype('uint8')) else: image = wx.Image(w, h, (data * 255.).astype('uint8')) else: rgb = np.zeros((h, w, 3), dtype='float') rgb[:, :, 0] = rgb[:, :, 1] = rgb[:, :, 2] = data image = wx.Image(w, h, (rgb * 255.).astype('uint8')) return image.Scale(int(self.scale * w), int(self.scale * h)) def onSize(self, evt=None): if evt is not None: fh, fw = evt.GetSize() else: fh, fw = self.GetSize() h, w = self.GetImageSize() if self.rot90 in (1, 3): w, h = h, w self.scale = max(0.10, min(0.98 * fw / (w + 0.1), 0.98 * fh / (h + 0.1))) wx.CallAfter(self.Refresh) def onPaint(self, event): image = self.GrabWxImage() if image is None: return if len(self.capture_times) > 2 and self.writer is not None: ct = self.capture_times fps = (len(ct) - 1) / (ct[-1] - ct[0]) self.writer("Image %d: %.1f fps" % (self.image_id, fps)) bitmap = wx.Bitmap(image) self.full_size = image.GetSize() bmp_w, bmp_h = self.bitmap_size = bitmap.GetSize() pan_w, pan_h = self.panel_size = self.GetSize() pad_w, pad_h = int(1 + (pan_w - bmp_w) / 2.0), int(1 + (pan_h - bmp_h) / 2.0) dc = wx.AutoBufferedPaintDC(self) dc.Clear() dc.DrawBitmap(bitmap, pad_w, pad_h, useMask=True) x, y = self.x, self.y dh, dw = self.data.shape if y > -1 and y < dh and x > -1 and x < dw: self.motion_writer(PIXEL_FMT % (x, y, self.data[y, x])) if self.thumbnail is not None: self.thumbnail.data = self.data self.thumbnail.Refresh() def __draw_objects(self, dc, img_w, img_h, pad_w, pad_h): dc.SetBrush(wx.Brush('Black', wx.BRUSHSTYLE_TRANSPARENT)) if self.draw_objects is not None: for obj in self.draw_objects: shape = obj.get('shape', None) color = obj.get('color', None) if color is None: color = obj.get('colour', 'Black') color = wx.Colour(*color) width = obj.get('width', 1.0) style = obj.get('style', wx.SOLID) args = obj.get('args', [0, 0, 0, 0]) kws = obj.get('kws', {}) method = getattr(dc, 'Draw%s' % (shape.title()), None) if shape.title() == 'Line': margs = [ pad_w + args[0] * img_w, pad_h + args[1] * img_h, pad_w + args[2] * img_w, pad_h + args[3] * img_h ] elif shape.title() == 'Circle': margs = [ pad_w + args[0] * img_w, pad_h + args[1] * img_h, args[2] * img_w ] if method is not None: dc.SetPen(wx.Pen(color, width, style)) method(*margs, **kws)
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 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 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 == 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 ADMonoImagePanel(wx.Panel): """Image Panel for monochromatic Area Detector""" ad_attrs = ('image1:ArrayData', 'image1:ArraySize0_RBV', 'image1:ArraySize1_RBV', 'cam1:ArrayCounter_RBV') def __init__(self, parent, prefix=None, writer=None, draw_objects=None, rot90=0, contrast_level=0, size=(600, 600), **kws): super(ADMonoImagePanel, self).__init__(parent, -1, size=size) self.drawing = False self.adcam = None self.image_id = -1 self.writer = writer self.scale = 0.8 self.colormap = None self.contrast_levels = [contrast_level, 100.0 - contrast_level] self.rot90 = rot90 self.flipv = False self.fliph = False self.image = None self.draw_objects = None self.SetBackgroundColour("#E4E4E4") self.SetBackgroundStyle(wx.BG_STYLE_PAINT) self.Bind(wx.EVT_SIZE, self.onSize) self.Bind(wx.EVT_PAINT, self.onPaint) self.connect_pvs(prefix) self.restart_fps_counter() def restart_fps_counter(self, nsamples=100): self.capture_times = deque([], maxlen=nsamples) if self.writer is not None: self.writer("") def connect_pvs(self, prefix): prefix = fix_ad_prefix(prefix) self.adcam = Device(prefix, delim='', attrs=self.ad_attrs) self.adcam.add_callback('cam1:ArrayCounter_RBV', self.onNewImage) def GetImageSize(self): return (self.adcam.get('image1:ArraySize0_RBV'), self.adcam.get('image1:ArraySize1_RBV')) @DelayedEpicsCallback def onNewImage(self, pvname=None, value=None, **kws): if value > self.image_id and not self.drawing: self.drawing = True self.image_id = value self.Refresh() self.drawing = False def GrabNumpyImage(self): """get raw image data, as numpy ndarray, correctly shaped""" try: data = self.adcam.PV('image1:ArrayData').get() except: data = None if data is not None: w, h = self.GetImageSize() data = data.reshape((h, w)) poll() return data def GrabWxImage(self): """get wx Image: - scaled in size - color table applied - flipped and/or rotated - contrast levels set """ data = self.GrabNumpyImage() if data is None: return self.capture_times.append(time.time()) jmin, jmax = np.percentile(data, self.contrast_levels) data = (np.clip(data, jmin, jmax) - jmin) / (jmax + 0.001) w, h = self.GetImageSize() if callable(self.colormap): data = self.colormap(data) if data.shape[2] == 4: # with alpha channel image = wx.Image(w, h, (data[:, :, :3] * 255.).astype('uint8'), (data[:, :, 3] * 255.).astype('uint8')) else: image = wx.Image(w, h, (data * 255.).astype('uint8')) else: rgb = np.zeros((h, w, 3), dtype='float') rgb[:, :, 0] = rgb[:, :, 1] = rgb[:, :, 2] = data image = wx.Image(w, h, (rgb * 255.).astype('uint8')) if self.flipv: image = image.Mirror(False) if self.fliph: image = image.Mirror(True) if self.rot90 != 0: for i in range(self.rot90): image = image.Rotate90(True) w, h = h, w return image.Scale(int(self.scale * w), int(self.scale * h)) def onSize(self, evt=None): if evt is not None: fh, fw = evt.GetSize() else: fh, fw = self.GetSize() w, h = self.GetImageSize() self.scale = max(0.10, min(fw / (w + 5.0), fh / (h + 5.0))) def onPaint(self, event): image = self.GrabWxImage() if image is not None: if len(self.capture_times) > 2 and self.writer is not None: ct = self.capture_times fps = (len(ct) - 1) / (ct[-1] - ct[0]) self.writer("Image %d: %.1f fps" % (self.image_id, fps)) bitmap = wx.Bitmap(image) bmp_w, bmp_h = bitmap.GetSize() pan_w, pan_h = self.GetSize() pad_w, pad_h = int(1 + (pan_w - bmp_w) / 2.0), int(1 + (pan_h - bmp_h) / 2.0) dc = wx.AutoBufferedPaintDC(self) dc.Clear() dc.DrawBitmap(bitmap, pad_w, pad_h, useMask=True) # self.__draw_objects(dc, img_w, img_h, pad_w, pad_h) def __draw_objects(self, dc, img_w, img_h, pad_w, pad_h): dc.SetBrush(wx.Brush('Black', wx.BRUSHSTYLE_TRANSPARENT)) if self.draw_objects is not None: for obj in self.draw_objects: shape = obj.get('shape', None) color = obj.get('color', None) if color is None: color = obj.get('colour', 'Black') color = wx.Colour(*color) width = obj.get('width', 1.0) style = obj.get('style', wx.SOLID) args = obj.get('args', [0, 0, 0, 0]) kws = obj.get('kws', {}) method = getattr(dc, 'Draw%s' % (shape.title()), None) if shape.title() == 'Line': margs = [ pad_w + args[0] * img_w, pad_h + args[1] * img_h, pad_w + args[2] * img_w, pad_h + args[3] * img_h ] elif shape.title() == 'Circle': margs = [ pad_w + args[0] * img_w, pad_h + args[1] * img_h, args[2] * img_w ] if method is not None: dc.SetPen(wx.Pen(color, width, style)) method(*margs, **kws)
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