S7-SCL programozási nyelv Az SCL (Structured Control Language = Struktúrált Vezérlő Nyelv) a DIN EN 61131-3 szabvány szerint készült, magas szintű PASCAL szintaxisra épülő programozási nyelv.
Az SCL előnyei •
Támogatja a STEP7 rendszer blokkos felépítését.
•
Az SCL nyelv képes a hagyományos PLC nyelvekben megírt blokkok fogadására is, mint az STL (Statement List), FBD (Function Block Diagram), LAD (Ladder Logic).
•
Lehetséges a CPU operációs rendszerében meglévő függvényblokkok használata.
•
Az SCL könnyen kezelhető, gyorsan tanulható.
•
A programozó munkájának hatékony támogatása már a forrás fájl szerkesztésénél is, jól kialakított fejlesztői környezet.
•
A lefordított program futtatható minden S7 300/400-as rendszeren.
•
Az SCL teszt és hibakereső (debugger) funkciójával a lefordított programban felderíthetőek a logikai programhibák. A nem szintaktikai és nem fordítási időben felderíthető hibák megtalálását a hibakereső modul (Debugger) segíti. A hibakeresés kétféle módon lehetséges, az ún. Single-step-, és a Continuous-monitoring támogatással: Single-step monitoring („Lépésről-lépésre figyelés”): A változók értékei lépésről lépésre, elemi időközönként változnak és megfigyelhetők. Continuous-monitoring („Folyamatos figyelés”): A program folyamatosan fut és közben a változók értékei is folytonosan változnak követve a program futását. A hibák felderítésében segíthetnek még a programban elhelyezhető Breakpoint-ok („Töréspontok”), ahol a program felfüggeszti futását egészen addig, míg a folytatásra nem kap utasítást. A Single-step mód is így valósítható meg.
A fejlesztői környezet használata Új forrás létrehozása egy, már a Simatic Manager-ben létrehozott projekt-ben történhet a File|New menüpont alatt, vagy a Ctrl+N billentyűkombinációval illetve a ikonnal. A korábban mentett forrásfájl megnyitása szintén a projekt-ből történhet a File|Open menüpont alatt, vagy a Ctrl+O billentyűkombinációval illetve a ikonnal lehetséges. Egyszerre több forrást is megnyithatunk, ezek elrendezésére vonatkozó lehetőségek a Window menüpontban állnak rendelkezésre. A programforrás szerkesztése után a fordítást a File|Compile menüpontban, vagy a CTRL+B billentyűkombinációval, illetve a ikon segítségével lehet elvégezni. A fordítás eredménye az alsó „error” ablakban olvasható, a fordító itt sorolja fel az esetleges hibákat, amelyek még fordítási időben kideríthetőek, illetve itt hívja fel a figyelmünket azokra a dolgokra, amik még okozhatnak problémákat a program futása során. Mind a warning, mind az error üzenetek sorokra hivatkoznak, duplán kattintva rájuk a program a hiba helyére állítja a kurzort. (A hiba lokalizálása a magasszintű nyelvek feldolgozási sémája miatt sokszor félrevezető lehet, pl. egy-egy pontosvessző elhagyása az interpreter számára akár több hibát is okozhat a valós hibától független helyeken...). A hibára egyet klikkelve, majd az F1 1
billentyűt megnyomva a help képernyő jelenik meg, ami szerencsés esetben megjeleníti a hiba leírását és esetleges megoldását is. Fontos, hogy a fordítást a hivatkozási szintek szerinti sorrendben végezzük el, azaz mindig azt a forrást (függvényt, függvényblokkot) fordítsuk előbb, amit egy másikból meghívunk és miután ez hibamentesen lefordult, csak utána fordítsuk a hívó függvényt. Van lehetőség ún. Fordítás Vezérlő Fájl (Compilation Control File) létrehozására is a File|New menüpontban. Ekkor az Object type szűrőt „SCL compile control file”-ra kell állítani. Ebben a fájlban felsorolhatjuk a fordítandó forrásokat a fordítás sorrendjében. Amennyiben ez az ablak aktív és így indítjuk a fordítást, akkor az a definiált sorrendben fog lezajlani, ezáltal nem kell mindig figyelni a sorrendre. A sikeres fordítás után a generált kódot a PLC-be, vagy a szimulátorba (S7-PLCSIM) kell tölteni. Ezt a műveletet végezhetjük a SIMATIC MANAGER-ből, vagy az SCL fejlesztő környezetből is. Az utóbbi művelet a PLC|Download menüpont alatt érhető el. Letöltés után, futtatás közben végezhető a hibakeresés a monitor funkcióval, ami a Debug|Monitor menüpontban, vagy a Ctrl+F7 billentyűkombinációval, vagy a ikonnal érhető el. A monitor aktivizálódásakor az editor ablak két részre osztódik, a bal oldalon (pl. egérrel) kijelölt változók értékei a jobb oldali monitor ablakban jelennek meg. A Single step üzemmódú monitorozás töréspontok (Breakpoint) segítségével valósítható meg.
Változók Típus Bit Byte Word Double word Karakter Integer Double integer Lebegőpontos
Név BOOL BYTE WORD DWORD CHAR INT DINT REAL
Ábrázolás [bit] 1 bit 8 bit 16 bit 32 bit 8 bit 16 bit 32 bit 32 bit
S5TIME / S5T
16 bit
Idő periódus (1 TIME / T ms-os lépésközzel) Dátum (1 napos DATE / D lépésközzel) Napi idő (1 ms-os TIME_OF_DA lépésközzel) Y / TOD Dátum és idő DATE_AND_ TIME / DT Sztring STRING Tömb ARRAY Struktúra STRUCT
32 bit
S5 időegység
Értelmezési tartomány 0,1, vagy FALSE,TRUE
16 bit
Kiterjesztett ASCII kar. –32768 ... +32767 –2147483648 ... +2147483647 –3.402822E+38 ... –1.175495E–38 +/– 0 +1.175495E–38 ... +3.402822E+38 T#0H_0M_0S_10MS .. T#2H_46M_30S_0MS –T#24D_20H_31M_23S_647MS ... +T#24D_20H_31M_23S_647MS D#1990-01-01 ... D#2168-12-31
32 bit
TOD#0:0:0.0 … TOD#23:59:59.999
64 bit
DT#1990-01-01-0:0:0.0 ... DT#2089-12-31-23:59:59.999 max. 254 karakter
Változók, blokk paraméterek deklarálása, konstansok definiálása A PASCAL nyelvhez hasonlóan a változókat a program blokk elején kell deklarálni. Ennek formája függ a változó, ill. blokk paraméter feladatától. A blokk paraméter lehet kimeneti, bemeneti, ki-/bemeneti, a változó lehet dinamikus (temporális) és statikus. A blokk típusától függően használhatóak a blokk paraméterek és a változó típusok is, a következő táblázat ezt a korlátozást foglalja össze.
2
Statikus változók deklarálása: A rendszer a statikus változóknak a program futásának kezdetekor lefoglalja a memóriaterületet és a futás teljes időtartama alatt foglalja azt. Deklarációja a következő módon történik, egy példával illusztrálva: VAR X:INT; END_VAR
Dinamikus (temporary) változók deklarálása: A dinamikus változó a függvény hívásakor létrejön, függvényhívás végén pedig megszűnik. Deklarációja a következő módon történik, egy példán keresztül illusztrálva: VAR_TEMP X:INT; END_VAR
Összetett változók deklarálása: Létrehozandó_sztring_neve : STRING; Létrehozandó_sztring_neve : STRING[44]; Tömb_neve : ARRAY [1..3,1..4] OF változó_típ; Strukt_név : STRUCT data1 : REAL ; data2 : INT := 5; //Vált. dekl.,értékadással END_STRUCT ;
Kimeneti-, bemeneti- és ki/bemeneti blokk paraméterek deklarálása: A blokk paramétereket függvény, függvény-blokk, … paraméterátadásánál kell alkalmazni, a függvény ezeken keresztül kommunikál az őt hívó blokkal, a bemeneti paraméterekkel kapja a bemeneti értékeket, a kimeneti paraméterekkel pedig küldi a feladatától függő kimenő értékeket. A deklaráció a következő módon történik, egy példán keresztül illusztrálva: VAR_INPUT a:INT; END_VAR
//Bemeneti paraméter
VAR_OUTPUT b:INT; END_VAR
//Kimeneti paraméter
VAR_IN_OUT c:INT; END_VAR
//Be-/kimeneti paraméter
Konstans definiálása: A konstansokat szintén a program deklarációs részében kell megadni, a változók előtt, vagy után. CONST konstans_neve := érték; END_CONST
A változók és konstansok értékadásának szintaktikája: A változók értékeit és a konstansokat a következő módon adhatjuk meg: Típus BOOL BYTE WORD DWORD INT DINT REAL CHAR
Konstans szintaktika BOOL#1; bool#0; Bool#false; BOOL#TRUE BYTE#0; B#2#101; Byte#'ä'; b#16#f WORD#32768; word#16#f; W#2#1001_0100; WORD#8#177777 DWORD#16#f000_0000; dword#32768; DW#2#1111_0000_1111_0000; DWord#8#37777777777 INT#16#3f_ff; int#-32768; Int#2#1111_0000; inT#8#77777 DINT#16#3fff_ffff; dint#-1000_0000; DInt#2#1111_0000; dinT#8#17777777777 REAL#1; real#1.5; real#2e4; real#3.1 CHAR#A; CHAR#49
3
Blokkok, blokk típusok és felépítéseik az SCL nyelvben Rendszer-blokk (OB = Organization Block): Tartja a kapcsolatot a CPU operációs rendszere és a felhasználó program között. ORGANIZATION_BLOCK OBxxx VAR_TEMP // OB-hez szükséges tömb típusú változó és egyéb din. változók Info: ARRAY[0..19] OF BYTE; END_VAR BEGIN Utasitas1; Utasitas2; ... END_ORGANIZATION_BLOCK
Függvény-blokk (FB = Function Block): Logikai blokk statikus változókkal és memóriával, ahol például kimeneti értékeket lehet átadni. FUNCTION_BLOCK FBxxx VAR_INPUT // Bemeneti változók END_VAR VAR_OUTPUT // Kimeneti változók END_VAR VAR_TEMP // Dinamikus változók END_VAR VAR // Statikus változók END_VAR BEGIN Utasitas1; Utasitas2; ... END_FUNCTION_BLOCK
Függvény (FC = Function): Memória nélküli logikai blokk, visszatérési értékkel. Amennyiben nem kívánunk a függvényhez visszatérési értéket rendelni, akkor a függvény változó típusának VOID-ot kell megadni: FUNCTION FCxxx: VOID. FUNCTION FCxxx: INT VAR_INPUT // Bemeneti változók END_VAR VAR_OUTPUT // Kimeneti változók END_VAR VAR_TEMP // Dinamikus változók END_VAR BEGIN Utasitas1; Utasitas2; ... FCxxx := 100; END_FUNCTION
// Értékadás a függvénynek, ha nem VOID
Adat-blokk (DB = Data Block): Feladata a logikai blokkok (FB) adatainak tárolása. DATA_BLOCK DB20 STRUCT // Deklarációs rész VALUE:ARRAY [1..100] OF INT; END_STRUCT BEGIN . . END_DATA_BLOCK
Felhasználói adattípus (UDT = User Data Type): Felhasználó által definiált adatstruktúra elhelyezése. Az UDT felépítése példán keresztül: TYPE MEASVALUES STRUCT // UDT definíció statikus szimbólumazonosítókkal
4
BIPOL_1 : INT := 5; BIPOL_2 : WORD := W#16#FFAA; BIPOL_3 : BYTE := B#16#F1; BIPOL_4 : WORD := B#(25,25); MEASURE : STRUCT // Struktúrába ágyazott alstruktúra. BIPOLAR_10V : REAL; UNIPOLAR_4_20MA : REAL; END_STRUCT; END_STRUCT; END_TYPE // Az UDT használata pl. egy FB-ből. FUNCTION_BLOCK FB10 VAR MEAS_RANGE : MEASVALUES; END_VAR BEGIN ... MEAS_RANGE.BIPOL_1 := -4; MEAS_RANGE.MEASURE.UNIPOLAR_4_20MA := 2.7; ... END_FUNCTION_BLOCK
A blokkok keretszerkezetek (OB, FC, FB, DB, UDT). melyek elérhetőek és beilleszthetőek az SCL editor Insert|Block template menüpontjából is.
Műveletek Alapműveletek A következő táblázatból kiolvashatóak az alapműveletek elvégzéséhez és az eredmény tárolásához szükséges változó típusok, ahol •
ANY_INT bejegyzés az INT és DINT változókat jelöli
•
ANY_NUM bejegyzés az INT, DINT, és REAL változókat jelöli
Művelet Hatványozás Unary plus
Azonosító ** +
Unary minus
–
Szorzás
*
Osztás
/
Egész osztás
DIV
Modulo osztás Összeadás
MOD +
Kivonás
–
1. változó ANY_NUM ANY_NUM TIME ANY_NUM TIME ANY_NUM TIME ANY_NUM TIME ANY_INT TIME ANY_INT ANY_NUM TIME TOD DT ANY_NUM TIME TOD DATE TOD DT DT
2. változó ANY_NUM – – – – ANY_NUM ANY_INT ANY_NUM ANY_INT ANY_INT ANY_INT ANY_INT ANY_NUM TIME TIME TIME ANY_NUM TIME TIME DATE TOD TIME DT
5
Eredmény REAL ANY_NUM TIME ANY_NUM TIME ANY_NUM TIME ANY_NUM TIME ANY_INT TIME ANY_INT ANY_NUM TIME TOD DT ANY_NUM TIME TOD TIME TIME DT TIME
Precedencia 2 3 3 3 3 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5
Ezek használatával lehet csak a műveleteket elvégezni. Amennyiben egyéb változótípussal szeretnénk műveletet végezni, akkor az SCL alapfüggvényei között megtaláljuk a szükséges imlpicit vagy explicit konverziót – esetleg több lépésben – elvégző függvényeket. Implicit konverziós függvények: ANY_BIT = BOOL > BYTE > WORD > DWORD ANY_NUM = INT > DINT > REAL
A osztályú implicit konverziós függvények: BOOL_TO_BYTE, BOOL_TO_DWORD, BOOL_TO_WORD, BYTE_TO_DWORD, BYTE_TO_WORD, CHAR_TO_STRING, DINT_TO_REAL, INT_TO_DINT, INT_TO_REAL, WORD_TO_DWORD
B osztályú explicit konverziós függvények: BYTE_TO_BOOL, BYTE_TO_CHAR, CHAR_TO_BYTE, CHAR_TO_INT DATE_TO_DINT DINT_TO_DATE, DINT_TO_DWORD, DINT_TO_INT, DINT_TO_TIME, DINT_TO_TOD, DWORD_TO_BOOL, DWORD_TO_BYTE, DWORD_TO_DINT, DWORD_TO_REAL, DWORD_TO_WORD INT_TO_CHAR, INT_TO_WORD REAL_TO_DINT, REAL_TO_DWORD, REAL_TO_INT STRING_TO_CHAR TIME_TO_DINT TOD_TO_DINT WORD_TO_BOOL, WORD_TO_BYTE, WORD_TO_INT, WORD_TO_BLOCK_DB BLOCK_DB_TO_WORD
Például egy BYTE típusú változó (b) szorzása 3-mal a következő módon történik, felhasználva az SCL SFC (Standard Functions) konverter függvényeit: a:= WORD_TO_BYTE(INT_TO_WORD(3*WORD_TO_INT(BYTE_TO_WORD(b))));
Bitműveletek A logikai függvények elvégzése BOOL, BYTE, WORD, és DWORD típusú változókon értelmezett, a következő táblázatban ezek összefoglaló neve az ANY_BIT. Művelet Negálás Logikai ÉS Kizáró VAGY Logikai VAGY
Azonosító NOT AND XOR OR
1. változó ANY_BIT ANY_BIT ANY_BIT ANY_BIT
2. változó – ANY_BIT ANY_BIT ANY_BIT
Eredmény ANY_BIT ANY_BIT ANY_BIT ANY_BIT
Precedencia 3 8 9 10
Például két BYTE (b,c) típusú változó esetén az eredmény is kerülhet BYTE típusú változóba (a): a:=b AND c;
Elágazások, feltételek, ciklusszervező utasítások A PASCAL nyelvhez hasonlóan itt is megtalálhatóak a szokványos IF, CASE, FOR, WHILE, REPEAT (CONTINUE, EXIT) szerkezetek, amelyek funkcióikban teljesen szintaktikájában pedig nagyon hasonlóak a PASCAL-ban használt hasonló szerkezetekhez. MEGJEGYZÉS: Az SCL is tartalmazza a GOTO feltétel nélküli ugró utasítást, de annak használata mint minden magasszintű nyelvben elkerülhető és elkerülendő, mivel használata áttekinthetetlenné tenné a program működését.
6
CASE A vizsgált INTEGER típusú változó adott értékeihez definiálhatunk akciókat, illetve egy ELSE ágban adhatjuk meg a nem definiált értékek előfordulásakor elvégzendő műveleteket. A CASE blokk lezárása az END_CASE kulcsszóval történik. Szintaktikája egy példán keresztül bemutatva a következő: CASE TW OF 1 : DISPLAY:= OVEN_TEMP; //Ha TW változó értéke=1,akkor ...; 2 : DISPLAY:= MOTOR_SPEED; //Ha TW változó értéke=2,akkor ...; 3 : DISPLAY:= GROSS_TARE; QW4:= 16#0003; //Ha TW változó értéke=3,akkor ...; ...; 4..10: DISPLAY:= INT_TO_DINT (TW); QW4:= 16#0004; //Ha TW változó értéke=4,5,6,..,10,akkor ..; ...; 11,13,19: DISPLAY:= 99; QW4:= 16#0005; // Ha TW változó értéke=11,13,vagy 19 akkor ...; ELSE: DISPLAY:= 0; TW_ERROR:= 1; //Ha egyik sem teljesül,akkor ...; ...; END_CASE; //CASE blokk lezárása
IF A program feltételhez kötött elágazását valósítja meg. A feltételben egy BOOL típusú kifejezésnek kell állnia, aminek igaz (true) értéke esetén a THEN kulcsszó utáni blokk hajtódik végre, ellenkező esetben a program folytatja futását, amíg olyan feltételt nem talál, ami teljesülne. Ha egy feltétel sem teljesül, akkor az opcionális ELSIF („különben ha xy igaz”), vagy az ELSE („egyébként, azaz ha semmi nem teljesül”) ágban lévő programblokk hajtódik végre. Az IF blokk lezárása az END_IF kulcsszóval történik. Szintaktikája egy példán keresztül bemutatva a következő: IF FLAG THEN N := 0 ; SUM := 0 ; OK := FALSE ; ELSIF START = TRUE THEN //TRUE, akkor... N := N + 1 ; SUM := SUM + N ; ELSE OK := FALSE ; END_IF ;
//Ha a FLAG változó étréke TRUE, akkor ...
//Különben, ha START változó értéke
//Ha egyik sem teljesül, akkor ... //IF blokk lezárása
FOR A FOR ciklusszervező utasítás, egy INTEGER típusú változó értékét növeli ciklikusan adott értékkel, amíg a megadott végértéket el nem éri, közben pedig végrehajtja a blokkon belül szereplő utasításokat. A FOR blokk lezárása az END_FOR kulcsszóval történik. FIGYELEM: A FOR ciklus futási ideje egyenlő a ciklusok száma × a cikluson belül szereplő utasítások végrehajtásához szükséges idő-vel. Ha ez nagyobbra adódik egy PLC ciklusidőnél, akkor a program nem tud lefutni a PLC-ben, hiba miatt felfüggeszti a futását, még akkor is ha az a szimulátorban láthatóan hiba nélkül lefut. Ez igaz bármelyik ciklusszervező utasításra, tehát ezekkel óvatosan kell bánni. Biztonságosabb megoldás a kritikusnak tűnő ciklusokat pl. az OB1, vagy OB35-ös blokkal megoldani, ami ciklikusan meghívódik, közben végrehajtani az adott feladatot és számolni a lefutott ciklusok számát. Szintaktikája egy példán keresztül bemutatva a következő: // A ciklusváltozó az INDEX 0-tól fut 100-ig,2-es lépésközzel, ciklusonként
7
// az ARR nevű BOOL típusú tömb INDEX-edik elemét TRUE-ra állítja, // majd befejezi a ciklust. FOR INDEX := 0 TO 100 BY 2 DO ARR[INDEX]:=TRUE; END_FOR;
WHILE A WHILE utasítás is ismert lehet a magasszintű programozási nyelvekből, mint feltételes ciklusszervező utasítás. A blokk ún. előltesztelő vizsgálatot végez, azaz a blokkon belüli utasítások csak akkor és addig futnak le, amíg előtte a WHILE kulcsszó utáni BOOL értékű feltétel TRUE értékű. Az is előfordulhat, ellentétben majd a másik – soron következő – feltételes ciklusszervező utasítással (REPEAT), hogy a WHILE utasításblokkja egyszer sem fut le. A WHILE blokk tehát vizsgálja a megadott feltételt és ha az teljesül, akkor az END_WHILE kulcsszóig tartó utasításblokkot addig futtatja ciklikusan, amíg ez a feltétel teljesül, ellenkező esetben az utasításblokk futtatása nélkül kilép a ciklusból és továbbadja a vezérlést. Szintaktikája egy példán keresztül bemutatva a következő: // A ciklus akkor és addig fut egymás után folyamatosan, amíg az // INDEX nevű változó 50-nél kisebb ÉS az IDWORD tömb INDEX-edik // eleme nem azonos a ‘KEY’ bejegyzéssel. Egy ciklus alatt pedig az // INDEX nevű változó értéke növekszik 2-vel. A blokkot az END_WHILE // kulcsszó zárja. WHILE INDEX <= 50 AND IDWORD[INDEX] <> ’KEY’ DO INDEX := INDEX + 2; END_WHILE;
REPEAT A REPEAT a másik feltételes ciklusszervező utasítás. A blokk ún. hátultesztelő vizsgálatot végez, azaz a blokkon belüli utasítások csak akkor és addig futnak le, amíg a blokk utáni UNTIL kulcsszó utáni BOOL értékű feltétel TRUE értékű nem lesz. Mivel a vizsgálat az utasításblokk után van, ezért előfordulhat, hogy a feltétel TRUE már az első lefutás előtt is, de a ciklus ettől függetlenül egyszer mindenképpen le fog futni. Az utasításblokk a REPEAT kulcsszóval kezdődik és az UNTIL + feltétel, majd az END_REPEAT kulcsszóval végződik. Szintaktikája egy példán keresztül bemutatva a következő: REPEAT INDEX := INDEX + 2; UNTIL INDEX > 50 END_REPEAT;
// // // // //
Ciklus kezdete Utasításblokk Feltétel:amíg az INDEX nagyobb nem lesz 50-nél Blokk lezárása
CONTINUE A cikluson (FOR, WHILE, REPEAT) belül bárhol kiadva a CONTINUE utasítást a ciklus további része nem fut le, hanem előről indul a következő ciklus. Szintaktikája egy példán keresztül bemutatva a következő: WHILE INDEX <= 100 DO INDEX := INDEX + 1; // Ha ARRAY[INDEX] egyenlő az INDEX-szel, // akkor az ARRAY [INDEX] nem változott, a ciklus induljon előről. IF ARRAY[INDEX] = INDEX THEN CONTINUE; END_IF; ARRAY[INDEX] := 0; // Ha az IF nem teljesül, azaz a CONTINUE nem fut le, akkor végre //hajtódik a nullázás END_WHILE;
EXIT A cikluson (FOR, WHILE, REPEAT) belül bárhol kiadva az EXIT utasítást az a ciklusból való azonnali kiugrást eredményezi. FIGYELEM: Az EXIT használata áttekinthetetlenné teszi a program működését, lehetőség szerint ne használjuk. 8
Szintaktikája egy példán keresztül bemutatva a következő: FOR INDEX_1 := 1 TO 51 BY 2 DO // Kiugrás a ciklusból,ha IDWORD[INDEX_1]= ’KEY’ IF IDWORD[INDEX_1] =’KEY’ THEN INDEX_2 := INDEX_1; EXIT; END_IF; END_FOR;
Számlálók használata A számláló feladata a bemenetére érkező impulzusok számlálása az értelmezési tartományon belül. A számlálóknak a STEP7-ben három típusuk van: •
Felfelé számláló (S_CU)
•
Lefelé számláló (S_CD)
•
Fel/le számláló (S_CUD)
A számlálók paraméterei: Paraméter C_NO CD CU S PV R Q CV
Adat típus COUNTER INT BOOL BOOL BOOL WORD BOOL BOOL WORD
Leírás Számláló azonosító CD bemenet:lefelé számlálás CU bemenet:felfelé számlálás Számláló töltése PV-vel Kezdő érték, S-sel betölthető Reset bemenet Kimenet:Számláló státusza Kimenet:Érték bináris formában
Felfelé számláló (S_CU) használata, paraméterezése: •
A számláló értéke egyel növekszik, ha a CU bemenet 0-ról 1-re vált és a számláló értéke kisebb, mint 999, azaz felfutó élre billen.
•
A számláló feltölthető a PV bemenetében megadott értékkel, ha az S bemenetre felfutó él (0-1 átmenet) érkezik.
•
A számláló resetelhető, ha az R bemenetet 1-be állítjuk, ilyenkor az értéke 0-ra változik.
•
A Q kimeneten 1 van ha a számláló értéke nagyobb nullánál és 0, ha a számláló értéke is 0.
Lefelé számláló (S_CD) használata, paraméterezése: •
A számláló értéke egyel csökken, ha a CD bemenet 0-ról 1-re vált és a számláló értéke nagyobb, mint 0, azaz felfutó élre billen.
•
A számláló feltölthető a PV bemenetében megadott értékkel, ha az S bemenetre felfutó él (0-1 átmenet) érkezik.
•
A számláló resetelhető, ha az R bemenetet 1-be állítjuk, ilyenkor az értéke 0-ra változik.
•
A Q kimeneten 1 van ha a számláló értéke nagyobb nullánál és 0, ha a számláló értéke is 0.
9
A fel/le számláló használata , paraméterezése: Ekvivalens az előző kettővel, csak attól függően, hogy éppen fel, vagy lefelé szeretnénk számoltatni vagy a CU, vagy a CD bemenetet kell meghajtanunk. Példa számláló használatára: FUNCTION_BLOCK COUNT VAR_INPUT MYCOUNTER : COUNTER; END_VAR VAR_OUTPUT RESULT : INT;
//Számláló azonosítója //Számláló tartalma INTEGER //formátumban
END_VAR VAR SET : BOOL; RESET : BOOL; BCD_VALUE : WORD; BIN_VALUE : WORD; INITIALVALUE : WORD; END_VAR
//S flag //R flag //Számláló értéke BCD formában //Számláló értéke BCD formában //Betölthető kezdőérték
BEGIN //Felparaméterezés Q0.0 := 1; SET := I0.2; RESET := I0.3; INITIALVALUE := 16#0089; //Indítás lefelé számláló üzemmódban BCD_VALUE := S_CD( C_NO := MYCOUNTER, CD := I0.0, S := SET, PV := INITIALVALUE, R := RESET, CV := BIN_VALUE, Q := Q0.7); //Kimeneti paraméter megadása későbbi feldolgozáshoz RESULT := WORD_TO_INT (BIN_VALUE); QW4 := BCD_VALUE; //BCD kimenet kiküldése a PLC kimenetére END_FUNCTION_BLOCK
Időzítők használata Az időzítők feladata adott időtartam mérése, ez a bemeneti indítójeltől és a kimeneti funkciótól függően lehet: •
Adott hosszúságú impulzus (S_PULSE)
•
Adott hosszúságú, újraindítható impulzus (S_PEXT)
•
Bekapcsolási késleltető (S_ODT)
•
Önálló bekapcsolási késleltető (S_ODTS)
•
Kikapcsolási késleltető (S_OFFDT)
Az időzítők paraméterei: Paraméter T_NO S TV R Q BI
Adat típus TIMER INT BOOL S5TIME BOOL BOOL WORD
Leírás Időzítő azonosító Indító jel bemenet Kezdeti érték (BCD formátum) bemenet Reset bemenet Időzítő státusz kimenet Fennmaradó idő (bináris formátum) kimenet
10
Adott hosszúságú impulzus (S_PULSE):
Az időzítő kimenete az indító jel után addig marad magas szinten, amíg lejár a beállított idő, vagy amíg az indítójel le nem megy alacsony szintre. •
Az időzítő indítása az S bemeneten, 0–1 átmenettel, azaz felfutó éllel történik. Ha teljes időzítési ciklust szeretnénk előidézni, akkor az S bemenetnek az időzítő lejártáig magas szinten kell lennie, különben az időzítő leáll.
•
Az időzítő resetelését az R bemeneten keresztül végezhetjük 0–1 átmenettel, azaz felfutó éllel. Ekkor az időzítő nullára állítódik.
•
A Q kimeneten magas szint (1) található, amíg az időzítő működésben van és alacsony szint (0), ha a leállt.
•
Az időzítő aktuális állása a BI kimeneten és az S_PULSE függvény értékével kérdezhető le.
Adott hosszúságú, újraindítható impulzus (S_PEXT):
Az időzítő kimenete az indítójel után addig marad magas szinten, amíg lejár a beállított idő. Ha lejárat előtt újabb indítójel jön, akkor az időzítő újra indul, az időzített ciklus hosszabb lesz, anélkül, hogy közben a kimenet alacsony szintre esne vissza. •
Az időzítő indítása az S bemeneten, 0–1 átmenettel, azaz felfutó éllel történik. Az újraindítás egy újbóli 0–1 átmenettel előidézhető, akkor az időzítő újra töltődik és az időzítési ciklus a beállított periódusidővel meghosszabbodik.
•
Az időzítő resetelését az R bemeneten keresztül végezhetjük 0–1 átmenettel, azaz felfutó éllel. Ekkor az időzítő nullára állítódik.
•
A Q kimeneten magas szint (1) található, amíg az időzítő működésben van és alacsony szint (0), ha a leállt.
•
Az időzítő aktuális állása a BI kimeneten és az S_PEXT függvény értékével kérdezhető le.
11
Bekapcsolási késleltető (S_ODT):
Az időzítő kimenete az indítójel után az időzítési ciklus leteltével változik magas szintre és addig marad magas szinten, amíg az indítójel is magas szinten van. •
Az időzítő indítása az S bemeneten, 0–1 átmenettel, azaz felfutó éllel történik. Ha az S bemenetre az időzítő működése közben 1–0 váltás, azaz lefutó él érkezik, akkor az időzítő leáll.
•
Az időzítő resetelését az R bemeneten keresztül végezhetjük 0–1 átmenettel, azaz felfutó éllel. Ekkor az időzítő nullára állítódik.
•
A Q kimeneten magas szint (1) található, ha az időzítő hiba nélkül lejárt és az S bemeneten még magas szint van. Alacsony szint (0) adódik, ha a leállt a timer.
•
Az időzítő aktuális állása a BI kimeneten és az S_ODT függvény értékével kérdezhető le.
Önálló bekapcsolási késleltető (S_ODTS):
Az időzítő kimenete az indítójel után az időzítési ciklus leteltével változik magas szintre és ebben az állapotban marad az indítójel alacsony szintre ugrásától függetlenül. •
Az időzítő indítása az S bemeneten, 0–1 átmenettel, azaz felfutó éllel történik. Ha az S bemenetre az időzítő működése közben 1–0 váltás, azaz lefutó él érkezik, akkor az időzítő fut tovább („önállóan”), az időzítő újraindítását egy újabb felfutó éllel lehet előidézni az S bemeneten.
•
Az időzítő resetelését az R bemeneten keresztül végezhetjük 0–1 átmenettel, azaz felfutó éllel. Ekkor az időzítő nullára állítódik.
•
A Q kimeneten magas szint (1) található, ha az időzítő beállított ideje letelt, az S bemenettől függetlenül.
•
Az időzítő aktuális állása a BI kimeneten és az S_ODTS függvény értékével kérdezhető le.
12
Kikapcsolási késleltető (S_OFFDT):
Az időzítő kimenete az indítójel felfutása után magas szintre vált. Az indítójel lefutása után indul késleltetés, aminek letelte után a kimenet alacsony szintre változik. •
Az időzítő indítása az S bemeneten, 1–0 átmenettel, azaz lefutó éllel történik. Ha az S bemenetre 0–1 váltás érkezik, azaz lefutó él érkezik, akkor az időzítő kimenete magas szintre vált, az időzítés azonban csak a fent leírt, S bemenetre érkező 1–0 átmenetnél kezdődik. Az időzítés letelte után a kimenet ismét alacsony szintre vált. Újraindítás az S bemenetre érkező 1–0 átmenettel érhető el.
•
Az időzítő resetelését az R bemeneten keresztül végezhetjük 0–1 átmenettel, azaz felfutó éllel. Ekkor az időzítő nullára állítódik.
•
A Q kimeneten magas szint (1) található, ha az időzítő fut, vagy az S bemeneten magas szintű jel van.
•
Az időzítő aktuális állása a BI kimeneten és az S_OFFDT függvény értékével kérdezhető le.
Példa időzítő használatára: FUNCTION_BLOCK TIMER VAR_INPUT mytime : TIMER; END_VAR VAR_OUTPUT result : S5TIME; END_VAR VAR set : BOOL; reset : BOOL; bcdvalue : S5TIME; binvalue : WORD; initialvalue : S5TIME; END_VAR
//Időzítő azonosítója //Időzítő tartalma S5TIME formátumban //S flag //R flag //Idő alap és fennmaradó idő BCD formátumban //Idő érték bináris formátumban //Kezdeti érték S5TIME formátumban
BEGIN //Felparaméterezés Q0.0 := 1; set := I0.0; reset := I0.1; initialvalue := T#25S; //Időzítő indítása bcdvalue := S_PEXT( T_NO := mytime, S := set, TV := initialvalue, R := reset, BI := binvalue, Q := Q0.7); //Kimeneti paraméter megadása későbbi feldolgozáshoz result := bcdvalue; QW4 := binvalue; // Bináris kimenet kiküldése END_FUNCTION_BLOCK
13
