Control

Control theory is about making a system do what you command, despite loads, noise and modelling errors, by measuring what it actually does and correcting for the difference. This page covers open and closed loop, PID and PD control, transfer functions and step responses, sampling rates, the hobby servo's internal loop, and compliance, using the Strido servos and its MuJoCo model as examples.

In Strido

Rates: the firmware runs a $200 Hz$ control and IMU loop (kControlPeriodUs = 5000) and refreshes the servos at $200 Hz$ (kServoFrequencyHz; the SPT5435LV accepts up to $330 Hz$ ). It streams state to the host at $100 Hz$ (all in firmware/strido_esp32s3/src/board_config.h). The joint command stream is $100 Hz$ (strido_sim/walk.py) and the learned policy runs at $50 Hz$ (strido/policy.py).
Servo model in simulation: MuJoCo position actuators with kp="25" kv="0.4" forcerange="-3.432 3.432", plus joint damping="0.25" armature="0.012" frictionloss="0.05" (models/mujoco/strido.xml).
Hardware: 12 SPT5435LV-180W position servos driven by a PCA9685 PWM board (servos, firmware).

Open loop and closed loop

Open loop applies a precomputed input and never checks the result. A trot gait that replays foot trajectories through inverse kinematics is open loop with respect to the body: if the robot slips, the gait does not notice.

Closed loop (feedback) measures the output $y$ , compares it with the reference $r$ , and acts on the error $e = r - y$ . Feedback rejects disturbances and hides modelling errors. The price is stability problems if the gain is too high or the delay too long.

Strido stacks several loops, each faster than the one above it:

Rendering diagram…

The servos give no position feedback to the host (strido_sim/rl/env.py). So the only joint-level loop closes inside each servo. The policy closes the body-level loop through the IMU.

PID control

The classic controller combines three terms:

u (t) = K_{p} e (t) + K_{i} \int_{0}^{t} e (τ) d τ + K_{d} \dot{e} (t)

P pushes in proportion to the error, like a spring.
I accumulates past error and removes steady-state offsets, at the cost of overshoot and wind-up.
D opposes the rate of change, like a damper. In practice it acts on $- \dot{y}$ instead of $\dot{e}$ , which avoids a kick when the reference jumps.

For joints, the usual choice is PD with the target velocity set to zero:

τ = k_{p} (q^{*} - q) - k_{v} \dot{q}

This is exactly MuJoCo's <position kp kv> actuator. It is then clipped to the force range, $| τ | \leq 3.432 N m$ , the servo's stall torque.

Transfer functions and the step response

Model one joint as an inertia $I$ with viscous damping $b$ . In the Laplace domain, $I s^{2} Q = T - b s Q$ . With PD control the closed loop from target to angle is:

\frac{Q (s)}{Q^{*} (s)} = \frac{k_{p}}{I s^{2} + (b + k_{v}) s + k_{p}} = \frac{ω_{n}^{2}}{s^{2} + 2 ζ ω_{n} s + ω_{n}^{2}}, ω_{n} = \sqrt{\frac{k_{p}}{I}}, ζ = \frac{b + k_{v}}{2 \sqrt{k_{p} I}}

This standard second-order system explains most of what you see in a step response:

$ω_{n}$ sets the speed. Rise time $\approx 1.8 / ω_{n}$ , and bandwidth $\approx ω_{n}$ for $ζ$ near $0.7$ .
$ζ$ sets the shape. Below 1 the response overshoots and rings. The overshoot is $\exp (- π ζ / \sqrt{1 - ζ^{2}})$ . Above 1 it is sluggish but monotone.
Raising $k_{p}$ speeds the response up but lowers $ζ$ , so you raise $k_{v}$ with it.
The static stiffness is $k_{p}$ : a constant load $τ_{L}$ leaves an error of $τ_{L} / k_{p}$ . Only an integral term removes it.

Worked example: the MuJoCo knee

From models/mujoco/strido.xml: $k_{p} = 25 N m / rad$ , $k_{v} = 0.4 N m s / rad$ , joint damping $b = 0.25$ , armature $0.012 kg m^{2}$ . The calf adds $m r_{c}^{2} \approx 0.0521 \cdot {0.048}^{2} = 1.2 \times 10^{- 4} kg m^{2}$ plus its own $1.5 \times 10^{- 4} kg m^{2}$ about its centre of mass (mass_report.yaml), so $I \approx 0.0123 kg m^{2}$ for a swinging calf (the armature dominates). Then:

ω_{n} = \sqrt{\frac{25}{0.0121}} = 45 rad / s (7.2 Hz), ζ = \frac{0.25 + 0.4}{2 \sqrt{25 \cdot 0.0121}} = 0.59

