Linguaggio di scripting multilinea con evidenziazione della sintassi, utilizzabile nelle Equation, Formula e Script delle Smart Rule(s), e anche nelle interfacce Modbus e Packet Parser.

Nozioni di base

Assegnazione

1

Mu := Se + 2;

Algoritmo multilinea

Ogni riga è separata dal punto e virgola.

1
2

Last := Current;
Current := 0;

Valore restituito

• Risultato dell’ultima riga di codice
• RETURN(expression) interrompe l’esecuzione dell’algoritmo e restituisce il contenuto tra parentesi

1
2
3

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

Variabile temporanea

Esiste solo durante una singola esecuzione dello script.

1

VAR X := 5;

Clausola IF

Stile Excel

1
2

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

Stile multilinea

1
2
3
4
5
6
7

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

Switch

Verifica un’espressione rispetto a un elenco di casi e restituisce il valore corrispondente al primo caso che corrisponde, con un valore di default se nessun altro caso è soddisfatto.

1

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

Esempio:

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)

Loop

LOOP / WHILE … ripete una serie di comandi finché una condizione specificata è soddisfatta. CONTINUE … salta l’esecuzione dei comandi rimanenti e passa al ciclo successivo. BREAK … termina il ciclo.

Esempio con condizione all’inizio:

 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

Esempio con condizione alla fine:

1
2
3
4

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

Valore NaN (not a number)

NaN può essere restituito come valore nel caso in cui il valore reale non sia noto.

1
2

IF Temperature > 250 
  RETURN(NaN);

La funzione ISNAN(expression) restituisce TRUE se l’espressione non è un numero.

ISNULL

Restituisce true se il parametro è NULL, altrimenti false. Usato per i tipi String e Bytearray. Esempio: se l’elemento XML non viene trovato, il valore restituito è NULL, quindi il risultato della funzione è TRUE.

La sintassi della funzione è:

1

ISNULL(object)

Sleep

Mette in pausa lo script per un numero di millisecondi. Usare solo in casi molto specifici.

1

SLEEP(5);

Commenti

Nuova riga che inizia con il carattere #

1

# commento

Letterali numerici

Numeri esadecimali

Le espressioni possono interpretare anche numeri esadecimali. Il prefisso 0x è obbligatorio e il resto non è case-sensitive.

0x0A = 10

1
2

0xA0A0   (41120)
0xa0a0   (41120)

Numeri binari

0b1010 = 10

1

0b10101010   (170)

Espressioni matematiche

+, -, *, /

1

(20.5 + 9.5) / 2    (15)

Espressioni logiche

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

1
2

(!IsRaining OR (Wind>30))
MultiValueSwitchState != 2 (diverso da 2)

Funzioni

LINEAR

Restituisce un valore regolato linearmente – interpolazione lineare.

1

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

Parametri

• input… valore in ingresso
• value1_input… valore all’ingresso al limite inferiore
• value1_output… valore all’uscita al limite inferiore
• value2_input… valore all’ingresso al limite superiore
• value2_output… valore all’uscita al limite superiore
• [type]… parametro opzionale. Definisce cosa accade al risultato quando il valore in ingresso è fuori dall’intervallo value1_input ↔︎ value2_input:
  • senza parametro (uguale a BOUNDS)… Se il valore in ingresso è fuori dall’intervallo definito, il valore in uscita sarà uno degli estremi (minimo o massimo)
  • INFINITE… Se il valore in ingresso è fuori dall’intervallo definito, il risultato è un valore di estrapolazione
  • STRICT… Se il valore in ingresso è fuori dall’intervallo definito, il valore in uscita sarà NaN (non è un numero)

Esempi

1
2
3
4
5

Example 1: LINEAR(250,  0,0,  50,500)   (Risultato è 25°C)

Example 2: LINEAR(Co2,  400,0,  1200,1)
          (Se il valore dal sensore Co2 è 400ppm, l'output per il recupero aria sarà 0%. 
           Se Co2 è 1200, l'output sarà 100%. E se, ad esempio, Co2=800, l'output sarà 50%)

Esempi per differenti attributi [type]:

• input = 11
• value1_input = 0, value1_output = 400
• value2_input = 10, value2_output = 2000
• risultato per differenti parametri [type]:
  • BOUNDS (valore di default) = 2000
  • INFINITE = 2160
  • STRICT = NaN

HYSTERESIS

