Skip to content

SCADA Dashboards from PLC Signals

On this page

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, arrange them into pages, 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. Your work lives as a SCADA project in your workspace, so the pages, the rules, the targets you send to and the record of every send are files you can see in the Explorer and keep in version control.

SCADA Dashboards is part of the Pro plan when you build the dashboards yourself. Letting the chat assistant work on them for you (see Let the assistant build it) is part of AI for SCADA in 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 the signals of your machine: the data points with their data type and comment, plus the variables of your tag tables with their address. You load them in the Signals view from a PLC's exported OPC UA node set, from the connected TIA project or straight from a running CPU. You can also produce a SCADA configuration in Forge (mark blocks as SCADA interfaces and export a selection).
  • 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 side bar

Select the SCADA icon in the activity bar (the dashboard icon on the left edge) to open the SCADA side bar. It behaves like the Explorer: the icon opens and closes it, and SCADA in the View menu opens it too. The side bar holds five views, which you can collapse, resize and move like any other view:

  • Project: the files of the open SCADA project, with the actions to send and save.
  • Signals: the signals of a PLC, to select them and drag them onto a page.
  • Pages: the pages of the project, that is the screens of the dashboard.
  • Symbols: your own SVG symbols.
  • Rules: the rules the pages are built from, with their switches and hit counts.

The other parts of SCADA sit around the side bar. Each page opens in the page editor in the editor area. The SCADA Properties view in the secondary side bar on the right shows the properties, bindings, states and rule of what you select. The SCADA tab of the panel at the bottom holds Diagnostics, Send and Rule Hits. The status bar shows the target, the owner of the page, the rules and the signal source, and the SCADA channel of the Output view records what ran.

Open SCADA Page in the Command Palette (Ctrl+Shift+P) opens the side bar and the start page of the project in the page editor, or the first page when no start page is set. Without an open project it shows the Project view, and for a project without pages the Pages view. If a window still showed the SCADA page of an earlier Studio version, Studio opens the side bar and the start page in its place.

If your plan does not include SCADA, the side bar shows only the Project view, with a note and a Manage License link.

Work in a SCADA project

A SCADA project keeps your dashboard as files in a folder of your choice: one project file, and one page file for each page. Studio remembers the open project for the workspace, so it is open again the next time you work in that workspace.

The Project view shows the open project. Without one, it offers Create SCADA Project and Open SCADA Project. With a project open, its first line names the project and the file its signals come from, and counts the text lists and the files with unsaved changes. When project files have problems, a second line counts them, and Show in Diagnostics opens the list (see Diagnostics). Below is a tree of the project's files: the project file, the rules file and the send log, then the folders pages, symbols, texts, targets and backups. A file with unsaved changes is marked unsaved. Click a file to open it; a page file opens in the page editor. The tree follows every change in the project folder.

The title bar of the Project view holds Send to FUXA, Create SCADA Project..., Open SCADA Project... and, while a project is open, Import Text List... (see Text lists). Its ... menu holds Save FUXA File..., Save SCADA Export File..., Set Namespace Index... (for an OPC UA connection) and Close SCADA Project. The Command Palette offers the same commands.

  • Create a project. Choose a folder that does not hold a SCADA project yet and enter a name; the project file is named after it. Studio writes the project file and the folders pages, targets, symbols, texts and backups, adds a development target taken from your FUXA settings (never a password), and opens the project. Signals that are already loaded are copied into the project. When no valid FUXA address is set, the project is created without a target and a message asks you to set the address.
  • Open a project. Pick its project file, which ends in .scadaproject.json. Studio loads its pages, its targets, its signals and its symbol folder.
  • Close a project. The files stay in their folder; the SCADA views no longer show the project or the signals it loaded.
  • Import a saved screen plan. Load Screen Plan... in the ... menu of the Pages view, or Import Screen Plan into SCADA Project... in the Command Palette, turns a screen plan you saved earlier into page files. If the project already has pages, Studio asks before it replaces them; page files that the plan does not contain are removed, and a single Undo takes back all pages and the page list at once; Studio asks first when you undo it from a page or the project file. A message lists any background or symbol that lies outside the project folder, so you can point it to a file of the project before you send.

The project remembers its signals: signals you load while the project is open are copied into its folder, and opening the project loads them again. It also remembers the symbol folder you choose in the Symbols view, as long as that folder lies inside the project. The signals you tick in the Signals view are kept with the project too: each tick is an unsaved change of the project file that you can undo, and once you save, the same signals are ticked again the next time you open the project.

Changes you make in the SCADA views, the page editor and the Properties view reach the project files right away. A change to a file that already exists stays unsaved until you save it, like any edit, and you can undo it. When you open the project file or a target file in the editor, or a page file with Open With... in the text editor, the editor suggests the fields and marks mistakes as you type.

Point Studio at your FUXA instance

The address of your FUXA instance lives in the settings. Open the SCADA category of the settings, or, with a project open, click the SCADA target entry in the status bar and choose Change FUXA Address and Connection.... Enter the address, for example http://localhost:1881. If your instance requires a login, enter the user name there as well and set the password with Set Password...; it is stored securely and never shown again. Once you store a login for this address with Set Target Login and Stage (see Targets and stages below), Studio signs in with that login. The tooltip of the SCADA target entry names the address Studio sends to (see Settings for the whole SCADA category).

Test FUXA Connection, in the Command Palette and in the actions of the SCADA target entry, reads the current project back from the instance. A notification reports how many devices, views and tags it holds, and the FUXA version of the instance with whether Studio has checked it: checked with Studio, checked with some failed checks, not yet checked with Studio, or unknown. If the instance cannot be reached, the notification gives the precise reason; without an address it offers Open SCADA Settings. For a version that is not yet checked, failed some checks or is unknown, a warning appears once per version while the window is open; nothing is blocked, and you can keep sending. If you installed FUXA directly on this computer, pick its folder under FUXA Install Folder in the settings, and Studio reads the exact version from that folder instead of asking the running instance. The version in the status bar is the one the last send to that address found; the test does not change it.

Open FUXA opens the instance in a browser tab inside Studio, so you can watch the dashboard next to your work. You find it in the actions of the SCADA target entry, in the Send view of the SCADA panel and in the messages after a send or a deployment. Open FUXA in System Browser in the target actions opens the instance in your usual browser instead.

Targets and stages

A target is a FUXA instance your project is sent to, together with its stage: Development while you build, Test to check the project before it goes live, and Production for the running plant. Each target is a file in the targets folder of the project, one per stage (dev.json, test.json and prod.json), with the address of the instance and, if you like, the lowest FUXA version it accepts; a send to an older FUXA shows a warning and continues. A target never holds a password. Creating a project writes the development target from your settings. To add a test or production system, copy the development target, change its stage and address, and add it to the targets listed in the project file; the editor suggests the fields. Open Target File in the actions of the SCADA target entry opens the target of the current FUXA address.

Studio sends to the FUXA Address in the SCADA settings, and the target with that address decides the stage of the send; the SCADA target entry in the status bar shows that stage. To send to your test system, set the FUXA Address to the address of its target, or pick that target in the send dialog (see The send dialog below). An address without a target counts as development, unless you stored another stage for it. How the generated dashboard connects to the plant still comes from the Plant Connection settings.

A target can also say how the dashboard reaches each PLC of the project, in its device mapping: for each PLC the connection (OPC UA, Siemens S7 or MQTT) and its address, for OPC UA the security mode, the policy and the user, and for Siemens S7 the rack and the slot. Studio then connects every PLC as its entry says, and a PLC the target does not list uses the Plant Connection settings. If a target lists PLCs but leaves out one that the dashboard uses, Studio does not send and names the missing PLC. Add the missing PLC with its connection to the target, or rename an entry of the target to match it. When you pick another target in the send dialog, Studio builds the dashboard again for the PLCs of that target. A target created from your earlier settings already lists your single PLC, so it keeps working without changes. The OPC UA password you set in the settings serves every PLC that signs in with a user.

Set Target Login and Stage in the Command Palette, also in the actions of the SCADA target entry, records, once per instance, the login Studio uses and the stage you confirm for it. Pick the instance from the targets of the project, take the FUXA address from the settings, or enter another address. Then choose the stage and enter the user name (leave it empty when the instance allows anonymous access) and the password. The password is stored securely and never shown again; when you run the command again for the same user, leave the password empty to keep the stored one. For the FUXA address of the settings, the user name and password you enter here also become those of the FUXA Instance settings. Clear Target Login and Stage removes what you stored for an instance.

Studio checks the stage on every send:

  • A development target can be sent to without a stored login and stage.
  • A test or production target is refused until you have stored its login and stage.
  • When the stage in the target files and the stage you stored disagree, the send is refused until you correct one of them; the message names both.
  • Sending to a production target always asks a second time (see What happens on every send below).

Load the signals

The Signals view brings the signals of a PLC into the project. Until signals are loaded, it offers the ways to load them, and the same actions sit in its title bar:

  • Load Node Set File... loads a node set that a CPU exported earlier.
  • Load From TIA Project... exports the OPC UA node set of a CPU of the connected TIA project and loads it. It is available as soon as Studio is connected to TIA Portal, also when the Project Explorer was never opened; while Studio is still reading the project, it waits until the CPUs are known.
  • Load From CPU... reads the signals straight from a running CPU through its PLC / OPC UA connection (see Load signals from a running CPU below).

While a load runs, the load actions are unavailable, so a second load cannot start. A message says how many data blocks were loaded and from where; a file that is not a node set, or holds no data blocks, gets an error that says so. With a SCADA project open, the loaded signals become the signal source of the project: Studio copies them into the project folder, and the message names the file the project now uses.

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

Load signals from a running CPU

Select Load From CPU... in the title bar of the Signals view, or run SCADA: Load Signals From CPU... in the Command Palette. When CPUs are connected in PLC / OPC UA, choose one from the list; the CPU the loaded signals came from is listed first. When no CPU is connected yet, or when you choose Connect to Another CPU in PLC / OPC UA..., PLC / OPC UA opens and a notification waits until you connect to the CPU there. The signals load as soon as the connection is up, and you can cancel the wait. Connect to the CPU with OPC UA in PLC / OPC UA: when the connection does not use OPC UA, a message says so and the load ends. A progress notification counts the nodes read, and you can cancel it.

Studio only reads the CPU and never writes to it. Inside a SCADA project the signals are saved as a file of the project, so the project opens again without a connection. Signals read from a CPU carry no comments, so comment tokens such as units, limits and alarms, and rules that look at comments, need a node set file or the export of the TIA project. When some signals report a data type Studio cannot name, they are loaded without a data type and cannot be bound on a page; a warning says so, and the SCADA channel of the Output view lists them. If the read may be incomplete, a warning asks you to load the signals again. Loading from a CPU needs PLC / OPC UA in your plan as well as SCADA.

Select and find signals

Once signals are loaded, the Signals view lists them by data block and structure. Its header shows how many are selected and where they come from, for example 12 of 340 selected, PLC_1.xml. Each row has:

  • a checkbox: tick the signals you want on the dashboard. The checkbox of a structure or data block selects or clears everything in it, and a partly selected one shows a mixed state;
  • a drag handle, to drag the row onto a page (see Drop signals and symbols on a page below);
  • the name, and the data type of a signal;
  • for a structure or data block, a chip with its type name: click it to show every structure of exactly that type;
  • RW for a signal a widget can write to the PLC, and No Access for a signal the OPC UA server neither reads nor writes;
  • Why? for a signal a widget of a page shows: it explains that widget (see Explain a widget below), or lets you choose when several widgets show it.

The filter box above the tree filters by name and type name. Type type: followed by a type name to show exactly the structures of that type, as the type chip does; here upper and lower case count. A badge counts the matches. While a filter is active, Select All Signals and Clear Signal Selection in the title bar act only on the filtered signals, so a type chip followed by Select All Signals selects every signal in the structures of that type. Expand All and Collapse All are in the ... menu. On the keyboard, Space ticks or clears the focused row, and Tab moves into its chips.

Without pages, the dashboard is built from the ticked signals, and Propose Screens builds pages from them.

Choose how the dashboard connects

