Example #1
0
	def prepare_response_func(self):

		"""See base_response_item."""

		self._keyboard = keyboard(self.experiment, timeout=self._timeout,
			keylist=self._allowed_responses)
		return self._keyboard.get_key
Example #2
0
	def prepare_response_func(self):

		"""See base_response_item."""

		self._keyboard = keyboard(self.experiment,
			keylist=self._allowed_responses, timeout=self._timeout)
		if self.var._dummy == u'yes':
			return self._keyboard.get_key
		# Prepare the device string
		dev = self.var.dev
		if dev == u"autodetect":
			dev = None
		# Dynamically create an srbox instance
		if not hasattr(self.experiment, "srbox"):
			self.experiment.srbox = libsrbox.libsrbox(self.experiment, dev)
			self.experiment.cleanup_functions.append(self.close)
			self.python_workspace[u'srbox'] = self.experiment.srbox
		# Prepare the light byte
		s = "010" # Control string
		for i in range(5):
			if str(5 - i) in str(self.var.lights):
				s += "1"
			else:
				s += "0"
		self._lights = chr(int(s, 2))
		debug.msg(u"lights string set to %s (%s)" % (s, self.var.lights))
		if self._allowed_responses is not None:
			self._allowed_responses = [int(r) for r in self._allowed_responses]
		self._require_state_change = self.var.require_state_change == u'yes'
		return self._get_button_press
Example #3
0
    def __init__(self, experiment, src):

        """<DOC>
		Initializes the sampler with a specified file.

		Arguments:
		experiment -- An instance of libopensesame.experiment.experiment.
		src -- A path to a .wav or .ogg file.

		Example:
		>>> from openexp.sampler import sampler
		>>> src = exp.get_file('my_sound.ogg')
		>>> my_sampler = sampler(exp, src)
		</DOC>"""

        if src != None:
            if not os.path.exists(src):
                raise osexception(u"openexp._sampler.legacy.__init__() the file '%s' does not exist" % src)

            if os.path.splitext(src)[1].lower() not in (".ogg", ".wav"):
                raise osexception(u"openexp._sampler.legacy.__init__() the file '%s' is not an .ogg or .wav file" % src)

            self.sound = mixer.Sound(src)

        self.experiment = experiment
        self.keyboard = keyboard(experiment)
        self._stop_after = 0
        self._fade_in = 0
        self._volume = 1.0
	def __init__(self, experiment, tracker):

		"""
		Constructor

		Arguments:
		experiment -- opensesame experiment
		tracker -- an eyelink instance
		"""

		pylink.EyeLinkCustomDisplay.__init__(self)

		self.experiment = experiment
		self.my_canvas = canvas(self.experiment)
		self.my_keyboard = keyboard(self.experiment, timeout=0)
		self.my_mouse = mouse(self.experiment)

		self.__target_beep__ = synth(self.experiment, length = 50)
		self.__target_beep__done__ = synth(self.experiment, freq = 880, length = 200)
		self.__target_beep__error__ = synth(self.experiment, freq = 220, length = 200)

		self.state = None

		self.imagebuffer = array.array('l')
		self.pal = None
		self.size = (0,0)
		self.tmp_file = os.path.join(tempfile.gettempdir(), '__eyelink__.jpg')

		self.set_tracker(tracker)
		self.last_mouse_state = -1
		self.experiment.eyelink_esc_pressed = False
	def confirm_abort_experiment(self):
	
		"""
		Asks for confirmation before aborting the experiment. Displays a #
		confirmation screen, collects the response, and acts accordingly.

		Exceptions:
		Raises a response_error upon confirmation.

		Returns:
		False if no confirmation was given.
		"""
		
		# Display the confirmation screen
		conf_canvas = canvas(self.experiment)
		conf_kb = keyboard(self.experiment, timeout=None)
		yc = conf_canvas.ycenter()
		ld = 40
		conf_canvas.clear()
		conf_canvas.text(u'Really abort experiment?', y=yc-3*ld)
		conf_canvas.text(u'Press \'Y\' to abort', y=yc-0.5*ld)
		conf_canvas.text(u'Press any other key or wait 5s to go to setup', \
			y = yc+0.5*ld)
		conf_canvas.show()
		# process the response:
		try:
			key, time = conf_kb.get_key(timeout=5000)
		except:
			return False
		# if confirmation, close experiment
		if key == u'y':
			raise exceptions.runtime_error(u'The experiment was aborted')
		else:
			return False
