Matlab/Simulink podprto generiranje PLC kode v skladu s ...arhiviramo naše delo. Programiranje je mogoče v treh različnih jezikih in sicer v lestvični logiki (Ladder Diagram LD),

Uroš Marčič

Matlab/Simulink podprto generiranje PLC kode v skladu s standardom IEC61131-3

Diplomsko delo

Maribor, julij 2012

i

Diplomsko delo univerzitetnega študijskega programa

Matlab/Simulink podprto generiranje PLC kode v skladu s standardom IEC61131-3

študent: Uroš Marčič

študijski program: UN ŠP Elektrotehnika

smer: Avtomatika in robotika

mentor: izr. prof. dr. GOLOB MARJAN, univ.dipl.inž. elektrot.

lektor(ica):

ii

iii

ZAHVALA Zahvaljujem se mentorju izr. prof. dr. Marjanu

Golobu za pomoč in vodenje pri opravljanju

diplomskega dela.

Hkrati pa se zahvaljujem tudi celotnemu laboratoriju

LPA in še posebej dr. Bratini, za strokovno pomoč pri

diplomskem delu.

Posebna zahvala velja staršem, ki so mi omogočili

študij in mi ves čas stali ob strani.

iv

Matlab/Simulink podprto generiranje PLC kode v skladu s standardom IEC61131-3 Ključne besede: PLC coder, Siemens Simatic Step 7, OPC server, Matlab Simulink

UDK: 004.4'415:681.51(043.2).

Povzetek

V tem diplomskem delu je opisano spoznavanje in delo z novim dodatkom za

Matlab/Simulink, ki se imenuje PLC coder. Namenjen je generiranju PLC kode iz modela,

ustvarjenega v programu Simulink. PLC coder deluje tako, da najprej v Simulink-u

izdelamo model, iz katerega nam nato program samodejno generira kodo za izbrano

okolje krmilnika. Opisan je celoten postopek uporabe PLC coderja, vse od priprave

operacijskega sistema, zapletov med delom in do generiranja kode za PLK . Na koncu

sem še primerjal generirano kodo s kodo, napisano v programskem okolju krmilnika na

primeru procesa n-tega reda in opisal dobljene rezultate.

v

Matlab/Simulink based generation of PLC code according to IEC 61131-3 Keywords: PLC Coder, Siemens Simatic Step 7, OPC server, Matlab Simulink

UDK: 004.4'415:681.51(043.2).

Abstract

This diploma is describing exploring and working with new package from Matlab called

PLC coder, which is meant for generating code from Simulink models. With PLC coder

we can either generate code, generate and import code and as last option PLC coder

offers option to verify generated code in controller’s integrated development environment.

I described whole process of using the PLC coder, everything from preparing the

operating system, errors during work to generating and importing code to integrated

development environment. In conclusion I compared generated code with PLC coder with

the code written in integrated development environment for the system of n order and

commented on results.

vi

Vsebina

1 UVOD ....................................................................................................................................... 1

1.1 Cilji naloge .................................................................................................................................... 1

2 OPIS ELEMENTOV ............................................................................................................... 3

2.1 Logični krmilnik ............................................................................................................................ 3

2.2 Matlab .......................................................................................................................................... 4

2.2.1 Simulink ........................................................................................................................................... 4

2.2.2 Simulink PLC coder ........................................................................................................................... 4

2.3 SIEMENS SIMATIC STEP7 ............................................................................................................... 4

2.3.1 PLCSIM ............................................................................................................................................. 4

2.3.2 S7-‐SCL ............................................................................................................................................... 5

3 POTEK DELA IN ZAPLETI Z UPORABO ......................................................................... 6

3.1 Simulacijski model testnega procesa ............................................................................................. 6

3.1.1 Mrtva cona oz. MRT ......................................................................................................................... 6

3.1.2 Zakasnitve oz. Delay ......................................................................................................................... 7

3.1.3 Omejitev izhodnega signala ............................................................................................................. 7

3.1.4 Diskretna prenosna funkcija ............................................................................................................ 7

3.2 Priprava operacijskega sistema ..................................................................................................... 9

3.3 Spoznavanje PLC coderja ............................................................................................................ 10

3.3.1 Delo z vnaprej pripravljenimi funkcijami oz. demonstracijskimi programi .................................... 10

3.3.2 Prvi projekt generiran z PLK koderjem ........................................................................................... 10

3.4 Ustvarjanje modela in generiranje kode ..................................................................................... 11

3.5 Delo s Siemens SIMATIC STEP7 ................................................................................................... 17

3.5.1 Ustvarjanje projekta v STEP7 ......................................................................................................... 19

3.6 OPC strežnik ............................................................................................................................... 26

3.6.1 Delo s strežnikom ........................................................................................................................... 27

vii

4 ANALIZA REZULTATOV .................................................................................................. 29

4.1 Matlab Simulink model za primerjavo signalov ........................................................................... 29

4.1.1 Primerjava generirane kode z simulacijo v matlabu ...................................................................... 30

4.1.2 Primerjava kode generirane s PLK koderjem s kodo napisano v Simatic STEP7 ............................ 32

4.1.3 Primerjava zapisane kode v STEP7 in generirane z PLK koderjem ................................................. 33

4.2 Uporabnost PLK koderja ............................................................................................................. 34

5 SKLEP ................................................................................................................................... 35

6 VIRI IN LITERATURA ...................................................................................................... 36

viii

UPORABLJENE KRATICE :

PLC/PLK – programabilni logični krmilnik

MPI – Multi point interface

STEP7 – Siemensovo programsko okolje

DB – Data Blocks

FB - Function Blocks

OB – Object Blocks

SCL - Structured Control Language

MRT – Mrtva cona

Matlab/Simulink generiranje PLC kode

1

1 UVOD Življenski slog postaja iz leta v leto hitrejši, v povezavi s hitrejšim tempom življenja se prav

tako povečuje zanimanje po avtomatiziranih procesih in napravah. Zaradi vedno večjega

povpraševanja po avtomatiziranih procesih, so se nekatera podjetja odločila, da bodo

predstavila nove načine ustvarjanja programske kode za te procese. Takšno je na primer

podjetje MathWorks, ki je pred kratkim predstavilo nov način ustvarjanja programske kode

iz njihovega okolja Simulink, v katerem lahko s pomočjo grafičnih blokov ustvarimo

modele za različne procese v avtomatizaciji. Dodatek, s katerim lahko generiramo

programsko kodo se imenuje PLC coder, in ker je na tržišču samo kratek čas, sem se

odločil, da ga spoznam in preizkusim, ob tem pa preverim, kako se bo obnesel v

primerjavi z že preverjenimi načini pisanja programske kode za programabilne logične

krmilnike, za katere bom v diplomskem delu uporabljal kratico PLK. Pred menoj še ni

nihče na fakulteti preizkusil delovanja PLK koderja, zato sem pri uporabi z njim naletel na

številne posebnosti, na katere moramo biti pozorni pri uporabi z njim. Le-te sem v

diplomskem delu opisal in bodo v pomoč bodočim uporabnikom PLK koderja.

Za preverjanje delovanja PLK koderja sem se odločil, da ustvarim univerzalni dinamični

proces z mrtvim časom, modeliran z diskretno prenosno funkcijo,členom za mrtva cona in

členom za omejitev izhodnega signala. Ta proces sem testiral v simulatorju in nato tudi s

pomočjo PLK, kjer sem naletel na nove težave s komunikacijo med krmilnikom in

računalnikom. Ko sem preveril delovanje kode ustvarjene s PLK koderjem, sem jo

primerjal s kodo napisano v programskem okolju STEP7. V svoji nalogi sem podal še

primerjavo ustvarjene kode, primerjavo določenih delov ustvarjene kode, dodal pa sem

tudi grafične odzive kode in opisal razloge za odstopanja med signali. Zadnji del naloge

sem namenil oceni programa ter njegovi uporabnosti.

1.1 Cilji naloge Cilj moje diplomske naloge je zbrati vse informacije o novem dodatku programskega

okolja Matlab imenovanega PLC coder. Prav tako sem se moral seznaniti s programskim

okoljem Siemens Simatic, saj je moje delo potekalo s krmilnikom Siemens S7-400.

Naloge sem se lotil tako, da sem zbral vse informacije o programskem okolju Matlab in

preizkusil vse že vnaprej pripravljene primere uporabe PLK koderja, kjer sem opazil prve

težave z jezikovnimi vmesniki in operacijskimi sistemi. Najprej sem delo opravljal s


2

pomočjo simulatorja PLCsim, ki je priložen programskemu paketu Siemens Simatic

STEP7.

V simulatorju sem preizkusil vse opcije, ki jih ponuja PLK koder, in sicer generiranje kode,

generiranje in uvoz kode v programsko okolje in generiranje, uvoz in preverjanje

ustvarjene kode. Medtem ko je generiranje programske kode delovalo brez problema, je

