Skip to main content

Expressions

Expressions are a type of value supported in several different parts of an adapter script. Expressions allow a value to be calculated as a kind of mathematical or logical formula using other identifiers. Identifiers are variables or data sources defined in the script.

Variables come from the variables section of a config. A variable is a named list of operations applied to other variables or data sources.

Data sources are defined in other sections specific to a particular connectivity type. Some examples of data sources would be:

  • Pins for Labjack U3/T4/T7 integrations
  • Registers and coils for Modbus-TCP integrations
  • Tags for Ethernet/IP and OPC-UA integrations
  • Declared keys for MTConnect and MTConnect Adapter integrations

Some expressions used within variable definitions also support the special "this" identifier. The this identifier represents the result of the previous step in the variable's operation list.

Where Expressions are Used​

Expressions can appear in several different parts of an adapter script, so there can be some variation in the structure that surrounds them. Here are a few examples of where expressions can be used and what they would look like in that context.

Consider a simple expression that converts a tempoerature from Celcius to Fahrenheit: (temp-in * 9 / 5) + 32

Currently this is just a naked expression with no surrounding context. One place this expression could be put is in the source or expression operation of a variable:

variables:
  temp-f:
    - source: (temp-in * 9 / 5) + 32
variables:
  temp-f:
    - source: temp-in
    - expression: (this * 9 / 5) + 32

The source and expression operations take an expression as their main value. Expressions also appear as the main value of some other operations like and and or.

Expressions also appear in parameters of some more complex variable operations, such as the ammount or reset parameters of the count operation.

variables:
  over-temp-cycle:
    - source: temp-in > 100
    - count:
        amount: 1
        reset: not running

The source operation takes an expression as in the previous examples. Under the count operation, both the amount and reset parameters take expressions as well. Even though amount is the single digit 1, this is still a valid expression and could be a more complex calculation. The reset is an expression referencing another identifier, running.

When looking at an operation's page, pay attention to the Syntax section. Any field that can accept an expresion will be marked as such.

Expressions can show up outside of variables. In the data-items block, they can show up among the list of identifiers to write out as data expressions.

data-items:
  - part-count
  - part-material
  - system-ready: oven-temp > 40

Within the data-items list, part-count and part-material are identifiers that already exist from elsewhere in the script, while system-ready takes its value from the expression oven-temp > 40.

Expressions also show up in numerous places in the conditions block.

conditions:
  coolant-low:
    message: Coolant level is low
    value:
      FAULT: coolant-in < 1.5

Here, an expression is used for determining if this condition is in an active FAULT state.

Expressions vs. String Expressions

Some parts of the condition syntax make use of string expressions, which are strings that can contain expressions within them.

Expression Examples​

Here are a few example expressions. All of the following examples will just show naked expressions without any of the surrounding context of variables or other parts of an adapter script.

Convert a temperature from C to F

(temp-in * 9 / 5) + 32

Check if either is running

spindle-1 or spindle-2

Check if a pin is in a specific range

AIN0 > 1.2 and AIN0 < 3.4

Check if an execution key is set to STOPPED

exec == 'STOPPED'

Cause a counter to reset after counting up to 10

this >= 10

Property Access​

Certain data sources may produce objects or arrays instead of scalar values. Most transforms that expect expressions can access properties in the form of this.propertyname.
For example:

this.temperature * 9 / 5 + 32

If a data source provides items that are already a compound object, it's possible to index into those directly, even at multiple levels. For example:

oil.temperature * 9 / 5 + 32

If a property's name includes spaces or other characters that would make it illegal as an identifier, a square bracket syntax can be used to index into objects instead. For example:

system['X.01'].message

Update Triggers​

Variables and data sources are treated the same way in an expression. When any variable or data source referenced within an expression updates, the entire expression is immediately re-computed. This will cause cascading updates to occur where the expression is used.

For example, if an expression is used in the middle of a variable definition, an expression update will cause the entire variable's operation list to be re-executed with the last data it received. If this causes the variable's value to change, then any other expression that references the variable will be re-computed as well. Avoid creating circular update loops via expressions.

Expressions can also appear in data item and condition definitions, which are responsible for outputting data to the MachineMetrics cloud. If an expression update changes the value of the data item or condition, the update will immediately be sent out.

Operators​

Expressions support the following operators:

  • Arithmetic: +, -, *, /, % (modulus), ^ (power)
  • Boolean: and, or, not
  • Bitwise: &, |, ~, ^|, <<, >>, >>>
  • Relational: >, <, >=, <=, ==, !=
  • Conditional expression: (statement) ? (yes) : (no)

Expressions support grouping statements with parentheses. Parentheses can be nested arbitrarily deep and are useful for more complex logic or forcing order of operations.

Examples:

(temp-in * 9 / 5) + 32
AIN0 > 1.2 and AIN0 < 3.4
hv-relay-on ? hv-analog : (lv-analog * 10)

Functions​

While many capabilities within adapter scripts are supported through chaining operations, some functions are also available within expressions. Expression functions are available anywhere expressions can be used.

Functions are invoked by placing an opening and closing parentheses immediately after the function name, with any parameters placed within the parentheses as a comma-separated list. A nested function call can be used within the parameter list.

Examples:

AIN0 + abs(AIN1)
round(abs(spindle-speed), 2)

Function reference​