Programabilni logični krmilnik Tomaž Furlan, (C) 2010 tfurl[at]online.ie
Programabilni logični krmilnik Tomaž Furlan, (C) 2010
tfurl[at]online.ie
UNIVERZA V LJUBLJANI
FAKULTETA ZA RAČUNALNIŠTVO IN INFORMATIKO
Tomaž Furlan
Programabilni logični krmilnik
DIPLOMSKO DELO
NA UNIVERZITETNEM ŠTUDIJU
Mentor: prof. dr. Dušan Kodek
Ljubljana, 2010
I Z J A V A O A V T O R S T V U
diplomskega dela
Spodaj podpisani/-a Tomaž Furlan,
z vpisno številko 63980032,
sem avtor/-ica diplomskega dela z naslovom:
Programabilni logični krmilnik
S svojim podpisom zagotavljam, da:
sem diplomsko delo izdelal/-a samostojno pod mentorstvom (naziv, ime in priimek)
prof. dr. Dušan Kodek
in somentorstvom (naziv, ime in priimek)
/
so elektronska oblika diplomskega dela, naslov (slov., angl.), povzetek (slov., angl.)
ter ključne besede (slov., angl.) identični s tiskano obliko diplomskega dela
soglašam z javno objavo elektronske oblike diplomskega dela v zbirki »Dela FRI«.
V Ljubljani, dne ____________________ Podpis avtorja/-ice: ______________________
Zahvala
Zahvaljujem se Sabini za potrpljenje, ki ga je izkazovala ob mojih prebitih nočeh za delovno mizo. Zahvaljujem se Nini, ker si je vzela čas za lovljenje slovničnih napak. In zahvaljujem se mentorju, prof. dr. Kodeku, ker je uspešno “krotil” moje podivjane ideje.
To delo posvečam vsem računalniškim pionirjem in tistim posameznikom, ki skrbijo, da njihov duh ne ugasne.
Vsebina
Povzetek ..................................................................................................................................... 1
Abstract ...................................................................................................................................... 2
1. Uvod ....................................................................................................................................... 3
2. Programabilni krmilniki ......................................................................................................... 5
2.1 Programabilni logični krmilniki ........................................................................................ 5
2.1.1 Standard IEC 61131-3 ............................................................................................... 6
2.2 Okolje Arduino ................................................................................................................. 7
2.2.1 Strojna modularnost, programiranje in moţnost izbire ............................................. 7
2.2.4 Program v okolju Arduino ........................................................................................ 9
3. Krmilnik – strojni del ........................................................................................................... 10
3.1 Razvojno okolje .............................................................................................................. 10
3.2. Opis ................................................................................................................................ 11
3.3 Napajanje ........................................................................................................................ 12
3.4 Mikrokontroler ................................................................................................................ 12
3.5 Vezje PLK ....................................................................................................................... 14
3.6 Komunikacija .................................................................................................................. 14
3.7 Vhodi in izhodi ............................................................................................................... 15
4. Krmilnik – programski del ................................................................................................... 17
4.1 Čas .................................................................................................................................. 18
4.2 Podatkovni bloki in registri ............................................................................................. 19
4.3 Komunikacija in preprost protokol ................................................................................. 20
4.4 Krmilni program ............................................................................................................. 23
5. Razvojno okolje ................................................................................................................... 24
5.1 Programski jezik – podajanje programa ......................................................................... 25
5.2 Generiranje izvorne kode ............................................................................................... 27
5.3 Realizacija programskih gradnikov ................................................................................ 29
5.4 Prevajanje in krmilni program ........................................................................................ 34
5.5 Integrirano razvojno okolje ............................................................................................ 36
5.6 Knjiţnica za dostop do podatkov v krmilniku................................................................ 40
6. Primer uporabe – krmiljenje ogrevanja ................................................................................ 41
6.1 Vhodno / izhodna konfiguracija ..................................................................................... 41
6.2 Krmilni program ............................................................................................................. 44
6.3 Program za oddaljeno spremljanje in nadzor ................................................................. 46
7. Sklep ..................................................................................................................................... 48
Dodatek A ................................................................................................................................. 49
Analiza kode programskega nadzornika s programom USC CodeCount ............................ 49
Dodatek B ................................................................................................................................. 50
Primerjava uporabe mikrokontrolerjevih virov pri različnih parametrih ............................. 50
Dodatek C ................................................................................................................................. 52
Fotografija prototipa krmilnika v osnovni konfiguraciji ...................................................... 52
Shema vezja krmilnika ......................................................................................................... 53
Dodatek D ................................................................................................................................. 55
Podatkovni list temperaturnega senzorja Conrad C-Control I ............................................. 55
Dodatek E ................................................................................................................................. 56
Vsebina priloţene zgoščenke ............................................................................................... 56
Seznam slik in tabel .................................................................................................................. 57
Seznam slik........................................................................................................................... 57
Seznam tabel......................................................................................................................... 59
Viri ............................................................................................................................................ 60
Seznam uporabljenih kratic in simbolov
ARM Druţina 32-bitnih mikrokontrolerjev podjetja ARM
AVR Druţina 8-bitnih mikrokontrolerjev proizvajalca Atmel
DCE Digital Control Equipment (določa tip priklopa na serijski kabel)
FCB Function Block Diagram (funkcijsko-bločni diagram) - grafični programski
jezik, ki ga določa standard IEC 61131-3
MAX232 Integrirano vezje za pretvorbo nivojev TTL v RS232 in obratno
IEC 61131-3 Tretji del standarda za PLK krmilnike, ki določa programske jezike
I2C Inter-Integrated Circuit (tudi I2C) - uveljavljen vmesnik za povezovanje
mikrokontrolerjev z ostalimi komponentami, prvotno razvit pri podjetju Philips
PIC Druţina 8 in 16 bitnih mikrokontrolerjev proizvajalca Microchip Technology
PLK Programabilni logični krmilnik (angl. programmable logic controller, PLC)
RS232 Razširjen standard za serijsko komunikacijo med dvema napravama
RS485 Standard za komunikacijo med več napravami, pogosto uporabljen za
povezovanje naprav pri industrijskem krmiljenju
SPI Serial Peripheral Interface (serijski periferni vmesnik) - uveljavljen vmesnik za
povezovanje mikrokontrolerjev z ostalimi komponentami, prvotno razvit pri
podjetju Motorola
ST Structured Text - programski jezik, ki ga določa standard IEC 61131-3
UART Universal Asynchronous Receiver/Transmitter (splošni asinhroni
oddajnik/sprejemnik) – vmesnik za povezovanje, ki pretvarja paralelno podane
podatke v serijsko podane in obratno
Krmilnik Naprava, sestavljena iz elektronskih komponent, ki jo je mogoče
programirati in omogoča samostojno krmiljenje zunanjih naprav
Krmilni diagram Krmilni program v grafični obliki
Mikrokontroler Specializirano mikroprocesorsko integrirano vezje, ki vsebuje
tudi periferne naprave (angl. microcontroller, MCU) -
mikrokrmilnik
Modbus Serijski protokol za povezovanje industrijskih elektronskih
naprav
Programski nadzornik Preprost operacijski sistem predstavljenega krmilnika
Terminal Grafični programski gradnik, ki nima izhodov
1
Povzetek
Programabilni logični krmilniki (PLK) obvladujejo področje industrijske avtomatike ţe več
kot štirideset let. Kot preizkušene rešitve si še naprej utirajo pot v naš vsakdanjik kot del
sistemov za krmiljenje procesov, nadzor luči in prezračevanja v zgradbah idr. Hkrati s tem
postajajo mikrokontrolerski sistemi in mikrokontrolerska razvojna orodja vedno bolj
dostopna ljubiteljem. Zato ne preseneča, da postaja premagovanje vrzeli med tema dvema
pristopoma vedno bolj priljubljen izziv med računalniškimi in elektrotehniškimi
zanesenjaki.
V tej nalogi je opisana zasnova in razvoj preprostega PLK krmilnika na osnovi
mikrokontrolerja AVR ter preprostega razvojnega okolja na računalniku PC, ki je bil hkrati
razvit za ta krmilnik. Najprej so na kratko predstavljene osnove PLK krmilnikov in
poudarjene nekatere podobnosti s priljubljenim mikrokontrolerskim razvojnim okoljem
Arduino. Predstavljena je tudi osnovna zamisel realizacije PLK krmilnika znotraj tega
okolja. V glavnem delu je predstavljena strojna realizacija krmilnika in implementacija
programskega nadzornika ter predstavitev razvojnega okolja in implementacije grafičnega
jezika, ki ga podpira. Na koncu je prikazana uporaba krmilnika na poenostavljenem
vsakdanjem primeru krmiljenja ogrevanja stavbe in vzdrţevanja ţelene temperature v
prostoru.
Ključne besede:
programabilni logični krmilnik, industrijski krmilnik, odprtokodni krmilnik, arduino
2
Abstract
Programmable logic controllers (PLC) have been dominating the industrial automation and
control area for about fourty years. As a proven concept, they continue to strenghten their
silent presence in our everyday lives as parts of machine control, lights and ventilation
controlling systems in buildings, etc. At the same time, microcontroller systems and
development boards are becoming more and more available to the hobbyists nowadays. It's
no suprise that leaping the gap between these concepts is increasingly becoming an
appealing challenge for computer and electrical enthusiasts.
In this thesis, we describe a design and development of a simple AVR-based PLC and a
simple PC-based development environment that has also been developed for it. We start
with a brief introduction of PLC basics and expose similarities with the popular computing
platform Arduino. We also suggest a possible idea for a PLC realization inside the Arduino
concept. In the main part, we discuss the hardware part and firmware implementation,
followed by the discussion of the development environment for this controller and the
implementation of the graphical language it supports. At the end, we present an application
of the controller on a simplified real-life example of controlling the heating of a building
and maintaining the desired temperature in a room.
Keywords:
programmable logic controllers, industrial controllers, opensource controller, arduino
3
1. Uvod
Programabilni logični krmilniki (PLK) so ţe dobrih štirideset let prisotni pri krmiljenju
industrijskih procesov v taki ali drugačni obliki. Zaradi svoje univerzalnosti in prilagodljive
zasnove so se uveljavili tudi na področju nadzora in krmiljenja stavb, strojev in poslopij
(klimatske naprave, zračenje, osvetlitev), v kmetijstvu (npr. nadzor rastlinjakov) in na
podobnih področjih. Ponujajo zanesljivo, preizkušeno ter prilagodljivo rešitev. Ustrezajo
strogim zahtevam po varnosti, ki jih predpisujejo standardi za industrijsko uporabo ter s
seboj prinašajo ustrezno jamstvo proizvajalca. So končni produkt, ki je na voljo, je
preizkušen in ga je z dodajanjem in kombiniranjem zdruţljivih modulov za različne naloge
moč uporabiti takoj za večino problemov krmiljenja.
Po drugi strani pa postajajo mikrokontrolerska razvojna orodja, ki ponujajo svoj pristop do
gradnje rešitev krmiljenja, vedno bolj prisotna in dostopna tudi ljubiteljskim razvijalcem.
Nekatera razvojna okolja se po svoje pribliţujejo modularni zasnovi logičnih krmilnikov z
uvajanjem koncepta ţe sestavljenih in zaključenih modulskih »blokov«, ki jih je moč
sestavljati, kombinirati in dodajati k vezju po potrebi in tako omogočajo enostavno
eksperimentiranje in hiter razvoj krmilnih in drugih sistemov. To v nekaterih primerih še
vzpodbuja odprtokodna zasnova teh okolij, ki snovalcu-uporabniku pri razvoju in uporabi
ne postavlja omejitev. Navkljub podobnostim in določenem prekrivanju ciljnih področij
uporabe, pa ostajajo med programabilnimi logičnimi krmilniki in klasičnimi
mikrokontrolerskimi (krmilnimi) sistemi ključne razlike, ki se kaţejo tako v načinu
delovanja, rokovanja, programiranja kot konfiguracije in izgradnje končne aplikacije.
Premoščanje tega prepada je postal izziv za zanesenjake najbrţ ţe prvi dan, ko so
mikroprocesorska razvojna okolja postala dostopna navadnim ljudem. Še pred nekaj leti je
tipični domači »programabilni logični krmilnik« povečini pomenil zgolj neke vrste
mikroprocesorski sistem z dodanim vhodnim vezjem in relejskimi izhodi. Danes postajajo
tovrstni hobi projekti, ki jih je moč zaslediti v specializiranih revijah ali na internetu, vedno
bolj kompleksni in se skušajo vedno bolj pribliţati pravim krmilnikom.
Seveda se poraja vprašanje koliko je smiselno razvijati nekaj, kar je ţe razvito, preizkušeno
in (vsaj v niţjem zmogljivostnem razredu) na voljo relativno poceni – in je na koncu najbrţ
precej cenejša rešitev kot so sami stroški razvoja primerljive, običajno pa celo manj
zmogljive rešitve. Vendar komercialni vidik običajno ni glavno vodilo pri hobi projektih.
Odprtokodni programabilni logični krmilnik lahko (npr. v povezavi s kakšnim modularnim
razvojnim okoljem) predstavlja osnovo za učenje, nove izdelke, »domače« poceni rešitve
določenih nekritičnih nalog v hišni avtomatizaciji, avtomatizaciji rastlinjakov ipd. V tem
okviru pa tudi ovrţe očitek o odkrivanju vode na novo.
Odprtokodne programabilne logične krmilnike danes srečamo predvsem v obliki projektov,
ki skušajo realizirati funkcionalnosti krmilnikov v obliki posebne programske opreme, ki se
izvaja na računalnikih PC. Zamisli o realizaciji v klasični, strojni obliki so bistveno
redkejše. Prave strojne izvedbe, ki bi bila vsaj po osnovnih lastnostih primerljiva s
komercialnimi različicami, pa praktično ni. V nasprotju s tem pa nekatere programske
odprtokodne izvedbe dosegajo zavidljivo raven in ţe postajajo zrele za praktično uporabo v
proizvodnem okolju.
4
Programabilni logični krmilnik je pojem, ki zajema in zahteva več kot zgolj nekaj
elektronike z vhodi in izhodi, na katere lahko priključimo naprave, in mikrokontrolerski
program, ki to krmili. Je pojem, ki opisuje celotno rokovanje s tako »elektroniko«.
Programabilni logični krmilnik je naprava, od katere se pričakuje določen način delovanja,
programiranja, povezovanja, razširitev in samega upravljanja. To so zahteve, ki zajemajo
precej več kot zgolj ustrezno delovanje elektronike. Tipični nekomercialni strojni »PLK
krmilnik«, ki ga srečamo danes, redko ustreza delovanju komercialnih izvedenk ţe na
nivoju elektronike. Popolnoma pa odpove na področju povezovanja, programiranja in
programske opreme za rokovanje.
Bistveno več napredka so v tem ponovno dosegli odprtokodni programski (t.i. »mehki«)
krmilniki. Največ med njimi pa projekt Beremiz [18], ki je razvil in zdruţil v celoto
popolno razvojno okolje, ki ustreza obstoječim industrijskim standardom. Zato se ţe takoj
poraja ideja o uporabi in prenosu tega okolja na nivo morebitne strojne izvedenke krmilnika.
Na koncu se naloga zoţi na implementacijo ustreznega prevajalnika za standardna besedilna
jezika IL in ST, ki bi generiral ustrezno kodo, ki bi jo krmilnik lahko izvajal oziroma bi se
naprej prevedla v tako obliko z uporabo standardnih prevajalnikov. Projekt Beremiz ţe
vsebuje prevajalnik, ki kodo v omenjenih jezikih pretvori v kodo v jeziku C, ta pa se potem
izvaja v povezavi s programskim jedrom njihovega krmilnika. Zato projekt predstavlja
smiselno iztočnico za raziskovanja v tej smeri.
Drugi projekt, ki ga je vredno spremljati, je projekt Proview [20]. Njegovo okolje je
zgrajeno okoli grafičnega jezika Grafcet, podpira pa tudi programiranje v nekaterih
klasičnih programskih jezikih. Na domači strani projekta navajajo uspešen primer uporabe
njihovega projekta v obseţnejšem industrijskem procesu pri predelavi jekla v švedskem
podjetju SSAB Oxelösund.
Ostali projekti, ki se nanašajo tudi na strojne izvedenke, so npr. LDmicro [19] – urejevalnik
lestvičnih diagramov in prevajalnik, ki generira strojno kodo za procesorje AVR in nekateri
podobni, ki so vredni ogleda, vendar pa nam zaradi izbire programskega jezika, preprostosti
ali drugih podrobnosti, pri doseganju zastavljenih ciljev te naloge niso pretirano v pomoč.
Zanimiva je zamisel o vtičnem povezovanju več mikrokontrolerskih ploščic Arduino prek
vodila I2C, pri čimer bi lahko vsaka ploščica opravljala svojo nalogo, podobno kot je to pri
razširljivih PLK krmilnikih. Zamisel je opisana v [6].
Iz vidika snovanja strojnega krmilnika je zanimiv starejši članek [2], objavljen v reviji
Elektor Electronics, ki opisuje gradnjo preprostega mikrokontrolerskega sistema, ki se skuša
po delovanju in načinu izvajanja programa pribliţati pravim programabilnim logičnim
krmilnikom. Po tej zasnovi se bomo tudi močno zgledovali v nadaljnjem delu. Potrebna bo
prilagoditev sodobnejšemu mikrokontrolerju, dodane moţnosti komunikacije,
implementacija nadzornega programa v jeziku Arduino, programska realizacija
komunikacije, merjenja in nastavljanja časa ipd.
Nastali krmilnik bom poskušal tudi prikazati in predstaviti s preprostim realnim primerom
uporabe.
5
2. Programabilni krmilniki
2.1 Programabilni logični krmilniki
Programabilni logični krmilniki (PLK) so posebna zvrst mikroračunalnikov, ki so
prilagojeni za krmiljenje strojev v proizvodnih procesih. Njihova osnovna značilnost je
večje število vhodov in izhodov, prek katerih je krmilnik priklopljen na senzorje ter
naprave, ki jih krmili. So tipični primer realnočasovnih (angl. real-time) sistemov, saj mora
biti zakasnitev v odzivu izhodov glede na spremembe vhodov manjša od nekega določenega
(majhnega) časa.
Krmilna koda (program) se v krmilniku izvaja znotraj krmilnega cikla (angl. scan cycle). V
takem ciklu krmilnik najprej prebere stanje na vhodih in to shrani v vhodne registre. Nato
izvede krmilni program, ki je v resnici le koda, ki na podlagi vrednosti vhodnih registrov
določi stanje izhodnih registrov. Na koncu krmilnik prepiše stanje izhodnih registrov na
izhode. Ta postopek se izvaja v neskončni zanki in se ne konča, dokler ne pride do izpada
napajanja, napake ali pa programer (v postopku razvoja) tega eksplicitno ne zahteva.
Tovrstno izvajanje prinaša tudi nekatere nevarnosti: če pride na vhodu do sprememb v času,
ki je manjši od odzivnega časa krmilnika (vsota vseh časov, ki so potrebni za prepisovanje
vhodov in izhodov, izvedbo sprotnih rutin, ki jih zahteva delovanje krmilnika ter za
izvajanje krmilne kode), se zgodi da krmilnik teh sprememb ne zazna. Zato imajo krmilniki
vgrajene dodatne mehanizme, ki spremembe zaznavajo tudi v tem vmesnem času, pogosto
pa podpirajo tudi moţnost delovanja s pomočjo prekinitev.
Slika 1. Program v programabilnem logičnem krmilniku.
Očitna razlika med delovanjem logičnega krmilnika in običajnimi računalniki je v
pojmovanju programa. Krmilni program v programabilnem logičnem krmilniku je zgolj
krmilna koda v obliki funkcije, ki se kliče na določenem mestu znotraj izvajalnega cikla
(slika 1).
6
Najbolj tipična oblika podajanja krmilne kode je t.i. lestvični diagram (angl. ladder
diagram). Uporablja se predvsem v ZDA. Izhaja neposredno iz postopka vezave relejev, ki
so jih za krmiljenje uporabljali v preteklosti. Lestvični diagrami ostajajo priljubljeni, ker je
tovrstno grafično podajanje kode blizu elektroinţenirjem, v katerih domeni večinoma ostaja
snovanje krmilja strojev (več o tem načinu podajanja programov je moč prebrati v [10]).
Proizvajalci ponujajo tudi druge načine podajanja krmilne kode. Pristopi in tako nastala
krmilna koda med krmilniki in orodji različnih proizvajalcev običajno niso zdruţljivi. Več o
PLK krmilnikih je mogoče prebrati v [14].
2.1.1 Standard IEC 61131-3
Potreba uporabnikov po laţjem prehajanju med produkti različnih proizvajalcev, pa tudi
uveljavljanje novih trendov, ki vedno bolj vplivajo tudi na trţišče programabilnih
krmilnikov (prihajajo predvsem iz sveta PC računalnikov: poceni in vedno večji pomnilniki,
uveljavljanje novih načinov komunikacije, močnejši procesorji, cenejši, kompaktnejši in
zanesljivejši PC sistemi...) ter zasnova obstoječih krmilnikov, ki postaja vedno bolj
zastarela, so botrovali nastanku standarda IEC 61131-3. Ta predvideva in definira pet
načinov podajanja krmilne kode, ki so podani v tabeli 1. Več o tem je mogoče najti v [4,
13].
Tabela 1. Pet načinov predstavitve krmilnega programa po standardu IEC 61131-3.
V predstavitvi programa in krmilnika stori standard IEC 61131-3 korak naprej: Najširša
enota predstavitve je konfiguracija. Ta zdruţuje celotno krmilno kodo in informacijo o
tem, kako in kje naj se koda izvaja. Druga enota je vir (resource). Vir je lahko karkoli, kar
je zmoţno izvajati krmilni program. Pri današnjih krmilnikih je to dejansko krmilnik sam
(oziroma njegova procesorska enota). Lahko pa bi bil tudi npr. eno jedro v večjedrnem
procesorju ali pa program na računalniku PC, ki zna izvajati krmilno kodo. Znotraj vira so
definirana opravila. Opravilo (task) je enota, ki vsebuje informacijo o tem kako (npr. v
kakem časovnem intervalu) ali kdaj (ob kakšnem dogodku) naj se nek program izvede.
Program je glavna enota programske kode. Je na nek način kot funkcija v klasičnih
programskih jezikih, ki se kliče, ko je v ustreznem opravilu določen pogoj izpolnjen.
Konfiguracija lahko vsebuje več virov. Ravno tako se lahko na istem viru izvaja več opravil
7
(torej programov). Klasični krmilnik z eno procesorsko enoto si lahko v najosnovnejši
obliki predstavljamo kot en vir, eno opravilo in en program (ki se kliče v fiksnem
časovnem intervalu). Konfiguracija je torej najširša enota, ki opisuje krmilno aplikacijo.
2.2 Okolje Arduino
Arduino [11] je ljubiteljska strojno-razvojna platforma, ki omogoča enostavno raziskovanje
in gradnjo mikrokontrolerskih in vgradnih (angl. embedded) aplikacij. Strojno temelji na
Atmelovi druţini mikrokontrolerjev AVR, za programiranje pa ponuja svojo izpeljanko
jezika C++. Jezik, ki ga ponuja, je razširjen s knjiţnjicami in sintakso, ki programiranje
poenostavijo in pribliţajo začetniku. Ob tem pa so sintaktična razhajanja z jezikom C++ (in
v večji meri tudi z jezikom C) minimalna, kar omogoča relativno enostaven prenos
obstoječe kode v program ali morebiten kasnejši prenos v bolj standardno okolje. Prevajanje
programov se izvaja s pomočjo prevajalnika GNU C++ za druţino mikrokontrolerjev AVR
v dveh korakih, preko minimalno spremenjene vmesne kode (slika 2).
Slika 2. Program v jeziku Arduino po “prevajanju” v C++.
V nadalje bomo uporabljali pojma jezik Arduino in C++ precej enakovredno, čeprav to iz
tehničnega vidika mogoče ni vedno ustrezno. Gre namreč za veljavno programiranje v
jeziku C++, vendar so pristopi in »konvencije« včasih malo drugačni.
2.2.1 Strojna modularnost, programiranje in možnost izbire
Strojno je platforma zasnovana modularno, pri čemer uporabnik razširja in dopolnjuje
sistem z »rezinami« (oziroma »ščiti« - angl. shields), ki jih do neke mere lahko tudi niza in
8
kombinira med seboj. Pri različnih proizvajalcih je na voljo mnoţica ţe izdelanih rezin,
denimo s komponentami in vezji za brezţično komunikacijo bluetooth ali XBee, ţični
ethernet, z vgrajenim LCD zaslonom, relejskimi izhodi, vhodi idr. skupaj s pripadajočimi
knjiţnicami, ki močno poenostavijo uporabo in programiranje. Uporabnik lahko rezine
snuje tudi sam, bodisi z izdelavo v obliki tiskanih vezij ali pa z uporabo posebnih rezin s
prototipnim prostorom, prilagojenim za spajkanje. Mogoče pa je tudi hitro
eksperimentiranje in razvoj prototipov v kombinaciji s klasično vtično prototipno ploščo
(angl. breadboard) ali neposredno na ploščici. Platforma Arduino presega klasične
mikrokontrolerske razvojne plošče tudi v tem, da je po končanem razvoju ustrezno
konfiguriran sistem mogoče takoj vgraditi v končni izdelek. Ob uporabi in kombiniranju ţe
izdelanih rezin, ki so na voljo, se je tako v nekaterih primerih mogoče povsem izogniti
razvoju elektronike in tiskanih vezij, kar je privlačno predvsem pri izdelkih z majhnimi
serijami.
Programiranje mikrokontrolerja se vrši neposredno na ploščici prek navadnega USB kabla
(v starejših izpeljankah prek serijske povezave), ki ga priključimo na ploščico. Prek te
povezave je mogoča tudi komunikacija z računalnikom brez dodatnih komponent. Skupaj s
»prevajalnikom« za prilagojen jezik in razvojnim okoljem, predstavlja platforma Arduino
zaključeno celoto za razvoj mikrokontrolerskih aplikacij, ki omogočajo preprost in
eleganten razvoj. To dejstvo pa ne izključuje moţnosti uporabe drugih jezikov,
prevajalnikov in orodij, ki podpirajo mikrokontrolerje AVR.
Odprtokodna zasnova platforme, ki velja tako za strojni kot programski del, je omogočila
nastanek cele mnoţice zdruţljivih in izpeljanih izdelkov drugih proizvajalcev ter številnih
zanesenjakov. Skupna točka teh »klonov« je bodisi strojna zdruţljivost z razširitvenimi
rezinami, bodisi podpora za Arduino programski jezik in razvojno okolje ali pa celo popolna
zdruţljivost na obeh nivojih. Nekatere izpeljanke popeljejo platformo na popolnoma drug
nivo z uporabo močnejših mikrokontrolerjev ali mikrokontrolerjev iz drugih druţin (denimo
mikrokontrolerji ARM Cortex M3, PIC...), z izbiro drugega formata (npr. pomanjšan format
večjega DIL čipa) ali pa s tem, da ţe na sami ploščici podpirajo dodatne moţnosti (npr.
realnočasovna ura) in so na ta način prilagojene za namenu, ki ga je imel proizvajalec v
mislih.
9
2.2.4 Program v okolju Arduino
Potek izvajanja programa v okolju Arduino prikazuje slika 3. Ţe takoj je opazna podobnost
z izvajanjem programa v klasičnem programabilnem logičnem krmilniku (slika 1). Funkcija
void loop() po namenu in načinu izvajanja ustreza krmilni kodi logičnega krmilnika.
Slika 3. Program v okolju Arduino in način izvajanja.
Na podlagi te podobnosti se porodi zamisel realizacije funkcionalnosti programabilnih
logičnih krmilnikov v okolju Arduino, ki jo prikazuje slika 4.
Slika 4. Realizacija koncepta PLK v okolju Arduino.
10
3. Krmilnik – strojni del
3.1 Razvojno okolje
AT90USB646 je 8-bitni RISC mikrokontroler iz druţine AVR, proizvajalca Atmel. Ima
integriran vmesnik USB, ki omogoča neposreden priklop na vodilo USB in lahko prevzame
vlogo katerekoli USB naprave. Podpira moţnost t.i. zagonskih nalagalnikov (angl.
bootloaders), s pomočjo katerih lahko programiramo čip neposredno prek vodila USB. Ta
moţnost je tudi uporabljena v tem projektu za programiranje krmilnika. Osnovni podatki o
čipu so prikazani v tabeli 2. Več o mikrokontrolerju je mogoče prebrati v [5].
Tabela 2. Specifikacija mikrokontrolerja.
Za razvoj projekta je bila izbrana razvojna ploščica Teensy++ [21] (slika 5), ki je po
formatu podobna ploščicama Arduino Nano ter Arduino Pro Mini (več v [22]), od njiju se
loči po zmogljivejšem mikrokontrolerju, več vhodno/izhodnih noţicah in tem, da je
sestavljena zgolj iz čipa in pasivnih komponent, ki so nujne za njegovo delovanje. Je
samostojna enota, ki jo lahko ţe takoj pričnemo programirati in povezovati z drugimi
elementi. Preprostost ploščice odpravlja zahteve po dodatnih prilagoditvah pri morebitni
izdelavi krmilnika v posebnem tiskanem vezju.
Slika 5. Razvojna ploščica Teensy++ (slika vzeta iz proizvajalčeve domače strani).
V ploščici je tovarniško naloţen zagonski nalagalnik HalfKay, ki (kot ţe ime namiguje)
zasede samo polovico bajta v programskem pomnilniku čipa. V povezavi z njim deluje
odprtokodni programček za prenos kode teensy_cli, ki je na voljo za operacijski sistem
Linux. Sam zagonski nalagalnik v čipu je licenčno lastniške (angl. proprietary) narave,
vendar ga je mogoče nadomestiti z odprtokodno različico. Moţna pa je tudi uporaba
nalagalnikov, ki podpirajo protokole drugih programov za prenos. Za ploščico je na voljo
prilagojeno razvojno okolje Arduino [12], skupaj z večino prilagojenih osnovnih
11
programskih knjiţnic tega okolja. Izbira jezika in knjiţnic Arduino odpira vrata ideji
morebitne uporabe programske kode in realizacije krmilnika v obliki rezine na klasičnih
razvojnih ploščicah Arduino.
3.2. Opis
Strojna zasnova krmilnika izhaja iz zasnove programabilnega krmilnika na osnovi
mikrokontrolerja Intel 8052, objavljene v reviji Elektor Electronics [2]. Ta je bila
prilagojena mikrokontrolerju AT90USB646 in načinu programiranja prek USB vodila,
dodano je bilo vezje za serijsko komunikacijo z računalnikom, dodatna signalna dioda in
nekatere druge podrobnosti.
Programska oprema, ki nadzoruje krmilnik in izvajanje krmilnega programa ter zagotavlja
podlago za pisanje in integriranje krmilnih programov, je rezultat dela te naloge in je
napisana v programskem okolju Arduino za mikrokontroler AT90USB646.
Krmilnik je sestavljen iz treh funkcionalno ločenih vezij ter vezja z vhodi in izhodi (slika 6).
Vezje z vhodi in izhodi je po sami funkciji „zunanji“ modul, ki se lahko razlikuje,
kombinira in zamenja glede na potrebo in zahteve krmiljenja. Ostala tri vezja skupaj
sestavljajo celoto, ki funkcionalno ustreza krmilniku in je osnovni modul fizične
konfiguracije, ki ostaja vseskozi enak. Celotna shema vezja krmilnika je podana v dodatku
C.
Slika 6. Shematski prikaz krmilnika.
12
3.3 Napajanje
Vezje za napajanje (slika 7) skrbi za pretvorbo izmeničnega napajanja 220V v stabilno
enosmerno napajanje 5V. Poleg tega priskrbi še dodaten signal (PSSig), preko katerega v
mikrokontrolerju zaznavamo motnje v napajanju in nam omogoča da predvidimo izpad
napajanja in izvedemo poljubno (kratko) programsko rutino, še preden krmilnik preneha
delovati.
Slika 7. Vezje za napajanje (shema povzeta po [2]).
3.4 Mikrokontroler
Pet noţic (od C3 do C7) mikrokontrolerja AT90USB646 je porabljenih za povezavo z
vezjem PLK. Od tega so tri konfigurirane kot vhodi, dve pa kot izhoda (tabela 3).
Tabela 3. Uporaba nožic mikrokontrolerja in opis funkcij, ki jo jim določene.
Ena dodatna noţica (E6) je uporabljena za realizacijo funkcije RESET, ki resetira
mikrokontroler. Noţica je konfigurirana kot vhod, ki ob spremembi v visoko stanje sproţi
prekinitev, pripadajoč prekinitveni servisni program pa resetira čip z aktiviranjem čuvaja
(angl. watchdog) in nastavitvijo minimalnega moţnega časa odštevanja. Ta pristop je bil
izbran zaradi specifik Teensy++ razvojne ploščice in zagonskega nalagalnika, ki ga
13
uporablja čip. Signal na vhodu RESET, ki je dostopen na ploščici, namreč po resetiranju čipa
zaţene zagonski nalagalnik in ga postavi v stanje pripravljenosti. To pa za nadaljevanje
zahteva sodelovanje razvojne programske opreme na PC računalniku, kar ne ustreza
ţelenemu vedenju funkcije RESET krmilnika.
Slika 8. Uporaba nožic mikrokontrolerja.
Slika 8 prikazuje celotno vezavo noţic mikrokontrolerja. Noţica C6, prek katere se vrši
nastavljanje pomnilne celice RS, ki hrani podatek o vrsti zagona krmilnika, ter vklop/izklop
izhodnih modulov, je na pomnilno celico vezana prek inverterja. Na ta način stanje LOW na
noţicah mikrokontrolerja AT90USB646, ki se privzeto pojavi ob zagonu ali resetu, ne pokvari
vsebine pomnilne celice.
Dve noţici (D2 kot RX in D3 kot TX) sta porabljeni za serijsko komunikacijo in ju krmili
strojni UART vmesnik, ki ga vsebuje čip.
Tri noţice (F0, F1 in F2) so uporabljene za priklop dveh vhodnih in enega izhodnega
modula.
Noţici D0 (SCL) in D1 (SDA) sta prosti in na voljo za povezovanje prek vmesnika TWI (I2C).
Noţice B1 (SCLK), B2 (MOSI) in B3 (MISO) so proste in na voljo za povezovanje prek
vmesnika SPI.
Povezava na USB povezovalni kabel do računalnika za programiranje in komunikacijo prek
navideznega COM vmesnika poteka prek v čip vgrajenega vmesnika USB in nanj
priklopljenega konektorja USB MINI-B.
14
3.5 Vezje PLK
To vezje (slika 9) omogoča mikrokontrolerju da se navzven vede kot klasični programabilni
logični krmilnik. Osrednja značilnost je pomnilna celica RS (flip-flop), ki hrani stanje
krmilnika pred resetiranjem. Preprosta »operacijska« programska oprema krmilnika
(programski nadzornik) na podlagi stanja te pomnilne celice ob zagonu ugotovi ali je šlo za
»trdi« ali »mehki« reset in temu ustrezno nadaljuje.
Slika 9. Vezje PLK (shema povzeta po [2]).
Vezje skrbi tudi za to, da med stanjema RESET in STOP vsi izhodi preidejo v izključeno
stanje (signal OE v nizko stanje). Zunanji nadzor izvajanja se vrši prek stikala STOP-RUN-
RESET in treh LED diod, ki prikazujejo stanje, v katerem se nahaja krmilnik. Dve diodi
(STOP, RUN) krmili samo vezje, tretjo (ERR/RESET) pa programski nadzornik neposredno
prek izhodne noţice ERRout (C3).
3.6 Komunikacija
Pretvorbo TTL nivojev, ki jih generira vmesnik UART mikrokontrolerja, v RS232 nivoje in
obratno vrši specializirano integrirano vezje MAX232, ki je kot naprava DCE (Digital
Control Equipment) priključeno na standardni RS232 konektor, kot kaţe slika 10.
15
Slika 10. Vezje za serijsko komunikacijo RS232.
.
Alternativno je na voljo tudi navidezni COM vmesnik prek povezave USB, ki ga ob ustrezni
konfiguraciji vzpostavi programska oprema v mikrokontrolerju.
3.7 Vhodi in izhodi
Za povezovanje z vhodno/izhodnimi moduli sta na voljo vodili SPI in I2C ter preostale
vhodno/izhodne noţice krmilnika (osem noţic je v krmilniku uporabljenih za povezavo s
PLK vezjem ter vmesnik RS232). Ob uporabi vmesnikov SPI in I2C se število noţic, ki so
na voljo za neposredno povezovanje, ustrezno zmanjša.
Krmilnik v konfiguraciji, ki jo opisuje ta projekt, ima dodani dve digitalni vhodni in eno
digitalno izhodno vezje. Vhodi in izhodi so galvansko ločeni, zaščiteni pred prenapetostjo,
napetostnimi špicami in zamenjavo polaritete. Proţeni so z enosmerno napetostjo 24V.
Vhod sporoča stanje preko signala, ki je vezan neposredno na vhodno noţico
mikrokontrolerja. Ko je na vhodni strani vezja visoko stanje, je tudi TTL signal v visokem
stanju. Vezje prikazuje slika 11.
16
Slika 11. Krmilnikov vhod (slika povzeta po [2]).
Izhodno vezje (slika 12) je prek signala OE (omogoči izhode) povezano z vezjem PLK.
Krmiljenje poteka prek signala, ki je priključen na ustrezno izhodno noţico
mikrokontrolerja. Izhod modula se postavi v visoko stanje, ko je signal OE v visokem stanju
in krmilni TTL signal (vezan na noţico mikrokontrolerja) v nizkem stanju.
Slika 12. Izhod krmilnika (slika povzeta po [2]).
Na krmilnik je na ta način mogoče priključiti skupno do 38 vhodnih oziroma izhodnih vezij
(mikrokontrolerjeva vrata A, B, F, pet prostih noţic vrat D, šest prostih noţic vrat E ter tri
proste noţice vrat C).
17
4. Krmilnik – programski del
Slika 13. Prikaz delovanja krmilnika. Z rdečimi puščicami je ponazorjen krmilnikov izvajalni cikel.
Diagram na sliki 13 prikazuje delovanje krmilnika. Ob izvajanju prvega cikla nadzorna
programska oprema (programski nadzornik) najprej preveri stanje pomnilne celice na vhodu
18
FFIN. V primeru, da je ta v nizkem stanju, torej je predhodno prišlo do t.i. »trdega reseta«
(normalni zagon), takoj začne prvi cikel.
V nasprotnem primeru je prišlo do »mehkega reseta«, ki ga je sproţil čuvaj (angl.
watchdog) po preteku dovoljenega časa za izvajanje krmilnega programa. To je stanje
napake, ki ga signalizira priţgana rumena LED dioda, iz njega pa je mogoče izstopiti zgolj
s premikom stikala STOP-RUN-RESET v pozicijo STOP.
Izvajanje se vrši v neskončni zanki. Sleherni cikel se začne zgolj, ko je stikalo STOP-RUN-
RESET v poziciji RUN in je signal stabilnosti napajanja, ki ga zagotavlja napajalnik, v
visokem stanju (torej signal na vhodu VOLTAGEIN v nizkem). V nasprotnem primeru
krmilnik »stoji« in čaka, da so pogoji izpolnjeni.
4.1 Čas
Merjenje časa je realizirano (datoteka mPLK_time.pde) z uporabo knjiţnice MsTimer2 [8].
Gre za časovnik, ki ga nastavimo prek knjiţnice, prekinitveni servisni program pa vsakih
100 ms kliče funkcijo, ki aţurira krmilnikove časovne spremeljivke (slika 14).
Slika 14. Nastavitev časovnika.
Funkcija void mPLK_100MsPassed() aţurira globalne spremenljivke, ki hranijo vrednosti
trenutnega časa na način, ki ga prikazuje slika 15.
Slika 15. Izračunavanje časa po preteku 100ms.
Dostop do časa poteka z uporabo funkcij na sliki 16.
19
Slika 16. Funkcije za ravnanje s časom.
Čas teče samo, ko so v krmilniku izpolnjeni vsi pogoji za izvajanje programskega cikla (t.i.
»scan« cikla), sicer čas miruje.
4.2 Podatkovni bloki in registri
Izmenjava podatkov med zunanjim svetom in krmilnim programom je realizirana s pomočjo
podatkovnih blokov - posebne tabele spremenljivk, ki jih je mogoče brati in spreminjati iz
računalnika PC prek serijske povezave. Ti podatkovni bloki so implementirani v datoteki
mPLK_datablocks.pde na način kot je razvidno iz kode na sliki 17.
Slika 17. Implementacija podatkovnih blokov.
Konstanta MAX_DATA_BLOCKS določa število blokov. Biti mora ustrezno prilagojena
številu blokov, ki jih uporablja krmilni program.
Zaradi enostavnosti predstavitve so v nadzorniku implementirani samo podatkovni bloki
tipa int (podobno bi implementirali tudi hranjenje vrednosti ostalih podatkovnih tipov).
20
Na podoben način so v krmilniku realizirani tudi posebni »registri« dolţine enega bajta. V
opisani izvedbi je realiziran samo en register, t.i. sistemski register, ki v svojih bitih hrani
podatke o trenutnem stanju krmilnika. Te podatke lahko prek tega registra beremo iz
krmilnega programa na podoben način kot beremo podatkovne bloke. V realiziranem
sistemskem registru je bistven samo najniţji bit, ki je postavljen samo, ko krmilnik izvaja
cikel prvič (z detekcijo tega bita v krmilnem programu realiziramo npr. inicializacijo
spremenljivk).
4.3 Komunikacija in preprost protokol
Protokol temelji na abecedi ASCII. Je sinhrone narave (vsakemu zahtevku sledi pripadajoč
odgovor) in predpostavlja povezavo točka-v-točko, pri kateri je zunanja naprava (npr. PC)
gospodar, krmilnik pa suţenj. Ima zelo preprost in poenostavljen mehanizem za
ugotavljanje napak in sporov (ko prejeti podatki ne ustrezajo nobeni izmed predpisanih
oblik zahtev, jih krmilnik zavrţe, kot odgovor pa pošlje sporočilo o neznani zahtevi).
Protokol pozna tri vrste zahtev ter en poseben odgovor, ki so opisani v tabeli 4. Parametri
(naslov podatkovnega bloka, nova vsebina, vsebina bloka) – so podani kot niz sledečih si
znakov v abecedi ASCII, ki jim na koncu sledi poseben znak LOČILO. Za LOČILO je
rezerviran znak ' ' (presledek).
Tabela 4. Protokol za komunikacijo.
Zaradi enostavnosti so v krmilniku implementirani samo celoštevilski podatkovni bloki in
streţba tovrstnih zahtev prek serijske povezave. Števila se iz krmilnika prenašajo kot nizi
znakov.
Komunikacija je mogoča bodisi prek povezave RS232, bodisi prek USB kabla in
navideznega COM vmesnika, ki ga vzpostavi programska oprema v mikrokontrolerju.
21
Sistemske nastavitve komunikacije se nahajajo v datoteki SETUP.pde. Konstanta
SERIAL_COMMUNICATION_CYCLE določa, v katerem zaporednem ciklu naj se izvede
streţba trenutnega fragmenta prispele komunikacijske zahteve. S spreminjanjem te
konstante spreminjamo razmerje odzivnost komunikacije / odzivnost krmiljenja, s čimer
posledično vplivamo na delovanje krmilnika. Vrednost konstante npr. 100 bi pomenila
streţbo fragmenta obravnavane komunikacijske zahteve le v vsakem stotem ciklu.
Do serijskih vmesnikov dostopamo prek Arduino razredov Serial (prek USB) in Uart (prek
RS232). Izbiramo jih prek konstant SerialComm in SerialDebug (s prvo izberemo serijski
vmesnik, ki se bo uporabljal za komunikacijo, z drugo pa vmesnik za izpis sporočil za
spremljanje delovanja in razhroščevanje). Podajanje komunikacijskih parametrov je
prikazano na sliki 18.
Slika 18. Nastavitev komunikacijskih parametrov.
Uporabo vmesnikov (npr. ko ne potrebujemo razhroščevanja) onemogočimo (in sprostimo
mikrokontrolerjev ukazni pomnilnik) tako, da ustrezno definicijo konstante za izbiro
vmesnika zakomentiramo.
Serijska komunikacija je implementirana v datoteki mPLK_serial.pde. Trenutna zahteva se
hrani v treh spremenljivkah, ki jih glavna funkcija void communication_serveSerial()
posodablja sproti ob vsakem klicu glede na prispeli podatek na vmesniku (slika 19).
Slika 19. Spremenljivke, v katerih se hrani trenutno obravnavana zahteva.
Glavna komunikacijska funkcija void communication_serveSerial(), ki jo kliče sistemska
programska oprema (nadzornik), v vsakem N-tem zaporednem ciklu, kot je določeno v
nastavitvah, preveri če je na vmesniku na voljo podatek. Če je, ga zapiše v ustrezno
spremenljivko (kot ukaz ali parameter). Ta del kode je prikazan na sliki 20.
22
Slika 20. Prepoznavanje prispele komunikacijske zahteve.
Dolţina ukazov je vedno fiksna 1 bajt, zato z njimi ni teţav. Parametri pa prek serijskega
vmesnika prihajajo v obliki niza zaporednih ASCII znakov, zaključenih z bajtom
SERIAL_SEPARATOR. Pretvorba v celoštevilsko vrednost, primerno za zapis v
spremenljivki serial_param1 oziroma serial_param2, se zato vrši prek funkcij void
communication_addParam( int ) in int communication_computeParameter(). Prva prispele znake po
vrsti shranjuje v polje int serial_nbuffer[ SERIAL_NBUFFER_MAXSIZE ], druga pa iz niza
shranjenih znakov izračuna in vrne celoštevilsko vrednost, ki jo ti predstavljajo.
Funkcija communication_serveSerial() hkrati tudi implementira prepoznavanje in izvrševanje
prispelih serijskih zahtev. Ta del kode prikazuje slika 21.
23
Slika 21. Strežba prispelih zahtev.
4.4 Krmilni program
Krmilni program se nahaja v obliki dela kode na posebnem mestu v datoteki
mPLK_mainloop.pde (sem se med prevajanjem prepiše iz datoteke CONTROL.pde). Čas
izvajanja tega dela kode je omejen s konstanto v datoteki CONFIGURATION.pde:
#define WATCHDOG_TIME_PARAMETER WDTO_15MS
Ključna za pravilno delovanje krmilnika je hitra odzivnost na spremembe na vhodih in
ustrezno hitra reakcija s spremembami na izhodih. Zato čas izvajanja krmilnega cikla (in s
tem krmilnega programa) ne sme biti poljubno dolg. Z omejitvijo časa izvajanja se
izognemo tudi nepredvidljivostim v primeru, da se krmilni program zaradi napake ujame v
neskončno zanko. Po preteku maksimalnega časa mikrokontroler resetira krmilnik, izvajanje
pa nato prevzame programski nadzornik.
24
5. Razvojno okolje
Ena izmed zamisli pri snovanju razvojnega okolja je bila uporaba urejevalnika
PLCOpenEditor iz projekta Beremiz ter prilagoditev njihovega prevajalnika MatIEC, ki
tekstovno programsko kodo, ki jo na podlagi grafičnih gradnikov generira urejevalnik,
prevede v prilagojen program v jeziku C. Kot alternativa temu se je kazala moţnost uporabe
orodij, kot sta TXL ali platforma Coco/R (več o teh dveh orodij je moč najti v [1] in [3]), za
neposreden razvoj prevajalnika za pretvorbo generirane kode v jeziku ST v kodo v jeziku
Arduino. Na koncu sem se odločil za razvoj samostojnega programskega okolja, ki se
zgleduje po standardih, vendar je dovolj preprost, da ga je mogoče realizirati v časovnih
okvirih te naloge, hkrati pa tudi dovolj daljnoseţno zasnovan, da ga je mogoče kasneje
nadgrajevati.
Slika 22. Shematski prikaz zgradbe razvojnega okolja. Razviden je tok krmilnega programa od grafičnega urejanja
do prenosa v krmilnik.
25
Zgradbo okolja za razvoj krmilnih aplikacij prikazuje slika 22. Osnovni del, v katerem
uporabnik izrisuje krmilni algoritem in določa parametre (»razvojno okolje« v oţjem
smislu) je napisano v jeziku Java. Je orodje, s katerim programer upravlja celoten postopek
risanja, gradnje in prenosa programa v krmilnik. Najpomembnejša naloga tega dela je
generiranje ciljne kode programa v jeziku C++ na podlagi sheme gradnikov, ki jo sestavi
programer krmilnika. Prevajanje te kode, zdruţene s kodo programskega nadzornika, v
ozadju vrši prevajalnik GNU C++ za mikrokontrolerje AVR. Prenos programa v krmilnik
prek povezave USB se izvede s pomočjo odprtokodnega programa teensy_cli [16].
Postopek prevajanja in prenosa programa v krmilnik povezujejo skripte v lupini Bash.
Razvojno okolje deluje v operacijskem sistemu Linux.
V sklop razvojnega okolja sodi tudi preprosta knjiţnica v jeziku Java za dostop do
podatkovnih blokov krmilnika preko serijske povezave iz računalnika PC.
5.1 Programski jezik – podajanje programa
Programski jezik FBD (Function Block Diagram) je eden izmed petih programskih jezikov,
ki jih za programiranje PLK krmilnikov predvideva standard IEC 61131-3. Je grafični jezik,
v katerem pri programiranju sestavljamo programske gradnike v celoto. Predstavljeno
razvojno okolje se v grobem zgleduje po tem programskem jeziku in načinu programiranja,
ki ga ta prinaša.
Osredotočil sem se na dve osnovni programski enoti iz standarda IEC: funkcije in
funkcijske bloke. Funkcije ustrezajo funkcijam v klasičnih programskih jezikih. Funkcijski
bloki pa so neke vrste ekvivalenti razredom in objektom. Instance funkcijskih blokov (ter
vrednosti, ki jih hranijo) se ohranjajo skozi ves čas izvajanja programa. Tretji tip gradnikov
v predstavljenem okolju so spremenljivke. Te v obliki grafičnih gradnikov nastopajo bodisi
kot izvor ali ponor. Poseben razred gradnikov, ki vključuje tudi ponorni tip spremenljivk, so
terminali. To so končni elementi, ki nimajo izhodov. Gradnike, ki jih podpira razvojno
okolje, prikazuje tabela 5.
26
Tabela 5. Gradniki, ki jih podpira razvojno okolje.
Pri realizaciji spremenljivk sem se omejil na tri podatkovne tipe iz širšega nabora, ki ga
določa standard. To so najenostavnejši tipi, ki jih je mogoče neposredno preslikati v tipe
jezika Arduino. Predstavljeni so v tabeli 6, skupaj s podrobnostmi same implementacije.
Tabela 6. Realizacija podatkovnih tipov programskega jezika.
Spremenljivke se ločijo tudi po vrsti (tabela 7). Ta določa kako bo posamezna
spremenljivka deklarirana oziroma kakšen pomen bo v programu imela.
27
Tabela 7. Vrste spremenljivk in način njihove realizacije.
Direktne spremenljivke so posebna vrsta spremenljivk. To so spremenljivke prek katerih
dostopamo do vhodov, izhodov ali posebnih lokacij (npr. t.i. podatkovni bloki, ki jih
podpira predstavljeni krmilnik). Direktna spremenljivka v krmilnem programu je
predstavljena kot navadna spremenljivka vrste direct, ki ima določeno lokacijo. Z
dostopom do take spremenljivke dejansko dostopamo do lokacije. Primer poimenovanja
lokacij podaja tabela 8. Uporabniku so imena lokacij predstavljena z začetnim znakom %
(odstotek), npr. %I0.0.
Tabela 8. Primer poimenovanja lokacij krmilnika z razlago.
Standard pri poimenovanjih spremenljivk, funkcij, funkcijskih blokov ter ostalih
programskih elementov, predpisuje obliko, ki ne loči velikih in malih črk. Vsa imena se zato
pri prevajanju v C++ pretvorijo v obliko z majhnimi črkami, imena funkcijskih blokov
(razredov) pa v obliko z velikimi črkami.
5.2 Generiranje izvorne kode
Predstavitev in generiranje ciljne kode je implementirano z razredom FormattedCode v jeziku
Java. Ta razred omogoča sestavljanje formatirane izvorne kode, ki jo na koncu lahko
izvozimo kot niz. Metode razreda so opisane na sliki 23.
28
Slika 23. Programski vmesnik razreda za generiranje in predstavitev ciljne kode.
Gradnja celotne aplikacije je implementirana v razredu CodeGenerator s statično metodo void
generateCode(). Ta metoda ločeno generira deklaracije globalnih in lokalnih spremenljivk,
kodo za inicializacijo direktnih spremenljivk, kodo za preslikovanje vhodov/izhodov in
krmilno kodo ter vsako zapiše v ustrezno datoteko.
Generiranje kode iz grafične predstavitve krmilnega programa se vrši na način, da ima vsak
logični gradnik tipa LogicalPort oziroma LogicalTerminalBlock implementirano metodo public
FormattedCode getFormattedCode(), ki vrne ustrezno izvorno kodo, ki ustreza temu bloku in
podanim parametrom. Metoda pridobi vhodne podatke pozameznih vhodnih vrat tako, da
kliče metodo getFormattedCode() tistih izhodnih logičnih vrat, ki so na ta vhodna vrata
povezana.
Logični bloki so na podlagi diagrama povezani med seboj prek logičnih vrat (angl. port)
tako, da so vsaka vhodno orientirana vrata povezana z natanko enimi logičnimi vrati, ki so
orientirana izhodno. Logična vrata predstavljajo vhodne parametre in izhodne rezultate
posameznega bloka. Vsak logični končni gradnik (terminal) predstavlja nek končni rezultat
in generira svoj segment kode. Generiranje kode sproţimo s klicem njegove funkcije
generateFormattedCode().
Imena spremenljivk, ki nastopajo v programu, se med prevajanjem pretvorijo v »nadzorniku
prijazna« imena. Konflikti, ki bi utegnili nastopiti ob ujemanju z rezerviranimi besedami
jezika C++ in spremenljivkami ter imeni, ki jih uporablja nadzornik, se preprečijo z
dodajanjem dvojnega podčrtaja (»__«) na začetku imena spremenljivk. Podobno se rešijo
moţni konflikti pri imenih funkcij in instanc funkcijskih blokov. Imena instanc funkcijskih
blokov se generirajo po pravilu: dvojni podčrtaj + ime funkcijskega bloka + podčrtaj + ID
logičnega bloka (oznaka, ki je v zapisu programa lastna tej instanci).
29
5.3 Realizacija programskih gradnikov
Primer realizacije funkcije je gradnik EQ (slika 24), ki primerja dve vrednosti na vhodih in
vrne rezultat tipa BOOL.
Slika 24. Grafična predstavitev gradnika za primerjanje.
Generiranje kode gradnika se vrši s kodo na sliki 25.
Slika 25. Koda za generiranje ciljne kode gradnika EQ.
Postavitev z dvema vhodnima in eno izhodno spremenljivko (slika 24) nam tako generira
kodo na sliki 26.
Slika 26. Generirana koda za funkcijo EQ.
30
Primer funkcijskega bloka je gradnik za detekcijo pozitivne fronte R_TRIG, prikazan na
sliki 27.
Slika 27. Grafična predstavitev gradnika za detekcijo pozitivne fronte.
Funkcijski blok je na nivoju jezika C++ realiziran kot razred. Implementacijo funkcijskega
bloka za detekcijo pozitivne fronte prikazuje slika 28.
Slika 28. Realizacija funkcijskega bloka za detekcijo pozitivne fronte v C++.
Generiranje kode je v tem primeru malenkost bolj zapleteno. Ta del kode je prikazan na
sliki 29.
31
Slika 29. Koda za generiranje ciljne kode za klic instance funkcijskega bloka.
Ob predpostavki, da je ID gradnika v diagramu enak »3«, nam postavitev iz slike 27
generira ciljno kodo, ki je predstavljena na sliki 30. Hkrati s tem na mesto globalnih
deklaracij (datoteka GLOBALS.pde) vstavimo deklaracijo instance razreda (instanca
__r_trig_3). Vsak v krmilni diagram vstavljen gradnik funkcijskega bloka je lastna instanca
svojega razreda.
Slika 30. Generirana koda za klic instance funkcijskega bloka R_TRIG.
Realizacija in generiranje kode običajnih spremenljivk sta trivialna in razvidna ţe na
podlagi zgornjih primerov. Končni gradnik (ponor) preprosto generira stavek za prirejanje z
ustrezno prilagojenim imenom spremenljivke na levi strani in kodo, ki jo generira element
povezan z vhodom, na desni strani. Gradnik izvorne spremenljivke pa ob klicu metode za
generiranje kode zgolj vrne prilagojeno ime spremenljivke.
Obravnava direktnih spremenljivk je bolj zapletena. To so spremenljivke, ki imajo
pripisano lokacijo. Njihovo vključevanje v končno kodo opisuje slika 31. Lokacije so
specifične za vsako fizično konfiguracijo krmilnika posebej (priključeni V/I moduli ipd.) in
so definirane v posebni datoteki (npr. locations.xml) na način, ki ga podaja slika 32.
Zgradbo datoteke pa podaja slika 33.
32
Slika 31. Direktna spremenljivka. Slika prikazuje deklaracijo direktne spremenljivke v krmilnem programu (levo
zgoraj) ter njeno vključitev v kodo programskega nadzornika (desno).
Slika 32. Definicija lokacije in opis lastnosti.
33
Slika 33. Zgradba datoteke z definicijami lokacij.
34
5.4 Prevajanje in krmilni program
Programska koda končne krmilne aplikacije je zdruţena na enem mestu in razporejena v
hierarhijo, ki jo opisuje tabela 9. Del teh datotek posredno spreminja programer, ko riše
krmilni program v razvojnem okolju. Ostale datoteke so nespremenljive in so bodisi del
kode nadzornika bodisi skripte, knjiţnice ali orodja potrebna za prevajanje in prenos kode v
krmilnik.
Tabela 9. Hierarhija datotek, ki so potrebne za prevajanje.
Uporabniško kodo in nastavitve, ki jih generira razvojno okolje, vključimo med gradnjo v
program prek #include direktiv v kodi nadzornika (definicije globalnih spremenljivk,
konfiguracija) ter z zdruţevanjem segmentov kode nadzornika ter uporabniške kode.
Zdruţevanje je realizirano s preprostim prepisovanjem v datoteki Firmware/Core/Makefile.
35
Gradnjo izvršne kode krmilne aplikacije v treh korakih in prenos kode v krmilnik ponazarja
slika 34.
Slika 34. Postopek prevajanja.
36
5.5 Integrirano razvojno okolje
Pri oblikovanju okolja so bili upoštevani zgledi ostalih razvojnih okolij za programiranje
krmilnikov ter uveljavljenih okoljih splošnih programskih jezikov. Zaslon je tako razdeljen
na pet pomembnejših enot:
- paleto s programskimi gradniki,
- okno s prikazom definiranih spremenljivk, ki jih uporabljamo v programu,
- okno s prikazom lastnosti trenutno izbranega gradnika,
- krmilni diagram, ki je grafična predstavitev krmilnega programa in nastavitve
parametrov krmilnika,
- okno z izpisom rezultata prevajanja.
Slika 35. Glavni pogled razvojnega okolja.
Slika 35 prikazuje glavni pogled v razvojnem okolju. V spodnjem delu zaslona se nahaja
zavihek »VARIABLES« s seznamom spremenljivk, ki so deklarirane v trenutno odprtem
krmilnem programu. Spremenljivke lahko brišemo iz seznama ali jih dodajamo s klikom na
ustrezen gumb. Pri dodajanju nove deklaracije spremenljivke se odpre okno, v katerem
vpišemo ime spremenljivke, izberemo podatkovni tip in vrsto (lokalna, globalna, direktna),
37
pri direktnih pa tudi njihovo lokacijo (slika 36). Spremenljivko dodamo kot gradnik v
krmilni diagram tako, da jo izberemo na seznamu in kliknemo ukazni gumb »Insert as a
source« (kot izvor) ali gumb »Insert as a sink« (kot ponor).
Slika 36. Dodajanje deklaracije nove spremenljivke.
Na desnem delu zaslona se nahaja zavihek »BLOCKS« s programskimi gradniki, ki jih v
krmilni diagram dodajamo s klikom na ustrezen gumb. Pod njim je zavihek
»PROPERTIES« (slika 37), v katerem se izpisujejo lastnosti gradnika, ki je trenutno izbran
v diagramu.
Slika 37. Zavihek "PROPERTIES", v katerem se prikazujejo lastnosti trenutno izbranega gradnika.
Nastavitve parametrov, ki jih uporabljamo v krmilni aplikaciji, podamo kot kodo XML v
zavihku »CONFIGURATION« (slika 38). Te nastavitve so del krmilnega programa.
Moţnosti in razširjen primer nastavitve krmilnika prikazuje slika 39.
38
Slika 38. Določanje parametrov krmilnika.
Slika 39. Primer nastavljanja parametrov krmilnika.
39
Prevajanje programa sproţimo z izbiro v meniju Build > Build program (ali bliţnjico
CTRL+B). Podobno sproţimo prenos prevedenega programa v krmilnik z izbiro Build >
Upload to controller (ali izbiro CTRL+U). Opis uspešnosti teh postopkov se izpiše v
zavihku »BUILD OUTPUT«, ki ga najdemo na spodnjem robu okna (slika 40).
Slika 40. Okno z izpisom rezultatov prevajanja.
40
5.6 Knjižnica za dostop do podatkov v krmilniku
V sklopu razvojnega okolja je bila razvita tudi preprosta knjiţnica v jeziku Java za dostop
do krmilnikovih podatkovnih blokov iz računalnika PC. Serijska komunikacija je
implementirana z uporabo knjiţnice Giovynet [9]. Knjiţnica za dostop je zgolj zrcalna slika
implementacije protokola v krmilnikovem programskem nadzorniku. Omogoča
vzpostavitev povezave s krmilnikom, oddaljeno branje vrednosti podatkovnih blokov in
spreminjanje njihove vsebine (slika 41).
Slika 41. Metode razreda za dostop do podatkov v krmilniku in primer uporabe (celoštevilski konstanti
DB_TEMPERATURE in DB_SWITCH hranita naslova ustreznih blokov v krmilniku, spremenljivka newValue pa
novo celoštevilsko vrednost bloka).
41
6. Primer uporabe – krmiljenje ogrevanja
Uporaba je predstavljena s preprostim krmiljenjem ogrevanja. Krmilnik prek relejskega
izhoda neposredno krmili napajanje grelca. Trenutno temperaturo v prostoru pa spremlja s
pomočjo senzorja, ki je priključen na krmilnik prek vodila I2C. Delovanje krmilnika
spremljamo na oddaljenem PC računalniku s preprostim programom, ki je s krmilnikom
povezan serijsko prek povezave RS232. S programom krmilimo grelec ter nastavljamo
ţeleno tempeaturo sobe.
6.1 Vhodno / izhodna konfiguracija
Na vhodno izhodnem modulu je rele, ki se krmili preko namenskega čipa ULN2803. Izhod
je krmiljen neposredno z nastavljanjem vrednosti izhodne noţice mikrokontrolerja, na
način, da nizko stanje na noţici pomeni visoko stanje na izhodu krmilnika. Do izhoda
dostopamo prek lokacije %Q0.0.
Za merjenje temperature je uporabljen senzorski modul proizvajalca Conrad (slika 42), ki je
s krmilnikom povezan prek povezave I2C (več o senzorskem modulu v dodatku D in [7]).
Do senzorja dostopamo prek lokacije %IA1.0.
Slika 42. Temperaturni senzor Conrad C-CONTROL (slika vzeta iz proizvajalčeve domače strani).
Definicijo lokacij (datoteka locations.xml) za to vhodno/izhodno postavitev podajajo slike
od 43 do 45. Branje senzorja prek vodila I2C je relativno zahtevna operacija, temu primerno
je kompleksna tudi definicija lokacije. Za branje potrebujemo knjiţnico Wire.h, ki je
standardni del okolja Arduino. Branje in pretvorba podatkov v temperaturo poteka v štirih
korakih, ki jih opisuje koda na sliki 45. V nasprotju s tem je pisanje na izhod zelo preprosto.
Definicijo lokacije izhoda podaja slika 43.
42
Slika 43. Definicija lokacije izhoda.
Slika 44. Lastnosti definicije lokacije senzorja - prvi del.
43
Slika 45. Lastnosti definicije lokacije senzorja - drugi del (branje podatka in zapis temperature v spremenljivko).
44
6.2 Krmilni program
Krmilni program (slika 46) primerja izmerjeno temperaturo z nastavljeno vrednostjo in
glede na to izhod, ki krmili grelec, postavi v visoko ali nizko stanje. Komunikacija z
računalnikom PC poteka prek povezave RS232 z uporabo štirih podatkovnih blokov, preko
katerih se prenašajo parametri med računalnikom in krmilnikom (nastavitve na sliki 47).
Uporabljene spremenljivke in njihove deklaracije so predstavljene na sliki 48.
Slika 46. Krmilni program za vzdrževanje temperature v prostoru.
45
Slika 47. Nastavitve parametrov krmilnika.
Slika 48. Deklaracija uporabljenih spremenljivk v programu.
46
6.3 Program za oddaljeno spremljanje in nadzor
Program na računalniku PC je napisan v jeziku Java z uporabo razreda
ProgrammableLogicController, opisanega v poglavju 5.6. Omogoča spremljanje stanja
krmilnika (grelec vklopljen ali izklopljen, temperatura sobe), izklop in vklop grelca ter
nastavljanje temperaturnega praga.
Takoj po zagonu programa se prikaţe okno na sliki 47. V spodnjem desnem kotu je slika, ki
ponazarja trenutno stanje grelca. Povezava s krmilnikom se vzpostavi po kliku na gumb v
zgornjem levem kotu.
Slika 49. Osnovni zaslon nadzornega programa (grelec ugasnjen).
Po vzpostavitvi povezave se v ustreznem okencu prične izpisovati temperatura prostora. Z
vpisom ţelene temperature in klikom na gumb desno od vnosnega polja, se podatki
prenesejo v krmilnik. Zaslon s ponazoritvijo stanja delujočega grelca je prikazan na sliki 48.
47
Slika 50. Zaslon s ponazoritvijo delujočega stanja grelca.
S ponovnim klikom na gumb v zgornjem levem kotu grelec ugasnemo in prekinemo
povezavo s krmilnikom.
Branje podatkov iz krmilnika je realizirano v samostojni niti, ki v časovnem intervalu ene
sekunde prebere vrednosti podatkovnih blokov iz krmilnika, posodobi izpise v
uporabniškem vmesniku ter, če se parametri, ki jih je vnesel uporabnik, razlikujejo od tistih
v krmilniku, te zapiše v krmilnik.
48
7. Sklep
V pričujoči nalogi je bil realiziran preprost krmilnik, ki se po osnovnih značilnostih in
načinu delovanja pribliţuje klasičnim programabilnim logičnim krmilnikom. Strojni del
zajema krmilnikovo vezje z vezjem za komunikacijo in ločeno vezje za preprost
vhodno/izhodni modul. Vezje je bilo zasnovano modularno in razširljivo. Na podlagi tega je
bil razvit nadzorni program v jeziku Arduino, ki nadzoruje delovanje krmilnika in izvajanje
krmilne kode, omogoča povezovanje drugih naprav s krmilnikom ter skupaj z uporabniško
krmilno kodo predstavlja končni krmilni program, ki ga izvaja mikrokontroler. V jeziku
Java je bilo implementirano grafično razvojno okolje s preprostim jezikom, ki se zgleduje
po standardnem jeziku FBD. Za namene predstavitve delovanja je bil implementiran tudi
preprost program za oddaljeno spremljanje in nadzor na računalniku PC ter konfiguracija in
program za krmiljenje ogrevanja prostora v jeziku krmilnika.
Razvojno okolje v osnovi deluje v operacijskem sistemu Linux, vendar bi bil prenos v druge
operacijske sisteme, ki jih podpira prevajalnik GNU C++ za mikrokontrolerje AVR,
razmeroma enostaven.
Ţe med samim razvojem so se odpirale številne moţnosti za izboljšave in razširitve, vendar
sem skušal ostati znotraj okvirov te naloge in se odločil za implementacijo zgolj tistih
lastnosti krmilnika, ki so za osnovno ponazoritev nujne. Predstavljeni krmilnik po
zmogljivosti in moţnostih, ki jih ponuja, najbrţ ne more konkurirati komercialnim
izvedenkam, ki so trenutno na trgu. Je pa toliko dognan, da ga je mogoče uporabiti za
številne enostavnejše naloge krmiljenja v okoljih, kjer zanesljivost in kritičnost nista na
prvem mestu. Mogoče ga je uporabiti tudi kot izhodišče za nadaljnji razvoj in raziskovanje.
Pri uporabi PLK krmilnikov je pomembno, da se uporabniku ni treba spuščati na nivo
delovanja elektronskih komponent. V smislu ideje o modularnosti to pomeni, da za uporabo
vhodno/izhodnih modulov uporabniku ni potrebno poznati delovanja komponent in le-teh
programirati na niţjem nivoju. V primeru predstavljenega krmilnika je bilo to realizirano s
pomočjo definicij lokacij. To pomeni, da pri uporabi dodatnih modulov zadostuje, da ima
uporabnik na voljo tekstovne definicije lokacij teh modulov. Te vključi v svoj krmilni
program, razvojno okolje pa med prevajanjem samo na podlagi teh definicij vključi vso
potrebno kodo v končni program.
Programski jezik razvojnega okolja podpira zgolj omejeno število vnaprej definiranih
funkcij in funkcijskih blokov ter en glavni program, ki jih uporablja. Smiselno bi bilo dodati
moţnost definiranja novih funkcij in podatkovnih blokov ter razširiti nabor podatkovnih
tipov spremenljivk. Ravno tako bi bilo smiselno dodati podporo obvladovanja izpadov in
ponovne vzpostavitve napajanja tudi na nivoju razvojnega okolja.
Na strojnem nivoju in nivoju programskega nadzornika bi bilo smiselno prenesti
komunikacijo na pomoţni mikrokontrolerski modul in dodati podporo industrijsko bolj
uveljavljenim načinom povezovanja (npr. RS485 ter protokol Modbus). Marsikateri del v
kodi programskega nadzornika bi bilo mogoče napisati lepše, optimizirati ali drugače
izboljšati. Na celotnem nivoju mogoče celo v smeri uporabe katerega izmed odprtokodnih
realnočasovnih operacijskih sistemov. Pojav različic programskih knjiţnic in okolja
Arduino za močnejše mikrokontrolerje in razvojnih ploščic, kot je Maple [23], dodatno
odpira vrata številnim novim moţnostim.
49
Dodatek A
Analiza kode programskega nadzornika s programom USC
CodeCount
Tabela 10. Analiza vrstic kode nadzornika s programom USC CodeCount [17].
USC Unified CodeCount (UCC)
(c) Copyright 1998 - 2009 University of Southern California
SLOC COUNT RESULTS
Generated by UCC v.200911 on 6 27 2010
RESULTS FOR C_CPP FILES
Total Blank | Comments | Compiler Data Exec. |Logical | File Module
Lines Lines | Whole Embedded | Direct. Decl. Instr. | SLOC | Type Name
--------------------------------------------------------------------------------------------------------------
32 10 | 8 8 | 14 0 0 | 14 | CODE ../../mPLK/Firmware/Core/firmware.pde
48 16 | 11 0 | 0 1 20 | 21 | CODE ../../mPLK/Firmware/Core/mPLK_utils.pde
31 1 | 0 0 | 0 28 2 | 30 | CODE ../../mPLK/Firmware/Core/Prototypes.h
62 20 | 18 1 | 6 0 14 | 20 | CODE ../../mPLK/Firmware/Core/mPLK_reset.pde
90 33 | 35 5 | 20 1 1 | 22 | CODE ../../mPLK/Firmware/Core/mPLK_settings.pde
448 120 | 118 7 | 46 5 146 | 197 | CODE ../../mPLK/Firmware/Core/mPLK_mainloop.pde
72 25 | 14 8 | 5 3 21 | 29 | CODE ../../mPLK/Firmware/Core/mPLK_datablocks.pde
229 54 | 42 13 | 17 8 93 | 118 | CODE ../../mPLK/Firmware/Core/mPLK_serial.pde
87 21 | 14 5 | 0 5 43 | 48 | CODE ../../mPLK/Firmware/Core/mPLK_time.pde
RESULTS SUMMARY
Total Blank | Comments | Compiler Data Exec. | Number | File SLOC
Lines Lines | Whole Embedded | Direct. Decl. Instr. | of Files | SLOC Type Definition
--------------------------------------------------------------------------------------------------------------
1099 300 | 260 47 | 108 51 380 | 9 | 539 CODE Physical
1099 300 | 260 47 | 108 51 340 | 9 | 499 CODE Logical
Number of files successfully accessed........................ 9 out of 9
Ratio of Physical to Logical SLOC............................ 1.08
TOTAL OCCURRENCES OF C_CPP KEYWORDS
--------------------------------------------------------------------------------------------------------------
Compiler Directives Data Keywords Executable Keywords
#define................. 25 FILE.................... 0 goto.................... 0
#undef.................. 0 const................... 0 if...................... 32
#if..................... 1 bool.................... 0 else.................... 13
#ifdef.................. 33 int..................... 54 for..................... 2
#ifndef................. 0 long.................... 4 do...................... 2
#else................... 0 unsigned................ 2 while................... 5
#elif................... 0 short................... 2 continue................ 0
#endif.................. 34 char.................... 2 switch.................. 3
#include................ 15 wchar_t................. 0 case.................... 9
#line................... 0 float................... 3 break................... 12
#pragma................. 0 double.................. 0 default................. 1
#error.................. 0 enum.................... 0 return.................. 19
#dictionary............. 0 class................... 0 entry................... 0
#module................. 0 struct.................. 2 sizeof.................. 0
#import................. 0 union................... 0 new..................... 0
#using.................. 0 void.................... 37 delete.................. 0
typedef................. 2 try..................... 0
auto.................... 0 throw................... 0
register................ 0 catch................... 0
static.................. 1 typeid.................. 0
extern.................. 0 const_cast.............. 0
namespace............... 0 static_cast............. 0
asm..................... 0 dynamic_cast............ 0
template................ 0 reinterpret_cast........ 0
operator................ 0 stdin................... 0
mutable................. 0 stdout.................. 0
friend.................. 0 stderr.................. 0
volatile................ 5 cin..................... 0
using................... 0 cout.................... 0
explicit................ 0 cerr.................... 0
inline.................. 0 clog.................... 0
virtual................. 0
string.................. 0
50
Dodatek B
Primerjava uporabe mikrokontrolerjevih virov pri različnih
parametrih
A) Samo programski nadzornik, brez funkcionalnosti serijske komunikacije (podano z
izpisom skripte avr-mem.sh [15]):
AVR Memory Usage:
-----------------
Device: at90usb646
Program: 8532 bytes (13.0% Full) (.text + .data + .bootloader)
Data: 119 bytes (2.9% Full) (.data + .bss + .noinit)
B) Samo programski nadzornik, omogočena funkcionalnost serijske komunikacije prek
RS232:
AVR Memory Usage:
-----------------
Device: at90usb646
Program: 12246 bytes (18.7% Full) (.text + .data + .bootloader)
Data: 235 bytes (5.7% Full) (.data + .bss + .noinit)
C) Samo programski nadzornik, omogočena funkcionalnost serijskega povezovanja prek
povezave USB (vzpostavitev navideznega serijskega vmesnika programsko v
mikrokontrolerju):
AVR Memory Usage:
-----------------
Device: at90usb646
Program: 12302 bytes (18.8% Full) (.text + .data + .bootloader)
Data: 243 bytes (5.9% Full) (.data + .bss + .noinit)
51
D) Programski nadzornik, serijska komunikacija prek RS232, štirje podatkovni bloki,
krmilni program in vhodno/izhodna konfiguracija iz poglavja 5.2:
AVR Memory Usage:
-----------------
Device: at90usb646
Program: 12454 bytes (19.0% Full) (.text + .data + .bootloader)
Data: 243 bytes (5.9% Full) (.data + .bss + .noinit)
52
Dodatek C
Fotografija prototipa krmilnika v osnovni konfiguraciji
Slika 51. Prototip realizacije krmilnika na luknjičastih ploščicah. Na sliki je dodan digitalni V/I modul z dvema
vhodoma in enim tranzistorskim izhodom (krmilna napetost 24V DC). Spodaj desno na sliki je temperaturni senzor
Conrad C-Control.
53
Shema vezja krmilnika
Slika 52. Krmilnik s komunikacijskim vezjem.
54
Slika 53. Napajanje krmilnika.
Slika 54. Primer vhodno/izhodnega modula.
55
Dodatek D
Podatkovni list temperaturnega senzorja Conrad C-Control I
Slika 55. Podatkovni list temperaturnega modula (priloženo izdelku).
56
Dodatek E
Vsebina priložene zgoščenke
Tabela 11. Vsebina priložene zgoščenke.
Firmware/ Prevajalno okolje (knjiţnjice Arduino in Teensyduino, izvorna koda
programskega nadzornika, skripte za prevajanje)
Editor/ Izvorna koda razvojnega okolja (projekt v razvojnem okolju IntelliJ IDEA)
SimpleSCADA/ Izvorna koda preprostega programčka za oddaljen nadzor (projekt v razvojnem
okolju IntelliJ IDEA)
CentralHeating/ Predstavitveni krmilni program (program in konfiguracija, definicija lokacij)
Libraries/ Knjiţnice, potrebne za prevajanje
Tools/ Pripomočki (programi USC CodeCount, avr-mem, teensy_cli)
spremembe.txt Opis popravkov in prilagoditev v izvorni kodi knjiţnic in programov
pripomočkov, ki so bile potrebne za prevajanje in uporabo
Izvorna koda programov na zgoščenki, ki so nastali v sklopu te naloge, je objavljena pod
licenco GNU General Public Licence, različice 3. To se ne nanaša nujno na priloţene
programe in kodo, ki so delo drugih oseb in kodo, kjer je to posebej označeno. Priporočeno
je, da bralec preuči licenčne pogodbe in skladnost z njimi, preden uporabi kodo na tej
zgoščenki za druge namene kot lastno izobraţevanje.
57
Seznam slik in tabel
Seznam slik
Slika 1. Program v programabilnem logičnem krmilniku. ...................................................... 5
Slika 2. Program v jeziku Arduino po “prevajanju” v C++..................................................... 7
Slika 3. Program v okolju Arduino in način izvajanja. ........................................................... 9
Slika 4. Realizacija koncepta PLK v okolju Arduino. ............................................................. 9
Slika 5. Razvojna ploščica Teensy++ (slika vzeta iz proizvajalčeve domače strani). ........... 10
Slika 6. Shematski prikaz krmilnika. ..................................................................................... 11
Slika 7. Vezje za napajanje (shema povzeta po [2]). ............................................................. 12
Slika 8. Uporaba noţic mikrokontrolerja. ............................................................................. 13
Slika 9. Vezje PLK (shema povzeta po [2]). ......................................................................... 14
Slika 10. Vezje za serijsko komunikacijo RS232. ................................................................. 15
Slika 11. Krmilnikov vhod (slika povzeta po [2]). ................................................................ 16
Slika 12. Izhod krmilnika (slika povzeta po [2]). .................................................................. 16
Slika 13. Prikaz delovanja krmilnika. Z rdečimi puščicami je ponazorjen krmilnikov
izvajalni cikel. ........................................................................................................................ 17
Slika 14. Nastavitev časovnika. ............................................................................................. 18
Slika 15. Izračunavanje časa po preteku 100ms. ................................................................... 18
Slika 16. Funkcije za ravnanje s časom. ................................................................................ 19
Slika 17. Implementacija podatkovnih blokov. ..................................................................... 19
Slika 18. Nastavitev komunikacijskih parametrov. ............................................................... 21
Slika 19. Spremenljivke, v katerih se hrani trenutno obravnavana zahteva. ......................... 21
Slika 20. Prepoznavanje prispele komunikacijske zahteve. .................................................. 22
Slika 21. Streţba prispelih zahtev. ......................................................................................... 23
58
Slika 22. Shematski prikaz zgradbe razvojnega okolja. Razviden je tok krmilnega programa
od grafičnega urejanja do prenosa v krmilnik. ...................................................................... 24
Slika 23. Programski vmesnik razreda za generiranje in predstavitev ciljne kode. .............. 28
Slika 24. Grafična predstavitev gradnika za primerjanje. ..................................................... 29
Slika 25. Koda za generiranje ciljne kode gradnika EQ. ...................................................... 29
Slika 26. Generirana koda za funkcijo EQ. ........................................................................... 29
Slika 27. Grafična predstavitev gradnika za detekcijo pozitivne fronte. .............................. 30
Slika 28. Realizacija funkcijskega bloka za detekcijo pozitivne fronte v C++. ................... 30
Slika 29. Koda za generiranje ciljne kode za klic instance funkcijskega bloka. ................... 31
Slika 30. Generirana koda za klic instance funkcijskega bloka R_TRIG. ............................ 31
Slika 31. Direktna spremenljivka. Slika prikazuje deklaracijo direktne spremenljivke v
krmilnem programu (levo zgoraj) ter njeno vključitev v kodo programskega nadzornika
(desno). .................................................................................................................................. 32
Slika 32. Definicija lokacije in opis lastnosti. ....................................................................... 32
Slika 33. Zgradba datoteke z definicijami lokacij. ................................................................ 33
Slika 34. Postopek prevajanja. .............................................................................................. 35
Slika 35. Glavni pogled razvojnega okolja. .......................................................................... 36
Slika 36. Dodajanje deklaracije nove spremenljivke. ........................................................... 37
Slika 37. Zavihek "PROPERTIES", v katerem se prikazujejo lastnosti trenutno izbranega
gradnika. ................................................................................................................................ 37
Slika 38. Določanje parametrov krmilnika. .......................................................................... 38
Slika 39. Primer nastavljanja parametrov krmilnika. ............................................................ 38
Slika 40. Okno z izpisom rezultatov prevajanja. .................................................................. 39
Slika 41. Metode razreda za dostop do podatkov v krmilniku in primer uporabe
(celoštevilski konstanti DB_TEMPERATURE in DB_SWITCH hranita naslova ustreznih
blokov v krmilniku, spremenljivka newValue pa novo celoštevilsko vrednost bloka). ....... 40
Slika 42. Temperaturni senzor Conrad C-CONTROL (slika vzeta iz proizvajalčeve domače
strani). ................................................................................................................................... 41
Slika 43. Definicija lokacije izhoda. ..................................................................................... 42
59
Slika 44. Lastnosti definicije lokacije senzorja - prvi del. ..................................................... 42
Slika 45. Lastnosti definicije lokacije senzorja - drugi del (branje podatka in zapis
temperature v spremenljivko). ............................................................................................... 43
Slika 46. Krmilni program za vzdrţevanje temperature v prostoru....................................... 44
Slika 47. Nastavitve parametrov krmilnika. .......................................................................... 45
Slika 48. Deklaracija uporabljenih spremenljivk v programu. .............................................. 45
Slika 49. Osnovni zaslon nadzornega programa (grelec ugasnjen). ...................................... 46
Slika 50. Zaslon s ponazoritvijo delujočega stanja grelca. .................................................... 47
Slika 51. Prototip realizacije krmilnika na luknjičastih ploščicah. Na sliki je dodan digitalni
V/I modul z dvema vhodoma in enim tranzistorskim izhodom (krmilna napetost 24V DC).
Spodaj desno na sliki je temperaturni senzor Conrad C-Control. ......................................... 52
Slika 52. Krmilnik s komunikacijskim vezjem. .................................................................... 53
Slika 53. Napajanje krmilnika. .............................................................................................. 54
Slika 54. Primer vhodno/izhodnega modula. ......................................................................... 54
Slika 55. Podatkovni list temperaturnega modula. ................................................................ 55
Seznam tabel
Tabela 1. Pet načinov predstavitve krmilnega programa po standardu IEC 61131-3. ............ 6
Tabela 2. Specifikacija mikrokontrolerja. ............................................................................. 10
Tabela 3. Uporaba noţic mikrokontrolerja in opis funkcij, ki jo jim določene. .................... 12
Tabela 4. Protokol za komunikacijo. ..................................................................................... 20
Tabela 5. Gradniki, ki jih podpira razvojno okolje. ............................................................... 26
Tabela 6. Realizacija podatkovnih tipov programskega jezika. ............................................ 26
Tabela 7. Vrste spremenljivk in način njihove realizacije. .................................................... 27
Tabela 8. Primer poimenovanja lokacij krmilnika z razlago. ................................................ 27
Tabela 9. Hierarhija datotek, ki so potrebne za prevajanje. .................................................. 34
60
Viri
[1] J. R. Cordy, I. H. Carmichael, R. Halliday, »The TXL Programming Language«.
Dostopno na: http://www.txl.ca/docs/TXL105ProgLang.pdf
[2] E. Martens, »A Real uC PLC using AT89S8252 board«, Elector Electronics
Magazine, št. 352, zv. 32, str. 54-57, 2006.
[3] H. Mössenböck, J. Kepler, »The Compiler Generator COCO/R«. Dostopno na:
http://www.ssw.uni-linz.ac.at/coco/Doc/UserManual.pdf
[4] (1996) »IEC 61131-3 Common Elements«. Dostopno na:
http://www.plcopen.org/pages/pc2_training/downloads/downloads/common_element
s_text.zip
[5] (2009) AT90USB646/647/1286/1287, datasheet, revision K. Dostopno na:
http://www.atmel.com/dyn/resources/prod_documents/doc7593.pdf
[6] Arduino Backplane Experiment. Dostopno na:
http://pskillenrules.blogspot.com/2009/08/arduino-backplane-experiment.html
[7] (2010) I2C Thermometer on Arduino. Dostopno na:
http://www.local-guru.net/blog/2009/02/02/i2c-thermometer-on-arduino
[8] (2010) Knjiţnjica MsTimer2. Dostopno na:
http://www.arduino.cc/playground/Main/MsTimer2
[9] (2010) Knjiţnica za dostop do serijskih vrat – Giovynet. Dostopno na:
http://www.giovynet.com/serialport.html
[10] (2010) Ladder Logic Tutorial. Dostopno na:
http://ee.sharif.edu/~industrialcontrol/LADDER_LOGIC_Tutorial.pdf
[11] (2010) Okolje Arduino. Dostopno na: http://www.arduino.cc
[12] (2010) Okolje Teensyduino. Dostopno na:
http://www.pjrc.com/teensy/teensyduino.html
[13] (2010) PLCOpen. Dostopno na: http://www.plcopen.org
[14] (2010) Programmable Logic Controller. Dostopno na:
http://en.wikipedia.org/wiki/Programmable_logic_controller
[15] (2010) Programček avr-mem.sh. Dostopno na:
http://svn.gumstix.com/gumstix-buildroot/branches/projects/robostix/avr-mem.sh
[16] (2010) Program za prenos kode v MKE - teensy_cli. Dostopno na:
http://www.pjrc.com/teensy/loader_cli.html
61
[17] (2010) Program USC CodeCount. Dostopno na:
http://csse.usc.edu/research/CODECOUNT
[18] (2010) Projekt Beremiz. Dostopno na: http://www.beremiz.org
[19] (2010) Projekt Ldmicro. Dostopno na: http://www.cq.cx/ladder.pl
[20] (2010) Projekt Proview. Dostopno na: http://www.proview.se
[21] (2010) Razvojna ploščica Teensy++. Dostopno na: http://www.pjrc.com/teensy
[22] (2010) Razvojne ploščice Arduino. Dostopno na:
http://arduino.cc/en/Main/Hardware
[23] (2010) Razvojna ploščica Maple. Dostopno na: http://leaflabs.com/devices/maple/