Machines with a nervous system
Press the pedal of an electric-assist bicycle and a torque sensor in the crank measures how hard you push; a few milliseconds later a motor adds its share, and the harder you push, the more it helps. A car's accelerator pedal is no longer connected to the engine by a cable: it moves a position sensor, and a motor opens the throttle. A 3D printer, a washing machine, a camera's image stabiliser, an automatic door and a factory's pick-and-place robot all work the same way. A mechanism does the physical work, actuators drive it, sensors watch it, and a small computer decides.
That combination is mechatronics, a word coined in 1969 by Tetsuro Mori, an engineer at Japan's Yaskawa Electric, for machines in which mechanics and electronics are designed together. This lesson looks at its parts from the mechanical engineer's side. Lumenary EE explains how sensors and data conversion, microcontrollers and electric machines work inside; here the questions are what a sensor really tells you about a mechanism, how much force and speed an actuator delivers to a load, and how to choose and check them so that the machine meets its specification with margin.
The mechatronic chain
Every mechatronic machine is a chain. The sensors turn a mechanical quantity (an angle, a force, an acceleration) into an electrical signal. The controller, usually a microcontroller, compares what is happening with what should happen and computes a command, as in Control of mechanical systems. The driver takes that low-power command and meters out real power from the supply: an H-bridge of transistors for a motor, a valve for a hydraulic cylinder. The actuator turns that power into force or torque. The transmission (gears, belts, screws, linkages from Mechanisms and linkages) trades force for speed and carries the motion to the load.
Two paths run through the chain, and keeping them separate in your head (and on the circuit board) is half of good mechatronic design. The signal path carries information at milliwatts and must be precise and fast. The power path carries energy at watts to kilowatts and must be efficient, cool and safe. A good design asks of every link what limits it, because the chain is only as good as its weakest link: the best controller cannot exceed the actuator's torque, and the strongest actuator cannot position a load more precisely than its sensor can measure.
Sensors: how a machine feels
Definition— encoder, strain gauge, accelerometer
An incremental encoder produces pulses as a shaft turns, on two channels a quarter of a cycle apart (quadrature), so that the direction is known and each line on its disc can be counted four times. An absolute encoder reports the actual angle as a number, even just after power-up. A strain gauge is a thin metal-foil grid bonded to a part; when the part strains by , the grid's resistance changes by , with gauge factor for metal foil. Four gauges in a Wheatstone bridge, two stretched and two compressed, give an output voltage for an excitation voltage , and cancel the effect of temperature on all four. An accelerometer measures acceleration (including gravity) through the force on a tiny proof mass: MEMS accelerometers etch the mass and its springs into silicon; piezoelectric ones use a crystal that produces charge when squeezed.
The program puts numbers on all three. An encoder on a motor that drives a ball screw through a gearbox; a steel cantilever load cell with a full bridge (the bending stress at its root is , from Axial load, torsion and bending); and a stationary accelerometer whose output is integrated twice, as if to find position.
import numpy as np
# 1. An incremental encoder, read in quadrature (four counts per line), on a motor that drives a
# ball screw through a gearbox. What is one count worth at the table?
lines, gear, lead = 1000, 5.0, 10e-3 # lines per revolution, gear ratio, screw lead (m/rev)
counts = 4 * lines
print(f"encoder: {counts} counts per motor revolution; one count moves the table "
f"{1e6 * lead / gear / counts:.2f} micrometres")
# 2. A strain-gauge load cell: a steel cantilever 100 mm long, 20 mm wide, 6 mm thick, with four foil
# gauges near its root (two on top in tension, two underneath in compression) in a full bridge.
E, L, b, h = 200e9, 0.100, 0.020, 0.006 # Pa, m, m, m
GF, V_ex = 2.0, 5.0 # gauge factor, bridge excitation (V)
for F in (10.0, 50.0, 100.0):
stress = 6 * F * L / (b * h**2) # bending stress at the root, M c / I = 6 M / (b h^2)
strain = stress / E
print(f"load {F:5.0f} N: strain {1e6 * strain:6.1f} microstrain, bridge output "
f"{1e3 * GF * strain * V_ex:.3f} mV")
# A 24-bit converter with a +/-20 mV input range: what force is one least significant bit?
lsb = 40e-3 / 2**24
print(f"one bit of a 24-bit converter over +/-20 mV is {1e9 * lsb:.1f} nV, i.e. "
f"{1e3 * lsb / (GF * V_ex * 6 * L / (b * h**2 * E)):.2f} mN on this cell")
# 3. Why accelerometers do not measure position: integrate a stationary accelerometer's output twice.
rng = np.random.default_rng(1)
fs, T = 1000, 60.0 # 1 kHz sampling for one minute
bias, noise = 0.002 * 9.81, 0.01 * 9.81 # a 2 milli-g bias and 10 milli-g of noise (rms)
a = bias + noise * rng.standard_normal(int(fs * T))
v = np.cumsum(a) / fs
x = np.cumsum(v) / fs
for t in (1, 10, 60):
print(f"after {t:2d} s at rest, the integrated 'position' has drifted {x[t * fs - 1]:8.3f} m")A thousand-line encoder, through a 5:1 gearbox and a 10 mm lead screw, resolves half a micrometre at the table, which is why precision machines can be built with ordinary encoders. The load cell's whole working range is a few millivolts, 4.2 mV at 100 N, so its signal needs a careful amplifier and converter; on paper one bit of a 24-bit converter is 0.06 mN.
The accelerometer result is the important one. A tiny bias of 2 thousandths of , integrated twice, becomes a position error that grows with the square of time: 7 mm after one second, almost a metre after ten, 34 m after a minute. Accelerometers are superb for what they measure directly, vibration (the modal testing of Vibrations), tilt, impacts and orientation in phones, but position needs a position sensor, or an accelerometer whose drift is constantly corrected by one, which is what the Kalman filters of Lumenary Robotics do.
Electric motors from the mechanical side
From the shaft, a motor is described by how much torque it can deliver at each speed. For a brushed or brushless DC motor at a fixed supply voltage, the back-EMF grows with speed and leaves less voltage to drive current, so the torque falls in a straight line from the stall torque at rest to zero at the no-load speed. Mechanical power, torque times speed, is therefore a parabola, greatest at half the no-load speed. A motor drive adds a second limit: it caps the current, and so the torque, to protect the motor and itself.
Gearing changes what the load sees. A gearbox of ratio (motor turns per output turn) multiplies torque by (less friction losses) and divides speed by . It also changes inertia: a load inertia feels like at the motor, because both its acceleration and its torque are scaled by . For accelerating a load, that gives a beautiful result.
Theorem— Inertia matching
A motor of rotor inertia and torque drives a pure inertia through an ideal gearbox of ratio . The load's angular acceleration, , is greatest when , that is, when the load's inertia reflected to the motor, , equals the rotor's own.
Proof
, which is positive below and negative above it. With too small a ratio the motor's torque is not multiplied enough; with too large a one, the motor spends its torque accelerating its own rotor, which spins times faster than the load.
∎
The program applies this to a real task with a real motor's limits. An indexing table of 0.03 kg·m² must turn 90° and stop, as fast as possible, driven by the motor in the figure (rotor inertia kg·m², torque capped at 0.9 N·m, and never more than the torque–speed line allows). It simulates the fastest rest-to-rest move for a range of gear ratios, then checks whether the motor would overheat repeating it.
import numpy as np
# A brushed DC servomotor seen from the mechanical side: at a fixed supply voltage, its torque
# falls in a straight line from the stall torque at rest to zero at the no-load speed.
T_stall, n0 = 1.2, 4000.0 # stall torque (N m); no-load speed (rpm)
w0 = n0 * 2 * np.pi / 60 # no-load speed (rad/s)
print(" speed torque power")
for f in (0, 0.25, 0.5, 0.75, 1.0):
w = f * w0
T = T_stall * (1 - w / w0)
print(f"{w * 60 / (2 * np.pi):6.0f} rpm {T:6.2f} N m {T * w:6.0f} W")
# The job: turn an indexing table (inertia J_L) through 90 degrees and stop, as fast as possible.
# The drive limits the current, so the torque is at most T_pk, and never more than the line allows.
J_m, J_L = 6e-5, 0.03 # rotor inertia; table inertia (kg m^2)
T_pk, theta, dt = 0.9, np.pi / 2, 1e-5
def move(N):
"""Rest-to-rest move with gear ratio N (motor turns per table turn): full available torque,
then full braking torque -T_pk, switching when the braking distance equals what is left.
Returns the move time, the peak motor speed (rpm) and the motor torque at each step."""
J = J_L + N**2 * J_m # inertia felt at the table
w = phi = t = 0.0 # table speed (rad/s), angle (rad), time (s)
torques = []
while phi + w**2 / (2 * N * T_pk / J) < theta: # until it is time to brake
T = min(T_pk, T_stall * (1 - N * w / w0))
w += N * T / J * dt; phi += w * dt; t += dt
torques.append(T)
t_brake = w / (N * T_pk / J)
torques += [-T_pk] * int(round(t_brake / dt))
return t + t_brake, N * w * 60 / (2 * np.pi), np.array(torques)
print(f"\ninertia-matching ratio sqrt(J_L / J_m) = {np.sqrt(J_L / J_m):.1f}")
print(" ratio table inertia seen top motor move time")
print(" by the motor (x J_m) speed")
for N in (3, 5, 10, 14, 18, 22.4, 30, 50):
t, n_top, T = move(N)
print(f"{N:6.1f} {J_L / N**2 / J_m:9.1f} {n_top:6.0f} rpm {1000 * t:6.0f} ms")
t, N = min((move(N)[0], N) for N in np.arange(5, 40, 0.5))
print(f"fastest: ratio {N:.1f}, {1000 * t:.0f} ms")
# Will it overheat? Repeat the move every 0.5 s: the winding heats with the square of the current,
# so the motor's continuous torque rating must exceed the rms torque over the whole cycle.
t, n_top, T = move(N)
for cycle in (0.5, 1.0, 2.0):
print(f"one move every {cycle} s: rms motor torque {np.sqrt(np.sum(T**2) * dt / cycle):.2f} N m")With a 3:1 ratio the move takes 267 ms, because the motor's torque is barely multiplied; with 50:1 it takes 230 ms, because the motor is pinned at its no-load speed. In between the curve is flat: anything from about 14:1 to 22:1 is within a few milliseconds of the best, 147 ms at 17:1. The fastest ratio sits a little below the inertia-matching value of 22.4 because the theorem ignores the motor's speed limit; with a high ratio the motor runs out of speed before the table runs out of distance. That is typical: inertia matching is the right starting point, and a simulation with the real limits gives the answer.
Brushed DC motors are now mostly found in small, cheap products; machines use brushless permanent-magnet servomotors (the same torque–speed physics, with electronic commutation), stepper motors, which move in fixed steps without needing a sensor but lose position silently if overloaded, and induction motors, the robust workhorses of pumps, fans and conveyors, run at variable speed by inverters.
Hydraulic and pneumatic actuators
Where large forces are needed in a small space, mechanical engineers turn to fluid power. A cylinder converts pressure into force and flow into speed, by nothing more than the piston's area:
Hydraulics works at 100 to 350 bar (10 to 35 MPa), so modest cylinders produce tens or hundreds of kilonewtons; oil is nearly incompressible, so the actuator is stiff and holds position under load; and a pump far away can be connected by flexible hoses. That is why diggers, presses, aircraft flight controls, injection-moulding machines and heavy lifting gear use it. Its costs are a pump running continuously or a power pack, leaks, heat in the oil, and serious hazards from stored pressure. Pneumatics works at about 6 bar, so forces are smaller; air is compressible, so pneumatic cylinders are springy and hard to stop accurately in mid-stroke, and are mostly used end to end, for clamping, gripping, pushing parts off conveyors. They are cheap, clean, fast and tolerant of stalling, but compressed air is an expensive way to deliver energy.
import numpy as np
def cylinder(bore, rod, p, Q):
"""Ideal double-acting cylinder: forces (N) and speeds (m/s) extending and retracting.
bore, rod: diameters (m); p: supply pressure above the return line (Pa); Q: supply flow (m^3/s)."""
A_cap = np.pi * bore**2 / 4 # full piston area, pushed when extending
A_ann = A_cap - np.pi * rod**2 / 4 # annulus area, pushed when retracting
return p * A_cap, p * A_ann, Q / A_cap, Q / A_ann
# A hydraulic cylinder on a small press or a digger's arm: 63 mm bore, 36 mm rod, 160 bar, 20 L/min.
F_out, F_in, v_out, v_in = cylinder(0.063, 0.036, 160e5, 20e-3 / 60)
print("hydraulic, 63/36 mm at 160 bar and 20 L/min:")
print(f" extend : {F_out / 1e3:5.1f} kN at {1e3 * v_out:4.0f} mm/s")
print(f" retract: {F_in / 1e3:5.1f} kN at {1e3 * v_in:4.0f} mm/s")
print(f" hydraulic power p Q = {160e5 * 20e-3 / 60 / 1e3:.1f} kW")
# A pneumatic cylinder on a packaging machine: 50 mm bore, 20 mm rod, 6 bar gauge, 200 mm stroke.
bore, rod, p_g, stroke = 0.050, 0.020, 6e5, 0.200
F_out, F_in, _, _ = cylinder(bore, rod, p_g, 0.0)
print("\npneumatic, 50/20 mm at 6 bar:")
print(f" extend : {F_out:5.0f} N retract: {F_in:5.0f} N")
# Each stroke fills the cylinder with compressed air, which is then exhausted and lost.
p_atm = 1.013e5
V_cyl = np.pi * bore**2 / 4 * stroke + (np.pi * bore**2 / 4 - np.pi * rod**2 / 4) * stroke
free_air = V_cyl * (p_g + p_atm) / p_atm # volume at atmospheric pressure, per double stroke
work_out = (F_out + F_in) * stroke # most mechanical work it could do per double stroke
# Electrical energy to compress that air: ideal isothermal work, divided by a realistic 50 per cent
# for the compressor's motor, compression heat lost and pressure drops in the pipes.
W_iso = p_atm * free_air * np.log((p_g + p_atm) / p_atm)
print(f" free air per double stroke: {1e3 * free_air:.2f} L")
print(f" mechanical work out at most {work_out:.0f} J; electricity in about {W_iso / 0.5:.0f} J "
f"-> {100 * work_out / (W_iso / 0.5):.0f} per cent at best")
cycles = 20 * 60 * 16 * 250 # 20 strokes a minute, 16 h a day, 250 days a year
print(f" at 20 cycles a minute for a working year: {W_iso / 0.5 * cycles / 3.6e6:.0f} kWh")
# A 1 mm hole leaking at 6 bar: choked flow, about 0.0404 * Cd * A * p0 / sqrt(T0) kg/s.
A_leak, T0, Cd = np.pi * 0.001**2 / 4, 293.0, 0.8
mdot = 0.0404 * Cd * A_leak * (p_g + p_atm) / np.sqrt(T0)
print(f" a 1 mm leak wastes {mdot / 1.2 * 1e3 * 60:.0f} L of free air a minute: "
f"{mdot / 1.2 * p_atm * np.log((p_g + p_atm) / p_atm) / 0.5 * 8760 / 1e3:.0f} kWh a year if never fixed")The hydraulic cylinder, the size of a forearm, pushes with 50 kN, five tonnes-force, at about 0.1 m/s, from 5.3 kW of hydraulic power. Retracting, it pulls with only two-thirds of that force but moves half as fast again, the asymmetry in the figure. The pneumatic cylinder pushes with 1.2 kN. Each double stroke exhausts 5 litres of free air, and the electricity spent compressing it is at least four times the work the cylinder can do: about 22 per cent at best, and often much less, because a cylinder seldom needs its full force over its whole stroke. Over a working year that one cylinder uses about 2600 kWh, and a single 1 mm leak, left alone, wastes more than that again. Factories that audit their compressed air usually find leaks are among their largest avoidable energy costs, and many replace pneumatic axes with electric ones where they move often.
Microcontrollers in machines
The controller in most small machines is a microcontroller: a processor, memory, timers, analogue-to-digital converters and communication interfaces on one chip, costing from well under a dollar to a few dollars. From the mechanical side, four of its abilities matter. Hardware counters read quadrature encoders without missing a pulse, however busy the processor is. Timers run the control loop at a fixed rate, typically 1 to 20 kHz for a motor's current or position loop, and generate the pulse-width modulation (PWM) that switches the driver's transistors on and off tens of thousands of times a second, so that the motor sees an average voltage set by the duty cycle. Converters read strain gauges, temperatures and currents. And communication links it to the rest of the machine. Lumenary EE's microcontrollers lesson explains the chip; Lumenary Robotics' embedded control and safety explains how real-time loops are scheduled.
A position loop in firmware is short. This sketch, in C for a generic microcontroller (not run here; the encoder, PWM and timer functions come from the chip maker's libraries), is the PID and clamping anti-windup of the previous lesson in a dozen lines:
/* Firmware sketch, not run here: a 1 kHz position loop for a DC motor on an H-bridge. */
#include <stdint.h>
#define KP 0.8f /* duty cycle per encoder count of error */
#define KI 0.002f /* added to the integral per count, per tick */
#define KD 4.0f /* duty per (count per tick) of speed */
volatile int32_t target; /* set by the motion planner */
static int32_t last_pos;
static float integral;
void timer_1khz_isr(void) /* called by a hardware timer every millisecond */
{
int32_t pos = encoder_count(); /* hardware quadrature counter */
float e = (float)(target - pos);
float u = KP * e + integral - KD * (float)(pos - last_pos);
last_pos = pos;
if (u > 1.0f) u = 1.0f; /* duty-cycle limits: the actuator saturates */
else if (u < -1.0f) u = -1.0f;
else integral += KI * e; /* integrate only when not saturated */
pwm_set(u); /* the sign selects the H-bridge direction */
}In factories the same role is played by programmable logic controllers (PLCs), rugged industrial computers programmed in the languages of IEC 61131-3, and by dedicated motion controllers and servo drives that close current, velocity and position loops for many axes at once and talk to each other over real-time industrial networks.
Designing a small mechatronic axis
Here is the whole chain at work on a real design question: the vertical axis of a small desktop CNC router. A stepper motor turns an 8 mm lead screw with a bronze nut, lifting a 6 kg carriage and spindle. The requirements: move at 40 mm/s, accelerate at 0.5 m/s², and resist an upward cutting force of up to 50 N. The screw's lead (travel per turn) is the main choice, and it trades several things against each other: speed, torque, resolution, and whether the screw is self-locking, unable to be driven backwards by the load, so that the carriage stays put if the power fails. A screw is an inclined plane wrapped round a cylinder, one of the simple machines, with friction added: if its thread climbs at a lead angle and the friction coefficient defines a friction angle (slightly larger for a trapezoidal thread, whose sloping flanks wedge the nut), the efficiency raising a load is , and the screw self-locks when .
A stepper runs open loop: it is told to step and assumed to have stepped. If the load ever needs more torque than the motor's pull-out torque at that speed, it loses steps without knowing, and the machine's idea of where the tool is becomes wrong. So the design rule is a torque margin, here of 2, at the highest speed. Stepper torque falls with speed; the program uses an illustrative curve, not any particular product's.
import numpy as np
# Design check: the vertical (Z) axis of a small desktop CNC router. A stepper motor turns a lead
# screw (8 mm diameter, trapezoidal thread, bronze nut) that lifts the carriage and spindle.
m, F_cut = 6.0, 50.0 # moving mass (kg); upward cutting force to resist (N)
v, a = 0.040, 0.5 # required speed (m/s) and acceleration (m/s^2)
d_m, mu, flank = 0.0072, 0.15, np.radians(15) # mean thread diameter (m), friction, flank angle
J_rotor, steps = 8e-6, 200 * 16 # rotor inertia (kg m^2); microsteps per revolution
def pull_out(rpm):
"""Illustrative stepper torque curve (N m): 0.45 N m at low speed, halved by 400 rpm.
Real curves come from the maker's datasheet and depend on the driver's supply voltage."""
return 0.45 / (1 + rpm / 400)
def torque_needed(lead, F):
lam = np.arctan(lead / (np.pi * d_m)) # lead angle of the thread
phi = np.arctan(mu / np.cos(flank)) # friction angle (flanks wedge the nut)
eta = np.tan(lam) / np.tan(lam + phi) # efficiency when raising a load
T_acc = (J_rotor + m * (lead / (2 * np.pi)) ** 2) * a * 2 * np.pi / lead
return F * lead / (2 * np.pi * eta) + T_acc, lam, phi, eta
weight = m * 9.81
for spring in (0.0, weight): # without, then with a gas spring
F = m * a + weight - spring + F_cut # worst case: speeding up upwards while cutting
print(f"{'with a gas spring carrying the weight' if spring else 'no counterbalance'}: "
f"worst-case screw force {F:.0f} N")
print(" lead lead angle efficiency self-locking rpm needed available margin um/microstep")
for lead in (0.002, 0.004, 0.008):
T, lam, phi, eta = torque_needed(lead, F)
rpm = v / lead * 60
print(f" {1000 * lead:.0f} mm {np.degrees(lam):5.1f} deg {eta:4.2f} "
f"{'yes' if lam < phi else 'no ':3s} {rpm:5.0f} {T:.3f} Nm {pull_out(rpm):.3f} Nm"
f" {pull_out(rpm) / T:4.1f} {1e6 * lead / steps:5.2f}")
print()
print(f"step rate at 40 mm/s with the 2 mm lead: {v / 0.002 * steps:.0f} microsteps per second")Without a counterbalance, no lead passes. A fine 2 mm lead self-locks and resolves 0.6 µm per microstep, but needs 1200 rpm, where the stepper has little torque left: margin 1.0. A coarse 8 mm lead needs only 300 rpm but more torque per newton, and is not self-locking: margin 1.1, and the carriage would sink when the power is cut. The usual answer is mechanical, not electrical: a gas spring that carries the carriage's weight halves the worst-case force, giving the 4 mm lead a margin of 2.5 and the 2 mm lead 1.9. With the weight balanced, the risk of the carriage dropping is much reduced too, though a careful designer still adds a brake or chooses the self-locking lead. Notice also the last line: 64 000 step pulses a second for the 2 mm lead, a rate the microcontroller must generate with hardware timers, not software loops.
If you want to build something like this yourself, start small and low-voltage: a desktop axis driven from a protected 12 or 24 V supply, a hobby stepper or gearmotor, a microcontroller board, and parts you 3D-print, cut from plywood or buy as kits, built with supervision. Keep fingers, hair and loose clothing away from screws, belts and gears while they can move, never open mains-powered equipment, and treat large batteries, high-voltage drives and anything hydraulic as professional territory.
Mechatronics in industry, 2026
Electrification of motion. As of 2026 a broad trend replaces hydraulic and pneumatic axes with electric ones where efficiency, cleanliness and control matter: electric injection-moulding machines, all-electric presses for some tasks, battery-electric compact excavators, and on aircraft electro-hydrostatic actuators, each a self-contained electric motor, pump and cylinder, which remove long hydraulic lines. Hydraulics remains unbeaten for very high forces in small spaces and for rugged mobile machines, and the two are increasingly combined: variable-speed electric motors driving pumps only as fast as the load needs.
Integrated drives. Motors increasingly arrive with their encoder, drive and controller built in, networked to a central controller, and with self-tuning that identifies the load's inertia and resonances. Makers of motors, drives and fluid power are spread across Japan, Germany, Switzerland, Denmark, Sweden, Italy, the USA, China, Korea and elsewhere, and catalogues publish the torque–speed curves, continuous ratings and inertias this lesson used; read them with the duty cycle in hand.
Standards. Rotating machines are rated under the IEC 60034 series, which also defines the efficiency classes that many countries now require for industrial motors; fluid-power systems follow ISO 4413 and ISO 4414; and the safety functions that stop a machine are designed to ISO 13849 or IEC 62061.
Open tools. Much of the practice is open: Arduino boards and their libraries for learning and prototyping, open-source 3D-printer firmware such as Klipper, whose documentation discusses step timing and resonance compensation in real machines, and open motor-control projects that publish their hardware and firmware.
A short history
Joseph Bramah patented the hydraulic press in 1795, and by the late nineteenth century London had a public high-pressure water main that powered lifts and cranes across the city. Bonded wire strain gauges were invented independently by Edward Simmons at Caltech and Arthur Ruge at MIT in 1938. Servomotors and synchros aimed guns and radars in the Second World War; numerically controlled machine tools followed in the 1950s; the microprocessor of 1971 made it cheap to put a computer in a machine, and Mori's word "mechatronics" spread with it from Japan in the 1970s and 1980s. MEMS accelerometers went into mass production in the 1990s, first to trigger car airbags, and then into every phone.
Common misconceptions
Misconception
"A bigger motor is always safer." A bigger motor brings a bigger rotor inertia, which it must accelerate along with the load, and a heavier, costlier machine. For fast moves, a correctly geared smaller motor often beats a larger one. Size by the duty cycle: peak torque at speed, rms torque against the continuous rating, and inertia ratio.
Misconception
"Gear down as much as possible for the most torque." Beyond the inertia-matching ratio, more reduction makes acceleration worse, because the motor spends its torque spinning its own rotor ever faster, and it soon hits its speed limit. The lesson's table was slower at 50:1 than at 10:1.
Misconception
"Stepper motors always know where they are." They know only how many steps they were told to make. Overload one, or ask it to accelerate too quickly, and it slips silently. Open-loop steppers need a torque margin and a homing switch; closed-loop steppers and servomotors add an encoder.
Misconception
"Compressed air is free: it is just air." The air is free; compressing it is not. Most of the electricity a compressor uses becomes heat, and a pneumatic cylinder typically delivers well under a quarter of that energy as work, before counting leaks.
Exercises
Use m/s². Two exercises ask for Python functions; run them in the editor before submitting.
1. Mechatronics and actuators
Warm-upHumanA motor carries a 500-line incremental encoder, read in quadrature, and drives a conveyor roller through a 15:1 gearbox. How many encoder counts correspond to one revolution of the roller?
2. Mechatronics and actuators
Warm-upHumanA load cell has four foil gauges (gauge factor 2.0) in a full Wheatstone bridge, two in tension and two in compression, excited at 5.0 V. At full load the gauges see microstrain. What is the bridge's output at full load, in millivolts?
3. Mechatronics and actuators
CoreHumanA DC motor at a fixed supply voltage has a straight torque–speed line from its stall torque at rest to zero torque at its no-load speed . At what speed does it deliver the most mechanical power?
4. Mechatronics and actuators
CoreHumanA servomotor with rotor inertia kg·m² must accelerate a rotating fixture of inertia 0.018 kg·m² as quickly as possible. Ignoring speed limits and friction, what gear ratio (motor turns per fixture turn) gives the greatest acceleration?
5. Mechatronics and actuators
Warm-upHumanA pneumatic cylinder with a 40 mm bore is supplied at 6.0 bar gauge. What is its ideal extending force, in newtons, to the nearest whole number?
6. Mechatronics and actuators
CoreHumanThree jobs: (1) gripping and releasing cartons on a packaging line, end to end, many times a minute; (2) the boom of a compact digger, lifting several tonnes on a machine that must be rugged and portable; (3) positioning a laser cutter's head to within 10 µm along a 1 m axis. Which assignment of actuators fits best?
7. Mechatronics and actuators
CoreComputationalWrite move_time(N, T_pk, w_max, J_m, J_L, theta): the shortest rest-to-rest move of an inertia through angle theta, driven through gear ratio by a motor of rotor inertia , torque limit T_pk and top speed w_max (rad/s). Accelerate and brake at full torque, and coast at the motor's top speed if the move is long enough to reach it.
The starter forgets the speed limit. Run the tests to see it fail, then fix it.
8. Mechatronics and actuators
CoreComputationalWrite smallest_bore(F_extend, F_retract, p, rod_ratio, bores) returning the smallest bore diameter (m) in the list bores whose double-acting cylinder can push F_extend and pull F_retract (N) at pressure p (Pa), with a rod of diameter rod_ratio times the bore; return None if none is big enough.
The starter makes a common sizing mistake. Run the tests, then fix it.
Further reading and resources
- IEC, the International Electrotechnical CommissionPublishes the IEC 60034 series on rotating electrical machines (ratings, efficiency classes) and IEC 61131-3, the programming languages of industrial PLCs.
- ISO, the International Organization for StandardizationPublishes ISO 4413 and ISO 4414, the general rules and safety requirements for hydraulic and pneumatic systems.
- ArduinoOpen-source microcontroller boards and tools, widely used for learning and prototyping mechatronics.
- KlipperOpen-source 3D-printer firmware whose documentation explains step timing, kinematics and resonance compensation in real machines.
- MIT OpenCourseWare · Massachusetts Institute of TechnologySearch it for MIT's mechatronics, system dynamics and robotics courses, with free lecture notes on sensors, actuators and drives.