Home and service robots are robots that operate in human-centered environments such as homes, offices, hotels, and hospitals, performing tasks like cleaning, delivery, guidance, monitoring, or simple manipulation. Unlike industrial manipulators, these robots must cope with:

• Unstructured, cluttered environments and moving humans.
• Soft performance specifications (comfort, convenience, user satisfaction) rather than only precision.
• Frequent interaction with non-expert users and limited supervision.

At a high level, we can view a home/service robot as a system that repeatedly executes service tasks. Let the robot operate in discrete time steps \( k = 0,1,2,\dots \) (each step might be e.g. \(1\) s or \(0.1\) s). At each step:

• It perceives the environment (sensors and state estimation).
• It decides which task and motion to perform.
• It acts through its actuators on the environment.

A minimal mathematical abstraction, consistent with the sense–think–act loop, is:

\[ \text{state } \mathbf{x}_k \in \mathbb{R}^n,\quad \text{control } \mathbf{u}_k \in \mathbb{R}^m,\quad \mathbf{x}_{k+1} = f(\mathbf{x}_k,\mathbf{u}_k,\mathbf{w}_k) \]

where \( \mathbf{w}_k \) is an exogenous disturbance (e.g. a human unexpectedly moves a chair). In this lesson we will often use linear time-invariant (LTI) approximations:

\[ \mathbf{x}_{k+1} = \mathbf{A}\mathbf{x}_k + \mathbf{B}\mathbf{u}_k + \mathbf{w}_k, \quad \mathbf{y}_k = \mathbf{C}\mathbf{x}_k \]

which fit naturally with your background in discrete-time linear control.

flowchart TD
  U["User requests tasks (clean, deliver, monitor)"]
  U --> TSEL["Task selection & scheduling"]
  TSEL --> PLAN["Path & motion planning (high level)"]
  PLAN --> CTRL["Low-level control (discrete-time LTI)"]
  CTRL --> ACT["Actuators (drive, arm, gripper)"]
  ACT --> ENV["Home environment (rooms, humans, obstacles)"]
  ENV --> SENS["Sensors (lidar, camera, bump, IMU)"]
  SENS --> EST["State estimation (pose, map, task status)"]
  EST --> TSEL
        

A key feature of service robots is that users care less about exact trajectories and more about service performance: how many tasks are completed, how often, and with which reliability. We formalize this using simple discrete-time models.

Consider a finite set of tasks \( \mathcal{T} = \{1,2,\dots,N\} \), such as “vacuum living room”, “deliver package to door”, “check if window open”. For each task \( i \) at time step \( k \), define a binary completion variable

\[ y_i(k) = \begin{cases} 1 & \text{if task } i \text{ is complete at step } k,\\ 0 & \text{otherwise.} \end{cases} \]

The vector \( \mathbf{y}(k) = (y_1(k),\dots,y_N(k))^\top \) summarizes which tasks are done. A simple service level metric is the fraction of completed tasks:

\[ S(k) = \frac{1}{N} \sum_{i=1}^N y_i(k), \]

where \( S(k) \in [0,1] \). One can also weight tasks by importance coefficients \( w_i > 0 \) to obtain

\[ S_w(k) = \frac{\sum_{i=1}^N w_i y_i(k)}{\sum_{i=1}^N w_i}. \]

For recurring tasks (e.g. “keep floor clean”), we may not require that tasks remain in state 1 forever. Instead, we choose a refresh period \( H_i \) for each task, and define \( y_i(k) = 1 \) if task \( i \) was serviced at least once in the last \( H_i \) time steps.

Another important notion is per-task reliability. Suppose that whenever the robot attempts task \( i \), it succeeds with probability \( p_i \in (0,1] \), independently of previous attempts. If task \( i \) is attempted \( n_i \) times over some horizon, the number of successful completions \( K_i \) is binomial:

\[ K_i \sim \mathrm{Binomial}(n_i,p_i), \quad \mathbb{E}[K_i] = n_i p_i, \quad \mathbb{P}[K_i = n_i] = p_i^{n_i}. \]

