Streaming Control of a Rotary Joint

Neuron model

Elevate is a phenomenological model with sodium, potassium, calcium, slow potassium and leak currents:

$$C\frac{dV}{dt}=I_0+g_e(E_e-V)+g_i(E_i-V) +\sum_{k\in\{\mathrm{Na},\mathrm{K},\mathrm{Ca},\mathrm{KCa},L\}}g_k(E_k-V).$$

$V,t,C,I_0$ denote voltage, time, capacitance and applied current. Excitatory and inhibitory conductances $g_e,g_i$ have reversals $E_e,E_i$; intrinsic conductance $g_k$ has reversal $E_k$. Units are mV, ms, nF, µS and nA; no cell-area calibration is assumed.

For gates $j\in\{m,h,n,c,q\}$,

$$\tau_j\frac{dU_j}{dt}=V-U_j,\qquad x_j=\sigma\!\left[a_j(U_j-b_j)\right],\qquad \sigma(z)=\frac{1}{1+\exp(-z)}.$$

$U_j$ is filtered voltage (mV), $\tau_j$ its timescale (ms), $x_j$ a dimensionless gate, $a_j$ the slope (mV$^{-1}$), $b_j$ the midpoint (mV), and $z$ the dimensionless sigmoid argument. In that order, slopes are $(0.2,-0.1,0.1,0.2,0.1)$ and midpoints $(-25,-40,-15,-45,-30)$ mV:

$$g_{\mathrm{Na}}=\bar g_{\mathrm{Na}}x_mx_h,\quad g_{\mathrm{K}}=\bar g_{\mathrm{K}}x_n,\quad g_{\mathrm{Ca}}=\bar g_{\mathrm{Ca}}x_c,\quad g_{\mathrm{KCa}}=\bar g_{\mathrm{KCa}}x_q,\quad g_L=\bar g_L.$$

$\bar g_k$ is maximum conductance. Both potassium currents use $E_{\mathrm K}$. KCa depends on filtered voltage, with no calcium-concentration state. All six states, $V$ and the five $U_j$, start at $-60$ mV.

Numerical update and spike output

Each 1 ms step uses 40 split substeps of $h=0.025$ ms with fixed input conductances. First update the filters using the old voltage:

$$U_j^+=V+(U_j-V)\exp(-h/\tau_j).$$

The superscript $+$ denotes an updated value. Evaluate gates and conductances from $U_j^+$, then update the membrane with conductances frozen:

$$G=g_e+g_i+\sum_k g_k,\qquad V_\infty=\frac{I_0+g_eE_e+g_iE_i+\sum_k g_kE_k}{G}, \qquad V^+=V_\infty+(V-V_\infty)\exp(-hG/C).$$

$G$ is total conductance (µS), $V_\infty$ the equilibrium voltage (mV), and $k$ indexes the five intrinsic currents. Each frozen sub-update is exact; their composition approximates the coupled dynamics. A crossing $V\leq0<V^+$ mV sets the window’s spike flag without resetting state.

Synaptic and local drive

Let $r\in\{f,e\}$ denote flexor or extensor, $\bar r$ its peer, and $n=0,1,\ldots$ the control window. Synapses decay, then receive spike increments:

$$\begin{aligned} g_{\mathrm{s},r}^{n} &=e^{-\Delta t/\tau_{\mathrm{s}}}g_{\mathrm{s},r}^{n-1} +w_{\mathrm{s}}S_r^{n-1},\\ g_{\mathrm{p},r}^{n} &=e^{-\Delta t/\tau_{\mathrm{p}}}g_{\mathrm{p},r}^{n-1} +w_{\mathrm{p}}M_{\bar r}^{n-1}. \end{aligned}$$

$g_{\mathrm{s},r}$ and $g_{\mathrm{p},r}$ are sensory AMPA and peer GABA conductances (µS). $S_r^{n-1}$ and $M_{\bar r}^{n-1}$ count the preceding window’s sensory and peer motor spikes. With $\Delta t=1$ ms, decay times are $(\tau_{\mathrm{s}},\tau_{\mathrm{p}})=(10,50)$ ms and per-spike weights are $(w_{\mathrm{s}},w_{\mathrm{p}})=(0.035,0.2)$ µS. Initial conductances and input counts are zero; increments are added in full, without timestep scaling.

Unfiltered local excitation switches from starting to tonic drive:

$$g_{\mathrm{local},r}(t)= \begin{cases} g_{\mathrm{start},r}, & 0\leq t<T_{\mathrm{start}},\\ g_{\mathrm{tonic}}, & t\geq T_{\mathrm{start}}. \end{cases}$$

$t$ is model time from startup, $T_{\mathrm{start}}=20$ ms, $(g_{\mathrm{start},f},g_{\mathrm{start},e})=(0.5,0)$ µS and $g_{\mathrm{tonic}}=0.04$ µS. At $t_n=n\Delta t$, the membrane inputs are

$$g_{e,r}^{n}=g_{\mathrm{local},r}(t_n)+g_{\mathrm{s},r}^{n}, \qquad g_{i,r}^{n}=g_{\mathrm{p},r}^{n}.$$

$g_{e,r}^{n}$ and $g_{i,r}^{n}$ are total excitatory and inhibitory conductances. Recorded settings appear in the parameter table.

Joint dynamics model

Two muscles drive a spring-damped joint. Zero points downward; positive angles point right. Only the tip mass contributes gravity:

$$(J_0+mL^2)\ddot{\theta}+b\dot{\theta}+k(\theta-\theta_r)+mgL\sin\theta =\tau_{\max}(a_f-a_e).$$

