Example #1
0
    def kickoff(self):
        armed_status = DeviceStatus(self)
        self._disarmed_status = disarmed_status = DeviceStatus(self)

        pc = self.pos_capt
        external = bool(pc.arm.source.get()) # Using external trigger?

        if external:
            armed_signal = pc.arm.input_status
        else:
            armed_signal = pc.arm.output

        disarmed_signal = self.download_status

        self._collection_ts = time.time()

        def armed_status_cb(value, old_value, obj, **kwargs):
            if int(old_value) == 0 and int(value) == 1:
                armed_status._finished()
                obj.clear_sub(armed_status_cb)

        def disarmed_status_cb(value, old_value, obj, **kwargs):
            # I'm getting a stale 1 -> 0 update, so use timestamps to filter that out
            if int(old_value) == 1 and int(value) == 0:
                disarmed_status._finished()
                obj.clear_sub(disarmed_status_cb)

        armed_signal.subscribe(armed_status_cb, run=False)
        disarmed_signal.subscribe(disarmed_status_cb, run=False)

        # Arm it if not External
        if not external:
            self.pos_capt.arm.arm.put(1)

        return armed_status
Example #2
0
    def set(self, val):
        if self._set_st is not None:
            raise RuntimeError(f'trying to set {self.name}'
                               ' while a set is in progress')

        cmd_map = {self.open_str: self.open_cmd,
                   self.close_str: self.close_cmd}
        target_map = {self.open_str: self.open_val,
                      self.close_str: self.close_val}

        cmd_sig = cmd_map[val]
        target_val = target_map[val]

        st = DeviceStatus(self)
        if self.status.get() == target_val:
            st._finished()
            return st

        self._set_st = st
        print(self.name, val, id(st))
        enums = self.status.enum_strs

        def shutter_cb(value, timestamp, **kwargs):
            value = enums[int(value)]
            if value == target_val:
                self._set_st = None
                self.status.clear_sub(shutter_cb)
                st._finished()

        cmd_enums = cmd_sig.enum_strs
        count = 0

        def cmd_retry_cb(value, timestamp, **kwargs):
            nonlocal count
            value = cmd_enums[int(value)]
            count += 1
            if count > self.MAX_ATTEMPTS:
                cmd_sig.clear_sub(cmd_retry_cb)
                self._set_st = None
                self.status.clear_sub(shutter_cb)
                st._finished(success=False)
            if value == 'None':
                if not st.done:
                    time.sleep(self.RETRY_PERIOD)
                    cmd_sig.set(1)

                    ts = datetime.datetime.fromtimestamp(timestamp) \
                        .strftime(_time_fmtstr)
                    if count > 2:
                        msg = '** ({}) Had to reactuate shutter while {}ing'
                        print(msg.format(ts, val if val != 'Close'
                                         else val[:-1]))
                else:
                    cmd_sig.clear_sub(cmd_retry_cb)

        cmd_sig.subscribe(cmd_retry_cb, run=False)
        self.status.subscribe(shutter_cb)
        cmd_sig.set(1)

        return st
Example #3
0
 def trigger(self):
     if self._staged != Staged.yes:
         raise RuntimeError(
             "This device must be staged before being triggered")
     st = DeviceStatus(self)
     self._compute()
     st.set_finished()
     return st
Example #4
0
 def kickoff(self):
     """
     Set 'ready' to True and return a status object tied to 'injected'.
     """
     self.ready.set(1)
     self.hplc_status = HPLCStatus.waiting_injected
     self._injected_status = DeviceStatus(self.injected)
     self._done_status = DeviceStatus(self.done)
     return self._injected_status
Example #5
0
    def trigger(self):
        "Trigger one acquisition."
        if self._staged != Staged.yes:
            raise RuntimeError("This detector is not ready to trigger."
                               "Call the stage() method before triggering.")

        self._status = DeviceStatus(self)
        self._acquisition_signal.put(1, callback=self._acquisition_done)
        return self._status
Example #6
0
 def trigger(self):
     if self._staged != Staged.yes:
         raise RuntimeError(
             "This device must be staged before being triggered")
     st = DeviceStatus(self)
     gap = self.gap.get()
     datum = self._datum_factory(datum_kwargs={"gap": gap})
     self._asset_docs_cache.append(("datum", datum))
     self.image.put(datum["datum_id"])
     st.set_finished()
     return st
