Millisecond Forums

Amazing, works perfectly. Thanks very much. I'll let you know how the rest goes. :-)

Kind Regards

Zoe

To offer a bit more complete example involving two "levels", here's how I would go about it. Instead of using /branch to advance to the next level, I would use /skip. I.e., if we have a sufficient number of correct responses in a given level, skip the remaining trials (if any) in that level. In a nutshell:

-------------------------------------------------------------------------------------------------------------------------------------------
DIGITSPAN
-------------------------------------------------------------------------------------------------------------------------------------------

//stop if exit condition is met
<expt digitspan>
/ stop = [values.exit]
/ blocks = [1=backward_block; ]
/ preinstructions=(digitspanintro)
</expt>

// maximum of six trials per level
<block backward_block>
/ onblockbegin = [values.totaltrials=0]
/ trials = [1-6 = trial1; 7-12 = trial2; ]
</block>

// level 1: skip if we already have 4 correct responses in that level
// branch to exit if we have 3 errors in that level
<openended trial1>
/ skip =[openended.trial1.correctcount >= 4]
/ stimulustimes = [0 = signal; 1000 = eraser, digit1; 2000 = eraser, digit2;
3000 = eraser, signal; 4000 = eraser, b_instructions;]
/ validresponse = (anyresponse)
/ iscorrectresponse = [ expressions.b_digitsequence2 == openended.trial1.response]
/ branch = [if (openended.trial1.errorcount >= 3) trial.b_exit]
</openended>

// level 2: skip if we already have 4 correct responses in that level
// branch to exit if we have 3 errors in that level
<openended trial2>
/ skip =[openended.trial2.correctcount >= 4]
/ stimulustimes = [0 = signal; 1000 = eraser, digit1; 2000 = eraser, digit2;
3000 = eraser, digit3; 4000 = eraser, signal; 5000 = eraser, b_instructions;]
/ iscorrectresponse = [ expressions.b_digitsequence2 == openended.trial2.response]
/ validresponse = (anyresponse)
/ iscorrectresponse = [ expressions.b_digitsequence3 == openended.trial2.response]
/ branch = [if (openended.trial2.errorcount >= 3) trial.b_exit]
</openended>

<text digitspanendoftest>
/ items = ("You have reached the end of the Backward Digit Span Test test.~n~nThe next test will start shortly.")
/ fontstyle = ("Arial", 2.33%, false, false, false, false, 5, 0)
</text>

// if we get here, we have hit the exit condition
<trial b_exit>
/ ontrialend = [values.exit = true]
/ stimulusframes = [1 = digitspanendoftest]
/ trialduration = 15000
</trial>


**********************************************************************************************************************************************************************************************
INSTRUCTION PAGES
**********************************************************************************************************************************************************************************************
<instruct>
/ inputdevice = Keyboard
/ fontstyle = ("Arial", 2.5%, false, false, false, false, 5, 1)
/ windowsize = (80%, 80%)
</instruct>

<htmlpage digitspanintro>
/ file = "digitspaninstructions.htm"
</htmlpage>

<values>
/ exit = false
/ count = 0
/ skipblock = 0
/ con_errorcount = 0
/ sequence = 0
/ totaltrials = 0
/ assesstype = 0
/completed = 0
</values>

**********************************************************************************************************************************************************************************************
SEQUENCE SELECTION
**********************************************************************************************************************************************************************************************

<expressions>
/ 1digit = substring(list.digitsequences.nextvalue, 0, 1)
/ 2digit = substring(list.digitsequences.currentvalue, 1, 1)
/ 3digit = substring(list.digitsequences.currentvalue, 2, 1)
/ 4digit = substring(list.digitsequences.currentvalue, 3, 1)
/ 5digit = substring(list.digitsequences.currentvalue, 4, 1)
/ b_digitsequence1 = text.digit1.currentitem
/ b_digitsequence2 = concat(text.digit2.currentitem, expressions.b_digitsequence1)
/ b_digitsequence3 = concat(text.digit3.currentitem, expressions.b_digitsequence2)
</expressions>

<list digitsequences>
/items = (
4738965124981375;
8129563746841972;
2956417838752613;
7942563813165948;)
/replace = false
/selectionrate = trial
</list>

<item digits>
/1 = "1"
/2 = "2"
/3 = "3"
/4 = "4"
/5 = "5"
/6 = "6"
/7 = "7"
/8 = "8"
/9 = "9"
</item>

**********************************************************************************************************************************************************************************************
STIMULI SELECTION
**********************************************************************************************************************************************************************************************

<text digit1>
/items = digits
/select = expressions.1digit
/ txcolor = black
</text>

<text digit2>
/items = digits
/select = expressions.2digit
/ txcolor = black
</text>

<text digit3>
/items = digits
/select = expressions.3digit
/ txcolor = black
</text>

<text digit4>
/items = digits
/select = expressions.4digit
/ txcolor = black
</text>

<text digit5>
/items = digits
/select = expressions.5digit
/ txcolor = black
</text>

<shape eraser>
/ size = (30%, 30%)
/ color = white
</shape>

<shape signal>
/ shape = circle
/ size = (25, 25)
/ color = (255, 0, 0)
</shape>

<text b_instructions>
/ items = ("Type in the sequence of digits in BACKWARD (= reversed) order")
/ position = (50%, 40%)
/ fontstyle = ("Arial", 2.08%, false, false, false, false, 5, 0)
</text>

Extending this to include further levels should hopefully be straightforward, but let me know if you hit a roadblock!

What I would do is simply define a /stop condition in either the <block> or <expt>. Something like

<values>
/ exit = false
</values>

<expt digitspan>
/ stop = [values.exit]
/ blocks = [1=backward_block; ]
/ preinstructions=(digitspanintro)
</expt>

