IMDHMIControls LibraryShop main store

Explainer

Reading ctrlX CORE variables without an OPC UA server

SCADA and data logging Published 6 min read

Short answer

A SCADA server app running on ctrlX OS, SpiderControl is the documented case, reads the variables of its own ctrlX CORE directly through the ctrlX Data Layer, so the local path carries no OPC UA server app. Variables on any other controller still arrive through the server's drivers, one session per source: OPC UA, Modbus or ISO-on-TCP. The server license includes unlimited local access and unlimited HTML5 browser clients, and a 10-day trial is issued automatically.

On this page
  1. What the ctrlX Data Layer exposes
  2. The local read: server and data on one device
  3. When a driver takes over
  4. Making PLC variables visible
  5. Alarming, trending and the IT side
  6. Licenses, clients and the editor
  7. Working one machine: a local CORE, two remote PLCs, ten trial days
  8. What to prove before the trial ends
  9. Questions asked

A SCADA server app that runs on ctrlX OS — SpiderControl from iniNet Solutions is the documented case — reads the variables of its own ctrlX CORE straight through the ctrlX Data Layer. The local path carries no OPC UA server app: no second protocol stack between the visualization and the data, nothing extra to license on the controller for that hop. The rule is one line: variables on the device the server runs on ride the Data Layer, and variables on any other controller ride a driver session. The local access is unlimited under the offered server license, a 10-day trial is issued automatically, and that trial is where you prove the link before you pay.

What the ctrlX Data Layer exposes #

ctrlX OS gives every app on the device one shared, addressable data space: the ctrlX Data Layer. The ctrlX PLC application publishes its global variables there as nodes, and any other app on the same device — the SCADA server, a logger, a provider written with the vendor SDK — reads, writes and subscribes to those nodes without a network protocol in between. The Data Layer also runs an SSE server, so a web application can subscribe to node changes the same way the server app does. What stays invisible is everything the PLC application does not publish: internal program state and function-block locals are not nodes until the application exposes them.

The local read: server and data on one device #

The SpiderControl server installs as an app on the ctrlX OS device, so the SCADA server and the data it wants live on the same controller, and the server subscribes to Data Layer nodes directly. Structurally, the OPC UA server app drops out of the local path: one fewer app to license, no certificate pairing between two apps on one device, one fewer serialization hop between the page and the variable. iniNet's pitch for this is lower cost and better performance; the part you can verify without a benchmark is the structure — the server app talks to the Data Layer, and no second protocol stack stands between them.

When a driver takes over #

The rule flips the moment a variable lives anywhere else. Data from other controllers reaches the server through its SCADA drivers — the documented set on ctrlX OS includes OPC UA, Modbus and ISO-on-TCP among others — which is what lets one HTML5 page carry variables from several controllers, collect the alarms that accumulated on different controls, and archive trend and alarm history over the long term.

Where the variable lives Connection the server uses OPC UA server involved?
On the same ctrlX OS device as the server ctrlX Data Layer No
On any other controller One driver session (OPC UA, Modbus, ISO-on-TCP, others) Only when that source speaks OPC UA

Count sources, not tags, before you license: give each off-device controller one driver session, and a controller that speaks none of the server's protocols needs a translator in front of it — a selection-time decision, not something to discover after the server is bought. For the wider trade across mixed controllers, selecting SCADA software for mixed PLCs and SQL logging works the same question.

Making PLC variables visible #

Variables reach the Data Layer only because the ctrlX PLC application publishes them: mark the globals, and they appear as nodes. The bridge runs both ways — a watchlist built against the Data Layer can be imported into the ctrlX PLC project, pulling outside nodes into the application alongside local ones. Publishing costs license headroom on the ctrlX side, so read how the ctrlX PLC license calculates I/O data and core use before committing a large tag list. And a PLC method is not a node: when the page must trigger logic, expose a command interface of variables — start and finish bits, an input and an output variable — rather than hunting for a method call.

The SCADA functions are the reason to run a server rather than bare visualization: alarm collection across controllers, long-term archiving of trends and alarms, and the SpiderPLC layer, a function-block editor that runs in the browser. Its I4.0 Integration Library wires process variables to SQL databases, REST APIs, MQTT, HTTP, PDF generation, email, FTP, CSV variable files, logging, namespace operations, file handling, screen captures, string functions and external-process monitoring, and it starts and watches NodeJS and Python script engines. Treat the script engines as their own integration boundary and test their inputs, outputs and failure behavior like any other code before production reporting leans on them.

Licenses, clients and the editor #

Licensing splits in two. The server app on ctrlX OS is licensed through the ctrlX ecosystem: the offered license bundles alarming, trending, unlimited data access to the local controller through the Data Layer, and unlimited HTML5 browser clients; the trial is issued automatically in the customer account of the ctrlX licensing center; the production license comes from the ctrlX Store. The editor is the other half: the SCADA PC HMI Editor is a PC program with its own license line — permanent terms directly, with trial, volume and fixed-term subscription terms on request — and it imports an existing CODESYS V2.3 Webvisu and converts it to HTML5 instead of forcing a redraw. Build and edit on an industrial panel PC that stays at the machine, and the same station doubles as one of the browser clients the server license already allows.

