Pro
40 min

Tank Level Control PLC Ladder Diagram (Run It Free Online)

Tank level control is the cornerstone process-control scenario for any PLC programmer: a real installation must handle hysteresis between the LOW and HIGH float switches, alternate between two pumps so their run-hours stay balanced, and latch an overflow alarm the moment a HIGH_HIGH switch trips. Below is the full ladder diagram, I/O table and timing chart — and because this is a live scenario, you can write the logic yourself and watch the tank fill, drain and alarm in your browser without installing anything.

processhysteresisalarmlead-lagalternation
Tank Fill Station scenario preview

Ready to build this?

Sign up free — no credit card required. This scenario requires the Pro plan.

Sign up to play this scenario →

Already have an account? Log in

Briefing

A dual-pump tank fill station with lead/lag alternation. Pressing START arms the controller; the *lead* pump then fills the tank whenever the LOW level switch is made, and drops out at the HIGH switch — classic hysteresis. At the end of every fill cycle the lead pump swaps with the lag pump (PUMP_A → PUMP_B → PUMP_A …) so their cumulative runtimes stay balanced. The downstream process continuously draws product from the tank, so level slowly falls between cycles. HIGH_HIGH_SW is the overflow safety interlock: when the level exceeds HIGH_HIGH the ALARM latches, BOTH pumps trip off together, and the emergency DRAIN_VALVE opens. The alarm clears only when STOP is pressed with the level already back below HIGH_HIGH.

Objectives

  • START arms the controller; STOP stops both pumps and clears a recovered alarm
  • PUMP_A leads the first fill cycle; PUMP_B leads the second; they alternate thereafter
  • The lead pump turns on at LOW_LEVEL_SW and off at HIGH_LEVEL_SW (hysteresis — does not restart until LOW is made again)
  • HIGH_HIGH_SW latches ALARM; ALARM drops BOTH pumps and stays on until STOP clears it
  • DRAIN_VALVE opens whenever ALARM is latched

Hints

  • Use a RUN_BIT latch: SET on START, RESET on STOP
  • Use a T-flipflop bit (e.g. LEAD_IS_B) that toggles on every rising edge of HIGH_LEVEL_SW — standard pattern: | EDGE AND /BIT | S= BIT ; | EDGE AND BIT | R= BIT ;
  • A FILLING latch captures the "below HIGH until we hit it" cycle state — SET at LOW, RESET at HIGH / HIGH_HIGH / STOP / ALARM
  • Pump outputs: PUMP_A := FILLING AND NOT LEAD_IS_B AND safety contacts; PUMP_B := FILLING AND LEAD_IS_B AND safety contacts
  • ALARM latches on HIGH_HIGH_SW and only resets on STOP once HIGH_HIGH has released; tie DRAIN_VALVE directly to ALARM

I/O Table

Inputs

START

Start push-button (momentary)

BOOL · %I0.0

STOP

Stop push-button (momentary)

BOOL · %I0.1

LOW_LEVEL_SW

Low-level float switch (true when low)

BOOL · %I0.2

HIGH_LEVEL_SW

High-level float switch (true when high)

BOOL · %I0.3

HIGH_HIGH_SW

High-high overflow switch

BOOL · %I0.4

Outputs

PUMP_A

Fill pump A contactor

BOOL · %Q0.0

PUMP_B

Fill pump B contactor

BOOL · %Q0.1

ALARM

Overflow alarm lamp (latching)

BOOL · %Q0.2

DRAIN_VALVE

Emergency drain solenoid

BOOL · %Q0.3

Your program will be tested against:

All test cases run automatically when you submit. Assertions are hidden until you pass.

  1. #1Lead pump (PUMP_A) turns on when the tank is empty

    START while the tank is empty -> LOW is true -> PUMP_A on within one scan, PUMP_B off

  2. #2Lead pump turns off when high-level switch is made

    Start filling; wait for level to reach HIGH_SP; PUMP_A must drop out

  3. #3Lead pump alternates between PUMP_A and PUMP_B on successive fill cycles

    Complete one fill cycle (PUMP_A leads) then wait for level to fall back to LOW and complete a second cycle (PUMP_B leads)

  4. #4HIGH_HIGH_SW drops BOTH pumps and latches the alarm

    Force HIGH_HIGH_SW true while the lead pump is running; both pumps must trip off together and ALARM must latch

  5. #5STOP button drops both pumps immediately

    Lead pump is running; press STOP -> both pumps off within one scan