Example #6
0
	def on_mouse_click(self, pos):
	
		"""<DOC>
		Is called whenever the user clicks on the widget. Activates the text
		input for typing text.
		
		Arguments:
		pos -- an (x, y) tuple		
		</DOC>"""	
		
		self.focus = True
		my_keyboard = keyboard(self.form.experiment)
		while True:		
			self.form.render()		
			resp, time = my_keyboard.get_key()
			try:
				o = ord(resp)
			except:
				o = None
			if resp == 'space':			
				self.text += ' '
			elif resp == 'backspace' or o == 8:
				self.text = self.text[:-1]
			elif resp == 'tab':
				self.focus = False
				return None
			elif resp == 'return':
				if self.return_accepts:
					return self.text
				else:
					self.focus = False
					return None
			elif len(resp) == 1:
				self.text += resp
			self.set_var(self.text)
	def drift_correction(self, pos = None, fix_triggered = False):

		"""Dummy drift correction"""

		if fix_triggered:
			return self.fix_triggered_drift_correction(pos)

		self.simulator.set_visible(visible=True)

		my_keyboard = keyboard(self.experiment, keylist=["space"], timeout=0)
		errorbeep = synth(self.experiment, freq=220, length=200)

		if pos == None:
			pos = self.resolution[0] / 2, self.resolution[1] / 2

		errdist = 60 # pixels (on a 1024x768px and 39.9x29.9cm monitor at 67 cm, this is about 2 degrees of visual angle)

		pressed = None
		while not pressed:
			pressed, presstime = my_keyboard.get_key()
			if pressed:
				gazepos = self.sample()
				if ((gazepos[0]-pos[0])**2  + (gazepos[1]-pos[1])**2)**0.5 < errdist:
					self.simulator.set_visible(visible=False)
					return True
		errorbeep.play()
		self.simulator.set_visible(visible=False)
		return False
	def list_keys(self):

		"""Show a dialog with available key names"""

		my_keyboard = keyboard(self.experiment)
		s = _('The following key names are valid:<br />') \
			+ '<br />'.join(my_keyboard.valid_keys())
		self.experiment.notify(s)
Example #9
0
	def on_mouse_click(self, pos):

		"""
		desc:
			Is called whenever the user clicks on the widget. Activates the text
			input for typing text.

		arguments:
			pos:
				desc:	An (x, y) coordinates tuple.
				type:	tuple
		"""

		self.focus = True
		self.caret_pos = len(self.text)
		my_keyboard = keyboard(self.form.experiment)
		my_keyboard.show_virtual_keyboard(True)
		while True:
			self.form.render()
			resp, time = my_keyboard.get_key()
			try:
				o = ord(resp)
			except:
				o = None
			if resp == u'space':
				self.text = self.text[:self.caret_pos] + u' ' +\
							self.text[self.caret_pos:]
				self.caret_pos +=1
			elif resp == u'backspace' or o == 8:
				self.text = self.text[:self.caret_pos-1] +\
							self.text[self.caret_pos:]
				self.caret_pos = max(0,self.caret_pos-1)
			elif resp == u'delete':
				self.text = self.text[:self.caret_pos] +\
							self.text[self.caret_pos+1:]
			elif resp == u'tab':
				self.focus = False
				my_keyboard.show_virtual_keyboard(False)
				return None
			elif resp == u'return' or resp == u'enter':
				if self.return_accepts:
					my_keyboard.show_virtual_keyboard(False)
					return self.text
				else:
					self.focus = False
					my_keyboard.show_virtual_keyboard(False)
					return None
			elif resp == u'left':
				self.caret_pos = max(0,self.caret_pos-1)
			elif resp == u'right':
				self.caret_pos = min(len(self.text),self.caret_pos+1)
			elif len(resp) == 1:
				self.text = self.text[:self.caret_pos] + resp +\
							self.text[self.caret_pos:]
				self.caret_pos +=1
			self.set_var(self.text)
