Can this servo, stepper or DC motor make this move?

A point-to-point move accelerates at a, runs at the top speed v_max, and decelerates at d. The area under the velocity–time profile is the distance s.

s_accel = v_max² / (2·a)         distance the acceleration uses
s_decel = v_max² / (2·d)         distance the deceleration uses

if s_accel + s_decel ≤ s   (trapezoid — the top speed is reached)
    t_accel  = v_max / a
    t_cruise = (s − s_accel − s_decel) / v_max
    t_decel  = v_max / d
else                        (triangle — the acceleration runs straight into the deceleration)
    v_peak   = √( 2·s·a·d / (a + d) )
    t_accel  = v_peak / a,   t_cruise = 0,   t_decel = v_peak / d

t_total = t_accel + t_cruise + t_decel

The inverse — the time is given, what speed and acceleration does it need? — splits the time into acceleration, cruise and deceleration by two fractions and reads the peak speed off the area:

t_accel = f_accel·t_total,   t_decel = f_decel·t_total,   t_cruise = the rest
v_peak  = s / (t_accel/2 + t_cruise + t_decel/2)
a = v_peak / t_accel,   d = v_peak / t_decel

Worked example. 100 mm at 0.5 m/s with 3.5 m/s²: accelerating and decelerating need 35.7 mm each, so the move is a trapezoid — 0.143 s accelerating, 0.057 s cruise, 0.143 s decelerating, 0.343 s in all. Halve the distance and it turns triangular, peaking at 0.418 m/s in 0.239 s.

On the cyclogram this whole move — all three phases — is the bar's ramp-up (the stroke out); the body is the stay at the end position, and the ramp-down is the move back. A bar is travel over time, not speed.

Package motion-time (calcpkg/1, open format) — pure functions with tests; the browser version is held against it number for number.

The motor only knows shaft speed and torque. A screw of lead p behind a gearbox of ratio i moves the table K = p / i per motor turn:

n_motor = v / K · 60                            [rpm]
α_motor = a / K · 2π                            [rad/s²]

c = p / (2π · η_screw · η_trans · i)              N at the table → N·m at the motor
T_gravity  = (m − m_cw)·g·sin α · c
T_friction = μ·m·g·cos α · c
T_external = F_ext · c
T_preload  = μ₀·F₀·p / 2π / (i·η_trans)           nut preload drag
T_static   = T_gravity + T_friction + T_external + T_preload

J_load  = (m + m_cw)·(p/2π)² / i²                a mass on a drum of radius p/2π
J_mech  = J_screw / i²
J_total = J_load + J_mech + J_trans + J_rotor

T_accel = J_load·α/η + J_mech·α/η + J_trans·α/η_t + J_rotor·α + T_static
T_decel = T_static − ( (J_load + J_mech)·α_d·η + J_trans·α_d·η_t + J_rotor·α_d )
T_peak  = max |T| over the three phases

Load-side inertia is driven through the efficiency chain while accelerating (divided by η) and drives the motor while decelerating (multiplied by η) — the conservative sizing-sheet rule; catalogue procedures that put no η on the inertial term give a slightly lower acceleration torque. The result per phase (duration, torque, speed) is what the motor check turns into an RMS.

Checked against Oriental Motor's published ball-screw selection examples (vertical table with preload; horizontal stepper table): agreement within 0.5 %.

Package mech-ball-screw (calcpkg/1, open format) — pure functions with tests; the browser version is held against it number for number.

A pulley of pitch diameter D behind a ratio i moves the belt K = π·D / i per motor turn. Forces reach the motor through the pulley radius, masses through its square:

n_motor = v / K · 60,   α_motor = a / K · 2π
c = D / (2 · η_belt · η_trans · i)
T_static = [ (m − m_cw)·g·sin α + μ·m·g·cos α + F_ext ] · c

J_load  = (m + m_cw + m_belt)·(D/2)² / i²        the belt mass rides along
J_mech  = J_pulleys / i²
T_accel = J_load·α/η + J_mech·α/η + J_trans·α/η_t + J_rotor·α + T_static
T_decel = T_static − ( (J_load + J_mech)·α_d·η + J_trans·α_d·η_t + J_rotor·α_d )

Belt tension loads the bearings, not the motor, so it does not appear. A belt axis reflects a large inertia onto a direct-coupled motor — the example's ratio of 138 is typical and is why belt axes usually carry a gearbox.

Checked against Oriental Motor's belt-conveyor and belt-table selection examples: agreement within 0.5 %.

Package mech-belt-drive (calcpkg/1, open format) — pure functions with tests; the browser version is held against it number for number.

The same decomposition as a belt, on the sprocket's pitch diameter and with the chain's mass in the loop:

K = π·D / i,   n_motor = v / K · 60,   α_motor = a / K · 2π
c = D / (2 · η_chain · η_trans · i)
T_static = [ (m − m_cw)·g·sin α + μ·m·g·cos α + F_ext ] · c
J_load  = (m + m_cw + m_chain)·(D/2)² / i²,   J_mech = J_sprockets / i²
T_accel = J_load·α/η + J_mech·α/η + J_trans·α/η_t + J_rotor·α + T_static
T_decel = T_static − ( (J_load + J_mech)·α_d·η + J_trans·α_d·η_t + J_rotor·α_d )

The chordal speed variation of a chain on a small sprocket — a few percent — is neglected; the sprocket is treated as a round drum. For a conveyor, m is everything on the moving run and μ its friction on the bed.