I/O table: float switches, pumps and alarm

A dual-pump tank fill station uses five digital inputs and four digital outputs. The two level inputs that matter most are LOW_LEVEL_SW and HIGH_LEVEL_SW: the pump turns on when the level falls to LOW and turns off when it rises to HIGH — that gap between the two setpoints is the hysteresis band, and it is what prevents the pump from rapid-cycling at a single setpoint.

HIGH_HIGH_SW is a separate safety switch mounted above HIGH. When it trips, all pumps must stop immediately and the alarm must latch — it does not clear until an operator presses STOP after the level has fallen back below HIGH_HIGH.

tank level control PLC I/O table float switches pump outputs alarm
The dual-pump tank fill I/O: LOW and HIGH float switches, HIGH_HIGH overflow, two pump contactors, alarm lamp and emergency drain valve.

Pump control rung with hysteresis seal-in

The pump rung uses a FILLING latch bit to implement hysteresis. When the tank falls to LOW_LEVEL_SW the FILLING bit is SET, which turns the lead pump on. The pump stays on — sealed in — even after LOW_LEVEL_SW releases as the level rises. It only drops out when HIGH_LEVEL_SW is made, which RESETs the FILLING latch.

This start-at-LOW / stop-at-HIGH pattern means the pump never toggles at a single level point. The rung also includes normally-closed contacts for HIGH_LEVEL_SW, HIGH_HIGH_SW and ALARM in series with the coil, so any safety condition drops the pump immediately in the same scan — there is no one-scan lag.

tank level control PLC ladder diagram pump rung hysteresis seal-in LOW HIGH
The pump control rung: FILLING latch gives hysteresis — pump starts at LOW, seals in, and stops at HIGH or any alarm condition.

HIGH_HIGH overflow alarm latch rung

The alarm rung is a latching SET/RESET pair. HIGH_HIGH_SW SETs the ALARM bit on the scan it goes true. ALARM then RESETs the FILLING latch and opens a normally-closed ALARM contact in series with both pump coils — both pumps drop out in the same scan.

The ALARM bit can only be cleared by the STOP button, and only when HIGH_HIGH_SW is already released. This ensures an operator cannot silently restart the pumps while the tank is still overflowing. The DRAIN_VALVE output is wired directly to ALARM so the emergency drain solenoid opens the instant the alarm latches.

PLC ladder logic HIGH HIGH overflow alarm latch rung DRAIN_VALVE
The alarm latch rung: HIGH_HIGH_SW sets ALARM; STOP clears it only after HIGH_HIGH releases; DRAIN_VALVE follows ALARM directly.

Level and pump timing diagram — hysteresis band

The timing diagram shows one complete fill-and-drain cycle. The pump turns on the moment level crosses LOW (20 % of tank), runs while the level climbs through the hysteresis band, and turns off the moment level crosses HIGH (80 %). The downstream process then slowly draws product from the tank until the level falls back to LOW and the next fill cycle begins.

The band between LOW and HIGH is what makes the system stable: a wider band means fewer pump starts per hour and longer, more efficient pump runs. A narrower band gives tighter level control but more frequent cycling. In a real water tank PLC program the band is tuned to the process draw rate and the pump's minimum run time.

tank level plc ladder logic timing diagram hysteresis band pump on off LOW HIGH
The hysteresis timing: pump on at LOW, off at HIGH — the band between the two setpoints prevents rapid cycling.

Lead/lag pump alternation

Running two pumps in a lead/lag arrangement keeps their cumulative run-hours balanced, which extends service life and avoids one pump seizing from under-use. In this program a LEAD_IS_B flip-flop toggles on the rising edge of HIGH_LEVEL_SW: at the end of every fill cycle the lead role passes from PUMP_A to PUMP_B, then back to PUMP_A, alternating indefinitely.

The flip-flop uses a standard SET/RESET pair on the same edge bit so exactly one pump is designated lead per scan, with no race condition. When ALARM latches, both pumps trip regardless of which one is currently leading — safety always takes priority over alternation logic.

lead lag pump alternation PLC water tank fill station
Lead/lag alternation: the LEAD_IS_B flip-flop swaps lead responsibility on every HIGH rising edge so both pumps accumulate equal run-hours.

How to build a tank level control PLC program step by step