Example #10
0
	def get_button_state(self):
		
		"""See libboks."""

		from openexp.keyboard import keyboard
		_buttons = [str(b) for b in self.buttons]
		kb = keyboard(self.experiment, keylist=_buttons, timeout=0)
		key, timestamp = kb.get_key()
		if key == None:
			return []
		return [int(key)]
Example #11
0
	def list_keys(self):

		"""Show a dialog with available key names"""

		my_keyboard = keyboard(self.experiment)
		keylist = filter(lambda key: key.strip(), my_keyboard.valid_keys())
		md = u'# ' + _(u'Key names') + u'\n\n' \
			+ _(u'The following key names are valid:') + u'\n\n- ' \
			+ u'\n- '.join([u'`%s`' % key for key in keylist])
		self.tabwidget.open_markdown(md, icon=u'os-keyboard_response',
			title=_(u'Key names'))
    def prepare(self):

        """Preparation phase"""

        # Call the parent constructor.
        item.prepare(self)

        # create keyboard object
        self.kb = keyboard(self.experiment,timeout=1)

        self.init_var()
Example #13
0
	def get_button_press(self):
		
		"""See libboks."""

		from openexp.keyboard import keyboard
		_buttons = [str(b) for b in self.buttons]
		kb = keyboard(self.experiment, keylist=_buttons, timeout=self.timeout)
		key, timestamp = kb.get_key()
		# Make sure that we return `int`s instead of `str`s
		if key != None:
			key = int(key)
		return key, timestamp
	def prepare(self):

		"""
		Prepare the item. In this case this means drawing a fixation
		dot to an offline canvas.
		"""

		# create offline canvas
		self.canvas = canvas(self.experiment, auto_prepare=False)
		self.canvas.set_bgcolor(self.get("bgc"))
		self.canvas.clear()

		# draw the stimulus
		self.sx = self.get("width")/2
		self.sy = self.get("height")/2
		self.r = self.get("stims")/2
		self.canvas.circle(self.sx,self.sy,self.r,fill=True,color=self.get("fgc"))

		# create keyboard object
		if self.allow_keyboard == 'yes':
			kl = self.get("kl").split(';')
			self.kb = keyboard(self.experiment, keylist=kl, timeout=None)

		# calculate vibration time (ms)
		self.experiment.set("T", (1 / float(self.get("freq"))) * 1000)

		# determine functions for stepsize
		if self.get("direct") == 'horizontal':
			if self.get("mtype") == 'sinusoid':
				self.fx = self.sinusoid
			elif self.get("mtype") == 'linear':
				self.fx = self.linear
			else:
				self.fx = self.no_change
				print("Error in smooth_pursuit.prepare: unknown movement type!")
			self.fy = self.no_change

		elif self.get("direct") == 'vertical':
			if self.mtype == 'sinusoid':
				self.fy = self.sinusoid
			elif self.mtype == 'linear':
				self.fy = self.linear
			else:
				self.fy = self.no_change
				print("Error in smooth_pursuit.prepare: unknown movement type!")
			self.fx = self.no_change
		
		# Pass the word on to the parent
		item.item.prepare(self)

		# Report success
		return True
