A BECKHOFF típusú PLC használata.

Átírás

1 A BECKHOFF típusú PLC használata. Miskolci Egyetem 2007.

2 2 1. A PLC rendszer általános áttekintése. A BECKHOFF cég által kifejlesztett TwinCAT fantázianevű PLC család egy WINDOWS operációs rendszerre alapozott termék. A PLC folyamatcsatoló elemei (digitális be és kimenetek, valamint egyéb moduljai) nagysebességű soros buszon keresztül kapcsolódnak egy WINDOWS operációs rendszert tartalmazó központi egységhez. Az egyik alternatíva, hogy ez a központi egység egy ipari kivitelű PC, amely WINDOWS NT, 2000, vagy XP operációs rendszert tartalmaz. A TwinCAT fejlesztő rendszer ekkor a WINDOWS operációs rendszerbe beiktatja azt a négy taszkot (párhuzamosan futó programegységet), ami a folyamatirányítási (PLC), folyamat (megjelenítési) vizualizálási, és kommunikációs feladatok ellátásához szükségesek. Ezek a taszkok még akkor is képesek feladatuk ellátására, ha a WINDOWS rendszer a kezelők számára összeomlott. A másik alternatíva, hogy nem egy PC-ben képezzük le a PLC funkciókat, hanem egy rack fiókba épített mikroprocesszoros (PLC kártya) biztosítja ezt. Ezen kártya kialakítású PLC processzora az ipari célra kifejlesztett WINDOWS CE, vagy a WINDOWS XP beágyazott operációs rendszer alatt működik. Ebben az esetben a TwinCAT programmal kifejlesztett PLC alkalmazásokat le kell tölteni a PLC-be, és ez a berendezés csak a program futtatására alkalmas. Az elmondottakat illusztrálja az alábbi ábra. A jobb alsó ábrarészlet az mutatja, hogy az I/O modulok csatakoznak a TwinCAT programrendszert tartalmazó PC-hez, ami a PLC funkciók ellátását is szolgálja, a programfejlesztésen túl. A bal alsó ábra részlet azt mutatja, hogy az I/O egységek mellett megtalálható maga a PLC funkciót ellátó modul is. Ekkor a TwinCAT program (valamint a hozzá tartozó PC) a programfejlesztést, és beüzemelést (ill. a folyamatvizualizálást) szolgálja. A TwinCAT rendszer a technológia adatait a hálózaton keresztül szokványos WINDOWS eljárásokkal elérhetjük és így akár további felügyeleti feladatokat ellátó programokat, alkalmazásokat használhatunk. Az I/O modulok valamilyen terepi buszon keresztül csatlakoznak a PLC rendszerhez. Az alábbi ábra azt szemlélteti, hogy milyen buszokon keresztül csatlakoztathatjuk a moduljainkat.

3 3 Az I/O modulok választéka mind a kétállapotú, mind az analóg jelek fogadására, és kiadására szolgáló kártyákat egyaránt tartalmazza. A PLC paraméterei közül érdemes kiemelni, hogy maga a PLC vagy egy WINDOWS operációs rendszert tartalmazó (ipari) PC, vagy egy WINDOWS CE operációs rendszert tartalmazó egység, vagy a Beckhoff Fieldbus Controllers (BCxxxx, BXxxxx, IL230x-Cxxx) modul. A memória maximum 2 GByte, míg a program ciklusideje 50 μs értéktől nagyobb (tipikusan 1 ms). Egy 2.8 GHz órajel frekvenciájú PENTIUM4 processzort tartalmazó egység 1 μs idő alatt mintegy 1000 PLC utasítást hajt végre. Ez a hardver teljesítmény napjainkban a PLC-k világában a nagy teljesítményű berendezések közé tartozik. Nem is annyira a PLC, hanem az NC, és CNC feladatok ellátása, a mozgatási pozicionálási, interpolációs feladatok ellátása igényli ezt a nagy teljesítményt. A nagy teljesítmény a megbízhatóságban, és az élettartamban is megjelenik (fordított arányban). Napjainkban a klasszikus PLC-k élenjáró típusainál a két meghibásodás között eltelt átlagos idő (MTBF) néhány évtized (pl. a MODICON QUANTUM esetén 44 év). Nyilván ilyen adatokat, egy mozgó alkatrészeket (pl. hűtőventillátorok, diszk stb.) is tartalmazó berendezés nem tud produkálni, de ez nem feltétlenül a legfontosabb paraméter bizonyos alkalmazásoknál. A PLC programok fejlesztése a TwinCAT PLC Control programmal történik. A fejlesztő program az IEC szabvány szerinti programnyelvek használatát engedélyezi. Az alkalmazható programnyelvek: IL Utasítás lista (Instruction List) LD Létra diagramm (Ladder Diagramm) FBD/CFC Funkció blokk (Function Block Diagramm) SFC Sorrendi funkció blokk (Sequential Function Chart) ST Strukturált szöveg (Structured Text) Ez a fejlesztő eszköz a megírt program beüzemelésére szolgáló funkciókkal is rendelkezik. A PLC konfigurációjának, és a végrehajtásának legfontosabb paramétereit a TwinCat Sytem Manager nevű programkomponenssel 2. Az IEC szabvány. A PLC-k programozása.

4 4 A TwinCAT az IEC szabványra alapozva került kifejlesztésre. Ez a szabvány a korszerű PLC-k alkalmazásával kapcsolatos szabályokat tartalmazza. A fejezet megkísérli összefoglalni a 240 oldalas szabvány legfontosabb megállapításait. Az IEC szabvány szerint egy alkalmazás strukturálisan az alábbi programegységeket (POU = PROGRAM ORGANIZATION UNIT) tartalmazhatja. Funkció (FUN) Funkció blokk (FB) Program (PROG) A hierarchia legmagasabb helyén a program helyezkedik el, amely a végrehajtás során meghívhatja a funkciókat, és funkcióblokkokat is. A funkció és a funkció blokk közötti alapvető különbség, hogy a funkció minden esetben az aktuális bemenetek értékétől függő kimeneti értéket produkál, és a funkcióhoz rendelt statikus paraméterei nincsenek. Egy funkció (FUN) például, visszaadhatja két egész számot tartalmazó bemenete közül a kisebbik értéket. A funkció blokk (FB) tartalmazhat a funkcióhoz rendelt statikus (a funkcióblokkhoz tartozó saját) paramétereket. A funkciók, és funkció blokkok a gyakran ismétlődő feladatok megoldására szolgáló program részleteket tartalmazzák. A fenti programegységek hívási lehetőségeinek hierarchiáját az alábbi ábra mutatja. A szabvány rögzíti, hogy mely alapfunkciókat kell gyárilag biztosítani bármely PLC fejlesztőrendszerében (lásd később). Egy programrész (POU) logikailag két részre bontható. A programrészhez tartozó adatok, változók, és a program kód. 2.1 A program változók, és deklarálásuk. A programegység (POU) által használt változókat a programegység kezdetén deklarálni kell. Ennek formájára az alábbi részlet mutat példát.

5 5 A fenti példa a változók deklarálásának egy tipikus példája. A VAR_INPUT csoport a programrész (POU) belépő adatait tartalmazza. Ez jelen esetben egyetlen BOOL típusú logikai változó. A programegység (POU) kilépő változói a VAR_OUTPUT csoport belül kerül definiálásra. Ez jelen esetben egyetlen lebegőpontos (REAL) változó. A programegység lokális adatai egy egész (int), egy szöveg (string) konstans, és egy kétállapotú fizikai bemenet, amelyek teleppel védett memóriahelyen kerülnek letárolásra. Mint látható a változó nevet követően egy : karakter található, majd a változó típusa, és egy ; terminálja a deklarációt. Ha szisztematikusan nézzük a lehetséges változók deklarációjának lehetőségeit, akkor az alábbi csoportosítást adhatjuk. Elnevezés VAR VAR_INPUT VAR_OUTPUT VAR_IN_OUT VAR_EXTERNAL VAR_GLOBAL VAR_ACCESS VAR_TEMP VAR_CONFIG RETAIN NON_RETAIN CONSTANT AT Leírás Programegységen (POU) belüli változó Belépési érték, ami a POU-n belül nem módosítható A POU által szolgáltatott kilépési érték Belépési érték, ami módosításra kerül a POU-ben Egy másik programegységben definiált globális változó, ami módosítható a POU-ben. Globális változó Kommunikációs csatornán keresztül elérhető adat definiálása Átmenetileg tárolt változók FB éss FUN programegységek számára. Konfigurációs adatok Teleppel védett adatok megjelöléséhez Teleppel nem védett adatok megjelöléséhez Konstans, állandó érték Hely (be, kimenet) hozzárendelés A fenti deklarációs lehetőségek egy részére az alábbi részlet mutat példát.

