System Functions

The functions listed here can be used in expressions in Comfile Studio.

Math Functions

asin(value) : Arc-Sine
acos(value) : Arc-Cosine
atan(value) : Arc-Tangent
avg(x,y,z,…) : Returns the average of all values in the argument list
ceil(value) : Rounds number up to the nearest integer value.
cos(value) : Cosine
cosh(value) : Hyperbolic Cosine
exp(value) : e raised to a given exponent
fabs(value) : absolute value
fmod(x,y) : the remainder of x divided by y.
floor(value) : Rounds number down to the nearest integer value.
log(value) : Natural Logarithm
log10(value) : Log base 10
max(x,y,z,…) : Returns the largest value from the argument list
min(x,y,z,…) : Returns the smallest value from the argument list
max_index(x,y,z,…) : Returns the index of the largest value in the argument list
min_index(x,y,z,…) : Returns the index of the smallest value in the argument list
pow(x,y) : x raised to the power y
sin(value) : Sine
sinh(value) : Hyperbolic Sine
sqrt(value) : square root
stdev(x,y,z,…) : Returns the standard deviation of all values in the argument list
tan(value) : Tangent
tanh(value) : Hyperbolic Tangent

Bit, Byte, and Word Manipulation Functions

<html>
```
bit(subject, bitIndex)
```
</html> : Returns the value of the bit at bitIndex in subject. subject can be an expression or a variable name, but if it is a variable name, it must must be enclosed in double quotes. bitIndex can be an integer from 0 through 31.
```
bitValue = bit("a", 3)
bitValue = bit(a + 3, 1)
```
<html>
```
set_bit("variable_name", bitIndex, value = 1)
```
</html> : Sets the value of the bit at bitIndex in variable_name to value. variable_name is a variable name that must be enclosed in double quotes. bitIndex can be an integer from 0 through 31. value is optional and defaults to 1.
```
set_bit("a", 3, 1)
```
<html>
```
toggle_bit("variable_name", bitIndex, value)
```
</html> : Toggles the value of the bit at bitIndex in variable_name. variable_name is a variable name that must be enclosed in double quotes. bitIndex can be an integer from 0 through 31.
```
toggle_bit("a", 3)
```
<html>
```
hibyte(input_value)
```
</html> : Returns the most significant byte of input_value.
```
hibyte(0x1234) // returns 0x12
```
<html>
```
lobyte(input_value)
```
</html> : Returns the least significant byte of input_value.
```
lobyte(0x1234) // returns 0x34
```
<html>
```
hiword(input_value)
```
</html> : Returns the most significant word of input_value.
```
hiword(0x12345678) // returns 0x1234
```
<html>
```
loword(input_value)
```
</html> : Returns the least significant word of input_value.
```
loword(0x12345678) // returns 0x5678
```

String Functions

find_text(string_to_search, string_to_find) : Returns the character index of string_to_find in string_to_search. Returns -1 if not found.
num_to_text_int(number) : Prints a number as a base 10 integer character string.
num_to_text_int(number, digits) : Prints a number as a base 10 integer character string with leading 0's. Ex: num_to_text_int(3.14, 4) prints “0003”.
num_to_text_hex(number) : Prints a number as a base 16 integer character string.
num_to_text_hex(number, digits) : Prints a number as a base 16 integer character string with leading 0's
text_hex_to_num(hexadecimal_string) : Returns the binary number corresponding to hexadecimal_string. For example, if hexadecimal_string is “FF”, 255 will be returned.
num_to_text_dec(number, fractional digits) : Prints a number as a base 10 character string with a given number of fractional digits. Ex: num_to_text_dec(3.14159, 4) = “3.1416”

text_starts_with(target_string, prefix, ignore_case): Returns 1 if target_string begins with prefix. Returns 0 otherwise. If ignore_case is non-zero it will do a case-insensitive search. ignore_case defaults to 0.

text_starts_with("BREAKFAST", "break")    // Returns 0
text_starts_with("BREAKFAST", "BREAK")    // Returns 1
text_starts_with("BREAKFAST", "break", 1) // Returns 1
text_starts_with("BREAKFAST", "break", 0) // Returns 0

text_ends_with(target_string, suffice, ignore_case): Returns 1 if target_string ends with suffix. Returns 0 otherwise. If ignore_case is non-zero it will do a case-insensitive search. ignore_case defaults to 0.

text_ends_with("BREAKFAST", "fast")    // Returns 0
text_ends_with("BREAKFAST", "FAST")    // Returns 1
text_ends_with("BREAKFAST", "fast", 1) // Returns 1
text_ends_with("BREAKFAST", "fast", 0) // Returns 0

text_to_num(string) : Parses a character string in base 10.
replace_text(string_to_search, string_to_find, replacement) : Replaces any occurrence of string_to_find in string_to_search with replacement. String variable names must be enclosed in double quotes with the $ prefix omitted.
```
$var = "I ate lunch."; Replace_text("var", "lunch", "dinner")
```