These basic probabilistic models are later connected with motion and control to reason about the expected performance of a home robot over long periods.

Even though this course avoids full kinematic derivations, we can still model and analyze simple motion in a corridor or around a room using discrete-time linear systems.

Consider a robot moving along a straight line, with scalar position error \( e_k \) to a desired waypoint. Let the control input \( u_k \) be the commanded velocity. With discrete step size \( T_s > 0 \), an approximate model is

\[ e_{k+1} = e_k - T_s u_k. \]

A proportional controller uses \( u_k = K e_k \), where \( K > 0 \). Substituting into the dynamics gives

\[ e_{k+1} = e_k - T_s K e_k = (1 - T_s K) e_k. \]

This is a scalar linear system \( e_{k+1} = a e_k \) with \( a = 1 - T_s K \). From discrete-time linear control:

\[ \text{asymptotic stability} \iff |a| < 1. \]

Proposition. The closed-loop system is asymptotically stable if and only if

\[ 0 < T_s K < 2. \]

Proof. We have \( a = 1 - T_s K \). The condition \( |a| < 1 \) is equivalent to

\[ -1 < 1 - T_s K < 1. \]

Subtracting 1 throughout: \( -2 < - T_s K < 0 \), and multiplying by \( -1 \) reverses the inequalities: \( 0 < T_s K < 2 \), which proves the claim. \(\square\)

Physically, \( K \) cannot be arbitrarily large relative to the sampling time \( T_s \); otherwise, the robot will oscillate and overshoot, which in a home environment may lead to jerky motion and increased collision risk.

In vector form, if \( \mathbf{x}_k \) stacks positions and velocities along a corridor, we may approximate

\[ \mathbf{x}_{k+1} = \mathbf{A}\mathbf{x}_k + \mathbf{B}\mathbf{u}_k, \quad \mathbf{u}_k = -\mathbf{K}\mathbf{x}_k, \]

so the closed-loop system matrix is \( \mathbf{A}_{\mathrm{cl}} = \mathbf{A} - \mathbf{B}\mathbf{K} \). The domestic motion is stable if all eigenvalues of \( \mathbf{A}_{\mathrm{cl}} \) lie strictly inside the unit disk.

A typical home robot task is floor cleaning. From a geometric viewpoint, the environment can be discretized into \( M \) cells (grid squares). Let cell centers be \( \mathbf{p}_1,\dots,\mathbf{p}_M \in \mathbb{R}^2 \).

Define a binary indicator for whether cell \( j \) has been cleaned at or before step \( k \):

\[ c_j(k) = \begin{cases} 1 & \text{if cell } j \text{ has been visited by the cleaning head by step } k,\\ 0 & \text{otherwise.} \end{cases} \]

The coverage ratio is

\[ C(k) = \frac{1}{M} \sum_{j=1}^M c_j(k). \]

For deterministic coverage strategies, once a cell is cleaned it remains cleaned, so \( c_j(k+1) \geq c_j(k) \) and \( C(k) \) is non-decreasing in \( k \). If there is no re-soiling and the environment is fully reachable, then \( \lim_{k\to\infty} C(k) = 1 \).

The robot follows a path \( \mathbf{p}(0),\mathbf{p}(1),\dots \). A simple surrogate for energy consumption is the total path length:

\[ L(T) = \sum_{k=0}^{T-1} \left\|\mathbf{p}(k+1) - \mathbf{p}(k)\right\|_2. \]

This leads to a natural optimization problem: given a required coverage ratio \( C_{\min} \), find a path that minimizes total length:

\[ \min_{\mathbf{p}(0),\dots,\mathbf{p}(T)} L(T) \quad\text{s.t.}\quad C(T) \geq C_{\min},\quad \mathbf{p}(k+1) \in \mathcal{N}(\mathbf{p}(k)), \]

