Page History

Key Concepts and Terms

Tag

A process variable representing real-time and historical data, created locally or accessed remotely.

Asset Tree

A hierarchical representation of the solution data, containing variables and DataTemplates that match sensor readings, physical equipment, setpoints, recipes, management data, and all the variables necessary to implement and operate an application.

DataTemplate (UDT)

A user-defined data structure that includes variables and references to other templates, creating a hierarchical data structure.

TagProvider Connection

Enables direct interaction with variables in remote systems without creating specific tags, enhancing data access within the Unified Namespace.

Enumeration

Defines potential values or ranges for a variable, mapping messages and colors to each state.

Runtime Database

An in-memory real-time database for Unified Namespace data, ensuring efficient data management during solution execution.

UNS →  Tutorial | Concept | How-to Guide | ISA-95 | Reference

Configuration Workflow

Typical Process

1. Create DataTemplates - Define reusable structures
2. Create Tags and Folders - Organize data hierarchy
3. Configure TagProviders - Connect external sources
4. Build Asset Tree - Model physical/logical structure

Quick Actions

Core Components

DataTemplates

Create custom data types:

• Reusable structures
• Hierarchical organization
• Property inheritance
• Consistent modeling

Tags

Real-time variables with:

• Multiple data types
• Arrays support
• Retentive options
• Security settings

Enumerations

Value-to-text mappings:

0 → "Off"
1 → "On"
2 → "Fault"

TagProviders

External connections:

• OPC UA, MQTT
• Historian systems
• Other solutions
• Dynamic discovery

Runtime Architecture

Execution Model

At startup, the UNS loads

Configuring the Unified Namespace

Configuration Workflow

The Unified Namespace’s Asset Tree is where you build your data definitions. From this central point, you can create or import tags, organize the hierarchy, and monitor the current values of your variables.

When you start a new solution, the Asset Tree includes a built-in “RootTags” folder for all root-level tags, improving visualization for large tag sets.

Typical configuration process:

1. Creating DataTemplates: Define reusable tag data structures.
2. Creating Tags and AssetFolders: Organizing your data.
3. Creating TagProviders: Add links to folders for external data.

Editing the AssetTree

• Create a new folder: Organize and group assets using the new Asset Folder icon Image Removed or right-click menu from the Root or parent node.
• Create new Tags: Select a folder and use the New Tag toolbar Image Removed button or right-click menu.
• Move Tags: Drag tags to the desired folder.
• Create TagProviders: Use the toolbar icon New TagProvider Image Removed or the menu command File > New > TagProvider Connection.
• Link Remote Data: Right-click a folder and use the context menu command "Link Data from TagProvider", or use the toolbar iconImage Removed.

→ Read more about Asset Tree.

Defining DataTemplates

DataTemplates allow you to create custom data structures for reusable tag configurations, streamlining data management and improving system efficiency by defining hierarchical structures that represent assets or information models.

→ Read more about DataTemplates.

Defining Tags

The page Unified Namespace / Tags allows you to:

• Create, modify, and delete tag objects.

• Use built-in tools for search and filtering.

• Bulk-edit.

→ Read more about Tags.

Defining Enumerations

Enumerations are sets of named integer values representing discrete options or states, improving code readability and reducing errors. For example, a pump’s states like “Off”, “On”, and “Fault” with values 0, 1, and 2.

To Create Enumerations

1. Go to Unified Namespace / Enumeration.
2. Click ‘New’ on the grid toolbar.
3. Open the ‘Create New Enumeration’ pop-up window.
4. Enter the name of the enumeration and click ‘OK’.
5. Add properties to the enumeration set, such as ‘On’ and ‘Off’ with default values.

→ Read more about Enumerations.

Using TagProvider Connections

To incorporate data from TagProviders into the Asset Tree:

1. Select or create an AssetFolder.
2. Right-click the folder and execute the command “Link Data from TagProvider”.

The Unified Namespace / TagProvider Connections page allows reviewing the list of defined TagProviders or browsing external data contents.

→ Read more about TagProviders.

Working with the Unified Namespace

Runtime Execution

into an in-memory real-time database

(TServer.exe

Accessing Assets in Scripts and Expressions

Modules like Alarms and Displays can access any variable from the Unified Namespace using its full name or path. For example, to access a tag when creating an operator display, use “Tag” to access available tags. A property called “Temperature” from a template tag named “Machine1” would have the full path: Tag.Machine1.Temperature.

You can also access values using the Asset() method syntax. For example, if you place the tag defined in the previous example inside a folder called Line1, the path for that value would be:

):

