Uni-cycle — a one-wheeled cycle. The model treats the whole robot as one imaginary wheel. It rolls where it faces and can turn on the spot. It never slides sideways

$$\dot x = v\cos\theta, \qquad \dot y = v\sin\theta, \qquad \dot\theta = \omega$$

• Two commands move three coordinates. Sideways is not a command

$$v = \frac{v_R + v_L}{2}, \qquad \omega = \frac{v_R - v_L}{L}$$

• Two real wheels make that one imaginary wheel: the average is $v$, the difference is $\omega$
• Two wheels, four wheels, tracks — all are unicycles. Each side moves as one, and nothing steers. So the robot has only $v$ and $\omega$. Four wheels obey it only approximately: they slide (later)
• A Twist uses two of its six numbers: linear.x = $v$, angular.z = $\omega$

$$v_R = v + \omega\,\frac{L}{2}, \qquad v_L = v - \omega\,\frac{L}{2}, \qquad \text{joint speed} = \frac{v_{R,L}}{r}\ \ [\text{rad/s}]$$

• Which joint: the wheel's hinge — <right_joint> or <left_joint>. Its speed is how fast that wheel spins
• When the robot turns, the outer wheel goes $\omega L/2$ faster, the inner one $\omega L/2$ slower
• Divide by $r$: tyre speed in m/s becomes wheel spin in rad/s. The stock DiffDrive computes the same

    def on_cmd_vel(self, msg):                          # message thread, whenever a Twist arrives
        self.v, self.w = msg.linear.x, msg.angular.z    # keep v and ω, touch nothing else

    def pre_update(self, info, ecm):                    # every step, BEFORE physics
        if info.paused:                                 # paused world: do nothing
            return
        half = self.w * self.separation / 2             # ω·L/2
        # set_velocity writes a JointVelocityCmd; physics then holds the joint
        # at exactly that speed for this step, whatever torque it takes
        self.left.set_velocity(ecm, [(self.v - half) / self.radius])    # (v − ωL/2) / r
        self.right.set_velocity(ecm, [(self.v + half) / self.radius])   # (v + ωL/2) / r

A filter between the Twist and the wheels: the speed may change only so fast, and never past a maximum. A real robot cannot reach full speed in 1 ms — it would slip or tip

$$a_{min} \;\le\; \frac{v - v_{prev}}{\Delta t} \;\le\; a_{max}, \qquad\qquad v_{min} \;\le\; v \;\le\; v_{max}$$

• Yes, step by step: each 1 ms step the speed grows by at most $a_{max}\,\Delta t$ = 1 mm/s — 0 to 0.5 m/s takes 500 steps. Asked 0.8, it gets 0.5. Red dots: measured on the Pioneer, every 0.1 s

• Seen from above, forward is up. Arrow length is the wheel's speed. Positive $\omega$ turns left — anticlockwise, as everywhere in ROS
• $v = \omega L/2$: the inner wheel stands still, and the robot turns around it. $v < \omega L/2$: the turn centre is between the wheels, and the inner wheel runs backwards

Where the robot is, worked out from how far its wheels turned. Four steps, in post_update, every physics step:

Step	Formula	In words
1 · each wheel rolled	$\Delta s_L = r\,\Delta\varphi_L, \quad \Delta s_R = r\,\Delta\varphi_R$	change of wheel angle × radius = distance on the floor
2 · the body moved	$\Delta s = (\Delta s_R + \Delta s_L)\,/\,2$ $\Delta\theta = (\Delta s_R - \Delta s_L)\,/\,L$	average → forward; difference → turn
3 · add to the pose	$x \mathrel{+}= \Delta s\cos(\theta + \tfrac{\Delta\theta}{2})$ $y \mathrel{+}= \Delta s\sin(\theta + \tfrac{\Delta\theta}{2})$ $\theta \mathrel{+}= \Delta\theta$	one step along the heading
4 · publish	$v = \Delta s\,/\,\Delta t, \quad \omega = \Delta\theta\,/\,\Delta t, \quad q$	every 20 ms: where, which way, how fast

