Explainer
How the ctrlX PLC license calculates I/O data and core use
Short answer
The ctrlX PLC license sums the bits of I/O data the PLC program actually uses under the DataLayer_Realtime node and the CODESYS fieldbus add-ons, rounded up to whole bytes; one CPU core and up to 1 kByte fits the Standard license, and any program split across more than one core needs at least Advanced. The two-drive reference case counts 18 bits and lands on 3 bytes.
On this page
- The three criteria
- Core use decides the tier before bytes do
- What the metric counts
- What stays out of the count
- Bit widths and the rounding rule
- Worked example: two drives, one 2-byte parameter, one input bit and one output bit
- Where the bytes came from in a documented robot cell
- Reading the controller's own count
- Questions asked
The ctrlX PLC license metric counts three things: how many CPU cores the PLC program runs on, how many PLC tasks it uses, and how much I/O data the program actually consumes. Task count stopped being a license criterion from PLC version 3 onward, so a current project sizes against cores and bytes. The byte figure is the sum of every bit the program uses under the DataLayer_Realtime node and the CODESYS fieldbus add-ons, rounded up to whole bytes. Split the program across more than one core and you need at least the Advanced license whatever the bytes say; keep it on one core and the Standard license covers one core, multiple tasks and 1 kByte of counted I/O. The manufacturer's reference case — two drives, one extra 2-byte parameter, one input bit, one output bit — counts 18 bits and lands on 3 bytes.
The three criteria #
Bosch Rexroth's license overview describes the ctrlX PLC Standard license as the IEC 61131 runtime — the standard that defines the ladder, structured-text and function-block languages your program is written in — with one CPU core, multiple PLC tasks and 1 kByte of I/O data. Everything in the metric is measured against those three allowances:
| Criterion | What it measures | What moves the tier |
|---|---|---|
| CPU cores | The cores the PLC program actually executes on | More than one core requires at least the Advanced license |
| PLC tasks | The configured task count | Not limited from PLC version 3 onward; earlier versions follow their own license overview |
| I/O data | Bits under DataLayer_Realtime and the CODESYS fieldbus add-ons that the program uses | Past 1 kByte, Standard no longer covers the project |
Read the two readings separately: the PLC version governs the task criterion, and the core allocation governs the tier. Neither can be inferred from the other.
Core use decides the tier before bytes do #
A program on one CPU core meets the Standard core allowance at any byte count within 1 kByte. A program split across two or more cores for performance needs at least Advanced, and no small byte count changes that. Task count does not imply core count — multiple tasks can share one core — so read the actual core allocation in the engineering environment rather than deducing it from the task list. If you are considering collapsing to one core just to stay on Standard, verify task execution and timing under the real workload first; if the workload genuinely needs the split, keep the architecture and license it.
What the metric counts #
The byte count is the sum of the data configured under the DataLayer_Realtime node plus the data the PLC masters through the CODESYS fieldbus add-ons — cyclic fieldbus communication such as PROFINET, EtherNet/IP or Modbus TCP. EtherNet/IP I/O between a ctrlX adapter and a Rockwell scanner is one documented case of that second route.
By default, only variables actually used in the PLC program count. A variable that exists in the configuration but has no reference in the code adds nothing, while a single used status bit counts even when the rest of that device's data flows through another application. Counting only what the program consumes is not unique to this controller: how a WinCC RC license counts TCP/IP OPC tags draws the same line on the SCADA side.
What stays out of the count #
Motion-related values never need a DataLayer_Realtime mapping: the ctrlX MOTION App and the Motion Interface exchange them with the drive through the ctrlX Data Layer. Drive Status Word, Master Control Word, Position Command Value, Position Feedback Value and Probe Input Value belong to that path, so the axes themselves contribute nothing to the byte count. The drive-side engineering of that exchange is its own task, and interfacing an EFC5610 drive with a ctrlX CORE over EtherCAT walks through the configuration.
Only non-motion values the PLC must process in real time are added. Motor temperature is the standard case: add the parameter to the drive's cyclic process data in ctrlX IO Engineering, import that configuration into the ctrlX MOTION App — the motion values appear in the axis profile and stay uncounted — and then place the temperature value under DataLayer_Realtime, where its width joins the count.
FSoE telegrams are exchanged directly between the FSoE master and slave and never pass through the PLC, so they are outside the metric. The safety status the PLC reads — safe inputs such as e-stops and door contacts, plus the drives' safe-mode status — is mapped data and does count. Never let byte arithmetic decide what safety status gets mapped: those bytes are trivial next to an operator interface that cannot show why the machine stopped.
Bit widths and the rounding rule #
Each counted value contributes its process-data width: single bits for digital signals, the documented width for analog values and parameters. The width lives in the module's process data image, published in the ctrlX I/O product information — the XI332204 analog input terminal, a 4-channel 0 to 20 mA unit with 16-bit conversion, contributes 4 x 16 = 64 bits when the program uses all four channels.
The metric counts bit-wise and reports bytes: take the total bits, divide by 8 and round up to the next whole byte. Eighteen bits and nineteen bits both cost 3 bytes, and one lone bit costs a full byte.
Worked example: two drives, one 2-byte parameter, one input bit and one output bit #
Inputs, each with its source:
- Two ctrlX DRIVES whose axis values all serve motion control, from the manufacturer's reference configuration — nothing sits under DataLayer_Realtime for the axes.
- One cyclic drive parameter added for PLC processing, the motor-temperature case, at 2 bytes (16 bits), taken from the cyclic process-data configuration in ctrlX IO Engineering.
- One digital input the program reads: 1 bit.
- One digital output the program drives: 1 bit.
- The program executes on one CPU core, read from the core allocation.
The rule in words: add the widths of everything the program uses, inputs and outputs together, in bits; divide by eight and round up to a whole byte.
The arithmetic: 16 bits + 1 bit + 1 bit = 18 bits. 18 / 8 = 2.25, rounded up = 3 bytes.
Result: 3 bytes of counted I/O data.
Decision: 3 bytes sits far inside the 1 kByte Standard allowance and one core meets the Standard core limit, so Standard licenses this project. The same project split across two cores for performance needs Advanced with the byte count unchanged. Past 1 kByte of counted I/O, Standard no longer covers the project, and the next tier's allowance is listed in the License Overview tab in ctrlX OS and on the PLC page in the ctrlX Store.
Where the bytes came from in a documented robot cell #
A cell with two cartesian robots (six axes in total), one belt axis, one safety PLC and a bus coupler carrying six I/O modules counted 30 bytes:
| Source | Bytes |
|---|---|
| I/O modules | 5 |
| Fieldbuses | 0 |
| Non-motion drive parameters (S-0-0135, S-0-0240, S-0-2057/2058) | 24 |
| Communication with the safety PLC | 1 |
| Total | 30 |
The seven motion axes contributed nothing directly, and 24 of the 30 bytes were cyclic non-motion drive parameters. When a count looks high, audit the cyclic parameter list, not the axis count. At 30 bytes the tier still comes down to cores: single-core execution stays within Standard, and a performance split puts the project in Advanced.
Reading the controller's own count #
Select the controller and open the License Overview tab in ctrlX OS: that reading is the acceptance check, and a manual count is only a prediction. When the two disagree, work through variable references first, because the default counting includes only used variables. After an app upgrade — one documented case moved from 1.20.11 to a 2.6.10 target — a download can be refused with the message "control does not have the required licenses"; re-read the tab against the new version's criteria before buying anything, since that refusal can be a version-entitlement mismatch rather than a genuinely larger project.
Questions asked
Do the drives in my cell each add I/O bytes to the license count?
No. Motion-related values such as the drive status word, master control word, position command value, position feedback value and probe input value move between the ctrlX MOTION App and the drive through the ctrlX Data Layer without a DataLayer_Realtime mapping, so the axis count alone adds nothing. Only non-motion values the PLC must process in real time count, which is why the reference case with two drives totals just 3 bytes.
Does FSoE safety telegram traffic count toward the I/O bytes?
No. That traffic sits outside the metric because the safety telegrams bypass the PLC runtime entirely. The safety status you map into the program does count, including status of safe inputs such as e-stops and door contacts and the drives' safe-mode status. In the documented robot cell that communication with the safety PLC was 1 byte of a 30-byte total.
My controller shows fewer counted bytes than I configured. Which number is right?
The controller's reading is the acceptance number. By default the metric counts only variables actually used in the PLC program, so a variable that exists in the engineering configuration but has no reference in the code adds nothing. Reconcile the two lists by checking variable references before buying a larger license, and take the License Overview tab in ctrlX OS as the final check.
How many PLC tasks and CPU cores does the Standard license allow?
Standard covers one CPU core, multiple PLC tasks and 1 kByte of counted I/O data for the IEC 61131 runtime. From PLC version 3 onward, task count is no longer a license criterion at all. The moment your program is split over more than one CPU core for performance, you need at least the Advanced license whatever the byte count is.
Does adding a fieldbus master to the PLC change the license?
Yes, in bytes only. Data the PLC masters through the CODESYS fieldbus add-ons, such as cyclic PROFINET, EtherNet/IP or Modbus TCP exchanges, is counted the same as DataLayer_Realtime data, at each value's process-data width. In the documented robot cell the fieldbus line was 0 bytes because nothing was mastered there, and the tier still came down to cores and the byte total.