12. fejezet – Strukturált szöveg (ST)

Az eddigi fejezetekben már láttál ST-kódot: időzítőket hívtunk, számlálókat léptettünk. Most következik a nyelv rendszeres bemutatása.

Az ST (Structured Text, strukturált szöveg) a könyv fő nyelve. Három okból:

1. A legkifejezőbb. Amit létradiagramban tíz hálózat, azt ST-ben gyakran öt sor.
2. A hatályos szabványban is központi. Az IEC 61131-3 negyedik kiadásának nyelvcsomagjában ez az egyetlen szöveges nyelv (6. fejezet).
3. Átvihető tudás. Aki ismer bármilyen modern programozási nyelvet, itt otthon érzi magát — és fordítva: aki ST-t tanul, könnyebben lép tovább.

12.1 A szintaxis alapjai

Az ST utasításokból áll, és minden utasítást pontosvessző zár le.

iDarab := 0;
bMotor := TRUE;
rNyomas := rNyersertek * 0.01;

Az értékadás jele :=, nem =. Az = az összehasonlítás operátora:

iA := 5;              (* értékadás: iA legyen 5 *)
bEgyenlo := (iA = 5); (* összehasonlítás: igaz-e, hogy iA értéke 5 *)

Megjegyzések kétféleképpen írhatók:

(* Ez egy megjegyzés, akár
   több soron át is. *)

// Ez egy soros megjegyzés a sor végéig.

Az ST szabadon tördelhető: a sortörések és a behúzások nem befolyásolják a működést, csak az olvashatóságot. Ezt használd ki (12.8).

12.2 Operátorok és kiértékelési sorrend

Ha egy kifejezésben több operátor van, a kötési erősség dönti el, melyik hajtódik végre előbb.

A sorrend, a legerősebbtől a leggyengébbig:^{1 2}

És a szabály azonos erősség esetére:²

„Ha egy kifejezésben több operátor van, a magasabb precedenciájú operátorok értékelődnek ki előbb. Ha két operátornak azonos a precedenciája, a bal oldali értékelődik ki előbb.”

bRiaszt := rNyomas > 8.0 AND bUzem;

12.3 Elágazás: IF

Az IF szerkezet alakja:

IF rHomerseklet < 0.0 THEN
    iAllapot := 1;
ELSIF rHomerseklet = 0.0 THEN
    iAllapot := 2;
ELSE
    iAllapot := 3;
END_IF

Amit érdemes megjegyezni:

• az ELSIF egy szó (nem ELSE IF), és tetszőleges számú lehet belőle;
• az ELSE legfeljebb egy, és a végén áll;
• a szerkezetet END_IF zárja;
• az ágak fentről lefelé értékelődnek ki, és az első igaz ág fut le — a többi már nem.

IF rNyomas > 5.0 THEN
    iSzint := 1;
ELSIF rNyomas > 8.0 THEN
    iSzint := 2;      (* SOHA nem fut le *)
END_IF

12.4 Elágazás: CASE

Ha ugyanannak az egész változónak sok értékét vizsgálod, a CASE olvashatóbb.

A gyártói dokumentáció szerinti alak:³

CASE iAllapot OF
    1, 5:
        bLampa := TRUE;
    10..20:
        bLampa := TRUE;
    ELSE
        bLampa := NOT bLampa;
END_CASE

Amit a forrás kimond:³

• a feltétel egész típusú változó;
• több címke vesszővel sorolható fel (1, 5);
• tartomány két ponttal írható (10..20);
• az ELSE ág „opcionális, legfeljebb egyszer” fordulhat elő, és „alapértelmezett ugrási célpont, amelyre akkor ugrik, ha egyik korábbi címke sem egyezik a feltétellel”.

CASE iLepes OF
    0:  (* alaphelyzet *)
        IF bIndit THEN iLepes := 10; END_IF
    10: (* adagolás *)
        bAdagolo := TRUE;
        IF bTele THEN iLepes := 20; END_IF
    20: (* ürítés *)
        bAdagolo := FALSE;
        bUrito := TRUE;
        IF bUres THEN iLepes := 0; END_IF
END_CASE

12.5 Ciklusok — és miért veszélyesek PLC-ben

Az ST-ben három ciklusfajta van.

FOR — ismert számú ismétlés

FOR i := 1 TO 100 BY 2 DO
    IF arrErtek[i] = 70 THEN
        j := i;
        EXIT;
    END_IF
END_FOR;

A BY megadja a lépésközt (elhagyható, ekkor 1). Ez a legbiztonságosabb ciklusfajta, mert a ciklusszám előre látszik.

WHILE — elöltesztelő

WHILE j <= 100 AND arrErtek[j] <> 70 DO
    j := j + 2;
END_WHILE;

A feltételt a rendszer a ciklus elején vizsgálja: ha eleve hamis, a ciklus egyszer sem fut le.

REPEAT — hátultesztelő

REPEAT
    j := j + 2;
UNTIL j = 101 OR arrErtek[j] = 70
END_REPEAT;

Itt a vizsgálat a végén történik, tehát a ciklus legalább egyszer lefut.