Example #15
0
	def __init__(self, experiment, src):

		# Create required elements
		self.panner = gst.element_factory_make("audiopanorama","panner")
		self.pitcher = gst.element_factory_make("pitch","pitch_controller")
		convert = gst.element_factory_make("audioconvert", "convert")
		audiosink = gst.element_factory_make("autoaudiosink","playback")

		# Put in bin and link elements together
		output_bin = gst.Bin("postprocessing")
		output_bin.add_many(self.pitcher, self.panner, convert, audiosink)
		gst.element_link_many(self.pitcher, self.panner, convert, audiosink)

		# Create pad (entry point for playbin2 in output_bin)
		pad = self.pitcher.get_static_pad("sink")
		ghost_pad = gst.GhostPad("sink", pad)
		ghost_pad.set_active(True)
		output_bin.add_pad(ghost_pad)

		# Create player and route output to bin
		self.player = gst.element_factory_make("playbin2", "player")
		self.player.set_property("audio-sink", output_bin)

		# Create bus reference to keep track of what's happening in the player
		self.bus = self.player.get_bus()
		self.bus.enable_sync_message_emission()

		if src != None:
			if not os.path.exists(src):
				raise osexception(
					u"openexp._sampler.gstreamer.__init__() the file '%s' does not exist" \
					% src)
			else:
				# Determine URI to file source
				src = os.path.abspath(src)
				src = urlparse.urljoin('file:', urllib.pathname2url(src))

			self.player.set_property("uri", src)
			self.player.set_state(gst.STATE_PAUSED)

		self.experiment = experiment
		self.keyboard = keyboard(experiment)

		# Handler of Gstreamer messages
		self.gst_listener = threading.Thread(target=self._monitor_events,
			args=())

		self._playing = False
		self._end_of_stream_reached = False
		self._stop_after = 0
		self._fade_in = 0
		self._volume = 1.0
Example #16
0
	def list_keys(self):
	
		"""Show a dialog with available key names"""
		
		my_keyboard = keyboard(self.experiment)
		s = "The following keys have been detected. Note that different backends may use slightly different names.<br /><br />"
		s += "Keyboard backend: %s<br/><br />" % self.get("keyboard_backend")
		for name in sorted(my_keyboard.valid_keys()):			
			s += "Key: <b>%s</b><br />" % cgi.escape(str(name))
			syn = my_keyboard.synonyms(name)
			if syn != [name]:
				s += "(or %s)<br />" % (", ".join([cgi.escape(str(x)) for x in syn]))
		self.experiment.notify(s)
	def fix_triggered_drift_correction(self, pos = None, min_samples = 30, max_dev = 60, reset_threshold = 10):

		"""Dummy drift correction (fixation triggered)"""

		self.simulator.set_visible(visible=True)

		if pos == None:
			pos = self.resolution[0] / 2, self.resolution[1] / 2

		self.prepare_drift_correction(pos)
		my_keyboard = keyboard(self.experiment, keylist=["escape", "q"], timeout=0)

		# loop until we have sufficient samples
		lx = []
		ly = []
		while len(lx) < min_samples:

			# pressing escape enters the calibration screen
			if my_keyboard.get_key()[0] != None:
				self.simulator.set_visible(visible=False)
				self.recording = False
				print("libeyelink.fix_triggered_drift_correction(): 'q' pressed")
				return False

			# collect a sample
			x, y = self.sample()

			if len(lx) == 0 or x != lx[-1] or y != ly[-1]:

				# if present sample deviates too much from previous sample, reset counting
				if len(lx) > 0 and (abs(x - lx[-1]) > reset_threshold or abs(y - ly[-1]) > reset_threshold):
					lx = []
					ly = []

				# collect samples
				else:
					lx.append(x)
					ly.append(y)

			if len(lx) == min_samples:

				avg_x = sum(lx) / len(lx)
				avg_y = sum(ly) / len(ly)
				d = ((avg_x - pos[0]) ** 2 + (avg_y - pos[1]) ** 2)**0.5

				if d < max_dev:
					self.simulator.set_visible(visible=False)
					return True
				else:
					lx = []
					ly = []
 def wait_no_button_pressed(self, feedback_stimulus_text=None, polling_intervall=500):
     """level detection needs to be switch on
     display feedback_stimulus (optional) if one button pressed
     """
     if rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0 or \
                     rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0:
         if feedback_stimulus_text is not None:
             cnv = canvas(self._exp)
             cnv.text(feedback_stimulus_text)
             cnv.show()
         kbd = keyboard(self._exp)
         while rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0 or \
                         rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0:
             kbd.get_key(timeout=polling_intervall)
    def make_connection(self):
        """hand shake and filename,
        returns forceDAQ version
        """
        kbd = keyboard(self._exp)
        cnv = canvas(self._exp)

        cnv.text("Prepare force recording <br> press key if ready")
        cnv.show()
        kbd.get_key()
        canvas(self._exp).show()

        while not self.udp.connect_peer(FORCE_SERVER_IP):
            cnv = canvas(self._exp)
            cnv.text("ERROR while connecting to server <br> try again or Q to quit")
            cnv.show()
            key = kbd.get_key()
            if key[0] == u'q':
                msg = "Experiment quitted by user!"
                self.udp.send(rc.Command.QUIT)
                print(msg)
                self._exp.end()
                exit()
            canvas(self._exp).show()
            self.clock.wait(300)

        cnv = canvas(self._exp)
        cnv.text("Connected")
        cnv.show()
        self.clock.wait(500)
        self.udp.send(rc.Command.FILENAME + "{0}_{1}.csv".format(self.experiment_name,
                                                                 self.subject_number))
        rtn = self.udp.receive(5)  # paused
        if rtn is None:
            msg = "Force server not responding"
            cnv = canvas(self._exp)
            cnv.text(msg)
            cnv.show()
            kbd.get_key()
            self.udp.send(rc.Command.QUIT)
            print(msg)
            self._exp.end()
            exit()
        version = rc.get_data(rc.Command.GET_VERSION)
        cnv = canvas(self._exp)
        cnv.text("Connected <br> Version " + version)
        cnv.show()
        self.clock.wait(1000)
        return version
