A robot is a coupled energy–information system. Mechanical structure and actuators (Lessons 1–2) only work if power is delivered safely and signals are carried with integrity. We separate:

• Energy path: from source (battery, PSU) → conversion/regulation → distribution → loads.
• Signal path: from sensors → conditioning → conversion → computation → command output → actuators.

flowchart TD
  PS["Power Source (battery/PSU)"] --> REG["Regulation (DC-DC/LDO)"]
  REG --> DIST["Distribution (rails, fuses, switches)"]
  DIST --> LOADS["Loads: motors, computers, sensors"]

  SENS["Sensors"] --> COND["Signal Conditioning (filters, amplifiers)"]
  COND --> ADC["A/D or digital interface"]
  ADC --> CPU["Compute/Control"]
  CPU --> DAC["D/A or PWM/commander"]
  DAC --> DRV["Drivers/Actuator electronics"]
  DRV --> ACT["Actuators"]
        

The two paths interact: high-current actuation can inject noise into sensor lines or disturb ground reference. Managing these interactions is the essence of hardware architecture.

Let each subsystem \( i \) draw voltage \( V_i \) and current \( I_i(t) \). Instantaneous electrical power is \( P_i(t) = V_i I_i(t) \), and total robot power is \( P_{\text{tot}}(t) = \sum_i P_i(t) \).

For components with duty cycles (motors, compute bursts), define the mean current over a horizon \( T \):

\[ \bar{I}_i = \frac{1}{T}\int_0^T I_i(t)\,dt, \qquad \bar{P}_{\text{tot}} = \sum_i V_i \bar{I}_i . \]

Batteries are characterized by nominal voltage \( V_b \) and capacity \( C_{\text{Ah}} \) (ampere-hours). The stored energy is approximately

\[ E_b \approx 3600\, V_b\, C_{\text{Ah}} \quad [\text{J}]. \]

If the robot consumes average power \( \bar{P}_{\text{tot}} \), ideal runtime is

\[ T_{\text{run}} \approx \frac{E_b}{\bar{P}_{\text{tot}}} = \frac{3600\, V_b\, C_{\text{Ah}}}{\bar{P}_{\text{tot}}}. \]

Proof (energy balance): Over runtime \(T_{\text{run}}\), energy consumed equals the integral of power:

\[ \int_0^{T_{\text{run}}} P_{\text{tot}}(t)\,dt \approx \bar{P}_{\text{tot}} T_{\text{run}} = E_b . \]

Solving gives the expression above. Real runtime is smaller due to conversion losses, battery internal resistance, and cut-off voltage limits.

To include conversion efficiency \( \eta \in (0,1] \) for a chain of regulators, use \( \bar{P}_{\text{useful}} = \eta \bar{P}_{\text{tot}} \), so

\[ T_{\text{run,real}} \approx \frac{3600\, V_b\, C_{\text{Ah}}}{\bar{P}_{\text{tot}}/\eta} = \eta\; T_{\text{run}} . \]

Peak current matters for safety and stability. Let \( I_{\max} = \max_t \sum_i I_i(t) \). The power system must be rated so that \( I_{\max} \le I_{\text{rated}} \), with margin.

Wires are not ideal: they have resistivity \( \rho \), length \( L \), and cross-sectional area \( A \). From microscopic conduction theory (drift with collisions), the macroscopic resistance is

\[ R_w = \rho \frac{L}{A}. \]

Derivation: Ohm’s law in differential form is \( \mathbf{J}=\sigma \mathbf{E} \), where \( \sigma=1/\rho \). For uniform wire, \( I = JA \) and \( V = EL \), so

\[ I = \sigma A \frac{V}{L} \;\Rightarrow\; \frac{V}{I} = \rho \frac{L}{A} \equiv R_w . \]

The voltage drop on a supply line feeding current \( I \) is

\[ \Delta V = I R_w = I \rho\frac{L}{A}. \]

Resistive power loss is \( P_{\text{loss}} = I^2 R_w \). Therefore long, thin wires to motors can waste energy and reduce torque.

Constraint sizing: If a load requires at least \( V_{\min} \) and source provides \( V_s \), then

\[ V_s - \Delta V \ge V_{\min} \;\Rightarrow\; L \le \frac{A}{\rho I}(V_s - V_{\min}). \]

This inequality is a practical rule for selecting wire gauge and routing.

Distribution defines how power rails and grounds are routed. Two common ground topologies are:

• Daisy-chain ground: modules share a sequential return path.
• Star ground: each module returns to a single low-impedance node.

Consider two loads: motor driver (\( I_m \)) and sensor board (\( I_s \)). Let ground wire segments have resistance \( R_g \).

Daisy-chain analysis: Sensor ground sits after motor return:

\[ V_{g,s} = I_m R_g . \]

The sensor measures a signal referenced to its local ground, so any motor current creates a spurious offset of \(I_mR_g\) (ground bounce).

Star-ground analysis: Both returns meet at a node with negligible impedance between them:

\[ V_{g,s} \approx 0 \quad \text{(ideally)}, \]

so motor current does not elevate sensor reference. The reduction follows from superposition: in a star network, the series impedance shared by both currents is minimized.

flowchart TB
  subgraph Daisy_chain
    M1["Motor return"] --> G1["Shared ground segment Rg"] --> S1["Sensor return"]
  end
  subgraph Star_ground
    M2["Motor return"] --> N["Single ground node"]
    S2["Sensor return"] --> N
  end
        

In practice, we also add fuses and current-limited switches. If a branch can draw maximum current \( I_{\text{br}} \), we pick fuse rating \( I_f \) such that \( I_{\text{nom}} < I_f < I_{\text{fault}} \).

Sensor outputs are rarely “ready” for computation. The canonical chain is: transduction → conditioning → conversion → computation → command → actuation.

Suppose a sensor generates analog voltage \( v_s(t) \). A common conditioning stage is a first-order low-pass filter (RC), which reduces high-frequency noise before sampling.

RC filter dynamics: With resistor \(R\), capacitor \(C\), input \(v_s\), and output \(v_o\), Kirchhoff’s current law gives:

\[ \frac{v_s(t)-v_o(t)}{R} = C \frac{d v_o(t)}{dt}. \]

Rearranging yields a linear ODE:

\[ \frac{d v_o}{dt} + \frac{1}{RC} v_o = \frac{1}{RC} v_s . \]

Transfer function proof: Taking Laplace transforms (zero initial conditions):

\[ s V_o(s) + \frac{1}{RC}V_o(s) = \frac{1}{RC}V_s(s) \;\Rightarrow\; H(s)=\frac{V_o(s)}{V_s(s)} = \frac{1}{1+sRC}. \]

Let the time constant be \( \tau = RC \). The magnitude response is

\[ |H(j\omega)| = \frac{1}{\sqrt{1+(\omega \tau)^2}}, \]

and the cutoff frequency (−3 dB) is \( \omega_c = 1 / \tau \), or

\[ f_c = \frac{\omega_c}{2\pi} = \frac{1}{2\pi RC}. \]

After conditioning, an ADC quantizes the signal. With ADC range \([0, V_{\text{ref}}]\) and \(n\)-bit resolution, the quantization step is

\[ \Delta_q = \frac{V_{\text{ref}}}{2^n}. \]

Quantization error satisfies \( |e_q| \le \Delta_q/2 \) under standard rounding.

Major noise sources in robots include motor commutation, switching regulators, and electromagnetic coupling from long cables. We quantify integrity via signal-to-noise ratio (SNR).

If the desired signal power is \( P_x \) and noise power is \( P_n \), then \( \text{SNR} = P_x/P_n \) and in decibels

\[ \text{SNR}_{\text{dB}} = 10\log_{10}\!\left(\frac{P_x}{P_n}\right). \]

A fundamental lower bound is thermal (Johnson) noise. For resistor \(R\), bandwidth \(B\), temperature \(T\), the noise variance is

\[ v_n^2 = 4 k_B T R B, \]

where \(k_B\) is Boltzmann’s constant. Though small, it fixes a baseline.

Practical mitigation (conceptual, no deep EM):

• Separate power & signal routing: avoid parallel runs with motor lines.
• Twisted pairs / differential sensing: noise couples similarly into both conductors and cancels in subtraction.
• Shielding: conductive braid tied to ground to intercept fields.
• Decoupling capacitors: local energy reservoirs near ICs to prevent rail dips.

The following short programs compute (i) runtime from a power budget, (ii) voltage drop along a wire, and (iii) RC filter cutoff.

7.1 Python (NumPy)

import numpy as np

# --- Power budget & runtime ---
Vb = 14.8            # battery voltage [V]
C_Ah = 5.0           # capacity [Ah]
eta = 0.9            # overall conversion efficiency

