Többsoros szkriptnyelv szintaxiskiemeléssel, amely okos szabályokban használható Egyenlet, Képlet és Szkript, valamint Modbus- és Csomag‑elemző felületeken is.

Alapok

Összekapcsolás

Mu := Se + 2;

Többsoros algoritmus

Minden sort pontosvessző választ el.

Last := Current;
Current := 0;

Visszatérési érték

• Az utolsó sor eredménye
• A RETURN(expression) leállítja az algoritmus végrehajtását, és a zárójelek között található kifejezés értékét adja vissza

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

Ideiglenes változó

Csak egy szkript‑végrehajtás idejére él.

VAR X := 5;

IF feltétel

Excel-stílus

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

Többsoros stílus

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

SWITCH

Egy kifejezést egy feltétellista alapján tesztel, és az első egyező esethez tartozó értéket adja vissza, illetve egy alapértelmezett értéket, ha egyik eset sem felel meg.

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

Példa:

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

Ciklus

A LOOP / WHILE … egy adott feltétel alapján ismétli egy parancssorozat végrehajtását. A ciklus addig fut, amíg a feltétel igaz. A CONTINUE … a hátralévő parancsok végrehajtását kihagyja, és a következő iterációra lép. A BREAK … kilép a ciklusból.

Példa: feltétel ellenőrzése a ciklus elején:

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

Példa: feltétel ellenőrzése a ciklus végén:

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

NaN (nem szám) érték

NaN érték akkor adható vissza, ha a valós érték nem ismert.

IF Temperature > 250 
  RETURN(NaN);

Az ISNAN(expression) függvény TRUE-t ad vissza, ha a kifejezés nem szám.

ISNULL

TRUE-t ad vissza, ha a paraméter NULL, ellenkező esetben FALSE. String és Bytearray típusokra használható. Példa: ha egy XML‑elem nem található, a visszatérési érték NULL, és az ISNULL igaz lesz rá.

A függvény szintaxisa:

ISNULL(object)

Sleep

A szkriptet késlelteti milliszekundumban megadott idővel. Csak nagyon specifikus esetekben használható.

SLEEP(5);

Megjegyzések

Új sor # jellel kezdve.

# comment

Numerikus literálok

Hexadecimális számok

A kifejezések hexadecimális számokat is értelmezhetnek. A prefix 0x kötelező, a maradék nem case‑sensitive.

0x0A = 10

0xA0A0   (41120)
0xa0a0   (41120)

Bináris számok

0b1010 = 10

0b10101010   (170)

Matematikai kifejezések

+, -, *, /

(20.5 + 9.5) / 2    (15)

Logikai kifejezések

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

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

Függvények

LINEAR

Visszaadja a lineárisan igazított értéket – lineáris interpolációt végez.

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

Paraméterek

• input … bemeneti érték
• value1_input … a bemeneti érték az alsó határnál
• value1_output … a kimeneti érték az alsó határnál
• value2_input … a bemeneti érték a felső határnál
• value2_output … a kimeneti érték a felső határnál
• [type] … opcionális paraméter. Meghatározza, mi legyen az eredmény, ha a bemeneti érték kívül esik a value1_input ↔︎ value2_input tartományon:
  • paraméter nélkül (ugyanaz, mint a BOUNDS) … Ha a bemeneti érték a definiált tartományon kívül van, a kimeneti érték az egyik szélsőérték (minimum vagy maximum) lesz
  • INFINITE … Ha a bemeneti érték a meghatározott tartományon kívül van, az eredmény extrapolált érték
  • STRICT … Ha a bemeneti érték a meghatározott tartományon kívül van, a kimeneti érték NaN.

Példák

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%)

Példa [type] attribútumokra:

• input = 11
• value1_input = 0, value1_output = 400
• value2_input = 10, value2_output = 2000
• eredmény különböző [type] paramétereknél:
  • BOUNDS (alapértelmezett) = 2000
  • INFINITE = 2160
  • STRICT = NaN

HISTERÉZIS

