Select multistate indicator text with a PLC message number

How does a message number select the text on the panel?

The panel's message-display object keeps a numbered list of texts. The number in its tag's register selects which line it shows. Write 1, 2, 3 or 4 into one data register such as V2000, and the panel follows the register. The panel reads the tag. The object draws the text that the number names. The PLC's only job is to keep that number current. There is nothing to build on the PLC side beyond the constant write, and that write is the whole interface.

Confirm the object type before writing logic. A message-number object picks its text from a value. An object built on separate discrete states expects its own bits, and it ignores a plain number in a register. If the label you need has only two states, one bit drives both texts, as in showing two text states on an HMI from one PLC bit. The same register-write pattern also runs screen changes, where the PLC writes the screen number to its register. That case is covered in writing a screen number from a PLC to the panel register.

What do you need before you write the first rung?

You need four things in hand: the panel object configured for message-number selection, the register address it reads, the message texts numbered the same on both sides, and the machine conditions that define each state. Checked once, they keep the rest of the job straight:

• The panel object opened in the project, with its selection mode confirmed as message number and its text list visible.
• The register address its tag points at, written down. The examples use V2000. If the project already points somewhere else, use that address in the ladder instead.
• A numbering plan agreed between the panel list and the ladder, one number per text, with 0 held for idle and reset.
• The conditions that define each state. The examples use fault bits C0, C1 and C2, and a level compare of V400 against 350 raw counts.

The tag's width decides how far the numbering can run. Multi-state indicator message limits and bit widths collects what each width carries.

How do you point the panel tag at the register?

Create one numeric tag in the panel project. Point it at the exact register the PLC will write, V2000 in these examples. Bind it to the object's message-number field. Check this mapping before any ladder work, because a tag pointed elsewhere makes every later rung look broken. Do the mapping first, while nothing else has changed:

1. Open the message-display object in the panel project and confirm it selects text by message number.
2. Create one integer tag addressed to the register the rungs will write, V2000 in these examples.
3. Attach the tag to the object's message-number field. The field defines how the value is used; the tag only carries it.
4. Type the texts into the object's list under the numbers the ladder will write, including the text for number 0.
5. Save and download the project to the panel.

With the mapping fixed, a wrong message on the screen points at the rungs, not at a moving address.

How do you write each message number from the ladder?

Each message is one rung with three instructions: the condition on top, a constant load with the message number, and a register write to V2000. Message 1 is STR C0, LD K1, OUT V2000. Every other message repeats the same shape with its own condition and number. Five rungs carry the whole example:

1. Reserve the register. V2000 carries nothing but the message number; sharing it with any other logic garbles the text.
2. Write one rung per bit-driven message:

STR C0
LD K1
OUT V2000

STR C1
LD K2
OUT V2000

STR C2
ANDN C1
LD K3
OUT V2000

3. Write one rung per comparison-driven message. Here the bin level register at or above 350 raw counts selects message 4:

V400 >= K350
LD K4
OUT V2000

4. Add the reset rung at the bottom of the block:

STR C10
LD K0
OUT V2000

5. A fifth message is one more rung of the same shape with its own condition and number. One 16-bit register stores 0 to 65,535, so message numbers 1 to 4 occupy 4 of the 65,536 possible values. No message instruction is involved at any point.

The mnemonics are the style one programming package prints. Your editor draws the same rung as a contact on top, a constant load and a register write, in that order.

What happens when two rungs are true in the same scan?

Rungs execute in program order once per scan. When two are true in the same scan, the one lower in the program writes last and its number wins. Overlap is your ordering to fix, not a panel fault. On a small PLC a full scan takes on the order of 10 ms, so the winner lands within 10 ms of the scan start and the screen never shows the loser. As drawn above, C0 and C1 both true leaves rung 2 writing after rung 1. The screen shows the jam text with the guard open. Two fixes, usable together:

• Guard each rung against the more urgent conditions. Rung 3 already does this: ANDN C1 keeps message 3 from overwriting the jam text.
• Order the block by urgency, most urgent rung last, so the scan's final write is the message the operator must act on.

Put the reset rung last of all. While C10 is held, K0 wins the scan. When the button releases, a still-true fault rung rewrites its number on the next pass, so the text comes back if the fault is still there.

OUT writes only while its rung is true. A fault that clears with nothing else on leaves the last number standing, and the screen keeps showing that text. Either accept that as an acknowledged alarm, or add an idle rung, true while every fault condition is off, that writes K0.

The same overlap shows up away from message boards, where a bit that seems to ignore a reset is fighting another condition. A write-up of a bit reset that stops executing while conditions overlap works through the same mutually exclusive fix.

Example: which message does the panel show at each line state?

A packing line with four fault conditions and one reset shows the whole method end to end. Numbers 1 to 4 go in V2000, a compare rung watches the bin level at 350 raw counts, and a reset writes 0. The operator stands about 15 ft from the panel, so at the common planning figure of 30 ft of viewing distance per inch of letter height, capitals of 0.5 in are large enough for fast reading. The block above gives this board:

Guard opens mid-run: rung 1 writes K1 and the screen shows the guard text. The jam bit is also true, and rung 2 sits below rung 1. K2 overwrites K1 in the same scan, within about 10 ms, and the screen shows the jam text. If the guard outranks the jam, swap the two rungs so the guard writes last.

Bin level: the level register V400 reads 412 raw counts. 412 >= 350 is true, the rung writes K4, and the screen shows the bin text. The level falls to 297 counts. 297 >= 350 is false, the rung stops writing, and the register keeps 4. The screen keeps message 4 until the reset or the idle rung writes 0. That is the stale-text case from the previous section.

Reset: the operator holds C10 for one scan, K0 lands in V2000, and the screen shows the all-clear text. Held with the jam still true, reset and rung 2 both write in the scan. Reset is lowest, so the all-clear text shows while held, and the jam text returns on release. That tells the operator the fault is still present.

Recommendation: order the message rungs so the most urgent fault writes last, add the idle rung above the reset, and keep 0 as the shared idle and reset number. Test all five screen states, plus one deliberate overlap and one reset, before the project goes live. For five or fewer messages this needs no message instruction at any point.

How do you check that the panel shows the right text?

Put the machine in a safe test state, watch the register in the PLC's data view, and drive one condition at a time. Each fault bit must move V2000 to its number and the panel to its text. Then the pairs, then the reset. Disable the drive and close the guards first, because a forced bit is a real command to the machine. Then:

1. Open the PLC data view on V2000 beside the panel.
2. Drive C0 only: the register reads 1 and the screen shows the guard text.
3. Drive C1 only: 2 and its text. Add C2: 3 and its text, confirming the ANDN guard holds. Drive C0 with C1: whichever text wins, confirm the winner matches your rung order.
4. Bring the level compare true with a test signal: 4 and its text.
5. Press C10: 0 and the all-clear text. Release with a fault still true: the fault text returns.
6. Cycle the panel's power once and confirm the object comes back reading the register.

If V2000 holds the correct number and the text stays stale, the panel is reading somewhere else: trace the value path from register to object. Also check any tag that arrived from an import against the register it actually addresses, as in fixing an imported HMI tag that ignores PLC register writes.

The panel stays the state display, because the object reads the register directly. A larger screen at the line playing your own slides suits shift targets and notices. Shop-floor signage displays are built for that second job.

Questions