Dokumentacja

Wyrażenia / Język skryptowy

Wieloliniowy język skryptowy z podświetlaniem składni, używany w Smart Rules, Równaniu, Formule i Skrypcie, a także w interfejsach Modbus i Packet Parser.

Podstawy

Przypisanie

1

Mu := Se + 2;

Algorytm wieloliniowy

Każda linia jest oddzielona średnikiem.

1
2


Last := Current;
Current := 0;

Zwracana wartość

Wynik ostatniej linii kodu
RETURN(expression) zatrzymuje wykonanie algorytmu i zwraca wartość podaną w nawiasach

1
2
3


(Co2 > 800) AND (Wind < 10);
equals:
RETURN((CO2 > 800) and (Wind < 10));

Zmienna tymczasowa

Istnieje w ramach pojedynczego wykonania skryptu.

1

VAR X := 5;

Klauzula IF

Styl Excel

1
2


IF(logical_expression, value_if_true, value_if_false);
IF(logical_expression, value_if_true);

Styl wieloliniowy

1
2
3
4
5
6
7


IF X < 5
  RETURN(1);
ELSEIF X > 10
  RETURN(3);
ELSE
  RETURN(0);
END

Switch

Testuje wyrażenie względem listy przypadków i zwraca odpowiednią wartość pierwszego dopasowanego przypadku, z wartością domyślną, jeśli żaden przypadek nie zostanie spełniony.

1

SWITCH(expression, case1, value1, [case2, ...], [value2, ...], default_value)

Przykład:

1
2
3
4
5
6
7
8
9


SWITCH( MODBUSR(H, 168, UInt16),
  0, 0,
  0x0002, 1,
  0x0004, 2,
  0x0008, 3,
  0x0010, 4,
  0x0040, 5,
  0x0800, 6,
  NaN)

Pętla

LOOP / WHILE … powtarza serię poleceń na podstawie określonego warunku, aż warunek przestanie być spełniony. CONTINUE … pomija wykonanie bieżących poleceń i przechodzi do kolejnego cyklu. BREAK … kończy pętlę.

Przykład z warunkiem na początku:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


int i := 10;
while i > 0
    i := i - 1;
    
    if i > 5
        continue;
    else
        break;
    end
loop

Przykład z warunkiem na końcu:

1
2
3
4


int i := 10;
do
    i := i + i;
loop while i < 10

Wartość NaN (not a number)

NaN może być zwrócone jako wartość w przypadku, gdy prawdziwa wartość nie jest znana.

1
2


IF Temperature > 250 
  RETURN(NaN);

Funkcja ISNAN(expression) ZWRACA TRUE, jeśli wyrażenie nie jest liczbą.

ISNULL

Zwraca TRUE, jeśli parametr jest NULL, w przeciwnym razie FALSE. Używana dla typów String i Bytearray. Przykład: jeśli element XML nie zostanie znaleziony, zwrócona wartość to NULL, więc ISNULL zwróci TRUE.

Składnia funkcji:

1

ISNULL(object)

Sleep

Usypia skrypt na określoną liczbę milisekund. Używać tylko w bardzo specyficznych przypadkach.

1

SLEEP(5);

Komentarze

Nowa linia zaczynająca się od znaku #

1

# comment

Liczby stałe

Liczby szesnastkowe

Wyrażenia mogą również interpretować liczby szesnastkowe. Prefiks 0x jest wymagany, dalsza część nie jest wrażliwa na wielkość liter.

0x0A = 10

1
2


0xA0A0   (41120)
0xa0a0   (41120)

Liczby binarne

0b1010 = 10

1

0b10101010   (170)

Wyrażenia matematyczne

+, -, *, /

1

(20.5 + 9.5) / 2    (15)

Wyrażenia logiczne

AND, OR, !, =, !=, >, <

1
2


(!IsRaining OR (Wind>30))
MultiValueSwitchState != 2 (Not equal to 2)

Funkcje

LINEAR

Zwraca wartość przekształconą liniowo – interpolacja liniowa.

1

LINEAR(input, value1_input, value1_output, value2_input, value2_output, [type])

Parametry

input… wartość wejściowa
value1_input… wartość wejściowa na dolnym ograniczeniu
value1_output… wartość wyjściowa na dolnym ograniczeniu
value2_input… wartość wejściowa na górnym ograniczeniu
value2_output… wartość wyjściowa na górnym ograniczeniu
[type]… parametr opcjonalny. Definiuje, jaki ma być wynik, gdy wartość wejściowa wyjdzie poza zakres value1_input ↔︎ value2_input:
- bez parametru (taki sam efekt jak BOUNDS)… jeśli wartość wejściowa wyjdzie poza zdefiniowany zakres, wartość wyjściowa będzie jedną z wartości skrajnych (minimalną lub maksymalną)
- INFINITE… jeśli wartość wejściowa wyjdzie poza zdefiniowany zakres, wynik to wartość ekstrapolowana
- STRICT… jeśli wartość wejściowa wyjdzie poza zdefiniowany zakres, wartość wyjściowa będzie NaN

Przykłady

1
2
3
4
5


Example 1: LINEAR(250,  0,0,  50,500)   (Result is 25°C)

Example 2: LINEAR(Co2,  400,0,  1200,1)
          (If value from Co2 sensor is 400ppm, output for air recovery will be 0%. 
           If Co2 is 1200, output will be 100%. And if e.g. Co2=800, output will be 50%)

Przykład dla różnych atrybutów [type]:

input = 11
value1_input = 0, value1_output = 400
value2_input = 10, value2_output = 2000

Wynik dla różnych parametrów [type]:

BOUNDS (domyślna wartość) = 2000
INFINITE = 2160
STRICT = NaN

HYSTERESIS

Histereza może być używana do filtrowania sygnałów tak, aby reakcja wyjścia była wolniejsza, z uwzględnieniem historii systemu. Na przykład termostat zarządzający grzejnikiem może włączać grzejnik, gdy temperatura spadnie poniżej A, ale nie wyłączać go, dopóki temperatura nie wzrośnie powyżej B.

Zwraca 0 lub 1.

1

HYSTERESIS(value, upper_bound, lower_bound, upper_output, lower_output, last_value)

Przykład: utrzymanie temperatury 20 °C w zakresie histerezy 2 °C. Włączaj grzejnik, gdy temperatura spadnie poniżej 18 °C i wyłączaj, gdy temperatura przekroczy 22 °C.

1

heater := HYSTERESIS(temperature,   22, 18,   0, 1,   heater);

