From prior lessons/chapters, you already know (i) translational mass–spring–damper modeling (Chapter 3) and (ii) rotational inertia, torsional springs, and torsional dampers (Chapter 4, Lesson 1). This lesson adds lossless kinematic couplings (gears/levers/etc.) that do not store energy but transform variables between ports.

By the end of this lesson you will be able to:

• Model gears and levers as ideal two-port elements using kinematic constraints and power balance.
• Derive torque/force scaling from velocity/displacement scaling (and vice versa) using virtual work.
• Reflect load inertia/damping/stiffness through gear ratios or lever arms to obtain equivalent single-port models.
• Implement and simulate the resulting ODE models in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica.

A wide range of mechanical couplings (gears, levers, pulleys, wheel-radius couplings) can be treated as a two-port mapping between a “port 1” and a “port 2”. Each port has:

• Generalized displacement \( q \) (translation: \( x \), rotation: \( \theta \)),
• Generalized velocity \( \dot{q} \) (translation: \( v \), rotation: \( \omega \)),
• Generalized effort \( e \) (translation: \( F \), rotation: \( \tau \)).

The instantaneous power entering a port is: \( P = e \, \dot{q} \). For an ideal lossless transformer (no energy storage, no dissipation inside the transformer), the net power is zero:

\[ P_1 + P_2 = e_1 \dot{q}_1 + e_2 \dot{q}_2 = 0. \]

The kinematic constraint of an ideal transformer is a fixed ratio between velocities (or displacements). A common and very convenient definition is: \( n \): the speed ratio from port 1 to port 2, defined by

\[ \dot{q}_1 = n \, \dot{q}_2, \quad n \neq 0. \]

Integrating (for constant \( n \)) gives the displacement relation (up to a constant set by initial conditions):

\[ q_1 = n \, q_2 + c_0. \]

Proposition 1 (Effort scaling): For a lossless transformer with \( \dot{q}_1 = n\dot{q}_2 \), the efforts satisfy \( e_2 = -n \, e_1 \).

Proof (power balance): From losslessness,

\[ e_1 \dot{q}_1 + e_2 \dot{q}_2 = 0. \]

Substitute \( \dot{q}_1 = n \dot{q}_2 \):

\[ e_1 (n \dot{q}_2) + e_2 \dot{q}_2 = (n e_1 + e_2)\dot{q}_2 = 0. \]

For general motion (i.e., not identically \( \dot{q}_2 = 0 \)), the bracket must vanish: \( e_2 = -n e_1 \). The negative sign encodes opposite power directions: if power enters port 1, it leaves port 2.

Remark (sign conventions): In many mechanical devices, motion directions are opposite (e.g., external gears). You can incorporate direction into the kinematic constraint with a sign, e.g., \( \dot{q}_1 = -n \dot{q}_2 \). The same proof yields the corresponding sign in effort scaling.

flowchart TD
  P1["Port 1: (q1, q1dot, e1)"] --> T["Lossless transformer ratio n"]
  T --> P2["Port 2: (q2, q2dot, e2)"]
  P1 --- R1["Constraint: q1dot = n * q2dot"]
  P2 --- R2["Power: e1*q1dot + e2*q2dot = 0"]
  R2 --- R3["Result: e2 = -n * e1"]
        

Transformer modeling becomes powerful when we can replace a two-port connection by an equivalent one-port model “as seen” from a chosen side. This is done by reflecting parameters.

Assume a transformer with \( \dot{q}_1 = n\dot{q}_2 \), and suppose port 2 is connected to a load whose constitutive relation is expressed at port 2. We want an equivalent relation at port 1.

Lemma 1 (general reflection law): If the port-2 effort is \( e_2 \) and port-2 velocity is \( \dot{q}_2 \), then using \( \dot{q}_2 = \dot{q}_1/n \) and \( e_1 = -e_2/n \) (from Proposition 1), any load relation can be translated to port 1.

We now apply this to the three canonical lumped elements you already know (from Chapter 3 and Chapter 4, Lesson 1):

(A) Inertia element (translation: mass, rotation: inertia):

