A timer on a tag-based PLC is a structure, so no HMI editor lists TIMER as a type. Put the member in the tag name itself: .ACC and .PRE as DINT for the numbers, .TT and .DN as BOOL for the status bits, one tag per member. Import the controller's tag database when a screen needs members from several timers.
A timer on a tag-based PLC is a structure: preset, accumulated value and status bits live inside one tag with named members. HMI editors do not offer TIMER as a type, because a type describes a single value and a structure is not one. The fix costs nothing: write the member into the tag name itself, for example PUMP_TMR.ACC, and give that tag the member's own scalar type. DINT covers the two numeric members, BOOL covers the status bits. This page sets the tags up step by step, works a 30 second example end to end, and shows how to verify the screen against the controller before the panel goes on the wall.
Why is there no TIMER in the data type list?
A timer on a tag-based PLC is a structure with several members, and the editor's list only holds single-value types (INT, DINT, SINT, BOOL, STRING), so you never select TIMER at all: you name one member in the tag and give that member its own scalar type.
The dropdown lists scalar types only, and a scalar holds exactly one value. A timer tag holds several: a preset, an accumulated time and status bits such as .TT and .DN. When you name a tag CYCLE_TIMER and pick DINT, you tell the editor to expect one integer at that name, and the controller holds a structure there, so nothing resolves to a number. The information the editor is missing, which member and which type, goes into the two fields you already have: the tag name field and the type field.
How do I write a timer member into the tag name?
Type the timer's exact name from the controller, then a dot, then the member suffix: for a timer called CYCLE_TIMER, the accumulated value is the tag name CYCLE_TIMER.ACC with DINT selected.
The suffix is part of the address, not a display setting. Copy the timer name out of the controller project instead of retyping it, because CYCLE_TMR and CYCLE_TIMER differ by one character and the short version reads as an unknown tag. Keep the notation exactly as the controller writes it: tag name, dot, member.
Register-based controllers have no suffix to offer, because their timers live in numbered registers and their status bits in control words. That difference is why tag address formats change between PLC protocols, which our article on HMI tag address formats compares protocol by protocol.
Which data type does each timer member need?
Two types cover every timer member you will put on screen: DINT for the numeric values .PRE and .ACC, BOOL for the status bits .TT and .DN, with one HMI tag created per member shown.
| Member | Type | What it holds |
|---|---|---|
| .PRE | DINT | Preset time, in milliseconds |
| .ACC | DINT | Accumulated time, in milliseconds |
| .TT | BOOL | Timer timing status |
| .DN | BOOL | Timer done: .ACC has reached .PRE |
DINT is a 32-bit signed integer and BOOL is a single bit. INT and SINT are smaller integer types used by members of other structures; none of the four timer members above needs them. If you want the whole family of PLC data types, BOOL, SINT, INT, DINT and REAL, with sizes and typical uses, this PLC data types explainer lays them out.
The same method reads any structure on the controller: member in the name, type matched to that member. For a structure other than a timer, take the member's declared type from the controller project instead of guessing from the name.
How do I set the tags up step by step?
Four members mean four tags when the screen shows the whole timer: create one tag per member, type the full name with its suffix, set the type to match, and assign the tag to a numeric display or a status lamp.
What you need:
- Access to the controller project, to copy exact tag names and check member types
- The HMI editor's tag configuration for the panel
- The panel connected on the network, or its transfer path
- A way to make the timer run: a live cycle or a test rung
- Open the controller project and find the timer tag. Copy its exact name and note the members the screen needs: .PRE or .ACC for numbers, .TT or .DN for status.
- In the HMI editor's tag configuration, create one tag per member and paste the full name into the tag name field: CYCLE_TIMER.ACC, CYCLE_TIMER.DN, and so on.
- Set the data type on each tag: DINT for .ACC and .PRE, BOOL for .TT and .DN.
- Assign each tag to an object: a numeric display for the DINT tags, a status lamp for the BOOL tags. Put the lamps next to the number so one glance reads the whole timer; our article on displaying 16 PLC input and output bits on one screen shows how to lay out a bank of status bits.
- If an operator should change the preset, add a numeric entry object on the .PRE tag and set the entry object's type to DINT as well; a mismatched entry type is the usual cause of a refused write, which this note on rejected numeric entry writes walks through.
- Download the application to the panel and open the screen while the timer runs.
If the editor reports an invalid address on a name you copied correctly, work through our article on fixing HMI invalid address errors before touching the controller logic.
What does a worked example look like with a 30 second timer?
A 30 second wash timer shows the whole chain: the controller stores the preset as 30,000 because timer values count milliseconds, the screen tag is WASH_TMR.ACC as a DINT, and divide-by-1,000 scaling turns 30,000 ms into 30.0 s on the display.
Scenario: a wash cycle timed by a tag named WASH_TMR, target 30 seconds.
Controller side. The timer counts milliseconds, so the preset rung takes 30 × 1000 ms = 30,000. The controller's .PRE reads 30000. While the rung is true, .ACC climbs from 0 toward 30000 in 1 ms steps and reaches it after exactly 30 s, at which point .DN switches on.
Screen side. Two tags:
- WASH_TMR.ACC, type DINT, on a numeric display
- WASH_TMR.DN, type BOOL, on a status lamp
Raw milliseconds mean little to an operator, so set the numeric object's scaling to divide by 1000 and show one decimal. Check the arithmetic: 30,000 ms ÷ 1000 = 30.0 s, and a live value of 12,345 ms ÷ 1000 = 12.3 s on the screen. The operator watches 12.3 climb to 30.0 and the lamp come on.
Headroom check. A DINT tops out at 2,147,483,647, the largest 32-bit signed integer. In time units: 2,147,483,647 ms ÷ 1000 = 2,147,483.647 s; ÷ 3600 = 596.5 h; ÷ 24 = 24.9 days. Any cycle, batch or shift timer fits in a DINT with room to spare, so the type choice never limits the preset here.
How do I check the screen value against the controller?
Run the timer and compare the same numbers in both places: the screen's numeric display should track the controller's .ACC in 1 ms steps, and the status lamp should switch at the moment the controller's .DN bit switches.
Make the comparison easy: set a test preset of 2000 ms in the controller project, which gives a 2 second cycle you can watch several times without waiting for a full batch.
What each symptom points at:
- A numeric display that stays blank points at the tag address, not the timer; our article on a numeric display that shows nothing starts that check at the tag.
- A number frozen at the target indicates the object is bound to .PRE where you meant .ACC. Check the suffix in the tag name field.
- A lamp that never lights: confirm the object is bound to the tag ending in .DN with BOOL selected, then compare with the controller's .DN bit online.
- A number that counts wrongly: the object's scaling, not the tag; recheck the divide-by-1000 setting from the example.
For the counting display itself, our article on showing an HMI timer counting from a PLC current value covers the object settings once the tag binds.
Keep the guarding in the controller: the screen is a view for people, and no interlock should depend on a panel refresh. A lamp-and-number view belongs on the HMI panel; a standalone status board for the aisle is a separate job, and our factory and plant displays are built for it: they play their own content from a card or USB stick and take no video input from the controller.
When is importing the tag database faster than typing names?
When a screen draws members from several structures, stop typing names: export a small test project from the controller software, import the file into the HMI editor, and let the import expand the structures into member tags automatically.
Build the test project in the controller software with every data type the screen will show, export it in the interchange format those controllers use (the L5K export), and import the file in the editor's tag configuration. The import expands the structures into member tags, so the names and types arrive already matched. Review the imported names against the controller project and against the objects that use them before the panel goes into production, because an import carries in whatever the test project contained.
Typing four names per timer is quick work. Once a screen draws members from more than three timers, twelve or more member names, the import wins on accuracy as well as speed.
Recommendation: put the member in every timer tag, .ACC and .PRE as DINT and .TT and .DN as BOOL, one tag per member the screen shows. Type the names while a screen needs members from three timers or fewer; switch to importing the controller's exported tag database once a screen draws on more than three.
Questions
Can I write a new preset from the screen, or is a timer member read-only?
Yes for .PRE. Bind a numeric entry object to TIMERNAME.PRE with DINT selected and type the value in milliseconds, so a 45 second preset is entered as 45000. Leave .ACC as a display value; the preset is the member an operator has a reason to change. After you enter a new preset, watch the controller's .PRE member change to confirm the write landed.
Does the same member notation work for an array of timers?
Yes. Put the array index before the member suffix: for a timer array named LINE_TIMERS, element 2's accumulated value is LINE_TIMERS[2].ACC with DINT, and its done bit is LINE_TIMERS[2].DN with BOOL. Create one tag per member you display, exactly as with a single timer. An editor that imports the controller's tag database expands array elements into individually addressable names too.
Do register-based PLCs use member suffixes too?
No. On a register-based PLC a timer lives in fixed data registers, so you address the accumulator and preset by register number, and the status bits come from bits in an adjacent control word, not from a dot suffix. The design rule carries over unchanged: numeric members take a signed integer type and status bits take BOOL. Check your controller's timer instruction reference for the exact register layout.
Planning information, not legal or engineering advice. Rules differ by place: check codes and permits with your local authority and your licensed trades.