Learn Omron machine automation with cookie cutters, vending machines and donut boxes instead of dry manuals. There are thirteen interactive tracks plus deep dives, and no spaghetti code.
Arrays from scratch: numbered slots, indexing, reading and writing values. You scrub through the walk-through step by step with a box full of donuts.
A gentle on-ramp to reusable logic: why function blocks, what an instance is, and how copies roll off the line in Sysmac Studio. It gives you the mental model before the deep course.
The main course. Fifteen chapters run across Basics → Reuse → Advanced, covering function blocks, structured text, namespaces, libraries and design patterns, and finish with a certified Hero Test.
The toolkit that makes machines run: TON/TOF timers, state machines, in-out references, error handling, and the IEC languages (Ladder vs ST vs FBD) side by side.
How an NJ/NX controller actually runs your code, task after task. The I/O refresh, the primary periodic task & its period, task execution time & the watchdog, multitasking with priorities, and what survives a power cycle.
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 and global variable tables.
Where logic finally moves a servo. 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 exactly one state, such as Disabled, Standstill, Homing, Discrete Motion, Stopping or ErrorStop. Instead of memorising the diagram, you drive it. The track ends with the coordinated-group version, also clickable.
Give the machine a face and open it to the world. The NA-series operator panel, polling vs subscription, host comms over FINS & CIP, then OPC UA across the plant and MQTT to the cloud. All live toys.
The world your code runs in. What a FINS node address really is and how you reach other brands, how Sysmac libraries deliver features, the NJ/NX hardware family, CX-Programmer vs Sysmac Studio, and every variable scope mapped.
The capstone skill: the online view, breakpoints & stepping, the Sysmac Troubleshooter, the event log & error codes, EtherCAT bus diagnostics (find the dropped slave), and Data Trace, plus a method that chases any bug to ground.
Functional safety on the same backplane: why it's an independent layer, the NX safety I/O units, the NX-SF safety logic & FSoE, the monitored E-stop circuit, how safe & standard code coexist, and SIL/PL with the safety lifecycle.
Teach the machine to see: the FH vision system as an EtherCAT slave in the same Sysmac project, scenes as recipes, trigger-and-judge from your code, and the calibration that turns pixels into millimetres. Then run a live guided-pick cell where the measured offset corrects the pick.
The whole host-comms world, taken apart: what FINS and CIP actually are, node & unit addressing, ports & services, building routing tables, the raw read/write services, and crossing to other brands, sites & the cloud.
Reuse, all the way down: what a Sysmac library is, the standard set Omron ships, namespaces & versioning, the library catalog & references, building & publishing your own, and the versioning discipline that keeps a fleet on one codebase.
Every box, sorted: brain vs dumb I/O, the NX/EJ couplers & terminals (build an island), the NJ/NX CPU family, the NY IPC & Panel PC, the EtherCAT backbone (watch a frame fly the chain), and sizing the right controller.
The generation gap in full: CJ/CP legacy vs NJ/NX modern, the one-tool Sysmac Studio IDE, multi-core real-time, structured programming & integrated motion, which hardware runs which, and the reality of migrating a project across.
Who sees what, and for how long, fully mapped. The three questions, the input/output/in-out interface (by value vs by reference), internal & temp variables, globals & AT I/O mapping, Retain lifetimes, and access from the outside.
Every custom type, with a real application: STRUCT for recipes, ENUM for machine modes, UNION for decoding fieldbus data, and arrays of structs for a whole tabulated line, then composing them into a 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.
How a controller talks to the field: the cyclic-vs-acyclic split, serial RS232/RS485, Modbus RTU & TCP (the register model), and EtherCAT (the Omron real-time model). For each one you learn what it is for, when to use it, and how variables move through it.
Run the controller with no hardware: simulate I/O, model the machine, and test logic against a virtual plant before commissioning. Beginner-friendly, fully interactive.