Text Memory Functions

Text memory is a specific string memory area in the HMI runtime. The contents are lost when the panel PC is powered off. It is similar to internal memory except it stores strings. The default capacity of the text memory is 1024 strings (0 ~ 1023) and each string is default initialized to an empty string. The capacity can be expanded with the set_tmem_size function.

<html>
```
set_tmem_size(maximum possible number of strings)
```
</html>: Sets the maximum capacity of text memory up to 100,000 strings.
<html>
```
tmem(address)
```
</html>: Reads a value from a specific address (i.e. index) in text memory.
<html>
```
set_tmem(address, "string value")
```
</html>: Writes a string at a specific address (i.e. index) in text memory. You can increase the parameters by concatenating them with commas to record the string consecutively. Example: <html>
```
set_tmem(10,"one","two","three")
```
</html> will set strings at address 10, 11, and 12 respectively.
<html>
```
text_split("string","separator", start address to contain the result, maximum number of results)
```
</html>: Divides the string with a specific separator and writes the result to text memory. The maximum number of outputs is optional. Example: If <html>
```
text_split("a#b#c#d"),"#",10,3)
```
</html> is executed, “a” will be written to address 10, “b” will be written to address 11, and “c” will be written tot address 12.
<html>
```
text_merge(start address, number, "separator")
```
</html>: Concatenates strings in text memory joined by a separator and returns the result as a single string. Example: If <html>
```
text_merge(10,3,"-")
```
</html> is executed when “aa” is at address 10, “b” is at address 11, and 'c' is at address 12, the string “aa-bc” is returned.

Communication Functions

The following functions can be used to detect communication problems between the ComfileHMI and the PLC.

timeout_result() : Returns 1 if the last communication resulted in a timeout waiting for a response. Returns 0 if no timeout occurred. To have a specific action for each external device execute when a timeout occurs, check [External Device Properties > Run an Action Group When a Timeout Occurs With This External Device] and create a user action group.
timeout_count() : Returns the total number of times a communication timeout occurred since the project was executed.
reset_timeout_count() : Resets the timeout count returned from timeout_count() to 0.

Internal Memory Functions

The following functions are used to read from and write to internal memory.

mem(index) : Reads the value current stored in internal memory at index.
membit(index, bit_index) : Returns 1 if the bit at bit_index is ON or 0 if the bit at bit_index is OFF. bit_index can range from 0 through 31 with 0 corresponding to the least significant bit.
```
switch = membit(50,3)
```
set_mem(index, value) : Writes value to internal memory at index.
set_mem(index, value1, value2, …, valueN)
set_membit(index, bit_index, bit_value = 1) : Turns ON or OFF a bit at bit_index in the internal memory location at index. bit_index can range from 0 through 31 with 0 corresponding to the least significant bit. If bit_value is 0, the bit is turned OFF, and if bit_value is not 0, the bit is turned ON. If bit_value is omitted, it defaults to 1.
```
set_membit(50,15)
set_membit(50,3,0)
```
toggle_membit(index, bit_index) : Toggles the bit at bit_index for the value in internal memory at index. bit_index can range from 0 through 31 with 0 corresponding to the least significant bit.
```
toggle_membit(40,7);
```

File Functions

base64_to_file(base64_string, file_path, append) : Decodes base64_string and saves it to the the file specified by file_path. If append is 1 the data is appended to the end of the file. If append is 0, the file is overwritten.
```
base64_to_file($base64_data, "storage card\myfile.bin", 1)
```
delete_file(file_path): Deletes the file from the file system.
delete_folder(folder_path) : Deletes the folder and all containing subfolders from the file system.
```
delete_folder("storage card\folder1")
```
ensure_folder_exist(folder_path) : Ensures a folder exists. The folder, and any required parent folders, are created if it does not exist.
```
ensure_folder_exist("storage card\folder1\folder2")
```
file_exists(file_path): Returns 1 if file_path exists, 0 if not.
```
file_exists("storage card\myfile.txt") == 1
```
file_to_base64(file_path): Returns the contents of the file specified by file_path as a base 64 string.
```
$base64_data=file_to_base64(“storage card\data.bin")
```
file_to_text(file_path): Returns the contents of file_path as a string. If the file's contents have the byte-order mark FF FE, the contents of the file will be Unicode encoded.
```
$content = file_to_text("storage card\myfile.txt")
```
text_to_file(string, file_path): Stores string variable string to the file file_path.
```
text_to_file($content, "storage card\myfile.txt")
```
file_size(file_path): Returns the size of the given file in bytes.
rename_file(existing_file_path, new_file_path): Renames existing_file_path to new_file_path.

Remote Script Functions