prišlo do nekaj napak pri uvozu generirane kode v programsko okolje STEP7. Razlog za

napako je bil slovenski jezikovni vmesnik na operacijskem sistemu.

Kasneje ko sem začel delati s krmilnikom sem za lažjo komunikacijo in preglednost

uporabil OPC vmesnik, s pomočjo katerega sem se lahko povezal na krmilnik in do njega

dostopal kar v programskem okolju Matlab, kar mi je omogočilo lažjo primerjavo odzivov.

Tako je moje delo potekalo v dveh delih v prvem delu sem enak proces najprej zapisal v

programskem okolju, nato pa sem identičen model sestavil tudi v Simulinku. Na koncu

sem oba procesa naložil na PLK. V drugem delu sem PLK povezal z OPC strežnikom,

tako sem lahko do vseh spremenljivk na krmilniku dostopal z OPC klientom, ki je povezan

s Simulinkovim modelom za primerjavo obeh signalov kot je prikazano na spodnji shemi.

Po opravljenih meritvah sem lahko določil, kako dobro deluje Matlabov PLC coder in

koliko odvečne kode nastane pri generiranju.

PLK

koder

Simulink

model

STEP7

PLK

Program napisan

v Step 7 SCL

OPC

strežnik

OPC klient

Simulink model za

primerjavo signalov


3

2 OPIS ELEMENTOV Pri svojem projektu sem uporabljal programsko okolje Matlab/Simulink in njegov dodatek

PLC coder. Za PLK sem si izbral Siemens S7-400, ki sem ga programiral v Siemensovem

programskem okolju imenovanem Simatic STEP7.

2.1 Logični krmilnik Za izvajanje programske kode sem si izbral PLK Siemens Simatic S7-400, ki je del

SIMATIC-ove serije procesnih krmilnikov. Gre za krmilnik ki je namenjen področju

proizvodnje in procesne avtomatizacije. Sam sem delal s krmilnikom ki je uporabljal CPU

414-3. Krmilnik ima 16 digitalnih in 8 analognih vhodov in izhodov. Za povezavo z

računalnikom sem uporabljal povezavo PC-MPI preko serijske komunikacije(COM port).

Slika 2.1 PLK S7-400


4

2.2 Matlab Matlab je matematični program, ki nam omogoča reševanje različnih matematičnih

problemov, tudi reševanje algoritmov in izris grafov.

2.2.1 Simulink

Simulink je dodatek Matlaba in je namenjen grafičnemu izdelovanju matematičnih funkcij,

algoritmov in ostalih modelov. Knjižnica Simulinka se iz leta v leto povečuje, v njej lahko

najdemo bloke, s katerimi lahko izdelujemo osnovne matematične funkcije in bloke za

reguliranje proizvodnih postopkov v industriji in ostalih procesih. Prav tako nam Simulink

omogoča izdelavo simulacij izdelanih modelov, kot tudi izdelavo programskih vmesnikov.

V Matlabovi verziji 2010b pa je bil kot dodatek predstavljen tudi PLC coder.

2.2.2 Simulink PLC coder

PLC coder je namenjen ustvarjanju kode za krmilnike iz Simulinkovih modelov.

Ustvarjanje kode temelji na standardu IEC 61131-3. PLC coder podpira generiranje kode

za naslednje sisteme SIEMENS SIMATIC STEP 7, KW-Software MULTIPROG, PHOENIX

CONTACT PC WORX v najnovejši različici 2012a so dodali še podporo za Rockwell

Automation RSL logix[2]. Za vse te sisteme nam PLC coder poleg generiranja kode

omogoča tudi vnos ter preverjanje ustvarjene kode.

2.3 SIEMENS SIMATIC STEP7 STEP7 je osnovni program za SIMATIC S7, SIMATIC C7 in SIMATIC WinAC

avtomatizacijske sisteme[4]. Uporabniku omogoča enostavno uporabo vseh funkcij

avtomatizacijskih okolij. S pomočjo okolja STEP7 lahko konfiguriramo in določamo

parametre naše strojne opreme, komunikacijo med krmilnikom in računalnikom,

programiramo, testiramo program in preverjamo napisano kodo, dokumentiramo in

arhiviramo naše delo. Programiranje je mogoče v treh različnih jezikih in sicer v lestvični

logiki (Ladder Diagram LD), s funkcijskimi bloki (Function Block Diagram FBD) in ukaznimi

listami (Instruction List IL). Vsaka napisana koda mora biti napisana v skladu s

standardom IEC 61131-3 [7].

2.3.1 PLCSIM

Gre za simulator programskega okolja STEP7, v katerem lahko preverimo delovanje naše

kode. Uporabljamo ga tako, da vnesemo vhode in izhode, ki jih želimo opazovati. Našo


5

kodo testiramo tako, da spreminjamo vrednosti vhoda in nato opazujemo vrednosti na

izhodu.

2.3.2 S7-SCL

Podprogram SCL je zelo uporaben za programiranje bolj kompleksnih algoritmov in

aritmetičnih funkcij. SCL je strukturiran programski jezik z elementi ostalih programskih

jezikov, skupaj z nekaj dodatnimi funkcijami prirejenimi za programiranje PLK-jev. SCL

ima prednost, in sicer lažje in hitrejše pisanje programov s pomočjo struktur, kot so IF,

THEN, ELSE.


6

3 POTEK DELA IN ZAPLETI Z UPORABO

3.1 Simulacijski model testnega procesa Za svoj projekt sem izbral diskretno prenosno funkcijo, ki ji lahko izbiramo red, njene

člene, mrtvo cono, zakasnitve in določimo omejitev izhodnega signala.

Slika 3.1 Simulacijski model procesa v Simulinku

3.1.1 Mrtva cona oz. MRT

Slika 3.2 Simbol za mrtvo cono

Mrtva cona nam omogoča, da določimo območje na katerega izhodni signal ne bo

občutljiv. To storimo tako da izberemo območje s pomočjo spodnje (LL) in zgornje meje

(UL) mrtvega časa. Funkcijo opisujejo naslednja pravila:

Pravila za mrtvo cono [1]

Vhod Izhod

U >= LL in U <=UL 0

U > UL U – UL

U < LL U- LL


7

3.1.2 Zakasnitve oz. Delay

Blok za zakasnitev nam omogoči zakasnitev vhodnega signala za določeno število

odtipkov. Sam sem v svoji univerzalni funkciji omogočil zakasnitve do 10 odtipkov.

Slika 3.3 Simbol za Delay

3.1.3 Omejitev izhodnega signala

Z blokom za omejitev izhodnega signala lahko določimo vrednosti, ki omejujejo izhodni

signal.

Slika 3.4 Simbol za omejitev izhodnega signala

3.1.4 Diskretna prenosna funkcija

Diskretna prenosna funkcija nam opisuje dinamiko določenega sistema. Za svojo

prenosno funkcijo sem si izbral funkcijo 2. reda z naslednjimi členi:

𝐻 =1.5

𝑠! + 1.5𝑠 + 0.5

Če na to zvezno funkcijo pripeljemo stopnično vzbujanje, dobimo naslednji odziv:

Slika 3.5 Odziv zvezne funkcije na stopnično vzbujanje

V nadaljevanju bom delal tudi z realnim sistemom, zato je potrebno to funkcijo pretvoriti iz

»s« prostora v »z« prostor[3]. Pri transformaciji moramo biti pozorni na čas tipanja. Čas, ki

0 1 2 3 4 5 6 7 8 9 100

0.5

1

1.5

2

2.5

3

Ćas

Odziv


8

sem si ga izbral je100ms. Ko pretvorimo funkcijo v »z« prostor dobimo diskretno prenosno

funkcijo 2. reda.

𝐻𝑧 =0.007135707𝑧 + 0.006787694

𝑧! − 1.856066842𝑧 + 0.860707976


9

Če na to funkcijo pripeljemo stopnično vzbujanje in uporabimo čas tipanja 100ms, dobimo naslednji odziv:

Tako smo zvezno funkcijo preoblikovali v diskretno prenosno funkcijo 2. reda, s katero

bomo testirali delovanje PLK koderja na realnem krmilniku.

3.2 Priprava operacijskega sistema PLK koder ima veliko omejitev glede operacijskega sistema, zato sem moral že na

začetku projekta naložiti vse programe, ki jih PLK koder zahteva. Za svojo nalogo sem

uporabil Siemens-ov krmilnik S7-400. Najprej sem moral naložiti Siemens-ovo

programsko okolje SIMATIC STEP7 v5.4, saj je bila to edina verzija, ki jo krmilnik podpira.

Po nekaj neuspešnih poizkusih uvoza kode v okolje STEP7, sem ugotovil, da Matlab

2011b zahteva natanko določene verzije sistema Siemens SIMATIC STEP7, ki so:

-Siemens SIMATIC Manager: Version V5.4+SP5+HF1, Revision K5.4.5.1,

- S7-SCL: Version V5.3+SP5, Revision K5.3.5.0. ,