That predicts a rise time of about $40 ms$ and roughly $10 %$ overshoot. These are estimates: they ignore friction loss, the torque clamp and the other links.

In the stand the knee carries $0.70 N m$ (see statics and dynamics), so the model sags by:

Δ q = \frac{0.70}{25} = 0.028 rad \approx {1.6}^{\circ}

The policy can learn to command slightly past the target to cancel this. Because the RL environment randomises the servo stiffness each episode (env.py), the policy cannot rely on one exact value.

Sampling, delay and bandwidth

Digital controllers sample. The Nyquist limit says you need more than two samples per period of the fastest signal you care about. For good control, the rule of thumb is a loop 10–20 times faster than the closed-loop bandwidth. Delay matters just as much: a pure delay $T_{d}$ adds phase lag $φ = ω T_{d}$ , which eats the phase margin and eventually destabilises a high-gain loop.

For Strido:

Loop	Rate	Period / worst-case added delay
Policy	$50 Hz$	$20 ms$
Joint command stream	$100 Hz$	$10 ms$
ESP32 control + IMU	$200 Hz$	$5 ms$
Servo PWM frame	$200 Hz$ (max $330 Hz$ )	$5 ms$ ( $3.0 ms$ )
MuJoCo physics	$500 Hz$	$2 ms$

A classic analogue servo takes a new pulse only every $20 ms$ ( $50 Hz$ ). At the $7.2 Hz$ joint bandwidth estimated above, that much delay alone costs $ω T_{d} = 45 \cdot 0.02 = 0.9 rad \approx 52^{\circ}$ of phase. At $200 Hz$ it is $13^{\circ}$ . That is presumably why the firmware runs the PCA9685 at $200 Hz$ . The $50 Hz$ policy is fine because it only shapes the gait, whose cycle is $0.4 s$ ( $2.5 Hz$ , GAIT_PERIOD_S in strido/policy.py). That gives 20 policy steps per cycle, while the fast loops below it do the stiff work.

The hobby servo's internal loop

A hobby servo is a small closed-loop system in a box: a DC motor, a gearbox, a potentiometer on the output and a controller chip. The pulse width encodes the target angle. The chip compares it with the pot reading and drives the motor with roughly proportional (often PD-like) control, saturating at the stall torque. You can neither read its position nor tune its gains. Externally it behaves like a stiff PD joint with a torque limit, a speed limit (no-load $0.14 s / 60^{\circ}$ at $6 V$ , about $7.5 rad / s$ ) and some deadband. That is the abstraction MuJoCo's position actuator models. The firmware adds a $6 rad / s$ slew limit on top (MAX_JOINT_SPEED_RAD_S), so that sudden steps do not pull near-stall current.

Impedance and compliance

A position controller with gains $k_{p}$ and $k_{v}$ makes the joint behave like a spring and damper towards the target:

τ_{ext} = k_{p} Δ q + k_{v} \dot{q}

Mapped to the foot through $τ = J^{⊤} F$ and $δ p = J δ q$ , the foot's Cartesian stiffness is:

K_{x} = J^{- ⊤} K_{q} J^{- 1}

Impedance control chooses this stiffness on purpose. A legged robot wants its feet compliant when they touch down, so impacts are absorbed and small terrain errors do not jolt the body, and stiff during stance. Robots with torque-controlled motors (the MIT Cheetah, for example) set $K_{x}$ in software. A hobby servo is stiff and fixed, so on Strido compliance comes from lower commanded speed, the slew limit, the foot pads, and a policy trained with randomised stiffness.

Check yourself

Why does a PD-controlled joint carrying a constant load not reach its target exactly?
If you double $k_{p}$ and keep $k_{v}$ , what happens to $ω_{n}$ and $ζ$ ?
Why would a $50 Hz$ servo frame hurt more than a $50 Hz$ policy?
Where is the only joint-position feedback loop on the real robot?

Answers

At steady state the P term must supply the load torque, so $e = τ_{L} / k_{p} \neq 0$ . Only an integral term removes it.
$ω_{n}$ grows by $\sqrt{2}$ . $ζ$ shrinks by $\sqrt{2}$ , so there is more overshoot.
The frame delay sits inside the fast, stiff joint loop, whose bandwidth is several hertz. The policy shapes slower body motion (the $2.5 Hz$ gait cycle) and relies on the joint loops beneath it.
Inside each servo, between its potentiometer and its controller chip. The host and the ESP32 never see the joint angle.

Control ​

Open loop and closed loop ​

PID control ​

Transfer functions and the step response ​

Worked example: the MuJoCo knee ​

Sampling, delay and bandwidth ​

The hobby servo's internal loop ​

Impedance and compliance ​

Check yourself ​

Further reading ​