Adjusting values

The write box under the readback accepts native scalar values. Write or Enter in the box sends the edit at once unless Tools → Confirm before writing is on. Enum selection and the Adjust section's slider, dial and step buttons only stage the edit; press Write to send it. Readback stages the exact current value; it is disabled for truncated arrays so an incomplete readback cannot silently replace the full array. It is also disabled for a string that fills the 39 bytes a plain string field is read with (CA DBR_STRING, or QSRV), because a longer field such as DESC or a link may have been cut short; open it with $ (for example rec.DESC$) to read and write the exact text. Over pvAccess, QSRV refuses writes to link fields through $; write links over CA. Readback is also disabled for text holding bytes that are not UTF-8 (shown as U+FFFD), which Write refuses because they cannot be written back exactly. CA exposes 64-bit integer fields as doubles, so readbacks at or above 2^53 in magnitude may be rounded. Readback and Undo are disabled for these ambiguous values, including arrays, unknown record types and fields whose type metadata has not arrived. Identified scalar VAL fields of standard ai, ao, calc, calcout and sub records remain available because they are actual doubles. Use pva:// for exact 64-bit integer readbacks and Undo. Explicit integer text, including quoted integers in JSON arrays, writes exactly over CA only when QtProbe is connected to the IOC itself (see the CA gateway note below). Numeric range controls initially use the IOC display limits and can be changed locally. Changing these limits does not modify the IOC. Controls are disabled when disconnected or while a write is pending. The write box and Adjust are hidden in a read-only session and for PVs the server reports as not writable; they stay in place during a disconnect. The server (IOC or gateway) remains authoritative for access and accepted limits. Write results and errors appear on the line below the box. Adjust has Min, Max and Step fields, a slider between − and + step buttons, and Dial reveals the optional dial. CA writes and Process use a put with completion callback (unlike the Motif Probe's plain put): the result line reports completion after the record finishes processing, and no other write to that PV is sent meanwhile. If completion takes longer than 10 s (a long motor move or another asynchronous record), the result line says the record is still processing and QtProbe keeps waiting while the PV stays connected; the result is reported when the server sends it. Reconnect or Stop abandons the wait, and a disconnect during the write leaves its outcome unknown: inspect readback and reconnect before another write is enabled. Through a CA gateway, a write interrupted by the gateway losing the IOC is reported as "Channel write request failed"; arriving with the disconnect, it is also treated as unknown. Check readback after any failed write through a gateway. Stop fields such as a motor's STOP are separate PVs and can be written from their own inspector. A failed CA put of two or more numeric or string elements may have changed earlier elements before the IOC rejected a later one (byte arrays and $ fields are copied whole). QtProbe requests fresh readback, reports the potentially partial write, disables Undo and keeps further writes disabled until Reconnect. CA array writes are not transactional; a failure does not imply that the whole array stayed unchanged. After a pvAccess string or array put, QtProbe checks readback for server size limits. Its completion message warns if the server kept fewer elements or shortened a string, including individual elements of a string array.

Undo writes back the exact value QtProbe last received before your last successful write from this inspector; its tooltip shows that value. A monitor deadband (MDEL, or a dbnd filter in the name) can hide small changes made by others since then; the confirmation's current value is that same value. Undo is itself a write, so pressing it again restores the value it replaced. Undo sends the saved elements as they were received, so enum states and byte arrays are restored exactly. It is unavailable after a write that replaced a truncated array (see --max-elements) or a plain string that filled 39 bytes, because the full earlier value is not known; after a write that replaced a plain string holding bytes that are not UTF-8, because those bytes cannot be written back exactly (a $ field or character array keeps an exact Undo); and after a write whose outcome is unknown, because the PV may hold either value. Undo is also disabled if the PV's type, scalar/array shape, state list or CA array capacity changes. A scalar readback cannot restore a replacement array. An earlier CA value that may hold a rounded 64-bit integer cannot be restored with Undo, including while the record type is not yet known after a reconnect; the tooltip explains this limit.

