Programabilni logični krmilnik · PDF fileUNIVERZA V LJUBLJANI FAKULTETA ZA RAČUNALNIŠTVO IN INFORMATIKO Tomaž Furlan Programabilni logični krmilnik DIPLOMSKO DELO NA UNIVERZITETNEM

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



C) Samo programski nadzornik, omogočena funkcionalnost serijskega povezovanja prek

povezave USB (vzpostavitev navideznega serijskega vmesnika programsko v

mikrokontrolerju):

AVR Memory Usage:

-----------------

Device: at90usb646



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



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

http://pskillenrules.blogspot.com/2009/08/arduino-backplane-experiment.html

http://ee.sharif.edu/~industrialcontrol/LADDER_LOGIC_Tutorial.pdf

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/

Documents

Programabilni logični krmilnik · PDF fileUNIVERZA V LJUBLJANI FAKULTETA ZA RAČUNALNIŠTVO IN INFORMATIKO Tomaž Furlan Programabilni logični krmilnik DIPLOMSKO DELO NA UNIVERZITETNEM