EXIT és CONTINUE

• EXIT — kilép a ciklusból, és a ciklus utáni utasításon folytatja.
• CONTINUE — „a FOR, WHILE vagy REPEAT cikluson belül használatos, hogy a ciklus következő végrehajtásának elejére ugorjon”.⁵

A gyártó saját példája jól mutatja, mire jó a CONTINUE:⁵

FOR Counter := 1 TO 5 BY 1 DO
    INT1 := INT1 / 2;
    IF INT1 = 0 THEN
        CONTINUE;   (* to avoid a division by zero *)
    END_IF
    Var1 := Var1 / INT1;   (* executed, if INT1 is not 0 *)
END_FOR;
Erg := Var1;

A veszély

De a veszély ennél tágabb, és a PLC sajátossága.

Gondold végig a 2. fejezet ciklusmodelljét: bemenetek beolvasása → program futása → kimenetek kiírása. Ha a programodban egy ciklus sokáig fut, akkor:

1. a kimenetek addig nem frissülnek — a berendezés „nem reagál”;
2. a ciklusidő megnő, ami elrontja az időzítéseket;
3. ha a ciklusidő átlépi a (Time × Sensitivity) határt, a watchdog kiold, és a task kivétellel megáll (8. fejezet).

WHILE NOT bKesz DO
    ;   (* várunk, hogy megérkezzen a jel *)
END_WHILE;

CASE iLepes OF
    10: (* a következő cikluson újra megnézzük *)
        IF bKesz THEN iLepes := 20; END_IF
    20: (* mehet tovább *)
END_CASE

Mire használd mégis a ciklust? Tömbökön való végigmenéshez, ha a tömb mérete kicsi és ismert: 8 csatorna ellenőrzése, 16 riasztásbit összegzése, 100 elemű átlagolás. Ezek véges, rövid ciklusok — nem várakozás.

12.6 Funkcióblokk hívása ST-ben

A 10. fejezetből tudod: a funkcióblokkot példányon keresztül hívjuk. ST-ben ez így néz ki:

VAR
    tonKesleltet : TON;
    ctuDarab     : CTU;
END_VAR

