Star delta starter PLC program, step by step

Difficulty: intermediate · 45–75 minutes

This is a build-along exercise, not a reading page. You get a short job card of the kind a contractor actually receives, an I/O table to wire against, and a worked solution to check yourself with once your own version runs — plus the test sequence that proves it, because a program you haven't tried to break is a program you haven't tested. Sketch first, build second, test third. Same order as on site.

The job card

Job card: the 45 kW borehole transfer pump at a Northern Cape mine workshop starts direct-on-line and every start dims the lights across the yard. The electrician has fitted the three contactors for a star-delta starter — main, star and delta — and wants the timing done in the PLC instead of a pneumatic timer block. Requirements: start in star, run up for 6 seconds, drop star, wait 100 milliseconds of dead time, then pull in delta. Star and delta must never be in together — that is a line-to-line short through the windings. Stop and overload drop everything instantly, and after a power dip the starter must wait for a fresh start command.

Read it the way a foreman hands it to you. Every requirement on that card is a test case: when you think the program is done, walk the card line by line and force each condition in the watch table. Any line without a matching test you actually ran means you're not done yet. That habit — card in one hand, watch table in the other — is what separates a programmer who commissions clean from one who gets the call-back at month end.

I/O assignment

Wire your simulator project to this table exactly. Half the value of an exercise like this is tag discipline: name the points the same way the table does and the solution steps further down will read straight onto your rungs without translation.

A note on the Type column: DI is a digital input, DO a digital output, AI and AO are analogue in and out, and M is an internal memory bit that never leaves the CPU. The addresses use IEC notation (%I, %Q, %M). If your head is in Allen-Bradley land, map %I0.0 to I:0/0 and carry on — the logic doesn't change, only the spelling of the addresses.

Think before you build

Don't open the ladder editor yet. The notes below are the design decisions that determine whether your program works first time or fights you for an hour. Read them, then sketch the rung shapes on paper. Pencil and the back of a delivery note is fine — most working programs start exactly there.

• The software interlock is each contactor's coil rung containing a normally-closed contact of the other. But software is not enough on its own: the panel must also have the hardware interlock, each coil circuit wired through the other contactor's NC auxiliary. The PLC exercise here mirrors what the copper must already guarantee.
• Dead time exists because contactors open slower than logic. Star's coil de-energising and star's contacts actually parting are 30-50 ms apart; fire delta in that gap and the arc across the star contacts meets the delta connection. 100 ms of nothing is cheap insurance on a 45 kW motor.
• Six seconds in star is a starting point, not gospel. The right time is when the motor approaches full speed in star — transition too early and the delta inrush is nearly as bad as DOL; too late and the motor never accelerates past what star torque can manage. Watch the current in commissioning.

Step-by-step solution

Build one rung at a time and test after every rung. Never write the whole program and then test the lot — when five rungs go in untested and the machine misbehaves, you're debugging five suspects instead of one. The steps below follow that order. In the pseudo-rungs, ] [ is a normally-open examine, ]/[ is normally-closed, and ( ) is the output coil.

Rung 1: the run seal-in

Standard pattern: (StartPB OR Run) AND StopPB AND OverloadOK driving an internal Run bit. Everything downstream hangs off Run, so stop and overload kill main, star and delta in the same scan, and a power dip drops the seal so there is no self-restart.

// ──┬──[ ]StartPB──┬──[ ]StopPB──[ ]OverloadOK──( )Run
//   └──[ ]Run──────┘

Rung 2: star phase with the transition timer

TON tStar times the star phase: IN from Run, PT of T#6s. StarK3 energises while Run is true, the timer is not done, and DeltaK2 is off — that last normally-closed DeltaK2 contact is the software interlock in this direction.

// Run ──[TON tStar, PT := T#6s]
// Run AND NOT tStar.Q AND NOT DeltaK2 ──( )StarK3

Rung 3: dead time, then delta

A second TON tDead with IN of tStar.Q AND NOT StarK3 — it only starts timing once star has actually dropped out — and PT of T#100ms. DeltaK2 energises on Run AND tDead.Q AND NOT StarK3, the NC StarK3 contact being the interlock in the other direction. Delta then seals itself in for the rest of the run.

// tStar.Q AND NOT StarK3 ──[TON tDead, PT := T#100ms]
// Run AND tDead.Q AND NOT StarK3 ──( )DeltaK2

Rung 4: the main contactor

MainK1 simply follows Run. It closes together with star at the start, carries the motor through the 100 ms coast during transition, and opens with everything else on stop. Some panels close main marginally after star to ease the star contactor's duty — note it, but follow your panel drawing.

// Run ──( )MainK1

Test the transition with a trace

Run it and watch all three outputs in a trace or the simulator's timeline view. You are looking for: star and main together at start, star dropping at 6.0 s, a visible 100 ms gap where only main is in, then delta. Force a stop during star, during the dead time, and during delta — all three outputs must drop instantly each time. Then cycle PLC power mid-run and confirm nothing restarts without a fresh start press.