The Connection in the SCADA settings (under Plant Connection) chooses how the finished dashboard reaches the plant, and Address takes the matching address. The Address starts out empty and shows an example for the chosen connection until you enter your own; until then, sending or saving names the missing address and generates nothing. The tooltip of the SCADA target entry in the status bar shows the connection and the address the dashboard will use.

  • 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 and an OPC UA Security section appear in the settings: 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. An open SCADA project keeps its own namespace index: signals you load bring their index into the project, and Set Namespace Index... in the ... menu of the Project view changes it (a whole number from 0 to 65535). Without a project, the loaded signals bring their own index.
  • 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 Set Password... and Clear Password buttons of the OPC UA Security section (also available as Set OPC UA Password and Clear OPC UA Password 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.

Several PLCs

A project can read the signals of more than one PLC, for example the PLC of a line and the PLC of a packaging machine. List each PLC once among the signal sources of the project file, with a short name of its own, the signal file it reads and, if needed, its namespace index; the editor suggests the fields. The first entry is the default PLC of the project. A project with one PLC needs no such list. Each PLC gets its own entry in the targets (see Targets and stages above) and its own connection alarm (see The connection alarm below).

  • A page reads the default PLC unless you choose another PLC for it.
  • A widget shows the signals of one PLC: its own, or else the PLC of its page. The page background follows the PLC of its page.
  • Alarms from signal comments and from alarm rules are raised for the default PLC. An alarm token in the comment of a signal of another PLC is left out, and the Diagnostics view says so.
  • The ticked signals of the Signals view, from which Propose Screens and a dashboard without pages are built, must come from one PLC. When they come from several, Studio refuses and says so; place the signals of the other PLCs on the pages in the page editor or with the assistant.

When the screens of a project are rewritten as a whole, for example by the assistant, every page that stays keeps its PLC and its roles, and an alarm keeps its roles when its level changes.

PLCs in the Signals view

When a project reads several PLCs, the Signals view shows each PLC as its own row above its data blocks, the default PLC first. The row names the PLC, its connection and address in the target, and how many of its signals are ticked. A PLC that the target does not list is marked Not Mapped and is connected with the SCADA settings. Tick the checkbox of a PLC to select all of its signals.

The PLC of a page and a widget

  • Page. With the page selected, the Properties tab of the Properties view shows its PLC; click Change... to choose which PLC the page reads. The same choice is Set PLC of Page... on the menu of an empty spot of the page in the page editor, and in the Command Palette. Widget slots that have no PLC of their own follow the page. If one of their signals does not exist on the chosen PLC, the page keeps its PLC and a warning names the missing signals: bind those slots to signals of the chosen PLC first, or choose the PLC of their widgets in the Bindings tab. If the page has such slots and no signals are loaded, it keeps its PLC as well. After a change, a message says which PLC the page reads now and how many slots of its widgets moved with it.
  • Widget. The Bindings tab shows in its PLC column which PLC each slot reads. Click PLC... to switch the widget to another PLC; the change applies to every bound slot of the widget, because a widget shows the signals of one PLC.
  • Dropping signals. You can drop signals of any PLC on a page. A signal of another PLC dropped on a widget, or a state of a background part from another PLC than the page's, is refused until you switch the widget to that PLC. Assign Variable... lists the signals of every PLC, with the PLC next to each signal.
  • Status bar. The tooltip of the SCADA target lists every PLC with its connection, and marks a PLC the target does not list as connected with the settings.
  • Diagnostics. Problems with the PLCs of the project carry the category PLC (see Diagnostics below).

A detail view has no PLC of its own; it reads the PLC of the structure that opens it (see Detail views below).

Arrange the pages

By default the dashboard is a plain value table of the ticked signals. To build a structured dashboard with several pages, open or create a SCADA project and use the Pages view. Each page is a page file in the pages folder of the project.

The Pages view lists the start page first, marked start page, with the other overview pages; then the process pages, the device pages (grouped under Device pages when there are more than eight), and the pages that hold an alarm table. Each row shows the page name, its id and an owner chip: Studio for a page Studio builds, Runtime editor for a page that belongs to the runtime's browser editor, which Studio shows read-only and leaves out of every send (see Merge or replace below); the tooltip of the chip says since when. A page file with problems is marked has problems. Click a page to open it in the page editor; selecting a page, with the mouse or the arrow keys, also shows its fields in the Properties view and its owner in the status bar.

  • New Page... asks for a name, creates the page with an id made from the name, and opens it.
  • Propose Screens turns the ticked signals into pages: an overview page with navigation tiles, one page per top-level machine module, and detail pages for large groups. If the project already has pages, Studio asks before it replaces them, and a single Undo takes back the whole change; Studio asks first when you undo it from a page or the project file.
  • Apply Rules builds the pages from the rules (see Assign widgets with rules below).
  • In the ... menu, Save Screen Plan... writes the pages to a plan file, Load Screen Plan... imports a saved plan (see Work in a SCADA project above), and Clear Screen Plan removes all pages of the project after asking.
  • With an EPLAN project open in Studio, Propose Screens by EPLAN Structure... in the ... menu builds the pages along the plant structure of EPLAN. Choose Mounting Location, Functional Assignment or Plant, and the ticked signals get one page for each such structure, named after it and its EPLAN description, for example +A1 Feed. Signals that EPLAN knows without that structure land on No EPLAN Structure, the rest on Not in EPLAN. A signal is found in EPLAN when its name is the symbolic address in EPLAN or the TIA tag name of the signal, or when its name or comment contains the EPLAN device tag, for example =GL1+A1-QA1. As with Propose Screens, Studio asks before it replaces existing pages. Needs an EPLAN licence (Pro+ or Enterprise).
  • Right-click a page for Rename Page... (F2), Set as Start Page, Move Page Up and Move Page Down (Alt+Up and Alt+Down, within its group), and Delete Page (Delete). Renaming a page, here or in the Name field of the Properties view, also renames the navigation tiles and buttons that open it and still carry its old name as their label; a label you changed yourself stays, and one Undo takes back both. Deleting asks first, and the question lists what goes: the page file, the page's entry in the project and in the navigation, and, when other pages have buttons or tiles that open this page, which of them no longer open it and which are removed because opening this page was all they did. Undo brings everything back at once. The start page can be deleted only once another page is the start page. A page whose file has gone missing, for example because it was deleted outside Studio, can be deleted the same way; clicking it shows a message instead of opening it. The keys work while a page in the list has the focus; on the group row of the device pages, Delete and F2 do nothing.

Every change is an unsaved edit of the page and project files that you can undo. Without pages, the view offers Propose Screens, Apply Rules and New Page.

A page has a layout: Tiles, Sections, Table or Free. The page editor puts a page on the free layout as soon as you move or resize a widget on it, drop signals on empty space or drop a symbol onto it. To choose another layout, or to give a page a background image (an SVG from the project folder, for example a plant drawing exported from a design tool), set it in the page file or ask the assistant. The background sits behind the widgets, and anything unsafe in its file is removed before it is used.

While the project has pages, sending and saving build the planned multi-page dashboard instead of the plain table.

The symbol folder

The Symbols view shows your own SVG symbols as tiles: a small drawing of each symbol, its name (its path in the folder without .svg, for example pumps/pump) and how many states its manifest gives it. Choose Symbol Folder... in its title bar loads a folder of symbols, including the ones kept in subfolders, so a nested symbol library is picked up whole. A message reports how many symbols were loaded and how many files were skipped, and the view keeps showing how many symbols the folder holds and how many files could not be used. When files were skipped, a warning names each of them with its first problem and counts any beyond the first five. Keep the folder inside the project, so the project remembers it and the page files can use its symbols; for a folder outside the project the view says that the page files cannot refer to its symbols. Drag a tile onto a page to place the symbol (see Drop signals and symbols on a page below). Export Symbols to FUXA writes the library into a FUXA you installed directly (see Your symbols in the FUXA editor below).

A plain symbol turns its widget into a bound on/off switch using its off and on colors; a symbol with state bindings follows them instead (see Symbols with states below).

Edit a page in the page editor

A page file opens in the page editor: from the Pages view, the Project view, the Explorer or Open SCADA Page. The tab shows the page id; Open With... offers the text editor for the page file instead. The page editor shows the page as the send builds it: one picture of the whole page, with a frame over each widget.

The toolbar holds, from left to right:

  • Select: click a widget to select it, Shift+click to add or remove one, and drag on empty space to select every widget the rectangle touches.
  • Move the View: drag to move the view of the page. Holding Space does the same with any tool.
  • Grid: shows a grid of 10 pixels; moved and resized widgets snap to it while it is shown.
  • Insert Widget...: places an alarm table, a message table or a navigation tile (see Insert a widget below). It is unavailable on a read-only page and in the preview.
  • Apply Rules and Preview (see Preview below).
  • Send to FUXA and View in FUXA (see View in FUXA below).
  • Zoom Out, Zoom In, Zoom to 100 % and Zoom to Fit, with the zoom level. The mouse wheel zooms at the pointer.
  • Show Properties: opens the Properties view for the selected widget, also when the secondary side bar is hidden.

To move and resize widgets:

  • Drag a widget, or the whole selection, to move it.
  • Drag one of the eight handles of a single selected widget to resize it. Hold Shift to keep its proportions, and press Escape to cancel.
  • The arrow keys move the selection by 1 pixel, or by 10 with Shift. While the grid is shown, they move it by one grid step, or by five grid steps with Shift, and the selected widget snaps to the grid; other selected widgets keep their distance to it.
  • Delete or Backspace removes the selection.
  • Ctrl+A selects all widgets, Ctrl+Right and Ctrl+Left select the next and the previous widget, and Escape clears the selection.
  • Right-click a widget, or press Shift+F10 or the Menu key on the selected widget, for its menu: Assign Variable..., Remove Binding, Save as Symbol Default, Save as Rule for All of Its Type, Derive Rule from Widget and Show Properties. Each entry shows only on the widgets it works on; Remove Binding is not offered when the widget cannot exist without the signal of its slot. On a page you can change, the menu also offers Insert Widget....
  • Right-click empty space on the page, or press Shift+F10 or the Menu key with no widget selected, for the menu of the page. It offers Insert Widget... and leaves the selection as it is.

Every gesture is one change that a single Undo takes back (Ctrl+Z, and Ctrl+Y to redo, while the page has the focus), and your changes stay unsaved until you save the page. If you press Undo more often than you made changes and reach a change that touched several files, such as Apply Rules, a new or imported screen plan, or deleting a page, Studio asks first, for example "Would you like to undo 'Apply SCADA Rules'?". No leaves everything as it is; Yes takes back that whole change at once. Redo does not ask. A page on the Tiles, Sections or Table layout switches to the free layout on its first move or resize, or when you first drop signals on empty space or a symbol onto it, and every widget keeps the place it has on the screen. A change the page file cannot take is not applied: a warning names the reason, and the widget goes back to where the file has it.

The picture tells you how the page will come out. A widget the send would leave out has a red dashed frame, and a symbol still shows its drawing inside it. A control that FUXA draws itself (a slider, chart, alarm table, message table, selection, input field, gauge or image) has a grey dashed frame. Inside that frame, an alarm table shows its label and what its filter lets through (the levels, the text, the group and the number of signals, or All alarms), and a message table shows its label, a header row with its column labels and how many slots of which buffer it shows; the runtime fills both with the live alarms and buffer slots. A number badge counts the findings of a widget, and its hover explains each finding in a sentence. Below the page, a legend sums up the page (its widgets, those left out and those drawn by the runtime) and lists each widget that has a finding, with its findings in sentences; click a line to select the widget. When no picture can be built, for example before the signals are loaded, the legend says why, symbols show their drawing and other widgets show their label in a dashed box. For a moment after a change, until Studio has taken it in, the picture is dimmed and a note says so.

Insert a widget

To add an alarm table, a message table or a navigation tile, click Insert Widget... in the toolbar, or right-click the page, on a widget or on an empty spot, and choose Insert Widget.... While a page editor is active, the command is also in the Command Palette. A list asks which widget you want:

  • Navigation Tile: a second list asks for the page the tile opens (the page you edit is not offered), and the tile takes the name of that page as its label.
  • Alarm Table: set its filter afterwards on the Properties view (see Properties below).
  • Message Table: a second list offers the message buffers in the loaded signals, each with its number of slots and its members. The table starts with the columns Time, Module, Number and Additional Info, which you change on the Properties view (see Message table below).

The widget lands where you right-clicked, otherwise in the middle of the visible part of the page, and always inside the page. A page on the Tiles, Sections or Table layout switches to the free layout. The new widget is selected, the Properties view opens beside the page, and one Undo takes the insert back. A message stops the insert when no signals are loaded, when the signals hold no message buffer, when the project has no other page a navigation tile could open, or when the page became read-only while the list was open.

Preview

Preview runs the page in the page editor without writing anything. Click a widget that opens a page as a card, for example the page of a device, and the card appears centered over the dimmed page; click a button or tile that opens another page, and that page is shown. Escape closes a card, then goes back to the page you edit. FUXA moves a card 48 pixels up when its navigation is hidden; the preview does not.

Below the page, Simulated slot values lists the bound slots of the selected widget, each with a field. Type a number, true or false, and the page shows the colors, visibility and variant that value produces. For a slot that shows one bit of a signal, true or a number other than 0 sets that bit and false or 0 clears it. A blinking part shows its first blink color, and moving or turning parts stay at rest. When a value changes nothing, the field says why. Select Preview again to go back to editing.

View in FUXA

View in FUXA opens this page on the development target of the project in a browser tab inside Studio, so you can compare it with the running dashboard after a send. When the project has no development target, a message says so, and when the page cannot be opened, a message says why.

Read-only pages

The page editor shows a page read-only, with a banner that says why, when the page belongs to the runtime's browser editor (owner Runtime editor, see Merge or replace), when your plan does not include SCADA, or when the page file itself is read-only. You can select widgets and use the preview, but nothing can be moved, dropped or changed. Propose Screens and Load Screen Plan... do not rewrite a page of the FUXA editor either: a message names the page, and nothing is changed. A page file that cannot be read shows its first problem; open it in the text editor to repair it.

Drop signals and symbols on a page

Drag signals, structures or data blocks from the Signals view onto a page in the page editor. While you drag over the page, a frame marks where they land, whether a widget, a part of a symbol, a part of the page background or the whole page, and a short text says what the drop will do, for example Place 3 widgets, Bind slot fault or Add a state to the part badge. When the drop is not possible, the text gives the reason instead, for example BOOL expected, REAL dragged, and nothing is dropped.

  • On empty space, Studio places the widgets the rules give the signals, in a grid from the point where you drop them, inside the page. A page on the Tiles, Sections or Table layout switches to the free layout, and its other widgets keep their places.
  • On a symbol, the signal is bound to the one free slot of the symbol that fits it. When several slots fit, or when you hold Alt while dropping, a list Bind signal to a Slot lets you choose the slot, including a slot that is already bound, whose signal is then replaced. A structure dropped on a symbol fills every slot it can, and a message says how many slots were bound.
  • An integer signal on a yes or no slot: Studio asks which bit of the integer the slot shows.
  • On a part of a symbol that has no state yet, Studio asks what the signal changes: Fill Color, Outline Color, Visibility, Blinking, Continuous Rotation, Rotation by Value, Move by State or Position by Value. It adds a state with a first set of values, selects the widget and opens the States tab of the Properties view with the new state marked, so you can adjust the values.
  • On a part of the page background, the same happens for the background part. A widget on the page must already show the signal.

Every drop is one step of Undo and leaves the page unsaved, and a screen reader announces the result. After you bind a signal, the message offers Save as Rule for All type (see Reuse a binding below). Dropped into a text editor instead, the signals are inserted as their paths, one per line.

Symbols from the Symbols view are dropped the same way: drag a tile onto a page, and a frame of the symbol's size shows where it lands. Like a drop of signals on empty space, it switches a laid-out page to the free layout. A symbol from another SCADA project, a symbol that is not in the symbol folder, or a drop on a read-only page is refused, and the frame names the reason.

Assign a variable by keyboard

Select the widget, press Shift+F10 or the Menu key, and choose Assign Variable.... Choose the slot when the widget has several, then a signal from the loaded signals whose data type fits; for a bound slot, the signal you choose replaces the one it shows. For an integer signal on a yes or no slot, enter the bit number. Assign Variable... also sits on the Bindings tab of the Properties view and in the Command Palette. From the Command Palette, the binding commands act on the widget selected in the page editor; only without a selection do they ask for the page and the widget. It is offered on every widget that can show a signal, which excludes images, navigation tiles and alarm tables.

Remove Binding clears a slot again. Applying the rules does not fill that slot again. A slot the widget cannot exist without, such as the value of a value display or a lamp, cannot be cleared; choose another signal for it instead.

Reuse a binding

  • Save as Symbol Default writes the slots and states of a symbol widget into the manifest of its symbol, so every new use of the symbol starts with them. The manifest stays unsaved until you save it.
  • Save as Rule for All of Its Type adds a rule at the top of the rules file that makes this widget, with its bindings, for every signal of the same type. It needs a bound signal whose structure has a type name. The new rule puts every structure of that type on the page of its own data block and leaves the page of a single signal to the other rules; the widget you saved it from stays on its page.
  • Derive Rule from Widget adds a rule for exactly the signal this widget shows, with its bindings, its label and its page.

Both rule commands need the signals of the project to be loaded, and they open the rules file at the new rule. The widget itself is taken over by the new rule, so the next Apply Rules updates it instead of placing a second one; a message says so. When the project has no rules file yet, no rule is added, and the message offers Create Rules File.

The Properties view

The SCADA Properties view sits in the secondary side bar on the right while a SCADA project is open. It follows what you select in the page editor or the Pages view and reads the page as it stands in the editor, so unsaved changes show at once. Its header names the selection, for example a widget with its page. A field takes effect when you press Enter or leave it, and Escape restores the old value; each change is one unsaved edit that you can undo. For a page that belongs to the FUXA editor, or when your plan does not include SCADA, a banner says so and everything is read-only, except Open Rule and Why This Widget?.

The view has four tabs.

Properties

With a page selected, the tab shows its id, its Name and Size (both editable), its background, its owner and the number of its widgets. While the project reads several PLCs, it also shows the PLC of the page, with Change... to choose another (see Several PLCs above). For a detail view it shows Detail View Of with the data type (see Detail views below). With nothing or only a page selected, the Assistant Preview sits at the foot, collapsed at first; it shows the screens the assistant proposes in chat.

With one widget selected, the tab shows:

  • Widget: its kind, id, name (editable) and page.
  • Position and Size: a value you type moves or sizes the widget exactly as a drag on the page does. On a page that is not on the free layout, the page becomes free and every other widget keeps its place, and one Undo takes back both. While the layout places the widget, the fields are empty, the greyed values show where it is drawn, and a note says so. When the layout does not place the widget at all, the fields are unavailable and a note says why.
  • Symbol: a list of the symbols in the symbol folder. For a widget of another kind the first entry, None, keep the kind widget, keeps it as it is. A symbol widget also offers Revert to the Rule's Symbol, or Revert to the Rule's Widget when the rules give its signal another kind of widget; from then on the rules manage it again. While no rule decides the widget, the button is unavailable and a line says why.
  • Tile Rows (tiles only): the label, unit and number of decimals of each row, which you can move up or down or remove.
  • Button Action (buttons only): for a button with a signal, Toggle the value (selected while no action is set) or Write a fixed value with the value it writes; a button without a signal shows No write, the button only opens a page.
  • Events (not for message tables): the pages a click on the widget opens, each with Open as card and, for a card, Close other cards. Add Event adds one. A card that opens a detail view has a field for the instance, the structure whose values the card shows. When the click already opens a page, for example on a navigation tile, the section names that page. Under a card event the send would ignore, for example because the same click already opens a page, a warning says why.
  • Alarm Filter (alarm tables): which of the active alarms the table shows. Tick the Levels to show (High High, High, Low and Info; with none ticked, every level shows), type a part of the alarm text under Text or of the group under Group (upper and lower case do not matter), and add signals under Signals with Add a Signal.... The list offers the signals the page binds and the signals that raised alarms in the last build, marked (alarm of the last build). Remove a signal with the cross on its chip; while no signal is chosen, the field reads All signals. The table shows the active alarms that match every filter you set. Each change is one step of Undo, and a filter you empty completely is removed.
  • Message Table (message tables): the Buffer it shows, the number of Slots and the Columns. Each column shows one member of every slot, with its Label, its Width (empty for the default) and a Text List; the buttons of the row move the column up or down or remove it, and Add Column adds a column for the next member not yet shown, up to eight. A line below the slots counts the signals the table binds against the budget and turns into a warning when the table is over it (see Message table below). Until the signals of the project are loaded, the buffer shows as text with a note to load them. Each change is one step of Undo.

A value the page file cannot take, for example 0 slots, shows as an error at the end of its section.

With several widgets selected, the tab lists them, and a click on one selects it alone.

Bindings

One row per slot of the widget, with the Slot, the Variable it shows, its Type, its Access and, under State, a color swatch for each fill or outline color the slot drives. An empty slot offers Assign Variable...; a bound slot offers Replace... and Unbind, and a slot the widget cannot exist without offers only Replace.... Drag a signal from the Signals view onto a row to bind it; one signal of a fitting type is bound, an integer on a yes or no slot first asks for the bit, and a signal of another type is refused with a message that names both types. On a bound slot, the dropped signal replaces the old one only while you hold Alt; without Alt, a message says so and nothing changes. To fill several slots from one structure, drop it on the symbol in the page editor.

While the project reads several PLCs, the PLC column shows the PLC each slot reads, and PLC... switches the whole widget to another PLC (see Several PLCs above). On a detail view the table shows Member instead of Variable, and Member... chooses a member of the data type (see Detail views below).

Below the table, Reuse shows the new binding once it is on the page and offers Save as Rule for All type, Derive Rule from Widget and, for a symbol, Save as Symbol Default (see Reuse a binding above).

States

Symbol States is the state table of a symbol widget. Each slot is a group, with the signal it is bound to. Each row has:

  • Value or Range: a value such as 3, a range such as 2..5, ..5 or 5.., or Otherwise for every other value;
  • Meaning: the effect in words;
  • Target: the whole symbol, a part, or a part of the background;
  • Property: Fill Color, Outline Color, Visibility, Blinking, Continuous Rotation, Rotation by Value, Variant, Move by State or Position by Value;
  • Setting: the color, shown or hidden, the two blink colors with the interval, the direction, the variant, the offset, or for a value that is followed, the range of values with the angle or distance it becomes;
  • buttons to move the row up or down, remove it, or clear the default.

Add Row adds a row for the next free value. A strip per slot shows the symbol in every state, drawn as the page editor draws it; moving and turning parts are shown at rest. Notes below the table point out overlapping rows, a binding without a default, and every combination FUXA cannot show (see When a binding cannot be shown below).

While the widget has no states of its own, the table shows the default states of its symbol; the first change copies them to the widget, which keeps its own states from then on. Save as Symbol Default below the table writes the states and slots of the widget into the symbol's manifest. When the page background has parts, Background States is a second table for the background parts that this widget's signals drive. After a drop that adds a state, the tab opens with the new state marked.

Rule

  • Made By lists the rules that made the widget, each with Open Rule, which opens the rules file at that rule, or the Rules view for a built-in rule. When no rule made the widget, for example a widget you placed by hand, the tab says so, and applying the rules leaves the widget as it is.
  • Where the Fields Come From lists each field with its value and its source: a rule, a built-in rule, by hand, by drag and drop, by the automatic layout, by the status patterns, or not recorded.
  • Rule Trace lists the rules that match, then each other rule with the first condition it fails; the rest are counted, and Why This Widget? shows the full list. It needs the signals of the project to be loaded.
  • Why This Widget? opens the full explanation (see Explain a widget below).
  • Detail View, for a widget that opens a detail view as a card: the page it opens, the instance, and whether a rule or you set it.

Assign widgets with rules

Instead of choosing every widget by hand, you can let rules decide which widget each signal gets, how it is labeled, and on which page and in which section it appears. The rules of a project live in one file next to the project file, rules.scadarules.json. Three commands work with it while a SCADA project is open; you find them in the Command Palette and in the title bar of the Rules view:

  • Create Rules File writes the rules file with an empty list of rules and the built-in rules switched on, and opens it. If the project already has one, Studio opens it instead.
  • Open Rules File opens the rules file. If the project has none yet, a message offers Create Rules File; until then, Apply Rules uses the built-in rules.
  • Apply Rules applies the rules to the pages of the project (see Apply the rules below). It also sits in the title bar of the Pages view and in the toolbar of the page editor.

In the editor, the rules file suggests every field with a short description and marks mistakes as you type. Each rule has an id, an optional description, its conditions under when and what it sets under then:

  • Conditions pick signals and structures by their type name (typeName, also that of the parent or of any structure above), by their path in the form Block::a.b.c (* stands for one level, ** for any number of levels), by their name, data block, data type or access, by their comment, or by a comment token such as {symbol=pump} (token). all, any and not combine conditions.
  • Effects set the widget kind with its label and options, a symbol with the members bound to its slots and its state bindings, the page, the section and the position in it, or make a Boolean the status of its overview tile. A rule can also let every structure of a data type open the detail view of that type as a card (see Detail views below). exclude leaves out a signal, or a structure with everything in it. Labels, pages and sections can use placeholders such as ${name}, ${parent} and ${block}.

For each field, the first rule in the file that matches decides. Move a rule up to give it precedence, and set stop so that no later rule is looked at for a signal the rule matches. A rules file can use further rules files of the project after its own rules (extends), at most two levels deep.

This rule turns every structure of the type Pump into a pump symbol on the page of its data block and binds the running slot of the symbol to the member status.bRunning; consume keeps the bound members from getting widgets of their own:

{
  "id": "pump-symbol",
  "description": "Every pump becomes a pump symbol.",
  "when": { "node": "container", "typeName": "Pump" },
  "then": {
    "widget": { "kind": "symbol", "label": "${name}" },
    "symbol": { "ref": "pumps/pump" },
    "slots": { "running": "status.bRunning" },
    "place": { "page": "${block}" },
    "consume": "slots"
  }
}

The rule editor

Opening the rules file, from the Rules view, the Explorer, Open Rules File or a finding in the Diagnostics view, shows the rule editor: on the left a form with the Settings, the Widget Rules and the Alarm Rules, on the right the JSON of the same file with the same suggestions and checks as above. An edit on either side changes the same file, is one step you can undo, and stays unsaved until you save the file.

  • In the form you switch a rule on or off (On), rename it, change its description, and move it with Move Up and Move Down or remove it with Remove Rule. Each rule card shows in words when it applies and what it sets, and how many signals it hits and on how many it wins, for example Hits: 12, won: 10.
  • New rules are written on the JSON side; the form has no button to add one. For a field the form does not show, open JSON of the Rule on the card, edit it and click Apply JSON.
  • Each alarm rule card shows how many alarms the last build raised, in total and per level, for example Alarms in the last build: 3 (High: 3), and the first examples with their signal, level and alarm text; before the first build it says so. An alarm text that refers to a text of a text list shows that text in the default language of the project, as the dashboard shows it.
  • Problems at the bottom of the form lists the mistakes in the file; click one to jump to it. The rules are listed in the order in which they take precedence: for each field, the first matching rule wins.
  • Apply Rules in the toolbar applies the rules to the pages. The Refactor Preview shows every change first, and nothing is written until you apply it there.

To use the text editor instead, choose Open With... on the file.

The Rules view

The Rules view lists the rules the pages are built from. Problems of the rules files show at the top. Below come Project Rules with your rules file, one Extended Rules group for each file your rules file extends, and Built-in Rules, collapsed at first, with how many of them are on. Each rule shows a switch, its name (its description, or its id when it has none) and how many signals it hits and on how many it decides a field, for example Hits: 83, won: 83. While the counts are worked out the row reads counting, and while they cannot be counted, for example before the signals of the project are loaded, it reads not counted.

  • The switch of one of your rules switches it on or off in the rules file, as an unsaved edit that one Undo takes back. Space does the same for the focused rule.
  • The rules of an extended file are read-only here; the tooltip names the file to change.
  • The switch of a built-in rule turns all built-in rules on or off together, as the rules file does.
  • Click a rule to list its hits in the Rule Hits view of the SCADA panel (see Rule Hits below). Double-click it, or press Enter, to open the rules file at that rule.

Your alarm rules (see Alarm rules below) sit in an Alarm Rules group below the rules of their file, which says how many of them are on. Each shows a switch, its id, what it matches and which signal state raises the alarm, for example typeName=mixerT; signal bool true, and, after the pages were built, the number of alarms it raised in that build. A dash stands in for the number while none can be given, and its tooltip says why, for example that the pages were not built since the project was opened. The switch, Space, Enter and a double-click work as for the other rules, and the alarm rules of an extended file are read-only. Warnings on alarm rules show as rows under the group. While no rules file has alarm rules, the group says so; a click opens the rules file, where you add them under alarmRules, or you ask the assistant.

The view title reads how many rules are active and how many built-in rules are on. Without a rules file, the view explains that Apply Rules uses the built-in rules and offers Create Rules File. The layout rules of the navigation are not listed here; you switch them in the project file.

Apply the rules

Apply Rules runs the rules over every signal of the loaded node set. The ticked signals in the Signals view do not limit it; to leave signals out, write a rule with exclude. Studio then opens the Refactor Preview with every change: the changes to each page file, the page files it creates, and the change to the project file. Nothing is written until you click Apply there; Discard leaves the project as it was. Afterwards a message says how many pages were changed and how many were created. The files stay unsaved until you save them, and you can undo the change. When the pages already follow the rules, a message says so.

If you apply only part of the changes in the Refactor Preview, the message counts only the changes that were applied. When that leaves the project inconsistent, for example because it lists a new page whose page file was not created, an error names the problem and advises you to undo the change or to apply the rules again.

If you undo from a page after applying the rules and reach the applied change, Studio asks "Would you like to undo 'Apply SCADA Rules'?" before anything happens. Yes takes back the whole change at once, and every page it created goes with it; No leaves everything as it is.

When the file of a page has gone missing, for example because it was deleted outside Studio, Apply Rules creates the page again at its old place when the rules still make it, and the page keeps its navigation entry. If the rules no longer make that page, the rules are not applied, and a message names the page and its file: delete the page in the Pages view, or restore its file, and apply the rules again.

A rule that opens the detail view gives every structure of that type a widget that opens the detail view as a card when clicked. If no page of the project is the detail view of that type, Apply Rules says so, and the widget stays as it would be without that effect. An event you set on a widget yourself stays as you set it.

What you set yourself always stays:

  • A field you set in the page editor, in the Properties view or through the assistant counts as set by hand, and no rule changes it. That includes a symbol you pick, a widget you move or resize, a signal you drop on a slot and a binding you remove.
  • A widget you made by hand keeps its place, also when it already shows a signal that a rule would give a widget of its own: the rules never replace it and add no second widget for that signal. A note after applying names these widgets.
  • A page the project already has, for example the page of a data block that you made yourself or with Propose Screens, is used again when the rules place signals on a page of that name: they go onto it, and it keeps its name and the label of its overview tile, instead of a second page being created. Names that differ only in upper and lower case count as the same page.
  • Pages that belong to the runtime's browser editor are never changed, and applying the rules never deletes a page.

Widgets that Propose Screens placed count as made by the built-in rules, so a rule of your own changes them on the next Apply Rules. Widgets the rules made earlier and no longer produce are removed. When a new page still gets the name of an earlier page, for example because members of two data blocks have the same name, it is created all the same, and a note after applying names both pages, so you can change the rules or rename one of them. When the rules leave out widgets or slots, for example a tile row without a bound signal, a warning lists them. Apply Rules needs the signals of the project to be loaded; when the rules file has a problem, the message names it and offers Open Rules File.

The built-in rules

Without a rules file, and after your own rules unless you switch them off, a set of built-in rules decides. They build the same kind of pages as Propose Screens:

  • A writable BOOL gets a button, a read-only BOOL named bError a lamp that lights in the fault color, and any other BOOL a lamp.
  • A writable number with {min=} and {max=} in its comment gets a slider, any other writable number an input field; a read-only number with such a range gets a gauge, any other a value display.
  • A data block with no more than 40 signals becomes one page. In a larger one, the signals directly in the block go on a page of the block, and each member gets a page of its own with a General section, a section for each small group and, for each larger group, a detail page with a button that opens it. Set another limit with detailThreshold under settings in the rules file.
  • The overview gets a tile for each page that no other widget opens. Its status follows the first Boolean named bIsOk, bReady or bError, with bError shown inverted.

The built-in rules cannot be edited. A rule of your own comes first and overrides the field it sets; to switch all built-in rules off, set "includeBuiltins": false under settings in the rules file, or use the switch of a built-in rule in the Rules view.

Three built-in layout rules decide the navigation of the dashboard: the overview and the process pages appear in it and detail pages do not, pages that open as a card stay out, and each entry shows the icon of its page role. You switch them on or off one by one in the project file (see Header and navigation below).

Explain a widget

Why This Widget? explains where a widget of the open project comes from. Run it from the Command Palette and pick the page and then the widget, each listed with its label, kind and id. You reach it as well from the Why? chip of a signal in the Signals view, from the Rule tab of the Properties view, and by clicking a row of the Rule Hits view; there Studio explains the widget that shows the signal, or lets you choose when several do. A read-only document titled Why this widget opens with three parts:

  • Fields and Where They Come From: every field of the widget with its value and its source, such as the rule or built-in rule that set it, set by hand, placed by the automatic layout, or not recorded.
  • Rule Trace: the facts of the signal, every rule with whether it matches or the first condition it fails, and for each field the rule that won and the rules it overruled. When the rules did not make the widget, the document says so, and that applying the rules leaves it as it is.
  • Navigation: whether the page of the widget appears in the navigation, with its text, its position and its icon, and whether an entry of the project file, a built-in layout rule or the default put it there.

The rule trace needs the signals of the project to be loaded, and the navigation also needs pages that can be generated. Without signals, the document asks you to load them and still shows where the fields come from. Run the command again to refresh the document.

Symbols with states

Your own SVG symbols can show the state of the plant: a part changes its color, blinks, appears or disappears, turns or moves when a signal changes. Keep the symbols in the symbol folder of the project and load it with Choose Symbol Folder... in the Symbols view (see The symbol folder above). When the folder lies in the project, the assistant can tell you why a file was skipped. Everywhere, in the Symbol list of the Properties view, in page files and in rules, a symbol is named by its path in the folder, with forward slashes and without .svg, for example pumps/pump.

When you open a project whose page files still name a symbol by its file path, Studio changes the path to this form as an unsaved edit that a single Undo takes back. When a page file names a symbol that the folder does not hold, the project opens with a warning, and sending leaves out only that widget until you correct the name.

Mark the parts of a symbol

In your drawing tool, give the elements that should change an id that starts with one of these markers:

  • part-<name>, for example part-body, marks a part whose color, visibility, blinking, turning or position can change. Only marked parts change color; everything else keeps its colors.
  • variant-<name> marks one of several alternative drawings of the symbol, of which one is shown at a time.
  • keep-<name> marks an element inside a part that keeps its own colors when the part changes color.

A symbol without state bindings of its own and without default bindings in a manifest works as a plain on/off switch, as before.

Add a manifest

Next to the SVG you can put a manifest with the same name and the ending .scadasymbol.json, for example pumps/pump.scadasymbol.json next to pumps/pump.svg. The editor suggests its fields and marks mistakes as you type. The manifest gives:

  • size: the default width and height of the symbol; the symbol keeps its aspect ratio.
  • slots: the named inputs of the symbol, such as running or speed, each with the data types it accepts.
  • defaultBindings: the state bindings that every widget with this symbol uses as long as it has none of its own.
  • parts: parts named by the id of an element, for a drawing whose ids carry no part- marker.

Save as Symbol Default writes the slots and states of a widget into the manifest for you (see Reuse a binding above). After you change a drawing or edit a manifest yourself, load the symbol folder again with Choose Symbol Folder....

Edit the default states

Edit Symbol States opens the states editor for a symbol. Start it from the Command Palette and pick the symbol, click the Edit States icon on a tile of the Symbols view (or right-click the tile and choose Edit States), or click Edit Symbol Defaults on the States tab of the Properties view for the symbol of the selected widget. If the symbol has no manifest yet, Studio creates one for you from the symbol's size, slots and current default states; it does so only for a symbol folder inside the project.

  • Drawing shows the symbol, and Parts lists the whole symbol, its marked parts and its variants. Point at a row of the table or an entry of the list, and the part it changes is outlined in the drawing.
  • Default States is the same table as on the States tab, for the slots of the manifest: per slot and value, how the symbol or one of its parts looks. Every change is one step you can undo, and the manifest stays unsaved until you save it. Every new use of the symbol starts with these states.
  • Preview of Every State shows the symbol once for each state the table produces, labelled with the slot and the value; moving and turning parts are shown at rest.
  • Checks lists problems such as blinking and visibility on the same part, overlapping ranges, a missing default and states FUXA cannot show.

If the drawing marks no parts, the states change the whole symbol; to add parts, give elements of the SVG an id that starts with part-, for example part-door. Open as Text opens the manifest in the text editor. The States tab of the Properties view keeps changing the states of the selected widget only.

Bind a part to a signal

A state binding lets the whole symbol (target item), a marked part (part:<name>) or a marked part of the page background (background.part:<name>) follow a value. The value comes from a slot of the symbol or straight from a signal, and can be a single bit of it. The property says what changes:

  • fill or stroke: the color of the fill or of the outline;
  • visible: shown or hidden;
  • blink: blinking between two colors, 100 to 10000 milliseconds apart;
  • spin: turning continuously, clockwise or counterclockwise, or standing still;
  • variant: which variant of the symbol is shown;
  • move: a position for each state;
  • rotate: an angle that follows the value;
  • position: an offset along one axis that follows the value.

Most properties use rows under map: each row applies to one value (eq) or a range (min, max) and gives the value for it, and default applies when no row matches. rotate and position use linear instead, with the four numbers inMin, inMax, outMin and outMax: the values from inMin to inMax become the angle from outMin to outMax in degrees or, for position, the offset from the home position in pixels along the axis x or y. A rotation starts at inMin 0 and runs from a smaller outMin to a larger outMax; mirror the drawing to turn the other way. This binding turns the part vane from 0 to 270 degrees while the speed slot goes from 0 to 100:

{
  "id": "vane-speed",
  "target": "part:vane",
  "property": "rotate",
  "source": { "slot": "speed" },
  "linear": { "inMin": 0, "inMax": 100, "outMin": 0, "outMax": 270 }
}

To move a part with a value, name the axis as well: "linear": { "axis": "x", "inMin": 0, "inMax": 100, "outMin": 0, "outMax": 200 }.

The easiest way to bind a part is to drop a signal on it in the page editor and adjust the values on the States tab of the Properties view (see The Properties view above). Default bindings live in the manifest, and the bindings of a single widget under stateBindings in its page file; the assistant can set them for you. A widget with bindings of its own uses only those, and the off and on colors of a symbol widget apply only to a symbol without state bindings.

The page background can have marked parts too, for example the outline of a plant area that follows the state of its module: mark the elements in the background SVG with part-<name> in the same way, list their names under parts of the background in the page file, and bind them from a widget on that page with the target background.part:<name>, or drop the signal on the background part.

Moving with a value needs FUXA 1.3.4 or newer. A send to FUXA 1.3.3 is refused, and the message names the effect; for a FUXA version Studio has not checked, a warning appears instead and the send continues.

When a binding cannot be shown

Some combinations cannot be shown in FUXA. When Studio builds the dashboard, it leaves such a binding out and builds the rest of the page; a symbol whose bindings all fail keeps its drawing without states. A warning after sending or saving says that some entries could not be generated and names, for each kind of problem, the page and the widget where it occurs; the Diagnostics view lists them too, and the assistant explains each entry in plain words, with a fix. Studio refuses these combinations:

  • A part that moves inside something that moves. A part cannot move inside a symbol or part that moves itself, because FUXA moves a group together with everything in it. The outer motion is kept; draw the moving part outside of it, so that each moves on its own.
  • A part that turns while it moves. A part or symbol that moves cannot also turn, and nothing inside a moving part can turn. The motion is kept and the turn is left out; draw what turns as a separate part or symbol that does not move. A turning part cannot contain a part that moves either, but the whole symbol may turn while parts inside it move.
  • Two axes on one part. A part moves along one axis. A second position binding on the other axis is left out; draw the part as two parts that do not contain each other and give each one its own binding.
  • Colors from two signals. The fill and the outline of one part take their colors from one signal; combine the states into one status word in the PLC.
  • States from text. FUXA compares states only as numbers; drive them from a number or a status word.

Header and navigation

The header and the navigation of the running dashboard come from the layout section of the project file. The editor suggests each field with a description, and the assistant can set them for you.

  • Navigation. The dashboard shows one navigation entry per page, with the page name and an icon. By default the built-in layout rules decide which pages appear and which icon each entry shows (see The built-in rules above); switch them on or off one by one under rules in the layout section, and pick another icon for each page role. A navigation entry of your own for a page sets its position and its icon, adds a page the rules leave out, or hides it. A detail view never appears in the navigation.
  • Header. Switch on what the header shows: a title with the name of the project, the date and time in a format you choose, and the name of the signed-in user next to the login button. In a project with languages, the header can also show the language button, with which the operator switches the language of the dashboard (see Languages below). The counter of active alarms appears on its own as soon as the project has alarms, and a separate information counter as soon as it has an alarm of the level Info, and FUXA shows the login button whenever its login is on.

Changes in FUXA. In the layout dialog of FUXA you can still add navigation entries for pages you made in FUXA or for links, add buttons to the header, and change settings Studio does not set, such as the theme or the zoom: Studio keeps all of these on every send with merge. The entries of the Studio pages, the header items Studio adds and the colors, sizes and style of the header and the navigation belong to Studio: when they were changed in FUXA, the next send shows the difference, and once you confirm, Studio puts its own back (see What happens on every send below). A send that replaces the whole project writes only the header and the navigation of Studio, so it removes what was added in FUXA. To leave the header and the navigation entirely to the FUXA editor, set owner to fuxa in the layout section; Studio then leaves them as they are, and replacing the whole project is locked until you hand them back.

Command buttons, tiles and cards

A few widget forms do more than show a value. You set them on the Properties tab of the Properties view (Button Action, Tile Rows and Events), in the page file (the editor suggests the fields), with a rule, or by asking the assistant.

  • Command button. A button normally switches its signal on and off with each click, also when no other widget on the page shows that signal. For a command that the PLC program carries out and then resets, give the button an action that writes a fixed value instead (Write a fixed value, in the page file for example "action": { "kind": "setValue", "value": 1 }): every click writes that one value, and the button never resets it; the PLC program does that once it has handled the command. Such a button writes only to a signal that the signal list marks as read/write, of the type BOOL (written as 1 or 0), a whole-number type, TIME, REAL, LREAL, STRING or WSTRING; for any other signal the button is left out and a warning says so. When the FUXA login is on, only a signed-in user can use the button.
  • Tile. A tile shows several values of one plant unit under one title: one row per value, each with its own label, unit and number of decimals, and it can color its frame by the state of its main signal. On a page with the Tiles layout every tile has the same size and shows at most two rows; on a Sections or Free page a tile grows with its rows. Rows that do not fit into a tile are left out, and a warning says so.
  • Card. A navigation tile, a button that writes no signal, or a display such as a lamp or a symbol can open a page as a card on top of the current page instead of switching to it (Open as card, in the page file an event such as { "kind": "openCard", "target": "speed" }, where target is the id of the page). The card appears centered over the page, and each widget opens at most one card. With Close other cards ("replaceCards": true), the cards that are already open close before the new one opens; otherwise the new card joins the open ones. A card event on a widget whose click already opens a page is ignored, because opening a page closes every card; the Events section of the Properties view warns about it. Pages that open as a card stay out of the navigation. The preview of the page editor shows the cards before you send.

Detail views

A detail view is one page that shows the members of one data type, for example a motor, and opens as a card for any structure of that type, with the values of that structure. A type with many instances then needs one page instead of one page per instance.

  1. Make a page the detail view. Give the page the role detail in its page file, or ask the assistant. The Properties tab then shows Detail View Of: choose the data type there from the types of the loaded signals, or None, an ordinary page to make it an ordinary page again.
  2. Bind the members. On a detail view, the Bindings tab shows the members of the type instead of signals. Click Member... to choose one, or drag a signal from inside a structure of that type onto a slot row; the member must fit the slot, and an integer on a yes or no slot first asks for the bit. Signals cannot be dropped on the detail view itself or bound with Assign Variable... there; a message points you to Member.... A detail view can show values, lamps, buttons and symbols with states, but no charts, alarm tables or message tables, because they cannot follow the structure that opens the card.
  3. Open it for an instance. On a widget of another page, add an event with Open as card that opens the detail view, and enter the instance, the structure whose values the card shows. Or let a rule do this for every structure of the type (see Apply the rules above). Every motor then opens the same page with its own values.

Every structure that opens the detail view must hold every member the page shows; the Diagnostics view names a member that is missing. A detail view reads the PLC of the structure that opens it, so it has no PLC of its own. It opens only as a card, so it cannot be the start page or a visible entry of the navigation; Studio refuses that when you set it and when you send, and a card of a detail view cannot open a further detail view. The screen plan does not show detail views and never removes them; edit a detail view in its own page.

Roles

Roles decide who sees and who operates what on the running dashboard. List the roles of your runtime in the project file, each with an id and a name, for example Operator and Maintenance; the editor suggests the fields. Then choose, in the page file and in the rules file or through the assistant:

  • for each page, which roles see it in the navigation and which roles may operate it;
  • for each widget, which roles see it and which roles may operate it; a widget without a choice of its own follows its page;
  • for each alarm rule, which roles see its alarms and which roles may acknowledge them.

If you choose only who sees a page, a widget or an alarm, the same roles may also operate it or acknowledge it. A role you choose must be one the project lists; otherwise Studio does not load the project and names the role. Leave the roles out, and every page, widget and alarm stays open to everyone.

When you send, Studio creates the roles that are still missing on the runtime and switches the runtime to roles, before it saves the backup and writes the project. Switching the runtime to roles restarts it once: every active alarm is reset and comes back unacknowledged, and the live values pause for a few seconds. So the first send of a project with roles asks you first: the send dialog warns about the restart, the confirmation names the number of active alarms, and the message after the send says that the roles were switched on and the runtime restarted. Live mode never does this: it stops such a send and asks you to send once with Send to FUXA. It never removes a role and never changes a user account, and it checks the roles on the runtime after writing them. If a role name of your project is already used by another role on the runtime, the send stops before anything is changed and names both roles. If the runtime cannot be switched to roles, the send stops and tells you, so your restrictions never go out without effect. If the project on the instance reads differently after the switch, Studio checks the send again and asks you once more only when the send would now do more than you confirmed. If you cancel a send with roles, or it does not reach the runtime, Studio switches the roles of the runtime off again, so the previous screens stay usable.

Assign the roles to your users in the runtime's user administration. A signed-in user with none of the project's roles sees only what is open to everyone; the pages built from ticked signals, in a project without pages, are open to every signed-in user. Once the runtime uses roles, entries that carry no roles, for example pages or navigation entries you made in the runtime's browser editor, may no longer show for signed-in users who are not administrators; give them roles in the runtime's browser editor. If the runtime already uses roles but your project lists none, Studio warns you that signed-in users who are not administrators may not see the navigation.

Alarms

The dashboard raises an alarm when a signal enters its alarm state, and shows an alarm banner in the header while any alarm is active. Alarms come from three places: a token in the comment of a signal, the alarm rules of the rules file, and the connection alarm every project gets. They are built each time the pages are built: on every send, in the preview and when you save a FUXA file.

Mark a signal in its comment

You mark a single 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=}. A marked signal raises its alarm even when no page shows it. For that signal, the token wins over every alarm rule.

