JoeGuardian Automation

15. Cascading Timers and Practical Timer Applications

---

In the previous post, we covered the basic PLC timer instructions:

TON = Timer On Delay
TOF = Timer Off Delay
RTO = Retentive Timer On

Now we are going one step deeper.

In real industrial machines, timers are often used together to control sequences, delays, alarms, debounce logic, auto-starts, auto-stops, and fault detection.

One important method is called cascading timers.

In simple words:

Cascading timers means one timer starts another timer or another step in the process.

This allows the PLC to create a timed sequence.

Example:

Timer 1 done → start Timer 2
Timer 2 done → start Timer 3
Timer 3 done → move to next step

Timers are commonly used in PLC programming for delays, timed outputs, sequence control, and machine protection. In Logix-style controllers, timer structures include elements like .EN, .TT, .DN, .PRE, and .ACC, and presets are commonly entered in milliseconds.

---

Why Cascading Timers Are Used

Machines often need things to happen in order.

Example:

1. Start conveyor.
2. Wait 2 seconds.
3. Open valve.
4. Wait 5 seconds.
5. Start pump.
6. Wait 3 seconds.
7. Confirm flow.

This type of timing logic can be created with cascading timers.

Cascading timers are useful when a process needs:

Step-by-step timing
Startup sequencing
Shutdown sequencing
Delay between machine actions
Timed fault detection
Pulsing or flashing outputs
Auto-close or auto-release logic
Product handling delays

---

Basic Cascading Timer Concept

A basic cascading timer sequence looks like this:

Start_Command → TON T_Step1
T_Step1.DN    → TON T_Step2
T_Step2.DN    → TON T_Step3
T_Step3.DN    → Final_Action

Each timer depends on the previous timer’s done bit.

That means the sequence only moves forward when the previous delay is complete.

---

Simple Example: Three-Step Startup Sequence

Requirement

When the operator presses Start:

1. Start conveyor immediately.
2. After 2 seconds, start blower.
3. After 5 more seconds, start pump.

Tags

Tag	Description
Start_Request	Operator or HMI start request
T_BlowerDelay	Delay before blower starts
T_PumpDelay	Delay before pump starts
Conveyor_Run_Command	Conveyor command
Blower_Run_Command	Blower command
Pump_Run_Command	Pump command

---

Logic Concept

Start_Request → Conveyor_Run_Command
Start_Request → TON T_BlowerDelay 2000 ms
T_BlowerDelay.DN → Blower_Run_Command
T_BlowerDelay.DN → TON T_PumpDelay 5000 ms
T_PumpDelay.DN → Pump_Run_Command

Plain English

The conveyor starts first.
After 2 seconds, the blower starts.
After 5 more seconds, the pump starts.

This is cascading timer logic.

---

Cascading Timers in Ladder Logic

Rung 1 — Conveyor Starts Immediately