Example #7
0
class SaturnSoftTrigger(BlueskyInterface):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._status = None
        self._acquisition_signal = self.mca.erase_start

        self.stage_sigs[self.mca.stop_signal] = 1
        self.stage_sigs[self.dxp.preset_mode] = 'Real time'
        #self.stage_sigs[self.dxp.preset_mode] = 'Live time'

        self._count_signal = self.mca.preset_real_time
        self._count_time = None

    def stage(self):
        if self._count_time is not None:
            self.stage_sigs[self._count_signal] = self._count_time

        super().stage()

    def unstage(self):
        try:
            super().unstage()
        finally:
            if self._count_signal in self.stage_sigs:
                del self.stage_sigs[self._count_signal]
                self._count_time = None

    def trigger(self):
        "Trigger one acquisition."
        if self._staged != Staged.yes:
            raise RuntimeError("This detector is not ready to trigger."
                               "Call the stage() method before triggering.")

        self._status = DeviceStatus(self)
        self._acquisition_signal.put(1, callback=self._acquisition_done)
        return self._status

    def _acquisition_done(self, **kwargs):
        '''pyepics callback for when put completion finishes'''
        if self._status is not None:
            self._status._finished()
            self._status = None

    @property
    def count_time(self):
        '''Exposure time, as set by bluesky'''
        return self._count_time

    @count_time.setter
    def count_time(self, count_time):
        self._count_time = count_time
Example #8
0
class SaturnSoftTrigger(BlueskyInterface):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._status = None
        self._acquisition_signal = self.mca.erase_start

        self.stage_sigs[self.mca.stop_signal] = 1
        self.stage_sigs[self.dxp.preset_mode] = 'Real time'

        self._count_signal = self.mca.preset_real_time
        self._count_time = None

    def stage(self):
        if self._count_time is not None:
            self.stage_sigs[self._count_signal] = self._count_time

        super().stage()

    def unstage(self):
        try:
            super().unstage()
        finally:
            if self._count_signal in self.stage_sigs:
                del self.stage_sigs[self._count_signal]
                self._count_time = None

    def trigger(self):
        "Trigger one acquisition."
        if self._staged != Staged.yes:
            raise RuntimeError("This detector is not ready to trigger."
                               "Call the stage() method before triggering.")

        self._status = DeviceStatus(self)
        self._acquisition_signal.put(1, callback=self._acquisition_done)
        return self._status

    def _acquisition_done(self, **kwargs):
        '''pyepics callback for when put completion finishes'''
        if self._status is not None:
            self._status._finished()
            self._status = None

    @property
    def count_time(self):
        '''Exposure time, as set by bluesky'''
        return self._count_time

    @count_time.setter
    def count_time(self, count_time):
        self._count_time = count_time
 def trigger(self):
     "Trigger one acquisition."
     if not self._staged:
         raise RuntimeError("This detector is not ready to trigger."
                            "Call the stage() method before triggering.")
     self._save_started = False
     self._status = DeviceStatus(self)
     self._desired_number_of_sets = self.number_of_sets.get()
     self._plugin.num_capture.put(self._desired_number_of_sets)
     self.dispatch(self._image_name, ttime.time())
     # reset the proc buffer, this needs to be generalized
     self.proc.reset_filter.put(1)
     self._plugin.capture.put(1)  # Now the TIFF plugin is capturing.
     return self._status
Example #10
0
    def trigger(self):
        status = DeviceStatus(self)

        if self.status:
            status._finished()
        else:
            self._statuses.append(status)

        if not status.done:
            logger.warning('---')
            logger.warning('Waiting for beam status to change...')
            logger.warning('---')

        return status
Example #11
0
    def set(self, value):  # interface for BlueSky plans
        """value is either Taxi, Fly, or Return"""
        #         allowed = "Taxi Fly Return".split()
        allowed = "Taxi Fly".split()
        if str(value).lower() not in list(map(str.lower, allowed)):
            msg = "value should be one of: " + " | ".join(allowed)
            msg + " received " + str(value)
            raise ValueError(msg)

        if self.busy.value:
            raise RuntimeError("shutter is operating")

        status = DeviceStatus(self)

        def action():
            """the real action of ``set()`` is here"""
            if str(value).lower() == "taxi":
                self.taxi()
            elif str(value).lower() == "fly":
                self.fly()
#             elif str(value).lower() == "return":
#                 self.motor.move(self.return_position)

        def run_and_wait():
            """handle the ``action()`` in a thread"""
            self.busy.put(True)
            action()
            self.busy.put(False)
            status._finished(success=True)

        threading.Thread(target=run_and_wait, daemon=True).start()
        return status