Alarm rules

Alarm rules raise alarms for whole families of signals at once, for example for every fault bit of every motor, without a widget on any page. You write them under alarmRules in the rules file, next to the widget rules (see Assign widgets with rules above); the editor suggests every field with a description and marks mistakes as you type. An alarm rule has:

  • an id, unique in the rules file, and optionally enabled, false to switch it off;
  • match: which signals or structures it hits, with the same conditions as when of a widget rule, such as the type name, the path, the name, the data block or a comment token;
  • optionally commentPattern: a regular expression of at most 200 characters, with named groups, that reads the comment of the signal; its groups can choose the level and give the text. Studio refuses a pattern that could keep running for a very long time, also one with more than two open repeats in a row that can match the same characters, such as .*.*.*; put a separator between them that the part before cannot match on a long comment and names the part to rewrite;
  • signal: the state that raises the alarm, of one of four kinds. When the rule hits a structure, member names the member below it that carries the signal.
    • bool: a BOOL, active while it is true, or while it is false with "activeWhen": "false".
    • bits: a BYTE, WORD or DWORD, one alarm per bit, for all bits or the bit numbers you list; active while the bit is set, or while it is clear with "activeWhen": "clear".
    • band: a number, active while its value lies between min and max; one of the two is enough.
    • equals: a number, active while it equals value.
  • effect: the level (highhigh, high, low or info, or taken from a group of the comment pattern through a map), the text, the group and how the alarm is acknowledged (ack).

