Help simultus

LUA_SCRIPT (224)

ID 224

Wygląd bloku LUA_SCRIPT zależy od zdefiniowanych przez użytkownika jego wejść i wyjść.

Zastosowanie:

PLC

SIM

Grupa: I/O

Opis skrótowy:

Uwaga: Już w krótce w wersji programu Simultus DIGITAL TWIN 5.0 nowe ułatwienia w korzystaniu z języka skryptowego LUA. Między innymi ulepszony edytor, wyszukiwanie tekstu, oznaczanie błędów składni. W krótce więcej informacji.

Blok funkcyjny LUA_SCRIPT umożliwia bardzo elastyczne tworzenie własnych bloków funkcyjnych, które posiadają zdefiniowaną przez użytkownika liczbę i nazwy wejść i wyjść, a funkcjonalnośc bloku jest określona poprzez realizację powiązanego z nim skryptu w języku LUA (wersja języka LUA: 5.4.2.).

UWAGA - to się może przydać:
- Tworzenie własnych bloków funkcyjnych i ich eksport do osobnego pliku: czytaj o tym tutaj !
- Automatyczne generowanie kodu LUA przy pomocy ChataGPT i Microsoft Bing Copliot - czytaj tutaj!

Pętle, operacje arytmetyczne, definicje funkcji i wiele innych funkcji... - skrypty LUA znakomicie zwiększą funkcjonalność programu SIMULTUS.

Zdecydowaliśmy się na implementację języka skryptowego LUA z uwagi na jego dużą funkcjonalność, popularność oraz dostępność wielu materiałów szkoleniowych w tym podręczników.

Poniżej przedstawiamy kilka przydatnych linków dla tych z Państwa, którzy chcieliby już dzisiaj zapoznać się z możliwościami tego języka.

- Strona główna LUA.org - strona główna organizacji zajmującej się rozwojem języka LUA (wersja polska)

- Podręcznik - (j.ang.) - pełna wersja podręcznika w języku angielskim (częściowo przetłumaczony na j. polski - link)

- DEMO języka skryptowego LUA online - przydatne narzędzie (z gotowymi przykładami) do nauki i szybkiego testowania programów

- Skrócony kurs YouTube (1h, j. ang.) - skrócony (1h) kurs LUA w języku angielskim w formie filmu

Wejścia - liczba i typy uzależnione od ustawień użytkownika.

Wyjścia - liczba i typy uzależnione od ustawień użytkownika.

Ustawienia:

podstawowe:

Ustawienia liczby i typów wejść i wyjść:

Działanie funkcji:

W celu wykorzystania skryptu LUA w programie Simultus należy na diagram bloków funkcyjnych wstawić blok o nazwie LUA_SCRIP z zakładki I/O oraz wywołać go przy pomocy aktywowania jego wejścia, np:

W celu uruchamiania skryptu przy każdym cyklu programu można na stałe aktywować wejście 'exe' korzystając np z bloku funkcyjnego BOOLCONST ustawionego na wartość 1:

Po wstawieniu bloku LUA_SCRIPT oraz dwukrotnym kliknięciu myszką w ten blok pojawi się nowa zakładka ze skryptami. Pierwszym z nich będzie skryptem globalnym (wykonywany zawsze przy starcie programu tylko raz) a drugi będzie odpowiadał nazwie naszego bloku LUA_SCRIPT (w poniższym przykładzie 'moj skrypt').
Należy aktywować wykonanie skryptu 'moj skrypt' poprzez aktywowanie jego wejścia 'exe'.

UWAGA: Zmienne globalne:
- Wszystkie zmienne zadeklarowane w skrypcie globalnym (który wykonuje sie tylko raz przy starcie symulacji) mogą być wykorzystane w pozostałych skryptach (w blokach funkcyjnych LUA_SCRIPT).
- Zmienne globalne nie tablicowe mogą być w tych skryptach tylko odczytywane.
- Skrypt lokalny bazuje na kopii zmiennej środowiskowej _ENV ze skryptu globalnego. Wszelkie modyfikacje tej zmiennej widoczne są tylko w ramach danego skryptu lokalnego, dlatego też zmiana wartości zmiennej globalnej ze skryptu globalnego jest widoczna tylko w danym skrypcie lokalnym. Modyfikowane mogą być tablice, które są dynamicznie alokowanymi obiektami. Zmienne odwołujące się do tablic nie są same z siebie tablicami tylko wskaźnikami (referencjami) na nie. Zapis do takiej zmiennej nie powoduje zmiany wartości tej zmiennej, tylko modyfikuje obiekt, na który wskazuje.
- Aby zmienić w skrypcie lokalnym zmienną globalną należy w skrypcie 'global' utworzyć zmienną tablicową jak w przykładach poniżej:

PRZYKŁAD 1:
a = {}         -- utworzenie pustej tablicowej zmiennej globalnej

Nastepnie w dowolnym skrypcie można zmienić wartość elementu tablicy:
a[1] = 500

lub wykorzytać ją do obliczeń:

suma = a[1] + 7

PRZYKŁAD 2:
Podobnie można utworzyć większą tablicę np. o nazwie 'POS':

POS = {}
for i=1,100 do
    POS[i] = {}
    for j=1,6 do
        POS[i][j] = 0
        end
    end

Powyższy przykład tworzy globalną tabelicę 100 x 6 dla wszystkich skryptów w projekcie, zapełnioną wartościami '0' (zero)
Nastepnie w dowolnym skrypcie można zmienić wartość elementu tablicy:
POS[1][2] = 500

albo całego jej wiersza:
POS[ 2 ] = {-300, 300, 0, 0, 0, -45}

lub wykorzystać wartość z tablicy do obliczeń:
suma = POS[2][1] + POS[2][2]

____________________________________________________________
koniec uwagi o zmiennych globalnych

Dodatkowe zakładki pojawią się po wstawieniu kolejnych bloków typu LUA_SCRIPT na diagram.

W powyższym przykładzie skrypt globalny wykona się przy starcie programu a skrypty 'moj skrypt' oraz 'moj skrypt 2' po naciśnięciu odpowiednich przycisków na panelu.

Każdy blok skryptu może mieć konfigurowalną liczbę (maksymalnie 30 dla każdego typu) i typ wejść i wyjść. Konfigurację można wykonać we właściwościach każdego z bloków, np:



Konfigurować można również nazwy wejść i wyjść:

Skrypt ma dostęp do następujacych zmiennych programu użytkownika:

- wejść bloku LUA_SCRIPT (wejścia typu R, I oraz B), z którym jest powiązany - tylko odczyt
- wyjść bloku LUA_SCRIPT (wejścia typu R, I oraz B) , z którym jest powiązany - tylko zapis
- rejestrów symulacji VRn (gdy blok funkcyjny LUA_SCRIPT jest zamieszczony na diagramie SIM) - odczyt i zapis
- rejestrów sterownika Rn (gdy blok funkcyjny LUA_SCRIPT jest zamieszczony na diagramach STARTUP, CONTROL lub PLC) - odczyt i zapis
- markerów symulacji VMn (gdy blok funkcyjny LUA_SCRIPT jest zamieszczony na diagramie SIM) - odczyt i zapis
- markerów sterownika Mn (gdy blok funkcyjny LUA_SCRIPT jest zamieszczony na diagramach STARTUP, CONTROL lub PLC) - odczyt i zapis
- wejść fizycznych sterownika Xn - tylko odczyt
- wyjść fizycznych sterownika Yn - tylko zapis

Przy zapisie markerów Mn, wejść Xn i wyjść Yn należy używać liczb całkowitych: FALSE = 0, TRUE = 1 (każda wartość niezerowa = TRUE). Użycie "TRUE" lub "FALSE" nie działa.

Poniżej znajduje się szczegółowy opis dostępu do poszczególnych zmiennych.

Opis dodatkowych funkcji języka LUA stworzonych specjalnie na potrzeby programu Simultus znajdziesz tutaj.

Dostęp do nich odbywa się za pomocą specjalnych obiektów, które należy utworzyć (przykłady poniżej). Dostęp odbywa się za pomocą składni dostępu do tablicy (Indeksy od 1).

Dzięki zastosowaniu poniżej przedstawionego przykładowego kodu użytkownik będzie miał dostęp do odpowiednich zmiennych programu poprzez wykorzystanie utworzonych obiektów i korzystanie z nich jak z tablic. Np dostęp do rejestru VR5 sterownika (zarówno odczyt jak i zapis) będzie możliwy poprzez odwołanie się do obiektu SIM_Registers_VR[5].

Dostęp do wejść bloku LUA_SCRIPT (wejścia typu R, I oraz B), z którym jest powiązany - tylko odczyt:

Tworzymy obiekt zmienną o dowolnej nazwie (sugerujemy: Function_Block_Inputs). Obiekt najlepiej utworzyć na początku skryptu '(SIM) global' lub '(Dev) global'.:
Function_Block_Inputs = FBInTblHelper.new()