tonKesleltet(IN := bIndit, PT := T#5S);
bKesz := tonKesleltet.Q;

ctuDarab(CU := bEl, RESET := bTorol, PV := 100);
bTele := ctuDarab.Q;

A minta három részből áll:

1. példány deklarálása a VAR blokkban;
2. hívás a bemeneti paraméterekkel;
3. kimenet olvasása pontozott jelöléssel (példány.kimenet).

A hívás és a kimenetolvasás külön sorban is történhet, és sokszor így olvashatóbb — de figyelj a sorrendre: a kimenetet a hívás után olvasd, különben az előző ciklus értékét kapod.

tonKesleltet(IN := bIndit, PT := T#5S, Q => bKesz);

12.7 Kidolgozott mintafeladat

Feladat. Egy szállítószalag indítógombra indul, leállítógombra megáll. A szalagon áthaladó darabokat egy érzékelő számolja. Ha a darabszám eléri az 500-at, a szalag megáll, és jelzőlámpa gyullad ki. A lámpát és a számlálót nyugtázó gombbal lehet törölni. A szalag csak akkor indulhat, ha nincs vészjelzés.

PROGRAM PLC_PRG
VAR
    (* bemenetek *)
    bIndit      : BOOL;
    bLeallit    : BOOL;
    bErzekelo   : BOOL;
    bNyugtaz    : BOOL;
    bVesz       : BOOL;
    (* kimenetek *)
    bSzalag     : BOOL;
    bLampa      : BOOL;
    (* belső *)
    rtErzekelo  : R_TRIG;
    rsSzalag    : RS;
    ctuDarab    : CTU;
END_VAR

(* 1. Darabszámlálás – csak a felfutó élre *)
rtErzekelo(CLK := bErzekelo);
ctuDarab(CU := rtErzekelo.Q, RESET := bNyugtaz, PV := 500);

(* 2. A szalag indítás–leállítás logikája, reset-dominánsan *)
rsSzalag(
    SET    := bIndit,
    RESET1 := bLeallit OR bVesz OR ctuDarab.Q
);
bSzalag := rsSzalag.Q1;

(* 3. Jelzőlámpa a teljesítésről *)
bLampa := ctuDarab.Q;

Nézzük végig, mi miért így van:

12.8 Olvasható kód

Egy PLC-program élettartama 10–20 év. Nagy eséllyel nem te fogod javítani.

Elnevezés. Használj beszélő neveket, és jelöld a típust előtaggal — ez nem szabvány, hanem elterjedt szokás, de nagyon segít:

Tagolás. Csoportosítsd a kódot, és tedd ki, mi micsoda:

(* ---------- 1. Jelek előkészítése ---------- *)

(* ---------- 2. Vezérlési logika ---------- *)

(* ---------- 3. Kimenetek kiadása ---------- *)

Megjegyzés. Ne azt írd le, mit csinál a kód — az látszik. Azt írd le, miért:

(* rossz *)
iDarab := iDarab + 1;   (* megnöveljük a darabszámot *)

(* jó *)
iDarab := iDarab + 1;   (* a vevő minden 500. darab után kér mintavételt *)

Konstansok. Varázsszám helyett nevesített konstans (10. fejezet):

VAR CONSTANT
    MAX_DARAB : INT := 500;
END_VAR

12.9 Tipikus kezdő hibák

IF bFeltetel1 THEN
    bMotor := TRUE;
END_IF

IF bFeltetel2 THEN
    bMotor := FALSE;
END_IF

Összefoglalás

• Az ST utasításokból áll, minden utasítást pontosvessző zár. Az értékadás :=, az összehasonlítás =.
• Az operátorok kötési erőssége a zárójeltől az OR-ig csökken; azonos erősségnél balról jobbra történik a kiértékelés. Összetett feltételt zárójelezz.
• Az IF … ELSIF … ELSE … END_IF ágai fentről lefelé értékelődnek ki, és az első igaz ág fut le.
• A CASE egy egész változó értéke szerint ágazik el; a címkék vesszővel sorolhatók, tartomány ..-tal írható, és van opcionális ELSE ág.
• Három ciklus van: FOR (ismert számú), WHILE (elöltesztelő), REPEAT (hátultesztelő). Az EXIT kilép, a CONTINUE a következő menetre ugrik.
• PLC-ben nem várakozunk ciklussal. A hosszú ciklus megnöveli a ciklusidőt, és watchdog-kioldáshoz vezet. Várakozáshoz állapotgép vagy időzítő kell.
• A funkcióblokkot példányon keresztül hívjuk; a kimenet a példány.kimenet alakkal vagy a híváson belül => jellel olvasható.
• Az olvasható kód nem stílusgyakorlat: 10–20 évig kell működnie, és nem te fogod javítani.
• Egy kimenetnek egy helye legyen, ahol az értéke eldől.

Gyakorlatok

IF rNyomas > 2.0 THEN
    iSzint := 1;
ELSIF rNyomas > 5.0 THEN
    iSzint := 2;
ELSIF rNyomas > 8.0 THEN
    iSzint := 3;
END_IF

Ellenőrző kérdések

1. Mi a különbség a := és az = jel között?
2. Kétféle megjegyzésforma van az ST-ben — melyek ezek?
3. Sorold fel az operátorok kötési erősségét a legerősebbtől a leggyengébbig!
4. Mi történik azonos erősségű operátoroknál?
5. Mire való a MOD operátor? Mondj két gyakorlati példát!
6. Hány ELSIF és hány ELSE ág lehet egy IF szerkezetben?
7. Miért nem fut le soha a rNyomas > 8.0 ág, ha előtte rNyomas > 5.0 áll?
8. Milyen típusú lehet a CASE feltétele? Hogyan írsz benne értéklistát és tartományt?
9. Mi a különbség a WHILE és a REPEAT között?
10. Mit csinál az EXIT, és mit a CONTINUE?
11. Miért nem szabad WHILE ciklussal várni egy bemeneti jelre?
12. Mi történik, ha egy ciklus túl sokáig fut?
13. Hogyan hívsz funkcióblokkot ST-ben, és hogyan olvasod a kimenetét?
14. Miért hibás ugyanazt a kimenetet két helyen írni?

Tudáspróba

Válaszd ki az egyetlen helyes választ!

1. Az értékadás jele ST-ben: a) := b) = c) == d) =>

2. Melyik operátor köt a legerősebben? a) AND b) zárójel c) * d) +

3. A logikai OR operátor: a) a legerősebben köt; b) ugyanolyan erősen köt, mint az AND; c) a leggyengébben köt; d) erősebben köt, mint az összehasonlítás.

4. Az IF szerkezetben: a) tetszőleges számú ELSE ág lehet; b) az ELSIF két külön szó; c) minden igaz ág lefut; d) az első igaz feltételű ág fut le.

5. A CASE feltétele: a) egész típusú; b) BOOL típusú; c) REAL típusú; d) STRING típusú.

6. A CASE szerkezetben a 10..20 jelentése: a) 10 és 20 értékek; b) a 10-től 20-ig terjedő tartomány; c) 10 vagy 20; d) érvénytelen szintaxis.

7. Melyik ciklus fut le biztosan legalább egyszer? a) FOR b) WHILE c) REPEAT d) mindegyik

8. A CONTINUE utasítás: a) kilép a ciklusból; b) megszakítja a programot; c) újraindítja a taskot; d) a ciklus következő végrehajtásának elejére ugrik.

9. Ha egy WHILE ciklus feltétele soha nem lesz hamis: a) végtelen ismétlés és futásidejű hiba keletkezik; b) a fordító hibát jelez; c) a ciklus automatikusan kilép 1000 menet után; d) a task prioritása csökken.

10. Ha ugyanazt a BOOL kimenetet két helyen írod egy cikluson belül: a) a két érték logikai VAGY kapcsolatba kerül; b) az utolsó értékadás érvényesül; c) az első értékadás érvényesül; d) fordítási hiba keletkezik.

A megoldókulcs a B függelékben található.

A fejezet forrásai