-S7-PLCSIM: Version V5.4+SP3, Revision K5.4.3.0.

Naložiti sem moral tudi dodatek k programskemu orodju STEP7, ki se imenuje SCL in

temelji na ostalih osnovnih programskih jezikih. Zelo pozorni moramo biti tudi na to, da

imamo operacijski sistem v angleškem jeziku, saj drugače ne bomo mogli uporabljati

funkcij generiranja in uvoza kode ter generiranja, uvoza in preverjanja kode. Za

komunikacijo med krmilnikom in sistemom sem uporabljal orodje OPC strežnik

KEPserverEX v5, pri katerem sem naletel na manjšo težavo. Ker ga nisem mogel

povezati s simulatorjem PLK, sem potreboval nekoliko več časa pri preverjanju ustreznosti

0 1 2 3 4 5 6 7 8 9 100

0.5

1

1.5

2

2.5

3

Ćas

Odziv

Slika 3.6 Odziv diskretne prenosne funkcije na stopnično vzbujanje


10

generirane kode za PLK. Na koncu sem naložil še Matlab, pri katerem moramo biti

pozorni, da je novejši od verzije 2010b in da imamo naložen dodatek Simulink PLC coder.

3.3 Spoznavanje PLC coderja Ko je bil operacijski sistem pripravljen sem se odločil, da bom nekoliko bolje spoznal

dodatek PLC coder. Matlab mi je pri tem zelo pomagal z njegovo sekcijo pomoči o PLC

coder-ju kjer lahko najdemo vse od tega kako začeti z delom, do tega da ima pripravljenih

nekaj primerov uporabe PLC coderja. Najbolj mi je bila v pomoč njihova knjižnica z

vnaprej pripravljenimi funkcijami, na katerih lahko iz prve roke spoznamo, kako PLC coder

deluje. Ker je PLC coder šele v nastajanju, ne moremo generirati in uvoziti funkcij v vsa

programska okolja, medtem ko je generiranje kode omogočeno za večino programskih

okolij PLKjev.

3.3.1 Delo z vnaprej pripravljenimi funkcijami oz. demonstracijskimi programi

Matlab je pripravil veliko primerov uporabe generiranja kode. Ti programi zajemajo vse, od

povsem preprostih funkcij kot je množenje vhodnega signala do bolj zapletenih funkcij PID

bloka in funkcije za nadzor tekočega traku na letališču. Ob tem je pripravljen tudi opis

vsake izmed funkcij in navodilo, iz katerega podsistema lahko generiramo kodo za

krmilnik. Iz primerov lahko opazimo, da lahko generiramo kodo tudi iz Matlabovih funkcij

(.mat) in iz podsistemov ustvarjenih s podprogramom Stateflow, ne moremo pa generirati

kode iz S-funkcij.

3.3.2 Prvi projekt generiran z PLK koderjem

Za svoj prvi projekt sem si izbral povsem enostavno funkcijo, kjer sem vhod pomnožil z

nekim številom.

Nato sem po navodilih iz Matlab-ove pomoči ustvaril podsistem »desni klik« -> »Create

Subsystem«. Za generiran podsistem sem moral omogočiti možnost, da ga obravnavamo

kot atomsko enoto »Treat as Atomic unit«, saj je to potrebno za pravilno delovanje PLK

koderja. Naslednji korak je izbira programskega okolja »desni klik« -> »PLC Code

Slika 3.7 Model projekta za spoznavanje PLK koderja


11

Generation« -> »Options«. V svojem primeru sem izbral okolje STEP7. Tukaj si lahko

izberemo možnost, da Matlab ustvari kodo za preverjanje. To storimo tako, da odkljukamo

možnost »Generate testbench for subsystem«, ta opcija mora biti odkljukana v primeru,

kadar želimo generirano kodo tudi preveriti. Tako je naš sistem pripravljen za generiranje

kode. Kadar imamo opravka z nekoliko bolj zapletenimi modeli, lahko preverimo, če je

PLK koder sposoben generirati kodo za programsko okolje našega PLK. To storimo tako,

da izberemo možnost »Check Subsystem Compatibility«. Kodo nato generiramo tako, da

z desno tipko kliknemo na podsistem, kjer imamo na izbiro naslednje opcije :

-Generate Code for Subsystem (Generiranje kode za podsistem)

Ko izberemo to opcijo nam PLK koder ustvari, programsko kodo v skladu s pravili IEC

61131-3, generirana koda ima končnico .scl in jo moramo nato še uvoziti v STEP7.

-Generate and Import Code for Subsystem (Generiranje in uvoz kode za podsistem)

Pri uporabi te opcije moramo najprej zapreti vse projekte in programsko okolje, v katerega

bomo uvozili projekt. PLK koder nam ustvari poleg programa tudi tabelo s funkcijskimi

bloki s končnico .asc, nato pa oboje uvozi v STEP7, kjer je naš podsistem pripravljen za

uporabo.

-Generate, Import and Verify Code for Subsystem (Generiranje, uvoz in preverjanje kode

za podsistem)

Ta izbira nam omogoči, da nam PLK koder generirano, kodo tudi preveri. To stori tako, da

rezultate iz simulacije v Simulinku primerja z rezultati dobljenimi v simulatorju PLCSIM. Na

koncu nam poda primerjavo rezultatov, da se lahko tudi sami prepričamo, če so rezultati

pravilni.

Moja prva funkcija je bila namenjena predvsem spoznavanju vseh funkcij PLK koderja.

3.4 Ustvarjanje modela in generiranje kode Za svojo nalogo sem si izbral proces, ki mu lahko določamo mrtvo cono, zakasnitev, red

sistema in omejitev izhodnega signala. Najprej sem ustvaril diskretno funkcijo drugega

reda, jo generiral in uvozil s STEP7. Njen odziv sem primerjal s funkcijo, napisano v

programskem okolju STEP7. Ugotovil sem, da sta odziva skorajda identična. S tem sem

prvič preveril generirano kodo s PLK koderjem. Tako sem se lotil pisanja univerzalnega

bloka, ki mu lahko spreminjamo mrtvo cono, dodajamo zakasnitve, izbiramo red funkcije

in omejujemo izhod. Tukaj je prišlo do prvih zapletov, saj z vhodnimi signali ne moremo

zapisovati vrednosti v funkcije Simulinka.


12

Slika 3.8 Prikaz polj do katerih ne moremo dostopati

To mi je onemogočilo uporabo vnaprej pripravljenih blokov v Simulinku za izbiro reda

funkcije, mrtvega časa in omejitve izhodnega signala. S tem se je pokazala prva slabost

PLK koderja. Odločil sem se da bom vse funkcije zapisal ročno, kjer pa prav tako ni šlo

brez zapletov, saj PLK koder ne podpira vseh blokov v svoji knjižnici. Bloki, ki jih PLK

koder ne podpira, so predvsem tisti na katere pripeljemo dva signala npr. Switch. Takšne

bloke lahko uporabljamo le, kadar pogoj ni odvisen od vhoda, ki ga spreminjamo na

krmilniku.

Prav tako PLK koder ne podpira skorajda nobenega bloka iz podskupine »Ports &

Subsystems«. To so bloki, ki sem jih želel uporabiti, vendar jih PLK koder ni podpiral.

Slika 3.9 Primer kako ne moremo uporabljati bloka

switch


13

Slika 3.10 Bloki ki jih PLK koder ni podpiral

Brez teh blokov ni bilo mogoče zapisati funkcije za mrtvo cono in omejitev izhodnega

signala. Zato sem se odločil, da bom obe zapisal v Matlabovi funkciji, ki jo PLK koder

podpira.

Slika 3.11 Funkcija za mrtvo cono

Slika 3.12 Funkcija za omejitev izhodnega signala

Težave sem imel tudi z izdelavo, funkcije za izbiro reda diskretne prenosne funkcije in pri

vpisu njenih vrednosti, ker do vrednosti bloka diskretne prenosne funkcije nisem mogel


14

dostopati direktno z vhodi, sem moral model diskretne prenosne funkcije izdelati sam.

Model sem moral izdelati s pomočjo osnovnih blokov. Prenosno funkcijo sem zato izdelal

v vodljivostni normalni obliki.

Slika 3.13 Funkcija v vodljivostni normalni obliki

Ko sem imel izdelane modele za vse prenosne funkcije, sem znova naletel na slabost

PLK koderja, ki nam ne omogoča uporabe stikal. Tako sem moral izdelati model, ki mu

bomo lahko določili red šele v programskem okolju STEP7.


15

Slika 3.14 Razširjena prenosna funkcija

Kadar imamo opravka z diskretnimi prenosnimi funkcijami moramo prav tako biti zelo

pozorni, da spremenimo naš model v diskretnega. To storimo tako, da pod »options« ->

»solver« spremenimo v »FixedStepDiscrete« in določimo čas vzorčenja, ki je bil v mojem