Start with the RUN_BIT: SET on START, RESET on STOP — the standard 3-wire latching pattern. Add the ALARM SET rung (HIGH_HIGH_SW sets ALARM; STOP clears it only when HIGH_HIGH is released). Then add the FILLING latch (LOW_LEVEL_SW sets it; HIGH_LEVEL_SW, ALARM and STOP each reset it). Next write the pump output rungs: PUMP_A := FILLING AND NOT LEAD_IS_B AND NOT HIGH and NOT ALARM; PUMP_B mirrors it with LEAD_IS_B. Finally add the LEAD_IS_B alternation flip-flop on the HIGH_LEVEL_SW rising edge and wire DRAIN_VALVE directly to ALARM.

Run the simulator and verify in sequence: PUMP_A starts at LOW → drops at HIGH → PUMP_B leads the second cycle → HIGH_HIGH trips both pumps and opens drain → STOP clears alarm only after level recovers.

Automatic water level controller using PLC and float switches

Stripped to its essentials, this scenario is an automatic water level controller using a PLC and two float switches — the same logic that runs an overhead water tank, a sump or a reservoir. The LOW_LEVEL_SW float closes when the water drops to the low probe and SETs the FILLING latch, turning the pump on; the HIGH_LEVEL_SW float closes when the water rises to the high probe and RESETs the latch, turning the pump off. The gap between the two floats is the hysteresis band that stops the pump from rapid-cycling, and the HIGH_HIGH float gives a latched overflow trip on top. That two-float SET/RESET pair is the entire plc tank filling ladder logic — everything else (lead/lag alternation, the alarm, the drain valve) is built around it.

This water tank level control PLC program is runnable and auto-graded right here in your browser: the physics model drives a real fill rate and draw rate so the float switches trip exactly as they would on hardware. To keep a copy of this tank level control PLC ladder diagram (I/O table plus every rung) beside you while you build, press Ctrl/Cmd+P on this page and choose Save as PDF.

Frequently asked questions

What is hysteresis in a PLC tank level control program?

Hysteresis means the pump starts at one setpoint (LOW) and stops at a different, higher setpoint (HIGH). The gap between them — the hysteresis band — prevents the pump from rapid-cycling. Without it, a pump running at a single setpoint would start and stop many times per minute as small level fluctuations cross the threshold.

How do I wire LOW and HIGH float switches in a water tank PLC program?

LOW_LEVEL_SW is typically normally-open and closes (goes true) when the water level falls to the low-level probe. HIGH_LEVEL_SW closes when the level rises to the high probe. In the ladder logic, LOW_LEVEL_SW SETs the FILLING latch and HIGH_LEVEL_SW RESETs it — that pair of rungs is the hysteresis pump control.

What is lead/lag alternation in a dual-pump tank fill station?

Lead/lag alternation means the two pumps take turns being the active (lead) pump. At the end of each fill cycle a flip-flop bit toggles and assigns the lead role to the other pump. This keeps their cumulative run-hours roughly equal, reducing maintenance costs and preventing standby-pump seizure from inactivity.

How does a HIGH_HIGH alarm latch work in ladder logic?

A latching SET rung turns on the ALARM bit the moment HIGH_HIGH_SW closes. A separate RESET rung can only clear ALARM when the operator presses STOP AND HIGH_HIGH_SW has already released. Because ALARM holds even after the switch releases, the operator must physically intervene — the pumps cannot automatically restart after an overflow.

Can I run a tank level PLC ladder diagram without a real PLC?

Yes. This page is a live browser scenario: write the ladder logic, press Run, and watch the tank fill, drain and alarm on a simulated dual-pump station. The simulator runs a physics model with a real fill rate and draw rate, so the hysteresis, alternation and alarm behaviours play out exactly as they would on hardware — no PLC, no install, no licence required.

What PLC instructions are used in a tank level ladder program?

The core instructions are: SET and RESET coils for latching (FILLING, ALARM, LEAD_IS_B), normally-open and normally-closed contacts for float switch inputs and safety conditions, a rising-edge detector (R_TRIG) on HIGH_LEVEL_SW to clock the alternation flip-flop, and an output coil for DRAIN_VALVE. No timers are needed — level control is purely event-driven by the float switches.

How do you do tank level control using a PLC?