Example #20
0
	def prepare(self):

		"""Prepare the boks"""

		item.item.prepare(self)
		
		self._keyboard = keyboard(self.experiment)

		# Prepare the device string
		if self.get(u'_dummy') == u'yes':
			dev = u'dummy'
		else:
			dev = self.get(u'dev')
			if dev == u'autodetect':
				dev = None

		# Dynamically load a boks instance
		if not hasattr(self.experiment, u'boks'):
			self.experiment.boks = libboks.libboks(dev, experiment= \
				self.experiment)
			self.experiment.cleanup_functions.append(self.close)
		model, firmware_version = self.experiment.boks.info()
		self.experiment.set(u'boks_model', model)
		self.experiment.set(u'boks_firmware_version', firmware_version)
			
		# Prepare the allowed responses
		if self.has(u"allowed_responses"):
			self._allowed_responses = []
			for r in self.unistr(self.get(u"allowed_responses")).split(u";"):
				if r.strip() != u"":
					try:
						r = int(r)
					except:
						raise exceptions.runtime_error( \
							u"'%s' is not a valid response in boks '%s'. Expecting a number in the range 1 .. 4." \
							% (r, self.name))
					if r not in range(1,9):
						raise exceptions.runtime_error( \
							u"'%s' is not a valid response in boks '%s'. Expecting a number in the range 1 .. 8." \
							% (r, self.name))
					self._allowed_responses.append(r)
			if len(self._allowed_responses) == 0:
				self._allowed_responses = None
		else:
			self._allowed_responses = None			
		debug.msg(u"allowed responses set to %s" % self._allowed_responses)
			
		# Prepare the timeout
		self.prepare_timeout()
    def set_canvas(self, txt, time, fontsize, keypress = False):
    #"""Create and show a sketchpad element in Opensesame."""
        self.init_canvas.clear()
        self.init_canvas.set_font(style='serif',size=fontsize)
        self.init_canvas.text(txt)
        self.init_canvas.show()
        self.experiment.sleep(time)

        if keypress :
            # Add a keyboard object to be able to know when you press the spacebar
            my_keyboard = keyboard(self.experiment, keylist=['space'])
            while True:
                key, end_time = my_keyboard.get_key(timeout= 500)
                if key == 'space':
                    break
    def prepare(self):

        """Preparation phase"""

        # Call the parent constructor.
        item.prepare(self)

		# create keyboard object
        self.kb = keyboard(self.experiment,timeout=1)

        if hasattr(self.experiment, "pptrigger_dummy"):
            self.pptrigger_dummy = self.experiment.pptrigger_dummy
        else:
            raise osexception(
                    u'Parallel Port init is missing')
	def prepare(self):

		"""
		Prepare the plug-in

		Returns:
		True
		"""
		
		# check for eyetracker
		if not hasattr(self.experiment, "eyetracker"):
			raise exceptions.runtime_error( \
				u"Please connect to the eyetracker using the the eyetracker_calibrate plugin before using the AOI plugin")
		
		# timeout
		if type(self.get(u'timeout')) == int:
			self.notimeout = False
		else:
			self.notimeout = True
		
		# canvas
		self.cv = openexp.canvas.canvas(self.experiment)
		self.cv.copy(self.experiment.items[self.get(u'spname')].canvas)
		
		# keyboard
		self.kb = keyboard(self.experiment, keylist=None, timeout=1)
		
		# string to dict
		exec("self.aoidict = %s" % self.get("aoidictstr"))
		
		# create numpy arrays (for faster processing)
		blnkarray = numpy.array(numpy.zeros(len(self.aoidict)),dtype=numpy.int)
		self._lx = numpy.array(blnkarray, copy=True) # left x border
		self._rx = numpy.array(blnkarray, copy=True) # right x border
		self._ty = numpy.array(blnkarray, copy=True) # top y border
		self._by = numpy.array(blnkarray, copy=True) # bottom y border
		self._namelist = numpy.array(self.aoidict.keys())
		self._aoicount = numpy.zeros(len(self._namelist))
		self._notaoicount = 0
		
		for aoinr in range(0,len(self._namelist)):
			x, y, w, h = self.aoidict[self._namelist[aoinr]]
			self._lx[aoinr] = x
			self._rx[aoinr] = x + w
			self._ty[aoinr] = y
			self._by[aoinr] = y + h
				
		return True
	def prepare(self):

		"""
		Prepare the item. In this case this means drawing a fixation
		dot to an offline canvas.
		"""

		# create offline canvas
		self.canvas = canvas(self.experiment)
		self.canvas.set_bgcolor(self.get("bgc"))
		self.canvas.clear()

		# create keyboard object
		if self.allow_keyboard == 'yes':
			kl = self.get("kl").split(';')
			self.kb = keyboard(self.experiment, keylist=kl, timeout=None)

		# calculate stimulus radius
		self.r = self.get("stims")/2

		# define positions
		if self.get("direct") == "horizontal":
			self.positions = [
				(self.get("width")/2 - self.get("amp"), self.get("height")/2),
				(self.get("width")/2 + self.get("amp"), self.get("height")/2)
				]

		elif self.get("direct") == "vertical":
			self.positions = [
				(self.get("width")/2, self.get("height")/2 - self.get("amp")),
				(self.get("width")/2, self.get("height")/2 + self.get("amp"))
				]

		else:
			self.positions = [
				(self.get("width")/2, self.get("height")/2),
				(self.get("width")/2, self.get("height")/2)
				]
			print("Error in saccade.prepare: unkown direction!")

		# calculate vibration time (ms)
		self.experiment.set("T", (1 / float(self.get("freq"))) * 1000)
		
		# Pass the word on to the parent
		item.item.prepare(self)

		# Report success
		return True
