A prototype robot is usually built to answer technical questions (Can it work? Does the control concept stabilize the system? Can the sensors see the target objects?). Its performance is evaluated qualitatively and quantitatively, but reliability, manufacturability, and cost are secondary.

A product must satisfy:

• Quantified performance requirements (e.g., payload, speed, accuracy, cycle time).
• Reliability and safety constraints over long horizons (thousands of hours).
• Manufacturing, test, and maintenance processes that are repeatable.
• Regulatory / standards constraints and documentation.
• Target cost at volume, including fixed and variable costs.

The transition from prototype to product is therefore a system-level optimization problem constrained by physics, control, safety, and economics.

flowchart TD
  P["Functional prototype"] --> RQ["Refine requirements and metrics"]
  RQ --> TS["Trade studies (actuators, sensors, structure)"]
  TS --> DF["Design freeze: \nmechanics and electronics"]
  TS --> SF["Design freeze: \nsoftware and control"]
  DF --> V["Verification tests vs. specifications"]
  SF --> V
  V --> VAL["Validation in target environment"]
  VAL --> CERT["Compliance and standards review"]
  CERT --> PM["Pilot manufacturing and test"]
  PM --> RAMP["Full-scale product deployment"]
        

In what follows, we will build mathematical tools for reliability, tolerances, and cost that support decisions at each stage of this flow.

Let \( T_f \) be the random time to failure of a robot (or a specific subsystem). The reliability function is

\[ R(t) = \mathbb{P}(T_f > t), \quad t \ge 0. \]

A common simplifying assumption for early design phases is a constant failure rate \( \lambda > 0 \), leading to an exponential model:

\[ R(t) = \exp(-\lambda t), \quad f_T(t) = \lambda \exp(-\lambda t). \]

The mean time between failures (MTBF) for this model is

\[ \operatorname{MTBF} = \int_0^{\infty} R(t)\,\mathrm{d}t = \int_0^{\infty} \exp(-\lambda t)\,\mathrm{d}t = \frac{1}{\lambda}. \]

2.1 Series and Parallel Subsystem Reliability

Consider a robot composed of \( n \) independent subsystems with reliabilities \( R_1(t),\dots,R_n(t) \).

• Series configuration (all must work): the system fails if any subsystem fails,

  \[ R_{\text{series}}(t) = \prod_{i=1}^{n} R_i(t). \]

• Parallel configuration (at least one path works): e.g. redundant sensors,

  \[ R_{\text{parallel}}(t) = 1 - \prod_{i=1}^{n} \bigl(1 - R_i(t)\bigr). \]

For constant failure rates \( \lambda_i \) and exponential lifetimes, \( R_i(t) = \exp(-\lambda_i t) \), the series reliability becomes

\[ R_{\text{series}}(t) = \exp\!\left(-\sum_{i=1}^{n} \lambda_i t\right) = \exp(-\lambda_{\text{eq}} t), \quad \lambda_{\text{eq}} = \sum_{i=1}^{n} \lambda_i. \]

2.2 Meeting System-Level Reliability Targets

Suppose the product requirement specifies a system reliability \( R_{\text{sys}}(T_m) \ge R_{\text{target}} \) at mission duration \( T_m \). For a series system with constant rates \( \lambda_i \) this yields

\[ R_{\text{sys}}(T_m) = \exp\!\left(-\sum_{i=1}^{n}\lambda_i T_m\right) \ge R_{\text{target}}. \]

Taking logarithms (note \( 0 < R_{\text{target}} \le 1 \)) gives

\[ \sum_{i=1}^{n}\lambda_i \le -\frac{1}{T_m} \ln\bigl(R_{\text{target}}\bigr). \]

If all \( n \) subsystems are designed to be statistically identical with \( \lambda_i = \lambda_c \), then

\[ \lambda_c \le -\frac{1}{n T_m}\ln\bigl(R_{\text{target}}\bigr), \]

which directly translates a product-level requirement into a per-component reliability requirement used in component selection and testing.

flowchart LR
  S1["Series: component 1"] --> S2["Series: component 2"] --> S3["Series: component 3"]
  P1["Parallel: component A"] --> PJ["Redundant branch"]
  P2["Parallel: component B"] --> PJ
  PJ --> LOAD["System load"]
        