A hiszterézis használható a jelek szűrésére, hogy a kimenet ne reagáljon olyan gyorsan, hanem figyelembe vegye a rendszer előző állapotát. Például egy termosztát fűtést vezérel: bekapcsolja, ha a hőmérséklet A alá esik, de csak akkor kapcsolja ki, ha a hőmérséklet B fölé emelkedik.

0‑t vagy 1‑et ad vissza.

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

Példa: tartsunk 20 °C-os hőmérsékletet 2 °C hiszterézissel. Kapcsolja be a fűtést, ha a hőmérséklet 18 °C alá süllyed, és kapcsolja ki, amikor a hőmérséklet meghaladja a 22 °C‑ot.

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

Matematikai függvények

MIN

A MIN függvény visszaadja a megadott numerikus értékek közül a legkisebbet. 1 és 100 argumentumot vagy egyetlen gyűjteményt fogad. A NaN és NULL értékek figyelmen kívül maradnak.

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

Példák:

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)			... Result is d1

MINSTRICT

A MINSTRICT függvény visszaadja a megadott numerikus értékek közül a legkisebbet. 1 és 100 argumentumot vagy egyetlen gyűjteményt fogad. Ha bármelyik érték NaN vagy NULL, a függvény NaN/NULL értéket ad vissza.

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

Példák:

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)		... Result is NULL

MAX

A MAX függvény visszaadja a megadott numerikus értékek közül a legnagyobbat. 1 és 100 argumentumot vagy egyetlen gyűjteményt fogad. A NaN és NULL értékek figyelmen kívül maradnak.

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

Példák:

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)				... Result is d2

MAXSTRICT

A MAXSTRICT függvény visszaadja a megadott numerikus értékek közül a legnagyobbat. 1 és 100 argumentumot vagy egyetlen gyűjteményt fogad. Ha bármelyik érték NaN vagy NULL, a függvény NaN/NULL értéket ad vissza.

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

Példák:

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)		... Result is NULL

AVG

Az AVG függvény az átlagot (mean) számolja ki a megadott numerikus értékekből. 1 és 100 argumentumot vagy egyetlen gyűjteményt fogad. A NaN értékeket kizárja.

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

Példák:

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

Az AVGSTRICT függvény az átlagot számolja a megadott numerikus értékekből. 1 és 100 argumentumot vagy egyetlen gyűjteményt fogad. Ha bármelyik érték nem szám, NaN-t ad vissza.

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

Példák:

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

ROUND(value1)    

A megadott számot kerekített értékként adja vissza.

Példa 1: ROUND(2.01)   (Eredmény: 2)
Példa 2: ROUND(2.49)   (Eredmény: 2)
Példa 3: ROUND(2.5)    (Eredmény: 3)
Példa 4: ROUND(2.99)   (Eredmény: 3)

ABS

Az ABS függvény visszaadja a megadott szám abszolút értékét (azaz az előjel nélküli értéket).

ABS(number)

Példák:

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

DEWPOINT

DEWPOINT(temperature, relativeHumidity)

Visszaadja a harmatpont hőmérsékletét a jelenlegi hőmérséklet és relatív páratartalom alapján. A harmatpont a következő egyenlet szerint kerül kiszámításra.

Példa 1: DEWPOINT(20, 0.50) (Eredmény ~9,26)
Példa 2: DEWPOINT(0, 1.00) (Eredmény 0)

POWER

A POWER függvény egy számot megadott hatványra emel.

POWER(number, power)

Példák:

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

MOD

A MOD függvény a két megadott szám osztásának maradékát adja vissza.

MOD(number, divisor)

Argumentumok:

• number – az osztandó szám
• divisor – az az érték, amellyel a számot osztjuk

Példák:

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

CEIL

A CEIL függvény a megadott számot a megadott jelentőség legközelebbi, tőle felfelé eső többszörösére kerekíti (a nulla irányától függetlenül).

CEIL(number, significance)

Argumentumok:

• number – a kerekítendő szám
• significance (optional) – az a jelentőség, amelynek többszörösére a számot kerekíteni kell. Ha a jelentőséget nem adjuk meg, az alapértelmezett érték 1. (Általában ugyanazzal az előjellel kell rendelkeznie, mint a bemeneti szám.)