Example #12
0
    def set(self, value):  # interface for BlueSky plans
        """value is either Taxi or Fly"""
        if str(value).lower() not in ("fly", "taxi"):
            msg = "value should be either Taxi or Fly."
            msg + " received " + str(value)
            raise ValueError(msg)

        if self.busy.value:
            raise RuntimeError("shutter is operating")

        status = DeviceStatus(self)

        def action():
            """the real action of ``set()`` is here"""
            if str(value).lower() == "taxi":
                self.taxi()
            elif str(value).lower() == "fly":
                self.fly()

        def run_and_wait():
            """handle the ``action()`` in a thread"""
            self.busy.put(True)
            action()
            self.busy.put(False)
            status._finished(success=True)

        threading.Thread(target=run_and_delay, daemon=True).start()
        return status
    def set(self, val):
        st = self._status
        if st is not None:
            st._finished(success=False)
            self._status = None

        st = self._status = DeviceStatus(self)
        self.setpoint.put(val)
        return st
Example #14
0
    def kickoff(self):
        """
        run the trajectory
        """
        if self.verified == False:
            raise Exception("trajectory not defined/verified.")

        #self._traj_status = DeviceStatus(self.ExecuteState)
        self._traj_status = DeviceStatus(self)

        ##self.exec_traj(self.traj_par['run_forward_traj'])  # should not block
        th = threading.Thread(target=self.exec_traj,
                              args=(self.traj_par['run_forward_traj'], ))
        th.start()
        # always done, the scan should never even try to wait for this
        #status = DeviceStatus(self)
        #status._finished()
        return self._traj_status
Example #15
0
    def trigger(self):
        "Trigger one acquisition."
        if self._staged != Staged.yes:
            raise RuntimeError("This detector is not ready to trigger."
                               "Call the stage() method before triggering.")

        self._status = DeviceStatus(self)
        self._acquisition_signal.put(1, callback=self._acquisition_done)
        return self._status
Example #16
0
    def set(self, value):
        # check that a set is not in progress, and if not set the lock.
        if not self._set_lock.acquire(blocking=False):
            raise SetInProgress('attempting to set {} '.format(self.name) +
                                'while a set is in progress')

        # define some required values
        set_value = value
        status = DeviceStatus(self)

        initial_timestamp = None

        # grab these values here to avoidmutliple calls.
        equilibrium_time = self.equilibrium_time.get()
        tolerance = self.tolerance.get()

        # setup a cleanup function for the timer, this matches including
        # timeout in `status` but also ensures that the callback is removed.
        def timer_cleanup():
            print('Set of {} timed out after {} s'.format(
                self.name, self.timeout.get()))
            self._set_lock.release()
            self.readback.clear_sub(status_indicator)
            status._finished(success=False)

        self._cb_timer = threading.Timer(self.timeout.get(), timer_cleanup)

        # set up the done moving indicator logic
        def status_indicator(value, timestamp, **kwargs):
            # add a Timer to ensure that timeout occurs.
            if not self._cb_timer.is_alive():
                self._cb_timer.start()

            nonlocal initial_timestamp
            if abs(value - set_value) < tolerance:
                if initial_timestamp:
                    if (timestamp - initial_timestamp) > equilibrium_time:
                        status._finished()
                        self._cb_timer.cancel()
                        self._set_lock.release()
                        self.readback.clear_sub(status_indicator)
                else:
                    initial_timestamp = timestamp
            else:
                initial_timestamp = None

        # Start the move.
        self.setpoint.put(set_value)

        # subscribe to the read value to indicate the set is done.
        self._cid = self.readback.subscribe(status_indicator)

        # hand the status object back to the RE
        return status
    def set(self, val):
        if self._set_st is not None:
            raise RuntimeError('trying to set while a set is in progress')

        cmd_map = {
            self.open_str: self.open_cmd,
            self.close_str: self.close_cmd
        }
        target_map = {
            self.open_str: self.open_val,
            self.close_str: self.close_val
        }

        cmd_sig = cmd_map[val]
        target_val = target_map[val]

        st = self._set_st = DeviceStatus(self)
        enums = self.status.enum_strs

        def shutter_cb(value, timestamp, **kwargs):
            value = enums[int(value)]
            if value == target_val:
                self._set_st._finished()
                self._set_st = None
                self.status.clear_sub(shutter_cb)

        cmd_enums = cmd_sig.enum_strs
        count = 0

        def cmd_retry_cb(value, timestamp, **kwargs):
            nonlocal count
            value = cmd_enums[int(value)]
            # ts = datetime.datetime.fromtimestamp(timestamp).strftime(_time_fmtstr)
            # print('sh', ts, val, st)
            count += 1
            if count > 5:
                cmd_sig.clear_sub(cmd_retry_cb)
                st._finished(success=False)
            if value == 'None':
                if not st.done:
                    yield from bps.sleep(.5)
                    cmd_sig.set(1)
                    ts = datetime.datetime.fromtimestamp(timestamp).strftime(
                        _time_fmtstr)
                    print(
                        '** ({}) Had to reactuate shutter while {}ing'.format(
                            ts, val))
                else:
                    cmd_sig.clear_sub(cmd_retry_cb)

        cmd_sig.subscribe(cmd_retry_cb, run=False)
        cmd_sig.set(1)
        self.status.subscribe(shutter_cb)
        return st
    def set(self, value, *, wait=False, **kwargs):
        if value not in ('Open', 'Close'):
            raise ValueError(
                "must be 'Open' or 'Close', not {!r}".format(value))
        if wait:
            raise RuntimeError()
        if self._st is not None:
            raise RuntimeError()
        self._target = value
        self._st = st = DeviceStatus(self, timeout=None)
        self.cmd.put(value)

        return st
    def kickoff(self):
        self._running_status = running_status = DeviceStatus(self)
        holding_status = DeviceStatus(self)

        if self.hold.get():
            def state_cb(value, old_value, **kwargs):
                if old_value != 2 and value == 2:
                    holding_status._finished()
                    self.state.clear_sub(state_cb)

            self.state.subscribe(state_cb, run=False)
        else:
            holding_status._finished()

        self.go.put(1, wait=True)

        def running_cb(value, old_value, obj, **kwargs):
            if old_value == 1 and value == 0:
                obj.clear_sub(running_cb)
                running_status._finished()

        self.running.subscribe(running_cb, run=False)
        return holding_status
