10. fejezet – Változók, adattípusok és POU-k

Ez a fejezet nyelvfüggetlen. Mindegy, hogy strukturált szövegben vagy létradiagramban dolgozol: a változók, a hatókör és a POU-típusok ugyanazok.

A fejezet magja a 10.6–10.10. alfejezet: a három POU-típus pontos szétválasztása. Ez az a különbség, amit a kezdők a leggyakrabban elrontanak — és amely a 17. és 18. fejezet minden gyakorlatában visszaköszön.

10.1 Változó, deklaráció, hatókör

Minden változót deklarálni kell, mielőtt használnád: meg kell mondani a nevét és a típusát. A deklaráció egy kulcsszópárba kerül, és a kulcsszó dönti el a változó hatókörét: ki látja, ki írhatja, meddig él.

A leggyakrabban használt kulcsszavak:^{7 3 4}

És a ritkábban használtak, áttekintésül:⁷

10.2 Elemi adattípusok — röviden

Az elemi adattípusokat, a bitszélességüket és az értékkészletüket a 4. fejezet tárgyalta részletesen. Itt csak a legfontosabb emlékeztető:

Kezdőérték és konstans

Deklarációkor kezdőérték is adható:

VAR
    iDarab      : INT := 0;
    rHatarertek : REAL := 12.5;
    sNev        : STRING := 'szalag1';
END_VAR

VAR CONSTANT
    MAX_DARAB : INT := 500;
END_VAR

A CONSTANT módosítóval jelölt változó értéke futás közben nem módosítható. Használd minden olyan értékhez, amely a programban „varázsszámként” jelenne meg: a 500 önmagában semmit nem mond, a MAX_DARAB mindent.

10.3 Mi marad meg újraindításkor? — RETAIN és PERSISTENT

Ez a fejezet egyik legfontosabb — és a gyakorlatban legtöbb bosszúságot okozó — része.

Alapesetben minden változó újrainicializálódik, amikor a vezérlő újraindul. Ha egy értéknek túl kell élnie az újraindítást (például egy darabszámláló vagy egy üzemóra-számláló), akkor remanens változóra van szükség.

A deklaráció szintaxisa:⁸

VAR RETAIN
    iDarabszam : DINT;
END_VAR

VAR_GLOBAL RETAIN
    gDarabszam : DINT;
END_VAR

A PERSISTENT ugyanígy írható (VAR PERSISTENT, VAR_GLOBAL PERSISTENT), illetve külön, a perzisztenciaszerkesztővel kezelt listában.⁸

Mi mit él túl? A CODESYS súgójának élettartam-táblázata — és ugyanezt a táblázatot egy másik, szintén CODESYS-alapú környezet dokumentációja is szó szerint megadja:^{6 8}

10.4 Globális és lokális változók

10.5 A POU fogalma

Háromféle POU van: PROGRAM, FUNCTION és FUNCTION_BLOCK.² A következő négy alfejezet ezeket járja végig — és ha ezt megérted, a könyv többi része sokkal könnyebb lesz.

10.6 FUNCTION — állapotmentes, visszatérési értékkel

A gyártói megfogalmazás egyértelmű:³

„A függvényeknek nincs belső állapotinformációjuk, ami azt jelenti, hogy a függvények nem mentik el a változóik értékét a következő hívásig.”

Ebből minden más következik:³

• pontosan egy adatelemet ad vissza (ez lehet tömb vagy struktúra is), és a kimeneti változó maga a függvény neve;
• a deklaráció alakja: FUNCTION <név> : <adattípus>;
• nem használhat globális változókat és címeket — épp az állapotmentesség miatt.

FUNCTION Atlag : REAL
VAR_INPUT
    r1 : REAL;
    r2 : REAL;
    r3 : REAL;
END_VAR

Atlag := (r1 + r2 + r3) / 3.0;

Hívása:

rEredmeny := Atlag(20.0, 22.0, 24.0);

rEredmeny := Atlag(20.0, 22.0, 24.0);

fun(in1 := 1, in2 := 2, out1 => loc1, out2 => loc2);

10.7 FUNCTION_BLOCK — példányosítható, saját állapottal

A funkcióblokk a másik véglet:⁴

„Mindig példányon keresztül hívja a funkcióblokkot, amely a funkcióblokk másolata.”