Példák:

• 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

A FLOOR függvény a megadott számot a megadott jelentőség legközelebbi, tőle lefelé eső többszörösére kerekíti (a nulla felé).

FLOOR(number, significance)

Argumentumok:

• number – a kerekítendő szám
• significance (optional) – az a jelentőség, amelynek többszörösére kerekítünk. Ha a jelentőséget nem adjuk meg, az alapértelmezett érték 1. (Jellemzően ugyanazzal az előjellel rendelkezik, mint a bemeneti szám.)

Példák:

• 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

A RAND függvény véletlenszerű valós számot generál 0 és 1 között.

RAND()

Példák:

• RAND()

RANDINT

A RANDINT függvény véletlenszerű egész számot ad két megadott egész szám között.

RANDINT(bottom, top)

Példák:

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

SIGN

A SIGN függvény visszaadja a megadott szám aritmetikai előjelét (+1, -1 vagy 0). Például ha a szám pozitív, a SIGN 1‑et ad vissza, ha negatív, akkor -1‑et, ha pedig 0, akkor 0‑t.

SIGN(number)

Példák:

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

SQRT

A SQRT függvény a megadott szám pozitív négyzetgyökét számolja ki.

SQRT(number)

Példák:

• SQRT(25) … 5

LOG

A LOG függvény a megadott szám logaritmusát számolja ki egy megadott alaphoz viszonyítva.

LOG(number, base)

Argumentumok:

• number – a pozitív valós szám, amelynek a logaritmusát számolni akarjuk
• base (optional) – opcionális argumentum, amely meghatározza a logaritmus alapját. Ha ezt az argumentumot nem adjuk meg, az alapértelmezett érték 10.

Példák:

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

LN

Az LN függvény a megadott szám természetes logaritmusát számolja ki.

LN(number)

ahol a szám pozitív valós szám.

Példák:

• LN(100) … 4,60517

Bitektanások

GETBIT

Visszaadja egy bit értékét a megadott helyen.

GETBIT(number, bit_position)

Argumentumok:

• number – a szám, amelyből a bit értékét ki akarjuk nyerni
• bit_position – a bit pozíciója, 0‑tól jobbra számolva

Példák:

• GETBIT(2, 0) → az 1. bit a 2‑es számnál (0b0010) 0
• GETBIT(4,2) → a 3. bit a 4‑es számnál (0b0100) 1

GETBITS

Visszaadja megadott számú bit értékét a megadott helyen.

GETBITS(number, start_bit, number_of_bits)

Példák:

• GETBITS(216, 3, 2) → 216 = 0b1101 1000; a jobbról számított 4. bit értéke 1, az 5. bit is 1, ezért az eredmény 0b0011 = 3
• GETBITS(0xFF, 0, 4) → 0xFF = 255 = 0b1111 1111; az első 4 bit értéke 0b1111 = 0xF = 15

GETBYTE

Visszaad egy bájt értékét a megadott számnál.

GETBYTE( number, byte_position )

Argumentumok:

• number – a szám, amelyből ki akarjuk nyerni a bájt értékét
• byte_position – a bájt pozíciója, 0‑tól balra számolva

Példák:

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

SETBYTE

Új értéket rendel a megadott bájthoz a megadott számnál, és visszaadja a módosított értéket.

SETBYTE( number, byte_position, new_value )

Példák:

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

SETBIT

Új értéket rendel a megadott bithez a megadott számnál, és egy új számot ad vissza.

SETBIT(number, bit_position, new_value)

Argumentumok:

• number – a módosítani kívánt szám
• bit_position – a bit pozíciója, 0‑tól balra számolva
• new_value – 0 vagy 1 – az adott bitre beállítandó érték

Példák:

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

SETBITS

Új értéket rendel a megadott bitekhez a megadott számnál, és egy új számot ad vissza.

SETBITS(number, start_bit, number_of_bits, new_value)

Példák:

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

«   (BAL OLDALI BIT SHIFT)