L’isteresi può essere utilizzata per filtrare segnali in modo che l’uscita reagisca meno rapidamente di quanto farebbe altrimenti, tenendo in considerazione la storia recente del sistema. Ad es. un termostato che controlla un riscaldatore può accendere il riscaldatore quando la temperatura scende al di sotto di A, ma non spegnerlo finché la temperatura non sale oltre B.

Restituisce 0 o 1.

1

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

Esempio: mantenere una temperatura di 20 °C entro una banda di isteresi di 2 °C. Accendere il riscaldatore quando la temperatura scende sotto i 18 °C e spegnerlo quando la temperatura supera i 22 °C.

1

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

Funzioni matematiche

MIN

La funzione MIN restituisce il minimo tra i valori numerici forniti. Accetta tra 1 e 100 argomenti o una singola collezione. I valori NaN e NULL sono ignorati.

1
2

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

Esempi:

 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)			... Risultato è d1

MINSTRICT

La funzione MINSTRICT restituisce il minimo tra i valori numerici forniti. Accetta tra 1 e 100 argomenti o una singola collezione. Se uno qualsiasi dei valori forniti è NaN o NULL, la funzione restituisce NaN/NULL.

1
2

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

Esempi:

 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)		... Risultato è NULL

MAX

La funzione MAX restituisce il massimo tra i valori numerici forniti. Accetta tra 1 e 100 argomenti o una singola collezione. NaN e NULL sono ignorati.

1
2

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

Esempi:

 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)				... Risultato è d2

MAXSTRICT

La funzione MAXSTRICT restituisce il massimo tra i valori numerici forniti. Accetta tra 1 e 100 argomenti o una singola collezione. Se uno qualsiasi dei valori forniti è NaN o NULL, la funzione restituisce NaN/NULL.

1
2

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

Esempi:

 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)		... Risultato è NULL

AVG

La funzione AVG calcola la media aritmetica dei valori numerici forniti. Accetta tra 1 e 100 argomenti o una singola collezione. I valori NaN sono ignorati.

1
2

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

Esempi:

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

La funzione AVGSTRICT calcola la media dei valori numerici forniti. Accetta tra 1 e 100 argomenti o una singola collezione. Se uno dei valori forniti non è un numero, la funzione restituisce NaN.

1
2

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

Esempi:

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)    

Restituisce il valore arrotondato.

1
2
3
4

Esempio 1: ROUND(2.01)   (Risultato è 2)
Esempio 2: ROUND(2.49)   (Risultato è 2)
Esempio 3: ROUND(2.5)    (Risultato è 3)
Esempio 4: ROUND(2.99)   (Risultato è 3)

ABS

La funzione ABS restituisce il valore assoluto (cioè il modulo) di qualsiasi numero fornito.

1

ABS(number)

Esempi:

1
2

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

DEWPOINT

1

DEWPOINT(temperature, relativeHumidity)

Restituisce la temperatura del punto di rugiada data la temperatura attuale e l’umidità relativa. Il punto di rugiada è calcolato secondo questa equazione.

1
2

Example 1: DEWPOINT(20, 0.50) (Result is ~9.26)
Example 2: DEWPOINT(0, 1.00) (Result is 0)

POWER

La funzione POWER calcola un numero dato elevato a una potenza fornita.

1

POWER(number, power)

Esempi:

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

MOD

La funzione MOD restituisce il resto di una divisione tra due numeri forniti.

1

MOD(number, divisor)

Argomenti:

• number - Il numero da dividere.
• divisor - Il valore per cui si divide il numero.

Esempi:

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

CEIL

La funzione CEIL arrotonda un numero fornito per eccesso, al multiplo di un numero dato.

1

CEIL(number, significance)

Argomenti:

• number   - Il numero da arrotondare.
• significance (optional) - Il multiplo al quale il numero fornito deve essere arrotondato. Se non specificato, significance = 1. (Questo dovrebbe avere lo stesso segno aritmetico, positivo o negativo, del numero fornito)

Esempi:

• 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

La funzione FLOOR arrotonda un numero fornito verso zero, al multiplo di una significatività specificata.

1

FLOOR(number, significance)

Argomenti:

• number - Il numero da arrotondare.
• significance (optional) - Il multiplo al quale il numero fornito deve essere arrotondato. Se non specificato, è uguale a 1. (Questo dovrebbe avere lo stesso segno aritmetico, positivo o negativo, del numero fornito)

Esempi:

• 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

La funzione RAND genera un numero reale casuale tra 0 e 1.