i odwołujemy się do jej elementów jako tablicy:
stan_wejscia_5 = Function_Block_Inputs[5]

W ten sposób zapisaliśmy wartość 5-go zdefiniowanego przez nas wejścia (nie licząc wejścia 'exe') do zmiennej stan_wejscia_5.

Sugerujemy zamieszczenie następującego fragmentu kodu na początku każdego ze skryptów powiązanych z blokami funkcyjnymi LUA_SCRIPT:

-- utworzenie obiektu zapewniającego dostęp do we/wy bloku funkcyjnego LUA_SCRIPT:
Function_Block_Inputs = FBInTblHelper.new()
Function_Block_Outputs = FBOutTblHelper.new()

Dostęp wyjść bloku LUA_SCRIPT (wejścia typu R, I oraz B) , z którym jest powiązany - tylko zapis

Tworzymy obiekt o dowolnej nazwie (sugerujemy: Function_Block_Outputs). Obiekt najlepiej utworzyć na początku skryptu '(SIM) global' lub '(Dev) global'.:
Function_Block_Outputs = FBOutTblHelper.new()

i odwołujemy się do jej elementów jako tablicy:
Function_Block_Outputs[8] = 1

W ten sposób ustawiliśmy wartość 8-go zdefiniowanego przez nas wyjścia (nie licząc wejścia 'error') na 1.

Sugerujemy zamieszczenie następującego fragmentu kodu na początku każdego ze skryptów powiązanych z blokami funkcyjnymi LUA_SCRIPT:

-- utworzenie obiektu zapewniającego dostęp do we/wy bloku funkcyjnego LUA_SCRIPT:
Function_Block_Inputs = FBInTblHelper.new()
Function_Block_Outputs = FBOutTblHelper.new()

Dostęp do rejestrów symulacji VRn (gdy blok funkcyjny LUA_SCRIPT jest zamieszczony na diagramie SIM) - odczyt i zapis
(oraz rejestrów sterownika Rn (gdy blok funkcyjny LUA_SCRIPT jest zamieszczony na diagramach STARTUP, CONTROL lub PLC) - odczyt i zapis):

Tworzymy obiekt o dowolnej nazwie (sugerujemy: SIM_Registers_VR dla '(SIM) global'). Obiekt najlepiej utworzyć na początku skryptu '(SIM) global' lub '(Dev) global'.:
SIM_Registers_VR = RnTblHelper.new()

i odwołujemy się do jej elementów jako tablicy:
SIM_Registers_VR[5] = 3

W ten spoób utworzyliśmy obiekt o nazwie 'SIM_Registers_VR', który jest obrazem wartości przechowywanych w programie symulacji w rejestrach VR. Do tego obiektu (jak do tablicy) możemy zapisać lub odczytać wartość.

Przykład odczytu i zapisu do rejestrów:

SIM_Registers_VR[5] = 3
SIM_Registers_VR[6] = SIM_Registers_VR[5] + 2

Sugerujemy zamieszczenie następującego fragmentu kodu na początku skryptu '(SIM) global':

-- utworzenie obiektu zapewniającego dostęp do zmiennych symulacji:
SIM_Registers_VR = RnTblHelper.new()
SIM_Markers_VM = MnTblHelper.new()

Dostęp do markerów symulacji VMn (gdy blok funkcyjny LUA_SCRIPT jest zamieszczony na diagramie SIM) - odczyt i zapis
(oraz markerów sterownika Mn (gdy blok funkcyjny LUA_SCRIPT jest zamieszczony na diagramach STARTUP, CONTROL lub PLC) - odczyt i zapis):

Tworzymy obiekt o dowolnej nazwie (sugerujemy: SIM_Markers_VM dla '(SIM) global'). Obiekt najlepiej utworzyć na początku skryptu '(SIM) global' lub '(Dev) global'.:
SIM_Markers_VM = MnTblHelper.new()

i odwołujemy się do jej elementów jako tablicy:
SIM_Markers_VM[5] = 1

W ten sposób utworzyliśmy obiekt o nazwie 'SIM_Markers_VM', który jest obrazem wartości przechowywanych w programie symulacji w rejestrach VM lub w rejestrach sterownika M. Do tej tablicy możemy zapisać lub odczytać wartość.

Przykład odczytu i zapisu do markerów:

SIM_Markers_VM[6] = 1
stan_markera_6 = SIM_Markers_VM[6]

Sugerujemy zamieszczenie następującego fragmentu kodu na początku skryptu '(SIM) global':

-- utworzenie obiektu zapewniającego dostęp do zmiennych symulacji:
SIM_Registers_VR = RnTblHelper.new()
SIM_Markers_VM = MnTblHelper.new()

Dostęp do wejść fizycznych sterownika Xn - tylko odczyt

Tworzymy obiekt o dowolnej nazwie (sugerujemy: Device_Inputs_X). Obiekt najlepiej utworzyć na początku skryptu '(Dev) global'.:
Device_Inputs_X = XnTblHelper.new()

i odwołujemy się do jej elementów jako tablicy:
Device_Inputs_X[5] = 1

W ten spoób utworzyliśmy obiekt o nazwie 'Device_Inputs_X', który jest obrazem wartości wejść fizycznych sterownika. Z tego obiektu (jak z tablicy) możemy tylko odczytać wartość.

Przykład odczytu wejść fizycznych sterownika:

stan_wejscia_5 = Device_Inputs_X[5]

Tworzymy obiekt o dowolnej nazwie (sugerujemy: Device_Outputs_Y). Obiekt najlepiej utworzyć na początku skryptu '(Dev) global'.:
Device_Outputs_Y = XnTblHelper.new()

i odwołujemy się do jej elementów jako tablicy:
Device_Outputs_Y[3] = 1

W ten spoób utworzyliśmy obiekt o nazwie 'Device_Outputs_Y', który jest obrazem wartości wyjść fizycznych sterownika. Z tego obiektu (jak z tablicy) możemy odczytać lub zapisać wartość.

Przykład zapisu i odczytu wejść fizycznych sterownika:

stan_wyjscia_3 = Device_Outputs_Y[3]
Device_Outputs_Y[4] = Device_Outputs_Y[3]

Sugerujemy zamieszczenie następującego fragmentu kodu na początku skryptu '(Dev) global':

-- utworzenie obiektu zapewniającego dostęp do zmiennych i we/wy sterownika:
Device_Registers_R = RnTblHelper.new()
Device_Markers_M = MnTblHelper.new()
Device_Inputs_X = XnTblHelper.new()
Device_Outputs_Y = YnTblHelper.new()

Przykład skryptu wykorzystującego powyższe funkcje:

-- to jest przykład skryptu powiązanego z blokiem funkcyjnym LUA_SCRIPT

-- utworzenie obiektu zapewniającego dostęp do we/wy bloku funkcyjnego LUA_SCRIPT:
Function_Block_Inputs = FBInTblHelper.new()
Function_Block_Outputs = FBOutTblHelper.new()

-- utworzenie obiektu zapewniającego dostęp do zmiennych symulacji:
SIM_Registers_VR = RnTblHelper.new()
SIM_Markers_VM = MnTblHelper.new()

-- wykonanie działania na zmiennych LUA (zmienne tworzone dynamicznie):
a = 3
b = 4
c = math.sqrt(a^2 + b^2)

-- przekopiowanie wyniku działania do rejestrów VR symulacji:
SIM_Registers_VR[1] = c

-- pobranie wartości z wejść nr 1 oraz 2 bloku funkcyjnego LUA_SCRIPT
zezwolenie_1 = Function_Block_Inputs[1]
zezwolenie_2 = Function_Block_Inputs[2]

-- wykonanie działania na zmiennych logicznych:
zezwolenie = zezwolenie_1 & zezwolenie_2

-- przekopiowanie wyniku operacji logicznej do markerów VM symulacji:
SIM_Markers_VM[1] = zezwolenie

-- przekopiowanie wyniku operacji logicznej do wyjść bloku funkcyjnego:
Function_Block_Outputs[1] = SIM_Markers_VM[1]

Nazwy we/wy bloku funkcyjnego LUA_SCRIPT zadeklarowane we właściwościach bloku nie są powiązane z nazwami zmiennych w skrypcie.

Każdy typ umożliwia również pobranie rozmiaru (ilości elementów), np:.

rn[1] = MnTblHelper.size(mn)
rn[2] = RnTblHelper.size(rn)
rn[3] = FBInTblHelper.size(fb_in)
rn[4] = FBOutTblHelper.size(fb_out)

Uwaga!
Niektóre funkcje języka skryptowego LUA mogą bardzo spowalniać wykonywanie skryptu (np funkcja "print" ).
Proszę zachować ostrożność!