8 << 2   (32)

Excel: BITLSHIFT(number, shift_amount)

» (JOBBRA SHIFT)

32 >> 2   (8)

Excel: BITRSHIFT(number, shift_amount)

& (BITWISE AND)

3 & 1   (1)

Excel: BITAND(number1, number2)

| (BITWISE OR)

2 | 1 (3)

Excel: BITOR(number1, number2)

Lásd a bitműveletek Google Sheets példáit: https://docs.google.com/spreadsheets/d/1hF5FMpGMJbgYh-YLwWrq2n186_ATyGyLUb689__IhLY/edit?usp=sharing

Vagy próbáld ki az interaktív eszközt: http://bitwisecmd.com/

Szöveg, Karakterlánc és Bájtömb

LENGTH

Visszaadja egy objektum hosszát vagy bájtjainak számát. Az objektum lehet szám, logikai érték, string vagy gyűjtemény.

LENGTH( object )

Példák:

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

BYTECOLLECTION

Létrehoz egy Collection gyűjteményt meghatározott hexadecimális értékekből.

BYTECOLLECTION( bytes )

Példák:

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

INDEXOF

Visszaadja egy adott elem indexét karaktersorban vagy gyűjteményben. -1‑et ad vissza, ha az elem nem található.

INDEXOF( string/collection, element )

Példák:

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

Megadott szöveget vagy gyűjteményt (vagy annak részét) másolja.

COPY( string/collection, startIndex, length)

Példák:

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

Visszaad egy új szöveget vagy gyűjteményt, amelyben a megadott érték minden előfordulását lecseréli az új értékre.

REPLACE( string/collection, oldValue, newValue)

Példák:

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

Szöveget szeletel szét egy szeparátor alapján.

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

Példák:

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

Összehasonlít két szöveget, és visszaad egy egész számot, amely megmutatja az elemek rendezési viszonyát.

COMPARE( string, string, CompareOptions )

Példák:

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

APPEND

Értéket ad hozzá egy gyűjteményhez vagy szöveghez, és egy új objektumot ad vissza a hozzáadott értékkel.

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

Példák:

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

INSERT

Értéket szúr be a gyűjteménybe vagy szövegbe. Visszaadja a beszúrt értékkel módosított gyűjteményt vagy szöveget.

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

Példák:

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

Elemeket távolít el gyűjteményből vagy karakterláncból index és hossz alapján. Visszaadja a megadott elemeket már nem tartalmazó gyűjteményt vagy szöveget.

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

Példák:

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

Egy elem értékének lekérése gyűjteményből vagy szövegből a megadott index alapján.

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

Példák:

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

SETAT

Elem értékének beállítása a gyűjteményben vagy a szövegben a megadott indexnél.

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

Példák:

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

Megadott stringet kódol egy formátumba, és visszaadja az új stringet.

ENCODE( string, format )

Támogatott formátumok:

• XML
• Base64

Példák:

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

Megadott stringet dekódol egy formátumból, és visszaadja az új stringet.

DECODE( string, format )

Támogatott formátumok:

• XML
• Base64

Példák:

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

Két lebegőpontos számot hasonlít össze. A számok egyenlőnek tekintendők, ha | n1 - n2 | < epsilon. A küszöb (epsilon) alapértelmezett értéke 0,005, és opcionális paraméterként megadható.

EQUALS( number1, number2, epsilon=0.005 )

Példák:

EQUALS(1.33, 1.33)          1.0 (igaz)
EQUALS(1.333, 1.3335)		1.0 (igaz)
EQUALS(1.333, 1.338)		0.0 (hamis)
EQUALS(1.333, 1.338, 0.01)	1.0 (igaz)
EQUALS(NAN, NAN)		    1.0 (igaz)

Rendezés

Különböző ORDER változatok érhetők el:
Növekvő – ORDER, ORDERSTRICT – ORDERINDEX, ORDERINDEXSTRICT;
Csökkenő – ORDERDESC, ORDERDESCSTRICT – ORDERINDEXDESC, ORDERINDEXDESCSTRICT

ORDER