Start_Request        Conveyor_Run_Command
----] [----------------------( )----

Rung 2 — Blower Delay Timer

Start_Request        TON T_BlowerDelay
----] [------------------[TON]----
                         PRE 2000
                         ACC 0

Rung 3 — Blower Starts After Timer Done

T_BlowerDelay.DN        Blower_Run_Command
----] [------------------------( )----

Rung 4 — Pump Delay Timer Starts After Blower Delay

T_BlowerDelay.DN        TON T_PumpDelay
----] [--------------------[TON]----
                           PRE 5000
                           ACC 0

Rung 5 — Pump Starts After Pump Delay

T_PumpDelay.DN        Pump_Run_Command
----] [--------------------( )----

This creates a clean timed sequence.

---

Timer Sequence Timeline

Time 0 sec:
Start_Request ON
Conveyor starts

Time 2 sec:
T_BlowerDelay.DN turns ON
Blower starts

Time 7 sec:
T_PumpDelay.DN turns ON
Pump starts

Important detail:

The pump starts 7 seconds after Start_Request:
2 seconds for blower delay + 5 seconds for pump delay.

That is why cascading timer timing must be calculated carefully.

---

Important Rule: Cascading Timers Add Time

When one timer starts after another timer is done, the total time is cumulative.

Example:

Timer 1 = 2 seconds
Timer 2 = 5 seconds
Timer 3 = 3 seconds

Total time to final action:

2 + 5 + 3 = 10 seconds

This is a common troubleshooting point.

A technician may ask:

Why does this output take 10 seconds to turn ON?

The answer may be:

Because three timers are cascading before that output is allowed.

---

Practical Application 1 — Motor Start Delay

A motor start delay is used when a machine needs a short delay before energizing a motor.

Example

Start_Request → TON T_MotorStartDelay
T_MotorStartDelay.DN → Motor_Run_Command

Use Cases

Allow control power to stabilize
Prevent immediate restart
Delay motor startup after permissives become OK
Sequence multiple motors
Avoid starting several large motors at the same time

---

Practical Application 2 — Multiple Motor Startup Sequence

In some machines, you do not want all motors to start at the same time.

Example:

Motor 1 starts first.
Motor 2 starts 3 seconds later.
Motor 3 starts 3 seconds after Motor 2.

Why?

Reduce inrush current
Prevent mechanical shock
Allow process flow to stabilize
Avoid overloading upstream equipment

Logic Concept

Start_Request → Motor_1_Command
Motor_1_Command → TON T_Motor2Delay
T_Motor2Delay.DN → Motor_2_Command
Motor_2_Command → TON T_Motor3Delay
T_Motor3Delay.DN → Motor_3_Command

This is a classic cascading timer application.

---

Practical Application 3 — Conveyor Product Transfer Delay

A product may need time to move from one sensor to another.

Example

A box passes Photoeye 1. After a delay, the reject arm should activate.

Box_Detected_PE → TON T_RejectDelay
T_RejectDelay.DN → Reject_Command

This can be used for:

Reject systems
Box tracking
Position delay
Conveyor transfer timing
Photoeye-to-actuator spacing

Important:

For high-speed conveyors, a timer may not be accurate enough.
Use encoder tracking or shift registers when product position must be precise.

---

Practical Application 4 — Sensor Debounce

Debounce filters unstable signals.

Problem

A sensor flickers ON/OFF due to vibration, electrical noise, or mechanical bounce.

Solution

The signal must stay ON for a short time before the PLC accepts it.

Raw_Sensor → TON T_SensorOnDebounce
T_SensorOnDebounce.DN → Sensor_Valid

Example preset:

T_SensorOnDebounce.PRE = 100 ms

Use cases:

Photoeyes
Limit switches
Pushbuttons
Pressure switches
Flow switches
Proximity sensors affected by vibration

---

Practical Application 5 — OFF Debounce

Sometimes you also need to debounce the OFF transition.

Problem

The sensor briefly drops out, but the machine should not react immediately.

Solution

Use an OFF delay or a separate OFF debounce timer.

Example concept:

Sensor_Valid stays ON unless Raw_Sensor has been OFF for 100 ms.

This is useful for:

Photoeye flicker
Product gaps
Liquid splash detection
Unstable level switches
Vibration near limit switches

---

Practical Application 6 — Failed-To-Start Fault

This is one of the most important timer applications.

Requirement

If the PLC commands a motor to run, but feedback does not turn ON within 2 seconds, generate a fault.

Motor_Run_Command AND NOT Motor_Running_FB
→ TON T_FailedToStart

When done:

T_FailedToStart.DN → Flt_Motor_FailedToStart

This catches problems like:

Bad contactor coil
Blown fuse
Overload tripped
Loose wire
Failed output point
VFD not responding
Bad feedback auxiliary contact
Control voltage missing

This makes troubleshooting much faster because the PLC can tell you:

“I commanded the motor, but I did not receive proof.”

---

Practical Application 7 — Valve Failed-To-Open Timeout

Valves commonly use timer-based fault detection.

Requirement

If the PLC commands the valve open, but the open feedback does not turn ON within 5 seconds, fault the valve.

Valve_Open_Command AND NOT Valve_Open_FB
→ TON T_ValveOpenTimeout

When done:

T_ValveOpenTimeout.DN → Flt_ValveFailedToOpen

Possible causes:

No air pressure
Bad solenoid
Valve stuck
Bad limit switch
Broken wire
Output failed
Mechanical obstruction

---

Practical Application 8 — Auto-Close Timer

Industrial doors, clamps, and gates often use auto-close timers.

Example

Door_Fully_Open
AND AutoClose_Enable
AND NOT Photoeye_Blocked
→ TON T_AutoClose

When done:

T_AutoClose.DN → AutoClose_Request

Important:

Stop button, E-Stop, fault, or photoeye blocked should reset or inhibit auto-close.

A good auto-close timer should be conditional and safe.

---

Practical Application 9 — Fan Off Delay

A fan off delay keeps a fan running after another device stops.

Example

Heater_Running → TOF T_FanOffDelay
T_FanOffDelay.DN → Fan_Run_Command

Use cases:

Cooling fans
Ventilation
Heater cooldown
VFD cabinet fans
Process exhaust fans

---

Practical Application 10 — Alarm Delay

Not every short signal should create an alarm.

Example

Low pressure must exist for 3 seconds before generating an alarm.

Pressure_Low → TON T_LowPressureAlarmDelay
T_LowPressureAlarmDelay.DN → Alm_LowPressure

This avoids nuisance alarms caused by very short pressure dips.

Use cases:

Low air pressure
Low flow
High temperature
Low tank level
High vibration
Communication unstable

---

Practical Application 11 — Flashing Light Logic

Timers can create a blinking or flashing signal.

Example:

Fault_Active → Flash_Red_Light

A simple method uses two timers:

T_FlashOn
T_FlashOff

Concept:

Light ON for 500 ms
Light OFF for 500 ms
Repeat while fault is active

Use cases:

Alarm lights
Stack lights
Warning indicators
Maintenance lights
HMI animation bits

For more advanced systems, a dedicated clock bit or periodic task may be cleaner.

---

Practical Application 12 — Runtime Tracking

Use RTO timers for accumulated runtime.

Example

Pump_Running_FB → RTO T_PumpRuntime
Maintenance_Reset → RES T_PumpRuntime

Use cases:

Pump runtime
Motor operating hours
Fan runtime
Filter replacement interval
UV lamp hours
Maintenance PM tracking

Important:

RTO must have reset logic.

Without reset logic, the accumulated value will remain stored.

---

Practical Application 13 — Minimum Run Time

A minimum run timer prevents equipment from starting and stopping too quickly.

Example

A pump must run at least 30 seconds once started.

Why?

Prevent short cycling
Protect motor starter
Protect pump
Reduce mechanical wear
Stabilize process

Logic concept:

Pump starts → TON T_MinRunTime
Pump cannot stop normally until T_MinRunTime.DN = 1

Important:

Safety stops and faults should still stop the pump immediately.

Minimum run time should never override critical safety or protection logic.

---

Practical Application 14 — Minimum Off Time

A minimum off timer prevents equipment from restarting too soon.

Example

A compressor should remain off for 3 minutes before restarting.

Why?

Allow pressure equalization
Protect compressor
Avoid rapid cycling
Protect contactors and starters

Logic concept:

Compressor stops → TON T_MinOffTime
Compressor restart allowed only when T_MinOffTime.DN = 1

---

Practical Application 15 — Step Sequence Timing

Timers are often used in simple sequences.

Example:

Step 10: Extend cylinder
Wait until extended feedback OR timeout
Step 20: Hold position for 2 seconds
Step 30: Retract cylinder
Wait until retracted feedback OR timeout
Step 40: Complete cycle

Timers in sequences should usually be connected to step numbers.

Example:

Machine_State = 20 → TON T_HoldDelay
T_HoldDelay.DN → move to next step

This keeps the timer tied to a specific machine state.

---

Cascading Timers vs State Machine

Cascading timers are useful, but they can become hard to troubleshoot if the sequence becomes too large.

Cascading Timers Are Good For:

Small timed sequences
Simple startup delays
Short machine routines
Basic training examples
Simple flashing logic

State Machines Are Better For:

Complex sequences
Multiple steps
Fault recovery
Manual/auto operation
Restart after stop
Clear step transitions
HMI step display

For professional machine logic, use timers inside a state machine rather than building a huge chain of timers.

Example:

State 10 = Start Conveyor
State 20 = Wait Delay
State 30 = Open Valve
State 40 = Verify Feedback
State 50 = Complete

This is easier to troubleshoot than many timers chained together with no clear step structure.

---

Common Mistake 1 — Too Many Cascading Timers

A long chain of timers can become hard to read.

Bad:

T1.DN starts T2
T2.DN starts T3
T3.DN starts T4
T4.DN starts T5
T5.DN starts T6

Problem:

Hard to know what step the machine is in.
Hard to reset properly.
Hard to troubleshoot after stop or fault.
Hard to display status on HMI.

Better:

Use a machine state or step number.
Use timers inside each step.

---

Common Mistake 2 — Timer Does Not Reset

If the timer enable rung stays true, the timer may remain done.

Example:

T_ValveOpenTimeout.DN = 1

If the condition never goes false, the timer does not reset.

Always understand:

What enables the timer?
What resets the timer?
What should happen when the process stops?
What should happen when the fault resets?

---

Common Mistake 3 — Wrong Timer Preset

In Studio 5000, timer presets are usually milliseconds.

Example mistake:

PRE = 5

Thinking it means 5 seconds.

Actual result:

5 ms

Correct for 5 seconds:

PRE = 5000

---

Common Mistake 4 — Timer Used Instead of Feedback

A timer does not prove motion happened.

Example:

Start motor.
Wait 5 seconds.
Assume motor is running.

Better:

Start motor.
Wait for motor feedback.
If feedback does not arrive within 5 seconds, fault.

A timer should not replace real feedback when feedback is available.

---

Common Mistake 5 — Timer Used for Accurate Position Tracking

A timer can approximate product position on a conveyor, but it may not be accurate if speed changes.

Example:

Photoeye detects product.
Wait 2 seconds.
Fire reject solenoid.

This may fail if:

Conveyor speed changes
Product slips
VFD speed varies
Product spacing changes
Sensor is inconsistent

For accurate position tracking, use:

Encoder tracking
Shift register
Product tracking logic
Servo/motion feedback

---

Best Practices for Practical Timer Logic

Use these habits:

Use meaningful timer names.
Use comments explaining the purpose.
Use correct units in descriptions.
Use TON for ON delays and fault timeouts.
Use TOF for OFF delays.
Use RTO only when accumulated time must be remembered.
Use feedback plus timers for diagnostics.
Avoid huge chains of timers.
Use state machines for complex sequences.
Reset timers intentionally during stop, fault, or state change.
Do not use timers as a replacement for real feedback.

Good timer names:

T_Motor2StartDelay
T_ValveOpenTimeout
T_PhotoeyeDebounce
T_AutoCloseDelay
T_FanOffDelay
T_PumpRuntime
T_MinRunTime
T_MinOffTime
T_SequenceStepDelay

---

Troubleshooting Timer Applications

When a timer-controlled action does not work, ask:

Is the timer rung true?
Is .EN ON?
Is .ACC increasing?
Is .TT ON while timing?
Is .DN turning ON?
Is .PRE correct?
Is another rung resetting the timer?
Is the routine being scanned?
Is the timer waiting for another timer’s done bit?
Is the action waiting for feedback, not just time?

For cascading timers, also ask:

Which timer in the chain is not done?
Which previous condition is preventing the next timer?
Did a fault or stop reset one timer but not the others?
Is the total sequence time longer than expected?

---

Practical Troubleshooting Example

Problem

A pump starts too late after pressing Start.

Timer Chain

Start_Request → T_ConveyorDelay 3000 ms
T_ConveyorDelay.DN → T_BlowerDelay 5000 ms
T_BlowerDelay.DN → T_PumpDelay 4000 ms
T_PumpDelay.DN → Pump_Run_Command

Total Delay

3000 + 5000 + 4000 = 12000 ms

That means:

Pump starts 12 seconds after Start_Request.

The pump may not be late. The cascading timers may be working exactly as programmed.

---

Practical Troubleshooting Example 2

Problem

A valve failed-to-open fault occurs.

Logic

Valve_Open_Command AND NOT Valve_Open_FB
→ TON T_ValveOpenTimeout 5000 ms

Possible Causes

Valve_Open_Command is ON
Valve_Open_FB never turns ON
Timer reaches 5 seconds
Fault turns ON

Troubleshooting path:

Check open output.
Check solenoid voltage.
Check air supply.
Check valve movement.
Check open limit switch.
Check feedback wiring.
Check timer preset.
Check whether feedback is normally open or normally closed.

The timer points you toward the missing feedback.

---

Automation Technician Notes

Timers are not just delays.

Timers are diagnostic tools.

A good technician understands that timer logic can answer questions such as:

Did the device respond in time?
Was the signal stable long enough?
Did the machine wait long enough before the next step?
Has the equipment run long enough for maintenance?
Is a nuisance alarm being filtered properly?

Timer logic becomes much more powerful when combined with:

Feedback
Permissives
Interlocks
Faults
Machine states
HMI status

---

Key Terms

Term	Meaning
Cascading Timers	Timers where one timer starts another
Timer Sequence	Timed order of machine actions
Start Delay	Delay before starting a device
Fault Timeout	Timer used to detect missing feedback
Debounce	Timer-based filtering of unstable inputs
Auto-Close Timer	Timer that creates an automatic close request
Fan Off Delay	Keeps fan running after condition turns OFF
Runtime Tracking	Accumulated operating time
Minimum Run Time	Prevents stopping too soon
Minimum Off Time	Prevents restarting too soon
State Machine	Step-based sequence structure
.DN	Timer done bit
.ACC	Accumulated time
.PRE	Preset time

---

Final Thoughts

Cascading timers and practical timer applications are everywhere in industrial PLC programs.

They are used for startup sequences, shutdown delays, sensor debounce, fault timeouts, auto-close logic, flashing lights, alarm delays, runtime tracking, and machine sequencing.

The most important lesson is this:

Timers should support good control logic, not hide missing feedback.

Use timers to delay, verify, filter, and protect the machine. But whenever possible, use real feedback to prove that the machine actually did what the PLC commanded.

For an Automation Technician, understanding practical timer applications makes troubleshooting much easier because many machine problems are related to timing, missing feedback, bad presets, or timer chains that are misunderstood.