Reading a Wiresheet Logic

Every lesson in this chapter taught you a block family. This one teaches the job they add up to. The unit is misbehaving, the program is somebody else's, and the sheet in front of you is live — every wire wearing its current value. Nobody reads a sheet like that for pleasure; you read it because something is wrong. The whole skill is one question, start to finish: you didn't write this program and something's wrong — how do you read a live wiresheet to find the block that's lying?

Work backward from the wrong output

The beginner move is to read the sheet the way it was written: start at the inputs on the left, follow the signals forward, verify each block as you go. It feels rigorous. It's also the slowest possible route to the fault — because a broken sheet is still mostly healthy. One block is lying; the other thirty are doing their jobs perfectly. Read forward and you'll inspect the whole healthy ninety percent before you touch the one block that matters. Forward is how you learn a sheet; it isn't how you fix one.

So start at the other end. The complaint already names the wrong output — the heat that won't run, the damper that won't close, the alarm that won't clear. Put your finger on that output and step upstream, one wire at a time, asking the same question at every hop: given these inputs, is this output right? "Right" means what the sequence needs it to say — not merely what the block's label computes. As long as the answer is yes, the block is honest and the problem is further upstream. The first NO is your block.

That last distinction — what the sequence needs versus what the label computes — is the heart of it, because a block can lie two ways. Broken math is the rare way; blocks compute what they're told with total reliability. The common way is the wrong sentence configured into it: a comparator pointed the wrong direction, a missing inversion, a constant somebody typed wrong, a swapped pair of wires. A block like that answers its own question faithfully, forever — and its question is the wrong one. The trace corners it just the same: at that hop, the output stops matching what the sequence plainly needs, and everything upstream still makes sense. The block that's lying — or its config — is under your finger.

Two dividends fall out of the discipline for free. Every branch that never reaches the wrong output doesn't exist for this trace — you don't owe it a glance, no matter how suspicious it looks. And every hop where the answer is "yes, honest" retires the entire subtree above the healthy input: a TRUE permit leg clears the whole permissive chain that built it in one look. Backward tracing isn't just starting at the other end — it's a pruning strategy. The sheet gets smaller at every hop.

What the scan means for what you see

Function-Block Basics covered how a sheet runs: the controller evaluates every block several times a second — the scan — in dependency order, sources first, and a feedback wire carries the previous scan's value so a loop resolves instead of chasing itself. That was the mechanism. Standing in front of a live sheet, the mechanism becomes three things you'll actually observe.

Values move together, not in sequence. Within one scan a whole combinational chain settles — comparator, gate, output, done — and the display repaints far more slowly than the controller scans. You will never watch a value crawl block-to-block across the sheet, and you shouldn't wait for one to. The corollary is diagnostic gold: if a chain disagrees with itself — a TRUE feeding an AND whose other leg is TRUE while its output sits FALSE — that isn't propagation delay you're seeing, because there is none to see. Something is genuinely wrong at that block, and you've found your NO.

Feedback shows its age honestly. A latch displaying Q TRUE while its S input reads FALSE looks broken to a beginner — the output is on with nothing turning it on. It's the healthiest thing on the sheet: Q is state, and S only needed to be TRUE once, possibly thousands of scans ago. The same reading applies to any wire that loops back on itself — it carries last scan's value, one scan stale, by design. When the trace reaches a stateful block, the hop question shifts tense: not "given these inputs, is this output right?" but "given these inputs and a legitimate past, is it right?" — for a latch, check what could have fired S, not just what S says now.

Forcing an input is the fastest experiment you can run. Because the whole sheet settles every scan, a forced value ripples through everything downstream of it before the next repaint — force the temperature five degrees up and the comparator, the latch, the gate, and the output all confess at once. Whatever your platform calls it — force, override, out of service — it turns a passive read into an active test: if this input were X, would the sheet do the right thing? A yes moves the fault upstream of your force; a no keeps it downstream. That's a binary search, and it converges fast. The discipline that keeps it safe — log every force, clear every force — is the same override discipline commissioning runs; that lesson's override section is the rulebook, and it applies double on an occupied building.

Idiom recognition: five blocks, one name

