IMD SolutionComputing LibraryShop main store

Troubleshooting

Historian replication sends raw values to PI Server: fix it

Edge computing and IIoT Published 7 min read

Short answer

Historian 2023 R2 replication carries raw values to PI Server and scaled values to another Historian, so PI-bound tags need their value selection checked before any scaling change. Confirm the mismatch by comparing one stored sample at both servers against the source tag at the same timestamp. Then convert in exactly one place: scaled-value selection in the PI-bound interface if documented, otherwise one downstream conversion.

On this page
  1. Why does PI Server hold raw counts instead of engineering units?
  2. How do raw and scaled values differ on a historian tag?
  3. How much does carrying raw values distort a reading?
  4. How do you confirm the mismatch before changing anything?
  5. How do you switch the PI-bound replication to scaled values?
  6. What happens to the raw history already stored in PI Server?
  7. How do you keep the two destinations from drifting apart again?
  8. Questions asked

Replication from Historian 2023 R2 to PI Server carries the tags' raw values, while replication from the same source to another Historian carries the scaled values, so a reading that looks right on the second historian lands in PI Server as an unconverted count. Treat this as a value-representation problem in the PI-bound replication path, not as a fault in the acquisition scaling that already produces correct engineering units at the source. Confirm it with one matched sample read at both servers, then put the conversion in exactly one place: scaled-value selection in the PI-bound interface if your installed version documents it, otherwise a single downstream conversion. Do not rescale the source tag to compensate - that corrupts the local trends and the historian-to-historian leg that already carry the right number.

Why does PI Server hold raw counts instead of engineering units? #

The mismatch is reported behavior of FactoryTalk Historian 2023 R2: the same release feeds raw values to PI Server and scaled values to another Historian, and a 2017 U3 SP1 installation sent scaled values to PI Server, so the interface's value selection is the first thing to check.

The behavior is reported for a specific release pair, not a constant of the product: the 2017 comparison is a clue that value selection changed between versions, and your installed build still needs its own confirmation from the interface documentation. One source feeding two destination types that disagree localizes the fault to the PI-bound leg, because the acquisition path and the tag's scaling definition are producing a number the second historian stores correctly. Until the matched-sample test below runs, treat the historian-to-historian destination as the reference for what the correct number looks like.

How do raw and scaled values differ on a historian tag? #

Raw values are the counts or registers the acquisition path records before conversion, and scaled values are those counts mapped into engineering units, so the same physical sample legitimately exists as two different numbers.

For a tag with linear scaling and a nonzero raw span, the conversion is:

scaled value = engineering low + (raw value - raw low) × (engineering high - engineering low) / (raw high - raw low)

Both ranges come from the source tag's own configuration, never from a datasheet assumption. A nonlinear tag needs its configured relationship; the linear formula does not approximate it. When the PLC sends an unscaled integer and the historian performs the conversion, the same mapping rules apply, and historian tag scaling for an unscaled PLC integer works that case in detail. The distinction matters here because both representations are valid data: the fault is only that the PI-bound path delivers the representation the receiving application did not expect.

How much does carrying raw values distort a reading? #

The distortion equals the missing conversion: on an illustrative tag scaled 4000-20000 counts to 0-120 L/min, a sample of 12000 counts is 60.0 L/min at the source, so PI Server storing 12000 holds a number 200 times the true reading.

Worked example, with illustrative ranges - read your tag's actual configuration before reusing any of these numbers:

  • Raw range: 4000 to 20000 counts
  • Engineering range: 0 to 120 L/min
  • Raw sample stored at PI Server: 12000 counts

scaled value = 0 + (12000 - 4000) × (120 - 0) / (20000 - 4000) = 8000 × 120 / 16000 = 960000 / 16000 = 60.0 L/min

At that timestamp the source tag reports 60.0 L/min while PI Server holds 12000 against a point read in L/min - 200 times the true value, since 12000 / 60 = 200. The multiplier is not fixed across the range: one count is worth 120 / 16000 = 0.0075 L/min, so the error grows with the reading, and near the bottom of scale the destination would hold 4000 where the source reports 0 L/min. That is why the fix is per-tag value selection or per-tag conversion, never one universal multiplier applied to every point.

How do you confirm the mismatch before changing anything? #

Compare one stored sample at both servers against the same timestamp at the source: read the source tag's raw and scaled values, read what PI Server actually holds at that timestamp, and let the two numbers name the fault.

Run the checks in this order:

  1. Pick a source tag whose raw and engineering ranges differ; a tag with identical ranges yields the same number in both representations and cannot expose the fault.
  2. At the source, record the raw value, scaled value, timestamp, quality and units for one stable sample; the tag viewer that ships with the historian server shows recorded values without a client display in between.
  3. Read what PI Server stores at that timestamp straight from the archive, not through an operator screen.
  4. Read the same timestamp at the historian-to-historian destination as the control; it should hold the scaled number.
  5. Trace the PI display binding: the point it references, its unit label and any calculation performed in the display itself.
  6. Record the PI-bound interface's version and diagnostics, and compare them with an archived copy of the earlier configuration if one exists.

