○Draft — not verified

4.4 Control Theory Background

4.4.1 Feedback Control Systems

Classic Control Loop:

Reference --> Controller --> Plant --> Output
        ^                                    |
        <-------- Sensor <-- Error <---------

PID Controller:

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

Script Implementation (P-Controller):

// Proportional control only: u = Kp * error
        angularVel = angleError * 2.0;  // Kp = 2.0

4.4.2 Stability Theory

Lyapunov Stability: A system is stable if there exists a Lyapunov function $V (x)$ such that:

$V (x) > 0$ for all $x \neq = 0$
$\dot{V} (x) < 0$ for all $x \neq = 0$

For Navigation: An energy-like function decreases monotonically toward the goal, guaranteeing convergence.

4.5 Robot Kinematics Theory

4.5.1 Differential Drive Kinematics

Kinematic Model:

\overset{x}{˙} \overset{y}{˙} \dot{θ} = cos θ sin θ 0 001 [v ω] (2)

Constraints:

Nonholonomic: Cannot move sideways (lateral velocity is always zero)
Velocity constraints: $∣ v ∣ \leq v_{m a x}$ , $∣ ω ∣ \leq ω_{m a x}$

4.5.2 Configuration Space

C-Space: The space of all possible robot configurations, partitioned as:

Free space $C_{free}$ : collision-free configurations
Obstacle space $C_{obs}$ : configurations causing collision

Minkowski Sum: $C_{obs} = O \oplus R$ , where the obstacle is inflated by the robot geometry, reducing planning to a point-robot problem.

4.6 Behaviour-Based Robotics Theory

4.6.1 Subsumption Architecture

Layered Approach:

Level 3:  Plan changes to world
        Level 2:  Identify objects
        Level 1:  Explore world
        Level 0:  Avoid obstacles          <-- highest priority

Key Principles:

Lower levels can subsume (override) higher levels
No central world model is required
Complex behaviour emerges from simple layered rules

4.6.2 Behaviour Fusion vs. Arbitration

Fusion (Weighted Combination):

u = i \sum w_{i} u_{i} (3)

Arbitration (Winner-Takes-All):

u = u_{k}, k = ar g i max priority (i) (4)

Script Implementation (Arbitration):

if (obstacleAvoidance.needsAvoidance) {
            // Obstacle avoidance wins
        } else {
            // Goal-seeking behaviour
        }

4.7 Potential Field Theory

4.7.1 Artificial Potential Fields

Attractive Potential (toward goal):

U_{att} (x) = \frac{1}{2} ξ d^{2} (x, x_{goal}) (5)

Repulsive Potential (away from obstacles):

U_{rep} (x) = ⎩ ⎨ ⎧ \frac{1}{2} η (\frac{1}{d ( x , obs )} - \frac{1}{ρ _{0}})^{2} 0 if d (x, obs) < ρ_{0} otherwise (6)

Total Potential:

U (x) = U_{att} (x) + i \sum U_{rep}^{i} (x) (7)

Force (negative gradient of potential):

F (x) = - \nabla U (x) (8)

4.7.2 Script Implementation Analysis

Attractive Force (Proportional Control):

// Proportional to angle error
        angularVel = angleError * 2.0;

Repulsive Force (Obstacle Avoidance):

// Inverse relationship with distance
        repulsiveForce = 1.0 - minDistance / obstacleThreshold;
        angularVel     = avoidanceDirection * repulsiveForce;

4.8 Path Planning Theory

4.8.1 Configuration Space Planning

Roadmap Methods:

Sample configurations in C-space
Connect samples with simple, collision-free paths
Search the resulting graph (A*, Dijkstra)

Cell Decomposition:

Decompose free space into convex cells
Plan a path through the cell sequence

4.8.2 Reactive vs. Deliberative Planning

Deliberative (Global Planning):

World Model --> Plan --> Execute

Reactive (Local Planning):

Sensors --> Action   (no explicit world model)

Hybrid Approach (Script Implementation):

Global Goal + Local Reactive Avoidance

4.9 Obstacle Avoidance Theory

4.9.1 Vector Field Histogram (VFH)

Polar Histogram:

Divide the sensor range into angular sectors
Calculate obstacle density per sector from range data
Choose the movement direction with the lowest obstacle density

4.9.2 Dynamic Window Approach (DWA)

Velocity Space Search:

Generate velocity candidates $(v, ω)$ within the dynamic window
Predict the forward trajectory for each candidate
Evaluate each trajectory with the cost function
Select the velocity pair with minimum cost

Cost Function:

G (v, ω) = α \cdot heading (v, ω) + β \cdot dist (v, ω) + γ \cdot velocity (v, ω) (9)

where $α$ , $β$ , $γ$ are weighting coefficients balancing goal alignment, obstacle clearance, and forward progress respectively.