\[ e_2 = J_2 \, \ddot{q}_2 \quad \text{(rotational: } e_2=\tau_2,\; q_2=\theta_2\text{)} \]

Substitute \( q_2 = q_1/n \) so \( \ddot{q}_2 = \ddot{q}_1/n \), and then reflect effort:

\[ e_1 = -\frac{e_2}{n} = -\frac{1}{n}\left(J_2 \frac{\ddot{q}_1}{n}\right) = -\left(\frac{J_2}{n^2}\right)\ddot{q}_1. \]

Thus the equivalent inertia seen at port 1 is: \( J_{2 \rightarrow 1} = \frac{J_2}{n^2} \).

(B) Viscous damper (translation: \( F=c v \), rotation: \( \tau=b\omega \)):

\[ e_2 = b_2 \dot{q}_2 \;\;\Rightarrow\;\; e_1 = -\frac{1}{n}\left(b_2\frac{\dot{q}_1}{n}\right) = -\left(\frac{b_2}{n^2}\right)\dot{q}_1, \]

hence \( b_{2 \rightarrow 1} = \frac{b_2}{n^2} \).

(C) Spring (translation: \( F=k x \), rotation: \( \tau=k_\theta \theta \)):

\[ e_2 = k_2 q_2 \;\;\Rightarrow\;\; e_1 = -\frac{1}{n}\left(k_2\frac{q_1}{n}\right) = -\left(\frac{k_2}{n^2}\right)q_1, \]

hence \( k_{2 \rightarrow 1} = \frac{k_2}{n^2} \).

Key conclusion: for the ratio definition \( \dot{q}_1 = n\dot{q}_2 \), inertia, damping, and stiffness reflect by division by \( n^2 \) from port 2 to port 1. (Reflecting in the opposite direction multiplies by \( n^2 \).)

Consider two rigid gears in mesh with pitch radii \( r_1 \) and \( r_2 \). Under the idealization of (i) no slip at the pitch point and (ii) negligible compliance/losses in the mesh, the tangential velocities at the pitch circles are equal in magnitude.

Kinematic constraint (external gears):

\[ r_1 \dot{\theta}_1 + r_2 \dot{\theta}_2 = 0 \quad \Rightarrow \quad \dot{\theta}_1 = \left(\frac{r_2}{r_1}\right)(-\dot{\theta}_2). \]

Define the (magnitude) gear ratio \( n \):

\[ n \triangleq \frac{\dot{\theta}_1}{\dot{\theta}_2} = \frac{r_2}{r_1} = \frac{N_2}{N_1}, \quad n > 0, \]

where \( N_1, N_2 \) are tooth counts (for standard gears, \( r \propto N \)). The sign inversion (opposite rotation) is handled separately by the “external mesh” sign.

Torque relation (lossless mesh): Apply power balance \( \tau_1 \omega_1 + \tau_2 \omega_2 = 0 \) with \( \omega_1 = \dot{\theta}_1 \) and \( \omega_2 = \dot{\theta}_2 \). Using \( \omega_1 = -n \omega_2 \) (external gears):

\[ \tau_1(-n\omega_2) + \tau_2\omega_2 = 0 \quad \Rightarrow \quad \tau_2 = n \tau_1. \]

So a gear reduction with \( n > 1 \) yields torque amplification on gear 2 and speed reduction in magnitude.

Reflected load parameters (common modeling move): Suppose gear 2 carries a load with inertia \( J_L \), damping \( b_L \), and torsional stiffness \( k_L \) to ground. From Section 3, as seen at gear 1, the equivalent parameters are:

\[ J_{L\rightarrow 1} = \frac{J_L}{n^2}, \qquad b_{L\rightarrow 1} = \frac{b_L}{n^2}, \qquad k_{L\rightarrow 1} = \frac{k_L}{n^2}. \]

Energy consistency check: The kinetic energy of the load side is \( \tfrac{1}{2}J_L\omega_2^2 \). Using \( \omega_2 = -\omega_1/n \):