„A kimeneti változók és a belső változók értéke a végrehajtás után a következő végrehajtásig változatlan marad.”

A példány deklarálása: <példánynév> : <funkcióblokk>;⁴

PROGRAM Prog
VAR
    inst1 : FB1;
END_VAR

inst1.iVar1 := 33;
inst1();
ires := inst1.out1;

Amit kívülről elérhetsz:⁴

„A funkcióblokk-példányon kívülről csak a be- és kimeneti változók érhetők el, a belső változók nem.”

Ez nem korlátozás, hanem védelem: a blokk belső működése a blokk dolga. Ez az, amit programozásban egységbezárásnak neveznek.

10.8 PROGRAM — állapotos, de példány nélküli

A harmadik típus a legkülönösebb. Van állapota — de nincs példánya.⁵

„Minden érték változatlan marad a program végrehajtása után a következő végrehajtásig.”

„A programoknak nincsenek példányai.”

És a kulcsmondat, amely az egészet megmagyarázza:⁵

„Ha egy POU meghív egy programot, és ennek hatására a program értékei megváltoznak, akkor ezek a változások megmaradnak a következő programhívásig. A program értékei akkor is megmaradnak, ha a következő hívást egy másik POU végzi. Ez különbözik a funkcióblokk hívásától: a funkcióblokk hívásakor csak az adott példány értékei változnak.”

A programok hívási sorrendjét a task-objektumok határozzák meg.⁵

10.9 A három típus egymás mellett

10.10 A legfontosabb kezdő buktató

Ez az a hiba, amit szinte mindenki elkövet egyszer.

Tegyük fel, hogy két késleltetésre van szükséged: a lámpa 2 másodperc múlva gyulladjon ki, a motor 10 másodperc múlva induljon el.

Helyesen:

VAR
    tonLampa : TON;
    tonMotor : TON;
END_VAR