Example #20
0
    def trigger(self):
        "Trigger one acquisition."
        if self._staged != Staged.yes:
            raise RuntimeError("This detector is not ready to trigger."
                               "Call the stage() method before triggering.")

        self._status = DeviceStatus(self)
        # TODO Start the Aerotech controller and hook a callback or a Thread
        # to call self._status._finished() when it is done.

        # This will cause a Datum to be created.
        self.dispatch(self._image_name, time.time())

        super().trigger()
        return self._status
    def kickoff(self):
        self._running_status = running_status = DeviceStatus(self)
        holding_status = DeviceStatus(self)

        if self.hold.get():

            def state_cb(value, old_value, **kwargs):
                if old_value != 2 and value == 2:
                    holding_status._finished()
                    self.state.clear_sub(state_cb)

            self.state.subscribe(state_cb, run=False)
        else:
            holding_status._finished()

        self.go.put(1, wait=True)

        def running_cb(value, old_value, obj, **kwargs):
            if old_value == 1 and value == 0:
                obj.clear_sub(running_cb)
                running_status._finished()

        self.running.subscribe(running_cb, run=False)
        return holding_status
Example #22
0
    def trigger(self):
        self.sts = sts = DeviceStatus(self)
        # in the not step case, just return a done status object
        if self.mode_settings.scan_type.get() != 'step':
            sts._finished()
            return sts
        self._spec_saved.clear()

        def monitor():
            success = self._spec_saved.wait(60)
            sts._finished(success=success)

        # hold a ref for gc reasons
        self._th = threading.Thread(target=monitor)
        self._th.start()
        return sts
    def set(self, value):
        desired_value = value
        status = DeviceStatus(self)

        def are_we_there_yet(value, *args, **kwargs):
            if abs(value[-1] - desired_value) < self.tolerance:
                # This alerts the RunEngine that it can move on.
                status._finished()

        # Start us moving.
        self.setpoint.put(desired_value)
        # The function are_we_there_yet will receive
        # updates from pyepics as the readback changes.
        self.readback.subscribe(are_we_there_yet)
        # Hand this back the RunEngine immediately.
        return status
