Expression Tags

Expression tags compute their value from a formula evaluated by the Expression Evaluator service. Expressions can reference tags, devices, AI models, and model bindings, use arithmetic and logical operators, and call built-in math and statistical functions.

Expressions are evaluated in one of two ways:

Reactive: when a referenced tag updates, the expression re-evaluates immediately (within milliseconds). This is the default whenever the expression references at least one tag — through its value, status, or error code.
Timer-based: if the expression references no tags at all (for example it only references device, model, or binding fields), it evaluates once per second.

Common use cases include:

Unit conversions (e.g. Celsius to Fahrenheit)
Scaling raw signals (e.g. 4–20 mA to 0–100%)
Averaging multiple sensors
Smoothing noisy readings with time-aware filters
Computing rate of change for trend detection
Alarm thresholds with deadband filtering
Health monitoring (react to device or model failures)

References

Type @ in the expression editor to search and insert a reference. The autocomplete menu shows tags, devices, AI models, and model bindings, each with the fields you can reference.

Every reference has three segments — @[Type:Name:field]:

Segment	Meaning
`Type`	`Tag`, `Device`, `Model`, or `Binding`
`Name`	The entity name as it appears in the platform. Bindings use their numeric ID
`field`	`value`, `status`, or `error_code`

The type prefix is not optional

A reference written with only two segments — @[Supply Temp:value] — is treated as a tag reference. So @[OPC-UA Server 1:status] looks like a device reference but is resolved against your tags, and the expression fails with "Could not resolve 'OPC-UA Server 1' to a known tag". Insert references from the @ menu and the prefix is always correct.

Status Values

status is a numeric state, not a true/false flag:

Value	State
`0`	Stopped
`1`	Running
`2`	Failed

Test for the state you actually mean — == 1 for running, == 2 for failed, != 1 for "not running". An expression written as status == 0 to detect a failure never fires, because a failed entity reports 2.

Tag References

Reference a tag's live value, status, or error code:

@[Tag:Temperature Sensor:value]       → current numeric value
@[Tag:Temperature Sensor:status]      → 0 stopped, 1 running, 2 failed
@[Tag:Temperature Sensor:error_code]  → numeric error code (0 = no error)

Referencing a tag through any of these fields makes the expression reactive — it re-evaluates as soon as that tag updates.

Device References

Reference a device's connection status or error code:

@[Device:OPC-UA Server 1:status]      → 0 stopped, 1 running, 2 failed
@[Device:OPC-UA Server 1:error_code]  → numeric error code (0 = no error)

A device has no value of its own — status and error code are the only fields it exposes. Use them to publish a health flag for the connection.

Model References

Reference an AI model's status or error code:

@[Model:Chiller Model:status]      → 0 stopped, 1 running, 2 failed
@[Model:Chiller Model:error_code]  → numeric error code (0 = no error)

Binding References

Reference the raw prediction value from a model output binding. Bindings are identified by their numeric ID, not by a model/output name path:

@[Binding:42:value]       → the binding's output value
@[Binding:42:status]      → 0 stopped, 1 running, 2 failed
@[Binding:42:error_code]  → numeric error code (0 = no error)

Binding value references give you access to a model's prediction output without needing an in-memory tag to historize it first.

A value reference requires its source to be running

Before evaluating, the platform checks every :value reference in the expression. If any of those sources is not running, the expression tag goes to Failed with "Dependency is not running" and the formula is never evaluated. The check covers the whole expression, not just the branch a condition would take, so you cannot switch to a backup tag's value when the primary stops — the expression fails first. Conditional logic on :status and :error_code is safe; conditional logic that chooses between two :value references is not.

Autocomplete helps avoid typos

Always use the @ autocomplete menu to insert references rather than typing them manually. This ensures the name and field are spelled correctly and creates a tracked dependency. If an expression does fail to evaluate, see Expression & Value-Mapping Errors to diagnose it.

