In HRI, usability captures how easily a human can achieve a task with a robot, while human factors study the physical, cognitive, and organizational constraints of humans interacting with technical systems. A standard (ISO 9241-11) perspective decomposes usability into:

• Effectiveness — probability of successfully completing the task.
• Efficiency — resources (time, effort) used per successful task.
• Satisfaction — subjective comfort and acceptability.

We can package objective and subjective usability measures into a vector \( \mathbf{u} \in \mathbb{R}^m \), where each component corresponds to a dimension (e.g. task time, error rate, workload score). A simple scalar usability index is a weighted sum:

\[ U = \sum_{k=1}^{m} w_k\,u_k, \quad w_k \ge 0,\ \sum_{k=1}^{m} w_k = 1. \]

In design, we choose interface parameters (button size, robot speed, information density, etc.) to maximize \( U \), subject to physical and safety constraints. Importantly, \( U \) depends jointly on the human, the robot, the interface, and the task context.

flowchart TD
  T["Task and context"] --> H["Human operator"]
  H --> I["Interface (display and controls)"]
  I --> C["Robot controller software"]
  C --> R["Robot body and actuators"]
  R --> E["Environment"]
  E --> S["Robot sensors"]
  S --> C
  E --> FB["Perceptual feedback to human"]
  C --> M["Performance metrics \n(time, errors, workload)"]
        

The diagram highlights that the human is an integral part of the control loop. Human factors quantify the human node (limits, variability) and feed into quantitative design of the interface and robot behavior.

When a human points at a target using a joystick, touchscreen, or collaborative robot handle, the movement time depends on the distance to the target and its size. Fitts's law models this as

\[ MT = a + b \cdot ID, \quad ID = \log_2\!\left(1 + \frac{D}{W}\right), \]

where:

• \( MT \): average movement time (seconds),
• \( D \): distance (or amplitude) of movement,
• \( W \): target width (tolerance region),
• \( ID \): index of difficulty (bits),
• \( a, b \): empirically fitted constants.

The logarithmic \( ID \) comes from an information-theoretic argument. Consider the ratio \( D/W \) as the number of distinguishable positions along the movement axis. If the motor system transmits information with approximate capacity \( C \) bits/s, one movement conveys \( ID \) bits and takes on average

\[ MT \approx \frac{ID}{C}. \]

Allowing for initiation and termination overhead yields the affine law \( MT = a + b\cdot ID \), with \( b \approx 1/C \).

2.1 Effective Index of Difficulty and Throughput

Real users sometimes miss the target, giving a distribution of endpoints with standard deviation \( \sigma_x \). A common “effective” target width is

\[ W_e = 4.133\,\sigma_x, \quad ID_e = \log_2\!\left(1 + \frac{D}{W_e}\right). \]

Here \( W_e \) corresponds to a span covering roughly 96% of endpoints under a normal approximation. Over a sequence of \( N \) trials with effective indices \( ID_{e,i} \) and movement times \( MT_i \), we define the throughput:

\[ TP = \frac{\displaystyle\sum_{i=1}^{N} ID_{e,i}} {\displaystyle\sum_{i=1}^{N} MT_i} \quad [\text{bits/s}]. \]

In HRI experiments, higher \( TP \) indicates that a human can communicate more “bits” of movement information per second to the robot. Interface designs (e.g. handle stiffness, scaling between hand motion and robot motion) can be compared by their throughput while controlling for safety constraints.

When the human must select among discrete robot commands (buttons, voice commands, gestures), the reaction time increases with the number and distribution of alternatives. Hick–Hyman law models reaction time as linear in the information of the choice.

\[ H = -\sum_{i=1}^{n} p_i \log_2 p_i, \quad RT = a + b\,H, \]

where:

• \( p_i \): probability of choosing option \( i \),
• \( H \): entropy (bits) of the command set,
• \( RT \): mean reaction time (seconds),
• \( a, b \): fitted constants.

For equally likely commands \( p_i = 1/n \), entropy simplifies to