Package mech-chain-sprocket (calcpkg/1, open format) — pure functions with tests; the browser version is held against it number for number.

A pinion of pitch diameter D through the gearbox a rack axis nearly always carries:

K = π·D / i,   n_motor = v / K · 60,   α_motor = a·i / (D/2)
c = D / (2 · η_mesh · η_gearbox · i)
T_static = [ (m − m_cw)·g·sin α + μ·m·g·cos α + F_ext ] · c
J_load  = (m + m_cw)·(D/2)² / i²,   J_mech = J_pinion / i²
T_accel = J_load·α/η + J_mech·α/η + J_trans·α/η_t + J_rotor·α + T_static
T_decel = T_static − ( (J_load + J_mech)·α_d·η + J_trans·α_d·η_t + J_rotor·α_d )

Whether the motor rides on the carriage (moving pinion) or the rack moves past a fixed pinion, m is everything that translates. The example's 5:1 ratio brings a 20 kg carriage to an inertia ratio of 3.3; at 1:1 it would be 82.

Package mech-rack-pinion (calcpkg/1, open format) — pure functions with tests; the browser version is held against it number for number.

K = π·D / i,   n_motor = v / K · 60,   α_motor = a / K · 2π
c = D / (2 · η · η_trans · i)
T_static = [ F_tension + μ_press·F_press + F_ext ] · c      back tension, drag through the press
J_load  = m_strip·(D/2)² / i²                              the strip mass in motion
J_mech  = (J_roll_drive + J_roll_driven) / i²              both rolls turn at the roll speed
T_accel = J_load·α/η + J_mech·α/η + J_trans·α/η_t + J_rotor·α + T_static
T_decel = T_static − ( (J_load + J_mech)·α_d·η + J_trans·α_d·η_t + J_rotor·α_d )

With a real back tension the deceleration torque usually stays positive: the strip cannot push, so the tension keeps braking the feed. No slip between roll and strip is assumed — the feed force must stay below μ·F_pinch, which is a roll-design check, not a motor one.

Package mech-roll-feeder (calcpkg/1, open format) — pure functions with tests; the browser version is held against it number for number.

The profile is angular here (rad, rad/s, rad/s²). Through a reducer of ratio i:

n_motor = ω / 2π · i · 60,   α_motor = α_table · i
c = 1 / (η_reducer · η_coupling · i)
T_static = (T_external + T_friction) · c
J_load   = J_table / i²
T_accel  = J_load·α/η + J_trans·α/η_t + J_rotor·α + T_static
T_decel  = T_static − ( J_load·α_d·η + J_trans·α_d·η_t + J_rotor·α_d )

J_table = table itself + every workpiece:  J = m·(d_outer² + d_inner²)/8 + m·r²
                                          (a cylinder about its own axis, plus the parallel-axis term at radius r)

A horizontal table (vertical axis) has no gravity torque. A self-locking worm never lets the table drive the motor; the package still reports the signed deceleration torque so the drive's regeneration can be judged.

Checked against Oriental Motor's index-table example (ten loads at 125 mm on a Ø300 table): inertia and torque within 0.5 %.

Package mech-rotary-table (calcpkg/1, open format) — pure functions with tests; the browser version is held against it number for number.

F_gravity  = (m − m_cw)·g·sin α
F_friction = μ · ( m·g·cos α + F_attraction )        iron-core motors pull toward the track
F_static   = F_gravity + F_friction + F_ext

F_accel = (m + m_cw)·a + F_static
F_cruise = F_static
F_decel = F_static − (m + m_cw)·d
F_peak  = max |F|
F_rms   = √( Σ F_i²·t_i / (Σ t_i + t_dwell) )

check:  F_peak ≤ F_peak,motor    F_rms ≤ F_continuous    v_peak ≤ v_max

There is no gearbox to hide behind: if the continuous force is short, the cycle needs a longer dwell, a gentler profile, or the next motor size.

Package mech-linear-motor (calcpkg/1, open format) — pure functions with tests; the browser version is held against it number for number.

T_rms = √( Σ T_i²·t_i / (Σ t_i + t_dwell) )        heating torque over the cycle
duty  = Σ t_i / (Σ t_i + t_dwell)
ratio = J_load_reflected / J_rotor

servo    T_peak ≤ T_peak,motor      T_rms ≤ T_rated      n ≤ n_rated (up to n_max: warning, torque derates)
         inertia ratio ≤ 10 fine, 10–30 warns, > 30 fails (gear it down by i ≈ √(ratio/10))

stepper  f = n/60 · 360/step angle                 full steps per second
         T_peak · safety factor (2) ≤ pull-out torque at f (linear interpolation of the curve)
         an unramped move must start with f ≤ f_self-start
         inertia ratio ≤ 5 direct, ≤ 10 geared (warn);  duty > 50 % warns;  n > 1000 rpm: consider closed loop

dc       n_motor = n·i,   T_motor = T / (i·η)
         T_available = T_stall · (1 − n_motor/n0)      the straight torque–speed line
         T_motor · 1.3 ≤ T_available,   n_motor < n0,   T_rms,motor ≤ ½·T_stall (thermal)
         short of torque → i ≈ n0 / (2·n) puts the motor at its maximum-power point

Checked against Oriental Motor's AZM66AC selection example: required torque with the safety factor and the inertia ratio reproduced within 1 %.

Package motor-move-check (calcpkg/1, open format) — pure functions with tests; the browser version is held against it number for number.