\[ \frac{1}{2}J_L\omega_2^2 = \frac{1}{2}J_L\left(\frac{\omega_1^2}{n^2}\right) = \frac{1}{2}\left(\frac{J_L}{n^2}\right)\omega_1^2, \]

which is exactly the kinetic energy of an equivalent inertia \( J_L/n^2 \) spinning at \( \omega_1 \).

An ideal rigid lever about a pivot maps displacements and forces between two points at distances \( \ell_1 \) and \( \ell_2 \) from the pivot. Under small angular motion (a standard approximation in lumped modeling), the arc-length displacement at each point is proportional to lever arm length.

Kinematics (small angles): with lever rotation \( \theta \),

\[ x_1 \approx \ell_1 \theta, \qquad x_2 \approx \ell_2 \theta \quad \Rightarrow \quad \dot{x}_1 \approx \ell_1 \dot{\theta}, \qquad \dot{x}_2 \approx \ell_2 \dot{\theta}. \]

Therefore the speed ratio between point 1 and point 2 is \( \dot{x}_1/\dot{x}_2 = \ell_1/\ell_2 \). Using the transformer definition in Section 2 with port variables \( q_1=x_1 \) and \( q_2=x_2 \), we may identify:

\[ n = \frac{\dot{x}_1}{\dot{x}_2} = \frac{\ell_1}{\ell_2}. \]

Force scaling (virtual work / power):

\[ F_1 \dot{x}_1 + F_2 \dot{x}_2 = 0 \quad \Rightarrow \quad F_2 = -\left(\frac{\dot{x}_1}{\dot{x}_2}\right)F_1 = -n F_1 = -\left(\frac{\ell_1}{\ell_2}\right)F_1. \]

Thus a longer output arm (\( \ell_2 > \ell_1 \)) reduces output force magnitude and increases output motion magnitude, and vice versa—exactly the mechanical advantage trade-off.

Parameter reflection: A translational spring \( k_2 \) attached at point 2 reflects to point 1 as:

\[ k_{2\rightarrow 1} = \frac{k_2}{n^2} = k_2\left(\frac{\ell_2}{\ell_1}\right)^2, \]

which explains why a lever can make a spring appear stiffer or softer depending on lever geometry.

The same two-port framework covers several additional couplings frequently used in mechatronic modeling.

(A) Belt and pulley (ideal, no slip):

For pulleys of radii \( r_1 \), \( r_2 \) and belt linear speed \( v \): \( v = r_1\omega_1 = r_2\omega_2 \). Therefore:

\[ \omega_1 = \left(\frac{r_2}{r_1}\right)\omega_2, \quad \tau_2 = \left(\frac{r_2}{r_1}\right)\tau_1 \quad \text{(lossless)}. \]

(B) Radius-based rotational–translational coupling (wheel / drum):

A drum of radius \( r \) converts rotation to translation via the no-slip relation \( x = r\theta \). Differentiating:

\[ \dot{x} = r\dot{\theta} = r\omega, \qquad \ddot{x} = r\ddot{\theta}. \]

Power balance \( \tau\omega + F\dot{x} = 0 \) yields:

\[ \tau\omega + F(r\omega) = 0 \quad \Rightarrow \quad \tau = -Fr. \]

This is the rotational–translational transformer used implicitly in many actuator-load models (e.g., cable drums).

(C) Lead screw (conceptual idealization):

A screw with lead \( p \) (translation per revolution) gives the kinematic relation \( x = \frac{p}{2\pi}\theta \), hence \( \dot{x} = \frac{p}{2\pi}\omega \). Power balance then implies an ideal force–torque relation:

\[ \tau\omega + F\dot{x} = 0 \quad \Rightarrow \quad \tau = -F\left(\frac{p}{2\pi}\right). \]

In real screws, efficiency and friction are significant; those non-idealities belong conceptually with friction models (Chapter 3, Lesson 4) and with non-ideal gear effects (Chapter 4, Lesson 4). Here we keep the transformer ideal.

We build a minimal but representative rotational model that uses the transformer rules correctly. Consider:

• Motor side (gear 1): inertia \( J_m \), viscous damping \( b_m \), torsional spring to ground \( k_m \).
• Load side (gear 2): inertia \( J_L \), viscous damping \( b_L \), torsional spring to ground \( k_L \).
• Ideal external gear mesh with ratio \( n = r_2/r_1 = \omega_1/\omega_2 \) in magnitude.
• Input torque \( u(t) \) applied to motor shaft (gear 1).

Using reflection from load to motor side (Section 3), define:

\[ J_{\mathrm{eq}} = J_m + \frac{J_L}{n^2}, \qquad b_{\mathrm{eq}} = b_m + \frac{b_L}{n^2}, \qquad k_{\mathrm{eq}} = k_m + \frac{k_L}{n^2}. \]

The motor-side generalized coordinate is \( \theta_1 \). The equivalent single-DOF ODE is:

\[ J_{\mathrm{eq}} \, \ddot{\theta}_1(t) + b_{\mathrm{eq}} \, \dot{\theta}_1(t) + k_{\mathrm{eq}} \, \theta_1(t) = u(t). \]

Once \( \theta_1(t) \) is known, the load angle follows from kinematics (external gears):

\[ \theta_2(t) = -\frac{1}{n}\theta_1(t), \qquad \omega_2(t) = -\frac{1}{n}\omega_1(t). \]

Why this is “correct” (structural proof sketch): The model is obtained by (i) enforcing the kinematic constraint, (ii) eliminating redundant coordinates, and (iii) preserving energy/power across the mesh. The reflection formulas in Section 3 are exactly the algebraic statement of these three principles for linear lumped elements.

flowchart TD
  S0["Start: identify coupling type"] --> S1["Write kinematic constraint (velocity/displacement ratio)"]
  S1 --> S2["Impose lossless power balance across coupling"]
  S2 --> S3["Derive effort scaling from constraint + power"]
  S3 --> S4["Reflect load parameters through ratio (divide/multiply by n^2)"]
  S4 --> S5["Build equivalent single-port ODE in chosen coordinate"]
  S5 --> S6["Simulate ODE and back-compute other-side variables"]
        

We simulate the equivalent ODE from Section 7 using SciPy. Relevant libraries for System Dynamics workflows in Python include: numpy, scipy.integrate, sympy (symbolic derivations), and (later in the course) control for transfer functions/state-space.

import numpy as np
from scipy.integrate import solve_ivp

# Parameters
Jm = 0.02      # motor inertia [kg*m^2]
bm = 0.01      # motor viscous damping [N*m*s/rad]
km = 0.5       # motor torsional stiffness to ground [N*m/rad]

JL = 0.20      # load inertia [kg*m^2]
bL = 0.05      # load viscous damping [N*m*s/rad]
kL = 2.0       # load torsional stiffness to ground [N*m/rad]

n = 5.0        # gear ratio magnitude n = omega1 / omega2 = r2 / r1

# Reflected (equivalent) parameters as seen at motor side
Jeq = Jm + JL / (n**2)
beq = bm + bL / (n**2)
keq = km + kL / (n**2)

def u(t):
    # step torque input: 0.2 N*m after t >= 0.1 s
    return 0.2 if t >= 0.1 else 0.0

# State: x = [theta1, omega1]
def f(t, x):
    theta1, omega1 = x
    dtheta = omega1
    domega = (u(t) - beq*omega1 - keq*theta1) / Jeq
    return [dtheta, domega]

t0, tf = 0.0, 2.0
x0 = [0.0, 0.0]

sol = solve_ivp(f, (t0, tf), x0, max_step=1e-3, rtol=1e-8, atol=1e-10)

t = sol.t
theta1 = sol.y[0]
omega1 = sol.y[1]

# Back-compute load-side variables for external gears
theta2 = -theta1 / n
omega2 = -omega1 / n

# Example numerical summaries
print("Jeq =", Jeq, "beq =", beq, "keq =", keq)
print("theta1(tf) =", theta1[-1], "rad; theta2(tf) =", theta2[-1], "rad")
      

The variables \( \theta_2(t) \) and \( \omega_2(t) \) are obtained purely by the kinematic ratio; all dynamics were captured in the equivalent motor-side ODE via reflected parameters.

