An HMI numeric entry changes a PID setpoint when its analog tag points at the same PLC variable wired to the loop's SP node. Match Memory Type and Address to that variable, choose Signed int 16 or Unsigned int 16 to match its signedness, and set entry limits from the instrument span. A 0-100 inch loop takes an unsigned 3-digit entry capped at 100.
A numeric entry on the panel changes a PID setpoint by writing one PLC variable: the one your controller program wired to the loop's SP node. The screen has no private path into the loop, so the whole job is pointing an analog tag at that variable with the right memory type, the right address, and a 16-bit type that reads the bits the way the controller declared them. Add entry limits that fit the transmitter's span and the operator can retarget the loop from the screen with a 3-digit entry. The walkthrough below assumes a controller whose word memory is addressed as %R registers and a panel whose tag database offers Signed int 16 and Unsigned int 16; every other panel and controller pair follows the same sequence with its own names.
Where does a PID loop get its setpoint?
The loop reads its setpoint from the PLC variable wired to the SP node of the PID function, and your numeric entry works by writing that same variable, because the panel never connects to the loop block directly.
Name the three signals and the wiring becomes obvious. The PV is the measured process value, scaled in the controller into engineering units. The SP is the target the loop drives toward. The CV is the loop's output, in this application headed for an analog output channel. Each time the loop executes it compares PV with SP and adjusts the CV.
If the SP node is wired to a constant, retarget it to a variable first: a constant has no register for a tag to write, so no screen object can ever move that loop. While you are in the program, read the variable's live value online; a number you recognize confirms you are looking at the right operand before the panel work starts.
A plant-wide view of those three values is a different screen doing a different job. If you want one, our shop-floor signage displays play the content you publish, and the setpoint write stays with the HMI.
What do you need before building the panel screen?
You need four things in hand: the controller program with online access to read the SP variable, a configured communications entry in the panel project, the numeric entry range chosen from the instrument span, and a decision on signed versus unsigned made before any tag reaches a screen.
- Controller programming software with online access, so the SP variable's live value and address come from the controller itself, not from a screenshot or a guess.
- The panel project open, with its communications entry for this controller already exchanging data with the PLC.
- The entry range, decided from the transmitter span and the process limits before you draw the object.
- The signedness choice for the tag, which the next section settles.
Two of the four are one-time reads. Once the address and the type are on paper, the panel work itself takes minutes.
Which register does the analog tag point at?
The tag points at the exact memory type and address your program assigned to the SP variable, read live in the controller software; in the documented setup that is a %R register, and in your program it is whatever the rung prints.
The rung that wires the variable to the SP node gives you both facts: the memory type, register word data addressed as %R in the documented setup, and the register number. Go online and read the value at the same time; a live number you recognize confirms the register before any tag exists.
If the wiring runs through a move you cannot read at a glance, open the controller's PID setup screen. The documented dialog for loop configuration lists the addresses assigned to each loop's parameters, and the SP variable is among them.
Address formats are not portable between controller families, and the panel expects the format its driver defines. The article on why HMI tag address formats change between PLC protocols shows what moves when you retag the same value for a different controller.
Signed int 16 or Unsigned int 16 for the setpoint tag?
Match the tag type to the controller variable: Unsigned int 16 covers 0 to 65,535 and fits any setpoint that never goes negative, while Signed int 16 covers -32,768 to +32,767 and is required the moment the target can sit below zero.
Sixteen bits hold 2^16 = 65,536 distinct codes. Unsigned numbering spends them on 0 through 65,535. Signed two's complement splits them into -32,768 through +32,767. The same bit pattern means different numbers under the two names: a register holding the pattern for -10 displays as 65,536 - 10 = 65,526 on a tag set to Unsigned int 16.
IEC 61131-3, the standard that names PLC data types, calls the 16-bit signed integer INT and the 16-bit unsigned type UINT. The panel's Signed int 16 and Unsigned int 16 carry the same widths, so the rule is simple: read the controller variable's declaration and set the tag to agree. Where the two tools name types differently, the panel's controller setup documents the mapping; one documented pairing maps the controller's Unsigned Word type to the panel's Unsigned int 16.
Decide the type before the first screen is drawn; the panel's editor makes a used tag's type hard to reverse.
What are the steps in the panel project?
Five steps take the project from an empty tag database to a working entry: find the SP variable, read its address online, add the analog tag, point a numeric entry object at it, and save before you test.
- Find the PID function in the controller program and note the variable wired to its SP node. If that node holds a constant, replace it with a variable first.
- Go online, read the variable's live value, and note its memory type and address, for example its %R register number.
- Open the panel project's tag database and click Add.
- Under Device Name, select the communications entry bound to this controller. The first entry is created as DEV001; in a multi-controller project this field, not the address, decides which PLC the tag reaches.
- Type a tag name, and under Tag data type select Signed int 16 or Unsigned int 16 per the signedness decision.
- Set Memory Type and Address to the exact assignment from step 2.
- Save, then place a numeric entry object on the screen, assign the tag to it, and set its minimum, maximum and digit count.
If the panel refuses the address when you accept the tag, the usual cause is a memory type that disagrees with the address, and the article on fixing HMI invalid address errors when tagging PLC memory walks that check. The object writes the tag when the operator presses Enter, the handoff described in move an HMI numeric entry into PLC memory on Enter. A numeric display object can point at the same tag, but it only reads; the entry object is the one that writes.
What range should the numeric entry allow?
Set the entry limits from the instrument span and the process limits, not from what looks round: a transmitter spanned 4 to 20 mA across 0 to 100 inches gives a natural minimum of 0 and a maximum of 100, entered as a 3-digit number.
Take the numbers from the hardware. The transmitter's span sets the ceiling: 16 mA of span carrying 100 inches works out to 6.25 inches per mA, so a target above 100 inches commands a level the sensor can never confirm. The process sets its own ceilings below that where a full or empty vessel causes damage. Type both numbers into the object's minimum and maximum and the screen rejects 150 and -5 before they leave the panel.
Treat the screen limits as the first filter and the ladder as the backstop: clamping HMI numeric entry limits in PLC ladder logic shows the rung that catches a value that slips past the screen.
A setpoint write acts the moment the controller accepts it, and the loop starts driving its output toward the new target at once. Walk a large change in steps and let the process settle between steps.
How do you check the write reached the loop?
Watch the SP register online in the controller software while you type on the panel: an entry of 50 must appear in the register as 50, and a nudge to 52 must start the output moving toward the new target within the loop's next updates.
Run the panel and the controller software side by side. If the watch never moves, the tag sits on the wrong device entry or the object never wrote; if the watch moves but the number on the panel is absurd, the tag type and the controller variable disagree.
One trap deserves its own line: a numeric display on the same tag follows every change and looks convincing. It only reads. The entry object, or a dedicated write action, is what puts a value into the register.
Worked example: what numbers does a 0 to 100 inch level loop produce?
Take a well-level loop whose transmitter spans 4 to 20 mA across 0 to 100 inches, whose program wires the SP variable to a spare %R register, and whose target never goes negative: every number in the setup follows from those three facts.
The facts in full: CV driving an analog output to the discharge valve, target always 0 inches or more, and the SP variable assigned to a spare %R register. The register number here is illustrative; your rung prints the real one.
Signedness: never negative, plain engineering units, so the tag is Unsigned int 16. Sixteen bits give 2^16 = 65,536 codes numbered 0 through 65,535, and the loop only ever asks for 0 through 100, so the tag has room to spare.
Tag and object: an analog tag on device DEV001, Tag data type Unsigned int 16, Memory Type and Address copied from the rung, and a numeric entry with minimum 0, maximum 100 and 3 digits.
Behavior: the operator enters 62 and presses Enter, the register holds 62, and the loop drives toward 62 inches. An attempt to enter 150 is refused at the object. If the register ever held the pattern for -10, this tag would display 65,536 - 10 = 65,526, the signature of a signedness mismatch, and the reason any loop that can command below zero needs Signed int 16 with its -32,768 through +32,767 span.
Decision: unsigned for this loop; signed the day the application can demand a negative target or a value above 32,767.
Recommendation: tag the setpoint as Unsigned int 16 whenever the controller variable holds plain engineering units that cannot go negative, as in this 0 to 100 inch loop, and use Signed int 16 the moment the process can command a negative target or anything above 32,767. Settle the type before the tag appears on any screen, because changing it later means rebuilding every object that uses the tag.
Questions
Does the loop keep its setpoint if the panel is powered down?
Yes. The target lives in the controller register and the panel only writes and reads it, so the loop holds its last value with the panel dark. Whether the register also survives a controller power cycle or a program download depends on the controller's retentive memory settings, so re-enter the target after any download and confirm it on the online watch.
Can the same tagging method expose the loop's tuning parameters?
Yes. Each tuning parameter takes a tag the same way: P gain, I, D, upper clamp, lower clamp, deadband, slew time and sample period. Keep them off the operator screen unless tuning is part of someone's job. Every extra write path is one more value a stray touch can change, and a mistuned gain moves the output in ways no setpoint entry will.
What if the setpoint value is wider than 16 bits?
Move the number into a wider variable. Sixteen bits stop at 65,535 unsigned or +32,767 signed, so a target of 40,000 units does not fit raw. Store the setpoint in a 32-bit controller variable and use the panel's matching 32-bit integer tag type, or keep 16 bits and store tenths: 0 to 65,535 tenths covers 0 to 6,553.5 units, enough for the 0 to 100 inch example at 0.1 inch resolution.
Planning information, not legal or engineering advice. Rules differ by place: check codes and permits with your local authority and your licensed trades.