# loads: (V_i, avg current)
loads = [
    (14.8, 2.0),     # motors (avg)
    (5.0,  1.2),     # computer rail
    (3.3,  0.5)      # sensors rail
]
P_tot = sum(V * I for V, I in loads)          # [W]
E_b = 3600.0 * Vb * C_Ah                      # [J]
T_run = eta * E_b / P_tot / 3600.0            # [hours]

print("Average power [W] =", P_tot)
print("Estimated runtime [h] =", T_run)

# --- Wire voltage drop ---
rho = 1.68e-8        # copper resistivity [ohm*m]
L = 1.5              # one-way length [m]
A = 1.0e-6           # area [m^2] ~ AWG18 order
I = 5.0              # current [A]
Rw = rho * L / A
dV = I * Rw

print("Wire resistance [ohm] =", Rw)
print("Voltage drop [V] =", dV)

# --- RC cutoff ---
R = 1e3              # [ohm]
C = 0.1e-6           # [F]
fc = 1.0 / (2*np.pi*R*C)
print("Cutoff frequency [Hz] =", fc)
      

7.2 C++ (Embedded-style)

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

int main() {
    // Power budget
    double Vb = 14.8, C_Ah = 5.0, eta = 0.9;
    std::vector<std::pair<double,double>> loads = {
        {14.8, 2.0}, {5.0, 1.2}, {3.3, 0.5}
    };
    double P_tot = 0.0;
    for (auto &li : loads) P_tot += li.first * li.second;

    double E_b = 3600.0 * Vb * C_Ah;                // Joules
    double T_run_h = eta * E_b / P_tot / 3600.0;    // hours

    std::cout << "Average power [W] = " << P_tot << "\n";
    std::cout << "Estimated runtime [h] = " << T_run_h << "\n";

    // Wire drop
    double rho = 1.68e-8, L = 1.5, A = 1.0e-6, I = 5.0;
    double Rw = rho * L / A;
    double dV = I * Rw;
    std::cout << "Wire resistance [ohm] = " << Rw << "\n";
    std::cout << "Voltage drop [V] = " << dV << "\n";

    // RC cutoff
    double R = 1e3, C = 0.1e-6;
    double fc = 1.0 / (2.0 * M_PI * R * C);
    std::cout << "Cutoff frequency [Hz] = " << fc << "\n";
    return 0;
}
      

7.3 Java

import java.util.*;

public class PowerWiringSignalFlow {
    public static void main(String[] args) {
        double Vb = 14.8, C_Ah = 5.0, eta = 0.9;

        // loads: (V, Iavg)        
        double[][] loads = new double[][]{
            {14.8, 2.0},
            {5.0,  1.2},
            {3.3,  0.5}
        };
        double Ptot = 0.0;
        for (double[] li : loads) Ptot += li[0] * li[1];

        double Eb = 3600.0 * Vb * C_Ah;
        double TrunH = eta * Eb / Ptot / 3600.0;

        System.out.println("Average power [W] = " + Ptot);
        System.out.println("Estimated runtime [h] = " + TrunH);

        double rho = 1.68e-8, L = 1.5, A = 1.0e-6, I = 5.0;
        double Rw = rho * L / A;
        double dV = I * Rw;
        System.out.println("Wire resistance [ohm] = " + Rw);
        System.out.println("Voltage drop [V] = " + dV);

        double R = 1e3, C = 0.1e-6;
        double fc = 1.0 / (2.0 * Math.PI * R * C);
        System.out.println("Cutoff frequency [Hz] = " + fc);
    }
}
      

7.4 Matlab / Simulink

% Power budget & runtime
Vb = 14.8; C_Ah = 5.0; eta = 0.9;
loads = [14.8 2.0; 5.0 1.2; 3.3 0.5];  % [V, Iavg]
P_tot = sum(loads(:,1).*loads(:,2));
E_b = 3600*Vb*C_Ah;
T_run_h = eta*E_b/P_tot/3600;

disp(['Average power [W] = ', num2str(P_tot)])
disp(['Estimated runtime [h] = ', num2str(T_run_h)])

% Wire voltage drop
rho = 1.68e-8; L = 1.5; A = 1.0e-6; I = 5.0;
Rw = rho*L/A;
dV = I*Rw;
disp(['Wire resistance [ohm] = ', num2str(Rw)])
disp(['Voltage drop [V] = ', num2str(dV)])

% RC cutoff
R = 1e3; C = 0.1e-6;
fc = 1/(2*pi*R*C);
disp(['Cutoff frequency [Hz] = ', num2str(fc)])

% Simulink note:
% Implement RC low-pass using a "Transfer Fcn" block with numerator [1]
% and denominator [R*C 1]. Feed sensor signal into it before ADC.
      

Problem 1 (Battery Sizing): A mobile robot uses two DC motors at 12 V drawing 3 A each on average, an onboard computer at 5 V drawing 1.5 A, and sensors at 3.3 V drawing 0.4 A. The DC-DC conversion efficiency is 0.88. If the battery is 14.8 V, what minimum capacity \(C_{\text{Ah}}\) gives 2.5 hours of runtime?

Solution: Average power:

\[ \bar{P}_{\text{tot}} = 12(3+3) + 5(1.5) + 3.3(0.4) = 72 + 7.5 + 1.32 = 80.82\;\text{W}. \]

Real runtime condition \(T = \eta \cdot 3600 V_b C_{\text{Ah}}/\bar{P}_{\text{tot}}\). Solve for capacity:

\[ C_{\text{Ah}} = \frac{T\,\bar{P}_{\text{tot}}}{\eta \, 3600\, V_b} = \frac{2.5\times 80.82}{0.88\times 3600 \times 14.8} \approx 0.00432\;\text{Ah}^{-1}\times 2.5 \approx 3.24\;\text{Ah}. \]

Add design margin (aging, peaks), so choose at least \(4\) Ah.

Problem 2 (Wire Gauge Constraint): A 24 V motor driver is 2 m away from the battery (one-way). It draws 8 A during acceleration. Copper wire has \(\rho = 1.68\times 10^{-8}\, \Omega\cdot\text{m}\). If the motor voltage must stay above 22.5 V, find the minimum wire area \(A\).

Solution: Maximum drop is \(V_s - V_{\min} = 1.5\) V. Using \(\Delta V = I \rho L/A\):

\[ A \ge \frac{I\rho L}{\Delta V} = \frac{8 \cdot 1.68\times10^{-8}\cdot 2}{1.5} \approx 1.79\times 10^{-7}\,\text{m}^2. \]

This is about \(0.179\) mm\(^2\); practical selection rounds up to a standard gauge with margin (e.g., AWG 22 or thicker).

Problem 3 (RC Filter Design): A sensor signal has high-frequency noise at 200 Hz that you want attenuated by at least 20 dB. Design a first-order RC low-pass filter with cutoff \(f_c\) that achieves this. Give one possible \(R,C\) pair with \(R=2\text{ k}\Omega\).

Solution: For a first-order low-pass, \(|H(j\omega)|=1/\sqrt{1+(\omega RC)^2}\). Attenuation \(A_{\text{dB}}=-20\log_{10}|H|\). Requirement: \(A_{\text{dB}}\ge 20\) at \(f=200\) Hz, so \(|H|\le 0.1\).

\[ \frac{1}{\sqrt{1+(\omega RC)^2}} \le 0.1 \;\Rightarrow\; 1+(\omega RC)^2 \ge 100 \;\Rightarrow\; \omega RC \ge \sqrt{99}. \]

With \(\omega=2\pi f=400\pi\),

\[ RC \ge \frac{\sqrt{99}}{400\pi} \approx 0.0079\;\text{s}. \]

Given \(R=2000\,\Omega\), select

\[ C \ge \frac{0.0079}{2000} \approx 3.95\times10^{-6}\,\text{F} \approx 3.9\,\mu\text{F}. \]

Problem 4 (Ground Bounce Error): A motor branch draws a step current of 6 A through a shared ground segment \(R_g=30\text{ m}\Omega\). A nearby analog sensor outputs 50 mV per unit of measured force and is referenced to the local ground after the segment. What apparent force error is induced?

Solution: Ground rise is \(V_{g,s}=I_mR_g=6\times 0.03=0.18\) V. Equivalent apparent sensor output change:

\[ \Delta F = \frac{V_{g,s}}{0.05} = \frac{0.18}{0.05}=3.6\;\text{units}. \]

This large spurious offset motivates star grounding and separating returns.

We modeled robot power and signal pathways quantitatively. You learned to: (i) compute average power and battery runtime, (ii) derive wiring resistance and voltage-drop limits, (iii) analyze grounding topologies via circuit superposition, and (iv) derive and apply first-order filter and ADC formulas that support clean signal flow. These tools are essential for robust robot bring-up and will reappear as we study embedded computing and sensing.