Difference between revisions of "Contributions:BCPy2000"

From BCI2000 Wiki
Jump to: navigation, search
m (States)
m (Source Code Revisions)
Line 30: Line 30:
*Initial development: 2148
*Initial development: 2148
*Tested under: 2324
*Tested under: 2547
*Known to compile under: 2324
*Known to compile under: 2547
*Broken since: ----
*Broken since: ----

Revision as of 03:42, 17 September 2009


BCPy2000 takes the C++ out of BCI2000 programming. It is aimed at developers of new applications and new signal processing methods, providing a platform for rapid, flexible development of experimental Brain-Computer Interface systems in Python. It takes advantage of various high-level Python packages: VisionEgg[1] for stimulus presentation, NumPy[2] and SciPy[3] for signal processing and classification, and IPython[4] for interactive debugging.

You can program a python-based application module, signal processing module, or even a signal source module for generating custom test signals and playing back data files. Each module can open an IPython shell in which you can inspect and interact with every aspect of the running system. If you're using a BCPy2000-implemented source module, you can slow the system right down or even step through packet-by-packet, which can help you while you're interactively debugging your python code in one of your other modules with pdb.

BCPy2000 implements a lot of infrastructure that allows you to get an application module running quickly. It also contains a set of optional tools, which are still a work in progress, but which are rapidly turning into a kind of "standard library" of Pythonic signal-processing algorithms and stimulus widgets.

The source code is available under the terms of the GNU General Public License v3.

To learn more, see the BCPy2000 web pages[5]





Jeremy Hill, Thomas Schreiner, Christian Puzicha, Jason Farquhar

Version History

2008-09-30: BCPy2000 8570 (also known as 1.0)

Fully integrated framework, with documentation. Higher-level tools are still somewhat patchily documented.

2009-03-16: BCPy2000 11336

Second release of demo build. The three Python-related core modules are now gnu-compilable and can run on non-Windows platforms. A number of accumulated enhancements, optimizations and bug fixes, including improved precision of sound stimulus timing, and playback of older-style .dat files (bug reported by Marco Rotonda)

Source Code Revisions

  • Initial development: 2148
  • Tested under: 2547
  • Known to compile under: 2547
  • Broken since: ----


BCPy2000 has whatever parameters you want to define in your own python module implementations. There are a few that it implements in the framework already, however:


This boolean, defined by the application framework, determines whether a signal-packet clock should be shown in the bottom right corner of the screen.


Your experiment need not be trial-based, but there's a flexible and automatic way of keeping track of trials within blocks, and blocks within runs, if you choose to design it that way. The self.design() application API method helps you set this up, and this parameter, defined by the application module, specifies the number of trials in a block.


This defaults to 1, so we usually consider a "block" to be the same thing as a "run". However, we once designed an experiment where multiple blocks of trials where recorded continuously in one file, along with the inter-block rest periods. So that had multiple BlocksPerRun. The self.design() application API method allows you to configure this.


The default speed at which the Python source module sends its artificial signals through the system. The default value of this parameter, 1.0, means real time.


If you check this, then the PythonSignalProcessing and PythonApplication modules will be rendered unable to change the state variables, and PythonApplication's phase transitions will follow the PresentationPhase state instead of allowing the phase machine to run on its own. This allows recorded experiments to be played back, if you're careful about how they're programmed. Type self.doc('Replay') from one of the IPython prompts for more details.


An arbitrary string describing your Python application module's behaviour, filled in by the self.Description() hook in your BciApplication class implementation.


An arbitrary string describing your Python signal-processing module's behaviour, filled in by the self.Description() hook in your BciSignalProcessing class implementation.


An arbitrary string describing your Python source module's behaviour, filled in by the self.Description() hook in your BciSource class implementation.


BCPy2000 modules have whatever states you want to define for them in your Python implementation. However, the application module framework defines one or two already:


Records the state of the application's "phase machine" as a number. You probably should not rely on the numerical value of this state variable to interpret what was happening, when you read the file back. Instead, define your own state variables with more transparent names, and ensure that your BciApplication.Transition method sets these states accordingly when a transition occurs. Type self.doc('Phase Machine') at one of the modules' IPython prompts for more details.


This is used as a poor substitute for stimulus timing information when a physical synchronization signal is not available. It is set automatically whenever a phase transition occurs, and its value lets you localize that event in the data stream with reasonable precision. Type self.doc('Timing') at one of the BCPy2000 modules' shell prompts for more info.


If you have chosen to implement a trial-based experimental design, this state variable keeps track of the trial number.


If you have chosen to implement multiple blocks per run in your experimetnal design (see the parameter BlocksPerRun) then this keeps track of the block number.