Fix an HMI timer preset that resets to zero in the PLC

Why the entry goes back to zero

In the DL06 memory map, every timer owns a fixed word for its current count. T0's word is V0, labeled TA0 for timer accumulated 0. While the TMR rung has input, the instruction updates that word each scan. A write from the panel lands in the word, and the next scan overwrites it. That is the whole fault: the entry tag is aimed at a register the timer owns, so the entry never becomes the preset.

Working buttons elsewhere on the panel tell you the link is up. The tag address is a separate thing to check.

Symptoms and what each one points to:

• The entry snaps back to 0 on enter. The tag targets the accumulated-value word, V0/TA0 on this layout. Move the preset to a data word.
• The entry stays on screen but the cycle time never changes. The tag and the timer's preset operand point at two different words, so the timer never reads the value you wrote. Make both sides name one word.
• The value changes, then falls back to an old value minutes or cycles later. Another rung in the program writes into the preset word. Watch the word online and catch the rung that changes it; the same writer-hunt fixes a Modbus TCP slave register that resets after a write.

Move the preset to a free data word

Open the controller manual at the table titled dL06 Memory Map. In the data Words section, every listed V address is a general data word, free for preset storage while your program leaves it unused. V400 is the word in this example. Check the map against your own project first, because a collision with an existing tag creates a second fault that is much harder to see.

Then make both sides name the same word:

1. In the ladder, enter V400 as the preset operand of the TMR instruction that drives T0.
2. In the panel project, point the numeric-entry object's tag at V400.
3. Remove the old dwell assignment to V0. Leave V0 alone; the timer needs that word for its count.

Once the timer reads the same word the panel writes, the entry and the duration move together.

Set the tag to BCD and place the decimal

A DL06 timer reads its preset as BCD, one decimal digit per 4-bit group. In the panel project, open the data entry tag and set its tag Data Type to BCD Int 16. That one setting makes the conversion automatic: the operator types a normal number and the panel sends the BCD pattern to the word.

Set the entry object's display format next:

• Number of Digits controls the decimal point placement. Use one decimal place for a 0.1 s time base.
• Add a suffix such as sec so the number means something to the operator.
• Tick Range and enter the minimum and maximum as the raw counts sent to the PLC, not as displayed seconds.

With one decimal place, an entry of 5.2 sends 52 to V400. The decimal exists only on the display; the word holds 52.

A type mismatch corrupts the value quietly. If the tag stays on a binary type while the timer expects BCD, an intended setting of 52 arrives as the binary pattern for 52, hex 34, which the PLC reads as the digits 34: the rung times 34 × 0.1 s = 3.4 s. Match the tag type to the instruction on the rung. The same raw-value-versus-display rule matters when you format a PLC timer duration display.

Match the decimals to the timer's time base

The instruction on the rung sets the count size. Read the rung before you set decimal places; the panel object is the wrong place to learn it.

The right-hand column follows from the word size: a 16-bit BCD tag holds four digits, so the largest preset is 9999 counts, and 9999 × 0.1 s = 999.9 s. A preset past that needs a different arrangement, such as a scaled entry in minutes or an accumulating timer, and that is a design change to make deliberately. Controllers that declare the preset as a time-typed parameter take the entry as a time value directly; the count-and-decimal method here is for PLCs that read the preset as a raw BCD word, like the one in this layout.

On a TMRF rung, switch the display to two decimal places: an entry of 5.25 sends 525 counts, and 525 × 0.01 s = 5.25 s.

Example: a 5.2 second dwell set from the panel

Scenario: a packaging machine holds vacuum for a dwell the operators tune per product. The rung is TMR T0 with the preset operand changed to V400. The panel object writes V400 with tag Data Type BCD Int 16, one decimal place, a sec suffix, and Range checked at 20 to 600 raw counts.

1. The operator types 5.2 and presses enter.
2. The object writes 52 to V400 over the link.
3. On the next cycle, T0 counts to 52 at 0.1 s per count: 52 × 0.1 s = 5.2 s, then the done bit sets.
4. Online, V400 shows 52 while TA0 runs its own count from 0 up to 52. Two words, two numbers, which is what a working setup looks like.
5. Range test: an entry of 65.0 is refused because 650 exceeds the maximum of 600, and an entry of 1.5 is refused because 15 is below the minimum of 20.

Result: the dwell changes from the panel in one entry, with no download and no logic edit, and the range clamps keep a typo out of the cycle.

Keep the preset through a power cut

Retention is configured per memory range. In DirectSOFT, with the project open, go to PLC > Setup > Retentive Ranges and tick the range that covers V400; the screen lists exactly which words are checked. The battery keeps configured retentive memory alive through an outage, and the retentive-ranges screen decides what that covers.

Add a first-scan default too: a rung, driven from the first-scan bit, that writes a known starting preset of 30 into V400 at power-up. A cleared memory then starts with a valid 3.0 s dwell. Keep that rung off the steady-state scans. A default written every scan erases every operator entry, the same ownership problem behind why an HMI overwrites PLC retained variables at startup.

Prove it: enter 5.2, power the PLC down and up in a controlled way, then read V400. It should still hold 52.

Check the machine before it runs again

Run these checks in order:

1. With the PLC online, put V400 and TA0 in two separate watch windows.
2. Enter 5.2 from the panel. V400 must change to 52, and TA0 must stay a counting value.
3. Time one cycle against a stopwatch. The done bit should arrive close to 5.2 s after the rung input, within a count of jitter.
4. Try the limits: entries of 1.5 and 65.0 must both be refused.
5. If retention matters, repeat the controlled power-cut test and confirm V400 still holds 52.
6. Any failed check stops the job. Resolve it before the switch goes back to automatic.

A dwell is a machine timing, so the first timed runs after the change belong behind closed guards with nobody reaching into the cell. Re-verify any interlock that reads T0's done bit with the new number.

Fixed steps instead of typed values

If operators only choose between set dwell times, replace the typed entry with an increment/decrement value object writing the same BCD word, and a numeric display object beside it. The object adds or subtracts raw counts per press: a step of 600 counts moves a TMR preset by 600 × 0.1 s = 60 s, one minute per press. A minimum of 1200, a maximum of 6000 and a step of 600 give a 2 to 10 minute range in one-minute steps, since 1200 × 0.1 s = 120 s and 6000 × 0.1 s = 600 s.

The scaling options on the object can show the value in minutes, a 0 to 600 range displayed as 0 to 1, or you can leave it unscaled and show tenths of a second with one decimal. Stepped entries remove typos from the floor entirely, and they are the better choice whenever the process has only a few valid dwell times.

The decision

Match the symptom to the move:

• Entry reverts to 0: the tag sits on the accumulated-value word. Move it off V0/TA0 to a free data word such as V400, and point the timer's preset operand at the same word.
• Entry sticks but the duration never changes: tag address and preset operand disagree. Make them one word.
• Value lands but the duration is wrong: tag type or decimal places disagree with the instruction. BCD Int 16 against a TMR with one decimal, two decimals for a TMRF.
• Value holds through entry but not through a power cut: tick the retentive range covering the word in DirectSOFT, and add a first-scan default.

Recommendation: store every operator-entered timer preset in an unused data word, V400 in this layout, set the entry tag's tag Data Type to BCD Int 16, give a TMR one decimal place and a TMRF two, clamp the entry with Range limits in raw counts, and tick the retentive range that covers the word before the machine runs again. Choose an increment/decrement object instead of typed entries whenever operators pick from fixed steps, and keep operator data off the timer accumulated-value addresses for good.

Questions