Az ORDER függvény a megadott bemeneti értékeket növekvő sorrendbe rendezi, és egy új gyűjteményben adja vissza. N értékig (legfeljebb 100 argumentumig) vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell számoknak lenniük, de összehasonlíthatónak kell lenniük (pl. számok, TIMESPAN, DATETIME, szövegek). Kevert típusok (pl. számok és szövegek) nem megengedettek. A NaN és NULL értékeket figyelmen kívül hagyja, és ezek nem szerepelnek a visszaadott gyűjteményben.

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

Példák:

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

Az ORDERINDEX függvény a megadott bemeneti értékeket növekvő sorrendbe rendezi, hasonlóan az ORDER‑höz. A rendezett értékek helyett azonban egy indexgyűjteményt ad vissza, amely megmutatja a kiindulási értékek helyét a rendezett sorrendben. 1–100 argumentumot vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell számoknak lenniük, de összehasonlíthatóknak kell lenniük.

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

Példák:

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

Az ORDERSTRICT függvény növekvő sorrendben rendezi a megadott bemeneti értékeket, és egy új gyűjteményt ad vissza. 1–100 értéket vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell numerikusnak lenniük, de összehasonlíthatóknak kell lenniük. A NaN és NULL értékek mindig az eredmény elejére kerülnek.

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

Példák:

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

Az ORDERINDEXSTRICT függvény a megadott bemeneti értékeket növekvő sorrendbe rendezi, hasonlóan az ORDERSTRICT‑hez. A rendezett értékek helyett azonban egy indexgyűjteményt ad vissza, amely megmutatja a kiindulási értékek helyét a rendezett sorrendben. 1–100 argumentumot vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell számoknak lenniük, de összehasonlíthatóknak kell lenniük. A NaN és NULL értékek mindig az eredmény elejére kerülnek.

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

Példák:

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

Az ORDERDESC függvény a megadott bemeneti értékeket csökkenő sorrendbe rendezi, és egy új gyűjteményben adja vissza. N értékig (legfeljebb 100 argumentumig) vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell számoknak lenniük, de összehasonlíthatóknak kell lenniük. Kevert típusok (például számok és szövegek) nem megengedettek. A NaN és NULL értékeket figyelmen kívül hagyja.

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

Példák:

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

Az ORDERINDEXDESC függvény a megadott bemeneti értékeket csökkenő sorrendbe rendezi, hasonlóan az ORDERDESC‑hez. A rendezett értékek helyett azonban egy indexgyűjteményt ad vissza, amely megmutatja a kiindulási értékek helyét a rendezett sorrendben. 1–100 argumentumot vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell számoknak lenniük, de összehasonlíthatóknak kell lenniük. A NaN és NULL értékeket mindig figyelmen kívül hagyja.

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

Példák:

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

Az ORDERDESCSTRICT függvény a megadott bemeneti értékeket csökkenő sorrendbe rendezi, és egy új gyűjteményben adja vissza. 1–100 értéket vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell numerikusnak lenniük, de összehasonlíthatóknak kell lenniük. A NaN és NULL értékek szerepelnek az eredményben, és mindig az elejére kerülnek.

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

Példák:

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

Az ORDERINDEXDESCSTRICT függvény a megadott bemeneti értékeket csökkenő sorrendbe rendezi, hasonlóan az ORDERDESCSTRICT‑hez. A rendezett értékek helyett azonban egy indexgyűjteményt ad vissza, amely megmutatja a kiindulási értékek helyét a rendezett sorrendben. 1–100 argumentumot vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell számoknak lenniük, de összehasonlíthatóknak kell lenniük. A NaN és NULL értékek szerepelnek az eredményben, és mindig az elejére kerülnek.

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

Példák:

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”) 	= {1, 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}

Dátum és idő

DATETIME

Létrehoz egy DateTime objektumot. A DateTime.TICKS tulajdonság a 0001.01.01. 00:00:00,000 óta eltelt milliszekundumok számát jelenti. A DateTime a következő tulajdonságokkal rendelkezik: TICKS, YEAR, MONTH, DAY, DAYOFWEEK, DAYOFYEAR, HOUR, MINUTE, SECOND, MILLISECOND, KIND, UTCDATETIME, LOCALDATETIME, UNIXTIME.

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