\[ H = \log_2 n, \quad RT = a + b \log_2 n. \]

For HRI interface design, this suggests:

• Grouping commands into hierarchical menus to reduce entropy per step.
• Making frequent actions more salient, effectively increasing their \( p_i \), lowering entropy.
• Limiting the number of simultaneously visible choices when rapid response is critical.

Hick–Hyman and Fitts's laws together quantify the cognitive and motor components of interaction time, and can be combined into overall task-time models for HRI tasks.

Beyond time and accuracy, usability depends on workload and physical comfort. Psychometric instruments such as NASA-TLX produce subscale scores \( s_k \) (mental demand, physical demand, temporal demand, etc.) that we can combine linearly:

\[ WL = \sum_{k=1}^{m} w_k s_k, \]

where \( s_k \) are typically normalized to \([0,1]\) or \([0,100]\). Given data from \( N \) experiments, we can estimate the weights \( w_k \) by solving a constrained least squares problem:

\[ \mathbf{w}^\star = \arg\min_{\mathbf{w}} \bigl\|\mathbf{S}\mathbf{w} - \mathbf{y}\bigr\|_2^2, \quad \sum_{k} w_k = 1,\ w_k \ge 0, \]

where \( \mathbf{S} \in \mathbb{R}^{N \times m} \) contains the subscale scores and \( \mathbf{y} \in \mathbb{R}^N \) a global workload judgment.

4.1 Physical Ergonomics via Torque-Based Costs

Consider a human physically guiding a collaborative arm. Let \( \mathbf{q} \) be the human joint angles and \( \boldsymbol{\tau}_h(\mathbf{q}) \) the required joint torques to apply a certain handle force (from inverse dynamics or a simplified static model). A common ergonomic cost is quadratic:

\[ J_{\text{posture}}(\mathbf{q}) = \boldsymbol{\tau}_h(\mathbf{q})^{\top} Q\, \boldsymbol{\tau}_h(\mathbf{q}), \]

where \( Q \succeq 0 \) weights joints by importance or tolerance. Hard constraints ensure torques remain within safe limits:

\[ \left|\tau_{h,i}(\mathbf{q})\right| \le \tau_i^{\max}, \quad i=1,\dots,p. \]

Minimizing \( J_{\text{posture}} \) over feasible postures yields “comfortable” handle positions and robot configurations. Because you know linear-quadratic cost functions from control, you can interpret \( J_{\text{posture}} \) as a purely human-side quadratic penalty in an optimal control problem for HRI.

From a control perspective, the human behaves like a dynamic controller in series with the robot plant. For a single controlled degree of freedom (e.g. Cartesian position along a line), we can write:

\[ G(s) = \frac{K_r}{T_r s + 1} \quad \text{(robot plant)}, \\ H(s) = K_h e^{-sT_d} \quad \text{(human neuromuscular and cognitive response)}, \]

where:

• \( K_r \): robot gain, \( T_r \): robot time constant;
• \( K_h \): effective human gain (sensitivity),
• \( T_d \): reaction delay combining perception and decision-making.

The open-loop and closed-loop transfer functions are

\[ L(s) = H(s)G(s), \qquad T(s) = \frac{L(s)}{1 + L(s)}. \]

To use standard linear analysis, approximate the delay with a first-order Padé approximation:

\[ e^{-sT_d} \approx \frac{1 - \frac{sT_d}{2}}{1 + \frac{sT_d}{2}}, \quad H(s) \approx K_h \frac{1 - \frac{sT_d}{2}}{1 + \frac{sT_d}{2}}. \]

Increasing cognitive load (more complex displays, high entropy command sets) typically increases \( T_d \) and may reduce \( K_h \). In Bode plot terms:

• The delay adds approximately \(-\omega T_d\) radians of phase lag at frequency \( \omega \).
• A larger \( T_d \) reduces phase margin for the same crossover frequency.
• To maintain a desired phase margin, one can reduce \( K_r \) (robot gain) or bandwidth.

