Az S40 PLC-programozási nyelv (IEC1131-3 kompatibilis) elemkészletének ismertetése
programstruktúra adattípusok, változók deklarálása utasításkészlet függvények funkcióblokkok
Tartalomjegyzék 1. 2. 3.
A kézikönyvről............................................................................................. 5 A Sucosoft programstruktúrája ................................................................ 5 Adattípusok, változók deklarálása ............................................................ 6 Elemi adattípusok felsorolása ........................................................................................... 6 Adattípusok felosztása ..................................................................................................... 7 Származtatott adattípusok ................................................................................................. 8 Változó fajták ................................................................................................... 12 Változó típusok ................................................................................................... 14
4.
POU-k programutasítási része................................................................. 17 Utasításkészlet Függvények Funkcióblokkok
5.
................................................................................................... 17 ................................................................................................... 19 ................................................................................................... 20
Függvények ................................................................................................ 23 Adattípusokat konvertáló függvények ............................................................................ 25 Numerikus függvények................................................................................................... 27 Aritmetikai függvények .................................................................................................. 27 Állapotbit vizsgáló függvények ...................................................................................... 28 Bit mozgatások ................................................................................................... 30 Logikai függvények ................................................................................................... 31 Összehasonlítási függvények.......................................................................................... 31 Operációs rendszer-függvények ..................................................................................... 31 Megszakítást tiltó / engedélyező függvények................................................................. 32 Karakterlánccal kapcsolatos függvények........................................................................ 34 Kiválasztási függvények ................................................................................................. 37
6.
Funkcióblokkok......................................................................................... 40 _16BitBinaryToBCD _16Bit_Compare _16BitCounter ADRtoSTR BCDTo16BitBinary BlockCompare BlockTransfer CompareArray COMtoSTR CounterAlarm DATconcat DateConcat DateSplit
16-bit bináris kódolású szám -> decimálissá alakítása ............. 43 ................................................................................................... 45 16-bites előre- /hátraszámláló ................................................... 46 vett adatbájtok STRING típusú változóvá alakítása ................. 48 Decimális kódolású szám -> 16-bit binárissá alakítása ............ 49 adatblokkok összehasonlítása, adott adat keresése a blokkban (címváltozók alkalmazásával)................................... 50 adatblokk másolása, inicializálása (címváltozók alkalmazásával)......................................................................... 55 adatblokkok összehasonlítása, adott adat keresése a blokkban.................................................................................... 58 vett adatbájtok STRING típusú változóvá alakítása ................. 62 számláló megszakításkezelés .................................................... 64 dátum és idő (DATE_AND_TIME) típusú változó összeállítása egyedi UINT típusú adatokból............................. 68 dátum (DATE) típusú változó összeállítása egyedi UINT típusú adatokból ........................................................................ 70 dátum (DATE) típusú változó szétválasztása egyedi UINT típusú adatokra .......................................................................... 71
3
DATsplit DE4netK Deserialize EdgeAlarm FifoBx FifoWx GetRealTimeClock LifoBx LifoWx MI4netK MS_TimeFalling MS_TimeRising ReadMC ReloadData RealTimeClock RTC S_TimeFalling S_TimeRising SaveData SCO Serialize SetRealTimeClock SR_x SRB_x SRW_x STRtoADR STRtoCOM TimeConcat TimeGenerator TimePulse TimerAlarm TimeSplit TODconcat TODsplit TransferArray WriteMC
7.
4
dátum és idő (DATE_AND_TIME) típusú változó szétválasztása egyedi UINT típusú adatokra ............................ 72 DF4 frekvenciaváltók kommunikációs modulja ....................... 74 tömbből tetszőleges formátumú adatok kiválasztása ................ 77 változásfigyelés megszakításkezelés......................................... 79 8-bites csőtár regiszter .............................................................. 83 16-bites csőtár regiszter ............................................................ 86 Valós idejű óra kiolvasása......................................................... 89 8-bites veremtár regiszter.......................................................... 90 16-bites veremtár regiszter........................................................ 92 MI4 kijelzők kommunikációs modulja ..................................... 94 Elejtésre késleltetett időzítő (milliszekundumos megadással)............................................................................... 95 Meghúzásra késleltetett időzítő (milliszekundum megadással)............................................................................... 97 adatok olvasása a flash-memóriából ......................................... 99 adatok olvasása a flash-memóriából (címváltozók alkalmazásával)....................................................................... 102 valós idejű óra összehasonlítása egyedi bemeneti adatokkal ................................................................................. 104 valós idejű óra állítása............................................................. 108 Elejtésre késleltetett időzítő (szekundumos megadással) ....... 109 Meghúzásra késleltetett időzítő (szekundum megadással) ..... 111 adatok írása a flash-memóriába (címváltozók alkalmazásával)....................................................................... 113 transzparens soros vonali kommunikáció ............................... 115 tetszőleges adatstruktúra bájtos tömbbe való másolása ......... 125 Valós idejű óra állítás.............................................................. 128 bites léptető regiszter .............................................................. 130 bájtos lépető regiszter.............................................................. 133 szavas lépető regiszter............................................................. 136 STRING típusú változó adott címterületre másolása.............. 139 STRING típusú változó adott címterületre másolása.............. 140 idő (TIME) típusú változó összeállítása egyedi UINT típusú adatokból ...................................................................... 141 ütemadó impulzusgenerátor .................................................... 143 impulzusképző ........................................................................ 145 időzítéses megszakításkezelés................................................. 147 idő (TIME) típusú változó szétválasztása egyedi UINT típusú adatokra ........................................................................ 150 napi idő (TOD) típusú változó összeállítása egyedi UINT típusú adatokból ...................................................................... 152 idő (TIME_OF_DAY) típusú változó szétválasztása egyedi UINT típusú adatokra.................................................. 153 adatblokk másolása, inicializálása .......................................... 154 adatok írása a flash-memóriába............................................... 156
Sucosoft határértékek ............................................................................. 159
A Sucosoft programstrukturája 1.
A kézikönyvről
Ezen dokumentáció az AWB2700-1306 számú dokumentáció szerkesztett fordítása, mely az alapvető ismereteket és az általunk legfontosabb utasítások, függvények, funkcióblokkok fordítását tartalmazza a kompakt PLC-kre (PS4-200, PS4-300) vonatkozóan. Az egyes programnyelvi kifejezések az összes PLC típusra (PS4, PS416) azonosak. A különbségek csak az egyes PLC-k memórianagyságában, a támogatott adattípusokban illetve a különböző perifériákból adódhatnak. Ezen esetekben külön hivatkozunk az adott típusokra. A PS4-200 jelölés a PS4-141/-151-MM1 valamint a PS4-201/-271-MM1, a PS4-300 jelölés a PS4-341-MM1 kompakt PLC-kre, a PS416 jelölés pedig az összes moduláris CPU típusra (CPU-200, CPU-300, CPU-400) vonatkozik. Megjegyzések nélküli leírás részek minden PLC típusra érvényes.
2.
A Sucosoft programstruktúrája
A Sucosoft által használt programnyelvek megfelelnek az IEC1131-3 szabványnak. A különböző felhasználói programok strukturált kialakításához három porgramorganizációs egység (továbbiakban POU) áll rendelkezésre. •
PROGRAM (főprogram)
•
FUNCTION (függvények, továbbiakban FU)
•
FUNCTIONBLOCK (funkcióblokkok, továbbiakban FB)
A gyakran fellépő feladatok megkönnyítésére a Sucosoft a standard függvények és funkcióblokkok sorozatát kinálja fel. A Sucosoft mind az IEC1131-3 által, mind a Moeller Electric által definiált gyártó-definiált függvényeket és a funkcióblokkokat tartalmaz. (A fordítás csak a Moeller Electric által definiált gyártós pecifikus programelemeket ismerteti.) Az eredeti kézikönyvben az egyes függvények, funkcióblokkok eredetük szerint IEC vagy KM jelöléssel találhatók meg. A strukturált program feldolgozását a hívó POU (függvény, funkcióblokk) megszakítja, és a meghívott POU-ban történik tovább a programfeldolgozás. A hívás lehet közvetlen vagy (az előző programrész eredményétől függő) feltételhez kötött. Minden POU egy deklarációs részből és egy utasításrészből áll. Az összes adatelemet, mely az utasításrészben felhasználásra kerül, deklarálni kötelező. A program kommentárokat is tartalmazhat. A kommentárokat (* .. *) jelek közé kell elhelyezni. A kommnetárok egymásba ágyazhatók, ezáltal egyes programrészek egyszerűen kizárhatók 8kikommentározhatók) a programfutásból. Egy-egy POU tartalma adott kulcsszavakkal határolódik el egymástól, melyet a POU-editor (a programszerkesztő automatikusan generál. PROGRAM…. END_PROGRAM; FUNCTION… END_FUNCTION; FUNCTION_BLOCK…END_ FUNCTION_BLOCK;
5
Adattípusok 3.
Adattípusok, változók deklarálása
Az IEC1131-3 elemi és származtatott adattípusokat deklarál. A kulcsszavak kis és nagybetűvel egyaránt írhatók.
Elemi adattípusok felsorolása Az elemi adattípusokat az adott kulcsszavak egyértelműen meghatározzák. A kezdeti értékek a := hozzárendelési operátorral adhatók meg. Amennyiben nincs (kezdeti (inicializálási) érték a változóhoz hozzárendelve, akkor a változók a default értékeket veszik fel. Kulcsszó
adattípus
bitfoglalás
default érték
BOOL
kétértékű bináris szám, értéke: 1(igaz) vagy 0,(hamis)
1
0
SINT
short integer; rövid egész szám értéke: -128….+127
8
0
INT
integer; egész szám értéke: -32 768….+32 767
16
0
DINT 1)
double integer; dupla egész szám értéke:-2 147 483 648..+2 147 483 647
32
0
USINT
unsigned short integer; előjel nélküli rövid egész szám, értéke: 0…255
8
0
UINT
unsigned integer; előjel nélküli egész szám, értéke 0…65 535
16
0
UDINT 1)
unsigned double integer; előjel nélküli dupla egész szám, értéke: 0…4 294 967 295
32
0
REAL 1)
real; valós szám, értéke: +/-3,4 E+/-38
32
0
TIME
időtartam; megadása nap, óra, perc, sec., msec. értéktart.: -129d+1ms…+128d-1ms; PS4-200 esetén: -65d+1ms..-64d-1ms matematikai műv. esetén:0..64d-1ms
DATE
dátum formátum; YYYY-MM-TT
TIME_OF_DAY
időpont formátum: HH:MM:SS
T#0s
D#1900-01-01 TOD#00:00:00
DATE_AND_TIME dátum és idő
DT 1900-01-0100:00:00
STRING
változó hosszúságú karakterlánc
2)
’ ’(szóköz)
BYTE
bitsorozat 8bit szélességben
8
0
WORD
bitsorozat 16bit szélességben
16
0
DWORD*
bitsorozat 32bit szélességben
32
0
1)
6
csak a PS4-300 és Ps416 esetén
Adattípusok 2)
A karakterlánc hosszának default értéke 32jel. Amennyiben más értékre van szükség, akkor azt a deklarálás során kell kerek zárójelek között megadni. pl. Text : STRING(12) := ’ABC’; maximális STRING hossz PS4-200 esetén: 253jel, PS4-300 és PS416 esetén: 1024jel
BOOL R_EDGE és BOOL F_EDGE adattípusok (csak PS4-200 és PS4-300 esetén) A BOOL R_EDGE (felfutó él) és a BOOL F_EDGE (lefutó él) adattípusok az elemi típusok között szerepelnek. A jelváltozást kiértékelő adattípusok csak változó bemenetként (VAR_INPUT) használhatók felhasználó által definiált funkcióblokkok bemenetein. Ha a bemeneteken egy felfutó vagy lefutó élváltozás történt, akkor a R_EDGE vagy a F_EDGE-nek deklarált bemenetek az ezt követő híváskor logikai 1 értéket vesznek fel.
Adattípusok felosztása ANY
ANY_ ANY_NUM ANY_BIT ANY_DATE ANY_STRING TIME szárm. adattíp. ADDRESS# FUNCTION_ BLOCK ANY_REAL
ANY_INT
REAL REAL*
SINT SINT INT INT
BOOL BOOL BYTE BYTE
DATE DATE TIME_OF_DATE (TOD) TIME TIME_OF_DAY (TOD)
DINT DINT* USINT USINT
WORD WORD DWORD DWORD*
DATE_AND_TIME(DAT) (DAT) DATE_AND_TIME
UINT UINT UDINT UDINT*
felsorolás
ANY_ARRAY STRUCT ARRAY[..]
# az új fejlesztések esetén nem ajánlott! * csak aPS4-300 illetve PS416 estén
7
Adattípusok Az ADDRESS adattípus és az ANY kategóriajelölések csak mint általános adattípus jelölések a standard funkciók és funkcióblokkok bemeneti és kimeneti paramétereinél használatosak.
Származtatott adattípusok A származtatott adattípusokat az elemi adat adattípusokból lehet új, a felhasználó által adott kulcsszóval előállítani. A deklarálás a TYPE…END_TYPE kulcsszavakkal történik. A származtatott adattípusok definiálásával a VAR…END_VAR kulcsszavak közé egyedi adattípusú változókat tud bevezetni. példa: TYPE Analogertek : INT ; END_TYPE VAR Ertek1 : Analogertek ; END_VAR A származtatott adattípusok csak abban a POU-ban érvényesek, ahol a hozzátartozó típusdefiniálás megtörtént. Projekt globális származtatott adattípusokat a usertype.typ fájlban tetszőleges szövegszerkesztővel lehet a TYPE…END_TYPE kulcsszavakkal definiálni. (Lásd részletesen az AWB2700-1306 kézikönyvet.) Lehetséges származtatott adattípusok: • változók korlátozott értéktartománnyal: alkalmazásával lehetségessé válik az elemi adattípusok értéktartományát az újabb adattípus bevezetésével bekorlátozni. TYPE analogertek_1 : INT (-128..128) ; feszultseg
: INT (0..150) ;
temperatur : INT(-10..10) ; END_TYPE VAR Meresi_Ertek1 : analogertek_1 ; Meresi_Ertek2 : feszultseg ; Kazan_Temp END_VAR
8
: temperatur ;
Az alsó felső határértékeket két ponttal szóköz nélkül kell megadni. A pozitív értékek elé nem kell előjelet tenni!
Adattípusok • felsorolás adattípusok: A felsorolás adattípus definiálásával egy listát adunk meg, amilyen értékeket a változó a későbbiek folyamán felvehet. A típus definiálásakor a név megadását követően kerek zárójelben, egymástól vesszővel elválasztva adjuk meg a változó értékeket. A befejező zárójelet követően lehet a kezdeti értéket megadni. Amennyiben nincs kezdeti értékadás, akkor az első programfeldolgozáskor a változólista első eleme kerül felhasználásra. példa: típus-inicializálás Az adattípus Kozl_Lampa három értéket (piros, sarga, zold) vehet fel. A változó sarga kezdeti értékkel indul. Ha hiányozna az inicializálás, akkor a változó a pirost, mint az első értéket venné fel. TYPE Kozl_Lampa : (piros, sarga, zold) :=sarga ; END_TYPE VAR K_Lampa1 : Kozl_lampa ; K_Lampa2 : Kozl_lampa ; K_Lampa3 : Kozl_lampa ; Auto_Allj :BOOL ; END_VAR A program utasításrészében az egyes definiált értékek közvetlenül is felhasználhatók. LD
K_Lampa1
EQ
piros
St
Auto_Allj
• tömb típusú adatok: Több azonos típusú adatot egy változóba is össze lehet foglalni. Ezt az adattípust tömbnek nevezzük. Egy tömb tartalmazhat mind elemi mind származtatott adattípust. A definiálás az ARRAY kulcsszóval és az adatelemek számának megadásával történik. A tömbváltozók közvetlen címekkel is összekapcsolható az AT kulcsszó felhasználásával. példa: Tömbváltozó deklarálása A tomb1 ötelemű INT típusú, a tomb2 egy háromdimenziós 24 elemű változót jelent. A 17-es kezdeti értékű tömbelemet a program 5-re átírja. PROGRAM tomb TYPE tomb_5_INT : ARRAY [1..5] of INT :=[1,13,5,34,2] ; tomb_24_INT : ARRAY [1..2,1..3,1..4] of INT :=[[[3,7,2,9],[2,8,6,1],[5,7,2,17], [[2,3,0,5],[6,1,2,4],[3,0,1,4]]];
9
Adattípusok END_TYPE VAR tomb1 : tomb_5_int ; tomb2 :tomb_24_int ; END_VAR . . LD
5
ST
tomb2[1,3,4]
. END_PROGRAM • Struktúra adattípus definiálása: (csak a PS4-300 és a PS416 estén) Különböző típusú adatelemek egy adattípusba való összerendelésére szolgál az adatstruktúra. Az adatstruktúra tartalmazhat elemi vagy származtatott adattípusokat is. A deklaráláshoz a STRUCT kulcsszót kell megadni, majd ezt követi az egyes elemek felsorolása típus megadásukkal együtt. Egy struktúraelem megszólítása a struktúra változó névmegadással majd ponttal elválasztva a struktúraelem nevével történik. példa: kezdeti értékadás a deklarálás során PROGRAM struktur TYPE Berendezes_Adatok : STRUCT meres1: BOOL := 1 ; meres2: INT := -15 ; meres3: UINT := 100; meres4: REAL := 10.2; END_STRUCT END_TYPE VAR allomas1 : Berendezes_Adatok ; allomas2 : Berendezes_Adatok ; END_VAR LD .
10
allomas1. meres3
Adattípusok END_PROGRAM példa: kezdeti értékadás a deklarálás után PROGRAM struktur TYPE Berendezes_Adatok : STRUCT meres1: BOOL ; meres2: INT ; meres3: UINT ; meres4: REAL ; END_STRUCT := (meres1 :=1, meres2 := -15, meres3 := 100, meres4 : =10.2) ; END_TYPE VAR allomas1 : Berendezes_Adatok ; allomas2 : Berendezes_Adatok ; END_VAR A Berendezes_Adatok típus bevezetésével és az allomas1 és az allomas2 változókhoz való hozzárendeléssel az allomas1 és allomas2 változók mindegyike tartalmaz egy-egy BOOL, INT, UINT és REAL adattípust. Amennyiben a származtatott adattípusok típusdeklarációjában nem történik kezdeti értékadás, akkor az egyedi adatelemek kezdeti értékként a default értéküket veszik fel.
11
Változók Változó fajták A PLC-ben alkalmazott adatelemeket változóknak nevezzük. A változók csoportosítása: • változók, melyek a közbenső belső adattárolásra szolgálnak •
közvetlen címzésű változók, melyek a bemenetekhez, kimenetekhez, vagy meghatározott memóriaterülethez illetve a PLC kommunikációs memóriaterületéhez kapcsolódnak.
A változókat jellel, névvel lehet azonosítani. A nevek betűvel vagy aláhúzásjellel (_) kezdődhetnek, és egyébként kis- és nagybetűk, számok, aláhúzások sorozatából áll. Szóközöket, ékezetes betűket a név nem tartalmazhat. A kulcsszavakat szintén nem lehet változónévként használni. A változónevek maximális hossza 64 karakter. A kis és nagybetűs jeleknek nincs megkülönböztető jelentősége. Közvetlenül ábrázolható változók A fizikai PLC címek (be-/kimenetek, memóriaterületek) közvetlenül is megszólíthatók. A direkt ábrázolású változókat is kötelező deklarálni, azonban a direkt címekhez szimbolikus nevek hozzárendelése is megengedett. Direkt címzés esetén az operandusokat %-jellel és a fizikai címükkel lehet megszólítani. A deklarációs részben a fizikai címet (szóközzel elválasztva) AT kulcsszóval kell megadni. példa: Program poe4 VAR AT
AT %I0.0.0.0.0 : BOOL ;
Bemenet1
AT %I0.0.0.0.1 : BOOL ;
Eredmeny : BOOL ; END_VAR LD
Bemenet1
AND %I0.0.0.0.0 ST
Eredmeny
Ajánlatos a szimbolikus nevek használata a direkt címzésű változók esetén is, mert használatuk esetén a címváltoztatást egyszerűbb átvezetni. Ebben az esetben elegendő ugyanis a deklarációs részben a szimbolikus név és a direkt változó hozzárendelését javítani, az utasításrész változatlan maradhat. (Ellenkező esetben minden egyes direkt változó helyén el kell végezni a módosítást.) Közvetlenül címzésű változókat csak a főprogramban (PROGRAM nevű POU) lehet deklarálni. Igény esetén egy tömbhöz is lehet közvetlenül címeket hozzárendelni, de csak az azonos típusú címzéseket (BOOL, BYTE, SINT, USINT, WORD, INT stb.) lehet összefogni egy tömbbe. A PS4-200 és PS4-300 estén a bitváltozókat csak a 8 egészszámú többszöröseként
12
Változók lehet összefogni. A PROGRAM POU-ban deklarált globális direkt címzésű változókat a funkcióblokkokban, mint külső (EXTERNAL) deklarált változókként lehet felhasználni. Egy másik, gyorsabb lehetőség a funkcióblokkok esetén a változók paraméter átadása a VAR_IN_OUT típusokon keresztül. Ez a lehetőség azonban csak az írható változókra (PLC kimenetekre, memóriahelyekre, kommunikációs adatokra) vonatkozik. A Sucosoft a következő fizikai címeket ismeri: I: Q: M: IA: QA: IC: IS: SD: RD:
digitális bemenet digitális kimenet memóriaterület analóg bemenet analóg kimenet számláló bemenet status információs bemenet (diagnosztika) intelligens Suconet K résztvevőnek küldendő adat intelligens Suconet K résztvevőtől fogadott adat
A következő fizikai címek a közvetlen periféria hozzáféréshez használhatók: IP: digitális bemenet (PS4-200/-300) QP: digitális kimenet (PS4-200/-300) IPA: analóg bemenet (PS4-300) QPA: analóg kimenet (PS4-300) IPC: számláló bemenet (PS4-300) A rendelkezésre álló konfigurált hardver határozza meg, hogy milyen címek állnak rendelkezésre. Az egyes adatok nagyságát a következő szimbólumokkal jelöljük: szimbólum jelentése nagyság példa bit 1 bit %I0.0.0.0.0 B bájt 8 bit %IB0.0.0.0 W szó 16bit %IW0.0.0.0 D duppla szó 32bit %ID0.0.0.4 A direkt című változók memóriabeli szervezése a következő kimeneti változón (Q) látható: QD0.0.0.0 QW0.0.0.0
QD0.0.0.4 QW0.0.0.2
QW0.0.0.4
QW0.0.0.6
QB0.0.0.0 QB0.0.0.1 QB0.0.0.2 QB0.0.0.2 QB0.0.0.4 QB0.0.0.5 QB0.0.0.6 QB0.0.0.7 Q0.0.0.0.0 Q0.0.0.1.0 Q0.0.0.2.0 Q0.0.0.2.0 Q0.0.0.4.0 Q0.0.0.5.0 Q0.0.0.6.0 Q0.0.0.7.0 Q0.0.0.0.7 Q0.0.0.1.7 Q0.0.0.2.7 Q0.0.0.2.7 Q0.0.0.4.7 Q0.0.0.5.7 Q0.0.0.6.7 Q0.0.0.7.7
13
Változók Változó típusok A programozási egység deklarációs részében minden felhasználásra kerülő változót definiálni kell. A különböző változótípusokat a megfelelő kulcsszavakkal lehet jellemezni. A következőkben összefoglalva látható a különböző változótípusok és jellemzésük. Kulcsszó
Felhasználás
VAR
lokális változók; érvényességi körük csak az adott POU-ra, ahol definiálásra kerültek, vonatkozik.
VAR_GLOBAL
A globálisként deklarált változó érvényességi területe a teljes programra vonatkozik, azaz egy a PROGRAM POUban globálisan deklarált változó bármelyik programbeli funkcióblokkban (FB-ben) is előhívható. Az FB-ben, ahol egy globálisan deklarált változó felhasználásra kerül, a változót azonos névvel, mint VAR_EXTERNAL típusként kell deklarálni.
VAR_EXTERNAL
Ha egy FB-ben egy globálisan deklarált változó kerül felhasználásra, akkor az azonos névvel és VAR_EXTERNAL típusként kell deklarálni.
VAR_INPUT
Egy változó bemeneti változóként kerülhet definiálásra egy POU-ban (FU (= függvény), FB), ha ebben a programozási egységben a változót csak olvassák, vagy csak paraméterátadásra használják, vagyis a változó értékét nem szabad megváltoztatni.
VAR_OUTPUT
Egy FB kimeneti változójaként definiált változót az FB a hívás folyamán képes írni, azaz azt megváltoztatni.
VAR_IN_OUT
Az IN_OUT típusú változót az FB képes meghívni, és ugyanazon a néven módosított értéket adni. Mivel a az FB.n belül értékadás történhet, írásvédett változót (pl. CONSTANT) a VAR_IN_OUT-ként nem lehet használni.
TYPE
A TYPE kulcsszó a származtatott adattípusok jelölésére szolgál.
Minden egyes adatblokkot az END_VAR, vagy END_TYPE kulcsszavakkal kell lezárni. A VAR_IN_OUT változó mutató (pointer), amely az adott típusú deklarált változóra mutat. A változó csak FB-ben alkalmazható, és az FB hívása előtt már érvényes értékkel kell rendelkeznie. A nem inicializált VAR_IN_OUT változók a fordítás során szintaktikai hibát okoznak. A mutatót az FB hívása előtt akkor is inicializálni kell, ha az FB-ben a hívás során közvetlenül nem kerül felhasználásra. A mutatókat az FB hívásakor kerek zárójelben kell megadni. Példa: Mutató egy 201szavas tömbváltozóra A „demo” nevű FB-ben alkalmazott „w_array” VAR_IN_OUT típusú változó nem 201 szót tartalmazó tömb, hanem egy mutató, mely erre a tömbre mutat. A „demo” FB-ben a „word_array” globális tömbre történik a hivatkozás.
14
Változók A mutatók alkalmazása a következő előnyöket nyújtja: •
A „demo” hívásakor nem kell a tömböt átmásolni (időnyereség), és a VAR_IN_OUT változóra való hivatkozás mind az írást, mind az olvasást biztosítja.
•
A funkcióblokk így neutrális maradhat, mivel az EXTERNAL deklaráció is elmarad, mely egyébként adott globális változókhoz kapcsolódna.
PROGRAM user VAR_GLOBAL word_array : array[0..200] of word ; END_VAR VAR my_function_block : demo ; END_VAR cal my_function_block(w_array :=word_array) END_PROGRAM FUCTION_BLOCK demo VAR_IN_OUT w_array : array[0..200] of word ; END_VAR VAR seged1 : word ; seged2 : word ; END_VAR ld w_array[100] st seged1 ld seged2 st w_array[200] END_FUNCTION_BLOCK A lokális és globális változók további tulajdonságokkal is kiegészíthető. Kulcsszó
Felhasználás
RETAIN
A RETAIN kulcsszóval az adott változót remanensnek definiálhatjuk, azaz meleg start esetén a változó megtartja utolsó kikapcsolás előtti értékét. A RETAIN kulcsszó a VAR vagy a VAR_GLOBAL után szóközzel írandó.
CONSTANT
Amennyiben egy adatelem konstansként, azaz értéke állandóként definiálandó, akkor a CONSTANT attribútum használható. A CONSTANT kulcsszó a VAR vagy a VAR_GLOBAL után szóközzel írandó.
AT
Ha egy változóhoz fizikai címet kíván hozzárendelni, akkor ehhez az AT kulcsszó használható. PS4-200 esetén a memóriaváltozókat nem lehet a RETAIN kulcsszóval remanensé tenni. Ebben az esetben egy összefüggő memóriaterületet kell kijelölni, melyet a kód élőállítás -> Opciók -> PS-opciók -> Compiler… menüpont alatt lehet kijelölni. 15
Változók PS4-300 esetén a memóriaváltozókat mind a RETAIN kulcsszóval, mind a remanens memóriaterület kijelölésével (kód élőállítás -> Opciók -> PSopciók -> Compiler…) remanensé lehet tenni. A PS4-200 esetén egy funkcióblokk egyes változóit remanenssé beállítani nem lehet. Ebben az esetben az egész funkcióblokkot kell remanensként deklarálni. Változótípusok felhasználása VAR_INPUT
FU
FB
▲▲
▲▲
VAR_OUTPUT
▲▲
VAR_IN_OUT
▲▲
VAR_GLOBAL
PRG
▲▲
VAR_EXTERNAL
▲▲
VAR
▲▲
▲▲
▲▲
TYPE
▲▲*
▲▲*
▲▲*
▲▲ többszörös felhasználás lehetséges *
lokálisan egy POU-n belül, vagy globálisan a usertype.typ fájl megfelelő szerkesztésével!
Funkcióblokkok helyfoglalása A funkcióblokkot abban a POU-ban (PROGRAM vagy egy másik FB), ahol meghívásra kerül, külön deklarálni szükséges. A definiálás ebben az esetben szintén egy egyedi névadással és a típus (funkcióblokk prototípusának) megadásával történik. Pl. szamlalo : CTU ; azaz a funkcióblokk egy egyedi, szamlalo névvel ellátva, és CTU típusként kerül meghívásra. A bemeneti változókat a meghívás előtt kell paraméterezni, a kimeneteket vagy előtte, vagy a meghívás után lehet további változókhoz hozzárendelni. A függvényektől eltérően csak azokat a bemeneti változókat kell paraméterezni, amelyek lényegesek a funkcióblokk hívása esetén. Kivételek a VAR_IN_OUT típusú változók, melyeket minden híváskor paraméterezni kell, különben szintaktikai hiba lép fel a fordítás során.
16
Utasításkészlet 4.
POU-k programutasítási része
Utasításkészlet Operátor LD
Operandus ANY
LDN
ANY_BIT
ST
ANY
STN
ANY_BIT
Jelentés az operandus bemásolása a z akkumulátorba a negált operandus bemásolása a z akkumulátorba az akkumulátor tárolása az operandusba az akku negált értékének tárolása az operandusba
S
BOOL
az operandus = 1, ha az akku értéke 1
R
BOOL
az operandus = 0, ha az akku értéke 1
AND(N) 1)
ANY_BIT
logikai ÉS kapcsolat (eredmény negálva)
&(N) 1)
ANY_BIT
logikai ÉS kapcsolat (eredmény negálva)
OR(N) 1)
ANY_BIT
logikai VAGY kapcsolat (eredmény negálva)
XOR(N) 1)
ANY_BIT
logikai kizáró VAGY kapcsolat (eredmény negálva)
ADD 1)
ANY_INT
összeadás
SUB 1)
ANY_INT
kivonás
ANY_INT
szorzás
MUL DIV
1)
1)
ANY_INT
osztás
GT
1)
ANY_INT
összehasonlítás: nagyobb; akku = 1, ha igaz
GE
1)
ANY_INT
összehasonlítás: nagyobb/egyenlő; akku = 1, ha igaz
EQ
1)
ANY_INT
összehasonlítás: egyenlő; akku = 1, ha igaz
NE
1)
ANY_INT
összehasonlítás: nem egyenlő; akku = 1, ha igaz
LE
1)
ANY_INT
összehasonlítás: kisebb/egyenlő; akku = 1, ha igaz
LT
1)
ANY_INT
összehasonlítás: kisebb; akku = 1, ha igaz
JMP
címke
feltétel nélküli ugrás; ugrás helye a címke
JMPC(N)
címke
feltételes ugrás; feltétel (nem) igaz, ha az akku = 1
CAL
FB-név
feltétel nélküli hívás; adott nevű FB hívása
CALC(N)
FB-név
feltételes hívás; feltétel (nem) igaz, ha az akku = 1
RET
-
feltétel nélküli visszaugrás az adott nevű FB-ből
RETC(N)
-
feltételes visszaugrás; feltétel (nem) igaz, ha az akku = 1
1) Az utasítás zárójelekkel együtt is használható. Az utasítás a zárójelben megadott kifejezés eredményére vonatkozik. A zárójelek több szinten egymásba is ágyazhatók.
17
Utasításkészlet Programírási szabályok Egy utasítás szekvencia mindig LD(N) utasítással kezdődik. A szekvenciát az operandus írási utasítások (ST(N), S,R), valamint a feltételes ugrások, hívások és visszatérési utasítások zárják le. Kivételt képeznek a feltétel nélküli ugrások és hívások, valamint ta visszatérési utasítások. Ugrási címkéket az utasítási sor elejére kell írni és kettősponttal kell lezárni. Ugrási célként csak a szekvencia kezdetét lehet megadni. Fontos követelmény: Az utasításokat csak azonos típusú adatokkal lehet végrehajtani. A Sucosoftban természetesen konstansokkal is lehet dolgozni. Lehet adatelemeket CONSTANT attribútummal ellátva és a kívánt kezdeti értékkel inicializálva deklarálni. Másik lehetőség a programvégrehajtás során direkt értékadás alkalmazása névvel ellátott adatelem felhasználása nélkül. A konstansok különböző adattípusaihoz előírt helyesírási konvenció tartozik. A konstanson belül szóközök alkalmazása helyett térelválasztónak az aláhúzás jel megengedett. (A szóközök csak a SRTING változókban használhatók!) Konstansok áttekintése Konstansok
Példa
Jelentés
INT
-13 45165 vagy 45_165 +125
egész szám; -13 egész szám; 45 165 egész szám; 125
REAL 1)
13.12 123.45 0.123 –1.23E-3
valós szám: 13,12 valós szám: 123,45 valós szám: 0,123 valós szám:0,00123
bináris szám
2#0111_111 vagy 126
126 decimálisan
hexadecimális szám
16#123 vagy 291
291 decimálisan
STRING
’ABC’
karakterlánc ABC
TIME
T#12.3ms vagy TIME#12.3ms
12,3ms időtartam
DATE
DATE#1995-12-24 vagy D#1995-12-24
dátum: 1995 12. 24.
TIME_OF_DAY
TOD#12:05:14.56 vagy TIME_of_DAY#12:05:14.56
időpont: 12óra 5perc, 14,56másodp.
DATE_AND_TIME DT#1995-12-24-12:05:14.56 v. dárum és idő együtt: DATE_AND_TIME#19951995 12. 24 12-24212:05:14.56 12óra 5perc, 14,56másodperc 1)
csak a PS4-300 és Ps416 esetén
A PROGRAM a Sucosoft legfelső strukturális szintje. Ebben a POU-ban célszerű az alapvető vezérlési utasításokon túl a többi strukturált POU-t (függvények, funkcióblokkok) meghívni. A függvények hívása a függvény nevének beírásával, a funkcióblokkok hívása a Cal utasítással történik.
18
Utasításkészlet Függvények Rendszeresen ismétlődő feladatokhoz célszerű függvényeket alkalmazni. A függvény több beállítható induló paramétert tartalmazhat, a végrehajtás eredménye pedig egyetlen kimeneti adatban helyezkedik el, mely lehet egyetlen, de akár többelemű, tömb típusú is. A függvények érvényességi területe globális, azaz minden POU részére rendelkezésre áll, és nem kell külön a hívó POU-ban deklarálni. A függvény hívása a függvény nevének megadásával és a bemeneti adatok teljes paraméterátadásával történik. A függvény első paraméterét bemenetként az akkumulátoron keresztül, a további paramétereket egymástól vesszővel elválasztva (a függvénynevet szóközzel követően) a függvény argumentumaként kell megadni. A függvény az eredményt a függvény nevének megadásával az akkumulátoron keresztül adja vissza a meghívó POU-nak. A függvények nem képesek az eredmények tárolására. A függvény a lokális paramétereket minden függvényhíváskor az adattípusuknak megfelelően (lásd az elemi adattípusokat felsoroló táblázatot az előző fejezetben) inicializálja. Ha a hívás az eredmény állítása nélkül fejeződik be, akkor a függvény automatikusan visszaállítja a lokális változók típusnak megfelelő kezdeti értékét. Példa: összeadási függvény FUNCTION szumma : INT VAR_INPUT A : INT ; B : INT ; C : INT ;
(* deklarációs rész *)
END_VAR LD A (* utasításrész *) ADD B ADD C ST szumma PROGRAM pr_sum VAR tenyezo1 : INT := 1 ; tenyezo2 : INT := 2 ; tenyezo3 : INT := 3 ; eredmeny : INT ; END_VAR LD tenyezo1 Szumma tenyezo2, tenyezo3 ST eredmeny END_PROGRAM Egy függvényen belül további függvények is hívhatók Viszont egy függvénybe nem lehet funkcióblokkot beágyazni, továbbá nem lehet funkcióblokk nevet bemeneti paraméterként felhasználni.
19
Utasításkészlet A Sucosoft a gyakori feladatok számára nagyszámú gyártó specifikus függvényt ajánl fel. Online változtatás vagy állapotkijelzés, mint a PROGRAM vagy a FB esetén, a függvényeken belül nem lehetséges. A felhasználói függvények algoritmusának tesztelésére ezért célszerű FB-t kialakítani, majd később a leellenőrzött funkcióblokkot függvénnyé átalakítani. A PS4-200 esetén a felhasználó által megírható függvényeket a Sucosoft egyelőre nem támogatja.
Funkcióblokkok A gyakran előforduló feladatokhoz a függvényeken kívül funkcióblokkokat is lehet használni. A funkcióblokkok ellentétben a függvényekkel több kimeneti paraméterrel is rendelkezhetnek. A funkcióblokk a változóit megőrzi a következő hívásig, melyek így tovább feldolgozásra közvetlenül felhasználhatók. Egy funkcióblokk további FB-ket hívhat. A következő táblázat mutatja a funkcióblokk be/kimeneti változóinak megengedett használatát: Használat
funkcióblokkon belül
funkcióblokkon kivűl
bemenet olvasása
LD IN1 AND IN2 ST Q1
LD ST
FBx.IN1 %QW0.0.0.2
bemenet írása
nem megengedett!
LD ST CAL
Start FBx.IN1 FBx
kimenet olvasása
LD OUT1 AND IN2 ST OUT1
CAL LD ST
FBx(IN1 := Be, …) FBx.OUT1 %QW0.0.0.2
kimenet írása
LD ST
nem megengedett!
100 OUT1
Ha a bemeneti operandust, mint él figyelést kell alkalmazni, akkor a változót ennek megfelelően (pl. start : BOOL_R_EDGE ;) kell deklarálni! A él figyelésű változók használata csak a PS4-200 és a PS4-300 családban lehetséges. Az IEC szabvány két azonos eredménnyel járó eljárást engedélyez a funkcióblokkok paraméterátadására. A következő példában (a feladat többszörös középértékképzés) két hívással mutatjuk be a két eljárást.
20
Utasításkészlet A középértékképzést végző funkcióblokk prototípusa a következő: FUNCTION_BLOCK kozepertek VAR_INPUT Reset : BOOL ; Bem1 : USINT ; Bem2 : USINT ; END_VAR VAR_OUTPUT atlag : USINT ; END_VAR LD Bem1 ADD Bem2 DIV 2 St atlag END_FUNCTION_BLOCK Az FB-t hívó program felépítése: A kozepertek FB a programban különböző nevekkel kétszer kerül meghívásra (instancálásra). PROGRAM poe3 VAR Instanz1_nev : kozepertek ; Instanz2_nev : kozepertek ; ertek1 AT %IB0.0.0.0 : USINT ; ertek2 AT %IB0.0.0.1 : USINT ; eredmeny1 AT %QB0.0.0.0 : USINT ; eredmeny2 AT %QB0.0.0.1 : USINT ; torles AT %I0.0.0.2.0 : BOOL ; END_VAR (* FU hívás - 1. eljárás *) Cal Instanz1_nev (Reset := torles, Bem1 := ertek1, Bem2 := ertek2) LD Instanz1_nev.atlag St eredmeny1 (* FU hívás - 2. eljárás *) LD St LD ST LD ST Cal
torles torles ertek1 Instanz2_nev.bem1 ertek2 Instanz2_nev.bem2 Instanz2_nev
LD Instanz2_nev.atlag St eredmeny2 END_PROGRAM A csak egyszer kialakított FB szükség szerint többször is (más-más nevekkel) meghívható.
21
Utasításkészlet A neveket a fölérendelt hívó POU-ban kell deklarálni. A deklarálás során az egyedi neveket (itt: Instanz1_nev, Instanz2_nev) és a funkcióblokk prototípusát (itt: kozepertek) is meg kell adni. A Sucosoft a szükséges memóriaterületet az instancált FB-hez hozzárendeli, azaz a funkcióblokk minden egyes alkalmazásánál a belső adatok is letárolásra kerülnek. A funkcióblokk hívásakor (Cal Instanz1_nev) a történik meg a tulajdonképpeni paraméterezés, azaz ekkor rendelődnek hozzá a funkcióblokk bemeneti paramétereihez az adott specifikus változók. Az egyes operandusokat kerek zárójelben egymástól vesszővel elválasztva kell megadni. A funkcióblokk kimeneti paramétereit direkt hozzárendeléssel lehet átadni más változóknak: LD Instanz1_nev.atlag ST eredmeny1 A második eljárás esetén a funkcióblokk hívása előtt az egyes instanz-specifikus változókat, az akkumulátor segítségével, átadjuk a funkcióblokk bemeneti paramétereinek. Maga a funkcióblokk hívás nem tartalmaz semmilyen paraméter átadást. A funkcióblokk eredmények hasonló módon letárolódnak, és az LD utasítással megszólíthatók. Továbbá úgynevezett Moeller-specifikus funkcióblokk hívás is realizálható. Ekkor a be/kimeneti paraméterátadás – egymástól elválasztva a ”|”-jellel – egyszerre történik. Példa: Cal Instanz3_nev (Reset := torles, Bem1 := ertek1, Bem2 := ertek2 | eredmeny := atlag) Természetesen a három eljárás egymással keverve is használható, azaz lehet egyes értékeket akkumulátoron át paraméterezni, és a többi szükségeset pedig a CAL hívással együtt!
22
Függvények 5.
Függvények
A Sucosoft S40 a függvények nagy választékát nyújtja a programozás részfeladatainak megkönnyítésére. Az IEC 1131-3 által definiált függvényeken kívül a Moeller Electric a PLC-khez további gyártó specifikus függvényeket is készített, melyek kihasználják a PLC egyedi adottságait. Ezek használata tovább könnyítheti az egyes felhasználói alkalmazások elkészítését. Az alábbiakban csoportosítva felsoroljuk a fontosabb függvényeket:
Függvények
Jelentésük
Adattípusokat konvertáló függvények ...................................................................... 25 *_TO_**
típuskonverziók elemi adattípusok között
TRUNC
REAL szám egészét adja ANY_INT adattípusban
Numerikus függvények............................................................................................... 27 ABS
abszolút értékképzés
NEG
2-es komplemens képzés
Aritmetikai függvények .............................................................................................. 27 ADD
összeadás
MUL
szorzás
SUB
kivonás
DIV
egész számú osztás
MOD
maradékértéket adó osztás
Állapotbit vizsgáló függvények .................................................................................. 28 IsCarry
aritmetikai műveletet követően átvitel bit = ?
IsZero
aritmetikai műveletet követően eredmény nulla bit = ?
IsOverflow
aritmetikai műveletet követően túlcsordulás = ?
ISPositive
aritmetikai műveletet követően eredmény pozitív = ?
IsBitTrue
akkumulátor adott bit = ?
GetCarryRegister Átvitelregisztert az akkumulátorba felhozni
Bit mozgatások ............................................................................................................ 30 SHL
bitmintát adott értékkel balra tolni
SHR
bitmintát adott értékkel jobbra tolni
ShiftLeftCarry
bitmintát - carry biten - át adott értékkel balra tolni
ShiftRightCarry
bitmintát - carry biten - át adott értékkel jobbra tolni
ROL
bitmintát adott értékkel balra forgatni
ROR
bitmintát adott értékkel jobbra forgatni
23
Függvények Logikai függvények..................................................................................................... 31 AND, &
logikai ÉS kapcsolat
OR
logikai VAGY kapcsolat
XOR
logikai KIZÁRÓ VAGY kapcsolat
NOT
bitminta bitenkénti negálása
Összehasonlítási függvények...................................................................................... 31 GT
NAGYOBB, MINT összehasonlítás
GE
NAGYOBB, EGYENLŐ összehasonlítás
EQ
EGYENLŐ összehasonlítás
LE
KISEBB, EGYENLŐ összehasonlítás
NT
KISEBB, MINT összehasonlítás
NE
NEM EGYENLŐ összehasonlítás
Operációs rendszer-függvények ................................................................................ 31 PLC_Message
rendszerdiagnosztikai status-bájt/szó kiolvasása
PLC_ReadCLock valósidejű óra egyedi elemeinek kiolvasása
Megszakításkérést tiltó / engedélyező függvények................................................... 32 Disable_Interrupt megszakításkérés tiltás Enable_Interrupt megszakításkérés engedélyezés
Karakterlánccal kapcsolatos függvények ................................................................. 34 LEN
adott karakterlánc hosszát megállapítani
CONCAT
karakterláncokat egybefűzni
DELETE
karakterláncból adott karaktereket törölni
FIND
karakterláncban adott karaktersorozatot megtalálni
INSERT
karakterláncba választható hosszúságú karaktereket befűzni
LEFT
karakterláncból balról választható hosszúságú karakterek kiválasztása
MID
karakterlánc belsejéből választható hosszúságú karakterek kiválasztása
REPLACE
karakterláncban választható helyen adott karaktersorozat behelyettesítése
RIGHT
karakterlánc jobbról választható hosszúságú karakterek kiválasztása
Kiválasztási függvények ............................................................................................. 37 LIMIT
értékkorlátozás
MAX
maximumérték keresés
MIN
minimumérték keresés
MUX
multiplexer
SEL
feltételes operandus kiválasztás
24
Függvények Adattípusokat konvertáló függvények *_TO_**
típuskonverziók elemi adattípusok között
Az IEC programnyelv előírásai alapján a szoftver csak azonos adattípusú operandusok közötti műveleteket enged meg. Például ha egy (FB, FU) bemeneti változójának BYTE adattípusúnak kell lenni, akkor az átadandó változót, mely történetesen USINT adattípussal rendelkezik, átadás előtt az USINT_TO_BYTE konverziós függvénnyel át kell alakítani. A konverzió mindig az akkumulátorban levő adatra vonatkozik, a függvény eredménye is az akkumulátorban képződik. A numerikus adatok konverziója során ügyeljen arra, hogy a cél adattípus a megengedett értéket ne lépje túl. Ha a bemeneti operandus túl nagy, akkor a kimeneti operandus a rendelkezésre álló bithosszúságra redukálódik, mely hibás értéket eredményezhet! A Sucosoft az alábbi konverziós függvényeket biztosítja az elemi adattípusok között
BOOL
BYTE
WORD
DWORD 1)
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
DINT
1)
X
X
X
X
X
X
X
X
X
X
X
X
X
X
REAL 1)
X
X
X
X
X
X
BOOL
X
X
X
X
X
X
BYTE
X
X
X
X
X
X
X
WORD
X
X
X
X
X
X
X
X
DWORD 1)
X
X
X
X
X
X
X
X
USINT UINT UDINT
1)
DATE_AND_TIME X
X
X
X
X
X
X
STRING 1)
X
ADDRESS 2)
X
1) 2)
X X
X X X
TIME BCD
X
BCD
REAL 1)
X
STRING 1)
UDINT 1)
X
DATE
UINT
X
TOD
USINT
INT
DINT1)
SINT
INT
bemenet
SINT
kimenet
X
X
csak a PS4-300 és PS416 esetén csak a PS4-200 és PS4-300 esetén
25
Függvények Megjegyzések: 1.
Az előjeles numerikus értékek bitsorozattá való átalakítása során a függvény figyelembe veszi az előjelet. High Low pl. 0010_0101 0000_0000 0010_0101 SINT átalakítása WORD típussá, illetve pl.
2.
átalakítása
1111_1111 0010_0101 WORD típussá
A BYTE típusú adat legfelsőbb bitje nincs kiértékelve, ha az UINT/INT átalakításra kerül. A BYTE értéke a Low-bájtba kerül, míg a felső(High)-bájt o-val töltődik fel. High Low pl. 0010_0101 0000_0000 0010_0101 BYTE átalakítása UINT típussá, illetve pl.
3.
1010_0101 SINT
1010_0101 BYTE
átalakítása
0000_0000 1010_0101 UINT
típussá
REAL_TO_ANY_INT átalakítás során a tizedesvessző utáni szám az egészszámú kerekítés szabályai szerint történik. Ha a tizedesvessző utáni szám = 0,5, akkor a kerekítés a közelebb levő páros számra történik. Egyszerűbb megoldás a TRUNC függvény, mely a REAL adattípust ANY_INT típussá alakítja, miközben csak az egészrészt veszi figyelembe. (A TRUNC csak a PS4-300 és a PS416-ra van értelmezve.) pl.: 1.4 –1.4 1.6 –1.6 1.5 2.5 0.5 3.5
1 -1 2 -2 2 2 0 4
Ha a cél adattípus értéktartományát az átalakított eredmény túllépi, akkor a rendelkezésre álló bithossz redukálódik. pl. REAL_TO_SINT esetén 2049.1 1 2178.0 -126 4.
A TIME_TO_UINT és a TIME_TO_USINT függvények esetén a 65535, illetve 255nél nagyobb eredmények érvénytelenek. Az eredmény helyessége az IsOverflow függvénnyel kérdezhető le.
5.
A STRING_TO_UINT függvény csak a string változó baloldali két karakterét dolgozza fel. A high-bájtban az első, a low-bájtban a második karakter értéke jelenik Egy karakter esetén a jel értéke a low-bájtban helyezkedik el.
26
Függvények Numerikus függvények ABS
A függvény a bemenetre adott ANY_NUM abszolút értékét adja vissza. Az adattípus az átalakítás során nem változik. Vigyázat: A legkisebb SINT (-128) és a INT (-32768) értékeket a függvény nem változtatja meg, mivel a –128 és 128, illetve a –32768 és 32768 bináris értéke azonos. Ha ilyen értékek lépnek fel az ABS függvényben, akkor hiba generálás nem történik.
NEG A függvény ANY_NUM adattípusokra vonatkozik. Az adattípus az átalakítás során nem változik. Előjeles számok esetén a függvény kimenet = (-1)*bemenet, azonban előjel nélküli számok esetén a függvény eredménye egy másik szám!
Aritmetikai függvények
ADD SUB MUL DIV
ADD SUB
Numerikus értékek adattípusokkal való műveletek szabályai: Numerikus értékek (ANY_NUM) közötti műveletek esetén a be- illetve kimeneti operandusoknak azonos típusúak kell lenni. ADD, SUB, esetén, ha az eredmény túllépi az adattípusra megengedett tartományt, akkor a túlcsordulás állapot bit bebillen, mely az IsOverFlow függvénnyel kérdezhető le. MUL esetén, ha az eredmény túllépi az adattípusra megengedett tartományt, akkor a túlcsordult érték az átvitel regiszterbe (melynek mérete mindig megegyezik a bemeneti operandusok méretével) kerül. Értéke a GetCarryRegister függvénnyel kérdezhető le. DIV művelet esetén az egész osztás maradéka az átvitel regiszterbe (melynek mérete mindig megegyezik a bemeneti operandusok méretével) kerül. Értéke a GetCarryRegister függvénnyel kérdezhető le. Időtartam illetve dátum és óra adattípusokkal való műveletek szabályai: ADD esetén a második operandus csak TIME típusú lehet, amit az elsőként megadott TIME, TIME_OF_DATE, DATE_AND_TIME1) típushoz lehet hozzáadni. A kimenet adattípus megegyezik az első operandus adattípusúval. SUB esetén az alábbi táblázat szerinti változatok lehetségesek: bemenet1 – bemenet2 = Különbség (kimenet) TIME TIME TIME DATE1) DATE TIME TIME_OF_DAY TIME TIME_OF_DAY TIME_OF_DAY TIME_OF_DAY TIME 1) TIME DATE_AND_TIME DATE_AND_TIME DATE_AND_TIME1) DATE_AND_TIME TIME 1) csak a PS4-300 és a PS416 esetén Csak a PS4-200-ra vonatkozóan: A TIME adattípus csak pozitív tartományban ad helyes eredményt!
MUL DIV
A MUL és DIV esetén az első operandus lehet TIME adattípus, míg a második csak ANY_NUM adattípust vehet fel.
27
Függvények Cím (ADDRESS) adattípusokkal való műveletek szabályai: A címekkel kapcsolatos mind a négy alapművelet megengedett, de csak a PS4-200 és a PS4-300 esetén lehetséges! Az alábbi táblázat szerinti változatok lehetségesek: bemenet1 bemenet2 kimenet ADDRESS ANY_INT ADDRESS ADDRESS ADDRESS ADDRESS MOD
A függvény ANY_NUM adattípusokra vonatkozik. Az adattípus az átalakítás során nem változik. A függvény az egészszámú osztás maradékát helyezi el a kimeneten (akkumulátorban) Csak aPS4-300 és a PS416 esetén értelmezett függvény!
Állapotbit vizsgáló függvények A vizsgáló függvények kiválóan alkalmasak feltételes ugrások, hívások feltételeinek meghatározásához. IsOverflow, IsPositive, IsZero: Az állapotbit vizsgáló függvények közvetlenül az aritmetikai műveletek után használva adja a megfelelő eredményt BOOL adattípusban. IsOverflow: aritmetikai művelet során történt-e túlcsordulás? (igen = 1; nem = 0) IsPositive: aritmetikai művelet eredménye 0, vagy pozitívszám? (igen = 1; nem = 0) IsZero: aritmetikai művelet eredménye 0? (igen = 1; nem = 0) PROGRAM overflow VAR Edge : R_TRIG; Signal : AT %I0.0.0.0.0 : BOOL; Pulse : BOOL; Number1 : SINT := 127; END_VAR
(* felfutó vizsgálatát végző FB *)
LD Number1 ADD 12 IsOverflow CALC Edge (CLK := Signal) LD Edge.Q ST Pulse END_PROGRAM IsCarry: A függvénnyel, a bitmozgatási függvényeket követően, az átviteli bit értékelhető ki. Bemenete ANY_INT, kimenete BOOL. PROGRAM carrybit VAR Edge : R_TRIG; Signal : AT %I0.0.0.0.0 : BOOL; Pulse : BOOL; Byte1 : BYTE := 2#11110000; END_VAR
28
Függvények LD Byte1 SHL 3 BYTE_TO_USINT IsCarry CALC Edge (CLK := Signal) LD Edge.Q ST Pulse END_PROGRAM
(* Carry regiszter = 1 *)
IsBitTrue: az akkumulátorba elhelyezett bitminta (ANY_BIT) tetszőleges bitjének vizsgálatára alkalmas. PROGRAM bittest VAR BitPattern : BYTE := 2#11010011 Position :UINT := 4; BitValue : BOOL; END_VAR LD BitPattern IsBitTrue Position ST BitValue . . END_PROGRAM
(* bit értéke: 1 *)
GetCarryRegister A függvény a ANY_INT adatokon végzett MUL esetén előforduló túlcsordulás, valamint a DIV esetén a maradék megjelenítésére szolgál. USINT, SINT, UDINT, DINT adattípusok esetén a túlcsordulásról nem generálódik jelzés. A compiler ennek megfelelő hibajelzést ad. PROGRAM remainder VAR Number: INT := 127; Result_integ : INT; ResultRemainder : INT; END_VAR LD Number DIV 4 ST Result_integ GetCarryRegister ST ResultRemainder . . END_PROGRAM
(* osztás eredménye : 31, egész *) (* maradék : 3 *)
29
Függvények Bit mozgatások SHL SHR
a Az akkumulátorban levő ANY_BIT típusú bitmintát a függvény operandusaként megadott értékkel (ANY_INT) balra/balra tolja. A toláskor felszabaduló helyek 0-val töltődnek fel. Az eredmény az akkumulátorban a bemeneti bitmintával azonos adattípusban áll rendelkezésre. PROGRAM rot_bal VAR BitPattern : BYTE := 2#01110001; Places : INT := 3; NewBitPattern: BYTE; END_VAR LD BitPattern ROL Places ST NewBitPattern END_PROGRAM
(* új bitminta: 2#10001011 *)
ShiftLeftCarry, ShiftRightCarray: A függvények egy hellyel balra illetve jobbra tolja bemenetként megadott bitmintát. Például BYTE adattípus esetén: új átviteli bit
bitminta
régi átviteli bit
ShiftLeftCarry:
C
7
0
C
ShiftRightCarry:
C
7
0
C
PROGRAM shi_jobb VAR BitPattern : BYTE := 2#01011100; NewBitPattern : BYTE; END_VAR LD BitPattern ShiftRightCarry ST NewBitPattern (* új bitminta: x0101110 ahol "x" *) (* a 7. bitpozicíóban az átvitelbit régi értéke *) . .
END_PROGRAM ROL A függvények az akkumulátor tartalmát (ANY_BIT) a függvény paramétereként ROR megadott értékkel (ANY_INT) balra vagy jobbra forgatja, azaz a kitolt biteket a másik oldalon visszatölti. Az új bitminta az akkumulátorban áll rendelkezésre. PROGRAM rot_le VAR BitPattern : BYTE := 2#01110001; Places : INT := 3; NewBitPattern: BYTE; END_VAR
30
Függvények LD BitPattern ROL Places ST NewBitPattern END_PROGRAM
(* az új bitminta: 2#10001011 *)
Logikai függvények A függvények a szokásos logikai függvények (része a Sucosoft utasításkészletnek), melyek csak azonos adattípusokon (ANY_BIT) végezhető el. Az eredmény a bemenetekkel azonos típusú, és az akkumulátorban képződik.
Összehasonlítási függvények A függvények a szokásos logikai függvények (része a Sucosoft utasításkészletnek), melyek csak azonos adattípusokon (ANY_INT) végezhető el. Az eredmény BOOL típusú, és az akkumulátorban képződik.
Operációs rendszer-függvények PLC_Message: A függvénnyel a bemenetre adott felsorolás típusú változó egyik elemének értéke határozható meg. A bemenet MESSAGE_TYPE (Moeller által definiált, csak olvasható rendszerdiagnosztikai) változó, a kimenet BOOL típusú. A MESSAGE_TYPE változó az egyes PLC típusok esetén a következő elemeket tartalmazza (minden típusra a standard beállítás az ISA): PS4-200 esetén: TYPE MESSAGE_TYPE (ISA, (* start utáni első programciklus *) IRE, (* RESET nyomógomb működtetve *) IFO, (* RUN üzemmódban a FORCE aktív *) REC, (* újraindítás esetén a maradék-ciklus fut *) ICS, (* a vezérlés hidegen indítva *) NKD_1, (* az SBI1-en (SBI -= Suconet K busz) friss adatok vannak *) NKD_2, (* az SBI2-en (SBI -= Suconet K busz) friss adatok vannak *) NKD_3 (* az SBI3-en (SBI -= Suconet K busz) friss adatok vannak *) ) := ISA ; END_TYPE PS4-300 esetén: TYPE MESSAGE_TYPE (ISA, (* =0: start utáni első programciklus *) IRE, (* =1: RESET nyomógomb működtetve *) IFO, (* =2: RUN üzemmódban a FORCE aktív *) REC, (* =3: újraindítás esetén a maradék-ciklus fut *) ICS, (* =4: a vezérlés hidegen indítva *) NKD_1, (* =5: az SBI1-en (SBI -= Suconet K busz) friss adatok vannak *) NKD_2, (* =6: az SBI2-en (SBI -= Suconet K busz) friss adatok vannak *) NKD_3, (* =7: az SBI3-en (SBI -= Suconet K busz) friss adatok vannak *) ICT, (* =8: ECT az első programciklusban *) IAH, (* =9: EAH az első programciklusban *) IRT, (* =10: ERT az első programciklusban *) ) := ISA ; END_TYPE
31
Függvények PS416 esetén: TYPE MESSAGE_TYPE (ICS (* =0: start utáni első programciklus hideg indítással*) ISA, (* =1: start utáni első programciklus *) RTW, (* =2: run time warning -figyelmeztetés *) REC, (* =3: újraindítás esetén a maradék-ciklus fut ) DAKE, (* =4: AK-Error, az egység nem szólítható meg, esetleg nincs bent ) KOM, (* =5: a kommunikációs partner nem válaszol *) ) := ISA ; END_TYPE Példa: Rendszerdiagnosztikai távirat kiértékelése LD ISA PLC_Message JMPCN No_new_start PLC_ReadClock: A függvénnyel a bemenetre adott felsorolás típusú változó egyik elemének értéke határozható meg. A bemenet PLC_Clock (Moeller által definiált, csak olvasható) változó, a kimenet USINT típusú. A PLC_Clock standard beállítása a CK_YEAR): PLC_CLOCK: CK_YEAR, (* évek száma *) CK_MONTH, (* hónap *) CK_DAY, (* nap *) CK_WEEKDAY, (*hétnap sorszám; 0 = vasárnap *) CK_HOURS, (* órák *) CK_MINUTES, (* percek *) CK_SECONDS (* másodpercek *) ) := CK_YEAR; END_TYPE PROGRAM RD_Clock VAR Hours : USINT ; END_VAR LD CK_HOURS PLC_ReadClock ST Hours END_PROGRAM
Megszakítást tiltó / engedélyező függvények A függvények bemeneti paramétere a Moeller által specifikált, ALARM_CHANNEL felsorolás típusú változó, mely a PLC típusától függ: PS4-200 esetén: TYPE ALARM_CHANNEL (CounterAlarm_Channel, TimerAlarm_Channel, EdgeAlarm_Channel) := CounterAlarm_Channel ; END_TYPE
32
Függvények PS4-300 esetén: TYPE ALARM_CHANNEL (CounterAlarm_Channel, (* 0 *) TimerAlarm_Channel, (* 1 *) EdgeAlarm_Channel_1, (* 2 *) EdgeAlarm_Channel_2 (* 3 *) ) := CounterAlarm_Channel ; END_TYPE PS416 esetén: TYPE ALARM_CHANNEL (CounterAlarm_Channel1, (* 0 *) TimerAlarm_Channel, (* 1 *) EdgeAlarm_Channel_1, (* 2 *) EdgeAlarm_Channel_2, (* 3 *) EdgeAlarm_Channel_3, (* 4 *) EdgeAlarm_Channel_4, (* 5 *) EdgeAlarm_Channel_5, (* 6 *) EdgeAlarm_Channel_6, (* 7 *) EdgeAlarm_Channel_7, (* 8 *) EdgeAlarm_Channel_8) (* 9 *) ):= CounterAlarm_Channel ; END_TYPE Disable_Interrupt: A függvény használatával egy lehetséges megszakításkérés letiltásra kerül. Így a főprogrambeli írást, olvasást a megszakítást okozó forrás nem tudja félbeszakítani, azaz az adatok szinkronizálhatók. (Lehetséges megszakításkérő források a CounterAlarm, EdgeAlarm, és a TimerAlarm (PS4-200, PS4-300 esetén), illetve a CAlarm, FAlarm, TAlarm (PS416 esetén).) A függvényt önálló szekvenciaként kell alkalmazni. Lásd a következő alkalmazást. PROGRAM D_Alarm VAR_GLOBAL Intermediate_storage: INT ; Edgealarm : EdgeAlarm ; I_Routine : AlarmFB ; END_VAR LD ICS PLC_Message CALC Edgealarm (EnableDisable := 1, Number := 0, RisingEdge := 0, SetPointValue := 1, Subroutine := I_Routine) LD EdgeAlarm_Channel Disable_Interrupt LD 500 ST Intermediate_storage LD EdgeAlarm_Channel Enable_Interrupt END_PROGRAM
(*start figyelés, mert a megszakításkérést (*FB-t csak egyszer kell hívni *)
(* EdgeAlarm megszakításk. tiltás *)
(* megszakításkérés engedélyezés *)
33
Függvények FUNCTION_BLOCK AlarmFB VAR_EXTERNAL Intermediate_storage: INT ; END_VAR LD 30000 ST Intermediate_storage END_FUNCTION_BLOCK Enable_Interrupt: A függvény használatával egy korábban letiltott megszakításkérést lehet engedélyezni. (Lehetséges megszakításkérő források a CounterAlarm, EdgeAlarm, és a TimerAlarm (PS4-200, PS4-300 esetén), illetve a CAlarm, FAlarm, TAlarm (PS416 esetén). A függvényt önálló szekvenciaként kell alkalmazni. Példaként lásd az előző alkalmazást.
Karakterlánccal kapcsolatos függvények Az alábbi STRING változókat kezelő függvények csak a PS4-300 és a PS416 vezérlésekre érvényesek. LEN Egy karakterlánc hosszát adja meg INT adattípusban. PROGRAM how_long VAR Text: STRING := 'Term'; TextLength : INT; END_VAR LD Text LEN ST TextLength END_PROGRAM
(* szöveg hossza: 7 *)
CONCAT Több karakterláncot fűz egy újabb karakterláncba. PROGRAM n_texts VAR Text1 : String := 'ab'; Text2 : STRING := 'cd'; Text3 : STRING := 'ef'; Texts_1_2_3 : STRING; END_VAR LD Text1 CONCAT Text2, Text3 ST Texts_1_2_3 END_PROGRAM
(* Texts_1_2_3: 'abcdef' *)
Másik alkalmazási lehetőség, dátum és idő egy változóba való összefűzése. PROGRAM deadline VAR Date : DATE := D#1997-05-10; Time : TIME_OF_DAY := T0D#6:35:00.00; Date_and_Time : DATE_AND_TIME; END_VAR
34
Függvények LD Date CONCAT Time ST Date_and_Time END_PROGRAM
(*dátum és idő: DT#1997-05-10-6:35 *)
DELETE A megadott karakterláncban az L pozíciótól kezdve P számú karaktert letöröl. P és L ANY_INT típusúak. H L = 0, vagy P > mint az eredeti bemeneti karakterlánc hossza, akkor a karakterlánc változatlan marad. PROGRAM Delete VAR Text1 : STRING := 'abABCDcd'; Length : UINT := 3; Position : UINT := 5; Text2 : STRING; END_VAR LD Text1 DELETE Length, Position ST Text2 END_PROGRAM
(* Text2: 'abABd' *)
FIND A bemenetként megadott STRING változóban keresi az argumentumban megadott STRING változót. Kimenete INT típusú szám, mely megmutatja a keresett változó helyét. Ha nem találja, akkor a kimenet értéke 0. Ha a változós többször is előfordul a bemenetben, akkor az első előfordulás helyét mutatja a kimenet értéke. PROGRAM find VAR Basic_Text : STRING := 'On_condition'; Find_Text : STRING := 'on'; Position : INT; END_VAR LD Basic_Text FIND Find_Text ST Position (* Position: 5 *) END_PROGRAM INSERT A függvény első argumentumaként megadott STRING változót a másodikként, P változóval (ANY_INT) megadott értéktől kezdve beszúrja a bemeneti STRING változóba. Ha a P értéke nagyobb mint a bemeneti STRING változó hossza, akkor a bemeneti változó változatlan marad. PROGRAM insert VAR Text1 : STRING := 'abcd'; Text2 : STRING := 'ABCD'; Position : INT := 2; NewText : STRING; END_VAR LD Text1 INSERT Text2, Position ST NewText END_PROGRAM
(* NewText: 'abABCDcd' *)
35
Függvények LEFT A bemenetként megadott STRING változó bal szélső részét veszi át L (ANY_INT) értékben. PROGRAM li_text VAR String : STRING := 'Teststring'; CharNo : INT := 4; n_left_Chars : STRING; END_VAR LD String LEFT CharNo ST n_left_Chars END_PROGRAM
(* n_left_Chars: 'Test' *)
MID A bemenetként megadott STRING változóból L számú karaktert metsz ki a P argumentumtól kezdődően. Az L és P a függvény első és második argumentuma, és ANY_INT típusúak. PROGRAM parttext VAR String : STRING := 'Test_string'; CharNo : INT := 7; Start : INT := 5; Text_Section : STRING; END_VAR LD String MID CharNo, Start ST Text_Section END_PROGRAM
(* Text_Section: 'Characters' *)
Replace A bemenetként megadott STRING változóba behelyezi az első argumentumként megadott STRING változót a harmadik argumentumként megadott P (ANY_INT) pozíciótól kezdődően. Ugyanakkor a P-től kezdve a második argumentumként megadott L (ANY_INT) hosszban a bemeneti STRING változó karakterei törlődnek. L = 0 megfelel az INSERT függvénynek. Ha a P nagyobb, mint a bemenetként megadott STRING változó hossza, akkor a függvény a bemeneti STRING értéket adja vissza. PROGRAM replace VAR Old_Text : STRING := 'abbCDEe'; _Characters : STRING := 'cd'; New_Text : STRING; END_VAR LD Old_Text REPLACE New_Characters, 4, 3 (*L=4, P=3*) ST New _Text (* New _Text: 'abcde *) END_PROGRAM
36
Függvények RIGHT A bemenetként megadott STRING változó jobb szélső részét veszi át L (ANY_INT) értékben. PROGRAM re_text VAR String : STRING := 'TestString'; StringNo : INT := 6; n_right_chars : STRING; END_VAR LD String RIGHT StringNo ST n_right_chars END_PROGRAM
(*n_right_chars: 'String' *)
Kiválasztási függvények Az alábbi STRING változókat kezelő függvények csak a PS4-300 és a PS416 vezérlésekre érvényesek. LIMIT Értékkorlátozás LIMIT
*)
*)
MIN
*)
IN
*)
MX
*)
a támogatott adattípusok: ANY_BIT, ANY_INT, ANY_DATE, TIME, STRING(1) Az összes adattípusnak azonosnak kell lenni! MN IN MX
alsó határérték korlátozandó változó felső határérték
Az MN és az MX írják elő a az alsó és felső korlátértéket. Ha az IN-re adott érték a korlátok között van, akkor az IN, ha kisebb, akkor az MN ha nagyobb, akkor az MX jelenik meg a kimeneten. PROGRAM limits VAR max_value : INT := 124; min_value : INT := 17; MeasVal AT %IW0.0.0.10:INT; Result : INT; END_VAR LD min_value LIMIT MeasVal, max_value ST Result END_PROGRAM
(*IW0.0.0.10
mostani értéke: 135 *)
(* Result: 124 *)
37
Függvények MAX MIN
Maximum, (minimum) kiválasztás MAX (MIN) *)
IN1
*)
IN2 .
.
INn
*) *) IN1 INn
*)
a támogatott adattípusok: ANY_BIT, ANY_INT, ANY_DATE, TIME, STRING Az összes adattípusnak azonosnak kell lenni! bemeneti értékek, melyekből a legnagyobb kerül kiválasztásra …
Az MAX függvény a bemenetek közül a legnagyobbat, a MIN függvény a legkisebbet adja vissza. A STRING adattípusok közül a leghosszabb/legkisebb karakterlánc kerül kiválasztásra. Ha azonos hosszúakat talál a függvény, akkor az először nagyobb/kisebb értékű karakterrel rendelkező kerül kiválasztásra. PROGRAM minimum VAR Value1 : SINT := 155; Value2 : SINT := -24; Value3 : SINT := -3; Value4 : SINT := 5; Lowest : SINT; END_VAR LD Value1 MIN Value2, Value3, Value4 ST Lowest END_PROGRAM MUX
(*Lowest: -24 *)
Multiplexer MUX ANY_INT *)
IN0
*)
IN1
. *) *)
38
K
*)
. IN6
a támogatott adattípusok: ANY_BIT, ANY_INT, ANY_DATE, TIME, STRING Az IN0…IN6 adattípusnak azonosnak kell lenni!
Függvények K
IN0 IN6
Kiválasztó operandus. Az operandus értéke adja meg, hogy melyik bemenetet kell a függvény értékeként visszaadni. Érvényes értékek, K = 0…6, ha Kennél nagyobb, akkor a legnagyobb érvényes értéket választja ki. max. 7 bemeneti érték, melyekből a legnagyobb kerül kiválasztásra …
Példaprogram: két bemeneti érték közüli választás PROGRAM select VAR IN_No : USINT := 2; Numb0 : INT := 15; Numb1 : INT := -123; Numb2 : INT := 1; SelectedNo : INT; MUX a, b, c, d, e, f, g, h, i, j, K : BYTE; result : BYTE; END_VAR LD IN_Nr MUX Numb0, Numb1, Numb2 ST SelectedNo (* SelectedNo: 1 *) END_PROGRAM SEL
feltételes operandus kiválasztás SEL BOOL
*) G IN0 IN1
G
*)
IN0
*)
IN1
*)
a támogatott adattípusok: ANY_BIT, ANY_INT, ANY_DATE, TIME, STRING Az IN1, IN2 adattípusnak azonosnak kell lenni! kiválasztási feltétel G = 0 estén kiválasztandó operandus G = 1 estén kiválasztandó operandus PROGRAM select VAR Text1 : STRING := 'ABC'; Text2 : STRING := 'abc'; SelectorSwitch AT %I0.0.0.0.3 : BOOL; Selected : STRING; END_VAR LD SelectorSwitch SEL Text1, Text2 ST Selected (* a változó tartalmát az I0.0.0.0.3 határozza meg *) END_PROGRAM
39
Funkcióblokkok 6.
Funkcióblokkok
A Sucosoft S40 a funkcióblokkok nagy választékát nyújtja a programozás részfeladatainak megkönnyítésére. Az IEC 1131-3 által definiált funkcióblokkokon kívül a Moeller Electric a PLC-khez további gyártó specifikus funkcióblokkokat is készített, melyek kihasználják a PLC egyedi adottságait. Ezek használata tovább könnyítheti az egyes felhasználói alkalmazások elkészítését. Az alábbiakban csoportosítva felsoroljuk a fontosabb funkcióblokkokat:
A.
Időzítők
MS_TimeFalling
elejtésre késleltetett időzítő (milliszekundumos megadással)...................... 95
MS_TimeRising
meghúzásra késleltetett időzítő (milliszekundumos megadással)................ 97
S_TimeFalling
elejtésre késleltetett időzítő (szekundumos megadással) ........................... 109
S_TimeRising
meghúzásra késleltetett időzítő (szekundumos megadással) ..................... 111
TimeGenerator
ütemadó impulzusgenerátor ....................................................................... 143
TimePulse
impulzusképző............................................................................................ 145
B.
Számlálók és összehasonlítások
16Bit_Compare
16 bites összehasonlítások............................................................................ 45
_16bitCounter
16-bites előre- / hátraszámláló ..................................................................... 46
C.
Dátum, idő műveletek
GetRealTimeClock valós idejű óra kiolvasása............................................................................. 89 RealTimeClock
valós idejű óra összehasonlítása egyedi bemeneti adatokkal ..................... 104
RTC
valós idejű óra állítása................................................................................ 108
SetRealTimeClock valós idejű óra állítása................................................................................ 128 DATconcat
dátum és idő (DATE_AND_TIME) típusú változó összeállítása egyedi UINT típusú adatokból ..................................................................... 68
DATsplit
dátum és idő (DATE_AND_TIME) típusú változó szétválasztása egyedi UINT típusú adatokra ....................................................................... 72
DateConcat
dátum (DATE) típusú változó összeállítása egyedi UINT típusú adatokból ..................................................................... 70
DateSplit
dátum (DATE) típusú változó szétválasztása egyedi UINT típusú adatokra ....................................................................... 71
TimeConcat
idő (TIME) típusú változó összeállítása egyedi UINT típusú adatokból ................................................................... 141
TimeSplit
idő (TIME) típusú változó szétválasztása egyedi UINT típusú adatokra ..................................................................... 150
TODconcat
napi idő (TOD) típusú változó összeállítása egyedi UINT típusú adatokból ................................................................... 152
40
Funkcióblokkok TODsplit
D.
napi idő (TOD) típusú változó szétválasztása egyedi UINT típusú adatokra ..................................................................... 153
Regiszter műveletek
SR_x
bites léptető regiszter.................................................................................. 130
SRB_x
bájtos lépető regiszter................................................................................. 133
SRW_x
szavas lépető regiszter................................................................................ 136
LifoBx
8-bites veremtár regiszter ............................................................................. 90
LifoWx
16-bites veremtár regiszter ........................................................................... 92
FifoBx
8-bites csőtár regiszter.................................................................................. 83
FifoWx
16-bites csőtár regiszter................................................................................ 86
E.
Kódkonvertálások
_16BitBinaryToBCD 16-bit bináris kódolású szám -> decimálissá alakítása ............................ 43 BCDTo16BitBinary decimális kódolású szám -> 16-bit binárissá alakítása ............................ 49
F.
Tömb/adatblokk műveletek
CompareArray
adatblokkok összehasonlítása, adott adat keresése a blokkban.................... 58
TransferArray
adatblokk másolása, inicializálása ............................................................. 154
Serialize
tetszőleges adatstruktúra bájtos tömbbe való másolása ............................. 125
Deserialize
tömbből tetszőleges formátumú adatok kiválasztása ................................... 77
BlockCompare
adatblokkok összehasonlítása, adott adat keresése a blokkban (címváltozók alkalmazásával) ...................................................................... 50
BlockTransfer
adatblokk másolása, inicializálása (címváltozók alkalmazásával)............... 55
G.
String feldolgozás
ADRtoSTR
vett adatbájtok STRING típusú változóvá alakítása (címváltozókkal) ........ 48
STRtoADR
STRING típusú változó adott címterületre másolása (címváltozókkal) .... 139
COMtoSTR
vett adatbájtok STRING típusú változóvá alakítása (tömbváltozókkal)...... 62
STRtoCOM
STRING típusú változó adott címterületre másolása (tömbváltozókkal) .. 140
H.
Kommunikáció
SCO
transzparens soros vonali kommunikáció .................................................. 115
DE4netK
DF4 frekvenciaváltók kommunikációs modulja .......................................... 74
MI4netK
MI4 kijelzők kommunikációs modulja ........................................................ 94
I.
Memóriakártya írás, olvasás
ReadMC
adatok olvasása a flash-memóriából ............................................................ 99
WriteMC
adatok írása a flash-memóriába.................................................................. 156
ReloadData
adatok olvasása a flash-memóriából (címváltozók alkalmazásával) ......... 102
SaveData
adatok írása a flash-memóriába (címváltozók alkalmazásával)................. 113
41
Funkcióblokkok J.
Megszakítás kezelések
CounterAlarm
számláló megszakításkezelés ....................................................................... 64
EdgeAlarm
változásfigyelés megszakításkezelés............................................................ 79
TimerAlarm
időzítéses megszakításkezelés.................................................................... 147
42
_16BitBinaryToBCD _16BitBinaryToBCD
16-bit bináris kódolású szám -> decimálissá alakítása _16BitBinaryToBCD BinaryValue
INT
Signed
BOOL
DecimalHigh
UINT
DecimalLow
UINT
Az operandusok jelentése: BinaryValue
a binárisan kódolt bemeneti érték
Signed
a BCD szám előjele, (0 = pozitív, 1 = negatív)
DecimalHigh
a BCD szám 5. dekádja
DecimalLow
a BCD szám 1.- 4. dekádjai
Leírás: 16 bites binárisan kódolt számot átalakít 5 dekás hosszúságú BCD számmá. Az előjel a Signed kimeneten jelenik meg. ( 0 ⇒ + , 1 ⇒ - ) 4. dekád
3. dekád
2. dekád
1. dekád
DecimalLow 5. dekád DecimalHigh bináris szám
BCD
Signed
DecimalHigh
DecimalLow
0000
0
0
0
0
0
0
0
0
0
0
0001
1
0
0
0
0
0
0
0
0
1
..
..
7FFF
32767
0
0
0
0
3
2
7
6
7
8000
-32768
1
0
0
0
3
2
7
6
8
8001
-32767
1
0
0
0
3
2
7
6
7
0
0
0
0
0
0
0
1
.. FFFF
.. -1
1
43
_16BitBinaryToBCD Példaprogram: PROGRAM du16_bcd VAR Converter1 : _16BitBinaryToBCD; BinaryNumb : INT; Sign : BOOL; HighNumber : UINT; LowNumbers : UINT; END_VAR CAL Converter1(BinaryValue := BinaryNumb) LD Converter1.Signed ST Sign LD Converter1.DecimalHigh ST HighNumber LD Converter1.DecimalLow ST LowNumbers END_PROGRAM
44
_16Bit_Compare _16Bit_Compare _16Bit_Compare INT
InputValue1
Greater
BOOL
INT
InputValue2
Equal
BOOL
Less
BOOL
Az operandusok jelentése: InputValue1
első összehasonlítandó szám
InputValue2
második összehasonlítandó szám
Greater
eredmény: első szám nagyobb
Equal
eredmény: a két szám egyenlő
Less
eredmény: első szám kisebb
Leírás: A funkcióblokk a két bemeneti szám értékét hasonlítja össze. Az eredméyn három biten jelenik meg. Less
Equal
Greater
InputValue1 < InputValue2
1
0
0
InputValue1 = InputValue2
0
1
0
InputValue1 > InputValue2
0
0
1
Példaprogram: PROGRAM length VAR Compare_length : _16Bit_Compare; Length1 : INT := 10; Length2 : INT := 10; L1_equal_L2 : BOOL; END_VAR CAL Compare_length(InputValue1 := Length1, InputValue2 := Length2) LD Compare_length.Equal ST L1_equal_L2 END_PROGRAM
45
_16BitCounter _16BitCounter
16-bites előre- /hátraszámláló _16BitCounter
BOOL
Forward
BOOL
Backward
BOOL
Set
BOOL
ReSet
UINT
Zero OutputValue
BOOL UINT
InputValue
Az operandusok jelentése: Forward
Előreszámlálás, felfutó él
Backward
Visszaszámlálás, felfutó él
Set
Érték beírás, felfutó él
ReSet
Visszaállítás, törlés.
InputValue
Beírandó érték
Zero
Jelzés: számláló állapota=0
OutputValue
Számláló aktuális értéke
Leírás: A funkcióblokk impulzusok előre- / hátraszámlálására szolgál. A Forward bemenetre jutó felfutó él eggyel növeli, a Backward bemenetre jutó felfutó él eggyel csökkenti a számláló tartalmát. A számláló aktuális értéke az OutputValue kimeneten leolvasható. A Set bemenetre adott felfutó éllel lehet az InputValue értékét a számlálónak átadni. A ReSet bemenetre adott 1-el a számláló tartalma törölhető, tartós 1-el pedig a számláló letiltásra kerül. A számláló értelmezési tartománya: 0…..65535. A számok gyűrűszerűen körbefutják a tartományt. Ha számláló nem remanensként van deklarálva, akkor minden kezdéskor 0 értéket vesz fel, és így a Zero kimenet 1-t vesz fel. Remanens deklarálás esetén a számláló megtartja eredeti értékét. Megjegyzés! A pulzusok hosszának és a pulzusok közti szünetidőnek legalább egy-egy ciklusidőnél hosszabbnak kell lennie, hogy a számláló minden számlálandó pulzust figyelembe 1 vegyen. a maximális számlálási frekvencia: F = 2 * TCiklusidő
46
_16BitCounter Példaprogram: PROGRAM parts_16 VAR RETAIN Count_parts : _16BitCounter; END_VAR VAR Light_barrier AT %I0.0.0.0.0 : BOOL; Quantity UINT; Clear : AT %I0.0.0.0.1 : BOOL; END_VAR CAL Count_parts(Forward := Light_barrier, ReSet := Clear) LD Count_parts.OutputValue ST Quantity END_PROGRAM
47
ADRtoSTR ADRtoSTR
vett adatbájtok STRING típusú változóvá alakítása ADRtoSTR TextSring
ANY_STRING BOOL
Enable
UINT
StrLen
TextSring
ReceiveVariable
ADDRESS Az operandusok jelentése: Enable
Az átalakítási folyamat engedélyezése
StrLen
Az átalakítandó jelek száma
ReceiveVariable
A memóriaterület kezdőcíme, ahol az adatok találhatók
TextSring
Karakterlánc, mely a memóriaterület adataiból létrejött.
Leírás: A soros vonalon vett és az adott memóriaterületen elhelyezett adatokat a funkcióblokk átalakítja egy STRING típusú változóvá. Az Enable bemenetre adott 1es szinttel indítható az átalakítási művelet. Az StrLen bemenetre adott számmal lehet az átalakítandó karakterek számát, azaz az eredményül kapott STRING változó hosszát megadni. Amennyiben a deklarálás során a STRING változó karakterhossza rövidebb a vételi tömbben elhelyezett adatok számánál, akkor csak a STRING változóban definiált hosszúságú adatok kerülnek beolvasásra. Példaprogram: PROGRAM Str_Gen VAR Marker_to_String : ADRtoSTR; ReceiveText : STRING(4) := ´'HALT'; StartAddress AT %MB0.0.0.100 : ARRAY[1..20] OF BYTE; ReceiveLength : UINT := 4; END_VAR CAL Marker_to_String(Enable := 1, StrLen := ReceiveLength, ReceiveVariable := &StartAddress, TextString := ReceiveText) (* A karaterláncot a %MB0.0.0.100-től kezdődő adatokkal tölti fel! *) END_PROGRAM
48
BCDTo16BitBinary BCDTo16BitBinary
Decimális kódolású szám -> 16-bit binárissá alakítása BCDTo16BitBinary Signed
BOOL
BinaryValue
INT
DecimalValue
UINT Az operandusok jelentése: Signed
a BCD szám előjele, (0 = pozitív, 1 = negatív)
DecimalValue
a BCD szám (4 dekádban)
BinaryValue
a binárisan kódolt kimeneti érték
Leírás: 4 dekádos binárisan kódolt előjeles decimális számot átalakít előjeles bináris számmá. dekás hosszúságú BCD számmá. Értéktartomány: -9999…+9999. A konvertálandó 4 dekádos BCD számok: +11, +9999, -1311, -9999. Signed
DecimalValue
BinaryValue (hexadecimális)
BinaryValue (előjeles, decimális)
0
0
0
1
1
B
11
0
9
9
9
9
270F
9999
1
1
2
1
1
FAE1
-1311
1
9
9
9
9
DBF1
-9999
Példaprogram: PROGRAM bcd_du16 VAR Converter3 : BCDTo16BitBinary; DecimalNumber : UINT := 13; Sign : BOOL := 0; BinaryNumber : INT; END_VAR CAL Converter3(Signed := Sign, DecimalValue := DecimalNumber) LD Converter3.BinaryValue ST BinaryNumber END_PROGRAM
49
Blockcompare BlockCompare
adatblokkok összehasonlítása, adott adat keresése a blokkban (címváltozók alkalmazásával) BlockCompare
BOOL
Mode
ADDRESS
SourceAddress
ADDRESS
DestinationAddress
USINT
Greater
BOOL
Equal
BOOL
Less
BOOL
Output
USINT
Error
USINT
ElementNumber
Az operandusok jelentése: Mode
üzemmód: (0 = adatkeresés, 1 = blokk összehasonlítás)
SourceAddress
a forrástartomány kezdőcíme
DestinationAddress céltartomány kezdőcíme ElementNumber
másolandó elemek száma
Greater
összehasonlítás eredménye nagyobb jelzés
Equal
összehasonlítás eredménye azonos jelzés
Less
összehasonlítás eredménye kisebb jelzés
Output
pozíció megadása, hol van az első eltérés, vagy a keresett adat helye
Error
hibajelzés
Leírás: A funkcióblokknak kétféle üzemmódja van (adat keresés, és adatterületek összehasonlítása), Az üzemmód választás a Mode bemenetre adott értékkel történhet. Új fejlesztések esetén a BlockCompare helyett a CompareArray funkcióblokkot ajánlott alkalmazni! Keresési üzemmód A keresés üzemmód egy adatterületen elhelyezkedő egyedi érték megkeresésére szolgál. A keresendő adatot a SourceAddress bemeneten megadott című változó tartalmazza. Az ellenőrizendő tartomány kezdőcímét a DestinationAddress bemeneten levő változó, a tartomány nagyságát az ElementNumber bemenet adja meg. (A változócímeket a címváltozó elé írt & címoperátor jelzi. Ha a megadott helytől kezdve (DestinationAddress) átvizsgálva, a kijelölt területen belül (ElementNumber) a funkcióblokk megtalálja a keresett adatot (SourceAddress),
50
BlockCompare akkor a megtalált adat helyzete az Output kimeneten megjelenik, és az Equal kimenet magasba ( =1 ) kerül. A kimenetek állapota, amikor az értéket megtalálta az alábbi: Output = 0 …. (ElementNumber - 1)
Equal = 1; Less = Greater = 0
Ha a megadott értéket nem találja meg a kijelölt területen, akkor az Output kimenet egyenlő az ElementNunber változóval, az Equal kimenet = 0 lesz, a Less és a Greater kimenetek pedig az utolsó adatérték összehasonlításkor felvett értékűket tartják meg. A kimenetek állapota, amikor az értéket nem találta meg, tehát az alábbi: Output = ElementNumber
Equal = 0;
Less =1, Greater = 0 (Less = 0, Greater = 1)
A következő példa a MB23 merker bájtban tárolt "7D" értéket keresi a MB27 és a MB32 által határolt adatterületen Változócímek
Eredmény
Output = 3
változó értékek
%MB0.0.0.23
7D
%MB0.0.0.24
00
%MB0.0.0.25
00
%MB0.0.0.26
00
%MB0.0.0.27
3D
%MB0.0.0.28
70
%MB0.0.0.29
4D
%MB0.0.0.30
7D
%MB0.0.0.31
7D
%MB0.0.0.32
7D
%MB0.0.0.33
00
%MB0.0.0.34
00
Less = 0 Equal= 1
találatkor abbahagyja a keresési eljárást
Greater = 0 A "7D" értéket a DestinationAddress + (Output értéke) címen találta meg. ( Jelen esetben MB 27 + 3 )
51
Blockcompare Példaprogram: PROGRAM search VAR search_fb : BlockCompare; SourceAddress AT %MB0.0.0.23 : BYTE := 16#7D; (* a 23. bájt Marker 7Dhex kezdeti értékkel van inicializálva *) DestinationAddress AT %MB0.0.0.27 : BYTE; Start AT %I0.0.0.0.0 : BOOL; (* keresés indítása *) Found : USINT; Result_greater : BOOL; Result_equal : BOOL; Result_less : BOOL; END_VAR LD Start CALC search_fb(Mode := 0, (* keresési üzemmód! *) SourceAddress := &SourceAddress, DestinationAddress := &DestinationAddress, ElementNumber := 6 (* keresési tartomány: 6 bájt *) ) LD search_fb.Output ST Found (* találati hely, ahol az első azonosság kiderült *) (* értéke: "DestinationAddress" + "Output" *) LD search_fb.Greater ST Result_greater LD search_fb.Equal ST Result_equal LD search_fb.Less ST Result_less END_PROGRAM Összehasonlítási üzemmód Az adatterület összehasonlítási üzemmód két adatterület tartalmát hasonlítja össze. Az adatterületek kezdeteit a SourceAddress, és a DestinationAddress bemeneteken, az összehasonlítandó terület méretét az ElementNumber bemeneten kell megadni. Ha a két adatterület tartalma azonos, akkor az Output kimeneten az ElementNumber értéke jelenik meg, az Equal kimenet pedig 1-el jelzi az azonosságot. A kimenetek állapota, amikor az adatterületek azonosak az alábbi: Output = ElementNumber;
EQ = 1;
LT = 0;
GT = 0;
Ha a megadott adatterületek nem azonosak, akkor az Output kimenet jelzi az első eltérő adat helyét. Az Equal = 0 jelzi a különbséget, a Less és a Greater kimenetek az eltérő adatértékek összehasonlításkor felvett viszonyt mutatják. A kimenetek állapota, amikor az adatterületek nem azonosak az alábbi: Output = 0 …. (ElementNumber – 1);
52
EQ = 0;
Less =1, Greater = 0 (Less = 0, Greater = 1)
BlockCompare A következő példa a MB23 és MB26 közötti bájtok tartalmát hasonlítja össze az MB30 és a MB 33 közötti bájtok tartalmával. Változócímek
Eredmény
Output = 4
változó értékek
%MB0.0.0.23
7D
%MB0.0.0.24
3B
%MB0.0.0.25
64
%MB0.0.0.26
A6
%MB0.0.0.27
00
%MB0.0.0.28
00
%MB0.0.0.29
00
%MB0.0.0.30
7D
%MB0.0.0.31
3B
%MB0.0.0.32
64
%MB0.0.0.33
A6
%MB0.0.0.34
00
Less = 0
összehasonlítás eredménye
Equal = 1 Greater = 0 A két adatterület azonos (Equal = 1 és az Output = ElementNumber). Példaprogram: PROGRAM compare VAR compare_fb : BlockCompare; SourceAddress AT %MB0.0.0.23 : BYTE; DestinationAddress AT %MB0.0.0.30 : BYTE; Start AT %I0.0.0.0.0 : BOOL ; Discrepancy : USINT; Result_greater : BOOL; Result_equal : BOOL; Result_less : BOOL; END_VAR
(* összehasonlítás indítás *)
53
Blockcompare LD Start CALC compare_fb(Mode := 1, (* összehasonlítási üzemmód! *) SourceAddress := &SourceAddress, DestinationAddress := &DestinationAddress, ElementNumber := 4) (* összehasonlítandó blokkméret: 4*) LD such_fb.Output ST Discrepancy LD such_fb.Greater ST Result_greater LD such_fb.Equal ST Result_equal LD such_fb.Less ST Result_less END_PROGRAM
54
(*első pozícíó, ahol eltérés volt *) (* DestinationAddress + Output *)
BlockTransfer BlockTransfer
adatblokk másolása, inicializálása (címváltozók alkalmazásával) BlockTransfer
BOOL
Mode
ADDRESS
SourceAddress
ADDRESS
DestinationAddress
USINT
ElementNumber
Error
USINT
Az operandusok jelentése: Mode
üzemmód: (0 = inicializálás, 1 = blokk másolás)
SourceAddress
a forrástartomány kezdőcíme
DestinationAddress céltartomány kezdőcíme ElementNumber
másolandó elemek száma
Error
hibajelzés
Leírás: A funkcióblokknak kétféle üzemmódja van (adatok inicializálása, és adatterület másolása). Az üzemmód választás a Mode bemenetre adott értékkel történhet. Az ElementNumber bemenetre adott szám a az adatblokk nagyságát adja meg bájtban kifejezve. Az Error kimeneten az esetleges hibakód jelenik meg: 0
nincs hiba,
1
az elemek száma (ElementNumber) nulla.
2
érvénytelen forráscím a SourcsAddresse bemeneten
3
érvénytelen céltartomány cím a SourcsAddresse bemeneten
4
a forráscím azonos a céltartomány címével Új fejlesztések esetén a BlockTransfer helyett a TransferArray funkcióblokkot ajánlott alkalmazni!
Másolási üzemmód A másolás üzemmód egy adott adatterületen elhelyezkedő adatmennyiséget visz át egy másik területre. A másolandó tartomány kezdőcímét a SourceAddress bemeneten
55
BlockTransfer megadott című változó tartalmazza. A céltartomány kezdőcímét a DestinationAddress bemeneten levő változó címe, a tartomány nagyságát az ElementNumber bemenet adja meg. (A változócímeket a címváltozó elé írt & címoperátor jelzi. Példaprogram: A következő példa a MB23-tól az MB26ig terjedő merker bájtban tárolt értéket viszi át az MB30-tól az MB33ig terjedő adatterületre. Változócímek
változó értékek
%MB0.0.0.23
7D
%MB0.0.0.24
3B
%MB0.0.0.25
64
%MB0.0.0.26
A6
%MB0.0.0.27
00
%MB0.0.0.28
00
%MB0.0.0.29
00
%MB0.0.0.30
7D
%MB0.0.0.31
3B
%MB0.0.0.32
64
%MB0.0.0.33
A6
%MB0.0.0.34
00
PROGRAM copy VAR copy_fb : BlockTransfer; SourceAddress AT %MB0.0.0.23 : BYTE; DestinationAddress AT %MB0.0.0.30 : BYTE; Start AT %I0.0.0.0.0 : BOOL; END_VAR
(* másolás indítása*)
LD Start CALC copy_fb(Mode := 1, (* másolás üzemmód! *) SourceAddress := &SourceAddress, DestinationAddress := &DestinationAddress, ElementNumber := 4) (* másolandó elemek száma konstans *) END_PROGRAM
56
BlockTransfer Inicializálási üzemmód Az inicializálási üzemmódban egy adott adott értéket ír be egy kijelölt tartomány minden változójába. A másolandó változó címét a SourceAddress bemeneten megadott című változó tartalmazza. A céltartomány kezdőcímét a DestinationAddress bemeneten levő változó címe, a tartomány nagyságát az ElementNumber bemenet adja meg. (A változócímeket a címváltozó elé írt & címoperátor jelzi. Példaprogram: A következő példa a MB23 merker bájtban tárolt "7D" értéket viszi be a MB27 és a MB32 által határolt adatterületre Változócímek
változó értékek
%MB0.0.0.23
7D
%MB0.0.0.24
00
%MB0.0.0.25
00
%MB0.0.0.26
00
%MB0.0.0.27
7D
%MB0.0.0.28
7D
%MB0.0.0.29
7D
%MB0.0.0.30
7D
%MB0.0.0.31
7D
%MB0.0.0.32
7D
%MB0.0.0.33
00
%MB0.0.0.34
00
PROGRAM init VAR init_fb : BlockTransfer; SourceAddress AT %MB0.0.0.23 : BYTE := 16#7D; (* MarkerByte 23 initialised with the data value 7D *) DestinationAddress AT %MB0.0.0.27 : BYTE; Start AT %I0.0.0.0.0 : BOOL; (* a művelet indítása *) END_VAR LD Start CALC init_fb(Mode := 0, (* inicializálási üzemmód! *) SourceAddress := &SourceAddress, DestinationAddress := &DestinationAddress, ElementNumber := 6) (* elemek száma konstans: 6bájt *) END_PROGRAM
57
CompareArray CompareArray
adatblokkok összehasonlítása, adott adat keresése a blokkban CompareArray Source
ANY_ARRAY
Destination
ANY_ARRAY BOOL
Source Destination
Mode Greater
BOOL
DestinationOffset
Equal
BOOL
ElementNumber
Less
BOOL
UINT
SourceOffset
UINT UINT
Output Error
UINT USINT
Az operandusok jelentése: Mode
üzemmód: (0 = adatkeresés, 1 = blokk összehasonlítás)
Source
a forrástömb
Destination
céltömb
SourceOffset
a forrástömbbön belüli eltolás értéke
DestinationOffset
a céltömbbön belüli eltolás értéke
ElementNumber
másolandó bájtok száma
Greater
összehasonlítás eredménye nagyobb jelzés
Equal
összehasonlítás eredménye azonos jelzés
Less
összehasonlítás eredménye kisebb jelzés
Output
pozíció megadása, hol van az első eltérés, vagy a keresett adat helye
Error
hibajelzés
Leírás: A funkcióblokknak kétféle üzemmódja van (adat keresés, és adatterületek összehasonlítása), Az üzemmód választás a Mode bemenetre adott értékkel történhet. A forrás és a cél-tömb tetszőleges nagyságú tömb lehet. A tömb típusa ANY_INT vagy ANY_BIT lehet, kivéve a BOOL (bites) tömböket. Az Error kimenet a következő értékeket veheti fel:
58
0
nincs hiba,
1
az elemek száma (ElementNumber) nulla.
2
A SourceOffset értéke nagyobb, mint a Source tartomány értéke
CompareArray 3
Az elemek száma túllépi a a forrástartomány értékét
4
A DestinationOffset értéke nagyobb, mint a Destination tartomány értéke
5
Az elemek száma túllépi a céltartomány értékét
Keresési üzemmód A keresés üzemmód egy tömben elhelyezkedő egyedi érték megkeresésére szolgál. A keresendő adatot a Source bemeneten megadott tömb a SourceOffset által megadott változója tartalmazza. Az ellenőrizendő tartomány kezdetét a Destination bemeneten levő tömb és a DestinationOffset változó együttesen adja meg. Az átvizsgálandó blokk hosszát az ElementNumber határozza meg. Ha az átvizsgálás során a funkcióblokk a céltartomány és az elemszám által meghatározott területen a keresett adatot megtalálja, akkor a megtalált adat helyzete az Output kimeneten megjelenik, és az Equal kimenet magasba (=1) kerül. A kimenetek állapota, amikor az értéket megtalálta az alábbi: Output = 0 …. (ElementNumber - 1)
Equal = 1; Less = Greater = 0
Ha a megadott értéket nem találja meg a kijelölt területen, akkor az Output kimenet egyenlő az ElementNumber változóval, az Equal kimenet = 0 lesz, a Less és a Greater kimenetek pedig az utolsó adatérték összehasonlításkor felvett értékűket tartják meg. A kimenetek állapota, amikor az értéket nem találta meg, tehát az alábbi: Output = ElementNumber
Equal = 0;
Less =1, Greater = 0 (Less = 0, Greater = 1)
A következő példa a MB23 merker bájtban tárolt "7D" értéket keresi a MB27 és a MB32 által határolt adatterületen Példaprogram: PROGRAM search VAR search_fb : CompareArray; SourceAddress AT %MB0.0.0.23 : ARRAY [1..1] OF BYTE := [16#7D]; (* Az MB23 7D kezdeti értéket kap *) DestinationAddress AT %MB0.0.0.27 : ARRAY [1..1] OF BYTE; Start AT %I0.0.0.0.0 : BOOL; Found : UINT; Result_greater : BOOL; Result_equal : BOOL; Result_less : BOOL; END_VAR
59
CompareArray LD Start CALC search_fb(Mode := 0, (* keresési üzemmód *) Source := SourceAddress, Destination := DestinationAddress, ElementNumber := 6) (* keresési tartomány hossza: 6 bájt *) LD search_fb.Output ST Found
(* keresett érték helye: Destination + Output *)
LD search_fb.Greater ST Result_greater LD search_fb.Equal ST Result_equal LD search_fb.Less ST Result_less END_PROGRAM Összehasonlítási üzemmód Az adatterület összehasonlítási üzemmód két adatterület tartalmát hasonlítja össze. Az adatterületek kezdeteit a Source és a SourceOffset, valamint a Destination és a DestinationOffset bemenetek határozzák meg. Az összehasonlítandó terület méretét az ElementNumber bemeneten kell megadni. Ha a két adatterület tartalma azonos, akkor az Output kimeneten az ElementNumber értéke jelenik meg, az Equal kimenet pedig 1-el jelzi az azonosságot. A kimenetek állapota, amikor az adatterületek azonosak az alábbi: Output = ElementNumber;
EQ = 1;
LT = 0;
GT = 0;
Ha a megadott adatterületek nem azonosak, akkor az Output kimenet jelzi az első eltérő adat helyét. Az Equal = 0 jelzi a különbséget, a Less és a Greater kimenetek az eltérő adatértékek összehasonlításkor felvett viszonyt mutatják. A kimenetek állapota, amikor az adatterületek nem azonosak az alábbi: Output = 0 …. (ElementNumber – 1); EQ = 0;
Less =1, Greater = 0 (Less = 0, Greater = 1)
A következő példa a MB23 és MB26 közötti bájtok tartalmát hasonlítja össze az MB30 és a MB 33 közötti bájtok tartalmával. Példaprogram: PROGRAM compare VAR compare_fb : CompareArray; SourceAddress AT %MB0.0.0.23 : ARRAY [1..7] OF BYTE := [16#7D]; DestinationAddress AT %MB0.0.0.30 : ARRAY [1..7] OF BYTE := [16#7D];
60
CompareArray Start AT %I0.0.0.0.0 : BOOL; Deviation : USINT; Result_greater : BOOL; Result_equal : BOOL; Result_less : BOOL; END_VAR LD Start CALC compare_fb(Mode := 1, Source := SourceAddress, Destination := DestinationAddress, ElementNumber := 4) LD compare_fb.Output ST Deviation LD compare_fb.Greater ST Result_greater LD compare_fb.Equal ST Result_equal LD compare_fb.Less ST Result_less
(* összehasonlítási mód*) (* összehasonlítási tartomány: 4bájt *) (* eltérés helye: Destination" + Output *)
END_PROGRAM
61
COMtoSTR COMtoSTR
vett adatbájtok STRING típusú változóvá alakítása COMtoSTR ReceiveVariable
ANY_ARRAY
TextString
ANY_STRING UINT
StrLen
BOOL
Enable
ReceiveVariable TextString
Az operandusok jelentése: ReceiveVariable
A tömb kezdőcíme, ahol az adatok találhatók
TextSring Karakterlánc, mely a tömb adataiból létrejött. StrLen
Az átalakítandó jelek száma
Enable
Az átalakítási folyamat engedélyezése
Leírás: A soros vonalon vett és az adott tömbterületen elhelyezett adatokat a funkcióblokk átalakítja egy STRING típusú változóvá. Az Enable bemenetre adott 1-es szinttel indítható az átalakítási művelet. Az StrLen bemenetre adott számmal lehet az átalakítandó karakterek számát, azaz az eredményül kapott STRING változó hosszát megadni. Amennyiben a deklarálás során a STRING változó karakterhossza rövidebb a tömbben elhelyezett adatok számánál, akkor csak a STRING változóban definiált hosszúságú adatok kerülnek beolvasásra. Példaprogram: PROGRAM Str_Gen VAR EnableReceive AT%I0.0.0.0.0 : BOOL; Array_to_String : COMtoSTR; ReceiveText : STRING(20): ReceiveArray : ARRAY[1..20] of Byte; ReceiveLength: UINT; ReceiveFromSerial : COM ; END_VAR (* Vett adatok a soros interfészről *) LD EnableReceive ANDN ReceiveFromSerial.ReceiveActive ST ReceiveFromSerial.ReceiveStrobe
62
COMtoSTR CAL ReceiveFromSerial(Mode := 1; ReceiveStrobe := ; SlotNumber := 0; (*PS4-300 esetén mindig 0 *) ReceiveNumber := 20 ; ReceiveVariable := ReceiveArray; | ReceiveActive := ; ReceivedBytes := ; ReceiveError := ; InterfaceStatus := ; SlotError := ) (* A karakterlánc másolása a tömbbe *) LD EnableReceive ANDN ReceiveFromSerial.ReceiveActive ST Array_to_String.Enable CAL Array_to_String(Enable := ; StrLen := ReceiveFromSerial.ReceivedBytes; TextString := ReceiveText, ReceiveVariable := ReceiveArray) END_PROGRAM
63
CounterAlarm CounterAlarm
számláló megszakításkezelés CounterAlarm BOOL
EnableDisable
USINT
Number
CountValue
UINT
UINT
Predivide
CallUpValue
UINT
UINT
SetpointValue
ANY_FUNCTION_BLOCK
Error
USINT
SubRoutine
Az operandusok jelentése: EnableDisable
Megszakításkérő funkcióblokk engedélyezése / tiltása, felfutó élvez. (engedély=1, tiltás=0)
Number
megszakításkérő csatornaszám (PS4-141/-151/-201/-341 = 0)
Predivide
Számláló előosztója
SetpointValue
Számláló alapjel
SubRoutine
megszakításkérést kiszolgáló funkcióblokk neve
Error
hibajelzés
CountValue
aktuális számlálóérték
CallUpValue
megszakításkérő hívások száma
Leírás: A funkcióblokk az alapkészülék (PS4-150/200/-300) %I0.0.0.0.0 bemenetéhez van hozzárendelve. Az EnableDisable bemenet engedélyezi a számláló működését. A számláló indul, ha a bemeneten pozitív él váltás (0 → 1) következik be. A számláló leáll, és törlődik, ha ez a bemenet visszakapcsol (1 → 0). A CountValue kimeneten a hardverszámláló aktuális értéke látható A Predivide bemenet (értéktartománya: 1…65535) azt határozza meg, hogy mennyi impulzusnak kell a hardver bemenetre érkezni, hogy a számláló tartalma eggyel növekedjen. (előosztó funkció) A SetpointValue bemenet (értéktartománya: 1…65535) határozza meg, hogy a számláló mely értékénél kell a megszakítás, azaz mikor kell a funkcióblokkot felhívni.
64
CounterAlarm A rendszer maximálisan megengedett kiterhelése három tényező együttesétől függ: A Predivide, a SetpointValue értékétől és a rákapcsolt jel frekvenciájától. A nevezett tényezőket úgy kell megválasztani, hogy milliszekundumonként maximálisan két megszakítás lépjen csak fel. Az Error kimenet tartalmazza az esetleges fellépő hibák kódjait: 0 nincs hiba 1 alapjel (SetpointValue) = 0 2 előosztó (Predivide) = 0 3 érvénytelen megszakításkérő csatornaszám (csak a PS4-300 estén) 4 megszakításkérő csatornaszámot már felhasználták (csak a PS4-300 estén) 5 a számláló csatorna nincs fel- / leszámlálóként paraméterezve (csak a PS4-300 estén) A CounUpValue kimenet (értéktartomány: 0…65535) jelzi, hogy az alapjel értéket hányszor érte el a számláló, azaz hányszor történhetett megszakítás. Az SubRoutine bemenet biztosítja az eseményvezérelt programvezérlés beillesztését. Ennek érdekében ezen a bemeneten lehet a megszakításkérést kiszolgáló funkcióblokk nevét megadni. Mikor az esemény bekövetkezik (a CounterValue számláló eggyel növekszik) és az alprogram végrehajtódik. Ha erre a bemenetre nincs funkcióblokk kapcsolva, akkor csak a CounterValue számláló tartalma nő, és nincs megszakításkérés kiszolgálás. A megszakításkérést kiszolgáló funkcióblokk nem tartalmazhat sem bemenő, sem kimenő paramétereket. Egy ilyen funkcióblokk csak lokális változókat, vagy csak a főprogramban deklarált globális változókat, mint külső változókat (VAR_EXTERNAL) tartalmazhat. Eseményvezérelt program alkalmazásakor az alábbi szempontokat kell figyelembe venni: • Az esemény bekövetkezte a felhasználói program végrehajtását megszakítja, a regiszterek állapotát elmenti, és a SubRoutine bemeneten megadott címre ugorva végrehajtja az alprogramot. A megszakításkérő funkcióblokk nem szakítható meg egy másik megszakításkérő funkcióblokkal (az összes megszakításkérő funkcióblokknak azonos a prioritása). • A felhasználói program 5ms időtartamra (kb. 1000 utasítássor végrehajtása) korlátozza a megszakításkérő funkcióblokk végrehajtási idejét, mivel a megszakításkérő funkcióblokk működését a rendszerprogram sem tudja (még tápkimaradáskor sem) megszakítani. Ha a végrehajtási idő túllépi ezt a korlátot, akkor a táp kikapcsolásakor EDC hiba keletkezhet. • A megszakításkérő funkcióblokk végrehajtási ideje hozzáadódik a felhasználói program végrehajtási idejéhez, így a ciklusidő ellenőrzésbe is bekerül! • Mivel az eseményvezérelt program futtatásakor korlátozás nélkül elérhetők a globális változók is, a ciklikus felhasználói program és az eseményvezérelt program által közösen irható /olvasható adatokat reteszelés nélkül nem szabad
65
CounterAlarm felhasználni. Például a ciklikus felhasználói programban és a megszakításkérő funkcióblokkban ugyanabban a bájtban használt bithozzáférést csak a Disable_Interrupt és a Enable_Interrupt utasításokkal való szinkronizálással szabad korrekten végrehajtani. • A lehető leggyorsabb reagálás érdekében a megszakításkérő funkcióblokkban célszerű a közvetlen periféria hozzáférést használni, melyek az alapkészüléken állnak rendelkezésre (%QP0.0.0.0.x, %QPB0.0.0.0). • A megszakításkérő funkcióblokkok az alkalmazói programban elvileg többször is használhatók, de ezt általában kerülni érdemes, mivel a megszakításkérő funkcióblokk típusok ugyanazzal az eseményforrással, és így a programban csak az utoljára érvényesülő funkcióblokk határozza meg feldolgozást. A többszöri felhasználás azt jelenti, hogy az egyedi funkcióblokk-típus minden egyes alkalmazásához külön-külön adatterületet foglal le. A megszakításkérő funkcióblokkok bemeneteinek értékadása csak a híváskor történő zárójeles értékadással történhet. Közvetlen paraméter hozzárendelés a zárójelen kívül, vagy a hívást követően nem megengedett!
impulzusok
max: 3kHz
%I0.0.0.0.0 Predivide=5 SetpointValue=1 CountValue
0
1
2
3
4
0
1
2
3
4
0
...
CallUpNumber
0
0
0
0
0
1
1
1
1
1
2
...
0
Ugrás a funkcióblokkra Predivide =65535 SetpointValue =1 CountValue
0
1
2
3
4
..
..
..
..
65535
CallUpNumber
0
0
0
0
0
0
0
0
0
0
..
..
0
1
Ugrás a funkcióblokkra Predivide =3 SetpointValue =2 CountValue
0
1
2
0
1
2
0
1
2
0
1
2
0
1
CallUpNumber
0
0
0
0
0
0
1
1
1
1
1
1
2
2
Ugrás a funkcióblokkra
66
CounterAlarm Példaprogram: PROGRAM calarm VAR CountAlarm : CounterAlarm; Error : USINT; CountValue : UINT; END_VAR (* CounterAlarm funkcióblokk hívása számlálandó impulzusok a %I0.0.0.0.0 bemeneten *) LD ICS PLC_Message CALC CountAlarm(EnableDisable := 1, Number := 0, Predivide := 100, SetpointValue := 1)
(* Első programciklus vizsgálata, *) (* mert a a megszakításkérő FB-t *) (* csak egyszer kell hívni! *)
LD CountAlarm.Error ST Error LD CountAlarm.CountValue ST CountValue
(* Mutatja az aktuális értéket *)
END_PROGRAM
67
DATconcat DATconcat
dátum és idő (DATE_AND_TIME) típusú változó összeállítása egyedi UINT típusú adatokból DATconcat UINT
MilliSecond
UINT
Second
UINT
Minute
UINT
Hour
UINT
Day
UINT
Month
UINT
Year
OutputDAT Error
DT BOOL
Az operandusok jelentése: MilliSecond
dátum idő változó milliszekundum része
Second
dátum idő változó szekundum része
Minute
dátum idő változó perc része
Hour
dátum idő változó óra része
Day
dátum idő változó nap része
Month
dátum idő változó hónap része
Year
dátum idő változó év része
OutputDAT
az eredményül kapott dátum idő változó
Error
Hibajelzés
Leírás: A bemenetként UINT formátumban megadott egyedi értékeket a funkcióblokk a DAT_AND_TIME (DT) formátumú változóvá alakítja. Az egyes bemeneti értékek a nekik megfelelő értéktartományt nem léphetik át. Az év megengedett tartománya 1993….2092 között változhat. Amennyiben a megengedett értékeket túllépik, akkor az Error kimeneten jelenik. meg (= 1).
68
hiba
DATconcat Példaprogram: PROGRAM dtgen VAR DateTimeConcatenation : DATconcat; Millisecond : UINT; Second : UINT; Minute : UINT; Hour : UINT; Day : UINT; Month : UINT; Year : UINT; Error : BOOL; Date_1 : DATE_AND_TIME; END_VAR CAL DateTimeConcatenation(MilliSecond := Millisecond, Second := Second, Minute := Minute, Hour := Hour, Day := Day, Month := Month, Year := Year | Date_1 := OutputDAT, Error := Error) END_PROGRAM
69
DateConcat DateConcat
dátum (DATE) típusú változó összeállítása egyedi UINT típusú adatokból DateConcat UINT
Day
UINT
Month
UINT
Year
OutputDate
DATE
Error
BOOL
Az operandusok jelentése: Day
dátum változó nap része
Month
dátum változó hónap része
Year
dátum változó év része
OutputDAT
az eredményül kapott dátum változó
Error
Hibajelzés
Leírás: A bemenetként UINT formátumban megadott egyedi értékeket a funkcióblokk a DATE formátumú változóvá alakítja. Az egyes bemeneti értékek a nekik megfelelő értéktartományt nem léphetik át. Az év megengedett tartománya 1993….2092 között változhat. Amennyiben a megengedett értékeket túllépik, akkor az Error kimeneten jelenik. meg (= 1). Példaprogram: PROGRAM dategen VAR Dateconcaten : DateConcat; Datum : Date; Day : UINT; Month : UINT; Year : UINT; Error : BOOL; END_VAR CAL Dateconcaten(Day := Day, Month := Month, Year := Year | Datum := OutputDate, Error := Error) END_PROGRAM
70
hiba
DateSplit DateSplit
dátum (DATE) típusú változó szétválasztása egyedi UINT típusú adatokra DateSplit InputDate
DATE
Day
UINT
Month
UINT
Year
UINT
Error
BOOL
Az operandusok jelentése: InputDAT
a bemeneti dátum változó
Day
dátum változó nap része
Month
dátum változó hónap része
Year
dátum változó év része
Error
Hibajelzés
Leírás: A bemenetként DATE formátumban megadott változót a funkcióblokk UINT formátumú egyedi változókká alakítja át. Az év megengedett tartománya 1993….2092 között változhat, amennyiben az évszám a megengedett értékeket túllépi, akkor az Error kimeneten hiba jelenik. meg (= 1). Példaprogram: PROGRAM datetln VAR DateElements: DateSplit; Datum: Date := D#1999-12-24; Day : UINT; Month : UINT; Year : UINT; Error : BOOL; END_VAR CAL DateElements (InputDate := Datum | Day := Day, Month := Month, Year := Year, Error := Error) END_PROGRAM
71
DATsplit DATsplit
dátum és idő (DATE_AND_TIME) típusú változó szétválasztása egyedi UINT típusú adatokra DATsplit InputDAT
DT
MilliSecond
UINT
Second,
UINT
Minute
UINT
Hour
UINT
Day
UINT
Month
UINT
Year
UINT
Error
BOOL
Az operandusok jelentése: InputDAT
a bemeneti DATE_AND_TIME dátum idő változó
MilliSecond
dátum idő változó milliszekundum része
Second
dátum idő változó szekundum része
Minute
dátum idő változó perc része
Hour
dátum idő változó óra része
Day
dátum idő változó nap része
Month
dátum idő változó hónap része
Year
dátum idő változó év része
Error
Hibajelzés
Leírás: A bemenetként DATE_AND_TIME (DT) formátumban megadott változót a funkcióblokk UINT formátumú egyedi változókká alakítja át. Az év megengedett tartománya 1993….2092 között változhat, amennyiben az évszám a megengedett értékeket túllépi, akkor az Error kimeneten hiba jelenik. meg (= 1).
72
DATsplit Példaprogram: PROGRAM dtspalt VAR DT_Elements : DATsplit; Date_1 : DT := DT#1999-11-20-22:13:2; Millisecond : UINT; Second : UINT; Minute : UINT; Hour : UINT; Day : UINT; Month : UINT; Year : UINT; Error : BOOL; END_VAR CAL DT_Elements (InputDAT := Date_1 | Millisecond := MilliSecond, Second := Second, Minute := Minute, Hour := Hour, Day := Day, Month := Month, Year := Year, Error := Error) END_PROGRAM
73
DE4netK DE4netK
DF4 frekvenciaváltók kommunikációs modulja DE4netK
ARRAY [0..11] OF BYTE ARRAY [0..11] OF BYTE
SendData
SendData
ReadData
ReadData
BOOL
Enable
BOOL
Start
BOOL
Quickstop
BOOL
DCBrake
BOOL
TripReset
BOOL
ParameterSet
BOOL
MotorPotUp
BOOL
MotorPotDown
BOOL
FixedFrequency1
BOOL
FixedFrequency2
BOOL
FixedFrequency3
BOOL
Reversal
BOOL
FreezeRamp
INT
StatusWord
ReferenceFrequency
BYTE
Command
UINT
ParameterNumber
ActualFrequency
INT
EchoCommand
BYTE
EchoParameterNumber
UINT
Busy UINT
TransmitValue
UINT
TransmitValueOffset
BOOL
ReceiveValue
UINT
ReceiveValueOffset
UINT
ErrorCode Az operandusok jelentése:
74
WORD
SendData
operátorlista a küldő regiszter számára
ReadData
operátorlista a fogadó regiszter számára
Enable
1: frekvenciaváltó engedélyezése 0: frekvenciaváltó tiltása
Start
1: motort az alapjelre felfutatni 0: motort megadott lassulással leállítani
Quickstop
1: motort quick-stop-lassulással leállítani
DCBrake
1: egyenáramú fékezést aktivizálni
USINT
DE4netK TripReset
0 -> 1 átmenettel az aktuális hibajel törölhető
ParameterSet
0: 1-es paraméterkészlet aktiválása 1: 2-es paraméterkészlet aktiválása
MotorPotUp
1: motorpoti felfelé funkció aktiválás
MotorPotDown
1: motorpoti lefelé funkció aktiválás
FixedFrequency1
1: 1. fix frekvencia kiválasztás, ha FixedFrequency2 és FixedFrequency3 azonosan 0.
FixedFrequency2
1: 2. fix frekvencia kiválasztás, ha FixedFrequency3 = 0
FixedFrequency3
1: 3. fix frekvencia kiválasztás
Reversal
motor forgásirányváltás
FreezeRamp
0. fordulatszám felfutás engedélyezés 1. fordulatszám felfutás letiltás
ReferenceFrequency
motorfordulatszám alapjel
Command
parancs végrehajtás, (0: nincs parancs, 1: paraméter olvasás, 2: paraméter írás)
ParameterNumber
az átveendő paraméter száma
TransmitValue
az átveendő paraméter értéke
TransmitValueOffset
a 65535-nél nagyobb paraméterek eltolási értéke
StatusWord
frekvenciaváltó status szava
ActualFrequency
aktuális frekvencia kijelzés
EchoCommand
végrehajtott parancs, (0: nincs parancs, 1: paraméter olvasás, 2: paraméter írás)
EchoParameterNumber a végrehajtott parancs száma Busy
1: a végrehajtás folyamatban jelzés
ReceiveValue
kiolvasott parméter érték
ReceiveValueOffset
a 65535-nél nagyobb kiolvasott paraméterek eltolási értéke
ErrorCode
hibajelzés
Leírás: A DE4netK funkcióblokk képezi az illesztő felületet az alkalmazói PLC program és a frekvenciaváltót a Suconet K buszra illesztő DE4-NET-K modul között. Miután a PLC és a DF4 között a kapcsolat felépült, minden további programozási ráfordítás nélkül a folyamatadatok folyamatosan olvashatók. A DF4 paramétereit a Suconet K-n keresztül lehet megváltoztatni. A reakcióidő alacsony értéken tartása érdekében a funkcióblokkot a be- illetve a kimenetek aktualizálása érdekében minden ciklusban csak egyszer érdemes meghívni! A funkcióblokk következő be-/kimenetei (folyamatadatok) minden egyes híváskor
75
DE4netK automatikusan íródnak illetve kiolvasásra kerülnek: Bemenetek: Enable, Start, Quickstop, DCBrake, TripReset, ParameterSet, MotorPotUp, MotorPotDown, FixedFrequency1, FixedFrequency2, FixedFrequency3, Reversal, FreezeRamp, ReferenceFrequency, Kimenetek: StatusWord, ActualFrequency A frekvenciaváltó összes további paraméterét a kiválasztott paramétercsatornán keresztül lehet írni, olvasni. A SendData és aReadData operátorokat a mindenkori első adási illetve vételi adatbájthoz kell hozzárendelni. Az ezt követő további 11bájt automatikusan a tömbbel deklarálásra kerül. A rendelkezésre álló paraméterekről, értelmezési tartományukról a status szóról a frekvenciaváltó kezelési utasítása ad felvilágosítást. Paraméterek olvasása: Az aktuális paraméter számát a ParameterNumber mezőbe beírni., Command = ’1 beállítani. A Busy automatikusan átvált 0 -> 1-re . Várni, amíg a Busy jel visszavált 0-ba. ha ErrorCode = 0, akkor a ReceiveValue és az esetleges ReceiveValueOffset értéket kiolvasni, melyek a kérdéses paraméter értékét adja vissza. ha ErrorCode ≠ 0, akkor ki kell értékelni a hibakód értékét. Command = 0 parancsot kiadni, és majd a indulhat a következő feladat. Paraméterek írása: Az aktuális paraméter számát a ParameterNumber mezőbe beírni, a TransmitValue és a TransmitValueOffset mezőkbe a kívánt paraméter értékét beírni. Command = ’2 beállítani. A Busy automatikusan átvált 0 -> 1-re . Várni, amíg a Busy jel visszavált 0-ba. ha ErrorCode = 0, a parancs helyesen végrehajtásra került. ha ErrorCode ≠ 0, a parancs nem lett végrehajtva, ki kell értékelni a hibakód értékét. Command = 0 parancsot kiadni, és majd a indulhat a következő feladat. A lehetséges hibakódok: 0 nincs hiba 1
érvénytelen szolgáltatás
5
érvénytelen paraméterszám
6
nem megengedett parancsparaméter
10
nincs hozzáférési jogosítvány, illetve írási kísérlet csak olvasható paraméterre
14
határérték túllépés
254 idő túllépés, ha a reakcióidő egy írási/olvasási megbízás esetén > 5sec. 255 egyéb hiba, a megbízás jelenleg nem hajtható végre.
76
Deserialize Deserialize
tömbből tetszőleges formátumú adatok kiválasztása Deserialize
ANY ANY_ARRAY UINT
Destination
Destination
Buffer BufferOffset
Buffer DestinationLength Error
UINT USINT
Az operandusok jelentése: Destination
cél változó
Buffer
forrástartomány
BufferOffset
eltolás értéke a céltartományon belül
DestinationLength a célváltozó hossza bájtban megadva Error
hibajelzés
Leírás: A Deserialize funkcióblokk egy tetszőleges típusú változót választ ki elő egy adott forrástartománynak egy megadott helyéről. Az előzetesen megadott helyet a Buffer és a BufferOffset változókkal lehet meghatározni. A DestinationLength kimeneti változó a céladatok hosszát adja meg bájtos méretben. A Buffer tetszőleges méretű tömb lehet, típusa ANY_BIT és ANY_INT értékű lehet, kivéve a BOOL típust. Az Error kimenet az alábbi értékeket veheti fel: 0
nincs hiba
1
puffer túllépés
2
az Offset a Bufferen kívül helyezkedik el
3
a Destination a Bufferen belül helyezkedik el
4
A DestinationLength értéke 0 A BOOL adattípus, mint forrásváltozó típus nem támogatott, és a fordítás során (Compiler) megfelelő hibajelzés jelentkezik! Nézd még a Serialize funkcióblokknál megemlítetteket is!
A következő példa 20bájt kimásolása egy 30bájtos tömbből!
77
Deserialize Példaprogram: PROGRAM sendstruct VAR deserie_fb : Deserialize; struct_buffer AT %RDB1.1.0.0 : ARRAY [1..30] OF BYTE; CheckSumOffset : UINT := 0; CheckSum : UINT; DTOffset : UINT := 2; ReceiveDatum : DT; (* vett adatok *) DataOffset: UINT := 10; ReceiveData :Array [1..20] OF BYTE; (* falhasználói adatok *) DeserializedLength : UINT; Error : USINT; END_VAR (* Vett adatok kiválasztása *) CAL deserie_fb(Destination := CheckSum, Buffer := struct_buffer, BufferOffset := CheckSumOffset, | DeserializedLength := DestinationLength) LD deserie_fb.Error USINT_TO_BOOL JMPC _Fail
(* történt hiba ? *) (* hibakezelés *)
CAL deserie_fb(Destination := ReceiveDatum, Buffer := struct_buffer, BufferOffset := DTOffset, | DeserializedLength := DestinationLength) LD deserie_fb.Error USINT_TO_BOOL JMPC _Fail
(* történt hiba ? *) (* hibakezelés *)
CAL deserie_fb(Destination := ReceiveData, Buffer := struct_buffer, BufferOffset := DataOffset, | DeserializedLength := DestinationLength) LD deserie_fb.Error USINT_TO_BOOL JMPC _Fail (* vett adatok kiválasztása befejeződött *) _Fail:
78
(* hibakezelés *)
(* történt hiba ? *) (* hiba kezelés *)
EdgeAlarm EdgeAlarm
változásfigyelés megszakításkezelés EdgeAlarm BOOL
EnableDisable
USINT
Number
UINT
RisingEdge
UINT
SetpointValue
ANY_FUNCTION_BLOCK
SubRoutine
Error CallUpValue
USINT UINT
Az operandusok jelentése: EnableDisable
Megszakításkérő funkcióblokk engedélyezése / tiltása, felfutó élvez. (engedély=1, tiltás=0)
Number
megszakításkérő csatornaszám (PS4-141/-151/-201 = 0, PS4-341MM1 esetén 0 és 1)
RisingEdge
él választás (0 = felfutó, 1 = lefutó)
SetpointValue
Számláló alapjel
SubRoutine
megszakításkérést kiszolgáló funkcióblokk neve
Error
hibajelzés
CallUpValue
megszakításkérő hívások száma
Leírás: A funkcióblokk a PS4-201-MM1 alapkészülék %I0.0.0.0.1 bemenetéhez van hozzárendelve. A PS4-141-MM1 és PS4-151-MM1 esetén a hozzárendelés a %I0.0.0.1.0 bemenethez történik. A PS4-341-MM1 két élvezérelt bemenettel (%I0.0.0.1.0, és %I0.0.0.1.1) rendelkezik Az EnableDisable bemenet engedélyezi a számláló működését. A számláló indul, ha a bemeneten pozitív élváltás (0 → 1) következik be. A számláló leáll, és törlődik, ha ez a bemenet visszakapcsol (1 → 0). A RisingEdge bemenet adja meg, hogy milyen irányú jelváltozást kell feldolgozni. A SetpointValue bemenet (értéktartománya: 1…65535) határozza meg, hogy az előosztott számláló mely értékénél kell a megszakítás, azaz mikor kell a funkcióblokkot felhívni. A rendszer maximálisan megengedett kiterhelése két tényező együttesétől függ: A SetpointValue értékétől és a rákapcsolt jel frekvenciájától. A nevezett tényezőket úgy kell megválasztani, hogy milliszekundumonként maximálisan két megszakítás
79
EdgeAlarm lépjen csak fel. Az Error kimenet tartalmazza az esetleges fellépő hibák kódjait: 0 nincs hiba 1 alapjel (SetpointValue) = 0 3 érvénytelen megszakításkérő 4 megszakításkérő csatornaszámot már felhasználták (csak a PS4-300 estén) A CallUpNumber kimenet (értéktartomány: 0…65535) jelzi, hogy az alapjel értéket hányszor érte el a számláló, azaz hányszor történhetett megszakítás. Az SubRoutine bemenet biztosítja az eseményvezérelt programvezérlés beillesztését. Ennek érdekében ezen a bemeneten lehet a megszakításkérést kiszolgáló funkcióblokk nevét megadni. Mikor az esemény bekövetkezik (a CounterValue számláló eggyel növekszik) és az alprogram végrehajtódik. Ha erre a bemenetre nincs funkcióblokk kapcsolva, akkor csak a CounterValue számláló tartalma nő, és nincs megszakításkérés kiszolgálás. Eseményvezérelt program alkalmazásakor az alábbi szempontokat kell figyelembe venni: • Az esemény bekövetkezte a felhasználói program végrehajtását megszakítja, a regiszterek állapotát elmenti, és a SubRoutine bemeneten megadott címre ugorva végrehajtja az alprogramot. A megszakításkérést kiszolgáló funkcióblokk nem tartalmazhat sem bemenő, sem kimenő paramétereket. Egy ilyen funkcióblokk csak lokális változókat, vagy kívül deklarált globális változókat, mint külső változókat (VAR_EXTERNAL) tartalmazhat. • A megszakításkérő funkcióblokk nem szakítható meg egy másik megszakításkérő funkcióblokkal (az összes megszakításkérő funkcióblokknak azonos a prioritása). A felhasználói program 5ms időtartamra (kb. 1000 utasítássor végrehajtása) korlátozza a megszakításkérő funkcióblokk végrehajtási idejét, mivel a megszakításkérő funkcióblokk működését a rendszerprogram sem tudja (még tápkimaradáskor sem) megszakítani. Ha a végrehajtási idő túllépi ezt a korlátot, akkor a táp kikapcsolásakor EDC hiba keletkezhet. • A megszakításkérő funkcióblokk végrehajtási ideje hozzáadódik a felhasználói program végrehajtási idejéhez, így a ciklusidő ellenőrzésbe is bekerül! • Mivel az eseményvezérelt program futtatásakor korlátozás nélkül elérhetők a globális változók is, a ciklikus felhasználói program és az eseményvezérelt program által közösen irható /olvasható adatokat reteszelés nélkül nem szabad felhasználni. Például a ciklikus felhasználói programban és a megszakításkérő funkcióblokkban ugyanabban a bájtban használt bithozzáférést csak a Disable_Interrupt és a Enable_Interrupt utasításokkal való szinkronizálással szabad korrekten végrehajtani. • A lehető leggyorsabb reagálás érdekében a megszakításkérő funkcióblokkban célszerű a közvetlen periféria hozzáférést használni, melyek az alapkészüléken állnak rendelkezésre (%QP0.0.0.0.x, %QPB0.0.0.0). • A megszakításkérő funkcióblokkok az alkalmazói programban elvileg többször is
80
EdgeAlarm használhatók, de ezt általában kerülni érdemes, mivel a megszakításkérő funkcióblokk típusok ugyanazzal az eseményforrással, és így a programban csak az utoljára érvényesülő funkcióblokk határozza meg feldolgozást. A többszörös alkalmazásnak csak akkor van értelme, ha a funkcióblokkot a kiszolgáló rutinon belül újra kell paraméterezni, és él-figyelési reteszelést kell megoldani. A többszöri felhasználás azt jelenti, hogy az egyedi funkcióblokk-típus minden egyes alkalmazásához külön-külön adatterületet foglal le. A megszakításkérő funkcióblokkok bemeneteinek értékadása csak a híváskor történő zárójeles értékadással történhet. Közvetlen paraméter hozzárendelés a zárójelen kívül, vagy a hívást követően nem megengedett!
RisingEdge=0 SetpointValue=1 CallUpVAlue
0
1
2
3
4
5
6
7
8
9
10
1
1
2
...
Ugrás a funkcióblokkra
RisingEdge =0 SetpointValue =5 CallUpVAlue
0
0
0
0
0
1
1
1
2
2
2
Ugrás a funkcióblokkra
81
EdgeAlarm Példaprogram: PROGRAM alarm VAR Flankenalarm : EdgeAlarm; Error : USINT; CountValue : UINT; Pump : reakt_fb;
(*Az FB deklarálása, melyet aktíválni (* kell, ha az alarm fellép *)
END_VAR (* Ha egy adott szintet a elér a tárolóban a vízszint, akkor alarmot kell kiváltani, és működtetni a szivattyút. A jelfeldolgozás pozitív élre történi. *) LD ICS PLC_Message CALC Flankenalarm(EnableDisable := 1, Number := 0, RisingEdge := 0, SetPointValue := 1, SubRoutine := Pump)
(* Első programciklus vizsgálata, *) (* mert a a megszakításkérő FB-t *) (* egyszer kell hívni! *)
LD EdgeAlarm.Error ST Error LD EdgeAlarm.CallUpNumber ST CountValue END_PROGRAM
82
(* Az alarmok számát jelzi *)
FifoBx FifoBx
8-bites csőtár regiszter * BOOL
FillPulse
BOOL
ReadOutPulse
BOOL
ReSet
USINT
DataInput
Full
BOOL
Empty
BOOL
DataOutput
USINT
Az operandusok jelentése: FillPulse
betöltő impulzus, felfutó él
ReadOutPulse
kiolvasó impulzus, felfutó él
ReSet
visszaállítás, törlés
DataInput
adatbemenet
Full
regiszter tele jelzés
Empty
regiszter üres jelzés
DataOutput
adatkimenet
Leírás: A * helyén az adott prototípus funkcióblokk neve írandó be. A lehetséges nevek a következők: FifoB1, FifoB2, …FifoB128, ahol az egyes számok a 8-bites regisztermező hosszát adják meg. A DataInput bemeneten levő érték a FillPulse bemeneten megjelenő felfutó él hatására belép az első legmélyebb szabad regiszter helyre. A regisztert FillPulse impulzussal lehet tölteni, amíg a teljes regiszter tele nem lesz. A regiszter tele állapotát a Full kimenet 1 értékkel jelzi. ReadOutPulse
FillPulse
DataOutput
DataInput
x
7
6
5
4
019
255
035
095
3
2
1
0 014
ReadOutPulse
FillPulse
DataOutput
DataInput
x
7
6
5
4
3
019
255
035
095
014
2
1
0
83
FifoBx A ReadOutPulse bemeneten megjelenő felfutó él hatására a DataOutput kimeneten megjelenik az először, a legmélyebb szintre beírt érték. Minden további ReadOutPulse impulzus hatására újabb egyre magasabban levő értékek kerülnek kiolvasásra. Az utolsó kiolvasást követően, a regiszter üres állapotát az Empty kimenet 1 értékkel jelzi. ReadOutPulse
FillPulse
DataOutput
DataInput
x
7
6
5
4
019
255
035
095
3
2
1
0 x
ReadOutPulse
FillPulse
DataOutput
DataInput
019
7
6
5
4
255
035
095
014
3
2
1
0
A ReSet bemenetre adott logikai 1 szint törli a teljes regisztermezőt. Példaprogram: PROGRAM fifo8_1 VAR Queue_32_byte : FifoB32; Pulse1 : BOOL; Pulse2 : BOOL; Reset : BOOL; QueueData : USINT; full : BOOL; empty : BOOL; Outputdata : USINT; END_VAR CAL Queue_32_byte(FillPulse := Pulse1, ReadOutPulse := Pulse2, ReSet := Reset, DataInput := QueueData)
84
x
FifoBx LD Queue_32_byte.Full ST full LD Queue_32_byte.Empty ST empty LD Queue_32_byte.DataOutput ST Outputdata END_PROGRAM
85
FifoWx FifoWx
16-bites csőtár regiszter * BOOL
FillPulse
BOOL
ReadOutPulse
BOOL
ReSet
UINT
Full
BOOL
Empty
BOOL
DataOutput
UINT
DataInput
Az operandusok jelentése: FillPulse
betöltő impulzus, felfutó él
ReadOutPulse
kiolvasó impulzus, felfutó él
ReSet
visszaállítás, törlés
DataInput
adatbemenet
Full
regiszter tele jelzés
Empty
regiszter üres jelzés
DataOutput
adatkimenet
Leírás: A * helyén az adott prototípus funkcióblokk neve írandó be. A lehetséges nevek a következők: FifoW1, FifoW2, …FifoW128, ahol az egyes számok a 16-bites regisztermező hosszát adják meg. A DataInput bemeneten levő érték a FillPulse bemeneten megjelenő felfutó él hatására belép az első legmélyebb szabad regiszter helyre. A regisztert FillPulse impulzussal lehet tölteni, amíg a teljes regiszter tele nem lesz. A regiszter tele állapotát a Full kimenet 1 értékkel jelzi. ReadOutPulse
FillPulse
DataOutput
DataInput 7
x
5
4
3
2
1
0 13657
00197 02555 18637 00023
ReadOutPulse
FillPulse
DataOutput
DataInput 7
x
86
6
6
5
4
3
00197 02555 18637 00023 03657
2
1
0
FifoWx A ReadOutPulse bemeneten megjelenő felfutó él hatására a DataOutput kimeneten megjelenik az először, a legmélyebb szintre beírt érték. Minden további ReadOutPulse impulzus hatására újabb egyre magasabban levő értékek kerülnek kiolvasásra. Az utolsó kiolvasást követően, a regiszter üres állapotát az Empty kimenet 1 értékkel jelzi. ReadOutPulse
FillPulse
DataOutput
DataInput 7
x
6
5
4
3
2
1
0 x
00197 02555 18637 00023
ReadOutPulse
FillPulse
DataOutput
DataInput 7
00197
6
5
4
3
2
1
0
02555 18637 00023
x
A ReSet bemenetre adott logikai 1 szint törli a teljes regisztermezőt. Példaprogram: PROGRAM fifo16_1 VAR Queue_16_word : FifoW16; Pulse1 : BOOL; Pulse2 : BOOL; Reset : BOOL; QueueData : UINT; full : BOOL; empty : BOOL; Outputdata : UINT; END_VAR CAL Queue_16_word(FillPulse := Pulse1, ReadOutPulse := Pulse2, ReSet := Reset, DataInput := QueueData) LD Queue_16_word.Full ST full LD Queue_16_word.Empty
87
FifoWx ST empty LD Queue_16_word.DataOutput ST Outputdata END_PROGRAM
88
GetRealTimeClock GetRealTimeClock
Valós idejű óra kiolvasása GetRealTimeClock Year
USINT
Month
USINT
Day
USINT
Weekday
USINT
Hour
USINT
Minute
USINT
Second
USINT
Az operandusok jelentése: Year
az aktuális évszám, kétjegyűen
Month
hónap
Day
nap
Weekday hétnap sorszáma (0 = vasárnap) Hour
óra
Minute
perc
Second
másodperc
Leírás: A funkcióblokk hívásával a valósidejű órából folyamatosan a kimeneti paraméterekre íródik az aktuális dátum és idő értéke. Nincs szükség külön engedélyező jelre, a hívással egyidejűleg a funkcióblokk biztosítja az értékeket.
89
LifoBx LifoBx
8-bites veremtár regiszter * BOOL
FillPulse
BOOL
ReadOutPulse
BOOL
ReSet
USINT
DataInput
Full
BOOL
Empty
BOOL
DataOutput
USINT
Az operandusok jelentése: FillPulse
betöltő impulzus, felfutó él
ReadOutPulse
kiolvasó impulzus, felfutó él
ReSet
visszaállítás, törlés
DataInput
adatbemenet
Full
regiszter tele jelzés
Empty
regiszter üres jelzés
DataOutput
adatkimenet
Leírás: A * helyén az adott prototípus funkcióblokk neve írandó be. A lehetséges nevek a következők: LifoB1, LifoB2, …LifoB128, ahol az egyes számok a 8-bites regisztermező hosszát adják meg. A DataInput bemeneten levő érték a FillPulse bemeneten megjelenő felfutó él hatására belép az első legmélyebb szabad regiszter helyre. A zsákregisztert FillPulse impulzussal lehet tölteni, amíg a teljes regiszter tele nem lesz. A regiszter tele állapotát a Full kimenet 1 értékkel jelzi. FillPulse
DataInput 0
1
2
3
255
033
025
047
4
5
6
7 062 FillPulse
DataInput
90
0
1
2
3
4
255
033
025
047
062
5
6
7
LifoBx A ReadOutPulse bemeneten megjelenő felfutó él hatására a DataOutput kimeneten megjelenik az utoljára, a legmagasabb szintre beírt érték. Minden további ReadOutPulse impulzus hatására újabb egyre mélyebben levő értékek kerülnek kiolvasásra. Az utolsó kiolvasást követően, a regiszter üres állapotát az Empty kimenet 1 értékkel jelzi. ReadOutPulse
DataOutput 0
1
2
3
4
255
033
025
047
062
5
6
7
ReadOutPulse
DataOutput 0
1
2
3
255
033
025
047
4
5
6
7 062
A ReSet bemenetre adott logikai 1 szint törli a teljes regisztermezőt. Példaprogram: PROGRAM lifo8_1 VAR Stackregister_64_byte : LifoB64; Pulse1 : BOOL; Pulse2 : BOOL; Reset : BOOL; StackData : USINT; full : BOOL; empty : BOOL; Outputdata : USINT; END_VAR CAL Stackregister_64_byte (FillPulse := Pulse1, ReadOutPulse := Pulse2, ReSet := Reset, DataInput := StackData) LD Stackregister_64_byte.Full ST full LD Stackregister_64_byte.Empty ST empty LD Stackregister_64_byte.DataOutput ST Outputdata END_PROGRAM
91
LifoWx LifoWx
16-bites veremtár regiszter * BOOL
FillPulse
BOOL
ReadOutPulse
BOOL
ReSet
UINT
Full
BOOL
Empty
BOOL
DataOutput
UINT
DataInput
Az operandusok jelentése: FillPulse
betöltő impulzus, felfutó él
ReadOutPulse
kiolvasó impulzus, felfutó él
ReSet
visszaállítás, törlés
DataInput
adatbemenet
Full
regiszter tele jelzés
Empty
regiszter üres jelzés
DataOutput
adatkimenet
Leírás: A * helyén az adott prototípus funkcióblokk neve írandó be. A lehetséges nevek a következők: LifoW1, LifoW2, …LifoW128, ahol az egyes számok a 16-bites regisztermező hosszát adják meg. A DataInput bemeneten levő érték a FillPulse bemeneten megjelenő felfutó él hatására belép az első legmélyebb szabad regiszter helyre. A zsákregisztert FillPulse impulzussal lehet tölteni, amíg a teljes regiszter tele nem lesz. A regiszter tele állapotát a Full kimenet 1 értékkel jelzi. FillPulse
DataInput 0
1
2
3
12764
00346
01283
00034
4
5
6
7 02384 FillPulse
DataInput 0
1
2
3
4
12764
00346
01283
00034
02384
92
5
6
7
LifoWx A ReadOutPulse bemeneten megjelenő felfutó él hatására a DataOutput kimeneten megjelenik az utoljára, a legmagasabb szintre beírt érték. Minden további ReadOutPulse impulzus hatására újabb egyre mélyebben levő értékek kerülnek kiolvasásra. Az utolsó kiolvasást követően, a regiszter üres állapotát az Empty kimenet 1 értékkel jelzi. ReadOutPulse
DataOutput 0
1
2
3
4
12764
00346
01283
00034
02384
5
6
7
ReadOutPulse
DataOutput 0
1
2
3
12764
00346
01283
00034
4
5
6
7 02384
A ReSet bemenetre adott logikai 1 szint törli a teljes regisztermezőt. Példaprogram: PROGRAM lifo16_1 VAR Stackregister_32_word : LifoW32; Pulse1 : BOOL; Pulse2 : BOOL; Reset : BOOL; StackData : UINT; full : BOOL; empty : BOOL; OutputData : UINT; END_VAR CAL Stackregister_32_word(FillPulse := Pulse1, ReadOutPulse := Pulse2, ReSet := Reset, DataInput := StackData) LD Stackregister_32_word.Full ST full LD Stackregister_32_word.Empty ST empty LD Stackregister_32_word.DataOutput ST OutputData END_PROGRAM
93
MI4netK MI4netK
MI4 kijelzők kommunikációs modulja MI4netK RDB_Start
ANY_ARRAY
SDB_Start
ANY_ARRAY
Status
BYTE
Az operandusok jelentése: RDB_Start
A Suconet K adatátadási terület bemeneti puffer (RDB), pl. ha az MI4-s kijelzőnek az 1-es vonalon az 1-es címe van, és a puffer nagyság 20bájt, akkor: ARRAY [1..20] of BYTE AT %RDB1.1.0.0
SDB_Start
A Suconet K adatátadási terület kimeneti puffer (SDB), pl. ha az MI4-s kijelzőnek az 1-es vonalon az 1-es címe van, és a puffer nagyság 20bájt, akkor: ARRAY [1..20] of BYTE AT %SDB1.1.0.0
Status
MI4 kommunikációs státusa
Leírás: Az MI4netK a Suconet K hálózaton illeszti az MI4 készülékcsaládot a PLC-hez. A Status a következő információkat és kommunikációs hibajelzéseket adja: 01h PLC küld adatcsomagot az MI4-nek 02h PLC fogad adatcsomagot az MI4-től 04h nincs adatkérés C0h paraméterezési hiba a bemeneti paraméterekben 80h Az MI4 érvénytelen műveleti kódot küldött / kommunikációs hiba 81h Memóriatartomány túllépés / távirathossz hiba a PLC-merkerek olvasása során. 82h Memóriatartomány túllépés / távirathossz hiba a PLC-merkerek írása során. A funkcióblokk részletes leírása a”Kommunikáció MI4 <->PLC” kézikönyvben található (AWB27-1303).
94
MS_TimeFalling MS_TimeFalling
Elejtésre késleltetett időzítő (milliszekundumos megadással) MS_TimeFalling
BOOL
Set
BOOL
ReSet
BOOL
Hold
UINT
OutputControl
BOOL
ElapsedTime
UINT
PresetTime
Az operandusok jelentése: Set
indítási feltétel, pozitív éllel
ReSet
visszaállítás
Hold
időzítési futás leállítása
PresetTime
Időzítési alapjel milliszekundumban
OutputControl
időzítő kimenete
ElapsedTime
időzítés aktuális ideje
Idődiagramok: (1)
(2)
(3)
(4)
(5)
Set ReSet
Hold TH
TH
OutputControl T
T+TH
T+TH
T
T
95
MS_TimeFalling Leírás: Ha a Set bemenetre felfutó él jut, akkor a kimenet azonnal magasba vált. Ha a Set bemenet alacsonyra vált, a kimenet T idővel később követi. (1) A beállított késleltetési időnek a ciklusidőnél mindig nagyobbnak kell lenni, hogy biztosítva legyen a késleltetés nyomon követése. Az ElapsedTime kimenet a milliszekundumban mutatja a még hátra levő késleltetési időt. A késleltetési idő visszaszámlálása felfüggeszthető a bemenetre adott magas szinttel. A késleltetés megnő azzal az idővel, amíg a Hold bemenet magas, miközben Set bemenet már alacsony. (2), (3) Az OutputControl kimenet csak akkor követi a Set bemenetet a beállított időzítéssel, ha a Hold bemenet alacsony (4), (5). Az időzítő alaphelyzetbe kerül (kimenetei nullák), ha a ReSet bemenetet logikai 1-re kapcsoljuk. Ebben az esetben az időzítés indítása nem lehetséges. A Set bemeneten levő pozitív él váltás csak a ReSet bemenet 1->0 váltása után válik hatásossá. (5). Példaprogram: PROGRAM time4 VAR Timer4 : MS_TimeFalling; Start AT %I0.0.0.0.0 : BOOL; Halt AT %I0.0.0.0.1 : BOOL; TimeValue4 : UINT := 25; Output4 AT %Q0.0.0.0.0 : BOOL; END_VAR CAL Timer4 (Set := Start, Hold := Halt, PresetTime := TimeValue4) LD Timer4.OutputControl ST Output4 END_PROGRAM
96
(* TimeValue4 = 25 milliszekundum *)
MS_TimeRising MS_TimeRising
Meghúzásra késleltetett időzítő (milliszekundum megadással) MS_TimeRising
BOOL
Set
BOOL
ReSet
BOOL
Hold
UINT
OutputControl
BOOL
ElapsedTime
UINT
PresetTime
Az operandusok jelentése: Set
indítási feltétel, pozitív éllel
ReSet
visszaállítás
Hold
időzítési futás leállítása
PresetTime
Időzítési alapjel milliszekundumban
OutputControl
időzítő kimenete
ElapsedTime
időzítés aktuális ideje
Idődiagramok: (1)
(2)
(3)
(4)
(5)
Set
ReSet
HOLD TH OutputControl
T
T+TH
T
T
97
MS_TimeRising Leírás: Ha a Set bemenetre felfutó él jut, az OutputControl kimenet T idővel később követi a bemenetet (A T késleltetési dő beállítása a PresetTime bemeneten megadott értékkel történhet.) A Set bemenet lefutó éle a kimeneten azonnal érvényre jut.(1) A beállított késleltetési időnek a ciklusidőnél mindig nagyobbnak kell lenni, hogy biztosított legyen a késleltetés követése. Az ElapsedTime kimenet milliszekundumban mutatja a hátra levő késleltetési időt. A késleltetési idő visszaszámlálása felfüggeszthető a Hold bemenetre adott magas szinttel. A késleltetés megnő azzal az idővel, amíg a Hold bemenet magas. (2) Ha a Hold bemenet magas szinten van, miközben a Set-en pozitív élváltás történik, akkor az indítási folyamat a Hold bemenet 1-es szintű állapotáig késleltetik. (4). Amennyiben a késleltetési idő lefutását követően a vált a Set bemeneten a jel 0-ba, miközben a Hold bemenet 1-ben van, az OutputControl csak akkor vált vissza, ha a Hold bemenet visszavált 0-ba (3). Az időzítő alaphelyzetbe kerül (kimenetei nullák), ha a ReSet bemenetet logikai 1-re kapcsoljuk. Ebben az esetben az időzítés indítása nem lehetséges. A Set bemeneten levő pozitív élváltás csak a ReSet bemenet 1->0 váltása után válik hatásossá. (5). Példaprogram: PROGRAM time3 VAR Timer3 : MS_TimeRising; Start AT %I0.0.0.0.0 : BOOL; Halt AT %I0.0.0.0.1 : BOOL; Reset AT %I0.0.0.0.2 : BOOL; TimeValue3: UINT := 7; ActTime3 AT %QW0.0.0.2 : BOOL; Output3 AT %Q0.0.0.0.0 : BOOL; END_VAR CAL Timer3 (Set := Start, ReSet := Reset, Hold := Halt, PresetTime := TimeValue3) LD Timer3.OutputControl ST Output3 LD Timer3.ElapsedTime ST ActTime3 END_PROGRAM
98
(* TimeValue= 7 Milliseconds *)
ReadMC ReadMC
adatok olvasása a flash-memóriából ReadMC
ANY_ARRAY BOOL UINT USINT
DestinationAddress
DestinationAddress
Strobe SegmentNumber
Active MaxSegmentNumber
DataLength
Error
ANY_ARRAY BOOL UINT USINT
Az operandusok jelentése: DestinationAddress
a céltömb a visszaolvasandó adatok számára
Strobe
visszaolvasási folyamat indítása
SegmentNumber
a szegmens száma (megengedett: 0…n)
DataLength
a visszaolvasandó adatbájtok száma
MaxSegmentNumber a fájl utolsó lehetséges szegmensszáma Error
hibajelzés
Leírás: A ReadMC funkcióblokk segítségével a memóriamodulból lehet adatokat a CPU memóriaterületére visszaolvasni. Ez a funkcióblokk a WriteMC blokkal együtt fontos alkalmazási területe a remanens adattárolásnak, receptura-kezelésnek, illetve változók letárolásának egy program aktualizálást megelőzően. A memóriamodult a PLC-be betenni, illetve kivenni csak a PLC feszültségmentes állapotában szabad!
A memóriamodulban az adatok egyenként 128bájt hosszúságú szegmensre vannak felosztva. A szabad adatterület meghatározásához a funkcióblokkot DataLength = 0 értékkel kell meghívni, melynek hatására nem indul be az írási folyamat, ugyanakkor a MaxSegmentLength visszaadja az utolsó még használható szegmens értékét. A funkcióblokk a programfutással aszinkron módon kerül végrehajtásra, és több programcikluson keresztül is eltarthat. Ezalatt az idő alatt az Active kimenet 1-t ad. A hibátlan végrehajtást jelzi az Active kimenet 0-ba történő visszaváltása, miközben az Error kimenet is 0-t ad. Egyszerre több funkcióblokk is lehet egyidejűleg aktív. az operációs rendszer a hívások sorrendjében egymás után hajtja végre az írási műveleteket.
99
ReadMC Az Error kimenet a következő állapotokat veheti fel: 0
nincs hiba
1
nincs memóriamodul beépítve
2
online kapcsolat miatt nem lehetséges a hozzáférés (csak PS4-200 esetén)
3
nem lehetséges a hozzáférés egyidejű WriteMC hívás miatt (csak PS4-200 esetén)
4
érvénytelen SegmentNumber (PS4-200 esetén a megengedett: 0….511; PS4300 esetén a modultól fűggően: 0….1023)
5
érvénytelen adathossz (megengedett DataLength érték: 1….128)
6
-
7
nem lehetséges a hozzáférés, mert a memóriamodul , mint forráskód háttér van felhasználva (csak PS4-200 esetén)
8
a memóriamodul formázása nem engedi meg az adattárolási tartomány használatát (csak PS4-300 esetén)
Csak a PS4-200 esetén: Az Active kimenet a PS4-150/-200 esetén mindig 0. A funkcióblokk aktuális állapota csak egy ismételt hívás mellett az Error kimenet lekérdezésével oldható meg. Ha az Error 0-t ad, akkor a művelet hiba nélkül végrehajtódott. Ha a kimenet értéke 3, akkor a funkcióblokk még dolgozik. Az Error kimenet aktualizálásához a Strobe bemeneten egy újabb pozitív élet kell generálni. A ReadData funkcióblokk segítségével lehet a letárolt adatokat a memóriamodulból visszaolvasni! Példaprogram: PROGRAM RELOAD VAR StrobeReload AT %I0.0.0.0.0 :BOOL; ActiveReload AT %Q0.0.0.0.0 :BOOL; ErrorReload : USINT; FBReloadData : ReadMC; SegmentNumber : UINT; DataLength : USINT; LastSegmentNumber : UINT; DataArea : ARRAY[0..15] of USINT; END_VAR LD 8 ST SegmentNumber LD 16 ST DataLength
100
ReadMC (* 16 bájt olvasása a 8.szegmensből, céltartomány: DataArea nevű tömb *) CAL FBReloadData(Strobe := StrobeReload, SegmentNumber := SegmentNumber, DataLength := DataLength, DestinationAddress := DataArea | ActiveReload := Active, LastSegmentNumber := MaxSegmentNumber, ErrorReload := Error) LD ActiveReload JMPC CONTINUE LD ErrorReload EQ 0 JMPCN ERRORHANDLING (* az adatfeldolgozás folytatása *) JMP CONTINUE ERRORHANDLING: (* hibakezelési rutin *) CONTINUE: (* felhasználói program további része *) END_PROGRAM
101
ReloadData ReloadData
adatok olvasása a flash-memóriából (címváltozók alkalmazásával) ReloadData
BOOL ADDRESS UINT USINT
Strobe DestinationAddress SegmentNumber
Active MaxSegmentNumber
DataLength
Error
BOOL UINT USINT
Az operandusok jelentése: Strobe
visszatöltési folyamat indítása
DestinationAddress
visszatöltendő céladatok kezdő címe (típusa ADDRESS)
SegmentNumber
szegmensszám (0….n)
DataLength
a visszatöltendő adatmezők száma (1….128)
Active
1, ha a visszatöltési folyamat fut
MaxSegmentNumber a fájl utolsó lehetséges szegmensszáma Error
hibajelzés
Leírás: A ReloadData funkcióblokk segítségével a memóriamodulból lehet adatokat a CPU memóriaterületére visszatölteni. A memóriamodul logikailag 512, egyenként 128bájt hosszúságú szegmensre van felosztva. Egyszeri hívással maximum 128bájt olvasható vissza. A funkcióblokk egyik legfontosabb alkalmazási területe a remanens memóriaterületnek (pl. a receptura területnek), mely a compiler konfiguráció során a kódgeneráláskor kerül meghatározásra, közbenső letárolása és ezen adatok visszaolvasása egy készülékkonfiguráció megváltoztatása során. Az Error kimenet a következő állapotokat veheti fel:
102
0
nincs hiba
1
nincs memóriamodul beépítve
2
online kapcsolat miatt nem lehetséges a hozzáférés
3
nem lehetséges a hozzáférés egyidejű SaveData hívás miatt
4
érvénytelen SegmentNumber (megengedett: 0….511)
5
érvénytelen adathossz (megengedett DataLength érték: 1….128)
6
a kezdőcím érvénytelen
7
csak a PS4-200 esetén: nem lehetséges a hozzáférés, mert a memóriamodul , mint forráskód háttér van felhasználva
ReloadData 8
csak a PS4-300 esetén: a memóriamodul formázása nem engedi meg az adattárolási tartomány használatát
Csak a PS4-200 esetén: Az Active kimenet a PS4-150/-200 esetén mindig 0. A funkcióblokk aktuális állapota csak egy ismételt hívás mellett az Error kimenet lekérdezésével oldható meg. Ha az Error 0-t ad, akkor a művelet hiba nélkül végrehajtódott. Ha a kimenet értéke 3, akkor a funkcióblokk még dolgozik. Az Error kimenet aktualizálásához a Strobe bemeneten egy újabb pozitív élet kell generálni. A SaveData funkcióblokk segítségével lehet adatokat a memóriamodulra írni! Példaprogram: PROGRAM R_Card VAR ReadData : ReloadData; Start AT %I0.0.0.0.2 : BOOL; Mem_start AT %MB0.0.0.100 : BYTE; Segment_NR : UINT; DataLength : USINT; ErrorMessage : USINT; END_VAR CAL ReadData(Set := Start, DestinationAddress := &Mem_start, SegmentNumber := Segment_NR, DataLength := SegmentLength) LD ReadData.Error ST ErrorMessage NE 0 JMPC ErrorEvaluation (*...*)
(* ha nem egyenlő 0, akkor hiba! *)
ErrorEvaluation:
(* hiba kiértékelő rutin *)
(*...*) END_PROGRAM
103
RealTimeClock RealTimeClock
valós idejű óra összehasonlítása egyedi bemeneti adatokkal RealTimeClock Set
BOOL
Greater
BOOL
TIME_OF_DAY
RealTime
Equal
BOOL
DAY_OF_WEEK
WeekDay
Less
BOOL
DATE
RealDate
Error
BOOL
UINT
VariableDate
UINT
VariableTime
Az operandusok jelentése: Set
az összehasonlítás engedélyezése
RealTime
a valósidejű órával összehasonlítandó konstans idő (óra, perc), melyet a programozás során lehet megadni, és az a programfutás alatt már nem változik
WeekDay
a valósidejű órával összehasonlítandó konstans hétnap sorszám, melyet a programozás során lehet megadni, és az a programfutás alatt már nem változik A DAY_OF_WEEK úgynevezett Moeller adattípus, melynek értelmezése a következő: TYPE DAY_OF_WEEK: (Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday):= Monday; END_TYPE
104
RealDate
a valósidejű órával összehasonlítandó konstans dátum (nap, hónap, év), melyet a programozás során lehet megadni, és az a programfutás alatt már nem változik
VariableDate
a valósidejű órával összehasonlítandó változóérték (nap és hónap), ahol a nap a magasabb bájtban, a hónap az alacsonyabb bájtban kerül kódolásra
VariableTime
a valósidejű órával összehasonlítandó változóérték (óra és perc), ahol az óra a magasabb bájtban, a perc az alacsonyabb bájtban
RealTimeClock kerül kódolásra időzítés aktuális ideje Greater
1, ha a megadott összehasonlítandó érték nagyobb, mint a valósidejű óra értéke
Equal
1, ha a megadott összehasonlítandó érték azonos a valósidejű óra értékével
Less
1, ha a megadott összehasonlítandó érték kisebb, mint a valósidejű óra értéke
Error
1, ha a megadott összehasonlítandó érték érvénytelen
Leírás: A funkcióblokk összehasonlítja a valósidejű óra értékét a megadott bemeneti értékkel. Az összehasonlítás engedélyezése a Set = 1 bemenet állításává történhet. Set = 0 esetén az összehasonlítás letiltódik, a kimenetek mindegyike 0-t vesz fel. Az adatok megadására két lehetőség kínálkozik 1. A funkcióblokk hívása RealTime, WeekDay, RealDate bemenetek megadásával Az adatokat programozás során kell megadni. Ezek a konstans értékek programfutatás közben nem változtathatók meg. A funkcióblokk a konstans értékeket csak akkor veszi figyelembe, ha a VariableDate és a VariableTime bemenetek nincsenek paraméterezve. A paraméterezési példák: RealTime: TOD#20:35:10
WeekDay: -
RealDate: -
RealTime: TOD#20:35:10
WeekDay: Monday
RealDate: -
RealTime: TOD#20:35:10
WeekDay: -
RealDate: D#2000-03-15
Set Less Equal Greater aktív
2. A funkcióblokk hívása VariableDate, VariableTime bemenetek megadásával Ha a VariableDate és / vagy a VariableTime bemeneteken van érvényes érték, akkor a RealTime WeekDay RealDate bemenetek nem aktívak..A beírások szó formátumúak. A beírás megtörténhet a funkcióblokk behívásával, vagy a felhasználói programból.
105
RealTimeClock 15 14 13 12 11 10 9 0 0 0 1 0 0 0 óra 0 0 0 1 0 0 1 nap
8 1
7 0
6 0
5 1
0
0
0
0
4 0
3 2 0 0 perc 0 0 0 hónap
1 1
0 1
17 35 VariableTime
1
1
18 3
VariableDate
1 szó
A változó szóba a szám értelmezési tartományon belül bármely érték beírható, azonban a dátum / idő értelmezési tartományán kívüli érték esetén, például 25 óra, az Error kimenet jelez. Set 1) VariableDate, VariableTime
V1
V2
Less Equal Greater aktív
aktív
A funkcióblokk kimeneteinek állapota: •
Ha a beállított idő azonos a belső óra értékével, az Equal kimenet 1 percen át logikai 1-el jelzi az azonosságot. Ha beállított érték nagyobb akkor a Greater, ha kisebb a Less kimenet ad logikai 1 jelzést.
•
A jelváltás a "nagyobb, mint" (Greater), és a "kisebb, mint" (Less) között a 24. óra átmenetnél ( 23 → 0 ) az alábbiak szerint változik: RealTime vagy VariableTime operandusok esetén
minden nap 24 órakor
WeekDay operandus esetén
vasárnap 24 órakor
RealDate vagy VariableDate operandusok esetén
minden hónap végén 24 órakor
VariableDate és VariableTime operandusok esetén
minden év végén 24 órakor
1) Adatcsere a régi = V1, az új = V2 Az új értéket a Set bemeneten történt 0->1 átmenetet követő feldolgozási ciklusban veszi először figyelembe a felhasználói program
106
RealTimeClock Példaprogram: PROGRAM clock VAR R_Time : RealTimeClock; Clock_free : BOOL; T_Day : TIME_OF_DAY := TOD#12:00:00; Datum : Date :=D#1999-12-12 ; Midday AT %Q0.0.0.0.0 : BOOL; END_VAR (* idő összehasonlítás *) CAL R_Time (Set := Clock_free, RealTime := T_Day, RealDate :=Datum, WeekDay := Monday) LD R_Time.Equal ST Midday END_PROGRAM
107
RTC RTC
valós idejű óra állítása RTC BOOL
DATE_AND_TIME
EN PDT
Q CDT
BOOL DATE_AND_TIME
Az operandusok jelentése: EN
indítási feltétel, pozitív éllel
PDT
beállítandó dátum és idő ( érvényes évszámok: 1993….20092)
Q
CDT-n való idő helyességét jelző bit
CDT
aktuális dátum és idő
Leírás: Az EN-re adott felfutó éllel lehet a PDT-re adott dátum és idő értéket a PLC valós idejű órájába beírni. A beírt érték helyességét a Q jelzi. Az aktuális értékeket a CDTn lehet leolvasni, EN-től függetlenül. Példaprogram: PROGRAM clock VAR Set_Clock : RTC; Set_Input AT %I0.0.0.1.3 : BOOL; Date_and_Time: DATE_AND_TIME := DT#1995-01-01-00:00:00; Clock_Set : BOOL; Clock_Status : DATE_AND_TIME; END_VAR CAL Set_Clock (IN := Set_Input, PDT := Date_and Time) LD Set_Clock.Q ST Clock_Set LD Set_Clock.CDT ST Clock_Status END_PROGRAM
108
S_TimeFalling S_TimeFalling
Elejtésre késleltetett időzítő (szekundumos megadással) S_TimeFalling
BOOL
Set
BOOL
ReSet
BOOL
Hold
OutputControl
BOOL
ElapsedTime
UINT
PresetTime
UINT
Az operandusok jelentése: Set
indítási feltétel, pozitív éllel
ReSet
visszaállítás
Hold
időzítési futás leállítása
PresetTime
Időzítési alapjel szekundumban
OutputControl
időzítő kimenete
ElapsedTime
időzítés aktuális ideje
Idődiagramok: (1)
(2)
(3)
(4)
(5)
Set ReSet
Hold TH
TH
OutputControl T
T+TH
T+TH
T
T
109
S_TimeFalling Leírás: Ha a Set bemenetre felfutó él jut, akkor a kimenet azonnal magasba vált. Ha a Set bemenet alacsonyra vált, a kimenet T idővel később követi. (1) A beállított késleltetési időnek a ciklusidőnél mindig nagyobbnak kell lenni, hogy biztosítva legyen a késleltetés nyomon követése. Az ElapsedTime kimenet a szekundumban mutatja a még hátra levő késleltetési időt. A késleltetési idő visszaszámlálása felfüggeszthető a bemenetre adott magas szinttel. A késleltetés megnő azzal az idővel, amíg a Hold bemenet magas, miközben Set bemenet már alacsony. (2), (3) Az OutputControl kimenet csak akkor követi a Set bemenetet a beállított időzítéssel, ha a Hold bemenet alacsony (4), (5). Az időzítő alaphelyzetbe kerül (kimenetei nullák), ha a ReSet bemenetet logikai 1-re kapcsoljuk. Ebben az esetben az időzítés indítása nem lehetséges. A Set bemeneten levő pozitív él váltás csak a ReSet bemenet 1->0 váltása után válik hatásossá. (5). Példaprogram: PROGRAM time4 VAR Timer2 : S_TimeFalling; Start AT %I0.0.0.0.0 : BOOL; Halt AT %I0.0.0.0.1 : BOOL; TimeValue2 : UINT := 25; Output2 AT %Q0.0.0.0.0 : BOOL; END_VAR CAL Timer2 (Set := Start, Hold := Halt, PresetTime := TimeValue2) LD Timer2.OutputControl ST Output2 END_PROGRAM
110
(* TimeValue2 = 25 szekundum *)
S_TimeRising S_TimeRising
Meghúzásra késleltetett időzítő (szekundum megadással) S_TimeRising
BOOL
Set
BOOL
ReSet
BOOL
Hold
OutputControl
BOOL
ElapsedTime
UINT
PresetTime
UINT
Az operandusok jelentése: Set
indítási feltétel, pozitív éllel
ReSet
visszaállítás
Hold
időzítési futás leállítása
PresetTime
Időzítési alapjel milliszekundumban
OutputControl
időzítő kimenete
ElapsedTime
időzítés aktuális ideje
Idődiagramok: (1)
(2)
(3)
(4)
(5)
Set
ReSet
HOLD TH OutputControl
T
T+TH
T
T
111
S_TimeRising Leírás Ha a Set bemenetre felfutó él jut, az OutputControl kimenet T idővel később követi a bemenetet (A T késleltetési dő beállítása a PresetTime bemeneten megadott értékkel történhet.) A Set bemenet lefutó éle a kimeneten azonnal érvényre jut.(1) A beállított késleltetési időnek a ciklusidőnél mindig nagyobbnak kell lenni, hogy biztosított legyen a késleltetés követése. Az ElapsedTime kimenet másodpercben mutatja a hátra levő késleltetési időt. A késleltetési idő visszaszámlálása felfüggeszthető a Hold bemenetre adott magas szinttel. A késleltetés megnő azzal az idővel, amíg a Hold bemenet magas. (2) Ha a Hold bemenet magas szinten van, miközben a Set-en pozitív élváltás történik, akkor az indítási folyamat a Hold bemenet 1-es szintű állapotáig késleltetik. (4). Amennyiben a késleltetési idő lefutását követően a vált a Set bemeneten a jel 0-ba, miközben a Hold bemenet 1-ben van, az OutputControl csak akkor vált vissza, ha a Hold bemenet visszavált 0-ba (3). Az időzítő alaphelyzetbe kerül (kimenetei nullák), ha a ReSet bemenetet logikai 1-re kapcsoljuk. Ebben az esetben az időzítés indítása nem lehetséges. A Set bemeneten levő pozitív élváltás csak a ReSet bemenet 1->0 váltása után válik hatásossá. (5). Példaprogram: PROGRAM time1 VAR Timer1 : S_TimeRising; Start AT %I0.0.0.0.0 : BOOL; Halt AT %I0.0.0.0.1 : BOOL; TimeValue1 : UINT := 12; Output1 AT %Q0.0.0.0.0 : BOOL; END_VAR CAL Timer1 (Set := Start, Hold := Halt, PresetTime := TimeValue1) LD Timer1.OutputControl ST Output1 END_PROGRAM
112
(* TimeValue1 = 12 másodperc *)
SaveData SaveData
adatok írása a flash-memóriába (címváltozók alkalmazásával) SaveData BOOL
ADDRESS UINT USINT
Strobe SourceAddress SegmentNumber
Active MaxSegmentNumber
DataLength
Error
BOOL UINT USINT
Az operandusok jelentése: Strobe
letárolandó folyamat indítása
SourceAddress
letárolandó céladatok kezdő címe (típusa ADDRESS)
SegmentNumber
szegmensszám (0….n)
DataLength
a letárolandó adatmezők száma (1….128)
Active
1, ha a letárolási folyamat fut
MaxSegmentNumber a fájl utolsó lehetséges szegmensszáma Error
hibajelzés
Leírás: A SaveData funkcióblokk segítségével a memóriamodulba lehet adatokat a CPU memóriaterületéről letárolni. A memóriamodul logikailag 512, egyenként 128bájt hosszúságú szegmensre van felosztva. Egyszeri hívással maximum 128bájt olvasható vissza. A funkcióblokk egyik legfontosabb alkalmazási területe a remanens memóriaterületnek (pl. a receptura területnek), mely a compiler konfiguráció során a kódgeneráláskor kerül meghatározásra, közbenső letárolása és ezen adatok visszaolvasása egy készülékkonfiguráció megváltoztatása során. Az Error kimenet a következő állapotokat veheti fel: 0
nincs hiba
1
nincs memóriamodul beépítve
2
online kapcsolat miatt nem lehetséges a hozzáférés
3
nem lehetséges a hozzáférés egyidejű ReloadData hívás miatt
4
érvénytelen SegmentNumber (PS4-200 esetén a megengedett: 0….511; PS4300 esetén a modultól függően: 0….1023)
5
érvénytelen adathossz (megengedett DataLength érték: 1….128)
6
a kezdőcím érvénytelen
7
csak a PS4-200 esetén: nem lehetséges a hozzáférés, mert a memóriamodul , mint forráskód háttér van felhasználva
113
SaveData 8
csak a PS4-300 esetén: a memóriamodul formázása nem engedi meg az adattárolási tartomány használatát
Csak a PS4-200 esetén: Az Active kimenet a PS4-150/-200 esetén mindig 0. A funkcióblokk aktuális állapota csak egy ismételt hívás mellett az Error kimenet lekérdezésével oldható meg. Ha az Error 0-t ad, akkor a művelet hiba nélkül végrehajtódott. Ha a kimenet értéke 3, akkor a funkcióblokk még dolgozik. Az Error kimenet aktualizálásához a Strobe bemeneten egy újabb pozitív élet kell generálni. A ReloadData funkcióblokk segítségével lehet a letárolt adatokat a memóriamodulból visszaolvasni! Példaprogram: PROGRAM S_Card VAR SendData : SaveData; Start AT %I0.0.0.0.2 : BOOL; Mem_start AT %MB0.0.0.100 : BYTE; Segment_NR : UINT; DataLength : USINT; ErrorMessage : USINT; END_VAR CAL SendData(Set := Start, SourceAddress := &Mem_start, SegmentNumber := Segment_NR, DataLength := SegmentLength) LD SendData.Error ST ErrorMessage NE 0 JMPC ErrorEvaluation (*...*)
(* ha nem egyenlő 0, akkor hiba! *)
ErrorEvaluation:
(* hiba kiértékelő rutin *)
(*...*) END_PROGRAM
114
SCO SCO
transzparens soros vonali kommunikáció A PLC RS 232, vagy RS 485 interfészein keresztül a kommunikációt az SCO funkcióblokk szervezi. A transzparens ( képernyőn, ember-gép készüléken, vagy egyéb terminálon kivetített, megjelenített, vagy kiválasztott ) adatokat lehet küldeni, vagy fogadni ezeken az interfészeken A felhasználói program, és a PLC-hez csatlakoztatott terminál között az interfészt ez a funkcióblokk reprezentálja. • A kommunikáció az RS 232 interfészen keresztül 9600baud adatátviteli sebességgel, 8 adat bit, 1 stop bit, paritás bit nélkül valósul meg. (baud = bit/ sec.) • Az RS 485 interfészen történő adatátvitelkor több paraméter állítása lehetséges. • A paraméterek a Sucosoft S40 "Topológia konfigurátor” menüben állíthatók. • A funkcióblokkal az RS 232 interfészen keresztül 1 bájttól 63 bájtig, az RS 485 interfészen keresztül 1 bájtól 127 bájtig küldhető át adat. • A funkcióblokk vezérli az adatküldés, és fogadás folyamatát, de nem párhuzamosan, minthogy az adatátvitel fél-duplex módon történik. Az adatküldés feladata magasabb prioritású, mint az adatfogadás feladata. • Ha mindkét interfészen váltakozva akarunk adatot küldeni, akkor két SCO funkcióblokk behívása szükséges, egy az RS 232, egy másik az RS 485 interfész számára.
Az interfészekhez célszerű saját funkcióblokkot rendelni!
A funkcióblokk értékőrző (remanens) beállítási lehetősséggel nem rendelkezik. CTS/RTS "handshake" (fogadóoldali összekötetési módszer IEEE 488 szabvány ) nincs. SCO BOOL
Strobe
USINT
Command
USINT
CardAdress
ADDRESS USINT
MemoryAddress DataSize
Busy
BOOL
ElementNumber
USINT
Error
USINT
115
SCO Az operandusok jelentése: Strobe engedély (pozitív éllel vezérelve) Command
parancs fajtája (1…4)
CardAddress
interfész választás (0=RS 232,
MemoryAddress
A vételi ill. az adási terület kezdőcíme
DataSize
A vételi ill. az adási terület nagysága
Busy
funkcióblokk állapot
ElementNumber
A vételi ill. adási adatbájtok száma
Error
Hibaüzenetek
1=RS 485)
A funkcióblokk be- /kimenetei A funkcióblokk kimenetei Stobe: Indítás, engedélyezés A bemenet élvezérelt. A felfutó él ( 0 → 1 ) a "Command" bemeneten korábban megadott érték alapján indítja az elvégzendő feladatot. A funkcióblokk valamennyi, a felfutó élnél aktuális bemeneti paramétere eltárolódik. A BUSY kimenet magas (1) szintje jelzi a funkcióblokk aktív állapotát, azaz a Strobe jel adatküldés feladatot, vagy adatfogadásra kész állapotot kezdeményezett. Az adatfogadásra kész állapot a Strobe bemenet lefutó élével lezárható. Command: Parancs A Command bemenetre adottt érték állítja be az SCO funkcióblokk üzemmódját. Az üzemmód kiválasztás csak a Strobe bemenet felfutó élénél aktív. Az RS 232 interfészen keresztül 1…63 közötti adatbájt, az RS 485 interfészen keresztül 1…127 közötti adatbájt küldhető. 1. Adás Először az interfész inicializálódik, majd végrehajtásra kerül az adás. 2. Vételkészség a vételi puffer törlésével Először inicializálódik az RS 232 vagy az RS 485 interfész, majd a DataSize-on megadott nagyságú puffer területet kitörli. A fogadott adatbájtok számát az ElementNumber kimenet mutatja. Amennyiben a puffer terület megtelik, a BUSY kimenet 0-ba vált. Egy új él a Strobe bemeneten törli az összes fogadott adatot. 3. Vételkészség a vételi puffer törlése nélkül A 3. üzemmód akkor használható, ha a kapcsolat az 1., vagy 2. üzemmódban már létrejött, mivel csak ez a két üzemmód kapcsolja át a portot a SUCOM módból (a PLC default kommunikációs protokollja), az SCO funkcióblokkon keresztüli a transzparens módú soros kommunikációra. Az ElementNumber kimenet mutatja a vett adatbájtok számát. A vételi puffer nem törlődik ebben az üzemmódban. Ha az előző műveletből maradt még adat a tárban, akkor az új fogadott adatok a tár szabad területére íródnak. Amennyiben a puffer terület megtelik, a BUSY kimenet
116
SCO 0-ba vált. 4. Az SCO funkcióblokkon keresztül a soros kommunikáció kikapcsolása (SUCOM aktiválás) Megjegyzés! Ha az RS 232 interfészen keresztül több, mint 63 adatbájt érkezik, akkor az automatikusan átkapcsol a SUCOM módra. Cardaddress Interfész kiválasztás A Cardaddress bemenet jelöli ki, hogy melyik interfészen történjen a kommunikáció. 0: RS 232 1: RS 485 MemoryAddress Kezdő cím Az adási, illetve a vételi tartomány kezdő címét lehet megadni ezen a bemeneten. A vett adatok közvetlenül beíródnak a megadott területre. Az %MB, %SDB, %RDB tartományokat bájt méretben kell megadni. DataSize Az adási, és a vételi tartományok mérete Az egyszerre adásra kerülő bájtok számát a DataSize bemeneten kell megadni. Ha a vételi állapot az aktív, akkor a DataSize bemeneten a puffer területmérete definiálható. Az alábbi értékek engedélyezettek: RS 232 interfész: 1... 63 RS 485 interfész: 1…127 A funkcióblokk kimenetei BUSY Az SCO funkcióblokk állapota A funkcióblokk visszajelzése: 0: A funkcióblokk inaktív 1: A funkcióblokk aktív Ha egy adási feladat lett indítva, vagy a vételkész állapot lett aktiválva, akkor a funkcióblokk aktív állapotát a BUSY kimenet 1 értéke jelzi. BUSY = 1. Az adás végrehajtása után a BUSY kimenet alacsony szintre kapcsol. BUSY = 0. Ha a vételi puffer teljesen megtelik, a BUSY kimenet szintén nullára vált. BUSY = 0.
117
SCO ElementNumber Az adatbájtok száma A már elküldött, vagy a vett adatbájtok számát jelzi ez a kimenet. ERR Hiba üzenetek 0: Nincs hiba 1: Helytelen paraméter a Command bemeneten. A helyes értékek 1, .., 4 2: Helytelen paraméter a CardAddress bemeneten. A helyes értékek 0, vagy 1. 3: Ütközési konfliktus a SUCOM, vagy a Suconet használatakor. Lehetséges hiba okok: RS 232: SUCOM aktív RS 485: Az SCO funkcióblokk paraméterei nincsenek beállítva (topológia konfigurátorban nem lett kiválasztva). 4: A merkercím túl nagy. A felhasznált memóriának a CPU definiált memóriatartományában kell lenni. (Konfigurációs menü: Programcode Generation -> Options -> Compiler -> Aktiv marker range). 5: Helytelen paraméter a DataSize bemeneten. A helyes értékek: RS 232 interfész: 1... 63 RS 485 interfész: 1…127 6: Helytelen paraméter a MemoryAddress bemeneten A MemoryAddress és a DataSize kombinációjából adódóan megsértette a definiált CPU merkerterületet. Pl.: Aktív terület: 120; MemoryAddress (100) + DataSize (40) = 140 => túl nagy! 7: A fogadó puffer túlcsordulása Több mint 63, illetve 127 bájt érkezett. 8: RS 485 paritás hiba Az adó/vételi interfész paraméterei nem egyeznek meg. 9: Az alkalmazói program egyszerre próbált egy adást és egy vételi feladatot elindítani. Az SCO funkcióblokk használatakor az RS 232, és az RS 485 interfészek az alábbi paraméterekkel rendelkeznek: RS 232
118
Adat átviteli sebesség:
9600 baud ( baud = bit/ sec. )
Adatbitek száma:
8
Stop bit:
1
Paritás vizsgálat:
nincs
SCO RS 485 Az RS 485 interfész paramétereit a Sucosoft S40 "Topológia konfigurátor" menüben lehet kiválasztani. Válassza a Topológia konfigurátorban az Edit -> Set Parameters… -> Bus status (Transparens modus) ->Interface Parameters A szoftver a nem megengedett kombinációkat felismeri, és lehetetlenné teszi a beállításukat. Példák: Az SCO funkcióblokk alkalmazását két példán bemutatjuk be. Adatforgalom (kommunikáció) PLC és nyomtató között soros vonalon. Az RS 485, vagy az RS 232 interfészen keresztül a PLC adatot küld a nyomtatónak. Készülék csatlakozások. Programozó készülék
PLC
Nyomtató
RS485 A példa kipróbálásához szükséges hardver: PLC (pl. PS4-201-MM1 a 04 verziószámtól ) Digitális szimulátor Nyomtató soros vonallal (pl. IPP 144-40E, Metrix) RS 485 / RS 232 nyomtató kábel A példa kipróbálásához szükséges szoftver: Sucosoft S40 a 2.0 verziótól A nyomtató kábel láb ( pin ) kiosztása PLC ( RS-485 )
IPP 144-40E
5 pólusú kerek apa
9 pólusú SUB-D apa
1
Adatkábel ( T / RB )
2
3
0V
1
4
Adatkábel ( TA / RA )
5
PLC ( RS-232 )
IPP 144-40E
9 pólusú kerek apa
9 pólusú SUB-D apa
3
0V
5
5
Tx D
2
119
SCO A példa kipróbálásához szükséges interfészek Az RS-485 paraméterei a Sucosoft S40 "Topológia konfigurátor" menüben állíthatók. A nyomtató interfész paramétereinek beállítása megtalálható a nyomtató gépkönyvében, amely tájékoztat az igényelt speciális karakterekről is. Példaprogram: A PLC a "Sendchar" program felhasználásával küld adatot a nyomtatónak. A " 'Machine 1 ready to start " szöveg küldendő a PLC-től a soros nyomtatóra. A karakterek a STRING változóban vannak letárolva, és a "STRtoCOM" funkcióblokk készíti elő az SCO funkcióblokkal való küldéshez. A szöveges változó tartalmazza a soremelés vezérlő karaktert is, azaz 23 karakterig lehet a nyomtatóra adatokat küldeni. A %I0.0.0.0.7 bemenet választja ki a RS232-es vagy a RS485-as interfészt. %I0.0.0.0.7 = 0
=>
RS232
%I0.0.0.0.7 = 1
=>
RS485
A %I0.0.0.0.0 bemenet felfutó éle indítja az adási műveletet. Mivel az adás alatt a Busy kimenet 1, azaz a %Q0.0.0.0.0 kimenet rövid időre felvillan, a szöveg pedig kinyomtatásra kerül. PROGRAM Sendchar VAR Start AT %I0.0.0.0.0 : BOOL; Interface AT %I0.0.0.0.7 : BOOL; Active AT %Q0.0.0.0.0 : BOOL; Error AT %Q0.0.0.0.3 : BOOL; SendText : STRING ; SendBuffer AT %MB0.0.0.100 : BYTE; Convert : STRtoADR; DataVolume : USINT; Send : SCO; END_VAR LD 'Machine 1 ready to start$0D'
(* szöveges változó a soremelés (*(0Dh) vezérlő karakterrel *) (* A puffer startcíme *) (* Stringet adott memóriaterületre (* átvivő FB *) (* szöveg hossza *)
(* szöveg tárolása (* STRING változóban *)
ST SendText (* A szöveges változó átvitele az adott memóriaterületre *) CAL Convert(Enable := 1, TextString := SendText, TransmitVariable := &SendBuffer) LD Convert.StrLen UINT_TO_USINT ST DataVolume
120
(* formátum adaptálás (* SCO funkcióblokkhoz *)
az
SCO (* A szöveg kiküldése a nyomtatóra *) CAL Send(Strobe := Start, Command := 1, CardAddress := (Interface BOOL_TO_USINT ), MemoryAddress := &SendBuffer, DataSize := DataVolume) LD Send.Busy ST Active LD Send.Error NE 0 ST Error
(* Adás *)
(*kimenet status a %Q0.0.0.0.0*) (* hibakijelzés *)
END_PROGRAM Soros vonali adatforgalom (kommunikáció) PLC és terminál között. Készülék csatlakozások. Terminál
PLC
A példa kipróbálásához szükséges hardver: PLC ( pl. PS4-201-MM1 a 04 verziószámtól felfelé) Digitális szimulátor ZB 4-303-KB1 kábel A példa kipróbálásához szükséges szoftver: Sucosoft S40 a 2.0 verziószámtól Terminál emulátor program ( pl.: Telix ) A példa kipróbálásához szükséges interfészek Az RS-232 paraméterei: 9600 baud, 8 adatbit, 1 stop bit, nincs paritás bit. A terminál paraméterei a terminál emulátor programban beállíthatók.
121
SCO Példaprogram: Az adatcsere a vezérlő és a terminál között a COM9600A program segítségével történik. Adási folyamat A szöveg küldését a terminál felé a %I 0.0.0.0.1 bemeneten megjelenő felfutó él váltja ki. A text 1, és a text 2 közötti választás az %I0.0.0.0.0 értékétől függ: %I0.0.0.0.0 = 0 : "Start condition 1 fulfilled" (az indítási feltétel teljesült) %I0.0.0.0.0 = 1 : "Limit switch 2 activated" (a határoló kapcsoló 2 aktív) Az elküldendő adatok a %MB0.0.0.200 merkerbájttal kezdődő területen találhatók. Vétel A %I0.0.0.0.6 bemenetre adott értékkel lehet a mode 2 vagy a mode 3 üzemmódok között választani. %I0.0.0.0.6 = 0,
mode 2 -- 2. üzemmód (vétel puffer törléssel együtt)
A DataSize adja meg a vett adatok részére lefoglalt puffer méretét. A %I0.0.0.0.2 bemenetre tett érték kapcsolja az SCO funkcióblokkot vételi állapotba, és a funkcióblokk BUSY kimenet magas szintje jelzi a funkcióblokk aktív állapotát. A vett adatok közvetlenül beíródnak a funkcióblokk MemoryAddress bemenetén definiált kezdőcímtől (jelen példában %MB0.0.0.0.400) kezdődő memóriaterületre. Az ElementNumber kimenet a már vett adatok számát mutatja. A BUSY kimenet nullába vált, ha a fogadó puffer teljesen betelt (ElementSize = DataSize). Ha a %I0.0.0.0.2 bemenet ismét aktív, a funkcióblokk fogadja az új adatokat. A funkcióblokk ElementNumber kimenetén megjelenő 0 jelzi, hogy a vételi puffer törlődött. %I0.0.0.0.6 = 1
mode 3 -- 3. üzemmód (vétel puffer törlés nélkül)
Ez a eljárás megegyezik a 2. üzemmód eljárásával. Az egyetlen különbség az, hogy a fogadó puffer nem törlődik. Csak annyi adatbájtot képes fogadni, amennyit a fogadó puffer tárolni képes. Ha a fogadó puffer betelt, ebben az üzemmódban további adat nem fogadható mindaddig, amíg nem törli a fogadó puffer területét a 2. üzemmódban. Ebben a példában két független funkcióblokk végzi az adás és a vétel műveleteit. A funkcióblokkok egymást kölcsönösen reteszelik, így az egyidejű működés nem lehetséges (half-duplex üzemmód). PROGRAM COM9600A VAR (* Változódeklarálás az adott fizikai be-/kimenetekhez *) TextSelection : BOOL AT %I0.0.0.0.0; SendJob : BOOL AT %I0.0.0.0.1; ReceiveJob : BOOL AT %I0.0.0.0.2; ReceiveMode : BOOL AT %I0.0.0.0.6; ReceiveVolume : BYTE AT %QB0.0.0.0; SendBuffer : BYTE AT %MB0.0.0.200; ReceiveBuffer : BYTE AT %MB0.0.0.400; (* lokális változók / közbenső belső változók *)
122
(* 0 = Text1; 1 = Text2 *)
SCO Text1 : STRING; Text2 : STRING := 'Limit switch 2 activated';
(* Text 2 kezdeti értékadással *) (*kap értéket *)
ReceiveText : STRING; DataVolume : USINT; Send_active : BOOL; Receive2_active : BOOL; Receive3_active : BOOL; Error_SD : BYTE; Error_RD : BYTE; (* FB-k deklarálása *) SendFB : SCO; ReceiveFB : SCO; SendConverter : STRtoADR ; ReceiveConverter : ADRtoSTR ; END_VAR LD 'Start condition 1 fulfilled' ST Text1
(* Text 1 a program során ka értéket *)
LD Receive2_active OR Receive3_active JMPC Not_send LD TextSelection JMPC Second_Text CAL SendConverter(Enable := 1, TextString := Text1, TransmitVariable := &SendBuffer) LD SendConverter.StrLen UINT_TO_USINT ST DataVolume
(*formátum adaptálás az SCO-hoz *) (* közvetlenül is tárolható: ST SendFB.DataSize *)
CAL SendFB(Strobe := (SendJob ANDN Receive2_active ANDN Receive3_active ), Command := 1, CardAddress := 0, MemoryAddress := &SendBuffer, DataSize := DataVolume)
(*adás üzemmód *) (*RS232*)
LD SendFB.Busy ST Send_active
123
SCO Second_Text: CAL SendConverter(Enable := 1, TextString := Text2, TransmitVariable := &SendBuffer) LD SendConverter.StrLen UINT_TO_USINT ST DataVolume
(*formátum adaptálás az SCO-hoz *)
CAL SendFB(Strobe := SendJob, Command := 1, CardAddress := 0, MemoryAddress := &SendBuffer, DataSize := DataVolume)
(* adás üzemmód *) (*RS232*)
LD SendFB.Busy ST Send_active Not_send: LD Send_active JMPC Not_Receive LD ReceiveMode JMPC ReceiveMode_3 CAL ReceiveFB(Strobe := ReceiveJob, Command := 2, CardAddress := 0, MemoryAddress := &ReceiveBuffer, DataSize := 63)
(*RS232*)
LD ReceiveFB.Busy ST Receive2_active ReceiveMode_3: CAL ReceiveFB(Strobe := ReceiveJob, Command := 3, CardAddress := 0, MemoryAddress := &ReceiveBuffer, DataSize := 63) LD ReceiveFB.Busy ST Receive3_active Not_Receive: END_PROGRAM
124
(*RS232*)
Serialize Serialize
tetszőleges adatstruktúra bájtos tömbbe való másolása Serialize ANY
Source
Source
ANY_ARRAY
Buffer
Buffer
UINT
BufferOffset
SourceLength Error
UINT USINT
Az operandusok jelentése: Source
forrás változó
Buffer
céltartomány
BufferOffset
eltolás értéke a céltartományon belül
SourceLength
a forrásváltozó hossza bájtban megadva
Error
hibajelzés
Leírás: A Serialize funkcióblokk egy tetszőleges típusú változót másol át egy adott céltartományba. Az adott céltartományt a Buffer és a BufferOffset változókkal lehet meghatározni. Az átmásolt akár egymástól is különböző típusú adatok, mint tömb más PLC-be átküldhető, és ott a Deserialize funkcióblokkal ismét kicsomagolható. A SourceLength kimeneti változó a forrásadatok hosszát adja meg bájtos méretben. A Buffer tetszőleges méretű tömb lehet, típusa ANY_BIT és ANY_INT értékű lehet, kivéve a BOOL típust. Az Error kimenet az alábbi értékeket veheti fel: 5
nincs hiba
6
puffer túllépés
7
az Offset a Bufferen kívül helyezkedik el
8
a Source a Bufferen belül helyezkedik el
9
A SourceLength értéke 0 A BOOL adattípus, mint forrásváltozó típus nem támogatott, és a fordítás során (Compiler) megfeleő hibajelzés jelentkezik!
A különböző memóriafoglalási technikák miatt a Serialize funkcióblokk minden PLC-típusnál egymástól eltérő eredményeket ad(pl. a struktúrák esete) Ha PLC-k között különböző típusú adatokat kíván cserélni, akkor csak az elemi ANY_BIT (kivéve a BOOL) és ANY_INT adattípusokat és tömböket másolja át, hiszen a STRING, ARRAY OF BOOL, mint származtatott adattípusok az egyes
125
Serialize PLC-ben különbözőképpen kerülnek ábrázolásra. A fenti korlátozások azonos típusú PLC-k közti adatcserére nem vonatkoznak. A következő példa 20bájtot másol át egy 30bájtos tömbbe! Példaprogram: PROGRAM sendstruct VAR serie_fb : Serialize; struct_buffer AT %SDB1.1.0.0 : ARRAY [1..30] OF BYTE; CheckSumOffset : UINT := 0; CheckSum : UINT; DTOffset : UINT := 2; TransDatum : DT; (* adási dátum *) DataOffset: UINT := 10; TransmitData : Array [1..20] OF BYTE; (* felhasználói adatok *) SerializedLength : UINT; Error : USINT; END_VAR (* adatok előkészítése küldésre *) CAL serie_fb(Source := CheckSum, Buffer := struct_buffer, BufferOffset := CheckSumOffset, | SerializedLength := SourceLength) LD serie_fb.Error USINT_TO_BOOL JMPC _Fail
(* volt-e hiba? *) (* hibakezelési rutin *)
CAL serie_fb(Source := TransDatum, Buffer := struct_buffer, BufferOffset := DTOffset, | SerializedLength := SourceLength) LD serie_fb.Error USINT_TO_BOOL JMPC _Fail
(* volt-e hiba? *) (* hibakezelési rutin *)
CAL serie_fb(Source := TransmitData, Buffer := struct_buffer, BufferOffset := DataOffset, | SerializedLength := SourceLength)
126
Serialize LD serie_fb.Error USINT_TO_BOOL JMPC _Fail
(* volt-e hiba? *)) (* hibakezelési rutin *)
(* az adatstruktúra összeállt, el lehet küldeni *) _Fail:
(*hibakezelési rutin *)
127
SetRealTimeClock SetRealTimeClock
Valós idejű óra állítás SetRealTimeClock
BOOL ADDRESS
Set DataAddress
Error
USINT
DataAddress
Az operandusok jelentése: Set
engedélyező jel (felfutó él) az adatcímek
DataAddress
a memóriaterület kezdőcíme, ahol a dátum és időértékek találhatók
Error
hibajelzés
Leírás: A Set bemeneten 0 → 1 felfutó éllel lehet a valóidejű óra értékét átírni. Az új értékek átírása közvetett módon történik. A DataAddress által meghatározott memória kezdőcímtől kezdve hét egymást követő adatbájt tartalmazza a beírandó új valóidejű dátum és idő értékeket. A bájtok sorrendje év, hónap, nap, hétnap sorszáma, óra, perc, másodperc. A felfutó él hatására a teljes érték átíródik, azaz a teljes memóriaterületnek a helyes információt kell tartalmazni. Részinformációk külön- külön nem kezelhetők. A deklarált adattípusok bájt szélességűnek kell lenni, tehát BYTE, SIINT, vagy USINT. Célszerű az USINT alkalmazása. Hibaüzenetek Az ERR kimenet tartalmazza a lehetséges hibák kódját 1:
Helytelen DataAddress paraméter
2:
Helytelen év paraméter ( 0 … 99 )
3:
Helytelen hónap paraméter ( 1 … 12 )
4:
Helytelen nap paraméter ( 1 … 31 )
5:
Helytelen hétnap paraméter ( 0 … 6, 0 = vasárnap )
6:
Helytelen óra paraméter ( 0 … 23 )
7:
Helytelen perc paraméter ( 0 … 59 )
8:
Helytelen másodperc paraméter ( 0 … 59 )
Új fejlesztések esetén az óra állítására használja inkább az RTC funkcióblokkot!
128
SetRealTimeClock Példaprogram: PROGRAM Clock VAR Year AT %MB0.0.0.0 : USINT := 97; Month AT %MB0.0.0.1 : USINT := 1; Day AT %MB0.0.0.2 : USINT := 1; Weekday AT %MB0.0.0.3 : USINT := 2; (*2 = kedd*) Hour AT %MB0.0.0.4 : USINT:= 12; Minute AT %MB0.0.0.5 : USINT ; Second AT %MB0.0.0.6 : USINT ; (* Default érték kedd, 1.1.1997 12.00h *) Set_time : SetRealTimeClock; (* FB deklaráció*) Set AT %I0.0.0.0.0 : BOOL ; END_VAR LD 98 ST Year LD 9 ST Month LD 12 ST Day LD 6 ST Weekday
(* év beállítás: 1998 *) (* hónap beállítás: szeptember *) (* nap beállítás: 12. *) (* hétnap sorszám beállítás: szombat *)
(* A valósidejű óra az FB-hívással teljesen átíródik *) (* FIGYELEM: 12.00, mint alapérték ( default) kerül felhasználásra! *) CAL Set_time(Set := Set, DataAddress := &Year) LD Set_time.Error NE 0 JMPC Hiba_kiertekeles . . . .END_PROGRAM
(* hiba figyelés *)
129
SR_x SR_x
bites léptető regiszter * BOOL
ForwardPulse
Output_1
BOOL
BOOL
BackwardPulse
Output_2
BOOL
BOOL
ReSet
.
BOOL
BOOL
ForwardData
.
BOOL
BOOL
BackwardData
Output_n
BOOL
Az operandusok jelentése: ForwardPulse
léptető impulzus előre, felfutó él
BackwardPulse
léptetó impulzus vissza, felfutó él
ReSet
visszaállítás, törlés
ForwardData
adatbemenet, előre
BackwardData
adatbemenet, vissza
Output_
adatkimenet 1
Output_n
utolsó adatkimenet
Leírás: A * helyén az adott prototípus funkcióblokk neve írandó be. A lehetséges nevek a következők: SR_1, SR_2, …SR_128, ahol az egyes számok az 1-bites regisztermező hosszát adják meg. A ForwardData bemeneten levő érték a ForwardPulse bemeneten megjelenő felfutó él hatására belép az első regiszter helyre. A regiszter eredeti tartalma egy lépéssel előre lép. BackwardPulse BackwardData x
ForwardPulse Outout_8
Output_1 ForwardData
8
7
6
5
4
3
2
1
1
1
0
0
1
1
0
1
BackwardPulse
1
ForwardPulse léptetés iránya
BackwardData x
Outout_8
Output_1 ForwardData
8
7
6
5
4
3
2
1
1
0
0
1
1
0
1
1
8 bit hosszú léptető regiszter a ForwardData bemenet figyelembevételével egyet előre lép.
130
SR_x A BackwardData bemeneten levő érték a BackwardPulse bemeneten megjelenő felfutó él hatására belép az utolsó regiszter helyre. A regiszter eredeti tartalma egy lépéssel vissza lép. BackwardPulse BackwardData 0
ForwardPulse Outout_8
Output_1 ForwardData
8
7
6
5
4
3
2
1
1
0
0
1
1
0
0
1
BackwardPulse
x
ForwardPulse léptetés iránya
BackwardData
Outout_8
Output_1 ForwardData
8
7
6
5
4
3
2
1
0
1
0
0
1
1
0
0
x
8 bit hosszú léptető regiszter a BackwardData bemenet figyelembevételével egyet visszalép.
Az Output_1…Output_n kimenetek a regiszter aktuális tartalmát jeleníthetik meg. HA a ReSet törlő bemenet logikai 1-t kap, akkor a regiszter tartalma, azaz az összes kimenet törlődik. A regisztermező hossza 128 lépésben van korlátozva. Több léptetőregiszter egymáshoz fűzhető, és így 128 lépésnél hosszabb regiszter is kialakítható. Példaprogram: PROGRAM sh_reg1 VAR Shiftregister_4_bit : SR_4; Pulse1 : BOOL; Pulse2 : BOOL; Reset : BOOL; Data_bit1 : BOOL; Data_bit2 : BOOL; Output1 : BOOL; Output2 : BOOL; Output3 : BOOL; Output4 : BOOL; END_VAR
131
SR_x CAL Shiftregister_4_bit(ForwardPulse := Pulse1, BackwardPulse := Pulse2, ReSet := Reset, ForwardData := Data_bit1, BackwardData := Data_bit2) LD Shiftregister_4_bit.Output_1 ST Output1 LD Shiftregister_4_bit.Output_2 ST Output2 LD Shiftregister_4_bit.Output_3 ST Output3 LD Shiftregister_4_bit.Output_4 ST Output4 END_PROGRAM
132
SRB_x SRB_x
bájtos lépető regiszter * BOOL
ForwardPulse
Output_1
USINT
BOOL
BackwardPulse
Output_2
USINT
BOOL
ReSet
.
USINT
USINT
ForwardData
.
USINT
USINT
BackwardData
Output_n
USINT
Az operandusok jelentése: ForwardPulse
léptető impulzus előre, felfutó él
BackwardPulse
léptető impulzus vissza, felfutó él
ReSet
visszaállítás, törlés
ForwardData
adatbemenet, előre
BackwardData
adatbemenet, vissza
Output_
adatkimenet 1
Output_n
utolsó adatkimenet
Leírás: A * helyén az adott prototípus funkcióblokk neve írandó be. A lehetséges nevek a következők: SRB_1, SRB_2, …SRB_128, ahol az egyes számok a 8-bites regisztermező hosszát adják meg. A ForwardData bemeneten levő érték a ForwardPulse bemeneten megjelenő felfutó él hatására belép az első regiszter helyre. A regiszter eredeti tartalma egy lépéssel előre lép. BackwardPulse BackwardData x
ForwardPulse Outout_8
Output_1 ForwardData
8
7
6
5
4
3
2
1
019
255
035
095
122
023
082
003
BackwardPulse
102
ForwardPulse léptetés iránya
BackwardData x
Outout_8
Output_1 ForwardData
8
7
6
5
4
3
2
1
255
035
095
122
023
082
003
102
8 bit hosszú léptető regiszter a ForwardData bemenet figyelembevételével egyet előre lép.
133
SRB_x A BackwardData bemeneten levő érték a BackwardPulse bemeneten megjelenő felfutó él hatására belép az utolsó regiszter helyre. A regiszter eredeti tartalma egy lépéssel vissza lép. BackwardPulse BackwardData 007
ForwardPulse Outout_8
Output_1 ForwardData
8
7
6
5
4
3
2
1
019
255
035
095
122
023
082
003
BackwardPulse
x
ForwardPulse léptetés iránya
BackwardData
Outout_8
Output_1 ForwardData
8
7
6
5
4
3
2
1
007
019
255
035
095
122
023
082
x
8 bit hosszú léptető regiszter a BackwardData bemenet figyelembevételével egyet vissza lép.
Az Output_1…Output_n kimenetek a regiszter aktuális tartalmát jeleníthetik meg. HA a ReSet törlő bemenet logikai 1-t kap, akkor a regiszter tartalma, azaz az összes kimenet törlődik. A regiszterhossz 128 lépésben van korlátozva. Több léptetőregiszter egymáshoz fűzhető, és így 128 lépésnél hosszabb regiszter is kialakítható. Példaprogram: PROGRAM sch_reg8 VAR Shiftregister_2_byte : SRB_2; Pulse1 : BOOL; Pulse2 : BOOL; Reset : BOOL; Data1 : USINT; Data2 : USINT; Output1 : USINT; Output2 : USINT; END_VAR
134
SRB_x CAL Shiftregister_2_byte(ForwardPulse := Pulse1, BackwardPulse := Pulse2, ReSet := Reset, ForwardData := Data1, BackwardData := Data2) LD Shiftregister_2_byte.Output_1 ST Output1 LD Shiftregister_2_byte.Output_2 ST Output2 END_PROGRAM
135
SRW_x SRW_x
szavas lépető regiszter * BOOL
ForwardPulse
Output_1
UINT
BOOL
BackwardPulse
Output_2
UINT
BOOL
ReSet
.
UINT
UINT
ForwardData
.
UINT
UINT
BackwardData
Output_n
UINT
Az operandusok jelentése: ForwardPulse
léptető impulzus előre, felfutó él
BackwardPulse
léptető impulzus vissza, felfutó él
ReSet
visszaállítás, törlés
ForwardData
adatbemenet, előre
BackwardData
adatbemenet, vissza
Output_
adatkimenet 1
Output_n
utolsó adatkimenet
Leírás: A * helyén az adott prototípus funkcióblokk neve írandó be. A lehetséges nevek a következők: SRB_1, SRB_2, …SRB_128, ahol az egyes számok a 16-bites regisztermező hosszát adják meg. A ForwardData bemeneten levő érték a ForwardPulse bemeneten megjelenő felfutó él hatására belép az első regiszter helyre. A regiszter eredeti tartalma egy lépéssel előre lép. BackwardPulse BackwardData
ForwardPulse Outout_8 8
x
Output_1 ForwardData 7
6
5
4
3
2
1
00197 02555 18637 00023 12987 00292 09688 00023
BackwardPulse
13657
ForwardPulse léptetés iránya
BackwardData
Outout_8 8
x
Output_1 ForwardData 7
6
5
4
3
2
1
02555 18637 00023 12987 00292 09688 00023 13657
8 bit hosszú léptető regiszter a ForwardData bemenet figyelembevételével egyet előre lép.
136
SRW_x A BackwardData bemeneten levő érték a BackwardPulse bemeneten megjelenő felfutó él hatására belép az utolsó regiszter helyre. A regiszter eredeti tartalma egy lépéssel vissza lép. BackwardPulse BackwardData
ForwardPulse Outout_8 8
00984
Output_1 ForwardData 7
6
5
4
3
2
1
00197 02555 18637 00023 12987 00292 09688 00023
BackwardPulse
x
ForwardPulse léptetés iránya
BackwardData
Outout_8 8
Output_1 ForwardData 7
6
5
4
3
2
1
00984 00197 02555 18637 00023 12987 00292 09688
x
8 bit hosszú léptető regiszter a BackwardData bemenet figyelembevételével egyet vissza lép.
Az Output_1…Output_n kimenetek a regiszter aktuális tartalmát jeleníthetik meg. HA a ReSet törlő bemenet logikai 1-t kap, akkor a regiszter tartalma, azaz az összes kimenet törlődik. A regiszterhossz 128 lépésben van korlátozva. Több léptetőregiszter egymáshoz fűzhető, és így 128 lépésnél hosszabb regiszter is kialakítható. Példaprogram: PROGRAM s_reg16 VAR Shiftregister_2_wort : SRW_2; Pulse1 : BOOL; Pulse2 : BOOL; Reset : BOOL; Data1 : UINT; Data2 : UINT; Output1 : UINT; Output2 : UINT; END_VAR
137
SRW_x CAL Shiftregister_2_wort(ForwardPulse := Pulse1, BackwardPulse := Pulse2, ReSet := Reset, ForwardData := Data1, BackwardData := Data2) LD Shiftregister_2_wort.Output_1 ST Output1 LD Shiftregister_2_wort.Output_2 ST Output2 END_PROGRAM
138
STRtoADR STRtoADR
STRING típusú változó adott címterületre másolása STRtoADR TextSring
ANY_STRING
TextSring
TransmitVariable
ADDRESS
Enable
BOOL
StrLen
UINT
Az operandusok jelentése: TextSring
Karakterlánc, melyet a memóriaterületre kell bemásolni.
TransmitVariable
A memóriaterület kezdőcíme, ahová az adatok bemásolódnak
Enable
Az átalakítási folyamat engedélyezése
StrLen
Az átalakított jelek száma
Leírás: A soros vonalra küldendő adatokat előzetesen a soros vonali funkcióblokk (pl.SCO) adási területére kell bemásolni. Az STRtoADR blokk erre a célra használható. Az Enable bemenetre adott 1-es szinttel indítható az átalakítási művelet. Az StrLen kimeneten az átmásolt adatok száma olvasható le. Amennyiben a STRING változó karakterhossza hosszabb a letárolási hely méreténél, akkor a STRING változó vége értelemszerűen lemarad, azaz nem kerül bemásolásra. Példaprogram: PROGRAM Textcopy VAR String_to_Marker : STRtoADR; SendText : STRING := 'Small Example'; StartAddress AT %MB0.0.0.100 : BYTE; SendLength : UINT; END_VAR CAL String_to_Marker (Enable := 1, TextString := SendText, TransmitVariable := &StartAddress) (* A karakterlánc a %MB0.0.0.100-tól kezdődően kerül bemásolásra *) LD String_to_Marker.StrLen ST SendLength END_PROGRAM
139
STRtoCOM STRtoCOM
STRING típusú változó adott címterületre másolása STRtoCOM TextString
ANY_StTRING
TransmitVariaable
ANY_ARRAY
TextString TransmitVariaable
Enable
BOOL
Az operandusok jelentése: TextSring
Karakterlánc, melyet a tömb adataiba kell bemásolni.
TransmitVariable
A tömb, ahová a karakterláncot be kell másolni
Enable
Az átalakítási folyamat engedélyezése
StrLen
Az átalakítandó jelek száma
Leírás: A soros vonalra küldendő adatokat előzetesen a soros vonali funkcióblokk (pl.SCO) adási területére kell bemásolni. Az STRtoCOM blokk erre a célra használható. Az Enable bemenetre adott 1-es szinttel indítható az átalakítási művelet. Az StrLen kimeneten az átmásolt adatok száma olvasható le. Amennyiben a STRING változó karakterhossza hosszabb a letárolási hely méreténél, akkor a STRING változó vége értelemszerűen lemarad, azaz nem kerül bemásolásra. Példaprogram: PROGRAM Textsend VAR String_to_Array : STRtoCOM; SendText : STRING := 'Small Example'; SendArray : ARRAY [1..100] OF BYTE; SendLength : UINT; END_VAR CAL String_to_ Array(Enable := 1, TextString := SendText, TransmitVariable := SendArray | SendLength :=.StrLen) END_PROGRAM
140
TimeConcat TimeConcat
idő (TIME) típusú változó összeállítása egyedi UINT típusú adatokból TimeConcat UINT
MilliSeconds
UINT
Seconds
UINT
Minutes
UINT
Hours
UINT
Days
UINT
Sign
OutputTime
TIME
Overflow
BOOL
Az operandusok jelentése: MilliSeconds
időtartam változó milliszekundum része
Seconds
időtartam változó szekundum része
Minutes
időtartam változó perc része
Hours
időtartam változó óra része
Days
időtartam változó nap része
Sign
az időtartam előjele
OutputTime
az eredményül kapott idő változó
Overflow
Túlcsordulás
Leírás: A bemenetként UINT formátumban megadott egyedi időtartam értékeket a funkcióblokk a TIME formátumú változóvá alakítja. A funkcióblokk az egyes értékeket átszámítja az időtartam változó megfelelő részeivé, és szükség esetén túlcsordulást képez. A bemeneti változók minden megengedett UINT típusú értéket felvehetnek, amíg az összérték túl nem lépi a T#63d23h59m59s999ms értéket. Amennyiben megtörténik a túllépés, akkor az Overflow kimeneten túlcsordulás jelzés ( = 1) jelentkezik. A bemeneti értékek előjelbitje az eredményértékben is megjelenik. A Sign = 0 pozitív, a Sign = 1 érték negatív kimeneti operandust eredményez.
141
TimeConcat Példaprogram: PROGRAM time_gen VAR TimeConcaten : TimeConcat; Milliseconds : UINT; Seconds : UINT; Minutes : UINT; Hours : UINT; Days : UINT; Sign: BOOL := 0; TimeStructure : TIME; Overflow : BOOL; END_VAR CAL TimeConcaten (MilliSeconds := Milliseconds, Seconds := Seconds, Minutes := Minutes, Hours := Hours, Days := Days, Sign := Sign | TimeStructure := OutputTime, Overflow := Overflow) END_PROGRAM
142
TimeGenerator TimeGenerator
ütemadó impulzusgenerátor TimeGenerator Set
BOOL
PulseOutput
BOOL
Period
UINT
Az operandusok jelentése: Set
indítási feltétel, pozitív éllel
Period
Periódusidő milliszekundumban
PulseOutput
impulzus kimenete
Idődiagramok:
Set
PulseOutput T Leírás Ha a Set bemenet magasba vált a PulseOutput kimeneten (a Period bemeneten, milliszekundumban definiált periódusidővel) 1:1 kitöltési tényezőjű pulzussorozat generálódik mindaddig, amíg az Set bemenet magas. A periódusidőnek mindig nagyobbnak kell lennie a ciklusidő kétszeresénél, hogy az impulzus alacsony, és magas szintje tisztán elkülönüljenek. Ha a periódusidőt meghatározó Period bemenetre tett érték változik, ez csak akkor módosítja a periódusidőt, ha a Set bemenetre egy felfutó él jut. A megadott periódusidő pontosságát az alkalmazói program ciklusideje és az operációs rendszer futási ideje befolyásolhatja. A funkcióblokk programcikluson belüli többszöri hívása (különösen a periódusidő és a program ciklusidő azonos nagyságrendbe esése esetén) a pontatlanságot csökkenti. A periódusidő páratlan értékét a belső szoftver a következő páros értékre lefelé kerekíti.
143
TimeGenerator Példaprogram: PROGRAM frequency VAR ClockGenerator : PulseGenerator; Start AT %I0.0.0.3.6 : BOOL; PeriodTime: UINT := 320; Clock : BOOL; END_VAR CAL ClockGenerator(Set := Start, Period := PeriodTime) LD ClockGenerator.PulseOutput ST Clock END_PROGRAM
144
(* A periódusidő milliszekundumban *)
TimePulse TimePulse
impulzusképző TimePulse BOOL
Set
BOOL
ReSet
PulseOutput
BOOL
ElapsedTime
UINT
PresetTime
UINT
Az operandusok jelentése: Set
indítási feltétel, pozitív éllel
ReSet
visszaállítás, törlés
PreSetTime
impulzus időérték milliszekundumban
PulseOutput
impulzus kimenete
ElapsedTime
ténylegesen eltelt impulzus idő milliszekundumban
Idődiagramok:
Set ReSet PulseOutput T
T
T
Leírás A Set bemenet felfutó élével indítva PulseOutput kimenet a PresetTime bemeneten (milliszekundumban ) definiált időtartamra magas értéket vesz fel. A Set állapotától függetlenül az adott hosszúságú impulzus a PulseOutput kimeneten fennmarad, és csak a pulzusidő letelte után lesz ismét alacsony a P kimenet értéke. Az ElapsedTime kimenet milliszekundumban kijelzi a időszámláló aktuális értékét. A ReSet bemenet magas szintje, alaphelyzetbe állítja az időtagot. Alaphelyzetben a kimenetek értéke nulla.
145
TimePulse Példaprogram: PROGRAM pulse VAR Timer1 : TP; Start AT %I0.0.0.2.6 : BOOL; PulseDuration: TIME := T#125ms; OutputPulse : BOOL; ActualTime : TIME; END_VAR CAL Timer1 (IN := Start, PT := PulseDuration) LD Timer1.Q ST OutputPulse LD Timer1.ET ST ActualTime END_PROGRAM
146
TimerAlarm TimerAlarm
időzítéses megszakításkezelés
TimerAlarm BOOL
EnableDisable
USINT
Mode
UINT
Predivide
UINT
SetpointValue
ANY_FUNCTION_BLOCK
SubRoutine
Error CallUpValue
USINT UINT
Az operandusok jelentése: EnableDisable
Megszakításkérő funkcióblokk engedélyezése / tiltása, felfutó élvez. (engedély=1, tiltás=0)
Number
üzemmód (1 = timer funkció, 2 = impulzusgenerátor funkció)
RisingEdge
előosztó
SetpointValue
Impulzusszám alapjel
SubRoutine
megszakításkérést kiszolgáló funkcióblokk neve
Error
hibajelzés
CallUpValue
megszakításkérő hívások száma
Leírás: A funkcióblokk a PS4-201-MM1 alapkészülék %I0.0.0.0.1 bemenetéhez van hozzárendelve. A PS4-141-MM1 és PS4-151-MM1 esetén a hozzárendelés a %I0.0.0.1.0 bemenethez történik. A PS4-341-MM1 két élvezérelt bemenettel (%I0.0.0.1.0, és %I0.0.0.1.1) rendelkezik Az EnableDisable bemenet engedélyezi a funkcióblokk működését. Ha a bemeneten pozitív élváltás (0 → 1) következik be, a funkcióblokk indul, valamint átveszi aSubRoutine bemenetre adott megszakításkérő funkcióblokk nevet, a Predivide és a SetpointValue bemenetekre adott értékeket és közbensőleg letárolja azokat. A CallUpNumber kimenet egyidejűleg törlődik. A bemenet 1 -> 0 átmenete esetén a funkcióblokk leáll, és egyúttal törlődik is. A funkcióblokk az 1. üzemmódban egy időzítőt valósít meg.. Az időalap = (a Predivide bemeneten levő érték) µs-ban, a megengedett legrövidebb időalap 512µs. Az alapérték = (a SetpointValue bemeneten levő érték). Ha az alapértéknek megfelelő számú, egyenként az időalap hosszúságú idő teljesen letelt, akkor a
147
TimerAlarm CallUpNumber tartalma eggyel nő, és ha a SubRoutine bemenet nem üres, akkor behívja a bemeneten feltüntetett megszakítást kiszolgáló funkcióblokkot. A funkcióblokk a 2. üzemmód állásban egy jelgenerátor valósít meg. A jelgenerátor az alapkészülék (PS4-150/-200-/300-MM1) %Q0.0.0.0.0 kimenetéhez csatlakozik. A generátor periódus ideje = (a Predivide bemeneten levő érték) µs-ban. A SetpointValue bemeneten a %Q0.0.0.0.0 kimeneten megjelenő összes le- és felfutó él összegét kell megadni. Ha a SetpointValue alapérték felének megfelelő számú, egyenként az időalap hosszú impulzus teljesen letelt, akkor a CallUpNumber tartalma eggyel növekszik. Az ERR kimenet tartalmazza a hibák kódjait: 0 = nincs hiba 1 = alapérték (SetpointValue) bemeneten 0 van 2 = előosztó (Predivide) bemeneten az érték < 512. 3 = a Mode bemeneten nincs megfelelő érték (nem 1, vagy 2) A SubRoutie bemenet lehetővé teszi egy eseményvezérelt program beillesztését. Ennek érdekében ezen a bemeneten a kiszolgáló funkcióblokk címét kell megadni. Mikor az esemény bekövetkezik (a CallUpValue számláló eggyel nő) a funkcióblokk meghívásra kerül. Ha ezen a bemeneten nincs cím, akkor csak a CallUpValue számláló tartalma nő. A megszakításkérést kiszolgáló funkcióblokk nem tartalmazhat sem bemenő, sem kimenő paramétereket. Egy ilyen funkcióblokk csak lokális változókat, vagy csak a főprogramban deklarált globális változókat, mint külső változókat (VAR_EXTERNAL) tartalmazhat. Eseményvezérelt program alkalmazásakor az alábbi szempontokat kell figyelembe venni: • Az esemény bekövetkezte a ciklikus felhasználói program végrehajtását megszakítja, a regiszterek állapotát elmenti, és a SubRoutine bemeneten megadott címre ugorva végrehajtja a kiszolgáló funkcióblokkot. A megszakításkérő funkcióblokk nem szakítható meg egy másik megszakításkérő funkcióblokkal (az összes megszakításkérő funkcióblokknak azonos a prioritása). • A felhasználói program 5ms időtartamra (kb. 1000 utasítássor végrehajtása) korlátozza a megszakításkérő funkcióblokk végrehajtási idejét, mivel a megszakításkérő funkcióblokk működését a rendszerprogram sem tudja (még tápkimaradáskor sem) megszakítani. Ha a végrehajtási idő túllépi ezt a korlátot, akkor a táp kikapcsolásakor EDC hiba keletkezhet. • A megszakításkérő funkcióblokk végrehajtási ideje hozzáadódik a felhasználói program végrehajtási idejéhez, így a ciklusidő ellenőrzésbe is bekerül! • Mivel az eseményvezérelt program futtatásakor korlátozás nélkül elérhetők a globális változók is, a ciklikus felhasználói program és az eseményvezérelt program által közösen irható /olvasható adatokat reteszelés nélkül nem szabad felhasználni. Például a ciklikus felhasználói programban és a megszakításkérő funkcióblokkban ugyanabban a bájtban használt bithozzáférést csak a Disable_Interrupt és a Enable_Interrupt utasításokkal való szinkronizálással
148
TimerAlarm szabad korrekten végrehajtani. • A lehető leggyorsabb reagálás érdekében a megszakításkérő funkcióblokkban célszerű a közvetlen periféria hozzáférést használni, melyek az alapkészüléken állnak rendelkezésre (%QP0.0.0.0.x, %QPB0.0.0.0). • A megszakításkérő funkcióblokkok az alkalmazói programban elvileg többször is használhatók, de ezt általában kerülni érdemes, mivel a megszakításkérő funkcióblokk típusok ugyanazzal az eseményforrással, és így a programban csak az utoljára érvényesülő funkcióblokk határozza meg feldolgozást. A többszöri felhasználás azt jelenti, hogy az egyedi funkcióblokk-típus minden egyes alkalmazásához külön-külön adatterületet foglal le. A következő példában aTimerAlarm, mint impulzusgenerátor (mode = 2) működik. Az időalap 1ms,( Predivide = 1000). Mivel a SetpointValue = 100, a %Q0.0.0.0.0 kimeneten 50db impulzus jelenik meg 1:1 kitöltéssel. A megszakításkérő funkcióblokkok bemeneteinek értékadása csak a híváskor történő zárójeles értékadással történhet. Közvetlen paraméter hozzárendelés a zárójelen kívül, vagy a hívást követően nem megengedett! min. 512 Predivide=512 Mode=1 SetpointValue=1 CallUpNumber
0
1024
1
2
t [µs]
3
4
5
6
7
8
9
-
-
65534
0
Ugrás a funkcióblokkra 512 Predivide =512 Mode =1 SetpointValue=3 CallUpNumber 0
1024
0
0
1
1 1 2 2 Ugrás a funkcióblokkra
2
3
3
3
4
4
0
1 1 1 1 Ugrás a funkcióblokkra
2
2
2
2
3
3
kimenet 512 Predivide =512 Mode =2 SetpointValue=4 CallUpNumber 0
1024
0
0
149
TimeSplit TimeSplit
idő (TIME) típusú változó szétválasztása egyedi UINT típusú adatokra TimeSplit InputTime
TIME
MilliSeconds
UINT
Seconds
UINT
Minutes
UINT
Hours
UINT
Days
UINT
Sign
BOOL
Az operandusok jelentése: InputTime
a bemeneti TIME időtartam változó
MilliSeconds
időtartam változó milliszekundum része
Seconds
időtartam változó szekundum része
Minutes
időtartam változó perc része
Hours
időtartam változó óra része
Days
időtartam változó nap része
Sign
az időtartam előjele
Leírás: A bemenetként TIME formátumban megadott változót a funkcióblokk UINT formátumú egyedi változókká alakítja át. A Sign kimenet adja meg az időtartam változó előjelét. 0 a pozitív időtartamot, 1 a negatív időtartamot jelképezi. Példaprogram: PROGRAM zt_split VAR TimeElements : TimeSplit; Duration : TIME := T#20d22h13m12s800ms; Milliseconds : UINT; Seconds : UINT; Minutes : UINT; Hours : UINT; Days : UINT; Sign : BOOL; END_VAR
150
TimeSplit CAL TimeElements(InputTime := Duration | Milliseconds := MilliSeconds, Seconds := Seconds, Minutes := Minutes, Hours := Hours, Days := Days, Sign := Sign) END_PROGRAM
151
TODsplit TODconcat
napi idő (TOD) típusú változó összeállítása egyedi UINT típusú adatokból TODconcat UINT
Millisecond
UINT
Second
UINT
Minute
UINT
Hour
OutputTOD Error
TIME_OF_DAY BOOL
Az operandusok jelentése: Millisecond
idő változó nap része
Second
idő változó hónap része
Minute
idő változó év része
Hour
idő változó óra része
OutputTOD
az eredményül kapott dátum változó
Error
Hibajelzés
Leírás: A bemenetként UINT formátumban megadott egyedi értékeket a funkcióblokk a idő (TIME_OF_DAY) formátumú változóvá alakítja. Az egyes bemeneti értékek a nekik megfelelő értéktartományt nem léphetik át. Amennyiben a megengedett értékeket túllépik, akkor az Error kimeneten hibajelzés lép fel (= 1). Példaprogram: PROGRAM time2 VAR TimeOfDay : TODconcat; Millisecond : UINT; Second : UINT; Minute : UINT; Hour : UINT; TODStructure : TIME_OF_DAY; Error : BOOL; END_VAR CAL TimeOfDay(MilliSecond := Millisecond, Second := Second, Minute := Minute, Hour := Hour | TODStructure:= OutputTOD, Error:= Error) END_PROGRAM
152
TODsplit TODsplit
idő (TIME_OF_DAY) típusú változó szétválasztása egyedi UINT típusú adatokra TODsplit InputTOD
DT
MilliSecond
UINT
Second,
UINT
Minute
UINT
Hour
UINT
Az operandusok jelentése: InputTOD
a bemeneti TIME idő változó
MilliSecond
idő változó milliszekundum része
Second
idő változó szekundum része
Minute
idő változó perc része
Hour
idő változó óra része
Leírás: A bemenetként TIME_OF_DAY formátumban megadott változót a funkcióblokk UINT formátumú egyedi változókká alakítja át. Példaprogram: PROGRAM time1 VAR Split_time : TODsplit; TimeOfDay : TOD := TOD#12h13m12s800ms; Milliseconds : UINT; Seconds : UINT; Minutes : UINT; Hours : UINT; END_VAR CAL Split_time (InputTOD := TimeOfDay | Milliseconds := MilliSecond, Seconds := Second, Minutes := Minute, Hours := Hour) END_PROGRAM
153
TransferArray TransferArray
adatblokk másolása, inicializálása TransferArray Source
ANY_ARRAY
Destination
ANY_ARRAY BOOL
Source Destination
Mode
UINT
SourceOffset
UINT
DestinationOffset
UINT
ElementNumber
Error
USINT
Az operandusok jelentése: Source
a forrástömb
Destination
céltartomány
Mode
üzemmód: (0 = inicializálás, 1 = másolás)
SourceOffset
a forrástömbön belüli eltolás értéke
DestinationOffset
a céltömbön belüli eltolás értéke
ElementNumber
másolandó bájtok száma
Error
hibajelzés
Leírás: A funkcióblokknak kétféle üzemmódja van (adatok inicializálása, és adatterület másolása). Az üzemmód választás a Mode bemenetre adott értékkel történhet. A forrás és a cél-tömb tetszőleges nagyságú tömb lehet. A tömb típusa ANY_INT vagy ANY_BIT lehet, kivéve a BOOL (bites) tömböket. Az Error kimeneten az esetleges hibakód jelenik meg:
154
0
nincs hiba,
1
az elemek száma (ElementNumber) nulla.
2
A SourceOffset értéke nagyobb, mint a Source tartomány értéke
3
Az elemek száma túllépi a a forrástartomány értékét
4
A DestinationOffset értéke nagyobb, mint a Destination tartomány értéke
5
Az elemek száma túllépi a céltartomány értékét
6
forráscím és a célcím azonos
TransferArray Inicializálási üzemmód Az inicializálási üzemmódban a Source és a SourcsOffset által meghatározott tömbelemet másol a Destination és a DestinationOffset által meghatározott tömbterületre. A forrás és a cél egy tömbön belül is lehet. A felülírt tömbelemek számát az ElementNumber adja meg. Másolási üzemmód A másolási üzemmódban egy tömb, vagy annak egy része (Source + SourceOffset) kerül átmásolásra a (Destination + DestinationOffset) által meghatározott területre. A másolandó bájtok számát az ElementNumber határozza meg.A forrás és a cél egy tömbben is elhelyezkedhetnek, azaz blokkeltolás is lehetséges. A TransferArray-re vonatkozó példa a BlockTransfer funkcióblokk alatt található, mivel a két funkcióblokk egymással azonos, csupán a deklarációs eljárás különbözik. (A cél- és forráscímeket a cél- és forrástömb deklarációkkal kell helyettesíteni.)
155
WriteMC WriteMC
adatok írása a flash-memóriába WriteMC
ANY_ARRAY BOOL UINT USINT
SourceAddress
SourceAddress
Strobe SegmentNumber
Active MaxSegmentNumber
DataLength
Error
BOOL UINT USINT
Az operandusok jelentése: SourceAddress
a forrástömb, mely tartalmazza a mentendő adatokat
Strobe
letárolási folyamat indítása
SegmentNumber
a szegmens száma (megengedett: 0…n)
DataLength
a tárolandó adatbájtok száma
MaxSegmentNumber a fájl utolsó lehetséges szegmensszáma Error
hibajelzés
Leírás: A WriteMC funkcióblokk segítségével a memóriamodulba lehet adatokat a CPU memóriaterületéről letárolni. Ez a funkcióblokk a ReadMC blokkal együtt fontos alkalmazási területe a remanens adattárolásnak, receptura-kezelésnek, illetve változók letárolásának egy program aktualizálást megelőzően. A memóriamodult a PLC-be betenni, illetve kivenni csak a PLC feszültségmentes állapotában szabad!
A memóriamodulban az adatok egyenként 128bájt hosszúságú szegmensre vannak felosztva. A szabad adatterület meghatározásához a funkcióblokkot DataLength = 0 értékkel kell meghívni, melynek hatására nem indul be az írási folyamat, ugyanakkor a MaxSegmentLength visszaadja az utolsó még használható szegmens értékét. A funkcióblokk a programfutással aszinkron módon kerül végrehajtásra, és több programcikluson keresztül is eltarthat. Ezalatt az idő alatt az Active kimenet 1-t ad. A hibátlan végrehajtást jelzi az Active kimenet 0-ba történő visszaváltása, miközben az Error kimenet is 0-t ad. Egyszerre több funkcióblokk is lehet egyidejűleg aktív. az operációs rendszer a hívások sorrendjében egymás után hajtja végre az írási műveleteket.
156
WriteMC Az Error kimenet a következő állapotokat veheti fel: 0
nincs hiba
1
nincs memóriamodul beépítve
2
online kapcsolat miatt nem lehetséges a hozzáférés (csak PS4-200 esetén)
3
nem lehetséges a hozzáférés egyidejű WriteMC hívás miatt (csak PS4-200 esetén)
4
érvénytelen SegmentNumber (PS4-200 esetén a megengedett: 0….511; PS4300 esetén a modultól fűggően: 0….1023)
5
érvénytelen adathossz (megengedett DataLength érték: 1….128)
6
-
7
nem lehetséges a hozzáférés, mert a memóriamodul , mint forráskód háttér van felhasználva (csak PS4-200 esetén)
8
a memóriamodul formázása nem engedi meg az adattárolási tartomány használatát (csak PS4-300 esetén)
Csak a PS4-200 esetén: Az Active kimenet a PS4-150/-200 esetén mindig 0. A funkcióblokk aktuális állapota csak egy ismételt hívás mellett az Error kimenet lekérdezésével oldható meg. Ha az Error 0-t ad, akkor a művelet hiba nélkül végrehajtódott. Ha a kimenet értéke 3, akkor a funkcióblokk még dolgozik. Az Error kimenet aktualizálásához a Strobe bemeneten egy újabb pozitív élet kell generálni. A ReadData funkcióblokk segítségével lehet a letárolt adatokat a memóriamodulból visszaolvasni! Példaprogram: PROGRAM SAVE VAR StrobeSave AT %I0.0.0.0.0 : BOOL; ActiveSave AT %Q0.0.0.0.0 : BOOL; ErrorSave : USINT; FBSaveData : WriteMC; SegmentNumber : UINT; DataLength : USINT; LastSegmentNumber : UINT; DataArea : ARRAY[0..31] of USINT; END_VAR LD ActiveSave JMPCN CONTINUE (* adatok előkészítése a tárolásra *)
157
WriteMC CONTINUE: LD 47 ST SegmentNumber LD 32 ST DataLength (* A DataArea tömbből 32 bájt írása a memóriamodul 47-es szegmensébe *) CAL FBSaveData(Strobe := StrobeSave, SegmentNumber := SegmentNumber, DataLength := DataLength, SourceAddress := DataArea | ActiveSave := Active, LastSegmentNumber := MaxSegmentNumber, ErrorSave := Error) LD ErrorSave EQ 0 JMPC NO_ERROR (* hiba kezelési rutin *) NO_ERROR: (* további programrészek END_PROGRAM
158
*)
Sucosoft határértékek 7.
Sucosoft határértékek PS4-200
PS4-300
PS416
256
256
256
32 karakter
32 karakter
32 karakter
65 535
65 535
65 535
a változónevek max. hossza
64 karakter
64 karakter
64 karakter
a POU név max. hossza
32 karakter
32 karakter
32 karakter
-
-
A Project Manager határértékei a POU-k max. száma egy projektben a projektnév max. hossza. a neveknek az első 8 karakterben különbözőknek kell lenni! A program szerkesztő (Editor) korlátai a sorok max. szám egy POU-ban
Állapotkijelzés (Status Display) határértékei egyszerre kijelezhető változók száma
ca. 50
1)
A konfigurátor (Topology Configurator) határértékei konfigurációban a max. komponensek száma 2)
175
630
753
az I/O monitorban a kiválasztható komponensek max. száma
10
10
10
Korlátok a CPU és a fordító (compiler) függvényében max. programméret beleértve az összes FB-t max. programméret beleértve az összes FB-t (adat + programkód együttesen)
63 kbájt
512 kbájt
CPU200: 256kB CPU300: 512kB CPU400:1MB
egy POU max. programkód mérete
56 kbájt
64 kbájt
64 kbájt
32000 global 32000/POUloc.
16000 global 16kB/POUloc.
16000 global 16kB/POUloc.
a fastruktúra max. mérete (összekapcsolt funkcióblokkok száma)
8
16
16
a funkcióblokkok hívásának max. mélysége
16
16
16
4000
4000
4000
az AT deklarálások max száma 2)
16 kbájt
16 kbájt
5450
egy tömb max. mérete
8 kbájt
16 kbájt
16 kbájt
3
4
4
az összes változó max mérete (főprogram + összes FB)
programonkénti instancálások száma 2)
egy tömb max dimenziója index tartomány megengedett értéke felsorolás típusú változók max. elemszáma
0...255 255
-2147483648 -2147483648 .+2147483647 ...+2147483647 65000
65000
159
Sucosoft határértékek PS4-200
PS4-300
PS416
253 karakter
1024 karakter
1024 karakter
1100
1100
1100
TIME adattípus megengedett tartománya
+63/-64 nap, 23 h, 59perc, 59sec., 999ms.
+127/-128nap 23 h, 59perc, 59sec., 999ms.
+127/-128nap 23 h, 59perc, 59sec., 999ms.
DATE adattípus megengedett tartománya
1900-1-1 2154-12-31
1900-1-1 2154-12-31
1900-1-1 2154-12-31
maximálisan konfigurálható ciklusidő
255 ms
1000 ms
1000 ms
importált S30 programok max. mérete
54 kByte
nincs korlát
nincs korlát
online feldolgozás miatti ajánlott max. POU méret
< 2 kByte
< 8 kByte
< 8 kByte
egy STRING változó max. mérete globális típus definíciók max. száma
1)
Az adattípustól függ. Ha a korlátértéket meghaladja, akkor az adott érétkek helyén kérdőjel jelenik meg.
2)
A korlátozás függ természetesen a rendelkezésre álló PLC memóriaterülettől is.
160