Arithmetic Operations

Standard math operators are supported:

Operation	Symbol	Example	Result
Addition	`+`	`5 + 3`	8
Subtraction	`-`	`10 - 4`	6
Multiplication	`*`	`6 * 7`	42
Division	`/`	`20 / 4`	5.0
Power	`**`	`2 ** 3`	8
Modulo	`%`	`10 % 3`	1

Comparison Operations

Comparisons return True or False and are commonly used inside conditional expressions:

Operation	Symbol	Example	Result
Equal	`==`	`5 == 5`	True
Not Equal	`!=`	`5 != 3`	True
Greater Than	`>`	`10 > 5`	True
Less Than	`<`	`3 < 7`	True
Greater or Equal	`>=`	`5 >= 5`	True
Less or Equal	`<=`	`3 <= 5`	True

Logical Operations

Combine conditions with and, or, and not:

True and True    → True
True or False    → True
not True         → False

Math Functions

Built-in math functions for common calculations:

Function	Description	Example	Result
`sin(x)`	Sine (radians)	`sin(1.5708)`	1.0
`cos(x)`	Cosine (radians)	`cos(3.14159)`	-1.0
`tan(x)`	Tangent (radians)	`tan(0.7854)`	1.0
`sqrt(x)`	Square root	`sqrt(16)`	4.0
`exp(x)`	e raised to power x	`exp(1)`	2.718
`log(x)`	Natural logarithm	`log(2.71828)`	1.0
`log10(x)`	Base-10 logarithm	`log10(100)`	2.0
`fabs(x)`	Absolute value	`fabs(-5.5)`	5.5
`ceil(x)`	Round up to integer	`ceil(4.3)`	5
`floor(x)`	Round down to integer	`floor(4.7)`	4
`trunc(x)`	Truncate to integer	`trunc(4.7)`	4
`pow(x, y)`	x raised to power y	`pow(2, 3)`	8
`degrees(x)`	Radians to degrees	`degrees(3.14159)`	180.0
`radians(x)`	Degrees to radians	`radians(180)`	3.14159

Statistical Functions

Functions that operate on lists of values:

Function	Description	Example	Result
`mean(list)`	Average of values	`mean([1, 2, 3, 4, 5])`	3.0
`median(list)`	Middle value	`median([1, 3, 5, 7, 9])`	5
`std(list)`	Population standard deviation	`std([2, 4, 4, 4, 5, 5, 7, 9])`	2.0
`var(list)`	Population variance	`var([2, 4, 4, 4, 5, 5, 7, 9])`	4.0
`min(list)`	Minimum value	`min([5, 2, 8, 1, 9])`	1
`max(list)`	Maximum value	`max([5, 2, 8, 1, 9])`	9
`sum(list)`	Sum of all values	`sum([1, 2, 3, 4, 5])`	15

Random helpers are also available for testing and simulation: random() (float in 0–1), randint(a, b), uniform(a, b), and choice(list).

Lists use square brackets

Statistical functions require a list as input. Create lists using square brackets: [value1, value2, value3]. You can mix tag references and constants inside a list.

Filter Functions

Filter functions smooth, transform, or gate input signals. They maintain internal state across evaluations, so each call remembers its previous output.

filter: Exponential Moving Average

filter(value, tau) applies an exponential moving average. The tau parameter is the time constant in seconds. It controls how quickly the output tracks the input, regardless of how often the expression evaluates.

Parameter	Description
`value`	The current input value
`tau`	Time constant in seconds. Larger values = more smoothing

At each evaluation the filter computes: alpha = 1 - e^(-dt / tau), then output = alpha x input + (1 - alpha) x previous. On the first evaluation the output equals the input.

Expression	Description	Use Case
`filter(@[Tag:Temperature:value], 5)`	5-second time constant	Fast-changing signals, light smoothing
`filter(@[Tag:Pressure:value], 30)`	30-second time constant	Moderate noise reduction
`filter(@[Tag:Level:value], 120)`	2-minute time constant	Very noisy sensors, stable reading needed

