Save HMI numeric entries to an indexed PLC table

How do you save each numeric entry to the next V-memory word?

You write the entry through a pointer. Load the pointer word V2200 with the table start O3000 once on the first scan, then on every accepted entry run LD V2100, OUT P2200 and INCB V2200, and reset the event bit C3.

A pointer is an ordinary data word that holds an address instead of a measurement. OUT P2200 sends the value in the accumulator to whichever word the pointer addresses, so when INCB adds 1 word to V2200 the destination moves from V3000 to V3001 and the next press stores there. One press, one word, in order, for as many entries as the table has room for.

Why does every entry overwrite the same word?

A fixed destination never moves. OUT V3100 writes V3100 on the first press and writes V3100 again on every press after it, so 10 accepted entries leave one word holding the last number and 9 numbers gone.

Changing the trigger, or pressing Enter again, cannot move a destination that is written into the instruction. The address has to live in a word the logic can change, and an offset or a pointer gives it that home.

For a single setpoint the fixed move is all you need, and moving an HMI numeric entry into PLC memory on Enter covers that one-word case. The rest of this page builds the pointer version, which is the one that fills a table.

What do you need before you write the logic?

Three bit assignments and 3 addresses: the entry object's notification bit C5, handshake bit C6 and accept button C3 set in the panel project, and in the PLC an entry word V2100, a pointer word V2200, and a table that starts at V3000. Decide the table length before the line runs. A 100-word table takes 100 entries before you have to reset the pointer.

• In the panel project, the numeric entry object needs its notification bit and handshake bit assigned. The arrangement used here puts Enter notification on C5, handshake on C6, and a momentary accept button on C3.
• In the PLC, V2100 is the word the panel writes the entered number into, V2200 holds the pointer, and the table starts at V3000 with as many reserved words as you decide to give it.
• Keep the entry word and the pointer word in different addresses. If the pointer lives in the entry word, the first number entered replaces the address, and the next store lands wherever that number happens to point.
• Open data view in the programming software so you can watch V2100, V2200 and the table words while you test.

How do you point the pointer at the table start?

Initialize it once, on the first scan, with SP0. STR SP0, LDA O3000 and OUT V2200 load the octal address O3000, the start of the table, into the pointer word V2200 before any entry can fire.

SP0 is the special relay that is on only for the first scan after power-up, so the initialization runs exactly 1 time. LDA loads the address in octal form, which is what the O in O3000 marks. An initialization rung left on every scan would snap the pointer back to V3000 before each store, so the rung must sit behind SP0.

STR SP0
LDA O3000
OUT V2200
END

To start the table over and write over it from the top, run the same LDA O3000 and OUT V2200 again from a panel reset button or an internal condition. Keep that reset rung separate from the store rung so an ordinary entry never re-initializes the pointer.

Which rung stores the entry and advances to the next word?

One rung does the whole store. Triggered by the accept bit C3, it copies the entry word V2100 through the pointer with OUT P2200, increments the pointer with INCB V2200, and resets C3 so the same press cannot store twice.

1. Assign the bits in the entry object: notification on C5, handshake on C6, and the momentary accept button on C3.
2. Enter the first-scan initialization rung from the previous section.
3. Add the handshake rung:

STR C5
SET C6
END

4. Add the store rung:

STR C3
LD V2100
OUT P2200
INCB V2200
RST C3
RST C6
END

5. Save the program to the PLC and open data view on V2100, V2200 and V3000 on.
6. Enter a test value and press accept. V3000 takes the value and the pointer advances 1 word from O3000. Enter a second value: it lands in V3001 with the pointer 1 word further on.

Order inside the store rung matters. The value goes out through the pointer first, then INCB advances the pointer, then the bits reset. Resetting C3 inside the same rung is what makes one press store exactly 1 word.

Recommendation: store through a pointer whenever entries have to accumulate one per press. Initialize V2200 with LDA O3000 behind SP0, keep the entry word and the pointer word in separate addresses, reset the event bit inside the store rung, and pick the OUTX offset form only when the logic has to compute a destination from a position number.

What do the notification and handshake bits do?

The notification bit tells the PLC that the operator pressed Enter, and the handshake bit tells the panel that the PLC took the number. The arrangement used here assigns notification to C5 and handshake to C6, sets C6 when C5 comes on, and resets C6 in the store rung.

The bits do nothing until they are assigned. If the entry object's control settings leave notification and handshake empty, C5 never comes on, the store rung never fires, and no ladder edit will fix it. Check the entry object's control settings in the panel software before debugging the ladder.

The momentary accept button is a separate event. The panel sets C3 and the PLC must reset it in the rung that consumes the value, or clear every event bit each scan before END with STR SP1 and an RST for each event bit, C3 and any others such as C7 or C17.

That set-and-clear exchange is the same handshake an HMI uses when it signals an alarm acknowledgment back to the PLC.

Example: six entries through the pointer

Six entries fill V3000 through V3005, one word each. The pointer starts holding O3000, every accepted entry writes through it, and INCB then moves the pointer 1 word, so entry 1 lands in V3000 and entry 6 lands in V3005.

Say the operator keys in a part count and presses accept 6 times. Entry 1 is 120: C3 fires, OUT P2200 writes 120 into V3000, INCB moves the pointer to O3001, and RST C3 clears the event. Entry 2 is 45 and lands in V3001. The run continues like this:

The count checks out. The pointer holds the table start plus the number of accepted entries: 3000 plus 6 gives 3006, so a seventh entry would write V3006. To write over the table from its top, re-run LDA O3000 and OUT V2200. The next accepted entry then overwrites V3000 while entries 2 through 6 keep their values until the pointer reaches them again.

How do you check the table fills one word per entry?

Watch 4 things in data view while the line is in a safe state: the entry word V2100, the pointer V2200, the event bits, and the table words from V3000 on. Each accepted entry should change exactly 1 table word and advance the pointer by 1 word.

Check the panel-to-PLC path first: enter a value and watch V2100 change, because the store rung can only copy what arrived. Then check the initialization. Before the first entry, V2200 should hold O3000. Then take entries one at a time.

A bit that stays true across scans fires the store rung again, and the reset belongs in the rung that consumed the event; PLC flag triggers an HMI event once: check the reset path walks that pattern. A pointer aimed at the wrong word can overwrite data the process depends on, so a value outside the table takes the entry function out of service until the mapping is fixed.

When the checks pass, each press stores exactly 1 word, the pointer sits 1 word ahead of the last entry, and the reset rung brings the next tableful back to V3000.

Questions