# Input

> Operator value entry written to a point: the box takes what the point takes, and refuses the rest with the reason.

**Input** is the operator's entry field: a draft the operator owns, and a **Set** key
that sends it to a point through the station's single write funnel. It draws no reading
of its own: whoever wants the point's value beside the box composes a
[Value](component-value) next to it, and naming the field is a
[Label](component-label). It is a *Control* component; a new one occupies 4 × 1 cells.

The draft belongs to the operator: the live refresh never overwrites what was typed,
and a refused entry stays in the box so the correction is an edit, not a retype.

## Data {#data}

| Field | What it does | Values | Default |
|---|---|---|---|
| Address | The rooted Logic address of the written point: a memory variable, a writable tag, a unit's staging field (`Next.<field>`) or the run comment point (`Commands.Comment`). Nothing is ruled out here: what the box then accepts is read off the point itself. | Free text; suggestions from the live point list | empty |

Under the address, the panel prints what the field takes right now ("This field takes a
number, 0 to 100, to 1 decimal place."), so a two-state point is seen turning the row
into a key per state before the screen ever runs.

## What the box takes {#what-the-box-takes}

The entry kind is **derived from the point**, never chosen beside it: a category you
could state against the point would be a second declaration, free to disagree with the
one the point already makes:

| The point | The box | Conduct |
|---|---|---|
| A Boolean point | A key per state (**On** / **Off**) instead of a box | One touch is the whole instruction. The keys carry absolute values, so they stay usable under bad quality, unlike the [Toggle](component-toggle), which must know the reading it negates. Neither key shows the point's state. |
| An integer point | A whole-number box | Decimal entries are refused; the touch keyboard offers digits. An integer tag whose Scale or Calibration changes the value takes a decimal number: its engineering value is a real. |
| A real (decimal) point | A number box | Judged against the band and the declared places when **Set** is pressed, never per keystroke; the touch keyboard offers a decimal pad. |
| Text, an instant, a staging or comment point, or an address nothing answers yet | A free text box | The band and decimals are not read, and the panel says so. |

## Number {#number}

The band and the fineness the operator states *on top of* the point:

| Field | What it does | Values | Default |
|---|---|---|---|
| Minimum | Lowest number the field sends. Blank leaves that side of the band open. | Any number, or blank | blank |
| Maximum | Highest number the field sends. Blank leaves that side open. A minimum above the maximum leaves no number between them, and the panel warns that the field would refuse every entry. | Any number, or blank | blank |
| Decimals | How fine an entry the field sends. Blank sends whatever precision was typed. A point that counts pins it at 0 whatever is stored. The places are asked of the value, not the digits: `12.500` is `12.5`, so trailing zeros a keypad added are never refused. | 0 to 15, or blank | blank |

A tag that declares limits of its own (its **Limits** conversion stage enabled) tightens
whatever is stated here: the field accepts only what the typed value pipeline would
carry through unchanged.

An entry outside the band, too fine, or not a number at all is **refused with the
reason and nothing is written**. The number is an instruction to the plant, and a
different one taken at the edge would be the station deciding for the operator. This is
deliberately the opposite of the editor's own configuration fields, which take an
out-of-band entry at the nearest edge and say so.

## Write semantics {#write-semantics}

- **Memory variable**: the draft is validated against the variable's output category,
  then written through the logic funnel. An empty box writes an empty value.
- **Writable tag**: the draft goes to the funnel as the engineering value, never
  converted to the tag's node type first. The funnel de-calibrates and de-scales it on its
  way to the wire (the tag's conversion pipeline in reverse), so 0.5 on an Int16 tag scaled
  by 0.1 reaches the device as 5. A value the node type cannot hold once de-scaled (a
  negative number into an unsigned type, one past the type's maximum) is refused with the
  type's range, and nothing is written.
- **`Next.<field>`**: stores the text in the unit's staging area for the next run.
  Staging is preparation, not a plant write: no funnel, no journal entry. The answer
  line says "Staged".
- **`Commands.Comment`**: appends a run comment (or a post-run note while idle) to the
  unit's active context, attributed to the signed-in operator; the box clears and the
  answer line says "Comment added". An empty comment is refused.

The transient answer line reports every outcome and expires after a few seconds.
Authorization is re-checked at the press. In a cell with no line for it and no corner title
standing over the row, the answer takes the **Set** key's word while it shows (over a
two-state point, the word of the key that was pressed), a refusal in the error ink. The key
keeps its width, so what it cannot hold ends in an ellipsis with the whole answer in the
tooltip, and the field never moves.

The field is the one that waits for the equipment, not the Logic, so the line reports what
became of the value and not merely that it was sent. A refusal is written in the words of
whoever refused it: the station's own for what it settled before sending ("'Setpoint' was
not written: the device is not connected.") and the equipment's or its driver's for what
happened on the wire. A value that a newer entry on the same point overtook before it was
sent is not a refusal and says nothing: the newer value is the one the plant is given.

## Permissions and the lock {#permissions-and-the-lock}

Writing a variable or tag needs the role permission to operate dashboards; the staging
and comment points are Process mutations and need the run-procedures permission
instead. A blocked press draws the shared lock mark with the reason in the tooltip, and
the box itself is disabled while locked (see the [dashboards page](home)). A bound point
that fails to read wears the shared bad-reading mark; the flag keys and the text box
remain usable, since their instruction does not depend on the reading.

The shared Appearance, Identification, Position and layer and Actions sections are
described on the [components page](components#the-shared-property-sections).