41 structured lessons from scan cycles to PID tuning. Every concept has a live simulator exercise — you don’t read about ladder logic, you run it.
Every lesson is grounded in the way real machines are programmed — and every chapter ends with an exercise you run in the browser. No video lectures, no filler.
Every lesson ties back to a scenario you can run. Read about seal-in rungs, then write one and watch the motor start.
Fundamentals → contacts → timers → state machines → PID. No prerequisites assumed.
Pick up where you left off. Lessons, scenarios, quizzes, and interview tracks share one progress record.
The first few lessons never need a card. Upgrade when you want state machines, PID, safety, and SCL.
Titles and summaries are public. Lesson bodies and exercises open once you sign up.
The plain-English answer: a PLC is a small rugged computer that runs machines. Where you find them and why they exist.
How a PLC actually runs your program: read inputs, run program, write outputs — three phases in a loop, dozens of times a second.
The memory model, program organisation (tasks + POUs + watchdog), and the IDE project workspace — how the pieces inside a PLC actually fit together.
Why ladder diagrams look like electrical schematics: they ARE electrical schematics, redrawn for a CPU to interpret.
Reading and writing your first rungs — contacts, coils, series, and parallel.
Why a slash through a contact symbol matters: normally-closed contacts make stop buttons failsafe.
TON/TOF/TP timer blocks and CTU/CTD/CTUD counters — side-by-side timing diagrams and a conveyor that demonstrates the rising-edge bug.
Why a momentary start button can run a motor for hours: the seal-in latch pattern.
Seal-in rungs, SET/RESET coils, and stop-priority design.
Time-dependent logic with the on-delay timer block. Continuous input for PT seconds → output goes true.
Model sequential processes with state bits, guarded transitions, and one-shot edges.
SFC as visual sequencing — steps, transitions, action qualifiers (N/S/P/R), and parallel AND-split / AND-join branches driven by a kinetic chart you can hold-to-advance.
ST as Pascal-with-PLC-semantics — variable declarations, IF/ELSIF branches stepped line-by-line, CASE state machines, and the parenthetical function-block call style.
Scan-time pitfalls visualised — mid-scan readback, double-write conflicts, and the watchdog timer trip you never want to see in the field.
Live-zero current loops, resistive voltage drop, and the full scale/unscale pipeline — driven by a kinetic 4–20 mA loop scene, a dual-axis linear interpolation visualiser, and a clamping/reverse-acting output demo.
Stateless functions vs stateful FB instances; IEC pin layout; TON/CTU lifecycle and edge cases; R_TRIG debouncing; best practices for FB instantiation.
EQ/NEQ/GT/LT/GEQ/LEQ comparison instructions and ADD/SUB/MUL/DIV math — live operand sliders, overflow detection, and a window-comparator scan-order demo.
Master shift registers for conveyor part tracking and sortation. Watch bits travel cell-by-cell in a kinetic 8-station register, then see a diverter solenoid fire at the exact right moment when the tracked bit arrives.
Watch a live PV-response curve chase a setpoint step as you toggle between open-loop, P-only, and full PID — then explore integral windup, anti-windup clamping, bumpless Auto/Manual transfer, and cascade control in an interactive PLC block diagram.
ISA-18.2 alarm state machine — thresholds, ack/reset workflow, first-out latching, alarm shelving, deadband hysteresis, and safe-state design, all driven by live kinetic simulations.
Animated client/server packet exchange, all eight function codes, the four Modbus address spaces, exception responses, and polling strategies.
SIL basics, ISO 13849 PL categories, dual-channel cross-monitoring, and a kinetic dual-channel discrepancy latch + E-stop rising-edge reset demo.
POU types (Program / Function Block / Function), how task scheduling sets scan rates across swim lanes, and global vs local variable scope — all demonstrated with kinetic visuals you can interact with.
Structured fault isolation using decision trees, live watch tables with force simulation, and single-variable change tracking to avoid the most common diagnostic pitfalls.
A multimeter is the simplest way to verify your wiring. Set the dial to V DC, place the black probe on 0 V, the red probe on the input, and watch the voltage jump when you press the button.
In software you just clicked a simulated button. In real life, that button is wired to the PLC input terminal — and that wire IS what X0 sees.
Real machines use sensors instead of buttons. A photoeye is a switch that closes when something passes through its beam — your program reads it exactly like a button press.
The same start-stop logic written two ways: ladder (visual) and Structured Text (code). The simulator runs both — pick whichever you prefer.
A photoeye that won't turn the input on. Probe with the meter, find 0 V where you expected 24 V — the photoeye is wired NPN (sinking) when the PLC expects PNP (sourcing). Swap the wires.
A panel with a missing PE ground bond doesn't trip the breaker when the chassis goes live. Fault current has nowhere to flow. Bond every touchable metal frame to the ground bar.
The Start button does nothing. The program looks fine. The wire is in terminal slot 7; the program reads X0 (slot 8). The slot you wire to has to match the address the program reads.
An open-collector NPN sensor whose pull-up resistor is wired to 0V instead of +24V. The PLC input reads 0V no matter what the sensor does. The pull-up has to pull UP — to +24V.
A Start button works most of the time but randomly fails. Wiggling the wire fixes it. The terminal screw is loose — re-torque it to spec.
You wired +24 V into the input but the PLC never reads ON. The 0 V return wire from the PLC back to the supply common is missing — current can't flow, so the input can't respond.
Profinet wiring at the cable layer: M12 D-coded vs RJ45 IP20 connectors, daisy-chain vs star vs ring topologies, and the diagnostic LED protocol every Siemens panel speaks.
Pressing Stop does nothing — the motor keeps running. The wiring looks fine. The bug is in the rung: the Stop contact is Normally-Open instead of Normally-Closed.
A broken start-stop circuit: motor runs while START is held, drops the moment it's released. The seal-in contact is missing. Once you spot it, you can't un-spot it.
Press Start — nothing happens. The wiring is fine. The bug is in the program: the rung is reading the wrong input address. The wire and the symbol have to share a name.
A rung has all the right input contacts but no output. Conditions are met. Nothing happens. Every rung needs something on its right-hand side that DOES something.
A rung runs the motor backwards: idle when conditions are met, running when they aren't. The bug is an inverted contact at the start of the rung — fix it by removing the slash.
A 10-second drying cycle finishes in 1 second. The rung looks correct. The bug is a single-character typo in the timer preset value.
Lessons are broken into short chapters. Each chapter mixes explanation, a worked example, and an exercise you complete in the live editor.
Sign up free — the first lessons are on us. No card, no download.