Example #25
0
	def prepare_response_func(self):

		"""See base_response_item."""

		self._keyboard = keyboard(self.experiment,
			keylist=self._allowed_responses, timeout=self._timeout)
		if self.var._dummy == u'yes':
			return self._keyboard.get_key
		# Dynamically load a joystick instance
		if not hasattr(self.experiment, u'joystick'):
			_joystick = plugins.load_mod(__file__, u'libjoystick')
			self.experiment.joystick = _joystick.libjoystick(
				self.experiment, device=self._device)
			self.python_workspace[u'joystick'] = self.experiment.joystick
		if self._allowed_responses is not None:
			self._allowed_responses = [int(r) for r in self._allowed_responses]
		return self._get_button_press
Example #26
0
	def __init__(self, keylist=KEYLIST, timeout=KEYTIMEOUT):

		# See _keyboard.basekeyboard.BaseKeyboard

		# try to copy docstring (but ignore it if it fails, as we do
		# not need it for actual functioning of the code)
		try:
			copy_docstr(BaseKeyboard, OSKeyboard)
		except:
			# we're not even going to show a warning, since the copied
			# docstring is useful for code editors; these load the docs
			# in a non-verbose manner, so warning messages would be lost
			pass

		self.experiment = osexperiment
		self.keyboard = keyboard(self.experiment, keylist=keylist, timeout= \
			timeout)
