Exporting SCL Blocks as XML with TIA Portal Openness API

Structured Control Language (SCL) is Siemens' high-level, Pascal-derived text language for S7-1200, S7-1500, S7-300/400, and WinAC controllers programmed in the TIA Portal. Engineers building MES connectors, PLCOpen-style cross-vendor pipelines, or SCM-driven code-management workflows routinely need an XML representation of SCL code rather than the raw .scl source. TIA Portal V15 introduced a documented XML export/import interface for SCL blocks through the TIA Portal Openness API, and Siemens has continued to refine that schema in subsequent releases up to V20.

This reference consolidates the supported export paths, the documented XML element structure, the differences between the Siemens-specific Openness XML and the vendor-neutral PLCOpen XML schema, and the practical limitations you will hit when wiring an XML pipeline against an S7 program.

1. SCL Export Options at a Glance

2. TIA Portal Openness API Prerequisites

The TIA Portal Openness API is a .NET-based automation interface that ships with the TIA Portal installation. It exposes the S7 program as a COM-visible object model.

1. Install TIA Portal V15 (or later; current documentation targets V20). Openness is selected during installation under “TIA Portal Openness”.
2. Add references to the Openness assemblies in your C# / VB.NET project:
   • Siemens.Engineering.dll
   • Siemens.Engineering.Hmi.dll (HMI blocks)
   • Siemens.Engineering.SW.dll (PLC software)
3. Target .NET Framework 4.8 (V18+ supports .NET 6 / .NET 8 side-by-side assemblies; check the release notes for the exact TIA version in use).
4. Run the host process as the same Windows user that opened TIA Portal, or launch TIA Portal in headless mode from the Openness application via MyTiaPortal.StartWithoutGui() (V17+).
5. Disable “Automatic program save” prompts or handle the TiaPortalMode returned by GetCurrentProcess() explicitly.

The official TIA Portal Openness API documentation is published at the Siemens documentation portal, including the V20 reference page for TIA Portal Openness. For SCL-specific block import/export see Export/Import of SCL call blocks.

3. Exporting an SCL Block to XML

The SCL body is exposed through the PlcBlock / PlcCodeBlock types. The XML serialisation is invoked through Export() on a block instance.

// C# / .NET 6 snippet - TIA Portal Openness V20
using Siemens.Engineering;
using Siemens.Engineering.SW;
using Siemens.Engineering.SW.Blocks;

TiaPortal tia = new TiaPortal(new TiaPortalProcessArguments());
Project project = tia.Projects.Open(new FileInfo(@"C:\Projects\Line01.ap18"));

foreach (Device device in project.Devices)
{
    PlcSoftware plc = device.GetService<PlcSoftware>();
    if (plc == null) continue;

    foreach (PlcBlock block in plc.BlockGroup.Blocks)
    {
        if (block is PlcCodeBlock codeBlock && codeBlock.ProgrammingLanguage == ProgrammingLanguage.SCL)
        {
            FileInfo xmlFile = new FileInfo($"C:\\Export\\{codeBlock.Name}.xml");
            codeBlock.Export(xmlFile, ExportOptions.WithDefaults);
            Console.WriteLine($"Exported {codeBlock.Name} -> {xmlFile.FullName}");
        }
    }
}

Calling Export() with a .xml target extension triggers the Openness XML serializer. The resulting file is well-formed XML, namespace-qualified, and includes the block interface, the SCL statement body, and the SCL-specific metadata (compile time, author, version). The opposite path — Import() — accepts the same schema and recreates the block inside the project tree.

4. Documented XML Schema for SCL Blocks

The Openness XML is a Siemens-internal schema, not PLCOpen TC6. The V20 documentation describes the following key element types (refer to the official page for the full XSD):

A literal string in SCL is serialised as shown below (this is the canonical example Siemens publishes):

#myString := 'Hello world';   // SCL source

<Access Scope="LocalVariable">
  <Symbol>
    <Component Name="myString" />
  </Symbol>
  <Access>
    <Constant>
      <ConstantValue>Hello world</ConstantValue>
      <ConstantType Informative="true">STRING</ConstantType>
    </Constant>
  </Access>
</Access>

The Informative="true" flag on ConstantType tells the importer that the type was added by the serializer for round-trip safety, not declared explicitly in the original SCL. Round-trip tooling should strip or re-attribute such nodes before re-emitting SCL.

5. Round-Trip Behaviour: What XML Export Does Not Preserve

Openness XML export is sufficient for inspection, version control, and MES metadata exchange. It is not a lossless representation of the project. Documented limitations include:

• Comments (// and (* ... *)) are preserved as text nodes inside the statement list, but comment placement relative to statements may shift.
• Block attributes such as {S7_optimized_DB_access := 'TRUE'} are exported but must be re-applied through the PlcBlockAttribute collection on import.
• Multi-instance declarations inside FBs round-trip, but the instance DB name is regenerated by TIA Portal on import.
• Know-how-protected blocks cannot be exported in XML. Openness throws EngineeringTargetInvocationException with the inner exception Siemens.Engineering.EngineeringSecurityException.
• Library-derived types (master copies from a global library) are referenced by symbolic name; the receiving project must have the same library version installed.
• Hardware identifiers (HW ID, channel names, slot numbers) belong to the device configuration, not the SCL block, and are not included.

6. PLCOpen XML (IEC 61131-10) — The Vendor-Neutral Alternative

PLCOpen XML is the vendor-neutral exchange format defined by PLCopen Technical Committee 6 and adopted as IEC 61131-10. It is the format Beckhoff exports from TwinCAT through the Automation Interface, and it is the de-facto interchange format between CODESYS-based tools and third-party editors.

TIA Portal does not natively import or export PLCOpen XML. Engineers targeting a vendor-neutral pipeline either (a) translate the Siemens Openness XML to PLCOpen XML through a custom XSLT or code generator, or (b) maintain a parallel SCL source tree that is checked in alongside the project and processed by a build server using Openness. Option (b) is the path Siemens’ own Continuous Integration demo for TIA Portal V18+ takes.

7. MES Integration via XML (Siemens UADM / UAPI)

Siemens MES offerings — notably the UADM (Unified Automation Data Management) and UAPI (Unified Automation Programming Interface) modules of Opcenter Execution / SIMATIC IT — use XML as their primary payload for recipe, tag, and code metadata exchange. The Openness XML export fits directly into a UADM “code sync” workflow:

1. TIA Portal Openness exports the SCL block(s) as XML files into a watched folder.
2. UADM ingests the XML, validates against its internal schema, and stores the block definition under a versioned artefact key.
3. On a production release, UADM — or a downstream UAPI call — pushes the XML back into TIA Portal Openness, which imports it into the receiving project.
4. Compile, download, and HMI tag generation run in the headless TIA Portal instance.

For brownfield projects where the SCL code already lives in a Siemens library, you can shortcut this by exporting .scl text files and wrapping them in a minimal XML envelope matching the UADM contract. This avoids invoking the full Openness V15 dependency on every CI run.

8. Version Control and XML — Field Reality

Git and Subversion merge tools handle line-based text well but produce noisy diffs on XML. Three patterns are used in production CI pipelines for TIA Portal projects:

For pattern B, the recommended Git merge driver is a small XSLT that canonicalises the Openness XML (attribute order, namespace prefixes, whitespace) before storing the blob. The Siemens Continuous Integration (CI) sample on GitHub uses a similar approach with the tia-portal-openness Docker image for V18+.

9. Supported Versions and Known Issues

Common error codes returned during XML export/import via Openness:

10. Verification Checklist

After an XML export/import cycle, validate with the following checks:

1. Open the receiving project in TIA Portal; verify the block appears in the project tree with the same name and number.
2. Open the block in the SCL editor; confirm the code body compiles without errors (Compile → Software (rebuild all)).
3. Diff the XML <StatementList> element against the source — only the Informative="true" nodes should differ on a clean round trip.
4. Compare the block interface (inputs, outputs, in-outs, stat, temp) against the source block using Project tree → Properties → Interface.
5. Run the project through the TIA Portal Check consistency command to catch any cross-block reference breaks (UDTs, FB multi-instances, GVLs).
6. If the block is part of a program download, trigger a Download to device simulation to confirm the compiled block is accepted by the S7-PLCSIM instance.

11. Practical Recommendations

• Default to .scl for SCM. Use plain SCL text for day-to-day version control. Reserve the Openness XML for tool integration, MES sync, and ad-hoc inspection.
• Lock the Openness version. The XML schema evolves. Pin a specific TIA Portal version (e.g., V20) on every CI job and reject cross-version XML diffs to keep the build green.
• Validate before import. Run the XML through xmllint --schema tia-openness.xsd with the official XSD (V20 schema is shipped with the Openness installer under Siemens\Automation\Portal V20\Openness\Schemas) before pushing it back into TIA Portal.
• Don't reinvent PLCOpen. If the goal is vendor-neutral exchange, generate PLCOpen XML from the Openness XML using an XSLT rather than maintaining two parallel code-bases.
• Watch know-how protection. Add a pre-export check that skips any block with BlockProtection.PlcBlockProtectionAttribute set, and log the skip with the block path so audit trails stay complete.
• Mind the WinCC / HMI coupling. If the SCL block is referenced from an HMI tag list, re-export the .xlsx tag table after the import to keep the HMI in sync.

12. Reference Summary