SCADA / HMI · Module

UDT Converter

Convert a Rockwell L5X UDT into Ignition UDT JSON. OPC item paths, parameter expansion, and extra Ignition fields configured per conversion.

Free tier Updated May 11, 2026 5 min read
L5X → JSON
Conversion direction
~2 min
Per UDT, end to end
Free tier
Available
The 2-minute path

These four steps produce an L5X ready for Studio 5000 import. The full guide below covers every option in detail.

  1. 1 Upload · An L5X with one or more UDT definitions.
  2. 2 Configure · OPC path, parameters, and extra fields.
  3. 3 Convert · Run the conversion. Preview the JSON inline.
  4. 4 Import · Into Ignition Designer via Import Tags.

Overview

UDT Converter takes a Rockwell L5X with one or more DataType definitions and produces an Ignition UDT JSON ready for import into Designer. Member data types are mapped automatically, OPC item paths are built from a configurable pattern, and per-member metadata carried into Ignition (descriptions, alarm fields, custom strings) is configured through the Extra Fields editor.

Use it when you maintain matching PLC and SCADA tag structures and want to keep them in sync without a manual spreadsheet step.

Direction. Today the module converts L5X to Ignition JSON. The reverse direction (JSON → L5X) is on the roadmap

Step 1. Upload your source UDT

Drop an .l5x file into the upload panel, or pick a previously saved session from the Load Saved list. The L5X can be a UDT-only export, an AOI export that defines UDTs, or a program-level export. Anything containing DataType elements.

PLCflow parses the file and shows every UDT it found in an expandable list. Each panel exposes the member table: name, data type, and description. Confirm that the members and types look right before moving on.

The page header shows a PLC (L5X) badge once a file is uploaded, indicating the conversion direction for this session.

Step 2. Configure the conversion

The Conversion Settings panel has three controls:

OPC Item Path

The template PLCflow uses to build the opcItemPath on each Ignition UDT member. The default pattern is [Default]{tagName}, where [Default] is your Ignition OPC connection name and any {placeholder} in the path becomes a UDT parameter that the consumer fills in per instance.

Examples:

[PLC]{InstanceName}.{paramName}    ← {InstanceName} is auto-injected; one path per member
[PLC]Program:Main.{InstanceName}   ← Tag lives inside a Program
[PLC]{InstanceName}                ← Path resolves at the parent UDT level

{InstanceName} is a built-in token that resolves to the UDT instance’s name at import time in Ignition. Any other {placeholder} is auto-detected and surfaced under Parameters.

Parameters

Parameters from the OPC path are pulled into the Parameters table automatically. For each one you can set:

  • Data Type. String, Boolean, Integer, Int16, Int32, Float32, Float64.
  • Type. memory (default value baked into the UDT definition) or parameter (filled per instance with the {name} placeholder).
  • Default Value. The initial value, or for parameter type the placeholder Ignition asks the importer to fill.

Add custom parameters by clicking Add Parameter if you want extras Ignition exposes that the L5X doesn’t drive.

Extra Fields

Any additional Ignition tag attribute you want on every member. Each row has:

  • Field Name. The Ignition attribute (e.g. tooltip, documentation).
  • Data Type. String, Boolean, Int16, Int32, Float32, Float64.
  • Value Type. memory (literal), opc (read from an OPC binding), or expr (Ignition expression).
  • Value. The literal, OPC path, or expression. Supports {description} token to pull the per-member description from the L5X.

This is how you carry e.g. the L5X member description into Ignition tooltips, or wire member-level OPC bindings to a different gateway path than the parent UDT.

Step 3. Convert

Click Convert. PLCflow:

  1. Maps each Rockwell type to the Ignition equivalent (BOOL→Boolean, DINT→Int32, REAL→Float32, etc.).
  2. Substitutes parameters and Extra Fields into every member.
  3. Bundles the converted UDTs into a single JSON file named udt_converted_ignition_<date>.json.

The File Preview pane shows the generated JSON inline with a per-file Copy button, useful for sanity-checking the OPC paths and parameter values before download.

Step 4. Import into Ignition

In Ignition Designer:

  1. Open the Tag Browser.
  2. Right-click the destination tag folder (commonly the UDT Definitions area).
  3. Import Tags, then pick the converted JSON.

Ignition imports the UDT definitions. Creating instances is a separate step. See the UDT Generator module if you need to batch-create instances from a definition.

Saving and reloading

Save stores the current uploaded UDTs and conversion settings under a name. Load brings any saved session back. Useful for reusing the same OPC pattern + Extra Fields across multiple UDT conversions.

Common pitfalls

  • [PLC] prefix doesn’t match the Ignition Gateway. The OPC item paths embed your connection name. If your Gateway connection is [GW1] and your path is [PLC]…, every tag imports with bad quality. Match the connection name exactly.
  • Auto-detected parameter has the wrong data type. Default for new parameters is String. Change it to Float32 or Int32 if the value should be numeric, or Ignition treats it as a string at import.
  • Member with a custom data type imports as String. Rockwell allows ALARM, MESSAGE, and nested-UDT members that have no direct Ignition equivalent. PLCflow falls back to String for unmapped types and flags it in the console. Override the member type or strip the unsupported member before converting.
  • L5X references a nested UDT that isn’t in the upload. PLCflow has no way to resolve the nested type. Convert both UDTs in one upload, or include their definitions in the same L5X.
  • Conversion saved but the next session has a different OPC pattern. Save sessions are per-UDT-set. Reusing a pattern across different uploads means re-saving (or just loading the previous session and re-uploading the new L5X).

FAQ

Can I convert Ignition JSON back to L5X?

Not via the UI today. The parser supports it but the JSON intake isn’t exposed yet. If this is blocking you, drop us a line at [email protected].

Do I need an Ignition Gateway running to use this?

No. The module produces an importable JSON file. You only need Ignition Designer to import it.

What if the L5X has multiple UDTs that share members?

PLCflow converts each UDT independently. Shared members come through with the same OPC pattern and Extra Fields on each parent UDT. The resulting JSON includes one UDT definition per source UDT.

What's the difference between Parameters and Extra Fields?

Parameters drive the OPC item path. They’re tokens like {paramName} that Ignition fills per instance. Extra Fields add Ignition attributes to every member (descriptions, expression bindings, tooltips). Different roles; both surfaces side-by-side in the settings panel.

  • Tag Database. Holds the tag catalog that drives the same UDT structures you convert here. Single source of truth for tag → UDT mappings across PLC and SCADA.
  • I/O Code. The L5X you converted into Ignition is the same UDT your I/O Code rungs reference on the PLC side.
What's next

Related modules

Tag Database

Library of reusable device, alarm, and parameter definitions. Tags defined here can be pulled into any code generation module via Import from DB.

I/O Code

Generate a Studio 5000 routine from an I/O list. Upload a spreadsheet, paste from one, or add rows by hand. Output is an importable L5X with tags, UDTs, and AOIs bundled in.

Was this helpful?

Honest feedback. We read all of it.

Email support Talk to an engineer

Try UDT Converter on real data

Free tier, no credit card. Bring a real spreadsheet, see what comes out.

Open UDT Converter