Series chains dominate industrial manipulators (joint drives, power, controller, safety circuits), whereas parallel structures arise in redundancy (dual encoders, dual network links, redundant power supplies).

Moving from prototype to product requires guaranteeing that performance specifications are satisfied for all units despite manufacturing tolerances and component variation. Let \( p \in \mathbb{R}^m \) denote a vector of uncertain parameters (e.g., motor torque constants, friction coefficients, sensor gains).

Let \( Y(p) \) be a scalar performance metric such as steady-state tracking error or maximum payload. Near a nominal design \( p_{\text{nom}} \), we can approximate \( Y(p) \) via first-order Taylor expansion:

\[ Y(p) \approx Y(p_{\text{nom}}) + \nabla Y(p_{\text{nom}})^{\top} (p - p_{\text{nom}}). \]

Assume each parameter varies in a bounded interval \( |p_i - p_{\text{nom},i}| \le \Delta p_i \). A conservative lower bound on performance is then

\[ Y_{\min} \approx Y(p_{\text{nom}}) - \sum_{i=1}^{m} \left|\frac{\partial Y}{\partial p_i}(p_{\text{nom}})\right| \Delta p_i. \]

To guarantee the specification \( Y_{\min} \ge Y_{\text{spec}} \), we must choose \( p_{\text{nom}} \) and tolerances \( \Delta p_i \) such that

\[ Y(p_{\text{nom}}) - Y_{\text{spec}} \ge \sum_{i=1}^{m} \left|\frac{\partial Y}{\partial p_i}(p_{\text{nom}})\right| \Delta p_i. \]

The left-hand side is the design margin; the right-hand side is the worst-case loss due to parameter variation. This inequality quantifies how much margin is needed before freezing the design.

3.1 Connection to Linear Control Design

Because you have studied linear control, you can relate margin-based design to familiar concepts. For a single-input single-output linear closed-loop system with characteristic polynomial \( a(s,\theta) \) depending on an uncertain parameter \( \theta \), we may require that all closed-loop poles satisfy \( \operatorname{Re}(s_k(\theta)) \le -\sigma_{\min} \) for all \( \theta \) in a specified interval. The distance \( \sigma_{\min} \) between the poles and the imaginary axis is again a margin that must exceed the worst-case shift caused by parameter variation.

In practice, engineers often translate this into requirements on phase margin and gain margin, and then add additional safety factors before design freeze to account for unmodelled dynamics and manufacturing spread.

When scaling to production, every mechanical dimension, sensor threshold, or calibration parameter is subject to variation. Yield is the probability that a randomly manufactured unit passes all dimensional and functional tests.

4.1 Tolerance Stack-Up Model

Consider a linear chain of independent dimensions in a robotic joint:

• \( d_1 \): shaft length (nominal \( \mu_1 \), std. dev. \( \sigma_1 \)).
• \( d_2 \): bearing thickness (nominal \( \mu_2 \), std. dev. \( \sigma_2 \)).
• \( d_3 \): spacer thickness (nominal \( \mu_3 \), std. dev. \( \sigma_3 \)).

The critical assembled dimension is \( D = d_1 + d_2 + d_3 \). If each \( d_i \sim \mathcal{N}(\mu_i,\sigma_i^2) \) independently, then

\[ D \sim \mathcal{N}\bigl(\mu_D,\sigma_D^2\bigr), \quad \mu_D = \sum_{i=1}^{3} \mu_i, \quad \sigma_D^2 = \sum_{i=1}^{3} \sigma_i^2. \]

Suppose the functional requirement is that \( D \) must lie in \( [L,U] \) to guarantee that the bearing preload and backlash remain within limits. The manufacturing yield with respect to this single constraint is

\[ Y = \mathbb{P}(L \le D \le U) = \Phi\!\left(\frac{U - \mu_D}{\sigma_D}\right) - \Phi\!\left(\frac{L - \mu_D}{\sigma_D}\right), \]

where \( \Phi \) is the standard normal cumulative distribution function.

4.2 Multiple Constraints and Overall Yield

If there are several independent pass/fail criteria \( C_1, \dots, C_k \) with yields \( Y_j = \mathbb{P}(C_j \text{ satisfied}) \) and if they can be treated as approximately independent, then the overall yield is