tonLampa(IN := bIndit, PT := T#2S);
tonMotor(IN := bIndit, PT := T#10S);
bLampa := tonLampa.Q;
bMotor := tonMotor.Q;

Hibásan — egyetlen példányt használva két helyen:

VAR
    ton1 : TON;
END_VAR

ton1(IN := bIndit, PT := T#2S);
bLampa := ton1.Q;
ton1(IN := bIndit, PT := T#10S);   (* felülírja az előzőt! *)
bMotor := ton1.Q;

A második hívás ugyanazon a példányon dolgozik: felülírja a PT-t, és ugyanazt az eltelt időt használja. Az eredmény: egyik késleltetés sem működik helyesen.

És figyeld meg a különbséget a programmal szemben: egy PROGRAM esetében minden hívó ugyanazon az állapoton dolgozik.⁵ Ott nincs mód „két példányra” — ha két független működés kell, funkcióblokkot kell választanod.

10.11 Akciók, metódusok, öröklés — áttekintés

A POU-khoz további programozási objektumok is rendelhetők: „metódus, akció és egyebek”.²

Az EXTENDS és az IMPLEMENTS csak funkcióblokknál áll rendelkezésre — a függvénynél és a programnál nem.²

10.12 A task és a POU-k hívási lánca

Ki hívja meg az első POU-t? A task.

„A task az IEC-programod időbeli végrehajtási egysége. A task definiálja a POU-k hívási láncát (hívási hierarchiáját).”¹

Ez zárja be a kört a 8. fejezettel: ott állítottad be a task típusát és intervallumát, itt derül ki, mit is indít el vele. A lánc jellemzően így néz ki:

Task (pl. MainTask, ciklikus, t#20ms)
  └─ PLC_PRG                     (PROGRAM)
       ├─ Szallitoszalag()       (FUNCTION_BLOCK példány)
       ├─ Adagolo()              (FUNCTION_BLOCK példány)
       └─ rSkalazott := Skalaz(...)   (FUNCTION)

A következő fejezet — a lineáris és strukturált programfelépítés — pontosan erről a láncról szól: mikor éri meg felbontani a programot, és hogyan.

Összefoglalás

• A deklarációs kulcsszó dönti el a hatókört. VAR = lokális, kívülről nem írható; VAR_INPUT / VAR_OUTPUT = a POU be- és kimenetei; VAR_GLOBAL = az egész projektben ismert.
• A VAR_IN_OUT mutatóként adja át a változót: a POU a hívó saját változóját módosítja.
• A CONSTANT módosítóval jelölt érték futás közben nem módosítható — használd varázsszámok helyett.
• Remanencia: a RETAIN túléli a meleg indítást, a PERSISTENT a hideg indítást és az új letöltést is. Mindkettőt törli a gyári visszaállítás.
• A RETAIN kulcsszó nem garancia: megfelelő memóriatartomány (NVRAM, UPS) nélkül az értékek áramkimaradáskor elvesznek.
• POU = a program szervezési egysége. Három típusa van.
• FUNCTION: nincs állapota, egy visszatérési értéke van, globális változót nem használhat.
• FUNCTION_BLOCK: példányosítható, minden példánynak saját állapota van; kívülről csak a be- és kimeneti változói érhetők el.
• PROGRAM: van állapota, de nincs példánya — minden hívó ugyanazon dolgozik.
• A leggyakoribb kezdő hiba: egy példány két helyen. Ahány független működés kell, annyi példány.
• A task definiálja a POU-k hívási láncát.

Gyakorlatok

VAR
    tmr : TON;
END_VAR

tmr(IN := bJel1, PT := T#3S);
bKeslelt1 := tmr.Q;
tmr(IN := bJel2, PT := T#5S);
bKeslelt2 := tmr.Q;

Ellenőrző kérdések

1. Mi a különbség a VAR és a VAR_GLOBAL között?
2. Miben más a VAR_IN_OUT, mint a VAR_INPUT? Mi ennek a veszélye?
3. Mikor inicializálódik újra a VAR_TEMP, és mikor a VAR_STAT?
4. Mire való a CONSTANT módosító?
5. Melyik remanens változó éli túl a hideg indítást, és melyik nem?
6. Mit törölhet mindkét remanens változófajtából?
7. Miért nem elég önmagában a RETAIN kulcsszó az áramkimaradás túléléséhez?
8. Mi a POU, és mi a három típusa?
9. Miért nem használhat egy FUNCTION globális változót?
10. Mit jelent az, hogy a funkcióblokkot példányon keresztül hívjuk?
11. Mely változói érhetők el kívülről egy funkcióblokk-példánynak?
12. Miben más a PROGRAM a FUNCTION_BLOCK-tól az állapot szempontjából?
13. Hány TON-példány kell három független késleltetéshez? Miért?
14. Mi definiálja a POU-k hívási láncát?

Tudáspróba

Válaszd ki az egyetlen helyes választ!

1. A VAR … END_VAR blokkban deklarált változó: a) lokális, kívülről nem írható; b) az egész projektben látható; c) minden ciklusban újrainicializálódik; d) csak függvényekben használható.

2. A VAR_IN_OUT paraméter átadása: a) másolattal történik; b) mutatóval (call-by-reference) történik; c) csak konstansokra működik; d) nem megengedett funkcióblokkban.

3. A VAR_TEMP változó: a) az első híváskor inicializálódik; b) sosem inicializálódik; c) minden POU-híváskor újrainicializálódik; d) csak függvényben használható.

4. Melyik változófajta éli túl az új letöltést? a) VAR b) VAR RETAIN c) egyik sem d) VAR PERSISTENT

5. A meleg indítás (Reset Warm) után: a) a RETAIN és a PERSISTENT megmarad; b) minden változó törlődik; c) csak a PERSISTENT marad meg; d) semmi nem változik.

6. A FUNCTION: a) példányosítható; b) nincs belső állapota, és nem használhat globális változót; c) több visszatérési értéke lehet; d) csak ST nyelven írható.

7. A funkcióblokk-példányon kívülről elérhető: a) minden változója; b) csak a belső változói; c) csak a bemeneti és kimeneti változói; d) semmi.

8. A PROGRAM: a) példányosítható, mint a funkcióblokk; b) nem hívható taskból; c) nincs állapota; d) van állapota, de nincs példánya.

9. Három független késleltetéshez szükséges TON-példányok száma: a) 3 b) 2 c) 1 d) attól függ, milyen hosszúak

10. Az EXTENDS és az IMPLEMENTS kulcsszó: a) minden POU-típusnál használható; b) csak funkcióblokknál; c) csak függvénynél; d) csak programnál.

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

A fejezet forrásai