Tank level control using a PLC is a hysteresis loop between two setpoints: a float or sensor at the LOW level SETs a FILLING latch to start the pump, and a float or sensor at the HIGH level RESETs it to stop the pump. The gap between LOW and HIGH stops the pump rapid-cycling. Add a HIGH_HIGH safety switch that latches an overflow alarm and trips the pumps, and for two pumps add a lead/lag flip-flop so they share run-hours. You can write and run exactly this control loop in the browser scenario on this page.

What is the PLC tank filling ladder logic?

The plc tank filling ladder logic is two rungs at its core: LOW_LEVEL_SW (gated by RUN and NOT ALARM) SETs the FILLING latch, and HIGH_LEVEL_SW (plus ALARM and STOP) RESETs it. The pump output is then driven by FILLING with normally-closed HIGH, HIGH_HIGH and ALARM contacts in series so any safety condition drops the pump in the same scan. That SET/RESET pair gives the start-at-LOW, stop-at-HIGH hysteresis behaviour that defines tank filling control.

How do you build an automatic water level controller using a PLC?

An automatic water level controller using a PLC reads two float switches — one at the low water level, one at the high level — and runs the pump between them with a SET/RESET latch (SET at LOW, RESET at HIGH). Add a HIGH_HIGH float for a latched overflow alarm and an emergency drain valve, and the controller fills and protects the tank with no operator input. The live scenario on this page is exactly this water tank level control PLC program, graded automatically against a physics model with real fill and draw rates.

Ready to build this?

Sign up free — no credit card required. This scenario requires the Pro plan.

Sign up to play this scenario →

Already have an account? Log in

Runnable simulator field guide

Tank fill PLC scenario: implementation, evidence and troubleshooting

Direct answer

Tank fill PLC scenario becomes useful when it connects initial level, start and stop commands, low and high states, high-high trip, pump availability, alternation state, drain response, alarm latch, reset and cycle evidence with operator request through permissives, lead selection, pump command, modeled level response, high-level stop, cycle count and independent alarm evidence, then proves one complete fill, high-level stop, drain and second cycle proving that the lead pump alternates under normal, boundary, fault and recovery conditions. The objective is a repeatable engineering or learning result, not merely activity inside a page or tool.

This guide is written for pLC and process-control learners programming a fill cycle with level states, alternating pumps, high-high response, stop behavior and observable process feedback. The intended result is specific: the learner can distinguish command from level proof, implement a repeatable fill cycle and defend the logic against abnormal level, stop, reset and alternation cases.

an instrumentation engineer correlating a process skid, transmitter, calibrator, PLC trend and actuator response while studying tank level sequencing, pump alternation and alarm acceptance testing
The physical context keeps tank level sequencing, pump alternation and alarm acceptance testing tied to declared inputs, owned decisions, observable results and evidence that another person can verify.

System map / 02

Six concepts that control the result

Treat these as connected checkpoints. Each checkpoint has an expected state, an observable state and a boundary to the next part of the system. That structure prevents a software indication from being mistaken for physical proof.

NODE 01observable

Define the operating contract

initial level, start and stop commands, low and high states, high-high trip, pump availability, alternation state, drain response, alarm latch, reset and cycle evidence. For tank level sequencing, pump alternation and alarm acceptance testing, record the initial condition, actor, requested change, observable result and stopping condition before selecting a tool or implementation.

NODE 02observable

Map the evidence path

operator request through permissives, lead selection, pump command, modeled level response, high-level stop, cycle count and independent alarm evidence. Separate request, internal state, output or service, physical or user-visible result and independent feedback so each boundary can be inspected.

NODE 03observable

Prove normal operation

one complete fill, high-level stop, drain and second cycle proving that the lead pump alternates. Run more than one cycle from a known state and retain the values, timings or artifacts that demonstrate repeatability.

NODE 04observable

Exercise a boundary case

high-high during filling, stop during a cycle, failed level progression, unavailable lead pump, reset timing, restart and contradictory level states. Choose minimum, maximum, simultaneous, delayed or restart conditions that reveal assumptions hidden by the happy path.

NODE 05observable

Diagnose a controlled fault

an input-state, permissive, command, alternation, process-response, alarm, reset or acceptance-test defect. Preserve the first symptom, divide the system at a measurable boundary and change one condition only after predicting the result.

NODE 06observable

Transfer and hand over