primeru 100ms oziroma 0.1s .

Za izdelavo izbire zakasnitve sem uporabil enak sistem izbire kot pri izbiri reda prenosne

funkcije, kar pomeni, da bomo lahko število zakasnitev izbrali šele v programskem okolju

STEP7.


16

Slika 3.15 Model za izbiro zakasnitev

Končni model je sestavljen iz več podsistemov. Za vsakega od podsistemov sem nato s

pomočjo PLK koderja generiral kodo za programsko okolje STEP7.

Slika 3.16 Končni model


17

3.5 Delo s Siemens SIMATIC STEP7 Ko sem imel ustvarjen model v Simulink-u sem lahko s PLK koderjem generiral kodo za

krmilnik. PLK koder nam generira kodo v formatu .scl, ki jo nato uvozimo v programsko

okolje STEP7 [2].

Najprej moramo v programskem okolju STEP7 ustvariti nov projekt, zažene se čarovnik,

kjer moramo poleg imena izbrati tudi krmilnik, s katerim bomo delali in CPU, ki ga lahko

odčitamo iz PLK. Ko smo ustvarili projekt moramo vpisati komponente našega krmilnika

pod sekcijo »Hardware«, če imamo krmilnik že priključen z računalnikom, lahko

komponente prenesemo kar iz krmilnika, če ne, jih moramo vnesti ročno.

Slika 3.17 Konfiguracija krmilnika

Ko imamo ustvarjen projekt in vpisano konfiguracijo krmilnika, lahko uvozimo našo kodo

generirano z PLK koderjem. To storimo tako da v zavihku Sources pritisnemo desno tipko

in izberemo »insert new object« kjer izberemo naš SCL source.


18

Slika 3.18 Vnašanje SCL kode

Slika 3.19 Blok proces v STEP7

Sedaj lahko najdemo program pod zavihkom »Sources«, kjer ga lahko odpremo s SCL

editorjem in ga po želji tudi dodatno urejamo. Koda je zapisana v obliki funkcijskega bloka

FB, ki ga moramo nato definirati v tabeli simbolov, ki jo najdemo pod zavihkom »options«

v SCL editorju. Sedaj lahko opazimo pod zavihkom Blocks našo uvoženo kodo z oznako

FB. V nadaljevanju moramo našo funkcijo uporabiti v glavnem programu, ki ga lahko

najdemo pod oznako OB. To storimo tako da pod zavihkom FB poiščemo našega ga

vstavimo v glavni program na njega pripeljemo vhod mu po želji dodamo stikalo za vklop

(enable) in mu na koncu dodamo še spremenljivko za izhodni signal. Določiti mu moramo


19

tudi blok, kamor lahko vpisuje vmesne vrednosti spremenljivk oziroma Data Block (DB).

Obstajajo tudi druge možnosti uporabe generirane kode. Ustvarjeno kodo lahko

dopolnimo kar v programskem jeziku SCLin se tako izognemo programiranju v lestvični

logiki.

Pozorni pa moramo biti tudi na vhod imenovan ssMethodType, ta se pojavi le pri nekoliko

bolj kompleksnih funkcijskih blokih. Ta vhod služi z namenom, da kadar na njega

pripeljemo vhodno vrednost 0 se inicializirajo vse spremenljivke na začetno vrednost, šele

ko na vhod pripeljemo vrednost 1, prične funkcija delovati.

3.5.1 Ustvarjanje projekta v STEP7

Svojega projekta sem se lotil tako, da sem nadgradil univerzalni projekt Nenada Muškinje,

v katerem je že bil pripravljen funkcijski blok za izbiro reda funkcije, mrtvega časa in izbiro

števila zakasnitev [8]. Nato sem generiral kodo s PLK koderjem za vsak blok posebej.

Kodo sem uvozil v omenjeni projekt in za vsak del ustvarjene kode dodal še podatkovni

blok (DB) in vzpostavil povezave. Pri vsem tem moramo biti pozorni, da vrednosti

vpisujemo v obliki REAL, torej z decimalno vejico/piko.

Slika 3.20 Blok za mrtvo cono


20

Slika 3.21 Blok za zakasnitve

Najprej sem ustvaril funkcijski blok za mrtvo cono, ki mu na vhod pripeljemo signal ki ga

ustvarimo s pomočjo krmilnik in ima oznako MD14. Na vhodih LL (Lower Limit) in UL

(Upper Limit) mu lahko nastavimo meje mrtvega časa. Spremenljivka MD104 služi za

povezavo z blokom za izbiro števila zakasnitev.

Naslednji generiran blok je za izbiro števila zakasnitev. Pri tem lahko izbiramo med 0 in 10

zakasnitvami, opazimo lahko tudi, da se nam prvič pojavi vhod ssMethodType. Vrednosti

tega vhoda sem definiral s pomočjo logičnih bitov in funkcije MOVE.


21

Slika 3.22 Definicija ssMethodType

Naslednji generiran blok je namenjen diskretni prenosni funkciji, ki ji lahko določamo red

in vpisujemo člene prenosne funkcije.


22

Slika 3.23 Blok za izbiro reda


23

Zadnji generiran blok je namenjen omejitvi izhodnega signala. Njegov izhod je tudi končni

in ga bomo primerjali z ostalimi odzivi. Podobno kot pri bloku za mrtvo cono lahko tudi

tukaj določimo spodnjo in zgornjo mejo izhodnega.

Slika 3.24 Blok za omejitev izhodne vrednosti

Funkcija s katero bom primerjal odzive pa je bila v celoti zapisana v STEP 7. Njene

spremenljivke lahko spreminjamo znotraj funkcije, enako kot pri kodi generirani s PLK

koderjem ji lahko spreminjamo mrtvo cono, red funkcije in število zakasnitev.


24

Slika 3.25 Blok napisan v STEP7


25

Ko imamo pripravljene vse bloke, jih lahko najprej prenesemo v simulator, kjer lahko

preizkusimo njihovo delovanje. Delo s simulatorjem je lažje in predvsem hitrejše, saj se

glavni program prenese na simulator v nekaj sekundah. Ko smo preverili v simulatorju, da

naš program pravilno deluje, moramo le še spremeniti povezavo iz simulatorja na PLK. To

storimo tako, da pod zavihkom »Options« -> »PG Interface«, izberemo povezavo

»PCADAPTER(MPI)«, sedaj prenesemo naš program na krmilnik in pripravljeni smo na

delo. Tako sem končal s prvim delom svoje naloge, ki je od mene zahteval zapis

identične kode s pomočjo PLK koderja in v programskem okolju PLK.

PLK

koder

Simulink

model

STEP7

PLK

Program napisan

v Step 7 SCL


26

3.6 OPC strežnik Zaradi lažje primerjave odzivov sem se odločil uporabljati OPC strežnik. OPC strežnik

nam omogoča da se lahko preko njega povežemo na krmilnik nato pa dostopamo do

vrednosti v različnih programskih okoljih[5]. Sam sem uporabljal OPC strežnik predvsem

zaradi lažje primerjave odzivov na krmilniku, saj mi je omogočil, da sem lahko vse odzive

posnel kar v programskem okolju Matlab in jih najprej primerjal z simulacijo, nato pa še

med seboj.

PLK OPC

strežnik

OPC klient

Simulink model za

primerjavo signalov


27

3.6.1 Delo s strežnikom

V programu strežnika najprej izberemo »channel«, kjer izberemo tip povezave, v našem

primeru je to serijska komunikacija oziroma COM port, nato izberemo priključek na

katerega je priključena komunikacija s krmilnikom. Pozorni moramo biti tudi na prenos, ki

je v našem primeru 19200 kb/s .

Slika 3.26 Ustvarjanje projekta v KepserverEX [6]

Ustvari se nam projekt v katerem nato pod našim kanalom dodamo še željeno napravo, v

našem primeru je to krmilnik Simatic S7-400.

Ko imamo dodano napravo lahko začnemo vnašati spremenljivke oz. TAG-e, ki smo jih

definirali v programskem okolju SIMATIC. Pri izbiranju TAG, moramo biti pozorni na

podatkovne tipe, kjer moramo vse podatke tipa REAL, spremeniti v FLOAT zaradi hitrosti

prenašanja podatkov. Do vrednosti spremenljivk na krmilniku lahko dostopamo preko

klinta strežnika, kjer lahko prav tako spreminjamo vhode in opazujemo obnašanje

izhodnih signalov. Preverimo lahko tudi kakovost povezave, ki jo najdemo pod kolono

»Quality«. V primeru, da je naša povezava slaba oziroma smo izbrali napačen tip

povezave se nam izpiše »Quality Low«.


28

Slika 3.27 Klient s katerim lahko opazujemo vrednosti spremenljivk na krmilniku


29

4 ANALIZA REZULTATOV S pomočjo OPC serverja sem se odločil, da bom vse rezultate testiral v programskem

okolju Matlab/Simulink, kjer sem že ustvaril model, s katerim bi ustvaril vhodni signal s

