WinCC OPC Tag to Internal Tag Copy: VBScript Methods

1. Problem Definition

WinCC runtime projects regularly need to mirror the value of an external OPC item into a local internal tag. The canonical case is a WinCC station that has been deployed for many years, where the source PLC/HMI system cannot be firmware-upgraded, the field bus topology cannot be changed, and the only available data path is the OPC DA (or OPC UA) subscription that is already in place. The engineer is then forced to bridge an external OPC tag into a tag that lives inside the WinCC tag database, so that the local HMI screens, scripts, archives, and alarms can reference it the same way they would reference any locally-defined tag.

This article documents the practical VBScript-based bridge patterns that work in WinCC V7.0 through V7.5 SP2, the configuration parameters that govern refresh cadence, the quality-code handling that prevents stale or bad values from contaminating internal tags, and the cross-platform equivalents that apply when the runtime is Ignition or Kepware/KEPServerEX instead of WinCC.

2. Architecture Decision Matrix

Two valid topologies exist. Choose before you write any code, because the choice dictates which machine runs the OPC stack, which side owns the tag database, and which direction the data flows.

Use Topology A when the remote system is fixed as the data source and the local WinCC project needs a local copy. Use Topology B when the remote system is the writer and WinCC is the canonical store. The remainder of this article focuses on Topology A, which is the case the original question describes.

3. Prerequisites

1. WinCC V7.0 SP3 or later installed with a valid runtime license. The VBScript global action engine requires the "WinCC Scripting" option to be enabled at install time.
2. An active OPC DA connection in the WinCC project. Verify in WinCC Explorer > Tag Management > OPC > [connection name] that the connection state is OK and that at least one OPC tag is returning a non-bad quality code.
3. The list of OPC tag names exactly as they appear in the WinCC tag database (case-sensitive). These follow the naming convention [OPC_ConnectionName]\GroupName\TagName when referenced by VBScript via the internal OPCServer.Namespace, or the plain tag name when referenced through the HMIRuntime object.
4. The destination internal tags must already exist in the WinCC tag database with the correct data type. A mismatch between the OPC source data type (e.g. VT_I4) and the internal tag type (e.g. 16-bit unsigned) is the single most common cause of runtime exceptions.
5. Editor rights on the WinCC project and write access to the runtime directory so that compiled C-actions (if used) can be rebuilt by Graphics Designer.

4. Configuring the OPC Channel in WinCC

Open WinCC Explorer > Tag Management and right-click OPC. Select Add New Connection and enter the ProgID or CLSID of the remote OPC DA 2.05 / 3.0 server. The most common values are:

After the connection is established, the WinCC tag browser shows the remote namespace. Drag the desired tags into the project tag list. Do not reference these tags from VBScript directly as if they were local tags — although WinCC does expose them, doing so couples the script to a single OPC topology. Always mirror them into a dedicated internal tag (Data Type = Binary Tag, no I/O address) and let the script read from / write to that internal tag.

5. VBScript Implementation

All examples below assume the following tag set exists in the WinCC project:

5.1 Unidirectional Mirror (Remote → Local)

This is the most common requirement: copy a handful of values from the remote OPC server into local internal tags once per second. Place the following VBScript into a Global Action triggered by a 1-second cyclic timer.

' === Global Action: gAct_OPCToInternal (cyclic, 1 s) ===
Option Explicit

Dim oSrc, oDst
Dim sErr

' --- Temperature (analog) ---
Set oSrc = HMIRuntime.Tags("OPC_Source_Temp")
Set oDst = HMIRuntime.Tags("Internal_Temp_Mirror")
oSrc.Read
If oSrc.Quality <> 0 Then
    ' Quality code 0 = Good. Anything else means stale or bad.
    ' Skip the write to avoid overwriting the last good value with garbage.
    sErr = "OPC_Source_Temp quality=" & oSrc.Quality
    HMIRuntime.Trace sErr
Else
    oDst.Value = CDbl(oSrc.Value)
    oDst.Write
End If

' --- State (digital/word) ---
Set oSrc = HMIRuntime.Tags("OPC_Source_State")
Set oDst = HMIRuntime.Tags("Internal_State_Mirror")
oSrc.Read
If oSrc.Quality = 0 Then
    oDst.Value = CLng(oSrc.Value) And &HFFFF&  ' mask to 16 bits
    oDst.Write
End If

5.2 Bidirectional Mirror with Edge Detection

For commands that must travel back to the remote system, use edge detection so the write fires exactly once per operator action. Polling the value every cycle would re-fire the command continuously as long as the operator held the button.

' === Global Action: gAct_InternalToOPC (cyclic, 500 ms) ===
Option Explicit

Dim oCmd, oPrev, oAck
Dim bRise

Set oCmd  = HMIRuntime.Tags("Internal_Cmd_Reset")
Set oPrev = HMIRuntime.Tags("Internal_Cmd_Reset_Prev")
Set oAck  = HMIRuntime.Tags("OPC_Dest_ResetAck")

oCmd.Read
oPrev.Read

' Rising-edge detection: 0 -> 1 transition
bRise = (oCmd.Value = 1) And (oPrev.Value = 0)

If bRise Then
    oAck.Value = 1
    oAck.Write         ' Write to remote OPC server
    ' Latch a one-shot acknowledgement back to the local mirror after 1 s
    HMIRuntime.Wait 1000
    oAck.Value = 0
    oAck.Write
End If

oPrev.Value = oCmd.Value
oPrev.Write

5.3 Centralized Mapping via a Dictionary

