Troubleshooting
Trace Ignition Edge MQTT values that only update on refresh
Short answer
Values that appear only after a refresh mean the Edge transmitter publishes nothing on its own: the forced republish masks a stalled change-driven path. Set a 10,000 ms scan rate with a 0.00000001 deadband and a moving signal publishes at the scan rate, then verify by counting 6 updates per minute with no refresh anywhere. Trace tag value and timestamp at each hop to find where it stops.
On this page
- Why do my Ignition Edge values only update when I hit refresh?
- What does the refresh tag in MQTT Transmission actually do?
- Where should I trace the stalled update first?
- Which settings stop MQTT Transmission publishing on change?
- How do I make Edge publish every 10 seconds?
- Why does every Edge tag arrive as its own node in MQTT Engine?
- How do I prove values are flowing without touching refresh?
- Questions asked
Values that show up only after you hit refresh are not an MQTT failure — they are a stalled change-driven publish path with refresh masking it. The Cirrus Link MQTT Transmission module publishes a tag when its value moves past the deadband at the scan rate; a source that never changes, a deadband wider than the process noise, or a scan rate measured in minutes all produce silence, and the forced republish a refresh triggers paints current values over the gap. Trace one tag from its Edge source to MQTT Engine, fix the numbers that gate publishing, and prove the fix by counting updates in a window where nobody touches refresh. The node-per-tag layout is a separate, mostly cosmetic matter you settle last.
Why do my Ignition Edge values only update when I hit refresh? #
Your transmitter is publishing nothing between forced republishes: Sparkplug B publishes a metric only when its value changes past the deadband, so hitting the refresh tag — which forces a full republish of current values — is the only event producing data. The Sparkplug B specification sets the cadence: an edge node publishes its full state once in a birth certificate when it connects, then sends a data message for a metric only when that metric moves past its deadband, and republishes full state only when a rebirth is forced. A refresh is exactly such a forced event, so it always produces data. That narrows the fault to three candidates:
- The source tag is not changing on the Edge gateway — a stale OPC path, an offline device, or a tag group that never evaluates.
- The value changes but never qualifies — the deadband is wider than the signal's movement, or the scan rate is so long that evaluation rarely runs.
- The transmitter is not staying in a started state, so it acts only on the forced reloads your refresh triggers.
The two refreshes in the reported symptom compound the confusion: the Edge-side refresh forces the republish and the central-side folder refresh redisplays the nodes, so the system looks healthy until the next quiet period.
What does the refresh tag in MQTT Transmission actually do? #
Setting the refresh tag in the MQTT Transmission → Transmission Control folder to true reloads the transmitter and republishes its current values, which is why data appears the moment you hit it — and why it proves nothing about ongoing publishing. This is the documented way to start a transmitter, so treat it as a restart button: a burst of data will appear no matter how broken routine publishing is, which is why a successful refresh is not a passing test. Its central-side counterpart, refreshing the Edge Nodes folder in MQTT Engine, only re-reads the node and tag structure the Engine has already discovered. Neither click creates ongoing publishing.
Where should I trace the stalled update first? #
Start at the Edge source tag: record its value and timestamp, then compare the same pair at the transmitter, the broker and MQTT Engine, because the first boundary where the timestamp stops moving is your fault. Work one tag through the path in order:
- On the Edge gateway, open the source tag and confirm its value and timestamp move on their own. If they do not, the fault is upstream of MQTT: the device, the OPC connection, or the tag group.
- Make one controlled change on a test tag — a scratch tag, never a live setpoint, because you are writing toward a running process.
- Confirm the transmitter is started, that its tag set includes your test tag, and that its scan rate is short enough to evaluate during the test.
- Subscribe to the Edge node's topics on the broker with any plain MQTT client and watch for a data message when the tag changes.
- On the central server, read the same tag through MQTT Engine — value and timestamp — without refreshing anything.
The first boundary where the timestamp stops moving is the fault:
| What you see | What it proves | Where to work |
|---|---|---|
| Edge source value frozen | The tag is not changing at the source | Device, OPC connection, tag group |
| Edge moves, no message reaches the broker | The change never qualifies or the transmitter is idle | Scan rate, deadband, transmitter state, tag inclusion |
| Broker delivers, MQTT Engine shows nothing | Transport reached the broker but not the subscriber | Engine server definition, namespace, subscription |
| Engine value and timestamp advance, the display does not | The MQTT path is healthy | The consuming tag reference or view |
Which settings stop MQTT Transmission publishing on change? #
Two numbers gate every publish: the scan rate, how often the transmitter evaluates the tag, and the deadband, how far the value must move from the last published value before a new message is sent. Out of the box the module publishes when a tag's value is modified, so anything that stops a modification from being seen stops the publish. A long scan rate produces exactly that long a publish interval; the documented correction is to lower the tag's scan rate on the transmitter profile, or override it on the tag itself. A tag group left in exempt mode never evaluates on a timer at all, which is the same silence behind why Edge historian gaps look like held values centrally. For the full walk-through of these settings, see configuring Ignition MQTT tag publishing to a broker.
Worked example — a deadband swallowing the signal. A tank-level tag spans 0–100 % with a transmitter deadband of 5.0. The level drifts from 40.0 % to 42.6 % over an hour: 42.6 − 40.0 = 2.6 % of movement, which never reaches the 5.0 % threshold, so nothing publishes and MQTT Engine correctly holds 40.0 % with an hour-old timestamp. Decision: set the deadband to 0 on any tag a person watches; reserve a wide deadband for signals where you have deliberately accepted coarse reporting.
How do I make Edge publish every 10 seconds? #
Set the tag group scan rate to 10,000 ms and the transmitter deadband to 0.00000001: the transmitter then evaluates every ten seconds and every nonzero movement qualifies, so a moving signal publishes at the scan rate. The basis is the documented observation that a deadband of 0.00000001 produced a stored sample every 2 seconds at a 2-second scan rate — once the deadband stops gating, the scan rate sets the cadence. The arithmetic for the test window: 60,000 ms ÷ 10,000 ms = 6 publishes per tag per minute.
The honest limit: a perfectly flat value still publishes nothing, because the rules are change-driven — and everywhere it matters the value is already correct; only the timestamp ages. If a consumer needs a moving timestamp on a flat signal, that consumer should poll; do not rebuild the publisher for it. Readers looking for a dedicated fixed-interval mode find the module change-driven and land on this same configuration: scan rate for cadence, near-zero deadband so every evaluation qualifies.
Why does every Edge tag arrive as its own node in MQTT Engine? #
Each tag arrives as its own node because the Edge side gives each tag its own node identity — one transmitter publishes one Sparkplug edge node — and that layout changes how clients address the tags, not whether they update. A transmitter's tags normally arrive as metrics under its single node, so a node per tag means separate transmitters or separate node identities on the Edge side. Your references already resolve where the tags land, so the layout is not the fault. Decision: leave it alone while you fix delivery; consolidate the tags into one transmitter publishing a single edge node identity only if consumers need one browsable node, and re-verify every reference after that change.
How do I prove values are flowing without touching refresh? #
Watch MQTT Engine's value and timestamp for one moving test tag across a 60-second window with no refresh anywhere: at a 10,000 ms scan rate you should count 6 updates, and 0 updates means the publish path is still stalled. Fewer than 6 on a tag with visible movement means the deadband is still gating — return to the settings section. Six updates with nobody refreshing anything on either server closes the fault. Two adjacent stalls are worth ruling out while you are there:
- If the broker connection has been dropping, MQTT Transmission queues messages and replays them after reconnect, and live values lag until the queue drains — MQTT store and forward backfill after a connection outage traces that path.
- When history is configured on the Engine tags without reference tags, the Edge side must publish its historic data in order before live data resumes, so a backfill can hold fresh values back — getting backfilled Sparkplug history through Ignition reference tags covers that configuration.
Hand the system over only when the count passes with no refresh in the window; the refresh tag then goes back to being a configuration tool, not a data source.
Questions asked
Does Sparkplug B have a fixed publish interval?
No. The specification is report-by-exception: full state goes out once in the birth certificate, data messages only when a value moves past its deadband, and a full republish only when a rebirth is forced, which a supervisory client sends as a command. A quiet process is compliant silence, not a fault; judge liveness by the birth and death certificates and the cadence of changing tags, not by a fixed rate.
How much broker traffic does a 10-second cadence add?
At 40 tags, a 10,000 ms scan rate puts 40 x 6 = 240 metric publishes per minute on the broker. Halving the scan rate to 5,000 ms gives 60,000 / 5,000 = 12 publishes per tag, so 40 x 12 = 480 per minute. Sparkplug batches the metrics that change in the same evaluation into shared data messages, so the message count can sit below the metric count.
Can a store-and-forward backlog look like this same fault?
Yes, after a connection dropout. The transmitter replays its queued messages on reconnect and current values lag until the queue drains. The tell is that MQTT Engine timestamps keep advancing on their own, just behind wall-clock time, whereas a deadband or scan-rate stall shows timestamps frozen solid until something forces a republish.
Does refreshing the Edge Nodes folder in MQTT Engine request new data?
No. That click re-reads the structure the Engine has already discovered from messages it received; it does not command the Edge gateway to publish. Anything that looks newer afterwards came from the Edge-side refresh or a rebirth, which is exactly why the fix has to be verified in a window with no refresh at all.