Example #27
0
    def prepare_response_func(self):
        """See base_response_item."""

        self._keyboard = keyboard(self.experiment,
                                  keylist=self._allowed_responses,
                                  timeout=self._timeout)
        if self.var._dummy == u'yes':
            return self._keyboard.get_key
        # Dynamically load a joystick instance
        if not hasattr(self.experiment, u'joystick'):
            _joystick = plugins.load_mod(__file__, u'libjoystick')
            self.experiment.joystick = _joystick.libjoystick(
                self.experiment, device=self._device)
            self.python_workspace[u'joystick'] = self.experiment.joystick
        if self._allowed_responses is not None:
            self._allowed_responses = [int(r) for r in self._allowed_responses]
        return self._get_button_press
Example #28
0
	def warn(self):

		"""Show screen to warn user that no markers will be send to the VU-AMS device"""
		
		my_canvas = canvas(self.experiment)
		my_canvas.set_font(size=32)
		my_canvas.set_bgcolor(u'yellow')
		my_canvas.clear()
		my_canvas.set_fgcolor(u'red')
		my_canvas.text(u'Warning: <b>no markers</b> will be sent to the VU-AMS! \n\n <i>Hit "c" to Continue or "Esc" to quit</i>')
		my_canvas.show()
		my_keyboard = keyboard(self.experiment)
		my_keyboard.get_key(keylist=[u'c', u'C'])
		my_canvas.set_font(size=21)
		my_canvas.set_bgcolor(u'black')
		my_canvas.clear()
		my_canvas.set_fgcolor(u'purple')
		my_canvas.text(u'Preparing experiment...')
		my_canvas.show()
Example #29
0
    def on_mouse_click(self, pos):

        """
		desc:
			Is called whenever the user clicks on the widget. Activates the text
			input for typing text.
		
		arguments:
			pos:
				desc:	An (x, y) coordinates tuple.
				type:	tuple
		"""

        self.focus = True
        my_keyboard = keyboard(self.form.experiment)
        my_keyboard.show_virtual_keyboard(True)
        while True:
            self.form.render()
            resp, time = my_keyboard.get_key()
            try:
                o = ord(resp)
            except:
                o = None
            if resp == u"space":
                self.text += " "
            elif resp == u"backspace" or o == 8:
                self.text = self.text[:-1]
            elif resp == u"tab":
                self.focus = False
                my_keyboard.show_virtual_keyboard(False)
                return None
            elif resp == u"return":
                if self.return_accepts:
                    my_keyboard.show_virtual_keyboard(False)
                    return self.text
                else:
                    self.focus = False
                    my_keyboard.show_virtual_keyboard(False)
                    return None
            elif len(resp) == 1:
                self.text += resp
            self.set_var(self.text)