Example #24
0
    def set(self, value, **kwargs):
        """interface to use bps.mv()"""
        if value != 1:
            return

        working_status = DeviceStatus(self)
        started = False

        def exsc_cb(value, timestamp, **kwargs):
            value = int(value)
            if started and value == 0:
                working_status._finished()

        self.exsc.subscribe(exsc_cb)
        self.exsc.set(1)
        started = True
        return working_status
Example #25
0
    def complete(self):
        #print('complete():', self.name)
        # Callback will not work with simulation run control
        # self.runcontrol_stop.put(1)
        self.runcontrol_stop.put(1, wait=True)
        status = DeviceStatus(self)
        enums = self.runcontrol_stateenum.enum_strs

        def inner_cb(value, old_value, **kwargs):
            old_value, value = enums[int(old_value)], enums[int(value)]
            #print('complete():', kwargs['timestamp'], old_value, value, value == 'Idle')
            if value == "Idle":
                status._finished(success=True)
                self.runcontrol_stateenum.clear_sub(inner_cb)

        self.runcontrol_stateenum.subscribe(inner_cb)

        return status
Example #26
0
    def trigger(self):
        if self._staged != Staged.yes:
            raise RuntimeError("not staged")

        self._status = DeviceStatus(self)
        self.settings.erase.put(1)
        self._acquisition_signal.put(1, wait=False)
        trigger_time = ttime.time()
        if self._mode is SRXMode.step:
            for sn in self.read_attrs:
                if sn.startswith("channel") and "." not in sn:
                    ch = getattr(self, sn)
                    self.dispatch(ch.name, trigger_time)
        elif self._mode is SRXMode.fly:
            self.dispatch(self._f_key, trigger_time)
        else:
            raise Exception(f"unexpected mode {self._mode}")
        self._abs_trigger_count += 1
        return self._status
Example #27
0
    def complete(self):
        print("complete()")
        expected_triggers = self.expected_triggers.get()
        start = self.start.get()
        end = self.end.get()
        positive = end > start
        status = DeviceStatus(self)
        print(f'start={start:.3}, end={end:.3}, positive={positive}')

        def check_triggers():
            if self.actual_triggers.get() != expected_triggers:
                status._finished(success=False)

        def callback(value, old_value, **kwargs):
            # status._finished(success=False)
            if (positive and value > end) or ((not positive) and value < end):
                print('Motion profile done.  Waiting, then checking triggers.')
                time.sleep(5)  # grace period for triggers to finish
                success = self.actual_triggers.get() == expected_triggers
                if success:
                    print(
                        "Fly scan completion was never confirmed, but we have enough trigger. Finishing successfully..."
                    )
                    status._finished(success=True)
                else:
                    print(
                        "Not enough triggers received. Stopping with failed status."
                    )
                    status._finished(success=False)
                self.motor_rbv.clear_sub(callback)

        # When we get put-completion from the SSEQ record,
        # validate that we have the correct number of triggers immediately.
        # If we do not, finish with failure.
        fly_status = self.fly.set(self.fly.enum_strs[1])
        fly_status.add_callback(check_triggers)
        # Watch the motor readback, which is expected to provide readings past it
        # setpoint / destination. Once it reaches its destination, wait for some
        # interval and then fail if
        self.motor_rbv.subscribe(callback)

        return status
Example #28
0
    def set(self, new_position, *, timeout=None):
        # to be subscribed to 'value' cb on readback
        sts = self._done_sts = DeviceStatus(self, timeout=timeout)
        if self.setpoint.get() == new_position:
            self._done_sts._finished()
            self._done_sts = None
            return sts

        self._setpoint = new_position

        self.setpoint.set(self._setpoint)

        # todo, set up subscription forwarding
        if self._target_channel == 'setpoint':
            self.setpoint.subscribe(local_cb, 'value')
        else:
            target = getattr(self, self._target_channel).T
            target.subscribe(self._value_cb, 'value')

        return self._done_sts
Example #29
0
    def kickoff(self):
        #print('kickoff():', self.name)
        status = DeviceStatus(self)

        enums = self.runcontrol_stateenum.enum_strs

        def inner_cb(value, old_value, **kwargs):
            old_value, value = enums[int(old_value)], enums[int(value)]
            #print('kickoff():', old_value, value, time.time())
            if value == "Run":
                status._finished(success=True)
                self.runcontrol_stateenum.clear_sub(inner_cb)

        self.runcontrol_stateenum.subscribe(inner_cb)

        # Callback will not work with simulation run control
        #self.runcontrol_start.put(1)
        self.runcontrol_start.put(1, wait=True)

        return status