6 6 A különböző típusú adatcsoportok programegységeken belüli deklarálási lehetőségeit az alábbi táblázat foglalja össze. Mint látható a funkciók (FUN) nem adhat vissza adatokat, így OUTPUT típusú változókat ezen programegységekben nem lehet definiálni. Globális (más programegységekből is elérhető) adatokat (GLOBAL, ACCESS) csak a PROGRAM blokkban lehet definiálni. Egy-egy deklarációs csoporton belül többféle változó típus definiálására van lehetőség. A változók lehetséges típusát az alábbi táblázat mutatja, ahol N a változó hosszát (bitben) mutatja. Tipus BOOL SINT INT DINT LINT USINT UINT UDINT ULINT REAL LREAL TIME DATE TIME_OF_DAY (TOD) DATE_AND_TIME (DT) STRING BYTE WORD DWORD LWORD WSTRING Leírás Igaz/hamis Rövid egész Egész Dupla egész Hosszú egész Rövid előjel nélküli egész Előjel nélküli egész Előjel nélküli dupla egész Előjel nélküli hosszú egész Valós változó Hosszú valós egész Eltelt idő (pl. T#14ms) Dátum (pl ) A napon belüli idő (pl TOD#15:26:48.23) Dátum és idő (pl. DT# :36:24.34) Szöveg változó Byte (8 bit) Szó (16 bit) Dupla szó (32 bit) Hosszú szó (64 bit) Változó hosszú szó N *karakterek száma *szavak száma A TYPE END_TYPE kulcsszavak között további (felhasználó, vagy gyártó által) származtatott adattípusokat definiálhatunk. Például a TYPE ANALOG_ADAT : INT ; END_TYPE deklaráció az ANALOG_ADAT nevű változóhoz INT típust rendel. Deklarálhatunk egyedi, és csoportváltozókat. Az egyedi változók deklarálásakor egy változóhoz az előbbi táblázat valamelyik típusát rendelhetjük (pl. Var: SINT;). A változó neve és típusa közé : karakter illesztendő, és a változó típusát követően a ; karakter zárja a deklarációt. Külön beszélnünk kell arról, ha valamely be, vagy kimenthez (memóriacímhez) rendelünk egy változót. Ennek az a formája, hogy egy % karaktert követő előtagokkal nevezzük meg a változó helyét. Ezen előtagok lehetséges karakterei az alábbiak.

7 7 I Q M X B W D L bemenet kimenet memória bites változó byte (8 bit) változó szó (16 bit) változó dupla szó (32 bit) változó hosszú szó (64 bit) változó A fenti jelölésekkel pl. a %IX7.1 változó egy kétállapotú fizikai bemenetet jelöl (7. cím 1. csatorna). A %QW26 például egy D/A konverter (kimeneti 16 bitjét) azonosíthatja. Több (csoport) változó definiálására két alternatíva áll rendelkezésünkre: Tömb-deklarálás. Az ugyanazon típusú változókból képezett tömb definiálására van lehetőségünk. Az alábbi példa azt mutatja, hogy egy 16 elemet tartalmazó INT tömböt hogyan definiálhatunk, ami feltételezésünk szerint 16 analóg csatorna adatit fogja tartalmazni. TYPE ANALOG_ADAT : INT ; END_TYPE ANALOG_ADATOK : ARRAY[1..16] OF ANALOG_ADAT; A leírás alapján az látszik, hogy egy 16 elemű tömb definiálására az ARRAY [1..16] OF kulcsszavak utalnak. A tömb egy (a példában 6.) elemére az ANALOG_ADATOK[6] formában hivatkozhatunk. Struktúra-deklarálás. A különböző típusú, de logikailag összetartozó adatokat célszerű egy adat struktúrába szervezni. Egy analóg csatornára jellemző adatok lehetnek például az alábbiak: TYPE ANALOG_CSATORNA: STRUCT NEV: STRING[32]; DIM: STRING[16]; ADMIN: INT; ADMAX: INT; MIN: REAL; MAX:REAL; END_STRUCT END_TYPE (* csatorna név *) (* dimenzió *) (* minimumhoz tartozó A/D adat *) (* maximumhoz tartozó A/D adat *) (* méréshatár minimum *) (* méréshatár maximum *) A struktúra egy elemére, például az ANALOG_CSATORNA : ACSAT ; deklarációt követően az ACSAT.MIN változónévvel hivatkozhatunk.

8 8 2.2 A programozás. A program egységek (POU) kód részét a IEC szabvány alapján az alábbi programnyelvek valamelyikén hozhatjuk létre. Létradiagram (LD) Funkció blokk diagram (FBD) Utasítás lista (IL) Strukturált szöveg (ST) A különböző programozási lehetőségek illusztrálására szolgál az alábbi ábra. Az egyszerűbb, klasszikus vezérlési feladatok megoldásánál talán a leghatékonyabb a létradiagram, vagy a funkcióblokk diagram nyelv alkalmazása. A két nyelv közötti választást a programozó személyének sajátosságai motiválhatják. A klasszikustó eltérő vezérlési feladatok megoldása során hatékonyabb (szemléletesebb) lehet a szöveges programnyelvek (IL, ST) alkalmazása. A szabvány lehetővé teszi egy kiegészítő, sorrendi leírónyelv diagram (SFC) nyelv használatát, ami a PLC program programkomponenseinek végrehajtási struktúráját írja le Az SFC leírónyelv. Az SFC nyelvben egy-egy program egységet egy lépésnek tekinthetünk. A nyelv célja, hogy a programegységek végrehajtásának struktúráját (sorrendiségét) a céljaink szerint definiálni

9 9 tudjuk. A gyakorlatban csaknem kizárólagosan grafikus szimbólumokkal írjuk le a végrehajtási sorrendet. A lépések végrehajtása során az alábbi jelöléseket alkalmazhatjuk. A Step nevű lépés egy kezdeti (inicializáló) lépést, míg az S2 nevű lépés egy normál programegységet jelöl. A szimbólumon belül a lépés neve szerepel. Két lépés egymást követő sorrendi végrehajtását az alábbi ábrarészlet mutatja. Az S1 végrehajtását követően akkor hajtódik végre az S2 lépés, ha az f jelű (BOOL) feltétel igaz (TRUE). A következő ábra két programlépés alternatív végrehajtását jelöli. Az S1 végrehajtását követően az S2 hajtódik végre, ha az f feltétel igaz. Ha ez a feltétel nem teljesül, akkor az S3 fog végrehajtódni, ha a g feltételváltozó igaz. Az egyidejű (konkurens) végrehajtásra mutat példát a következő ábra.

10 10 Itt az S1 végrehajtását követően S2 és S3 egyidejűleg (konkurens módon) hajtódik végre. A fenti ábrarészlet arra mutat példát, hogy az S2 és S3 mindkét lépés befejezését követően hajtódik végre az S1 nevű lépés. Az SFC struktúra leírás alkalmas program lépések átugrásának előírására is. Abban az esetben, ha az a jelű feltétel igaz, akkor S1 után S2 lépés fog végrehajtódni, majd a b feltétel teljesülése után hajtódik végre az S3. Ha az a feltétel nem teljesül, míg a c feltétel igaz, akkor S1 után az S3 hajtódik végre, azaz az S2 átlépésre kerül.

11 11 Programegységek ciklikus végrehajtását is előírhatjuk SFC nyelven. Az S2 lépés mindaddig ismétlődik, amíg a b feltétel hamis, és a c feltétel igaz. Ha a b feltétel igazzá válik, akkor az S3 lépés fog végrehajtódni Az utasításlistás programnyelv (IL). Az IL programnyelv opcionálisan négy elemet tartalmazhat: Címkét, amit pontosvessző zár le Utasítást Operanduszt Megjegyzés mezőt A program szerkezetére jellemző pl. az alábbi programrészlet START: LD AND ST %IX1.2 %M3.2 %QX5.4 (* nyomógomb állapotának betöltése *) (* engedélyezési feltétellel ÉS kapcsolat *) (* működtető jel kiadása *) A műveletek végrehajtását úgy kell elképzelni, hogy egy akkumlátor regiszter, és az utasításban szereplő operandusz között értelmeződik a kapcsolat, és az eredmény az akkumlátor regiszterben képződik. A kifejezések zárójelezhetők, azaz például az AND( LD %IX3.2 OR %IX3.3 ) utasítássor az akkumlátor értékét ÉS kapcsolatba hozza a két változó VAGY kapcsolatának eredményével. A PLC fejlesztőtől a szabvány az alábbi (IL) utasításokat követeli meg.

12 12 Utasítás kód LD Módosító Leírás ST N S R AND N, ( OR N, ( XOR N, ( NOT ADD SUB MUL DIV MOD ( ( ( ( ( GT ( GE ( EQ ( NE ( LT ( LE ( JMP C, N CAL C, N RET C,N ) N Az operandus értékét (LD), vagy annak negáltját (LDN) tölti az akkumlátorba Az akkumlátor (ST), vagy annak negáltját (STN) viszi az operandus által megadott helyre. Beírja a címzett RS tárolót, ha az akkumlátor tartalma TRUE Törli a címzett RS tárolót, ha az akkumlátor tartalma TRUE Logikai ÉS kapcsolatba hozza az akkumlátort az operandus értékével (AND), vagy annak negáltjával (ANDN). Logikai VAGY kapcsolatba hozza az akkumlátort az operandus értékével (OR), vagy annak negáltjával (ORN). Logikai KIZÁRÓ VAGY kapcsolatba hozza az akkumlátort az operandus értékével (XOR), vagy annak negáltjával (XORN). Az akkumlátor tartalmának negálása Az operanduss értékének (aritmetikai) hozzáadása az akkumlátorhoz Az operandus értékének (aritmetikai) kivonása az akkumlátorból Az akkumlátor megszorzása (aritmetikai) az operandussal Az akkumlátor osztása (aritmetikai) az operandussal Az akkumlátor osztása (aritmetikai) az operandussal, és az osztás maradékának a képzése Logikai 1 értéket szolgáltat, ha az operandus (aritmetikai) értéke nagyobb mint az (aritmetikai) akkumlátor értéke. Logikai 1 értéket szolgáltat, ha az operandus (aritmetikai) értéke nagyobb, vagy egyenlő mint az (aritmetikai) akkumlátor értéke. Logikai 1 értéket szolgáltat, ha az operandus (aritmetikai) értéke egyenlő az (aritmetikai) akkumlátor értékével. Logikai 1 értéket szolgáltat, ha az operandus (aritmetikai) értéke nem egyenlő az (aritmetikai) akkumlátor értékével. Logikai 1 értéket szolgáltat, ha az operandus (aritmetikai) értéke kisebb mint az (aritmetikai) akkumlátor értéke. Logikai 1 értéket szolgáltat, ha az operandus (aritmetikai) értéke kisebb, vagy egyenlő mint az (aritmetikai) akkumlátor értéke. Ugrás az operandusként szereplő címkére (JMP), vagy ugrás a címkére, ha az akkumlátor tartalma 1 (JMPC), vagy ugrás a címkére, ha az akkumlátor tartalma 0 (JMPN). Az operandusként szereplő funkcióblokk hívása (CAL), vagy a funkcióblokk hívása, ha az akkumlátor tartalma 1 (CALC), vagy a funkcióblokk hívása, ha az akkumlátor tartalma 0 (CALN). Visszalépés a hívott funkcióból, funkcióblokkból, vagy programból (RET). A RETC akkor eredményez visszalépést, ha az akkumlátor 1 értékű, míg a RETN akkor, ha az akkumlátor 0. Záró zárójel A funkció és a funkcióblokkok hívására az IL nyelven a következő részlet mutat példát:

13 13 A példa azt mutatja, hogy a funkció (FUN) esetében nem szerepelhet formális paraméterlista, míg a funkcióblokk (FB) hívása esetében formális paraméterlistával kell meghívnunk a blokkot. Nem szükségszerű, hogy valamennyi paraméter értékét a definiálás szerinti sorrendben megadjuk. Mind az átadott paraméterek száma és sorrendjében szabadságunk van az alábbiak szerint. Egy funkció blokk nemcsak egy formális paraméterlista megadásával hívható, hanem a funkcióblokk paramétereit egy struktúrán keresztül is cserélhetjük. Az ábrán egy fel-le számláló grafikus (FBD) szimbólumát láthatjuk. A Counter_UD funkcióblokknak 5 bemenet van, é s három kimenete. Ezen funkcióblokk bementi és kimeneti paramétereit az alábbi eljárással adhatjuk meg, ill. menthetjük ki. Végezetül nézzünk egy példát IL programnyelven írt funkcióra. A válto

14 Strukturált szöveg (ST) programnyelv. Az ST nyelv, gyakorlatilag Pascal, vagy C nyelvhez hasonló magas szintű programnyelvnek tekinthető. Lényeges egyszerűbben, és áttekinthetőbb formában lehet egy feladatot megoldani az ST nyelv alkalmazásával, mint az IL utasításlistás programmal. A kifejezések formája az ST nyelven például az A+B-C*ABS(D) formában írhatók. A műveletek végrehajtásának a sorrendjét a műveletek precedenciája, és az azonos precedenciaszintű műbeleteknél a balról jobbra haladó kiértékelés szabja meg, mint az más programnyelveknél is szokásos. Ha az A, B, C, D változók 1, 2, 3, 4 értékűek, akkor az eredmény -9 lesz ebben a példában. A nyelv alkalmazása során az alábbi műveleti utasításokat használhatjuk (a felsorolás csökkenő precedencia sorrendben készült). Precedencia Megnevezés 1 Funkció hívása (végrehajtása) 2 Negáció Komplemens képzése 3 Hatványozás 4 Szorzás Osztás Osztási maradék 5 Összeadás Kivonás 6 Összehasonlítás 7 Egyenlőség Egyenlőtlenség 8 Logikai ÉS Logikai ÉS 9 Logikai kizáró vagy 10 Logikai VAGY Jelölés Funkciónév (paraméter lista) NOT ** * / MOD + <, >, <=, >= = <> & AND XOR OR A műveleteken felül egyéb utasításokat is alkalmazhatunk a programjainkban.

15 15 Értékadó utasítás. Például az A := C; CV := CV+1; C := SIN(X); utasítások mindegyike a kifejezések bal oldalán szereplő változónak ad új értéket. Funkcióblokk hívása, és a visszatérési érték felhasználása. Erre példát az alábbi sorok mutatnak. CMD_TMR(IN := %IX5.0, PT := T#300ms); A := CMD_TMR.Q; RETURN. A RETURN; utasítás a programegységből való kilépést fogja eredményezni. Feltételes programvégrehajtást eredményező IF utasítás. Példa az IF utasítás használatára. IF devtimer.q THEN devtimer ( IN := FALSE, PT := devspeed ); engine := NOT engine; IF engine = FALSE THEN steps := steps + 1; END_IF ELSE devtimer ( IN := TRUE, PT := devspeed ); END_IF A példából azt láthatjuk, hogy ha az IF utasításban szereplő feltétel TRUE (igaz), akkor a THEN kulcsszót követő utasítások hajtódnak végre, ha pedig a feltétel nem teljesül (FALSE), akkor az ELSE kulcsszót követő utasítások fognak végrehajtódni. Az ELSE kulcsszó használata opcionális, nem kötelező, mint az a példából is látszik. Az IF utasításhoz kapcsolódó utasításokat az END_IF kulcsszó határolja (terminálja). A CASE utasítás. ERTEK := BCD_TO_INT(PEREMKEREKES_KAPCSOLO_ERTEK); CASE ERTEK OF 1,5: DISPLAY := VILAGIT; 2: DISPLAY := INVERZ; 3,4: DISPLAY := VILLOG; ELSE : DISPLAY := SOTET; END_CASE A fenti programrészlet azt mutatja, hogy az ERTEK jelű változó értékétől függően a DISPLAY jelű változó más, és más értéket (VILAGIT, SOPTET stb.) kap. A FOR ciklusszervező utasítása.

16 16 A programrészlet azt mutatja, hogy az I értéke 1,3,5 stb. (kettővel növekvő) értékeket vesz fel egymás után, és azt ellenőrizzük, hogy a WORDS jelű szövegtömb ugyanezen elemei tartalmazzák-e a KEY szövegrészletet. Ha igen akkor az EXIT (a ciklus belsejéből való kiugrás) utasítás fog végrehajtódni. Az ismétlődő utasítás sorozat végét az END_FOR kifejezés jelzi. Azaz a fenti FOR ciklus után J értéke azon számértékkel azonos, amelyik tömbelemen a KEY szócska szerepel (1,3,5, ), vagy ha nem szerepel a KEY szó, akkor J=101 értékű lesz. Amennyiben a BY 2 kulcsszó nem szerepelne, akkor alapfeltételezés szerint (default) I értéke egyesével változik. A ciklusok szervezése a WHILE utasítással is lehetséges. Az előző pontban leírt feladat a formában is megoldható, és J értéke azonos lesz a FOR ciklusnál szereplő J értékével. Látható, hogy a WHILE ciklus végét az END_WHILE kulcsszó mutatja. A ciklus szervezés következő lehetősége a REPEAT utasítás felhasználása. A korábban már ismertetett feladatot a formában is megoldhatjuk. A REPEAT kulcsszót követő utasítássorozat mindaddig ismétlődik, míg az UNTIL kifejezésben szereplő feltétel nem teljesül. Jelen esetben vagy J=101 értékűvé nem válik, vagy a WORDS tömb soron következő eleme KEY tartalmú szócska. A FOR, WHILE, REPEAT ciklusok törzséből való kiugrást az EXIT utasítás használata teszi lehetővé. A ; jel az üres (termináló) utasítást jelenti. A következő részlet egy ST nyelven megírt funkcióblokkot mutat illusztrációként.

17 17 Az ábra felső részén a változók definiálása látszik. A funkcióblokkhoz egyetlen lokális (i) változó tartozik, míg a többi változó értelemszerűen globális definiálású (és ez itt nem látszik). A blokk egy logikai TRUE értéket ad vissza, ha az alkalmazás legfeljebb MAX_NBR_WINDOWS számú (az aktív, vagy üzenetet küldő) ablakai közül van olyan, aminek a státusza eltér az UI_MESSAGE_ERASE, vagy UI_MESSAGE_ONLY, UI_MESSAGE_STRING állapot értéktől. Ha egyetlen ilyen ablak sincs, akkor a funkcióblokk FALSE értékkel tér vissza. Az ST programnyelv alkalmazása akkor javasolt, ha egy viszonylag bonyolult vezérlési, irányítási feladatot kell megoldani, és ez grafikus (LD, FBD) programnyelven gyakorlatilag reménytelen, az IL listás nyelv pedig túlságosan áttekinthetetlen programot eredményezne. Az általunt áttanulmányozott berendezés működtető program részei kizárólag ST nyelven írt utasítás sorokat tartalmaztak, és esély sem volt arra, hogy ezeket más programnyelven hatékonyan meg lehetett volna oldani. Az ST nyelven írt programok azt a veszélyt hordozzák, hogy programozói hiba miatt egy-egy programegység (POU) hibásan fog működni, például végtelen ciklus alakul ki, egy feltétel hibás megfogalmazása miatt. Ezért ezeket a programrészeket különös gondossággal kell ellenőrizni, tesztelni Létradiagramos (LD) programnyelv. Az LD programnyelv leginkább a vezérlések áramút tervéhez hasonlítható, és a relés logikai tervezésekor követett gondolkodásmódot örökíti át a PLC programozás világába. Egy energia vezetéktől, ha az energia az alkalmazott kontaktusokon, funkcióblokkokon keresztül eljut egy tekercshez, akkor a tekercs (a kimenet) gerjesztett logikai 1 állapotba kerül. Ha az energiafolyam valamely elem (kontaktus, funkcióblokk) állapota miatt megszakad, akkor a kimenet nem gerjesztődik, logikai 0 állapotba kerül.

18 18 Az LD programok Vízszintes, és függőleges energiavezetékeket Kontaktusokat Tekercseket Funkciókat, és funkcióblokkokat tartalmaznak. A szabvány szerint az alábbi alapelemek alkalmazhatók záró kontaktus. Ha a kontaktushoz rendelt logikai változó 1 értékű, akkor átengedi az energiát, ellenkező esetben szakítja. -- / -- bontó kontaktus. Ha a kontaktushoz rendelt logikai változó 0 értékű, akkor átengedi az energiát, ellenkező esetben szakítja. -- P -- Pozitív él. Ha a kontaktushoz rendelt logikai változó 0 értékről 1 értékre nő, akkor átengedi az energiát ezen mintavételezés idejére, ellenkező esetben szakítja azt. -- N --Negatív él. Ha a kontaktushoz rendelt logikai változó 1 értékről 0 értékre csökken, akkor átengedi az energiát ezen mintavételezés idejére, ellenkező esetben szakítja azt. --( )-- Tekercs. Amennyiben a tekercs energiát kap, akkor a tekercshez rendelt logikai változó 1 értéket kap, ellenkező esetben a változó 0 értékű lesz. A tekercs bal oldalának (1 vagy 0) állapota átmásolódik a tekercs jobb oldalán lévő csatlakozó pontra is. --( / )-- Negált működtetésű tekercs. Amennyiben a tekercs energiát kap, akkor a tekercshez rendelt logikai változó 0 értéket kap, ellenkező esetben a változó 1 értékű lesz. A tekercs bal oldalának (1 vagy 0) állapota átmásolódik a tekercs jobb oldalán lévő csatlakozó pontra is. --(S)-- RS tároló beírás. Ha energia kapcsolódik a tekercsre, akkor a címzett RS tároló beírásra kerül. A tekercs bal oldalának (1 vagy 0) állapota átmásolódik a tekercs jobb oldalán lévő csatlakozó pontra is. --(R)-- RS tároló törlés. Ha energia kapcsolódik a tekercsre, akkor a címzett RS tároló törlésre kerül. A tekercs bal oldalának (1 vagy 0) állapota átmásolódik a tekercs jobb oldalán lévő csatlakozó pontra is. --(P)-- Ha a tekercsre kapcsolt jel 0-ról 1-re változik, akkor a címzett logikai jel egy végrehajtási ciklusra 1 értékbe íródik. A tekercs bal oldalának (1 vagy 0) állapota átmásolódik a tekercs jobb oldalán lévő csatlakozó pontra is. --(N)-- Ha a tekercsre kapcsolt jel 1-ről 0-ra változik, akkor a címzett logikai jel egy végrehajtási ciklusra 1 értékbe íródik. A tekercs bal oldalának (1 vagy 0) állapota átmásolódik a tekercs jobb oldalán lévő csatlakozó pontra is. --- Vízszintes, és függőleges vezetékszakasz.

19 19 A funkcióblokkokat téglalapok jelölik, amelyekbe a funkcióra jellemző szövegek, a bementek, és kimenetek vannak feltüntetve. A funkcióblokkos programozásra az alábbi ábra mutat példát. A képernyőn egy funkcióblokk LD programja látható, ami négy NETWORK-ból áll. Az első network a funkció hívásakor a devicedown logikai változót 1-be, míg a deviveup változót 0ba írja, amelyek egy-egy RS tároló kimenetei. A második network MOVE funkcióblokkja a 2000 ms értéket írja egy időzítő időzítési értékeként. A harmadik network az időzítő bementi változóját teszi logikai 1 értékbe. Végezetül a negyedik network egy bekapcsolási időzítőt mutat. Az EN jelű bemenetek a funkcióblokk működésének engedélyező bemenetét jelöli. A leírás azt akarja bemutatni, hogy a networkok egymás után növekvő sorszámok szerint hajtódnak végre (értékelődnek ki) Funkcióblokkos (FBD) programnyelv. A funkcióblokkos FBD programozás a logikai kapukkal, és funkcióblokkokkal való feladatleírást jelenti. Inkább az egyén szubjektív látásmódjától függ, hogy az LD, vagy az FBD programnyelv használatát preferálja.

20 20 Az FBD nyelv a VAGY (OR), az ÉS (AND), és a NEM (NOT) kapcsolat leírását szolgáló blokkokat tartalmazza. Ezen túl a könyvtárak funkcióblokkjait használhatjuk a program fejlesztésénél. Az alábbi ábra egy példát mutat az FBD nyelv használatára: A példa azt mutatja, hogy az ido jelű bekapcsolás késleltetőt a be1, és be2 jelek ÉS kapcsolatával indítjuk. A ki3 kimenet pedig a be1, és ki3 negált változók NOR kapcsolataként állítódik elő A szabványos funkcióblokkok. A szabvány rögzíti, hogy milyen funkcióblokkokat kell tartalmaznia egy PLC fejlesztőrendszerének. A funkciók csoportosítása az alábbi. Flipflopok Él detektálás Számlálók Időzítők A táblázat a csoporton belüli elemek elnevezését, bemeneteit és kimeneteit tartalmazza.

21 21 A jelölések magyarázata az alábbi A szabványos funkcióhívások. A szabvány az alábbi funkciócsoportokat, és funkciókat definiálja. A táblázatokban feltüntetésre kerül a funkció neve, be és kimenő paramétereinek típusa, a funkció rövid leírása, valamint a funkció felülbírálhatósága, és kiterjeszthetősége (lásd alább). Az adat típusok megnevezésekor az ANY valamennyi adattípust (pl. BOOL, INT, SINT stb.), az ANY_INT pedig valamennyi INT típust (INT, DINT, SINT) jelenti. Értelemszerűen ugyanez a logika igaz az ANY_REAL stb. változó típusokra is. Adat típus konvertáló függvények

22 22 Numerikus függvények Aritmetikai függvények Bit sorozatokkal való műveletek

23 23 Kiválasztás, és összehasonlítás Stringek kezelése Idő és dátum kezelése

24 24 Felsorolás típusok kezelése A funkciókban szereplő jelölések összefoglalása az alábbi. A funkcióknál szereplő overloaded (felülbírálható) igen jelölés azt mutatja, hogy a funkció különböző típusú adatokra egyaránt alkalmazható, mint azt az alábbi ábra mutatja. Az összeadás (ADD) normál (INT), dupla pontos (DINT), és rövid (SINT) egész számokra egyaránt alkalmazható. A funkcióknál szereplő extensible (kiterjeszthető) igen jelölés azt mutatja, hogy a bemenetek száma tetszőlegesen bővíthető, mint a következő ábra mutatja.

25 25 3. A TwinCAT PLC Control programkomponens Ez a program szolgál a PLC program fejlesztésére, és a kifejlesztett program működésének ellenőrzésére (nyomkövetésére). A programfejlesztés lépéseit kövessük végig egy egyszerű példa kapcsán. A PLC egyetlen kimenete 2 s ciklusidővel villogtasson egy lámpát akkor, ha a start jelű bemenetén egy kapcsolót bekapcsolunk (a bemenet logikai 1 állapotban van). Szándékosan ilyen egyserű feladatot akarunk megoldani, hogy ne a programozás részleteinek a nehézségeivel, hanem a rendszer alkalmazásának a lépéseivel ismerkedjünk. Ugyanazt az egyszerű feladatot többfajta programnyelv alkalmazásával, néha több funkcióblokkra lebontva oldjuk meg, hogy a lehetőségek világossá váljanak. A program indítását követően a File menüpontra kattintást követően a következő bejelentkezési felület jelenik meg a PC képernyőjén.

26 26 Válasszuk ki, hogy egy új PLC projektet (alkalmazást) kívánunk fejleszteni. Az alkalmazás fejlesztésével kapcsolatos első párbeszédablak arra vonatkozik, hogy a fejlesztendő program milyen típusú PLC-n fog futni. Itt kell megneveznünk, hogy vagy egy PC-n, vagy egy rack (modul) kialakítású központi egységen fog a futni a PLC programunk. A következő párbeszédablakban azt kell megadnunk, hogy a fejlesztendő program egységnek milyen a jellege, és milyen programnyelven kívánjuk fejleszteni a programunkat.

27 27 A programfejlesztés az IEC szabvány valamennyi programnyelvén lehetséges. Egy-egy alkalmazásnak egy MAIN nevű programot kell tartalmaznia. Ez a program szegmens, ami néhány ms ciklusidővel újra és újra végrehajtódik, és ez tekinthető az alkalmazás főprogramjának. Ez a főprogram funkció újabb programot, funkció blokkokat (FB), vagy funkciókat (FUN) tartalmazó programegységeket hívhat meg. A programok ciklusidejét a TwinCAT System Manager programkomponensében írhatjuk elő. Ennek a ciklusidőnek a szükséges nagysága a működtetett technológia jellegétől függ. A PLC reakcióideje az említett ciklusidő kétszerese. Azaz egy lassúbb berendezés esetén akár a 10 ms ciklusidő (20 ms reakcióidő), de egy gyors technológiánál ez a ciklusidő gyakorlatilag elfogadhatatlan. A funkció nem tartalmaz statikus paramétereket, hanem az aktuálisan átadott paraméterek alapján kiszámítja a funkcióhoz rendelt algoritmus szerinti értéket, és ezt visszaadja a hívó programnak. A funkciókkal, és funkcióblokkokkal bővíthetjük a PLC gyári funkcióit a leggyakrabban előforduló feladatok ellátására szolgáló saját programrészekkel. A régebbi PLC-k általában csak egyetlen programszegmenset (a MAIN) kezelték, azaz valamennyi utasítás ebben az egy programszegmensben helyezkedett el. Egyszerűbb esetben ez a technika valóban megfelel, de egy bonyolultabb vezérlés esetén célszerűbb a feladat megoldását szolgáló programot több részre bontani (szegmentálni). Erre a célra szolgálnak a felhasználó által írt funkcióblokkok, ill. funkciók esetleg programok. A szegmentáláshoz akár újabb programokat is hívhatunk a főprogramból. Ez alapvetően annyiban különbözik a funkcióblokkoktól, hogy a fizikai be kimenetek kezelése a programon belül megtörténik, míg a funkcióblokkok hívásakor ez nem következik be. Most ugyanazt a feladatot (a lámpa villogtatását) különböző programnyelveken oldjuk meg. 3.1 A feladat megoldása LD programnyelven. Az LD (vagy az FBD) programnyelv talán a leginkább megszokott a PLC-k programozásánál, ha klasszikus vezérlési feladatokat kell megoldani. A mérnöki szemlélethez közelebb áll, mint a szöveges (ST, IL) programnyelvek, és a program nyomkövetése, a programhibák okának felderítése is egyszerűbb, mint szöveges programnyelvekben.

28 28 Egyetlen MAIN szegmens alkossa a programunkat az egyszerűség kedvéért, tehát az előző ábra párbeszédablakában az OK gombra kattintva megjelenik előttünk a MAIN program adatrészének definiálására, valamint ettől elválasztva a LAD szimbólumok rajzolására szolgáló hely. A rajzfelületre húzzuk rá (vagy válasszuk ki) a megfelelő kapcsolási szimbólumokat, és így rajzoljuk meg az elképzelt LD programot. Ügyeljünk arra, hogy egy NETWORK, csak egy tekercset tartalmazhat (speciális esetben, ha párhuzamosan több kimenetet működtetünk, akkor több tekercset is rajzolhatunk.) Ha egy rajzszimbólumot (pl. kontaktust), akkor a fejlesztő rendszer azt várja, hogy adjuk meg a szimbólumhoz tartozó változó nevét. Amennyiben egy olyan szimbólumnevet adunk meg ami (pl. start) még nem szerepel a változók listájában, akkor automatikusan megjelenik egy párbeszédablak a változó definiálására. A példában a start nevű bites változót egy adott címre (%IX1.0) képezzük le, ahova a PLCből a változó értékét ki tudjuk majd olvasni. Azokat a változókat, amelyek a PLC be vagy kimenetein is megjelennek, legyenek azok kétállapotú (pl. BOOL ami egy fizikai bemenethez kapcsolódik), vagy akár szavas (pl. INT, egy A/D konverter számértéke) azokat erre a címterületre kell definiálni. Azokat a változókat, amelyek nem kapcsolódnak a PLC be vagy

29 29 kimeneti moduljaihoz (nem a PLC modulokkal való táviratozási kapcsolatban kapnak értéket), azoknál értelemszerűen a cím (Addres) mezőt üresen kell hagyni. A definíció során megadhatjuk, hogy a változó melyik csoportba tartozik. A Class ablakban jelölhető meg, hogy a POU (program egység) bemeneti, kimeneti, vagy belső lokális változójáról van-e szó. A változó típusaként az alábbi csoportokból választhatunk. Az ábrán megjelenített típusok az IEC szabvány adat típusai. Az adat típusok kiválasztása során további csoportok típusdefiníciói közül is választhatunk. Amennyibe a TYPE definíciós paranccsal más elnevezésű típusokat hozunk létre (mint felhasználók), akkor ebből a csoportból is rendelhetünk változó típust az objektumunkhoz. A szabvány standard funkcióblokkjaihoz rendelt adatstruktúrák csoportjából rendelhetjük a változóhoz a számunkra megfelelőt (pl. TON). Az általunk írt funkcióblokkjaihoz rendelt adatstruktúrák csoportjából rendelhetjük a változóhoz a számunkra megfelelőt. A RETAIN és PERSISTENT kijelölésekkel előírhatjuk, hogy a változó értéke megőrződjön. A RETAIN kijelölés a program leállításakor érvényes értéket foga újrainduláskor betölteni a változókba, míg a PERSISTENT jelölés minden futási ciklusban a változó értékének mentését fogja eredményezni. A CONSTANT jelölés egy olyan objektumot eredményez, aminek az értéke a futás során nem módosítható.

30 30 A változókhoz egy megjegyzés (comment) szöveget rendelhetünk, ami nagymértékben segítheti a változó szerepének a megértését. Amikor egy változót definiálunk (kitöltjük a párbeszédablak általunk megkívánt paramétereit, és az OK funkcióval lezárjuk a párbeszédablakot), akkor ez a változó meg fog jelenni a A változókat olyan formában is definiálhatjuk, hogy az egeret elmozgatjuk a változók definícióit tartalmazó ablakra, majd megnyomjuk az egér jobb oldali tűzgombját, aminek hatására az alábbi menü jelenik meg. Erről a menü listáról az Auto Declare menü pontot választva a korábbi deklarációs párbeszédablak jelenik meg. Lépésenként tehát felépíthetjük az alábbi programvázlatot.

31 31 A grafikus szimbólumok (kontaktusok, időzítők) kirajzolása után a fejlesztő rendszer kérdőjelekkel jelzi, hogy a jelölt helyeken adjuk meg a változók, vagy egyéb konstansok nevét (konstans esetén értékét). Tehát az első NETWORK első záró kontaktusának elhelyezését követően a start változónevet kell begépelnünk, és ha az még nem szerepel, akkor azt a korábban leírt formában deklarálni kell. Az elemek és funkcióblokkok kiválasztásához (elhelyezéséhez) célszerű ugyancsak az egér jobb oldali tűzgombját megnyomni (vagy az Insert menü pontot aktivizálni), aminek hatására a következő menüből választhatjuk ki a kívánt szerkesztési funkciót.

32 32 Mint látható a példánál valamennyi változó a MAIN szegmens lokális változójaként van definiálva, mert nincs más program egység (POU), aminek ugyancsak látnia kellene egyes változókat. A több POU számára közös változókat globális minősítésűnek kell definiálni. Magának a programnak a működése a következő. Alapállapotban mind a vilagosletelt, mind a sotetletelt változók értéke 0. Amikor a start bemenetre 1 értéket adunk elindul a felső bekapcsolás késleltető, és 2 s múlva a vilagosletelt értéke 1 lesz. Ez elindítja az alsó bekapcsolás késleltetőt. Újabb 2 s múlva ezen időzítő sotetletelt kimenete 1 értékre vált, és ezen érték azonnal törli a felső időzítőt (az IN bemeneten megszűnik az energia), és így a vilagosletelt tekercs is 0 értékű lesz. Ez a 0 érték a második időzítő (és a sotetletelt tekercs) törlését fogja kiváltani, és ezzel előröl kezdődik a ciklus A villogolampa fizikai kimenet akkor fogja a lámpát működtetni, ha a start fizikai bemenet 1 állapotban van (be van kapcsolva a rá csatlakozó kapcsoló), és a vilagosletelt időzítő kimenete ugyancsak A feladat megoldása ST programnyelven. Az előző fejezetben LAD nyelven megoldottuk a lámpa villogtatását. Most ugyanezt a feladatot ST programnyelven oldjuk meg. Hajszálpontosan ugyanazokat a függvényeket, kapcsolatokat írjuk le ST programnyelven, mint azt korábban a létradiagramos nyelven tettük.

33 33 A programhoz tartozó változók egy kivételével azonosak az LD programnál felsoroltakkal. A be jelű BOOL segédváltozó csak itt az ST nyelvű programnál szerepel, és mint a program utasításaiból látható a start és a sotetletelt negáltjának ÉS kapcsolatát tartalmazza. Ez a változó adja a tvilagos (TON típusú struktúra) IN bemenetének értékét. A második sor a standard bekapcsolás késleltető funkcióblokk hívását tartalmazza. A TON funkcióblokknak átadandó paraméterek nevét és szerepét, az IEC szabvány ismertetése tartalmazza. Az időzítő aktuális Q kimenete a tvilagos adatstruktúra tvilagos.q elemén keresztül érhető el. A negyedik sor a tsotet jelű bekapcsolási időzítő hívását mutatja. Belátható, hogy a példában szereplő sotetletelt, vilagosletelt BOOL segédváltozók alkalmazása itt szükségtelen, hiszen az időzítők Q struktúra elemén keresztül közvetlenül szerepeltethetnénk más kifejezésekben ugyanezen változók értékét. Itt az LD programmal való kompatibilitás miatt szerepeltejük ezeket a változókat. Maga a program úgy működik, hogy a hat utasítássor egymás után végrehajtódik, majd ezt követően ismét az első sorral kezdődően fog végrehajtódni a program (mintegy végtelenszer ciklikusan ismételve ezt a hat utasítássort). A program változók deklarálásánál a korábban már leírt utat követhetjük. Ha a változó nevét begépeljük a programunkba, és a változó még nincs definiálva, akkor megjelenik a definiálásra szolgáló párbeszédablak. A másik lehetőség, hogy az adat deklarációs ablakrészre mozgunk az egérrel, és a jobb oldali egérgomb megnyomásakor megjelenő menüből az Auto Declare menüpontot választjuk a párbeszédablak megjelenítéséhez, mint azt az LD programnyelven való programíráskor is elmondtuk. A program utasításainak az írásakor, ha megnyomjuk ugyancsak az egér jobb gombját, és a megjelenő menüből az Input Assistant menü pontot választjuk akkor megjelenik az alábbi párbeszédablak.

34 34 Látható, hogy a párbeszédablak bal oldalán kijelölhetünk egy csoportot, és a jobb oldalon megjelenő választék egy elemét emelhetjük át a programunkba. Gyakorlatilag mind a változók bármelyike, valamint bármelyik utasítás, vagy funkció elérhető ezen a párbeszédablakon keresztül. Nem kötelező a támogatás igénybevétele, de kétségtelenül eseteként előnyös a használata egy-egy programsornál (pl. elfelejtettük egy globális változó pontos nevét). 3.3 Az SFC alkalmazása a feladat megoldásánál. Az SFC nyelv a program végrehajtásánál jelenthet nagy segítséget. Azon túl, hogy a szekvenciális (sorrendi) vezérlések lépéseinek leírására, átláthatóságának javítására egy hatékony módszer, a hardver teljesítmény jobb felhasználását (kisebb ciklusidőket) is biztosíthatja. Ennek igazolására vigyük végig az alábbi gondolat kísérletet. Egy berendezés egy kapcsoló állapotától függően vagy kézi, vagy automatikus üzemben működtethető. Amennyiben a program végrehajtását (!) nem szegmentálnánk az SFC nyelv alkalmazásával, akkor minden végrehajtási ciklusban mind az automatikus, mind a kézi működtetés programlépéseit ki kell értékelni. Ha figyelembe vesszük, hogy csak vagy az egyik, vagy a másik üzemmód lehetséges, úgy az SFC nyelven az alábbi alternatív programvégrehajtást írhatjuk elő.

35 35 Ilyenkor az alternatív ágak egyike kerül csak értelmezésre a kézi/automatikus kapcsoló állapotától függően, tehát a program ciklusideje a kevesebb kiértékelt utasítás miatt lényegesen (esetleg a felére) csökkenthető. Ha program végrehajtását (nem csak a program szerkezetét!) tovább bontjuk még további hatékonyságjavulást érhetünk el. A korábban ismertetett, és az LD ill. ST nyelven megírt feladatnál az SFC nyelv alkalmazásához valamiféle programszegmentálást kellene definiálni. Bontsuk a feladatot két programlépésre. 1. A tvilagos jelű időzítés leteltére való várakozás 2. A tsotet jelű időzítés leteltére való várakozás. A gondolatmenet alapján a két programlépéshez rendeljünk egy-egy programszegmenset (egy-egy funkcióblokkot). Ezen kívül a program tartalmazza a MAIN program szegmenset ami a végrehajtás leírását tartalmazza. A három programegység már indokolttá teszi, hogy a közösen használt változókat a globális változók közé soroljuk. Ennek az a menete, hogy az alsó sor bal oldalán lévő ikonok közül a jobb oldali erőforrások (Resurces) fülre kattintunk (a fülek balról jobbra az alábbi megjelenítéseket eredményezik: program egységek, adatok, vizualizáció, erőforrások). Ekkor a megjelenő választékból a globális adatok pontot választjuk, és az ablakba mozgatjuk az egeret, és a jobb oldali egérgomb megnyomásakor megjelenő menüből az Auto Declare menüpontot választjuk a párbeszédablak megjelenítéséhez.

36 36 Ezen a párbeszédablakban a korábban leírtak szerint deklarálhatjuk a globális változókat. Esetünkben a példához kapcsolódóan a következő globális adatok kerültek definiálásra. Ezen változók mindegyike bármelyik programegységből elérhető. A tvilagos, és tsotet TON struktúrák a két időzítőhöz rendelődnek. A tsotet_in, és tvilagos_in BOOL változók az időzítők bementére (indítására) kapcsolódó jeleket jelöli. A start és villogolampa a fizikai be és kimeneteket azonosítja. Logikailag az SFC program ismertetésével kellene folytatni a magyarázatot, de a tényleges programírási sorrend ettől eltér. A tényleges programírási sorrend: Belépés a TwinCAT fejlesztőrendszerbe, és a programegységek (POU) kertének (nincsenek sem adat definíciók, sem programutasítások) létrehozása. Első lépésben a MAIN (SFC nyelvű) programot hozzuk létre.

37 37 A képernyő bal oldali része fölé mozgatva az egeret, és megnyomva a jobb oldali egérgombot az alábbi menülista Add Object parancsával létrehozzuk az idozites1 funkcióblokk keretét ST programnyelven (az új POU létrehozása a Project menülista Object menüpontjában is kiadható (Add)). Hasonló módon hozzuk létre az idozites2 funkcióblokk keretét ST programnyelven Definiáljuk a korábban leírt módon a globális változókat. Megírjuk ST programnyelven az idozites1, majd az idozites2 funkcióblokkokat. Elkészítjük a MAIN programszegmens SFC programját. Most térjünk el ettől a tényleges sorrendtől, és kezdjük az ismertetést az SFC nyelvű MAIN szegmens (program) leírásával. A leírtak szerint két lépésből fog állni a programunk. A programlépéseket az inicializáló blokk után kell elhelyezni egymást követően. Egy lépésblokk elhelyezésének az a menete, hogy elmozgunk az egérrel a beilleszteni kívánt hely lépésfeltételének környezetébe, majd a bal oldali egérgomb megnyomásával kijelölődik maga a lépésfeltétel. A jobb oldali gomb megnyomásával megjelenik egy menü, és ebből kiválaszthatjuk, hogy hova szeretnénk elhelyezni a új lépés blokkot, valamint a lépésfeltételt.

38 38 A programunkban két programlépést helyezünk el egymást követően (STEP1, és STEP2). A lépésfeltételek vagy egyszerűen felülírhatók egy logikai változó nevével, vagy egy, a lépésfeltételt előállító programrész megírásával. Az ismertetett módon az alábbi programvázlat került megrajzolásra.

39 39 A STEP2 programlépés az idozites1 funkcióblokk hívását (a tvilagos jelű időzítő indítását) tartalmazza. Ez a programlépés akkor hajtható végre, ha start bemenet logikai 1 értékű, azaz ez lesz a lépésfeltétel. A STEP3 programlépés az idozites2 funkcióblokk hívását (a tsotet jelű időzítő indítását) tartalmazza, és ennek végrehajtása akkor aktuális, ha a már elindított időzítő (tvilagos) ideje már letelt. Az Init kezdőlépésre való visszaugrás akkor történhet meg, ha a második időzítő (tsotet) ideje letelt. Az Init lépésblokk esetünkben a változók meginicializálását (alaphelyzetbe hozását) szolgálja. A lépéshez tartozó programutasítások a lépés rajzszimbólumán az egér bal oldali gombjára való dupla kattintással jeleníthető meg. A villogolampa fizikai kimenetet töröljük, hogy a lámpa sötét legyen, és a két időzítő bementi változójának is 0 (FALSE) értéket adunk, hogy az időzítők az első meghíváskor törlődjenek. A STEP2 lépés akkor fog végrehajtódni, ha a start jel 1 értékű lesz. A lépés az alábbi programutasításokat tartalmazza.

40 40 Az első sor az idozites1 (az ido1 egy idozites1 funkcióblokkhoz rendelt adatstruktúra) funkcióblokk meghívását tartalmazza. Ez a funkcióblokk mindössze egy TON bekapcsolás késleltető hívását tartalmazza. Ezen funkcióblokk első hívásakor a bementre kapcsolt tvilagos_in indító jel (az Init lépésben való inicializálás miatt) 0 értékű, azaz az időzítő törlődik. A funkcióblokkból kilépve ez a jel 1 értéket kap. Így a második, valamint a további hívásokkor viszont ez a bement már 1 értékű lesz, és a tvilagos időzítő működik. A villogolampa kimenet 0 értéket kap, a lámpa sötét lesz. 2 s múlva a tvilagos.q lépésfeltétel 1 értékű lesz, és így a következőkben a STEP3 lépés fog végrehajtódni. A STEP3 lépéshez tartozó utasítások az alábbiak. Az első sor az idozites2 (az ido2 egy idozites2 funkcióblokkhoz rendelt adatstruktúra) funkcióblokk meghívását tartalmazza. Ez a funkcióblokk mindössze egy TON bekapcsolás késleltető hívását tartalmazza.

41 41 Az előzőekben leírtakhoz hasonlóan az első futáskor a bementre kapcsolt tsotet_in indító jel (az Init lépésben való inicializálás miatt) 0 értékű, azaz az időzítő törlődik. A funkcióblokkból kilépve ez a jel 1 értéket kap. Így a második, valamint a további hívásokkor viszont ez a bement már 1 értékű lesz, és a tsotet időzítő működik. A villogolampa kimenet 1 értéket kap és a lámpa világos lesz. 2 s múlva a tvilagos.q lépésfeltétel 1 értékű lesz, és így a visszalépünk az Inic kezdőlépésre, kezdődik a ciklus újra. 3.4 A projekt (program) fordítása A kifejlesztett program a Project menülista Build, vagy Rebuild all menüpontjaival fordítható le. Ha a program fordítása előtt nem adjuk meg a PLC konfigurációját a TwinCAT System Manager programban, akkor a fordítás egy figyelmeztető hibaüzenet ad, és a keletkezett program nem használható. A fordítás előtt tehát mindenképpen el kell készíteni a PLC konfigurációjának a megadását a TwinCAT System Manager program futtatásával. Normál esetben a program fordításának hiba nélkül kell megtörténnie. Ezért most nézzük meg a TwinCAT System Manager program működését, feladatait. 4. A TwinCAT System Manager programkomponens. A fejlesztő rendszer egyik alapvető feladata, hogy támogassa a PLC rendszer konkrét kialakításának megadását. Ezt a funkciót a TwinCAT System Manager programkomponens valósítja meg. A példa kedvéért egy kísérleti, minimális kiépítésű kialakítás legfontosabb adatai: PLC kialakítását tételezzük fel. A A PLC program a PC Windows operációs rendszere alatt kerül futtatásra. A PC egy FC 2001 típusú fénykábeles PCI csatolókártyát tartalmaz, aminek a feladata a kommunikációs kapcsolat biztosítása a PLC be és kimeneti kártyái között. Egy BK2000 típusú buszcsatoló kártya (fénykábeles rendszer) Egy KL 2134 típusú 4 darab digitális kimeneti csatorna (24 V, 0.5 A) Egy KL 1114 típusú 4 digitális bemeneti csatorna (24 V) Egy KL 9010 busz lezáró modul.

42 42 A program indítását követően az alábbi képernyő jelenik meg. Nézzük végig azokat a lépéseket amelyeket meg kell tennünk, hogy a PLC programunk futtathatóvá váljon. 4.1 Az I/O konfiguráció megadása. Első lépésben definiáljuk az I/O konfigurációját. Mozogjunk el az I/O Devices szimbolumra az egérrel, majd nyomjuk meg a jobb oldali egérgombot. A megjelenő menülistából válasszuk ki az Append Device menüpontot, és aktivizáljuk ezt. Ekkor megjelennek azok a PC kártya típusok, amelyek a kommunikációs kapcsolat megvalósítására alkalmazhatók.

43 43 Nekünk ebből a listából a bejelölt típust kell kiválasztanunk, mert ez van behelyezve a gépünkbe Amennyiben az OK gombbal elfogadjuk a kártya kijelölését, úgy megjelenik a kiválasztott FC 2001 PCI kártya részletesebb leírása. Ezen két lapon láthatjuk az adatokat. A General fül adatai inkább informálisak most számunkra. Viszont az FC 200x fülre kattintva az egérrel, egy igen fontos és pontosításra váró adat jelenik meg.

44 44 A PCI busz paraméterei nem állítódnak be automatikusan, hanem itt kell aktivizálni a Search.. funkciót. Ennek hatására a program kikeresi, és megjeleníti a PC-be bedugott kártya PCI azonosítóit, amit el kell fogadnunk. Ha az itt szereplő PCI azonosítók nem a tényleges állapotnak megfelelők, akkor a PC és a Beckhoff buszcsatoló között a táviratozási kapcsolat nem működik, hibaüzenet jelenik meg. Miután megadtuk a PC-ben lévő kártya adatait, a BK 2000 busz csatolót kell definiálnunk jelen esetben. Mozogjunk az egérrel a Device1 szimbólumra, és a jobb oldali egér gombbal jelenítsük meg a menülistát. Válasszuk az Append Box menüpontot. A megjelenített választékból válasszuk ki az általunk alkalmazott BK 2000 típusú buszcsatolót.

45 45 A kiválasztott típust az OK gomb megnyomásával fogadhatjuk el. A következő lépés a BK 2000 buszcsatoló K buszára csatlakoztatott bemeneti és kimeneti egységek felsorolása. Ez megint csak úgy történhet, hogy elmozgunk a Box1 szimbólumra, és a jobb oldali egérgombbal megnyitjuk a következő menülistát.

46 46 Aktivizálnunk kell az Append Terminal menüpontot minden egyes be illetve kimeneti egységre. Az egységek definiálási sorrendje azonos kell, hogy legyen a K buszra felfűzés sorrendjével. Esetünkben a BK 2000 egység mellet a KL 2134 kimeneti, majd azt követően (a buszlezáró mellett) a KL 1114 bementi modul van elhelyezve. A definiálás végén az alábbi eszközöket tartalmazó képet kapunk.

47 47 Az I/O konfigurálás lezáró aktusa a Mapping (leképezés) információk előállítása. Ennek a leképezésnek az a célja, hogy a PC által lekérdezendő be és kimenteket számát meghatározzuk, és legyen egy olyan összerendelő táblázat, hogy a PLC program egy be illetve kimeneti változóját melyik fizikai modul, melyik fizikai csatornájához rendeljük hozzá. Ennek a leképezésnek az előállításához a PLC Configuration szimbólumnál hozzá kell fűzni a PLC tpy kiterjesztésű állományát. Ez az állomány az ismertetett lépések sorrendjében még nem létezik. Ezt a tpy kiterjesztésű projekt állományt a TwinCAT PLC Control program hozza létre a projekt Build, vagy Rebuild All parancsára akkor, ha már a PLC konfigurációra vonatkozó tsm kiterjesztésű állomány is létezik. Ez az állomány most állt elő (azzal a szépséghibával, hogy még nincs meg a PC és PLC táviratozási objektumok kölcsönös leképezése). Ezért mentsük el a Save as paranccsal a konfiguráció egy jelentős részét tartalmazó állományt a projekt többi állományával azonos néven, azonos alkönyvtárba. Ha ezt követően a TwinCAT PLC Control programmal újrafordítjuk a programunkat most már figyelmeztető hibaüzenet nélkül kell lefordulni a programnak.

48 48 Ha a fordítás sikeres és létrejött a tpy kiterjesztésű projekt állomány, akkor ismét lépjünk be a TwinCAT System Manager programba, és ezt a projekt állomány fűzzük hozzá az eddigi konfigurációs állományhoz. A PLC Configuration szimbólumára kell mozognunk az egérrel, majd a jobb egér gombbal megjeleník a menülista. Az Append PLC project parancsot aktivizálva jelöljük ki a projekt állományt. A villogtat.tpy PLC projekt állomány hozzáfűzése után kinyithatjuk az táviratozásban szereplő változók listáját.

49 49 Látható, hogy a MAIN programszegmens start, és a villogolampa be illetve kimenete szerepel az adatcserében. Ezekhez a PLC változókhoz kell hozzárendelni az általunk elképzelt fizikai bementet (legyen az 1. csatorna), és kimenetet (legyen az 1. csatorna). A változó, és a fizikai csatorna összerendelése úgy történhet, hogy elmozgunk a kívánt változóra, majd az egér gombra kattintva megjelenik a változó leírása. A Linked to parancsgomb megnyomásával megjelenik a fizikai csatornák választéka, és az általunk megkívánt csatornát rendelhetjük a változóhoz.

50 50 Ezt az eljárás valamennyi be és kimenetre el kell végezni. Az összerendeléseket követően most már valóban létrehozható a Mapping állomány. Ez az Actions menüpont Generate Mappings parancsával kerül létrehozásra. A leképezés állomány az alábbi ábrán látható részlete azt mutatja, hogy a PC-ben a %QX2.0 címre definiált villogolampa bit a PC 3-ik memória bájtján van, és ez a BK2000 ben a kiolvasott adatok tárhelyének 0.-ik bájtján található.

51 51 Ha a fordított irányú adatforgalmat (a BK 2000 olvasását) nézzük úgy azt látjuk, hogy a PC IX1.0 start bemeneti változója a PC 2. bájtjára van leképezve, és ezt a BK bájtjáról olvassa be a táviratozó program.

52 52 A leképezést követően mentsük el a konfigurációs állomány végső verzióját. A TwinCAT PLC Control programmal ismét fordítsuk le a programunkat is, hogy az is a konfigurációs leírás utolsó verzióját tartalmazza. Ezt követően már a programunk futtatásával, és tesztelésével kezdhetünk foglalkozni. 5. A program futtatása, hibakeresése, tesztelése. A kifejlesztett programot első lépésben célszerű szimulációs üzemmódban (a technológia nélkül) egy alaptesztnek alávetni, hogy a működés durva rendellenességeit kiszűrjük. Amikor ez a beüzemelési fázis már megtörtént, sorra kerülhet a technológia működtetésével lefolytatott tesztekre is. Ekkor a PLC funkciók már ténylegesen a technológiára alapozva hajtódnak végre. Amikor úgy tűnik, hogy elkészült a PLC projektünk végleges változata, akkor a TwinCat rendszert, és a PLC programot automatikusan akarjuk futtatni. 5.1 A program futtatása szimulációs üzemmódban. A szimulációs üzemmódhoz nincs szükség semmilyen hardver eszközre (FC2001, BK 2000 stb.), csupán a TwinCAT szoftver rendszerre. Első lépésben el kell indítani a TwinCAT rendszert. Ennek egyik lehetséges módja, hogy az ikonon keresztül kiadjuk a rendszer start parancsot.

53 53 A rendszer indítását követően belépünk a TwinCAT PLC Control programba, és az alkalmazás (projekt) betöltését követően belépünk az Online menüpontba. A Choose Run-Time System paranccsal kijelöljük, hogy a maximálisan lehetséges négy PLC program melyikét kívánjuk szimulációs környezetben tesztelni.

54 54 Jelenleg egyetlen PLC program választható, így csak ennek a szimulált futtatására van lehetőség. A kiválasztást követően a Login paranccsal a TwinCAT PLC Control programot logikailag összekapcsoljuk a TwinCAT rendszer programjával (ataszkjával). Ismét az Online menüt aktivizálva el kell indítanunk a PLC program futtatását a Run parancs kiadásával.

55 55 Amennyiben a PLC a PC-ben van leképezve, úgy a tényleges PLC programja fog futni, csak a be és kimenetek távirati úton való cseréje (a busz csatolón keresztül) nincs bekapcsolva. Ha egy rack típusú PLC van akkor a menüben a Simulation Mode bekapcsolhatóvá válik, és be is kell kapcsolni, mert ekkor a PLC programjának futtatását a normál esetben a külső (PLC) processzor végzi, és át kell venni ezt a funkciót a PC-nek szimulációs üzemben. Szimulációs üzemmódban a technológiától érkező adatok nincsenek, ezeket a Write, Force parancsokon keresztül tudjuk beállítani. A Run parancs kiadását követően a képernyőn már megjelenik a működés követésére, hibafelderítésre is alkalmas program kép. A program nyomkövetésének részletesebb leírását később fogjuk tárgyalni. 5.2 A program normál futtatása. Amikor a programunkat már a technológiai környezetben akarjuk tesztelni, akkor a bemenetek és kimenetek kezelése is szükséges, azaz a táviratozást a PC és a buszcsatoló között már üzemeltetni kell. Első lépésként el kell indítanunk a TwinCAT System Manager programot, és be kell tölteni a projecthez tartozó konfigurációs állományt. Ezt követően az Actions menüpont Activate Configuration parancsát kell kiadni.

56 56 A parancs hatására a kezeléshez szükséges konfiguráció betöltődik a rendszer kitüntetett területére (\TwinCAT\Boot alkönyvtár CurrentConfig.xml nevű állománya). Az aktiválás után a következő menüponttal (Set/Reset TwinCAT to Run Mode ) a TwinCAT rendszer indítása, vagy újraindítása szükséges. Következő lépésben a a TwinCAT PLC Control programban az Online menüpontban ismét a Login, majd a PLC indítására szolgáló Run parancsot kell kiadni. Ekkor a fizikai be és kimenetek kezelése már megtörténik, de a Force paranccsal felülbírálhatjuk ezek tartalmát. 5.3 A PLC program automatikus indításának beállítása. Amennyiben úgy döntünk, hogy egy PLC program fejlesztése befejeződött akkor általában azt szeretnénk, hogy PLC program a rendszer (PC) bekapcsolásakor automatikusan elinduljon. Ennek az a menete, hogy a normál módban elindított program működése közben a TwinCAT PLC Control program Online menüpontjában ki kell adnunk a

57 57 Create Bootproject parancsát. A parancs hatására a PLC automatikus indításához szükséges állományok a \TwinCAT\Boot alkönyvtárba elmentődnek. Jelenleg az 1-es jelű PLC program került elmentésre. Ahhoz, hogy a PC indításakor mind a TwinCAT rendszer, mind a PLC elinduljon, azt még elő kell írni.

58 58 A Properties parancs hatására megjelenő ablakokban az automatikus indítást mind a rendszerre, mind a PLC-re előírhatjuk. A System ablakon belül a rendszer Auto Boot módját engedélyezhetjük, vagy tilthatjuk. A rendszerhez tartozó három szerver program (taszk) az engedélyezés esetén automatikusan elindul. A PLC ablakban a PLC automatikus indítását engedélyezhetjük, ill. tilthatjuk.

59 59 Az ábrán a PLC program automatikus indítását engedélyezhetjük, vagy tilthatjuk. Ezeket a parancsokat a TwinCAT System Manager programjának System Configuration és PLC Configuration ikonján keresztül is be tudjuk állítani. 5.4 A PLC taszk ciklusidejének a beállítása. A TwinCAT rendszer taszkjai beépülnek a Windows operációs rendszerének egyéb programjai közé. Ezeknek a taszkoknak szigorú ütemezés szerint, valós időben ( real-time) kell futnia. Az alábbi ábra a TwinCAT taszk futásának időbeli ütemezését mutatja.

60 60 Az ábrán azt láthatjuk, hogy alapidőnek 1 ms van beállítva ami azt jelenti, hogy ilyen időközönként történhet újraütemezés. Előírásunk szerint a TwinCAT taszknak 2 ms ciklikussággal kell futnia. Még beállításiadat, hogy a CPU felhasználását a TwinCAT taszk számára 50%-ban limitáltuk (azaz 0.5 ms). Balról jobbra haladva azt látjuk, hogy 2 ms időközönként (a ciklusidő) a következő szituációk alakulhatnak ki a tasz futásával kapcsolatban: 1. Beolvassuk a fizikai bementeket (piros szín), értelmezzük a PLC program utasításait (fekete), kiadjuk a fizikai kimeneteket (szürke). Ez az első ciklusban a limitidőn (0.5 ms) belül lezajlik, és a Windows egyéb taszkjai kerülnek végrehajtásra. 2. A program a 0.5 limitidőn belül nem fejeződik be, ezért a futása megszakad, és a Windows egyéb taszkjai fognak futni. A TwinCAT taszk a következő átütemezési időpillanatban (3. ms) folytatja futását, majd befejezi limitidőn belül a működését és ismét a Windows egyéb programjai hajtódnak végre. 3. A taszk ismét limitidőn belül fejezi be a működését. A mechanizmus alapján azt mondhatjuk, hogy a PLC egy bementi változásra (pl. a vész stop megnyomása) a legrosszabb esetben a ciklusidő (a magyarázatnál 2 ms) kétszerese alatt fog reagálni, a kimeneten beavatkozni (a példánál 4 ms). A reagálás szükséges gyorsaságát a technológia szabja meg. Egy normál folyamatnál sokszor a több 10 ms ciklusidők is elfogadhatok, és alkalmazhatók. A BOSCH által használt berendezésekhez 4 ms ciklusidő kapcsolódik, a technológia gyorsasága miatt. A ciklusidő, a CPU sebessége, a CPU idő megosztási limitje együtt korlátozza a végrehajtható program nagyságát. Egy nagyon bonyolult (terjedelmes) program igen gyakran nem biztos, hogy végrehajtható. A TwinCAT rendszer nem csupán egy, hanem több taszk kapcsolódik. A rendelkezésre álló időszelethez (CPU használathoz) ezek a taszkok a prioritásuk sorrendjében férnek hozzá. Az alábbi ábra a prioritás szerepét mutatja egy magasabb, és egy alacsonyabb prioritású taszk esetére.

61 61 A real-time rendszerekre jellemző képet látjuk, amíg a magas prioritású taszk nem fejezi be a működését, addig az alacsonyabb prioritású taszk nem jut szóhoz. A Windows rendszerben a kisebb prioritási szám jelenti a magasabb prioritást. Ezeket a fontos, a rendszer működését alapjaiban érintő adatok egy részét TwinCAT PLC Control program erőforrások ablakán belül, a Task configuration szimbólumra állással lehet beállítani.

62 62 A négy lehetséges taszk egymás közötti prioritási szintjét, és a ciklusidőt tudjuk ezen a felületen beállítani. Ha szükséges a taszk nevét, és fajtáját (típusát) állíthatjuk még be a párbeszédablakban. Az alapidőt, és a CPU használat limit idejét a TwinCAT System Manager programban állíthatjuk be, és ugyanitt változtathatjuk meg a taszkok (abszolút) prioritását.

63 A program hibakeresése, tesztelése. Amikor egy működő (futó) PLC program mellet Online üzemmódban használjuk a TwinCAT PLC Control programot, akkor a fejlesztő rendszerben követhetjük, valamint befolyásolhatjuk a PLC programunk működését hiba felderítési, vagy tesztelési céllal. A PLC program fejlesztés stádiumában eleve a TwinCAT PLC Control program alatt szimuláljuk, vagy töltjük le, és indítjuk el a programunkat. Ekkor természetes folytatásként a képernyőn megjelenik a futás követésére alkalmas kép. Amennyiben a TwinCAT Control program indításakor már fut a PLC-ben egy korábban elindított program, úgy az Online menülista Login parancsát követően (ha TwinCAT PLC Control programban a futó projekt be van töltve), akkor ugyanúgy megjelenik a program működésének követéséra alkalmas kép, mint az előző esetben A grafikus (LD, FBD) nyelven megírt programok hibakeresése. A grafikus nyelveken (LD, vagy FBD) megírt programok működését értelemszerűen grafikus formában láthatjuk. A szín megváltozásával kerül megjelenítésre, hogy egy vezetékszakaszon, kontaktuson, tekercsen keresztül az energia átkerül, avagy nem. Ezen a túl a változók aktuális értéke is kiíratásra kerül.

64 64 Az ábrán a kék szín jelöli a logikai 1 állapotot, az energia meglétét, míg a fekete szín a 0 (energiamentes) állapotot jelöli. Az állapotok változásának vizuális képe, valamint a változók aktuális értékének a figyelése alapján némi gyakorlattal követhetjük a programunk működését, és a programozás esetleges hibáit is felismerhetjük. A programteszteléshez igen fontos segítséget nyújt, hogy a változókba a számunkra kívánatos értékeket írhatjuk (write), vagy kényszerítjük (force). A két eljárás között az a különbség, hogy írás esetén az általink megadott értéket (vagy értékeket) az írás érvényesítésekor beírjuk az adott változókba (vagy változókba) egyszer, és utána hagyjuk, hogy ezen változók tartalma már a program működésének megfelelően változzon. A kényszerítés esetén a kijelölt változók tartalma a program működésétől függetlenül az általunk definiált értékek lesznek a kényszer érvényesítését követően. Mindkét eljárás, mind BOOL, mind egyéb (pl. INT, REAL stb.) változóra alkalmazható. Ezt a szolgáltatást a legegyszerűbben olyan módon vehetjük igénybe, hogy az egérrel elmozdulunk a kívánt változó deklarációs sorába, és az egér bal oldali billentyűjére duplán kattintva megjelenik a változó lehetséges új értéke BOOL változónál, vagy egy ablak a nem BOOL változó új értékének megadására.

65 65 A fenti ábrán azt látjuk, hogy a start (fizikai) bemenő változó a jelenlegi állapot szerint FALSE, de mi azt jelöljük, hogy a program majd TRUE értéket vegyen figyelembe, ha életbe léptetjük az új értéket (írás, vagy kényszerítés funkció). Egy kimenetre a (vilagosletelt) ugyancsak a TRUE értéket jelöltünk ki. Azt, hogy a start bemenetet 1 értékbe tesszük, még lehet, ennél az egyszerű példánál is némi magyarázatot adni, de a kimenet 1 állapotba hozása egy logikátlan lépés, csak azt mutatja, hogy a kimenet értéke is írható, és kényszeríthető bármely állapotba. Ha valamelyik változónál ismét duplán kattintunk az egér bal oldali gombjával, akkor a FALSE logikai jelet készítenénk elő új értékként. A következő dupla kattintás az előkészítés törlését eredményezné. Azaz logikai (BOOLE) változóknál ez a három állapot fog változni. Amennyiben a tvilagos bekapcsolás késleltető időzítési értékét (PT) is változtatni akarnánk, akkor ugyancsak duplán kell rákattintani a kérdéses változóra az egér bal gombjával. Ezen idő típusú változó új értékét ebben a párbeszédablakban adhatjuk meg. Miután valamennyi változó általunk kívánt értékét beállítottuk, az értékek érvényesítésének módjára tehát kétfajta eljárást választhatunk. Az Online menülista

66 66 Write Value menüpontja az előkészített változók írását, míg a Force Values menüpont az előkészített értékek kényszerítését fogja eredményezni. A kényszerítés megszüntetése a Release Force menüpont hívásával lehetséges. A preparált adatok értékét megjeleníthetjük, vagy ezek érvényre juttatását, megszüntetését is elrendelhetjük a Write/Force Dialog párbeszédablakban.

67 67 Az FBD programnyelven írt programok működése hasonló elvek alapján történik. A példafeladatot nem dolgoztuk ki sem FBD, sem IL programnyelven. Ha most igen gyorsan pótolni akarnánk ezt a hiányt, akkor az alábbi menüpont aktivizálásával az LD nyelvű program egy újrafordítást követően FBD (vagy IL) programnyelvre átkonvertálható.

68 68 A konvertálásnál most jelöljük meg az FBD programnyelvet. A konvertálás után a programot letöltve, és elindítva az alábbi formában láthatjuk a program működését.

69 Szöveges (ST, IL) programnyelven írt programok hibakeresése. A szövegese programnyelven írt programok működéskövetése gyakorlatilag ne tér el a normál (nem PLC) programok nyomkövetésénél megszokott technikától. A program nyomkövetéséhez az alábbi szolgáltatások állnak rendelkezésre. A programunk végrehajtásánál tetszőleges utasításokra töréspontot helyezhetünk, vagy szüntethetünk meg A program lépésenkénti (utasításonkénti) végrehajtását kezdeményezhetjük A változók értékének a manipulálása az előző fejezetben leírt formában biztosított. Az ST nyelven megírt programunkat, ha futtatjuk, úgy a működését az alábbi képernyőn követhetjük.

70 70 A változók aktuális értékét egyrészt a deklarációs ablakban láthatjuk, másrészt az utasítás ablak jobb oldali részén az adott utasítássor bal és jobb oldalán szereplő változók aktuális értéke folyamatosan frissítve megjelenik. Az adatok írása, vagy kényszerítése a korábban leírtakkal teljesen azonos módon lehetséges. Demonstrációként a program harmadik utasítássorába helyezzünk el egy töréspontot, az egér utasítássorára való mozgatásával, kijelölésével, majd az F9 funkcióbillentyű megnyomásával (vagy az Online menülista, Toggle Breakpoint menüpont). A program futása ezen a ponton megszakad, és lehetőség van a következő futtatási alternatívák valamelyikének alkalmazására. Az F5 funkciógomb (vagy az Online menülista Run menüpont) megnyomásával a program folyamatosan fut, és akkor fog a működés leállni, ha ismét a töréspontra fut a program. Az F10 funkcióbillentyű megnyomásával (vagy az Online menülista Step Over menüpont) egyetlen programlépés hajtódik végre. Ekkor egy funkcióhívás egyetlen lépésnek tekinthető (nem lépünk be a funkció blokkba). Az F8 funkcióbillentyű megnyomásával (vagy az Online menülista Step In menüpont) egyetlen programlépés hajtódik végre. Ekkor a funkcióhíváskor belépünk a funkcióblokk belsejébe, és ott fojtathatjuk a program működésének követését. A töréspont az ismételt kijelöléssel meg is szüntethető. Az ábrán két programlépés után látható a program képe..

71 71 Az IL utasításlistás nyelven megírt programok működésének követése teljesen hasonló formában történik. Ha a programunkat gépileg (a korábban említett módon az LD alkalmazás) átkonvertáljuk, és elindítjuk, akkor az előző képernyőszerkezetet fogjuk újra látni. A változók beírása, kényszerítése, a töréspont beiktatása, eltávolítása, a lépésenkénti végrehajtás módja ugyanaz, mint azt korábban leírtuk.

72 Az SFC programnyelven írt programok hibakeresése. Az SFC nyelvű programok futtatásával az alábbi kép jelenik meg.

73 73 Ezen a képen a kék szín jelzi, hogy éppen melyik POU (programegység) végrehajtása történik. A korábban elmondottaktól eltérően a lépésfeltétel változók nem írhatók, és nem kényszeríthetők. Amennyiben valamelyik lépésre mozgunk az egérrel, és duplán rákattintunk a bal oldali egérgombra, akkor az adott lépés programja a programnyelvének (grafikus, szöveges) megfelelő formában kínálja a lépés működésének követését.

74 74 6. A gyártóberendezés programjának vizsgálata. 6.1 A program általános jellemzése, hiba ok keresése. A gyártóberendezés programja kizárólag ST programnyelven került kidolgozásra, ami közelebb esik egy normál programhoz, mintsem a klasszikus PLC programnyelvekhez (LD, FBD). Ez a kijelentés semmiféle kritikai tartalmat nem hordoz, mert egy ilyen bonyolultságú vezérlési feladatot ilyen színvonalon, grafikus programnyelven megoldani reménytelen vállalkozás. A grafikus programnyelvek azért preferáltak a PLC technikában, mert az egyszerű utasításszerkezet (az ugró és ciklusszervező utasítások alkalmazásának hiánya miatt) a programok lefagyása nem szokott előfordulni, minden körülmények között megtörténik az esetleg hibás beavatkozás a folyamatba. Az ST programnyelv alkalmazása magával vonja, hogy a létező összes programozási hibát el lehet követni. Végtelen ciklusokat szervezhetünk a FOR, WHILE, REPEAT utasítások szervezése során. Tömböket túlcímezhetünk a programunk futása során (pl. egy 10 elemű tömb 12-ik elemébe kísérelünk meg adatot írni). Egy-egy részfolyamat megengedett időértékének (time-out) helytelen megválasztása miatt utasítások csoportja kerülhet átlépésre, és emiatt feltételek nem fognak teljesülni, így esetleges a beavatkozások egy része is elmarad. Sajnos egy több ezer soros programban a hibákat felismerni, amelyek egy része nem szisztematikus, hanem csak bizonyos feltételek együttes teljesülése során következik be igen nehéz feladat.

75 75 A programok tesztelése során az azokat a hibákat, amelyek néhány percen, esetleg órákon belül ismételten fellépnek, általában elhárítják. Azok a hibaforrások maradnak meg általában a programjainkban, amelyek előfordulása több napos ciklussal ismétlődik. Azokat a hibákat a legnehezebb felderíteni, amelyek ismétlődése még ennél is ritkább (igen kis valószínűséggel következik be. A hiba ok felderítés során első lépés annak vizsgálata, hogy a folyamatvizualizáló rendszer vajon generált-e az eseménynaplóban a kérdéses hibára vonatkozó üzenetet. Amennyiben a hiba előfordulására (pl. érzékelő meghibásodása, time-out túllépés stb.) a program tervezője számított, akkor találunk erre vonatkozó bejegyzést, és viszonylag biztos alapokról indulhatunk el a hiba ok megszüntetése érdekében. Sajnos nincs olyan rendszer, ami minden elképzelhető hiba okáról eseménybejegyzést készítene. Ezért, ha az eseményüzenetek nem tartalmaznak még csak utalást sem a hiba lehetséges kiváltó okáról, akkor második lépésben kezdjünk gyanakodni a TwinCAT rendszer működési környezetére. A TwinCAT LogView szolgáltatásának elindításával láthatjuk, hogy magának a TwinCAT rendszernek a működése során nem keletkezett-e olyan bejegyzés ami kiinduló alapot jelenthetne számunkra. Belépve a LogView programba a következő kép jelenik meg. Mint látható három csoportra tagolva láthatjuk a bejegyzéseket. Számunkra bármelyik csoportban szereplő bejegyzés hasznos kiinduló információval szolgálhat, akár csak olyan szinten is, hogy milyen környezeti történéshez kapcsolódik a hiba fellépése. Még ha nem is találjuk meg ekkor a konkrét hiba okot, de ha már ötödször mindig ugyanazon környezeti

76 76 változást érzékeljük a hiba időpontjában, akkor a gyanúnk ennek a hatásnak a komolyabb vizsgálatát is kezdeményezheti. Bármelyik konkrét bejegyzésre (duplán) rákattintva az egérrel a bejegyzés részletesebb leírása válik láthatóvá. Amennyiben a rendszerünk eddigi ismertetett szolgáltatásai nem adnak támpontot a hiba okára, akkor kénytelenek vagyunk intuitív módon a PLC program nyomkövetésével rájönni erre. A sikeres munka alapfeltétele, a technológiai lépések sorozatának, a végrehajtási feltételeknek a minél teljesebb körű ismerete. Amennyiben a hiba tartósa fennáll indítsuk el a TwinCAT PLC Controll fejlesztőprogramot, és lépjünk be (Login) az a Online üzemmódba. Ekkor a program futásának korábban leírt működéskövetése lehetővé válik. Elsőször ne helyezzünk el töréspontot, és ezzel ne befolyásoljuk a program végrehajtásának időzítési viszonyait. Passzívan figyeljük a program futását. A programunk alapvető (kiinduló) szegmense mindig a MAIN program, ami ciklikusan (néhány ms ciklusidővel) ismétlődik, és ez aktivizálja a további program egységeket (POU). Próbáljunk meg teóriát felállítani, hogy melyik programszegmens (POU), melyik program részlet futása során van hiba. A MAIN szegmensből indulva a hívási lánc lépéseit követve lépdeljünk el a kérdéses szegmensre, passzívan szemlélve a változók alakulását, vagy azt, hogy egyáltalán tapasztalunk-e bármilyen a futásra jellemző változást. A leginkább a gyanús programszegmensen belül szemlélődjünk. A változók alakulásából kíséreljünk meg

77 77 következetni a hiba okára (érzékelő hiba, időzítési hiba, stb.). Ha úgy érezzük, hogy látjuk a hibát okozó program környezetet, és szükségesnek tűnik a gyanú beigazolásához, akkor a töréspont alkalmazásával, majd a lépésenkénti végrehajtással egy az emberi gondolkodás számára is elfogadható sebességgel hajtsuk végre az utasításokat, és ekkor valószínűleg rájövünk a hiba okára. Ne felejtsük el, hogy a lépésenkénti végrehajtással alapvetően megváltozattuk a program időzítési viszonyait, és ez esetleg nemhogy a tisztázás, hanem a téves következtetések levonására fog inspirálni. Ahhoz, hogy esélyünk legyen a hiba ok intuitív felismerésére, a PLC program szerkezetét is alaposan ismerni kell. Ezért nézzük meg, hogy milyen szerkezetűek a gyártó berendezések PLC programja. 6.2 A gyártósorok PLC programjainak a szerkezete. A programszerkezet tanulmányozását kezdjük a változók megismerésével, hiszen ezen adatok felhasználásával működnek a programegységek. Csak ezt követően térjünk át a programegységek tanulmányozására Az adatok (struktúrák, és felsorolások) szerkezetének definiálása. A TwinCAT PLC Control programban az adatok ablakban láthatjuk az adatok (struktúrák, felsorolások) definiálását, hiszen ezekre, a típusokra a későbbi változódeklarációkban hivatkozni fogunk.

78 78 A képernyőn egy a gyártmány adatok struktúráját definiáló részletet láthatjuk. A következő képen egy felsorolás jellegű adatsor definiálását láthatjuk A globális adatok. Az erőforrások ablakban az alkalmazás legfontosabb globális (az alkalmazás programegységei számára egyaránt használható) adatcsoportjait láthatjuk. A program tervezői a globális adatokat csoportokba (állományokba) sorolták. A kiépítést (konfigurációt) leíró globális adatok (Global_Config_ jelöléssel). A Global_GFB_Machine a globális funkcióblokkok deklarációját tartalmazza A Global_GM_ XXX jelölésű, a globális memória adatait tartalmazó állományok (az XXX elnevezésű berendezésre) A Global_GCM_ XXX jelölésű, az eszközök közötti kommunikációt jellemző adatokat tartalmazza (az XXX elnevezésű berendezésre) A Global_GRM_ XXX a programegységek be és (vagy) kimeneti adatdefinícióit tartalmazza (az XXX elnevezésű berendezésre) A Global_ControlPanelMemory az alkalmazás kezelői felületéhez kapcsolódó adatdeklarációkat tartalmazza. A Global_IO a fizikai be, és kimenetek azonosítóit tartalmazó állomány

79 79 A képen a géphez (berendezéshez) kapcsolódó konfiguráció leírást láthatjuk. Mi lehet vajon a programtervező szándéka, hogy ennyi konstanst definiál, és ezeket szerepelteti a PLC programban, nem pedig a számértékeket (ami talán egyszerűbbé tenné a program működésének követését). Az ok valószínűleg az, hogy ugyanez a program más kiépítésű berendezések működtetésére is szolgál. A konkrét típusokra való program applikáció részben ezen adatoknak (konstansoknak) a megváltoztatásával végezhető el. Természetesen ez a kapcsolódó berendezésekre is igaz, hiszen másfajta környezetbe is lehet ugyanazt a berendezést telepíteni, azaz azok konfigurációja, kiépítettsége hasonlóan adható meg. A berendezésekre, folyamatokra, definiálásra kerülnek azok a globális változók, amelyek több programszegmens számára is elérhetők. Vegyük szemügyre az alábbi példát.

80 80 A változók nevének képzésekor a program tervezői egy nagyon aprólékosan megtervezett logikát alkalmaztak arra vonatkozóan, hogy ha ránézünk egy változó névére, akkor tudjuk, hogy nagyjából milyen típusú változóval állunk szembe. A G a globális adatra utaló jel, míg a G-t követő néhány karakter az adat szerepére, és a hozzá tartozó berendezésre utaló rövidítés. Az IO, értelemszerűen a be és kimenetekre, az IN, OUT elnevezések a programegység be valamint kimeneti változóira utalnak. A globális adatoknál az adatok szerepére az alábbi jelekkel utalnak. A GM a berendezés globális (memória) adatait, a GCM a globális kommunikációs adatokat (memóriát), míg a GRM a (POU) globális be és kimeneti adatait (memóriát) azonosítja. A további néhány karakter még mindig a csak a változó típusára utaló jelölések. Például a bo jelöli a BOOL típusú változót, míg a boa a BOOL változókból képezett tömb (ARRAY) jelölésére szolgál. Ennek analógiájára már szinte azonnal kitalálhatjuk, hogy az str a struktúra, míg az stra a struktúra tömb azonosítására szolgáló jelölések. A változó típusára az IEC szabvány lehetséges változó típus deklarációjának első, vagy néhány első karaktere szolgál. Nézzük meg néhány összerendelés rövidítéseit (változó típusa, majd a rövidítése sorrendben). INT UINT DINT UDINT WORD DWORD BOOL BYTE REAL i ui di udi w dw bo by, vagy b re

81 81 LREAL lr STRING s STREUKTUR str ENUM e Timer FB t, vagy ton Tömb jele a Csak ezt követően kerül megadásra a változó tényleges neve (pl. AcknowledgeError). A programegységek (POU) neveinek megadásakor a bevezető karaktersorok esetén az alábbi szabályok érvényesek: Funkció blokk Fukció Program Globális funkció fb_ fu_ pr_ gfb Azaz pl. a gfb bevezető karaktersor a globális funkció blokkra utaló jelölést jelenti. A berendezés globális szimbólumai a StandardGlobal alkönyvtárban találhatók. Az egyik állomány konstansokat (a program futása során nem változtatható adatokat) tartalmaz. A kiragadott részlet éppen a hibákhoz rendelt kódokat tartalmazza. Ezek a kódok, a felhasználói adatbázis egy-egy szövegéhez kapcsolódnak, és a hiba esetén ez a (magyar,

82 82 német, angol stb. nyelvfüggő) szöveg jelenik meg. A másik állomány a program működése során használt globális változókat tartalmazza. Különösen nagy figyelmet kell fordítani a fizikai be és kimenetek szimbólumait tartalmazó állományra. Kizárólag ebben az állományban kerültek definiálásra a fizikai be és kimentekhez kapcsolódó szimbólumok.

83 83 Ezek a globális szimbólumok az bemenet esetén az I_, míg kimenetnél az O_ jelölésekkel kezdődnek. Magának a neveknek a tanulmányozása megmutatja, hogy milyen érzékelők, és egyéb bemenetek befolyásolják a program futását, valamint azt, hogy milyen beavatkozások történnek A program egységek (POU) szerkezete. Amennyiben meghívjuk az erőforrások ablak Task funkcióját, akkor láthatóvá válik a legnagyobb programegységek (taszkok) szerkezete.

84 84 Mint az ábrán látható négy taszk alkotja a teljes programrendszert, ami egyben a TwinCAT rendszerben futtatható taszkok maximális számával azonos. Ha megnézzük, akkor láthatóvá válik, hogy mind a négy taszk ciklikusan fut 4, 4, 5 és 100 ms ciklusidővel (felülről lefelé sorrendben). A taszkok felülről lefelé csökkenő prioritási sorrendben kerültek megjelenítésre. A taszkok futása a korábbi fejezetben leírt konkurens módon kerül végrehajtásra. A legmagasabb prioritású taszk a Standard PLC funkciót megvalósító MAIN programegység. Ez a programegység 4 ms időközönként ciklikusan működik, és a berendezés működtetése a feladata. A Com_Task a pr_com programot jelenti. Ez a program is 4 ms ciklusidővel, újra és újra futásra kerül, de prioritása alacsonyabb, mint a MAIN szegmensnek, így a MAIN élvez elsőbbséget a konkurens (párhuzamos) futás során. A pr_com program taot tanulmányozva azt láthatjuk (lásd POU ablak pr_com program) egy soros vonalon keresztül (9600 Baud, 8 adatbit, NOPARITY, 1 stop bit) egy vonalkód leolvasó három kérdéscsomagra adott válaszait letárolja egy globális (GM_straDMCBuffer) területre, a feldolgozó program számára. A VMDT taszk 5 ms ciklusidővel ismétlődik, és a prioritása az előző (kommunikációs) taszktól alacsonyabb prioritású. A pr_vmdt programszegmens egyetlen funkcióhívás, a kapcsolódó berendezés adat (struktúrájának) a lekérdezése. A 100 ms ciklusidővel ismétlődő pr_uimainscreen program a legalacsonyabb prioritású. A kezelői kép megjelenítéséhez szükséges inicializálásokat, és frissítéseket végzi ez a taszk. Az elvek megértéséhez vegyük szemügyre a MAIN programszegmens működését.

85 85 Mint látható a MAIN szegmens első néhány sorában egyéb programok meghívása történik. A programok és a későbbiekben meghívandó (ezen a képen még nem látható) funkcióblokkok ciklikusan 4 ms ciklusidővel újra és újra meghívásra kerülnek. Egy-egy programegységnek többféle végrehajtási fázist (lépést) kell megvalósítani (pl. adatok inicializálása, üzenetre való várakozás stb.). Vegyük szemügyre az első sorban látszó pr_evaluteuicomdata programszegmensen belül, hogyan valósul meg ez a lépések szerinti tagolódás.

86 86 Látható, hogy a változók deklarációs részében mindössze két lehetséges lépés van definiálva. Az egyik lépés a kezelői felületről érkező új adatra való várakozás, a másik lépés pedig az új adat lekezelése. A program első futásakor az aktuális lépés wstep változójába 0, az új adatra való várakozás üzemmód állítódik be (inicializálás). A program minden egyes futásakor, az első sorban lévő CASE utasítás wstep változójának tartalma határozza meg, hogy mi lesz a program belépés helye. Mindaddig az stp_waiting_for_new_data: a belépés helye, míg a sort követő programlépésben (IF), az új pozíció vételére utaló (BOOL) változó FALSE értékű. Ha ez a változó TRUE (van új vett pozíció), akkor a wstep egy új stp_evaluate_new_data értékkel töltődik fel, és a program következő hívásakor ezen stp_evaluate_new_data: belépési ponton fogunk belépni. A belépési pontot követő programrészlet a következő módon alakul. stp_evaluate_new_data : (*================================================= clear receive variables (*===============================================*) sactstring := ''; (* ui String *) iactsmalint_selection := 0; (* ui Smalint or Selection *) diactinteger := 0; (* ui Integer *) lractdouble := 0; (* ui Double *) lractposition := 0; (* ui Axis position *) iactaxisnbr := 0; (* ui axis nbr *) lractdistance := 0; (* ui Distance *) iactdistancecount := 0; (* ui Distance count *) (*===================================================== write values into receive variables (*====================================================*)

87 87 CASE Module_Positions.wPositionType OF 1: MEMCPY (ADR(sActString),ADR(Module_Positions.baValue),SIZEOF(sActString)); 2: MEMCPY (ADR(iActSmalint_Selection), ADR(Module_Positions.baValue), SIZEOF(iActSmalint_Selection)); 3: MEMCPY (ADR(diActInteger),ADR(Module_Positions.baValue), SIZEOF(diActInteger)); 4: MEMCPY (ADR(lrActDouble),ADR(Module_Positions.baValue), SIZEOF(lrActDouble)); 5: MEMCPY (ADR(lrActPosition),ADR(Module_Positions.baValue), SIZEOF(lrActPosition)); MEMCPY(ADR(iActAxisNBr),ADR(Module_Positions.baValue[9]), SIZEOF(iActAxisNbr)); 6: MEMCPY (ADR(lrActDistance),ADR(Module_Positions.baValue), SIZEOF(lrActDistance)); MEMCPY(ADR(iActAxisNBr),ADR(Module_Positions.baValue[9]), SIZEOF(iActAxisNBr)); MEMCPY(ADR(iActDistanceCount),ADR(Module_Positions.baValue[11]), SIZEOF(iActDistanceCount)); END_CASE (*==================================== write receive variables to Global Config GCM (*===============================================*) CASE Module_Positions.wStation OF STATION_WT_TRANSPORT: fu_wttransportevaluateuicomdata ( in_wposition :=Module_Positions.wPosition, in_sactstring :=sactstring, in_iactsmalint_selection := iactsmalint_selection, in_diactinteger := diactinteger, in_lractdouble := lractdouble, in_lractposition := lractposition, ); END_CASE Module_Positions.boNewPositionReceived := FALSE; wstep := stp_waiting_for_new_data ; END_CASE (* wstep *) Azt láthatjuk, hogy ezen a belépési ponton a változók átvétele, és a kapott adatoktól függő funkciók meghívása látható. Az elv szempontjából lényeges programsorok az utolsó előtti két sor. A lépés sorszámot tartalmazó wstep változóba ismét az új adatra való várakozásnak megfelelő kódot írják, valamint a várakozás-lépésben vizsgált változót FALSE értékre állítják. Ezzel ismét az első lépéstől kezdődik ennek a programnak a végrehajtása. Egy-egy programegység nem csak két, hanem ettől lényegesen több lépésből is állhat. Az alábbi részlet a MAIN szegmensből meghívott pr_checkfuse (biztosíték ellenőrző) program egy részletét mutatja.

88 88 A változódeklarációs részben 15 azonos funkcióblokk egy-egy példányát deklaráljuk. A programrészben a funkcióblokkoknak az egyes példányait, egymást követően meghívjuk a megfelelő belépő paraméterekkel. A képernyőn csak egyetlen példány hívása látható, de további példányok hívásaival folytatódik a programlista. Valamennyi hívás ugyanazon fb_handleerrormessage funkcióblokk egy-egy példányát hívja. Nézzük meg ennek a funkcióblokknak a szerkezetét. A változók deklarálásának ablakában a alábbi FUNCTION_BLOCK fb_handleerrormessage VAR CONSTANT (*========================================================================================= step constants (*=========================================================================================*) stp_init : WORD := 0; stp_wait_for_error : WORD := 10; stp_send_error : WORD := 100; stp_wait_error_active : WORD := 110; stp_receive_error : WORD := 120; (*========================================================================================= specific constants (*=========================================================================================*) tdelay_error_active : TIME := T#3s; tmin_error_active_time : TIME := T#1s; END_VAR VAR_INPUT (*========================================================================================= input variables (*=========================================================================================*) in_boactive : BOOL; in_wmodule : WORD;

89 89 in_wstation : WORD; in_wpart : WORD; in_werrorlangnbr : WORD; in_berrorquitoption : BYTE; in_waerrorbuttontext : ARRAY[1..4] OF WORD; in_baerrorsuppdata : ARRAY[1..8] OF BYTE; in_saerrorsuppstring : ARRAY[1..2] OF STRING(9); END_VAR VAR_OUTPUT (*========================================================================================= output variables (*=========================================================================================*) out_boactive : BOOL; out_wquit : WORD; END_VAR VAR (*========================================================================================= error variables (*=========================================================================================*) werroractualnbr : WORD; wstep : WORD; (*========================================================================================= local standard variables (*=========================================================================================*) (*========================================================================================= standard instances of function blocks (*=========================================================================================*) fbreceiveerror : ui_receiveerror; (*========================================================================================= specific instances of function blocks (*=========================================================================================*) fbdelay : TON; END_VAR A deklaráció első néhány sorában láthatjuk, hogy öt belépési pontja (öt lépése) van ennek a funkcióblokknak. A wstep változó amikor létrehozunk egy funkcióblokkot, akkor az értéke 0 lesz, azaz az stp_init inicializáló lépésnek megfelelő belépési pontra fogunk lépni.

90 90 A funkcióblokk stp_init belépési pontján beállítják a stp_wait_for_error értéket a wstep változóba, és ezzel ki is lépünk a funkcióblokkból (egyéb inicializálási tevékenység nincs). Mindaddig a stp_wait_for_error belépési ponton fogunk belépni a funkcióblokk hívásakor, amíg a belépési változó wstep értékét át nem állítjuk. Erre akkor kerül sor, ha a bemeneti in_boactive változóval indított időzítés (bekapcsolás késleltető) a kimenetén logikai 1-et értéket szolgáltat (3 s múlva). Azaz a biztosíték állapotát mutató pl. I_10112D1_FUSE_F11_Ok bementnek legalább 3 s ideig folyamatosan FALSE, 0 értékűnek kell lennie, mert ekkor kerül átállításra a wstep érétke a stp_send_error értékre, ami a hiba feldolgozás következő lépésének értékét jelenti. Ezzel egyidejűleg az időzítőt töröljük a bemenetére kapcsolt FALSE értékkel meghívva. A program további részében azt láthatjuk, ahogy az egyes részfeladatok megoldását követően lépésenként haladunk tovább, és itt az utolsó lépést követően ismét a stp_wait_for_error lépésre fogunk visszaugrani. Visszatérve a MAIN szegmens működésére, a pr_checkfuse program után a teljesen hasonló elvek alapján működő, a motorok hőmérsékletének, és a terminálok 24 V-os feszültségének ellenőrzésére szolgáló programok kerülnek meghívásra. A MAIN szegmens pr_relateinputs programja ciklikusan minden meghívásakor (4 ms) a fizikai bemenetek állapotától függően előállítja azokat a globális változókat, amelyek ezen bemenetek értékéből képződnek, és a működtetést befolyásolják. Az alábbi ábra a program első néhány sorát mutatja.

91 91 A következő ábra még mindig ennek a programnak egy további részletét mutatja, ahol az is kiderül, hogy bizonyos esetekben az érzékelő hiánya miatt a bemenet értékeként a működtető kimenet állapota olvasódik vissza.

92 92 Amennyiben az ebben rejlő veszélyt meg kellene világítani, akkor ezt egy egyszerű példával tehetnénk. Ha egy PLC valamelyik kimenetének 1 értékével működtetünk egy motort, akkor az nyilván nem közvetlenül történik, hanem a PLC egy mágnes kapcsolót fog működtetni. A motor csak akkor fog működni, ha a mágnes kapcsoló ténylegesen rákapcsolja a motorra a feszültséget. Általában ez így is van, ha gerjesztjük a mágnes kapcsolót. Azonban ha a motor túlterhelése miatt a bimetálos hővédelem működik, akkor hiába adunk feszültséget a PLC kimenetén a mágnes kapcsolóra, mégsem működik a motor. Ezért a PLC kimenetéből nem szokás a motor állapotára közvetlenül következtetni, mert ez akár balesetek okaként is szerepelhet. Minimum a mágnes kapcsoló egy segédkontaktusát szokás a motor működésjelzéseként felhasználni, de egyes esetekben a forgásérzékelő alkalmazása sem indokolatlan. Személy szerint az ismeretek hiánya miatt nem tudom értékelni, hogy a leírásban szereplő berendezések vonatkozásában mennyire hozható analógiába a feltételezés a motor példában leírtakkal. A MAIN szegmens (a 280-ik program sorban) meghívja a pr_relateinputs programot. Ennek a programnak az első néhány sorát láthatjuk az alábbi ábrán.

93 93 Ez a program a bemeneti változók értéke alapján, a logikai kapcsolatoknak megfelelően képezett globális (kimeneti) változók értékéből, a fizikai kimenetek konkrét (FALSE,TRUE) értékét állítja elő. Mit csinál a MAIN programunk az utoljára említett két programrész hívása közötti programsorokban? Egyrészt átemeli a kezelői felületen megadott adatokat, üzemmód beállításokat, és ezekből, valamint a bemenő adatokból képezi a kimeneteket a beírt utasítások logikája szerint. A MAIN szegmens végrehajtása során az üzemmódtól függően a CASE utasítások több belépési pontján folytatódhat a végrehajtás.

94 94 Az üzemmódtól függő lépések az állomás működtetésének leírására szolgáló állomásvezérlő struktúra tartalmának módosítását jelenti. Ez a struktúra a Data ablakban lévő definíciók között található, és az alábbi szerkezetű. TYPE StationControl_Type : STRUCT strdata : StationData; boinitialized : BOOL := FALSE; boclearstation : BOOL := FALSE; END_STRUCT END_TYPE A struktúrán belüli állomás adtok struktúra ugyanezen helyről kiemelve, az alábbi szerkezetet mutatja. TYPE StationData : STRUCT (* Data for and from station *) Cmd : COMMANDS := sc_no_command; Result : RESULTS := sr_no_result; Position : ARRAY [1..6] OF LREAL; Offset : ARRAY [1..3] OF LREAL; SuppData : ARRAY [1..10] OF WORD; bapatterndata : ARRAY [1..120] OF BYTE; END_STRUCT END_TYPE Mint látható ezekbe a struktúrákba adatokat írhatunk, ami akár egy vezérlési lépésként is felfogható. A StationData struktúra Cmd eleme a struktúrába beírt parancs jellegét

95 95 tartalmazza. Az alábbi (a Data ablakban megjeleníthető) listából választható parancsmódok állíthatók. TYPE Commands : ( sc_no_command, sc_init_automode, sc_start_automode, sc_end_automode, sc_init_pass_mode, sc_start_pass_mode, sc_end_pass_mode, sc_init_testmode, sc_start_testmode, sc_end_testmode, sc_init_teachmode, sc_start_teachmode, sc_end_teachmode, sc_clear_teachmode, sc_start_homing, sc_drive_to_position, sc_do_teach_function, sc_function, sc_end_function, sc_process_patternline, sc_check_station ); END_TYPE Ezen struktúra kiértékelését, és végrehajtását követően, az eredményről a végrehajtást végző funkcióblokk a Result elemben adja meg a választ. Ezek lehetséges értéke. TYPE Results : ( sr_no_result, sr_ok, sr_nok, sr_wait, sr_wait_or_run_out ); END_TYPE A végrehajtáshoz kapcsolódó egyéb paramétereket a struktúra többi elemében adhatjuk meg. A program szerkezete azt sugallja, hogy a vezérlési feladat e struktúrában való megfogalmazását, tanuló üzemmódban lépésenként adhatjuk meg. A MAIN szegmens ez a részlete látható az alábbi ábrán.

96 96 A tanuló üzemmódban megadott értékek, a parancs jellege beíródik az ismertetett struktúra elemeibe.