Time-aware smoothing

The tau parameter is specified in real seconds, so the filter behaves identically whether the expression evaluates once per second or once per minute. A tau of 30 always means a 30-second time constant.

moving_avg: Moving Average

moving_avg(value, window) computes the average of all samples received within the last window seconds.

Parameter	Description
`value`	The current input value
`window`	Window size in seconds

Expression	Description
`moving_avg(@[Tag:Flow:value], 60)`	Average flow over the last 60 seconds
`moving_avg(@[Tag:Power:value], 300)`	5-minute rolling average of power consumption

rate: Rate of Change

rate(value) returns the rate of change of the input in units per second. It only updates when the input actually changes, so repeated evaluations with a stale value don't distort the result.

Parameter	Description
`value`	The current input value

Expression	Description
`rate(@[Tag:Temperature:value])`	Degrees per second of temperature change
`rate(@[Tag:Level:value]) * 60`	Level change per minute

deadband: Deadband Filter

deadband(value, threshold) only passes through changes larger than threshold. The output holds its last accepted value until the input moves far enough away.

Parameter	Description
`value`	The current input value
`threshold`	Minimum change to pass through (must be > 0)

Expression	Description
`deadband(@[Tag:Setpoint:value], 0.5)`	Ignore changes smaller than 0.5
`deadband(filter(@[Tag:Noisy:value], 10), 1.0)`	Smooth first, then deadband

Conditional Expressions

Use Python's ternary syntax for if-else logic:

value_if_true if condition else value_if_false

Expression	Description
`1 if @[Tag:Switch:value] == 1 else 0`	Binary output based on switch state
`@[Tag:Temp:value] * 1.8 + 32 if @[Tag:Units:value] == 1 else @[Tag:Temp:value]`	Convert to Fahrenheit if units flag is set
`100 if @[Tag:Valve:value] == 1 else 50 if @[Tag:Valve:value] == 0.5 else 0`	Multiple conditions (nested)

Expressions must produce a number

The result of an expression is stored as a number. An expression that returns text — "High" if ... else "Low" — fails to evaluate and the tag goes to Failed. To show a text label for a numeric value, calculate the number here and use value mapping to display it.

Practical Examples

Temperature Conversion

Celsius to Fahrenheit:

@[Tag:Temperature C:value] * 1.8 + 32

Scaling and Offset

Convert a 4–20 mA signal to 0–100%:

(@[Tag:Current:value] - 4) * 100 / 16

Average of Multiple Sensors

(@[Tag:Sensor1:value] + @[Tag:Sensor2:value] + @[Tag:Sensor3:value]) / 3

Device Health Flag

Output 1 while the device connection is up, 0 when it is stopped or failed:

1 if @[Device:Primary OPC-UA:status] == 1 else 0

Device Failure Alarm

Raise an alarm only on a genuine failure, so a device you deliberately disabled does not trigger it:

1 if @[Device:Primary OPC-UA:status] == 2 else 0

Model Health Check

Output 1 when the AI model is running, 0 when it's stopped or failed:

1 if @[Model:Chiller Model:status] == 1 else 0

Alarm with Deadband

High alarm above 95 that ignores input movements smaller than 5 units, so a value hovering around the threshold does not chatter the alarm on and off:

1 if deadband(@[Tag:Process:value], 5) > 95 else 0

Smoothed Differential

Smoothed pressure differential with a 30-second time constant:

filter(@[Tag:Pressure In:value] - @[Tag:Pressure Out:value], 30)

Rate of Temperature Change

Degrees per minute:

rate(@[Tag:Supply Temp:value]) * 60

Smoothed Deadband

Reduce noise first, then gate small changes:

deadband(filter(@[Tag:Vibration:value], 10), 0.5)

Creating a SOAP Tag Importing & Exporting Tags