def keyboard(**resp_args):

	"""
	desc: |
		A convenience function that creates a new `keyboard` object. For a
		description of possible keywords, see:

		- [/python/keyboard/](/python/keyboard/)

	returns:
		desc:	A `keyboard` object.
		type:	keyboard

	example: |
		my_keyboard = keyboard(keylist=[u'a', u'b'], timeout=5000)
		key, time = my_keyboard.get_key()
	"""

	from openexp.keyboard import keyboard
	return keyboard(experiment, **resp_args)
Example #31
0
	def __init__(self, experiment, src, **playback_args):

		if src is not None:
			if isinstance(src, basestring):
				if not os.path.exists(src):
					raise osexception( \
						u"openexp._sampler.legacy.__init__() the file '%s' does not exist" \
						% src)
				if os.path.splitext(src)[1].lower() not in (".ogg", ".wav"):
					raise osexception( \
						u"openexp._sampler.legacy.__init__() the file '%s' is not an .ogg or .wav file" \
						% src)
				# The mixer chokes on unicode pathnames that contain special
				# characters. To avoid this we convert to str with the
				# filesystem encoding. (Python 2 only).
				if not py3 and isinstance(src, str):
					import sys
					src = src.encode(misc.filesystem_encoding())
			self.sound = mixer.Sound(src)
		sampler.sampler.__init__(self, experiment, src, **playback_args)
		self.keyboard = keyboard(experiment)
    def hold_check(self, holding_time=3000,
                    left_pos=-200, right_pos=200, radius=50,
                    col_fine='gray',
                    col_too_low='green',
                    col_too_strong='red'):
        kbd = keyboard(self._exp)
        blank = canvas(self._exp)
        blank.show()

        self.udp.send("hold:test")
        self.clock.reset_stopwatch()
        prev_lv = None
        while True:
            self.udp.clear_receive_buffer()
            lv = [rc.get_data(rc.Command.GET_THRESHOLD_LEVEL),
                  rc.get_data(rc.Command.GET_THRESHOLD_LEVEL2)]
            if prev_lv!=lv:
                # level has changes
                self.clock.reset_stopwatch()
                prev_lv = lv
                cnv = canvas(self._exp)
                for i, pos in enumerate([left_pos, right_pos]):
                    if lv[i] == WEAK:
                        cnv.circle(x=pos, y=0, r=radius, fill=True,
                                   color=col_too_low)
                    elif lv[i] == STRONG:
                        cnv.circle(x=pos, y=0, r=radius, fill=True,
                                   color=col_too_strong)
                    elif lv[i] == FINE:
                        cnv.circle(x=pos, y=0, r=radius, fill=True,
                                   color=col_fine)
                cnv.show()

            key, _ = kbd.get_key(timeout=0)
            if (lv == [FINE, FINE] and self.clock.stopwatch_time > holding_time) or\
                    (key is not None):
                break

        blank.show()
Example #33
0
    def __init__(self, experiment, src):

        if src != None:
            if isinstance(src, basestring):
                if not os.path.exists(src):
                    raise osexception( \
                     u"openexp._sampler.legacy.__init__() the file '%s' does not exist" \
                     % src)
                if os.path.splitext(src)[1].lower() not in (".ogg", ".wav"):
                    raise osexception( \
                     u"openexp._sampler.legacy.__init__() the file '%s' is not an .ogg or .wav file" \
                     % src)
                # The mixer chokes on unicode pathnames that contain special
                # characters. To avoid this we convert to str with the filesystem
                # encoding.
                if isinstance(src, unicode):
                    import sys
                    src = src.encode(misc.filesystem_encoding())
            self.sound = mixer.Sound(src)
        self.experiment = experiment
        self.keyboard = keyboard(experiment)
        self._stop_after = 0
        self._fade_in = 0
        self._volume = 1.0