Funkcje matematyczne

MIN

Funkcja MIN zwraca minimalną wartość spośród podanych wartości liczbowych. Akceptuje od 1 do 100 argumentów lub jedną kolekcję. Wartości NaN i NULL są ignorowane.

1
2


MIN( n1, n2, n3, …)
MIN( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


MIN(40, 80)  		= 40
MIN(2, 2, 6) 		= 2
MIN(80, NAN)		= 80
MIN(NAN, NAN)		= NaN

VAR data := {10, 20, 30}; MIN(data) 	= 10
MIN({1, 2, 3})							= 1
MIN({1, NaN, 3})						= 1

VAR d1 := DATETIME(2014, 12, 8, 0, 0, 0, 0, DateTimeKind.Utc);
VAR d2 := DATETIME(2015, 12, 8, 0, 0, 0, 0, DateTimeKind.Utc);
MIN(d1, d2)			... Wynik to d1

MINSTRICT

Funkcja MINSTRICT zwraca minimalną wartość spośród podanych wartości liczbowych. Akceptuje od 1 do 100 argumentów lub jedną kolekcję. Jeśli którakolwiek z podanych wartości jest NaN lub NULL, funkcja zwraca NaN/NULL.

1
2


MINSTRICT( n1, n2, n3, …)
MINSTRICT( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


MINSTRICT(40, 80)  		= 40
MINSTRICT(2, 2, 6) 		= 2
MINSTRICT(80, NAN)		= NaN
MINSTRICT(NAN, NAN)		= NaN

VAR data := {10, 20, 30}; MINSTRICT(data) 	= 10
MINSTRICT({1, 2, 3})						= 1
MINSTRICT({1, NaN, 3})						= NaN

VAR d1 := DATETIME(2014, 12, 8, 0, 0, 0, 0, DateTimeKind.Utc);
VAR d2 := DATETIME(2015, 12, 8, 0, 0, 0, 0, DateTimeKind.Utc);
MINSTRICT(d1, NULL, d2)		... Wynik to NULL

MAX

Funkcja MAX zwraca maksymalną wartość spośród podanych wartości liczbowych. Akceptuje od 1 do 100 argumentów lub jedną kolekcję. Wartości NaN i NULL są ignorowane.

1
2


MAX( n1, n2, n3, …)
MAX( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


MAX(40, 80)  			= 80
MAX(2, 2, 6) 			= 6
MAX(80, NAN)			= 80
MAX(NAN, NAN)			= NaN

VAR data := {10, 20, 30}; MAX(data) = 30
MAX({1, 2, 3})						= 3
MAX({1, NaN, 3})					= 3

VAR d1 := DATETIME(2014, 12, 8, 0, 0, 0, 0, DateTimeKind.Utc);
VAR d2 := DATETIME(2015, 12, 8, 0, 0, 0, 0, DateTimeKind.Utc);
MAX(d1, d2)				... Wynik to d2

MAXSTRICT

Funkcja MAXSTRICT zwraca maksymalną wartość spośród podanych wartości liczbowych. Akceptuje od 1 do 100 argumentów lub jedną kolekcję. Jeśli którakolwiek z podanych wartości jest NaN lub NULL, funkcja zwraca NaN/NULL.

1
2


MAXSTRICT( n1, n2, n3, …)
MAXSTRICT( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


MAXSTRICT(40, 80)  			= 80
MAXSTRICT(2, 2, 6) 			= 6
MAXSTRICT(80, NAN)			= NaN
MAXSTRICT(NAN, NAN)			= NaN

VAR data := {10, 20, 30}; MAXSTRICT(data) 	= 30
MAXSTRICT({1, 2, 3})				= 3
MAXSTRICT({1, NaN, 3})				= NaN

VAR d1 := DATETIME(2014, 12, 8, 0, 0, 0, 0, DateTimeKind.Utc);
VAR d2 := DATETIME(2015, 12, 8, 0, 0, 0, 0, DateTimeKind.Utc);
MAXSTRICT(d1, NULL, d2)		... Wynik to NULL

AVG

Funkcja AVG oblicza średnią arytmetyczną z podanych wartości liczbowych. Akceptuje od 1 do 100 argumentów lub jedną kolekcję. Wartości NaN są ignorowane.

1
2


AVG( n1, n2, n3, …)
AVG( collection )

Przykłady:

1
2
3
4
5
6
7
8
9


AVG(40, 80)  		= 60
AVG(2, 2, 6) 		= 3.3333
AVG(80, NAN)		= 80
AVG(‘a’, ‘c’)		= ‘b’
AVG(NAN, NAN)		= NaN

VAR data := {10, 20, 30}; AVG(data) 	= 20
AVG({1, 2, 3})							= 2
AVG({1, NaN, 3})						= 2

AVGSTRICT

Funkcja AVGSTRICT oblicza średnią arytmetyczną podanych wartości liczbowych. Akceptuje od 1 do 100 argumentów lub jedną kolekcję. Jeśli któraś z wartości nie jest liczbą, zwracana jest NaN.

1
2


AVGSTRICT( n1, n2, n3, …)
AVGSTRICT( collection )

Przykłady:

1
2
3
4
5
6
7
8


AVGSTRICT(40, 80)  		= 60
AVGSTRICT(2, 2, 6) 		= 3.3333
AVGSTRICT(80, NAN)		= NaN
AVGSTRICT(NAN, NAN)		= NaN

VAR data := {10, 20, 30}; AVGSTRICT(data) 	= 20
AVGSTRICT({1, 2, 3})						= 2
AVGSTRICT({1, NaN, 3})						= NaN

ROUND

1

ROUND(value1)

Zwraca wartość zaokrągloną.

1
2
3
4


Example 1: ROUND(2.01)   (Wynik to 2)
Example 2: ROUND(2.49)   (Wynik to 2)
Example 3: ROUND(2.5)   (Wynik to 3)
Example 4: ROUND(2.99)   (Wynik to 3)

ABS

Funkcja ABS zwraca wartość bezwzględną (tj. moduł) dowolnej podanej liczby.

1

ABS(number)

Przykłady:

1
2


ABS(100)  ...   100
ABS(-100)   ...   100

DEWPOINT

1

DEWPOINT(temperature, relativeHumidity)

Zwraca temperaturę punktu rosy dla bieżącej temperatury i wilgotności względnej. Punkt rosy obliczany jest zgodnie z równaniem opisanym tutaj: this equation.

1
2


Example 1: DEWPOINT(20, 0.50) (Wynik to ~9.26)
Example 2: DEWPOINT(0, 1.00) (Wynik to 0)

POWER

Funkcja POWER oblicza daną liczbę podniesioną do zadanej potęgi.

1

POWER(number, power)

Przykłady:

POWER(2,3) … 2^3 = 8
POWER(10, -3) … 0,001
POWER(25, 0) … 1

MOD

Funkcja MOD zwraca resztę z dzielenia dwóch podanych liczb.

1

MOD(number, divisor)

Argumenty:

number - liczba do podzielenia
divisor - wartość, przez którą dzielona jest liczba

Przykłady:

MOD(6, 4) … 2
MOD(6, 2.5) … 1

CEIL

Funkcja CEIL zaokrągla podaną liczbę w górę do najbliższej wielokrotności danej liczby.

1

CEIL(number, significance)

Argumenty:

number - liczba, która ma być zaokrąglona
significance (optional) - wielokrotność, do której liczba ma być zaokrąglona. Jeśli nie podano, domyślnie 1 (powinna mieć ten sam znak arytmetyczny – dodatni lub ujemny – co podana liczba).

Przykłady:

CEIL(22.25,0.1) … 22.3
CEIL(22.25,1) … 23
CEIL(22.25) … 23
CEIL(-22.25,-1) … -23
CEIL(-22.25,1) … -22
CEIL(-22.25) … -22
CEIL(-22.25,-5) … -25

FLOOR

Funkcja FLOOR zaokrągla liczbę w dół, w kierunku zera, do najbliższej wielokrotności określonej wartości znaczącej.

1

FLOOR(number, significance)

Argumenty:

number - liczba, która ma być zaokrąglona
significance (optional) - wielokrotność, do której ma być zaokrąglona podana liczba. Jeśli nie podano, domyślnie 1 (powinna mieć ten sam znak arytmetyczny co podana liczba).

Przykłady:

FLOOR(22.25,0.1)… 22.2
FLOOR(22.25,1) … 22
FLOOR(22.25) … 22
FLOOR(-22.25,-1) … -22
FLOOR(-22.25,1) … -23
FLOOR(-22.25) … -23
FLOOR(-22.25,-5) … -20

RAND

Funkcja RAND generuje losową liczbę rzeczywistą między 0 a 1.

1

RAND()

Przykłady:

RAND()

RANDINT

Funkcja RANDINT generuje losową liczbę całkowitą między dwoma podanymi całkowitymi.

1

RANDINT(bottom, top)

Przykłady:

RANDINT(1,5)
RANDINT(-2,2)

SIGN

Funkcja SIGN zwraca znak arytmetyczny (+1, -1 lub 0) podanej liczby. Tzn. jeśli liczba jest dodatnia, funkcja zwraca +1, jeśli ujemna -1, a jeśli 0, zwraca 0.

1

SIGN(number)

Przykłady:

SIGN(100) … 1
SIGN(0) … 0
SIGN(-100) … -1

SQRT

Funkcja SQRT oblicza dodatni pierwiastek z podanej liczby.

1

SQRT(number)

Przykłady:

SQRT(25) … 5

LOG

Funkcja LOG oblicza logarytm danej liczby przy zadanej podstawie.

1

LOG(number, base)

Argumenty:

number - dodatnia liczba rzeczywista, dla której obliczany jest logarytm
base (optional) - opcjonalny argument określający podstawę logarytmu. Jeśli nie podano, domyślnie 10.

Przykłady:

LOG(4,0.5) … -2
LOG(100) … 2

LN

Funkcja LN oblicza naturalny logarytm danej liczby.

1

LN(number)

gdzie argument number to dodatnia liczba rzeczywista, dla której obliczany jest logarytm naturalny.

Przykłady:

LN(100) … 4,60517

Operacje na bitach

GETBIT

Zwraca wartość bitu na podanej pozycji.

1

GETBIT(number, bit_position)

Argumenty:

number - liczba, z której wyciągamy wartość konkretnego bitu
bit_position - pozycja bitu, licząc od 0, od prawej

Przykłady:

GETBIT(2, 0) → pierwszy bit liczby 2 (0b0010) to 0
GETBIT(4,2) → trzeci bit liczby 4 (0b0100) to 1

GETBITS

Zwraca wartość określonej liczby bitów z określonej pozycji.

1

GETBITS(number, start_bit, number_of_bits)

Przykłady:

GETBITS(216, 3, 2) → liczba 216 = 0b11011000; wartość 4. bita od prawej to 1, 5. bit to 1, więc wynik to 0b0011 = 3
GETBITS(0xFF, 0, 4) → liczba 0xFF = 255 = 0b1111 1111; wartość pierwszych 4 bitów od prawej to 0b1111 = 0xF = 15

GETBYTE

Zwraca wartość bajtu w zadanej liczbie.

1

GETBYTE( number, byte_position )

Argumenty:

number - liczba, z której wyciągamy wartość konkretnego bajtu
byte_position - pozycja bajtu, zaczynając od 0, od prawej

Przykłady:

1
2
3


GETBYTE(256, 0)  →  0001 0000 0000 →  0
GETBYTE(256, 1)   →  0001 0000 0000  →  1
GETBYTE(259, 0)   →  0001 0000 0011   →  3

SETBYTE

Nadaje nową wartość wskazanemu bajtowi w podanej liczbie i zwraca nową liczbę.

1

SETBYTE( number, byte_position, new_value )

Przykłady:

1
2
3
4


SETBYTE(1, 0, 0)   →   0
SETBYTE(256, 0, 255)   →   511
SETBYTE(256, 1, 1)	  →   256
SETBYTE(259, 1, 2)	  →    515

SETBIT

Nadaje nową wartość wskazanemu bitowi w podanej liczbie i zwraca nową liczbę.

1

SETBIT(number, bit_position, new_value)

Argumenty:

number - liczba do zmodyfikowania
bit_position - pozycja bitu, zaczynając od 0, od prawej
new_value - 0 lub 1 – wartość, która ma być ustawiona na określony bit

Przykłady:

SETBIT(1, 1, 1) → 3
SETBIT(3, 1, 1) → 3
SETBIT(4, 2, 0) → 4
SETBIT(12, 1, 0) → 14

SETBITS

Nadaje nową wartość wskazanym bitom w podanej liczbie i zwraca nową liczbę.

1

SETBITS(number, start_bit, number_of_bits, new_value)

Przykłady:

SETBITS(192, 4, 2, 3) → 240
SETBITS(192, 5, 2, 3) → 224

« (LEFT BIT SHIFT)

1

8 << 2   (32)

Excel: BITLSHIFT(number, shift_amount)

» (RIGHT BIT SHIFT)

1

32 >> 2   (8)

Excel: BITRSHIFT(number, shift_amount)

& (BITWISE AND)

1

3 & 1   (1)

Excel: BITAND(number1, number2)

| (BITWISE OR)

1

2 | 1 (3)

Excel: BITOR(number1, number2)

Zobacz przykład operacji na bitach w Google Sheets: https://docs.google.com/spreadsheets/d/1hF5FMpGMJbgYh-YLwWrq2n186_ATyGyLUb689__IhLY/edit?usp=sharing

Lub wypróbuj interaktywne narzędzie na http://bitwisecmd.com/

Tekst, ciąg znaków i bajtów

LENGTH

Zwraca długość obiektu lub liczbę bajtów. Obiekt może być liczbą, wartością logiczną, łańcuchem lub Kolekcją.

1

LENGTH( object )

Przykłady:

1
2
3
4


LENGTH(“Hello World”)			(Result is 11)
LENGTH(“40”)				(Result is 2)
LENGTH(40)					(Result is 8)
LENGTH(BYTECOLLECTION(“010203”)	(Result is 3)

BYTECOLLECTION

Tworzy Collection z podanych wartości szesnastkowych.

1

BYTECOLLECTION( bytes )

Przykłady:

1
2


BYTECOLLECTION(“010203”) 				(Result is Collection<UInt8> {01, 02, 03})
BYTECOLLECTION(“aa, be1-1,fe”) 			(Result is Collection<UInt8> {aa be 11 fe})

INDEXOF

Zwraca indeks określonego elementu w łańcuchu lub kolekcji. Zwraca -1, jeśli element nie został znaleziony.

1

INDEXOF( string/collection, element )

Przykłady:

1
2
3
4
5
6


INDEXOF("Hello", “H”)					(Result is 0)
INDEXOF("Hello World", “Wor”)				(Result is 6)
INDEXOF("Hello World", “Wor”)				(Result is 6)
INDEXOF("Hello World", “or12”)				(Result is -1)
INDEXOF(BYTECOLLECTION("ab cd ee ff 01 02"), 2)	(Result is 5)
INDEXOF({1, 2, 3}, 3)						(Result is 2)

COPY

Kopiuje wskazany ciąg znaków lub kolekcję (lub ich część).

1

COPY( string/collection, startIndex, length)

Przykłady:

1
2
3
4
5


COPY("Hello")					(Result is “Hello”)
COPY("Hello World", 2)				(Result is “llo World”)
COPY("Hello World", 2, 4)				(Result is “llo ”)
COPY(BYTEARRAY("01020304")			(Result is byte array 01020304)
COPY(BYTEARRAY("01020304", 2, 1)		(Result is byte array 03)

REPLACE

Zwraca nowy łańcuch znaków lub kolekcję, w której wszystkie wystąpienia określonej wartości są zastąpione nową wartością.

1

REPLACE( string/collection, oldValue, newValue)

Przykłady:

1
2
3


REPLACE("Hello", “l”, “”)				(Result is “Heo”)
REPLACE("Hello", “lo”, “22”)			(Result is “Hel22”)
REPLACE(BYTECOLLECTION(“050607"), 5, 9)	(Result is Collection<UInt8>{09, 06, 07}

SPLIT

Dzieli łańcuch na podłańcuchy w oparciu o separatory.

1
2
3
4


SPLIT( string, string )
SPLIT( string, char )
SPLIT( string, Collection<string> )
SPLIT( string, Collection<char> )

Przykłady:

1
2
3


SPLIT("1;2;3;4", “;”)			(Result is Collection<String>{“1”, “2”, “3”, “4”})
SPLIT("1;2;3.4", “2;”)		(Result is Collection<String>{“1;”, “3.4”})
SPLIT("1;2;3.4", {“2”, “3.”)		(Result is Collection<String>{“1;”, “;”, “4”})

COMPARE

Porównuje dwa łańcuchy znaków i zwraca liczbę całkowitą wskazującą ich względne położenie w porządku sortowania.

1

COMPARE( string, string, CompareOptions )

Przykłady:

1
2
3


COMPARE("abc", “abc”)						(Result is 0)
COMPARE("abc", “ABC”)						(Result is 32)
COMPARE("abc", “ABC”, CompareOptions.IgnoreCase)	(Result is 0)

APPEND

Dołącza wartość do kolekcji lub łańcucha i zwraca nowy obiekt z dołączoną wartością.

1
2


APPEND( string, string )
APPEND( Collection, value )

Przykłady:

1
2


APPEND({1, 2}, 3)     (Result is Collection<Double>{1, 2, 3})
APPEND("abc", “def”)  (Result is “abcdef”)

INSERT

Wstawia wartość do kolekcji lub łańcucha. Zwraca kolekcję lub łańcuch z wstawioną wartością.

1
2


INSERT( collection, index, value )
INSERT( string, index, value )

Przykłady:

1
2
3


INSERT(“Hello”, 5, “ World”)      (Result is “Hello World”)
INSERT(“Hello”, 1, “i”)			  (Result is “Hiello”)
INSERT({1, 2, 4}, 2, 3)			  (Result is Collection<Double>{1, 2, 3, 4})

REMOVEAT

Usuwa elementy z kolekcji lub łańcucha na podstawie indeksu elementu i długości. Zwraca kolekcję lub łańcuch bez podanych elementów.

1
2


REMOVEAT( collection, index, length )
REMOVEAT( string, index, length )

Przykłady:

1
2
3
4


REMOVEAT(“Hello”, 1)			(Result is “Hllo”)
REMOVEAT(“Hello”, 3, 2)			(Result is “Ho”)
REMOVEAT({1, 2, 3, 4}, 2)			(Result is Collection<Double>{1, 2, 4})
REMOVEAT({1, 2, 3, 4}, 2, 2)		(Result is Collection<Double>{1, 2})

GETAT

Pobiera wartość elementu z kolekcji lub łańcucha na podstawie podanego indeksu.

1
2


GETAT( collection, index )
GETAT( string, index )

Przykłady:

1
2


GETAT(“Hello”, 2)			(Result is “l”)
GETAT({1, 2, 4}, 2)			(Result is 4)

SETAT

Ustawia wartość elementu w kolekcji lub łańcuchu pod podanym indeksem.

1
2


SETAT( collection, index, value )
SETAT( string, index, value )

Przykłady:

1
2
3


SETAT(“Hello”, 1, “a”)          (Result is “Hallo”)
SETAT(“Hello”, 4, “o World”)    (Result is “Hello World”)
SETAT({1, 2, 4}, 2, 3)          (Result is Collection<Double>{1, 2, 3})

ENCODE

Koduje wskazany łańcuch w jednym z formatów i zwraca nowy łańcuch.

1

ENCODE( string, format )

Obsługiwane formaty:

XML
Base64

Przykłady:

1
2
3


ENCODE("Hello", “xml”)				(Result is “Hello”)
ENCODE("<Hello id=1>", “xml”)		(Result is “&lt;Hello id=1&gt;”)
ENCODE("Hello", “base64”)			(Result is “SGVsbG8=”)

DECODE

Dekoduje wskazany łańcuch, używając jednego z formatów, i zwraca nowy łańcuch.

1

DECODE( string, format )

Obsługiwane formaty:

XML
Base64

Przykłady:

1
2
3


DECODE("Hello", “xml”)				  (Result is “Hello”)
DECODE("&lt;Hello id=1&gt;", “xml”)   (Result is “<Hello id=1>”)
DECODE("SGVsbG8=", “base64”)		  (Result is “Hello”)

EQUALS

Porównuje dwie liczby w arytmetyce zmiennoprzecinkowej. Liczby uznaje się za równe, jeśli | n1 - n2 | < epsilon. Domyślna wartość progu (*epsilon) wynosi 0.005 i jest parametrem opcjonalnym.

1

EQUALS( number1, number2, epsilon=0.005 )

Przykłady:

1
2
3
4
5


EQUALS(1.33, 1.33)          1.0 (true)
EQUALS(1.333, 1.3335)		1.0 (true)
EQUALS(1.333, 1.338)		1.0 (false)
EQUALS(1.333, 1.338, 0.01)	1.0 (true)
EQUALS(NAN, NAN)		    1.0 (true)

Sortowanie

Istnieje wiele wariantów ORDER: rosnąco – ORDER, ORDERSTRICT – ORDERINDEX, ORDERINDEXSTRICT; malejąco – ORDERDESC, ORDERDESCSTRICT – ORDERINDEXDESC, ORDERINDEXDESCSTRICT.

ORDER

Funkcja ORDER sortuje podane wartości wejściowe w porządku rosnącym i zwraca je w nowej kolekcji. Akceptuje n wartości (do 100 argumentów) lub jedną kolekcję. Wartości nie muszą być liczbowe, ale muszą być porównywalne (np. liczby, TIMESPAN, DATETIME, łańcuchy). Mieszane typy (np. liczby i ciągi znaków) nie są dozwolone. Wartości NaN i NULL są ignorowane i wykluczane z zwracanej kolekcji.

1
2


ORDER( n1, n2, n3 , … )
ORDER( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ORDER(3, 1, 2)				= {1, 2, 3}
ORDER(1)					= {1}
ORDER(3, NaN, 2, NaN)		= {2, 3}
ORDER(NaN)					= {}
ORDER('Z', 'a', 'X')				= {'X', 'Z', 'a'}
ORDER(“str1”, “STR2”, “stR1”} 		= {"STR2", "stR1", "str1"}
ORDER(“str1”, NULL, “STR2”, “stR1”} = {"STR2", "stR1", "str1"}

ORDER(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {TIMESPAN(0,0,0,0,99), TIMESPAN(0,0,0,0,100)}
ORDER(NULL, TIMESPAN(0,0,0,0,99)					= {TIMESPAN(0,0,0,0,99)}

ORDERINDEX

Funkcja ORDERINDEX sortuje podane wartości wejściowe rosnąco, podobnie jak ORDER. Zamiast zwracać posortowane wartości, zwraca kolekcję indeksów wskazujących pozycje oryginalnych wartości w posortowanej kolejności. Akceptuje n wartości (do 100 argumentów) lub jedną kolekcję. Wartości nie muszą być liczbowe, ale muszą być porównywalne (np. liczby, TIMESPAN, DATETIME, łańcuchy). Mieszane typy (np. liczby i łańcuchy) nie są dozwolone. Wartości NaN i NULL są ignorowane i wykluczane z zwracanej kolekcji.

1
2


ORDERINDEX( n1, n2, n3 , … )
ORDERINDEX( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ORDERINDEX(3, 1, 2)				= {1, 2, 0}
ORDERINDEX(1)					= {0}
ORDERINDEX(3, NaN, 2, NaN)		= {2, 0}
ORDERINDEX(NaN)					= {}
ORDERINDEX('Z', 'a', 'X')				= {2, 0, 1}
ORDERINDEX(“str1”, “STR2”, “stR1”} 		= {1, 2, 0}
ORDERINDEX(“str1”, NULL, “STR2”, “stR1”} = {2, 3, 0}

ORDERINDEX(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {1, 0}
ORDERINDEX(NULL, TIMESPAN(0,0,0,0,99)					= {1}

ORDERSTRICT

Funkcja ORDERSTRICT sortuje podane wartości wejściowe rosnąco i zwraca je w nowej kolekcji. Akceptuje n wartości (do 100 argumentów) lub jedną kolekcję. Wartości nie muszą być liczbowe, ale muszą być porównywalne (np. liczby, TIMESPAN, DATETIME, łańcuchy). Mieszane typy (np. liczby i łańcuchy) nie są dozwolone. Wartości NaN i NULL są uwzględniane i zawsze sortowane jako pierwsze w wyniku.

1
2


ORDERSTRICT( n1, n2, n3 , … )
ORDERSTRICT( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ORDERSTRICT(3, 1, 2)			= {1, 2, 3}
ORDERSTRICT(1)					= {1}
ORDERSTRICT(3, NaN, 2, NaN)		= {NaN, NaN, 2, 3}
ORDERSTRICT(NaN)				= {NaN}
ORDERSTRICT('Z', 'a', 'X')		= {'X', 'Z', 'a'}
ORDERSTRICT(“str1”, “STR2”, “stR1”} 		= {"STR2", "stR1", "str1"}
ORDERSTRICT(“str1”, NULL, “STR2”, “stR1”}	= {NULL, "STR2", "stR1", "str1"}

ORDERSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {TIMESPAN(0,0,0,0,99), TIMESPAN(0,0,0,0,100)}
ORDERSTRICT(NULL, TIMESPAN(0,0,0,0,99)					= {NULL, TIMESPAN(0,0,0,0,99)}

ORDERINDEXSTRICT

Funkcja ORDERINDEXSTRICT sortuje podane wartości wejściowe rosnąco, podobnie jak ORDERSTRICT. Zamiast zwracać posortowane wartości, zwraca kolekcję indeksów wskazujących pozycje oryginalnych wartości w posortowanej kolejności. Akceptuje n wartości (do 100 argumentów) lub jedną kolekcję. Wartości nie muszą być liczbowe, ale muszą być porównywalne (np. liczby, TIMESPAN, DATETIME, łańcuchy). Mieszane typy (np. liczby i łańcuchy) nie są dozwolone. Wartości NaN i NULL są uwzględniane i zawsze sortowane jako pierwsze w wyniku.

1
2


ORDERINDEXSTRICT( n1, n2, n3 , … )
ORDERINDEXSTRICT( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ORDERINDEXSTRICT(3, 1, 2)				= {1, 2, 0}
ORDERINDEXSTRICT(1)						= {0}
ORDERINDEXSTRICT(3, NaN, 2, NaN)		= {1, 3, 2, 0}
ORDERINDEXSTRICT(NaN)					= {0}
ORDERINDEXSTRICT('Z', 'a', 'X')			= {2, 0, 1}
ORDERINDEXSTRICT(“str1”, “STR2”, “stR1”}		= {1, 2, 0}
ORDERINDEXSTRICT(“str1”, NULL, “STR2”, “stR1”}	= {1, 2, 3, 0}

ORDERINDEXSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {1, 0}
ORDERINDEXSTRICT(NULL, TIMESPAN(0,0,0,0,99)					= {0, 1}

ORDERDESC

Funkcja ORDERDESC sortuje podane wartości wejściowe w porządku malejącym i zwraca je w nowej kolekcji. Akceptuje n wartości (do 100 argumentów) lub jedną kolekcję. Wartości nie muszą być liczbowe, ale muszą być porównywalne (np. liczby, TIMESPAN, DATETIME, łańcuchy). Mieszane typy (np. liczby i łańcuchy) nie są dozwolone. Wartości NaN i NULL są ignorowane i wykluczone z zwracanej kolekcji.

1
2


ORDERDESC( n1, n2, n3 , … )
ORDERDESC( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ORDERDESC(3, 1, 2)					= {3, 2, 1}
ORDERDESC(1)						= {1}
ORDERDESC(3, NaN, 2, NaN)			= {3, 2}
ORDERDESC(NaN)						= {}
ORDERDESC('Z', 'a', 'X')			= {'a', 'Z', 'X'}
ORDERDESC(“str1”, “STR2”, “stR1”} 	= {"str1", "stR1", "STR2"}
ORDERDESC(“str1”, NULL, “STR2”, “stR1”} 	= {"str1", "stR1", "STR2"}

ORDERDESC(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)}
ORDERDESC(NULL, TIMESPAN(0,0,0,0,99)					= {TIMESPAN(0,0,0,0,99)}

ORDERINDEXDESC

Funkcja ORDERINDEXDESC sortuje podane wartości wejściowe w porządku malejącym, podobnie jak ORDERDESC. Zamiast zwracać posortowane wartości, zwraca kolekcję indeksów wskazujących pozycje oryginalnych wartości w posortowanej kolejności. Akceptuje n wartości (do 100 argumentów) lub jedną kolekcję. Wartości nie muszą być liczbowe, ale muszą być porównywalne (np. liczby, TIMESPAN, DATETIME, łańcuchy). Mieszane typy (np. liczby i łańcuchy) nie są dozwolone. Wartości NaN i NULL są ignorowane i wykluczane z wyniku.

1
2


ORDERINDEXDESC( n1, n2, n3 , … )
ORDERINDEXDESC( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ORDERINDEXDESC(3, 1, 2)				= {0, 2, 1}
ORDERINDEXDESC(1)					= {0}
ORDERINDEXDESC(3, NaN, 2)			= {0, 2}
ORDERINDEXDESC(NaN)					= {}
ORDERINDEXDESC('Z', 'a', 'X')					= {1, 0, 2}
ORDERINDEXDESC(“str1”, “STR2”, “stR1”} 			= {0, 2, 1}
ORDERINDEXDESC(“str1”, NULL, “STR2”, “stR1”} 	= {0, 3, 2}

ORDERINDEXDESC(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {0, 1}
ORDERINDEXDESC(NULL, TIMESPAN(0,0,0,0,99)					= {1}

ORDERDESCSTRICT

Funkcja ORDERDESCSTRICT sortuje podane wartości wejściowe w porządku malejącym i zwraca je w nowej kolekcji. Akceptuje n wartości (do 100 argumentów) lub jedną kolekcję. Wartości nie muszą być liczbowe, ale muszą być porównywalne (np. liczby, TIMESPAN, DATETIME, łańcuchy). Mieszane typy (np. liczby i łańcuchy) nie są dozwolone. Wartości NaN i NULL są uwzględniane i zawsze sortowane jako pierwsze w wyniku.

1
2


ORDERDESCSTRICT( n1, n2, n3 , … )
ORDERDESCSTRICT( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ORDERDESCSTRICT(3, 1, 2)			= {3, 2, 1}
ORDERDESCSTRICT(1)					= {1}
ORDERDESCSTRICT(3, NaN, 2, NaN		= {NaN, NaN, 3, 2}
ORDERDESCSTRICT(NaN)				= {NaN}
ORDERDESCSTRICT('Z', 'a', 'X')					= {'a', 'Z', 'X'}
ORDERDESCSTRICT(“str1”, “STR2”, “stR1”} 		= {"str1", "stR1", "STR2"}
ORDERDESCSTRICT(“str1”, NULL, “STR2”, “stR1”} 	= {NULL, "str1", "stR1", "STR2"}

ORDERDESCSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)}
ORDERDESCSTRICT(NULL, TIMESPAN(0,0,0,0,99)					= {NULL, TIMESPAN(0,0,0,0,99)}

ORDERINDEXDESCSTRICT

Funkcja ORDERINDEXDESCSTRICT sortuje podane wartości wejściowe w porządku malejącym, podobnie jak ORDERDESC. Zamiast zwracać posortowane wartości, zwraca kolekcję indeksów wskazujących pozycje oryginalnych wartości w posortowanej kolejności. Akceptuje n wartości (do 100 argumentów) lub jedną kolekcję. Wartości nie muszą być liczbowe, ale muszą być porównywalne (np. liczby, TIMESPAN, DATETIME, łańcuchy). Mieszane typy (np. liczby i łańcuchy) nie są dozwolone. Wartości NaN i NULL są ignorowane i wykluczane z zwracanego wyniku.

1
2


ORDERINDEXDESCSTRICT( n1, n2, n3 , … )
ORDERINDEXDESCSTRICT( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ORDERINDEXDESCSTRICT(3, 1, 2)				= {0, 2, 1}
ORDERINDEXDESCSTRICT(1)						= {0}
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN)		= {1, 3, 0, 2}
ORDERINDEXDESCSTRICT(NaN)					= {0}
ORDERINDEXDESCSTRICT('Z', 'a', 'X')			= {1, 0, 2}
ORDERINDEXDESCSTRICT(“str1”, “STR2”, “stR1”}		= {0, 2, 1}
ORDERINDEXDESCSTRICT(“str1”, NULL, “STR2”, “stR1”} 	= {0, 3, 2}

ORDERINDEXDESCSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {0, 1}
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0,0,0,0,99)						= {0, 1}

ORDERDESCSTRICT

1
2


ORDERDESCSTRICT( n1, n2, n3 , … )
ORDERDESCSTRICT( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ORDERDESCSTRICT(3, 1, 2)			= {3, 2, 1}
ORDERDESCSTRICT(1)					= {1}
ORDERDESCSTRICT(3, NaN, 2, NaN		= {NaN, NaN, 3, 2}
ORDERDESCSTRICT(NaN)				= {NaN}
ORDERDESCSTRICT('Z', 'a', 'X')					= {'a', 'Z', 'X'}
ORDERDESCSTRICT(“str1”, “STR2”, “stR1”} 		= {"str1", "stR1", "STR2"}
ORDERDESCSTRICT(“str1”, NULL, “STR2”, “stR1”} 	= {NULL, "str1", "stR1", "STR2"}

ORDERDESCSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)}
ORDERDESCSTRICT(NULL, TIMESPAN(0,0,0,0,99)					= {NULL, TIMESPAN(0,0,0,0,99)}

ORDERINDEXDESCSTRICT

1
2


ORDERINDEXDESCSTRICT( n1, n2, n3 , … )
ORDERINDEXDESCSTRICT( collection )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ORDERINDEXDESCSTRICT(3, 1, 2)				= {0, 2, 1}
ORDERINDEXDESCSTRICT(1)						= {0}
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN)		= {1, 3, 0, 2}
ORDERINDEXDESCSTRICT(NaN)					= {0}
ORDERINDEXDESCSTRICT('Z', 'a', 'X')			= {1, 0, 2}
ORDERINDEXDESCSTRICT(“str1”, “STR2”, “stR1”}		= {0, 2, 1}
ORDERINDEXDESCSTRICT(“str1”, NULL, “STR2”, “stR1”} 	= {0, 3, 2}

ORDERINDEXDESCSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {0, 1}
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0,0,0,0,99)						= {0, 1}

DATE and time

DATETIME

Tworzy obiekt DateTime. Właściwość DateTime.Ticks to liczba milisekund od 01.01.0001 00:00:00.000. DateTime ma właściwości: TICKS, YEAR, MONTH, DAY, DAYOFWEEK, DAYOFYEAR, HOUR, MINUTE, SECOND, MILLISECOND, KIND, UTCDATETIME, LOCALDATETIME, UNIXTIME.

1
2
3
4


DATETIME( ticks, DateTimeKind )
DATETIME( string, format )
DATETIME( string, DateTimeKind )
DATETIME( year, month, day, hour, minute, second, millisecond, DateTimeKind  )

Przykłady:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


VAR date:= DATETIME(2014, 12, 8, 23, 54, 12, 456);
VAR date:= DATETIME(2014, 12, 8, 23, 54, 12, 456, DateTimeKind.Local);
VAR date:= DATETIME(2014, 12, 8, 23, 54, 12, 456, DateTimeKind.Utc);
VAR date:= DATETIME("13:36");
VAR date:= DATETIME("2022-08-03T07:39:03.688133+05:00");
VAR date:= DATETIME("03.01 2008 10:00"); 
VAR date:= DATETIME("mar.01 2008 10:00");
VAR date:= DATETIME("03.01 2008 10:00", "dd.MM yyyy hh:mm");
VAR date:= DATETIME(518832000);
VAR date:= DATETIME(518832000, DateTimeKind.Utc);
VAR date := NOW(); date.YEAR := 1999;
DATETIME date; date.UNIXTIME := 123456;

NOW

Zwraca obiekt DateTime ustawiony na bieżącą datę i godzinę w lokalnej strefie czasowej.

1

NOW()

Przykłady:

1

VAR now := NOW();

TIMESPAN

Funkcja TIMESPAN tworzy zmienną reprezentującą okres czasu, określony w dniach, godzinach, minutach, sekundach i milisekundach. TIMESPAN ma właściwości do bezpośredniego dostępu do każdego składnika okresu: DAYS, HOURS, MINUTES, SECONDS, MILLISECONDS. TIMESPAN ma także właściwości do dostępu do całkowitej długości czasu w określonych jednostkach (z wartościami ułamkowymi): TOTALDAYS, TOTALHOURS, TOTALMINUTES, TOTALSECONDS, TOTALMILLISECONDS.

1

TIMESPAN( days, hours, minutes, seconds, milliseconds )

Przykłady:

1
2
3
4


VAR t := TimeSpan(1, 2, 3, 4, 0);
	t.TOTALSECONDS			

Result ... 93784

LOCALTIMEZONE

Zwraca lokalną strefę czasową jako liczbę milisekund względem czasu UTC.

1

LOCALTIMEZONE()

Przykłady:

1

VAR timezoneDiff := LOCALTIMEZONE();

DATETIMEADD

Dodaje określoną liczbę lat, miesięcy, dni, godzin, minut, sekund lub milisekund do istniejącego DateTime i zwraca nowy DateTime.

1

DATETIMEADD(datetime, years, months, days, hours, minutes, seconds, milliseconds)

Przykłady:

1

VAR dt := NOW(); VAR yearBefore := DATETIMEADD(dt, -1);

Konwersje typów danych

TODOUBLE

Konwertuje tekst na liczbę. Zwraca NaN w przypadku błędu.

1

TODOUBLE( text )

Przykłady:

1
2
3


TODOUBLE(“232”) ... 232)
TODOUBLE(“-192.332”)  ...  -192.332
TODOUBLE(“some text”)  ...  NaN

TOSTRING

Zwraca wartość łańcuchową dla podanej wartości lub Kolekcji zgodnie z określonym kodowaniem. Kodowanie jest opcjonalne (domyślnie używane jest iso-8859-1).

1

TOSTRING(value, encoding)

Przykłady:

1
2
3
4


TOSTRING(192, “X”)  …  Wynik = “C0”
TOSTRING(192, “X4”)  …  Wynik = “00C0”
TOSTRING(192, “F4”)  …  Wynik = “123.3400”
TOSTRING(192, “F0”)  …  Wynik = “123”

1
2
3


TOSTRING(BYTECOLLECTION("48656c6c6f"))			(Result is “Hello”)
TOSTRING(BYTECOLLECTION(\"48656c6c6f\"), “iso-8859-1”)	(Result is “Hello”)
TOSTRING(192, “X4”)							(Result is “00C0”)

TOBCD

Konwertuje podaną liczbę do formatu BCD (binary-coded decimal). Schemat kodowania to BCD-8421.

1

TOBCD(number)

Przykłady:

1
2
3


TOBCD(1)  ...  1
TOBCD(9)  ...  9
TOBCD(10)  ...  16

FROMBCD

Dekoduje podaną liczbę, zakodowaną w formacie BCD (binary-coded decimal). Schemat kodowania to BCD-8421.

1

FROMBCD(number)

Przykłady:

1
2


FROMBCD(16)  ...  10
FROMBCD(32)  ...  20

TOBYTEARRAY

Konwertuje ciąg znaków do tablicy bajtów zgodnie z określonym kodowaniem. Kodowanie jest opcjonalne (domyślnie iso-8859-1).

1

TOBYTEARRAY( string, encoding )

Przykłady:

1

TOBYTEARRAY("Hello")			(Result is byte array 48656c6c6f)

RGBTOHSV

Konwertuje definicję koloru RGB i zwraca kolor w formacie Hue / Saturation / Brightness.

1

RGBTOHSV( r, g, b )      (r, g, b ... 0 - 0xFF)

Przykład:

1
2
3
4


VAR HSVColor := RGBTOHSV( r, g, b );
VAR saturation := HSVColor.Saturation;   (Saturation ... 0 - 1)
VAR hue := HSVColor.Hue;                 (Hue ... 0 - 360)
VAR value := HSVColor.Value;             (Value ... 0 - 1)

HSVTORGB

Konwertuje kolor zdefiniowany przez Hue / Saturation / Brightness i zwraca kolor w formacie RGB.

1

HSVTORGB( hue, saturation, value )

Przykład:

1
2
3
4


VAR color := HSVTORGB( hue, saturation, 1)
VAR red := color.red;                   (red ... 0 - 0xFF)
VAR green := color.green;               (green ... 0 - 0xFF)
VAR blue := color.blue;                 (blue ... 0 - 0xFF)

Funkcje parsowania

PARSETEXT

Zwraca część wejściowego tekstu na podstawie wzorców wyszukiwania po lewej i prawej stronie.

1

PARSETEXT( input, left_pattern, right_pattern)

Przykłady:

1
2
3
4
5
6
7


PARSETEXT(“Lorem ipsum dolor sit amet”, “ipsum”, “amet”) (Result is “dolor sit”)
PARSETEXT(“<temp>12.2</temp>”, “<temp>”, “</temp”) (Result is 12.2)
PARSETEXT(“<temp>12.2</temp>”, “<temp>”) (Result is 12.2)
PARSETEXT(“status:ok,error:none”, “status:”) (Result is “ok”)
PARSETEXT(“Lorem ipsum dolor sit amet”, “ipsum”) (Result is “dolor”)
PARSETEXT(“Lorem ipsum dolor sit amet”, “ipsum…sit”) (Result is “amet”)
PARSETEXT(“Lorem ipsum dolor sit amet consectetur adipiscing”, “ipsum…sit”, “adipiscing”) (Result is “amet consectetur”)

PARSEJSON

Zwraca wartość elementu z sformatowanego JSON w postaci string. Element określany jest ścieżką JSON.

1

PARSEJSON( json_string, json_path, ignore_error)

Przykłady:

Z json =

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


{
  "firstName": "John",
  "lastName" : "doe",
  "age" : 26,
  "address"  : {
    "streetAddress": "naist street",
    "city"         : "Nara",
    "postalCode"   : "630-0192"
  }
}

1
2
3
4
5


PARSEJSON(json, “firstName”)			(Result is “John”)
PARSEJSON(json, “address.city”)		(Result is “Nara”)
PARSEJSON(json, “address.country”)		(error)
PARSEJSON(json, “address.country”, 0)		(error)
PARSEJSON(json, “address.city”, 1)		(Result is null)

PARSEXML

Zwraca wartość elementu z łańcucha XML. Element określany jest ścieżką XML.

1

PARSEXML( xml_string, xml_path)

Przykłady:

Z xml=

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


<?xml version="1.0"?>
<catalog>
	<book id="bk101">
		<author>Gambardella, Matthew</author>
		<title>XML Developer's Guide</title>
		<genre>Computer</genre>
		<price>44.95</price>
		<publish_date>2000-10-01</publish_date>
		<description>An in-depth look at creating...</description>
	</book>
	<book id="bk102">
		<author>Ralls, Kim</author>
		<title>Midnight Rain</title>
		<genre>Fantasy</genre>
		<price>5.95</price>
		<publish_date>2000-12-16</publish_date>
		<description>A former architect battles…</description>
	</book>
</catalog>

1
2
3
4


PARSEXML(xml, "//catalog/book[1]/price") (Result is 44.95)
PARSEXML(xml, "//book[2]/title") (Result is "Midnight Rain")
PARSEXML(xml, "//book[1]/@id") (Result is "bk101")
PARSEXML(xml, "//catalog/magazine[1]/price") (Result is null)

Jeśli XML zawiera przestrzenie nazw, należy w pełni określić nazwy elementów wraz z przestrzeniami, np. PARSEXML(xml, “//DIDL-Lite:container[dc:title=‘My Playlist’’]/DIDL-Lite:res”);

Packet parser

Aby uzyskać więcej informacji, zobacz stronę o Packet Parser

SENDHTTPREQUEST

SENDDATA

MQTTPUBLISH

FTPDOWNLOAD

FTPUPLOAD

COMPLETESERVICEATTRIBUTE

COMPLETESERVICEACTION

Modbus

Modbus

Detailed info on Modbus configuration.