the sequence transferred only after process, electrical, instrumentation and safety requirements are independently reviewed. Restore normal state, remove temporary changes, repeat affected checks and document which claims remain limited to the learning environment.

Procedure / 03

A six-step practice and commissioning workflow

Run the steps in order the first time. Later, the same structure becomes a diagnostic loop: define the expected condition, observe the boundary, interpret the difference and choose one proving action.

  1. 01

    Write the acceptance case

    Convert initial level, start and stop commands, low and high states, high-high trip, pump availability, alternation state, drain response, alarm latch, reset and cycle evidence into initial conditions, one stimulus and observable pass criteria.

    Evidence: Another person can repeat the case without guessing the intended result.

    Avoid: Using page completion or an animation as the acceptance criterion.

  2. 02

    Build the map

    Document operator request through permissives, lead selection, pump command, modeled level response, high-level stop, cycle count and independent alarm evidence and name who owns each state or decision.

    Evidence: Every request and result has a source, destination and useful inspection point.

    Avoid: Using the same value as command, status and independent feedback.

  3. 03

    Run the baseline

    Apply one complete fill, high-level stop, drain and second cycle proving that the lead pump alternates from a clean start and record the expected evidence.

    Evidence: Repeated runs produce the same bounded result.

    Avoid: Changing several parameters before a baseline exists.

  4. 04

    Challenge assumptions

    Test high-high during filling, stop during a cycle, failed level progression, unavailable lead pump, reset timing, restart and contradictory level states without changing the acceptance contract.

    Evidence: Limits, timing and restart behavior reach defined states.

    Avoid: Testing only one ideal sequence.

  5. 05

    Isolate one failure

    Introduce or analyse an input-state, permissive, command, alternation, process-response, alarm, reset or acceptance-test defect and locate the first disagreement.

    Evidence: The proving action distinguishes the leading hypotheses.

    Avoid: Resetting, forcing or replacing before evidence is retained.

  6. 06

    Close the evidence loop

    Complete the sequence transferred only after process, electrical, instrumentation and safety requirements are independently reviewed and repeat the affected regression cases.

    Evidence: A run is complete only when the requested behavior, stop behavior, fault response and recovery are observable from a fresh initial condition.

    Avoid: Treating an acknowledged message or one successful rerun as handover.

Diagnostic matrix / 04

Symptoms, proving points and next actions

The table is a reasoning aid, not a parts-replacement chart. Preserve the initial symptom, inspect the named boundary and use the interpretation to choose the next controlled test. Site safety procedures and equipment manuals remain authoritative.

Diagnostic symptoms, inspection points, interpretations and next actions for Tank fill PLC scenario: implementation, evidence and troubleshooting
Observed symptomInspectInterpretationNext proving action
The expected result is unclearRequirement, initial state, actor, stimulus, units and pass conditionThe operator, programmer and reviewer may be solving different versions of the task.Rewrite one observable acceptance case before continuing.
Internal state changes but the outcome does notRequest, final owner, output or service boundary and independent feedbackA software or interface indication proves intent at one layer, not the complete outcome.Trace the first boundary after the changing state.
Normal case passes but an edge case failsLimits, timing, simultaneous events, reset and restart assumptionsThe implementation contains a hidden assumption exposed by the changed condition.Add the failed boundary as a permanent regression case.
The failure disappears after resetOriginal symptom, histories, diagnostics, timestamps and active causeReset changed evidence or state without proving the initiating cause.Reproduce under a controlled condition and preserve pre/post-event data.
Simulator and target disagreeModel boundary, software version, task timing, I/O behavior, data types and configurationA learning model and the intended target do not share one of the recorded assumptions.Reduce the case and verify against current target documentation.
The result cannot be explainedPrediction, observation, proving action, alternative hypotheses and limitationsActivity occurred but the evidence is not yet transferable or reviewable.Have the learner defend the signal path and repeat a changed case.

Product evidence / 05

What the browser practice can actually demonstrate

The browser runtime joins editable control state to visible I/O and machine or process behavior, allowing the same initial conditions and stimuli to be replayed.

Where simulation stops

The scenario is a bounded teaching model, not a hydraulic design, safety instrumented function, pump protection study or commissioned process-control system.

Commissioning notebook / 06

Six cases that turn the concepts into evidence

Use these as written briefs rather than click-through instructions. For every case, state the expected condition before acting, retain the first useful observation and explain why the final result proves the requirement. A different program or component choice can still be correct when it produces the same bounded behavior and evidence.