The text is a list of sources, and the first one that gives a text wins: { "comment": true } takes the comment of the signal without its tokens, { "template": "..." } a text of your own, { "regexGroup": "name" } a group of the comment pattern, and { "bitTexts": { "0": "...", "1": "..." } } one text per bit of a bits signal. A template, a bit text and the group as well can use these variables: {block}, {path}, {name}, {parent}, {idx} (the innermost array index), {bit}, {n} (the message number of a bit in a packed status word), {comment}, {seg:N} and {segi:N} (the name and the index of part N of the path, counted from the end when N is negative) and {re:group}. Add |padN to pad a number with zeros, for example {idx|pad3}. When no source gives a text, the alarm is left out, so end the list with a template.

This rule raises one alarm for each of the first three bits of the member faultWord of every structure of the type Motor. Bits 0 and 1 get their own text, bit 2 gets the template, for example Motor1: fault 2, and the alarms are grouped by data block:

"alarmRules": [
  {
    "id": "motor-faults",
    "match": { "typeName": "Motor" },
    "signal": { "kind": "bits", "member": "faultWord", "bits": [0, 1, 2] },
    "effect": {
      "level": "high",
      "text": [
        { "bitTexts": { "0": "Overload", "1": "Phase failure" } },
        { "template": "{parent}: fault {bit}" }
      ],
      "group": "{block}"
    }
  }
]

When several alarm rules hit the same signal with the same level, the first rule in the file wins, and the others are reported. If the rules file has an error, sending stops and names the problem, so fix the rules file first. Watch for these warnings:

  • An alarm that is active while a value is false or a bit is clear is also raised whenever the connection to the PLC is lost, because the value then reads 0: on every matching signal at once, in addition to the connection alarm. Use it only for a signal that is 0 in the fault case by design.
  • When one group name is part of another, for example Line1 and Line10, a group filter of an alarm table shows both. Pad the numbers with |padN, or rename the groups.
  • A project holds at most 1000 alarms. Beyond that, the rest is left out in the order of the file, and a warning says how many. Narrow the rules, or set a higher alarmBudget under settings in the rules file.

The connection alarm

Every project you send raises an alarm of the highest level for each PLC when the connection to it is lost for more than 10 seconds. You do not need to set it up.

The alarm table

An alarm table widget lists the active alarms with their time, message, group and acknowledgment. Place it with Insert Widget... in the page editor (see Insert a widget above) and choose which alarms it shows under Alarm Filter in the Properties view (see Properties above). When none of the signals of its filter can be read, the table is left out rather than showing every alarm, and the Diagnostics view says so.

An alarm of the level Info is listed in every alarm table whose filter lets Info through. In the header of the dashboard it is not counted at the alarm counter but at the separate information counter, which Studio shows as soon as the project has an Info alarm.

Alarms and sending

Studio writes the alarms to the FUXA instance only when they changed. A send whose alarms did not change keeps the active alarms. When the alarms changed, the whole project is written, and the restart confirmation says that FUXA reloads every alarm, so every active alarm is reset, and names how many alarms are active right now. Send alarm changes in a maintenance window. The first send after the Studio update that added roles writes the whole project once and resets the active alarms, also in a project without roles.

When the FUXA instance already holds an alarm on the same signal and level under another name, for example from an earlier version of the project, Studio does not add that level a second time. The other levels are written, a warning after the send names both alarms, and the Diagnostics view lists them. Remove the old alarm, for example with a send that removes what Studio no longer generates, and send again. When an alarm cannot be built at all, for example a band without a minimum or a maximum or a bit outside 0 to 31, a message after the send names the alarms that were left out and why.

Notifications

A notification tells a person or a system when alarms of chosen levels are active, by e-mail or by a call to a web address. You list the notifications in the project file, each with a name, the alarm levels it reports, an optional delay and repeat interval in minutes, and a receiver name; the editor suggests the fields. The name is the subject of the e-mail, so keep it on one line and at most 120 characters. The project file names the receiver only, never the address itself. The runtime sends e-mail through the mail server set in its own settings.

To give a receiver its address, run Set Notification Receiver... from the Command Palette on each computer that sends to the runtime. Pick the receiver name from the list, which shows whether an address is stored and which notifications use it, then enter the e-mail address or the web address, starting with http:// or https:// and without a user name or password in it. The input is masked, and the address is stored securely on this computer and never shown again. Clear Notification Receiver... removes it again.

  • When you send, Studio uses the addresses stored on this computer; saving a FUXA file or previewing never includes them.
  • Without a stored or valid address, a send from this computer does not update that notification and says so; the runtime keeps the version it already has. A colleague who sends without the address therefore never switches your alerts off.
  • If a send reports that the stored receivers could not be read, nothing was sent; try again, or store the receivers again.
  • After a send that changes notifications, the result message says how many notifications were written and removed.
  • When you remove a notification from the project, the next send asks before it removes it from the runtime, and names it. An address you stored for it stays on this computer until you clear it.

The runtime keeps the address, so it also appears in the backups Studio saves before each send.

Where alarm problems appear

The Diagnostics view lists the problems of the alarm rules and the alarm findings of the last build, for example a rule that matches no signal, and a click on a row opens the rule or shows the signal (see Diagnostics below). The Rules view shows how many alarms each rule raised (see The Rules view above), and the Alarm Hits of the Rule Hits view list them one by one (see Rule Hits below). The assistant can mark a signal, write alarm rules and drop an alarm table for you.

Message table

Many PLC programs keep their messages in a message buffer: an array of structures with one slot per message, each slot holding members such as the time, the module and the message number. A message table widget shows such a buffer on a page, one row per slot and one column per member you choose.

  • Place it with Insert Widget... in the page editor and pick the buffer (see Insert a widget above).
  • Under Message Table in the Properties view, choose the buffer, the number of slots and the columns, each with its member, its label and its width (see Properties above).
  • The page editor shows the table with its column labels and the number of slots; the runtime fills in the slots.

The table shows the current slots of the buffer, not a message history: when the PLC overwrites a slot, the row shows the new message. The time in a message table comes from the PLC clock, while the alarm table shows the time of the SCADA runtime. The two clocks can differ by a few minutes, so compare times only within one table.

This version shows numbers: a column shows the message number, not its text. You can already choose a text list for a column (see Text lists below); Studio keeps the choice, and a later version shows the text.

Each cell of the table reads one signal, so a table binds its slots times its columns in signals. The line below the slots in the Properties view counts them against the budget of 800 signals per table, or the messageTableTagBudget you set under settings in the rules file. A table over the budget is left out and the Diagnostics view says so: show fewer slots or columns. A column whose member the slots of the buffer do not hold is reported there too.

Text lists

A text list gives a text to each key, for example to each message number, in one language. The text lists of the project live in its texts folder, one file per list and language.

To import a text list, click Import Text List... in the title bar of the Project view (the cloud icon), or run SCADA: Import Text List... from the Command Palette:

  1. Pick a CSV or a JSON file. A CSV file has two columns, the key and the text, separated by a semicolon or a comma. If Studio cannot tell which separator the file uses, add the header row key;text or key,text as its first line. A JSON file holds an object that maps each key to its text, or a list of entries with key and text.
  2. Choose the list to import into, or New Text List... and enter its id, for example messages, with letters, digits, dots, hyphens and underscores.
  3. Choose the language from the languages of the project and of the existing text lists, or Other Language... and enter a language tag such as en or de-CH.

When the list already exists in that language, Studio asks before it replaces its texts. The list then lands in the texts folder and the project file lists it: a new list is saved at once, a replaced list and the project file stay unsaved until you save them, and a single Undo takes the whole import back. A message says how many texts were imported, or that the list already holds exactly these texts. A file with problems is not imported: the message names the first problems with their rows, and nothing is written.

The Project view shows each text list under texts with its language and its number of entries, and its first line counts the text lists. A list that cannot be read shows cannot be read and the problem next to the file, and the Diagnostics view names the reason. A file in the texts folder whose name does not have the form list, language and .json, for example messages.en.json, is not read as a text list, and the Diagnostics view warns about it. The assistant can import a text list for you.

Languages

The dashboard can show its texts in several languages. List the languages of your runtime in the project file, each with a language code such as en or de-CH and the name its language menu shows, and mark exactly one as the default; the editor suggests the fields. Each code starts with two letters, and two languages may not start with the same two letters, so de-CH and de-DE cannot both be listed.

Every text list you import for a listed language is sent with the project. Navigation entries, the header title and alarm texts that refer to a text of a text list by its key then appear in the language the operator chooses with the language button in the runtime header (see Header and navigation above). If a text is missing in the default language, the runtime shows it in another language, and the Diagnostics view names the texts to complete; an alarm text whose key names no text is reported there too. Without listed languages, the dashboard has one language: a key shows the English text of its list, or else its first language.

Changing a text or a translation later goes out with the next send without restarting the runtime and without resetting active alarms, and Studio checks the changed texts and languages on the runtime after writing them. When the project no longer contains texts that Studio sent earlier, the send removes them after you confirm, and the confirmation lists them. Texts the runtime already had stay.

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.

Send and save

Three actions finish the dashboard:

  • Send to FUXA, in the title bar of the Project view, in the toolbar of the page editor and in the Command Palette, sends the dashboard to the FUXA address in the settings. For each send you choose in the send dialog whether it is merged into the project on the instance or replaces it, as described below.
  • Save FUXA File..., in the ... menu of the Project view, writes a FUXA project file (.fuxa.json) you can import into FUXA by hand.
  • Save SCADA Export File..., in the same menu, writes the ticked signals to a signal configuration file (.scada.json) so you can reuse it later.

After a successful send of the whole project, a message says how many devices, tags and views the project on the instance now holds and offers Open FUXA to view the result; a send of only the changed pages reports those instead (see Send only the changed pages below). When you use a Siemens S7 connection, a message lists any signals that were left out. The send then shows in the Send view of the SCADA panel.

When some entries of the pages cannot be generated, for example a binding FUXA cannot show or a symbol the folder does not hold, the rest of the dashboard is still generated, and a warning lists the problems: each kind once, with the page and, where Studio can tell, the widget where it occurs; beyond five, it counts the rest. The Diagnostics view of the SCADA panel lists every entry, and the page editor marks the widgets. When the pages cannot be generated at all, the message lists the problems in the same way.

Merge or replace

By default a send merges the dashboard into the project already on the instance:

  • Pages, devices and alarms you added by hand in FUXA are kept.
  • The pages, devices and alarms Studio generated are updated. A page you handed over to the runtime's browser editor is left exactly as it is (see below); when a Studio page was changed on the instance anyway, Studio names the pages concerned and asks first.
  • Pages, alarms and devices that Studio sent from your project earlier and that the project no longer contains are removed from the instance too. Studio lists them and asks before it removes them.
  • If Studio cannot tell its own pages apart on the instance, for example because another project or another Studio user sent to it, or an older copy was loaded in FUXA, it removes nothing, names the pages concerned and asks before it overwrites them.

In the Mode section of the send dialog you can choose Replace the Whole Project instead: the whole project on the instance is replaced by the generated one, which restarts its runtime. The choice applies to that one send; the next send opens with Merge into the Project again.