pomočjo omenjenega orodja. Tudi tukaj ni šlo brez zapletov, saj je bil prenos oziroma

preračunavanje podatkov preslabo in tako nisem mogel uporabljati bloka iz OPC knjižnice,

ki je namenjen spreminjanju vrednosti na krmilniku, prav tako pa tudi nisem mogel

uporabiti možnosti pripravljene v Simulinku imenovane Pseudo Real Time, ki nam lahko

pospeši oziroma upočasni realni čas, saj sem bil omejen z hitrostjo računalnika. Vse

vrednosti sem moral zato spreminjati s pomočjo OPC strežnika oziroma njegovega

klienta, kjer sem lahko dostopal do spremenljivk funkcije z ukazom desni klik->

»asynchronous write«. Ker sem spremenljivke spreminjal ročno se vzbujalni signali

pričnejo ob različnih časih.

4.1 Matlab Simulink model za primerjavo signalov

Slika 4.1 Simulink model namenjen primerjavi odzivov


30

Za analizo sem ustvaril končni model v Simulinku v katerem lahko opazujemo signale

programa napisanega v okolju STEP7. Vzbujalni signal, ki je ustvarjen na krmilniku, je

vzbujalni signal simulacije, izdelane v Simulinku in mu lahko prav tako določamo mrtvo

cono ter število zakasnitev. K primerjanju lahko dodamo tudi blok s prenosno funkcijo 2.

reda, ki je bil ustvarjen za preverjanje ustreznosti rezultatov kode, ustvarjene s PLK

koderjem. Zadnji je signal naše funkcije, ki smo jo ustvarili v Simulinku in iz nje generirali

kodo za programsko okolje STEP7.

4.1.1 Primerjava generirane kode z simulacijo v matlabu

Slika 4.2 Odziv prenosne funkcije 2. Reda

Na prvem grafu lahko vidimo prenosno funkcijo 2. reda, brez dodanega mrtvega časa in

zakasnitev. Razberemo lahko, da se obe funkciji, ki sta bili ustvarjeni s PLK koderjem na

stopnico odzivata skorajda identično, do razlike pride, ko generirano kodo primerjamo s

simulacijo. Tukaj pride do razlike predvsem zaradi komunikacije, saj mora vsak podatek

potovati do krmilnika, ki izvede izračun in nato nazaj do računalnika. Kljub temu lahko

opazimo, da sta obliki signala enaki. Prav tako lahko opazimo, da ni nobene zakasnitve,

saj obe funkciji pričneta naraščati nekoliko kasneje, to se zgodi zaradi tega, ker

uporabljamo vzbujalni signal iz krmilnika.

0 2 4 6 8 10 12 14 16 18 200

0.5

1

1.5

2

2.5

3

ćas

Odz

iv

Odziv brez zaksnitve in mrtvega casa

Vzbujalni signal

Simulacija

PLCcoder1

PLCcoder2


31

Slika 4.3 Odziv z mrtvim časom 0.5

Pri drugi primerjavi sem obema funkcijama dodal mrtev čas 0,5. Dobili smo podobne

odzive, enako kot pri funkciji brez mrtvega časa. Tudi pri teh dveh funkcijah simulacija

narašča nekoliko hitreje.

Slika 4.4 Funkcija 4. Reda

Kot zadnjo primerjavo sem primerjal funkciji 4. reda. Tukaj pride med simulacijo in

generirano kodo do nekoliko večje razlike. Simulacija namreč narašča hitreje kot

generirana koda. Kljub temu imata enako obliko, kar mi je omogočilo da sem se lahko

0 2 4 6 8 10 12 14 16 18 200

0.5

1

1.5

Ćas

Odz

iv

Odziv z mrtvim ćasom 0.5

Vzbujalni signalSimulacijaPLCcoder

0 2 4 6 8 10 12 14 16 18 200

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

Ćas

Odz

iv

Funkcija 4. reda



32

prepričal, če generirana koda deluje pravilno. Kasneje sem jo primerjal tudi z programom

napisanim v programskem okolju STEP7.

4.1.2 Primerjava kode generirane s PLK koderjem s kodo napisano v Simatic STEP7

Ko sem odzive generirane s PLK koderjem primerjal s simulacijo v Simulinku, sem jih

primerjal tudi z identično kodo zapisano v programskem okolju STEP7.

Slika 4.5 Primerjava funkcije 2. reda z 10 zakasnitvami

Najprej sem primerjal funkcijo 2. reda in 10 zakasnitvami. Opazimo lahko, da sta funkciji

skorajda identični. Znova nekaj razlik nastane pri simulaciji, ki ima nekoliko več

zakasnitve, kar je posledica tega, da signal ustvarjamo na krmilniku in zato potrebuje

nekoliko več časa, da funkcija v Simulinku dobi ta odziv.

0 2 4 6 8 10 12 14 16 18 200

0.5

1

1.5

Ćas

Odz

iv

Primerjava signalov Simatic in PLCcoder funkcije 2. reda z zaksnitvijo 10

S7 odzivVzbujalni signalSimulacijaPLC coder


33

Slika 4.6 primerjava funkcije 4. reda z zakasnitvijo 4 in mrtvim časom 0.5

Da bi se prepričal, če je delovanje generirane kode pravilno tudi pri funkcijah višjega reda,

sem primerjal funkciji 4. reda z zakasnitvijo 4 in mrtvim časom 0,5. Opazimo lahko, da sta

funkciji tudi tokrat skorajda povsem identični, kar nam pove, da je koda generirana za

funkcije višjega reda enakovredna kodi zapisani v programskem okolju STEP7. Znova je

mogoče opaziti razliko v primerjavi s simulacijo, saj tudi tukaj le-ta narašča nekoliko

hitreje.

4.1.3 Primerjava zapisane kode v STEP7 in generirane z PLK koderjem

Kot smo že ugotovili iz analize signalov, imata obe kodi skorajda identične odzive. Iz

priloge bo razvidno, da ima koda ustvarjena s PLK koderjem veliko več odvečne kode kot

pa tista, ki je napisana v STEP7. Do večine odvečne kode pride predvsem zaradi omejitve

uporabe vseh blokov z PLK koderjem. Tako smo morali program razdeliti na več manjših

programov in na novo izdelati model za diskretno prenosno funkcijo. Posledica vsega tega

je v ogromni količini odvečne kode. Če pa kodi ne dodamo možnosti izbiranja reda,

mrtvega časa in zakasnitev, lahko ugotovimo, da se količina odvečne kode zmanjša

0 5 10 15 20 250

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

Time

Odz

iv

Primerjava signalov Simatic in PLCcoder funkcije 4. reda z Delay-em 4 in mrtvim casom 0.5

Vzbujalni signalSimulacijaPLCcoder odzivSimatic odziv


34

oziroma je zelo podobna tisti, ki jo napišemo v programskem okolju STEP7. Pri najbolj

enostavnih funkcijah pa odvečne kode skorajda ni.

4.2 Uporabnost PLK koderja PLK koder je uporabno orodje za vse tiste, ki nimajo znanja iz programiranja in želijo

pisati programe za PLK, saj lahko ustvarijo enostavnejše programe kar v Simulniku. Prav

tako je odlično orodje za tiste, ki nimajo veliko izkušenj s programskim okoljem PLK, ki ga

uporabljajo, saj jim le-ta omogoča generiranje, uvoz in celo preverjanje kode, tako je

potrebno le še program prenesti na krmilnik. Pozitivna stran PLK koderja je tudi možnost

pisanja nekaterih kompleksnejših modelov, ki se lahko v Simulinku ustvarijo lažje kot s

programiranjem. Tukaj je velika prednost PLK koderja grafični vmesnik saj se tudi pri zelo

dolgih programih z veliko elementi ne izgubimo, medtem pa lahko v simulatorju hitro

preverimo našo kodo in jo zaradi boljše preglednosti tudi hitro popravimo. Prav tako

generirana koda s PLK koderjem upošteva standard IEC61131-3, ki je standard v

procesni avtomatizaciji. Negativna stran PLK koderja je, da ne more generirati kode iz

vseh blokov in da ne moremo vpisovati spremenljivk v vnaprej pripravljene bloke. To nam

lahko povzroči precej nevšečnosti pri ustvarjanju modela in veliko odvečne kode v

končnem programu. Veliko časa zahteva tudi priprava celotnega operacijskega sistema in

upoštevanje točno določenih verzij programskih okolij. Kljub temu pa se PLK koder z

vsako verzijo nekoliko izboljša, saj so mu vedno znova dodane nove funkcije. Vsaka

novejša verzija podpira vedno več programskih okolij krmilnikov različnih znamk.


35

5 SKLEP Cilj diplomskega dela je bil spoznati in preizkusiti nov program za generiranje kode za

PLK, ga nato primerjati s kodo napisano v programskem okolju PLK in na koncu podati

primerjavo med obema načinoma pisanja kode. Podroben opis uporabe PLK koderja pa

bo tudi v pomoč bodočim študentom, ki ga bodo uporabljali.

Pri uporabi PLK koderja sem naletel na veliko omejitev in slabosti tega programa, kot so

prilagoditve operacijskega sistema, omejitve pri uporabi blokov v Simulink-u in pri

primerjavi odzivov s simulacijo. Vse slabosti sem podrobneje opisal v diplomskem delu,

prav tako pa sem tudi opisal, kako sem sam rešil nekatere izmed teh problemov oziroma,

kako se lahko tem težavam izognemo.

Vse to nas pripelje do končne ocene programa. Opazil sem, da je delo s PLK koderjem

lahko zelo zapleteno, če hočemo generirati kodo za proces, ki mu želimo spreminjati

vrednosti znotraj funkcije. Naš problem moramo zelo dobro poznati, saj ga moramo

ustvariti iz osnovnih blokov. To nam vzame zelo veliko časa, če k temu prištejemo še

omejitve uporabe nekaterih blokov. Ugotovimo lahko, da je nekatere probleme skorajda

nemogoče ustvariti oziroma bi za njih porabili neprimerljivo več časa, kot če bi jih napisali

v programskem okolju. Povsem drugače pa je pri enostavnih funkcijah, ki jim ni potrebno

spreminjati vrednosti. Te funkcije lahko v Simulinku ustvarimo zelo hitro, generiranje kode

za krmilnik je zelo enostavno in ne vsebuje odvečne kode.

Torej PLC coder je programsko orodje, ki je zelo obetavno in bi lahko v prihodnosti

olajšalo pisanje programske kode za krmilnike PLK. Vendar mislim, da lahko trenutna

verzija programa koristi tistim, ki ne poznajo niti osnov iz programiranja oziroma ga bodo

uporabljali le za generiranje enostavnejših funkcij. Pozitivna stran koderja je tudi hitra

možnost preizkusa programa preden ga naložimo na krmilnik. Prav tako je PLK koder tudi

zelo pregleden, kar lahko koristi pri programiranju zelo dolgih programov, ki postanejo pri

klasičnem programiranju zelo nepregledni medtem ko PLK koder omogoča grafični prikaz

vseh elementov in hitro možnost simulacije in popravkov. Glede na to da je PLC coder

plačljiv dodatek, za katerega je treba prilagoditi operacijski sistem in nam niti ne omogoča

uporabe vseh blokov iz Simulink-ove knjižnice. To povzroča delo z njim veliko bolj

zamudno in naporno. Torej tistim, ki poznajo vsaj osnove programiranja priporočam, da

poskušajo kodo zapisati v programskem okolju krmilnika in počakajo da MathWorks

odpravi trenutne omejitve PLK koderja.


36

6 VIRI IN LITERATURA [1] Matlab help, Version R2011b, 2011.

[2] Berger, H. Automating with STEP 7 in STL and SCL, 2007.

[3] Svečko, R. Diskretni regulacijski sistemi, FERI, Maribor, 2005.

[4] SIMATIC STEP 7: the comprehensive engineering system. Dostopno na:

http://www.automation.siemens.com/mcms/simatic-controller-

software/en/step7/pages/default.aspx [11.7.2012]

[5] OPC server. Dostopno na:

http://en.wikipedia.org/wiki/Opc_server [11.7.2012]

[6] KepserverEX. Dostopno na:

http://www.kepware.com/Products/kepserverex_features.asp [11.7.2012]

[7] Tiegelkamp, M. IEC 61131-3: Programming Industrial Automation Systems, Springer,

Berlin, 2001.

[8] Polajžer, M. Programabilni logični krmilnik kot simulacijsko okolje za testiranje

industrijskih regulatorjev, FERI, Maribor, 2010.


37

Priloga A

Kazalo slik SLIKA 3.1 PLK S7-‐400 .......................................................................................................................................... 3

SLIKA 4.1 SIMULACIJSKI MODEL PROCESA V SIMULINKU ................................................................................................. 6

SLIKA 4.2 SIMBOL ZA MRTVO CONO ........................................................................................................................... 6

SLIKA 4.4 SIMBOL ZA DELAY ..................................................................................................................................... 7

SLIKA 4.5 SIMBOL ZA OMEJITEV IZHODNEGA SIGNALA .................................................................................................... 7

SLIKA 4.6 ODZIV ZVEZNE FUNKCIJE NA STOPNIČNO VZBUJANJE ......................................................................................... 7

SLIKA 4.7 ODZIV DISKRETNE PRENOSNE FUNKCIJE NA STOPNIČNO VZBUJANJE ..................................................................... 9

SLIKA 4.8 MODEL PROJEKTA ZA SPOZNAVANJE PLK KODERJA ........................................................................................ 10

SLIKA 4.9 PRIKAZ POLJ DO KATERIH NE MOREMO DOSTOPATI ........................................................................................ 12

SLIKA 4.10 PRIMER KAKO NE MOREMO UPORABLJATI BLOKA SWITCH .............................................................................. 12

SLIKA 4.11 BLOKI KI JIH PLK KODER NI PODPIRAL ........................................................................................................ 13

SLIKA 4.12 FUNKCIJA ZA MRTVO CONO ..................................................................................................................... 13

SLIKA 4.13 FUNKCIJA ZA OMEJITEV IZHODNEGA SIGNALA .............................................................................................. 13

SLIKA 4.14 FUNKCIJA V VODLJIVOSTNI NORMALNI OBLIKI ............................................................................................. 14

SLIKA 4.15 RAZŠIRJENA PRENOSNA FUNKCIJA ............................................................................................................ 15

SLIKA 4.16 MODEL ZA IZBIRO ZAKASNITEV ................................................................................................................ 16

SLIKA 4.17 KONČNI MODEL .................................................................................................................................... 16

SLIKA 4.18 KONFIGURACIJA KRMILNIKA .................................................................................................................... 17

SLIKA 4.19 VNAŠANJE SCL KODE ............................................................................................................................ 18

SLIKA 4.20 BLOK PROCES V STEP7 .......................................................................................................................... 18

SLIKA 4.21 BLOK ZA MRTVO CONO .......................................................................................................................... 19

SLIKA 4.22 BLOK ZA ZAKASNITVE ............................................................................................................................. 20

SLIKA 4.23 DEFINICIJA SSMETHODTYPE .................................................................................................................... 21

SLIKA 4.24 BLOK ZA IZBIRO REDA ............................................................................................................................ 22

SLIKA 4.25 BLOK ZA OMEJITEV IZHODNE VREDNOSTI ................................................................................................... 23

SLIKA 4.26 BLOK NAPISAN V STEP7 ........................................................................................................................ 24

SLIKA 4.27 USTVARJANJE PROJEKTA V KEPSERVEREX [6] ............................................................................................. 27

SLIKA 4.28 KLIENT S KATERIM LAHKO OPAZUJEMO VREDNOSTI SPREMENLJIVK NA KRMILNIKU .............................................. 28

SLIKA 5.1 SIMULINK MODEL NAMENJEN PRIMERJAVI ODZIVOV ....................................................................................... 29

SLIKA 5.2 ODZIV PRENOSNE FUNKCIJE 2. REDA .......................................................................................................... 30


38

SLIKA 5.3 ODZIV Z MRTVIM ČASOM 0.5 ........................................................................................................... 31

SLIKA 5.4 FUNKCIJA 4. REDA .................................................................................................................................. 31

SLIKA 5.5 PRIMERJAVA FUNKCIJE 2. REDA Z 10 ZAKASNITVAMI ...................................................................................... 32

SLIKA 5.6 PRIMERJAVA FUNKCIJE 4. REDA Z ZAKASNITVIJO 4 IN MRTVIM ČASOM 0.5 ................................................. 33

0 2 4 6 8 10 12 14 16 18 200

0.5

1

1.5

Ćas

Odz

iv

Odziv z mrtvim ćasom 0.5


0 5 10 15 20 250

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

Time

Odz

iv

Primerjava signalov Simatic in PLCcoder funkcije 4. reda z Delay-em 4 in mrtvim casom 0.5

Vzbujalni signalSimulacijaPLCcoder odzivSimatic odziv


39

Priloga B

Programi generirani z PLC coderjem Koda za funkcijo 2. reda, ki ji ne moremo spreminjati vrednosti:

Koda generirana za mrtvo cono:


40

Koda generirana za izbiro zakasnitev:

FUNCTION_BLOCK FB103

VAR_INPUT

ssMethodType: INT;

Delay0: REAL;

Delay1: REAL;

Delay2: REAL;

Delay3: REAL;

Delay4: REAL;

Delay5: REAL;

Delay6: REAL;

Delay7: REAL;

Delay8: REAL;

Delay9: REAL;

Delay10: REAL;

END_VAR

VAR_OUTPUT

Delay_0: REAL;

Delay_1: REAL;

Delay_2: REAL;

Delay_3: REAL;

