From Vol I intuition to a control problem
In Volume I you learned that motor-cortex activity can drive a cursor. The graduate version of that sentence is precise and unforgiving: motor neural decoding for a limb or cursor is continuous, real-time regression of kinematics, executed inside a closed feedback loop where the user watches the effector and corrects it many times per second. This is categorically different from the discrete, one-shot classification of a P300 speller — there is no 'trial' to average over, and every estimate you emit immediately changes the input distribution you see next.
The substrate: what we record, and what it encodes
High-performance motor BCIs today rest on intracortical recording from primary motor cortex, typically with one or more Utah arrays (~96–192 channels) — the substrate of the BrainGate trials. In practice the features are not painstakingly spike-sorted single units; threshold-crossing counts (the unsorted multiunit 'hash') and multiunit band power usually carry nearly all the decodable information at far less fragility.
What does M1 encode? The historical arc matters. Early work found neurons are broadly directionally tuned — firing rate follows a cosine tuning curve of reach direction — which motivated the population vector decoder. Later closed-loop work found velocity to be the most reliably decodable correlate for cursor control. The modern dynamical-systems view reframes single-neuron tuning as a shadow of low-dimensional population dynamics — a thread we pick up in the frontier guide.
f_i = b_{0,i} + \mathbf{b}_i^\top\mathbf{v} = b_{0,i} + m_i\,\lVert\mathbf{v}\rVert\cos\!\left(\theta - \theta_i^{\mathrm{pref}}\right)Cosine tuning written as a linear map from movement velocity to expected firing rate — the seed of every linear motor decoder.
Writing cosine tuning as a baseline plus a dot product of velocity turns "a neuron fires for its preferred direction" into a clean linear equation — the starting point every linear motor decoder is built on.
- f_i
- The expected firing rate of unit i.
- \mathbf{v},\ \lVert\mathbf{v}\rVert
- Movement velocity and its magnitude (speed).
- \mathbf{b}_i,\ \theta_i^{\mathrm{pref}}
- The unit's directional tuning weights and preferred direction.
- b_{0,i},\ m_i
- Baseline rate and modulation depth.
Invert this linear relation across many units and you can read velocity back out from the rates — the seed of cosine-tuned decoding.
The pipeline as one loop
Draw the whole system once and keep it in your head. Every stage adds delay, and delay in a feedback loop costs stability and throughput — a 20–50 ms bin plus decode and rendering latency is the closed-loop 'reaction time' the user must control through.
- Acquire: amplify and digitize spikes / LFP from the microelectrode array.
- Bin & feature-ize: count threshold crossings (or take band power) in ~20–50 ms bins.
- Decode: map features to intended kinematics with the decoder (a Kalman filter in the next guide).
- Actuate: move the cursor / arm; the user sees the result.
- Correct: the user adjusts intention to null the visible error — and the loop repeats.
Why velocity, and why the loop wins
Two design choices define classic cursor BCI. First, decode velocity, not position: velocity commands are more directly and stably represented in M1, and integrating them to a position is forgiving of momentary errors. Second, exploit the loop: the user continuously supplies error-correcting feedback, so the decoder need not be perfect — it needs to be controllable. A slightly biased but predictable decoder can be mastered; an unbiased but jittery one cannot.