Three outcomes decide the case. PI Server holds the raw number: the representation fault is in the PI-bound path, go to the fix. PI Server holds the scaled number but the screen differs: the fault is the display or its point binding. Both destinations hold the wrong number: the source tag's scaling definition itself is wrong.

How do you switch the PI-bound replication to scaled values? #

Commit to one conversion location first: select scaled values in the PI-bound replication path if the installed interface documents that selection, and otherwise convert exactly once downstream - never by editing the source tag's acquisition scaling.

No parameter or setting name for that selection is documented in the material available for this case, so work from your installed interface's own configuration reference instead of a setting name quoted from memory, and decide among three cases:

  • Scaled-value selection documented for your interface version: back up the current scaling, mapping and destination configuration first, enable the selection for one test tag, and widen the scope only after a matched sample proves it. These settings usually apply to the whole interface, so an untested change re-maps every tag at once.
  • The interface documents raw-only transfer to PI Server: keep the path as designed and convert once in the receiving platform's own documented conversion facility, at the point or in the reporting layer. Remove any display-side conversion for that point first, or the sample is converted twice.
  • The documentation is silent: escalate to product support with the evidence from the matched-sample test rather than experimenting on a production interface.

After any change, read one matched sample at both servers again; agreement at the same timestamp is the acceptance test, not the absence of complaints.

What happens to the raw history already stored in PI Server? #

Changing the configuration fixes only future samples: values already written raw stay raw until you delete the affected range and re-send it from the source, so repair the path first, then decide history tag by tag.

Re-sending a range into PI Server is a backfill job, and backfilling PI from an existing plant historian covers the mechanics of moving source data into PI once the path is correct. Before re-sending, check the write mode your interface documents for out-of-order samples, because append and replace behave very differently against data already in the archive. Treat any window that downstream reports have already consumed - especially anything feeding an operational calculation - as suspect until it has been re-sent, and decide per tag: a diagnostic tag may not justify a rewrite, a number used in production accounting does.

How do you keep the two destinations from drifting apart again? #

After the fix, one matched sample per checked tag at a known timestamp proves both destinations agree, and a quarterly spot check catches interface changes that alter value selection - the difference between the 2017 and 2023 behavior is exactly such a change.

Keep the exported scaling, mapping and interface configuration under the same change control as the historian version itself, so the next upgrade review starts from a known state. After any interface, historian or PI Server upgrade, rerun the matched-sample test on one tag per interface before reopening the data path to clients - upgrades are the realistic trigger for this fault to reappear. Archive the test values with their timestamps so each rerun compares against a documented baseline rather than memory.

Questions asked

Which write modes apply when history is re-sent out of order?

The historian-to-historian interface documents that its history recovery honors all write modes for out-of-order data relative to the target archive: ARCAPPEND, ARCREPLACE and ARCNOREPLACE. Append adds the re-sent range beside existing data; replace overwrites it. Confirm what the PI-bound interface documents before re-sending, and verify one re-sent sample at the destination before releasing the whole window.

Why do some tags show no difference between raw and scaled values?

Tags whose raw range and engineering range are numerically identical produce the same number in both representations, so they look correct even while the path carries raw values. A clean-looking tag therefore proves nothing about the path. Run the matched-sample test on a tag with different ranges, such as a counts-to-pressure conversion, before judging the fix complete.

Can the conversion be applied at the PI point instead of the interface?

Some receiving platforms let a point carry its own conversion, which turns stored raw data into engineering units at read time. It works arithmetically, but every consumer of the point inherits that conversion, and a second conversion in a display or report then double-scales the value. If you choose it, record it as the one conversion location and strip conversions from displays and reports for that point.

What should you send to product support when the documentation is silent?

Send the replication interface name and version, the tag mapping, the source tag's scaling definition, and one matched sample set: the source's raw and scaled values with timestamp and quality, the value stored at PI Server at the same timestamp, and the control reading from the historian-to-historian destination. That package lets support say whether your build is raw-only by design or a value-selection setting exists.

Keep reading

  • How-to

    Expose historian latest values over OPC UA or MQTT

    Yes — connect an integration gateway to the historian's classic I/O Server over SuiteLink (application name aahiosvrsvc, topic TagName) and publish the current values as OPC DA and MQTT. After a historian restart the I/O Server and the Live table return nothing until the source sends a new value, so a true last-known-from-disk read needs T-SQL or the historian SDK.

    Edge computing and IIoT

  • How-to

    Backfilling PI from an existing plant historian

    Split the historian-to-PI backfill into four independent stages — extract, intermediate store, external compression, destination load — and qualify throughput with a measured pilot. Rows divided by elapsed seconds, not tag count, sets the schedule: 12,000 tags from 2020 at 500 rows/s is about 203 days. Check the native Historian 2023 replication route before writing pipeline code.

    Edge computing and IIoT

  • Explainer

    Do you need a historian or just an OPC tag server?

    No. An OPC tag server (OPC DA) supplies the current value, quality and timestamp of each item and stores nothing, so monthly figures need a historian or a SQL logger collecting from that same server. Keep a reporting client like ActiveFactory only if you also run the historian it expects.

    Edge computing and IIoT