where \( \mathcal{N}(\mathbf{p}(k)) \) is the set of neighboring cells reachable in one step. This is a constrained combinatorial optimization problem related to Hamiltonian paths and traveling salesman tours on grid graphs; exact solutions are intractable for large environments, so practical home robots use heuristic strategies (lawnmower patterns, wall-following, randomized motion) that still achieve high coverage ratios with bounded expected time.

A robot deployed in a home is expected to operate for months or years. We therefore model not only control dynamics, but also reliability and availability.

A standard assumption in reliability engineering is an exponential time-to-failure distribution with rate \( \lambda > 0 \). If \( T \) is the random time to failure, then

\[ \mathbb{P}(T \leq t) = 1 - e^{-\lambda t},\quad R(t) = \mathbb{P}(T > t) = e^{-\lambda t}, \]

where \( R(t) \) is the reliability (survival probability) at time \( t \). The mean time to failure is \( \mathbb{E}[T] = 1/\lambda \).

Suppose a home robot executes cleaning cycles of duration \( T_c \). The probability that a full cycle completes without failure is

\[ R(T_c) = e^{-\lambda T_c}. \]

If each cycle achieves coverage \( C_c \) (e.g. \( 90\% \) of the floor), and the robot repeats the cycle \( n \) times before maintenance, the expected number of successful cycles is

\[ \mathbb{E}[N_{\mathrm{succ}}] = \sum_{k=1}^n \mathbb{P}(T > k T_c) = \sum_{k=1}^n e^{-\lambda k T_c} = e^{-\lambda T_c}\,\frac{1 - e^{-\lambda n T_c}}{1 - e^{-\lambda T_c}}. \]

The expected number of covered floors is then \( C_c \mathbb{E}[N_{\mathrm{succ}}] \). Designing servicing schedules (battery replacement, preventative maintenance) becomes a trade-off between \( \lambda \), \( T_c \), and user comfort.

Many home robots are organized around a finite-state machine (FSM) on top of continuous control. Typical high-level states include:

• Idle: wait for user command or schedule time.
• Navigate: move towards target region while avoiding obstacles.
• Clean: perform coverage motion in the current region.
• Dock: return to charging station when battery low.
• Error: stop and request human help.

We can represent this as a state machine where transitions are triggered by logical conditions such as “time to start cleaning”, “battery below threshold”, or “all cells in region covered”.

flowchart TD
  I["Idle"] -->|start command| N["Navigate to region"]
  N -->|arrived| C["Clean region"]
  C -->|region done & more regions| N
  C -->|all regions done| D["Dock"]
  N -->|battery low| D
  C -->|battery low| D
  D -->|fully charged & pending tasks| N
  D -->|no tasks| I
  N -->|obstacle not cleared| E["Error"]
  C -->|sensor fault| E
  D -->|dock not found| E
        

Each high-level state \( s_k \) (Idle, Navigate, etc.) is paired with an underlying continuous control law. For example, in Navigate, a discrete-time LTI controller drives the robot to a waypoint; in Clean, a coverage controller enforces wall-following or spiral patterns.

Let \( s_k \) denote the FSM state and \( \mathbf{x}_k \) the continuous state. A simple abstraction is:

\[ s_{k+1} = g(s_k,\mathbf{x}_k,\text{events}_k),\quad \mathbf{x}_{k+1} = f_{s_k}(\mathbf{x}_k,\mathbf{u}_k), \]

where \( f_{s_k} \) changes with the discrete state (different controller in each mode). This is a simple example of a hybrid system: discrete and continuous dynamics interacting.

We now show minimal software sketches implementing a discrete-time controller and FSM similar to the previous section. These examples are deliberately simple and do not depend on specific robotics middleware; in practice, home and service robots are often implemented using ROS 2: rclpy (Python) and rclcpp (C++), ROSJava bindings for Java, and the Robotics System Toolbox in MATLAB/Simulink.

7.1 Python: Discrete-Time Control and FSM Skeleton

import enum
import math

T_s = 0.1  # sampling time [s]
K_p = 1.0  # proportional gain (must satisfy 0 < T_s * K_p < 2)