• Event-driven updates
• Module data exchange
• Real-time synchronization
• Optimized performance

Data Access Methods

Direct Tag Access:

csharp

@Tag.Machine1.Temperature
@Tag.Line1/Pump1/Status

Asset() Function:

csharp

Asset("/Line1/Machine1.Temperature")

Asset(@Client.Context.AssetPath + "/Status")

Asset Tree Structure

Organization Examples

By Location:

/Plant
  /Area1
    /Line1
      /Machine1
        Temperature
        Pressure
        Status

By Function:

/Production
  /Mixing
  /Packaging
/Utilities
  /Power
  /Water

Integration Points

Module Access

All modules can access UNS data:

• Displays - Visualization
• Alarms - Event monitoring
• Historian - Data logging
• Scripts - Logic execution
• Reports - Data presentation

External Systems

TagProviders enable:

• Protocol integration
• Historian connections
• Database links
• API interfaces

Common Issues and Solutions

Recursive Data Model Crash

Issue: Templates containing circular references Solution: Avoid recursive structures; validate template hierarchy

Missing External Data

Issue: TagProvider data not updating Solution:

• Verify connection status
• Check external system
• Review security settings
• Monitor network connectivity

Import Inconsistencies

Issue: Data missing after import Solution:

• Validate file format
• Check column mapping
• Verify data types
• Review import logs

Performance Issues

Issue: Slow data updates Solution:

• Optimize tag count
• Review update rates
• Check network latency
• Monitor resource usage

Namespace Properties

Access runtime properties:

csharp

// Tag count
int tagCount = @Info.Model.TagCount;

// Check if tag exists
bool exists = @Info.Model.HasTag("Machine1.Temperature");

// Get tag reference
var tag = @Info.Model.GetTag("Machine1.Temperature");

Security Considerations

Tag Security

• Read/Write permissions per tag
• User group restrictions
• Visibility settings (Private/Protected/Public)

Connection Security

• TagProvider authentication
• Encrypted communications
• Certificate validation

Performance Optimization

Design Guidelines

• Limit hierarchy depth (3-5 levels)
• Group related tags
• Use templates efficiently
• Optimize polling rates

Runtime Tips

• Monitor memory usage
• Check update frequencies
• Review connection counts
• Optimize queries

Best Practices Checklist

Data Structure Organization

•  Plan hierarchy - Consider relationships carefully
•  Use templates - Reduce redundancy
•  Clear naming - Consistent conventions
•  Logical folders - Intuitive navigation
•  Document structure - Maintain documentation

System Monitoring

•  Add displays - Monitor performance
•  Implement alarms - Critical connections
•  Track status - Connection health
•  Log events - Audit trail

Troubleshooting

Connection Issues

• Check network connectivity
• Verify credentials
• Review firewall settings
• Test with simple query

Data Quality

• Check Quality property (192 = good)
• Verify timestamps
• Review error messages
• Monitor communication logs

Performance

• Check CPU/memory usage
• Review tag count
• Optimize update rates
• Monitor network traffic

In this section...

Best Practices and Recommendations

To maximize the benefits of the Unified Namespace, follow these best practices:

Organization of the Data Structure

• Organize tags into a clear hierarchy with folders and templates for easier navigation and understanding.
• Plan data structures carefully, considering the relationships between assets, tags, and templates.
• Use templates for reusable data structures, reducing redundancy.
• Seamlessly integrate external data sources using TagProviders.
• Use consistent naming conventions for tags to simplify navigation and troubleshooting.

Status Monitoring 

• Add specific displays and scripts to regularly monitor system performance and connection status.
• Implement alarm conditions for critical connection losses.

Common Issues and Solutions

Some common issues while working with the Unified Namespace include:

Crash when using recursive data model

• Make sure you're not using recursive Data Models - for example, a template which contains another template that contains another template etc. This may cause the system to overload and crash.

Inconsistency or Missing Data from External Systems:

• Ensure that the external application maintains the Unified Namespace, including variable names and structure.
• Refer to the UNS TagProviders Connections section for diagnosing connection issues.
• For device communication drivers, the tag name will always display correctly in the Unified Namespace, but its value depends on the connection with the remote device.
• Refer to the Devices (Field Communication) section in the documentation for setup and diagnostic information.
• This applies to any external data source, such as remote SQL databases or custom scripting using external APIs.

Inconsistency or Missing Data After Importing:

• Ensure that import files (Excel, CSV, etc.) are properly formatted with the required columns and compatible data types.

In this section: