A K preset is a program constant, so no panel can edit it. Replace each timer's K literal with its own V-memory address in the preset field, then bind a numeric-entry tag in BCD Integer 16 format to that same word. Six timers take six distinct words; writing the accumulator never moves the preset.
A K value in a timer instruction is a constant written into the PLC program, and no panel can edit it. Making the setpoint operator-adjustable takes two moves: replace the K literal in the timer's preset field with a V-memory address, then point one numeric-entry tag per timer at that same address in BCD Integer 16 format. Writing the timer's accumulator never moves the preset, which is why a value pushed into a current-value word disappears the moment the process starts. This page works the change end to end for a panel driving six timers, from picking valid addresses in the memory map to proving the write before the process needs it. The general swap of a constant for a memory operand is laid out in let an HMI change a PLC timer preset instead of a constant; this page is the hands-on version, down to the words and the formats.
Why writing the accumulator never moves the preset
A timer instruction carries four things: the timer address, the preset, the time base and the accumulator. The accumulator counts elapsed time, the preset is the target, and the done output fires when the accumulator reaches the preset. The accumulator has its own word in V-memory; for the first timer in this setup, that word is V0.
That explains the symptom. A value written into V0 sits on the display until the process starts, then clears and counts up toward the old K target. The timing logic clears the accumulator on each pass and compares it against whatever stands in the preset field, and with a K literal that operand points at a constant inside the program, out of the panel's reach. The word that refused to hold the write is still the right word, just for reading: it is where the count lives, not where the target lives. The target has to move into memory the panel can reach, which is the edit the next sections make. How long one count lasts is the timer's time base, and the manual's timer chapter states that base for each timer type.
What you need
- The PLC program open in the programming software, with write access and the site's usual change-control procedure for the download.
- The memory map, in two places: the view in the programming software and the same map in the processor's user manual (page 4-28 of the manual for the processor in this setup).
- Six free V-memory words inside the user range the map shows, one per timer.
- The HMI project for the panel, open in the HMI configuration software.
- One numeric entry object per timer preset, plus one numeric display object for each timer worth watching.
- A safe test window, with the process in a state where a changed setpoint cannot spoil product or stress equipment.
Give each timer its own preset word
- Open PLC > Memory Map in the programming software and read the valid user ranges for the installed processor. For the processor in this setup, the manual lists V2000 through V2377 as user V-memory, and the map view confirms the range on the processor actually installed.
- Reserve one word per timer. Six timers take six words. Record the pairing before touching the logic: T0 at V2000, T1 at V2001, T2 at V2002, T3 at V2003, T10 at V2004, T11 at V2005. Two timers on one word share one target, so share a word only when one common setpoint is the deliberate intent.
- Open each timer instruction in the ladder. Leave the timer identifier where it is: T0 stays the timer, in the timer field.
- In the preset field, the line where the K appears, erase the literal and type the word's address. K300 becomes V2000 for the first timer.
- Repeat for the remaining five timers, each with its own recorded address.
- Save and download the program under the site's change-control procedure.
The arrangement looks like this, with the timer's own done contact making it self-resetting:
| | T0 |-|/|-------------|TMR T0|
| | V2000 |
That is the operand layout, not a complete program: the identifier T0 in the timer field, the preset address V2000 in the line where K300 stood. The edit also moves ownership of the setpoint. A K literal reloads with every program download; a preset word holds the last value written to it, so the panel becomes the place setpoints change and the programming software comes back out only when the logic itself changes.
Point the panel tags at the same words
- In the HMI tag database, create one tag per timer preset and name it for the timer. The name is a label for people; the address is what both machines read.
- Assign the tag the exact address from the timer's preset field, character for character. V2000 and V2001 differ by one character and drive two different timers.
- Set the tag's data format to BCD Integer 16, the format these preset words use: the typed value travels as decimal digits, each digit stored in its own 4-bit group.
- Add a numeric entry object to the panel screen and bind it to the tag.
- Repeat for the other five words.
The format is not decoration. A tag set to a binary integer type writes a different bit pattern for the same typed number, and the timer then runs to a different count. What each format does and how to set it are covered in setting the correct HMI data format for a PLC timer preset.
Example: six timers, six words, one panel
Inputs:
- Six timers to drive from the panel: T0, T1, T2, T3, T10 and T11.
- Existing logic: each timer carries a fixed K literal, K300 on T0 as the worked value.
- Valid user V-memory for the processor: V2000 through V2377, from the manual's memory map.
- Panel format for the preset words: BCD Integer 16.
- One word per preset, 16 bits per word.
Rule in words: a timer reads its target from whatever address stands in its preset field, on every scan, and the panel writes decimal digits into that address as BCD, one digit per 4 bits.
Arithmetic. Words needed: 6 timers × 1 word each = 6 words, assigned as:
| Timer | Address typed in the preset field | Tag format |
|---|---|---|
| T0 | V2000 | BCD Integer 16 |
| T1 | V2001 | BCD Integer 16 |
| T2 | V2002 | BCD Integer 16 |
| T3 | V2003 | BCD Integer 16 |
| T10 | V2004 | BCD Integer 16 |
| T11 | V2005 | BCD Integer 16 |
All six sit inside the documented V2000 through V2377 range. Capacity per word: 4 digits × 4 bits = 16 bits, so the largest setpoint one tag carries is 9999 count units. The old literal on T0 was K300, so the operator types 300, well inside that limit.
Result: the operator enters 300 on the T0 entry object, V2000 holds the digits as BCD, and T0 counts to 300 exactly as it did against K300. The next change happens at the panel, with no laptop and no download.
Decision: if every setpoint on the panel stays at 9999 count units or below, one BCD Integer 16 word per timer carries the whole job, six distinct words from the map-verified range, one entry object each. A setpoint above 9999 does not fit four BCD digits, so this one-word tag cannot carry it; that value needs a different arrangement in the PLC logic before any panel can promise it.
Show the timers counting
Reading the count is a second object on a different word. The first timer's current value lives at V0, the same word that refused to hold a written preset, and a numeric display object bound to a read tag on V0 in BCD format shows the count climbing and clearing as the timer works. The manual's timer chapter lists the current-value word for each timer number, so T1, T2, T3, T10 and T11 each get a display tag on their own word.
Keep the two paths apart. Entry objects write preset words; display objects read current-value words and need no write access. An entry object pointed at a current-value word rebuilds the original fault. Turning the raw count into minutes and seconds on the panel is its own subject, covered in how to format a PLC timer duration display.
Check the write before the process needs it
- Put the process in a safe test state.
- Enter a known setpoint through the T0 entry object: 300.
- Open the data view in the programming software and read V2000. It should show 300 in BCD, which appears as 0x0300 when the view is in hexadecimal.
- Open the timer instruction and confirm the preset field still reads V2000, with no leftover K and no neighbouring word.
- Run T0 and watch the display object on V0. The count climbs from zero and the done output fires as the accumulator reaches 300.
- Change one preset at a time and confirm only its own timer's target moves.
- If an entry fails to land, check in this order: the word's validity in PLC > Memory Map, the address in the timer's preset field, the tag's address, the tag's data format.
A preset word that drops back to zero after a power cycle or a download is a different fault from a write that never landed, and it has its own fix in fix an HMI timer preset that resets to zero in the PLC.
Recommendation: give each timer its own preset word from the map-verified user range, set every preset tag to the BCD format those words use, bind one numeric entry object per word, and keep the current-value words display-only. With that in place the panel is where setpoints change from now on, and the programming software comes out only when the logic changes.
Questions
Can two timers share one word on purpose?
Yes, when one common setpoint is the intent. Point every timer's preset field at the same V-memory word and bind a single numeric-entry tag to it; one edit then moves all of those timers together. The failure to avoid is accidental sharing, where two timers land on one word while operators expect independent setpoints. Record the pairing of timer to word before you edit the ladder, so shared and separate setpoints stay a conscious choice.
Will the new preset survive a power cycle?
That depends on whether the word lies in the processor's retentive V-memory, which the memory map marks. A word in a retentive range holds the last value written to it through power-down and power-up. A word outside the retentive ranges returns to its cleared state at power-up until the logic or the panel writes it again. Read the retentive marking when you pick the word; if the range you need is not retentive, have the operator re-enter the setpoint after startup.
The timer now stops at the wrong count. What changed?
Usually the tag's data format. Preset words on this processor expect BCD Integer 16, which stores each typed decimal digit in its own 4-bit group, and a binary integer tag writes a different bit pattern for the same typed number. The timer then runs to a different count before its done output fires. Set the tag back to BCD Integer 16 and confirm in the data view that the word shows the digits you typed.
Planning information, not legal or engineering advice. Rules differ by place: check codes and permits with your local authority and your licensed trades.