class Part: def __init__(self, part): # Let errors propagate self._name = part.get('name') self._vset = part.get('vset') self._base = part.get('base') self._scale = part.get('scale') self._ramping = EpicsSignalRO(f'{self._base}{RAMPING}') self._set_voltage = EpicsSignal(f'{self._base}{VSET}') @property def name(self): return self._name @property def vset(self): return self._vset @property def base(self): return self._base def set_voltage(self, zero=False): if zero: self._set_voltage.put(0) else: self._set_voltage.put(self.vset) @property def ramping(self): return self._ramping.get()
def fug_fil_degas(I_target, pressure_pv, max_pressure, max_voltage, current=fug_current, voltage=fug_voltage, enable=fug_enable): """ fug_fil_degas(1 (in A), prep_pressure, 1*10**-8, 10 (in Volts)) """ # pressure_pv_dict = { # ['Load_Lock_1']= 'XF:21IDD-VA{LOCK1:4A-CCG:EA4_1}P-I', # ['Load_Lock_2']= 'XF:21IDD-VA{LOCK2:3A-CCG:EA3_1}P-I', # ['Preparation']= 'XF:21IDD-VA{PREP:2A-CCG:EA5_1}P-I', # ['Low_Temp']= 'XF:21IDD-VA{LOWT:5A-CCG:EA5_1}P-I', # ['Analysis']= 'XF:21IDD-VA{ANAL:1A-CCG:EA1_1}P-I' } pressure_pv = EpicsSignal(pressure_pv_dict[pressure_pv]) voltage.put(max_voltage) current.put(0) enable.put(1) while I_target > current.get(): incr = .1 print("Current value: " + str(round(current.get(), 2)) + ". Going to " + str(round(current.get() + incr, 2))) while (pressure_pv.get() >= max_pressure): time.sleep(10) current.put(current.get() + incr) time.sleep(10) current.put(0) voltage.put(0) enable.put(0)
class MMC_Axis: def __init__(self, base_pv, name=None): self.base_pv = base_pv self.rbv = EpicsSignalRO(self.base_pv+'.RBV', auto_monitor=True) self.val = EpicsSignal(self.base_pv+'.VAL') self.dmov = EpicsSignalRO(self.base_pv+'.DMOV', auto_monitor=True) self.name = name def mv(self, target, wait=False): self.set(target) if wait: time.sleep(0.2) while self.dmov.value==0: time.sleep(0.2) def mvr(self, adjustment, wait=False): target = self.get() + adjustment self.mv(target, wait=wait) def set(self, target): self.val.set(target) def get(self): return self.rbv.value def wm(self): return self.get()
class HxnScanStatus: '''Broadcast if a scan is in progress via PV Processed on every start/end document ''' def __init__(self, running_pv): self._last_start = None self.running_signal = EpicsSignal(running_pv) self._running = False @property def running(self): return self._running @running.setter def running(self, running): self._running = running if running is None: running = 0 try: self.running_signal.put(running) except DisconnectedError: logger.error('ScanRunning PV disconnected. Is the hxntools IOC running?') def __call__(self, name, doc): '''Bluesky callback with document info''' if name == 'start': self._last_start = doc if self._last_start and name in ('start', 'stop'): self.running = (name == 'start')
def move_to_target(frame_cfg=[1, 'F1', 1, 'F2', 1, 'F3'], frame=1, target='A1'): ''' Description: script to move to a predefined target in the target holder. Assuming for now that columns are letters, and raws are numbers. Columns start from A and finish at I from left to right and raws start from 1 to 7 from top to bottom. All these while looking at the target holder from the back (opposite view from questar 1). Since everytarget frame is position a few 100um differt due to screw slop, there are two epics user pv that can be set as a correction for each target. These correctionis should be small (<1mm), and are best reset when going to a different frame. They are the user PVs 57 and 58. IN: frame_cfg : the configuration of the frames on the target holder as viewed from the back, meaning the opposite view of Q1. TO DO: need to confirm size of the half-U frame. frame : the number of the frame where the targets are located. Can be full size or half size U frame. TO DO: need to confirm size of the half-U frame. target : the number of the target to go to within this frame. OUT: move to target ''' xcorr = EpicsSignal('MEC:NOTE:DOUBLE:57').get() ycorr = EpicsSignal('MEC:NOTE:DOUBLE:58').get() # 1U is 40mm large, 0.5U is 20mm, starting from just after the calibration cartridge global msg_log_target frame_pos = x_start_pos if (frame > 1): # -1 to not account for the first frame, and count for the other position in the array for idx in np.arange(0, 2 * (frame - 1), 2): if (frame_cfg[idx] == 1): frame_pos = frame_pos + one_u else: frame_pos = frame_pos + half_u # starting position from where the target value will be evaluated # +1 because the array start target_col = letter_arr.index(target[0]) + 1 target_raw = int(target[1]) # initialisation of x and y target positions y_target_pos = y_start_pos x_target_pos = 0.0 # calculating the y position of the target if (target_raw > 1): y_target_pos = y_target_pos + ((target_raw - 1) * y_step) # calculatinf the x position of the target if (target_col > 1): x_target_pos = x_target_pos + ((target_col - 1) * x_step) # execute the motion tgx(pin_pos - (x_target_pos + frame_pos) + xcorr) hexy.put(y_target_pos + ycorr) print('Moving to Frame {}, target {}.'.format(frame, target)) print('Tweak position as appropriate.') print('The frame configuration is {}.'.format(frame_cfg)) # print in the eLog only the naming used by the users to avoid confusion msg_log_target = 'on frame {}, target {}'.format( frame_cfg[(2 * frame) - 1], target)
def test_local_without_defaults_no_string(testdir): from ophyd import EpicsSignal signal = EpicsSignal(f"{pv_base}.SCAN", name="signal") signal.wait_for_connection() desc = signal.describe() assert not signal.as_string assert desc["signal"]["dtype"] == "integer"
class HDCMPIEZOPITCH(PVPositionerPC): setpoint = Cpt(EpicsSignal, '') readback = Cpt(EpicsSignalRO, '') pid_enabled = EpicsSignal('XF:05IDD-CT{FbPid:02}PID:on') pid_I = EpicsSignal('XF:05IDD-CT{FbPid:02}PID.I') def reset_pid(self): yield from bps.mov(self.pid_I, 0.0)
def __init__(self, part): # Let errors propagate self._name = part.get('name') self._vset = part.get('vset') self._base = part.get('base') self._scale = part.get('scale') self._ramping = EpicsSignalRO(f'{self._base}{RAMPING}') self._set_voltage = EpicsSignal(f'{self._base}{VSET}')
def pv_scan(detectors, pvname, start, stop, num, events=None): """ Scan over a PV as a UI test utility """ sig = EpicsSignal(pvname, name=pvname) mot = PhonyMotor(sig) config_in_scan(detectors, [mot], events) sig.wait_for_connection() return (yield from scan(detectors, sig, start, stop, num))
def live_data_stream(self): self.PVs = GetPVs() gatt = self.PVs.get('gatt', None) self.signal_gatt = EpicsSignal(gatt) #wave8 = self.PVs.get('wave8', None) #self.signal_wave8 = EpicsSignal(wave8) diff = self.PVs.get('diff', None) self.signal_diff = EpicsSignal(diff) self.gatt = self.signal_gatt.get() self.diff = self.signal_diff.get()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._num_images = 1 self._acquisition_signal = self.cam.acquire self._counter_signal = self.cam.array_counter #self._trigger_signal = EpicsSignal('XF:16ID-TS{EVR:C1-Out:FP3}Src:Scale-SP') self._trigger_signal = EpicsSignal('XF:16IDC-ES{Zeb:1}:SOFT_IN:B0') self._status = None self.first = True self.acq_t = 0
def __init__(self, open=None, open_status=None, close=None, close_status=None): super(Shutter, self).__init__() signals = [ EpicsSignal(open_status, write_pv=open, alias='_open'), EpicsSignal(close_status, write_pv=close, alias='_close'), ] for sig in signals: self.add_signal(sig)
class ValueReader(metaclass=Singleton): def __init__(self, signals): self.signals = signals self.PVs = dict() self.PV_signals = list() self.live_data = True self.signals.run_live.connect(self.run_live_data) def run_live_data(self, live): self.live_data = live def live_data_stream(self): self.PVs = GetPVs() gatt = self.PVs.get('gatt', None) self.signal_gatt = EpicsSignal(gatt) #wave8 = self.PVs.get('wave8', None) #self.signal_wave8 = EpicsSignal(wave8) diff = self.PVs.get('diff', None) self.signal_diff = EpicsSignal(diff) self.gatt = self.signal_gatt.get() self.diff = self.signal_diff.get() def sim_data_stream(self): """ context_data = zmq.Context() socket_data = context_data.socket(zmq.SUB) socket_data.connect(".join(['tcp://localhost:', '8123'])") socket_data.subscribe("") while True: md = socket_data.rev_json(flags=0) msg = socket.recv(flags=0,copy=false, track=false) buf = memoryview(msg) data = np.frombuffer(buf, dtype=md['dtype']) data = np.ndarray.tolist(data.reshape(md['shape'])) self.gatt = data[0] self.diff = data[1] """ x = 0.8 y = 0.4 self.gatt = sinwv(x) self.diff = sinwv(y) def read_value(self): # needs to initialize first maybe using a decorator? if self.live_data: self.live_data_stream() return({'gatt': self.gatt, 'diff': self.diff}) else: self.sim_data_stream() return({'gatt': self.gatt, 'diff': self.diff})
def calibrate(): for i in range(4): EpicsSignal(pv + 'CurrentScale' + str(i + 1)).put(1) EpicsSignal(pv + 'CurrentOffset' + str(i + 1)).put(0) EpicsSignal(pv + 'Range').put(0) time.sleep(1) EpicsSignal(pv + 'CalibrationMode').put(1) time.sleep(1) EpicsSignal(pv + 'CopyADCOffsets.PROC').put(0) time.sleep(1) EpicsSignal(pv + 'CalibrationMode').put(0) time.sleep(1) try: with open(path + "/offsets.csv", "r") as f: print('Offset file already exists.') i = 0 for line in f: if i <= 3: EpicsSignal(pv + 'ADCOffset' + str(i + 1)).put( line.strip()) print('Setting ADCOffset ' + str(i + 1) + ' to ' + line.strip() + '.') i += 1 except Exception as e: print(e) print('Offset file does not exist. Calibrating.') f = open(path + "/offsets.csv", "w") for i in range(4): offset = EpicsSignal(pv + 'ADCOffset' + str(i + 1)).get() f.write(str(offset) + '\n') print('offset ' + str(i) + ': ' + str(offset)) f.close() print('Finished')
def stop_turbo(): turbo_onoff = EpicsSignal('XF:12IDC-VA:2{Det:300KW-TMP:1}OnOff', name='turbo_onoff') turbo_onoff.put(0) iv1 = EpicsSignal('XF:12IDC-VA:2{Det:300KW-IV:1}Cmd:Cls-Cmd', name='iv1') iv1.put(1)
async def pid_output_name(self, instance, async_lib): while (self.pid_output_name.value == ''): await async_lib.sleep(1) self.pid_output = EpicsSignal(self.pid_output_name.value, name='pid_output') def subscription(value, **kwargs): if value != 0: if self.pid_enable is not None: if self.pid_enable.get() == 0: self.pid_output.put(0) self.pid_output.subscribe(subscription)
class Ring(Device): current = EpicsSignalRO('SR:C03-BI{DCCT:1}I:Real-I', name='ring_current') lifetime = EpicsSignalRO('SR:OPS-BI{DCCT:1}Lifetime-I', name='ring_lifetime') energy = EpicsSignalRO('SR{}Energy_SRBend', name='ring_energy') mode = EpicsSignal('SR-OPS{}Mode-Sts', name='ring_ops', string=True) filltarget = EpicsSignalRO('SR-HLA{}FillPattern:DesireImA', name='ring_filltarget')
def bias(): #BIAS f = open(path+"/bias.csv","w") out='bias,rbv,measured' f.write(out+'\n') biases=np.arange(-10,11) #array from -10 to 10 for bias in biases: for i in range(3): EpicsSignal(pv+'BiasVoltage').put(bias) time.sleep(0.1) pro.write("meas:volt:dc?",27) value_measured=pro.readline() value_RBV=EpicsSignal(pv+'BiasVoltage_RBV').get() out=str(bias)+', '+str(value_RBV)+', '+value_measured.split(',')[0].split('N')[0] print(out) f.write(out+'\n') f.close() print('Finished')
def test_read_pv_timestamp_monitor(self): mtr = EpicsMotor(config.motor_recs[0]) mtr.wait_for_connection() sp = EpicsSignal(mtr.user_setpoint.pvname, auto_monitor=True) rbv = EpicsSignalRO(mtr.user_readback.pvname, auto_monitor=True) rbv_value0 = rbv.get() ts0 = rbv.timestamp sp.put(sp.value + 0.1, wait=True) time.sleep(0.1) rbv_value1 = rbv.get() ts1 = rbv.timestamp self.assertGreater(ts1, ts0) self.assertAlmostEqual(rbv_value0 + 0.1, rbv_value1) sp.put(sp.value - 0.1, wait=True)
def collect(id): while time.time() < start_time+span: if id==0: pro.write("meas:volt:dc?",13) value_measured_orig=pro.readline() value_measured=value_measured_orig.split(',')[0].split('N')[0] try: volts.append(float(value_measured)) except: print(value_measured_orig+'.split(\',\')[0].split(\'N\')[0] cannot be converted into a float') if id==1: isAquiring = EpicsSignal(pv+'TS:TSAcquiring').get() if isAquiring == 0: #if it's done acquiring for channel in range(1): #collect data for each channel curr_str=EpicsSignal(pv+'TS:Current'+str(channel+1)+':TimeSeries').value #print(str(channel)+' '+str(curr_str)) currentArr[channel].append(curr_str[0]) EpicsSignal(pv+'TS:TSAcquire').put(1) #acquire new data
class BYKIKS_BURST(Display): _abort_req = EpicsSignal(ABORT_REQ_PV) _last_shots = EpicsSignalRO(LAST_SHOTS_PV) _last_enable = EpicsSignalRO(LAST_EN_PV) _cur_shots = EpicsSignal(CUR_SHOTS_PV) _cur_enable = EpicsSignal(CUR_EN_PV) def __init__(self, parent=None, args=None, macros=None): super(BYKIKS_BURST, self).__init__(parent=parent, args=args, macros=macros) self._abort_req.subscribe(self.abort_clbk) self.ui.clear_abort_btn.clicked.connect(self.clear_abort) def ui_filename(self): """Boiler plate pydm""" return 'bykiks_burst.ui' def ui_filepath(self): """Boiler plate pydm""" return os.path.join(os.path.dirname(os.path.realpath(__file__)), self.ui_filename()) def _set_emer_vis(self, val): """Hide or Show label if abort is active""" if int(val) is 1: #self.ui.abort_en_cb.setDisabled(True) #self.ui.num_shots_le.setDisabled(True) self.ui.emer_label.show() self.ui.clear_abort_btn.show() else: #self.ui.abort_en_cb.setDisabled(False) #self.ui.num_shots_le.setDisabled(False) self.ui.emer_label.hide() self.ui.clear_abort_btn.hide() def abort_clbk(self, value, **kwargs): self._set_emer_vis(value) def clear_abort(self): # Get the previous values and restore self._cur_shots.put(self._last_shots.get()) self._cur_enable.put(self._last_enable.get()) self._abort_req.put(0)
def test_write_pv_timestamp_no_monitor(motor): motor.set(0, wait=True) sp = EpicsSignal(motor.user_setpoint.pvname, name='test') sp_value0 = sp.get() ts0 = sp.timestamp sp.put(sp_value0 + 0.1, wait=True) time.sleep(0.1) sp_value1 = sp.get() ts1 = sp.timestamp assert ts1 > ts0 assert_almost_equal(sp_value0 + 0.1, sp_value1) sp.put(sp.get() - 0.1, wait=True)
def __init__(self): self._sync_markers = { 0.5: 0, 1: 1, 5: 2, 10: 3, 30: 4, 60: 5, 120: 6, 360: 7 } with safe_load('Spare Event Sequencer'): self.seq2 = EventSequencer('ECS:SYS0:11', name='seq_11') with safe_load('PP trigger'): self.evr_pp = Trigger('XCS:USR:EVR:TRIG1', name='evr_pp') with safe_load('SmarAct'): self.las1 = SmarActTipTilt(prefix='XCS:MCS2:01', tip_pv=':m1', tilt_pv=':m2', name='las1') self.las2 = SmarActTipTilt(prefix='XCS:MCS2:01', tip_pv=':m4', tilt_pv=':m5', name='las2') self.las3 = SmarActTipTilt(prefix='XCS:MCS2:01', tip_pv=':m7', tilt_pv=':m8', name='las3') # with safe_load('elog'): # kwargs = dict() # self.elog = HutchELog.from_conf('XCS', **kwargs) # with safe_load('lw68_motors'): self.iStar_focus = Newport('XCS:USR:MMN:06', name='iStar_focus') self.bbo_wp = Newport('XCS:USR:MMN:07', name='bbo_wp') self.huber_x = IMS('XCS:USR:MMS:40', name='huber_x') self.huber_y = IMS('XCS:USR:MMS:37', name='huber_y') self.ldx = IMS('XCS:LAM:MMS:06', name='ldx') self.ldy = IMS('XCS:LAM:MMS:07', name='ldy') self.bs6x = IMS('XCS:LAM:MMS:11', name='bs6x') self.bs6y = IMS('XCS:LAM:MMS:12', name='bs6y') self.att = IMS('XCS:SB2:MMS:15', name='att') # need to chose one ATT motor that does the desired attenuation and identify the two positions to go just in/out. Motor 15 is the 320um filter which does about a factor of 10. with safe_load('Triggers'): self.gateEVR = Trigger('XCS:R42:EVR:01:TRIG4', name='evr_trig4') self.gateEVR_ticks = EpicsSignal('XCS:R42:EVR:01:CTRL.DG4D', name='evr_trig4_ticks') self.GD = self.gateEVR.ns_delay self.tx = self.huber_y self.ty = gon_sy self.tn = self.huber_x #self.ty = xcs_gon.ver self.lp = LaserShutter('XCS:USR:ao1:7', name='lp')
def test_read_pv_timestamp_no_monitor(motor): motor.set(0, wait=True) sp = EpicsSignal(motor.user_setpoint.pvname, name='test') rbv = EpicsSignalRO(motor.user_readback.pvname, name='test') assert rbv.get() == sp.get() rbv_value0 = rbv.get() ts0 = rbv.timestamp sp.put(sp.get() + 0.1) time.sleep(.5) rbv_value1 = rbv.get() ts1 = rbv.timestamp assert ts1 > ts0 assert_almost_equal(rbv_value0 + 0.1, rbv_value1) sp.put(sp.get() - 0.1)
def scan(): pv_EM1 = 'quadEMTest:NSLS_EM:' pv_motor = 'RGD:' pv_EM2 = 'XF:12IDA-BI:2{EM:BPM1}' home_position = [25.05,-10,38.808] #home_position = [0,0,0] step_size=0.005 #in mm radius=1 #in mm init_pos = np.add(home_position,[-radius,0,-radius]) positions = [] for i in range(int(radius*2/step_size + 1)): for j in range(int(radius*2/step_size + 1)): delta=[step_size*j,0,step_size*i] positions.append(np.add(init_pos,delta)) #print(positions) f = open(path+"/scan_"+str(step_size)+"mm.csv","w") #out='x,y,z,photodiode (micro amp), current A, current B, current C, current D' #f.write(out+'\n') for i in range(len(positions)): EpicsSignal(pv_motor+'X.VAL').put(positions[i][0]) EpicsSignal(pv_motor+'Z.VAL').put(positions[i][2]) if(i%int(radius*2/step_size + 1)==0): time.sleep(2) else: time.sleep(0.3) currA=EpicsSignal(pv_EM2+'Current1:MeanValue_RBV').get() currB=EpicsSignal(pv_EM2+'Current2:MeanValue_RBV').get() currC=EpicsSignal(pv_EM2+'Current3:MeanValue_RBV').get() currD=EpicsSignal(pv_EM2+'Current4:MeanValue_RBV').get() currPhoto=EpicsSignal(pv_EM1+'Current1:MeanValue_RBV').get() print('moved to '+str(positions[i][0]-home_position[0])+', '+str(positions[i][2]-home_position[2])) out=str(positions[i][0])+', '+str(positions[i][1])+', '+str(positions[i][2])+', '+str(currPhoto)+', '+str(currA)+', '+str(currB)+', '+str(currC)+', '+str(currD) print(out) f.write(out+'\n') f.close() EpicsSignal(pv_motor+'X.VAL').put(home_position[0]) EpicsSignal(pv_motor+'Y.VAL').put(home_position[1]) EpicsSignal(pv_motor+'Z.VAL').put(home_position[2]) print("Finished")
class Ramper(Device): pv_sp = Cpt(EpicsSignal, 'pv_sp', name='pv_sp') pv_sp_rate = Cpt(EpicsSignal, 'pv_sp_rate', name='pv_sp_rate') # pv setpoint change rate in pv units per minute go = Cpt(EpicsSignal, 'go', name='go') pv_pause = EpicsSignal('XF:08IDB-Ramping:pause', name='pv_pause') tprog = Cpt(EpicsSignal, 'tprog', name='tprog') pvprog = Cpt(EpicsSignal, 'pvprog', name='pvprog') dwell = Cpt(EpicsSignal, 'dwell', name='dwell') safety_thresh = Cpt(EpicsSignal, 'safety_thresh', name='safety_thresh') safety_timer = Cpt(EpicsSignal, 'safety_timer', name='safety_timer') pid_enable_name = Cpt(EpicsSignal, 'pid_enable_name', name='pid_enable_name') pid_output_name = Cpt(EpicsSignal, 'pid_output_name', name='pid_output_name') def __init__(self, aux_pv_sp=None, *args, **kwargs): super().__init__(*args, **kwargs) self.aux_pv_sp = aux_pv_sp self._subscribe_aux_pv_sp() self.subscribe_safety_timer_upd() def _subscribe_aux_pv_sp(self): if self.aux_pv_sp is not None: def subscription(value, **kwargs): setpoint = value self.aux_pv_sp.put(setpoint) return self.pv_sp.subscribe(subscription) def subscribe_safety_timer_upd(self): def subscription(value, **kwargs): if value>5: self.safety_timer.put(0) self.safety_timer.subscribe(subscription) def enable(self): self.pv_pause.put(0) self.go.put(1) def pause(self): self.pv_pause.put(1) def depause(self): self.pv_pause.put(0) def disable(self, pv_sp_value=25): self.go.put(0) self.pv_pause.put(0) ttime.sleep(0.3) if pv_sp_value is not None: self.pv_sp.put(pv_sp_value)
def collect(id): while time.time() < start_time+span: if id==0: #Temperature collection #pro.write("meas:volt:dc?",13) #value_measured_orig=pro.readline() #value_measured=value_measured_orig.split(',')[0].split('N')[0] if id==1: #Drift collection isAquiring = EpicsSignal(pv_EM6+'TS:TSAcquiring').get() if isAquiring == 0: #if it's done acquiring channel=1 #1-4 curr_str=EpicsSignal(pv_EM6+'TS:Current'+channel+':TimeSeries').value drift_curr_6.append(curr_str[0]) EpicsSignal(pv_EM6+'TS:TSAcquire').put(1) #acquire new data temp_thread = threading.Thread(target=collect, args=(0,)) drift_thread = threading.Thread(target=collect, args=(1,)) EpicsSignal(pv_EM6+'TS:TSAcquire').put(1) #acquire new data start_time=time.time() # starting thread 1 drift_thread.start() # starting thread 2 temp_thread.start() # wait until thread 1 is completely executed drift_thread.join() # wait until thread 2 is completely executed temp_thread.join() end_time=time.time() temp_curr_mean = np.average(temp_curr_102) temp_curr_std = np.std(temp_curr_102,ddof=1) temp_curr_num = len(temp_curr_102) drift_curr_mean = np.average(drift_curr_6) drift_curr_std = np.std(drift_curr_6,ddof=1) drift_curr_num=len(drift_curr_6) out=str(start_time)+','+str(end_time)+','+str(voltage_mean)+','+str(voltage_std)+','+str(voltage_num)+','+str(current_mean)+','+str(current_std)+','+str(current_num) print(out) f.write(out+'\n') f.flush()
def test_add_signal(sim_signal): # Create Signals epics_sig = EpicsSignal('Tst:This') # Create empty plot ttp = TyphonTimePlot() # Add to list of available signals ttp.add_available_signal(epics_sig, 'Epics Signal') assert ttp.ui.signal_combo.itemText(0) == 'Epics Signal' assert ttp.ui.signal_combo.itemData(0) == 'ca://Tst:This' ttp.add_available_signal(sim_signal, 'Simulated Signal') assert ttp.ui.signal_combo.itemText(1) == 'Simulated Signal' assert ttp.ui.signal_combo.itemData(1) == 'sig://tst_this_2'
def dark_current(): shb = user_ns['shb'] reopen = shb.state.get() == shb.openval if reopen: print('\nClosing photon shutter') yield from shb.close_plan() print('Measuring current offsets, this will take several seconds') EpicsSignal("XF:06BM-BI{EM:1}EM180:ComputeCurrentOffset1.PROC", name='').put(1) EpicsSignal("XF:06BM-BI{EM:1}EM180:ComputeCurrentOffset2.PROC", name='').put(1) EpicsSignal("XF:06BM-BI{EM:1}EM180:ComputeCurrentOffset3.PROC", name='').put(1) EpicsSignal("XF:06BM-BI{EM:1}EM180:ComputeCurrentOffset4.PROC", name='').put(1) yield from sleep(3) BMM_log_info('Measured dark current on quadem1') if reopen: print('Opening photon shutter') yield from shb.open_plan() print('You are ready to measure!\n')
class MaxiGauge: def __init__(self, devName): self.pres_sig = EpicsSignal(devName + 'P:Raw-I') def pressure(self): msg = self.pres_sig.get() if msg == "UNDER": return 1.0e-3 elif msg == "OVER": return 1.1e3 else: return float(msg)
def gv_temp_open(sysdev, duration): """ gv_temp_open("XF:21IDB-VA{BT:10-GV:10_D_1}", 1.5 (seconds)) """ open_pv_str = sysdev + "Cmd:Opn-Cmd" close_pv_str = sysdev + "Cmd:Cls-Cmd" open_cmd = EpicsSignal(name="open_cmd", read_pv=open_pv_str, write_pv=open_pv_str) close_cmd = EpicsSignal(name="close_cmd", read_pv=close_pv_str, write_pv=close_pv_str) open_cmd.put(1) time.sleep(duration) close_cmd.put(1)
def cryofill(wait_time_after_v19_claose=60 * 10): cryo_v19_possp = EpicsSignal('XF:05IDA-UT{Cryo:1-IV:19}Pos-SP', name='cryov19_possp') cryo_v19_possp.set(100) while abs(cryo_v19.get() - 1) > 0.05: cryo_v19_possp.set(100) time.sleep(2) time.sleep(5) while (cryo_v19.get() - 0) > 0.05: print('cryo cooler still refilling') time.sleep(5) cryo_v19_possp.set(0) print('waiting for', wait_time_after_v19_claose, 's', 'before taking data...') time.sleep(wait_time_after_v19_claose)
def __init__(self, *args, gain_0, gain_1, gain_2, hspeed_bit, bw_10mhz_bit, bw_1mhz_bit, lnoise, hspeed, bwidth, par = None, **kwargs): super().__init__(*args, **kwargs) self.gain_0 = EpicsSignal(self.prefix + gain_0, name=self.name + '_gain_0') self.gain_1 = EpicsSignal(self.prefix + gain_1, name=self.name + '_gain_1') self.gain_2 = EpicsSignal(self.prefix + gain_2, name=self.name + '_gain_2') self.hspeed_bit = EpicsSignal(self.prefix + hspeed_bit, name=self.name + '_hspeed_bit') self.bw_10mhz_bit = EpicsSignal(self.prefix + bw_10mhz_bit, name=self.name + '_bw_10mhz_bit') self.bw_1mhz_bit = EpicsSignal(self.prefix + bw_1mhz_bit, name=self.name + '_bw_1mhz_bit') self.low_noise_gain = EpicsSignal(self.prefix + lnoise, name=self.name + '_lnoise') self.high_speed_gain = EpicsSignal(self.prefix + hspeed, name=self.name + '_hspeed') self.band_width = EpicsSignal(self.prefix + bwidth, name=self.name + '_bwidth') self.par = par
def test_write_pv_timestamp_no_monitor(self): mtr = EpicsMotor(config.motor_recs[0]) mtr.wait_for_connection() sp = EpicsSignal(mtr.user_setpoint.pvname) sp_value0 = sp.get() ts0 = sp.timestamp sp.put(sp_value0 + 0.1, wait=True) time.sleep(0.1) sp_value1 = sp.get() ts1 = sp.timestamp self.assertGreater(ts1, ts0) self.assertAlmostEqual(sp_value0 + 0.1, sp_value1) sp.put(sp.value - 0.1, wait=True)
from ophyd import (EpicsSignal, Signal) from ophyd.utils.epics_pvs import record_field def callback(sub_type=None, timestamp=None, value=None, **kwargs): logger.info('[callback] [%s] (type=%s) value=%s', timestamp, sub_type, value) # Test that the monitor dispatcher works (you cannot use channel access in # callbacks without it) logger.info('[callback] caget=%s', rw_signal.get()) logger = config.logger motor_record = config.motor_recs[0] val = record_field(motor_record, 'VAL') rbv = record_field(motor_record, 'RBV') rw_signal = EpicsSignal(rbv, write_pv=val) rw_signal.subscribe(callback, event_type=rw_signal.SUB_VALUE) rw_signal.subscribe(callback, event_type=rw_signal.SUB_SETPOINT) rw_signal.value = 2 time.sleep(1.) rw_signal.value = 1 time.sleep(1.) # You can also create a Python Signal: sig = Signal(name='testing', value=10) logger.info('Python signal: %s', sig)
def __init__(self, running_pv): self._last_start = None self.running_signal = EpicsSignal(running_pv) self._running = False
class ICAmplifier(Device): #low_noise_gain = Cpt(EpicsSignal, 'LN}I0') def __init__(self, *args, gain_0, gain_1, gain_2, hspeed_bit, bw_10mhz_bit, bw_1mhz_bit, lnoise, hspeed, bwidth, par = None, **kwargs): super().__init__(*args, **kwargs) self.gain_0 = EpicsSignal(self.prefix + gain_0, name=self.name + '_gain_0') self.gain_1 = EpicsSignal(self.prefix + gain_1, name=self.name + '_gain_1') self.gain_2 = EpicsSignal(self.prefix + gain_2, name=self.name + '_gain_2') self.hspeed_bit = EpicsSignal(self.prefix + hspeed_bit, name=self.name + '_hspeed_bit') self.bw_10mhz_bit = EpicsSignal(self.prefix + bw_10mhz_bit, name=self.name + '_bw_10mhz_bit') self.bw_1mhz_bit = EpicsSignal(self.prefix + bw_1mhz_bit, name=self.name + '_bw_1mhz_bit') self.low_noise_gain = EpicsSignal(self.prefix + lnoise, name=self.name + '_lnoise') self.high_speed_gain = EpicsSignal(self.prefix + hspeed, name=self.name + '_hspeed') self.band_width = EpicsSignal(self.prefix + bwidth, name=self.name + '_bwidth') self.par = par def set_gain(self, value: int, high_speed: bool): val = int(value) - 2 if not ((high_speed and (1 <= val < 7)) or (not high_speed and (0 <= val < 6))): print('{} invalid value. Ignored...'.format(self.name)) return 'Aborted' if high_speed: val -= 1 self.low_noise_gain.put(0) self.high_speed_gain.put(val + 1) self.hspeed_bit.put(1) else: self.low_noise_gain.put(val + 1) self.high_speed_gain.put(0) self.hspeed_bit.put(0) self.gain_0.put((val >> 0) & 1) self.gain_1.put((val >> 1) & 1) self.gain_2.put((val >> 2) & 1) def set_gain_plan(self, value: int, high_speed: bool): val = int(value) - 2 if not ((high_speed and (1 <= val < 7)) or (not high_speed and (0 <= val < 6))): print('{} invalid value. Ignored...'.format(self.name)) return 'Aborted' if high_speed: val -= 1 yield from bps.abs_set(self.low_noise_gain, 0) yield from bps.abs_set(self.high_speed_gain, val + 1) yield from bps.abs_set(self.hspeed_bit, 1) else: yield from bps.abs_set(self.low_noise_gain, val + 1) yield from bps.abs_set(self.high_speed_gain, 0) yield from bps.abs_set(self.hspeed_bit, 0) yield from bps.abs_set(self.gain_0, (val >> 0) & 1) yield from bps.abs_set(self.gain_1, (val >> 1) & 1) yield from bps.abs_set(self.gain_2, (val >> 2) & 1) def get_gain(self): if self.low_noise_gain.value == 0: return [self.high_speed_gain.enum_strs[self.high_speed_gain.value], 1] elif self.high_speed_gain.value == 0: return [self.low_noise_gain.enum_strs[self.low_noise_gain.value], 0] else: return ['0', 0]