The Cycle Time That Dropped from 18 Seconds to 12
We designed a machine for a customer. The required cycle was 12 seconds. On paper, the sequential cycle was 18 seconds: pick (2 s), place (2 s), press (3 s), index (2 s), check (1 s), unload (2 s), reload (3 s), return (3 s). The customer needed 12. We couldn’t speed up any single move (the press took 3 s minimum). The solution: parallelize. The robot picks the next part while the press is working. The operator reloads while the index rotates. We overlapped the moves. The cycle dropped to 12 seconds. The mistake was designing the sequence as strictly sequential — no parallel moves.
Cycle time parallelization overlaps independent moves to shorten the cycle. This article covers how.
Sequential vs Parallel
Sequential: every step waits for the previous one. The robot picks, then places, then presses, then indexes. The total is the sum of every step.
Parallel: steps that don’t depend on each other overlap. The robot picks the next part while the press holds. The operator unloads while the index rotates. The total is the longest path (the critical path), not the sum.
Step 1: Identify the Critical Path
Draw the cycle as a sequence. Which steps must happen one after another (dependent)? Which can happen in parallel?
Dependent steps (must be sequential):
- Pick → Place (the part must be picked before it’s placed).
- Press down → dwell → retract (the press cycle is sequential).
- Index before the next station’s work (the part must be at the station before work starts).
Independent steps (can parallel):
- The press working (3 s) while the robot picks the next part (2 s).
- The index rotating (2 s) while the operator unloads the finished part (2 s).
- The conveyor advancing (1 s) while the sensor checks (0.5 s).
The critical path is the longest chain of dependent steps. Parallelize everything off the critical path.
Step 2: Overlap the Robot with the Process
The biggest time saver: the robot doesn’t wait. While the press (or the indexer, or the oven) works, the robot does something else:
- Robot picks the next part while the press holds: The press takes 3 s. The robot (after placing the part in the press) picks the next part (2 s) and returns. The press finishes while the robot is ready. No wait.
- Robot unloads while the index rotates: The index takes 2 s. The robot unloads the finished part (2 s) in parallel.
The parallelization rule: The robot shouldn’t wait. While a process (press, index, oven) runs, the robot picks/places the next part. Find the process that takes longest, and overlap the robot with it. The cycle that dropped from 18 to 12 was the press (3 s) now overlapped with robot picking.
Step 3: Two Stations (Double the Throughput)
If one station is the bottleneck, duplicate it. Two press stations (alternating). The robot loads station A, presses A, then loads B while A presses. The effective press time is halved (the robot doesn’t wait for the press).
This doubles the cost (two presses), but it halves the cycle time. For a customer who needs 12 seconds and the press alone is 8 seconds, two presses (with the robot alternating) solve it.
Step 4: Pre-Stage the Part
Stage the raw part at the pick position (a feeder, a conveyor) before the cycle starts. The robot doesn’t wait for the feeder to present the part — it’s already there.
For example: a vibratory feeder (article 47) keeps parts at the pick position. The robot picks immediately (no waiting for the bowl to feed).
Step 5: PLC Logic (Overlap)
The PLC sequence must allow parallel actions. Instead of a strict sequence (step 1 → step 2 → step 3), the PLC runs parallel threads:
- Thread 1: robot moves.
- Thread 2: press cycle.
- Thread 3: index.
Each thread runs independently. The PLC synchronizes them (waits for dependencies: the press waits for the part to be loaded, etc.). Modern PLCs (and robot controllers) support this (multi-tasking, or a sequence with parallel branches).
| Technique | Time Saved | Best For |
|---|---|---|
| Robot overlaps press/index | 1–3 s | Process (press) is the bottleneck |
| Duplicate station (2 presses) | ~50% of bottleneck | Bottleneck too long to overlap |
| Pre-stage parts (feeder) | 0.5–1 s | Waiting on a feeder |
| Parallel PLC threads | Enables the above | Multi-tasking sequence |
A Parallelization Checklist
- What is the required cycle time?
- What is the sequential cycle time? (List every step.)
- What is the critical path? (Longest dependent chain?)
- Which steps are independent? (Can they overlap?)
- Can the robot overlap the process? (Pick next while press holds?)
- Is the bottleneck duplicated? (Two stations?)
- Are parts pre-staged? (No waiting on feeder?)
- Does the PLC support parallel threads? (Sequence design?)
- Is the cycle tested (real, not ideal)? (Article 110?)
- Is there margin for wear? (20%?)
The Bottom Line
Cycle time parallelization overlaps independent moves. The cycle that dropped from 18 to 12 had the robot waiting for the press. Overlap the robot’s next pick with the press hold. Duplicate the bottleneck station if needed. Pre-stage parts so the robot doesn’t wait. The machine that met the 12-second spec wasn’t faster — it ran in parallel.