Thus, usability constraints (low cognitive load) and control constraints (stability margin) are tightly coupled. A “too aggressive” robot controller can become unstable once realistic human delays are included, especially under stress or multitasking.

Consider a mobile robot approaching a human to hand over an object. We want the approach to feel fast (good usability) but also safe. Assume:

• The robot moves at constant speed \( v \) toward the human.
• The human needs reaction time \( t_r \) to start moving away or braking the robot (e.g. emergency stop button).
• The robot can decelerate with maximum magnitude \( a_{\max} \).
• The minimum separation for safety is \( d_{\text{safe}} \).

A simple 1D stopping-distance model gives

\[ d_{\text{stop}}(v) = v\,t_r + \frac{v^2}{2 a_{\max}}. \]

Safety requires \( d_{\text{stop}}(v) \le d_{\text{safe}} \). Solving for the maximum allowable speed \( v_{\max} \) yields:

\[ v_{\max} = -a_{\max} t_r + \sqrt{a_{\max}^2 t_r^2 + 2 a_{\max} d_{\text{safe}}}. \]

The reaction time \( t_r \) itself can be estimated from Hick–Hyman law. For example, with equally likely \( n \) emergency responses (different stop buttons, voice commands, gestures),

\[ t_r = a + b \log_2 n. \]

Hence, adding more emergency options (increasing \( n \)) or making them harder to discriminate increases \( t_r \) and shrinks \( v_{\max} \). Usability (fast reaction, low entropy) and safety (small stopping distance) must therefore be designed jointly.

flowchart TD
  A["Specify task and safety distance d_safe"] --> B["Estimate reaction time t_r via experiments or Hick-Hyman law"]
  B --> C["Compute v_max from stopping-distance inequality"]
  C --> D["Choose commanded speed v <= v_max"]
  D --> E["Run user study: measure comfort, workload, performance"]
  E --> F["Iterate on interface design and controller gains"]
        

In practice, HRI experiments log data (e.g. via ROS/ROS 2 topics) and then compute Fitts's throughput, Hick–Hyman reaction times, and safe approach speeds offline. Below we show minimal implementations in Python, C++, Java, and MATLAB that could be embedded in robotics analysis tools or lightweight controller nodes.

7.1 Python Implementation

import numpy as np

# In a real robot stack, these functions operate on logs from a ROS node
# that records target distances, widths, and timestamps.

def shannon_id(D, W):
    """Index of difficulty ID = log2(1 + D/W)."""
    D = np.asarray(D, dtype=float)
    W = np.asarray(W, dtype=float)
    return np.log2(1.0 + D / W)

def fitts_mt(D, W, a, b):
    ID = shannon_id(D, W)
    return a + b * ID

def throughput(ID, MT):
    """Throughput TP = sum(ID) / sum(MT)."""
    ID = np.asarray(ID, dtype=float)
    MT = np.asarray(MT, dtype=float)
    return ID.sum() / MT.sum()

def hick_rt(probs, a, b):
    """Reaction time RT = a + b * H, H = -sum p log2 p."""
    p = np.asarray(probs, dtype=float)
    p = p / p.sum()
    H = -(p * np.log2(p)).sum()
    return a + b * H

def safe_velocity(t_r, a_max, d_safe):
    """
    Solve v^2/(2 a_max) + t_r v - d_safe = 0 for v >= 0.
    Returns the smaller non-negative root (the safety-bound speed).
    """
    A = 1.0 / (2.0 * a_max)
    B = t_r
    C = -d_safe
    disc = B**2 - 4.0 * A * C
    if disc < 0.0:
        return 0.0
    v1 = (-B + np.sqrt(disc)) / (2.0 * A)
    v2 = (-B - np.sqrt(disc)) / (2.0 * A)
    candidates = [v for v in (v1, v2) if v >= 0.0]
    return min(candidates) if candidates else 0.0

