Learn industrial PLC programming with cookie cutters, vending machines and donut boxes instead of dry manuals. There are fourteen interactive tracks plus deep dives, and none of it is spaghetti code.
Arrays from scratch: numbered slots, indexing, and reading and writing values. You scrub through the walk-through step by step with a box full of donuts.
A gentle on-ramp to object thinking: why you would use OOP, what a function block is, and how instances roll off the line. You get the mental model here, before the deep dive.
The main course. Fifteen chapters in three parts (Basics, Reuse, Advanced) cover function blocks, methods, properties, inheritance, interfaces, pointers and patterns, and the course ends with a certified Hero Test.
The everyday toolkit that keeps machines running: timers, state machines, pointers & references, error handling, and the IEC languages (LD vs ST vs FBD) side by side.
How a PLC runs your code, cycle after cycle: the process image, cycle-time budgets & the watchdog, multitasking with priorities, and what survives a reboot. Every other track stands on this mental model.
Tidy your variables with custom types. Bundle fields into a STRUCT, name states with an ENUM, reinterpret bytes with a UNION and tabulate with arrays of structs. Then file it all into POUs, GVLs and libraries.
This is where logic moves a motor. Enable an axis with MC_Power, command absolute & relative moves, shape the velocity profile, and home & jog. After that you read an analog sensor and scale raw counts to real engineering units.
The rules under every motion command. An axis is always in exactly one state (Disabled, Standstill, Homing, Discrete Motion, Continuous Motion, Synchronized Motion, Stopping, ErrorStop), and instead of memorising the diagram you drive it. The track ends with the coordinated-group version, which you can also click through.
Give the machine an operator screen and connect it to other systems. The track covers the operator panel, polling vs subscription and a deep dive on ADS (routes, handles, notifications, sum commands & TwinCAT-only tricks), then OPC UA across the plant and MQTT to the cloud. Every part comes with a live toy to try.
The system your code runs in: what an AmsNetId 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. You also learn a method for chasing 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. You get a live donut-glazing line to run, wind up to 20× and break on purpose. Then comes the TwinCAT-specific part: how Activate onto the local runtime (127.0.0.1.1.1) cycles the real task with a simulated EtherCAT bus, and the ladder from SIL to HIL to digital twin.
The same donut line makes strawberry rings, choc-sprinkles and sugar minis without anyone 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 (RecipeManagement), and why changeover, repeatability and traceability all hang on this.
The whole of ADS taken apart: what ADS is (a 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 what coexistence looks like in practice & migrating a project from 2 to 3.
Who sees what, and 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. The last chapter composes them all into one 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: cyclic vs acyclic traffic, serial RS232/RS485, Modbus RTU & TCP (the register model), and EtherCAT (the Beckhoff real-time model). For each one you see what it is for, when to use it and how variables move through it.
Lock down the robot on rails. Start with the attack surface of a seventh-axis slider and STRIDE threat modelling, then spend four chapters on IEC 62443: the framework, Security Levels SL1–4, Zones & Conduits and the Foundational Requirements. The track closes 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. It is live now: open it →