In C++, common choices for System Dynamics simulation include: Boost.Odeint (ODE integration), Eigen (linear algebra), and custom fixed-step integrators when deterministic step sizes are needed (e.g., embedded control). Below is a minimal fixed-step RK4 implementation of Section 7.

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

struct Params {
  double Jeq, beq, keq, n;
};

double u(double t) {
  return (t >= 0.1) ? 0.2 : 0.0;
}

// x = [theta1, omega1]
std::vector<double> f(double t, const std::vector<double>& x, const Params& p) {
  double theta1 = x[0];
  double omega1 = x[1];
  double dtheta = omega1;
  double domega = (u(t) - p.beq * omega1 - p.keq * theta1) / p.Jeq;
  return {dtheta, domega};
}

std::vector<double> rk4_step(double t, const std::vector<double>& x, double h, const Params& p) {
  auto k1 = f(t, x, p);

  std::vector<double> x2 = {x[0] + 0.5*h*k1[0], x[1] + 0.5*h*k1[1]};
  auto k2 = f(t + 0.5*h, x2, p);

  std::vector<double> x3 = {x[0] + 0.5*h*k2[0], x[1] + 0.5*h*k2[1]};
  auto k3 = f(t + 0.5*h, x3, p);

  std::vector<double> x4 = {x[0] + h*k3[0], x[1] + h*k3[1]};
  auto k4 = f(t + h, x4, p);

  return {
    x[0] + (h/6.0)*(k1[0] + 2.0*k2[0] + 2.0*k3[0] + k4[0]),
    x[1] + (h/6.0)*(k1[1] + 2.0*k2[1] + 2.0*k3[1] + k4[1])
  };
}

int main() {
  // Original parameters
  double Jm = 0.02, bm = 0.01, km = 0.5;
  double JL = 0.20, bL = 0.05, kL = 2.0;
  double n  = 5.0;

  Params p;
  p.n   = n;
  p.Jeq = Jm + JL/(n*n);
  p.beq = bm + bL/(n*n);
  p.keq = km + kL/(n*n);

  double t0 = 0.0, tf = 2.0, h = 1e-3;
  std::vector<double> x = {0.0, 0.0}; // theta1, omega1

  for (double t = t0; t <= tf; t += h) {
    if (static_cast<int>(t/h) % 500 == 0) {
      double theta2 = -x[0]/p.n;
      double omega2 = -x[1]/p.n;
      std::cout << "t=" << t
                << " theta1=" << x[0]
                << " omega1=" << x[1]
                << " theta2=" << theta2
                << " omega2=" << omega2
                << "\n";
    }
    x = rk4_step(t, x, h, p);
  }
  return 0;
}
      

For production-grade simulation, replace the manual RK4 loop with Boost.Odeint integrators (adaptive or fixed step), while keeping the same reflected-parameter model structure.

In Java, Apache Commons Math provides ODE solvers suitable for System Dynamics prototypes. Below is a compact example using a fixed-step classical Runge–Kutta integrator.

import org.apache.commons.math3.ode.FirstOrderDifferentialEquations;
import org.apache.commons.math3.ode.nonstiff.ClassicalRungeKuttaIntegrator;
import org.apache.commons.math3.ode.sampling.FixedStepHandler;
import org.apache.commons.math3.ode.sampling.StepNormalizer;

public class GearReflectedODE {

  static double u(double t) {
    return (t >= 0.1) ? 0.2 : 0.0;
  }

