SCADA Dashboards

AnyAutomation Studio can turn the signals of your PLC program into a running web dashboard (a SCADA screen) without hand-building it. You pick the signals, optionally arrange them into screens, choose how the dashboard connects to the plant, and send the result to your own FUXA instance, a free open-source web SCADA. You can also save the dashboard as a file and import it into FUXA by hand.

SCADA Dashboards is part of the Pro plan. See Licensing for the plans.

Before you start

You need three things:

• A FUXA instance you host. FUXA is a separate web application that runs the finished dashboard. You can run one yourself, or let Studio start one for you (see Deploy a FUXA instance below).
• A signal list. The dashboard is built from a SCADA configuration: the data points of your machine with their data type and comment, plus the variables of your tag tables with their address. You produce it in Forge (mark blocks as SCADA interfaces and export a selection), or from a PLC's exported OPC UA node set. You can also gather the signals right on the SCADA page.
• Access to the plant. The generated dashboard connects to a live source, over OPC UA, a direct Siemens S7 link, or an MQTT broker.

Open the SCADA page

Select the SCADA icon in the activity bar (the dashboard icon on the left edge), and the SCADA page opens straight away in the center of the workbench. You can also run Open SCADA Page from the Command Palette (Ctrl+Shift+P). The page gathers the whole workflow: the FUXA connection, an optional deployment, the signal source, the signal tree, the screen plan and the generate actions. Opening it again brings the same page back to the front. For your project tree, use the TIA Portal icon next to it.

Point Studio at your FUXA instance

In the Connection area at the top, enter the address of your FUXA instance, for example http://localhost:1881. If your instance requires a login, set the access token with the button next to the field; it is stored securely and never shown again.

Test Connection reads the current project back from the instance and shows a green line with the number of devices, views and tags it holds, or a red line with a precise reason if it cannot reach it. Open FUXA opens the instance in your browser so you can watch the dashboard while you work.

Load the signals

Use the Source area to bring in the signals:

• Export from CPU reads the address space of a connected PLC and loads it directly.
• Open Node Set File loads a node set that a CPU exported earlier.

If you produced a SCADA configuration in Forge, open that file with Generate FUXA Project (see The two file commands below) instead.

Once signals are loaded, the signal tree lists them indented by block and folder. Each row has a checkbox and a small badge showing whether the signal is read-only or read/write, and a running tally shows how many are selected. Tick the signals you want on the dashboard; the generate actions work on the ticked selection.

Choose how the dashboard connects

The Connection dropdown in the generate area chooses how the finished dashboard reaches the plant. The address field below it changes its label to match your choice.

• OPC UA server (the default). Enter the OPC UA endpoint URL of the PLC, for example opc.tcp://192.168.0.5:4840. A Namespace Index field and an OPC UA Security row appear: pick the message security (None, Sign, or Sign and Encrypt) and, when it is not None, a policy and an optional user name with a stored password. The PLC must trust the FUXA client certificate; in your CPU, add it to the OPC UA server's trusted clients or allow clients to be accepted at runtime.
• Siemens S7 PLC. Enter the PLC's IP address and set the Rack and Slot (S7-1200 and S7-1500 use rack 0 and slot 1). Only signals that carry a fixed hardware address are included, that is tag-table flags, inputs and outputs, and absolute data-block addresses. Symbolic data-block members have no fixed address and are left out; a message lists what was left out, and those signals need an OPC UA connection instead.
• MQTT broker. Enter the broker URL, for example mqtt://192.168.0.20:1883. Every signal becomes a topic named after it, and the dashboard subscribes to it. A read/write signal also sends its value back to its topic when you change it on the dashboard from an input field or a button. To read a value out of a JSON message instead of a whole topic, or to set which topic a signal uses, add a token to the signal's comment (see Read a JSON member or set the topic below).

The password commands Set OPC UA Password and Clear OPC UA Password (also in the Command Palette) manage the OPC UA login password when you use one.

Read a JSON member or set the topic

On an MQTT dashboard, two tokens in a signal's comment give you more control. They are written like the unit and alarm tokens and are removed from the label shown on the dashboard:

• {topic=plant/motor1/status} sets the exact topic the signal uses, instead of the signal's name. Several signals can point at structured topic paths this way.
• {jsonkey=speed} binds the signal to the speed member of a JSON message on the topic, instead of a whole topic value. Several signals can share one topic with different keys, each reading its own member. A read/write signal with a key writes that member back.

A signal sends to the same topic it reads from, so one signal is one topic. A separate command topic and status topic are two separate signals.

Arrange the screens

By default the dashboard is a plain value table of the ticked signals. To build a structured, multi-screen dashboard, use the Screens area:

• Propose Screens turns the ticked signals into a screen plan: an overview screen with navigation tiles, one screen per top-level machine module, and detail screens for large groups.
• Each screen row can be renamed, given a layout (Tiles, Sections, Table or Free), moved up or down, merged into another screen, or removed.
• Background picks an SVG image for a screen, for example a plant drawing exported from a design tool. The image sits behind the screen's widgets. Anything unsafe in the file is removed automatically and a short notice says how many items were stripped.
• Choose Symbol Folder loads a folder of your own SVG symbols, including the ones kept in subfolders, so a nested symbol library is picked up whole. Once symbols are loaded, each top-level widget gains a Symbol dropdown that turns it into a bound on/off switch using the chosen symbol and its off and on colors.
• Save Plan and Load Plan write and read a plan file, and Clear Plan drops it.

While a screen plan is present, the generate actions build the planned multi-screen dashboard instead of the plain table.

Alarms

Mark a signal as an alarm and the dashboard raises it when the signal enters its alarm state, and shows an alarm banner in the header while any alarm is active. You mark a signal by adding a token to its comment, for example {alarm=high}, with an optional group and message text, and an analog band with {alarmmin=} and {alarmmax=}. You can also add an alarm table widget to a screen that lists the active alarms with their time, message, group and acknowledgment. The assistant can mark a signal and drop an alarm table for you.

Values, units and trends

A value shows the unit and the number of decimals noted in the signal's comment, for example {unit=bar}{digits=1}, and an input field keeps entries within the signal's limits when you note {min=} and {max=}. A trend chart keeps its history and opens already filled with recent values.

Generate and send

Three actions finish the dashboard:

• Generate and Send to FUXA sends the dashboard to your instance. By default it merges into the project already there, so the screens, devices and alarms you built by hand in FUXA are kept and only the generated ones are added or updated. The On Send dropdown switches this to Replace, which overwrites the whole project. Either way a confirmation first tells you how many devices, views and tags are currently on the instance. When you use a Siemens S7 connection, a message afterwards lists any signals that were left out.
• Save as .fuxa.json writes a FUXA project file you can import into FUXA by hand.
• Save as .scada.json writes the signal configuration back to a file so you can reuse it later.

After a successful send, a message offers Open FUXA to view the result.

Deploy a FUXA instance

If you do not run FUXA yet, the Deployment area can start one for you through Docker. Leave the Docker host empty to use the local Docker engine, or point it at a remote engine. The buttons start, stop or restart the instance, and Deploy brings up a fresh instance. This needs Docker to be installed and running on the chosen host.

Let the assistant build it

The chat assistant knows the signals loaded on the open SCADA page. On your instruction it can read the node set, curate the signals, group them into named screens, mark alarms, and generate or send the dashboard. It fills the page's Assistant Preview and selects the matching signals in the tree so you see exactly what it proposes before anything is sent, and it tells you plainly whether a send went through, was declined or failed. When it sends, it asks whether to keep your existing FUXA project or replace it, whichever you asked for.

The two file commands

Two commands work straight from a file, without opening the SCADA page:

• Generate FUXA Project, on the right-click menu of a *.scada.json file (or from the Command Palette), builds a FUXA project from that configuration and either saves it or sends it to your instance.
• Generate SCADA from OPC UA Nodes, on the right-click menu of a *.xml node set file (or from the Command Palette), reads a CPU's exported OPC UA node set and builds the same dashboard from it, then offers to save a configuration, send it to your instance, or write a project file.

Both share the same connection prompt and the same confirmation as the SCADA page.