def test_pre_suspend_plan(RE, pre_plan, post_plan, expected_list, hw): sig = hw.bool_sig scan = [Msg('checkpoint'), Msg('sleep', None, .2)] msg_lst = [] sig.put(0) def accum(msg): msg_lst.append(msg) susp = SuspendBoolHigh(sig, pre_plan=pre_plan, post_plan=post_plan) RE.install_suspender(susp) RE._loop.call_later(.1, sig.put, 1) RE._loop.call_later(1, sig.put, 0) RE.msg_hook = accum RE(scan) assert len(msg_lst) == len(expected_list) assert expected_list == [m[0] for m in msg_lst] RE.remove_suspender(susp) RE(scan) assert susp.RE is None RE.install_suspender(susp) RE.clear_suspenders() assert susp.RE is None assert not RE.suspenders
def test_suspender_plans(RE, hw): 'Tests that the suspenders can be installed via Msg' loop = RE._loop sig = hw.bool_sig my_suspender = SuspendBoolHigh(sig, sleep=0.2) def putter(val): sig.put(val) putter(0) # Do the messages work? RE([Msg('install_suspender', None, my_suspender)]) assert my_suspender in RE.suspenders RE([Msg('remove_suspender', None, my_suspender)]) assert my_suspender not in RE.suspenders # Can we call both in a plan? RE([ Msg('install_suspender', None, my_suspender), Msg('remove_suspender', None, my_suspender) ]) scan = [Msg('checkpoint'), Msg('sleep', None, .2)] # No suspend scan: does the wrapper error out? start = ttime.time() RE(suspend_wrapper(scan, my_suspender)) stop = ttime.time() delta = stop - start assert delta < .9 # Suspend scan start = ttime.time() threading.Timer(.1, putter, (1, )).start() threading.Timer(.5, putter, (0, )).start() RE(suspend_wrapper(scan, my_suspender)) stop = ttime.time() delta = stop - start assert delta > .9 # Did we clean up? start = ttime.time() threading.Timer(.1, putter, (1, )).start() threading.Timer(.5, putter, (0, )).start() RE(scan) stop = ttime.time() delta = stop - start assert delta < .9
def test_pretripped(RE, hw): 'Tests if suspender is tripped before __call__' sig = hw.bool_sig scan = [Msg('checkpoint')] msg_lst = [] sig.put(1) def accum(msg): msg_lst.append(msg) susp = SuspendBoolHigh(sig) RE.install_suspender(susp) RE._loop.call_later(1, sig.put, 0) RE.msg_hook = accum RE(scan) assert len(msg_lst) == 2 assert ['wait_for', 'checkpoint'] == [m[0] for m in msg_lst]
def test_pause_from_suspend(RE, hw): 'Tests what happens when a pause is requested from a suspended state' sig = hw.bool_sig scan = [Msg('checkpoint')] msg_lst = [] sig.put(1) def accum(msg): msg_lst.append(msg) susp = SuspendBoolHigh(sig) RE.install_suspender(susp) RE._loop.call_later(1, RE.request_pause) RE._loop.call_later(2, sig.put, 0) RE.msg_hook = accum with pytest.raises(RunEngineInterrupted): RE(scan) assert [m[0] for m in msg_lst] == ['wait_for'] RE.resume() assert ['wait_for', 'wait_for', 'checkpoint'] == [m[0] for m in msg_lst]
def test_pause_from_suspend(fresh_RE): 'Tests what happens when a pause is requested from a suspended state' RE = fresh_RE sig = ophyd.Signal() scan = [Msg('checkpoint')] msg_lst = [] sig.put(1) def accum(msg): msg_lst.append(msg) susp = SuspendBoolHigh(sig) RE.install_suspender(susp) RE._loop.call_later(1, RE.request_pause) RE._loop.call_later(2, sig.put, 0) RE.msg_hook = accum RE(scan) assert [m[0] for m in msg_lst] == ['wait_for'] RE.resume() assert ['wait_for', 'wait_for', 'checkpoint'] == [m[0] for m in msg_lst]
def test_deferred_pause_from_suspend(RE, hw): 'Tests what happens when a soft pause is requested from a suspended state' sig = hw.bool_sig scan = [Msg('checkpoint'), Msg('null')] msg_lst = [] sig.put(1) def accum(msg): print(msg) msg_lst.append(msg) susp = SuspendBoolHigh(sig) RE.install_suspender(susp) threading.Timer(1, RE.request_pause, (True, )).start() threading.Timer(4, sig.put, (0, )).start() RE.msg_hook = accum with pytest.raises(RunEngineInterrupted): RE(scan) assert [m[0] for m in msg_lst] == ['wait_for', 'checkpoint'] RE.resume() assert ['wait_for', 'checkpoint', 'null'] == [m[0] for m in msg_lst]
from ophyd import EpicsSignal from bluesky.suspenders import SuspendBoolHigh fast_shutter = EpicsSignal('XF:28IDC-ES:1{Sh:Exp}Sw:Cls1-Sts') shutter_sus = SuspendBoolHigh(fast_shutter, sleep=3) # RE.install_suspender(shutter_sus)
# Here are some conditions that will cause scans to pause automatically: # - when the beam current goes below a certain threshold susp_current = SuspendFloor(beamline_status.beam_current, suspend_thresh=150.0, resume_thresh=240.0, tripped_message='beam current too low', ) # - when the shutter is closed susp_shutter = SuspendBoolLow(beamline_status.shutter_status, tripped_message='shutter not open', ) # - if the beamline isn't enabled susp_enabled = SuspendBoolLow(beamline_status.beamline_enabled, tripped_message='beamline is not enabled', ) susp_cryo_cooler = SuspendBoolHigh(beamline_status.cryo_filling, sleep=60*10, tripped_message='Cyrocooler is refilling') # NOTE: to enable or disable the suspenders, (un)comment the following: # Install all suspenders: #RE.install_suspender(susp_current) #RE.install_suspender(susp_shutter) #RE.install_suspender(susp_enabled) #RE.install_suspender(susp_cryo_cooler)
#new figure feature import os import json import bluesky.plans as bp import bluesky.plan_stubs as bps import bluesky.preprocessors as bpp from bluesky.suspenders import SuspendBoolHigh import uuid from cycler import cycler import pandas as pd # Add suspender for shutter # Note: to clear suspenders use RE.clear_suspenders() suspend_fe_shutter = SuspendBoolHigh(EpicsSignalRO('XF:23ID-PPS{Sh:FE}Pos-Sts')) RE.install_suspender(suspend_fe_shutter) suspend_ds_shutter = SuspendBoolHigh(EpicsSignalRO('XF:23ID2-PPS{PSh}Pos-Sts')) RE.install_suspender(suspend_ds_shutter) def relabel_fig(fig, new_label): fig.set_label(new_label) fig.canvas.manager.set_window_title(fig.get_label()) # NOTE : This now requires DETS as a list def multi_part_ascan(DETS, motor1, steps, motor2, asc_p): for d in steps: yield from bps.abs_set(motor1, d, wait=True) yield from bp.scan(DETS, motor2, *asc_p)
print(__file__) from bluesky.suspenders import (SuspendBoolHigh, SuspendBoolLow, SuspendFloor, SuspendCeil, SuspendInBand, SuspendOutBand) fe_shut_suspender = SuspendBoolHigh(EpicsSignalRO(shutter_fe.status.pvname), sleep=10 * 60) ph_shut_suspender = SuspendBoolHigh(EpicsSignalRO(shutter_ph.status.pvname), sleep=10 * 60) # suspender for beamline current is mA beam_current_suspender = SuspendFloor(nsls_ii.beam_current, suspend_thresh=300, sleep=10 * 60) suspenders = [ fe_shut_suspender, ph_shut_suspender, beam_current_suspender, ] ''' Some help on suspenders /bluesky # how to add a suspender: # Method 1: # RE.install_suspender(fe_shut_suspender) # Method 2 (in the plan): # RE(bpp.suspend_wrapper(myplan(), [suspenders])) # general bluesky info # blue sky plans (mostly) reside here: # general plans
all_BMM_suspenders.append(suspender_bmps) except: pass ## ---------------------------------------------------------------------------------- ## suspend if the main photon shutter closes, resume 5 seconds after opening try: suspender_sha = SuspendBoolLow(user_ns['idps'].state, sleep=60) all_BMM_suspenders.append(suspender_sha) except: pass ## ---------------------------------------------------------------------------------- ## suspend if the experimental photon shutter closes, resume 5 seconds after opening try: suspender_shb = SuspendBoolHigh(user_ns['shb'].state, sleep=5) all_BMM_suspenders.append(suspender_shb) except: pass def BMM_suspenders(): BMMuser = user_ns['BMMuser'] if BMMuser.suspenders_engaged: return for s in all_BMM_suspenders: user_ns['RE'].install_suspender(s) BMMuser.suspenders_engaged = True def BMM_clear_suspenders():
from bluesky.suspenders import SuspendFloor, SuspendBoolHigh ring_suspender = SuspendFloor(ring_curr, 190, resume_thresh=200, sleep=120) #, post_plan=beamline_align_v2) shutterb_suspender = SuspendBoolHigh(EpicsSignalRO(shutterb.status.pvname), sleep=10 * 60) #post_plan=beamline_align_v2) # Is this the right PV??? fe_shut_suspender = SuspendBoolHigh(EpicsSignal('XF:02ID-PPS{Sh:FE}Pos-Sts'), sleep=10 * 60) #fe_shut_suspender = SuspendBoolHigh(EpicsSignal('XF:02ID-PPS{Sh:FE}Pos-Sts'), sleep=10*60) ## It needs: ## RE.install_suspender(test_shutsusp) ## RE.remove_suspender(test_shutsusp) RE.install_suspender(ring_suspender) RE.install_suspender(fe_shut_suspender) RE.install_suspender(shutterb_suspender) print("") print( "You can safely ignore the 'SuspendOutBand' warning - this is a known issue that is fixed in a newer version." )
susp_rc = SuspendFloor(ring_current, 140, resume_thresh=160, sleep=10 * 60, pre_plan=list(shuttergenerator(shut_b, 'Close')), post_plan=list(shuttergenerator(shut_b, 'Open'))) # Cryo cooler suspender susp_cryo = SuspendCeil(cryo_v19, 0.8, resume_thresh=0.2, sleep=15 * 60, pre_plan=list(shuttergenerator(shut_b, 'Close')), post_plan=list(shuttergenerator(shut_b, 'Open'))) # Shutter status suspender susp_shut_fe = SuspendBoolHigh(EpicsSignalRO(shut_fe.status.pvname), sleep=10) susp_shut_a = SuspendBoolHigh(EpicsSignalRO(shut_a.status.pvname), sleep=10) susp_shut_b = SuspendBoolHigh(EpicsSignalRO(shut_b.status.pvname), sleep=10) # HDCM bragg temperature suspender susp_dcm_bragg_temp = SuspendCeil(dcm.temp_pitch, 120, resume_thresh=118, sleep=1) # Install suspenders RE.install_suspender(susp_rc) RE.install_suspender(susp_shut_fe) RE.install_suspender(susp_dcm_bragg_temp)
print(__file__) from bluesky.suspenders import (SuspendBoolHigh, SuspendBoolLow, SuspendFloor, SuspendCeil, SuspendInBand, SuspendOutBand) fe_shut_suspender = SuspendBoolHigh(shutter_fe.state, sleep=10 * 60) ph_shut_suspender = SuspendBoolHigh(shutter_ph.state, sleep=10 * 60) # suspender for beamline current is mA beam_current_suspender = SuspendFloor(nsls_ii.beam_current, suspend_thresh=300, sleep=10 * 60) suspenders = [ fe_shut_suspender, ph_shut_suspender, beam_current_suspender, ] ''' Some help on suspenders /bluesky # how to add a suspender: # Method 1: # RE.install_suspender(fe_shut_suspender) # Method 2 (in the plan): # RE(bpp.suspend_wrapper(myplan(), [suspenders])) # general bluesky info # blue sky plans (mostly) reside here: # general plans import bluesky.plans as bp # (bp.count())
def tell_slack_shb_closed(): print('triggering closed message') post_to_slack('B shutter closed') return (yield from null()) def tell_slack_shb_opened(): print('triggering opened message') post_to_slack('B shutter opened') return (yield from null()) try: suspender_shb = SuspendBoolHigh(user_ns['shb'].state, sleep=5, pre_plan=tell_slack_shb_closed(), post_plan=tell_slack_shb_opened()) all_BMM_suspenders.append(suspender_shb) except Exception as e: print(f'failed to create shb suspender: {e}') pass def BMM_suspenders(): BMMuser = user_ns['BMMuser'] if BMMuser.suspenders_engaged: return for s in all_BMM_suspenders: user_ns['RE'].install_suspender(s) BMMuser.suspenders_engaged = True
from bluesky.suspenders import (SuspendBoolHigh, SuspendBoolLow, SuspendFloor, SuspendCeil, SuspendInBand, SuspendOutBand) from ophyd import EpicsSignal from .startup import RE ring_suspender = SuspendFloor(EpicsSignal('XF:23ID-SR{}I-I'), 250, sleep=3 * 60) #ring_suspender = SuspendFloor(EpicsSignal('XF:23ID-SR{}I-I'), 250, sleep=3) fe_shut_suspender = SuspendBoolHigh(EpicsSignal('XF:23ID-PPS{Sh:FE}Pos-Sts'), sleep=10 * 60) #fe_shut_suspender = SuspendBoolHigh(EpicsSignal('XF:23ID-PPS{Sh:FE}Pos-Sts'), sleep=3) ps1_shut_suspender = SuspendBoolHigh(EpicsSignal('XF:23IDA-PPS:1{PSh}Pos-Sts'), sleep=5 * 60) #ps1_shut_suspender = SuspendBoolHigh(EpicsSignal('XF:23IDA-PPS:1{PSh}Pos-Sts'),sleep=3) RE.install_suspender(ring_suspender) RE.install_suspender(fe_shut_suspender) RE.install_suspender(ps1_shut_suspender)