write_byte(value): Writes a single byte of binary data to the response of a remote script. Returns 1 on success and 0 on failure.
write_word(value): Writes 2 bytes of binary data in little endian to the response of a remote script. Returns 1 on success and 0 on failure.
write_dword(value): Writes 4 bytes of binary data in little endian to the response of a remote script. Returns 1 on success and 0 on failure.
write_text(string): Writes a UTF-8 string to the response of a remote script. Returns 1 on success and 0 on failure.
write_file_contents(file path): Writes at most 1MB of binary data from a file to the response of a remote script. Returns 1 on success and 0 on failure.

Trend Graph Functions

trendgraph_restart(trendgraph_alias) : Clears the trend graph identified by trendgraph_alias and begins sampling.
```
trendgraph_restart("my_graph")
```
trendgraph_stop(trendgraph_alias, clear = 0) : Stops the trend graph identified by trendgraph_alias and optionally clears the trend graph according to the clear flag (default 0).
```
trendgraph_stop("my_graph")
trendgraph_stop("my_graph", 1)
```

Type Conversion Functions

Functions to convert between data types.

<html>
```
bytes_to_float("variable1", "variable2", "variable3", "variable4")
```
</html> : Assembles a floating point value from the provided byte variables. variable1 is the least significant byte and variable4 is the most significant byte. variables are case-sensitive and must be enclosed in double quotes. Example: <html>
```
float_to_bytes(3.14, "a", "b", "c", "d");result = bytes_to_float("a", "b", "c", "d")
```
</html> ⇒ result will contain the value 3.14.
<html>
```
float_to_bytes(floatValue, "variable1", "variable2", "variable3", "variable4")
```
</html> : Decomposes a floating point value into its composed bytes. Afterward the bytes can be manipulated in various ways to, for example, change the byte order and store the values in addressable internal memory. variable1 is the least significant byte and variable4 is the most significant byte. variables are case-sensitive and must be enclosed in double quotes.

Conditional Branching Functions

select_if(conditional_expression, Value1, Value2): Returns value1 if conditional_expression is true, or value2 if conditional_expression is false.
select_case (default_value, conditional_expression_1, value_1, conditional_expression_2, value_2, conditional_expression_3, value_3, …): Arguments are evaluated sequentially. If conditional_expression_1 is true, value_1 is returned. Else, if conditional_expression_2 is true, value_2 is returned. Else, if conditional_expression_3 is true, value_3 is returned, etc. If none of the conditional expressions are satisfied, default_value is returned. value_{index} arguments may can be strings, but in that case, they must all be strings.
(Example 1) select_case (1000, a>5, 100, $b==” APPLE”, 200) ⇒ 100 is returned if a is greater than 5, 200 is returned if the value of the internal string variable $b is “APPLE”, and 1000 is returned if neither case is true.
(Example 2) select_case (“NORMAL”, temp>100, ”HOT”, temp<0, ”ICE”) ⇒ If temp is greater than 100, “HOT” is returned, and if temp is less than 0, “ICE” is returned. If neither condition is true “NORMAL” is returned.
select_by_key(default_value, key_expression, key_1, value_1, key_2, value_2, key_3, value_3, …) If key_expression is equal to 2, value_2 is returned, if key_expression is equal to key_3, value_3 is returned, etc. (The return value, default_value, and value_{index} can be strings, but in that case they must all be strings.
(Example 1) select_by_key(-1,a+b,10,100, 20,200, 30,300) ⇒ If a+b is 10 100 is returned, if it is 20 200 is returned, if it is 30 300 is returned, otherwise -1 is returned.
(Example 2) select_by_key(0, $a+$b,”ONE”,1 ,”TWO”,2 , “THREE”,3) ⇒ If $a+$b is “ONE” 1 is returned, if “TWO” 2 is returned, if “THREE” 3 is returned, otherwise 0 is returned.
(Example 3) $a=select_by_key(“NOTHING”, a+b,1,”ONE” ,2,”TWO”, 3,“THREE”) ⇒ If a+b is 1 “ONE” is returned, if it is 2 “TWO” is returned, if it is 3 “THREE” is returned , otherwise “NOTHING” is returned.
select_by_index(default_value, index_expression, start_index, value_1, value_2, value_3, …) If index expression evaluates to the start index value_1 is returned, if index_expression evaluates to start index + 1 value 2 is returned, if index_expression evaluates to start_index + 2 value_2 is returned, etc. Otherwise, default_value is returned. (The return value, default_value, value_{index} can be strings, but in that case, they must all be strings)
(Example 1) var = select_by_index(-1,a,5,100,200,300) ⇒ If a is 5 100 is returned, if 6 200 is returned, and if 7 300 is returned. Otherwise -1 is returned.
(Example 2) $result = select_by_index(“NOTHING”,a,5,”A”,”B”,”C”)⇒ If a is 5 “A” is returned, if a is 6 “B” is returned, If a is 7, “C” is returned, otherwise “NOTHING” is returned.