  public static void main(String[] args) {
    // Parameters
    double Jm = 0.02, bm = 0.01, km = 0.5;
    double JL = 0.20, bL = 0.05, kL = 2.0;
    double n  = 5.0;

    double Jeq = Jm + JL/(n*n);
    double beq = bm + bL/(n*n);
    double keq = km + kL/(n*n);

    FirstOrderDifferentialEquations ode = new FirstOrderDifferentialEquations() {
      @Override
      public int getDimension() { return 2; }

      @Override
      public void computeDerivatives(double t, double[] x, double[] xDot) {
        double theta1 = x[0];
        double omega1 = x[1];
        xDot[0] = omega1;
        xDot[1] = (u(t) - beq*omega1 - keq*theta1) / Jeq;
      }
    };

    double h = 1e-3;
    ClassicalRungeKuttaIntegrator integrator = new ClassicalRungeKuttaIntegrator(h);

    integrator.addStepHandler(new StepNormalizer(0.05, (FixedStepHandler) (t, x, xDot, isLast) -> {
      double theta1 = x[0];
      double omega1 = x[1];
      double theta2 = -theta1 / n;
      double omega2 = -omega1 / n;
      System.out.printf("t=%.2f theta1=%.6f omega1=%.6f theta2=%.6f omega2=%.6f%n",
                        t, theta1, omega1, theta2, omega2);
    }));

    double[] x0 = new double[] {0.0, 0.0};
    double[] xf = new double[2];
    integrator.integrate(ode, 0.0, x0, 2.0, xf);
  }
}
      

Later in the course (after transfer functions/state-space), Java workflows often combine ODE integration with linear algebra (e.g., EJML) for MIMO models.

In MATLAB, the reflected-parameter model is implemented directly as a second-order ODE. In Simulink, you can realize the same ODE using Integrator blocks with gains corresponding to \( 1/J_{\mathrm{eq}} \), \( b_{\mathrm{eq}} \), and \( k_{\mathrm{eq}} \), and then compute \( \theta_2 = -\theta_1/n \), \( \omega_2 = -\omega_1/n \) with Gain blocks.

% Parameters
Jm = 0.02; bm = 0.01; km = 0.5;
JL = 0.20; bL = 0.05; kL = 2.0;
n  = 5.0;

Jeq = Jm + JL/(n^2);
beq = bm + bL/(n^2);
keq = km + kL/(n^2);

u = @(t) (t >= 0.1) * 0.2;  % step torque

% State: x = [theta1; omega1]
f = @(t, x) [ x(2);
              (u(t) - beq*x(2) - keq*x(1))/Jeq ];

tspan = [0 2];
x0 = [0; 0];
opts = odeset('RelTol',1e-8,'AbsTol',1e-10);
[t, x] = ode45(f, tspan, x0, opts);

theta1 = x(:,1);
omega1 = x(:,2);
theta2 = -theta1/n;
omega2 = -omega1/n;

disp([Jeq, beq, keq]);
disp([theta1(end), theta2(end)]);
      

Simulink block-level recipe (no images):

• Use two Integrator blocks in series: \( \ddot{\theta}_1 \rightarrow \dot{\theta}_1 \rightarrow \theta_1 \).
• Compute \( \ddot{\theta}_1 = (u - b_{\mathrm{eq}}\dot{\theta}_1 - k_{\mathrm{eq}}\theta_1)/J_{\mathrm{eq}} \) using Sum and Gain blocks.
• Add Gain blocks for \( -1/n \) to produce \( \theta_2 \) and \( \omega_2 \) from \( \theta_1 \) and \( \omega_1 \).
• Drive \( u(t) \) with a Step block (step time 0.1, final value 0.2).

Mathematica provides direct symbolic and numerical solving via NDSolve. The model below matches Section 7.

Jm = 0.02; bm = 0.01; km = 0.5;
JL = 0.20; bL = 0.05; kL = 2.0;
n  = 5.0;

Jeq = Jm + JL/n^2;
beq = bm + bL/n^2;
keq = km + kL/n^2;

u[t_] := Piecewise[{ {0.2, t >= 0.1} }, 0.0];