For more than a handful of tags, maintain a VBScript Scripting.Dictionary in a project module so the mapping is data-driven and easy to extend without editing every action.

' === Project Module: mod_OPCBridge ===
Option Explicit

Public Sub Bridge_OPC_To_Internal()
    Dim map, k, oSrc, oDst, v
    Set map = CreateObject("Scripting.Dictionary")
    map.Add "OPC_Source_Temp",      "Internal_Temp_Mirror"
    map.Add "OPC_Source_State",     "Internal_State_Mirror"
    map.Add "OPC_Source_Pressure",  "Internal_Pressure_Mirror"
    map.Add "OPC_Source_ValvePos",  "Internal_ValvePos_Mirror"

    For Each k In map.Keys
        Set oSrc = HMIRuntime.Tags(k)
        Set oDst = HMIRuntime.Tags(map(k))
        oSrc.Read
        If oSrc.Quality = 0 Then
            v = oSrc.Value
            ' Type coercion: WinCC returns Variants; force the right type
            Select Case oDst.TypeName
                Case "Float":     v = CDbl(v)
                Case "Integer":   v = CLng(v)
                Case "Bool":      v = CBool(v)
                Case "String":    v = CStr(v)
            End Select
            oDst.Value = v
            oDst.Write
        End If
    Next
End Sub

Call Bridge_OPC_To_Internal from a cyclic global action. Adding a new mirror is now a one-line change in the dictionary.

6. Cycle Selection and Performance Budget

The cycle at which the bridge action runs is the single most important performance parameter. Faster is not better — every cycle triggers one Read and one Write per tag pair, and each call carries an OPC DA round-trip in the order of 1–5 ms on a 100 Mbit/s LAN. A conservative budget is shown below.

7. Inline SVG: Data-Flow Topology

8. Trigger Mechanisms: Cyclic vs Event-Driven

By default, global actions are configured as cyclic on a fixed interval. For tag values that change infrequently, an event-driven trigger that fires only when the OPC value actually changes is far more efficient.

9. Cross-Platform Equivalents

When the runtime is not WinCC but an Ignition by Inductive Automation deployment, the same bridge can be implemented with much less code because Ignition natively differentiates between OPC items (direct references to the live PLC tag, no local copy) and tags (internal Ignition tags with optional OPC tag binding). If a true copy is required, the recommended approach in Ignition is a Tag History binding or an Expression tag with {[~]OPC/path/Tag} as the source expression. Drag-and-drop from the OPC Browser creates the tag in the Tag Browser window and preserves the binding automatically. See the Ignition 7.9 Browsing and Creating OPC Tags manual and the Creating OPC Tags Manually video for the canonical procedure.

For Kepware/KEPServerEX installations, the bridge can be implemented at the driver level using internal tags (sometimes called "advanced tags" or "client tags"). These tags live entirely inside the KEPServerEX process and are not visible in the server configuration, but they can be browsed by an OPC client and used as a way to hold a value computed from other tags. The KEPServerEX internal tags reference lists the special tag syntax used for this purpose.

10. Verification Procedure

After implementing the bridge, perform the following checks before declaring the work complete. Each step has an objective, the action to take, and the expected result.

1. Verify OPC subscription state. Open WinCC Explorer > Tag Management > OPC > [connection]. The connection state must be OK and the OPC tags must show a green indicator. Result: All OPC_* tags show a numeric value and a quality of Good.
2. Verify mirror values match. In the Graphics Designer, drop two I/O fields on a test picture, one bound to OPC_Source_Temp and one to Internal_Temp_Mirror. Force a value change at the source (e.g. write to the remote PLC). Result: Both fields update within one cycle (default 1 s) and show identical numeric values.
3. Verify quality gating. Disconnect the OPC connection by stopping the remote OPC server. Result: The OPC_* tag quality goes to BadComm and the Internal_* tag retains the last good value. The WinCC Trace log shows the quality message from the script.
4. Verify bidirectional write-back. Set Internal_Cmd_Reset to 1 from a test screen button. Result: The remote system's OPC_Dest_ResetAck tag transitions to 1 within the 500 ms cycle, holds for 1 second, then returns to 0. Check the remote HMI to confirm the acknowledgement was received.
5. Verify CPU load. Open Windows Task Manager > Details, sort by CPU, and observe CCWriteArchive.exe and CCExplorer.exe. Result: Combined CPU stays under 5 % during a 10-minute steady-state run.
6. Verify archive continuity. Open the WinCC Tag Logging editor and confirm the Internal_* tags are being archived. Result: No gaps in the archive timeline when the OPC source is healthy.

11. Troubleshooting Matrix

12. Field-Proven Caveats

• Always declare Option Explicit at the top of every global action. WinCC's VBScript interpreter will silently create Variant variables for undeclared names, masking typos that are otherwise hard to find.
• The HMIRuntime.Tags(...) object is a tag handle, not a value. Calling .Read populates .Value from the tag database. Calling .Write pushes .Value back. Forgetting .Read is the most common scripting bug.
• String tags have a maximum length of 256 characters in WinCC V7.x. If the OPC source is a longer string, truncate explicitly with Left(s, 256) before writing, or the write will throw a runtime exception.
• When the project is later migrated to WinCC Professional in TIA Portal, all VBScript global actions must be re-authored as C# scripts or as a Unified PC script. The VBScript surface is not carried over.
• For compliance with 21 CFR Part 11 or similar audit frameworks, the Write path of the bridge must be logged. WinCC's Audit option (separately licensed) records tag writes automatically; without it, an unauthorized Write into the internal tag will not leave a trace.

FAQ