How-to
Migrating Modicon SCADA libraries to Plant SCADA 2023
Short answer
Yes — the Modicon General Purpose libraries for Citect SCADA 2018 reach Plant SCADA 2020 and 2023 by migrating the SGC include file, which their product design allows into any later version. No newer SCADA-side release exists, so migrate the include file with the project and prove each screen by tracing its values back through binding, tag, driver and controller address.
On this page
- Is the Modicon General Purpose library compatible with Plant SCADA 2020 and 2023?
- What does the SGC include file actually carry into the new version?
- What should you record before converting anything?
- How do you migrate the include file to Plant SCADA 2023?
- Why does a migrated screen open but show the wrong value?
- How do you prove commands still reach the right controller address?
- When is rebuilding a graphic faster than migrating it?
- Questions asked
Yes — the Modicon General Purpose libraries for Citect SCADA 2018 reach both Plant SCADA 2020 and Plant SCADA 2023, and the SGC include file is the vehicle. The library's product design is that this include file migrates into any later Plant SCADA version and keeps working, and no newer SCADA-side release has come out to replace it, so there is nothing to wait for. Migrate the include file together with the project, recompile, then prove the screens: each migrated display is traced backward through object binding, project tag, driver and controller address until the number on the screen matches the number in the controller.
Is the Modicon General Purpose library compatible with Plant SCADA 2020 and 2023? #
Yes. The 2018 R2 General Purpose offer is the last SCADA-side release, and its SGC include file is designed to migrate into any later Plant SCADA version, so both 2020 and 2023 are reached by migrating that include file, not by waiting for a new library.
The documented record backs this. Schneider Electric publishes the Modicon Libraries range as stand-alone components for the M580 and M340 controllers or in combination with its HMI offers, including Plant SCADA. The General Purpose 2018 R2 offer for Citect SCADA was validated on Citect SCADA 2016 and paired with the 2018 R2 controller-side offer — the SCADA-side package has always trailed the SCADA versions it serves, which is exactly why its design leans on forward migration of the include file rather than re-validation for every release. The newest General Purpose release in the range, the 2024 V2, targets Control Expert V15.3 on the controller engineering side, not a new Plant SCADA library.
| Path | What it assumes | Decision |
|---|---|---|
| Migrate the SGC include file with the project | The include file's documented forward migration into any later Plant SCADA version | Take this path for both 2020 and 2023 |
| Wait for a new SCADA-side library release | A release that is not in the range today | Do not wait; nothing is pending |
| Rebuild screens on a newer graphics library | Object-by-object rework | Reserve for objects the diagnostics or the trace prove broken |
If the same revamp also reselects the controller platform, settle that before the migration, because the library choice follows the controller: SCADA and PLC platform selection for plant revamps walks that decision.
What does the SGC include file actually carry into the new version? #
The include file carries the library itself — the reusable graphics and functions your pages call — while your pages, tag database, equipment substitutions and driver configuration stay in the main project and migrate with it.
In Plant SCADA, libraries store the items you reuse across graphics pages, and this library delivers those items as an include file attached to your project: the graphics, their internal functions and the behaviors your pages call. Your own pages, the tag database, the equipment substitutions that tell each reused object which plant item it represents, and the driver configuration all live in the main project.
Two consequences follow. First, both halves must arrive in the target version — if the include file is detached, compilation reports unresolved references to the library's objects. Second, any edits made inside the include file over the years are part of what migrates, so list them before conversion rather than discovering them afterwards.
What should you record before converting anything? #
Record one screen per reusable-object family before you open anything in the new software: its intended equipment tag, its normal value at a known process state, and one command it must issue — that record is the acceptance baseline.
Take the baseline on the running 2018 system, not from memory. Back up the application, the SGC include file and their dependencies into a restorable state, and keep that copy separate from the migration copy. Then write down, for every reusable-object family the plant actually uses:
| What to record | Where it comes from | Why the migration needs it |
|---|---|---|
| One screen per object family, read-only and command objects | The running 2018 project | It becomes the acceptance sample |
| The intended equipment tag per object | Equipment substitutions on the pages | It is what the binding must resolve to after conversion |
| The normal value at a known process state | The live display or the controller | It is the number the trace must reproduce |
| Local edits inside the include file | The include file itself | It tells you what custom behavior must survive |
The value record matters more than it looks: after conversion, visual similarity proves nothing, and a plausible number on a wrong tag is the failure mode you cannot see.
How do you migrate the include file to Plant SCADA 2023? #
Run the vendor's documented project upgrade path — back up, convert with the migration tool, recompile, clear diagnostics, re-check bindings, then runtime-test — never a manual copy of files between versions.
- Back up the working Citect SCADA 2018 application, the SGC include file and their dependencies, and open a copy — never the original — in the target software.
- Install the target Plant SCADA version and read its documented project upgrade chapter, which covers moving an existing Citect SCADA or Plant SCADA installation to the 2023 release, before converting anything.
- Convert the project with the documented Project Migration Tool for that version, keeping the include file attached exactly as it was.
- Compile and clear every diagnostic: fix the dependency each message names — a detached include file, a changed path, a missing entry — before touching any library object.
- Compare the equipment bindings on your baseline screens against the record from the running 2018 system, especially where reused objects take equipment-specific substitutions.
- Run the runtime tests: reads first, then one command per object family under an arrangement that prevents the machine from acting on it.
Stand the migrated runtime on its own machine rather than sharing the production server — an industrial mini PC beside the controller is enough client for the acceptance run. A clean compilation is the gate to these runtime tests, not their substitute: references can compile while pointing at the wrong equipment, and only a live or simulated runtime shows that.
Why does a migrated screen open but show the wrong value? #
Because a screen that opens proves only that the graphics resolved; the value still crosses four layers — object binding, project tag, driver, controller address — and each layer can be wrong while the screen loads cleanly.
| What you see | Layer at fault | The deciding check |
|---|---|---|
| Object missing or blank | Include file and page dependencies | Does the referenced object exist, and does compilation resolve it? |
| One object shows another equipment's value | Object binding and equipment substitution | Does the resolved tag match the intended equipment tag? |
| Many objects on one connection show invalid data | Driver and controller communications | Read the same tags directly, independent of the graphics |
| Value looks right but the wrong device answers commands | Write binding and controller destination | Trace the command to the controller address it actually writes |
Reading the tags directly, off the graphics, is the same discipline described in reading M580 I/O in Plant SCADA without mapped memory addresses. When a whole connection goes stale at once, why HMI values show question marks during PLC comms timeouts is the layer to open first.
Worked example, illustrative numbers. Take one faceplate on a temperature loop. The project scales the tag 0–10 000 counts to 0–100.0 °C, and the controller holds 680 counts in the register this example calls %MW210. The arithmetic the display must reproduce: 680 ÷ 10 000 = 0.068, and 0.068 × 100.0 °C = 6.8 °C. The screen must read 6.8 °C. If it reads 680, the binding resolved to the raw tag instead of the scaled one — a binding fix, not a library replacement. If it reads 0.0 °C while a direct read of the same tag returns 680 counts, the fault sits in the driver or the connection, not in the migrated graphic. Use your own scaling constants and register numbers from the tag database; the method is the arithmetic, not these values.
How do you prove commands still reach the right controller address? #
Trace one command per object family end to end — button, write binding, tag, controller address — and observe the change at the controller address itself, because a write can succeed against a valid but unintended tag.
Exercise the command and watch the destination change at the controller, in the programming software or a diagnostics view, not on the screen that issued it. Writes that land nowhere without any visible error are a failure class of their own, covered in why a SCADA write to a PLC real address fails silently. Test commands only with the machine prevented from acting on them — outputs isolated or the controlled equipment in a verified safe state — so a wrong write proves the address without moving anything.
When is rebuilding a graphic faster than migrating it? #
Rebuild the individual object only when the diagnostics or the acceptance trace proves that object broken; the include file itself stays as the base, and wholesale replacement is not part of this migration path.
Rebuild triggers are concrete: a diagnostic that keeps naming one object after the configuration is intact, a binding that cannot be corrected by fixing the substitution, or a behavior the 2018 object cannot deliver on the target version. In each case replace that object and leave the include file in place for everything else — the migrated library remains the working foundation, and a per-object rebuild is contained work, while replacing the library wholesale restarts the entire acceptance effort you just finished.
Questions asked
Does converting the include file give me a newer library generation?
No. Conversion changes the project format so the content compiles and runs in the new version; it does not regenerate the graphics. The migrated objects stay the 2018 R2 generation, and the newest General Purpose release in the range, the 2024 V2, targets Control Expert V15.3 on the controller side rather than the SCADA side.
Can the migration run beside the live 2018 system?
Yes. Convert a copy, keep the original 2018 project and its runtime serving production, and run the migrated project on separate hardware pointed at a simulation or a test controller until the acceptance checks pass. Cutover is then a configuration change, not a rework of the screens.
What does an unresolved reference after conversion usually mean?
It usually means a configuration gap, not a library defect: the include file is detached from the application, its path entry changed, or the include list lost an entry during conversion. Reattach the include file and restore the path first; replace a library object only if the diagnostic still names that object once the configuration is intact.
Do Plant SCADA 2020 and 2023 need different migration steps?
No. Both targets use the same include-file path: back up, convert with the documented project upgrade procedure for that version, compile, clear diagnostics, re-check bindings, then runtime-test. The steps are identical; only the version-specific prerequisites in each upgrade chapter differ, so convert against the version you will actually run.