The structured text version

The same logic in IEC 61131-3 structured text — each output written as a boolean equation you can read aloud.

(* Star-delta starter, IEC 61131-3 ST *)
Run := (StartPB OR Run) AND StopPB AND OverloadOK;
tStar(IN := Run, PT := T#6s);
StarK3 := Run AND NOT tStar.Q AND NOT DeltaK2;
tDead(IN := tStar.Q AND NOT StarK3, PT := T#100ms);
DeltaK2 := Run AND tDead.Q AND NOT StarK3;
MainK1 := Run;

Ladder wins this argument when an electrician has to fault-find your program at 02:00 with a multimeter mindset — the rung looks like the circuit diagram it replaced, and that familiarity is worth real money on a breakdown. ST starts winning when the pattern repeats: ten pumps with the same interlock shape is one ST function called ten times, where ladder hands you ten near-identical rungs to keep in sync by hand forever. Learn both. Build the exercise in ladder first, then write the ST version and confirm the two behave identically in the simulator. That translation skill — same logic, two languages — is exactly what technical interviews and commissioning work both test.

Common mistakes

Every mistake below comes from a real program: either one of ours from years back, or one we were called in to fix. Check your build against the list before you call the exercise done.

• No dead time: delta is fired on the same scan star drops. The PLC sees clean logic; the contactors, which take tens of milliseconds to physically open, briefly bridge star and delta and the result is a phase-to-phase fault through the starter.
• Software interlock only. A welded star contactor passes every logic check — the rung says StarK3 is off because the output is off, while the contacts are still made. The NC auxiliary of each contactor hard-wired into the other's coil circuit is non-negotiable.
• Building Run as a SET/RESET latch. It rides through a power dip, and when the supply returns after load-shedding the starter can wake up with the timer expired and pull straight into delta across a stationary motor — a DOL start of the worst kind.
• Transition time set by folklore. Six seconds suits one pump; a fan with high inertia may need 12. If the changeover current spike is nearly DOL-sized, the motor was nowhere near speed when you switched — time it against the current, not against the example code.

Most of these share one root cause: the rung shape doesn't match the intent, so the program passes the obvious test and fails the edge case. That's why the solution steps force the edge cases deliberately instead of stopping at "it starts and it stops". Steal that habit for every program you write from here on.

Take it further

Got it working first time? Good — now make it earn its keep. Each extension below changes the spec the way a real client does: after you've finished. Treat each one as a fresh job card, and re-test the whole program afterwards, not just the new part. Regressions hide in the rungs you didn't touch.

• Add a star-time setpoint from an HMI tag, clamped between 3 and 20 seconds in logic, and an incomplete-sequence alarm if delta feedback is not confirmed within 1 second of the command.
• Add contactor feedback inputs (aux contacts) and a welded-contactor check: any feedback TRUE while its command is FALSE locks out the next start and lights a fault lamp.
• Compare the pattern against a soft starter: same motor, ramped voltage instead of switched windings, one output instead of three. The staggered motor start exercise then handles several of these motors in sequence.

If you build even one extension, screenshot the finished rungs and keep them somewhere organised. A folder of working, tested exercise solutions is the start of a portfolio — and hiring engineers ask candidates to explain a rung far more often than they ask to see certificates.

Run this in the simulator

The sandbox on the free tier lets you build the core rungs of this intermediate exercise yourself — no card details, no install, signed up and on a rung inside two minutes. The watch table is the part that matters here: force the inputs, watch the outputs, and run the test sequence from the solution steps against a live scan cycle instead of imagining it. To be straight about what's paid: the guided version of this exercise — graded checkpoints, feedback on every submission — sits in the curriculum on the Basic tier at USD 12 per month and Pro at USD 29 per month, alongside the wiring track, sensor school and cert packs. Training centres and engineering departments wanting this in a lab should look at the Teams tier (USD 199 per seat per year, minimum 5 seats); the training-centres page carries the institutional details and the contact form. If you're an individual learning the trade, prove the core rungs in the free sandbox first and decide whether the graded track is worth the money. And once this one runs clean, line up the next exercise a notch harder — the step up is where the skill gets built.

Reference

Motor soft starter on Wikipedia covers the background theory behind this exercise, and it's worth twenty minutes of your time after the build — theory sticks better once your hands have done the work. The languages used here are defined by the IEC 61131-3 standard from iec.ch, and your CPU vendor's manual remains the canonical source for how a specific controller executes them.

What we don't claim

This site is not SAQA-registered, not MerSETA-accredited, and not an NQF-registered qualification provider. Our completion certificates are course-level only — they describe what you covered, not an NQF Level X qualification. The CCST cert from ISA is the portable industry credential we recommend; we are not an ISA cert delivery partner either, but our cert packs are CCST-aligned. The exercise on this page is practice material written by working programmers: finishing it proves the skill to yourself and to the simulator's progress tracking, not to a regulator.