• The unicycle formulas, run backwards: wheels → body. Nothing outside the robot is used — a slipping wheel is invisible to it

$$\Delta s_{L,R} = r\,\Delta\varphi_{L,R}, \qquad \Delta s = \frac{\Delta s_R + \Delta s_L}{2}, \qquad \Delta\theta = \frac{\Delta s_R - \Delta s_L}{L}$$

• Each tyre rolled its wheel's angle change times the radius
• The centre moved by the average. The robot turned by the difference, divided by $L$

def post_update(self, info, ecm):                       # every step, AFTER physics: read only
    left = self.left.position(ecm)                      # φ_L, rad — a list; None until asked for
    right = self.right.position(ecm)                    # φ_R, rad
    if info.paused or left is None or right is None:    # nothing to read yet
        return
    ds_l = self.radius * (left[0] - self.last[0])       # Δs_L = r·Δφ_L
    ds_r = self.radius * (right[0] - self.last[1])      # Δs_R = r·Δφ_R
    self.last = (left[0], right[0])                     # φ now → "previous" next step
    ds = (ds_r + ds_l) / 2                              # Δs
    dth = (ds_r - ds_l) / self.separation               # Δθ

• Ask for the angles once, in configure: enable_position_check(ecm)

$$x \mathrel{+}= \Delta s\cos\!\left(\theta + \tfrac{\Delta\theta}{2}\right), \qquad y \mathrel{+}= \Delta s\sin\!\left(\theta + \tfrac{\Delta\theta}{2}\right), \qquad \theta \mathrel{+}= \Delta\theta$$

• Move $\Delta s$ forward along the heading, then turn by $\Delta\theta$
• Why $\Delta\theta/2$: during the step the heading turns from $\theta$ to $\theta + \Delta\theta$. Stepping along the heading halfway through that turn follows the arc better than the start heading would

    self.x += ds * math.cos(self.th + dth / 2)          # x += Δs·cos(θ + Δθ/2): heading at mid-step
    self.y += ds * math.sin(self.th + dth / 2)          # y += Δs·sin(θ + Δθ/2)
    self.th += dth                                      # θ += Δθ

• Odometry is a sum: every small error is added, and never taken back

$$v = \frac{\Delta s}{\Delta t}, \qquad \omega = \frac{\Delta\theta}{\Delta t}, \qquad q = \left(0,\ 0,\ \sin\tfrac{\theta}{2},\ \cos\tfrac{\theta}{2}\right)$$

• Why $\theta/2$: a quaternion stores half the angle. A turn by $\theta$ about the vertical axis is $(0, 0, \sin\frac{\theta}{2}, \cos\frac{\theta}{2})$

    if info.sim_time >= self.next_pub:                  # in post_update: every 20 ms of sim time
        self.next_pub += timedelta(milliseconds=20)     # the next message's time
        msg = Odometry()                                # gz.msgs.Odometry
        t = info.sim_time                               # stamp: sim time, not the wall clock…
        msg.header.stamp.sec = t.days * 86400 + t.seconds   # …whole seconds
        msg.header.stamp.nsec = t.microseconds * 1000       # …and nanoseconds
        msg.pose.position.x, msg.pose.position.y = self.x, self.y   # x, y, m
        msg.pose.orientation.z = math.sin(self.th / 2)  # q: half the angle…
        msg.pose.orientation.w = math.cos(self.th / 2)  # …about z only: a flat robot
        msg.twist.linear.x = ds / info.dt.total_seconds()    # v = Δs/Δt, m/s
        msg.twist.angular.z = dth / info.dt.total_seconds()  # ω = Δθ/Δt, rad/s
        self.odom.publish(msg)                          # out on /model/<name>/odometry