A page belongs to Studio until you hand it over to the runtime's browser editor. To change a page there, save it and send it to the development target first, then choose Edit in the Runtime Editor: right-click the page in the Pages view, open More Actions (...) in the toolbar of the page editor, or run it from the Command Palette. Studio opens the runtime's browser editor in a browser tab inside Studio and tells you which view to pick there. The message also offers the symbol palette for the runtime's editor (see Your symbols in the FUXA editor below). From then on the Pages view marks the page Runtime editor, the page editor shows it read-only with a banner, and every send leaves it as it is on the instance, so your changes in the runtime's editor are kept. If the page has unsaved changes, was not part of the last send to the development target, or was changed on the instance since that send, Studio does not hand it over and tells you what to do first.

To bring the page back, choose Restore Studio State in the same places. Studio saves the runtime's version of the page in the backups folder of the project, shows the differences between that backup and the Studio version side by side, and asks you to confirm. After you confirm, the page belongs to Studio again, and Studio sends the project to the development target, which puts the Studio version of the page back on the instance.

While any page, or the header and the navigation, belongs to the runtime's browser editor, replacing the whole project is refused: a send with Replace, restoring the runtime volumes and deploying a Compose file over the running container. The message names the pages; take them back with Restore Studio State first.

Send only the changed pages

When you send your SCADA project with merge and only pages, or the header and the navigation, changed since Studio's last send to this instance, Studio writes just the changed pages, one after the other, and checks each of them on the instance. FUXA keeps running: there is no restart and no restart confirmation, active alarms stay as they are, and the live values keep running. The message after the send says that the changes were sent without restarting the runtime and counts the new, changed, removed and unchanged pages; it adds that the header and the navigation were updated too when they changed, and offers Open FUXA. FUXA viewers that are open keep the old pages until they are reloaded.

Studio writes the whole project instead, and FUXA restarts, when that is needed: on the first send to an instance, when the devices or their tags, the alarms, the charts or other project settings changed, when two pages of the project have the same name, when more pages changed than the instance accepts one by one, or when Studio cannot confirm its earlier send on the instance. The restart confirmation then names the reason, for example that Studio has no record of an earlier send to this FUXA instance. A send with Replace always writes the whole project.

On the first send to an instance that already holds a project, you answer a single restart question. Besides the reason, it says that Studio cannot yet tell its own pages from pages made elsewhere, and what the send does because of that: with merge, a page with the same id as one of yours is overwritten and no page is removed; with Replace, the whole project on the instance is replaced, pages made elsewhere included. There is no second question about this.

If a send of changed pages stops midway, the message says what went wrong, for example which page the instance did not keep. When part of the changes may already be on the instance, it says so and, where Studio knows it, how many of the writes were done, for example 2 of 5. Send again to complete it. If you cancel such a send once writing has started, a warning says that the instance may hold only part of the changes.

The send dialog

When you send, Studio shows one dialog, Send the SCADA Project, before anything is written:

  • Target: the target the send goes to. If you pick another target, click Plan the Send Again, and Studio shows the dialog again with the plan for that target, built for the PLCs that target lists; nothing is written in between. When you then send, that target becomes the active one, and the FUXA address in the settings follows it. When you cancel instead, the FUXA address and live mode stay as they were. While the dialog is open with another target, live mode sends nothing, and a live send that is already running finishes first.
  • Mode: Merge into the Project adds or updates the pages, devices and alarms Studio owns and keeps everything else on the instance; Replace the Whole Project replaces the whole project on the instance with the generated one, which restarts its runtime. Every send opens with merge. While a page, or the header and the navigation, belongs to the runtime's browser editor, Replace the Whole Project cannot be chosen, and a sentence under it says why. If you choose the other mode, the pages still show the plan for the mode you started with, a note says so, and the button reads Plan the Send Again: Studio then plans the send with the chosen mode, together with a new target if you picked one, and shows you the new plan before anything is written. Choosing another mode or target also resets the choice for pages changed on the instance to Cancel the Send and clears the production approval.
  • Pages: every page with whether it is new, changed, unchanged, removed or skipped. When only the changed pages are sent, you can clear the checkbox of a page to hold it back; that page stays as it is on the instance. Clearing a removed page keeps it on the instance, and its row then reads Kept on the instance. When the whole project is written, every page is checked and cannot be cleared. Pages that belong to the runtime's browser editor appear greyed as skipped and are not sent.
  • Backup: always checked and cannot be cleared. It names the file Studio saves the current project on the instance to before it writes anything.
  • If pages were changed on the instance since your last send, for example in the runtime's browser editor, the dialog says so and asks how to handle them: Cancel the Send (the default), Overwrite After Backup, or, for a send of the changed pages to a development target, Hand Over to the Runtime Editor. Handing over keeps those changes: Studio hands the changed pages over to the runtime's browser editor and cancels this send, and the button reads Hand Over and Cancel Send. Send again afterwards to send your other changes.
  • For a production target, check I reviewed the changes and approve the send to the production target. before you can send.
  • Warnings about the FUXA version, effects Studio has not checked, a restart of the runtime, alarms, devices, texts and notifications the send removes, and the runtime's editor when it is open in a Studio browser tab on the same instance; a tab that only shows the running dashboard does not count.
  • Save and Send lists the SCADA files with unsaved changes; Studio saves them when you send.

The button that sends reads Merge into Project, Replace Project, Send to Production, Overwrite After Backup or Plan the Send Again, depending on what you chose, and stays disabled until nothing blocks the send; the dialog lists what still does. Cancel sends nothing. If you cleared a page and the instance changed in the meantime so that the send would now do more, Studio shows the dialog again before it writes anything. If your workspace settings fix the FUXA address, change it there; the dialog cannot switch it.

What happens on every send

Every send runs the same safeguards, whether it starts in the SCADA side bar, in the page editor, from one of the file commands or from the assistant. Live mode runs them too, but asks nothing except before it removes pages (see Live mode below). For a send you start, the questions below are all in the send dialog (see The send dialog above); a send of the assistant asks them one after the other.

  1. If SCADA files of the project have unsaved changes, Studio asks to save them first, because it sends only saved files.
  2. Studio checks the stage of the target (see Targets and stages above) and refuses the send when the stage is not confirmed.
  3. Studio reads the current project from the instance. If it cannot, nothing is backed up and nothing is sent. The send also stops here when a page of your project has the name of a page on the instance that Studio did not create: a warning names both pages, so you can rename one of them and send again. It stops as well when the pages use an effect that the FUXA version of the target does not support, for example moving with a value on FUXA 1.3.3; the message names the effect, and you update FUXA on the target or remove the effect from the pages.
  4. A confirmation names what the instance holds now and whether the dashboard is merged into it or replaces it. Further confirmations follow where they apply: the Studio pages, alarms, devices, texts and notifications the send removes; when the whole project is written, the restart of the FUXA runtime, with the number of alarms active right now and the reason why the whole project is written; when the runtime is switched to roles, the restart this causes, with the number of alarms active right now; for a production target, a second confirmation that names the target and its stage; and changes made on the instance that the send would overwrite, including a header or navigation changed in the layout dialog of FUXA.
  5. When the project lists roles, Studio creates the missing roles on the instance and switches it to roles, which restarts the runtime once after you confirmed it (see Roles above). Studio then saves a backup of the project that was on the instance into the backups folder of your SCADA project, one file per send, named after its date and time.
  6. Studio sends the dashboard, and a send log in the project folder records the time, the target with its stage, and the result; the Send view of the SCADA panel shows it. Right before the first write, Studio checks that the project on the instance is still the one it read in step 3. If it changed in the meantime, for example in the FUXA editor while a confirmation was open, nothing is written: the message says that nothing was sent and asks you to send again to review the change. The change on the instance and the backup both stay.

Without an open SCADA project, the backup and the send log go to a folder of Studio, and a message names where the backup was saved.

When Studio writes the whole project, FUXA restarts its runtime to load it: every active alarm is reset and comes back unacknowledged, and the live values pause for a few seconds. With every send, FUXA viewers that are open keep showing the old pages until they are reloaded, and a runtime editor that is open can write its old copy back, so close it before you send; the send dialog warns you when the runtime's editor is open in a tab in Studio. If the FUXA version has not been checked by Studio, or is older than the lowest version the target accepts, a notice says so and the send continues. The same goes for effects on the pages, such as state colors or pages opened as a card, that Studio has not yet checked with the FUXA version of the target.

Live mode

Live mode sends your changes to the development system each time you save, so FUXA follows your work. Run SCADA: Toggle Live Mode in the Command Palette. It switches on only while a SCADA project is open and the FUXA address in the settings belongs to a development target of the project; otherwise a warning says why it stays off. Switching on asks once and names the address.

While live mode is on, the status bar shows Live, and its tooltip names the address it sends to.

  • Every save of the project file, a page, the rules file or a symbol manifest sends the changes to the development target one second after the last save, one send at a time. Saving again during a send leads to one more send afterwards.
  • A live send asks nothing more, except before it removes pages Studio sent earlier. When it goes through, no message appears; its row shows in the Send view of the SCADA panel.
  • When other SCADA files of the project are unsaved, the send waits and says so once.
  • When some entries of the pages could not be generated, the send still goes out, and a warning points to the Diagnostics view.
  • Changes the assistant made are sent only after you save them yourself, with Save or Ctrl+S; an automatic save does not send them. With automatic saving on, a notice names the files the assistant changed and holds the sends back until you save such a file yourself or choose Send Now on the notice. A change another program makes to the files never triggers a send.

Live mode switches itself off, with a warning that names the reason, whenever a send needs more than a quick update: the first send to the instance (send once with Send to FUXA, then switch live mode on again), a send that writes the whole project and restarts FUXA, a send that would switch the runtime to roles and so restart it, a clash with pages made elsewhere, a project that was changed on the instance, a send that needs a confirmation, a refused or failed send, and a change of the FUXA address, the project or the target. It also switches off when your license no longer includes SCADA. To switch it off yourself, click Live in the status bar or run the command again.

The SCADA panel and the status bar

The SCADA tab of the panel at the bottom of the window holds three views. Without an open project, each offers Open SCADA Project and Create SCADA Project.

Diagnostics

Diagnostics is one list of every problem of the open project: the problems of the project, page and target files, the entries the last send or save could not generate, and the version and effect warnings of the last send. Each row shows the severity, a code, the page or file, the place in the file and the detail, and the view title counts the errors, warnings and notes. The filter box matches code, page, file, place and text. Click a row, or press Enter, to open the file in the text editor at that place; a warning of a send opens the SCADA channel of the Output view, which records it. The same findings are underlined in the text editor and listed in the Problems view.

The list also holds the problems of the text lists, the alarm findings of the last build, one row per kind with a count and examples, and a warning for each alarm the FUXA instance already holds under another name (see Alarms and sending above). A finding of one alarm rule names the rule, for example rule motor-faults, in the place column; click it to open the rules file at that rule. A finding on one signal names the signal; click it to see the signal selected in the Signals view, with any filter that would hide it cleared. Hover over a code to see what it means.

While the project reads several PLCs, a Category column marks the problems of its PLCs, their signal sources, the PLC of a page or a slot and the PLCs of a target, with PLC and the PLC's name, and the filter box matches it too. A PLC problem that names no page or file shows the row of that PLC in the Signals view when you click it.

Send

Send lists the sends of the open project, newest first: the time, the target with its stage, whether only the changed pages or the whole project was written, the result (Sent, Partly sent or Failed), how many pages that send wrote and removed, and the error. Rows of sends from an earlier Studio version that wrote only the changed pages show the number of Studio pages instead, for example Studio pages: 5, removed: 0. Show Backup shows the backup Studio wrote before that send, and Open FUXA opens the target of that row. The view follows the send log, so a new send shows up at once. Nothing is sent from this view.

Rule Hits

Rule Hits shows what the rules do to the loaded signals. With a rule selected in the Rules view, it lists that rule's hits: the signal, whether it is a data block, a structure or a signal, the field, the outcome (Winner, Overruled or Stopped) and what overruled it, another rule or a manual assignment. Without a selection, it lists every winner, grouped by rule. At most the first 1000 rows of a rule are listed, and the view title says so when rows were left out. Click a row to explain the widget that shows that signal.