Delay_4: REAL;

Delay_5: REAL;

Delay_6: REAL;

Delay_7: REAL;

Delay_8: REAL;

Delay_9: REAL;

Delay_10: REAL;

END_VAR

VAR

Delay91_DSTATE: ARRAY [0..9] OF REAL;






41





Delay_DSTATE: REAL;

idxDelay: DINT;

i: DINT;

END_VAR

CASE ssMethodType OF

0:

(* InitializeConditions for Delay: '<S1>/Delay' *)

Delay_DSTATE := 0;

(* InitializeConditions for Delay: '<S1>/Delay11' *)

Delay11_DSTATE[0] := 0;












FOR i := 0 TO 4 DO

Delay41_DSTATE[i] := 0;

END_FOR;

(* End of InitializeConditions for Delay: '<S1>/Delay41' *)


42


FOR i := 0 TO 5 DO


END_FOR;



FOR i := 0 TO 6 DO


END_FOR;



FOR i := 0 TO 7 DO


END_FOR;



FOR i := 0 TO 8 DO


END_FOR;



FOR i := 0 TO 9 DO


END_FOR;


1:

(* Outport: '<Root>/Out1' incorporates:

* Inport: '<Root>/Delay0' *)

Delay_0 := Delay0;


43


* Delay: '<S1>/Delay' *)

Delay_1 := Delay_DSTATE;


* Delay: '<S1>/Delay11' *)

Delay_2 := Delay11_DSTATE[0];























44




(* Update for Delay: '<S1>/Delay' incorporates:

* Update for Inport: '<Root>/Delay1' *)

Delay_DSTATE := Delay1;

