This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong. {{ wiki:s7:rubik.png|Rubic-cube}} ====== Simatic S7 szoftver alapfogalmak ====== Amennyiben ön már programozott valamilyen magas szintű nyelven, kérem, felejtse el! A PLC programozás alapvetően más elveken nyugszik. Egy magas szintű nyelv ma jellemzően objektum orientált (OOP), ahol a programok lefutása jellemzően eseményekhez (events) van kötve, a program futásideje nem értelmezhető, hiszen a végrehajtás mindig valahol a kódon belül „kódorog”.\\ A PLC programok jellemzően (mert kivétel itt is van) teljesen szekvenciális lefutásúak, a futásnak ráadásul szintideje van, amit ha a kód nem tud teljesíteni, akkor a PLC leáll. A szintidő miatt az eseményvezéreltségnek lőttek -- és nincs is igazán értelme itt -- megszakítások kezelése lehetséges, de ezeket is meglehetősen egyedi megszorításokkal lehet alkalmazni. ====== A PLC programok szerkezeti elemei ====== A PLC bármely funkciójának ismertetése hasonlóan az angol nyelvtanhoz, meglehetősen ellentmondásos mutatvány tud lenni, hiszen itt is a rendhagyó esetek brutális mennyisége időnként kérdésessé teszi a szabályrendszer létét. Mindenesetre megkísérelem a csupasz szabályokat ismertetni, a kivételeket, extrákat és miegyebeket majd később fogjuk erre az egyszerű szerkezetre aggatni. A PLC gyártók emellett gondosan ügyelnek arra, hogy a programjaik ne legyenek átvihetőek se más gyártó (se újabb generációs) PLC-ire. Bár létezik a plcOpen kezdeményezés, azért a nagy gyártók ezt csak a maguk módján tartják be - ha csatlakoztak is ehhez, vagy hasonló kezdeményezéshez. A PLC-k szerkezeti elemei - eredeti funkciójuk hasonlóságából adódóan - nem nagyon tudnak eltérni egymástól, így a Siemens S7 definiciói alapul véve próbálom bemutatni ezeket az elemeket, és majd a későbbiekben ezt majd talán kiegészíteni gyártóspecifikus eltérésekkel és elnevezésekkel. {{ wiki:s7:baustein.png?128x150|Baustein}} ===== Baustein-ok ===== {{anchor:s7_baustein}} de: Bausteine, en: blocks Magyarra ezt a szót építőkövekként lehet(ne) fordítani, de ebből mindenki valami építészeti fogalomra asszociálna itthon. Az angol block kifejezés se sokkal szerencsésebb, mint a német eredeti, így maradok ennél. A Baustein-ok a program építőelemei, a PC-s fájlok analógiájára ez alatt is többféle funkciójú és tartalmú állomány értendő. == A baustein-ok fogalmába tartozó objektumok a Simatic környezetben == ^Baustein^jelölése (pl.)^jellemzése| | [[#ob|OB]] |OB1|A szervező (Organisations-) Baustein-ok tartalmazzák a főprogramot, innen kerülnek meghívásra a program további részei. A legfontosabb - és legalapvetőbb - az OB1.\\ Innen hívható Baustein-ok: FB, FC, SFB, SFC.| | [[#db|DB]] |DB10|Az adat Baustein-ok (Datenbaustein) adatokat tartalmaznak, melyeknek a struktúrája alapvetően kötetlen. Két változatuk létezik, a global és az instanz. Az istanz DB-k jellemzően valamely FB-hez vannak hozzárendelve.| | [[#fc|FC]] |FC11|A funkció programot tartalmazhat, mely paraméterekkel is felhívható, és kilépési paramétereket is tartalmazhat. Hívása OB-ből, FC-ből vagy FB-ből történhet.\\ Belső, lokális változói minden híváskor újra inicializálásra kerülnek.| | [[#fb|FB]] |FB12|Működése megegyezik az FC-vel, azzal a külömbséggel, hogy kétféle kokális változót is tartalmazhat. Lehet olyan változója, mint az FC-nél, hogy minden híváskor újra inicializálandó, és van olyan változótípusa, ami értéktartó.\\ Ezt egy hozzárendelt (instant) DB-vel éri el, ahová minden futás után menti az adott változókat, és ismételt hívás esetén innen tölti be azokat.\\ Paraméterek átvátelére és átadására ugyanúgy alkalmas, mint az FC.| | [[#sfc|SFC]] |SFC12|Zárolt rendszer FC (Systemfunction), mely adott célból hívható és paraméterezhető, de a kódja nem tekinthető meg (ergo nem is változtatható). A rendszerkönyvtárból hívható le.| | [[#sfb|SFB]] |SFB22|Megegyezik az SFC-vel, azzal a kiegészítéssel, hogy minden hívása esetén egy (instant) DB-t kell hozzárendelni.| | [[soft_s7#s7_udt|UDT]] |UDT21|Felhasználó által definiált valtozó (user defined type), melyet a többi változóhoz hasonlóan lehet alkalmazni.| | VAT |VAT3|Változók pillanatnyi státuszának a követésére / állítására alkalmas baustein.| ===== memória ===== de: Speicher, en: memory A memória egy PLC típusától függő méretű terület, melynek bármely részére szabadon hivatkozhatunk. Lehetőségünk van a maszkolásra is, azaz ugyanarra a területre többször, több formátumban is hivatkozhatunk. A hivatkozás lehet direkt és szimbolikus, a szimbólumokat egy e célra rendszeresített táblázatban kell rögzítenünk, típusmegjelöléssel és memóriaterület hivatkozással. Az S7 memória-definíciók összefoglalása [[hu:s7:valtozotipusok_es_ob_k#merker|itt található]]. A szoftveres "memória" hivatkozások alatt természetesen a felhasználó által elérhető munkamemóriát értjük. A memória fajtáinak (munka-, rendszer-, betöltő-) tisztázása a [[hard_basic#memoria|hardver alapok fejezetben]] található. A memóriát a németből átvett „merker” (jelölő) szócskával szoktuk illetni, mellé biggyesztve a hivatkozás típusát is, pl. merker-byte, merker-bit, merker-szó, merker-duplaszó. Hülyén néz ki, de megszokható. Jellemzően, ha valaki csak merker-t emleget, akkor egy bitet ért alatta. Memória hivatkozáskor - ha nem az alap bietet értjük rajta - akkor meg kell jelölni a hivatkozás hosszára utaló típusát. A memória címzés lehet byte alapú (pl. Siemens) vagy word alapú (pl. Omron). Byte-alapú címzés esetén a merkereket [**Byte.**0..7] formában, word esetén [**word.**0..15] formában címezhetjük. A memóriaterület mérete PLC függő, erre néhány (S7) példa: CPU 312: 128 byte, CPU 314: 256 byte, CPU 315-2DP: 2048 byte, CPU 317-2DP: 4096 byte. Fontos még a memória alkalmazása esetén szem előtt tartani a remanens (memória) terület hosszát. Ez az a terület, mely újraindítás esetén is megőrzi a tartalmát, azaz nem nullázodik. Ennek a beállítását Siemens esetén a HW-Konfig-ban, a CPU-ra kétszer kattintva a "Remanenz" ablakban ellenőrizheti. ^memória változótípus megnevezése ^hossza ^jelölésére példák ^szabályok az alkalmazására (Simatic S7)| |merker (merker-bit)| 1 bit | érvényes: **M 12.1 M 15.7** érvénytelen: **M12 M12.9 ** |A memóriát alapvetően byte-os tagolással lehet címezni, így a M [byte.bit] szintaktika esetén a 0 <= bit < 8 szabály érvényes.| |merker byte| 8 bit |**MB12 MB0**| | |merker szó\\ (merker word)| 16 bit 2 byte |**MW10 MW11**| | |merker duplaszó\\ (merker dword)| 32 bit 4 byte 2 word |**MD10 MD11**| | === Simatic S7 példák a memóriaváltozók alkalmazására === <code> // merker-bit muvelet U M 12.1 U M 12.3 = M 14.3 // merker-byte muvelet L MB 12 L MB 15 +I T MB 20 // merker-szo muvelet L MW 22 L MW 31 *I T MW 11 // merker duplaszo muvelet L MD 5 L MD 16 /R T MD 41 </code> ===== PAE, PAA ===== {{anchor:s7_pae}} {{anchor:s7_paa}} de: Prozessabbild der Eingänge, en: input process image, hu: bemeneti szignálkép\\ de: Prozessabbild der Ausgänge, en: output process image, hu: kimeneti szignálkép A PAE az összes bemeneti jel összességét jelenti, melyek valamelyik perifériától érkeznek a PLC-be, és az adott memóriaterületen tárolásra kerülnek. A PAA azt a memóriaterületet jelöli, ahonnan a kimenetek kerülnek kiírásra. A PAE/PAA mérete PLC-függő. ===== Ciklus ===== {{anchor:s7_ciklus}} de: Zyklus, en: cycle A PLC programok ezen a ponton térnek el teljesen a PC-s (meg egyéb) programozástól, itt ugyanis ciklikus programvégrehajtást kell futtatni ahhoz, hogy a bemeneti jelekre tudjon reagálni a program, és a kimeneteket is (ciklikusan) kiadja. A PLC-nként meghatározott maximális ciklusidő túllépése esetén a PLC hibaüzenettel STOP-ba megy. A PLC-knek a ciklusideje - egyes kezdő programozók vélekedésével szemben - nem csak a felhasználói program futását tartalmazza, hanem: {{wiki:s7:PAE_PAA_2.png?597x153|PLC cycle}} \\ - ciklusidő indítása - szignálképek kiadása a kártyákra / perifériákra - szignálképek beolvasása a kártyákról / perifériákról, PAE aktualizálása - felhasználói program futtatása - az operációs rendszer futtatása (ZKP/BeSy) - a CPU kivárja a (projektált) minimum ciklusidőt, és ennek leteltével zárja a ciklusidő mérést Ha sikerül programunkkal a ciklusidő keretein belül maradni, akkor a végrehajtás nagyjából a fenti séma szerint zajlik: {{wiki:s7:PAE_PAA.png?431x263|PLC cycle 2}} \\ - A bemenetekről a rendszer feltölti a PAE-t. - Megindul a program futása (jellemzően az OB1 végrehajtásával). - A programok olvassák a PAE-t és írják / olvassák a PAA-t. - A program futása lezárul. - A rendszer végrehajtja a PAA terület kiírását a perifériákra. A felhasználói program futása a ki- és bemenetek kezelésén kívül, egyéb operációs rendszer szintű műveleteket és kommunikációt is igényel. Ezek a feladatok úgy valósulnak meg, hogy a felhasználói program futását a CPU 1 ms-os időszeletekre osztja, és ezekben - mint a lenti ábra szemlélteti - valósítja meg a fenti funkciókat. {{wiki:s7:PAE_PAA_3.png?606x270|PLC cycle 3}} \\ === ZKP === de: Zykluskontrollpunkt A ZKP a ciklus végét jelöli, a rendszer itt értékeli ki a ciklusidőt, és amennyiben ez kisebb, mint a minimum ciklusidő, úgy addig vár ezen a ponton a végrehajtással, amíg ez az idő ki nem tellik. Az esetleg a felhasznälí program által létrehozott / törölt DB-k kezelése is itt történik meg. === Ciklusidő számítása === A felhasználói program futtatásán kívül is "foglal" ciklusidőt a PLC. Egyrészt egy alapterhelést (de: Grundlast), amit a belső inicializálásokkal használ el, és persze a szignálképek ([[#pae|PAE]], [[#paa|PAA]]) frissitése is eszi az időt. Ezeknek a hozzávetőleges számítását példázza a lenti szám&iaiacute;tás S7-31x-as PLC-re: * + alapterhelés * + bájtok száma a a 0.rack szignálképén x (A) * + bájtok száma a a 1. - 3. rack szignálképén x (B) * + szavak száma a DP szignálképén x (D) * + szavak száma a Profinet szignálképén (P) * + ZKP {{ wiki:s7:io_card.png?200x200}} ^Konst. ^Elemek ^CPU 312 ^CPU 314 ^CPU 315 ^CPU 317 ^CPU 319 | ^K|Alapterhetés|150 μs|100 μs|100 μs|50 μs|25 μs| ^A|minden byte a 0. rack-en|20 μs|20 μs|20 μs|15 μs|15 μs| ^B|minden byte a 1.-3. rack-en| |30 μs *|30 μs *|25 μs *|22 μs *| ^D|minden szó az integrált DP interface-en| | |0,5 μs|0,5 μs|2,5 μs| ^P|minden szó az integrált Profinet interface-en| | |0,5 μs|0,5 μs|2,5 μs| *: +20 μs minden rack után }===== Fizikai bemenetek / kimenetek ===== de: Eingängen / Ausgängen, en: inputs / outputs A fő feladata jellemzően a beérkező inputok feldolgozása és a kimenő outputok felügyelete. A jeleket a PLC (részben, de az egyszerűség kedvéért) un. i/o kártyákon kapja meg (bemeneti kártyák) és adja ki (kimeneti kártyák). Az i/o-k jellemzően lehetnek digitálisak (bitek) vagy analógok (word-ök), de például a digitális területet is olvashatjuk más formátumban (pl. EB : Eingang byte). A bemenetet angolul input, németül az Eingang szavakkal illetjük, a kimenet pedig output-tal illetve Ausgang-gal. A i/o egységek címkiosztását és a rendszer felépítését a HW Konfig programmal végezhetjük. A bemenetek beolvasása a [[#pae|PAE]] területre történik. A kimeneteket a PLC a [[#paa|PAA]] terület állása szeint vezérli ki. Az S7 fizikai be- és kimenet összefoglalása [[soft_s7#input|itt található]]. ===== Periféria be- és kimenetek ===== de: PEW:Peripherie-Eingangs-Wort,\\ PAW: Peripherie-Ausgangs-Wort,\\ en: PIW: periphery input word,\\ PAW: periphery output word A periféria be- és kimenetek direkt hozzáférést nyújtanak a központi egységre és a decentralizált egységre csatolt kártyákhoz. A perifériákon jellemzően az analóg jeleket kezeljük, az alapértelmezett periféria bemenet a PEW, kimenetként a PAW (Az analóg jeleket általában word-ön írhatjuk és olvashatjuk). A i/o egységek címkiosztását és a rendszer felépítését a HW Konfig programmal végezhetjük. A bemenetek beolvasása a [[#pae|PAE]] területre történik. A kimeneteket a PLC a [[#paa|PAA]] terület állása szeint vezérli ki. Az S7 periféria be- és kimenet összefoglalása [[soft_s7#p_input|itt található]]. ===== Logikai bemenetek / kimenetek ===== de: Schnittstelle - Eingängen / Ausgängen, en: interface - inputs / outputs {{ wiki:s7:local_var_pelda.png?219x297|interface - inputs / outputs}}A logikai be- és kimenetek alatt az FB-k és FC-k csatlakozóit értjük. Ezek néha egybeesnek a fizikai be- és kimenetekkel, de jellemzően inkább közvetlen paraméterátadási felületként alkalmazzuk ezeket a programok között, illetve merker-eken keresztül adjuk át ezeknek a paramétereket. Kicsit lejjebb, az [[#fc|FC, SFC]] bekezdésben látható egy példa, ahol a második oszlopban találhatók a direkt címek. Itt elég vegyesen látható E és A (fizikai be- és kimenet), M és DB (merker és adatblokk). Az jobb oldali példán látható egy FC interface-listája, ahol az IN csoportban a bemeneti, az OUT csoportban a kimeneti és az IN/OUT csoportban a be- és kimeneti interface-ek láthatók. Az IN/OUT állapotváltozókhoz jól használható interface típus, ahol a modul belső működésére hatással van a változó, de a modulból fel is lehet bírálni (:írni) azt. A TEMP-ről egy bekezdéssel lejjebb olvashat, a RETURN az FC-knél kötelező módon megadandó funkció-visszatérési értéket deklarálja. Ennek alapértelmezett elnevezése az oldalt is látható RET_VAL. \\ ===== lokális változók ===== de: Lokaldaten, en: local variables {{ wiki:s7:local_var_pelda.png?219x297|local variables}}A lokális változók az OB-ken és FC-ken és FB-ken belül definiált változók, melyeknek az érvényessége lokális, azaz csak az adott funkción belül léteznek, a funkcióból való kilépéskor értéküket elvesztik. Ha programunkban egy nem definiált lokális változót másolunk át a kimenetre, annak tartalma teljesen esetleges lesz. Az oldalsó ábrán egy FC lokális "TEMP" változója is látható WinCC_par_temp néven. Az FC-ben, mielőtt bármi műveletet is végzünk ezzel a változóval, mindenképpen inicializálni kell azt. Az S7 lokális változók összefoglalása [[soft_s7#local|itt található]]. \\ ===== DB ===== {{anchor:s7_db}} de: Datenbaustein, en: data block {{wiki:s7:hozzaferes.png|data block}} \\ A DB-ket a PLC-n a PC-s fájlok analógiájára hozták létre. A DB-k szeparált és előre meghatározott struktúra szerint felépített adatterületek. Két típusuk lehetséges, a globális és az instant DB. A **globális DB**-t jellemzően a programozó hozza létre, és univerzális célokra alkalmazza, míg az **instant DB**-t jellemzően az FB meghívás generálja, és jellemzően az instant DB az adott FB-hez köthető. A két DB típus AWL-ben "átfordítható", azaz a program futása közben gobális DB-ből csinálhatunk instant DB-t, és fordítva. Az S7 periféria DB típus összefoglalása [[soft_s7#db|itt található]]. \\ ==== instant DB ==== {{ wiki:s7:fb_interface_pelda.png?148x220|instant DB}} en: instant DB, de: instanz DB Az instant DB-t jellemzően programozás közben hozzuk létre, amikor egy FB felhívásakor megadunk egy DB-t, melyet a szerkesztő az FB-ben meghatározott interface-listával inicializál. A jobb oldali példán egy FB interface deklarációja látható. Az FC deklarációtól csk a STAT csoporttal tér el, ebben a csoportban lehet azokat a változókat definiálni, melyek az FB-ből kilépve is megőrzik az értéküket úgy, hogy az FB-hez rendelt DB-ben letárolásra kerülnek. A TEMP csoport változói - ugyanúgy, mint az FC változói - kilépés után nem őrzik meg értéküket, meghívás esetén kezdeti értékük bizonytalan. A TEMP csoport változói értelemszerűen nem kerülnek be az instant DB-be. Nézzük végig lépésről lépésre az instant DB létrehozását az FB meghívásán keresztül. === instant DB létrehozása FB hívással === {{wiki:s7:instant_db_1.png?586x250|instant DB generating}} \\ Amikor a példa szerinti FB50-et felhívjuk, egy DB-t is mellé kell rendelni. (Az FB50 interface listája egy képpel feljebb, jobb oldalon látható). Amennyiben az FB még nem létezik, a fenti kérdésbe fogunk belefutni, melyre - akár gondolkodás nélkül is - JA-val válaszolhatunk. {{wiki:s7:instant_db_2.png?586x145|instant DB generating 2}} \\ Az editor ilyenkor létrehozza a DB-t, és az FB-hez meghatározott interface-eket felhajítja. Az interface-ekhez nem kötelező változót hozzárendelni - akár így is maradhat, mivel a rendszer feltételezi, hogy ha nem itt, akkor direkt a hozzárendelt DB változóiban kerülnek a paraméterek átadásra / változtatásra. Ezzel párhozamosan a DB tartalma így alakul: {{wiki:s7:instant_db_3.png?677x223|instant DB generating 3}} \\ A szerkesztő a DB-be szerkeszti a logikai be- és kimeneteket, a STAT változókat, de a TEMP-et nem. (Az IN_2 egy ARRAY) Az S7 periféria DB típus összefoglalása [[soft_s7#db|itt található]]. Amennyiben az FB-ben az alábbi csoportokban változás áll be: IN, OUT, IN/OUT, STAT. Ilyenkor a mellérendelt DB-t is érdemes újradefiniálni, és még az FB előtt letölteni. Enélkül, ha bővült az FB változó-indexe, akkor az ki fog mutatni a DB-ből, ami programozói hibát eredményez. ===== FC, SFC ===== {{anchor:s7_fc}} {{anchor:s7_sfc}} de: Funktion / Systemfunktion,\\ en: function / system function A funkció strukturált programozás egyik alapeleme. Az FC rendelkezhet bemeneti, kimeneti paraméterekkel és lokális (belső) változókkal, jellemzően egy funkciót tartalmaz (pl. Motor FC). Speciális esete az SFC (Systemfunktionen), mely egy előre megírt célfunkció, melyet az alapkönyvtárban találhatunk meg. A funkció lezárásával a lokális változóit „elveszti”, amennyiben a kimenetet az FC-ben nem definiáltuk vagy olyan lokális változót másoltunk ki a kimenetre, melyet a programban nem inicializáltunk, akkor a kimenet tartalma bizonytalan lesz. Hívása OB-ből, FC-ből vagy FB-ből történhet - amennyiben paramétereket határoztunk meg, úgy ezeket a hívó oldalon (kiadni, fogadni) kezelni kell. {{wiki:s7:fc_pelda_1.png?740x230|call function S7}} \\ példa egy FC paraméterekkel hívására ===== FB, SFB ===== {{anchor:s7_fb}} {{anchor:s7_sfb}} de: Funktionsblock / Systemfunktionsblock,\\ en: function block / system function block Funkciós baustein vagy funkciós blokk. Ez egy „emlékező funkció”, ugyanis minden FB-hez hozzá kell rendelni egy instant DB-t, melybe az erre a célra kijelölt változóit elmenti. Ebből is létezik az SFB (Systemfunktionsbausteine), melyet szintén az alapkönyvtárból tudunk előkaparni. A DB-ben eltárolásra nem kerülő változók (TEMP) az FC lokális változóihoz hasonlóan viselkednek. Hívása OB-ből, FC-ből vagy FB-ből történhet - amennyiben paramétereket határoztunk meg, úgy ezeket a hívó oldalon (kiadni, fogadni) kezelni kell. {{wiki:s7:fb_pelda_1.png?515x393|call functionsblock S7}} \\ //példa egy FB paraméterekkel hívására// A fenti példán egy (PID) FB hívása látható. Kritikusabb szemlélő rögtön eldörmögheti az orra alatt, hogy "nah, ez is megdolgozott a pénzéért", mivel túl sok paraméter nincs kitöltve, és akár igaza is lehet. Viszont legfelül, a hívásnál látható a DB642, és annak is érdemes utánanézni, hogy esetleg a paraméterezés nem közvetlenül a DB-be történik, ugyanis ennek a lehetősége is nyitott. (Egyébként, de, a DB-be kerülnek a paraméterek, mert így, közvetlenül egyszerűbb a megjelenítési rendszerből átvenni / illetve oda átadni ezeket, köztes változó alkalmazása nélkül). Így - talán - ezen a példán keresztül sikerül szemléltetnem, a PLC programban nem is olyan egyértelmű az, ami annak látszik. Amennyiben az FB-ben az alábbi csoportokban változás áll be: IN, OUT, IN/OUT, STAT. Ilyenkor a mellérendelt DB-t is érdemes újradefiniálni, és még az FB előtt letölteni. Enélkül, ha bővült az FB változó-indexe, akkor az ki fog mutatni a DB-ből, ami programozói hibát eredményez. ===== OB ===== {{anchor:s7_ob}} de: Organisationsbausteine, en: organisation blocks Organisationsbausteine (szervezkedő építőkövek?). A PLC a betöltött OB-kat hívogatja minden ciklusban (prioritás --sorrendben), és az innen meghívott FC-k és FB-k kerülnek végrehajtásra, természetesen hívási sorrendben.\\ Az OB-knek [[hu:s7:valtozotipusok_es_ob_k#S7 OB-k teljes jegyzéke, leírással|sok típusa létezik]] (vannak, melyek időközönként, mások eseményekre -- például programozói hiba esetén -- kerülnek meghívásra). ==== OB1 ==== Az alap-OB, melynek a prioritása jellemzően a legalacsonyabb. Ez azt jelenti, hogy a magasabb prioritású OB-k ennek a futását megszakítják. Addig, amíg a többi OB indítása valamely feltételhez van kötve (időzítés, esemény bekövetkezése), az OB 1 folyamatosan futtatásra kerül. Amennyiben a programunk csak az OB1-ből áll, és más OB nem kerül meghívásra a ciklusidő kiosztás az alábbi ábra szerint alakul: {{wiki:s7:ob_1.png?637x131|running OB1}} \\ Az ábákon PP-vel a PLC-processzt jelölöm. Az OB1-ben, mint az fent látható, a program futása folyamatos, de annak sűrűsége és ciklusideje a kód hosszától függ, egyedileg nem állítható (..alapból). ==== időzített OB-k ==== de: Weckalarm-OBs Ezeknek a listája összegezve [[hu:s7:valtozotipusok_es_ob_k#S7 OB-k teljes jegyzéke, leírással|itt található]]. Ezeknek az OB-knak az indítása időraszterhez van kötve. A lenti ábrán az időzített-OB-k beállítási felülete látható - nem túl széles paraméterezési lehetőséggel. Ez azért van, mert ellenben az S7-400-as PLC sorozattal, ahol jellemzően ezek a beállítások eszközölhetők és az OB-k használhatók, az S7-300-as PLC-ken általában csak az OB35 használható, fix prioritással, csak az időzítés állítható. {{wiki:s7:ob_k_allitasa.png?526x450|CP 315 OB descriptions}} \\ Amennyiben a teljes programunkat az OB35-ből hívjuk, és az OB1-et nem használjuk (ezt a bugyuta opciót a CFC alapból megajánlja), az alábbi futásképet kapjuk eredményként. {{wiki:s7:ob_2.png?663x131|running OB35}} \\ Látható, hogy a fix időnkénti indításnak "köszönhetően" jelentős mennyiségű üresjárat alakult ki. Az időzített OB-ket jellemzően csak speciális műveletek szűk köréhez szokás hasznáni, ahol a hívás-sűrűség fontos. Ilyen például a szabályozók (főleg a PID-ek) hívása. {{wiki:s7:ob_3.png?663x131|running OB1 - OB35}} \\ A fenti példán ez az eset látható. Az OB1 fut, ahogy sikerül neki, és időnként (az alap 100 ms-onként) az OB35 megszakítja a futását. ==== A többi OB ==== A többi OB futását jellemzően valami esemény váltja ki - ezek eseményvezéreltek. Az események nagy része hiba, ezeknek a - nem túl részletes, inkább bemutató jellegű bemutatását [[hu:s7:valtozotipusok_es_ob_k#ob|itt találja]]. Itt [[hu:s7:valtozotipusok_es_ob_k#ob121|megtalálható]] az OB121 is, az oldal címadója, mely akkor aktiválódik, ha programozói hiba lép fel. Ha az adott OB nincs letöltve a PLC-re, az STOP-ra fut - kínos. ===== Simatic S7 programozási lehetőségek ===== {{wiki:s7:S7_prg_lehetosegek.png?626x381|S7 program languages}} \\ A Simatic fejlesztői rendszere -- hasonlóan más fejlesztői környezethez -- több programozás technikát is megenged. Ezek alapból a [[#_KOP_(Kontaktplan)|KOP (Kontaktplan)]], [[#_FUP|FUP (Funktionsplan)]] és az [[#_AWL|AWL (Anweisungsliste)]]. Az "alap" programnyelv az S7 Simatic környezetben az AWL. Az AWL részben átkapcsolható KOP vagy FUP nézetbe, a KOP, FUP nézet viszont minden esetben AWL-re váltható. Az SCL egy pascal-szerű, magas szintű nyelv, ami egy compiler programmal AWL kódba forgatható át. Az SCL kód és AWL hozzárendelés a compiler dolga, és minaddig ez meg is valósítható (pl. a PLC státusz az SCL kódban megjeleníthető), amíg az eredeti SCL kód rendelkezésre áll. Az eredeti SCL kód nélkül az AWL forrás nem forgatható vissza, így például a PLC-ről való közvetlen letöltés ebben az esetben is csak (egy meglehetősen kusza) AWL-t eredményez, forrás SCL-ek nélkül. A CFC egy projektáló környezet, ahol a létrehozott FC-ket és FB-ket lehet felhívni és paraméterezni egy grafikus környezetben. A projektet a program SCL forrássá alakítja, majd innen kerül AWL formába tovább kompilálásra. A Symboltabelle (inkább nem fordítom a magyar szimboltáblázatra, mert szerintem az eredeti német azonosítás szélesebb körben elterjedt) egy hozzárendelési táblázat, ahol az abszolut címekkel rendelhető azonosítókhoz (FB-k, FC-k, I/O-k, Merkerek, stb..) lehet szimbolikus nevet és kommentárt rendelni. Ez a szimbólikus megnevezés a szerkesztőkörnyezet minden editorában felhívható, megjeleníthető. A szimbólumokat a compiler az MC7 kódba nem viszi tovább, így a PLC-ről visszafejtett kódok szimbólum-hozzárendeléseket nem tartalmaznak (és persze ennek hiányában nehezen értelmezhetők). ==== MC7 ==== {{anchor:s7_mc7}} en: machine code (S)7 A PLC kód letöltése egyben a lefordítást is jelenti a Step7 esetén. A letöltött MC7 kód egy - a PC-s .exe kódra hasonlító - , a processzor számára közvetlenül végrehajtható gépi kód. Ez a kód a PLC-ről AWL formába visszatölthető - ha nincs lock-olva, de a szimbólikus tartalom hiánya jelentősen csökkenti ennek az élvezeti értéket. <code> ...... // MC7-kód 0x 65, 0x 00, // MC7-kód Baustein-ende 0x 01, // ?? 0x 0A, 0x 00, // Bausteinnummer low+high hier 10 0x 04, 0x 00, // Länge der Parameter in Byte hier 4 0x 00, 0x 00, // ?? 0x bb, 0x cc, // 1. Parameter 0x 02, 0x 01, // 2. Parameter 0x vv // ?? 0x 02, 0x 00, // Anzahl Netzwerke low+high 0x 08, 0x 00, // Länge NW 1 0x 0C, 0x 00, // Länge NW 2 </code> //péda az MC7 kódra// ===== AWL, KOP, FUP ===== {{ wiki:s7:kop_fup_awl_valt.png?211x223|AWL / KOP / FUP}} Az AWL, KOP és FUP voltaképpen nem külön programnyelvek, hanem gyakorlatilag ugyanannak a tartalomnak a külömböző változatai. Az összesnek az alapja az AWL, de néha egy-egy összetett és - és nem műveletnek egy átláthatóbb nézetét adhatja a KOP vagy FUP. A nézetek átkapcsolását az editorban, az Ansicht pont alatt teheti meg - mint az a jobb oldali képen is látható. {{wiki:s7:main_clip_image003.jpg?328x373|AWL / KOP}} \\ A programunk természetesen (?) lehet „vegyes felvágott”, azaz a programozási technikákat ötvözhetjük is egymással, de ez a technika -- magunk között szólva -- nem tesz jót a megítélésünknek. A kombinálást a fejlesztői rendszer sem támogatja, de nagyon sok olyan művelet van, amit a bal oldali példával élve, nem lehet KOP-ban megjeleníteni, ezért ezek a részek AWL-ben íródhatnak csak. (A bal oldali programban az első két sor egy Word másolásáról szól, ezt a műveletet a KOP nem tudja megjeleníteni, ezért az egész network-öt AWL-ben hozza fel.) <WRAP center round info 60%> Érdekesség, hogy például a 300-as „F” (Fail-safety) program biztonsági részét csak KOP-ban és/vagy FUP-ban lehet írni, az AWL-t nem kedveli. (Illetve van egy, un. F-AWL program, de ez már egy másik bolygó..) </WRAP> ==== KOP / LAD ==== de: KOP (Kontaktplan), en: LAD (Ladder logic) Talán a leggyakrabban felbukkanó programozás technika. Vannak olyan fejlesztői környezetek, ahol más lehetőség nincs is a programozásra. Óriási előnye, hogy gyorsan áttekinthető, és a logikája könnyen követhető. A lenti ábrán egy példát mutatok be, ahol a nyitott kontaktusok az ÉS, a zártak pedig az ÉS NEM jelentéssel bírnak. Baloldalról indulnak az ágak, és minden egyes új ág egy VAGY kapcsolatot jelent. Érdemes a rajzot a többi programkezelési móddal is összevetni. A kezdő programozók szívét leginkább ez a technika dobogtatja meg, de a rutin kialakulásával egyre inkább csak akadályozza a KOP alkalmazása a PLC teljes körű megismerését, ugyanis nagyon sok utasítás a KOP-ból nem érhető el. {{wiki:s7:kop_pelda_1.png?607x502|KOP (Kontaktplan) / LAD (Ladder logic)}} \\ ==== FBS / FUP ==== de: FUP (Funktionsplan) vagy FBS (Funktionsbausteinsprache) \\ en: FBD (Function block diagram) \\ hu: funkcióblokk nyelv A funkcióblokk nyelv (FBS) az EN 61131-3 (IEC 61131-3) által a PLC-k programozásához definiált öt nyelv egyike. Ezt gyakran funkcionális diagramnak (FUP) is nevezik, különösen a Simatic Step7 környezetben. Ez a grafikai programozási nyelv a Boole algebra logikai szimbólumrendszerét használja kvázi programozásra. A FUP-ra is vonatkozik az a kitétel, mint a KOP-ra, hogy sok utasítás nem írható le itt sem AWL vagy SCL nélkül. {{wiki:s7:fup_pelda_1.png|FUP (Funktionsplan) / FBD (Function block diagram)}} \\ ==== AWL / STL ==== de: AWL (Anweisungsliste), en: STL (Statement list) És végül, de nem utolsó sorban bemutatom az AWL-t, a kezdő programozók rémálmát. Átláthatóságával nem könnyíti meg a programozók életét, de legalább -- ha a program írója nincs igazán tisztában a parancsok prioritásával -- pokollá teszi azt.\\ Úgy érzem, elérkezett a pillanat, hogy elővezessem kedvenc -- AWL-re mindenképpen igaz -- beköpésemet, miszerint **„A program nem szándékaid, hanem utasításaid szerint működik”**. (Gyengébbek kedvéért, az idézet NEM tőlem származik, HANEM számomra - nekem is kedvenc, vagy mi. Szerintem nyelvtanilag ez így helyes). Az AWL-t meg kell szokni, főleg azért mert sok esetben megkerülhetetlen. Némi rutinnal már csak ritkán (minden network-ben csak egyszer-kétszer) okoz meglepetéseket, és még több rutinnal igazán hatékony eszközzé válik a programozáshoz. Az AWL a Simatic S7 fejlesztő rendszer legalacsonyabb szintű, alap fejlesztő programozási nyelve. Szerkezete leginkább a PC-s környezetbeli asszembler (en: assembly) nyelvre hasonlít. A magasabb szintű S7 nyelvek, például a pascal-szerű SCL, vagy az SCL-re épülő chart jellegű CFC a programokat - beépített fordítóprogramok segítségével - első lépésben AWL-be forgatja be, és csak ezt követően tölti le (ajánlja letöltésre) a PLC-re. {{wiki:s7:awl_pelda_1.png?586x556|AWL (Anweisungsliste)/ STL (Statement list) }} \\ Két fontos dolog abszolut kezdőknek: - Az új Netzwerk nem jelenti azt, hogy az előző netzwerk-től szeparálódik a tartalom. Ez voltaképpen csak egy szerkesztési lehetőség, az előző Netzwerk eredménye (VKE-je) "áthúzodik", ha az előzőleg nem lett lezárva. - Új Netzwerk beillesztése: Ctrl-R. Az S7 változótípusai és OB-i [[hu:s7:valtozotipusok_es_ob_k|ebben a fejezetben]] kerülnek bemutatásra. Az S7-AWL teljes utasításkészletének az ismertetését [[hu:s7:awl_leiras|itt találja]]. ===== Kódolástechnikák ===== ==== BCD ==== {{anchor:s7_bcd}} A [[hu:comm:comdict#bcd|BCD]]-ben a 0-9-ig decimális számokhoz egy-egy 4 bites hozzárendelés kapcsolódik, a lenti táblázat szerint, így 1 BYTE-on 2 számjegy ábrázolható. (A BCD alatt egészen konkrétan a BCD-8421-et értjük). ^ **decimális érték** ^ **BCD-8421-szám** | | 0 | 0000 | | 1 | 0001 | | 2 | 0010 | | 3 | 0011 | | 4 | 0100 | | 5 | 0101 | | 6 | 0110 | | 7 | 0111 | | 8 | 1000 | | 9 | 1001 | ^**fel nem használt kombinációk**^| | 10 | 1010 | | 11 | 1011 | | 12 | 1100 | | 13 | 1101 | | 14 | 1110 | | 15 | 1111 | A BCD nem túl hatékony tárolási mód, hiszen, mint a fenti táblázat második részéből is kiderül, a 4 biten kódolható 16 jelből csak 10-et használ fel. Egy szó hosszon 4 jelet tárolhatunk (0-9999), míg ez az érték a szintén 16 bites INT esetén : -32.768 - +32.767. Jellemzően szegmens-kijelzők esetén és a régi, Simatic S5 típusú változók esetén szokás alkalmazni. ==== Kettes komplementer képzés ==== {{anchor:s7_kettes_komplementer}} A [[hu:comm:comdict#kettes_komplementer|kettes komplementer]] képzés a rettenetes elnevezés ellenére nem bonyolult eljárás. Az [[hu:s7:valtozotipusok_es_ob_k#int|INT]] és [[hu:s7:valtozotipusok_es_ob_k#dint|DINT]] típusoknál alkalmazzuk. Vegyük lépésről lépésre: - Adva van egy ábrázolandó számértékünk (pl. -10) - Ezt akarjuk INT-be leírni. - Ha a szám pozitív, egyszerűen leírjuk binárisan, és kész is vagyunk. - Ha nulla, szintúgy nincs teendőnk. - Ha negatív, akkor adjon hozzá egyet. (-10 » -9). - Írja le a számot (az előjellel ne foglalkozzon a továbbiakban) binárisan: (0000_0000_0000_1001). - Forgassa át az összes bitet (0 » 1, 1 » 0) . (1111_1111_1111_0110). - Ennyi. Néhány példa, hogy a technikát kissé //„be tudja járatni”//: ^ Szám\\ (decimális formában) ^ INT\\ (bináris formában) | | 100 | 2#0000_0000_0110_0100 | | 10 | 2#0000_0000_0000_1010 | | 2 | 2#0000_0000_0000_0010 | | 1 | 2#0000_0000_0000_0001 | | 0 | 2#0000_0000_0000_0000 | | -1 | 2#1111_1111_1111_1111 | | -2 | 2#1111_1111_1111_1110 | | -10 | 2#1111_1111_1111_0110 | | -100 | 2#1111_1111_1001_1100 | A kettes komplementer képzést az alábbi típusok alkalmazzák: * [[hu:s7:valtozotipusok_es_ob_k#int|INT]] * [[hu:s7:valtozotipusok_es_ob_k#dint|DINT]] * [[hu:s7:valtozotipusok_es_ob_k#time|TIME]] ==== Lebegőpontos számábrázolás ==== {{anchor:s7_lebegopontos}} Először az IEEE Standard for Binary Floating-Point Arithmetic (IEEE 754-1985) definiálta a lebegőpontos számok fogalmát - lassan 30 éve. Legutoljára ezt az IEEE 754-2008 írta felül, ezt a szabványt alkalmazza a Simatic [[hu:s7:valtozotipusok_es_ob_k#real|S7 REAL]] típusa is. A szabvány leírja az egyszeres pontosságú (single-precision) 32 bites és kétszeres pontosságú (double-precision) 64 bites számokat, valamint a legalább 43 bites kibővített egyszeres (single-extended precision) és a legalább 79 bites kibővített kéteszeres (double-extended precision) pontosságú változókat. A széles skála ellenére csak a 32 bites single REAL a szabványos típus, a többi opcionálisan alkalmazható. A bitek számozása a lebegőpontos típusban (is) jobbról balra történik, a változó teljes hosszában. {{wiki:s7:lebego1.png|Lebegőpontos számábrázolás}} \\ Gyakorlatilag a számábrázolás úgy működik, hogy a számábrázolást a változó a mantissza részben, míg a hatványrészt a kitevő részben tárolja. Minél nagyobb vagy kisebb egynél a hatványrész, a mantissza pontossága egyre inkább elvész. Magyarul (1-től) minél nagyobb vagy kisebb számokat ábrázolunk a típusban, annak a pontossága annál alacsonyabb lesz. <WRAP center round important 60%> Számláló (léptető) funkcióra például nagy számok esetén nem érdemes használni a REAL típust, mert ha a kitevő elér egy magasabb értéket, a mantissza helyiértékei megemelkednek, így hiába próbáljuk ennek az értékét például eggyel növelni vagy csökkenteni, a mantissza nem fog változni, azaz a REAL meg sem fog "rezzenni." </WRAP> A kitevő a rendelkezésre álló területen kettes komplementer szerű képzéssel kerül letárolásra, így a megadott kitevő értéket minden esetben a (2<sup>e − 1</sup>) − 1 képlet eredményével kell korrigálni, ahol az e a kitevő hossza bitben. Így például, ha e=7 és a kitevő hossza 8 bit, akkor értéke: 7 + (2<sup>8 − 1</sup>) − 1 = 7 + 128 - 1 = 134. Jellemzően a kitevő alapja a 2 - azaz a kitevőn a kettes számrendszer adja, de több esetben a kitevő alapja a 10, így tizes számrendszerbeli az ábrázolás. Az ábrázolt érték az alábbi képlettel fejezhető ki: {{wiki:s7:lebego2.png?561x26}} \\ ahol * az előjel ha 0 bit, akkor az ábrázolt érték pozitív vagy +0 * az előjel ha 1 bit, akkor az ábrázolt érték negatív vagy -0 * a kitevőt a fent leírt korrekcióval kell számolni, mely a kitevő hossztól függ, például 8 bit esetén 127. * a kitevő alapja deklaráció kérdése, és leginkább 2, de néha 10. * a mantissza minden esetben 1 ≤ m < 2, tárolása során az 1 levonásra kerül, így visszaszámoláskor a tárolt értékhez kell adni A tárolt lebegőpontos számértékek speciális esetei * Ha a kitevő 0, és a mantissza is 0, akkor az ábrázolt érték ±0 * Ha a kitevő 2<sup>e</sup> - 1 és a frakció 0, akkor az ábrázolt érték végtelen * Ha a kitevő 2<sup>e</sup> - 1 és a frakció nem 0, akkor az ábrázolt érték érvénytelen számérték (NaN - not a number) A lehetséges esetek összefoglalása ^típus ^kitevő ^mantissza | |nulla|0|0| |denormalizált számérték|0|nem 0| |normalizált számérték|1 -től 2<sup>e</sup> − 2 -ig|mindegy| |végtelen|2<sup>e</sup> − 1|0| |NaN (érvénytelen számérték)|2<sup>e</sup> − 1|nem 0| egyszeres pontosságú single REAL A single-REAL 32 bit hosszú, az előjel hossza 1 bit, a kitevő hossza 8 bit, a maradék 23 bitet pedig a mantissza foglalja el. A tárolt kitevőt itt is a (2<sup>e − 1</sup>) − 1 képlet szerint kell korrigálni, mely a 8 bit hossz esetén 127. Az feljebb már ábrázolt képlet szerint: {{wiki:s7:lebego2.png?561x26}} \\ ahol * az előjel ha 0 bit, akkor az ábrázolt érték pozitív vagy +0 * az előjel ha 1 bit, akkor az ábrázolt érték negatív vagy -0 * a kitevő korrekció 127. * a kitevő alapja 2. néhány fontosabb, single REAL ábrázolt érték ^típus ^előjel ^kitevő ^kitevő +\\ korrekció ^kitevő ^mantissza ^ábrázolt érték | |nulla| 0 |-127| 0|0000 0000|000 0000 0000 0000 0000 0000|0.0| |negatív nulla| 1 |-127| 0|0000 0000|000 0000 0000 0000 0000 0000|−0.0| |egy| 0 |0| 127|0111 1111|000 0000 0000 0000 0000 0000|1.0| |mínusz egy| 1 |0| 127|0111 1111|000 0000 0000 0000 0000 0000|−1.0| |legkisebb denormalizált érték| * |-127| 0|0000 0000|000 0000 0000 0000 0000 0001|±2<sup>−23</sup> × 2<sup>−126</sup> = ±2<sup>−149</sup> ≈ ±1.4 × 10<sup>−45</sup>| |"közép" denormalizált érték| * |-127| 0|0000 0000|100 0000 0000 0000 0000 0000|±2<sup>−1</sup> × 2<sup>−126</sup> = ±2<sup>−127</sup> ≈ ±5.88 × 10<sup>−39</sup>| |legnagyobb denormalizált érték| * |-127| 0|0000 0000|111 1111 1111 1111 1111 1111|±(1−2<sup>−23</sup>) × 2<sup>−126</sup> ≈ ±1.18 × 10<sup>−38</sup>| |kegkisebb normalizált érték| * |-126| 1|0000 0001|000 0000 0000 0000 0000 0000|±2<sup>−126</sup> ≈ ±1.18 × 10<sup>−38</sup>| |legnagyobb normalizált érték| * |127| 254|1111 1110|111 1111 1111 1111 1111 1111|±(2−2<sup>−23</sup>) × 2<sup>127</sup> ≈ ±3.4 × 10<sup>38</sup>| |pozitív végtelen| 0 |128| 255|1111 1111|000 0000 0000 0000 0000 0000|+∞| |negatív végtelen| 1 |128| 255|1111 1111|000 0000 0000 0000 0000 0000|−∞| |NaN (érvénytelen számérték)| * |128| 255|1111 1111|non zero|NaN| |* előjel bit lehet 0 vagy 1||||||| A számábrázolás jellegéből adódóan a kitevő emelkedésével arányosan (ezzel együtt az ábrázolt számérték méretével arányosan is) a pontosság csökken, erre mutat néhány példát az alábbi táblázat: ^ kitevő^ ábrázolható minimum^ ábrázolható maximum^ Pontosság (felbontás)| |0|1|1.999999880791|1.19209289551e-7| |1|2|3.99999976158|2.38418579102e-7| |2|4|7.99999952316|4.76837158203e-7| |10|1024|2047.99987793|1.220703125e-4| |11|2048|4095.99975586|2.44140625e-4| |23|8388608|16777215|1| |24|16777216|33554430|2| |127|1.7014e38|3.4028e38|2.02824096037e31| ===== Változótípusok ===== ==== A Simatic Step 7 változótípusai ==== A változótípusok csoportosítása hosszuk szerint: ^Bit\\ (1 bit)^Byte\\ (8 bit)^Szó\\ (16 bit)^Duplaszó\\ (32 bit)^64 bit| | [[hu:s7:valtozotipusok_es_ob_k#Bit|BOOL]] | [[hu:s7:valtozotipusok_es_ob_k#Byte|BYTE]] | [[hu:s7:valtozotipusok_es_ob_k#Word|WORD]] | [[hu:s7:valtozotipusok_es_ob_k#dword|DWORD]] | | | | [[hu:s7:valtozotipusok_es_ob_k#char|CHAR]] | | | | | | | [[hu:s7:valtozotipusok_es_ob_k#int|INT]] | [[hu:s7:valtozotipusok_es_ob_k#Dint|DINT]] | | | | | [[hu:s7:valtozotipusok_es_ob_k#date|DATE]] | | | | | | [[hu:s7:valtozotipusok_es_ob_k#s5time|S5TIME]] | | | | | | | [[hu:s7:valtozotipusok_es_ob_k#real|REAL]] | | | | | | [[hu:s7:valtozotipusok_es_ob_k#time|TIME]] | | | | | | [[hu:s7:valtozotipusok_es_ob_k#time_of_day_(TOD)|TOD]] | | | | | | | [[hu:s7:valtozotipusok_es_ob_k#date_and_time_(DT)|DT]] | Egyéb (változó hosszú) deklarációk: [[hu:s7:valtozotipusok_es_ob_k#array|ARRAY]], [[hu:s7:valtozotipusok_es_ob_k#struct|STRUCT]], [[hu:s7:valtozotipusok_es_ob_k#udt|UDT]], [[hu:s7:valtozotipusok_es_ob_k#string|STRING[n]]] hu/s7/plc_szoftver_alapfogalmak.txt 2022/04/21 15:04()