$\theta$ is angle (rad); dots denote derivatives in seconds. $J_0$ is base inertia (kg m$^2$), $m$ tip mass (kg), $L$ arm length (m), $g$ gravity (m/s$^2$), $\theta_r$ spring rest angle (rad), $b$ damping (N m s/rad), and $k$ stiffness (N m/rad). $a_f,a_e\in[0,1]$ are flexor/extensor activations; $\tau_{\max}$ is maximum muscle torque (N m).

At mechanical step $n$, muscle $i\in\{f,e\}$ updates as

$$a_{i,n+1}=\min\!\left(1, a_{i,n}\exp[-\Delta t/\tau_a]+q\,s_{i,n}\right).$$

Here $\Delta t=0.001$ s, $\tau_a$ is activation decay time (s), $q$ the dimensionless spike increment, and $s_{i,n}$ the preceding window’s motor spike count per neuron. Updated activations set torque. Semi-implicit Euler updates velocity, then angle; stops at $\theta_r\pm1$ rad clamp angle and zero velocity.

The joint starts at $\theta_r=\pi/2$ (90°), with zero velocity and activation. Total inertia is $0.00508$ kg m$^2$; initial gravity torque is $-0.003924$ N m. Flexor raises the mass against gravity; extensor lowers it.

Before each update, sensory spikes excite flexor for $\theta<\theta_r-\theta_s$ and extensor for $\theta>\theta_r+\theta_s$. The sensory centre is $\theta_r$, threshold $\theta_s=0.25$ rad, and minimum interspike interval 10 ms. Each channel repeats while beyond threshold.

Architecture Pseudocode

1. Overall

ROS2 Humble runs flexor, extensor and plant as separate processes on separate CPUs. All three receive the same resolved recipe configuration. Each controller owns an independent SNNLab stream containing one Elevate neuron; the plant integrates joint mechanics without a neural network. These Python-like blocks omit boilerplate. ROS2 scheduling and message helpers are schematic; prepare_stream and stream.advance denote SNNLab’s streaming interface.

from snnlab.sim import prepare_stream
from torch import float64

cfg = recorded_configuration
dt = cfg["dt_ms"] * ms
nodes = launch_ros2_processes("flexor", "extensor", "plant")
wait_for_ros2_discovery_and_controller_warmup(nodes)
arm_shared_start(nodes, future_ros_time())


def prepare_controller():
    bundle = author_network(cfg)
    stream = prepare_stream(
        bundle,
        window_steps=1,
        batch_size=1,
        device="cpu",
        dtype=float64,
        performance=recorded_performance,
    )
    warm_up_then_reset(stream)
    return stream


def windows(node):
    for n in range(total_windows):
        release = node.monotonic_origin + n * dt
        spin_ros2_until(node, release)
        frames = wait_for_ros2_frames(node, index=n - 1)
        enforce_lag_limit(release)
        with measure_callback(node, deadline=release + dt):
            yield n, frames
            publish_ros2_frame(node, n, node.output_events)

Each node consumes both other nodes’ complete preceding windows from /frames/flexor, /frames/extensor or /frames/plant. The initial inputs are empty; every completed window is published, including silence. Late nodes catch up without dropping windows or shifting deadlines. Callback timing includes model execution, spike publication and diagnostic buffering, but excludes input waiting. Buffered diagnostics are exported after control finishes.

2. Flexor node

The flexor receives excitatory sensory spikes from the plant and inhibitory motor spikes from the extensor. Its local excitation is 0.5 µS for the first 20 ms, then 0.04 µS. SNNLab retains membrane and synaptic state between steps.

node = create_ros2_node("flexor")
stream = prepare_controller()

for n, frames in windows(node):
    drive = cfg["flexor_initial_us"] if n * dt < 20 * ms else cfg["tonic_us"]
    inputs = snnlab_inputs(
        tonic=drive,
        sensory=count_sensory_spikes(frames["plant"], channel="flexor"),
        peer=count_spikes(frames["extensor"]),
    )
    result = stream.advance(inputs)
    node.output_events = motor_spike_events(result)
    publish_ros2_spikes("/motor/flexor", node.output_events)
    buffer_voltage_and_spikes(node, result)

3. Extensor node

The extensor receives excitatory sensory spikes from the plant and inhibitory motor spikes from the flexor. Its SNNLab stream is separate from the flexor’s. Local excitation starts at 0 µS for 20 ms, then switches to the same 0.04 µS tonic drive.

node = create_ros2_node("extensor")
stream = prepare_controller()

for n, frames in windows(node):
    drive = cfg["extensor_initial_us"] if n * dt < 20 * ms else cfg["tonic_us"]
    inputs = snnlab_inputs(
        tonic=drive,
        sensory=count_sensory_spikes(frames["plant"], channel="extensor"),
        peer=count_spikes(frames["flexor"]),
    )
    result = stream.advance(inputs)
    node.output_events = motor_spike_events(result)
    publish_ros2_spikes("/motor/extensor", node.output_events)
    buffer_voltage_and_spikes(node, result)

4. Plant/Joint node

The plant receives both controllers’ motor windows. Before advancing mechanics, it encodes the current angle as sensory spikes; motor spikes then update muscle activation and joint motion. Sensory output returns through ROS2 and enters the controllers in the next logical window. This node does not execute SNNLab.

node = create_ros2_node("plant")
joint = Joint(cfg["joint"])

for n, frames in windows(node):
    sensory = joint.encode(n * dt / second)
    motor = [count_spikes(frames["flexor"]), count_spikes(frames["extensor"])]
    joint.advance(motor, dt / second)
    node.output_events = sensory_spike_events(sensory)
    publish_ros2_spikes("/sensory/flexor", sensory[0])
    publish_ros2_spikes("/sensory/extensor", sensory[1])
    buffer_angle_velocity_and_activation(node, joint)

Network diagram

Parameters

Values come from the selected recording’s native snapshot and configuration.