Példák:

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

Visszaad egy DateTime objektumot, amely a helyi időzónában a jelenlegi dátumot és időt tartalmazza.

NOW()

Példák:

VAR now := NOW();

TIMESPAN

A TIMESPAN függvény egy olyan változót hoz létre, amely egy időtartamot jelöl napokban, órákban, percekben, másodpercekben és milliszekundumokban. A TIMESPAN tulajdonságaihoz közvetlenül hozzáférhetünk minden komponenshez: DAYS, HOURS, MINUTES, SECONDS, MILLISECONDS. A TIMESPAN az idő összesített értékét is elérhetővé teszi adott egységekben (törtrészeket is tartalmazhat): TOTALDAYS, TOTALHOURS, TOTALMINUTES, TOTALSECONDS, TOTALMILLISECONDS.

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

Példák:

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

Result ... 93784

LOCALTIMEZONE

Visszaadja a helyi időzónát, mégpedig az UTC időponttól való eltérést milliszekundumban.

LOCALTIMEZONE()

Példák:

VAR timezoneDiff := LOCALTIMEZONE();

DATETIMEADD

Megnöveli egy adott DateTime értéket évek, hónapok, napok, órák, percek, másodpercek és milliszekundumok számával, és egy új DateTime értéket ad vissza.

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

Példák:

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

Adattípus-konverziók

TODOUBLE

Stringet számértékké konvertál. Hiba esetén NaN-t ad vissza.

TODOUBLE( text )

Példák:

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

TOSTRING

Visszaadja a megadott érték vagy gyűjtemény szöveges értékét a megadott formátum szerint. A második paraméter itt formátumminta, nem karakterkódolás.

TOSTRING(value, format)

Példák:

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

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

TOBCD

A megadott számot binary-coded decimal (BCD) formátumba konvertálja. A kódolás BCD‑8421.

TOBCD(number)

Példák:

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

FROMBCD

Dekódolja a megadott számot, amely BCD formátumban van kódolva. A kódolás BCD‑8421.

FROMBCD(number)

Példák:

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

TOBYTEARRAY

Konvertálja a szöveget bájt‑tömbbé a megadott kódolással. A kódolás opcionális (alapértelmezés szerint iso‑8859‑1).

TOBYTEARRAY( string, encoding )

Példák:

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

RGBTOHSV

Átalakítja az RGB színdefiníciót; visszaadja a színt Hue / Saturation / Value formátumban.

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

Példa:

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

A Hue / Saturation / Value által meghatározott színt RGB formátumba konvertálja.

HSVTORGB( hue, saturation, value )

Példa:

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)

Parsolási függvények

PARSETEXT

A bevitt szövegből adott bal és jobb keresési minta alapján visszaad egy részletet.

PARSETEXT( input, left_pattern, right_pattern)

Példák:

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

Visszaadja egy elem értékét JSON formátumú stringből. Az elemet a json_path útvonal adja meg.

PARSEJSON( json_string, json_path, ignore_error)

Példák:

JSON példa:

 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"
  }
}

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

Visszaadja egy elem értékét XML stringből. Az elemet az xml_path útvonal adja meg.

PARSEXML( xml_string, xml_path)

Példák:

XML minta:

 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>

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)

Ha az XML tartalmaz neve‑space‑eket, az elemek nevét teljes egészében, a namespace-szel együtt kell megadni, pl. PARSEXML(xml, “//DIDL-Lite:container[dc:title=‘My Playlist’’]/DIDL-Lite:res”);

PACKET PARSER

További információ a Packet parser oldalán

SENDHTTPREQUEST

SENDDATA

MQTTPUBLISH

FTPDOWNLOAD

FTPUPLOAD

COMPLETESERVICEATTRIBUTE

COMPLETESERVICEACTION

Modbus

Modbus

Részletes információk a Modbus konfigurálásáról.