[solved] keypress or time limit?

Comments

• lvanderlinden

  February 2013 edited February 2013

  Hi,

  In your experiment it's not surprising that participants cannot respond until 1000ms-since-sketchpad-onset have passed. Because a trial sequence is ran in sequential order, the keyboard item is simply not initiated by then.

  To collect responses immediately after sketchpad and until 1000 ms are passed, you could do the following:

  • Set the duration of your sketchpad to 0. This does not mean that the sketchpad is presented for only 0ms, but that the experiment will advance to the next item (the keyboard_response) right away. Since the keyboard_response waits for a response, but doesn't change the screen, the target will remain visible until a response has been given.
  • Set the timeout of your keyboard_response item to 1000 ms. This is the maximum interval that the keyboard_response waits before deciding that the response was incorrect and setting the 'response' variable to 'None' (in OpenSesame 0.27, in previous versions 'response' get's the value 'timeout').
  • When the keyboard_response item is followed by another sketchpad item (blank screen), this one will be presented as soon as a participant responded or a timeout occurred.

  Does such a trial sequence lead to the desired behaviour? If you still have questions, don't hesitate to ask!

  By the way, I think the best way to become familiar with OpenSesame is by following the step-by-step tutorial (which covers all the above tips and much more). The tutorial can be downloaded here:

  • http://files.cogsci.nl/software/opensesame/tutorial2/Mathot_OpenSesame_Tutorial.pdf

  Good luck!

  Lotje

  Did you like my answer? Feel free to
• Edwin

  February 2013 edited February 2013

  EDIT: I see Lotje was a wee bit quicker!

  Hi!

  You could set the sketchpad's Duration to 0 and put a keyboard_response directly behind it. Next, set the keyboard_response's timeout to 1000 ms. Now you present the sketchpad for a 1000 ms or until a key is pressed. After 1000 ms, it will disappear and no keypress can be registered anymore, though (your experiment will simply continue).

  If you do not want this to happen, put a second keyboard_response straight behind the first one, with a timeout of 'infinite'. Now, in the sequence item where both keyboard_responses are part of, set the Run if of the second keyboard_reponse to: [response] = 'timeout'. Be sure to but a blank screen between the keyboard_responses if you do not want your stimulus presented after the 1000 ms!

  Good luck!
• yotam

  February 2013 edited 1:27AM

  Hi Lotje, Eric !

  first of all thank you so much for helping !
  I tried what you suggested, but it's not quite what I need.
  I want the patient to have as much time as he wants to respond, but
  the visual stimulus to disappear after 1000ms. If I do as you suggest,
  every answer that is pressed beyond 1000ms is considered erroneous
  even it is correct, any ideas ?

  thanks

  yot
• yotam

  February 2013 edited 1:27AM

  p.s. - I did went through the entire tutorial - was very much helpful to a clueless guy like me !
• Edwin

  February 2013 edited 1:27AM

  If you did everything right, the stimulus should disappear after 1000 ms with my solution:

  • sketchpad (showing stimulus), duration: 0 ms
  • keyboard_response_1, timeout: 1000 ms
  • sketchpad (showing blank screen), duration: 0 ms
  • keyboard_response_2, timeout: infinite (Run if: [response] = 'timeout')

  Have you set the correct response correctly in the second keyboard_response?
• sebastiaan

  February 2013 edited 1:27AM

  Just a quick note, to avoid confusion. The Run-if statement should be:

  [response] = None

  It used to be 'timeout', but this was changed in 0.27 to increase consistency (at the expensive of this minor, but unfortunate backwards-incompatibility). To make it work in all versions, use:

  [response] = None or [response] = timeout

  Cheers!

  
  
  Check out SigmundAI.eu for our OpenSesame AI assistant!
  
• yotam

  February 2013 edited 1:27AM

  again thank you all, still doesn't work.
  Edwin with your solution for some reason it never runs
  the second keyboard response element (considering sebastiaan
  remark as well).
  and another question - so it does work, I would still get as if
  they were mistaken for the first keyboard response item - furthermore,
  some of the answer would be counted on the first keyboard response
  (in those the patient was fast enough) and others would on the second one -
  so I think it'll ruin my statistics.
  what do you say?
• Edwin

  February 2013 edited February 2013

  Hi yotam,

  First, considering the fact that it does not work: I believe None might be perceived as a string (i.e. 'None'), instead of as how it should (i.e. None). Therefore, when the first keyboard_response returns None, it is compared with the entry in the sequence's Run if-statement, which would look as something like this:

  if 'None' == None:
      run this item
  

  To us it's clear that those are kind of the same, but Python has no clue. Sebastiaan, is this actually true? In that case, this would make a fine addition for the list of bugs to be fixed. (I see one simple solution: putting back 'timeout'; otherwise I'm guessing the OpenSesame syntax should recognize None-types, which seems like quite a bit of work...)

  Now, on to when this would work (you could make it work by using OpenSesame 0.26, btw). You could log two different responses: response_keyboard_response_1 and response_keyboard_response_2 by selecting both of them in a log item placed right after the nr. 2 (this would result in having two columns in your logfile, named after the keyboard_response items). The total RT would be the RT of both of these together if a participant took over 1000 ms, or simply that of keyboard_response_1 if the participant was fast enough.

  Same goes for the response itself: if a participant was fast enough, it would be keyboard_response_1, otherwise it would be 'keyboard_response_2'. It should be fairly easy to implement this in an analysis script.

  Other solution: use the following inline_scripts:

  inline_script_1 (run phase, place right after the second sketchpad)

  exp.set("response_1", exp.get("response"))
  exp.set("response_time_1", exp.get("response_time"))
  

  inline_script_2 (run phase, right after second keyboard response, put Run if to same as keyboard_response_2!)

  exp.set("response_time", exp.get("response_time_1") + exp.get("response_time"))
  
