Additions:
Starts the queue for input events generated by a device.
On Linux and Windows, the optional 'deviceIndex' is the index of the device
whose queue should be started. If omitted, the default devices queue will be
Deletions:
Starts the queue for keyboard events generated by a device.
On Linux, the optional 'deviceIndex' is the index of the keyboard device whose
queue should be started. If omitted, the default keyboard's queue will be
Additions:
""<div class="subfct" id="PsychHID">""===[[KbQueueStart PsychHID('KbQueueStart')]]===
==[[Psychtoolbox]] › [[PsychHID]].{mex*,dll} subfunction==
%%(matlab;Usage)PsychHID('KbQueueStart' [, deviceIndex])%%
Starts the queue for keyboard events generated by a device.
PsychHID('KbQueueCreate') must be called before this routine.
On Linux, the optional 'deviceIndex' is the index of the keyboard device whose
queue should be started. If omitted, the default keyboard's queue will be
started. On other systems, the last queue will be started.
<<=====See also:=====
KbQueueCreate, KbQueueStop, KbQueueCheck, KbQueueFlush, KbQueueRelease<<""</div>""
Deletions:
===[[KbQueueStart]]===
==[[Psychtoolbox]] › [[PsychBasic]]==
KbQueueStart([deviceIndex])
The routines KbQueueCreate, KbQueueStart, KbQueueStop, KbQueueCheck
KbQueueWait, KbQueueFlush and KbQueueRelease provide replacments for
KbCheck and KbWait, providing the following advantages:
1) Brief key presses that would be missed by KbCheck or KbWait
are reliably detected
2) The times of key presses are recorded more accurately
3) The times of key releases are also recorded
=== Limitations: ===
1) If a key is pressed multiple times before KbQueueCheck is called,
only the times of the first and last presses and releases of that
key can be recovered (this has no effect on other keys)
2) If many keys are pressed very quickly in succession, it is at least
theoretically possible for the queue to fill more quickly than
it can be emptied, losing key events temporarily while filled to
capacity. The queue holds up to thirty events, and events are
constantly being removed from the queue and processed, so this is
unlikely to be a problem in actual use.
Only a single device can be monitored at any given time. The deviceNumber can
be specified only in the call to KbQueueCreate. The other routines then
relate to that specified device. If deviceNumber is not specified, the first
device is the default (like KbCheck). If KbQueueCreate has not been called
first, the other routines will generate an error message. Likewise, if
KbQueueRelease has been called more recently than KbQueueCreate, the other
routines will generate error messages.
It is acceptable to call KbQueueCreate at any time (e.g., to switch to a new
device or to change the list of queued keys) without calling KbQueueRelease.
KbQueueCreate([deviceNumber, keyList])
Creates the queue for the specified (or default) device number
If the device number is less than zero, the default device is used.
keyList is an optional 256-length vector of doubles (not logicals)
with each element corresponding to a particular key (use KbName
to map between keys and their positions). If the double value
corresponding to a particular key is zero, events for that key
are not added to the queue and will not be reported.
No events are delivered to the queue until KbQueueStart or
KbQueueWait is called.
KbQueueCreate can be called again at any time
KbQueueStart()
Starts delivering keyboard events from the specified device to the
queue.
KbQueueStop()
Stops delivery of new keyboard events from the specified device to
the queue.
Data regarding events already queued is not cleared and can be
recovered by KbQueueCheck
[pressed, firstPress, firstRelease, lastPress, lastRelease]=
KbQueueCheck()
Obtains data about keypresses on the specified device since the
most recent call to this routine, KbQueueStart, KbQueuWait
Clears all scored events, but unscored events that are still being
processsed may remain in the queue
pressed: a boolean indicating whether a key has been pressed
firstPress: an array indicating the time that each key was first
pressed since the most recent call to KbQueueCheck or KbQueueStart
firstRelease: an array indicating the time that each key was first
released since the most recent call to KbQueueCheck or KbQueueStart
lastPress: an array indicating the most recent time that each key was
pressed since the most recent call to KbQueueCheck or KbQueueStart
lastRelease: an array indicating the most recent time that each key
was released since the most recent call to KbQueueCheck or
KbQueueStart
For firstPress, firstRelease, lastPress and lastRelease, a time value
of zero indicates that no event for the corresponding key was
detected since the most recent call to KbQueueCheck or KbQueueStart
To identify specific keys, use KbName (e.g., KbName(firstPress)) to
generate a list of the keys for which the events occurred
For compatibility with KbCheck, any key codes stored in
ptb_kbcheck_disabledKeys (see "help DisableKeysForKbCheck"), will
not caused pressed to return as true and will be zeroed out in the
returned arrays. However, a better alternative is to specify a
keyList arguement to KbQueueCreate.
secs=KbQueueWait()
Waits for any key to be pressed and returns the time of the press
KbQueueFlush should be called immediately prior to this function
(unless the queue has just been created and started) to clear any
prior events.
Note that this command will not respond to any keys that were
inactivated by using the keyList argument to KbQueueCreate.
Since KbQueueWait is implemented as a looping call to
KbQueueCheck, it will not respond to any key codes stored in
the global variable ptb_kbcheck_disabledKeys
(see "help DisableKeysForKbCheck")
KbQueueFlush()
Removes all unprocessed events from the queue and zeros out any
already scored events.
KbQueueRelease()
Releases queue-associated resources; once called, KbQueueCreate
must be invoked before using any of the other routines
This routine is called automatically at clean-up (e.g., when
'clear mex' is invoked and can be omitted expense of keeping
memory allocated and an additional thread running unnecesarily
Note that any keyboard typing used to invoke KbQueue commands will be
recorded. This would include the release of the carriage return used
to execute KbQueueStart and the keys pressed and released to invoke
KbQueueCheck
----
See also: KbQueueCreate, KbQueueStart, KbQueueStop, KbQueueCheck,
KbQueueWait, KbQueueFlush, KbQueueRelease
""
<div class="code_header" style="text-align:right;">
<span style="float:left;">Path </span> <span class="counter">Retrieve current version of KbQueueStart.m from berliOS: <a href=
"http://svn.berlios.de/svnroot/repos/osxptb/beta/Psychtoolbox/PsychBasic/KbQueueStart.m">beta</a> | view WebSVN <a href=
"http://svn.berlios.de/wsvn/osxptb/trunk/Psychtoolbox/PsychBasic/KbQueueStart.m?op=log">changelog</a> of trunk branch</span>
</div>
<div class="code">
<code>Psychtoolbox/PsychBasic/KbQueueStart.m</code>
</div>
""
Additions:
===[[KbQueueStart]]===
==[[Psychtoolbox]] › [[PsychBasic]]==
KbQueueStart([deviceIndex])
The routines KbQueueCreate, KbQueueStart, KbQueueStop, KbQueueCheck
KbQueueWait, KbQueueFlush and KbQueueRelease provide replacments for
KbCheck and KbWait, providing the following advantages:
1) Brief key presses that would be missed by KbCheck or KbWait
are reliably detected
2) The times of key presses are recorded more accurately
3) The times of key releases are also recorded
=== Limitations: ===
1) If a key is pressed multiple times before KbQueueCheck is called,
only the times of the first and last presses and releases of that
key can be recovered (this has no effect on other keys)
2) If many keys are pressed very quickly in succession, it is at least
theoretically possible for the queue to fill more quickly than
it can be emptied, losing key events temporarily while filled to
capacity. The queue holds up to thirty events, and events are
constantly being removed from the queue and processed, so this is
unlikely to be a problem in actual use.
Only a single device can be monitored at any given time. The deviceNumber can
be specified only in the call to KbQueueCreate. The other routines then
relate to that specified device. If deviceNumber is not specified, the first
device is the default (like KbCheck). If KbQueueCreate has not been called
first, the other routines will generate an error message. Likewise, if
KbQueueRelease has been called more recently than KbQueueCreate, the other
routines will generate error messages.
It is acceptable to call KbQueueCreate at any time (e.g., to switch to a new
device or to change the list of queued keys) without calling KbQueueRelease.
KbQueueCreate([deviceNumber, keyList])
Creates the queue for the specified (or default) device number
If the device number is less than zero, the default device is used.
keyList is an optional 256-length vector of doubles (not logicals)
with each element corresponding to a particular key (use KbName
to map between keys and their positions). If the double value
corresponding to a particular key is zero, events for that key
are not added to the queue and will not be reported.
No events are delivered to the queue until KbQueueStart or
KbQueueWait is called.
KbQueueCreate can be called again at any time
KbQueueStart()
Starts delivering keyboard events from the specified device to the
queue.
KbQueueStop()
Stops delivery of new keyboard events from the specified device to
the queue.
Data regarding events already queued is not cleared and can be
recovered by KbQueueCheck
[pressed, firstPress, firstRelease, lastPress, lastRelease]=
KbQueueCheck()
Obtains data about keypresses on the specified device since the
most recent call to this routine, KbQueueStart, KbQueuWait
Clears all scored events, but unscored events that are still being
processsed may remain in the queue
pressed: a boolean indicating whether a key has been pressed
firstPress: an array indicating the time that each key was first
pressed since the most recent call to KbQueueCheck or KbQueueStart
firstRelease: an array indicating the time that each key was first
released since the most recent call to KbQueueCheck or KbQueueStart
lastPress: an array indicating the most recent time that each key was
pressed since the most recent call to KbQueueCheck or KbQueueStart
lastRelease: an array indicating the most recent time that each key
was released since the most recent call to KbQueueCheck or
KbQueueStart
For firstPress, firstRelease, lastPress and lastRelease, a time value
of zero indicates that no event for the corresponding key was
detected since the most recent call to KbQueueCheck or KbQueueStart
To identify specific keys, use KbName (e.g., KbName(firstPress)) to
generate a list of the keys for which the events occurred
For compatibility with KbCheck, any key codes stored in
ptb_kbcheck_disabledKeys (see "help DisableKeysForKbCheck"), will
not caused pressed to return as true and will be zeroed out in the
returned arrays. However, a better alternative is to specify a
keyList arguement to KbQueueCreate.
secs=KbQueueWait()
Waits for any key to be pressed and returns the time of the press
KbQueueFlush should be called immediately prior to this function
(unless the queue has just been created and started) to clear any
prior events.
Note that this command will not respond to any keys that were
inactivated by using the keyList argument to KbQueueCreate.
Since KbQueueWait is implemented as a looping call to
KbQueueCheck, it will not respond to any key codes stored in
the global variable ptb_kbcheck_disabledKeys
(see "help DisableKeysForKbCheck")
KbQueueFlush()
Removes all unprocessed events from the queue and zeros out any
already scored events.
KbQueueRelease()
Releases queue-associated resources; once called, KbQueueCreate
must be invoked before using any of the other routines
This routine is called automatically at clean-up (e.g., when
'clear mex' is invoked and can be omitted expense of keeping
memory allocated and an additional thread running unnecesarily
Note that any keyboard typing used to invoke KbQueue commands will be
recorded. This would include the release of the carriage return used
to execute KbQueueStart and the keys pressed and released to invoke
KbQueueCheck
----
See also: KbQueueCreate, KbQueueStart, KbQueueStop, KbQueueCheck,
KbQueueWait, KbQueueFlush, KbQueueRelease
""
<div class="code_header" style="text-align:right;">
<span style="float:left;">Path </span> <span class="counter">Retrieve current version of KbQueueStart.m from berliOS: <a href=
"http://svn.berlios.de/svnroot/repos/osxptb/beta/Psychtoolbox/PsychBasic/KbQueueStart.m">beta</a> | view WebSVN <a href=
"http://svn.berlios.de/wsvn/osxptb/trunk/Psychtoolbox/PsychBasic/KbQueueStart.m?op=log">changelog</a> of trunk branch</span>
</div>
<div class="code">
<code>Psychtoolbox/PsychBasic/KbQueueStart.m</code>
</div>
""
Deletions:
""<div class="subfct" id="PsychHID">""===[[KbQueueStart PsychHID('KbQueueStart')]]===
==[[Psychtoolbox]] › [[PsychHID]].{mex*,dll} subfunction==
%%(matlab;Usage)PsychHID('KbQueueStart' [, deviceIndex])%%
Starts the queue for keyboard events generated by a device.
PsychHID('KbQueueCreate') must be called before this routine.
On Linux, the optional 'deviceIndex' is the index of the keyboard device whose
queue should be started. If omitted, the default keyboard's queue will be
started. On other systems, the last queue will be started.
<<=====See also:=====
KbQueueCreate, KbQueueStop, KbQueueCheck, KbQueueFlush, KbQueueRelease<<""</div>""
Additions:
""<div class="subfct" id="PsychHID">""===[[KbQueueStart PsychHID('KbQueueStart')]]===
==[[Psychtoolbox]] › [[PsychHID]].{mex*,dll} subfunction==
%%(matlab;Usage)PsychHID('KbQueueStart' [, deviceIndex])%%
Starts the queue for keyboard events generated by a device.
PsychHID('KbQueueCreate') must be called before this routine.
On Linux, the optional 'deviceIndex' is the index of the keyboard device whose
queue should be started. If omitted, the default keyboard's queue will be
started. On other systems, the last queue will be started.
<<=====See also:=====
KbQueueCreate, KbQueueStop, KbQueueCheck, KbQueueFlush, KbQueueRelease<<""</div>""
Deletions:
===[[KbQueueStart]]===
==[[Psychtoolbox]] › [[PsychBasic]]==
KbQueueStart([deviceIndex])
The routines KbQueueCreate, KbQueueStart, KbQueueStop, KbQueueCheck
KbQueueWait, KbQueueFlush and KbQueueRelease provide replacments for
KbCheck and KbWait, providing the following advantages:
1) Brief key presses that would be missed by KbCheck or KbWait
are reliably detected
2) The times of key presses are recorded more accurately
3) The times of key releases are also recorded
=== Limitations: ===
1) If a key is pressed multiple times before KbQueueCheck is called,
only the times of the first and last presses and releases of that
key can be recovered (this has no effect on other keys)
2) If many keys are pressed very quickly in succession, it is at least
theoretically possible for the queue to fill more quickly than
it can be emptied, losing key events temporarily while filled to
capacity. The queue holds up to thirty events, and events are
constantly being removed from the queue and processed, so this is
unlikely to be a problem in actual use.
Only a single device can be monitored at any given time. The deviceNumber can
be specified only in the call to KbQueueCreate. The other routines then
relate to that specified device. If deviceNumber is not specified, the first
device is the default (like KbCheck). If KbQueueCreate has not been called
first, the other routines will generate an error message. Likewise, if
KbQueueRelease has been called more recently than KbQueueCreate, the other
routines will generate error messages.
It is acceptable to call KbQueueCreate at any time (e.g., to switch to a new
device or to change the list of queued keys) without calling KbQueueRelease.
KbQueueCreate([deviceNumber, keyList])
Creates the queue for the specified (or default) device number
If the device number is less than zero, the default device is used.
keyList is an optional 256-length vector of doubles (not logicals)
with each element corresponding to a particular key (use KbName
to map between keys and their positions). If the double value
corresponding to a particular key is zero, events for that key
are not added to the queue and will not be reported.
No events are delivered to the queue until KbQueueStart or
KbQueueWait is called.
KbQueueCreate can be called again at any time
KbQueueStart()
Starts delivering keyboard events from the specified device to the
queue.
KbQueueStop()
Stops delivery of new keyboard events from the specified device to
the queue.
Data regarding events already queued is not cleared and can be
recovered by KbQueueCheck
[pressed, firstPress, firstRelease, lastPress, lastRelease]=
KbQueueCheck()
Obtains data about keypresses on the specified device since the
most recent call to this routine, KbQueueStart, KbQueuWait
Clears all scored events, but unscored events that are still being
processsed may remain in the queue
pressed: a boolean indicating whether a key has been pressed
firstPress: an array indicating the time that each key was first
pressed since the most recent call to KbQueueCheck or KbQueueStart
firstRelease: an array indicating the time that each key was first
released since the most recent call to KbQueueCheck or KbQueueStart
lastPress: an array indicating the most recent time that each key was
pressed since the most recent call to KbQueueCheck or KbQueueStart
lastRelease: an array indicating the most recent time that each key
was released since the most recent call to KbQueueCheck or
KbQueueStart
For firstPress, firstRelease, lastPress and lastRelease, a time value
of zero indicates that no event for the corresponding key was
detected since the most recent call to KbQueueCheck or KbQueueStart
To identify specific keys, use KbName (e.g., KbName(firstPress)) to
generate a list of the keys for which the events occurred
For compatibility with KbCheck, any key codes stored in
ptb_kbcheck_disabledKeys (see "help DisableKeysForKbCheck"), will
not caused pressed to return as true and will be zeroed out in the
returned arrays. However, a better alternative is to specify a
keyList arguement to KbQueueCreate.
secs=KbQueueWait()
Waits for any key to be pressed and returns the time of the press
KbQueueFlush should be called immediately prior to this function
(unless the queue has just been created and started) to clear any
prior events.
Note that this command will not respond to any keys that were
inactivated by using the keyList argument to KbQueueCreate.
Since KbQueueWait is implemented as a looping call to
KbQueueCheck, it will not respond to any key codes stored in
the global variable ptb_kbcheck_disabledKeys
(see "help DisableKeysForKbCheck")
KbQueueFlush()
Removes all unprocessed events from the queue and zeros out any
already scored events.
KbQueueRelease()
Releases queue-associated resources; once called, KbQueueCreate
must be invoked before using any of the other routines
This routine is called automatically at clean-up (e.g., when
'clear mex' is invoked and can be omitted expense of keeping
memory allocated and an additional thread running unnecesarily
Note that any keyboard typing used to invoke KbQueue commands will be
recorded. This would include the release of the carriage return used
to execute KbQueueStart and the keys pressed and released to invoke
KbQueueCheck
----
See also: KbQueueCreate, KbQueueStart, KbQueueStop, KbQueueCheck,
KbQueueWait, KbQueueFlush, KbQueueRelease
""
<div class="code_header" style="text-align:right;">
<span style="float:left;">Path </span> <span class="counter">Retrieve current version of KbQueueStart.m from berliOS: <a href=
"http://svn.berlios.de/svnroot/repos/osxptb/beta/Psychtoolbox/PsychBasic/KbQueueStart.m">beta</a> | view WebSVN <a href=
"http://svn.berlios.de/wsvn/osxptb/trunk/Psychtoolbox/PsychBasic/KbQueueStart.m?op=log">changelog</a> of trunk branch</span>
</div>
<div class="code">
<code>Psychtoolbox/PsychBasic/KbQueueStart.m</code>
</div>
""
Additions:
KbQueueStart([deviceIndex])
Deletions:
KbQueueStart()
Requires Mac OS X 10.3 or later
Additions:
"http://svn.berlios.de/svnroot/repos/osxptb/beta/Psychtoolbox/PsychBasic/KbQueueStart.m">beta</a> | view WebSVN <a href=
"http://svn.berlios.de/wsvn/osxptb/trunk/Psychtoolbox/PsychBasic/KbQueueStart.m?op=log">changelog</a> of trunk branch</span>
Deletions:
"http://svn.berlios.de/svnroot/repos/osxptb/beta/Psychtoolbox/PsychBasic/KbQueueStart.m">beta</a> | view in <a href=
"http://svn.berlios.de/wsvn/osxptb/beta/Psychtoolbox/PsychBasic/KbQueueStart.m?view=markup">WebSVN with changelog</a></span>
Additions:
are reliably detected
only the times of the first and last presses and releases of that
key can be recovered (this has no effect on other keys)
theoretically possible for the queue to fill more quickly than
it can be emptied, losing key events temporarily while filled to
capacity. The queue holds up to thirty events, and events are
constantly being removed from the queue and processed, so this is
unlikely to be a problem in actual use.
If the device number is less than zero, the default device is used.
with each element corresponding to a particular key (use KbName
to map between keys and their positions). If the double value
corresponding to a particular key is zero, events for that key
are not added to the queue and will not be reported.
KbQueueWait is called.
queue.
the queue.
recovered by KbQueueCheck
most recent call to this routine, KbQueueStart, KbQueuWait
processsed may remain in the queue
pressed since the most recent call to KbQueueCheck or KbQueueStart
released since the most recent call to KbQueueCheck or KbQueueStart
pressed since the most recent call to KbQueueCheck or KbQueueStart
was released since the most recent call to KbQueueCheck or
KbQueueStart
ptb_kbcheck_disabledKeys (see "help DisableKeysForKbCheck"), will
must be invoked before using any of the other routines
'clear mex' is invoked and can be omitted expense of keeping
memory allocated and an additional thread running unnecesarily
KbQueueWait, KbQueueFlush, KbQueueRelease
"http://svn.berlios.de/wsvn/osxptb/beta/Psychtoolbox/PsychBasic/KbQueueStart.m?view=markup">WebSVN with changelog</a></span>
Deletions:
are reliably detected
only the times of the first and last presses and releases of that
key can be recovered (this has no effect on other keys)
theoretically possible for the queue to fill more quickly than
it can be emptied, losing key events temporarily while filled to
capacity. The queue holds up to thirty events, and events are
constantly being removed from the queue and processed, so this is
unlikely to be a problem in actual use.
If the device number is less than zero, the default device is used.
with each element corresponding to a particular key (use KbName
to map between keys and their positions). If the double value
corresponding to a particular key is zero, events for that key
are not added to the queue and will not be reported.
KbQueueWait is called.
queue.
the queue.
recovered by KbQueueCheck
most recent call to this routine, KbQueueStart, KbQueuWait
processsed may remain in the queue
pressed since the most recent call to KbQueueCheck or KbQueueStart
released since the most recent call to KbQueueCheck or KbQueueStart
pressed since the most recent call to KbQueueCheck or KbQueueStart
was released since the most recent call to KbQueueCheck or
KbQueueStart
ptb_kbcheck_disabledKeys (see "help DisableKeysForKbCheck"), will
must be invoked before using any of the other routines
'clear mex' is invoked and can be omitted expense of keeping
memory allocated and an additional thread running unnecesarily
KbQueueWait, KbQueueFlush, KbQueueRelease
"http://svn.berlios.de/viewcvs/osxptb/beta/Psychtoolbox/PsychBasic/KbQueueStart.m?view=markup">WebSVN with changelog</a></span>
Additions:
""
<div class="code_header" style="text-align:right;">
<span style="float:left;">Path </span> <span class="counter">Retrieve current version of KbQueueStart.m from berliOS: <a href=
"http://svn.berlios.de/svnroot/repos/osxptb/beta/Psychtoolbox/PsychBasic/KbQueueStart.m">beta</a> | view in <a href=
"http://svn.berlios.de/viewcvs/osxptb/beta/Psychtoolbox/PsychBasic/KbQueueStart.m?view=markup">WebSVN with changelog</a></span>
</div>
<div class="code">
<code>Psychtoolbox/PsychBasic/KbQueueStart.m</code>
</div>
""
Deletions:
%%(php;Path)Psychtoolbox/PsychBasic/KbQueueStart.m%%
Additions:
==[[Psychtoolbox]] › [[PsychBasic]]==
are reliably detected
only the times of the first and last presses and releases of that
key can be recovered (this has no effect on other keys)
theoretically possible for the queue to fill more quickly than
it can be emptied, losing key events temporarily while filled to
capacity. The queue holds up to thirty events, and events are
constantly being removed from the queue and processed, so this is
unlikely to be a problem in actual use.
If the device number is less than zero, the default device is used.
with each element corresponding to a particular key (use KbName
to map between keys and their positions). If the double value
corresponding to a particular key is zero, events for that key
are not added to the queue and will not be reported.
KbQueueWait is called.
queue.
the queue.
recovered by KbQueueCheck
most recent call to this routine, KbQueueStart, KbQueuWait
processsed may remain in the queue
pressed since the most recent call to KbQueueCheck or KbQueueStart
released since the most recent call to KbQueueCheck or KbQueueStart
pressed since the most recent call to KbQueueCheck or KbQueueStart
was released since the most recent call to KbQueueCheck or
KbQueueStart
ptb_kbcheck_disabledKeys (see "help DisableKeysForKbCheck"), will
must be invoked before using any of the other routines
'clear mex' is invoked and can be omitted expense of keeping
memory allocated and an additional thread running unnecesarily
KbQueueWait, KbQueueFlush, KbQueueRelease
Deletions:
==[[Psychtoolbox]] › PsychBasic==
are reliably detected
only the times of the first and last presses and releases of that
key can be recovered (this has no effect on other keys)
theoretically possible for the queue to fill more quickly than
it can be emptied, losing key events temporarily while filled to
capacity. The queue holds up to thirty events, and events are
constantly being removed from the queue and processed, so this is
unlikely to be a problem in actual use.
If the device number is less than zero, the default device is used.
with each element corresponding to a particular key (use KbName
to map between keys and their positions). If the double value
corresponding to a particular key is zero, events for that key
are not added to the queue and will not be reported.
KbQueueWait is called.
queue.
the queue.
recovered by KbQueueCheck
most recent call to this routine, KbQueueStart, KbQueuWait
processsed may remain in the queue
pressed since the most recent call to KbQueueCheck or KbQueueStart
released since the most recent call to KbQueueCheck or KbQueueStart
pressed since the most recent call to KbQueueCheck or KbQueueStart
was released since the most recent call to KbQueueCheck or
KbQueueStart
ptb_kbcheck_disabledKeys (see "help DisableKeysForKbCheck"), will
must be invoked before using any of the other routines
'clear mex' is invoked and can be omitted expense of keeping
memory allocated and an additional thread running unnecesarily
KbQueueWait, KbQueueFlush, KbQueueRelease
Additions:
ptb_kbcheck_disabledKeys (see "help DisableKeysForKbCheck"), will
Deletions:
ptb_kbcheck_disabledKeys (see "help DisableKeysForKbCheck"), will
Additions:
==[[Psychtoolbox]] › PsychBasic==
Requires Mac OS X 10.3 or later
The routines KbQueueCreate, KbQueueStart, KbQueueStop, KbQueueCheck
KbQueueWait, KbQueueFlush and KbQueueRelease provide replacments for
KbCheck and KbWait, providing the following advantages:
1) Brief key presses that would be missed by KbCheck or KbWait
are reliably detected
2) The times of key presses are recorded more accurately
3) The times of key releases are also recorded
=== Limitations: ===
1) If a key is pressed multiple times before KbQueueCheck is called,
only the times of the first and last presses and releases of that
key can be recovered (this has no effect on other keys)
2) If many keys are pressed very quickly in succession, it is at least
theoretically possible for the queue to fill more quickly than
it can be emptied, losing key events temporarily while filled to
capacity. The queue holds up to thirty events, and events are
constantly being removed from the queue and processed, so this is
unlikely to be a problem in actual use.
Only a single device can be monitored at any given time. The deviceNumber can
be specified only in the call to KbQueueCreate. The other routines then
relate to that specified device. If deviceNumber is not specified, the first
device is the default (like KbCheck). If KbQueueCreate has not been called
first, the other routines will generate an error message. Likewise, if
KbQueueRelease has been called more recently than KbQueueCreate, the other
routines will generate error messages.
It is acceptable to call KbQueueCreate at any time (e.g., to switch to a new
device or to change the list of queued keys) without calling KbQueueRelease.
KbQueueCreate([deviceNumber, keyList])
Creates the queue for the specified (or default) device number
If the device number is less than zero, the default device is used.
keyList is an optional 256-length vector of doubles (not logicals)
with each element corresponding to a particular key (use KbName
to map between keys and their positions). If the double value
corresponding to a particular key is zero, events for that key
are not added to the queue and will not be reported.
No events are delivered to the queue until KbQueueStart or
KbQueueWait is called.
KbQueueCreate can be called again at any time
KbQueueStart()
Starts delivering keyboard events from the specified device to the
queue.
KbQueueStop()
Stops delivery of new keyboard events from the specified device to
the queue.
Data regarding events already queued is not cleared and can be
recovered by KbQueueCheck
[pressed, firstPress, firstRelease, lastPress, lastRelease]=
KbQueueCheck()
Obtains data about keypresses on the specified device since the
most recent call to this routine, KbQueueStart, KbQueuWait
Clears all scored events, but unscored events that are still being
processsed may remain in the queue
pressed: a boolean indicating whether a key has been pressed
firstPress: an array indicating the time that each key was first
pressed since the most recent call to KbQueueCheck or KbQueueStart
firstRelease: an array indicating the time that each key was first
released since the most recent call to KbQueueCheck or KbQueueStart
lastPress: an array indicating the most recent time that each key was
pressed since the most recent call to KbQueueCheck or KbQueueStart
lastRelease: an array indicating the most recent time that each key
was released since the most recent call to KbQueueCheck or
KbQueueStart
For firstPress, firstRelease, lastPress and lastRelease, a time value
of zero indicates that no event for the corresponding key was
detected since the most recent call to KbQueueCheck or KbQueueStart
To identify specific keys, use KbName (e.g., KbName(firstPress)) to
generate a list of the keys for which the events occurred
For compatibility with KbCheck, any key codes stored in
ptb_kbcheck_disabledKeys (see "help DisableKeysForKbCheck"), will
not caused pressed to return as true and will be zeroed out in the
returned arrays. However, a better alternative is to specify a
keyList arguement to KbQueueCreate.
secs=KbQueueWait()
Waits for any key to be pressed and returns the time of the press
KbQueueFlush should be called immediately prior to this function
(unless the queue has just been created and started) to clear any
prior events.
Note that this command will not respond to any keys that were
inactivated by using the keyList argument to KbQueueCreate.
Since KbQueueWait is implemented as a looping call to
KbQueueCheck, it will not respond to any key codes stored in
the global variable ptb_kbcheck_disabledKeys
(see "help DisableKeysForKbCheck")
KbQueueFlush()
Removes all unprocessed events from the queue and zeros out any
already scored events.
KbQueueRelease()
Releases queue-associated resources; once called, KbQueueCreate
must be invoked before using any of the other routines
This routine is called automatically at clean-up (e.g., when
'clear mex' is invoked and can be omitted expense of keeping
memory allocated and an additional thread running unnecesarily
Note that any keyboard typing used to invoke KbQueue commands will be
recorded. This would include the release of the carriage return used
to execute KbQueueStart and the keys pressed and released to invoke
KbQueueCheck
----
See also: KbQueueCreate, KbQueueStart, KbQueueStop, KbQueueCheck,
KbQueueWait, KbQueueFlush, KbQueueRelease
%%(php;Path)Psychtoolbox/PsychBasic/KbQueueStart.m%%
Deletions:
==PtbReference › PsychBasic==
KbQueueStart()
Requires Mac OS X 10.3 or later
The routines KbQueueCreate, KbQueueStart, KbQueueStop, KbQueueCheck
KbQueueWait, KbQueueFlush and KbQueueRelease provide replacments for
KbCheck and KbWait, providing the following advantages:
1) Brief key presses that would be missed by KbCheck or KbWait
are reliably detected
2) The times of key presses are recorded more accurately
3) The times of key releases are also recorded
Limitations:
1) If a key is pressed multiple times before KbQueueCheck is called,
only the times of the first and last presses and releases of that
key can be recovered (this has no effect on other keys)
2) If many keys are pressed very quickly in succession, it is at least
theoretically possible for the queue to fill more quickly than
it can be emptied, losing key events temporarily while filled to
capacity. The queue holds up to thirty events, and events are
constantly being removed from the queue and processed, so this is
unlikely to be a problem in actual use.
Only a single device can be monitored at any given time. The deviceNumber can
be specified only in the call to KbQueueCreate. The other routines then
relate to that specified device. If deviceNumber is not specified, the first
device is the default (like KbCheck). If KbQueueCreate has not been called
first, the other routines will generate an error message. Likewise, if
KbQueueRelease has been called more recently than KbQueueCreate, the other
routines will generate error messages.
It is acceptable to call KbQueueCreate at any time (e.g., to switch to a new
device or to change the list of queued keys) without calling KbQueueRelease.
KbQueueCreate([deviceNumber, keyList])
Creates the queue for the specified (or default) device number
If the device number is less than zero, the default device is used.
keyList is an optional 256-length vector of doubles (not logicals)
with each element corresponding to a particular key (use KbName
to map between keys and their positions). If the double value
corresponding to a particular key is zero, events for that key
are not added to the queue and will not be reported.
No events are delivered to the queue until KbQueueStart or
KbQueueWait is called.
KbQueueCreate can be called again at any time
Starts delivering keyboard events from the specified device to the
queue.
KbQueueStop()
Stops delivery of new keyboard events from the specified device to
the queue.
Data regarding events already queued is not cleared and can be
recovered by KbQueueCheck
[pressed, firstPress, firstRelease, lastPress, lastRelease]=
KbQueueCheck()
Obtains data about keypresses on the specified device since the
most recent call to this routine, KbQueueStart, KbQueuWait
Clears all scored events, but unscored events that are still being
processsed may remain in the queue
pressed: a boolean indicating whether a key has been pressed
firstPress: an array indicating the time that each key was first
pressed since the most recent call to KbQueueCheck or KbQueueStart
firstRelease: an array indicating the time that each key was first
released since the most recent call to KbQueueCheck or KbQueueStart
lastPress: an array indicating the most recent time that each key was
pressed since the most recent call to KbQueueCheck or KbQueueStart
lastRelease: an array indicating the most recent time that each key
was released since the most recent call to KbQueueCheck or
KbQueueStart
For firstPress, firstRelease, lastPress and lastRelease, a time value
of zero indicates that no event for the corresponding key was
detected since the most recent call to KbQueueCheck or KbQueueStart
To identify specific keys, use KbName (e.g., KbName(firstPress)) to
generate a list of the keys for which the events occurred
For compatibility with KbCheck, any key codes stored in
ptb_kbcheck_disabledKeys (see "help DisableKeysForKbCheck"), will
not caused pressed to return as true and will be zeroed out in the
returned arrays. However, a better alternative is to specify a
keyList arguement to KbQueueCreate.
secs=KbQueueWait()
Waits for any key to be pressed and returns the time of the press
KbQueueFlush should be called immediately prior to this function
(unless the queue has just been created and started) to clear any
prior events.
Note that this command will not respond to any keys that were
inactivated by using the keyList argument to KbQueueCreate.
Since KbQueueWait is implemented as a looping call to
KbQueueCheck, it will not respond to any key codes stored in
the global variable ptb_kbcheck_disabledKeys
(see "help DisableKeysForKbCheck")
KbQueueFlush()
Removes all unprocessed events from the queue and zeros out any
already scored events.
KbQueueRelease()
Releases queue-associated resources; once called, KbQueueCreate
must be invoked before using any of the other routines
This routine is called automatically at clean-up (e.g., when
'clear mex' is invoked and can be omitted expense of keeping
memory allocated and an additional thread running unnecesarily
Note that any keyboard typing used to invoke KbQueue commands will be
recorded. This would include the release of the carriage return used
to execute KbQueueStart and the keys pressed and released to invoke
KbQueueCheck
_________________________________________________________________________
See also: KbQueueCreate, KbQueueStart, KbQueueStop, KbQueueCheck,
KbQueueWait, KbQueueFlush, KbQueueRelease
PsychBasic
Additions:
===[[KbQueueStart]]===
==PtbReference › PsychBasic==
Deletions:
===PsychBasic===