def _read_bool(self, channel, invert=False, event=None, **kwargs): """ Read a boolean value from a channel or group of channels Parameters ---------- channel: string a channel or group of channels that will all be read at the same time invert: bool whether or not to invert the read value event: dict a dictionary of event information to emit after a True reading Returns ------- The value read from the hardware """ if channel not in self.tasks: raise NIDAQmxError("Channel(s) %s not yet configured" % str(channel)) task = self.tasks[channel] task.start() # while task.get_samples_per_channel_acquired() == 0: # pass value, bits_per_sample = task.read(1) value = value[0, 0] task.stop() if invert: value = 1 - value value = bool(value == 1) if value: events.write(event) return value
def _queue_wav(self, wav_file, start=False, event=None, **kwargs): """ Queue the wav file for playback Parameters ---------- wav_file: string Path to the wave file to load start: bool Whether or not to immediately start playback event: dict a dictionary of event information to emit just before playback """ if self.wf is not None: self._stop_wav() events.write(event) logger.debug("Queueing wavfile %s" % wav_file) self._wav_data = self._load_wav(wav_file) if self._analog_event_handler is not None: # Get the string of (scaled) bits from the event handler bit_string = self._analog_event_handler.to_bit_sequence(event) # multi-channel outputs need to be of shape nsamples x nchannels if len(self._wav_data.shape) == 1: values = self._wav_data.reshape((-1, 1)) else: values = self._wav_data # Add a channel of all zeros self._wav_data = np.hstack([values, np.zeros((values.shape[0], 1))]) # Place the bit string at the start self._wav_data[:len(bit_string), -1] = bit_string self._get_stream(start=start, **kwargs)
def _read_analog(self, channel, nsamples, event=None, **kwargs): """ Read from a channel or group of channels for the specified number of samples. Parameters ---------- channel: string a channel or group of channels that will be read at the same time nsamples: int the number of samples to read event: dict a dictionary of event information to emit after reading Returns ------- a numpy array of the data that was read """ if channel not in self.tasks: raise NIDAQmxError("Channel(s) %s not yet configured" % str(channel)) task = self.tasks[channel] task.configure_timing_sample_clock(source=self.clock_channel, rate=self.samplerate, sample_mode="finite", samples_per_channel=nsamples) values = task.read(nsamples) events.write(event) return values
def _read_analog(self, channel, nsamples, event=None, **kwargs): """ Read from a channel or group of channels for the specified number of samples. Parameters ---------- channel: string a channel or group of channels that will be read at the same time nsamples: int the number of samples to read event: dict a dictionary of event information to emit after reading Returns ------- a numpy array of the data that was read """ if channel not in self.tasks: raise NIDAQmxError("Channel(s) %s not yet configured" % str(channel)) task = self.tasks[channel] task.configure_timing_sample_clock(source=self.clock_channel, rate=self.samplerate, sample_mode="finite", samples_per_channel=nsamples) values = task.read(nsamples) events.write(event) return values
def _read_bool(self, channel, invert=False, event=None, **kwargs): """ Read a boolean value from a channel or group of channels Parameters ---------- channel: string a channel or group of channels that will all be read at the same time invert: bool whether or not to invert the read value event: dict a dictionary of event information to emit after a True reading Returns ------- The value read from the hardware """ if channel not in self.tasks: raise NIDAQmxError("Channel(s) %s not yet configured" % str(channel)) task = self.tasks[channel] task.start() # while task.get_samples_per_channel_acquired() == 0: # pass value, bits_per_sample = task.read(1) value = value[0, 0] task.stop() if invert: value = 1 - value value = bool(value == 1) if value: events.write(event) return value
def _write_analog(self, channel, values, is_blocking=False, event=None, **kwargs): """ Write a numpy array of float64 values to the buffer on a channel or group of channels Parameters ---------- channel: string a channel or group of channels that will all be written to at the same time values: numpy array of float64 values values to write to the hardware. Should be of dimension nchannels x nsamples. is_blocking: bool whether or not to block execution until all samples are written to the hardware event: dict a dictionary of event information to emit just before writing Returns ------- True """ if channel not in self.tasks: raise NIDAQmxError("Channel(s) %s not yet configured" % str(channel)) task = self.tasks[channel] task.stop() task.configure_timing_sample_clock(source=self.clock_channel, rate=self.samplerate, sample_mode="finite", samples_per_channel=values.shape[0]) if self._analog_event_handler is not None: # Get the string of (scaled) bits from the event handler bit_string = self._analog_event_handler.to_bit_sequence(event) # multi-channel outputs need to be of shape nsamples x nchannels if len(values.shape) == 1: values = values.reshape((-1, 1)) # Add a channel of all zeros values = np.hstack([values, np.zeros((values.shape[0], 1))]) # Place the bit string at the start values[:len(bit_string), -1] = bit_string # Write the values to the nidaq buffer # I think we might want to set layout='group_by_scan_number' in .write() task.write(values, auto_start=False) events.write(event) task.start() if is_blocking: task.wait_until_done() task.stop() return True
def _write_analog(self, channel, values, is_blocking=False, event=None, **kwargs): """ Write a numpy array of float64 values to the buffer on a channel or group of channels Parameters ---------- channel: string a channel or group of channels that will all be written to at the same time values: numpy array of float64 values values to write to the hardware. Should be of dimension nchannels x nsamples. is_blocking: bool whether or not to block execution until all samples are written to the hardware event: dict a dictionary of event information to emit just before writing Returns ------- True """ if channel not in self.tasks: raise NIDAQmxError("Channel(s) %s not yet configured" % str(channel)) task = self.tasks[channel] task.stop() task.configure_timing_sample_clock(source=self.clock_channel, rate=self.samplerate, sample_mode="finite", samples_per_channel=values.shape[0]) if self._analog_event_handler is not None: # Get the string of (scaled) bits from the event handler bit_string = self._analog_event_handler.to_bit_sequence(event) # multi-channel outputs need to be of shape nsamples x nchannels if len(values.shape) == 1: values = values.reshape((-1, 1)) # Add a channel of all zeros values = np.hstack([values, np.zeros((values.shape[0], 1))]) # Place the bit string at the start values[:len(bit_string), -1] = bit_string # Write the values to the nidaq buffer # I think we might want to set layout='group_by_scan_number' in .write() task.write(values, auto_start=False) events.write(event) task.start() if is_blocking: task.wait_until_done() task.stop() return True
def _stop_wav(self, event=None, **kwargs): try: logger.debug("Attempting to close pyaudio stream") events.write(event) self.stream.close() logger.debug("Stream closed") except AttributeError: self.stream = None try: self.wf.close() except AttributeError: self.wf = None
def _stop_wav(self, event=None, **kwargs): try: logger.debug("Attempting to close pyaudio stream") events.write(event) self.stream.close() logger.debug("Stream closed") except AttributeError: self.stream = None try: self.wf.close() except AttributeError: self.wf = None
def _read_bool(self, channel, invert=False, event=None, **kwargs): """ Read a value from the specified channel Parameters ---------- channel: int the channel from which to read invert: bool whether or not to invert the read value Returns ------- bool: the value read from the hardware Raises ------ ArduinoException Reading from the device failed. """ if channel not in self._state: raise InterfaceError("Channel %d is not configured on device %s" % (channel, self.device_name)) if self.device.inWaiting() > 0: # There is currently data in the input buffer self.device.flushInput() self.device.write(self._make_arg(channel, 0)) # Also need to make sure self.device.read() returns something that ord can work with. Possibly except TypeError while True: try: v = ord(self.device.read()) break # serial.SerialException("Testing") except serial.SerialException: # This is to make it robust in case it accidentally disconnects or you try to access the arduino in # multiple ways pass except TypeError: ArduinoException("Could not read from arduino device") logger.debug("Read value of %d from channel %d on %s" % (v, channel, self)) if v in [0, 1]: if invert: v = 1 - v value = v == 1 if value: events.write(event) return value else: logger.error("Device %s returned unexpected value of %d on reading channel %d" % (self, v, channel))
def _play_wav(self, is_blocking=False, event=None, **kwargs): """ Play the data that is currently in the buffer Parameters ---------- is_blocking: bool Whether or not to play the sound in blocking mode event: dict a dictionary of event information to emit just before playback """ logger.debug("Playing wavfile") events.write(event) self.stream.start() if is_blocking: self.wait_until_done()
def _play_wav(self, is_blocking=False, event=None, **kwargs): """ Play the data that is currently in the buffer Parameters ---------- is_blocking: bool Whether or not to play the sound in blocking mode event: dict a dictionary of event information to emit just before playback """ logger.debug("Playing wavfile") events.write(event) self.stream.start() if is_blocking: self.wait_until_done()
def _write_bool(self, channel, value, event=None, **kwargs): '''Write a value to the specified channel :param channel: the channel to write to :param value: the value to write :return: value written if succeeded ''' if channel not in self._state: raise InterfaceError("Channel %d is not configured on device %s" % (channel, self)) logger.debug("Writing %s to device %s, channel %d" % (value, self, channel)) events.write(event) if value: s = self.device.write(self._make_arg(channel, 1)) else: s = self.device.write(self._make_arg(channel, 2)) if s: return value else: raise InterfaceError('Could not write to serial device %s, channel %d' % (self.device, channel))
def _stop_wav(self, event=None, **kwargs): """ Stop the current playback and clear the buffer Parameters ---------- event: dict a dictionary of event information to emit just before stopping """ try: logger.debug("Attempting to close stream") events.write(event) self.stream.stop() logger.debug("Stream closed") except AttributeError: self.stream = None try: self.wf.close() except AttributeError: self.wf = None self._wav_data = None
def _stop_wav(self, event=None, **kwargs): """ Stop the current playback and clear the buffer Parameters ---------- event: dict a dictionary of event information to emit just before stopping """ try: logger.debug("Attempting to close stream") events.write(event) self.stream.stop() logger.debug("Stream closed") except AttributeError: self.stream = None try: self.wf.close() except AttributeError: self.wf = None self._wav_data = None
def _write_bool(self, channel, value, event=None, **kwargs): """ Write a boolean value to a channel or group of channels Parameters ---------- channel: string a channel or group of channels that will all be written to at the same time value: bool or boolean array value to write to the hardware event: dict a dictionary of event information to emit just before writing Returns ------- True """ if channel not in self.tasks: raise NIDAQmxError("Channel(s) %s not yet configured" % str(channel)) task = self.tasks[channel] events.write(event) task.write(value, auto_start=True) return True
def _write_bool(self, channel, value, event=None, **kwargs): """ Write a boolean value to a channel or group of channels Parameters ---------- channel: string a channel or group of channels that will all be written to at the same time value: bool or boolean array value to write to the hardware event: dict a dictionary of event information to emit just before writing Returns ------- True """ if channel not in self.tasks: raise NIDAQmxError("Channel(s) %s not yet configured" % str(channel)) task = self.tasks[channel] events.write(event) task.write(value, auto_start=True) return True
def _queue_wav(self, wav_file, start=False, event=None, **kwargs): """ Queue the wav file for playback Parameters ---------- wav_file: string Path to the wave file to load start: bool Whether or not to immediately start playback event: dict a dictionary of event information to emit just before playback """ if self.wf is not None: self._stop_wav() events.write(event) logger.debug("Queueing wavfile %s" % wav_file) self._wav_data = self._load_wav(wav_file) if self._analog_event_handler is not None: # Get the string of (scaled) bits from the event handler bit_string = self._analog_event_handler.to_bit_sequence(event) # multi-channel outputs need to be of shape nsamples x nchannels if len(self._wav_data.shape) == 1: values = self._wav_data.reshape((-1, 1)) else: values = self._wav_data # Add a channel of all zeros self._wav_data = np.hstack( [values, np.zeros((values.shape[0], 1))]) # Place the bit string at the start self._wav_data[:len(bit_string), -1] = bit_string self._get_stream(start=start, **kwargs)
def _poll(self, channel=None, invert=False, last_value=False, suppress_longpress=False, timeout=None, wait=None, event=None, *args, **kwargs): """ Runs a loop, querying for the boolean input to return True. Parameters ---------- channel: default channel argument to pass to _read_bool() invert: bool whether or not to invert the read value last_value: bool if the last read value was True. Necessary to suppress longpresses suppress_longpress: bool if True, attempts to suppress returning immediately if the button is still being pressed since the last call. If last_value is True, then it waits until the interface reads a single False value before allowing it to return. timeout: float the time, in seconds, until polling times out. Defaults to no timeout. wait: float the time, in seconds, to wait between subsequent reads (default no wait). Returns ------- timestamp of True read or None if timed out """ logger.debug("Begin polling from device %s" % self.device_name) if timeout is not None: start = time.time() if channel not in self.tasks: raise NIDAQmxError("Channel(s) %s not yet configured" % str(channel)) task = self.tasks[channel] task.start() while True: # Read the value - cannot use _read_bool because it must start and stop the task each time. value, bits_per_sample = task.read(1) value = value[0, 0] if invert: value = 1 - value value = bool(value == 1) if value: events.write(event) if not isinstance(value, bool): task.stop() raise ValueError("Polling for bool returned something that was not a bool") if value is True: if (last_value is False) or (suppress_longpress is False): logger.debug("Input detected. Returning") task.stop() return datetime.datetime.now() else: last_value = False if timeout is not None: if time.time() - start >= timeout: logger.debug("Polling timed out. Returning") task.stop() return None if wait is not None: utils.wait(wait)
def run(self): """ Runs the trial Summary ------- The main structure is as follows: Get stimulus -> Initiate trial -> Play stimulus -> Receive response -> Consequate response -> Finish trial -> Save data. The stimulus, response and consequate stages are broken into pre, main, and post stages. Only use the stages you need in your experiment. """ self.experiment.this_trial = self # Get the stimulus self.stimulus = self.condition.get() # Any pre-trial logging / computations self.experiment.trial_pre() # Emit trial event self.event.update(action="start", metadata=str(self.index)) events.write(self.event) # Record the trial time self.time = dt.datetime.now() # Perform stimulus playback self.experiment.stimulus_pre() self.experiment.stimulus_main() self.experiment.stimulus_post() # Evaluate subject's response self.experiment.response_pre() self.experiment.response_main() self.experiment.response_post() # Consequate the response with a reward, punishment or neither if self.response == self.condition.response: self.correct = True if self.condition.is_rewarded and self.block.reinforcement.consequate( self): self.reward = True self.experiment.reward_pre() self.experiment.reward_main() self.experiment.reward_post() else: self.correct = False if self.condition.is_punished and self.block.reinforcement.consequate( self): self.punish = True self.experiment.punish_pre() self.experiment.punish_main() self.experiment.punish_post() # Emit trial end event self.event.update(action="end", metadata=str(self.index)) events.write(self.event) # Finalize trial self.experiment.trial_post() # Store trial data self.experiment.subject.store_data(self) # Update session schedulers self.experiment.session.update() if self.experiment.check_session_schedule() is False: logger.debug("Session has run long enough. Ending") raise EndSession
def _play_wav(self, event=None, **kwargs): logger.debug("Playing wavfile") events.write(event) self.stream.start_stream()
def run(self): """ Runs the trial Summary ------- The main structure is as follows: Get stimulus -> Initiate trial -> Play stimulus -> Receive response -> Consequate response -> Finish trial -> Save data. The stimulus, response and consequate stages are broken into pre, main, and post stages. Only use the stages you need in your experiment. """ self.experiment.this_trial = self # Get the stimulus self.stimulus = self.condition.get() # Any pre-trial logging / computations self.experiment.trial_pre() # Emit trial event self.event.update(action="start", metadata=str(self.index)) events.write(self.event) # Record the trial time self.time = dt.datetime.now() # Perform stimulus playback self.experiment.stimulus_pre() self.experiment.stimulus_main() self.experiment.stimulus_post() # Evaluate subject's response self.experiment.response_pre() self.experiment.response_main() self.experiment.response_post() # Consequate the response with a reward, punishment or neither if self.response == self.condition.response: self.correct = True if self.condition.is_rewarded and self.block.reinforcement.consequate(self): self.reward = True self.experiment.reward_pre() self.experiment.reward_main() self.experiment.reward_post() else: self.correct = False if self.condition.is_punished and self.block.reinforcement.consequate(self): self.punish = True self.experiment.punish_pre() self.experiment.punish_main() self.experiment.punish_post() # Emit trial end event self.event.update(action="end", metadata=str(self.index)) events.write(self.event) # Finalize trial self.experiment.trial_post() # Store trial data self.experiment.subject.store_data(self) # Update session schedulers self.experiment.session.update() if self.experiment.check_session_schedule() is False: logger.debug("Session has run long enough. Ending") raise EndSession
def _play_wav(self, event=None, **kwargs): logger.debug("Playing wavfile") events.write(event) self.stream.start_stream()
def _poll(self, channel=None, invert=False, last_value=False, suppress_longpress=False, timeout=None, wait=None, event=None, *args, **kwargs): """ Runs a loop, querying for the boolean input to return True. Parameters ---------- channel: default channel argument to pass to _read_bool() invert: bool whether or not to invert the read value last_value: bool if the last read value was True. Necessary to suppress longpresses suppress_longpress: bool if True, attempts to suppress returning immediately if the button is still being pressed since the last call. If last_value is True, then it waits until the interface reads a single False value before allowing it to return. timeout: float the time, in seconds, until polling times out. Defaults to no timeout. wait: float the time, in seconds, to wait between subsequent reads (default no wait). Returns ------- timestamp of True read or None if timed out """ logger.debug("Begin polling from device %s" % self.device_name) if timeout is not None: start = time.time() if channel not in self.tasks: raise NIDAQmxError("Channel(s) %s not yet configured" % str(channel)) task = self.tasks[channel] task.start() while True: # Read the value - cannot use _read_bool because it must start and stop the task each time. value, bits_per_sample = task.read(1) value = value[0, 0] if invert: value = 1 - value value = bool(value == 1) if value: events.write(event) if not isinstance(value, bool): task.stop() raise ValueError( "Polling for bool returned something that was not a bool") if value is True: if (last_value is False) or (suppress_longpress is False): logger.debug("Input detected. Returning") task.stop() return datetime.datetime.now() else: last_value = False if timeout is not None: if time.time() - start >= timeout: logger.debug("Polling timed out. Returning") task.stop() return None if wait is not None: utils.wait(wait)