Automatic message scrolling with lookup text in PLC logic

Why the list sits still

A lookup-text or text-list object maps values to strings: value 3 shows the message assigned to 3. The mapping is fixed configuration data, and some editors also let a value range point at one entry. The entry on screen changes only when the register value changes, so automatic scrolling means automatic register writes from the PLC. Editing the object, reordering the table or lengthening the block changes which text belongs to which number; none of those edits creates a periodic update. Decide which behavior you want before writing logic, because two designs get called scroll:

• Cyclic display: a fixed list shown in order, advancing on an interval and wrapping to the first message. The list never changes; only the index moves.
• Queue: messages arrive, are shown, and are removed. Data moves only when a message enters or leaves the list.

A fixed repeating list needs the cyclic design, and the rest of this article builds it.

What you need

• The message count, 10 in this design, and the first register of the message block.
• The selection register the lookup object reads, with its address and data type confirmed in the editor. A 16-bit signed integer is the common type for a text-list index.
• The value mapping, set so message 1 sits on value 1; the index then runs 1 to 10 with no offset. If your first value is 0, run the index 0 to 9 and wrap to 0.
• An on-delay timer and a rising-edge (one-shot) instruction.
• A first-scan bit, or an enable edge, to write 1 to the index at start.
• The screen-number tag, if the messages belong to one screen.

Build the cycle in the PLC

1. Initialize on the first scan. On the first-scan bit, or on the rising edge of the enable, write 1 to the index and move it to the selection register. This is also the legitimate way to put the first message up immediately, which is what people expect a 0 preset to do.
2. Time the interval. Run the on-delay timer from the enable with the preset at 5 s, and reset it from the done pulse so the next interval starts at once.
3. Add 1 per pulse. On the rising edge of the timer-done bit, compare the index with the last message, 10 in this design. Below 10, add 1. At 10, write 1. One edge, one increment, no skips.
4. Publish the index. Write the index to the register the lookup object reads, in the increment rung or every scan. Keep the index in its own register, clear of the message text block, so a wrap or a hand test can never overwrite message words.
5. Gate the run to the screen. AND the enable with a compare on the screen-number tag so the timer holds while the operator is elsewhere; run PLC logic only on the HMI current screen number tag shows how to read that tag. Decide the restart here as well: the initialize step returns the display to message 1 after a power cycle, and whatever you choose belongs in the rung comments.

What a zero preset means

Define 0 before a maintenance screen types it in. Build in this rule: a preset of 0 stops cycling and the display holds the current message. Put a preset > 0 compare in series with the timer so 0 can never start a timing run.

The other reading, shift now and keep shifting, is a fault to design out. A done bit that never clears fires once per scan, and a small controller completes a scan in a few milliseconds. At 5 ms per scan the index climbs 200 times a second, all 10 messages pass in 50 ms, a twentieth of a second, and the selection register takes 200 writes a second. The behavior people want from 0, the first message up at once, belongs to the initialize step on its own edge.

Watch the time base too. On a controller with no millisecond timer, an interval built from a 1 s clock bit can step no faster than once per second, so that same preset means five clock pulses; build a PLC seconds countdown with a one-second clock shows that construction. When a screen object writes the preset and leaves 0 behind, the cycle stops by this rule; fix an HMI timer preset that resets to zero in the PLC covers that repair.

Cyclic index or FIFO queue

Use the timed index for any fixed list that repeats: safety notices, changeover reminders, product messages. Use a FIFO when the content is a true queue: alarms logged as they occur, work orders consumed in sequence. A FIFO moves data only when its logic performs the shift, on arrival or on removal, and the screen still shows whichever entry the selection register names. Shifting the message block on the scroll timer couples presentation timing to data handling, moves every message word on every step, and puts queue data in the path of a presentation bug. Pick one design per screen: fixed list, timer and index; queue, events and shift.

Example: 10 messages at 5 s

Scenario: a packaging line notice board on the shop floor cycles 10 messages on one screen. Inputs: the text list maps values 1 to 10 to messages 1 to 10; the index is a 16-bit integer with an initial value of 1; the timer preset is 5 s; the enable comes from the screen-number compare.

• Cycle time: 10 messages × 5 s = 50 s per full pass.
• Interval check: the longest message runs 15 words. Silent reading for an adult sits near 200 to 250 words per minute, so 15 words takes 15 ÷ 250 × 60 ≈ 3.6 s at the quick end and 15 ÷ 200 × 60 = 4.5 s at the slow end. The interval covers the slowest reader with margin.
• Wrap check: at index 10 the compare index < 10 goes false, so the branch writes 1. Value 11 has no entry, because the list ends at 10, so the object has nothing defined to show there.
• Zero case: the preset > 0 compare reads false, cycling stays off, and message 1 holds.

Result: message 1 is up within one scan of the screen opening, messages 2 through 10 follow at interval steps, and the pass repeats every 50 s. At a 3 s preset the same list would pass in 30 s, and 3 s is shorter than the 4.5 s a slow reader needs for the 15-word line, which is why this design commits to the interval it chose.

How to check it worked

With the line in a safe state:

1. Write 1, then 5, then 10 to the index by hand and confirm the object shows messages 1, 5 and 10. One pass proves the address, the data type and the mapping together.
2. Enable the cycle and time one pass with a stopwatch: 10 messages, a wrap from 10 to 1, close to 50 s.
3. Open another screen and come back: the timer holds on the screen-number compare, and the pass resumes at the message it stopped on.
4. Cut control power and re-enable: the first-scan initialize puts the index back to 1.
5. Enter 0 as the preset from a maintenance screen: cycling stops and the current message holds.

Then read the failures. If the register steps 1 to 10 on schedule but the text stays put, the object's address or data type is wrong. If the text skips messages, the increment is firing on the done level instead of the done edge, so add the rising-edge instruction. A one-scan done pulse is real in the logic even when it never appears on screen; why an R_TRIG pulse never shows on the HMI screen explains that gap.

The decision, case by case

Recommendation: For a fixed repeating list, run the cycle in the PLC: initialize the index to 1 on the first scan, preset the timer between 3 and 5 s from your longest line, about 4 s per 15 words of silent reading, add 1 on the rising edge of the timer-done bit, wrap to 1 at the last message, and guard the rung so a 0 preset means off. Reserve the FIFO for queues that grow and shrink, shifted by arrival and removal events. Let one device own the index register; if a maintenance screen also writes it, name the owner for each machine mode in the rung comments, or the display will look random however correct the timer is.

Questions