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 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 –32768 ... +32767
Double integer DINT 32 bit –2147483648 ... +2147483647
Lebegőpontos REAL 32 bit –3.402822E+38 ... –1.175495E–38
+/– 0
+1.175495E–38 ... +3.402822E+38
S5 időegység S5TIME / S5T 16 bit T#0H_0M_0S_10MS ..
T#2H_46M_30S_0MS
Idő periódus (1 TIME / T 32 bit –T#24D_20H_31M_23S_647MS ...
ms-os lépésközzel) +T#24D_20H_31M_23S_647MS
Dátum (1 napos DATE / D 16 bit D#1990-01-01 ... D#2168-12-31
lépésközzel)
Napi idő (1 ms-os TIME_OF_DA 32 bit TOD#0:0:0.0 … TOD#23:59:59.999
lépésközzel) Y / TOD
Dátum és idő DATE_AND_ 64 bit DT#1990-01-01-0:0:0.0 ...
TIME / DT DT#2089-12-31-23:59:59.999
Sztring STRING max. 254 karakter
Tömb ARRAY
Struktúra STRUCT
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 //Bemeneti paraméter
a:INT;
END_VAR

VAR_OUTPUT //Kimeneti paraméter

b:INT;
END_VAR

VAR_IN_OUT //Be-/kimeneti paraméter

c:INT;
END_VAR

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 Konstans szintaktika

BOOL BOOL#1; bool#0; Bool#false; BOOL#TRUE
BYTE BYTE#0; B#2#101; Byte#'ä'; b#16#f
WORD WORD#32768; word#16#f; W#2#1001_0100; WORD#8#177777
DWORD DWORD#16#f000_0000; dword#32768;
DW#2#1111_0000_1111_0000; DWord#8#37777777777
INT INT#16#3f_ff; int#-32768; Int#2#1111_0000; inT#8#77777
DINT DINT#16#3fff_ffff; dint#-1000_0000; DInt#2#1111_0000;
dinT#8#17777777777
REAL REAL#1; real#1.5; real#2e4; real#3.1
CHAR 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; // Értékadás a függvénynek, ha nem VOID
END_FUNCTION

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 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
 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
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
 // 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 // Ciklus kezdete
INDEX := INDEX + 2; // Utasításblokk
UNTIL INDEX > 50 // Feltétel:amíg az INDEX nagyobb nem lesz
// 50-nél
END_REPEAT; // 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 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
 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; //Számláló azonosítója
END_VAR
VAR_OUTPUT
RESULT : INT; //Számláló tartalma INTEGER
//formátumban
END_VAR
VAR
SET : BOOL; //S flag
RESET : BOOL; //R flag
BCD_VALUE : WORD; //Számláló értéke BCD formában
BIN_VALUE : WORD; //Számláló értéke BCD formában
INITIALVALUE : WORD; //Betölthető kezdőérték
END_VAR

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 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
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; //Időzítő azonosítója
END_VAR
VAR_OUTPUT
result : S5TIME; //Időzítő tartalma S5TIME formátumban
END_VAR
VAR
set : BOOL; //S flag
reset : BOOL; //R flag
bcdvalue : S5TIME; //Idő alap és fennmaradó idő BCD formátumban
binvalue : WORD; //Idő érték bináris formátumban
initialvalue : S5TIME; //Kezdeti érték S5TIME formátumban
END_VAR

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