Process (the circled triangle beside Reconnect) writes 1 to the record's PROC field, as caput rec.PROC 1 does. It appears for Channel Access PVs when the PROC field is connected and writable, and never in a read-only session.

Tools → Confirm before writing (off by default) asks before each write, Undo and Process, showing the new and current values as they are sent (enum states with their labels, arrays with their element counts); the setting is remembered. If the PV's type, states or array format changes while the question is open, the write is refused; check the PV and enter the value again. Tools → Write log lists every write and Process requested in this session, newest first, with the time, PV, value before, value written and the result, including failures and refusals. Export CSV… saves the log; Clear empties it. The log holds the latest 1000 entries, with each value limited to 1000 characters, and is not saved between sessions.

Integer writes are range checked for the type the server reports and are sent without losing 64-bit precision. Channel Access reports USHORT fields as LONG, and ULONG and 64-bit integer fields as DOUBLE. CA scalar writes outside 0–65535 to a LONG or of 2^32 or more to a DOUBLE, and array elements of 2^53 or more, are therefore sent as integer text that the IOC parses for the field's own type, exactly or rejected as out of range. Other CA array elements, and negative values written to unsigned fields (as with caput), are converted by the IOC without a range check; use pva:// for exact type checks. A CA readback of a 64-bit field beyond 2^53 is rounded, so use pva:// to read it exactly. Through a CA gateway (ca-gateway or another relay built on the EPICS portable CA server), the gateway converts each CA write to the type it reports for the field before the IOC sees it: DOUBLE for ULONG and 64-bit integer fields, LONG for USHORT. Integer text, in scalars and arrays alike, is then converted by the gateway instead of being parsed by the IOC, and the result still reads "Write completed". Values beyond 2^53 in magnitude are rounded to the nearest double, and values near or outside the field's limits are stored as other values instead of being rejected. USHORT wraps modulo 65536 (70000 stores 4464). On a Linux x86-64 IOC built with GCC, ULONG wraps modulo 2^32 (4294967296 stores 0); UINT64 values from 2^64−1024 upward, including 18446744073709551615, are stored as 0; and INT64 values from 2^63−512 (9223372036854775296, a valid value) upward, or below the INT64 range, are stored as the most negative 64-bit integer. IOCs built for other platforms or with other compilers can store other wrong values. CA scalar writes to LONG and USHORT fields beyond ±2147480000 fail at the gateway, including valid LONG values; nothing is written. Write USHORT, ULONG and 64-bit integer fields, and LONG scalars near the 32-bit limits, with pva:// when CA goes through a gateway. Numeric adjustments are disabled for 64-bit integers beyond the exact range of double; use the native value editor for those values. Hexadecimal integers can use 0x. Floating-point writes must be finite. Enum writes accept a label or a valid index; when a label reads as a number, typed text selects that label. The state list and Readback stage text that selects the chosen state. CA and PVA text is UTF-8; CA strings hold at most 39 UTF-8 bytes. Bytes that are not UTF-8 show as U+FFFD and cannot be written back. Text writes and string-array elements reject embedded NUL characters. A byte array takes binary data as a JSON array only while it shows numeric values; while it shows text, anything typed, including [1, 0, 2], is written as text. Array writes use JSON: [1, 2, 3] or ["one", "two"]. Quote integers above 2^53−1, for example ["18446744073709551615"], to avoid JSON numeric precision loss. Array writes replace the value array; empty array writes are not supported. A server may shorten a string or array to its field size without an error (an IOC keeps 15 bytes of EGU and 25 of a state name; QSRV keeps 39 bytes of a string field and NELM elements), so QtProbe reads CA string writes and PVA string and array writes back, and the result line says when the server kept less than was sent. QSRV reads fields other than VAL (links, DESC) back as 39 bytes; then the result line asks you to check the field with $. Arbitrary PVA structures/unions are inspection only unless they contain a supported scalar/array value or NTEnum value.index.