Mobile Manipulator Kinematics: When FollowBot Reaches Out
Stacking a mobile base and an arm creates redundancy — and redundancy without a null-space policy creates unpredictable whole-body motion.
🎯 By the end you'll understand
How to form the augmented Jacobian for a mobile manipulator by stacking the base mobility contribution with the arm Jacobian. What null-space motion is, why a redundant system has infinitely many joint-velocity solutions for a given end-effector velocity, and how choosing the wrong null-space policy causes the base to drift invisibly. How the non-holonomic constraint of a differential-drive base limits which null-space motions are physically realizable. And the practical whole-body control formulation FollowBot uses to hand an object to a person without moving the base under the operator's nose.
KEY INSIGHTRedundancy is a gift that punishes the careless
When FollowBot's arm can reach the same target with the base in three different positions, you do not have three solutions — you have an infinite family of solutions parameterized by one free variable. That freedom is either your most powerful tool or the source of your most confusing field failure.
A 6-DOF arm has exactly zero redundancy for a 6-DOF task: one configuration per target (ignoring multiple IK branches). Mount that arm on a diff-drive base that can translate forward-backward and rotate in place, and the system now has 8 or more degrees of freedom for a 6-DOF task. The extra dimensions span a subspace called the null space of the task Jacobian. Motion in the null space does not move the end-effector — it moves everything else. If you do not explicitly specify what should happen in the null space, the solver will pick something arbitrary, and that "something" will usually be the base drifting sideways into the person FollowBot is tracking.
The augmented Jacobian maps a vector of all joint velocities (base + arm) to end-effector velocity. Its pseudoinverse gives the minimum-norm joint-velocity solution — which minimizes total joint motion but does not keep the base still. If you want the base to stay put while the arm reaches, you must explicitly project that goal into the null space. This is not an optimization detail — it is a safety contract. An uncontrolled base moving under a person who is not watching it is a collision hazard.
CORE CONCEPTThe augmented Jacobian: stacking base and arm
Recall from Lesson 2.4 that the Jacobian J maps joint velocities q̇ to end-effector velocity ẋ:
ẋ = J(q) q̇ — end-effector velocity equals Jacobian times joint-velocity vector. For a pure arm, q̇ ∈ ℝⁿ where n is the number of arm joints. For a mobile manipulator, q̇ is extended.
For a mobile manipulator, the "joints" include the base degrees of freedom. A differential-drive base contributes two velocity inputs — linear velocity v and angular velocity ω — but in Cartesian terms it contributes three Cartesian velocities: (ẋ_base, ẏ_base, θ̇). The augmented Jacobian stacks these contributions:
The base Jacobian J_base encodes how base motion in the world frame maps to end-effector velocity. This depends on the arm's current configuration: if the arm is fully extended horizontally, a base rotation produces a large end-effector velocity; if the arm is folded back over the base, the same base rotation produces almost none. The coupling is real and configuration-dependent.
For a 2D planar analysis (which covers most of FollowBot's grasp-and-handoff task): the base contributes linear velocity v (forward), lateral velocity (zero for diff-drive, a key constraint), and rotation ω. The arm contributes joint velocities θ̇₁...θ̇ₙ. The augmented Jacobian then has shape (3 × (2 + n)) for planar tasks, and any n > 1 creates redundancy.
The 3D treatment is conceptually identical but produces larger matrices. The null-space phenomenon — base drifting while the end-effector stays fixed — appears equally clearly in a 2D planar example with a 3-DOF arm on a 1-DOF sliding base (4 DOFs, 2D task → 2 null-space dimensions). This is exactly what the widget below demonstrates.
HOW IT WORKSNull-space motion: the math behind invisible base drift
Given the augmented Jacobian J (dropping the "aug" subscript for clarity), the pseudoinverse solution for joint velocities that achieve a desired end-effector velocity ẋ_d is:
q̇ = J⁺ ẋ_d + (I − J⁺J) z
The first term J⁺ ẋ_d is the minimum-norm particular solution: it moves the end-effector as commanded with the smallest possible total joint motion. The second term (I − J⁺J) z is the null-space projection of an arbitrary vector z. Pre-multiplied by the null-space projector N = (I − J⁺J), any vector z maps to the null space: the contribution has zero effect on ẋ. You can choose z freely to optimize any secondary objective — and you must, or z defaults to zero (the minimum-norm solution).
The minimum-norm solution (z = 0) is not "neutral" — it distributes joint motion to minimize the Euclidean norm ‖q̇‖. In a mobile manipulator, this often means moving the base (which has large Cartesian leverage and therefore requires little joint velocity to contribute to the task) rather than moving the arm joints (which require more angular velocity for the same Cartesian result near the arm's root). The base drifts because it is kinematically cheap, not because you asked it to.
The null-space projector N = I − J⁺J is a matrix that projects any vector onto the null space of J. It has a concrete geometric meaning: columns of N span the directions in joint space that produce zero end-effector motion. For a 3-DOF arm on a 1-DOF sliding base with a 2D planar task:
Task-space component
J⁺ ẋ_d — the part of joint motion that moves the end-effector to the target. Constrained to satisfy ẋ = ẋ_d. No freedom here.
Null-space component
N z — the part of joint motion that moves joints without moving the end-effector. This is where the base can drift, elbow can reconfigure, and joint limits can be avoided — if you choose z wisely.
Choose z = 0 (default)
Minimum-norm: smallest ‖q̇‖. Tends to move the base because base motion is geometrically "cheap." Base drifts unpredictably.
Choose z = gradient of secondary objective
Explicit null-space policy: minimize joint-limit proximity, keep base stationary, maximize manipulability. Requires deliberate design.
Practical null-space policies for mobile manipulators include: (1) penalizing base velocity — add a term in z that drives the base velocity toward zero; (2) maximizing arm manipulability — use z = ∇w(q_arm) where w is the manipulability measure from Lesson 2.5; (3) keeping the arm in a preferred mid-range configuration — useful when operating near joint limits.
SEE ITRedundancy explorer: null-space slider
Below is a 3-DOF planar arm on a 1-DOF sliding base — 4 DOFs total for a 2D end-effector task (x, y). The system has 2 null-space dimensions. The end-effector is pinned to a fixed target (the red cross). Move the null-space slider to explore how the base drifts while the end-effector stays fixed. The velocity decomposition panel shows how the total joint velocity splits between task-space and null-space components.
The key observation: at every slider position, the end-effector stays on target (EE error ≈ 0), but the base position changes dramatically. In a real FollowBot scenario, this base motion is not visible in the arm's task frame — the operator watching the arm sees the end-effector on target and does not notice the base has moved 0.4 m sideways into the person being followed.
CORE CONCEPTThe non-holonomic constraint: not all null-space motions are achievable
The analysis above treats the mobile base as if it can move in any direction — it contributes (ẋ, ẏ, θ̇) to the augmented Jacobian. But a differential-drive robot cannot move sideways. The non-holonomic constraint says:
ẏ_base = 0 in the robot's local frame, or equivalently: the component of velocity perpendicular to the robot's heading is always zero. Formally: ẋ sin(θ) − ẏ cos(θ) = 0. This is a velocity constraint, not a position constraint — it restricts which velocities are achievable, but not (over time, with maneuvering) which positions are reachable.
This constraint has two important consequences for mobile manipulator control:
Null-space motion involving lateral base velocity is not directly achievable
If the null-space projector produces a joint-velocity command that includes lateral base motion, the base cannot execute it in one step. The diff-drive must maneuver — turn, translate, turn back — to achieve lateral displacement over time. This converts what looks like a simple null-space reconfiguration into a multi-step maneuver with transient end-effector disturbance (since during the maneuver the arm must compensate for base rotation).
The base contributes only 2 independent Cartesian DOFs, not 3
Even though a planar base has 3 configuration parameters (x, y, θ), the non-holonomic constraint means only 2 velocities are independently commanded at any instant: v (forward) and ω (rotation). The effective contribution to J_base must respect this — the lateral column is constrained. The true augmented Jacobian for a diff-drive mobile manipulator has the lateral column of J_base zeroed out (or replaced by the heading-dependent projection). This reduces the null-space dimension by one compared to the fully holonomic case.
Null-space policy design must account for the constraint
The most natural null-space policy for FollowBot's grasp task is "keep the base stationary while the arm reaches." This is achievable — it just sets q̇_base = 0 and solves for arm joints alone. But the second-best policy — "slide the base gently forward while the arm extends" — requires that the commanded base velocity be purely forward (aligned with the robot's current heading). Policies that would require lateral base motion must instead use a longer-horizon maneuver plan, which couples the null-space control with path planning.
Many textbook treatments of mobile manipulator kinematics use an omnidirectional base for clarity. The math is cleaner and the null-space is fully exploitable. Porting those results to FollowBot's diff-drive base without accounting for the non-holonomic constraint produces joint-velocity commands the base cannot execute. The controller will silently saturate the lateral velocity to zero, and the resulting motion will deviate from the planned trajectory in a configuration-dependent, hard-to-predict way.
HOW IT WORKSWhole-body control: putting it together
Whole-body control (WBC) is the general framework that unifies the augmented Jacobian, null-space projection, and constraint handling into a single control loop. The idea: express all objectives as a priority-ordered stack, solve for joint velocities that satisfy higher-priority objectives exactly and lower-priority objectives in the null space of the higher-priority tasks.
For FollowBot's grasp-and-handoff task, the priority stack is:
| Priority | Task | Formulation | Failure if violated |
|---|---|---|---|
| P1 (highest) | Joint limits | Velocity damping near limits | Hardware stop, arm lockout |
| P2 | End-effector position | J⁺ ẋ_d (task Jacobian) | Grasp fails, object missed |
| P3 | Base velocity = 0 | Null-space term: z = −K_base q̇_base | Base drifts, LIDAR occlusion |
| P4 (lowest) | Arm manipulability | Null-space term: z = K_m ∇w(q) | Arm approaches singularity |
The P3 term is the safety-critical one. By projecting a restoring force on q̇_base into the null space of the task Jacobian, we penalize base motion without compromising end-effector tracking. The gain K_base trades off how aggressively to suppress base motion — too high and it fights the task at the cost of arm joint velocities; too low and the base still drifts.
The full WBC command is:
q̇ = J_aug⁺ ẋ_d + N (z_base + z_manip)
where N = I − J_aug⁺ J_aug is the null-space projector, z_base = −K_base q̇_base (damps base velocity), and z_manip = K_m ∇w(q_arm) (increases manipulability). Priority is enforced by stacking: z_base is applied first in the null space, then z_manip in the null space of the combined [J_aug; J_base] system.
In ROS 2 / MoveIt 2, this is implemented through a combination of the servo kinematics solver (real-time Jacobian-based IK) and custom constraints in the planning scene. The arm controller runs at 100–500 Hz using a Cartesian servo loop; the base velocity command passes through a separate diff-drive controller node. Synchronization is handled by a wholebody_coordinator node that publishes both arm joint targets and cmd_vel from the same WBC solve loop.
import numpy as np import rclpy from rclpy.node import Node class WholeBodyController(Node): def __init__(self): super().__init__('wholebody_controller') self.K_base = 5.0 # base damping gain in null space self.K_manip = 0.5 # manipulability gradient gain def compute_qdot(self, J_aug, xdot_d, q_dot_base_cur): # pseudoinverse (damped least squares, λ=0.01) lam = 0.01 JT = J_aug.T n = J_aug.shape[1] J_pinv = JT @ np.linalg.inv(J_aug @ JT + lam * np.eye(J_aug.shape[0])) # particular solution: track end-effector q_dot_task = J_pinv @ xdot_d # null-space projector N = np.eye(n) - J_pinv @ J_aug # null-space objective 1: suppress base velocity z_base = np.zeros(n) z_base[:2] = -self.K_base * q_dot_base_cur # damp v, ω # combined null-space command q_dot = q_dot_task + N @ z_base return q_dot
Three things to notice. First, the damped pseudoinverse (λ = 0.01) avoids singularity blowup near degenerate configurations — this is the same damped-least-squares approach introduced in Lesson 2.6. Second, z_base only has non-zero entries at the base DOFs — it is specifically a base-damping term, not a global velocity penalty. Third, the null-space projector N is computed fresh at every control step because it changes as the configuration q changes.
FOLLOWBOTFollowBot's grasp-and-handoff task
FollowBot's arm is a 6-DOF serial manipulator mounted on the diff-drive base. The grasp-and-handoff task has three phases: approach (base moves to within arm reach), grasp (arm reaches to object while base holds still), and handoff (arm extends to person while base optionally repositions). The null-space control is critical in the grasp and handoff phases.
The FollowBot milestone for Stage 2 includes the arm FK and Jacobian from DH parameters (built in Lessons 2.3 and 2.4). For the whole-body controller, the Stage 2 deliverable is the augmented Jacobian computed from the current base pose and arm configuration, and the WBC node that publishes arm joint targets and cmd_vel synchronously at 50 Hz. The null-space base-suppression term is the critical piece that distinguishes a safe grasp from one that risks base drift.
import numpy as np def augmented_jacobian(J_arm: np.ndarray, base_pose: np.ndarray, T_base_ee: np.ndarray) -> np.ndarray: """ Build J_aug = [J_base | J_arm] for a diff-drive mobile manipulator. Args: J_arm: (6, n) Jacobian of arm joints in arm base frame base_pose: (3,) = [x, y, theta] base pose in world frame T_base_ee: (4,4) transform from base frame to EE frame Returns: J_aug: (6, n+2) augmented Jacobian [J_base | J_arm] """ theta = base_pose[2] c, s = np.cos(theta), np.sin(theta) # position of EE in WORLD frame (required for moment arm calc) R_world_base = np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]]) p_ee_world = R_world_base @ T_base_ee[:3, 3] # [px, py, pz] in world frame # Diff-drive base contribution to EE velocity (planar, 6×2) # Column 0: forward velocity v → (cos θ, sin θ, 0, 0, 0, 0) # Column 1: angular velocity ω → (-p_y_world, p_x_world, 0, 0, 0, 1) J_base = np.zeros((6, 2)) J_base[0, 0] = c # vx from forward velocity J_base[1, 0] = s # vy from forward velocity J_base[0, 1] = -p_ee_world[1] # vx from rotation (world-frame moment arm) J_base[1, 1] = p_ee_world[0] # vy from rotation (world-frame moment arm) J_base[5, 1] = 1.0 # ωz from base rotation # Augment: concatenate along columns J_aug = np.hstack([J_base, J_arm]) # shape (6, n+2) return J_aug
The non-holonomic constraint is already encoded here: J_base has only 2 columns (v and ω), not 3. The lateral velocity is simply absent — the base cannot produce it, so it contributes nothing to the Jacobian. This is the correct formulation for a diff-drive base, and it automatically reduces the null-space dimension by 1 compared to the omnidirectional case.
By the end of Stage 2, FollowBot's kinematics stack includes: (1) diff-drive forward/inverse kinematic model with odometry integration producing /odom at 50 Hz; (2) arm FK from DH parameters with a singularity monitor; (3) arm Jacobian computed at every control step; (4) augmented Jacobian combining base and arm; (5) WBC node with null-space base suppression. The workspace visualization shows the reachable space of the arm from the current base position — and, critically, shows how base repositioning expands that reachable space without disrupting an active end-effector task.
WEAKNESSWhere this bites
The most field-critical failure in mobile manipulator deployments is not arm singularity — it is invisible base drift. When you use the minimum-norm pseudoinverse without a null-space base-suppression policy, the base slides to positions that were not operationally planned. In FollowBot's person-following context, this means: (1) the LIDAR field of view shifts and the person cluster moves out of the expected sector, disrupting the person tracker; (2) the base edge approaches the person from a direction they are not watching; (3) the diff-drive rotation associated with null-space reconfiguration temporarily points the LIDAR away from the person. All three happen silently — no error is raised, no alarm sounds. The person tracker simply starts to produce less confident estimates, which propagates through the EKF into the planner. By the time the behavior anomaly is noticed, the robot may be pressed against the person's leg.
A null-space policy derived for an omnidirectional base produces base velocity commands that include lateral components. When executed on a diff-drive base, the lateral component is silently saturated to zero by the motor driver. The resulting motion is different from what the WBC planned — the base moves in a curved trajectory instead of the intended null-space path. The arm controller does not know the base deviated, so it continues to compute J_aug based on the planned base pose rather than the actual one. The end-effector position error grows as the Jacobian becomes inconsistent with reality. Symptom: grasp consistently misses by a small, repeatable offset that scales with the magnitude of the intended lateral motion. Fix: always project null-space base velocities through the diff-drive kinematic constraint before computing J_aug.
Setting K_base very large to aggressively suppress base motion forces all task-space motion onto the arm joints. If the end-effector target is at the boundary of the arm's reachable space, and the base is not allowed to help, the arm will be commanded toward its workspace boundary — where the Jacobian approaches singularity. The damped pseudoinverse handles this gracefully in theory (by regularizing near-singular Jacobians), but the practical effect is that arm velocity spikes near the workspace boundary, joint limits are approached, and the P1 joint-limit constraint fires. The robot stops the grasp motion entirely even though the target was reachable — if the base were allowed to move slightly. The fix is to use a smooth gain schedule: low K_base when the arm has plenty of manipulability, higher K_base when the arm is near the center of its workspace, and an override that allows base motion if the manipulability measure drops below a threshold.
KEY INSIGHTHow this connects
- The Jacobian: Velocity Kinematics and the Spine of Robotics (2.4) — the fundamental J q̇ = ẋ relationship underpins everything here. The augmented Jacobian is J_arm extended with J_base columns. Every identity in this lesson reduces to a J manipulation.
- Singularity Analysis and Manipulability (2.5) — the manipulability measure w(q) = √det(JJᵀ) is the secondary null-space objective for joint-limit and singularity avoidance. Understanding when ‖J‖ → 0 tells you when the null-space policy must override base suppression to preserve arm mobility.
- Inverse Kinematics: Closed-Form and Numerical Methods (2.6) — the damped-least-squares pseudoinverse used for IK is the same tool used here to compute J_aug⁺. The regularization parameter λ serves the same role: preventing velocity blowup near singularity.
- Velocity Control in Practice: cmd_vel to Wheel Commands (2.7) — the base velocity command q̇_base from WBC feeds directly into the diff-drive inverse kinematic model from Lesson 2.7. The non-holonomic constraint lives in the diff-drive model, not the WBC — the two layers are cleanly separated, and Lesson 2.7 is where the constraint is enforced.
- 3.1 · Newton-Euler Dynamics: Forces, Torques, and Rigid Bodies — Stage 3 extends the kinematic WBC to a dynamic WBC that accounts for inertia and gravity. The augmented Jacobian becomes the key tool for computing joint torques from desired task-space forces.
Mobile manipulator kinematics is the last major kinematic concept before Stage 3 dynamics. Every velocity-level tool from Stage 2 — the Jacobian, pseudoinverse, manipulability, IK — recurs in Stage 3 at the force-torque level. The null-space policy introduced here reappears as the null-space torque projection in the operational-space control formulation. The insight that "the null space is where secondary objectives live" is the architectural organizing principle of all modern whole-body control.
GLOSSARYKey terms
- Augmented Jacobian
- The Jacobian of a mobile manipulator formed by horizontally concatenating the base contribution J_base (how base velocities move the end-effector) with the arm Jacobian J_arm. Has shape (m × (n_base + n_arm)) where m is the task-space dimension.
- Null space
- The subspace of joint velocities that produce zero end-effector velocity. For a system with n joint DOFs and m task DOFs (n > m), the null space has dimension n − m. Motion in the null space reconfigures the robot without disturbing the end-effector task.
- Null-space projector
- The matrix N = I − J⁺J that projects an arbitrary vector z onto the null space of J. The vector N z produces zero end-effector velocity regardless of z. Used to implement secondary objectives without violating the primary task constraint.
- Minimum-norm solution
- The pseudoinverse solution q̇ = J⁺ ẋ_d, which minimizes ‖q̇‖² subject to J q̇ = ẋ_d. Does not produce null-space motion (z = 0 is implicit), but may cause the base to drift because base motion is kinematically cheap for the task.
- Non-holonomic constraint
- A velocity constraint on a robot's motion that cannot be integrated into a position constraint. For a differential-drive base: lateral velocity is always zero. Restricts which velocities are instantaneously achievable, even though all positions (x, y, θ) are reachable over time.
- Whole-body control (WBC)
- A control framework that formulates all robot objectives as a priority-ordered stack and solves for joint velocities (or torques) that satisfy higher-priority objectives exactly and lower-priority objectives in the remaining null space. Unifies base motion, arm motion, and constraint handling.
- Redundancy
- The condition where a robot has more degrees of freedom than the task requires (n > m). Creates a family of solutions for any given end-effector velocity, parameterized by null-space motion. Redundancy is beneficial (more dexterous) but requires an explicit null-space policy to be controlled.
- LIDAR occlusion (mobile manipulator)
- The condition where base drift during arm operation moves the LIDAR sensor into a position where the tracked person falls outside its field of view or is shadowed by the robot's own body. A failure mode unique to mobile manipulators — fixed-base arms cannot cause it.
ACTIVE RECALLCheck your understanding
Answer in your own words first, then reveal.
1A 6-DOF arm is mounted on a diff-drive base. What is the dimension of the null space of the augmented Jacobian for a full 6-DOF spatial task?›
The diff-drive base contributes 2 independent velocity DOFs (v and ω) in the augmented Jacobian — not 3, because the non-holonomic constraint eliminates lateral velocity. The arm contributes 6 DOFs. Total joint DOFs in J_aug: 8. Task DOFs: 6. Null-space dimension: 8 − 6 = 2. (For an omnidirectional base with 3 independent DOFs, the null space would be 3-dimensional.) This means there are infinitely many joint-velocity solutions for any given end-effector velocity, parameterized by a 2D free vector z.
2Why does the minimum-norm pseudoinverse solution tend to move the mobile base even when you would prefer it to stay still?›
The minimum-norm solution minimizes ‖q̇‖² — total joint velocity magnitude. Base motion is kinematically cheap: a small base velocity produces a large end-effector velocity (because the moment arm from base to end-effector is long when the arm is extended). So the solver naturally prefers using a little base motion rather than a lot of arm joint motion to achieve the same end-effector result. The base "helps" the task for free in the Euclidean sense, but at the cost of physically moving the platform. The fix is to add a null-space term z = −K_base q̇_base that explicitly penalizes base velocity, projecting that penalty through N so it does not interfere with end-effector tracking.
3FollowBot's whole-body controller uses K_base = 50 (very high). The operator notices that the arm frequently stops short of the target with no error reported. What is happening, and how do you fix it?›
A very high K_base aggressively suppresses all base motion via the null-space term. This forces all task-space motion onto the arm joints. If the target is near the boundary of the arm's reachable workspace, the arm is being driven toward workspace boundary — where the Jacobian approaches singularity and the arm velocity spikes. The joint-limit priority task (P1) fires, clamping arm velocity to zero. The grasp stops short even though the target was reachable if the base were allowed to reposition slightly. Fix: implement an adaptive gain schedule. Monitor manipulability w(q_arm) at each step. When w drops below a threshold (say w < 0.15), reduce K_base to allow the base to contribute and expand the effective workspace. When w is high (arm well-conditioned), restore K_base to protect against base drift. This trades safety against precision based on the current kinematic configuration.
4A colleague ports an omnidirectional mobile manipulator null-space controller to FollowBot's diff-drive base. Grasps consistently miss by a small repeatable offset. What is the root cause?›
The omnidirectional controller produces base velocity commands that include a lateral component. The diff-drive base silently saturates this component to zero — the motor driver simply ignores it, no error is raised. The WBC continues to compute J_aug assuming the planned base pose, but the actual base is at a different position (it moved along a curved arc instead of the planned path). The Jacobian is now inconsistent with the actual robot configuration. The arm compensates for the wrong base pose, placing the end-effector at an offset from the true target. The fix: project all base velocity commands through the diff-drive kinematic model (v, ω) before computing J_aug and before publishing cmd_vel. Lateral velocity must be zeroed before the Jacobian computation, not after, so the arm Jacobian portion accounts for the constrained base motion.