The Machine That Missed the Cycle Time by 3 Seconds
We designed a machine for a customer. The required cycle time was 12 seconds per part. On paper (in the design calculation), we summed the move times: robot pick (2 s), place (2 s), press (3 s), index (2 s), sensor check (1 s). Total: 10 seconds. We told the customer “10 seconds, with margin.” On the floor, the actual cycle was 13 seconds. The robot moved slower than calculated (we used the rated speed, not the actual acceleration/deceleration ramps). The press took 3.5 seconds (not 3) because the ram accelerated slowly. The index table took 2.5 seconds (not 2). The “non-value” time (sensor settling, valve response, PLC scan) added another 0.5 seconds. We missed the customer’s spec by a second. The mistake was using idealized numbers (rated speeds) instead of real ramps and settling times. We should have added 20% margin to every move.
Machine cycle time calculation is the sum of every move and delay. Get it wrong, and the machine doesn’t meet the customer’s throughput. This article covers the method.
The Cycle Time Formula
The cycle time is the sum of every element in one cycle:
T_cycle = T_pick + T_place + T_process + T_index + T_sensor + T_overhead
Each element is the actual time, not the rated time.
Step 1: List Every Move
Walk through the machine’s sequence. List every action:
- Robot move to pick (with acceleration/deceleration).
- Gripper close.
- Robot move to place.
- Gripper open.
- Press down (ram acceleration + force + dwell + retract).
- Index table rotate (acceleration + rotate + deceleration + settle).
- Sensor check (the sensor settling time).
- Conveyor advance.
Don’t skip the small ones. A 0.2-second gripper close, repeated every cycle, adds up.
Step 2: Use Real Move Times (Not Rated Speeds)
The robot’s datasheet says “maximum speed 2 m/s.” But the actual move time includes acceleration and deceleration. A short move (100 mm) never reaches 2 m/s — it accelerates, moves, and decelerates. The actual time is longer than distance/speed.
For a move of distance d, acceleration a, and max speed v:
T_move = v/a + d/v (for a long move that reaches v)
For a short move (doesn’t reach v): T_move = 2 × sqrt(d/a).
For a robot with a = 10 m/s², a move of 0.3 m (300 mm): it reaches v at t = v/a = 0.2 s, covering 0.2 m. The remaining 0.1 m at v = 2 m/s takes 0.05 s. Total = 0.2 + 0.05 = 0.25 s (plus deceleration, another 0.2 s). Total: about 0.5 s for a 300 mm move.
Don’t use d/v = 0.15 s. That ignores the ramps. The real time is 0.5 s.
The cycle time rule: Add 20% margin to every calculated move. The machine that missed by 3 seconds used idealized (rated speed) numbers. Use real acceleration/deceleration ramps, settling times, and overhead. Sum them, then add 20%. If the customer needs 12 seconds, design for 10 (so you have margin).
Step 3: Non-Value-Added Time
Not every second is “moving.” There’s overhead:
- PLC scan time: The PLC reads inputs, runs logic, writes outputs. About 10–50 ms per scan.
- Valve response: A pneumatic valve takes 20–50 ms to open/close.
- Sensor settling: A photoelectric sensor takes 5–20 ms to stabilize after the part arrives.
- Gripper close/open: 0.2–0.5 seconds (not instantaneous).
- Robot wait: The robot waits for the press (or the index) to finish.
These add up. For a 12-second cycle, the overhead can be 1–2 seconds. Include it.
Step 4: Find the Bottleneck
The cycle time is limited by the slowest station (the bottleneck). If the press takes 4 seconds and the robot takes 2, the press is the bottleneck. The robot waits for the press.
To improve the cycle time, attack the bottleneck (the longest element), not the fast ones. Speeding up the robot by 0.5 s doesn’t help if the press is 4 s.
For a multi-station machine, balance the stations (each station takes about the same time). If one station is much slower, it’s the bottleneck.
Step 5: Simulate the Cycle
Before building, simulate the cycle (offline, using the robot’s simulation software, or a spreadsheet). Time each move. Find the bottleneck. If the cycle is too slow, re-route the robot (faster path), parallelize (two robots), or speed up the bottleneck.
| Element | Ideal Time | Real Time (with ramps/overhead) |
|---|---|---|
| Robot move 300 mm | 0.15 s | 0.5 s |
| Gripper close | 0 s | 0.3 s |
| Press down + dwell + up | 3 s | 3.5 s |
| Index 90° | 2 s | 2.5 s |
| Sensor check | 0 s | 0.1 s |
| Overhead (PLC, valves) | 0 s | 0.5 s |
| Total | 7.15 s | 12.4 s |
A Cycle Time Checklist
- What is the customer’s required cycle time?
- List every move and process step in the cycle.
- Use real move times (with accel/decel ramps)?
- Include gripper, valve, and sensor times?
- Include PLC scan and overhead?
- Sum all elements (real, not ideal)?
- Add 20% margin?
- Is the bottleneck identified? (The slowest station?)
- Can the bottleneck be sped up? (Or parallelized?)
- Is the cycle simulated offline? (Before building?)
- Is there margin for wear? (Worn parts slow the machine?)
- Is the cycle time committed in the contract? (With penalty clauses?)
The Bottom Line
Machine cycle time calculation sums real moves, not ideal rated speeds. The machine that missed by 3 seconds used d/v for every move — ignoring ramps, gripper time, and overhead. Use real acceleration/deceleration times, add the overhead (PLC, valves, sensors), and add 20% margin. Find the bottleneck and attack it. Simulate the cycle offline before building. The machine that meets the customer’s spec wasn’t the fastest one on paper — it had realistic numbers and margin.
