Learn industrial PLC programming the fun way — cookie cutters, vending machines, and donut boxes instead of dry manuals. Twelve interactive tracks plus deep dives, zero spaghetti.
Arrays from scratch — numbered slots, indexing, reading and writing values. A walk-through you scrub step by step with a box full of donuts.
Your gentle on-ramp to object thinking — why OOP, what a function block is, and how instances roll off the line. The mental model before the deep dive.
The flagship. Fifteen chapters across Basics → Reuse → Advanced — function blocks, methods, properties, inheritance, interfaces, pointers, patterns — capped by a certified Hero Test.
The practical toolkit that makes machines run: timers, state machines, pointers & references, error handling, and the IEC languages (LD vs ST vs FBD) side by side.
How a PLC actually runs your code, cycle after cycle. The process image, cycle-time budgets & the watchdog, multitasking with priorities, and what survives a reboot. The mental model everything else stands on.
Tidy your variables with custom types. Bundle fields into a STRUCT, name states with an ENUM, reinterpret bytes with a UNION, tabulate with arrays of structs — then file it all into POUs, GVLs and libraries.
Where logic finally moves a motor. Enable an axis with MC_Power, command absolute & relative moves, shape the velocity profile, home & jog — then read an analog sensor and scale raw counts to real engineering units.
The rulebook under every motion command. An axis is always in one state — Disabled, Standstill, Homing, Moving, Stopping, ErrorStop — and you don't memorise the diagram, you drive it. Ends with the coordinated-group version, clickable.
Give the machine a face and open it to the world. The operator panel, polling vs subscription, a deep dive on ADS (routes, handles, notifications, sum commands & TwinCAT-only tricks), then OPC UA across the plant and MQTT to the cloud. All live toys.
The world your code runs in. What an AmsNetId really is and how you reach other brands, how libraries deliver features, the hardware family (CX5060, couplers, Panel-PC-as-CPU), TwinCAT 2 vs 3, and every variable scope mapped.
The capstone skill: the online view, breakpoints & stepping, write vs force, the event logger & ADS error codes, EtherCAT bus diagnostics (find the dropped slave), and the Scope — plus a method that chases any bug to ground.
Functional safety on the same hardware: why it's an independent layer, the yellow safe I/O terminals, the TwinSAFE logic & FSoE, the monitored E-stop circuit, how safe & standard code coexist, and SIL/PL with the safety lifecycle.
Run the runtime with no hardware. A live donut-glazing line you can run, wind to 20× and break on purpose — then the TwinCAT-specific bit: how Activate onto the local runtime (127.0.0.1.1.1) cycles the real task with a simulated EtherCAT bus, and the SIL → HIL → digital-twin ladder.
The same donut line makes strawberry rings, choc-sprinkles and sugar minis — without touching the code. Pick a recipe and watch the live line reconfigure itself: the recipe STRUCT, the active copy, the stored set, where TwinCAT keeps them (Tc2_RecipeManagement), and why changeover, repeatability and traceability all hang on this.
The whole ADS world, taken apart: what ADS actually is (message router), AmsNetId anatomy, ports & services, building routes, the raw services & IndexGroup/Offset addressing, and crossing to other brands, sites & the cloud.
Reuse, all the way down: what a library is, the standard set Beckhoff ships, namespaces & versioning, the repository & references, building & publishing your own, and the versioning discipline that keeps a fleet on one codebase.
Every box, sorted: brain vs dumb I/O, couplers & terminals (build an island), the CX embedded-PC family, IPCs & Panel-PC-as-CPU, the EtherCAT backbone (watch a frame fly the chain), and sizing the right controller.
The generation gap in full: the big differences, the Visual-Studio IDE, multi-core real-time, OOP & C++/Simulink modules, which hardware runs which, and the reality of coexistence & migrating a project from 2 to 3.
Who sees what, for how long — fully mapped. The three questions, the INPUT/OUTPUT/IN_OUT interface (by value vs by reference), TEMP/STAT/CONSTANT, globals & AT %I* I/O mapping, RETAIN/PERSISTENT lifetimes, and access modifiers.
Every custom type, with a real application: STRUCT for recipes, ENUM for machine modes, UNION for decoding fieldbus data, ALIAS & subrange for clarity & range-safety — then composing them all into a whole production-line model.
Every built-in type, with the gotchas: BOOL & bit-packing, the integer family & silent overflow, REAL vs LREAL precision, STRING & TIME literals, and converting safely (plus pointers & references).
How a PLC talks to the field: the cyclic-vs-acyclic landscape, serial RS232/RS485, Modbus RTU & TCP (the register model), and EtherCAT (the Beckhoff real-time model) — what each is for, when to use it, and how variables move through each.
Lock down the robot on rails. The attack surface of a seventh-axis slider, STRIDE threat modelling, then four chapters deep on IEC 62443 — the framework, Security Levels SL1–4, Zones & Conduits and the Foundational Requirements — closing with secure controller code and a live exploit-vs-defence lab.
Raise, acknowledge and store machine alarms with TcEventLogger, surface them on the HMI, and keep an audit trail of what happened and when. Now live — open it →