Gear Train — Robotics/Actuators And Drivetrain

Gear Train

Robotics / Actuators And Drivetrain

An ideal gear ratio with a real efficiency: ω_out = ω_in / N and τ_out = N · η^±1 · τ_in. A reducer trades speed for torque exactly; the efficiency is what it keeps of that trade.

The exponent follows the power flow, and that is the whole block. Driving forward, the output receives η of the ideal torque. When the load drives the gearbox back – regenerative braking, an overhauling load, a robot arm being pushed – the input shaft must be fed 1/η of it instead. A pair of Gain blocks can only apply one of the two factors, so it is right on half a duty cycle and quietly wrong on the other half.

Power flow is read from the two signs: the load is driving back when ω_in and τ_in disagree in sign, and the shaft is driving forward otherwise.

Ports

• omega_in – the input shaft speed, any size [m,n] (rad/s, per the family's convention).
• tau_in – the torque applied to the input shaft, positive in the direction of positive omega_in. It must be the same size as omega_in; the two are paired entry by entry as one shaft's state, and neither is broadcast over the other.
• omega_out – the output shaft speed ω_in/N, the same size as the inputs.
• tau_out – the output torque, the same size as the inputs.

Parameters

• Gear Ratio – N = ω_in / ω_out, a scalar. Greater than one is a reduction (slower, stronger); a negative N is a train that reverses direction, and is accepted. Zero is rejected. Default 10.
• Efficiency – η, a scalar in (0, 1]. The default 1 is a lossless gearbox, at which both branches are the same function – set it below one to model a real train, and note that a test which leaves it at the default verifies only half of this block.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text.

The three HDL targets are genuinely synthesizable Q16.16, not simulation-only: the block emits two comparisons and one multiply per output, with no division and nothing transcendental in the datapath.

N and η are inlined at export, not tunable. What the generated core carries is the three folded coefficients 1/N, N·η and N/η, computed once when the config is read. Exposing the ratio and the efficiency as retunable parameters would mean re-deriving those three on the core – which is exactly the divider the folding exists to keep out of the hardware. Re-export to change a gearbox.

Because both branches are pure multiplication by a constant, every backend agrees with the C++ reference to the last bit in software. The fixed-point targets carry one exposure worth stating: a sample whose omega_in or tau_in lies within one quantum (≈1.5×10⁻⁵) of zero can take the other branch in Q16.16 than it does in double precision. The two factors differ by η², so such a sample is out by that ratio on a torque that is itself near the noise floor.

Simulink bridge

No equivalent (Support::None). The counterpart is Simscape Driveline's Simple Gear, and Simscape is not installed on this machine (measured: isfolder([matlabroot '/toolbox/simscape']) is false, as for the Robotics System Toolbox). It is a physical-network block in any case, so it would not map onto a signal-flow port list without an interpretation this block would have to invent. To rebuild the behaviour in Simulink: a Gain of 1/N on the speed path, and on the torque path a Switch between gains N·η and N/η driven by a sign comparison of the two inputs – keep the switch's zero case on the forward gain, as this block does.

Notes

• Algebraic and stateless: both outputs depend only on the current inputs, so the block cannot break an algebraic loop. It carries no inertia and no compliance – put those in the plant on either side of it ( DC Motor upstream, Two Mass Drivetrain for a flexible shaft).
• Piecewise linear, and deliberately carries no state space. The two half-spaces have different torque gains, so a single (A, B, C, D) would describe one branch and misrepresent the other; a fabricated linear form would let model reduction merge matrices that do not describe this block.
• At zero power the forward factor applies. With ω_in = 0 (a stalled shaft holding a load) or τ_in = 0 no power crosses the mesh and neither factor follows from physics; charging η there is this block's convention, stated rather than derived.
• Efficiency is a single constant, not a friction model. A real train's η falls at low load and with temperature; if that matters, drive this block from a lookup and put a Stribeck Friction term on the shaft.
• The output torque is what the gearbox delivers, not what the load accepts. Nothing here checks that the two are consistent – this is a signal-flow block, not a physical network.