# 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**:

1. **Innermost (Function)**: $parse('json', a, '$.reading') extracts the numeric value 125.5.
2. **Middle (Math)**: The relational expression 125.5 > 120.0 is evaluated by the numeric engine, which returns 1.0 (true).
3. **Outermost (Function)**: The $switch function receives 1.0 as its input. It matches the case 1 and proceeds to evaluate the corresponding result argument.
4. **Nested Evaluation**: The $format function is executed, producing the final alarm string.
5. **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**:

1. The $concat function requires all its arguments to be resolved first.
2. **Arg 1**: 'events/' is a literal.
3. **Arg 2**: $parse('json', a, '$.type') is evaluated, returning 'sensor'.
4. **Arg 3**: '/' is a literal.
5. **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'.

6. **Arg 5**: '/' is a literal.
7. **Arg 6**: $parse('json', a, '$.id') is evaluated, returning 'T-101'.
8. **Final Assembly**: $concat combines the resolved arguments.
9. **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**:

1. **Innermost ($function)**: $fromHex(a) converts the string 'A9' to the decimal number 169.
2. **Middle (Math)**: band(169, 8) is executed. The bitwise AND of 10101001 and 00001000 is 00001000, which is the decimal number 8.
3. **Next Level (Math)**: The relational expression 8 > 0 is evaluated, returning 1.0 (true).
4. **Outermost ($function)**: The $switch function receives 1.0 as its input, matches the case 1, and returns the corresponding result.
5. **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)**:

1. $regex(a, 'SPEED=(\[0-9.]+)', 1) finds the pattern and extracts the first capture group, returning the string '1825.5'.
2. $split('1825.5', ';', 0) is technically redundant here but ensures that if there were trailing characters, they would be ignored. It returns '1825.5'.
3. The engine implicitly converts this string to a number and performs the division: 1825.5 / 60, resulting in 30.425.
4. roundn(30.425, 2) rounds the result to two decimal places, returning 30.43.
5. $format('Motor speed is %.2f Hz', 30.43) produces the final output.
6. Final Result: The string 'Motor speed is 30.43 Hz'.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://easyedge.gitbook.io/easyedge/reference/expressions-operations-engine/practical-use-cases.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.