• sebastiaan

  February 2013 edited 1:27AM

  Hi guys,

  The situation is easier than it might seem. Neither the variable types (string or None) nor the response times are really an issue. For the response times, Edwin's solution should work (and you can do it post-hoc during the analysis as well, as long as you log all variables), but here's a note on the type issue:

  I believe None might be perceived as a string (i.e. 'None'), instead of as how it should (i.e. None).

  OpenSesame script (of which run-if statements are part) does indeed not recognize the Python None type. But that's not a problem, because OpenSesame will take care of that by automatically choosing variable types in a way that is intended to give the most intuitive results:

  • http://osdoc.cogsci.nl/usage/variables-and-conditional-qifq-statements/#smart-typing

  In general, you don't have to worry about types and quotes in Run-if statements. In cases where this becomes ambiguous, you can switch to using Python code by prepending an '=' sign (but this isn't necessary here).

  • http://osdoc.cogsci.nl/usage/variables-and-conditional-qifq-statements/#using-conditionals

  In other words, this Run-if statement should be fine:

  [response] = None

  For a working example, see:

  • http://pastebin.com/HX1E0fGd

  Hope this helps!

  Cheers,
  Sebastiaan

  
  
  Check out SigmundAI.eu for our OpenSesame AI assistant!
  
• yotam

  February 2013 edited 1:27AM

  Well, turns out i'm an ** !
  Edwin, your solution did work - I did not capitalize the 'N' of None
  so it didn't work. The logging issue on the other hand remains - because
  I have now 2 keyboard response items - so if the patient does not answer
  within 1000ms, it gets correct = 0 , if he answers correct while the next keyboard
  response element is on (after 1000ms) it gets correct = 1 - that means for the same stimulus he gets both correct = 1 and correct = 0 hence accuracy = 50% which is obviusoly wrong.

  the reaction time logging is not as it should be either - because for each response it calculates the average of both keyboard response items - example - if the patient answered after 2000ms - that means 1000ms for the first item + 1000ms for the second item - he will get response time of 1500 for this answer ! which is ofcourse wrong . ...
  I'm uploading an image of my logfile so you could see what I mean.

  You guys are really great,
  thank you so much !!

  yotam

  
• froukehe

  February 2013 edited 1:27AM

  I tried this and it worked well (even with a longer sequence). The feedback, however, seems to be affected. How do I only take into account the provided response (of two or more keyboard responses, for each of the moments on which the participant can interrupt the sequence) in the average RT and accuracy?
• sebastiaan

  February 2013 edited 1:27AM

  I tried this and it worked well (even with a longer sequence). The feedback, however, seems to be affected.

  That's true. Both response items modify the feedback variables, and this throws things off. The easiest way to get around this is probably to keep track of the feedback through an inline_script item. Just before the block_loop, you add an inline_script to clear (and initialize) the feedback variables:

  # Create an empty list to remember the rt and correctness for each response
  global lRt, lCorrect
  lRt = []
  lCorrect = []
  

  Then, after the response collection, you insert a simple script that updates avg_rt and acc, so you can use these in a feedback item n the regular way:

  # We assume that the variables `response_time` and `correct`
  # are correctly set at this point.
  #
  # Add the current response to lRt and lCorrect and use these
  # lists to determine `avg_rt` and `acc`.
  global lRt, lCorrect
  lRt.append(self.get('response_time'))
  if self.get('correct') in (0,1): # correct may also be 'undefined'
      lCorrect.append(self.get('correct'))
  exp.set('avg_rt', 1.*sum(lRt)/len(lRt))
  if len(lCorrect) > 0:
      exp.set('acc', 100.*sum(lCorrect)/len(lCorrect))
  else:
      exp.set('acc', 'undefined')
  

  Hope this helps!

  
  
  Check out SigmundAI.eu for our OpenSesame AI assistant!
  
• froukehe

  February 2013 edited 1:27AM

  The combination of the two solutions (computing the response time by adding two measurements) and the modified feedback worked!

  My solution, allowing a response after the presentation of the second stimulus:
  

  
  

  With this additional code to compute the response time:

  if self.get('response_time_keyboard_250')<250:
  exp.set('response_time',self.get('response_time_keyboard_250'))

  if self.get('response_time_keyboard_250')>=250 and self.get('response_time_keyboard_500')<500:
  exp.set('response_time',self.get('response_time_keyboard_250')+self.get('response_time_keyboard_500'))

  if self.get('response_time_keyboard_250')>=250 and self.get('response_time_keyboard_500')>=500:
  exp.set('response_time',self.get('response_time_keyboard_250')+self.get('response_time_keyboard_500')+self.get('response_time_keyboard_infinite'))

  My first bit of Python code, so I guess there is still a bit of space for improvement
• crsh

  May 2014 edited May 2014

  For an experiment I'm building right now, I had a similar problem. I want to show a stimulus for two seconds and than a blank screen. During both presentation of the stimulus and the blank I want participants to be able to respond. The blank screen is supposed to remain on screen until a response is registered.

  I think I achieved this with just one keyboard response-element and no inline code using a parallel element and a sequence:

  

  The duration of the word sketchpad is set to the presentation time of two seconds, the blank sketchpad to 0 and the keyboard_response is set to infinite. And I think it records correct response times and responses.

  Does this approach have any drawbacks?

  Edit: Yes, this approach has a major drawback. It works on Linux (Ubuntu) but it crashes when I execute the program on Windows 7.