\[ Y_{\text{overall}} \approx \prod_{j=1}^{k} Y_j. \]

This multiplicative structure makes clear why apparently minor tolerances or test limits become critical in high-volume products: small degradations in each individual yield multiply into substantial loss at system level.

Let us decompose the cost of producing a robot product:

• \( F \): fixed non-recurring engineering (NRE) cost (design, tooling, certification).
• \( c_v \): variable manufacturing cost per attempted unit (materials, assembly labor).
• \( c_o \): overhead per shipped unit (packaging, logistics, support).
• \( Y \): overall manufacturing and test yield.

If \( N \) units are shipped, then on average \( N/Y \) units must be built. An approximate cost per shipped unit is

\[ c_{\text{unit}}(N) = \frac{F}{N} + \frac{c_v}{Y} + c_o. \]

The derivative with respect to \( N \) is

\[ \frac{\mathrm{d}c_{\text{unit}}}{\mathrm{d}N} = -\frac{F}{N^2} \le 0, \]

so unit cost decreases monotonically with production volume as the fixed cost is amortized.

5.1 Choosing Between Alternative Designs

Consider two alternative designs A and B with parameters \( (F_A,c_{v,A},c_{o,A},Y_A) \) and \( (F_B,c_{v,B},c_{o,B},Y_B) \). The unit costs are

\[ c_A(N) = \frac{F_A}{N} + \frac{c_{v,A}}{Y_A} + c_{o,A}, \quad c_B(N) = \frac{F_B}{N} + \frac{c_{v,B}}{Y_B} + c_{o,B}. \]

The break-even volume \( N^{\ast} \) at which both have equal cost solves

\[ c_A(N^{\ast}) = c_B(N^{\ast}) \quad \Rightarrow \quad N^{\ast} = \frac{F_A - F_B} {\left(\frac{c_{v,B}}{Y_B} + c_{o,B}\right) - \left(\frac{c_{v,A}}{Y_A} + c_{o,A}\right)}. \]

When \( N^{\ast} \) is smaller than the expected market volume, it may be worth investing in a higher fixed-cost, lower variable-cost design (e.g., custom motor, custom casting). Otherwise, a design with low NRE but higher per-unit cost becomes attractive.

The following snippets illustrate how reliability and cost formulas can be embedded into engineering tools and test scripts. In a real product, such computations would feed into dashboards, automated reports, or continuous integration pipelines for the robot.

6.1 Python: Reliability and Break-Even Volume

import math

def series_reliability(lambdas, t):
    """
    lambdas: iterable of constant failure rates [1/h]
    t: mission time [h]
    """
    lam_eq = sum(lambdas)
    return math.exp(-lam_eq * t)

def parallel_reliability(lambdas, t):
    """
    Parallel system of independent exponential components.
    """
    # Probability each component fails by time t
    fail_probs = [1.0 - math.exp(-lam * t) for lam in lambdas]
    system_fail = 1.0
    for q in fail_probs:
        system_fail *= q
    return 1.0 - system_fail

def max_component_lambda(R_target, t, n):
    """
    Maximum allowable constant failure rate for n identical
    series components achieving R_target at time t.
    """
    if R_target <= 0.0 or R_target >= 1.0:
        raise ValueError("R_target must be in (0, 1)")
    lam_eq = -math.log(R_target) / t
    return lam_eq / n

def unit_cost(F, c_v, c_o, Y, N):
    """
    Unit cost model c_unit(N) = F/N + c_v/Y + c_o.
    """
    return F / N + c_v / Y + c_o

if __name__ == "__main__":
    # Example: 3 components in series, 1000 h mission
    lam = [1e-4, 2e-4, 1.5e-4]
    t_mission = 1000.0
    R_ser = series_reliability(lam, t_mission)
    R_par = parallel_reliability([1e-4, 1e-4], t_mission)
    print("Series reliability at 1000 h:", R_ser)
    print("Parallel redundancy (2 identical) at 1000 h:", R_par)

    # Cost comparison of designs A and B
    F_A, cA, Y_A, c_oA = 5e4, 250.0, 0.95, 40.0
    F_B, cB, Y_B, c_oB = 1.5e4, 280.0, 0.98, 35.0
    N = 2000
    print("c_A(N):", unit_cost(F_A, cA, c_oA, Y_A, N))
    print("c_B(N):", unit_cost(F_B, cB, c_oB, Y_B, N))
      