Two chips above the table choose what the view lists: Rule Hits, the list above, and Alarm Hits, the alarms your alarm rules raised in the last build. For each alarm it shows the rule, the signal (with the bit for a bit alarm) and the level, sorted by rule and then by signal, at most 1000 rows per rule. The title says how many alarms came from how many rules, for example Alarm hits: 3, alarm rules with hits: 1, and adds a note when the rules file changed after that build, so that you build the pages again. Click a row, or press Enter, to explain the widget that shows its signal. The arrow keys switch between the chips.

Output

The SCADA channel of the Output view records what ran: the steps of each send with its warnings, the entries a send or save could not generate, each Apply Rules, each project opened or closed, each signal load, each read of a CPU and each connection test. Look there when a message refers to the SCADA output.

The status bar

While a SCADA project is open, the status bar shows:

  • The SCADA target, for example SCADA: dev, FUXA 1.3.4 checked: the stage of the target of the FUXA address and the FUXA version the last send to it found, with whether Studio has checked that version. Its tooltip names the target file, the FUXA address and the connection of the dashboard; while the project reads several PLCs, it lists every PLC with its connection and marks a PLC the target does not list as connected with the settings. Click it for the target actions: Set Target Login and Stage..., Clear Target Login and Stage, Test FUXA Connection, Open FUXA, Open FUXA in System Browser, Open Target File and Change FUXA Address and Connection....
  • The owner of the selected or open page, Owner: Studio or Owner: Runtime editor. Click it to show the Pages view.
  • The rules, for example Rules: 4 active, 6 built-in, or Rules: problems with the first problem in the tooltip. Click it to show the Rules view.
  • The signal source: the file the signals come from, marked (not loaded) until they are loaded. Its tooltip names the number of data blocks and the namespace index. Click it to show the Signals view.

While live mode is on, Live shows as well (see Live mode above).

Deploy a FUXA instance

If you do not run FUXA yet, Studio can start one for you in a Docker container. Open the SCADA category of the settings and use the Deployment section: set the Docker Host (empty for the local Docker engine, or a remote engine), then Check Docker, and Deploy a fresh instance, or Deploy from Compose File... with a Docker Compose file of yours. Start, Stop and Restart control the container later. The same actions are in the Command Palette, for example Deploy FUXA in Docker. Each one shows its progress and result as a notification, and a deployed instance fills in the FUXA address for you. This needs Docker to be installed and running on the chosen host. If you installed FUXA directly, for example on a laptop without Docker, skip the Docker actions and just enter its address; backing up its data folder and turning on its login work for it as well.

Deploy installs a FUXA release that Studio has checked. Before it creates the container, Studio asks where FUXA should be reachable: Only on the Docker Host (recommended: other computers cannot open FUXA, and Studio reaches it only when Docker runs on this computer), or on a network address of the Docker host that you enter, so operator stations in that network can open it; then turn on the FUXA login and protect that network with a firewall. The container starts again on its own when the Docker host restarts, unless you stopped it. Your FUXA project, users, logs and a staged symbol library are kept in Docker volumes, so they stay when the container is replaced by a newer checked release. When a FUXA container already exists, Deploy asks before it replaces it: Studio first backs up the volumes to a folder you choose, starts the new container, and removes the old one only once the new one runs. If that fails, the old container comes back. A container that already runs the checked release is left as it is.

Turn on the FUXA login

After the first deployment, Studio offers to turn on the FUXA login right away: enter the user name of the FUXA administrator (the built-in admin is suggested) and a new password of at least 8 characters, twice. Studio stores the password securely and signs in with it from then on. If you skip this step, a message warns that anyone who reaches the address has administrator rights until you turn the login on.

To turn it on later, or for a FUXA you installed directly, run Enable FUXA Login (the Enable Login... button of the FUXA Login row in the settings). After you confirm, everyone who opens FUXA must sign in, operators included, and Studio replaces the password of the administrator you name and stores it.

Back up, restore and install offline

The Backup and Offline Install row of the Deployment section, and the matching commands in the Command Palette, look after the instance:

  • Back Up... (Back Up FUXA Volumes) writes the volumes of the FUXA container into one archive file in a folder you choose; the container stops for a short time while it is copied. For a FUXA installed directly, it copies the data folder FUXA runs with instead; stop FUXA before you do so.
  • Restore... (Restore FUXA Volumes) brings back a volume backup made by Studio. Studio first writes a fresh backup of the current state to a folder you choose, and the confirmation says what the restore replaces: the whole project on the instance with its users, alarm history and logs, how many pages are replaced, and that active alarms are reset. A container that was running is started again afterwards.
  • Load Image File... (Load FUXA Image from File) loads a FUXA image file into Docker, for a Docker host without internet access. When the file holds the checked release, Deploy works offline afterwards; otherwise the message tells you what to change.
  • Export Compose Template... (Export Docker Compose Template) writes a Docker Compose file for the checked release, with the address FUXA listens on and, if you choose, a reverse proxy that serves FUXA over HTTPS. Deploy it with Deploy from Compose File....

Every change of the FUXA image and every restore writes a backup first.

Your symbols in the FUXA editor

The generated dashboard already embeds the symbols your pages use, so nothing more is needed to see them. If you edit a page in the runtime's browser editor (see Merge or replace above) and want to pick your own symbols from its palette there, make them available once in the Symbol Library section of the SCADA settings: Stage in Container... copies a symbol folder into the running Docker container and restarts FUXA. A container that Studio deployed keeps the library when it is replaced by a newer release; any other container needs the staging again after it is recreated. Export..., also available as Export Symbols to FUXA in the title bar of the Symbols view, writes the library into the shapes folder of a FUXA you installed directly and registers it there; restart FUXA afterwards. See Settings for the details.

Let the assistant build it

The chat assistant works on the open SCADA project. This is part of AI for SCADA in the Pro+ plan, and the free trial unlocks it; with the Pro plan you build your dashboards yourself, and the chat offers neither the SCADA tools nor the SCADA Builder agent. On your instruction it can:

  • read the project, its pages and its targets, and the signals loaded for the project;
  • create, open or close a project, and import a saved screen plan;
  • load the signals of a CPU you connected in PLC / OPC UA, as the signal source of the project. It only reads the CPU and asks first, and while it loads, the load actions of the Signals view are unavailable;
  • propose pages: it picks the signals that matter, groups them into named pages, marks alarms and writes the result into the page files. Changed pages stay unsaved until you save them, and the Assistant Preview in the Properties view and the ticked signals in the Signals view show what it proposed. Its confirmation names every button of the proposed pages that switches a signal in the PLC;
  • with an EPLAN project open, group the loaded signals by the plant structure of EPLAN and build one page for each mounting location, functional assignment or plant (needs an EPLAN licence);
  • change single pages and widgets: create, rename, resize, move or delete pages, place, move, resize, label or remove widgets, choose a symbol or go back to the widget the rules give, set colors, command buttons, cards and tile rows, and edit the header and the navigation. Before it changes pages, its confirmation names every button that writes to the PLC for the first time or differently after the change: a button that switches its signal, and a command button with the value it writes. If Studio expects the change to be refused, the confirmation says so and why. Input fields and sliders, where an operator enters the value, are not part of this list;
  • work on a page the way you do in the page editor: move, resize, add, rename and remove widgets as a drag or a drop does, one change at a time, and select widgets, so the page editor and the Properties view show you which ones it means. Its confirmation names the page and the widgets, and says when the page is put on the free layout first;
  • bind signals: bind, replace and remove the signals of slots, add or change states, place the widgets the rules give dropped signals, save a binding as the default of its symbol, and save a widget as a rule for its type or for its one signal. Its confirmation names what changes and every button that writes to the PLC afterwards;
  • draw a page the way the preview of the page editor shows it, with simulated values and an open card, to check its work before a send;
  • open FUXA in a browser tab of Studio, read the page and take a screenshot, for example to compare a page after a send;
  • create the rules file, which stays unsaved until you save it and which Undo removes again, change its rules, switch them on and off, and apply them through the same Refactor Preview, where you decide what is written;
  • read and edit the alarm rules: add, change, move and remove them, switch them on and off, and tell you which alarms each rule raised in the last build and what the warnings on them mean. Its changes stay unsaved until you save the rules file, and one Undo takes them back;
  • import a text list from the content of a CSV or JSON file, and list the text lists of the project with their entries;
  • set the alarm filter of an alarm table and the buffer, slots and columns of a message table;
  • explain a widget the way Why This Widget? does, including how its page got into the navigation;
  • set the state bindings of a symbol or of the page background, set the default states of a symbol in its manifest, and list the symbols of the project's symbol folder with their parts, slots and problems. Before it sets default states, its confirmation names the symbol and the number of states; the manifest stays unsaved until you save it, and Undo takes the change back;
  • check what a send would do before it sends: the backup, the Studio entries a merge would remove, whether only the changed pages are written or the whole project and why, the runtime restart with the number of active alarms, and any version warning;
  • send the saved pages to a development or test target, always as a merge and only the changed pages where that is enough, and tell you plainly whether the send went through, was declined or failed, and what it sent;
  • save a FUXA project file or a SCADA configuration file;
  • change the details of an existing target, such as its FUXA user name, the lowest FUXA version it accepts, or how it reaches each PLC of the project;
  • choose which PLC a page reads and bind a widget to the signals of any PLC of the project;
  • choose which roles see and operate a page or a single widget, and which roles see and acknowledge the alarms of an alarm rule;
  • set the languages of the project, and show or hide the language button in the runtime header;
  • make a page the detail view of a data type, which every structure of that type opens as a card. It never makes a detail view the start page or shows it in the navigation, and when a page file has problems, it asks you to repair it before it makes that page the start page or shows it in the navigation;
  • add, change or remove a notification, one at a time. It only names the receiver: you store the e-mail address or the web address yourself with Set Notification Receiver..., and the assistant never sees it;
  • drive the Docker deployment: check Docker, deploy, start, stop or restart the container, stage symbols from the project and export a Docker Compose template;
  • hand a page over to the runtime's browser editor and take it back with Restore Studio State, send to a production target, and replace the whole project on an instance. Each of these asks you in the chat first and then again in Studio before anything changes: a handover in its own dialog, even when the chat approves its steps on its own, a take-back with the backup, the differences and its confirmation, and a production send or a replace with Studio's send confirmations. A replace stays refused while a page belongs to the runtime's browser editor.

Whatever the assistant changes in the project files stays unsaved until you save it, and you can undo it; changing files never sends anything. It uses only the PLCs, roles, data types and members your project already has. With live mode on, its changes are sent only once you save them yourself.

The assistant does not change a page that belongs to the runtime's browser editor (owner Runtime editor). When a request would change such a page, nothing is changed, and the assistant tells you which page it is. It can still move that page in the list, make it the start page, change its navigation entry or delete it.

Before the assistant clicks, types, drags or hovers in a web page, for example in FUXA in a browser tab of Studio, it asks you first: the question Click Element?, Type in Page?, Drag Element? or Hover Element? names the element and the page, and for typing the text or the key. A click on a control of a running dashboard can write a value to the PLC, so check the element before you allow it. When you let the chat approve its steps on its own, these questions are skipped like every other confirmation.

Some steps stay with you: listing the roles of the project, setting up the users of the runtime, storing or clearing a notification receiver, loading a node set file or the export of the TIA project, connecting to a CPU in PLC / OPC UA, choosing the symbol folder, switching live mode on or off, setting the namespace index, creating a target, setting the login and stage of a target, backing up and restoring the volumes, loading an image file, deploying from a Compose file, adding or changing symbol drawings, editing the size, the slots and the parts of a symbol manifest by hand, and exporting the symbol library into a FUXA installation. Passwords never pass through the assistant: when an action needs one, Studio asks you directly.

The assistant's SCADA tools appear as a group of their own in Tool Approvals, so you can decide for each of them, or for the whole group, whether it asks every time, runs without asking, or is always denied (see AI Chat). A tool that changes something and that you set to always deny stays denied even while the chat approves tools on its own. A send from the assistant still shows Studio's own confirmations, and applying rules still opens the Refactor Preview.

The two file commands

Two commands work straight from a file, without a SCADA project:

  • 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; the send dialog lets you merge it into the project on the instance or replace that project.
  • 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 ask for the address the dashboard connects to, matching the Connection in the settings, and run the same safeguards on every send: the stage check, the confirmations, the backup and the send log. Because they do not send your SCADA project, they never remove anything from the instance, and their backup and send log go to a folder of Studio, which the message after the backup names.