Case 01

predict → observe → prove

Prove define the operating contract

Engineering context. initial level, start and stop commands, low and high states, high-high trip, pump availability, alternation state, drain response, alarm latch, reset and cycle evidence. For tank level sequencing, pump alternation and alarm acceptance testing, record the initial condition, actor, requested change, observable result and stopping condition before selecting a tool or implementation. Begin with a written normal condition and identify which request, state, physical result or communication value will provide independent confirmation. Do not begin by changing the configuration; the initial state is part of the evidence and should remain reproducible.

Controlled setup. Use the “Write the acceptance case” stage of the workflow: convert initial level, start and stop commands, low and high states, high-high trip, pump availability, alternation state, drain response, alarm latch, reset and cycle evidence into initial conditions, one stimulus and observable pass criteria. The acceptance record should show this result: another person can repeat the case without guessing the intended result. Record initial conditions, the exact stimulus and the observation point so another learner can repeat the case without relying on your memory.

Fault challenge. Introduce or analyse “The expected result is unclear” as one bounded deviation. Inspect requirement, initial state, actor, stimulus, units and pass condition The working interpretation is that the operator, programmer and reviewer may be solving different versions of the task. The next proving action is to rewrite one observable acceptance case before continuing. Change only one condition before observing the result, and preserve timestamps or measurements where timing matters.

Review and recovery. The most common trap here is using page completion or an animation as the acceptance criterion. After restoring the cause, repeat the normal case and at least one stop, timeout, disconnect or restart boundary relevant to this topic. Remove temporary forces and bypasses, return the model to a known state and retain the evidence that both operation and recovery are deliberate.

Explain it aloud: How should a PLC control a tank fill sequence? A defensible short answer is: Define the initial level and permissives, select the available lead pump, stop at the high condition, handle high-high independently and verify every command with modeled or physical feedback.

Case 02

predict → observe → prove

Prove map the evidence path

Engineering context. operator request through permissives, lead selection, pump command, modeled level response, high-level stop, cycle count and independent alarm evidence. Separate request, internal state, output or service, physical or user-visible result and independent feedback so each boundary can be inspected. Begin with a written normal condition and identify which request, state, physical result or communication value will provide independent confirmation. Do not begin by changing the configuration; the initial state is part of the evidence and should remain reproducible.

Controlled setup. Use the “Build the map” stage of the workflow: document operator request through permissives, lead selection, pump command, modeled level response, high-level stop, cycle count and independent alarm evidence and name who owns each state or decision. The acceptance record should show this result: every request and result has a source, destination and useful inspection point. Record initial conditions, the exact stimulus and the observation point so another learner can repeat the case without relying on your memory.

Fault challenge. Introduce or analyse “Internal state changes but the outcome does not” as one bounded deviation. Inspect request, final owner, output or service boundary and independent feedback The working interpretation is that a software or interface indication proves intent at one layer, not the complete outcome. The next proving action is to trace the first boundary after the changing state. Change only one condition before observing the result, and preserve timestamps or measurements where timing matters.

Review and recovery. The most common trap here is using the same value as command, status and independent feedback. After restoring the cause, repeat the normal case and at least one stop, timeout, disconnect or restart boundary relevant to this topic. Remove temporary forces and bypasses, return the model to a known state and retain the evidence that both operation and recovery are deliberate.

Explain it aloud: How do you test alternating pumps in a tank-fill PLC program? A defensible short answer is: Run at least two complete cycles from known states and verify that each completed cycle changes the next lead selection without bypassing stop, trip or availability rules.

Case 03

predict → observe → prove

Prove prove normal operation

Engineering context. one complete fill, high-level stop, drain and second cycle proving that the lead pump alternates. Run more than one cycle from a known state and retain the values, timings or artifacts that demonstrate repeatability. Begin with a written normal condition and identify which request, state, physical result or communication value will provide independent confirmation. Do not begin by changing the configuration; the initial state is part of the evidence and should remain reproducible.

Controlled setup. Use the “Run the baseline” stage of the workflow: apply one complete fill, high-level stop, drain and second cycle proving that the lead pump alternates from a clean start and record the expected evidence. The acceptance record should show this result: repeated runs produce the same bounded result. Record initial conditions, the exact stimulus and the observation point so another learner can repeat the case without relying on your memory.

