IMDTouchKnowledge BaseShop main store

Troubleshooting

Displaying the 1756-DNB StatusDisplay as text on an HMI

HMI and touchscreens Published 7 min read

Short answer

The 1756-DNB StatusDisplay bytes are ASCII codes stored as numbers, so a string display pointed at the array prints their decimal values. Copy Local:2:StatusDisplay[0] into a controller-scoped STRING with a COP length of 4, set the string's LEN member to 4, and point the HMI string display at that STRING over the Ethernet shortcut — no DeviceNet mapping needed.

On this page
  1. Why a string display turns the StatusDisplay array into numbers
  2. Symptoms and what each one means
  3. Copy the four status bytes into a controller STRING
  4. Worked example: turning Local:2:StatusDisplay[0-3] into A#00
  5. Point the string display at the converted value
  6. If the display still does not match
  7. Questions asked

Your PanelView Plus shows numbers because Local:2:StatusDisplay[0-3] is a four-element numeric array: each element holds the ASCII code of one character, and a string display that is handed numbers prints numbers. The fix belongs in the controller, not in the display application. Copy the four status bytes from the 1756-DNB's module-defined StatusDisplay array into a controller-scoped STRING, write 4 into the string's LEN member, and point the HMI string display at that STRING through the terminal's existing Ethernet shortcut to the processor. The terminal never joins DeviceNet, and once the object reads a true STRING it reproduces the four characters shown on the module's front panel — A#00 in the case worked through below.

Why a string display turns the StatusDisplay array into numbers #

ASCII gives every character a numeric code, and the 1756-DNB publishes its four-character status as four bytes holding exactly those codes. In RSLogix 5000 you read them as characters only because the tag monitor's style is set to ASCII. That style is a formatting view inside the programming software: it changes how the numbers are shown to you, not what is stored, and it does not travel with the tag.

An HMI string display expects a value that carries character storage plus a current length. Pointed at a numeric element or a numeric array, the driver returns the bytes as plain numbers. The object does not inherit the monitor style, and it will not merge four independent elements into one four-character string.

Changing the object's numeric format is the wrong lever: a format setting decides how one number prints, and it cannot fuse four bytes into text. The pattern is the same as when a value reads wrong because its bytes are interpreted in the wrong order — the data is fine and the interpretation is not, which is exactly the fault described in displaying a PLC real value over Modbus on an HMI. Keep the conversion in the controller so the HMI reads one stable, correctly typed value.

Symptoms and what each one means #

  • Characters appear in the controller monitor only with the ASCII style. That is the software formatting numeric bytes for you. The tag never carried text, so this is normal and not a fault to chase.
  • The HMI prints a decimal value for each byte instead of the characters. The object is reading the numeric array. No format setting fixes this; the object needs a STRING.
  • The HMI cannot browse the module tag, or the tag is missing from the list. The shortcut, the controller path or the online tag visibility is wrong, and the conversion cannot be selected until the processor itself is reachable.
  • The string display stays blank after the copy runs. The LEN member is still 0, the rung is not executing, or the object points at the wrong tag.
  • The text is formatted correctly but goes stale. The data path works; the source array or the HMI refresh is not updating. Confirm each element changes when the module's front display changes.

Start by monitoring elements 0 through 3 online with the style set to ASCII and comparing that view with the module's physical display. If the two disagree, the problem is in the module or its network — sort the source out before touching the PanelView application.

Copy the four status bytes into a controller STRING #

  1. Create a STRING tag in controller scope. This article calls it Module_Status, which is an example name — pick your own. Controller scope keeps it easy for the HMI to browse.
  2. Add a rung that executes every scan and put a COP instruction on it. Set the source to Local:2:StatusDisplay[0], replacing the 2 with the slot your 1756-DNB actually occupies, and set the copy length to 4. Set the destination to the first element of the string's character storage: expand the STRING tag in the browser and select that member, because the STRING begins with its LEN member, and bytes copied straight onto the tag would overwrite the length instead of the text.
  3. On the same rung, write 4 into the string's LEN member. Without a current length the storage can hold exactly the right bytes while the HMI, correctly by its own rules, reports an empty string.
  4. Go online and confirm two things: LEN reads 4, and the first four character positions match the module's front display character for character.
  5. Treat a persistent mismatch as the fault, not a single-scan difference. A status change mid-scan can leave one scan carrying a mix of old and new bytes, and a diagnostic readout wants the stable, repeated value.

Worked example: turning Local:2:StatusDisplay[0-3] into A#00 #

The inputs, and where each comes from:

  • Hardware and path: a 1756-DNB in slot 2 of a ControlLogix chassis, which produces the tag Local:2:StatusDisplay[0-3], and a PanelView Plus 1250 that reaches the processor over Ethernet — the arrangement this article answers.
  • Source bytes: with the monitor style set to ASCII the array shows A, #, 0, 0, so the stored decimal codes are the ASCII table values 65, 35, 48 and 48. Those are precisely the numbers the string display has been printing.
  • Destination: a controller-scoped STRING; Module_Status is the example name from the previous section.

The rule in words: copy four one-byte elements into character positions 0 through 3 of the string's storage, then declare 4 as the current length so the display reads exactly those four positions.

The arithmetic: a COP length of 4 elements at 1 byte per element moves 4 bytes into positions 0-3. A LEN of 4 makes the HMI read characters 0 through 3 and nothing beyond. Each byte decodes against the ASCII table: 65 → A; 35 → #; 48 → 0; 48 → 0.

The result: Module_Status holds A#00 with LEN at 4.