1

RAND()

Esempi:

• RAND()

RANDINT

La funzione RANDINT genera un intero casuale tra due interi forniti.

1

RANDINT(bottom, top)

Esempi:

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

SIGN

La funzione SIGN restituisce il segno aritmetico (+1, -1 o 0) di un numero fornito. Ad es. se il numero è positivo, SIGN restituisce +1, se è negativo restituisce -1 e se è 0 restituisce 0.

1

SIGN(number)

Esempi:

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

SQRT

La funzione SQRT calcola la radice quadrata positiva di un numero fornito.

1

SQRT(number)

Esempi:

• SQRT(25) … 5

LOG

La funzione LOG calcola il logaritmo di un numero dato, con una base fornita.

1

LOG(number, base)

Argomenti:

• number - Il numero reale positivo di cui si vuole calcolare il logaritmo.
• base (optional) - Argomento opzionale che specifica la base a cui calcolare il logaritmo. Se non specificato, la base di default è 10.

Esempi:

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

LN

La funzione LN calcola il logaritmo naturale di un numero dato.

1

LN(number)

dove l’argomento è il numero reale positivo di cui si vuole calcolare il logaritmo naturale.

Esempi:

• LN(100) … 4,60517

Operazioni sui bit

GETBIT

Restituisce il valore di un bit nella posizione specificata.

1

GETBIT(number, bit_position)

Argomenti:

• number - numero da cui estrarre il valore di un bit specifico
• bit_position - posizione del bit, partendo da 0, da destra

Esempi:

• GETBIT(2, 0) → il primo bit del numero 2 (0b0010) è 0
• GETBIT(4,2) → il terzo bit del numero 4 (0b0100) è 1

GETBITS

Restituisce il valore di un numero specificato di bit nella posizione specificata.

1

GETBITS(number, start_bit, number_of_bits)

Esempi:

• GETBITS(216, 3, 2) → numero 216 = 0b1101 1000; il valore del 4° bit da destra è 1, il 5° bit è 1, quindi il risultato è 0b0011 = 3
• GETBITS(0xFF, 0, 4) → numero 0xFF = 255 = 0b1111 1111; il valore dei primi 4 bit da destra è 0b1111 = 0xF = 15

GETBYTE

Restituisce il valore di un byte nel numero specificato.

1

GETBYTE( number, byte_position )

Argomenti:

• number - numero da cui estrarre il valore di un byte specifico
• byte_position - posizione del byte, partendo da 0, da destra

Esemppi:

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

Assegna un nuovo valore al byte specificato nel numero fornito e restituisce il nuovo numero.

1

SETBYTE( number, byte_position, new_value )

Esempi:

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

Assegna un nuovo valore al bit specificato nel numero fornito e restituisce un nuovo numero.

1

SETBIT(number, bit_position, new_value)

Argomenti:

• number - numero da modificare
• bit_position - posizione del bit, partendo da 0, da destra
• new_value - 0 o 1 - valore che verrà impostato sul bit specificato

Esempi:

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

SETBITS

Assegna un nuovo valore ai bit specificati nel numero fornito e restituisce un nuovo numero.

1

SETBITS(number, start_bit, number_of_bits, new_value)

Esempi:

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

Vedi l’esempio di operazioni sui bit in Google Sheets: https://docs.google.com/spreadsheets/d/1hF5FMpGMJbgYh-YLwWrq2n186_ATyGyLUb689__IhLY/edit?usp=sharing

Oppure prova lo strumento interattivo su http://bitwisecmd.com/

Testo, Stringa e Byte array

LENGTH

Restituisce la lunghezza di un oggetto o il numero di byte. L’oggetto può essere un numero, un booleano, una stringa o una Collezione.

1

LENGTH( object )

Esempi:

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

Crea una Collection a partire da valori esadecimali specificati.

1

BYTECOLLECTION( bytes )

Esempi:

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

Restituisce l’indice dell’elemento specificato in una stringa o in una collezione. Restituisce -1 se l’elemento non viene trovato.

1

INDEXOF( string/collection, element )

Esempi:

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

Copia una stringa o una collezione (o una loro parte).

1

COPY( string/collection, startIndex, length)

Esempi:

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

Restituisce una nuova stringa o una nuova collezione, in cui tutte le occorrenze del valore specificato sono sostituite con il nuovo valore.

1

REPLACE( string/collection, oldValue, newValue)

Esempi:

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

