Budapesti Műszaki és Gazdaságtudományi Egyetem Villamosmérnöki és Informatikai Kar Irányítástechnika és Informatika Tanszék
Önálló laboratórium (BMEVIIIA355)
Téma:
Eaton-Moeller PLC-k alkalmazástechnikája
Készítette: Lóth Viktória Neptun: FT6HW1 Konzulens: Kovács Gábor
Budapest, 2014
1
Tartalom 1. Tartalom
2
2. Az Eaton-Moeller PLC-kről
3
3. Fejlesztőkörnyezet
4
4. A feladatom
6
4.1. Gyalogátkelőhely jelzőlámpáinak vezérlése
6
4.2. Megjelenítés a kijelzőn
9
5. Értékelés
14
2
2. Az Eaton-Moeller PLC-kről A PLC olyan berendezés, melyet ipari folyamatok vezérlésére és szabályozására fejlesztettek ki. Analóg és digitális jelekkel dolgozik, programozása hagyományos PC-vel valósítható meg. Az eszköz processzora felel az operációs rendszer és a felhasználói program futtatásáért, a PLC működéséért. A PLC-k egyik legjelentősebb tulajdonsága, hogy egyszerűen és gyorsan programozható valamilyen magasabb szintű programnyelven.
EasyControl EC4-200 A feladatom elvégzéséhez easyControl EC4P-221-MTXD1-es típusú PLC-t használtam, mely egy kompakt PLC. 256 kByte programmemóriával és 16 kByte adatterülettel rendelkezik. Ennek a típusnak 8 db tranzisztoros kimenete van, 12 db digitális bemenete, melyből 4 használható analóg bemenetként is. 2 soros csatlakozóval rendelkezik, melyet a PC-vel való összeköttetésre lehet használni. Ezen kívül CANopen interfésszel is képes a PC-hez vagy más PLC-khez csatlakozni. Külső felületén egy mátrixos kialakítású 4 soros és 16 oszlopos kijelző található. Ezeken láthatjuk a PLC menüjét, adatait és beállításait, a felhasználói programtól függően. Ezen kívül láthatunk még 4 gombot, melyekkel a PLC beállításait lehet megvalósítani. Továbbá kurzor gombokkal rendelkezik, melyekkel a kurzor helyét változtathatjuk, elősegítve a megfelelő opció kiválasztását.
3
3. Fejlesztőkörnyezet EasySoft CoDeSys A PLC programozásához az easySoft CoDeSys nevű szoftvert használtam, mely megfelel az IEC 61131-3 szabványnak és egy komplett fejlesztői környezetet biztosít ezen eszközök programozásához. Az easySoft CoDeSys egy egyszerűen kezelhető, széleskörűen használható szoftver. Új projekt kezdésénél kiválaszthatjuk, hogy melyik programnyelvet szeretnénk használni. Ezek az IL, LD, FBD, SFC, ST és CFC nyelvek lehetnek. Továbbá kiválaszthatjuk azt is, hogy új programot, funkcióblokkot, vagy függvényt szeretnénk írni. A függvény azonos bemenetekre, mindig ugyanazt az értéket adja ki. Ezzel szemben a funkcióblokkok saját memóriával rendelkeznek, így képesek a korábbi állapotok adataira „emlékezni”. Tehát a kimeneti értékeket a bemeneten kívül a tárolt adatok is befolyásolhatják. A felhasználói program legmagasabb hierarchia szinten levő egységét a programok jelentik, melyek a többi POU-nak (programszervezési egységnek) is biztosítják a PLCperifériákhoz való hozzáférést. Célunknak megfelelő egység kiválasztása után a munkaterületen láthatunk egy 2 részre osztott ablakot. Felső része a változó deklarációs rész, alsó része pedig a programtörzs, ahol a program írásának helye található. Ezek alatt egy üzenetablak látható, melyen többek között a hibaüzenetek jelenhetnek meg. Az elkészült programot, a PLC-re való töltés nélkül futtathatjuk és szimulálhatjuk. A szimulációval tesztelhetjük a megírt programunkat úgy, hogy online módba váltunk. Ekkor az ablak felső részében és a programtörzsben megjelennek a változók aktuális értékei. A „Run” gombbal indíthatjuk el a programot. Ekkor megvizsgálhatjuk, hogy elvárásainknak megfelelően működik-e a kód, azonban a változtatáshoz ki kell lépni az online módból. A fejlesztőkörnyezet sokféle változót és adattípust használ, mint például: BOOL, BYTE, DWORD, INT, TIME, TIME_OF_DAY, DATE_AND_TIME, stb. Támogatja a matematikai függvényeket (SIN, SQRT) és az adattípusok közti konverzió megengedett, melyet a programírás során többször is felhasználtam. Ilyen például, a DATE_AND_TIME és TIME_OF_DAY a közti átalakítás: DT_TO_TOD. Ekkor egy dátum és idő formátumú típusból alakít csak egy napra vonatkozó értéket. Az ST nyelv A feladatot ST nyelven írtam, ami a Structured Text rövidítése, vagyis strukturált szövegű programnyelven. Ez egy magas szintű, blokkszervezésű nyelv. Megengedi az összetett utasításokat, a feltételes végrehajtást, vagy elágazást (IF-THEN-ELSE, CASE), továbbá támogatja ciklikus végrehajtást (FOR, WHILE, REPEAT) is. 4
Általam felhasznált szabvány funkcióblokkok és függvények A feladatom elvégzéséhez szükségem volt timerekre, vagyis időzítőkre. Ezek szabvány funkcióblokkok (FB-k), melyekből több fajtával is rendelkezik a fejlesztőkörnyezet. Ilyen a TON (Timer on delay), TOF (Timer of delay) és TP (Timer Pulse). TON, vagyis a bekapcsolást késleltető időzítő egy olyan funkcióblokk, melynek 2 bemenete és 2 kimenete van. Akkor indul el a számlálás, ha a timer egyik bemenetén (IN) igaz (true) értéket kap. A kimenete (Q) akkor válik igazzá, miután letelt a másik bemeneten (PT) kapott időérték. Így be lehet állítani egy PT idejű késleltetést. A második kimenet (ET) az indulástól eltelt időt mutatja. Ha ez nem érte el PT értékét, akkor a kimenet sem fog megváltozni. A TON timer idődiagramja az alábbi ábrán látható.
A TP olyan időzítő, melynek ha IN bemenetén true értéket kap, akkor PT hosszúságú ideig Q kimenete is igazzá válik, majd ezen idő leteltekor újra false értéket vesz fel.
Az időzítőkön kívül használtam még felfutóél érzékelésre alkalmas funkcióblokkot (R_TRIG). Ekkor a bemenetre (CLK) kötött érték, amint igaz lesz, kimenete (Q) egy pillanatra igazzá válik. Ez a funkcióblokk alkalmas a gombnyomások értékelésére.
5
4. A feladatom 4.1. Gyalogátkelőhely jelzőlámpáinak vezérlése Egy nem nagy gyalogos forgalmú átkelőhelyen az autóforgalom haladása érdekében nyomógombbal rendelkező gyalogátkelőhelyek vannak. Az átkelőhely lámpája csak akkor vált zöldre, ha a gyalogos a nyomógombbal jelezte az átkelési szándékát, ekkor felvillan a „Várjon” felirat is. Ha viszont ez nem történt meg, akkor végig az alaphelyzetben marad, mikor az autósoknak zöld, a gyalogosoknak pedig piros lámpájuk van. Az alábbi táblázatban láthatóak az egyes fázisokban a jelzőlámpák állapotai. Autó piros
Autó sárga
Alap
Autó zöld X
Gyalogos
Gyalogos
Késleltetési
piros
zöld
idők [s]
X
Gombnyomás után 2
Fázis1
X
X
2
X
2
Fázis2
X
Fázis3
X
X
5
Fázis4
X
Villogó
3
Fázis5
X
Fázis6
X
Éjszaka0 Éjszaka1
X
2
X
X
2
X
X
2
X
2
X
Éjszaka2
Villogó
Éjjeli időszakban
Éjszaka3
X
X
2
Alaphelyzetből indulva a gombnyomás után 2 másodperccel az autóút lámpája sárgára vált, majd újabb 2 s múlva pirosra vált. Ebben a helyzetben áll 2 másodpercet, majd a gyalogosok zöld lámpája felvillan. Ezen fázis végét a 3 másodpercig tartó villogó zöld jelzés mutatja, majd ezután a lámpa pirosra vált. Újabb 2 másodperc múlva az autósok lámpáján a piros és sárga jelzés lesz látható. Ekkor tér vissza újabb 2 s után az alaphelyzetbe. Előfordulhat, hogy egy gyalogos éppen ekkor ér az árkelőhöz és megnyomja a gombot. Annak érdekében, hogy az autósoknak semmilyen körülmények között ne kelljen folyamatosan várnia, alaphelyzetbe téréskor legalább 5 másodpercig szabad jelzést kapnak és csak ezután kezdődik el újra az átkelési folyamat. Mivel éjszaka sem a gyalogos, sem az autós forgalom nem jelentős, ezért ilyenkor csak sárga figyelmeztető villogás van érvényben, míg a gyalogosok semmilyen jelzést nem kapnak. Éjszakai módba a tesztpanelen egy kapcsoló segítségével lehet átváltani. Valójában a PLC a valós időt is nézi, 6
és a beállított paramétereknek megfelelően válthat át éjszakai üzemmódba. Ennek megvalósításához a SysLibRtc.lib könyvtárban található SysRtcGetTime függvényt használtam fel, amely a kiolvassa a számítógép szerinti valós időt. Mikor ebbe az éjszakai állapotba kerül, az aktuális helyzetnek megfelelően vált át. Ha az alap állapotban van, akkor szabályos forgalomleállítás érdekében a 0-ás éjszakai fázisba ugrik, ahol a gyalogosoknak piros, az autósoknak sárga jelzésük van. Ezután az 1-es éjszakai állapotba kerül, mikor 2 másodpercig minden jelzőlámpán a piros jelzés látható. Ezután lép be a teljes éjszakai üzemmódba, mikor a sárga villogás van érvényben. Ebből az állapotból a éjszakai gomb kikapcsolásával, vagy az éjszakai időszak lejárásakor lép ki, mégpedig úgy, hogy a harmadik éjszakai állapotba ugrik, mikor minden lámpa pirosat mutat. Végül a 6-os fázisba lép, mikor az autósoknak piros-sárga jelzésük van. Ha viszont nem alap állapotban van a rendszer, mikor megtörtént az éjszakai váltás, akkor végiglépked az egyes fázisokon, míg eléri az 5-ödik fázist, amikor minden lámpa piros. Ezután egyből az 1-es éjszakai állapotba lép és a fentiekhez hasonlóan fut tovább. Az egyes állapotok váltásai az alábbi ábrán jól láthatóak állapotgép formában. A szaggatott vonal, az éjszakai módba való lépést jelenti.
Az állapotgépet ST nyelven a PLC_PRG nevű vezérlőprogramban CASE szerkezettel valósítottam meg. Először bemenetként deklaráltam az nyomógombokat, és a PLC felületén található gombokat, kimeneteknek pedig a gyalogátkelőhely lámpáit adtam meg. Ugyanitt megadtam az egyes timereket, és segédváltozókat, melyek a feladat megoldásához szükségesek voltak. Itt adtam meg a timerek késleltetési idejéhez szükséges segédváltozók kezdőértékét is. Erre azért van szükség, hogy a későbbiekben képesek lehessünk ezeken változtatni. 7
A villogó zöld és sárga jelzéshez létre kellett hoznom egy funkció blokkot, amely a lámpák kibekapcsolását valósítja meg. Ez a Blink funkcióblokk, melynek egy bemenete (IN) és egy kimenete (Q) van. A villogás akkor indul el, ha az IN bemenetére igaz értéket kap. 2 időzítő szükséges hozzá, egy TP és egy TON. Mindkét timer PT bemenetére 0,5 s értéket adtam, így fél másodpercig aktív, majd fél másodpercig nem aktív a jelzés, létrehozva ezzel a fél másodperces villogást. Az alábbi rajzon láthatjuk a 2 timer kapcsolási rajzát és a Blink funkcióblokk működését. IF IN THEN Timer_tp(IN:=Timer_ton.Q, PT:=T#0.5s); Timer_ton(IN:= NOT Timer_tp.Q, PT:=T#0.5s); Q:= Timer_tp.Q; END_IF A TP IN bemenetére a TON Q kimenetét kötve és a TON IN bemenetére a TP negált Q kimenetét kötve kapjuk meg a váltakozást. A funkcióblokk Q kimenete a TP timer Q kimenete, ahogyan ez az alábbi diagramon is jól megfigyelhető.
1. Ábra: Gyalogátkelőhely tesztpanel
8
4.2. Megjelenítés a kijelzőn A feladatom második része az volt, hogy a megírt gyalogátkelőhely vezérlés a PLC kijelzőjén is láthatóvá váljék, mégpedig úgy, hogy az egyes lámpák állapotait mutassa. Ezen kívül a timerek időit, és az éjjeli üzemmódidejét is be lehessen állítani. A kijelzőn való megjelenítéshez a PLC_PRG program meghívja a Visualisation() programot. Ezen kívül implementálni kell az EC_Visu2.lib könyvtárat, mely tartalmazza az összes kijelzővel kapcsolatos függvényt és funkcióblokkot. A kijelzéshez felhasznált függvények és funkcióblokkok ismertetése A kijelző használatához először is engedélyezni kell a használatát a Disp_EnableDisplay () függvénnyel. Ennek 2 paramétere van, az xEnable, mely elérhetővé tesz, és az xDisableEscKey, mellyel le ehet tiltani az ESC gomb használatát. A kijelzőre íratásnak 2 módja is van, az egyik a Disp_DisplayPage, a másik a Disp_DisplayElement funkcióblokk használatával történik. Mindkét esetben regisztrálni kell a kiírandó elemeket. Ezt a feladatot Disp_RegisterVariable() függvény látja el. Disp_RegisterVariable(): A kijelzőn látható menüpontokat, timerek neveit, és a jelzőlámpa neveit globális változóként megadtam string típussal. g_Disp_String0: STRING:='T0:'; A Disp_RegisterVariable 3 paraméterrel rendelkezik. Elsőként meg kell adni egy string típusú változónevet, mellyel a későbbiekben hivatkozni lehet a regisztrált tartalomra. Ezután meg kell adni az elérhetőségét, hogy milyen változónév alatt találjuk a kiírandó paramétert. Ezt az ADR() függvény képes elérni úgy, hogy a paramétereként megadjuk a globális változót, vagy a program egyik változóját. Végül meg kell adni, a megjelenítendő elem típusát is. Disp_RegisterVariable('TI', ADR(g_Disp0_String1), DISP_TYP_STRING); Disp_RegisterVariable('TS0', ADR(g_Disp_String0), DISP_TYP_STRING); Disp_RegisterVariable('TV0', ADR(PLC_PRG.Timer_var0), DISP_TYP_INT); Disp_DisplayPage: Olyan 4 bemenettel rendelkező funkcióblokk, amelynek negyedik bemenete tartalmazza az egyes elemek részletes adatait. Ez az aElementDescription. []-jelben lehet megadni, hogy melyik elem adataira vonatkozzon. A regisztráláskor megadott névvel lehet rá hivatkozni, továbbá számos paramétert lehet beállítani ezen leírás segítségével. Itt lehet megadni, hogy az adott elemet melyik sorba és oszlopba helyezze. Ezek a byLine és byColumn segítségével történik. 9
Display_Page0.aElementDescription[1].sName:='TI'; Display_Page0.aElementDescription[1].byLine:=1; Display_Page0.aElementDescription[1].byColumn:=1; Például egy timer nevét és hozzá tartozó időértéket az alábbi módon szabtam testre. A már ismertetett módon regisztráltam és pozicionáltam a képernyőn a kiírandó időzítő nevét. Ezután a hozzá tartozó paramétert hasonló módon megadtam, viszont ennek leírásában beállítottam a szám digitjeinek számát, illetve a minimális és maximális értékét is. Itt szabható testre az engedélyezési tulajdonsága is, vagyis, hogy ki lehet-e választani az ALT gomb nyomása után, illetve hogy ennek a paraméternek meg lehet-e változtatni az értékét. Ezek a tulajdonságok az xEnable és az xInputEnable engedélyezésével vagy tiltásával állíthatóak. Display_Page1.aElementDescription[1].sName:='TS0'; Display_Page1.aElementDescription[1].byLine:=1; Display_Page1.aElementDescription[1].byColumn:=1; Display_Page1.aElementDescription[5].sName:='TV0'; Display_Page1.aElementDescription[5].byLine:=1; Display_Page1.aElementDescription[5].byColumn:=5; Display_Page1.aElementDescription[5].byDigits:=5; Display_Page1.aElementDescription[5].byPrecision:=0; Display_Page1.aElementDescription[5].diMinInputValue:=0; Display_Page1.aElementDescription[5].diMaxInputValue:=10000; Display_Page1.aElementDescription[5].xEnable:=TRUE; Display_Page1.aElementDescription[5].xInputEnable:=TRUE; Azt, hogy melyik Disp_DisplayPage típusú oldalunk legyen érvényben, azt az alábbi módon lehet beállítani. A funkcióblokk másik 3 bemenetét, az xEnable, xEanableInput és byNoOfElements paraméterrel szabhatjuk testre. Ha nem ezt az oldalt szeretnénk engedélyezni, akkor az előbbi 2 paraméternek false értéket kell adni. A harmadik paraméter jelöli a kijelzőre kiírandó elemek számát. Mivel egy példány ebből a funkcióblokkból maximum 12 elemet tartalmazhat, így ez a szám is maximum 12 lehet. Ez a paraméter csak az értékének megfelelő mennyiségű elemet engedélyez a kijelzőre. Display_Page1(xEnable:=TRUE, xEnableInput:=TRUE, byNoOfElements:=8); Disp_DisplayElement: A Disp_DisplayElement funkcióblokk is elemek kijelzőre való írásához használható. A felépítése részben hasonló a Disp_DisplayPage-hez. Ennél is egy regisztrált változóval lehet hivatkozni a kiírandó elemre, ugyanúgy sort és oszlopot lehet megadni. Viszont ez a funkcióblokk csak egy elemre vonatkozik, ezért minden kiírandó részre külön funkcióblokkot kell deklarálni. Az alábbi példán a lámpák állapotait megjelenítő oldalon az autósok piros lámpájának állapotát jelölő kódrészletet szemléltetem. Az aktív állapotot a * karakter jelöli, melyre V1-el lehet hivatkozni. Mikor a piros lámpa nem világít, akkor a kijelzőn sem jelenik meg a * jel. Mivel az első sor első oszlopánál 10
kezdődik az autósok piros lámpájára vonatkozó string (C_red), ezért az aktivitást jelző karaktereket a 6. oszlopba helyeztem. Így egy oldalon láthatóvá válik az összes jelzőlámpa működése. IF PLC_PRG.C_red=TRUE THEN Display_Element1.sName:= 'V1'; ELSE Display_Element1.sName:= 'V2'; END_IF; Display_Element1.byLine:=1; Display_Element1.byColumn:=6; A Disp_DisplayPage-hez hasonlóan engedélyezni kell ahhoz, hogy a képernyőn való megjelenés láthatóvá váljék. Ezt elemenként tehetjük meg úgy, hogy minden DisplayElement xEnable paraméterének true értéket adunk. Display_Element1(xEnable:=TRUE); SysRtcGetTime(): A SysRtcGetTime() függvény, ha bemenetére igaz értéket kap, akkor megadja a rendszer valós idejét. Ezt a mód kiírásához használtam fel. Mivel kapott eredmény DATE_AND_TIME típusú ezért létrehoztam
egy
segédváltozót
(real_time2)
TIME_OF_DAY
típussal,
és
típuskonverziók
felhasználásával átalakítottam a valós időt csak egy napra vonatkoztatva. real_time:=SysRtcGetTime(TRUE); real_time2:=DT_TO_TOD(real_time); A program felépítése Mivel a legtöbb képernyőn megjelenítendő változó neve és helye fix, ezért nekik elég egyszer értéket adni. Ezt úgy valósítottam meg, hogy létrehoztam egy bool típusú globális változót g_xFirstCycleAfterStartProgram névvel, és egy start eseményhez kötött programot, mely csak az indítás utáni első ciklusban fut le. Ekkor ez a változó true értéket kap, így a Visualisation() programban ehhez a feltételhez kötve, az első ciklus alatt regisztrálódik az összes adat, és beállítódnak a paraméterek. Ugyanebben az IF ágban a Disp_EnableDisplay engedélyezi a kijelzőt. Az IF ág végén a g_xFirstCycleAfterStartProgram változót átállítjuk false-ra. Minden kijelzőn látható laphoz tartozik egy-egy Disp_DisplayPage típusú oldal, és CASE szerkezettel létrehoztam az ezek közötti váltást. 6 oldal van, ezek a főmenü, melyből a 3 különböző opciót lehet elérni: időzítők értékei (3 oldal), státusz (1 oldal) és az üzemmód (1 oldal). Az oldalak között gombokkal lehet lépkedni. A nyomások érzékelését a főprogramban deklarált élérzékeny változók teszik lehetővé. Minden gombhoz példányosítottam egy R_TRIG funkcióblokkot, melynek kimenete mutatja, hogy mikor történt gombnyomás. Az üzemmód határidejeinek beállításakor megjelenített értéket mindkét esetben (a nappal kezdete és vége) 2 külön részre osztva lehet kezelni. A 2 részt „:” választja el egymástól. Első felén az órát, második felén a percet lehet beírni, ezért külön-külön változókkal kezeli a program. Az óra 1-es, 11
a perc 2-es sorszámmal jelölve. Mivel a kijelzőre nem lehet közvetlenül TIME típusú értéket kiírni, ezért
ezeket
DWORD
típusban
lehet
megadni.
A
TOD
típus
átalakításkor
viszont
milliszekundumokban számlál, ezért az órát meg kell szorozni 60*60*1000-rel, és a percet 60*1000rel, így megkapva a beírás utáni helyes értéket. Day_Start:=DWORD_TO_TOD(Day_Start1*60*60*1000 + Day_Start2*60*1000); Day_End:=DWORD_TO_TOD(Day_End1*60*60*1000 + Day_End2*60*1000); Az így kiszámított határértékekkel hasonlítja össze a valós időt és dönti el, hogy milyen üzemmódba kell kapcsolnia. Eszerint írja ki a kijelzőre a módot, és vezérli a jelzőlámpák világítását. A megvalósítás kinézete Futtatás indítása után a kezdőoldal jelenik meg elsőként. Ezen az oldalon 3 menü közül lehet választani. Ezek az időzítők késleltetési idejének beállítása, a státusz, amely megmutatja, hogy éppen melyik jelzőlámpa világít, és a mód, amely kiírja, hogy jelenleg éjszakai vagy nappali üzemmód van-e érvényben és ezen kívül ebben a menüpontban be lehet állítani a nappali üzemmód határait, melyeken kívül az éjszakai mód aktív. Az ALT gomb megnyomása után megjelenik a * karakter, amely a kurzor láthatóságát teszi lehetővé, ezzel segítve a kiválasztást, melyet az OK gombbal fejezhetünk be. Ekkor lép át a kiválasztott oldalra. Ha a TIME feliratot választjuk ki, akkor a timer értékek beállításához jutunk. Itt láthatjuk az összes időzítőt felsorolva úgy, hogy minden sorban egy neve található az addig beállított értékével. Mivel több időzítőt is felhasználtam, mint amennyi egyszerre elfér a kijelzőn, ezért a többi timer adatainak megtekintéséhez a P1 vagy P3-as nyomógomb nyilakkal lehet lapozni. Ekkor engedélyezi a kért DisplayPage-et, és láthatjuk a következő 4 időzítő adatait. Az ALT gomb megnyomásával megjelenik a kurzor az első engedélyezett helyen, amelyen a beállított érték változtathatóvá válik. A nyilak segítségével lehet a sorok között váltani. Az OK megnyomásával megjelennek a digitek, melynek számát a programban megadtuk. A P1 és P3 gombokkal lehet kiválasztani az egyes digiteket, és a P2 és P4 gombokkal pedig az értéket lehet megadni. Az ESC gomb megnyomásakor nem változik meg az eredeti érték és kilép a kurzor módból, viszont OK esetén átállítja az új értékre a paramétert és a kurzor tovább ugrik a következő engedélyezett adatra. Újabb ESC érzékeléskor visszalép a főmenübe.
12
A STAT menü megmutatja a jelzőlámpák pillanatnyi állapotát. A bal oldali oszlopban az autósok, a jobb oldaliban a gyalogosok jelzőlámpái szerepelnek. Láthatóvá válik, hogy melyik jelzőlámpa világít az adott időpillanatban, melyet a * karakter jelöl. Ehhez a menühöz Disp_DisplayPage és Disp_DisplayElement FB-t is használtam. A lámpák nevei
DisplayPage
elemeként
szerepelnek, míg a világítást jelző karakterek egyszerű elemekként. ESC nyomásával újra a főmenüt látjuk. A harmadik opció kiválasztásakor az üzemmód paraméterei jelennek meg, ahol a nappali mód határértékeit lehet beállítani. Ezt az oldal teljes mértékben a Disp_DisplayPage funkcióblokk valósítja meg. Az ALT gomb nyomása után megjelenik a kurzor és a megfelelő paramétert kiválasztva lehet átállítani az értékeket, melyek 2-2 digites DWORD típusban vannak meghatározva. Az OK megnyomásával lehet átállítani az értéket.
Amint
megtörtént
a
bevitel,
a
program
megvizsgálja, hogy a valós idő még az addigi határok között van-e, és ha nem, akkor másik üzemmódba vált. ESC gomb segítségével visszatérhetünk a főoldalra.
13
5. Értékelés Az önálló laboratórium során megismerkedtem a PLC-kkel. Sokat tanultam a számomra eddig ismeretlen ST nyelvről és az Eaton-Moeller PLC-k fejlesztőkörnyezetéről (easySoft CoDeSys). A feladat megoldása során számos ismeretet sajátítottam el a PLC-k használatáról és a közúti forgalomban alkalmazott jelzőlámpák vezérléséről. A laboratóriumban a gyalogátkelőhely modellezésére szolgáló tesztpanelen kipróbálhattam a megírt programot, mely az elvárásoknak megfelelően működött.
14