The decision: point the string display at Module_Status and the screen shows A#00, matching the module's front display. If the object still references Local:2:StatusDisplay[0], it prints 65 35 48 48 again, because the tag reference — not any format setting — decides text versus numbers. If any decoded character differs from the front display, stop: the source data is wrong and the fault sits upstream of the HMI.

Point the string display at the converted value #

  • On the diagnostics page, add or edit a string display object.
  • Browse for the tag through the shortcut that already connects the terminal to the processor and select Module_Status — the STRING, not the array. Delete any reference to individual StatusDisplay elements from the object.
  • Run the application and compare the object's text with the controller STRING online and with the module's front display. All three should agree character for character.

Nothing on the DeviceNet side changes. The module-defined array is readable in the controller's tag set, so the terminal's Ethernet shortcut covers it. Mapping bytes into the scanner's output image — a character array reference aimed at Local:2:O.Data[4], for instance — matters only when data must travel the DeviceNet I/O connection to another node, and a PanelView Plus reading the processor over Ethernet is not that node.

The terminal will not reinterpret or rescale the bytes for you either. If a screen also needs a number shown in engineering units, that conversion belongs in the controller too, as laid out in how to scale a PLC integer into an HMI display value.

If the display still does not match #

Verify the layers in order and fix the first one that disagrees; each layer feeds the next.

  • Front display and array disagree: the scanner or its DeviceNet side is at fault, not the HMI. Decode the four-character codes with the module's installation manual (1756-IN566) and correct the source first.
  • Array right, STRING wrong: check that the rung executes every scan, that the source starts at StatusDisplay[0], that the destination starts at character position 0, and that the copy length is 4. A single offset shows up as one character shifted along the text.
  • Bytes right, display blank: LEN. Bring it to 4.
  • STRING right, HMI wrong: the object's tag reference or the shortcut. Confirm it points at the STRING in the same controller that holds the copy logic.
  • Text right but stale: the path works. Watch the array online while the front display changes and fix whatever is not refreshing.

Two time sinks to skip: reformatting the object's number display, which can never turn four numeric elements into one string, and building DeviceNet I/O mapping for a terminal that talks to the processor over Ethernet.

Mimicking the processor's own indicator LEDs is a separate read. The controller exposes its status through GSV/SSV objects that you access with logic in the controller, not through the scanner's four display bytes — read the controller status directly and give it its own objects on the diagnostics page.

Questions asked

Does the PanelView Plus have to sit on the DeviceNet network to read the scanner's status?

No. The module-defined StatusDisplay array lives in the controller's tag set, so any terminal with an Ethernet shortcut to that processor can read it once the controller holds it in a STRING. Mapping bytes into the scanner's output image matters only when the data must travel the DeviceNet I/O connection to another node. A standard PanelView that uses controller addresses follows the same method: aim the character array reference at StatusDisplay[0] with a size of 4.

Why does my string display show only one number instead of four?

That usually means the object is bound to the numeric array but only the first element is being read, so one number — 65, the decimal code of A — appears instead of four. Check which tag the object actually references. A true STRING with LEN set to 4 prints all four characters; the count of characters a string display shows follows the string's length member, never the size of a source array.

Can I show the processor's own LED states on the same diagnostics page?

Not from the scanner's four display characters — those report the DeviceNet scanner's module and network codes. The controller publishes its own status through GSV/SSV objects, which you read with logic in the controller and store in tags the HMI can browse. Read that status directly instead of deriving LED states from the StatusDisplay bytes, and keep the two sources as separate objects on the page.

The characters are right in the controller but the display is blank. What is missing?

Almost always the length. A Logix STRING carries character storage and a separate current-length member, and if LEN reads 0 the HMI correctly reports an empty string even though the bytes are in place. Go online and confirm LEN is 4 and that the rung with the copy executes unconditionally — a conditionally gated rung or a wrong slot number in the source path leaves both the bytes and the length untouched.

What do the four characters on the front of the 1756-DNB actually mean?

They are alphanumeric diagnostic codes for the scanner module and its DeviceNet connection, and they change as the module's state changes. The code list, together with the module's bi-color green and red status indicator, is documented in the module's installation manual, 1756-IN566. If the codes on the front display ever disagree with what the array holds in the controller, the problem is in the module or its data, not in HMI formatting.

Keep reading

  • Troubleshooting

    Displaying a PLC Real Value Over Modbus on an HMI

    An INTEGER display that reads the register proves the link, station and address, so a blank REAL display is a 32-bit mapping fault. Declare the HMI variable as a 32-bit float on the register pair (40064/40065), set the device double-word order to Low Word First to match the PLC, and give the numeric field six integer digits for 628402.0.

    HMI and touchscreens

  • How-to

    Displaying S7-200 Analog Inputs on a WinCC HMI

    Copy the channel word into V-memory with LD SM0.0 and MOVW AIW0,VW1000, put the CPU in RUN, then read VW1000 with a WinCC tag typed as a 16-bit integer and bind it to a numeric field. Four readings — channel word, destination word, tag, display — isolate any fault; the first one that fails names the layer to fix.

    HMI and touchscreens

  • How-to

    Decoding SLC N-File ASCII and Bit Arrays in FactoryTalk View ME

    20549 is hex 0x5045, the packed ASCII bytes for P and E — correct data read as an integer because FactoryTalk View ME has no Character Array object. Rebuild the text on a string-capable mapping (on ControlLogix, COP the bytes into a String tag's .DATA and set .LEN), and extract two-bit multistate codes with AND masks 3, 12, 48, 192 shifted right 0, 2, 4, 6.

    HMI and touchscreens