Example #30
0
    def set(self, value):
        # check that a set is not in progress, and if not set the lock.
        if self._set_lock:
            raise Exception('attempting to set {}'.format(self.name) +
                            'while a set is in progress'.format(self.name))
        self._set_lock = True

        # define some required values
        set_value = value
        status = DeviceStatus(self, timeout=self.timeout.get())

        initial_timestamp = None

        # grab these values here to avoidmutliple calls.
        equilibrium_time = self.equilibrium_time.get()
        tolerance = self.tolerance.get()

        # set up the done moving indicator logic
        def status_indicator(value, timestamp, **kwargs):
            nonlocal initial_timestamp
            if abs(value - set_value) < tolerance:
                if initial_timestamp:
                    if (timestamp - initial_timestamp) > equilibrium_time:
                        status._finished()
                        self._set_lock = False
                        self.readback.clear_sub(status_indicator)
                else:
                    initial_timestamp = timestamp
            else:
                initial_timestamp = None

        # Start the move.
        self.setpoint.put(set_value)

        # subscribe to the read value to indicate the set is done.
        self.readback.subscribe(status_indicator)

        # hand the status object back to the RE
        return status
Example #31
0
    def wait_until_settled(self, timeout=None, timeout_fail=False):
        """
        plan: wait for controller signal to reach target within tolerance
        """
        # see: https://stackoverflow.com/questions/2829329/catch-a-threads-exception-in-the-caller-thread-in-python
        t0 = time.time()
        _st = DeviceStatus(self.signal)

        if self.settled:
            # just in case signal already at target
            _st._finished(success=True)
        else:
            started = False

            def changing_cb(*args, **kwargs):
                if started and self.settled:
                    _st._finished(success=True)

            token = self.signal.subscribe(changing_cb)
            started = True
            report = 0
            while not _st.done and not self.settled:
                elapsed = time.time() - t0
                if timeout is not None and elapsed > timeout:
                    _st._finished(success=self.settled)
                    msg = f"{self.controller_name} Timeout after {elapsed:.2f}s"
                    msg += f", target {self.target.get():.2f}{self.units.get()}"
                    msg += f", now {self.signal.get():.2f}{self.units.get()}"
                    print(msg)
                    if timeout_fail:
                        raise TimeoutError(msg)
                    continue
                if elapsed >= report:
                    report += self.report_interval_s
                    msg = f"Waiting {elapsed:.1f}s"
                    msg += f" to reach {self.target.get():.2f}{self.units.get()}"
                    msg += f", now {self.signal.get():.2f}{self.units.get()}"
                    print(msg)
                yield from bps.sleep(self.poll_s)

            self.signal.unsubscribe(token)

        self.record_signal()
        elapsed = time.time() - t0
        print(f"Total time: {elapsed:.3f}s, settled:{_st.success}")
Example #32
0
    def set(self, value, **kwargs):
        """set the shutter to "close" or "open" """
        # first, validate the input value
        acceptables = (self.close_str, self.open_str)
        if value not in acceptables:
            msg = "value should be one of " + " | ".join(acceptables)
            msg += " : received " + str(value)
            raise ValueError(msg)

        command_signal = {
            self.open_str: self.open_bit,
            self.close_str: self.close_bit
        }[value]
        expected_value = {
            self.open_str: self.open_val,
            self.close_str: self.close_val
        }[value]

        working_status = DeviceStatus(self)
        simulate_delay = self.pss_state.value != expected_value

        def shutter_cb(value, timestamp, **kwargs):
            self.pss_state.clear_sub(shutter_cb)
            if simulate_delay:
                time.sleep(self.response_time)
            self.pss_state.set(expected_value)
            working_status._finished()

        self.pss_state.subscribe(shutter_cb)

        command_signal.put(1)

        # finally, make sure both signals are reset
        self.open_bit.put(0)
        self.close_bit.put(0)
        return working_status
 def trigger(self):
     status = DeviceStatus(self)
     i = next(self._counter)
     thread = threading.Thread(target=self._capture, args=(status, i))
     thread.start()
     return status
Example #34
0
 def trigger(self):
     # Re-implement this to trigger as desired in bluesky
     status = DeviceStatus(self)
     status._finished()
     return status
Example #35
0
 def trigger(self):
     # Re-implement this to trigger as desired in bluesky
     status = DeviceStatus(self)
     status._finished()
     return status