TIA Portal Tag Tables vs Data Blocks: S7-1500 Conversion from Allen-Bradley ControlLogix

Engineers migrating an established Logix Designer (RSLogix 5000 / Studio 5000) program into a Siemens SIMATIC S7-1200 or S7-1500 controller under TIA Portal v14 (or any newer v15-v20 release) immediately face a memory-organization decision that does not exist in the Allen-Bradley world: should every discrete and integer tag be declared in the PLC tag table or inside a global Data Block (DB)? The question is intensified by the desire to preserve exact tag names from the original Controller Tags scope so that downstream HMIs, drives, and SCADA retain their symbolic references after the cutover.

This reference consolidates the engineering guidelines, the S7-1500 firmware constraints, the differences in symbolic addressing, the upload-without-project behavior, and the step-by-step conversion method that produces a maintainable TIA Portal program. It applies to S7-1500 CPUs (CPU 1511, 1513, 1515, 1516, 1517, 1518) and S7-1200 CPUs (CPU 1211, 1212, 1214, 1215, 1217) on firmware V2.0 through V3.1, programmed with TIA Portal STEP 7 V14 SP1 through V20.

1. Memory Architecture: SIMATIC S7 vs Logix Designer

Before deciding between the tag table and a DB, the engineer must understand that Siemens and Allen-Bradley use opposite addressing philosophies at the most fundamental level.

From the table, the critical difference is that an Allen-Bradley Controller Tag is always a symbolic, structured object. In TIA Portal, a tag-table entry is a symbolic alias bound to a fixed absolute address (e.g. %MW100), while a DB member is a real variable inside an absolute-numbered data block. This single difference drives every best-practice decision below.

2. PLC Tag Table: Purpose, Layout, and Engineering Use

The PLC tag table is the place where you declare the symbolic name and absolute address for variables that do not belong to a structured data block: process image of inputs (%I), process image of outputs (%Q), bit memory (%M), and timer/counter word memory when relevant. It is a single project-wide table that can be split into sub-tables for clarity (e.g. Default tag table, I/O_Rack1, I/O_Rack2).

Per the TIA Portal Openness API documentation (which exposes the same model the editor uses), a tag table is a composition of PlcTag entries, each with a name, path, data type, address, and a comment. The Openness model treats the tag table as the canonical location for symbols that are not part of a DB.

2.1 When to Use the PLC Tag Table

• Process inputs (%I0.0, %IB0, %IW2) coming from the central rack or distributed I/O via PROFINET.
• Process outputs (%Q0.0, %QB4, %QW6) going to physical modules.
• Global bit/byte/word/double-word memory used as flags that span more than one organizational block (OB1 cyclic, OB35 cyclic interrupt, OB82 diagnostic, etc.).
• Constants and configuration words that you want to browse in the tag table for service engineers.
• HMI-visible status that you want to expose without opening a DB.

2.2 When NOT to Use the PLC Tag Table

• Variables that are part of a structured object (motor, valve, axis, recipe) — use a DB built from a PLC Data Type.
• Variables that need to be passed as InOut to many FBs — a DB member is addressable as "MyDB".MyMember with full type checking.
• Large arrays or structures — the tag table is a flat list and is awkward for arrays > 50 elements.
• Anything that must be retained across power cycles in a clearly grouped fashion — a DB can be set as Retain with one click; the tag table requires per-tag configuration.

2.3 Sample Default Tag Table Layout

3. Global Data Blocks: Purpose, Layout, and Engineering Use

A Data Block (DB) is a typed block of global memory that the CPU instantiates in load memory and, for optimized blocks, also in work memory with an internal symbol table. There are two fundamental flavors:

1. Global DBs (instance of PLC Data Type) — You create a new PLC Data Type, then create a DB based on that type. The DB is a single, named, structured container. This is the closest match to an Allen-Bradley UDT array of tags.
2. Global DBs (ad-hoc, no PLC Data Type) — You create a DB and add members directly in the DB editor. Useful for one-off structured data not part of a reusable type.

3.1 Optimized vs Non-Optimized Block Access

3.2 When to Use a Global DB

• Reusable structured data: Every motor, valve, axis, alarm, recipe row belongs to a DB derived from a PLC Data Type. This mirrors the way AOI instances work in Logix Designer.
• State machines and step logic — the entire state of a machine segment lives in one DB so the HMI can browse it.
• Interlocks shared across many FBs — a Plant_Interlocks DB can be read by 30 FBs without re-wiring symbolic names.
• Recipe data, production counters, batch records — large, structured, frequently retained.
• Bool flags that are part of a structured interface — e.g. Motor_Data[3].VFD_Fault is a Bool, but it is a member of a structured type, so it belongs in the DB, not in the tag table.

3.3 Sample Global DB Built From a PLC Data Type

Create a PLC Data Type named UDT_Motor with this structure:

TYPE "UDT_Motor"
VERSION : 0.1
  STRUCT
    Start_Cmd       : Bool;    // Operator start request
    Stop_Cmd        : Bool;    // Operator stop request
    Running         : Bool;    // VFD feedback: motor at speed
    Fault           : Bool;    // VFD feedback: faulted
    Fault_Ack       : Bool;    // HMI pushbutton: ack fault
    VFD_Enable      : Bool;    // Hard-wired safety OK
    Run_Time_Hr     : DInt;    // Total run hours
    Fault_Code      : Int;     // Last VFD fault number
    Speed_SP        : Real;    // Setpoint from HMI (Hz or RPM)
    Speed_PV        : Real;    // Feedback from VFD (Hz or RPM)
    Current         : Real;    // Motor current (A)
  END_STRUCT;
END_TYPE

Then create a DB DB_Motors based on this type, and add 16 array elements for 16 drives:

DATA_BLOCK "DB_Motors"
VERSION : 0.1
NON_RETAIN
  STRUCT
    Motor : Array[1..16] of "UDT_Motor";
  END_STRUCT;
END_DATA_BLOCK

Each motor can now be accessed symbolically as "DB_Motors".Motor[3].Running or "DB_Motors".Motor[3].Speed_PV, with full type checking in the editor. This is functionally identical to an Allen-Bradley Add-On Instruction with a UDT parameter and a controller tag array.

4. PLC Data Types: The UDT Replacement

The PLC Data Type (introduced in TIA Portal V12, hardened in V14) is the only clean way to map a Logix Designer UDT. It behaves like a C struct declaration that the S7-1500 CPU stores in load memory and that any DB can be built from.

Key facts:

• PLC Data Types live under PLC data types in the project tree, separate from DBs.
• A single PLC Data Type can be the template for many DBs.
• Nested structures are supported — a member can itself be of another PLC Data Type.
• Arrays of PLC Data Types are supported — e.g. Array[1..50] of "UDT_Motor".
• Strings up to 254 characters and DTL (date-time) are supported as native types.

5. The Bool Tag Question: Tag Table vs DB

Yes — it is correct to put Bool tags inside a DB. In fact, for any tag that is a member of a structured interface, putting it in the tag table would break the encapsulation of that interface. A Bool used as a global interlock flag with no structure may live in the tag table as a %M bit; a Bool that belongs to a motor (Motor[3].Fault) belongs in the DB.

Practical rules:

1. If the Bool is wired to a physical input or output, put it in the tag table.
2. If the Bool is the result of logic and is consumed by many FBs, put it in a DB.
3. If the Bool is a member of a structured UDT replacement, put it in the DB derived from that PLC Data Type.
4. If the Bool is a one-off global flag (e.g. First_Scan_On), put it in the tag table as a %M bit.

6. Symbolic Name Preservation Across the Conversion

The original poster’s goal of keeping AB tag names exact in TIA Portal is achievable for both the tag table and DBs, but with different mechanics.

7. Upload Without the Original Project: The Symbolic Name Loss Issue

When you upload an S7-1500 program from a CPU to TIA Portal without the original project (offline project), the symbolic names are not retained in their original form. The editor reconstructs the program from the compiled blocks in the CPU. The behavior depends on the upload mode:

• Upload from device (S7-1500): Symbol information is not uploaded. The project is reconstructed as a structure of blocks with absolute addresses and comments (if comments were written to the CPU — only in specific scenarios). Tag-table symbolic names are not present; only the absolute addresses (%MW100, %I0.0, etc.) survive.
• Upload of program blocks (S7-1500): If the project was downloaded as a “Know-how-protected” or compiled binary, the symbolic layer is stripped. You get FB/FC/DB numbers with anonymous variables.
• DB-based symbolic retention: If you use optimized DBs and download with the “Download to device” option that includes symbol information, TIA Portal embeds the symbol table in the CPU firmware backup area. After an upload from device, the symbols can be partially reconstructed, but cross-references and tag-table names are not guaranteed.

This is the most-cited disadvantage of relying on the tag table for symbolic lookups. The defensive engineering answer is to always keep the original TIA Portal project (and a versioned backup) on an engineering server. Treat the offline project as the single source of truth, not the CPU.

8. TIA Portal V14 Specifics and Later Version Improvements

If you are starting a new conversion in 2024-2026, the pragmatic choice is TIA Portal V18 or V20 with an S7-1500 CPU on firmware V2.9 or V3.1. The upload-fidelity of symbol information is materially better than V14 era builds, but the upload-without-project case is still lossy for tag-table symbols.

9. Step-by-Step Conversion Procedure: Logix Designer to TIA Portal V14+

9.1 Prerequisites

