WinCC OLE DB Provider: Writing to Tag and Alarm Archives via ODK

Overview

The Siemens WinCC OLE DB Provider exposes runtime archive data to external OLE DB consumers such as Excel, SQL Server Reporting Services, .NET applications, and third-party historians. A frequent field requirement is the inverse: pushing records that originated in a non-WinCC database back into WinCC while preserving the source timestamp. The WinCC OLE DB Provider does not support writes; archive segments are opened in read-only mode by design to protect archive integrity, license metering, and the swap-out buffer. This reference documents the supported write paths: the Open Development Kit (ODK) function TLGInsertArchiveData for tag logging, and the WinCC user-defined operator input message (SFM/operator message) mechanism for alarm logging, including parameter syntax, licensing, performance envelopes, and verification steps.

WinCC OLE DB Provider Architecture and Read-Only Constraint

The WinCC OLE DB Provider is implemented as an OLE DB 2.x-compliant data source and is registered on the WinCC server and WinCC client during installation. Connection strings use the form Provider=WinCCOLEDBProvider.1;Catalog=CC_<ProjectName>_<TimeStamp>;Data Source=<ServerName>\WinCC. The catalog suffix encodes the project runtime identifier.

Internally the provider opens archive database files (Microsoft SQL Server or the WinCC file-based archive) with the minimum access rights required to read segments from the swap buffer. The SQL parser rejects INSERT, UPDATE, and DELETE statements on the views dbo.TAG_EX and dbo.ALG_EX and returns HRESULT 0x80040E14 (DB_E_NOTSUPPORTED) on a non-SELECT statement. The design rationale is twofold: archive segments are circular, compressed, and indexed in a way that external writes would corrupt the swap buffer, and WinCC licensing meters the number of archive tags and message classes; external writes would bypass this metering.

Supported Write Paths

Siemens documents exactly two production-safe paths to insert externally generated records into WinCC archives:

1. Tag Logging via ODK function TLGInsertArchiveData — inserts a single value with explicit time stamp, quality code, and process value flags into a configured tag logging archive.
2. Alarm Logging via user-defined operator input messages — generates a WinCC message (information/error) with a freely defined message text and process value block. Timestamps are stamped by WinCC at the moment of generation, not by the calling script; for back-dated alarm entries, use the ODK MSRTGetMsg/MSRTGetMsgCRC family and the msrtx.dll low-level interface.

ODK Function Reference: TLGInsertArchiveData

The function prototype is declared in tlgbase.h (C/C++ ODK) and exposed in the C-style ODK DLL tlgproxy.dll:

BOOL TLGInsertArchiveData(
  LPCTSTR lpszTagName,
  LPCTSTR lpszArchiveName,
  LPCTSTR lpszTimeStamp,
  DWORD   dwFlags,
  VARIANT vValue,
  DWORD   dwQualityCode,
  DWORD   dwSQLState,
  LPCTSTR lpszUser,
  LPCTSTR lpszComment
);

Return value: non-zero on success, zero on failure. On failure, call TLGGetLastError for the text description.

Calling TLGInsertArchiveData from VBScript (C-Script in WinCC)

Because VBScript cannot bind to the C-style export directly, the recommended deployment uses a C function in the WinCC Global Script project that wraps the ODK call and is then exposed via a screen or background script. A minimal wrapper looks as follows:

// File: InsertTagValue.c (WinCC Global Script, action triggered)
#include "apdefap.h"
void InsertValue(char* tag, char* archive, char* ts, double val)
{
    VARIANT v;
    VariantInit(&v);
    v.vt = VT_R8;
    v.dblVal = val;
    BOOL rc = TLGInsertArchiveData(tag, archive, ts,
        0x04,           // manual entry flag
        v,
        0xC0,           // quality good
        0,
        "OPCBRIDGE",
        "Imported from external DB");
    VariantClear(&v);
    if(!rc) {
        char buf[256];
        TLGGetLastError(buf, 256);
        printf("TLGInsertArchiveData failed: %s\r\n", buf);
    }
}

Call from a C action in the WinCC Global Script editor. C# / .NET callers must use P/Invoke against tlgproxy.dll; the WinCC V7.5 ODK ships a managed wrapper Siemens.Engineering.WinCC.ODK.dll that exposes TagLogging.InsertArchiveData(...).

Importing External Data with Original Timestamps

The canonical use case is to load records from a legacy or non-WinCC database (e.g. an Oracle historian or a third-party SQL Anywhere) and replay them into WinCC with the source timestamp. Build a one-shot C action that loops over a SELECT result set and calls TLGInsertArchiveData per row. The loop body:

1. Read timestamp, value, quality from the external ODBC connection (use SQLExecute from odbc32.dll or a managed OdbcConnection).
2. Format the timestamp into YYYY-MM-DD HH:MM:SS.mmm.
3. Call TLGInsertArchiveData with dwFlags = 0x04 (manual entry) to flag the record in the archive.
4. Commit every 1000 records by calling TLGFlushArchive (if available in the build) or by closing and re-opening the archive handle to release the swap-buffer batch.

Performance scales roughly linearly with archive tag count. Empirical numbers from a V7.4 SP1 project on Windows Server 2016, 8 GB RAM, SSD:

User-Defined Operator Input Messages for Alarm Logging

For alarm logging there is no equivalent of TLGInsertArchiveData that takes a free-form timestamp. The supported path is the operator input message (SFM/Bedienmeldung) which stamps the current time at the moment of API call. The process is documented in Siemens FAQ 24325381.

From VBScript in a WinCC picture or Global Script:

Dim sMsgText
sMsgText = "External DB: pump P-101 trip @ " & Now
HMIRuntime.Alarm.CreateOperatorInputMsg 1, sMsgText

The first parameter is the message class number configured in the Alarm Logging editor (default classes 1-16 are system-reserved; user-defined classes start at 17). The timestamp is set to "now" by the message subsystem and cannot be back-dated. If a historical timestamp is required (e.g. for an audit trail of events that happened offline), use the ODK low-level function MSRTCreateMsgEx from msrtx.dll which accepts a SYSTEMTIME parameter.

Alternative: Direct SQL INSERT Against the Archive Database

Direct INSERT into the archive tables dbo.TA_<archive> is technically possible on a stopped WinCC runtime with a SQL Server archive, but it is not supported by Siemens. The archive schema is subject to change between WinCC versions (V7.3 -> V7.4 added the Flags column; V7.5 changed the swap-buffer format), and direct SQL bypasses the licensing counter, the dual-storage replication, and the integrity checks. If the ODK path cannot be used, the recommended enterprise alternative is to install WinCC Connectivity Station and write to a parallel "passive" archive that is mirrored to the live runtime by a scheduled SQL job.

Verification Steps After a TLGInsertArchiveData Import

1. Open WinCC Tag Logging editor and confirm the tag is enabled in the target archive.
2. Trigger a one-row import; verify the row appears in dbo.TA_<archive> by running SELECT TOP 1 * FROM dbo.TA_<archive> ORDER BY Timestamp DESC in SQL Server Management Studio against the archive database.
3. In WinCC Online Trend Control, place a trend on the tag, set the time range to the imported interval, and confirm the marker renders at the correct x-axis position. The 0x04 "manual entry" flag should also display a distinct color in the trend legend if the visualization plugin is configured to honor it.
4. Run DBANZEIG (or the WinCC Archive Connector) to ensure the count of inserted rows matches the count returned by the external source query.
5. Check the Windows Application event log for ODK warnings (source "WinCC ODK", event id 101/102).

Troubleshooting Matrix

Performance Hard Limits and Sizing

There is no fixed "row per second" ceiling enforced by the ODK; the bottleneck is dominated by the SQL Server write throughput and the swap-buffer flushing interval (default 1 s). For sizing purposes, model the import as a write workload of 8 bytes/record overhead plus the payload of each VARIANT. A 1 M-row import of double values therefore requires approximately 1 M * (8 + 8 + timestamp + user + comment) ~= 80 MB of archive growth. Plan disk accordingly: a single SQL Server instance can host 2-4 GB/s of write throughput to a striped LUN, so 1 M rows is dominated by ODK call overhead, not by the disk.

Concurrent reads through the OLE DB Provider during a heavy import will see latency spikes of 200-500 ms at each swap-flush. If the human-machine interface (HMI) is reading the same archive, consider pausing the OLE DB polling or routing HMI reads to a redundant WinCC server during the import window.

Field Commissioning Checklist

1. Confirm WinCC version (V7.3 / V7.4 / V7.5 / TIA WinCC) matches the ODK header set used in the wrapper.
2. Verify the ODK license on the runtime machine (license file "WinCC ODK" must be present in License Manager).
3. Run a one-record smoke test before enabling the bulk import.
4. Wrap the import loop in try/catch (or SEH on the C side) and log every failure to a text file, including the source record id so the import can be resumed after a fault.
5. Stop the WinCC runtime or set the archive to "manual" before re-importing the same time range to avoid duplicate primary keys.