if __name__ == "__main__":
    # Example: three pointing tasks
    D = np.array([0.20, 0.30, 0.40])  # meters
    W = np.array([0.04, 0.05, 0.06])  # meters
    MT = np.array([0.45, 0.50, 0.55])  # seconds
    ID = shannon_id(D, W)
    TP = throughput(ID, MT)
    print("Throughput [bits/s]:", TP)

    # Example: four commands with different probabilities
    probs = np.array([0.4, 0.3, 0.2, 0.1])
    rt = hick_rt(probs, a=0.25, b=0.15)
    print("Reaction time [s]:", rt)

    # Safe approach speed based on that reaction time
    a_max = 3.0   # m/s^2
    d_safe = 1.5  # m
    v_max = safe_velocity(rt, a_max, d_safe)
    print("Max safe approach speed [m/s]:", v_max)
      

7.2 C++ Implementation (Library-Free Core)

#include <vector>
#include <cmath>

// These functions could be called inside a ROS2 rclcpp node
// that subscribes to interaction logs and publishes usability metrics.

double shannonID(double D, double W) {
    return std::log2(1.0 + D / W);
}

double fittsMT(double D, double W, double a, double b) {
    return a + b * shannonID(D, W);
}

double throughput(const std::vector<double>& IDs,
                  const std::vector<double>& MTs) {
    double sumID = 0.0;
    double sumMT = 0.0;
    for (std::size_t i = 0; i < IDs.size(); ++i) {
        sumID += IDs[i];
        sumMT += MTs[i];
    }
    return sumID / sumMT;
}

double safeVelocity(double t_r, double a_max, double d_safe) {
    // Solve v^2/(2 a_max) + t_r v - d_safe = 0 for v >= 0.
    double A = 1.0 / (2.0 * a_max);
    double B = t_r;
    double C = -d_safe;
    double disc = B*B - 4.0*A*C;
    if (disc < 0.0) return 0.0;
    double sqrt_disc = std::sqrt(disc);
    double v1 = (-B + sqrt_disc) / (2.0 * A);
    double v2 = (-B - sqrt_disc) / (2.0 * A);
    double v = 1e9;
    if (v1 >= 0.0 && v1 < v) v = v1;
    if (v2 >= 0.0 && v2 < v) v = v2;
    if (v == 1e9) v = 0.0;
    return v;
}

int main() {
    std::vector<double> IDs{shannonID(0.2, 0.04),
                             shannonID(0.3, 0.05),
                             shannonID(0.4, 0.06)};
    std::vector<double> MTs{0.45, 0.50, 0.55};
    double TP = throughput(IDs, MTs);

    double t_r = 0.4;   // example reaction time [s]
    double a_max = 3.0; // m/s^2
    double d_safe = 1.5;
    double v_max = safeVelocity(t_r, a_max, d_safe);

    // In a real node, print or publish TP and v_max.
    return 0;
}
      

7.3 Java Implementation

public class HriMetrics {

    public static double shannonID(double D, double W) {
        return (Math.log(1.0 + D / W) / Math.log(2.0));
    }

    public static double fittsMT(double D, double W, double a, double b) {
        return a + b * shannonID(D, W);
    }

    public static double throughput(double[] IDs, double[] MTs) {
        double sumID = 0.0;
        double sumMT = 0.0;
        for (int i = 0; i < IDs.length; ++i) {
            sumID += IDs[i];
            sumMT += MTs[i];
        }
        return sumID / sumMT;
    }

    public static double safeVelocity(double t_r, double a_max, double d_safe) {
        // Solve v^2/(2 a_max) + t_r v - d_safe = 0 for v >= 0.
        double A = 1.0 / (2.0 * a_max);
        double B = t_r;
        double C = -d_safe;
        double disc = B*B - 4.0*A*C;
        if (disc < 0.0) return 0.0;
        double sqrt_disc = Math.sqrt(disc);
        double v1 = (-B + sqrt_disc) / (2.0 * A);
        double v2 = (-B - sqrt_disc) / (2.0 * A);
        double v = Double.POSITIVE_INFINITY;
        if (v1 >= 0.0 && v1 < v) v = v1;
        if (v2 >= 0.0 && v2 < v) v = v2;
        if (Double.isInfinite(v)) v = 0.0;
        return v;
    }