with values.exit set to true if you reach trial.b_exit

<trial b_exit>
/ ontrialend = [values.exit = true]
/ stimulusframes = [1 = digitspanendoftest]
/ trialduration = 15000
</trial>

Hi Dave 

Thanks for your reply i've had a look at the corsi block and it has helped but i'm still struggling a little. The below runs almost right except when you get to trial.b_exit when you have entered 3 incorrect answers it then starts <openended trial 1> again. At this point the experiment should just end.

I'm sure this is to do with having /trials = [1-6 = trial1;] which i tried rectifying by changing to /trials = [1=trial1;] and adding 
/ branch = [if (openended.trial1.totalcount <= 6) openended.trial1] to <openended trial1> so the trial will repeat until at least 6 trials have gone through but i hoped it would still consider the existing branch/ if scenarios, which it does not. 

Is there a better way of doing this? or is there a way to combine /branch instructions?

Kind Regards

Zoe

-------------------------------------------------------------------------------------------------------------------------------------------
DIGITSPAN
-------------------------------------------------------------------------------------------------------------------------------------------

<expt digitspan>
/ blocks = [1=backward_block; ]
/ preinstructions=(digitspanintro)
</expt>

<block backward_block>
/ onblockbegin = [values.totaltrials=0]
/ trials = [1 -6 =trial1;]
</block>

<openended trial1>
/ stimulustimes = [0 = signal; 1000 = eraser, digit1; 2000 = eraser, digit2;
3000 = eraser, signal; 4000 = eraser, b_instructions;]
/ validresponse = (anyresponse)
/ iscorrectresponse = [ expressions.b_digitsequence2 == openended.trial1.response]
/ recorddata = false
/ branch=[if (openended.trial1.correctcount >= 4) openended.trial2]
/ branch = [if (openended.trial1.errorcount >= 3) trial.b_exit]
</openended>

<openended trial2>
/ stimulustimes = [0 = signal; 1000 = eraser, digit1; 2000 = eraser, digit2;
3000 = eraser, digit3; 4000 = eraser, signal; 5000 = eraser, b_instructions;]
/ iscorrectresponse = [ expressions.b_digitsequence2 == openended.trial2.response]
/ validresponse = (anyresponse)
/ recorddata = false
</openended>

<text digitspanendoftest>
/ items = ("You have reached the end of the Backward Digit Span Test test.~n~nThe next test will start shortly.")
/ fontstyle = ("Arial", 2.33%, false, false, false, false, 5, 0)
</text>

<trial b_exit>
/ stimulusframes = [1 = digitspanendoftest]
/ trialduration = 15000
</trial>


**********************************************************************************************************************************************************************************************
INSTRUCTION PAGES
**********************************************************************************************************************************************************************************************
<instruct>
/ inputdevice = Keyboard
/ fontstyle = ("Arial", 2.5%, false, false, false, false, 5, 1)
/ windowsize = (80%, 80%)
</instruct>

<htmlpage digitspanintro>
/ file = "digitspaninstructions.htm"
</htmlpage>

<values>
/ count = 0
/ skipblock = 0
/ con_errorcount = 0
/ sequence = 0
/ totaltrials = 0
/ assesstype = 0
/completed = 0
</values>

**********************************************************************************************************************************************************************************************
SEQUENCE SELECTION
**********************************************************************************************************************************************************************************************

<expressions>
/ 1digit = substring(list.digitsequences.nextvalue, 0, 1)
/ 2digit = substring(list.digitsequences.currentvalue, 1, 1)
/ 3digit = substring(list.digitsequences.currentvalue, 2, 1)
/ 4digit = substring(list.digitsequences.currentvalue, 3, 1)
/ 5digit = substring(list.digitsequences.currentvalue, 4, 1)
/ b_digitsequence1 = text.digit1.currentitem
/ b_digitsequence2 = concat(text.digit2.currentitem, expressions.b_digitsequence1)
</expressions>

<list digitsequences>
/items = (
4738965124981375;
8129563746841972;
2956417838752613;
7942563813165948;)
/replace = false
/selectionrate = trial
</list>

<item digits>
/1 = "1"
/2 = "2"
/3 = "3"
/4 = "4"
/5 = "5"
/6 = "6"
/7 = "7"
/8 = "8"
/9 = "9"
</item>

**********************************************************************************************************************************************************************************************
STIMULI SELECTION
**********************************************************************************************************************************************************************************************

<text digit1>
/items = digits
/select = expressions.1digit
/ txcolor = black
</text>

<text digit2>
/items = digits
/select = expressions.2digit
/ txcolor = black
</text>

<text digit3>
/items = digits
/select = expressions.3digit
/ txcolor = black
</text>

<text digit4>
/items = digits
/select = expressions.4digit
/ txcolor = black
</text>

<text digit5>
/items = digits
/select = expressions.5digit
/ txcolor = black
</text>

<shape eraser>
/ size = (30%, 30%)
/ color = white
</shape>

<shape signal>
/ shape = circle
/ size = (25, 25)
/ color = (255, 0, 0)
</shape>

<text b_instructions>
/ items = ("Type in the sequence of digits in BACKWARD (= reversed) order")
/ position = (50%, 40%)
/ fontstyle = ("Arial", 2.08%, false, false, false, false, 5, 0)
</text>

"In order to make it harder and quicker to complete i would like it to run so the participants have to get 4 correct spans within one block (of 6 spans) before moving up to the next level and if they get 3 or more spans incorrect within any block they discontinue the test and the resulting level is the last block they successfully completed. Similar to the below."

The Corsi Block Tapping task applies logic similar to this. I'd suggest you take a look at that and then adapt it according to your needs for the Digit Span.