Divide una stringa in sottostringhe basate sui parametri separatori.

1
2
3
4

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

Esempi:

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

Confronta 2 stringhe e restituisce un intero che indica la loro posizione relativa nell’ordinamento.

1

COMPARE( string, string, CompareOptions )

Esempi:

1
2
3

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

APPEND

Aggiunge un valore a una collezione o a una stringa e restituisce un nuovo oggetto con il valore aggiunto.

1
2

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

Esempi:

1
2

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

INSERT

Inserisce un valore in una collezione o in una stringa. Restituisce la collezione o la stringa con il valore inserito.

1
2

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

Esempi:

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

Rimuove elementi dalla collezione o dalla stringa in base all’indice dell’elemento e alla lunghezza. Restituisce la collezione o la stringa senza gli elementi specificati.

1
2

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

Esempi:

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

Ottiene il valore di un elemento da una collezione o da una stringa in base all’indice fornito.

1
2

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

Esempi:

1
2

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

SETAT

Imposta il valore di un elemento nella collezione o in una stringa all’indice fornito.

1
2

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

Esempi:

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

Codifica una stringa specificata utilizzando uno dei formati e restituisce la nuova stringa.

1

ENCODE( string, format )

Formati supportati:

• XML
• Base64

Esempi:

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

Decodifica una stringa specificata utilizzando uno dei formati e restituisce la nuova stringa.

1

DECODE( string, format )

Formati supportati:

• XML
• Base64

Esempi:

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

Confronta due numeri in virgola mobile. I numeri sono considerati uguali se | n1 - n2 |< epsilon. Il valore predefinito della soglia (*epsilon) è 0.005 ed è un parametro opzionale.

1

EQUALS( number1, number2, epsilon=0.005 )

Esempi:

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)

Ordinamento

Esistono diverse varianti ORDER disponibili:
Ascendente - ORDER, ORDERSTRICT - ORDERINDEX, ORDERINDEXSTRICT
Discendente - ORDERDESC, ORDERDESCSTRICT - ORDERINDEXDESC, ORDERINDEXDESCSTRICT

ORDER

La funzione ORDER ordina i valori di input forniti in ordine crescente e li restituisce in una nuova collezione. Accetta n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti (ad es. numeri e stringhe) non sono consentiti. NaN e NULL sono ignorati ed esclusi dalla collezione restituita.

1
2

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

Esempi:

 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

La funzione ORDERINDEX ordina i valori di input in modo crescente, ma invece di restituire i valori ordinati, restituisce una collezione di indici che indicano le posizioni dei valori originali nell’ordine ordinato. Accetta n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono ignorati ed esclusi dalla collezione restituita.

1
2

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

Esempi:

 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

La funzione ORDERSTRICT ordina i valori di input in modo crescente e li restituisce in una nuova collezione. Può accettare n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono inclusi e sempre ordinati per primi nel risultato.

1
2

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

Esempi:

 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

La funzione ORDERINDEXSTRICT ordina i valori di input in modo crescente, simile a ORDERSTRICT. Tuttavia, invece di restituire i valori ordinati, restituisce una collezione di indici che indicano le posizioni dei valori originali nell’ordine ordinato. Accetta n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono inclusi e sempre ordinati per primi nel risultato.

1
2

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

Esempi:

 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

La funzione ORDERDESC ordina i valori di input forniti in ordine decrescente e li restituisce in una nuova collezione. Accetta n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono ignorati ed esclusi dalla collezione restituita.

1
2

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

Esempi:

 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

La funzione ORDERINDEXDESC ordina i valori di input in modo decrescente, simile a ORDERDESC. Tuttavia, invece di restituire i valori ordinati, restituisce una collezione di indici che indicano le posizioni dei valori originali nell’ordine ordinato. Accetta n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono ignorati ed esclusi dalla collezione restituita.

1
2

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

Esempi:

 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

La funzione ORDERDESCSTRICT ordina i valori di input in modo decrescente e li restituisce in una nuova collezione. Può accettare n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono inclusi e sempre ordinati per primi nel risultato.

1
2

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

Esempi:

 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

La funzione ORDERINDEXDESCSTRICT ordina i valori di input in modo decrescente, simile a ORDERDESC. Tuttavia, invece di restituire i valori ordinati, restituisce una collezione di indici che indicano le posizioni dei valori originali nell’ordine ordinato. Accetta n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono inclusi e sempre ordinati per primi nel risultato.