Fault challenge. Introduce or analyse “Normal case passes but an edge case fails” as one bounded deviation. Inspect limits, timing, simultaneous events, reset and restart assumptions The working interpretation is that the implementation contains a hidden assumption exposed by the changed condition. The next proving action is to add the failed boundary as a permanent regression case. Change only one condition before observing the result, and preserve timestamps or measurements where timing matters.

Review and recovery. The most common trap here is changing several parameters before a baseline exists. After restoring the cause, repeat the normal case and at least one stop, timeout, disconnect or restart boundary relevant to this topic. Remove temporary forces and bypasses, return the model to a known state and retain the evidence that both operation and recovery are deliberate.

Explain it aloud: What should I learn first about tank level sequencing, pump alternation and alarm acceptance testing? A defensible short answer is: Start with the operating contract and evidence path: initial level, start and stop commands, low and high states, high-high trip, pump availability, alternation state, drain response, alarm latch, reset and cycle evidence, followed by operator request through permissives, lead selection, pump command, modeled level response, high-level stop, cycle count and independent alarm evidence. Add advanced features only after the baseline is predictable.

Case 04

predict → observe → prove

Prove exercise a boundary case

Engineering context. high-high during filling, stop during a cycle, failed level progression, unavailable lead pump, reset timing, restart and contradictory level states. Choose minimum, maximum, simultaneous, delayed or restart conditions that reveal assumptions hidden by the happy path. Begin with a written normal condition and identify which request, state, physical result or communication value will provide independent confirmation. Do not begin by changing the configuration; the initial state is part of the evidence and should remain reproducible.

Controlled setup. Use the “Challenge assumptions” stage of the workflow: test high-high during filling, stop during a cycle, failed level progression, unavailable lead pump, reset timing, restart and contradictory level states without changing the acceptance contract. The acceptance record should show this result: limits, timing and restart behavior reach defined states. Record initial conditions, the exact stimulus and the observation point so another learner can repeat the case without relying on your memory.

Fault challenge. Introduce or analyse “The failure disappears after reset” as one bounded deviation. Inspect original symptom, histories, diagnostics, timestamps and active cause The working interpretation is that reset changed evidence or state without proving the initiating cause. The next proving action is to reproduce under a controlled condition and preserve pre/post-event data. Change only one condition before observing the result, and preserve timestamps or measurements where timing matters.

Review and recovery. The most common trap here is testing only one ideal sequence. After restoring the cause, repeat the normal case and at least one stop, timeout, disconnect or restart boundary relevant to this topic. Remove temporary forces and bypasses, return the model to a known state and retain the evidence that both operation and recovery are deliberate.

Explain it aloud: How do I practise tank level sequencing, pump alternation and alarm acceptance testing effectively? A defensible short answer is: Use short cases with known initial conditions, a written prediction, one action and an observable result. Then alter a boundary or fault and explain why the evidence changed.

Case 05

predict → observe → prove

Prove diagnose a controlled fault

Engineering context. an input-state, permissive, command, alternation, process-response, alarm, reset or acceptance-test defect. Preserve the first symptom, divide the system at a measurable boundary and change one condition only after predicting the result. Begin with a written normal condition and identify which request, state, physical result or communication value will provide independent confirmation. Do not begin by changing the configuration; the initial state is part of the evidence and should remain reproducible.

Controlled setup. Use the “Isolate one failure” stage of the workflow: introduce or analyse an input-state, permissive, command, alternation, process-response, alarm, reset or acceptance-test defect and locate the first disagreement. The acceptance record should show this result: the proving action distinguishes the leading hypotheses. Record initial conditions, the exact stimulus and the observation point so another learner can repeat the case without relying on your memory.

Fault challenge. Introduce or analyse “Simulator and target disagree” as one bounded deviation. Inspect model boundary, software version, task timing, I/O behavior, data types and configuration The working interpretation is that a learning model and the intended target do not share one of the recorded assumptions. The next proving action is to reduce the case and verify against current target documentation. Change only one condition before observing the result, and preserve timestamps or measurements where timing matters.

Review and recovery. The most common trap here is resetting, forcing or replacing before evidence is retained. After restoring the cause, repeat the normal case and at least one stop, timeout, disconnect or restart boundary relevant to this topic. Remove temporary forces and bypasses, return the model to a known state and retain the evidence that both operation and recovery are deliberate.

