def timestamp_mu(self): """Poll the RTIO input and returns an event timestamp (in machine units), according to the gating. If the gate is permanently closed, returns a negative value. """ return rtio_input_timestamp(self.i_previous_timestamp, self.channel)
def timestamp_mu(self): """Poll the RTIO input and returns an event timestamp (in machine units), according to the gating. If the gate is permanently closed, returns a negative value. """ return rtio_input_timestamp(self.i_previous_timestamp, self.channel)
def count(self): """Poll the RTIO input during all the previously programmed gate openings, and returns the number of registered events.""" count = 0 while rtio_input_timestamp(self.i_previous_timestamp, self.channel) >= 0: count += 1 return count
def timestamp_mu(self): """Poll the RTIO input and returns an event timestamp (in machine units), according to the gating. If the gate is permanently closed, returns a negative value. This function does not interact with the time cursor.""" return rtio_input_timestamp(self.i_previous_timestamp, self.channel)
def timestamp_mu(self): """Poll the RTIO input and returns an event timestamp (in machine units), according to the gating. If the gate is permanently closed, returns a negative value. This function does not interact with the time cursor.""" return rtio_input_timestamp(self.i_previous_timestamp, self.channel)
def count(self): """Poll the RTIO input during all the previously programmed gate openings, and returns the number of registered events.""" count = 0 while rtio_input_timestamp(self.i_previous_timestamp, self.channel) >= 0: count += 1 return count
def measure_frame_timestamp(self): """Measure the timestamp of an arbitrary frame and store it in `self.frame_tstamp`. To be used as reference for aligning updates to the FastLink frames. See `get_next_frame_mu()`. """ rtio_output(self.channel_base << 8, 0) # read any register self.frame_tstamp = rtio_input_timestamp(now_mu() + 4 * self.t_frame, self.channel_base) delay(100 * us)
def count(self, up_to_timestamp_mu): """Consume RTIO input events until the hardware timestamp counter has reached the specified timestamp and return the number of observed events. This function does not interact with the timeline cursor. See the ``gate_*()`` family of methods to select the input transitions that generate events, and :meth:`timestamp_mu` to obtain the timestamp of the first event rather than an accumulated count. :param up_to_timestamp_mu: The timestamp up to which execution is blocked, that is, up to which input events are guaranteed to be taken into account. (Events with later timestamps might still be registered if they are already available.) :return: The number of events before the timeout elapsed (0 if none observed). Examples: To count events on channel ``ttl_input``, up to the current timeline position:: ttl_input.count(now_mu()) If other events are scheduled between the end of the input gate period and when the number of events is counted, using ``now_mu()`` as timeout consumes an unnecessary amount of timeline slack. In such cases, it can be beneficial to pass a more precise timestamp, for example:: gate_end_mu = ttl_input.gate_rising(100 * us) # Schedule a long pulse sequence, represented here by a delay. delay(10 * ms) # Get number of rising edges. This will block until the end of # the gate window, but does not wait for the long pulse sequence # afterwards, thus (likely) completing with a large amount of # slack left. num_rising_edges = ttl_input.count(gate_end_mu) The ``gate_*()`` family of methods return the cursor at the end of the window, allowing this to be expressed in a compact fashion:: ttl_input.count(ttl_input.gate_rising(100 * us)) """ count = 0 while rtio_input_timestamp(up_to_timestamp_mu + self.gate_latency_mu, self.channel) >= 0: count += 1 return count
def count(self, up_to_timestamp_mu): """Consume RTIO input events until the hardware timestamp counter has reached the specified timestamp and return the number of observed events. This function does not interact with the timeline cursor. See the ``gate_*()`` family of methods to select the input transitions that generate events, and :meth:`timestamp_mu` to obtain the timestamp of the first event rather than an accumulated count. :param up_to_timestamp_mu: The timestamp up to which execution is blocked, that is, up to which input events are guaranteed to be taken into account. (Events with later timestamps might still be registered if they are already available.) :return: The number of events before the timeout elapsed (0 if none observed). Examples: To count events on channel ``ttl_input``, up to the current timeline position:: ttl_input.count(now_mu()) If other events are scheduled between the end of the input gate period and when the number of events is counted, using ``now_mu()`` as timeout consumes an unnecessary amount of timeline slack. In such cases, it can be beneficial to pass a more precise timestamp, for example:: gate_end_mu = ttl_input.gate_rising(100 * us) # Schedule a long pulse sequence, represented here by a delay. delay(10 * ms) # Get number of rising edges. This will block until the end of # the gate window, but does not wait for the long pulse sequence # afterwards, thus (likely) completing with a large amount of # slack left. num_rising_edges = ttl_input.count(gate_end_mu) The ``gate_*()`` family of methods return the cursor at the end of the window, allowing this to be expressed in a compact fashion:: ttl_input.count(ttl_input.gate_rising(100 * us)) """ count = 0 while rtio_input_timestamp(up_to_timestamp_mu + self.gate_latency_mu, self.channel) >= 0: count += 1 return count
def watch_done(self): """Stop watching the input at the position of the time cursor. Returns ``True`` if the input has not changed state while it was being watched. The time cursor is not modified by this function. This function always makes the slack negative. """ rtio_output(now_mu(), self.channel, 2, 0) success = True try: while rtio_input_timestamp(now_mu(), self.channel) != -1: success = False except RTIOOverflow: success = False return success
def watch_done(self): """Stop watching the input at the position of the time cursor. Returns ``True`` if the input has not changed state while it was being watched. The time cursor is not modified by this function. This function always makes the slack negative. """ rtio_output(self.target_sens, 0) success = True try: while rtio_input_timestamp(now_mu() + self.gate_latency_mu, self.channel) != -1: success = False except RTIOOverflow: success = False return success
def timestamp_mu(self, up_to_timestamp_mu): """Return the timestamp of the next RTIO input event, or -1 if the hardware timestamp counter reaches the given value before an event is received. This function does not interact with the timeline cursor. See the ``gate_*()`` family of methods to select the input transitions that generate events, and :meth:`count` for usage examples. :param up_to_timestamp_mu: The timestamp up to which execution is blocked, that is, up to which input events are guaranteed to be taken into account. (Events with later timestamps might still be registered if they are already available.) :return: The timestamp (in machine units) of the first event received; -1 on timeout. """ return rtio_input_timestamp(up_to_timestamp_mu + self.gate_latency_mu, self.channel)
def timestamp_mu(self, up_to_timestamp_mu): """Return the timestamp of the next RTIO input event, or -1 if the hardware timestamp counter reaches the given value before an event is received. This function does not interact with the timeline cursor. See the ``gate_*()`` family of methods to select the input transitions that generate events, and :meth:`count` for usage examples. :param up_to_timestamp_mu: The timestamp up to which execution is blocked, that is, up to which input events are guaranteed to be taken into account. (Events with later timestamps might still be registered if they are already available.) :return: The timestamp (in machine units) of the first event received; -1 on timeout. """ return rtio_input_timestamp(up_to_timestamp_mu + self.gate_latency_mu, self.channel)