• Logix Designer project (L5X or ACD) backed up to a read-only location.
• TIA Portal V14 SP1 or later installed with the appropriate S7-1500 / S7-1200 support package.
• S7-1500 CPU on firmware V2.0+ (V2.6+ recommended for full V14 SP1 feature parity).
• A list of all UDTs and AOIs from the AB project. The TIA Portal equivalent is PLC Data Type + Function Block.
• A list of all Controller Tags and Program Tags with their data types and usage (I/O vs. internal vs. structure).

9.2 Conversion Procedure

1. Export the AB tag database. In Logix Designer, right-click Controller Tags → Export Tags. Save the CSV with columns Name,Type,Usage,Scope,Description.
2. Classify each tag. For every row, mark it as Physical I/O, UDT member, or Free global. This classification drives the destination in TIA Portal.
3. Create PLC Data Types for every AB UDT. In TIA Portal, expand PLC data types → Add new data type. Reproduce the AB UDT structure. For nested UDTs, define them in dependency order.
4. Create the physical I/O tag-table entries. Add a new sub-table under PLC tags for each rack. Insert one row per physical signal, with the exact AB tag name in the Name column and the corresponding %I/%Q address.
5. Create global DBs for structured data. For each UDT instance family, create a DB based on the relevant PLC Data Type. Use arrays of the PLC Data Type for repeating elements.
6. Create a global DB for ad-hoc internal logic. One DB per program unit (DB_Conveyor, DB_Reactor, DB_Packaging) keeps the watch window readable.
7. Convert AOI logic to FB logic. Each AB AOI becomes a TIA Portal FB. The AOI input/output parameters become FB Input/Output/InOut/Static declarations. Local tags become Temp.
8. Convert programs / routines. LAD in AB maps to LAD in TIA Portal; FBD maps to FBD; SFC maps to SFC (Graph). ST routines map to SCL FB/FC methods.
9. Replace [tag] references. In TIA Portal, every tag in a DB is accessed as "DB_Name".Member. Use the Find and replace function to translate AB tag names into the correct TIA Portal path.
10. Configure retain behavior. Mark every DB member that must survive a power cycle as Retain in the DB editor. Mark every M-bit that must survive as Retain in the tag-table retain column.
11. Compile and download. Use Compile » Software (rebuild all blocks). Resolve all warnings; warnings about “address is already used” indicate a duplicate %I/%Q/%M assignment that must be fixed before download.
12. Verify symbolic accessibility. From the Watch table, force each renamed tag and confirm the HMI can read it. Export the symbol table to CSV and diff against the AB export.

9.3 Verification Checklist

10. Field-Proven Patterns and Anti-Patterns

10.1 Do

• Use the tag table for physical I/O exclusively. This makes the rack layout obvious to the maintenance technician with a multimeter.
• Use a Default tag table split into Inputs, Outputs, Memory sub-tables for projects with > 200 signals.
• Use PLC Data Types + DBs for all application objects (motors, valves, axes, recipes, alarms).
• Use one DB per program area. Avoid one giant “Data” DB with 2000 members.
• Use the UserConstants tag table (introduced in V15.1) for named constants rather than scattering them across DBs.
• Expose DB members to OPC UA Companion Specs using the S7-1500 OPC UA server (firmware V2.1+).

10.2 Do Not

• Do not put UDT-like structured data in the tag table. The tag table has no concept of nested structure.
• Do not declare 8000 individual Bool tags in the tag table when they could be 100 DB members of a structured type.
• Do not use non-optimized DBs unless interfacing with an older HMI that requires fixed offsets. The non-optimized block disables the compiler’s ability to pack fields efficiently.
• Do not use absolute addressing (DB1.DBX0.0) in application code; always use the symbolic name. Absolute addressing is fragile to DB renumbering.
• Do not rely on upload-from-device for symbol information. Treat the CPU as an executor, not a documentation source.

11. Migration Tooling and Acceleration

Manual conversion of a 5,000-tag ControlLogix program is a multi-week effort. Several tools accelerate the bulk of the mechanical work:

• TIAPortal Openness API (C#, VB.NET, Python via pytia): Programmatically read a Logix Designer L5X export, generate PLC Data Types, generate DBs, and populate the tag table. The Openness API exposes PlcTagTableComposition, PlcTag, PlcDataType, and DataBlock objects, as documented in the TIA Portal v20 Openness reference.
• SIMATIC Migration Tool: Siemens provides a starter converter for S7-300/S7-400 to S7-1500, but it does not natively read Logix Designer ACD/L5X. Use it for the SIMATIC side only.
• Third-party L5X-to-TIA converters: Several integration houses sell “Logix to TIA” toolchains. Verify each result manually; do not trust the output blindly.
• Excel-based bridge: Export AB tags to CSV, transform in Excel (add columns for TIA name, TIA address, TIA DB path), then import via Openness or manually into the TIA Portal editors.

12. Frequently Asked Questions