def buffering_low(self): status = PV('status') if not util.check_device('C1', self.proc) and status.get() in range(0,3): print "device not connected" return False count3 = PV('in_counts_3') low_3 = PV('low_limit_3') low_4 = PV('low_limit_4') trig_buffer = PV('trig_buffer') init = PV('initiate') poll(evt=1.e-5, iot=0.01) data3 = [] def getCount3(pvname, value, **kw): data3.append(value) if util.put_check(low_3, 0.0) and util.put_check(low_4, 0.0) and util.put_check(trig_buffer, 1000) and util.put_fuzzy('analog_out_period', 10e-5, 0.05): pass else: print "setting not taking place" return False, False count3.add_callback(getCount3) init.put(1) t0 = time.time() while time.time() - t0 < 3: poll(evt=1.e-5, iot=0.01) time.sleep(2) return len(data3)
class Motor(object): def __init__(self, name='SOL1B_M1'): if name not in mtc.MOTORS.keys(): raise ValueError('You have not specified a valid motor') motor_dict = mtc.MOTORS[name] self._name = name self._set = PV(motor_dict['set']) self._rbv = PV(motor_dict['rbv']) self._status = PV(motor_dict['status']) self._status_vars = self._status.get_ctrlvars() self._logger = logger.custom_logger(__name__) @property def name(self): return self._name @property def pos_set(self): return self._set.get() @pos_set.setter def pos_set(self, val): if not isinstance(val, int) or isinstance(val, float): self._logger('position must be int or float') return self._set.put(val) @property def pos_rbv(self): return self._rbv.get() @property def status_vars(self): return self._status_vars
def fault_codes(self): connect = self.proc.expect( [pexpect.TIMEOUT, pexpect.EOF, 'success'], timeout=5) if connect != 2: return -1 cmux_0, cmux_1, cmux_2, cmux_3 = PV('c_mux_0'), PV('c_mux_1'), PV('c_mux_2'), PV('c_mux_3') fault_message = PV('r_psu_fault_message') faults = [] perms = itertools.product([0,1], repeat=4) for i,j,k,c in list(perms): #print i,j,k,c cmux_0.put(i) poll(evt=0.1, iot=0.1) cmux_1.put(j) poll(evt=0.1, iot=0.1) cmux_2.put(k) poll(evt=0.1, iot=0.1) cmux_3.put(c) poll(evt=0.1, iot=0.1) faults.append(fault_message.get()) #print cmux_1.get(), cmux_2.get(), cmux_3.get(), cmux_4.get() return faults
def setupBlComm(): # global message_string_pv thread.start_new_thread(process_commands,(.05,)) # message_string_pv = PV(beamlineName + "_comm:message_string") comm_pv = PV(beamlineName + "_comm:command_s") comm_pv.put("\n",wait=True) comm_pv.add_callback(comm_cb)
def move(self, val, wait=True, delta=0.005, timeout=360.0): """Put value and press Go button.""" PV.put(self, val) sleep(0.2) self.go.put(1) if wait: Motor.motorWait(self, val, delta, timeout)
class BeckhoffMotor(Motor): """Beckhoff Motor class which inherits from pvScan Motor class.""" def __init__(self, pvname, pvnumber=0): if 'ESB' in pvname: rbv = pvname.split(':')[0] + ':CALC:' + ':'.join(pvname.split(':')[3:5]) + ':POS:MM' go = pvname.split(':')[0] + ':BO:' + ':'.join(pvname.split(':')[3:5]) + ':GO:POS' abort = pvname.split(':')[0] + ':BO:' + ':'.join(pvname.split(':')[3:5]) + ':STOP' elif 'UEDM' in pvname: rbv = pvname.split(':')[0] + ':UEDM:' + 'AI:' + pvname.split(':')[-2] + ':POS' go = pvname.split(':')[0] + ':UEDM:' + 'BO:' + pvname.split(':')[-2] + ':GOPOS' abort = pvname.split(':')[0] + ':UEDM:' + pvname.split(':')[-2] + ':STOP' else: rbv = pvname.split(':')[0] + ':CALC:' + ':'.join(pvname.split(':')[2:3]) + ':POS:MM' go = pvname.split(':')[0] + ':BO:' + ':'.join(pvname.split(':')[2:3]) + ':GO:POS:ABS' abort = pvname.split(':')[0] + ':BO:' + ':'.join(pvname.split(':')[2:3]) + ':STOP' BasePv.__init__(self, pvname, pvnumber, rbv) self.go = PV(go) self.abort = PV(abort) def move(self, val, wait=True, delta=0.005, timeout=360.0): """Put value and press Go button.""" PV.put(self, val) sleep(0.2) self.go.put(1) if wait: Motor.motorWait(self, val, delta, timeout)
def testEnumPut(self): pv = PV(pvnames.enum_pv) self.assertIsNot(pv, None) pv.put('Stop') time.sleep(0.1) val = pv.get() self.assertEqual(val, 0)
def acquisition_modes(self): if not self.connected: print "Device not connected" return False data = [] acquisition_mode = PV('acquisition_mode') burst_count = PV('burst_count') poll(evt=0.1, iot=0.1) print acquisition_mode.get() for i in range(0, 6): #acquisition_mode.put(i) util.put_check(acquisition_mode, i) if i == 5: util.put_check(burst_count, 0) #util.put_check(acquisition_mode, i) poll(evt=0.1, iot=0.1) print acquisition_mode.get() if acquisition_mode.get() == i: data.append(True) else: data.append(False) print data #teardown #acquisition_mode.put(0) #util.put_check(acquisition_mode, 1) acquisition_mode.put(1) print acquisition_mode.get() util.put_check(acquisition_mode, 0) #acquisition_mode.put(0) print acquisition_mode.get() poll(evt=1.0, iot=1.0) return data
def move(self, val, wait=True, delta=0.005, timeout=360.0): """Put value and press Go button.""" PV.put(self, val) sleep(1) self.go.put(1) if wait: self.pvWait(val, delta, timeout)
class SyncedPV(): def __init__(self, linked_pvname, synced_pvname, operation, auto_sync=False): self.operation_fun = self.get_operation(operation) self.auto_sync = auto_sync self.linked_pv = PV(linked_pvname) self.synced_pv = PV(synced_pvname, auto_monitor=True, callback=self.synced_pv_callback) self.sync_value = self.synced_pv.value def synced_pv_callback(self, pvname, value, **kwargs): if (self.auto_sync): self.linked_pv.put(self.operation_fun(self.linked_pv.value, value)) self.sync_value = value def sync(self): self.linked_pv.put( self.operation_fun(self.linked_pv.value, self.synced_pv.value)) def get_operation(self, operation): if (operation == '*'): return multiply elif (operation == '='): return equals
def acquire_image_spectrum(): print("push acquisition of the N image + average image") push_acq_image = PV('CAM1:det1:Acquire') push_acq_image.put(1) # push the spectrum acquisition + push_acq_spectr = PV('CCS1:det1:Acquire') push_acq_spectr.put(1) # sleep(10) print("acquire image") im_pv = PV('CAM1:image1:ArrayData') im = im_pv.get() sizex = PV('CAM1:det1:ArraySizeX_RBV') sizey = PV('CAM1:det1:ArraySizeY_RBV') nx = sizex.get() ny = sizey.get() #print('size image :', nx, ny) #print('size im' , im.shape) im0 = im.reshape(nx, ny) #print('size im' , im.shape) #print(im) return im.ravel(), nx, ny
def test_emptyish_char_waveform_no_monitor(self): '''a test of a char waveform of length 1 (NORD=1): value "\0" without using auto_monitor ''' with no_simulator_updates(): zerostr = PV(pvnames.char_arr_pv, auto_monitor=False) zerostr.wait_for_connection() # elem_count = 128, requested count = None, libca returns count = 1 zerostr.put([0], wait=True) time.sleep(0.2) self.assertEquals(zerostr.get(as_string=True), '') numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0]) self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '') numpy.testing.assert_array_equal(zerostr.get(as_string=False, as_numpy=False), [0]) # elem_count = 128, requested count = None, libca returns count = 2 zerostr.put([0, 0], wait=True) time.sleep(0.2) self.assertEquals(zerostr.get(as_string=True), '') numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0, 0]) self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '') numpy.testing.assert_array_equal(zerostr.get(as_string=False, as_numpy=False), [0, 0])
def discriminator_limits(self): if not self.connected: print "Device not connected" return False polarity3, polarity4, trig_buffer, int_time, init = PV( 'digital_out_polarity_3'), PV('digital_out_polarity_4'), PV( 'trig_buffer'), PV('analog_out_period'), PV('initiate') util.put_check(trig_buffer, 1000) int_time.put(10e-4) poll(evt=1.e-5, iot=0.01) count3 = PV('in_counts_3') count4 = PV('in_counts_4') low_limit3 = PV('low_limit_3') low_limit4 = PV('low_limit_4') high_limit3 = PV('high_limit_3') high_limit4 = PV('high_limit_4') util.put_check(low_limit3, 1.0) util.put_check(low_limit4, 1.0) util.put_check(polarity3, 1) util.put_check(polarity4, 1) util.put_check(high_limit3, 5.0) util.put_check(high_limit4, 5.0) poll(evt=1.e-5, iot=0.01) setting = self.proc.expect([pexpect.TIMEOUT, 'Error setting C400'], timeout=1) if setting == 1: polarity3.put(1) polarity4.put(1) data = [] data2 = [] def getCount(pvname, value, **kw): data.append(value) def getCount2(pvname, value, **kw): data2.append(value) count3.add_callback(getCount) count4.add_callback(getCount2) poll(evt=1.e-5, iot=0.01) init.put(1) poll(evt=1.e-5, iot=0.01) t0 = time.time() while time.time() - t0 < 3: poll(evt=1.e-5, iot=0.01) util.put_check(low_limit3, 0.0) init.put(1) poll(evt=1.e-5, iot=0.01) t0 = time.time() while time.time() - t0 < 3: poll(evt=1.e-5, iot=0.01) return sum(data), sum(data2)
def buffering(self, value): check = util.expect(self.proc, ["C1"]) count3 = PV('in_counts_3') low3 = PV('low_limit_3') trig_buffer = PV('trig_buffer', auto_monitor=False) int_time = PV('analog_out_period') init = PV('initiate') poll(evt=1.e-5, iot=0.01) data = [] #camonitor('trig_buffer') def getCount1(pvname, value, **kw): data.append(value) util.put_check(low3, 0.0) util.put_check(trig_buffer, value) util.put_fuzzy('analog_out_period', 10e-5, 0.05) print "set value " + str(value) print "buffer value " + str(trig_buffer.get()) #time.sleep(5) #print "buffer value " + str(trig_buffer.get()) count3.add_callback(getCount1) init.put(1) poll(evt=1.e-5, iot=0.01) t0 = time.time() while time.time() - t0 < 5: poll(evt=1.e-5, iot=0.01) run1 = len(data) return run1
def initialize_devices(self, devices): """ Initialize the devices if they are not already initialized. If the IOC is not running skip all tests """ # set single image mode, else will continuously acquire self.detector, self.plugin, self.image_channel = devices self.status = PV(self.detector.errormsgpv) if not self.status.connected: pytest.skip('PVs not connected') image_mode = PV('13SIM1:cam1:ImageMode') image_mode.put('Single') self.PVtime = PV('13SIM1:cam1:AcquireTime') self.PVtime.put(0.01) self.detector.stop() self.PVbroker = PV(self.plugin.brokerpv[:-4]) self.PVtopic = PV(self.plugin.topicpv[:-4]) pv = PV(self.plugin.msgpv[:-4]) pv.get() if pv.connected: self.PVmessage = pv pv = PV(self.plugin.statuspv[:-4]) pv.get() if pv.connected: self.PVstatus = pv self.log = self.detector.log
def get_current_readback(self): connect = self.proc.expect( [pexpect.TIMEOUT, pexpect.EOF, 'success'], timeout=5) if connect == 2: #enable = PV('c_psu_enable') resistance = PV('c_psu_resistance') readback_current = PV('r_psu_current') readback_voltage = PV('r_psu_voltage') # setpoint_current = PV('analog_in_current_setpoint') # setpoint_voltage = PV('analog_in_voltage_setpoint') command_v = PV('c_psu_control_voltage') poll(evt=1.0, iot=1.0) command_v.put(400) poll(evt=1.0, iot=1.0) change = self.proc.expect([pexpect.TIMEOUT, pexpect.EOF, 'success'], timeout=5) r_curr = readback_current.get() r_volt = readback_voltage.get() target = 400/resistance.get() # set_curr = setpoint_current.get() # set_volt = setpoint_voltage.get() return r_curr, target else: return -1
def abort(self): if not self.connected: print "Device not conncted" return False init = PV('initiate') data = [] a_in_1 = PV('analogIn1') poll(evt=1.e-5, iot=0.01) def getData1(pvname, value, **kw): if value != 0: data.append(value) a_in_1.add_callback(getData1) poll(evt=1.e-5, iot=0.01) init.put(1) poll(evt=1.e-5, iot=0.01) t0 = time.time() while time.time() - t0 < 10: poll(evt=1.e-5, iot=0.01) if len(data) >= 50: init.put(0) time.sleep(2) return len(data)
def set_command_voltage(self): connect = self.proc.expect( [pexpect.TIMEOUT, pexpect.EOF, 'success'], timeout=5) print self.proc.after print self.proc.before if connect == 2: command_v = PV('c_psu_control_voltage') value = random.random()*1000 command_v.put(value) poll(evt=1.0, iot=1.0) command = command_v.get() print command_v.info print command print command_v.get() #teardown #command_v.disconnect() #util.blowout_pvs() # epics.ca.clear_channel(command_v.chid) # ctx = epics.ca.current_context() # pvs = [] # for x in epics.ca._cache[ctx]: # pvs.append(x) # for pv in pvs: # import itertools # for element in itertools.product(*somelists): # print(element) epics.ca._cache[ctx].pop(pv) #print epics.ca._cache[ctx] #epics.ca._cache[ctx].pop('c_psu_control_voltage') return command, value else: return -1
def stopcount_value(self, value): initial_check = util.expect(self.proc, ["A1"]) data1 = [] def getData1(pvname, value, **kw): if value != 0: data1.append(value) analog1 = PV('analogIn1') stop_count = PV('outStopCount') init = PV('initiate') analog2 = PV('analogIn2') poll(evt=1.e-5, iot=0.01) analog1.wait_for_connection() analog2.wait_for_connection() init.wait_for_connection() stop_count.wait_for_connection() util.put_check(stop_count, value) analog1.add_callback(getData1) init.put(1) poll(evt=1.e-5, iot=0.01) t0 = time.time() while time.time() - t0 < 10: poll(evt=1.e-5, iot=0.01) run = len(data1) return run
def abort(self): initial_check = util.expect(self.proc, ["A1"]) init = PV('initiate') data = [] a_in_1 = PV('analogIn1') poll(evt=1.e-5, iot=0.01) def getData1(pvname, value, **kw): if value != 0: data.append(value) a_in_1.add_callback(getData1) poll(evt=1.e-5, iot=0.01) init.put(1) poll(evt=1.e-5, iot=0.01) t0 = time.time() while time.time() - t0 < 10: poll(evt=1.e-5, iot=0.01) if len(data) >= 50: init.put(0) time.sleep(2) return len(data)
def findBestDacTrim(pixel): wf = PV('vipic:Waveform1') caput('vipic:PixelToScan1', pixel) configCntWord = 1984 configCntWordReg = PV('vipic:configPixelCnt1') configCntWordReg.put(configCntWord, wait=True) peak = findAvgPeak(wf) bestDelta = 100 bestConfig = 1984 delta = delta1 = delta2 = 0 print 'configCntWord = ', configCntWord, ' Peak = ', peak while (abs(100 - peak) > 1): if (peak > 100): if ((abs(100 - peak) > 40) and (abs(delta) != 1)): delta = -5 else: delta = -1 else: if ((abs(100 - peak) > 40) and (abs(delta) != 1)): delta = 5 else: delta = 1 configCntWord += delta configCntWordReg.put(configCntWord, wait=True) peak = findAvgPeak(wf) print 'configCntWord = ', configCntWord, ' Peak = ', peak, ' Delta = ', delta, delta1, delta2 if (abs(100 - peak) <= bestDelta): bestDelta = abs(100 - peak) bestConfig = configCntWord if (((delta == -1) and (delta1 == 1) and (delta2 == -1)) or ((delta == 1) and (delta1 == -1) and (delta2 == 1))): break delta2 = delta1 delta1 = delta return bestConfig
def test_abortch_timestamp_after_6sec(softioc, caclient, fieldset, abt_ch): pv = PV(PVNAME) pv_sec = PV(PVNAME + ':TIME_SEC') pv_nsec = PV(PVNAME + ':TIME_NANO') pv.put(0, timeout=1) time.sleep(0.1) t = time.time() t_sec, t_nano = ('%.9f' % t).split('.') pv_sec.put(int(t_sec), timeout=1) pv_nsec.put(int(t_nano), timeout=1) time.sleep(6) pv.put(1, timeout=1) time.sleep(0.1) dt = datetime.fromtimestamp(int(t_sec)) d = dt.isoformat(' ') tstr = d + '.' + str(int(t_nano)).zfill(9) act = abt_ch.get_timestamp() err_msg = 'abt_ch:{} dt:{}'.format(act, tstr) assert act == '1970-01-01 09:00:00.000000000', err_msg pv.put(0, timeout=1) time.sleep(0.1)
class EnumWrapper: def __init__(self, pvname, elog=None): self._elog = elog self._pv = PV(pvname) self.names = self._pv.enum_strs # print(self.names) # if self.names: self.setters = Positioner([(nam, lambda: self.set(nam)) for nam in self.names]) def set(self, target): if type(target) is str: assert target in self.names, ("set value need to be one of \n %s" % self.names) self._pv.put(self.names.index(target)) elif type(target) is int: assert target >= 0, "set integer needs to be positive" assert target < len(self.names) self._pv.put(target) def get(self): return self._pv.get() def get_name(self): return self.names[self.get()] def __repr__(self): return self.get_name()
def channel_scaling(self): status = PV('status') if not util.check_device('A1', self.proc) and status.get() in range(0,3): print "device not connected" print status.get() print util.check_device('A1', self.proc) return False normal = PV('cleanIn1') linear = PV('linearIn1') log = PV('logIn1') both_scaled = PV('bothScaled') init = PV('initiate') poll(evt=1.e-5, iot=0.01) init.put(1) poll(evt=1.e-5, iot=0.01) time.sleep(2) base = normal.get() lin = linear.get() logged = log.get() both = both_scaled.get() print base, lin, logged, both return (self.check( lin, base*2 + 10, 0.01) and self.check( logged, 10**base, 0.01) and self.check(both, 10 ** (base*2 +10), 0.01))
def test_emptyish_char_waveform_monitor(self): '''a test of a char waveform of length 1 (NORD=1): value "\0" with using auto_monitor ''' with no_simulator_updates(): zerostr = PV(pvnames.char_arr_pv, auto_monitor=True) zerostr.wait_for_connection() zerostr.put([0], wait=True) time.sleep(0.2) self.assertEquals(zerostr.get(as_string=True), '') numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0]) self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '') numpy.testing.assert_array_equal( zerostr.get(as_string=False, as_numpy=False), [0]) zerostr.put([0, 0], wait=True) time.sleep(0.2) self.assertEquals(zerostr.get(as_string=True), '') numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0, 0]) self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '') numpy.testing.assert_array_equal( zerostr.get(as_string=False, as_numpy=False), [0, 0])
def test_emptyish_char_waveform_no_monitor(self): '''a test of a char waveform of length 1 (NORD=1): value "\0" without using auto_monitor ''' with no_simulator_updates(): zerostr = PV(pvnames.char_arr_pv, auto_monitor=False) zerostr.wait_for_connection() # elem_count = 128, requested count = None, libca returns count = 1 zerostr.put([0], wait=True) self.assertEquals(zerostr.get(as_string=True), '') numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0]) self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '') numpy.testing.assert_array_equal( zerostr.get(as_string=False, as_numpy=False), [0]) # elem_count = 128, requested count = None, libca returns count = 2 zerostr.put([0, 0], wait=True) self.assertEquals(zerostr.get(as_string=True), '') numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0, 0]) self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '') numpy.testing.assert_array_equal( zerostr.get(as_string=False, as_numpy=False), [0, 0]) zerostr.disconnect()
class PolluxMotor(Motor): """Pollux Motor class which inherits from pvScan Motor class.""" def __init__(self, pvname, pvnumber=0): if pvname.endswith('ACTPOS'): rbv = pvname velo = ':'.join(pvname.split(':')[0:2]) + ':AO:VELO' go = ':'.join(pvname.split(':')[0:2]) + ':BO:GOABS' abort = ':'.join(pvname.split(':')[0:2]) + ':BO:ABORT' pvname = ':'.join(pvname.split(':')[0:2]) + ':AO:ABSMOV' else: rbv = ':'.join(pvname.split(':')[0:2]) + ':AI:ACTPOS' velo = ':'.join(pvname.split(':')[0:2]) + ':AO:VELO' go = ':'.join(pvname.split(':')[0:2]) + ':BO:GOABS' abort = ':'.join(pvname.split(':')[0:2]) + ':BO:ABORT' BasePv.__init__(self, pvname, pvnumber, rbv) self.velo = PV(velo) self.go = PV(go) self.abort = PV(abort) def move(self, val, wait=True, delta=0.005, timeout=360.0): """Put value and press Go button.""" PV.put(self, val) sleep(0.2) self.go.put(1) if wait: Motor.motorWait(self, val, delta, timeout)
class EcolEnergy: def __init__(self, ID, val="SARCL02-MBND100:P-SET", rb="SARCL02-MBND100:P-READ", dmov="SFB_BEAM_ENERGY_ECOL:SUM-ERROR-OK"): self.ID = ID self.setter = PV(val) self.readback = PV(rb) self.dmov = PV(dmov) self.done = False def get_current_value(self): return self.readback.get() def move_and_wait(self, value, checktime=0.01, precision=2): curr = self.setter.get() while abs(curr - value) > 0.1: curr = self.setter.get() self.setter.put(curr + np.sign(value - curr) * 0.1) sleep(0.3) self.setter.put(value) while abs(self.get_current_value() - value) > precision: sleep(checktime) while not self.dmov.get(): #print(self.dmov.get()) sleep(checktime) def set_target_value(self, value, hold=False): changer = lambda: self.move_and_wait(value) return Task(changer, hold=hold)
def test(self): pv_w = PV(iocname + pv_write) pv_r = PV(iocname + pv_read) if type == "PUTGET": pv_w.put(value) time.sleep(DELAY) got = pv_r.get(as_string=True) fail_string = 'The PV values do not match, sent %s got %s but expected %s' % (value, got, expected) self.assertEqual(expected, got, fail_string) elif type == "PUTERROR": self.assertRaises(ValueError, pv_w.put, value) elif type == "GET": as_str=False dbl = 0 try: dbl = float(expected) except: as_str=True dbl = expected got = pv_r.get(as_string=as_str) fail_string = 'The value read was not as expected, got %s but expected %s' % (got, dbl) self.assertEqual(dbl, got, fail_string) elif type == "EQUAL": got1 = pv_r.get(as_string=True) got2 = pv_w.get(as_string=True) fail_string = 'The PV values do not match, got %s and %s' % (got1, got2) self.assertEqual(got1, got2, fail_string)
def channel_scaling(self): status = PV('status') start_time = time.time() while status.get() not in (0, 3): print str(status.get()) + "not connected yet" connected = status.get() in (0, 3) poll(evt=1.0, iot=0.51) if time.time() - start_time >= 60: connected = False print "timed out" break check = util.expect(self.proc, ["A1"]) normal = PV('cleanIn1') linear = PV('linearIn1') log = PV('logIn1') both_scaled = PV('bothScaled') init = PV('initiate') poll(evt=1.e-5, iot=0.01) init.put(1) poll(evt=1.e-5, iot=0.01) time.sleep(2) base = normal.get() lin = linear.get() logged = log.get() both = both_scaled.get() print base, lin, logged, both return (self.check(lin, base * 2 + 10, 0.01) and self.check(logged, 10**base, 0.01) and self.check(both, 10**(base * 2 + 10), 0.01))
def trigger_start(self): if not self.connected: print "Device not connected" return False status = PV('status') print status.get() if status.get() not in range(0,3): print "status" return False data = [] start_trig = PV('start_trigger_source') acquisition_mode = PV('acquisition_mode') poll(evt=1.e-5, iot=0.01) print "starting setup is, acquisition: " + str(acquisition_mode.get()) + " stoptrig: " + str(start_trig.get()) acquisition_mode.put(0) poll(evt=1.e-5, iot=0.01) #start_trig.put(1) util.put_check(start_trig, 1) print "trig1: " + str(start_trig.get()) poll(evt=1.0, iot=1.01) print "trig2: " + str(start_trig.get()) data.append(start_trig.get() == 1) time.sleep(3) print "trig3: " + str(start_trig.get()) #start_trig.put(0) util.put_check(start_trig, 0) poll(evt=1.0, iot=1.01) data.append(start_trig.get() == 0) time.sleep(3) print "trig4: " + str(start_trig.get()) return data
def trigger_pause(self): if not self.connected: print "Device not connected" return False data = [] pause_trig = PV('pause_trigger_source') acquisition_mode = PV('acquisition_mode') poll(evt=1.e-5, iot=0.01) print "starting setup is, acquisition: " + str( acquisition_mode.get()) + " stoptrig: " + str(pause_trig.get()) acquisition_mode.put(0) poll(evt=1.e-5, iot=0.01) #pause_trig.put(1) util.put_check(pause_trig, 1) print "trig1: " + str(pause_trig.get()) poll(evt=1.0, iot=1.01) print "trig2: " + str(pause_trig.get()) data.append(pause_trig.get() == 1) time.sleep(3) print "trig3: " + str(pause_trig.get()) #pause_trig.put(0) util.put_check(pause_trig, 0) poll(evt=1.0, iot=1.01) data.append(pause_trig.get() == 0) time.sleep(3) print "trig4: " + str(pause_trig.get()) return data
class PVObject(QObject): newValue = pyqtSignal(float, float) def __init__(self, pv, readback=None, parent=None): super(PVObject, self).__init__() self.name = pv self.pv = PV(self.name, callback=self.callback) self.dict = OrderedDict() self._value = [time.time(), self.pv.get()] self.writeAccess = False self.readBackName = readback if not self.readBackName is None: self.readBackPV = PV(self.readBackName) def callback(self, **kwargs): self.dict = OrderedDict(kwargs) if 'status' in kwargs and 'value' in kwargs and self.dict['status'] is 0: if not 'timestamp' in kwargs: timestamp = time.time() self._value = [self.dict['timestamp'], self.dict['value']] self.newValue.emit(*self._value) def setValue(self, value): self.value = value @property def value(self): if self._value[1] is None: return self.pv.get() if self.pv.get() is not None else 0 else: return self._value[1] @value.setter def value(self, val): self.put(val) @property def time(self): return self._value[0] def get(self): return self._value def getTime(self): return self._value[0] def getValue(self): return self._value[1] if self._value[1] is not None else 0 def put(self, value): ntries = 0 if self.writeAccess: self.pv.put(value) if not self.readBackName is None: rbkValue = self.readBackPV.get() while abs(rbkValue - self.value) > 0.01 and ntries < 10: time.sleep(0.05) rbkValue = self.readBackPV.get() ntries += 1
class DDGrabber(Experiment): """UED Direct Detector grabber.""" def __init__(self, cameraPvPrefix): Experiment.__init__(self) self.cameraPvPrefix = cameraPvPrefix self.grabFlag = PV(pvPrefix + ':GRABIMAGES:ENABLE').get() self.grabSeq2Flag = PV(pvPrefix + ':GRABIMAGES:SEQ2ENABLE').get() # Grab second image sequence after first self.grabSeq2Delay = PV(pvPrefix + ':GRABIMAGES:SEQ2DELAY').get() # Delay between 1st and 2nd sequence self.stepFlag = PV(pvPrefix + ':GRABIMAGES:STEPNUMBER').get() # Write step number into filename self.dataTime = PV(pvPrefix + ':GRABIMAGES:DATATIME').get() # Data capture time for DirectD self.dataStartStopPv = PV('UED:TST:FILEWRITER:CMD') # DataWriter start/stop PV self.dataStatusPv = PV('UED:TST:FILEWRITER:STATUS') # DataWriter status PV self.dataFilenamePv = PV('UED:TST:FILEWRITER:PATH') # DataWriter filename template PV self.nImages2 = None self.filenameExtras = '' self.timestampRBVPv = None self.captureRBVPv = None def dataWriterStatus(self): """Return status of dataWriter.""" status = self.dataStatusPv.get() if status: printMsg('DataWriter status is: ON') else: printMsg('DataWriter status is: OFF') return status def grabImages(self, nImages=0): """Set filepath PV, turn on/off dataWriter.""" #filenameTemplate='%s/%s%s_%s' %(timestamp('today'), self.expname, self.filenameExtras, timestamp(1)) if self.filenameExtras.startswith('_'): self.filenameExtras = self.filenameExtras.replace('_', '') filenameTemplate = ('%s/%s/%s_%s' %(timestamp('today'), self.expname, self.filenameExtras, timestamp(1))) self.dataFilenamePv.put(filenameTemplate + '\0') printMsg('Writing %s data for %d seconds...' % (self.cameraPvPrefix, self.dataTime)) print 'DirectD filepath: ', filenameTemplate #print self.dataStatusPv.get() #print caget('UED:TST:FILEWRITER:STATUS') self.dataStartStopPv.put(1) #caput('UED:TST:FILEWRITER:CMD',1) sleep(0.25) self.dataStartStopPv.put(1) #caput('UED:TST:FILEWRITER:CMD',1) sleep(0.25) self.dataWriterStatus() #print self.dataStatusPv.get() #print caget('UED:TST:FILEWRITER:STATUS') sleep(self.dataTime) self.dataStartStopPv.put(0) #caput('UED:TST:FILEWRITER:CMD',0) sleep(0.25) self.dataStartStopPv.put(0) #caput('UED:TST:FILEWRITER:CMD',0) sleep(0.25) self.dataWriterStatus() #print caget('UED:TST:FILEWRITER:STATUS') #print self.dataStatusPv.get() printMsg('Done Writing %s data.' % (self.cameraPvPrefix))
def test_stopcount(): proc = pexpect.spawn( "/home/steve/workspace/ig2_medical/ig2-2.6.7 /home/steve/workspace/ig2_medical/m10_stopcount.xml" ) proc.expect([pexpect.TIMEOUT, pexpect.EOF, 'Announce\(\) success'], timeout=10) print proc.after #util.pv_check('status', 0) stop = 1001 data1 = [] data2 = [] def getData1(pvname, value, **kw): if value != 0: data1.append(value) def getData2(pvname, value, **kw): if value != 0: data2.append(value) analog1 = PV('analogIn1') stop_count = PV('outStopCount') init = PV('initiate') analog2 = PV('analogIn2') analog1.wait_for_connection() analog2.wait_for_connection() init.wait_for_connection() stop_count.wait_for_connection() analog1.add_callback(getData1) if util.put_check('outStopCount', stop): init.put(1) t0 = time.time() while time.time() - t0 < 30: poll(evt=1.e-5, iot=0.01) else: print "Stopcount not set" return False buffered_run = len(data1) analog2.add_callback(getData2) time.sleep(2) if util.put_check('outStopCount', -1): init.put(1) t0 = time.time() while time.time() - t0 < 30: poll(evt=1.e-5, iot=0.01) else: print "Stopcount not set 2nd time" return False unbuffered_run = len(data2) return buffered_run, unbuffered_run
def test_put_string_waveform(self): write('String Array: \n') with no_simulator_updates(): pv = PV(pvnames.string_arr_pv) put_value = ['a', 'b', 'c'] pv.put(put_value) get_value = pv.get(use_monitor=False, count=len(put_value)) numpy.testing.assert_array_equal(get_value, put_value)
def test_put_string_waveform(self): write('String Array: put\n') with no_simulator_updates(): pv = PV(pvnames.string_arr_pv) put_value = ['a', 'b', 'c'] pv.put(put_value, wait=True) get_value = pv.get(use_monitor=False, as_numpy=False) numpy.testing.assert_array_equal(get_value, put_value)
def move(self, val, wait=False, delta=0.005, timeout=300.0): """Put with optional wait.""" PV.put(self,val) if wait or self.rbv: if not self.delta: delta = delta else: delta = self.delta self.pvWait(val, delta, timeout)
def init_var_channels(beamlineComm): global var_channel_list,beamlineStateChannel beamlineStateChannel = PV(beamlineComm + "beamlineState") beamlineStateChannel.put(0) for varname in list(stateVars.keys()): var_channel_list[varname] = PV(beamlineComm + varname) # beamline_support.pvPut(var_channel_list[varname],stateVars[varname]) var_channel_list[varname].add_callback(var_list_item_changeCb,varname=varname)
class Shutter(object): def __init__(self, pvname): self.out_pv = PV(pvname) def open(self): self.out_pv.put(str(1)) def close(self): self.out_pv.put(str(0))
class Shutter(object): def __init__(self): self.out_pv = PV('34idc:softGlue:OR-1_IN2_Signal') def open(self): self.out_pv.put(str(1)) def close(self): self.out_pv.put(str(0))
def test_put_string_waveform_single_element(self): write('String Array: put single element\n') with no_simulator_updates(): pv = PV(pvnames.string_arr_pv) put_value = ['a'] pv.put(put_value, wait=True) time.sleep(0.05) get_value = pv.get(use_monitor=False, as_numpy=False) self.failUnless(put_value[0] == get_value)
def test_put_string_waveform_mixed_types(self): write('String Array: put mixed types\n') with no_simulator_updates(): pv = PV(pvnames.string_arr_pv) put_value = ['a', 2, 'b'] pv.put(put_value, wait=True) time.sleep(0.05) get_value = pv.get(use_monitor=False, as_numpy=False) numpy.testing.assert_array_equal(get_value, ['a', '2', 'b'])
def test_put_string_waveform_zero_length_strings(self): write('String Array: put zero length strings\n') with no_simulator_updates(): pv = PV(pvnames.string_arr_pv) put_value = ['', '', ''] pv.put(put_value, wait=True) time.sleep(0.05) get_value = pv.get(use_monitor=False, as_numpy=False) numpy.testing.assert_array_equal(get_value, put_value)
def test_put_string_waveform_empty_list(self): write('String Array: put empty list\n') with no_simulator_updates(): pv = PV(pvnames.string_arr_pv) put_value = [] pv.put(put_value, wait=True) time.sleep(0.05) get_value = pv.get(use_monitor=False, as_numpy=False) self.failUnless('' == ''.join(get_value))
class Shutter(StandardDevice): #CALLBACK FUNCTION FOR THE SHUTTER STATUS PV #def onStatusChange(self, **kw): #self._open = not self._open #CONSTRUCTOR OF SHUTTER CLASS def __init__(self, pvStatusName="", pvControlName="", pvHutchName="", mnemonic="", invert=False): StandardDevice.__init__(self, mnemonic) self.delay = 0.01 self.invert = invert self.pvStatus = PV(pvStatusName) self.pvControl = PV(pvControlName) self.pvHutch = PV(pvHutchName) #IF POSSIBLE, OPEN THE SHUTTER AND WAIT UNTIL THE SHUTTER IS REALLY OPEN def open(self): if not self.isHutchReady(): raise Exception('Error: ','Hutch Not Ready') try: if not self.isOpen(): self.pvControl.put(1, wait=True) while not self.isOpen(): sleep(self.delay) else: print('Warning: ','Shutter already open') except Exception as e: print(e.args[0],e.args[1]) #IF POSSIBLE, CLOSE THE SHUTTER AND WAIT UNTIL THE SHUTTER IS REALLY CLOSE def close(self): try: if self.isOpen(): self.pvControl.put(1, wait=True) while self.isOpen(): sleep(self.delay) else: print('Warning: ','Shutter already closed') except Exception as e: print(e.args[0],e.args[1]) def isHutchReady(self): if(self.invert): return 1 - self.pvHutch.get() else: return self.pvHutch.get() def isOpen(self): if(self.invert): return 1 - self.pvStatus.get() else: return self.pvStatus.get()
def test_putcomplete(self): write('Put with wait and put_complete (using real motor!) \n') vals = (1.35, 1.50, 1.44, 1.445, 1.45, 1.453, 1.446, 1.447, 1.450, 1.450, 1.490, 1.5, 1.500) p = PV(pvnames.motor1) see_complete = [] for v in vals: t0 = time.time() p.put(v, use_complete=True) count = 0 for i in range(100000): time.sleep(0.001) count = count + 1 if p.put_complete: see_complete.append(True) break # print( 'made it to value= %.3f, elapsed time= %.4f sec (count=%i)' % (v, time.time()-t0, count)) self.failUnless(len(see_complete) > (len(vals) - 5))
def test_emptyish_char_waveform_monitor(self): '''a test of a char waveform of length 1 (NORD=1): value "\0" with using auto_monitor ''' with no_simulator_updates(): zerostr = PV(pvnames.char_arr_pv, auto_monitor=True) zerostr.wait_for_connection() zerostr.put([0], wait=True) self.assertEquals(zerostr.get(as_string=True), '') numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0]) self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '') numpy.testing.assert_array_equal(zerostr.get(as_string=False, as_numpy=False), [0]) zerostr.put([0, 0], wait=True) self.assertEquals(zerostr.get(as_string=True), '') numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0, 0]) self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '') numpy.testing.assert_array_equal(zerostr.get(as_string=False, as_numpy=False), [0, 0])
def test_positions(self): PVPREFIX = os.environ['MYPVPREFIX'] + 'LKUP:' filter = PV(PVPREFIX + 'SAMPX:FILTER1') filter.put('Rack1_Rct') posns = PV(PVPREFIX + 'SAMPX:POSITIONS') positions = posns.get() self.assertEqual(positions[0], 'Rack1_Rct_1') self.assertEqual(positions[2], 'Rack1_Rct_3') self.assertEqual(positions[10], 'END') posns = PV(PVPREFIX + 'MON3:POSITIONS') positions = posns.get() self.assertEqual(positions[0], 'In') self.assertEqual(positions[1], 'Out') self.assertEqual(positions[2], 'END') posns = PV(PVPREFIX + 'SAMPY:POSITIONS') positions = posns.get() self.assertEqual(positions[0], 'Top') self.assertEqual(positions[1], 'Bottom') self.assertEqual(positions[2], 'END')
class SimpleShutter(StandardDevice): SHUTTER_OPEN = 0 SHUTTER_CLOSE = 1 def __init__(self, mnemonic, shutter): super().__init__(mnemonic) self.shutter = PV(shutter) def isOpen(self): return self.shutter.get() == self.SHUTTER_OPEN def wait(self, timeout=3): pass def open(self, wait=False): self.shutter.put(self.SHUTTER_OPEN, wait=wait) def close(self, wait=False): self.shutter.put(self.SHUTTER_CLOSE, wait=wait)
def test_putcomplete(self): write('Put with wait and put_complete (using real motor!) \n') vals = (1.35, 1.50, 1.44, 1.445, 1.45, 1.453, 1.446, 1.447, 1.450, 1.450, 1.490, 1.5, 1.500) p = PV(pvnames.motor1) # this works with a real motor, fail if it doesn't connect quickly if not p.wait_for_connection(timeout=0.2): self.skipTest('Unable to connect to real motor record') see_complete = [] for v in vals: t0 = time.time() p.put(v, use_complete=True) count = 0 for i in range(100000): time.sleep(0.001) count = count + 1 if p.put_complete: see_complete.append(True) break # print( 'made it to value= %.3f, elapsed time= %.4f sec (count=%i)' % (v, time.time()-t0, count)) self.failUnless(len(see_complete) > (len(vals) - 5))
class ToggleShutter(StandardDevice): def __init__(self, mnemonic, shutter, shutterReadback): super().__init__(mnemonic) self.read = PV(shutterReadback) self.toggle = PV(shutter) self._open = self.read.get() self.changed = Event() self.read.add_callback(self.onReadChange) def isOpen(self): return self._open def onReadChange(self, value, **kwargs): self._open = value self.changed.set() def wait(self, timeout=3): ca.flush_io() self.changed.wait(timeout) def change(self, open, wait=False): if self.isOpen() == open: self.changed.set() return self.changed.clear() self.toggle.put(1) ca.flush_io() if wait: self.wait() def open(self, wait=False): self.change(open=True, wait=wait) def close(self, wait=False): self.change(open=False, wait=wait)
def test_lookps(self): PVPREFIX = os.environ['MYPVPREFIX'] + 'LKUP:' posn3 = PV(PVPREFIX + 'MON3:POSN') posn4 = PV(PVPREFIX + 'MON4:POSN') posnX = PV(PVPREFIX + 'SAMPX:POSN') posnY = PV(PVPREFIX + 'SAMPY:POSN') posn3sp = PV(PVPREFIX + 'MON3:POSN:SP') posn4sp = PV(PVPREFIX + 'MON4:POSN:SP') posnXsp = PV(PVPREFIX + 'SAMPX:POSN:SP') posnYsp = PV(PVPREFIX + 'SAMPY:POSN:SP') print(PVPREFIX + 'MON3:POSN') posn3sp.put('Out') posn4sp.put('In') posnXsp.put('Rack1_Rct_3') posnYsp.put('Bottom') time.sleep(self.DELAY) rbv3 = PV(PVPREFIX + 'MON3:COORD1:RBV') rbv4 = PV(PVPREFIX + 'MON4:COORD1:RBV') rbvX = PV(PVPREFIX + 'SAMPX:COORD1:RBV') rbvY = PV(PVPREFIX + 'SAMPY:COORD1:RBV') pvStationary = PV(PVPREFIX + 'SAMPX:STATIONARY') for i in range(20): stationary = pvStationary.get() if stationary==1: break print('Moving') print('3=' + str(rbv3.get()) + ' 4=' + str(rbv4.get()) + ' X=' + str(rbvX.get()) + ' Y=' + str(rbvY.get())) time.sleep(self.DELAY) time.sleep(self.DELAY) self.assertEqual(posn3.get(), 'Out') self.assertEqual(posn4.get(), 'In') self.assertEqual(posnX.get(), 'Rack1_Rct_3') self.assertEqual(posnY.get(), 'Bottom') coord3 = PV(PVPREFIX + 'MON3:COORD1') coord4 = PV(PVPREFIX + 'MON4:COORD1') coordX = PV(PVPREFIX + 'SAMPX:COORD1') coordY = PV(PVPREFIX + 'SAMPY:COORD1') self.assertAlmostEqual(coord3.get(), 10) self.assertAlmostEqual(coord4.get(), 5) self.assertAlmostEqual(coordX.get(), 30) self.assertAlmostEqual(coordY.get(), 12) self.assertAlmostEqual(rbv3.get(), 10) self.assertAlmostEqual(rbv4.get(), 5) self.assertAlmostEqual(rbvX.get(), 30) self.assertAlmostEqual(rbvY.get(), 12)
def move_to_sample_pos(x, y, z, wait=True, callbacks=[]): logger.info('Moving Sample to x: {}, y: {}, z: {}'.format(x, y, z)) motor_x = PV(epics_config['sample_position_x']) motor_y = PV(epics_config['sample_position_y']) motor_z = PV(epics_config['sample_position_z']) motor_x.put(x, use_complete=True) motor_y.put(y, use_complete=True) motor_z.put(z, use_complete=True) if wait: while not motor_x.put_complete and \ not motor_y.put_complete and \ not motor_z.put_complete: time.sleep(0.1) for callback in callbacks: callback() time.sleep(0.5) logger.info('Moving Sample to x: {}, y: {}, z: {} finished.\n'.format(x, y, z)) return
def test_subarrays(self): write("Subarray test: dynamic length arrays\n") driver = PV(pvnames.subarr_driver) subarr1 = PV(pvnames.subarr1) subarr1.connect() len_full = 64 len_sub1 = 16 full_data = numpy.arange(len_full)/1.0 caput("%s.NELM" % pvnames.subarr1, len_sub1) caput("%s.INDX" % pvnames.subarr1, 0) driver.put(full_data) ; time.sleep(0.1) subval = subarr1.get() self.assertEqual(len(subval), len_sub1) self.failUnless(numpy.all(subval == full_data[:len_sub1])) write("Subarray test: C\n") caput("%s.NELM" % pvnames.subarr2, 19) caput("%s.INDX" % pvnames.subarr2, 3) subarr2 = PV(pvnames.subarr2) subarr2.get() driver.put(full_data) ; time.sleep(0.1) subval = subarr2.get() self.assertEqual(len(subval), 19) self.failUnless(numpy.all(subval == full_data[3:3+19])) caput("%s.NELM" % pvnames.subarr2, 5) caput("%s.INDX" % pvnames.subarr2, 13) driver.put(full_data) ; time.sleep(0.1) subval = subarr2.get() self.assertEqual(len(subval), 5) self.failUnless(numpy.all(subval == full_data[13:5+13]))
# mdunning 1/7/16 from epics import PV from time import sleep import datetime, os, sys from threading import Thread import subprocess # PV prefix for pvScan IOC; should be passed as an argument to this script. pvPrefix = sys.argv[1] # Set an environment variable for so pvScan module can use it os.environ["PVSCAN_PVPREFIX"] = pvPrefix # For printing status messages to PV msgPv = PV(pvPrefix + ":MSG") msgPv.put("Initializing...") print "Initializing..." # Import pvScan module sys.path.append("/afs/slac/g/testfac/extras/scripts/pvScan/prod/modules/") import pvscan # --- Experiment --------------------------------------- # Create Experiment object. Sets default filepath and gets experiment name from PV. # First argument (optional) is an experiment name, leave blank to get from pvScan IOC. # Second arg (optional) is a filepath, leave blank to get from pvScan IOC. # Third arg (optional) is a scan name, leave blank to get from pvScan IOC. exp1 = pvscan.Experiment() exp1.targetname = PV(pvPrefix + ":SCAN:TARGETNAME").get() if " " in exp1.targetname: exp1.targetname = exp1.targetname.replace(" ", "_")
class RotaryMagnet(StandardDevice, IScannable): """ Class to add ICountable support for rotary magnet. Examples -------- >>> from py4syn.epics.RotaryMagnetClass import RotaryMagnet >>> >>> myMagnet = RotaryMagnet('myMagnet') >>> myMagnet.setValue(0) >>> """ # Callback function for the RotaryMagnet's PV value change def onValChange(self, value, **kw): self._active = (value == 1) # Constructor of RotaryMagnet def __init__(self, pvRotaryMagnetName="", mnemonic=""): StandardDevice.__init__(self, mnemonic) self._active = False self._done = self.isDone() self.pvRotaryMagnetDESC = PV(pvRotaryMagnetName+".DESC") self.pvRotaryMagnetVAL = PV(pvRotaryMagnetName+".VAL", self.onValChange) def getDescription(self): """ Obtain the current description of rotary magnet device or its identification. Returns ------- `String` A detail about the device or its identification. """ return self.pvRotaryMagnetDESC.get() def setDescription(self, magnetDescription): """ Method to set a description to the rotary magnet device. Parameters ---------- `String` A detail about the device or its identification. Returns ------- `None` """ self.pvRotaryMagnetDESC.put(magnetDescription) def getValue(self): """ Obtain the current value of rotary magnet device or its identification. Returns ------- `integer` .. note:: - **1** -- Active rotary magnet; - **0** -- Inactive rotary magnet. """ return self.pvRotaryMagnetVAL.get() def setValue(self, v): """ Method to set a value to the rotary magnet device. Parameters ---------- `integer` .. note:: - **1** -- Active rotary magnet; - **0** -- Inactive rotary magnet. """ self.pvRotaryMagnetVAL.put(v) def isActive(self): """ Return whether Rotary Magnet is currently active (set to 1). Returns ------- `boolean` .. note:: - **True** -- Rotary magnet is active (1); - **False** -- Rotary magnet is inactive (0). """ return self._active def isDone(self): return True def wait(self): while(not self._done): sleep(0.001) def getLowLimitValue(self): """ Obtain low limit value of rotary magnet. Parameters ---------- None Returns ------- `double` """ return -1 def getHighLimitValue(self): """ Obtain high limit value of rotary magnet. Parameters ---------- None Returns ------- `double` """ return 2
class PhotonicCCD(StandardDevice): #CALLBACK FUNCTION FOR THE CCD ACQUIRE STATUS PV def onAcquireChange(self, value, **kw): #print datetime.datetime.now(), " - Acquisition Done = ", (value == 0) self._done = (value == 0) #CONSTRUCTOR OF CCD CLASS def __init__(self, pvName, mnemonic, scalerObject=""): StandardDevice.__init__(self, mnemonic) self.pvAcquire = PV(pvName+":cam1:Acquire", callback=self.onAcquireChange) self.pvNumImages = PV(pvName+":cam1:NumImages") self.pvFileName = PV(pvName+":cam1:FileName") self.pvFilePath = PV(pvName+":cam1:FilePath") self.pvAcquireTime = PV(pvName+":cam1:AcquireTime") self.pvFileNumber = PV(pvName+":cam1:FileNumber") self.pvArrayCounter = PV(pvName+":cam1:ArrayCounter") self.pvArrayCounterRBV = PV(pvName+":cam1:ArrayCounter_RBV") self.scaler = scalerObject self._done = self.isDone() self.time = self.pvAcquireTime.get() def isDone(self): return (self.pvAcquire.get() == 0) def getAcquireTime(self): return self.pvAcquireTime.get() def getFileName(self): #name = ''.join([chr(c) for c in self.pvFileName.get()]) #name = name[0:-1] name = self.pvFileName.get(as_string=True) return name def getFilePath(self): #path = ''.join([chr(c) for c in self.pvFilePath.get()]) #path = path[0:-1] path = self.pvFilePath.get(as_string=True) return path def getFileNumber(self): return self.pvArrayCounterRBV.get() def getCompletePreviousFileName(self): return self.getFileName()+str(self.getFileNumber()-1).zfill(3) def getCompleteFileName(self): return self.getFileName()+str(self.getFileNumber()).zfill(3) def acquire(self, waitComplete=False): self.scaler.setCountTime(self.time) self.scaler.setCountStart() self.pvAcquire.put(1) self._done = False if(waitComplete): self.wait() self.scaler.setCountStop() def getIntensity(self): return self.scaler.getIntensity() def setFileNumber(self, number): self.pvArrayCounter.put(number-1, wait=True) self.pvFileNumber.put(number, wait=True) def setAcquireTime(self, time): self.time = time self.pvAcquireTime.put(time, wait=True) def setFileName(self, name): self.pvFileName.put(name+"\0", wait=True) def setNumImages(self, number): self.pvNumImages.put(number, wait=True) def wait(self): while(not self._done): sleep(0.001)