Machine cycle time with overlapping movements

Add up the durations of every movement and you get the cycle time of a machine that does one thing at a time. Real machines do not work like that: the clamp closes while the slide is still holding, the drill retracts while the ejector is already waiting. The cycle time of a machine with overlapping movements is not a sum. It is the length of the longest chain of movements that have to follow one another.

This article does that calculation by hand, so that the number a chart or a tool gives you is one you could have checked.

The station. A bronze bush is pushed into position on a slide, clamped, drilled, released and blown clear by an air jet. The target is one part every three seconds. The same station is drawn in the editor in the case study.

Step 1 — List the movements with their three parts

A movement is a stroke out, a time at the end position, and a stroke back. Write all three, because dependencies will hang on the boundaries between them.

The sum of the totals is 5.7 s. That is the cycle of the strictly sequential machine, and it is the upper bound: nothing you do with dependencies can make the cycle longer than this.

Step 2 — Write down what each movement waits for

For every movement, name the one event it cannot start before. Be precise about which event: a movement has four natural hooks, the start and end of its stroke out and the start and end of its stroke back.

The offset is dead time you deliberately insert: a valve's response, a settle before a cut, a safety gap. Here they are all zero. Keep the column anyway; it is where the honest numbers go later.

Two movements that do not appear in each other's "waits for" are independent, and the whole point of the exercise is that independent movements may overlap.

Step 3 — Compute each movement's start and end

Work through the list in an order where every movement's predecessor has already been computed (the slide first, then clamp, then drill, and the eject last). For each movement:

start      = time of the event it waits for + offset
arrived    = start + stroke out
released   = arrived + time at the end position
end        = released + stroke back

Step 4 — The cycle time is the latest end

The cycle ends when the last movement ends: 3.0 s. The same four movements that need 5.7 s in a row take 3.0 s with their dependencies honoured, and nothing got faster. The 2.7 s saved were always there, in the overlap; they were just invisible until the timing was written down.

The chain that produced the 3.0 s is slide (2.5 s) → eject (0.5 s). In scheduling language that is the critical path, the longest path through the dependency graph. The clamp chain ends at 2.1 s and the drill chain at 2.0 s; they have slack of 0.9 s and 1.0 s respectively.

Step 5 — Use the slack, and check the collisions

Slack tells you what a change will cost before you make it:

• Lengthen the drill by 0.2 s (a harder material). The drill chain ends at 2.2 s, still inside the slide's 2.5 s. Cycle time: unchanged, 3.0 s.
• Lengthen the slide's hold by 0.2 s. The slide is on the critical path, so the eject follows it out: cycle time 3.2 s.
• Slow the clamp stroke from 0.4 s to 0.6 s. The drill starts 0.2 s later and ends at 2.2 s. Cycle time: unchanged.

Slack is not permission, though. The first change leaves the drill in the hole until 2.2 s while the slide starts pulling back at 2.0 s. The cycle time did not move and the machine just broke a drill. A collision in time is two movements that overlap where they physically must not, and the arithmetic above will not flag it; you have to look down the vertical line at 2.0 s and ask what is where. The chart does that looking for you; a table does not.

The procedure, in general

1. List every movement with stroke out, dwell and stroke back. Their sum is the sequential cycle, your upper bound.
2. For each movement name the single event it waits for, which hook of which movement, and any deliberate offset. Movements that wait for nothing start at zero.
3. Compute start, arrived, released and end for each movement in dependency order. A movement with two predecessors starts at the later of the two events.
4. The cycle time is the largest end. The chain of predecessors that leads to it is the critical path; everything else has slack.
5. For every pair of movements that must not coincide, check the intervals do not overlap. Slack says what is free in time, not what is safe in space.

The same rules give the same answer whether you do them in a spreadsheet, on paper or in a tool. The free template does steps 1 to 4 in Excel with formulas. Cyclogram does all five live while you drag the bars, with the dependencies drawn as bindings that re-time everything downstream when a stroke changes, which is what the case study shows step by step.

A note on wrapping

Some machines never stand still: the first movement of the next cycle starts before the last movement of this one has finished, because they do not share an actuator. Then the cycle time is shorter than the span of one cycle's movements, and the question becomes whether any actuator is asked to be in two places at once across the cycle boundary. The arithmetic is the same, taken modulo the cycle time; the editor's wrap view draws it.