1
2

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

Esempi:

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

DATETIME

Crea un oggetto DateTime. La proprietà DateTime.Ticks è il numero di millisecondi dal 1.1.0001 00:00:00.000. DateTime ha le seguenti proprietà: 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  )

Esempi:

 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

Restituisce un oggetto DateTime impostato all’attuale data e ora nel fuso orario locale.

1

NOW()

Esempi:

1

VAR now := NOW();

TIMESPAN

La funzione TIMESPAN crea una variabile che rappresenta una durata di tempo, espressa in giorni, ore, minuti, secondi e millisecondi. TIMESPAN ha proprietà per accedere direttamente a ciascun componente della durata: DAYS, HOURS, MINUTES, SECONDS, MILLISECONDS. TIMESPAN ha inoltre proprietà per accedere al valore totale del tempo in unità specifiche (inclusi valori frazionari): TOTALDAYS, TOTALHOURS, TOTALMINUTES, TOTALSECONDS, TOTALMILLISECONDS.

1

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

Esempi:

1
2
3
4

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

Result ... 93784

LOCALTIMEZONE

Restituisce il fuso orario locale come numero di millisecondi rispetto all’ora UTC.

1

LOCALTIMEZONE()

Esempi:

1

VAR timezoneDiff := LOCALTIMEZONE();

DATETIMEADD

Aggiunge un numero specificato di anni, mesi, giorni, ore, minuti, secondi, millisecondi a una DateTime esistente e restituisce una nuova DateTime.

1

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

Esempi:

1

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

Conversioni tra tipi di dati

TODOUBLE

Converte una stringa in numero. Restituisce NaN in caso di errore.

1

TODOUBLE( text )

Esempi:

1
2
3

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

TOSTRING

Restituisce una stringa dal valore specificato o dalla Collection, secondo la codifica specificata. La codifica è opzionale (di default viene usata iso-8859-1).

1

TOSTRING(value, encoding)

Esempi:

1
2
3
4

TOSTRING(192, “X”)  …  Risultato = “C0”
TOSTRING(192, “X4”)  …  Risultato = “00C0”
TOSTRING(192, “F4”)  …  Risultato = “123.3400”
TOSTRING(192, “F0”)  …  Risultato = “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

Converte il numero fornito nel formato decimal-coded (BCD). Lo schema di codifica è BCD-8421.

1

TOBCD(number)

Esempi:

1
2
3

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

FROMBCD

Decodifica il numero fornito, che è codificato in Binary-Coded Decimal (BCD). Lo schema di codifica è BCD-8421.

1

FROMBCD(number)

Esempi:

1
2

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

TOBYTEARRAY

Converte una stringa in array di byte secondo la codifica specificata. La codifica è opzionale (di default è usata iso-8859-1).

1

TOBYTEARRAY( string, encoding )

Esempi:

1

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

RGBTOHSV

Converte una definizione di colore RGB e restituisce il colore in formato Hue / Saturation / Brightness.

1

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

Esempio:

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

Converte un colore definito da Hue / Saturation / Brightness e restituisce il colore in formato RGB.

1

HSVTORGB( hue, saturation, value )

Esempio:

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)

Funzioni di parsing

PARSETEXT

Restituisce una parte del testo di input, basata sui pattern di ricerca left e right.

1

PARSETEXT( input, left_pattern, right_pattern)

Esempi:

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”, “ipsum…sit”, “adipiscing”) (Result is “amet consectetur”)

PARSEJSON

Restituisce il valore di un elemento dalla stringa JSON formattata. L’elemento è specificato tramite json path.

1

PARSEJSON( json_string, json_path, ignore_error)

Esempi:

Con 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

Restituisce il valore di un elemento da una stringa XML. L’elemento è specificato tramite xml path.

1

PARSEXML( xml_string, xml_path)

Esempi:

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

Se xml contiene namespace, devi specificare completamente i nomi degli elementi con namespace, ad es. PARSEXML(xml, “//DIDL-Lite:container[dc:title=‘My Playlist’’]/DIDL-Lite:res”);

Packet Parser

Per ulteriori informazioni, vedere la pagina su Packet Parser

SENDHTTPREQUEST

SENDDATA

MQTTPUBLISH

FTPDOWNLOAD

FTPUPLOAD

COMPLETESERVICEATTRIBUTE

COMPLETESERVICEACTION

Modbus

Modbus

Informazioni dettagliate sulla configurazione Modbus.