Upload
others
View
1
Download
0
Embed Size (px)
Citation preview
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
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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.
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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.
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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.
Matlab/Simulink generiranje PLC kode
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.
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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.
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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.
Matlab/Simulink generiranje PLC kode
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.
Matlab/Simulink generiranje PLC kode
22
Slika 3.23 Blok za izbiro reda
Matlab/Simulink generiranje PLC kode
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.
Matlab/Simulink generiranje PLC kode
24
Slika 3.25 Blok napisan v STEP7
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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«.
Matlab/Simulink generiranje PLC kode
28
Slika 3.27 Klient s katerim lahko opazujemo vrednosti spremenljivk na krmilniku
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Vzbujalni signalSimulacijaPLCcoder
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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.
Matlab/Simulink generiranje PLC kode
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.
Matlab/Simulink generiranje PLC kode
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.
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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
Vzbujalni signalSimulacijaPLCcoder
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
Matlab/Simulink generiranje PLC kode
39
Priloga B
Programi generirani z PLC coderjem Koda za funkcijo 2. reda, ki ji ne moremo spreminjati vrednosti:
Koda generirana za mrtvo cono:
Matlab/Simulink generiranje PLC kode
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;
Delay81_DSTATE: ARRAY [0..8] OF REAL;
Delay71_DSTATE: ARRAY [0..7] OF REAL;
Delay61_DSTATE: ARRAY [0..6] OF REAL;
Delay51_DSTATE: ARRAY [0..5] OF REAL;
Matlab/Simulink generiranje PLC kode
41
Delay41_DSTATE: ARRAY [0..4] OF REAL;
Delay31_DSTATE: ARRAY [0..3] OF REAL;
Delay21_DSTATE: ARRAY [0..2] OF REAL;
Delay11_DSTATE: ARRAY [0..1] OF REAL;
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;
Delay11_DSTATE[1] := 0;
(* InitializeConditions for Delay: '<S1>/Delay21' *)
Delay21_DSTATE[0] := 0;
Delay21_DSTATE[1] := 0;
Delay21_DSTATE[2] := 0;
(* InitializeConditions for Delay: '<S1>/Delay31' *)
Delay31_DSTATE[0] := 0;
Delay31_DSTATE[1] := 0;
Delay31_DSTATE[2] := 0;
Delay31_DSTATE[3] := 0;
(* InitializeConditions for Delay: '<S1>/Delay41' *)
FOR i := 0 TO 4 DO
Delay41_DSTATE[i] := 0;
END_FOR;
(* End of InitializeConditions for Delay: '<S1>/Delay41' *)
Matlab/Simulink generiranje PLC kode
42
(* InitializeConditions for Delay: '<S1>/Delay51' *)
FOR i := 0 TO 5 DO
Delay51_DSTATE[i] := 0;
END_FOR;
(* End of InitializeConditions for Delay: '<S1>/Delay51' *)
(* InitializeConditions for Delay: '<S1>/Delay61' *)
FOR i := 0 TO 6 DO
Delay61_DSTATE[i] := 0;
END_FOR;
(* End of InitializeConditions for Delay: '<S1>/Delay61' *)
(* InitializeConditions for Delay: '<S1>/Delay71' *)
FOR i := 0 TO 7 DO
Delay71_DSTATE[i] := 0;
END_FOR;
(* End of InitializeConditions for Delay: '<S1>/Delay71' *)
(* InitializeConditions for Delay: '<S1>/Delay81' *)
FOR i := 0 TO 8 DO
Delay81_DSTATE[i] := 0;
END_FOR;
(* End of InitializeConditions for Delay: '<S1>/Delay81' *)
(* InitializeConditions for Delay: '<S1>/Delay91' *)
FOR i := 0 TO 9 DO
Delay91_DSTATE[i] := 0;
END_FOR;
(* End of InitializeConditions for Delay: '<S1>/Delay91' *)
1:
(* Outport: '<Root>/Out1' incorporates:
* Inport: '<Root>/Delay0' *)
Delay_0 := Delay0;
Matlab/Simulink generiranje PLC kode
43
(* Outport: '<Root>/Out2' incorporates:
* Delay: '<S1>/Delay' *)
Delay_1 := Delay_DSTATE;
(* Outport: '<Root>/Out3' incorporates:
* Delay: '<S1>/Delay11' *)
Delay_2 := Delay11_DSTATE[0];
(* Outport: '<Root>/Out4' incorporates:
* Delay: '<S1>/Delay21' *)
Delay_3 := Delay21_DSTATE[0];
(* Outport: '<Root>/Out5' incorporates:
* Delay: '<S1>/Delay31' *)
Delay_4 := Delay31_DSTATE[0];
(* Outport: '<Root>/Out6' incorporates:
* Delay: '<S1>/Delay41' *)
Delay_5 := Delay41_DSTATE[0];
(* Outport: '<Root>/Out7' incorporates:
* Delay: '<S1>/Delay51' *)
Delay_6 := Delay51_DSTATE[0];
(* Outport: '<Root>/Out8' incorporates:
* Delay: '<S1>/Delay61' *)
Delay_7 := Delay61_DSTATE[0];
(* Outport: '<Root>/Out9' incorporates:
* Delay: '<S1>/Delay71' *)
Delay_8 := Delay71_DSTATE[0];
(* Outport: '<Root>/Out10' incorporates:
* Delay: '<S1>/Delay81' *)
Delay_9 := Delay81_DSTATE[0];
Matlab/Simulink generiranje PLC kode
44
(* Outport: '<Root>/Out11' incorporates:
* Delay: '<S1>/Delay91' *)
Delay_10 := Delay91_DSTATE[0];
(* Update for Delay: '<S1>/Delay' incorporates:
* Update for Inport: '<Root>/Delay1' *)
Delay_DSTATE := Delay1;
(* Update for Delay: '<S1>/Delay11' incorporates:
* Update for Inport: '<Root>/Delay2' *)
Delay11_DSTATE[0] := Delay11_DSTATE[1];
Delay11_DSTATE[1] := Delay2;
(* Update for Delay: '<S1>/Delay21' incorporates:
* Update for Inport: '<Root>/Delay3' *)
Delay21_DSTATE[0] := Delay21_DSTATE[1];
Delay21_DSTATE[1] := Delay21_DSTATE[2];
Delay21_DSTATE[2] := Delay3;
(* Update for Delay: '<S1>/Delay31' incorporates:
* Update for Inport: '<Root>/Delay4' *)
Delay31_DSTATE[0] := Delay31_DSTATE[1];
Delay31_DSTATE[1] := Delay31_DSTATE[2];
Delay31_DSTATE[2] := Delay31_DSTATE[3];
Delay31_DSTATE[3] := Delay4;
(* Update for Delay: '<S1>/Delay41' incorporates:
* Update for Inport: '<Root>/Delay5' *)
Delay41_DSTATE[0] := Delay41_DSTATE[1];
Delay41_DSTATE[1] := Delay41_DSTATE[2];
Delay41_DSTATE[2] := Delay41_DSTATE[3];
Delay41_DSTATE[3] := Delay41_DSTATE[4];
Delay41_DSTATE[4] := Delay5;
Matlab/Simulink generiranje PLC kode
45
(* Update for Delay: '<S1>/Delay51' incorporates:
* Update for Inport: '<Root>/Delay6' *)
FOR idxDelay := 0 TO 4 DO
Delay51_DSTATE[idxDelay] := Delay51_DSTATE[idxDelay + 1];
END_FOR;
Delay51_DSTATE[5] := Delay6;
(* End of Update for Delay: '<S1>/Delay51' *)
(* Update for Delay: '<S1>/Delay61' incorporates:
* Update for Inport: '<Root>/Delay7' *)
FOR idxDelay := 0 TO 5 DO
Delay61_DSTATE[idxDelay] := Delay61_DSTATE[idxDelay + 1];
END_FOR;
Delay61_DSTATE[6] := Delay7;
(* End of Update for Delay: '<S1>/Delay61' *)
(* Update for Delay: '<S1>/Delay71' incorporates:
* Update for Inport: '<Root>/Delay8' *)
FOR idxDelay := 0 TO 6 DO
Delay71_DSTATE[idxDelay] := Delay71_DSTATE[idxDelay + 1];
END_FOR;
Delay71_DSTATE[7] := Delay8;
(* End of Update for Delay: '<S1>/Delay71' *)
(* Update for Delay: '<S1>/Delay81' incorporates:
* Update for Inport: '<Root>/Delay9' *)
FOR idxDelay := 0 TO 7 DO
Delay81_DSTATE[idxDelay] := Delay81_DSTATE[idxDelay + 1];
END_FOR;
Delay81_DSTATE[8] := Delay9;
(* End of Update for Delay: '<S1>/Delay81' *)
(* Update for Delay: '<S1>/Delay91' incorporates:
* Update for Inport: '<Root>/Delay10' *)
FOR idxDelay := 0 TO 8 DO
Matlab/Simulink generiranje PLC kode
46
Delay91_DSTATE[idxDelay] := Delay91_DSTATE[idxDelay + 1];
END_FOR;
Delay91_DSTATE[9] := Delay10;
(* End of Update for Delay: '<S1>/Delay91' *)
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;
Matlab/Simulink generiranje PLC kode
47
Red5: REAL;
Red6: REAL;
END_VAR
VAR
UnitDelay1_DSTATE: REAL;
UnitDelay8_DSTATE: REAL;
UnitDelay7_DSTATE: REAL;
UnitDelay9_DSTATE: REAL;
UnitDelay8_DSTATE_k: REAL;
UnitDelay7_DSTATE_l: REAL;
UnitDelay10_DSTATE: REAL;
UnitDelay9_DSTATE_c: REAL;
UnitDelay8_DSTATE_f: REAL;
UnitDelay7_DSTATE_f: REAL;
UnitDelay5_DSTATE: REAL;
UnitDelay4_DSTATE: REAL;
UnitDelay3_DSTATE: REAL;
UnitDelay2_DSTATE_c: REAL;
UnitDelay1_DSTATE_h: REAL;
UnitDelay2_DSTATE: REAL;
UnitDelay_DSTATE: REAL;
UnitDelay6_DSTATE: REAL;
UnitDelay6_DSTATE_d: REAL;
b_UnitDelay6_DSTATE: REAL;
UnitDelay_DSTATE_d: REAL;
rtb_UnitDelay1: REAL;
rtb_UnitDelay8: REAL;
rtb_UnitDelay7: REAL;
rtb_UnitDelay9: REAL;
rtb_UnitDelay8_j: REAL;
rtb_UnitDelay7_g: REAL;
rtb_UnitDelay10: REAL;
rtb_UnitDelay9_a: REAL;
rtb_UnitDelay8_o: REAL;
Matlab/Simulink generiranje PLC kode
48
rtb_UnitDelay7_d: REAL;
rtb_UnitDelay5: REAL;
rtb_UnitDelay4: REAL;
rtb_UnitDelay3: 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 Delay1' *)
UnitDelay1_DSTATE := 0;
(* InitializeConditions for UnitDelay: '<S3>/Unit Delay' *)
UnitDelay_DSTATE := 0;
(* InitializeConditions for UnitDelay: '<S4>/Unit Delay8' *)
UnitDelay8_DSTATE := 0;
(* InitializeConditions for UnitDelay: '<S4>/Unit Delay7' *)
UnitDelay7_DSTATE := 0;
(* InitializeConditions for UnitDelay: '<S4>/Unit Delay6' *)
UnitDelay6_DSTATE := 0;
(* InitializeConditions for UnitDelay: '<S5>/Unit Delay9' *)
UnitDelay9_DSTATE := 0;
(* InitializeConditions for UnitDelay: '<S5>/Unit Delay8' *)
UnitDelay8_DSTATE_k := 0;
(* InitializeConditions for UnitDelay: '<S5>/Unit Delay7' *)
Matlab/Simulink generiranje PLC kode
49
UnitDelay7_DSTATE_l := 0;
(* InitializeConditions for UnitDelay: '<S5>/Unit Delay6' *)
UnitDelay6_DSTATE_d := 0;
(* InitializeConditions for UnitDelay: '<S6>/Unit Delay10' *)
UnitDelay10_DSTATE := 0;
(* InitializeConditions for UnitDelay: '<S6>/Unit Delay9' *)
UnitDelay9_DSTATE_c := 0;
(* InitializeConditions for UnitDelay: '<S6>/Unit Delay8' *)
UnitDelay8_DSTATE_f := 0;
(* InitializeConditions for UnitDelay: '<S6>/Unit Delay7' *)
UnitDelay7_DSTATE_f := 0;
(* InitializeConditions for UnitDelay: '<S6>/Unit Delay6' *)
b_UnitDelay6_DSTATE := 0;
(* InitializeConditions for UnitDelay: '<S7>/Unit Delay5' *)
UnitDelay5_DSTATE := 0;
(* InitializeConditions for UnitDelay: '<S7>/Unit Delay4' *)
UnitDelay4_DSTATE := 0;
(* InitializeConditions for UnitDelay: '<S7>/Unit Delay3' *)
UnitDelay3_DSTATE := 0;
(* InitializeConditions for UnitDelay: '<S7>/Unit Delay2' *)
UnitDelay2_DSTATE_c := 0;
(* InitializeConditions for UnitDelay: '<S7>/Unit Delay1' *)
UnitDelay1_DSTATE_h := 0;
Matlab/Simulink generiranje PLC kode
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;
(* Outport: '<Root>/2. red' incorporates:
* Inport: '<Root>/b0'
* Inport: '<Root>/b1'
* Product: '<S3>/Product'
* Product: '<S3>/Product2'
* Sum: '<S3>/Sum3'
* UnitDelay: '<S3>/Unit Delay'
* UnitDelay: '<S3>/Unit Delay1' *)
Red2 := (UnitDelay1_DSTATE * b1) + (UnitDelay_DSTATE * b0);
(* UnitDelay: '<S4>/Unit Delay8' *)
rtb_UnitDelay8 := UnitDelay8_DSTATE;
(* UnitDelay: '<S4>/Unit Delay7' *)
rtb_UnitDelay7 := UnitDelay7_DSTATE;
(* Outport: '<Root>/3. red' incorporates:
* Inport: '<Root>/b0'
* Inport: '<Root>/b1'
* Inport: '<Root>/b2'
* Product: '<S4>/Product'
* Product: '<S4>/Product2'
Matlab/Simulink generiranje PLC kode
51
* Product: '<S4>/Product4'
* Sum: '<S4>/Sum16'
* Sum: '<S4>/Sum17'
* UnitDelay: '<S4>/Unit Delay6'
* UnitDelay: '<S4>/Unit Delay7'
* UnitDelay: '<S4>/Unit Delay8' *)
Red3 := ((UnitDelay8_DSTATE * b2) + (UnitDelay7_DSTATE * b1)) +
(UnitDelay6_DSTATE * b0);
(* UnitDelay: '<S5>/Unit Delay9' *)
rtb_UnitDelay9 := UnitDelay9_DSTATE;
(* UnitDelay: '<S5>/Unit Delay8' *)
rtb_UnitDelay8_j := UnitDelay8_DSTATE_k;
(* UnitDelay: '<S5>/Unit Delay7' *)
rtb_UnitDelay7_g := UnitDelay7_DSTATE_l;
(* Outport: '<Root>/4. red' incorporates:
* Inport: '<Root>/b0'
* Inport: '<Root>/b1'
* Inport: '<Root>/b2'
* Inport: '<Root>/b3'
* Product: '<S5>/Product'
* Product: '<S5>/Product2'
* Product: '<S5>/Product4'
* Product: '<S5>/Product6'
* Sum: '<S5>/Sum16'
* Sum: '<S5>/Sum17'
* Sum: '<S5>/Sum19'
* UnitDelay: '<S5>/Unit Delay6'
* UnitDelay: '<S5>/Unit Delay7'
* UnitDelay: '<S5>/Unit Delay8'
* UnitDelay: '<S5>/Unit Delay9' *)
Matlab/Simulink generiranje PLC kode
52
Red4 := (((UnitDelay9_DSTATE * b3) + (UnitDelay8_DSTATE_k * b2)) +
(UnitDelay7_DSTATE_l * b1)) + (UnitDelay6_DSTATE_d *
b0);
(* UnitDelay: '<S6>/Unit Delay10' *)
rtb_UnitDelay10 := UnitDelay10_DSTATE;
(* UnitDelay: '<S6>/Unit Delay9' *)
rtb_UnitDelay9_a := UnitDelay9_DSTATE_c;
(* UnitDelay: '<S6>/Unit Delay8' *)
rtb_UnitDelay8_o := UnitDelay8_DSTATE_f;
(* UnitDelay: '<S6>/Unit Delay7' *)
rtb_UnitDelay7_d := UnitDelay7_DSTATE_f;
(* Outport: '<Root>/5. red' incorporates:
* Inport: '<Root>/b0'
* Inport: '<Root>/b1'
* Inport: '<Root>/b2'
* Inport: '<Root>/b3'
* Inport: '<Root>/b4'
* Product: '<S6>/Product'
* Product: '<S6>/Product2'
* Product: '<S6>/Product4'
* Product: '<S6>/Product6'
* Product: '<S6>/Product8'
* Sum: '<S6>/Sum16'
* Sum: '<S6>/Sum17'
* Sum: '<S6>/Sum19'
* Sum: '<S6>/Sum20'
* UnitDelay: '<S6>/Unit Delay10'
* UnitDelay: '<S6>/Unit Delay6'
* UnitDelay: '<S6>/Unit Delay7'
* UnitDelay: '<S6>/Unit Delay8'
Matlab/Simulink generiranje PLC kode
53
* UnitDelay: '<S6>/Unit Delay9' *)
Red5:= ((((UnitDelay10_DSTATE * b4) + (UnitDelay9_DSTATE_c * b3)) +
(UnitDelay8_DSTATE_f * b2)) + (UnitDelay7_DSTATE_f *
b1)) + (b_UnitDelay6_DSTATE * b0);
(* UnitDelay: '<S7>/Unit Delay5' *)
rtb_UnitDelay5 := UnitDelay5_DSTATE;
(* UnitDelay: '<S7>/Unit Delay4' *)
rtb_UnitDelay4 := UnitDelay4_DSTATE;
(* UnitDelay: '<S7>/Unit Delay3' *)
rtb_UnitDelay3 := UnitDelay3_DSTATE;
(* UnitDelay: '<S7>/Unit Delay2' *)
rtb_UnitDelay2_j := UnitDelay2_DSTATE_c;
(* UnitDelay: '<S7>/Unit Delay1' *)
rtb_UnitDelay1_a := UnitDelay1_DSTATE_h;
(* Outport: '<Root>/6. red' incorporates:
* Inport: '<Root>/b0'
* Inport: '<Root>/b1'
* Inport: '<Root>/b2'
* Inport: '<Root>/b3'
* Inport: '<Root>/b4'
* Inport: '<Root>/b5'
* Product: '<S7>/Product'
* Product: '<S7>/Product10'
* Product: '<S7>/Product2'
* Product: '<S7>/Product4'
* Product: '<S7>/Product6'
* Product: '<S7>/Product8'
* Sum: '<S7>/Sum2'
* Sum: '<S7>/Sum3'
Matlab/Simulink generiranje PLC kode
54
* Sum: '<S7>/Sum5'
* Sum: '<S7>/Sum6'
* Sum: '<S7>/Sum7'
* UnitDelay: '<S7>/Unit Delay'
* UnitDelay: '<S7>/Unit Delay1'
* UnitDelay: '<S7>/Unit Delay2'
* UnitDelay: '<S7>/Unit Delay3'
* UnitDelay: '<S7>/Unit Delay4'
* UnitDelay: '<S7>/Unit Delay5' *)
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'
* Product: '<S2>/Product1'
* Sum: '<S2>/Sum7'
* UnitDelay: '<S2>/Unit Delay2' *)
UnitDelay2_DSTATE := Red_1 - (UnitDelay2_DSTATE * a0);
(* Update for UnitDelay: '<S3>/Unit Delay1' incorporates:
* Update for Inport: '<Root>/2. Red'
* Update for Inport: '<Root>/a0'
* Update for Inport: '<Root>/a1'
* Product: '<S3>/Product1'
* Product: '<S3>/Product3'
* Sum: '<S3>/Sum1'
* Sum: '<S3>/Sum4'
* UnitDelay: '<S3>/Unit Delay'
* UnitDelay: '<S3>/Unit Delay1' *)
UnitDelay1_DSTATE := Red_2 - ((UnitDelay1_DSTATE * a1) + (UnitDelay_DSTATE
* a0));
(* Update for UnitDelay: '<S3>/Unit Delay' *)
Matlab/Simulink generiranje PLC kode
55
UnitDelay_DSTATE := rtb_UnitDelay1;
(* Update for UnitDelay: '<S4>/Unit Delay8' incorporates:
* Update for Inport: '<Root>/3. Red'
* Update for Inport: '<Root>/a0'
* Update for Inport: '<Root>/a1'
* Update for Inport: '<Root>/a2'
* Product: '<S4>/Product1'
* Product: '<S4>/Product3'
* Product: '<S4>/Product5'
* Sum: '<S4>/Sum18'
* Sum: '<S4>/Sum22'
* Sum: '<S4>/Sum8'
* UnitDelay: '<S4>/Unit Delay6'
* UnitDelay: '<S4>/Unit Delay7'
* UnitDelay: '<S4>/Unit Delay8' *)
UnitDelay8_DSTATE := Red_3 - (((UnitDelay7_DSTATE * a1) +
(UnitDelay6_DSTATE * a0)) + (UnitDelay8_DSTATE * a2));
(* Update for UnitDelay: '<S4>/Unit Delay7' *)
UnitDelay7_DSTATE := rtb_UnitDelay8;
(* Update for UnitDelay: '<S4>/Unit Delay6' *)
UnitDelay6_DSTATE := rtb_UnitDelay7;
(* Update for UnitDelay: '<S5>/Unit Delay9' incorporates:
* Update for Inport: '<Root>/4. Red'
* Update for Inport: '<Root>/a0'
* Update for Inport: '<Root>/a1'
* Update for Inport: '<Root>/a2'
* Update for Inport: '<Root>/a3'
* Product: '<S5>/Product1'
* Product: '<S5>/Product3'
* Product: '<S5>/Product5'
* Product: '<S5>/Product7'
Matlab/Simulink generiranje PLC kode
56
* Sum: '<S5>/Sum13'
* Sum: '<S5>/Sum18'
* Sum: '<S5>/Sum22'
* Sum: '<S5>/Sum8'
* UnitDelay: '<S5>/Unit Delay6'
* UnitDelay: '<S5>/Unit Delay7'
* UnitDelay: '<S5>/Unit Delay8'
* UnitDelay: '<S5>/Unit Delay9' *)
UnitDelay9_DSTATE := Red_4 - ((((UnitDelay7_DSTATE_l * a1) +
(UnitDelay6_DSTATE_d * a0)) + (UnitDelay8_DSTATE_k *
a2)) + (UnitDelay9_DSTATE * a3));
(* Update for UnitDelay: '<S5>/Unit Delay8' *)
UnitDelay8_DSTATE_k := rtb_UnitDelay9;
(* Update for UnitDelay: '<S5>/Unit Delay7' *)
UnitDelay7_DSTATE_l := rtb_UnitDelay8_j;
(* Update for UnitDelay: '<S5>/Unit Delay6' *)
UnitDelay6_DSTATE_d := rtb_UnitDelay7_g;
(* Update for UnitDelay: '<S6>/Unit Delay10' incorporates:
* Update for Inport: '<Root>/5. Red'
* Update for Inport: '<Root>/a0'
* Update for Inport: '<Root>/a1'
* Update for Inport: '<Root>/a2'
* Update for Inport: '<Root>/a3'
* Update for Inport: '<Root>/a4'
* Product: '<S6>/Product1'
* Product: '<S6>/Product3'
* Product: '<S6>/Product5'
* Product: '<S6>/Product7'
* Product: '<S6>/Product9'
* Sum: '<S6>/Sum13'
* Sum: '<S6>/Sum14'
Matlab/Simulink generiranje PLC kode
57
* Sum: '<S6>/Sum18'
* Sum: '<S6>/Sum22'
* Sum: '<S6>/Sum8'
* UnitDelay: '<S6>/Unit Delay10'
* UnitDelay: '<S6>/Unit Delay6'
* UnitDelay: '<S6>/Unit Delay7'
* UnitDelay: '<S6>/Unit Delay8'
* UnitDelay: '<S6>/Unit Delay9' *)
UnitDelay10_DSTATE := Red_5 - (((((UnitDelay7_DSTATE_f * a1) +
(b_UnitDelay6_DSTATE * a0)) + (UnitDelay8_DSTATE_f *
a2)) + (UnitDelay9_DSTATE_c * a3)) + (UnitDelay10_DSTATE * a4));
(* Update for UnitDelay: '<S6>/Unit Delay9' *)
UnitDelay9_DSTATE_c := rtb_UnitDelay10;
(* Update for UnitDelay: '<S6>/Unit Delay8' *)
UnitDelay8_DSTATE_f := rtb_UnitDelay9_a;
(* Update for UnitDelay: '<S6>/Unit Delay7' *)
UnitDelay7_DSTATE_f := rtb_UnitDelay8_o;
(* Update for UnitDelay: '<S6>/Unit Delay6' *)
b_UnitDelay6_DSTATE := rtb_UnitDelay7_d;
(* Update for UnitDelay: '<S7>/Unit Delay5' incorporates:
* Update for Inport: '<Root>/6. Red'
* Update for Inport: '<Root>/a0'
* Update for Inport: '<Root>/a1'
* Update for Inport: '<Root>/a2'
* Update for Inport: '<Root>/a4'
* Update for Inport: '<Root>/a5'
* Inport: '<Root>/b3'
* Product: '<S7>/Product1'
* Product: '<S7>/Product11'
* Product: '<S7>/Product3'
Matlab/Simulink generiranje PLC kode
58
* Product: '<S7>/Product5'
* Product: '<S7>/Product7'
* Product: '<S7>/Product9'
* Sum: '<S7>/Sum1'
* Sum: '<S7>/Sum10'
* Sum: '<S7>/Sum11'
* Sum: '<S7>/Sum12'
* Sum: '<S7>/Sum4'
* Sum: '<S7>/Sum9'
* UnitDelay: '<S7>/Unit Delay'
* UnitDelay: '<S7>/Unit Delay1'
* UnitDelay: '<S7>/Unit Delay2'
* UnitDelay: '<S7>/Unit Delay3'
* UnitDelay: '<S7>/Unit Delay4'
* UnitDelay: '<S7>/Unit Delay5' *)
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));
(* Update for UnitDelay: '<S7>/Unit Delay4' *)
UnitDelay4_DSTATE := rtb_UnitDelay5;
(* Update for UnitDelay: '<S7>/Unit Delay3' *)
UnitDelay3_DSTATE := rtb_UnitDelay4;
(* Update for UnitDelay: '<S7>/Unit Delay2' *)
UnitDelay2_DSTATE_c := rtb_UnitDelay3;
(* Update for UnitDelay: '<S7>/Unit Delay1' *)
UnitDelay1_DSTATE_h := rtb_UnitDelay2_j;
(* Update for UnitDelay: '<S7>/Unit Delay' *)
UnitDelay_DSTATE_d := rtb_UnitDelay1_a;
END_CASE;
Matlab/Simulink generiranje PLC kode
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) ;
Matlab/Simulink generiranje PLC kode
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
Matlab/Simulink generiranje PLC kode
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;
Matlab/Simulink generiranje PLC kode
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];
3: //Parametri za člen 3. reda
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];
4: //Parametri za člen 4. reda
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];
Matlab/Simulink generiranje PLC kode
63
5: //Parametri za člen 5. reda
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
Matlab/Simulink generiranje PLC kode
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];
Matlab/Simulink generiranje PLC kode
65
END_FOR;
END_FUNCTION_BLOCK
Matlab/Simulink generiranje PLC kode
66
Matlab/Simulink generiranje PLC kode
67
Matlab/Simulink generiranje PLC kode
68