6.2 C++: Series Reliability Utility

#include <iostream>
#include <vector>
#include <cmath>

double seriesReliability(const std::vector<double> &lambdas, double t) {
    double lam_sum = 0.0;
    for (double lam : lambdas) {
        lam_sum += lam;
    }
    return std::exp(-lam_sum * t);
}

int main() {
    std::vector<double> lambdas{1e-4, 2e-4, 1.5e-4};
    double t = 1000.0;
    double R = seriesReliability(lambdas, t);
    std::cout << "Series reliability at t=" << t
              << " h is " << R << std::endl;
    return 0;
}
      

6.3 Java: Cost Model for Design Trade-Studies

public class CostModel {

    public static double unitCost(double F, double c_v, double c_o,
                                  double Y, double N) {
        return F / N + c_v / Y + c_o;
    }

    public static void main(String[] args) {
        double F_A = 50000.0, cA = 250.0, Y_A = 0.95, c_oA = 40.0;
        double F_B = 15000.0, cB = 280.0, Y_B = 0.98, c_oB = 35.0;

        for (int N = 500; N <= 3000; N += 500) {
            double cA_N = unitCost(F_A, cA, c_oA, Y_A, N);
            double cB_N = unitCost(F_B, cB, c_oB, Y_B, N);
            System.out.println("N=" + N
                    + "  c_A=" + cA_N
                    + "  c_B=" + cB_N);
        }
    }
}
      

6.4 MATLAB/Simulink: Reliability and Cost Visualization

function demo_productization()
    % Failure rates for 3 series components [1/h]
    lambdas = [1e-4, 2e-4, 1.5e-4];
    t = 0:100:2000;  % mission time grid

    R_series = exp(-sum(lambdas) * t);

    % Cost comparison for designs A and B
    F_A = 5e4; F_B = 1.5e4;
    cA = 250; cB = 280;
    Y_A = 0.95; Y_B = 0.98;
    c_oA = 40;  c_oB = 35;

    N = 1:5000;
    c_unit_A = F_A ./ N + cA ./ Y_A + c_oA;
    c_unit_B = F_B ./ N + cB ./ Y_B + c_oB;

    figure;
    subplot(2,1,1);
    plot(t, R_series, 'LineWidth', 1.5);
    xlabel('Mission time t [h]');
    ylabel('R_{series}(t)');
    grid on;
    title('Series reliability vs. mission time');

    subplot(2,1,2);
    plot(N, c_unit_A, N, c_unit_B, 'LineWidth', 1.5);
    xlabel('Production volume N');
    ylabel('Unit cost');
    legend('Design A','Design B', 'Location', 'best');
    grid on;
    title('Unit cost vs. production volume');
end

% (Optional) Simulink setup for a simple derating calculation:
% model = 'derating_model';
% new_system(model);
% open_system(model);
% add_block('simulink/Sources/Constant', [model '/Load']);
% add_block('simulink/Math Operations/Gain', [model '/Derating']);
% set_param([model '/Derating'], 'Gain', '0.8');  % 20%% derating
% add_block('simulink/Sinks/Scope', [model '/Scope']);
% add_line(model, 'Load/1', 'Derating/1');
% add_line(model, 'Derating/1', 'Scope/1');
% save_system(model);
      

In an industrial workflow, these scripts would be linked to hardware test benches, automated report generation, or offline Monte Carlo simulations that emulate manufacturing spread and failure-rate uncertainty.

This lesson formalized the transition from prototype to product as a quantitative design problem constrained by reliability, margins, yield, and cost. We introduced reliability functions and series/parallel architectures, linked parametric uncertainty to design margins via Taylor approximations, modeled tolerance stack-up and manufacturing yield using normal distributions, and derived cost models that combine fixed and variable contributions.

Simple computational examples in Python, C++, Java, and MATLAB/Simulink showed how these models can be embedded into engineering workflows. In later courses on advanced robotics and mechatronic design, these ideas will be extended to high-dimensional optimization, robust control synthesis, and integrated electro-mechanical co-design.