Practical Use Cases
This final section brings together all the concepts we have discussed by demonstrating how to solve real-world industrial scenarios with a single Computation String. These examples showcase the symbiotic relationship between the high-performance mathematical engine and the flexible dynamic functions, allowing for the creation of powerful, single-line automation logic.
Generating a Conditional Alarm Message
This use case demonstrates the correct pattern for conditional logic that results in a string output. The mathematical if() function (or a direct relational operator) is used to produce a numeric result (1.0 for true, 0.0 for false), which then drives a $switch function to select the appropriate string.
Scenario: A pressure sensor provides its reading in a JSON payload. If the pressure exceeds a dynamic threshold, a formatted alarm message needs to be generated for a monitoring system.
Goal: Create a string like "ALARM: Pressure at 125.5 PSI exceeds threshold of 120.0 PSI", but only if the condition is met. Otherwise, the output should be "OK".
Operands:
a: JSON payload, e.g., {"id":"P-101", "reading":125.5}
b: Numeric threshold, e.g., 120.0
Computation String: $switch($parse('json', a, '$.reading') > b, 1, $format('ALARM: Pressure at %.1f PSI exceeds threshold of %.1f PSI', $parse('json', a, '$.reading'), b), 'OK')
Breakdown:
Innermost (Function): $parse('json', a, '$.reading') extracts the numeric value 125.5.
Middle (Math): The relational expression 125.5 > 120.0 is evaluated by the numeric engine, which returns 1.0 (true).
Outermost (Function): The $switch function receives 1.0 as its input. It matches the case 1 and proceeds to evaluate the corresponding result argument.
Nested Evaluation: The $format function is executed, producing the final alarm string.
Final Result: The string 'ALARM: Pressure at 125.5 PSI exceeds threshold of 120.0 PSI'. If the pressure had been 110.0, the relational operator would have returned 0.0, and the $switch would have returned the default value, 'OK'.
Creating a Dynamic MQTT Routing Topic
This example showcases how multiple $functions can be nested to build complex, data-driven strings, perfect for tasks like creating dynamic topics for MQTT messages or generating structured log entries.
Scenario: Data from various devices needs to be published to an MQTT broker. The topic structure should be [base_topic]/[device_type]/[priority]/[device_id].
Goal: Dynamically construct the full MQTT topic from a single JSON payload.
Operands:
a: JSON payload, e.g., {"id":"T-101", "priority": 1, "type":"sensor"}
Computation String: $concat('events/', $parse('json', a, '$.type'), '/', $switch($parse('json', a, '$.priority'), 1, 'high_priority', 'low_priority'), '/', $parse('json', a, '$.id'))
Breakdown:
The $concat function requires all its arguments to be resolved first.
Arg 1: 'events/' is a literal.
Arg 2: $parse('json', a, '$.type') is evaluated, returning 'sensor'.
Arg 3: '/' is a literal.
Arg 4: A nested $switch is evaluated.
Its input, $parse('json', a, '$.priority'), returns the number 1.
The $switch matches the case 1 and returns the string 'high_priority'.
Arg 5: '/' is a literal.
Arg 6: $parse('json', a, '$.id') is evaluated, returning 'T-101'.
Final Assembly: $concat combines the resolved arguments.
Final Result: The string 'events/sensor/high_priority/T-101'.
Decoding and Checking a Device Status Register
This use case combines hexadecimal conversion with bitwise logic inside a conditional $switch to interpret low-level device data.
Scenario: A PLC provides a status register as a single hexadecimal string. You need to check if a specific error bit (e.g., the 4th bit, which has a value of 8 or 0x08) is active.
Goal: Return a human-readable status string based on the state of a single bit.
Operands:
a: The status register as a hex string, e.g., 'A9' (which is 10101001 in binary).
Computation String: $switch(band($fromHex(a), 8) > 0, 1, 'Overload Error', 'OK')
Breakdown:
Innermost ($function): $fromHex(a) converts the string 'A9' to the decimal number 169.
Middle (Math): band(169, 8) is executed. The bitwise AND of 10101001 and 00001000 is 00001000, which is the decimal number 8.
Next Level (Math): The relational expression 8 > 0 is evaluated, returning 1.0 (true).
Outermost ($function): The $switch function receives 1.0 as its input, matches the case 1, and returns the corresponding result.
Final Result: The string 'Overload Error'.
Extracting, Scaling, and Formatting a Value from a Composite String
This example demonstrates a complete data processing pipeline in one line: it finds a value in a complex string, extracts it, performs a unit conversion, and formats it for display.
Scenario: A legacy device sends a single string containing multiple key-value pairs, like "ID=MOT-03;SPEED=1825.5;TEMP=75.2". You need to extract the speed (in RPM), convert it to Hz, and create a formatted output string.
Goal: Extract "1825.5", calculate 1825.5 / 60, round it to two decimal places, and present it in a descriptive string.
Operands:
a: The composite string from the device.
Computation String: $format('Motor speed is %.2f Hz', roundn($split($regex(a, 'SPEED=([0-9.]+)', 1), ';', 0) / 60, 2))
Breakdown (Inside-Out):
$regex(a, 'SPEED=([0-9.]+)', 1) finds the pattern and extracts the first capture group, returning the string '1825.5'.
$split('1825.5', ';', 0) is technically redundant here but ensures that if there were trailing characters, they would be ignored. It returns '1825.5'.
The engine implicitly converts this string to a number and performs the division: 1825.5 / 60, resulting in 30.425.
roundn(30.425, 2) rounds the result to two decimal places, returning 30.43.
$format('Motor speed is %.2f Hz', 30.43) produces the final output.
Final Result: The string 'Motor speed is 30.43 Hz'.
Last updated