40 structured scenarios from traffic lights to PID temperature control, robot handshakes, and CIP sequences. IEC 61131-3, Allen-Bradley, and Siemens dialects. No install, no license key, no lab hardware.
PLC programming is the craft of writing controller logic that runs on a programmable logic controller — the industrial computer that drives motors, valves, conveyors, and sensors in a factory, water treatment plant, or process line. If you have ever pressed a crosswalk button and watched the light cycle, debated a garage-door safety beam, or stood next to a bottling line, you have interacted with a PLC.
People come to PLC programming from three main directions. Electrical and mechatronics students pick it up as part of their degree and need practice beyond what the textbook and a two-hour lab session provide. Software engineers move into controls and automation roles and need to internalise a scan-based, I/O-driven programming model that is nothing like the web stack. Plant technicians already familiar with wiring relays step up to the logic side when their employer replaces hardwired panels with PLCs.
All three groups want the same thing: enough reps on real-feeling scenarios to develop intuition. That is what this page, and the ten scenarios linked below, set out to provide.
Time estimate. Expect 15–20 hours to get competent on the fundamentals (first four scenarios). Another 40–60 hours to be comfortable with interlocks, sequencers, and closed-loop control. These are evening-practice numbers — a month or two, not a semester.
Courses (RealPars, PLC Academy, Udemy) and YouTube playlists are good for theory. The piece they cannot give you is reps — writing logic, running it, watching it fail a test, and fixing it. This page is built around that loop. Here is the sequence that works.
Before any rung, understand the scan cycle and the I/O image table: a PLC reads inputs, runs your program top-to-bottom, then writes outputs, forever. Almost every beginner confusion (“why did my coil flicker?”) comes from not having this model. Five minutes on the diagrams below saves hours later.
Start with ladder logic — normally-open and normally-closed contacts, output coils, series (AND) and parallel (OR) branches. It is the most-used PLC language and it maps directly onto relay schematics, so it is the fastest to read. Write a one-rung program that turns a lamp on with a button. That is your first real PLC program.
Layer on seal-in latching (hold a motor running off a momentary button), timers (TON / TOF / TP), counters (CTU / CTD), and edge detection (R_TRIG / F_TRIG). These four cover the large majority of real industrial logic. The Fundamentals section below explains each with a diagram.
Move into the scenario library. Each scenario gives you an I/O list, a written objective, and a hidden test suite. You write the ladder, hit Run, and the grader tells you exactly which requirement failed. That feedback loop — not watching a video — is where the skill actually forms. The first four scenarios are free.
Once ladder feels natural, learn Structured Text for the maths-heavy and looping logic that ladder makes awkward, and pick a target vendor — Allen-Bradley (Studio 5000) or Siemens (TIA Portal). The IEC 61131-3 standard means the concepts transfer; only the addressing and tooling change. When you are ready for a credential, see the structured course and certification guide.
Before scenario one, make sure these concepts click. Skip any you already know.
A PLC runs a three-phase loop: read all inputs into an image table, execute the user program top-to-bottom, then write the output image back to physical outputs. Every rung you write is evaluated once per scan. Scan time is typically 1–50 ms on industrial hardware. Internalising the scan model explains why coil order matters, why a rung can fire twice in one cycle, and why edge-detection exists.
Ladder logic draws a "rung" across two power rails. Left to right, you place contacts (inputs) and end with a coil (output). A normally-open contact (XIC in AB, --] [-- in standard notation) passes power when its tag is true. A normally-closed contact (XIO, --]/[--) passes when its tag is false. The coil at the end energises when power flows all the way across.
Most coils are non-retentive — they de-energise the instant the rung conditions fail. Latching solves the problem that most push-buttons are momentary. A SET / OTL coil turns the bit on and leaves it on; a RESET / OTU coil turns it off. The canonical three-wire motor seal-in rung uses a latch to keep a contactor energised after you release the START button.
The TON (on-delay timer) starts counting when its input goes true and sets its .Q output when the accumulator reaches the preset. TOF (off-delay) does the opposite. TP (pulse) produces a fixed-duration output pulse on a rising edge. Every scenario on this site uses timers; the Traffic Light scenario is essentially a timer-driven state machine.
CTU (count up) increments on rising edges, fires its .Q when the accumulator reaches the preset, and resets on command. CTD counts down. CTUD does both. Counters show up in conveyor-sort logic, batch counts, and anywhere you need to track discrete events.
R_TRIG fires for exactly one scan on a false-to-true transition; F_TRIG fires on true-to-false. Edge detection is how you make a rung respond to a push-button event rather than to the button being continuously held. Most beginner bugs in ladder logic are solved by adding an edge-detect block where you meant one.
Every physical input and output is mapped to an address. In Allen-Bradley: I:0/0, O:0/0. In Siemens: %I0.0, %Q0.0. In IEC 61131-3: you declare a tagged variable at an address (START_PB AT %I0.0 : BOOL;). Every scenario on this site ships with its IO list printed in the scenario brief; your first job is to map it mentally before you write a rung.
The Traffic Light is the cleanest beginner scenario on the site. You get a four-way intersection with north-south and east-west lamp outputs, a pedestrian walk button input, and a requirement to cycle through green, yellow, red with an all-red safety phase between transitions. The test harness checks sequencing, timing windows, and that no two opposing greens ever activate simultaneously.
Mechanically it reduces to three timers in a chain and a small state machine. You will write it, fail a test on a timing edge, realise the all-red phase needs a dedicated state, rewrite, and pass. That failure-and-fix loop is the actual learning; the scenario exists to make it happen in 15 minutes instead of a two-hour lab session.
You can load the scenario without an account at /scenarios/traffic-light to read the brief. Signing up unlocks the editor and the run button.
Each scenario introduces one or two new concepts and assumes everything before it. The library now spans 40 scenarios across six verticals. Resist the urge to skip to Pro tier; the sequencer muscle you build on Basic scenarios is what makes complex ones tractable.
Timers, state machines, sequencing.
Latching, seal-in rungs, interlocks (E-stop, thermal overload).
Reversing motor control, limit switches, obstacle detect.
Level control with hysteresis, latched alarms.
Photo-eyes, counters (CTU), reject actuator timing.
Multi-step sequencers, ingredient timing, agitator interlocks.
Entry/exit logic, loop detectors, barrier arm sequencing.
Multi-floor queueing, door timing, direction logic.
Closed-loop control, PID tuning, sensor feedback.
Indexing conveyor, filler/capper/reject interlocks.
We will say this clearly: a simulator is not a replacement for real hardware experience. You will eventually want time on an actual controller — wiring inputs, dealing with sinking-vs-sourcing DC, watching a contactor physically pull in, debugging an analog sensor with a multimeter. The logic half of PLC programming transfers cleanly from simulator to hardware; the wiring and commissioning half does not.
What this simulator does is get you through the logic half faster. You can iterate on a sequence a hundred times in the time it takes to wire one real panel. You can safely make the mistakes that would blow a fuse or damage an actuator in hardware. You can also practice on ten different machine archetypes in a weekend, which no reasonable hardware lab budget allows.
Once the scenarios start to feel easy, pair the simulator with: a cheap used PLC (a MicroLogix 1100 or a S7-1200 on eBay), a couple of limit switches and an LED bar, and a vendor certification you are prepping for. That combination — simulator for logic reps, hardware for commissioning reps, certification for the formal credential — is what gets people hired.
Scenario one takes about 15 minutes. Sign up free and write your first working ladder rung before your coffee goes cold.
Related: PLC simulator · ladder logic simulator · all scenarios · PLC programming course · PLC training · certification guide.