You don't read prose letter by letter — you read words. Sheets work the same way. The chapter's lessons each taught a recurring cluster of blocks that shows up on real sheets as a unit, and once you can name the cluster, five blocks collapse into one word. A forty-block sheet becomes six or seven idioms with wires between them — and the trace hops between patterns, not between blocks. Inside a recognized idiom you already know what every pin should be doing; the interesting hops are the seams.

Each of those has a lesson of its own in this chapter — Boolean Logic & Latches owns the permissive chain and the latch, Comparators & Deadband owns the band edges, Timers & Delays owns the proof window, and Setpoint Math & Reset Schedules owns the reset chain and the select. Here they only need their names, because the names are what make the next section possible.

A worked trace — cold morning, no heat

Here is the whole method on one sheet. An air handler's heating call: the program went in this fall, this is the first real cold morning, and the complaint is simple — the space is at 65 °F and falling, and the heat won't come on. You didn't write it. Read the idioms before the blocks: a band-edge cluster across the top building a heating thermostat around the 68 °F setpoint, a two-proof permissive chain at the bottom left, a gate AND joining them into the heat command — and a little branch off the freeze stat driving a trip lamp. Fifteen blocks; four patterns and a stub.

Blue wires carry analog values; green wires carry a TRUE digital signal, grey a FALSE one — the same coloring the editor uses live.

Step 1 — start at the symptom. HEAT reads OFF. Its only input is the gate's output, FALSE — an output block repeating a FALSE input is telling the truth, so hop upstream. Step 2 — the gate. Two legs: the permit reads TRUE, the call reads FALSE. Given TRUE and FALSE, an AND outputting FALSE is honest — and here the pruning pays: the TRUE permit leg retires the entire permissive chain below it. One glance — status ON, freeze stat OK, permit made — and you never read it again. Follow the FALSE leg. Step 3 — the latch. Q is FALSE with S FALSE and R FALSE. A latch with nothing setting and nothing resetting repeats last scan — legitimate if S has never fired. The latch is honest; the question moves upstream to why S never fires. Step 4 — the set leg. Inputs: 65, the space, against 67, the lower band edge. What the sequence needs this block to say is "the space has fallen below the band — call for heat," and 65 is plainly below 67: the answer should be TRUE. The block says FALSE. First NO. Now read the block instead of the wire: its label is A > B. It is answering "is 65 greater than 67?" — faithfully, forever — and that is the wrong question. The set leg of a heating thermostat needs A < B. Look at the reset leg above it: the same block, correctly used. Whoever built the cluster made the reset comparator first and copied it for the set leg — and never flipped the copy. One dropped character, cornered in four hops.

Count what the trace never touched. The permissive chain: cleared in one glance at step 2, never walked. The freeze-trip lamp branch at the bottom: never on the path at all — and it's the sheet's best trap, because every wire on it is grey. A beginner hunting for "dead" wires lands there first; grey only means FALSE, and FALSE is exactly what a healthy trip lamp shows. Nothing on that branch reaches the heat output, so the trace owes it nothing. A forward read starts at five sources and works the whole healthy sheet on its way to the one bad block; the backward trace touched four blocks, total.

One last observation worth keeping: an inverted comparison flips the whole sequence's sense with the weather. The same lie that blocks heat on a cold morning would have run it away hot on last week's mild afternoon — S fires anywhere above the 67 edge, and past 69, where R finally objects, the set-dominant latch lets S win. Symptoms that reverse with conditions smell like a backwards comparison. And the fix is its own small proof: flip the block to A < B, watch S go TRUE and the latch set and the heat start — then verify the release too, because a repair you didn't watch work is just a theory with a wrench in it.

Break one yourself

The trace above is fixed on the page; the skill is built live. Open the Function-Block Editor and load the heating thermostat example — the same band-edge cluster as the worked sheet, healthy this time. Then run the drill in three passes. Predict: select the TEMP block and type a new value into its inspector — that's your force — but before you look at the sheet, call every wire: both edges, both comparators, S, R, Q. Then look. Drive the temperature below the lower edge, back up through the band, and out the top, predicting each crossing before it paints. Break: now sabotage it on purpose — set the deadband constant to 5 and watch the heat go quiet on a cool space. Trace: backward from the output that stopped behaving: the gate is honest, the latch is honest, the comparator is honest — the lie has retreated all the way to a number somebody typed. Faults don't always live in the logic; sometimes the block that's lying is a constant.

Open the Function-Block Editor →