eq = Jeq*θ1''[t] + beq*θ1'[t] + keq*θ1[t] == u[t];
ics = {θ1[0] == 0, θ1'[0] == 0};

sol = NDSolve[{eq, ics}, θ1, {t, 0, 2}, MaxStepSize -> 0.001][[1]];

θ2[t_] := -θ1[t]/n;
ω1[t_] := θ1'[t];
ω2[t_] := -ω1[t]/n;

{Jeq, beq, keq}
(* Example evaluations *)
{θ1[2], θ2[2]} /. sol
      

Problem 1 (Gear kinematics and torque scaling): Two external gears have radii \( r_1 = 20 \) mm and \( r_2 = 80 \) mm. If \( \omega_1 = 120 \) rad/s and the input torque is \( \tau_1 = 0.4 \) N·m, find \( \omega_2 \) and \( \tau_2 \) (ideal lossless mesh).

Solution: The ratio magnitude is

\[ n = \frac{r_2}{r_1} = \frac{80}{20} = 4. \]

For external gears, \( \omega_1 = -n\omega_2 \), hence \( \omega_2 = -\omega_1/n = -120/4 = -30 \) rad/s. Power balance gives \( \tau_2 = n\tau_1 = 4 \times 0.4 = 1.6 \) N·m. The negative sign in \( \omega_2 \) indicates opposite rotation.

Problem 2 (Reflected inertia through a gear reduction): A motor drives a load through an ideal gear pair with \( n = \omega_1/\omega_2 = 6 \). The load inertia is \( J_L = 0.36 \) kg·m². Compute the reflected inertia at the motor shaft.

Solution: Using Section 3,

\[ J_{L\rightarrow 1} = \frac{J_L}{n^2} = \frac{0.36}{6^2} = \frac{0.36}{36} = 0.01 \;\text{kg·m}^2. \]

Problem 3 (Lever mechanical advantage and stiffness reflection): A lever has arms \( \ell_1 = 0.05 \) m and \( \ell_2 = 0.20 \) m. A linear spring of stiffness \( k_2 = 1000 \) N/m is attached at point 2. Find the equivalent stiffness seen at point 1.

Solution: The speed ratio is \( n = \ell_1/\ell_2 = 0.05/0.20 = 0.25 \). Reflect stiffness from port 2 to port 1:

\[ k_{2\rightarrow 1} = \frac{k_2}{n^2} = \frac{1000}{(0.25)^2} = \frac{1000}{0.0625} = 16000 \;\text{N/m}. \]

The lever makes the spring appear much stiffer at point 1 because point 1 moves less than point 2.

Problem 4 (Equivalent ODE parameters): In Section 7, let \( J_m=0.03 \), \( b_m=0.02 \), \( k_m=0 \), \( J_L=0.12 \), \( b_L=0.06 \), \( k_L=1.5 \), and \( n=3 \). Compute \( J_{\mathrm{eq}}, b_{\mathrm{eq}}, k_{\mathrm{eq}} \).

Solution:

\[ J_{\mathrm{eq}} = 0.03 + \frac{0.12}{3^2} = 0.03 + \frac{0.12}{9} = 0.043\overline{3}, \]

\[ b_{\mathrm{eq}} = 0.02 + \frac{0.06}{9} = 0.02 + 0.006\overline{6} = 0.026\overline{6}, \qquad k_{\mathrm{eq}} = 0 + \frac{1.5}{9} = 0.166\overline{6}. \]

Problem 5 (Designing a gear ratio for inertia matching): A load inertia is \( J_L = 0.5 \) kg·m². You want the reflected inertia at the motor shaft to be \( 0.02 \) kg·m². Find \( n \) (assume ideal gears and use \( J_{L\rightarrow 1} = J_L/n^2 \)).

Solution:

\[ \frac{J_L}{n^2} = 0.02 \quad \Rightarrow \quad n^2 = \frac{0.5}{0.02} = 25 \quad \Rightarrow \quad n = 5. \]

A 5:1 speed reduction (motor faster than load by a factor of 5) achieves the desired reflected inertia.

We modeled gears, levers, and related couplings as ideal, lossless transformers defined by a kinematic constraint plus power balance. This yielded effort scaling laws and the crucial \( 1/n^2 \) reflection rule for inertia, damping, and stiffness (given the definition \( \dot{q}_1 = n\dot{q}_2 \)). These results allow you to reduce multi-shaft coupled systems to equivalent single-coordinate ODEs while preserving physical consistency—an essential skill for accurate rotational/mechatronic modeling in the coming lessons.