class State(enum.Enum):
    IDLE = 0
    NAVIGATE = 1
    CLEAN = 2
    DOCK = 3
    ERROR = 4

class HomeRobotController:
    def __init__(self):
        self.state = State.IDLE
        self.position = 0.0     # 1D position along corridor
        self.goal = 0.0
        self.battery = 1.0      # normalized 0..1
        self.coverage = 0.0     # 0..1

    def set_cleaning_goal(self, goal_position):
        self.goal = goal_position
        if self.state == State.IDLE:
            self.state = State.NAVIGATE

    def low_battery(self):
        return self.battery < 0.2

    def step(self):
        """Single control step at rate 1/T_s."""
        if self.state == State.IDLE:
            # wait for command
            u = 0.0

        elif self.state == State.NAVIGATE:
            e = self.goal - self.position
            u = K_p * e
            # discrete-time position update: x_{k+1} = x_k + T_s * u_k
            self.position += T_s * u
            if abs(e) < 0.05:
                self.state = State.CLEAN
            if self.low_battery():
                self.state = State.DOCK

        elif self.state == State.CLEAN:
            # simple coverage model: increase coverage over time
            u = 0.2  # speed while cleaning
            self.coverage = min(1.0, self.coverage + 0.01)
            if self.coverage >= 0.99:
                self.state = State.DOCK
            if self.low_battery():
                self.state = State.DOCK

        elif self.state == State.DOCK:
            # navigate toward dock at position 0
            e = 0.0 - self.position
            u = K_p * e
            self.position += T_s * u
            if abs(e) < 0.05:
                # instant recharge for this toy model
                self.battery = 1.0
                if self.coverage >= 0.99:
                    self.state = State.IDLE
                else:
                    self.state = State.NAVIGATE

        else:  # ERROR
            u = 0.0

        # battery drains roughly proportional to |u|
        self.battery -= T_s * (0.01 + 0.02 * abs(u))
        self.battery = max(0.0, self.battery)

        return self.state, self.position, self.battery, self.coverage
      

7.2 C++: FSM and Discrete-Time Update

#include <iostream>
#include <cmath>

enum class State { IDLE, NAVIGATE, CLEAN, DOCK, ERROR };

struct HomeRobotController {
    double Ts{0.1};
    double Kp{1.0};
    State state{State::IDLE};
    double position{0.0};
    double goal{0.0};
    double battery{1.0};
    double coverage{0.0};

    bool lowBattery() const { return battery < 0.2; }

    void setCleaningGoal(double goal_pos) {
        goal = goal_pos;
        if (state == State::IDLE) {
            state = State::NAVIGATE;
        }
    }

    void step() {
        double u = 0.0;

        switch (state) {
        case State::IDLE:
            u = 0.0;
            break;

        case State::NAVIGATE: {
            double e = goal - position;
            u = Kp * e;
            position += Ts * u;
            if (std::abs(e) < 0.05) {
                state = State::CLEAN;
            }
            if (lowBattery()) {
                state = State::DOCK;
            }
            break;
        }
        case State::CLEAN:
            u = 0.2;
            coverage = std::min(1.0, coverage + 0.01);
            if (coverage >= 0.99) {
                state = State::DOCK;
            }
            if (lowBattery()) {
                state = State::DOCK;
            }
            break;

        case State::DOCK: {
            double e = 0.0 - position;
            u = Kp * e;
            position += Ts * u;
            if (std::abs(e) < 0.05) {
                battery = 1.0;
                if (coverage >= 0.99) {
                    state = State::IDLE;
                } else {
                    state = State::NAVIGATE;
                }
            }
            break;
        }
        case State::ERROR:
            u = 0.0;
            break;
        }

        battery -= Ts * (0.01 + 0.02 * std::abs(u));
        if (battery < 0.0) battery = 0.0;
    }
};
      

7.3 Java: Object-Oriented FSM

public class HomeRobotController {
    enum State { IDLE, NAVIGATE, CLEAN, DOCK, ERROR }