    public static void main(String[] args) {
        double[] IDs = new double[] {
            shannonID(0.2, 0.04),
            shannonID(0.3, 0.05),
            shannonID(0.4, 0.06)
        };
        double[] MTs = new double[] {0.45, 0.50, 0.55};
        double TP = throughput(IDs, MTs);

        double t_r = 0.4;
        double a_max = 3.0;
        double d_safe = 1.5;
        double v_max = safeVelocity(t_r, a_max, d_safe);

        // In an Android or Java-based HRI dashboard, display TP and v_max.
    }
}
      

7.4 MATLAB / Simulink Implementation

function hri_metrics_demo()
    % Compute Fitts throughput, Hick-Hyman RT, and safe approach speed.
    % In Simulink, the same equations can be implemented using basic math blocks.

    % Example pointing data
    D = [0.20 0.30 0.40];   % meters
    W = [0.04 0.05 0.06];   % meters
    MT = [0.45 0.50 0.55];  % seconds

    ID = log2(1 + D ./ W);
    TP = sum(ID) / sum(MT);

    % Hick-Hyman reaction time with non-uniform probabilities
    p = [0.4 0.3 0.2 0.1];
    p = p / sum(p);
    H = -sum(p .* log2(p));
    a = 0.25; b = 0.15;
    t_r = a + b * H;

    % Safe approach speed
    a_max = 3.0;   % m/s^2
    d_safe = 1.5;  % m
    [v_max] = safe_velocity(t_r, a_max, d_safe);

    fprintf('Throughput TP = %.3f bits/s\n', TP);
    fprintf('Reaction time t_r = %.3f s\n', t_r);
    fprintf('Max safe speed v_max = %.3f m/s\n', v_max);

    % Control-style human-in-the-loop model (for Simulink)
    K_r = 1; T_r = 0.5;
    K_h = 1; T_d = 0.3;
    s = tf('s');
    G = K_r / (T_r * s + 1);
    Hs = K_h * (1 - s*T_d/2) / (1 + s*T_d/2); % Pade approximation of delay
    T_closed = feedback(G*Hs, 1);
    disp('Closed-loop poles with human in the loop:');
    disp(pole(T_closed));
end

function v_max = safe_velocity(t_r, a_max, d_safe)
    % Solve v^2/(2 a_max) + t_r v - d_safe = 0 for smallest v >= 0.
    A = 1.0 / (2.0 * a_max);
    B = t_r;
    C = -d_safe;
    disc = B^2 - 4*A*C;
    if disc < 0
        v_max = 0.0;
        return;
    end
    v1 = (-B + sqrt(disc)) / (2*A);
    v2 = (-B - sqrt(disc)) / (2*A);
    candidates = [v1 v2];
    candidates = candidates(candidates >= 0);
    if isempty(candidates)
        v_max = 0.0;
    else
        v_max = min(candidates);
    end
end
      

In Simulink, you can create a block diagram equivalent of the MATLAB transfer-function model for \( T_{\text{closed}}(s) \), and then tune \( K_r \), \( K_h \), and \( T_d \) to meet desired bandwidth and stability margins while considering realistic human delays.

In this lesson we formalized usability and human factors in HRI using mathematical models of human performance. Fitts's law and Hick–Hyman law quantify motor and decision components of interaction time, while workload and ergonomic cost functions encode subjective and physical comfort. Using your background in linear control, we interpreted the human as a dynamic controller in a feedback loop with the robot, and we analyzed how reaction delays and gains affect stability margins. A safety-constrained approach-speed example illustrated how human performance models directly shape robot velocity limits. The multi-language code examples showed how these metrics can be computed from experimental data and integrated into a robotics software stack.