4.10 Motion Control Theory

4.10.1 Trajectory Tracking

Reference Trajectory: $x_{d} (t)$ , $y_{d} (t)$ , $θ_{d} (t)$

Error Dynamics:

e_{x} e_{y} e_{θ} = cos θ - sin θ 0 sin θ cos θ 0 001 x_{d} - x y_{d} - y θ_{d} - θ (10)

Control Law (trajectory tracking):

v = v_{d} cos (e_{θ}) + k_{x} e_{x} (11)

ω = ω_{d} + v_{d} sin (e_{θ}) + k_{θ} e_{θ} (12)

4.10.2 Point Stabilization

Goal: Drive the robot to a target point $(x_{g}, y_{g}, θ_{g})$ .

Polar Coordinates:

ρ = (x_{g} - x)^{2} + (y_{g} - y)^{2} (13)

α = atan2 (y_{g} - y, x_{g} - x) - θ (14)

β = - θ - α (15)

where $ρ$ is the distance to the goal, $α$ is the bearing angle, and $β$ is the heading angle.

Control Law:

v = k_{ρ} ρ cos α (16)

ω = k_{α} α + k_{β} β (17)

4.11 Real-Time Systems Theory

Sample Rate Selection:

Shannon–Nyquist criterion: $f_{s} > 2 f_{c}$ (sample at least twice the highest signal frequency)
Rule of thumb: 10–20 $\times$ faster than the system dynamics
Script: 10 Hz for navigation — a reasonable rate for a mobile robot

4.11.2 Computational Complexity

Real-Time Constraint:

T_{exec} \leq T_{sample} (18)

Algorithm Complexity:

Sensor processing: $O (n)$ , where $n$ is the number of laser points
Obstacle avoidance: $O (n)$ linear scan over sensor data
Goal seeking: $O (1)$ proportional control

Bug Algorithms:

Bug 0: Follow the obstacle boundary until closer to the goal, then leave the boundary.
Bug 1: Circumnavigate the entire obstacle; depart from the point closest to the goal.
Bug 2: Follow the $m$ -line (straight line from start to goal); leave the boundary when the $m$ -line is re-encountered closer to the goal.

Multiple Sensor Modalities:

Laser: Accurate range measurements, limited field of view
Sonar: Wide beam angle, susceptible to multiple reflections
Vision: Rich semantic information, computationally expensive

Sensor Model (independence assumption):

P (z ∣ x, m) = i \prod P (z_{i} ∣ x, m) (19)

where $z = {z_{i}}$ is the set of sensor measurements, $x$ is the robot state, and $m$ is the map.

4.13 Performance Analysis Theory

Convergence Conditions:

The goal is an attractive fixed point of the system
No local minima exist in the potential field (or are handled by escape strategies)
System energy decreases monotonically: $\dot{V} (x) < 0$

Perturbation Bounds:

Sensor noise tolerance: Maximum noise level before navigation degrades
Actuator uncertainty: Wheel slip and model parameter variations
Model parameter variations: Robustness to calibration error

Safety Guarantees:

Collision avoidance: $U_{rep} \to \infty$ as $d \to 0$ , creating an impenetrable repulsive barrier
Velocity limits: Control saturation enforces $∣ v ∣ \leq v_{m a x}$ , $∣ ω ∣ \leq ω_{m a x}$
Emergency stops: Highest-priority behaviour overrides all others

Integration: Theory to Practice

How Theory Connects to Script Implementation

SLAM Theory          --> Script Practice:
        Bayesian Inference     --> ROS backend (slam_toolbox)
        Coordinate Transforms  --> updateLaserVisualization()
        Occupancy Grids        --> drawOccupancyGrid()
        State Estimation       --> updateOdometry()
        
        Navigation Theory    --> Script Practice:
        Proportional Control   --> updateNavigation()
        Potential Fields       --> calculateObstacleAvoidance()
        Behaviour Arbitration  --> navigationMode switching
        Real-Time Control      --> 10 Hz navigation loop

Theoretical Design Choices

Why Proportional Control? Simple, stable, and real-time capable. No integral windup issues. Sufficient for demonstration and teleoperation scenarios where the disturbance environment is benign.

Why Potential Fields? Reactive navigation requires no path planning step, making it computationally efficient and suitable for dynamic environments. Natural behaviour emergence means obstacle avoidance and goal seeking combine seamlessly through superposition.

Why Behaviour-Based Architecture? Modular design makes the system easy to understand, debug, and extend. Adding a new behaviour requires only defining its priority level relative to existing layers. The architecture is inherently robust to sensor failures: if one sensor-driven behaviour fails, lower-priority layers continue to operate.

This theoretical foundation explains why the algorithms in the demonstration script work, when they might fail, and how they could be improved with more sophisticated techniques.

Theoretical Background: Navigation Fundamentals