    private double Ts = 0.1;
    private double Kp = 1.0;
    private State state = State.IDLE;
    private double position = 0.0;
    private double goal = 0.0;
    private double battery = 1.0;
    private double coverage = 0.0;

    public void setCleaningGoal(double goalPos) {
        goal = goalPos;
        if (state == State.IDLE) {
            state = State.NAVIGATE;
        }
    }

    private boolean lowBattery() {
        return battery < 0.2;
    }

    public void step() {
        double u = 0.0;

        switch (state) {
            case IDLE:
                u = 0.0;
                break;
            case NAVIGATE:
                double e = goal - position;
                u = Kp * e;
                position += Ts * u;
                if (Math.abs(e) < 0.05) {
                    state = State.CLEAN;
                }
                if (lowBattery()) {
                    state = State.DOCK;
                }
                break;
            case CLEAN:
                u = 0.2;
                coverage = Math.min(1.0, coverage + 0.01);
                if (coverage >= 0.99) {
                    state = State.DOCK;
                }
                if (lowBattery()) {
                    state = State.DOCK;
                }
                break;
            case DOCK:
                double ed = 0.0 - position;
                u = Kp * ed;
                position += Ts * u;
                if (Math.abs(ed) < 0.05) {
                    battery = 1.0;
                    if (coverage >= 0.99) {
                        state = State.IDLE;
                    } else {
                        state = State.NAVIGATE;
                    }
                }
                break;
            case ERROR:
                u = 0.0;
                break;
        }

        battery -= Ts * (0.01 + 0.02 * Math.abs(u));
        if (battery < 0.0) battery = 0.0;
    }
}
      

7.4 MATLAB/Simulink: Script-Level Discrete-Time Update

In MATLAB, Simulink models of such a controller can be constructed with Discrete-Time Integrator, Stateflow (for the FSM), and lookup or function blocks. The following script shows the same update law as a MATLAB function that can be used inside a MATLAB Function block in Simulink.

function [state, position, battery, coverage] = ...
    home_robot_step(state, position, goal, battery, coverage)

% States encoded as integers for simplicity
IDLE = 0; NAVIGATE = 1; CLEAN = 2; DOCK = 3; ERROR = 4;

Ts = 0.1;
Kp = 1.0;

u = 0.0;

lowBattery = (battery < 0.2);

switch state
    case IDLE
        % wait for external logic to set state to NAVIGATE
        u = 0.0;

    case NAVIGATE
        e = goal - position;
        u = Kp * e;
        position = position + Ts * u;
        if abs(e) < 0.05
            state = CLEAN;
        end
        if lowBattery
            state = DOCK;
        end

    case CLEAN
        u = 0.2;
        coverage = min(1.0, coverage + 0.01);
        if coverage >= 0.99
            state = DOCK;
        end
        if lowBattery
            state = DOCK;
        end

    case DOCK
        e = 0.0 - position;
        u = Kp * e;
        position = position + Ts * u;
        if abs(e) < 0.05
            battery = 1.0;
            if coverage >= 0.99
                state = IDLE;
            else
                state = NAVIGATE;
            end
        end

    case ERROR
        u = 0.0;
end

battery = battery - Ts * (0.01 + 0.02 * abs(u));
battery = max(0.0, battery);
      

In Simulink, one would typically implement the finite-state logic using Stateflow, with transitions conditioned on inequalities such as battery < 0.2 and abs(e) < 0.05, and connect continuous-time or discrete-time control blocks for each mode.

In this lesson we treated home and service robots as control systems executing recurring service tasks in human-centered environments. We defined task-level service metrics, coverage ratios, and reliability measures, and related them to simple discrete-time LTI models appropriate for domestic motion. We also introduced hybrid control via finite-state machines layered on continuous controllers and showed how small Python, C++, Java, and MATLAB/Simulink programs can realize such logic. These ideas prepare you to critically analyze case studies across manufacturing, healthcare, exploration, and environmental monitoring in the rest of this chapter.