S7-SCL programozási nyelv

Átírás

1 S7-SCL programozási nyelv Az SCL (Structured Control Language = Struktúrált Vezérlő Nyelv) a DIN EN 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

2 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 Név Ábrázolás [bit] Értelmezési tartomány Bit BOOL 1 bit 0,1, vagy FALSE,TRUE Byte BYTE 8 bit Word WORD 16 bit Double word DWORD 32 bit Karakter CHAR 8 bit Kiterjesztett ASCII kar. Integer INT 16 bit Double integer DINT 32 bit Lebegőpontos REAL 32 bit E E 38 +/ E E+38 S5 időegység S5TIME / S5T 16 bit T#0H_0M_0S_10MS.. T#2H_46M_30S_0MS Idő periódus (1 ms-os lépésközzel) TIME / T 32 bit T#24D_20H_31M_23S_647MS... +T#24D_20H_31M_23S_647MS Dátum (1 napos DATE / D 16 bit D# D# lépésközzel) Napi idő (1 ms-os TIME_OF_DA 32 bit TOD#0:0:0.0 TOD#23:59: lépésközzel) Y / TOD Dátum és idő DATE_AND_ TIME / DT Sztring STRING max. 254 karakter Tömb ARRAY Struktúra STRUCT 64 bit DT# :0: DT# :59: 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

3 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; 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; Ö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; END_STRUCT ; //Vált. dekl.,értékadással 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; //Bemeneti paraméter VAR_OUTPUT b:int; //Kimeneti paraméter VAR_IN_OUT c:int; //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# DWORD#16#f000_0000; dword#32768; DW#2#1111_0000_1111_0000; DWord#8# 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# REAL#1; real#1.5; real#2e4; real#3.1 CHAR#A; CHAR#49 3

4 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; 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 VAR_OUTPUT // Kimeneti változók VAR_TEMP // Dinamikus változók VAR // Statikus változók 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 VAR_OUTPUT // Kimeneti változók VAR_TEMP // Dinamikus változók 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.. 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

5 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;... 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 Azonosító 1. változó 2. változó Eredmény Precedencia Hatványozás ** ANY_NUM ANY_NUM REAL 2 Unary plus + ANY_NUM ANY_NUM 3 TIME TIME 3 Unary minus ANY_NUM ANY_NUM 3 TIME TIME 3 Szorzás * ANY_NUM ANY_NUM ANY_NUM 4 TIME ANY_INT TIME 4 Osztás / ANY_NUM ANY_NUM ANY_NUM 4 TIME ANY_INT TIME 4 Egész osztás DIV ANY_INT ANY_INT ANY_INT 4 TIME ANY_INT TIME 4 Modulo osztás MOD ANY_INT ANY_INT ANY_INT 4 Összeadás + ANY_NUM ANY_NUM ANY_NUM 5 TIME TIME TIME 5 TOD TIME TOD 5 DT TIME DT 5 Kivonás ANY_NUM ANY_NUM ANY_NUM 5 TIME TIME TIME 5 TOD TIME TOD 5 DATE DATE TIME 5 TOD TOD TIME 5 DT TIME DT 5 DT DT TIME 5 5

6 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 Azonosító 1. változó 2. változó Eredmény Precedencia Negálás NOT ANY_BIT ANY_BIT 3 Logikai ÉS AND ANY_BIT ANY_BIT ANY_BIT 8 Kizáró VAGY XOR ANY_BIT ANY_BIT ANY_BIT 9 Logikai VAGY OR ANY_BIT ANY_BIT ANY_BIT 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

7 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 //Ha a FLAG változó étréke TRUE, akkor... N := 0 ; SUM := 0 ; OK := FALSE ; ELSIF START = TRUE THEN //Különben, ha START változó értéke //TRUE, akkor... N := N + 1 ; SUM := SUM + N ; ELSE //Ha egyik sem teljesül, akkor... OK := FALSE ; END_IF ; //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

8 // 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

9 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 Adat típus Leírás C_NO COUNTER INT Számláló azonosító CD BOOL CD bemenet:lefelé számlálás CU BOOL CU bemenet:felfelé számlálás S BOOL Számláló töltése PV-vel PV WORD Kezdő érték, S-sel betölthető R BOOL Reset bemenet Q BOOL Kimenet:Számláló státusza CV WORD 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

10 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; VAR_OUTPUT RESULT : INT; VAR SET : BOOL; RESET : BOOL; BCD_VALUE : WORD; BIN_VALUE : WORD; INITIALVALUE : WORD; //Számláló azonosítója //Számláló tartalma INTEGER //formátumban //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 //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 Adat típus Leírás T_NO TIMER INT Időzítő azonosító S BOOL Indító jel bemenet TV S5TIME Kezdeti érték (BCD formátum) bemenet R BOOL Reset bemenet Q BOOL Időzítő státusz kimenet BI WORD Fennmaradó idő (bináris formátum) kimenet 10

11 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

12 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

13 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; VAR_OUTPUT result : S5TIME; VAR set : BOOL; reset : BOOL; bcdvalue : S5TIME; binvalue : WORD; initialvalue : S5TIME; //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 //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