Learn Omron machine automation 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 reusable logic — why function blocks, what an instance is, and how copies roll off the line in Sysmac Studio. The mental model before the deep course.
The flagship. Fifteen chapters across Basics → Reuse → Advanced — function blocks, methods, structured text, namespaces, libraries and design patterns — capped by 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, 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 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 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 — 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, 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 landscape, serial RS232/RS485, Modbus RTU & TCP (the register model), and EtherCAT (the Omron real-time model) — what each is for, when to use it, and how variables move through each.
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.