Working one machine: a local CORE, two remote PLCs, ten trial days #

The inputs, each with its source:

  • Server location: on the ctrlX CORE itself, as an app under ctrlX OS — the deployment the local-access clause of the license is written for.
  • Trial window: 10 days, server-app trial, from the ctrlX licensing center account.
  • Local variables: the ctrlX PLC application's published globals, reached as Data Layer nodes.
  • Remote sources: two controllers — one speaking Modbus TCP, one reached over ISO-on-TCP. These two are this example's assumptions; put your own count in their place.

The rule in words: one connection per data source. The source on the server's own device rides the Data Layer and needs no OPC UA server; every off-device source rides one driver session.

The arithmetic:

  • Connections: 1 Data Layer path + 2 driver sessions = 3 connections in the project.
  • OPC UA server apps required on the CORE: 0, because no source in this project speaks OPC UA.
  • Trial schedule: installation and configuration take the first day, so 10 days − 1 day = 9 days of live observation left inside the trial.

Result: three connections, zero OPC UA server apps, nine observation days. The decision that follows: the connection count sizes the licensing and the verification, so freeze the source list before the trial starts — the first variable that moves off the local device adds a driver session — and finish sign-off inside the ten days rather than against them, because production runs on the purchased license.

What to prove before the trial ends #

  1. Reads: every published global shows a live value in the browser page and changes when the process changes.
  2. Writes: one command from the page reaches the PLC through the Data Layer and the machine answers. Keep emergency stop and interlocks in the PLC — the page commands the process, it never guards it.
  3. Alarms: an alarm raised in a controller appears in the server's alarm list and archives rather than vanishing on acknowledge.
  4. Trends: a trend accumulates across hours and survives a page reload, proving the history sits on the server, not in the page.
  5. Remote sessions: each driver session reads its controller at the rate the displays need, with both remote PLCs online at once.

Questions asked

Does the SpiderControl server need an OPC UA server on the ctrlX CORE?

No. The server runs as an app on the ctrlX OS device and subscribes to local variables through the ctrlX Data Layer, so the local path carries no OPC UA server app. An OPC UA session enters the project only when a different controller is the data source and that controller exposes OPC UA.

How do I test the server before paying for a license?

The server-app trial runs 10 days and appears automatically in the ctrlX licensing center account, so there is nothing to request by hand. You can also run the whole check on a virtual control in ctrlX WORKS before touching the machine, then repeat it on the real controller with the same project.

Are browser clients limited by the license?

The offered ctrlX OS server license does not count them: HTML5 browser clients are unlimited, and so is data access to the local controller. What the license does not promise is concurrency headroom on the controller itself, which is exactly what the trial window lets you measure with your real pages.

What happens to existing CODESYS V2.3 Webvisu screens?

The SCADA PC HMI Editor imports a CODESYS V2.3 Webvisu and converts it to HTML5 rather than forcing a redraw. Convert one screen first and check that dynamic elements survived, then batch the rest; conversion quality is per element, and the trial period is a sensible window for that check.

Do the remote drivers need anything extra on the ctrlX CORE?

No additional app on the CORE: the drivers are part of the SCADA server. What each remote source needs is the protocol on its own side, an OPC UA endpoint, a Modbus TCP server or an ISO-on-TCP connection, and one driver session per source in the server configuration.

Keep reading

  • How-to

    Connect an S7-1500 to SCADA over OPC UA from TIA Portal

    The S7-1500 has a built-in OPC UA server from firmware V2.0, deactivated by default. Enable it in the CPU device properties in TIA Portal, select the installed server license, copy the endpoint URL, and download. Paste the opc.tcp address into any OPC UA SCADA client, trust the certificates on both sides, then browse the PLC variables and map them to SCADA tags.

    SCADA and data logging

  • Troubleshooting

    Getting Citect SCADA talking to a Mitsubishi iQ-R PLC

    Fix the transport before anything else: the Citect MELSECQ port on TCP_BOARD must match the iQ-R's SLMP connection module exactly — protocol, port number and IP address. If tags above device 65,535 fail, that is the MELSEC Q protocol's 16-bit address ceiling, and no setting fixes it; move to Mitsubishi's OPC MX UA server with a Citect OPC client driver.

    SCADA and data logging

  • Troubleshooting

    Reading M580 I/O in Plant SCADA without mapped memory addresses

    Bad I/O on %Q1.1.20 means Plant SCADA is reading a topological M580 channel address that no driver can resolve as a register, and no Modbus table exists to look up. Serve the points through the OFS gateway using PLC tag names, with an XVM export now and the Data Dictionary permanently, and add the missing variables by online change so the 24/7 line never stops.

    SCADA and data logging