Explain it aloud: What counts as proof of competence? A defensible short answer is: A repeatable artifact or system result plus an explanation of the signal path is stronger than time spent, screenshots or a copied answer. Physical competence requires separate supervised evidence.

Case 06

predict → observe → prove

Prove transfer and hand over

Engineering context. the sequence transferred only after process, electrical, instrumentation and safety requirements are independently reviewed. Restore normal state, remove temporary changes, repeat affected checks and document which claims remain limited to the learning environment. Begin with a written normal condition and identify which request, state, physical result or communication value will provide independent confirmation. Do not begin by changing the configuration; the initial state is part of the evidence and should remain reproducible.

Controlled setup. Use the “Close the evidence loop” stage of the workflow: complete the sequence transferred only after process, electrical, instrumentation and safety requirements are independently reviewed and repeat the affected regression cases. The acceptance record should show this result: a run is complete only when the requested behavior, stop behavior, fault response and recovery are observable from a fresh initial condition. Record initial conditions, the exact stimulus and the observation point so another learner can repeat the case without relying on your memory.

Fault challenge. Introduce or analyse “The result cannot be explained” as one bounded deviation. Inspect prediction, observation, proving action, alternative hypotheses and limitations The working interpretation is that activity occurred but the evidence is not yet transferable or reviewable. The next proving action is to have the learner defend the signal path and repeat a changed case. Change only one condition before observing the result, and preserve timestamps or measurements where timing matters.

Review and recovery. The most common trap here is treating an acknowledged message or one successful rerun as handover. After restoring the cause, repeat the normal case and at least one stop, timeout, disconnect or restart boundary relevant to this topic. Remove temporary forces and bypasses, return the model to a known state and retain the evidence that both operation and recovery are deliberate.

Explain it aloud: Why test faults and restart behavior? A defensible short answer is: Because an input-state, permissive, command, alternation, process-response, alarm, reset or acceptance-test defect or high-high during filling, stop during a cycle, failed level progression, unavailable lead pump, reset timing, restart and contradictory level states can expose assumptions that never appear during ideal startup and steady operation.

Answer surface / 07

Questions people ask about Tank fill PLC scenario

These concise answers define the operating, training and product boundaries most often missed in broad summaries. The full workflow and diagnostic table above provide the evidence behind them.

How should a PLC control a tank fill sequence?

Define the initial level and permissives, select the available lead pump, stop at the high condition, handle high-high independently and verify every command with modeled or physical feedback.

How do you test alternating pumps in a tank-fill PLC program?

Run at least two complete cycles from known states and verify that each completed cycle changes the next lead selection without bypassing stop, trip or availability rules.

What should I learn first about tank level sequencing, pump alternation and alarm acceptance testing?

Start with the operating contract and evidence path: initial level, start and stop commands, low and high states, high-high trip, pump availability, alternation state, drain response, alarm latch, reset and cycle evidence, followed by operator request through permissives, lead selection, pump command, modeled level response, high-level stop, cycle count and independent alarm evidence. Add advanced features only after the baseline is predictable.

How do I practise tank level sequencing, pump alternation and alarm acceptance testing effectively?

Use short cases with known initial conditions, a written prediction, one action and an observable result. Then alter a boundary or fault and explain why the evidence changed.

What counts as proof of competence?

A repeatable artifact or system result plus an explanation of the signal path is stronger than time spent, screenshots or a copied answer. Physical competence requires separate supervised evidence.

Why test faults and restart behavior?

Because an input-state, permissive, command, alternation, process-response, alarm, reset or acceptance-test defect or high-high during filling, stop during a cycle, failed level progression, unavailable lead pump, reset timing, restart and contradictory level states can expose assumptions that never appear during ideal startup and steady operation.

Can browser practice replace official software or hardware?

No. It can build concepts and diagnostic reasoning. Exact firmware, I/O electrical behavior, networking, safety and commissioning require current official tools, documentation and target equipment.

How should progress be documented?

Keep the requirement, initial state, program or configuration, observed values, fault hypothesis, proving action, recovery result and a concise limitations statement.

Real plc tank filling ladder logic footage

See this exact skill in the working simulator.

Watch the real browser product respond to the task on this page, then try the same practical workflow yourself. No slides, concept mockups, install, or credit card.

Try this in the browser
PLC Tank Fill Control — Level Switches, Pumps and Alarms