(* Update for Delay: '<S1>/Delay11' incorporates:


Delay11_DSTATE[0] := Delay11_DSTATE[1];

Delay11_DSTATE[1] := Delay2;




















45



FOR idxDelay := 0 TO 4 DO

Delay51_DSTATE[idxDelay] := Delay51_DSTATE[idxDelay + 1];

END_FOR;


(* End of Update for Delay: '<S1>/Delay51' *)





END_FOR;







END_FOR;







END_FOR;







46


END_FOR;



END_CASE;

END_FUNCTION_BLOCK

Koda generirana za univerzalen blok za izbiro reda in vpis parametrov:

FUNCTION_BLOCK FB101

VAR_INPUT

ssMethodType: INT;

Red_1: REAL;

Red_2: REAL;

Red_3: REAL;

b0: REAL;

b1: REAL;

b2: REAL;

b3: REAL;

a0: REAL;

a1: REAL;

a2: REAL;

a3: REAL;

b4: REAL;

b5: REAL;

a4: REAL;

a5: REAL;

Red_4: REAL;

Red_5: REAL;

Red_6: REAL;

END_VAR

VAR_OUTPUT

Red1: REAL;

Red2: REAL;

Red3: REAL;

Red4: REAL;


47

Red5: REAL;

Red6: REAL;

END_VAR

VAR

UnitDelay1_DSTATE: REAL;




UnitDelay8_DSTATE_k: REAL;

UnitDelay7_DSTATE_l: REAL;


UnitDelay9_DSTATE_c: REAL;

UnitDelay8_DSTATE_f: REAL;

UnitDelay7_DSTATE_f: REAL;




UnitDelay2_DSTATE_c: REAL;

UnitDelay1_DSTATE_h: REAL;


UnitDelay_DSTATE: REAL;


UnitDelay6_DSTATE_d: REAL;

b_UnitDelay6_DSTATE: REAL;

UnitDelay_DSTATE_d: REAL;

rtb_UnitDelay1: REAL;




rtb_UnitDelay8_j: REAL;

rtb_UnitDelay7_g: REAL;


rtb_UnitDelay9_a: REAL;

rtb_UnitDelay8_o: REAL;


48

rtb_UnitDelay7_d: REAL;




rtb_UnitDelay2_j: REAL;

rtb_UnitDelay1_a: REAL;

END_VAR

CASE ssMethodType OF

0:

(* InitializeConditions for UnitDelay: '<S2>/Unit Delay2' *)

UnitDelay2_DSTATE := 0;



(* InitializeConditions for UnitDelay: '<S3>/Unit Delay' *)

UnitDelay_DSTATE := 0;










UnitDelay8_DSTATE_k := 0;



49

UnitDelay7_DSTATE_l := 0;


UnitDelay6_DSTATE_d := 0;




UnitDelay9_DSTATE_c := 0;


UnitDelay8_DSTATE_f := 0;


UnitDelay7_DSTATE_f := 0;


b_UnitDelay6_DSTATE := 0;








UnitDelay2_DSTATE_c := 0;


UnitDelay1_DSTATE_h := 0;


50

(* InitializeConditions for UnitDelay: '<S7>/Unit Delay' *)

UnitDelay_DSTATE_d := 0;

1:

(* Outport: '<Root>/1. red' incorporates:

* Inport: '<Root>/b0'

* Product: '<S2>/Product'

* UnitDelay: '<S2>/Unit Delay2' *)

Red1 := UnitDelay2_DSTATE * b0;

(* UnitDelay: '<S3>/Unit Delay1' *)

rtb_UnitDelay1 := UnitDelay1_DSTATE;





* Product: '<S3>/Product2'

* Sum: '<S3>/Sum3'

* UnitDelay: '<S3>/Unit Delay'


Red2 := (UnitDelay1_DSTATE * b1) + (UnitDelay_DSTATE * b0);












51


* Sum: '<S4>/Sum16'

* Sum: '<S4>/Sum17'

* UnitDelay: '<S4>/Unit Delay6'



Red3 := ((UnitDelay8_DSTATE * b2) + (UnitDelay7_DSTATE * b1)) +

(UnitDelay6_DSTATE * b0);




rtb_UnitDelay8_j := UnitDelay8_DSTATE_k;


rtb_UnitDelay7_g := UnitDelay7_DSTATE_l;










* Sum: '<S5>/Sum16'

* Sum: '<S5>/Sum17'

* Sum: '<S5>/Sum19'






52

Red4 := (((UnitDelay9_DSTATE * b3) + (UnitDelay8_DSTATE_k * b2)) +

(UnitDelay7_DSTATE_l * b1)) + (UnitDelay6_DSTATE_d *

b0);




rtb_UnitDelay9_a := UnitDelay9_DSTATE_c;


rtb_UnitDelay8_o := UnitDelay8_DSTATE_f;


rtb_UnitDelay7_d := UnitDelay7_DSTATE_f;












* Sum: '<S6>/Sum16'

* Sum: '<S6>/Sum17'

* Sum: '<S6>/Sum19'

* Sum: '<S6>/Sum20'






53


Red5:= ((((UnitDelay10_DSTATE * b4) + (UnitDelay9_DSTATE_c * b3)) +

(UnitDelay8_DSTATE_f * b2)) + (UnitDelay7_DSTATE_f *

b1)) + (b_UnitDelay6_DSTATE * b0);








rtb_UnitDelay2_j := UnitDelay2_DSTATE_c;


rtb_UnitDelay1_a := UnitDelay1_DSTATE_h;














* Sum: '<S7>/Sum2'

* Sum: '<S7>/Sum3'


54

* Sum: '<S7>/Sum5'

* Sum: '<S7>/Sum6'

* Sum: '<S7>/Sum7'







Red6 := (((((UnitDelay5_DSTATE * b5) + (UnitDelay4_DSTATE * b4)) +

(UnitDelay3_DSTATE * b3)) + (UnitDelay2_DSTATE_c *

b2)) + (UnitDelay1_DSTATE_h * b1)) + (UnitDelay_DSTATE_d * b0);

(* Update for UnitDelay: '<S2>/Unit Delay2' incorporates:

* Update for Inport: '<Root>/1. Red'

* Update for Inport: '<Root>/a0'


* Sum: '<S2>/Sum7'


UnitDelay2_DSTATE := Red_1 - (UnitDelay2_DSTATE * a0);







* Sum: '<S3>/Sum1'

* Sum: '<S3>/Sum4'



UnitDelay1_DSTATE := Red_2 - ((UnitDelay1_DSTATE * a1) + (UnitDelay_DSTATE

* a0));

(* Update for UnitDelay: '<S3>/Unit Delay' *)


55

UnitDelay_DSTATE := rtb_UnitDelay1;









* Sum: '<S4>/Sum18'

* Sum: '<S4>/Sum22'

* Sum: '<S4>/Sum8'




UnitDelay8_DSTATE := Red_3 - (((UnitDelay7_DSTATE * a1) +

(UnitDelay6_DSTATE * a0)) + (UnitDelay8_DSTATE * a2));

(* Update for UnitDelay: '<S4>/Unit Delay7' *)

UnitDelay7_DSTATE := rtb_UnitDelay8;














56

* Sum: '<S5>/Sum13'

* Sum: '<S5>/Sum18'

* Sum: '<S5>/Sum22'

* Sum: '<S5>/Sum8'





UnitDelay9_DSTATE := Red_4 - ((((UnitDelay7_DSTATE_l * a1) +

(UnitDelay6_DSTATE_d * a0)) + (UnitDelay8_DSTATE_k *

a2)) + (UnitDelay9_DSTATE * a3));


UnitDelay8_DSTATE_k := rtb_UnitDelay9;


UnitDelay7_DSTATE_l := rtb_UnitDelay8_j;


UnitDelay6_DSTATE_d := rtb_UnitDelay7_g;













* Sum: '<S6>/Sum13'

* Sum: '<S6>/Sum14'


57

* Sum: '<S6>/Sum18'

* Sum: '<S6>/Sum22'

* Sum: '<S6>/Sum8'






UnitDelay10_DSTATE := Red_5 - (((((UnitDelay7_DSTATE_f * a1) +

(b_UnitDelay6_DSTATE * a0)) + (UnitDelay8_DSTATE_f *

a2)) + (UnitDelay9_DSTATE_c * a3)) + (UnitDelay10_DSTATE * a4));


UnitDelay9_DSTATE_c := rtb_UnitDelay10;


UnitDelay8_DSTATE_f := rtb_UnitDelay9_a;


UnitDelay7_DSTATE_f := rtb_UnitDelay8_o;


b_UnitDelay6_DSTATE := rtb_UnitDelay7_d;













58




* Sum: '<S7>/Sum1'

* Sum: '<S7>/Sum10'

* Sum: '<S7>/Sum11'

* Sum: '<S7>/Sum12'

* Sum: '<S7>/Sum4'

* Sum: '<S7>/Sum9'







UnitDelay5_DSTATE := Red_6 - ((((((UnitDelay1_DSTATE_h * a1) +

(UnitDelay_DSTATE_d * a0)) + (UnitDelay2_DSTATE_c *

a2)) + (UnitDelay3_DSTATE * b3)) + (UnitDelay4_DSTATE * a4)) +

(UnitDelay5_DSTATE * a5));






UnitDelay2_DSTATE_c := rtb_UnitDelay3;


UnitDelay1_DSTATE_h := rtb_UnitDelay2_j;

(* Update for UnitDelay: '<S7>/Unit Delay' *)

UnitDelay_DSTATE_d := rtb_UnitDelay1_a;

END_CASE;


59

END_FUNCTION_BLOCK

Koda napisana v STEP7, ki sem jo uporabljal za primerjavo signalov:

FUNCTION_BLOCK FB1

VAR_INPUT

ENABLE : BOOL ;

U : REAL ;

END_VAR

VAR_OUTPUT

// Output Variables

EXEC: BOOL := FALSE ;

Izhod : REAL := 0.0 ;

END_VAR

VAR

// Static Variables

// Parametri procesa n-tega reda

RED : INT := 4;

//A : ARRAY[1..6] OF REAL := -0.9048, 5(0.0) ;

//B : ARRAY[1..6] OF REAL := 0.09516, 5(0.0) ;

//A : ARRAY[1..6] OF REAL := -0.9672, 5(0.0) ;

//B : ARRAY[1..6] OF REAL := 0.03278, 5(0.0) ;

//Definicija spremenljivk za koeficiente diskretne prenosne funkcije

A : ARRAY[1..6] OF REAL := 6(0.0) ;

B : ARRAY[1..6] OF REAL := 6(0.0) ;

//Definicija spremenljivk za koeficiente polinoma

//C : ARRAY[1..20] OF REAL := 20(0.0) ;


60

TD : INT := 4; // zakasnitev med 0 in 10 * Ts

// Prejšnje vhodne in izhodne vrednosti

U1 : ARRAY[1..16] OF REAL := 16(0.0); //Polje zakasnjenih vhodnih vrednosti

Y1 : ARRAY[1..16] OF REAL := 16(0.0); //Polje zakasnjeniv izhodnih vrednosti

// Limite izhodne veličine

YMAX : REAL := 100.0 ;

YMIN : REAL := 0.0 ;

// Mrtva cona na vhodu procesa prvega reda

MRT : REAL := 0.5;

Y : REAL := 0.0;

END_VAR

VAR_TEMP

I : INT ;

END_VAR

BEGIN

// Statement Section

// Upoštevamo mrtvo cono za vhodni signal

IF U > MRT THEN

U1[1] := U - MRT;

ELSIF U < -MRT THEN

U1[1] := U + MRT;

ELSE

U1[1] := 0.0;

END_IF;

IF ENABLE = 1 THEN

// Statement Section_IF

Y := U1[TD+2] ; // TD+2 pomeni da je izhod zakasnjen za en odtipek če je TD=0


61

EXEC := FALSE ;

ELSE

CASE RED OF

1..6 :

// Statement Section_ELSE

CASE RED OF

1: // Parametri za člen 1. red

A[1] := -0.9672161;

B[1] := 0.032783899;

//Y := - A[1]*Yk[2]+B[1]*U1[TD];

2: //Parametri za člen 2. reda

(*

A[1] := 0.93997;

A[2] := -1.93904;

B[1] := 0.000457;

B[2] := 0.0004665;

*)

//(*

A[1] := 0.860707976;

A[2] := -1.856066842;

B[1] := 0.006787694;

B[2] := 0.007135707;

//*)

(*

A[1] := -1.97980265997351;


62

A[2] := 0.98019867330676;

B[1] := 0.00019866669324445;

B[2] := 0.00019734664;

*)

// Y := -A[2]*Yk[2] -A[1]*Yk[3] + B[2]*U1[TD] + B[1]*U1[TD+1];


A[1] := -0.92443;

A[2] := 2.846971;

A[3] := -2.92252;

B[1] := 0.0000024941526;

B[2] := 0.0000101746;

B[3] := 0.000002594087;

//Y := -A[3]*Yk[2] -A[2]*Yk[3] -A[1]*Yk[4]+ B[3]*U1[TD] +

B[2]*U1[TD+1] + B[1]*U1[TD+2];


A[1] := 0.9091564;

A[2] := -3.7243514;

A[3] := 5.7211871;

A[4] := -3.9059918;

B[1] := 0.0000000102;

B[2] := 0.0000001145211;

B[3] := 0.0000001167233;

B[4] := 0.000000010815;

// Y := -A[4]*Yk[2] -A[3]*Yk[3] -A[2]*Yk[4] - A[1]*Yk[5] + B[4]*U1[TD]

+ B[3]*U1[TD+1] + B[2]*U1[TD+2] + B[1]*U1[TD+3];


63


A[1] := -0.8911539;

A[2] := 4.5597607;

A[3] := -9.3322514;

A[4] := 9.5498351;

A[5] := -4.8861905;

B[1] := 0.00000000004005;

B[2] := 0.00000000106163;

B[3] := 0.00000000274720;

B[4] := 0.00000000110321;

B[5] := 0.00000000004325;

//Y := -A[5]*Yk[2] -A[4]*Yk[3] -A[3]*Yk[4] - A[2]*Yk[5] - A[1]*Yk[6] +

B[5]*U1[TD] + B[4]*U1[TD+1] + B[3]*U1[TD+2] + B[2]*U1[TD+3]+ B[1]*U1[TD+4];

END_CASE;

(*

Y := 0.0;

FOR I := 1 TO RED BY 1 DO

// Statement Section

Y := Y -A[I] * Y1[I] + B[I] * U1[TD+I] ;

EXEC := TRUE ;

END_FOR;

*)

Y := 0.0;

FOR I:= 0 TO RED-1 BY 1 DO


64

Y := Y - A[RED-I]*Y1[I+2]+B[RED-I]*U1[TD+I+2];

EXEC := TRUE ;

END_FOR;

7 : //Izračun polinomske funkcije

Y := A[6]*U1[1]*U1[1]*U1[1]*U1[1]*U1[1] + A[5]*U1[1]*U1[1]*U1[1]*U1[1] +

A[4]*U1[1]*U1[1]*U1[1] + A[3]*U1[1]*U1[1] + A[2]*U1[1] + A[1];

END_CASE;

END_IF;

// Limiter izhodne vrednosti

IF Y >= YMAX THEN

Y := YMAX;

ELSIF Y <= YMIN THEN

Y := YMIN;

END_IF;

Y1[1] := Y;

Izhod := Y;

// Pomik izhdnega signala za en odtipek

FOR I:= 16 TO 2 BY -1 DO

Y1[I] := Y1[I-1];

END_FOR;

// Pomik vhodnega signala za en odtipek

//FOR I:= (TD + RED) TO 2 BY -1 DO

FOR I:= 16 TO 2 BY -1 DO

U1[I] := U1[I-1];


65

END_FOR;

END_FUNCTION_BLOCK


66


67


68

Documents

Matlab/Simulink podprto generiranje PLC kode v skladu s ...arhiviramo naše delo. Programiranje je mogoče v treh različnih jezikih in sicer v lestvični logiki (Ladder Diagram LD),