• Everything else stays 0 — a flat robot. The header also names the frames: <model>/odom, <model>/chassis

$$\Delta\theta_{\text{odom}} = \frac{\Delta s_R - \Delta s_L}{L} \qquad\text{but}\qquad \Delta\theta_{\text{true}} = \frac{\Delta s_R - \Delta s_L}{L_{\text{eff}}}, \qquad L_{\text{eff}} = L\,\frac{\theta_{\text{odom}}}{\theta_{\text{true}}} > L$$

• The same wheel motion on top of both. The body turns less — as if the wheels were further apart
• Our Husky in Gazebo: $L_{\text{eff}} \approx 1.2\,L$
• Clearpath's own ROS 2 configuration for the real Husky multiplies the distance for this reason: wheel_separation_multiplier: 1.875
• What to do: measure $L_{\text{eff}}$ (spins on the spot against a reference) · model the slip (WheelSlip) · or fuse an IMU — later in the course

Friction coefficient — a property of a surface. Each wheel sets it on its <collision> (the tyre); the ground has its own; physics uses the smaller of the two. The largest force a tyre can push with = coefficient × load

$$\underbrace{\text{coefficient along} \times \tfrac{\text{track}}{2}}_{\text{turns the robot}} \;>\; \underbrace{\text{coefficient across} \times \tfrac{\text{wheelbase}}{2}}_{\text{holds it still}}$$

• Wheels push forward and back → that torque turns it. Tyres resist sliding sideways → that torque holds it

<friction><ode>               <!-- in each wheel's <collision>; Gazebo's skid example -->
  <fdir1>0 0 1</fdir1>        <!-- direction 1 = the wheel's own z = its axle = SIDEWAYS -->
  <mu>1</mu>                  <!-- friction coefficient in direction 1: across the tyre -->
  <mu2>1</mu2>                <!-- friction coefficient in direction 2: along the tyre -->
  <slip1>0.035</slip1>        <!-- sideways softness; 0 = hard -->
</ode></friction>

• With slip1 = 0 it does not turn: the coefficient is 1 both ways, and the track (1.25 m) is shorter than the wheelbase (1.51 m). Holding wins: the wheels spin, the body stays
• With slip1 = 0.035 the tyres give sideways, and it turns. The Husky: mu = 0.5 sideways, a track wider than its wheelbase — it turns, sliding

• pre_update writes the left speed into the joint, then the right speed — into the same joint, wheel_joint. Physics sees only the second:

$$\text{joint speed} = \frac{v + \omega L/2}{r}$$

• For example $v = 0$, $\omega = 1$, $L/2 = 0.15$: the wheel turns forward, the robot goes 0.15 m/s ahead. The code is right; the robot is wrong
• Odometry reads that joint twice: $\Delta s_R = \Delta s_L$, so $\Delta\theta = 0$ — "straight". And it is right
• One wheel on the centre line pushes only along it. The ball gives no side force. To turn you need two wheels — or one steered wheel: AckermannSteering
• With no right_joint: nothing moves, no odometry, no warning

	DiffDrive	MulticopterMotorModel + MulticopterVelocityControl
plugins per robot	one	one per rotor, and one controller
input	Twist — an intention	one speed per rotor, from the controller
what it sets every step	each wheel joint's speed — physics holds it exactly	the rotor's speed, and a force along the rotor axis with a twist on the body
formula	left $(v - \omega L/2)/r$, right $(v + \omega L/2)/r$ — exact kinematics	$T = k\,\Omega^2$ — then physics integrates it
who closes the loop	nobody needs to: the ground holds the robot level	the controller, watching the real velocity
odometry	yes, from the wheel angles	none — a separate plugin
on a real robot	firmware holds each wheel's speed: OpenCR, ARCOS, the Husky's MCU	an autopilot — PX4, ArduPilot — and an ESC per motor

• The wheel formula is exact: set the speeds, and the robot goes there. The rotor formula only says how hard to push — something must watch the result