Master Rad

UNIVERZITET U TUZLI
FAKULTET ELEKTROTEHNIKE
MAGISTARSKI RAD
AUTOMATSKO GENERIRANJE KODA ZA MPC

KONTROLERE
TUZLA, SEPTEMBAR 2018. GODINE

UNIVERZITET U TUZLI
FAKULTET ELEKTROTEHNIKE
IME I PREZIME KANDIDATA: MELIS ZULIĆ

DRUGI CIKLUS STUDIJA
STUDIJSKI PROGRAM: ELEKTROTEHNIKA I RAČUNARSTVO
USMJERENJE: AUTOMATIKA I ROBOTIKA
NASLOV RADA: AUTOMATSKO GENERIRANJE KODA ZA MPC KONTROLERE
UDK BROJ:
004.896:004.421(043.2)
004.942
Magistarski rad je odbranjen dana: 28.09.2018.
Sastav komisije za odbranu rada:
Dr.sc. Lejla Banjanović-Mehmedović, vanr. prof., predsjednik

Dr.sc. Naser Prljača, red. prof., mentor
Dr.sc. Amila Dubravić, docent, član
Redni broj iz matične evidencije: I-4-IIC/12

Broj Zapisnika: 05/3-4-1222/18.
Sažetak
Cilj ovog rada je pokazati mogućnosti automatske generacije koda softverskim rješenjima za
linearni model prediktivnog upravljanja. Konkretno, rad kroz primjere pokazuje mogućnost
generisanja široko upotrebljivog C koda prilagođenog za embedded aplikacije. Sama
implementacija algoritma razmatra mnoga ograničenja embedded aplikacija u realnom vremenu
a naročito aplikacija za mikrokontrolere: mala memorija, precizirano vrijeme izvršavanja.
Za potrebe ovog rada korišteno je open source rješenje pod imenom μAO-MPC koje je
razvijeno u Laboratoriju za teoriju sistema i automatsku kontrolu pri Univerzitetu u Magdeburgu.
Predstavlja Python paket koji pruža i MATLAB/simulink interfejs za generirani C kod. Osim
samog Python interpretera za potrebe rada korišteni su i paketi za razne matematičke proračune
poput NumPy, SciPy, Slyot.
Činjenica da definisanjem sistema kroz njegove parametre kao finalni produkt dobijamo C
kod za upravljanje MPC kontrolerima je impresivna. Generisani C kod je u potpunosti
kompatibilan sa ISO C89/C90 standardom i nezavisan je od platforme. Kod je moguće direktno
koristiti u embedded aplikacijama na popularnim platformama kao što su Arduino, Raspberry ili
bilo kojim drugim aplikacijama koje podržavaju C kod poput mnogih aktuelnih generacija
programabilnih logičkih kontrolera (PLC).
Ključne riječi: μAO-MPC, C kod, MPC, Python, Arduino, Raspberry, PLC.
ii
Abstract
The aim of this work is to demonstrate the ability of automatic code generation with software
solutions for a linear model predictive control. Specifically, this paper through examples
demonstrates the ability to generate a widely used C code adjusted for embedded application.
Specific implementation of the algorithm works with many embedded application constraints in
real time, and in particular microcontroller applications: low memory, deterministic execution
time.
For the purpose of this work, an open source solution called μAO-MPC was used, developed
in the Laboratory of System Theory and Automatic Control at the University of Magdeburg. It
represents a Python package that also provides a MATLAB / simulink interface for the generated
C code. In addition to the Python interpreter itself for the needs of the work, packages for various
mathematical calculations such as NumPy, SciPy, Slyot were used.
The fact that defining the system through its parameters as the final product we get the C
code to control MPC controllers is impressive. The generated C code is fully compatible with the
ISO C89 / C90 standard and is independent of the platform. The code can be directly used in
embedded applications with popular platforms such as Arduino, Raspberry or any other
application which accepts C code, like many current generation programable logic controllers
(PLC).
Keywords: μAO-MPC, C kod, MPC, Python, Arduino, Raspberry, PLC.
iii
Sadržaj
Poglavlje 1 Uvod u MPC ................................................................................................................ 7
1.1 Teorija i principi MPC-a .................................................................................................. 8
1.1.1 Baziranje predikcije na modelu............................................................................................. 8
1.1.2 Odabir trenutnog ulaza i smanjenje horizonta .................................................................... 10
1.1.3 Optimalne ili performanse sigurnosti .................................................................................. 11
1.1.4 Tuniranje ............................................................................................................................. 11
1.1.5 Manipulisanje ograničenjima .............................................................................................. 12
1.1.6 Sistematska upotreba budućih zahtjeva .............................................................................. 12
1.1.7 Sistematski dizajn upravljanja za multivarijabilne sisteme................................................. 12
1.1.8 Matematički opis MPC problema ....................................................................................... 13
Poglavlje 2 Uvod u muAO-MPC .................................................................................................. 16
2.1 Šta je muAO-MPC ......................................................................................................... 16
2.1.1 ltidt modul ........................................................................................................................... 16
2.2 Instaliranje softverskih paketa ........................................................................................ 17
2.2.1 Zahtjevi instalacije .............................................................................................................. 17
2.2.2 Bildanje i instalacija ............................................................................................................ 18
2.1 Razvoj open source softvera .......................................................................................... 19
2.2 Pregled promjena............................................................................................................ 20
Poglavlje 3 Način rada softvera .................................................................................................... 21
3.1 Kratak uvod u Python ..................................................................................................... 21
3.1.1 Prazan prostor ..................................................................................................................... 22
3.1.2 Python liste.......................................................................................................................... 22
3.1.3 NumPy ................................................................................................................................ 22
3.1.4 Indeksiranje ......................................................................................................................... 23
3.2 Osnovni MPC problem................................................................................................... 23
3.2.1 Opis MPC problema............................................................................................................ 23
3.2.2 Generiranje C koda ............................................................................................................. 24
3.2.3 Korištenje generisanog C-koda ........................................................................................... 25
3.2.4 Testiranje sa Python-om...................................................................................................... 26
3.3 Složeniji MPC problem .................................................................................................. 27
3.3.1 Opis MPC problema............................................................................................................ 27
iv
3.3.2 Generisanje C koda ............................................................................................................. 29
3.3.3 Korištenje generisanog C koda ........................................................................................... 30
3.3.4 Testiranje sa Python-om...................................................................................................... 31
3.4 Koji je sljedeći korak? .................................................................................................... 32
Poglavlje 4 MPC kontroleri .......................................................................................................... 33
4.1 Kreiranje MPC kontrolera .............................................................................................. 33
4.1.1 MPC podešavanja ............................................................................................................... 33
4.1.2 Sistem modul ...................................................................................................................... 34
4.1.3 Kreiranje Python MPC objekta ........................................................................................... 35
4.1.4 Generisanje C koda ............................................................................................................. 36
4.2 Upotreba MPC kontrolera .............................................................................................. 37
4.2.1 Osnove MPC ....................................................................................................................... 37
4.2.2 Korištenje Python interfejsa ................................................................................................ 38
4.2.3 Korištenje C implementacije ............................................................................................... 41
Poglavlje 5 Dodatne funkcije ........................................................................................................ 42
5.1 Klase simulacije u Python-u ........................................................................................... 42
5.1.1 Jednostepena simulacija ...................................................................................................... 42
5.1.2 Višestepena simulacija ........................................................................................................ 43
5.2 Podešavanje – tuniranje .................................................................................................. 44
5.2.1 Osnove podešavanja............................................................................................................ 44
5.2.2 Parametar odstupanja .......................................................................................................... 44
5.2.3 Podešavanje Hessian-a ........................................................................................................ 45
5.3 Automatski odabir stabilizirajuće matrice...................................................................... 47
5.3.1 Ključna riječ auto ................................................................................................................ 47
5.4 MATLAB/Simulink interfejs ......................................................................................... 48
5.4.1 Zavisnosti ............................................................................................................................ 48
5.4.2 Kreiranje interfejsa .............................................................................................................. 48
5.4.3 Korištenje MATLAB interfejsa .......................................................................................... 49
5.4.1 Korištenje Simulink interfejsa ............................................................................................ 50
v
Popis slika
Sl. 1.1 Osnovna struktura MPC-a ................................................................................................... 9

Sl. 1.2 Diskretna šema MPC-a ...................................................................................................... 13
vi
1.1Teorija i principi MPC-a ____________________________________________ Uvod u MPC
Poglavlje 1
Uvod u MPC
Model prediktivno upravljanje ( MPC ) je napredna metoda kontrole procesa koja se

primjenjuje u procesnim industrijama u hemijskim postrojenjima i rafinerijama od 1980.
godine. Posljednjih godina se također koristi u modelima za balansiranje elektroenergetskog
sistema. Modelski prediktivni kontroleri se oslanjaju na dinamičke modele procesa, najčešće
linearne empirijske modele dobijene identifikacijom sistema. Glavna prednost MPC-a je
činjenica da omogućava trenutni vremenski razmak da se optimizuje, uz istovremeno držanje
budućih vremena u proračunu. Ovo se postiže optimizacijom konačnog vremenskog horizonta,
ali samo implementiranjem trenutnog vremenskog intervala, a zatim ponovnim optimiziranjem,
što ga razlikuje od LQR-a . Takođe MPC ima mogućnost da predvidi buduće događaje i shodno
tome može da poduzme proračune. PID kontroleri nemaju ovu prediktivnu sposobnost. MPC je
skoro univerzalno primjenjen kao digitalna kontrola, iako postoje istraživanja o postizanju bržih
vremena odziva sa specijalno dizajniranim analognim kolima.
MPC je oblik kontrole u kojem se trenutna akcija kontrole dobiva rješavanjem on-line, na
svakom uzorkovanju trenutno, problem optimalnog upravljanja otvorene petlje sa konačnim
horizontom, koristeći trenutno stanje sistema kao početno stanje; optimizacija daje sekvencu
optimalnog upravljanja i prva kontrola u ovoj sekvenci se primjenjuje na sistem.
Filozofski rečeno, MPC odražava ljudsko ponašanje pri kojem izabiremo akcije upravljanja
za koje mislimo da će dovesti do najboljeg predviđenog ishoda (ili rezultata) u nekim
ograničenim horizontima. Da bi napravili ovaj izbor koristimo interni model procesa koji želimo
upravljati.
Stalno ažuriramo naše odluke pošto postaju dostupna nova zapažanja. Stoga, možemo reći da
zakon o prediktivnom upravljanju ima sljedeće komponente:
1. Zakon upravljanja zavisi od predviđenog ponašanja.
2. Izlazna predviđanja se izračunavaju koristeći model procesa.
3. Trenutni ulaz se određuje optimizacijom nekih mjerenja predviđenih performansi.
4. Uzmičući horizont: kontrolni ulaz se ažurira u svakom momentu uzorkovanja.
7
1.1 Teorija i principi MPC-a
Većina zakona o kontroli, recimo PID (proporcionalni, integralni i derivativni), ne razmatraju

eksplicitno buduće implikacije trenutnih akcija upravljanja. U određenoj mjeri ovo objašnjava
samo očekivana dinamika zatvorene petlje. MPC s druge strane eksplicitno izračunava
predviđeno ponašanje nad nekim horizontom. Stoga se može ograničiti izbor trenutnih
predloženih ulaznih putanja na one koji ne vode poteškoćama u budućnosti.
Razmislite o prelasku puta. Nije dovoljno da na putu nema automobila između vas i druge
strane; takođe provjeravate da li su automobili još uvijek na daljini koja će uskoro preći ispred
vas. To jest, predviđate da li ćete u bilo koje vrijeme tokom vašeg prelaska vjerovatno biti
udareni automobilom. Ako je odgovor da, čekate na ivičnjaku. Štaviše, sve vrijeme kada
prelazite, nastavite da gledate, to je ažuriranje vaših predviđanja, tako da ako je potrebno, vaša
putanja preko puta može biti izmjenjena.
1.1.1 Baziranje predikcije na modelu
Kako bismo predvidjeli buduće ponašanje procesa, moramo imati model kako se proces
ponaša. Konkretno, ovaj model mora pokazati zavisnost izlaza na trenutnu izmjerenu varijablu i
trenutne / buduće ulaze. Ovaj model ne mora biti linearan (npr., Funkcija prijenosa, prostor
stanja) i zapravo može biti vezan za bilo šta.
Kao ljudska bića često koristimo nejasne (fuzzy) modele, a ipak postižemo vrlo preciznu
kontrolu; na primjer, ako se vozimo u trećem stepenu prijenosa, brzinom 40 km/h, a ne nailazimo
na uspon, onda dajući komandu za ubrzanje (pritiskom na papučicu gasa) trebalo bi rezultirati
dobrim ubrzanjem. Ključna stvar koju treba primjetiti jeste da precizni model nije uvijek
neophodan da bi dobili dobru kontrolu; jer se odluke ažuriraju redovito, što će se nositi s nekim
nesigurnostima modela u relativno brzom vremenskom mjerilu. U gore navedenom primjeru,
neuspjeh postizanja dobrog ubrzanja uočit će se vrlo brzo usporedbom stvarnog ponašanja s
predviđenim ponašanjem modela; na primjer, jesam li u tačnom stepenu prijenosa, vozim li 40, a
ne 20, itd.? Odluku o najboljem upravljanju kontinuirano ažuriramo koristeći podatke iz ove
usporedbe.
Modeli koji se koriste u MPC-u su uglavnom namijenjeni da predstavljaju ponašanje
kompleksnih dinamičkih sistema. Dodatna složenost MPC kontrolnog algoritma uglavnom nije
potrebna da bi se obezbijedila adekvatna kontrola jednostavnih sistema, koji često dobro
kontrolišu generički PID kontroleri . Glavne dinamičke karakteristike koje su teške za PID
kontrolere podrazumijevaju velika kašnjenja i dinamiku velikog reda.
MPC modeli predviđaju promjenu zavisnih varijabli modeliranog sistema koja će biti
uzrokovana promjenama nezavisnih varijabli . U hemijskim procesima, nezavisne varijable koje
regulator može podesiti često su zadate vrijednosti regulatornih PID kontrolera (pritisak, protok,
temperatura, itd.) ili konačnih kontrolnih elemenata (ventili, amortizeri itd.). Nezavisne varijable
8
koje regulator ne može podesiti, koriste se kao smetnje. Zavisne varijable u ovim procesima su
druga mjerenja koja predstavljaju ili kontrolne ciljeve ili ograničenja procesa.
MPC koristi trenutna mjerenja sistema, trenutačno dinamičko stanje procesa, MPC modele i
ciljeve i ograničenja procesnih varijabli za izračunavanje budućih promjena zavisnih
varijabli. Ove promjene se izračunavaju kako bi zadržale zavisne varijable blizu ciljnih, poštujući
ograničenja na nezavisne i zavisne varijable. MPC uglavnom šalje samo prvu promjenu svake
nezavisne varijable koja se implementira, i ponavlja izračunavanje kada je potrebna sljedeća
promjena.
U praksi većina MPC algoritama koristi linearne modele jer je ovisnost predviđanja o
budućim izborima kontrole tada linearna, a to olakšava optimizaciju kao i off-line analizu
očekivanog ponašanja zatvorene petlje. Međutim, nelinearni modeli se mogu koristiti tamo gdje
korišteno računalno opterećenje nije problem, a linearne aproksimacije nisu dovoljno tačne.
Također je važno napomenuti ovdje komentar „koji odgovara svrsi“. U prediktivnoj kontroli,
model se koristi isključivo za izračunavanje izlaznih predviđanja sistema, tako da model
odgovara svrsi ako daje dovoljno precizne prognoze. Napor i detalji aplicirani u fazi modeliranja
trebali bi to odražavati. Možda nema potrebe modelirati svu fiziku, hemiju i unutrašnje
ponašanje procesa kako bi dobili model koji daje pouzdano predviđanje, i zapravo ne treba
modelirati sve ove detalje ako to nije potrebno. Osnovno pravilo navodi da se treba koristiti
najjednostavniji model kojem se može pribjeći. Sažeto rečeno: model se koristi za generiranje
predviđanja sistema. Treba upotrijebiti najjednostavniji model koji je prikladan za tu svrhu, tj.
daje dovoljno tačna predviđanja.
Sl. 1.1 Osnovna struktura MPC-a

Iako mnogi stvarni procesi nisu linearni, oni se često mogu smatrati približno linearnim u
malom radnom opsegu. Linearni MPC pristupi se koriste u većini aplikacija sa mehanizmom
povratne sprege MPC-a koji kompenzuje greške predviđanja zbog strukturne neusaglašenosti
između modela i procesa. U modelu prediktivne kontrole koji se sastoji samo od linearnog
modela, princip superpozicije linearne algebre omogućava efekt promjena u više nezavisnih
9
varijabli koje treba dodati zajedno da se predvidi odgovor zavisne varijable. Ovo
pojednostavljuje problem kontrole na seriju direktnih matričnih algebarskih izračunavanja koje
su brze i robusne.
Kada linearni modeli nisu dovoljno dobri da zamjene stvarne nelinearne procese, može se
koristiti nekoliko pristupa. U nekim slučajevima, varijable procesa mogu se transformirati prije i
/ ili nakon linearnog MPC modela kako bi smanjili nelinearnost. Proces se može kontrolirati
pomoću nelinearnog MPC-a koji koristi nelinearni model direktno u kontrolnoj
aplikaciji. Nelinearni model može biti u obliku empirijskih podataka (npr. Vještačke neuronske
mreže) ili dinamičkog modela velike vjernosti zasnovan na osnovnim masenim i energetskim
balansima. Nelinearni model može biti linearizovan da izvede Kalman filter ili da odredi model
za linearni MPC.
Algoritamska studija El-Gherwi, Budman i El Kamel pokazuje da korištenje pristupa sa
dvostrukim modom može pružiti značajno smanjenje online izračunavanja, a istovremeno
održavati uporedne performanse sa neizmjenjenom implementacijom. Predloženi algoritam
rješava N konveksne probleme optimizacije paralelno zasnovane na razmjeni informacija među
kontrolerima.
1.1.2 Odabir trenutnog ulaza i smanjenje horizonta
Prije nego je moguće odabrati trenutnu akciju kontrole, potrebno je imati kriterije za procjenu
koja je akcija najbolja. Budući da je MPC obično implementiran na računaru, to zahtijeva
numeričko definisanje kako bi se mogao napraviti tačan proračun, tj. koja predviđena ulazna
putanja daje najnižu numeričku vrijednost troškovima. Izbor funkcije troškova je područje
inženjerskog i teorijskog prosuđivanja, ali također stvara mnogo rasprava u akademskoj
zajednici, tako da nećemo raspravljati o tome.
Praktično iskustvo je da sve dok se slijede neke osnovne smjernice, izbor troškova često ima
malo uticaja na performanse zatvorene petlje. Glavni zahtjev je da trošak ovisi o budućim
kontrolama i da niske vrijednosti troškova vode ka dobrim performansama zatvorene petlje -
dobro definirano za proces koji je u pitanju. Naravno, izbor troška utiče na složenost primjenjene
optimizacije i ovo je također oblast razmatranja. Zbog toga su dvonormna mjerenja popularna,
kako bi optimizacija bila jednosmjerna.
Razmotrimo ponovno proces vožnje. Uobičajeno je razmotriti cestu nekoliko desetina metara
ispred sebe i predvidjeti sve potencijalne opasnosti. Dok se krećemo cestom, dio puta unutar
okvira našeg dometa vidljivosti se kreće s nama kako bismo uvijek mogli vidjeti sljedećih
nekoliko desetina metara. To je u biti uzmičući horizont, odnosno granica naše vizije (otprilike
200 metara) uvijek se kreće istom brzinom kojom se i mi krećemo – dakle, uzmiče. To znači da
stalno prikupljamo nove informacije iz udaljenog horizonta i ove informacije koriste se za
ažuriranje naših kontrolnih akcija (odluka). Prediktivna kontrola djeluje baš ovako: razmatra se
predviđeno ponašanje unutar nekog horizonta u budućnosti i istovremeno predviđa jedan naredni
uzorak u budućnosti u svakom uzastopnom trenutku uzorkovanja. Budući da su dostupne nove
informacije, ulazna trajektorija se automatski mijenja kako bi se uzela u obzir. Važno pitanje je,
10
međutim, koliko velik bi trebao biti ovaj horizont? Korištenjem ljudske intuicije, očito je da taj
horizont mora biti veći od vremena rješavanja sistema – u suprotnom ignorira se ponašanje s
značajnom dinamikom. Razmislimo o tome šta bi se dogodilo ako smo za vrijeme vožnje gledali
samo 20-ak metara ispred pri brzini 100 km/h (tj. daleko ispod distance kočenja) – sigurno bi se
srušili ili izletili s ceste na prvoj oštroj krivini.
1.1.3 Optimalne ili performanse sigurnosti
Da bismo vrlo precizno upravljali procesom, potreban nam je vrlo precizan model. Neki uvid
u ovo mogu se dati usporedbom sa reketnim sportovima. Kada učite sport, vaš um ima samo
neprecizan model o tome kako pokreti ruku, itd. utiču na putanju lopte. Kao rezultat toga,
kontrola, smjer, itd. su loši. Kako vježbate, vaš interni model postaje tačniji i time poboljšava
kvaliteta vaše igre. Ovo ima značajne uticaje na složenost budućih strategija upravljanja koje se
mogu razmotriti. Početnik koristi jednostavne strategije, jer imaju jednostavan model. Njihov je
cilj zadržati loptu u igri - oni misle samo o trenutnom potezu. Stručnjak, s druge strane, može
razmišljati o nekoliko poteza unaprijed i ciljati loptu vrlo precizno kako bi izgradio otvaranje
kojim bi osvojio poen. Isto vrijedi i za MPC. Nema smisla odabrati sljedećih 10 kontrolnih
poteza za optimiziranje dinamičkih performansi tijekom prijelaza ako imate loš model; bolje je
otići na sigurnu, možda sporiju opciju da se barem krećete u pravom smjeru i odaberete samo
jedan potez. Nasuprot tome, ako imate tačan model, možete pouzdano odabrati kontrolne poteze
tokom većeg budućeg horizonta i očekivati bolje dinamičke rezultate; bilo bi ludo, žrtvujući
potencijal, odabrati samo jedan potez u isto vrijeme.
1.1.4 Tuniranje
Postojalo je historijsko zanimanje za temu tuniranja (podešavanja) prediktivnih zakona o

upravljanju kako bi se osigurala stabilnost, u jednakim količinama koliko postoji znanja o tome
kako podesiti PID. Međutim, kod MPC-a je usvojeno mišljenje da je podešavanje bolje
nadoknaditi specifikacijama željenih performansi. Ako smo dobili pravu funkciju troškova,
stabilnost i tuniranje će se samostalno održavati, kako i po definiciji optimiziramo funkciju
troškova koja može biti mala jedino pri dobrim performansama. Kada se koriste razumne
smjernice, MPC će uvijek rezultirati stabilnom kontrolom (barem za nominalnu) pa su važne
odluke kako izbalansirati između performansi u različitim petljama, dobre osjetljivosti i
ravnoteže između ulaznih aktivnosti i brzine odziva.
Uobičajeno, ovi balansi se postižu težinskim matricama, tj. stavljanjem različitih naglasaka
na performanse u različitim petljama prema njihovoj važnosti. To je ipak neizvjesno, da se takve
težine sistemski mogu konstruirati sa financijskih / operativnih tački gledišta, stoga je općenito
potrebno on-line tuniranje do trenutka uspostave dobrog balansa. Tipična smjernica za dobijanje
dobre početne vrijednosti za težine bi bila normaliziranje svih signala (ulaz i izlaz) tako da je
raspon 0 do 1 jednako važan za svaki signal; zatim koristiti jedinične težine na svim petljama.
11
Teško je generalizirati dalje od toga jer svaki proces ima različite prioritete koji mogu biti suviše
suptilni da bi se uključili u opšte smjernice.
Neki autori smatraju da ne bi trebalo biti skaliranja težinama ulaznih podataka uopće, budući
da je cilj vidjeti izlaze u željenoj tački sa bilo kakvim potrebnim ulazima. U ovom slučaju je
najvažnije da pažljivo postavimo funkciju troškova kako bi izbjegli pretjerano tunirane zakone o
upravljanju i inverziju karakteristika ne-minimalne faze. Na primjer, ne smijemo tražiti nerealno
brzu izmjenu izlaza i ograničiti prostor dopuštenih ulaznih putanja prema onima koji se kreću
glatko.
1.1.5 Manipulisanje ograničenjima
Jedna od glavnih osobina koja prodaje MPC je njegova sposobnost on-line manipulacije
ograničenjima na sistematski način, zadržavajući u određenoj mjeri granice stabilnosti i
performanse zakona bez ograničenja. Algoritam to čini optimiziranjem predviđenih performansi
podložnim zadovoljavanju ograničenja. Na primjer, vozač utrke optimizira brzinu, podložnu
ograničenju da automobil ostaje na stazi. Ako bi optimizirali brzinu bez uzimanja eksplicitnog
razmatranja ograničenja, njihova vremena krugova zapravo bi bila daleko sporija.
Pojedinosti o tome kako su ograničenja uključena uveliko ovise o algoritmu koji se
primjenjuje o čemu nećemo detaljisati. Odabrani algoritam ovisit će o dostupnim sredstvima (tj.
vezan uz potencijalno povećanje dobiti) i vremenu uzorkovanja. Što više možete potrošiti, to ste
bliži pravom ograničenom optimumu koji će vaš algoritam vjerovatno dobiti.
1.1.6 Sistematska upotreba budućih zahtjeva
Prilikom vožnje, ako vidimo krivinu ispred sebe, prilagodimo stanje (brzina, stepen prijenosa,
itd.) automobila tako da možemo sigurno proći krivinu. Tipično, PID tip zakona upravljanja bavi
se krivinom samo kada se nađemo tu uz eventualnu opasnost slijetanja sa ceste zbog
prekomjerne brzine kojom ulazimo u krivinu. Može se dodati feedforward (upravljanje
unaprijed), ali taj dizajn može biti za prvu ruku.
Obrnuto, MPC automatski uključuje feedforward i štaviše to radi na sistemski način.
Optimizacija troškova uzima u obzir buduće promjene u željenoj trajektoriji i mjerljivim
poremećajima i tako ih uključuje kao unutrašnji dio cjelokupnog dizajna kontrole.
1.1.7 Sistematski dizajn upravljanja za multivarijabilne sisteme
Još jedna velika prodajna osobina MPC algoritma jeste da se mogu nositi s multivarijabilnim
(MIMO ili multi-input-multi-output) sistemima na sistematski način. Dobro je poznato da je PID
12
(tradicionalno upravljanje) dizajn za visoko interaktivne MIMO sisteme vrlo zahtjevan. Iako su
rješenja razvijena kroz kombinaciju iskustvo i vrijeme, često su suboptimalna i mogu biti vrlo
raštimovana. Čak i alati poput multivarijabilnog Nyquista često ne dovode do izravnog dizajna.
Poteškoća s podešavanjem PID-a za MIMO sisteme zapravo se odnosi na model; PID tipovi
dizajna koriste relativno malo informacija o postrojenju i stoga nisu u mogućnosti učinkovito se
nositi sa interakcijom. MPC algoritmi, s druge strane, zahtijevaju i koriste model i stoga
iskorištavaju više informacija. Time se sistematski dizajn i analiza znatno olakšavaju. Kod MPC-
a se specificira indeks performansi tako da u nekom smislu imamo sistemski dizajn; to jest,
dobijamo najbolje performanse po cijeni navedenoj za dati model. Iskustvo je pokazalo da je to
učinkovit način rješavanja interakcije (MIMO problemi), a osim toga daje i dobru propusnost i
dobitne / fazne margine za nominalni slučaj.
1.1.8 Matematički opis MPC problema
MPC se zasniva na iterativnoj optimizaciji konačnog horizonta modela sistema. U vremenu

t uzorkuje se trenutno stanje sistema i izračunava strategija kontrole sa minimalnim troškovima
(pomoću numeričkog algoritma za minimizaciju) za relativno kratak vremenski horizont u
budućnosti: [t, t + T]. Konkretno, računanje on-line ili on-the-fly se koristi za istraživanje
trajektorija stanja koje proizlaze iz trenutnog stanja i pronađu (pomoću rešenja Euler-Lagrange
jednačina ) strategiju kontrole minimiziranja troškova do vremena t + T. Samo je prvi korak
strategije upravljanja implementiran, tada stanje sistema se ponovo uzorkuje i proračuni se
ponavljaju počevši od novog trenutnog stanja, dajući novu kontrolu i novu predviđenu putanju
stanja. Horizont predviđanja nastavlja se pomjerati naprijed i iz tog razloga MPC se takođe
zove kontrola povlačećeg horizonta. Iako ovaj pristup nije optimalan, u praksi je dalo vrlo dobre
rezultate. Veliko akademsko istraživanje je učinjeno kako bi se pronašle brze metode rješavanja
jednačina tipa Euler-Lagrange, da bi se shvatile globalne karakteristike stabilnosti lokalnog
optimiziranja MPC-a, i generalno poboljšala MPC metoda. U određenoj mjeri teoretičari
pokušavaju da sustignu inženjere upravljanja kada je u pitanju MPC.
Sl. 1.2 Diskretna šema MPC-a
13
Model Predictive Control (MPC) je multivarijantni algoritam upravljanja koji koristi:
 interni dinamički model procesa
 historiju prošlih kontrolnih poteza i
 funkciju troškova optimizacije J nad povlačućim predviđenim horizontom, da bi

izračunao optimalne poteze kontrole.
Primjer nelinearne funkcije troškova za optimizaciju je dat sa:
𝑁 𝑁
𝐽 = ∑ 𝑤𝑥𝑖 (𝑟𝑖 − 𝑥𝑖 ) + ∑ 𝑤𝑢𝑖 ∆𝑢𝑖 2

2
𝑖=1 𝑖=1
bez narušavanja ograničenja (donja, gornja granica) sa:
𝑥𝑖 : 𝑖 𝑡ℎ kontrolna varijabla (npr. mjerena temperatura)
𝑟𝑖 : 𝑖 𝑡ℎ referentna varijabla (npr. zahtjevana temperatura)
𝑢𝑖 : 𝑖 𝑡ℎ manipulirana varijabla (npr. kontrolisani ventil)
𝑤𝑥𝑖 : težinski koeficijent koji preslikava relativnu važnost 𝑥𝑖
𝑤𝑢𝑖 : težinski koeficijent koji kažnjava relativno velike promjene na 𝑢𝑖 itd.
Nelinearni model prediktivne kontrole ili NMPC je varijanta modela prediktivne kontrole
(MPC) koja se karakteriše upotrebom nelinearnih sistemskih modela u predviđanju. Kao i u
linearnom MPC, NMPC zahtjeva iterativno rješenje problema optimalnog upravljanja na
konačnom horizontu predviđanja. Dok su ovi problemi konveksni u linearnom MPC, u
nelinearnom MPC oni više nisu konveksni. Ovo predstavlja izazove za teoriju stabilnosti NMPC
kao i numeričko rješenje.
Numeričko rješenje problema NMPC optimalnog upravljanja obično se zasniva na direktnim
metodama optimalnog upravljanja pomoću šema optimizacije tipa Newton, u jednoj od
varijanti: direktno jednokratno snimanje , metoda direktnog višekratnog snimanja ili direktna
kolokacija. NMPC algoritmi obično eksploatišu činjenicu da su uzastopni problemi sa
optimalnom kontrolom slični jedni drugima.
Ovo omogućava efikasnu inicijalizaciju postupka rješenja tipa Newton pomoću odgovarajuće
izmjene iz prethodno izračunatog optimalnog rješenja, čime se štede znatne količine vremena
izračunavanja. Sličnost uzastopnih problema se još više koristi kod algoritama za praćenje
putanje (ili "iteracijama u realnom vremenu") koji nikada ne pokušavaju da preusmjere bilo koji
problem optimizacije u konvergenciju, već umjesto toga samo potraži jednu iteraciju ka
rješavanju najnaprednijeg NMPC problema, prije prelaska na sljedeći, koji je prikladno
inicijalizovan.
Iako su aplikacije NMPC-a u prošlosti uglavnom bile korištene u procesnoj i hemijskoj
industriji sa relativno sporim stopama uzorkovanja, NMPC se sve više primjenjuje na aplikacije
14
sa visokim stepenom uzorkovanja, npr. u automobilskoj industriji ili čak kod distribuisanih stanja
u prostoru ( sistemi distribuiranih parametara ). Kao aplikacija u vazduhoplovstvu, nedavno je
NMPC korišten za praćenje optimalnih trajektorija za praćenje / izbjegavanje terena u realnom
vremenu.
Eksplicitni MPC (eMPC) omogućava brzu procjenu kontrolnog zakona (u rasponu od
mikrosekundi), što je u potpunom kontrastu sa online MPC. Eksplicitni MPC zasniva se
na tehnikama parametarskog programiranja , gdje je rješenje problema MPC-a koji se formuliše
kao problem optimizacije unaprijed izračunat offline. Ovo offline rješenje, tj. zakon o kontroli
često je u obliku djelimičnog afinitetnog djelovanja (PWA), pa je dobijanje optimalne kontrole
učinjeno smanjivanjem na samo procjenu funkcije. Pošto implementacija eMPC-a ne zahtjeva
značajne računske resurse (u poređenju sa online MPC-om), ona je jedinstvena za kontrolu
sistema sa brzom dinamikom.
Robusne varijante Model Predictive Control (MPC) mogu da objasne postavljene ograničene
poremećaje pri tome i dalje osiguravajući zadovoljavanje ograničenja stanja. Postoje tri glavna
pristupa robusnom MPC:
Min-max MPC . U ovoj formulaciji optimizacija se vrši u odnosu na sve moguće evoluacije
smetnje. Ovo je optimalno rješenje za linearne robusne probleme upravljanja, ipak nosi visoku
cijenu proračuna.
MPC sabijanja ograničenja. Ovdje se ograničenja stanja uvećavaju za datu marginu, tako da
se može garantovati da će trajektorija biti pronađena pod bilo kojom evoluacijom poremećaja.
Cijev MPC koristi nezavisni nominalni model sistema i koristi kontroler povratne sprege
kako bi se osiguralo da stvarno stanje konvergira nominalnom stanju. Količina razdvajanja koja
se zahtjeva od ograničenja stanja određena je robusnim pozitivno invarijantnim (RPI) skupom,
što predstavlja skup svih mogućih odstupanja stanja koja se mogu javiti usljed smetnje sa
kontrolerom povratne sprege.
Višestepeni MPC koristi formulaciju scenarija stabla aproksimirajući prostor neizvjesnosti sa
skupom uzoraka i pristup je nekonzervativan jer uzima u obzir da su informacije o mjerenju
dostupne u svakom trenutku predviđanja i odluke u svakoj fazi mogu biti drugačije i mogu
djelovati kao sredstvo za suzbijanje efekata neizvjesnosti. Međutim, nedostatak pristupa je da
veličina problema eksponencijalno raste sa brojem neizvjesnosti i horizontom predviđanja.
Komercijalni MPC paketi su dostupni i obično sadrže alate za identifikaciju i analizu modela,
dizajniranje i podešavanje kontrolera, kao i evaluaciju performansi kontrolera.
Istraživanje komercijalno dostupnih paketa pružili su SJ Qin i TA Badgwell u Control
Engineering Practice 11 (2003) 733-764.
Glavne razlike između MPC i LQR su da se LQR optimizuje u fiksnom vremenskom prozoru
(horizontu), dok se MPC optimizuje u vremenskom horizontu koji se povlači, i da se novo
rješenje često izračunava, dok LQR koristi jedno (optimalno) rješenje za cijeli vremenski
horizont. Stoga, MPC omogućava optimizaciju u realnom vremenu pod grubim
ograničenjima iako obično rješava problem optimizacije u manjim vremenskim prozorima nego
unutar cijelog horizonta i stoga dobija suboptimalno rješenje.
15
2.1Šta je muAO-MPC ___________________________________________ Uvod u muAO-MPC
Poglavlje 2
Uvod u muAO-MPC
2.1 Šta je muAO-MPC
 AO-MPC je skraćenica od riječi microcontroller applications online model predictive

control. Sastoji se uglavnom od muaompc Python paketa. Ovaj paket automatski generira
samostalni C-kod specifičan za model prediktivnog upravljanja (MPC) problem. Generirani C
kod je u potpunosti kompatibilan sa ISO C89/C90 standardom, i nezavisan je od platforme. Kod
se može direktno koristit u embedded aplikacijama sa popularnim platformama kao što su
Arduino i Raspbery, ili bilo kojoj aplikaciji koja podržava C/C++ kod, kao što su popularni
programibilni logički kontroleri (PLC). Problem se opisuje u Python modulu kojeg definira
korisnik. Generirani C-kod predstavlja brzu MPC implementaciju spremnu za korištenje.
Trenutno posmatramo sljedeću vrstu sistema:
• linearni vremenski nepromjenljivi i vremenski diskretni sistemi (takozvani ltidt modul)
Osim toga, za generirani kod obezbjeđuje se i MATLAB / Simulink inerfejs.  AO-MPC je

besplatan softver objavljen pod uvjetima BSD licence sa tri klauzule.
2.1.1 ltidt modul
Ovaj modul kreira model prediktivne kontrole (MPC) kontroler za linerane vremenski
nepromjenljive (lti), vremenski diskretne (dt) sisteme sa ulaznim i (opcinalno) ograničenjima
stanja kao i kvadratnu funkciju troškova. MPC problem je formulisan kao konveksan sažetak
kvadratnog programa koji se rješava pomoću proširene Lagrange-ove jednačine uz Nesterovu
gradijentnu metodu.
Opis MPC problema se zadaje u fajl pod nazivom modul sistema (pogledati Modul sistema
za više detalja). Nakon pisanja ovog fajla sljedeći korak je zapravo automatsko generiranje C-
koda. To se radi u dva jednostavna koraka:
1. Stvaranje muaompc objekta iz modula sistema i
2. Pisanje C-koda na osnovu tog objekta
16
2.2Instaliranje softverskih paketa __________________________________ Uvod u muAO-MPC
U nastavku je dat matematički opis podešavanja MPC-a. Sistem predviđen za upravljanje dat
je sa x  = Adx + Bdu, gdje su   C x ,  R n i u  Cu  R m vektor stanja i vektor ulaza. x  je
stanje u sljedećem trenutku uzorkovanja. Vremenski diskretni sistem i ulazne matrice redom su
obilježene sa Ad i Bd.
MPC se podešava na sljedeći način:
1 N 1
min
u
 (( x j  x _ ref j )T Q(x j  x _ ref j )  (u j  u _ ref j )T R(u j  u _ ref j ))
2 j 0
1
 ( x N  x _ ref N ) T P( x N  x _ ref N )
2
zadovoljavajući:
x j 1  Ad x j  Bd u j , j  0,  , N  1
u _ lb  u j  u _ ub, j  0,  , N  1
e _ lb  K x x j  K u u j  e _ ub, j  0,  , N  1
f _ lb  Fx N  f _ ub
x0  x
gdje je cijeli broj N  2 predviđena horizontala. Simetričme matrice Q, R i P su redom

težinske matrice trenutnog stanja, ulaznog i krajnjeg stanja. Ulazi su ograničeni i nalaze se
unutar donje granice u_lb i gornje granice u_ub. Štaviše vektori stanja i ulaza su također
ograničeni pomoću K x i K u kao i gornjom i donjom granicom e _ lb i e _ ub  R q . Pored toga
finalno stanje mora zadovoljiti neka ograničenja data sa f _ lb, f _ ub  R q , i matricom F.
Nizovi x _ ref , i u _ ref označavaju trenutne i ulazne reference redom. One se daju onlajn,
po defoltu.
2.2 Instaliranje softverskih paketa
2.2.1 Zahtjevi instalacije
Potrebna je instalacija sljedećih paketa :

Python interpreter. Ovaj kod je u potpunosti testiran sa Python verzijom 3.2.3, 3.4.3 i Python
2.7.3, 2.7.6
NumPy, testiran verzijom 1.6.2, 1.10.4. On u osnovi upravlja algebarskim operacijama ali
takođe ima i dodatne funkcije.
17
2.2Instaliranje softverskih paketa __________________________________ Uvod u muAO-MPC
C89/90 kompajler. Kako bi kompajlirali generisani kod potreban nam je C/C++ kompajler
koji podržava C89/90 ili kasnije standarde.
Opciono, ukoliko želimo imati još neke dodatne funkcije potrebno je sljedeće:
C99 kompajler. Za kompajliranje Python interfejsa u C kod potreban je kompajler koji
podržava promjenjivu dužinu nizova. GCC, testirana verzija 4.6 i 4.8. To je popularan kompajler
koji podržava standard C90 i C99 programskog jezika C. U stvari bilo koji kompajler koji
podržava C90/C99 bi trebao da radi. To isključuje Visual C ++ Express Edition (neće raditi jer
ne podršava C99). GCC port za Windows je MinGW.
SciPy verzija 0.11 ili novija se preporučuje jer obezbjeđuje nekoliko funkcija.
Slycot se koristi za izračunavanja stabilizacijskih matrica.
2.2.2 Bildanje i instalacija
Instalacija muaompc se vrši direktno iz source koda.

Instaliranje iz source koda na Linuxu i Mac OS X izvodimo na sljedeći način:
Linux i Mac OS X korisnici uglavnom imaju sve potrebne pakete već instalirane. Da bi
instalirali muaompc, prebacimo se u folder gdje smo ga raspakovali (trebao bi postojati fajl
setup.py) i u terminal tipkamo:
python setup.py install –user --force
Opcija --user naglašava da nisu potrebne administratorske privilegije. Opcija --force će

prepisati stare fajlove ako postoje iz prethodne instalacije. Općenito za globalnu instalaciju
tipkajte:
sudo python setup.py install --force
I to je sve što se tiče instaliranja paketa. U nastavku će biti opisano kako koristiti dati
program.
Instaliranje iz source koda na Windows sistemima izvodimo na sljedeći način:
Kako Windows sistemi po defoltu ne sadrže potrebne pakete, savjet je da se alat instalira pod
Linuxom ili OS X ako je moguće. Ako je Windows preferiran, preporučuje se instaliranje
Anaconda platforme koja sadrži sve neophodne python pakete. Ako ne postoji prethodno
iskustvo sa instaliranjem softvera baziranih na C ekstenziji pod Windowsom, savjet je instalirati
muaompc toolbox bez Python interfejsa.
Za punu instalaciju muaompc radimo sljedeće:
Instaliramo C99 kompajler, npr Visual Studio 2015 Community Edition ili MinGW.
18
2.1Razvoj open source softvera ___________________________________ Uvod u muAO-MPC
Instaliramo Anacondu. Pobrinuti se da je Anaconda konfigurisana ispravno da koristi

odabrani kompajler.
Otvorimo Anaconda Prompt, pozicioniramo se u folder gdje smo otpakovali muaompc
(folder koji sadrži setup.py), i tipkamo:
python setup.py install --force
Ako preferiramo instalaciju muaompc bez Python interfejsa za C kod, dovoljno je instalirati
Anacondu (nije potreban Visual Studio ili drugi kompajleri) i pratimo sljedeća uputstva.
Za instalaciju bez Python interfejsa (bez opcije kompajliranja) dovoljno je postupiti na
sljedeći način:
Za sve operativne sisteme (Linux, Windows, OS X), ako C99 kompajler nije dostupan, ili
Python interfejs za C kod nije potreban (npr. želimo samo generisati C kod za korištenje u
mikrokontroleru, nekoj C/C++ aplikaciji, ili za MATLAB interfejs) muaompc može biti
instaliran bez Python interfejsa na sljedeći način:
Pozicioniramo se u folder gdje smo otpakovali muaompc (folder koji sadrži setup.py i
install.cfg),
Deaktiviramo Python interfejs mjenjanjem konfiguracijskog fajla install.cfg:
Zamjenimo {"interface": 1} sa {"interface": 0} i sačuvamo fajl.
Nastavimo instalaciju toolboxa kao u prethodnom slučaju, npr. za Windows startamo
Anaconda Prompt, prebacimo se u muaompc folder i tipkamo:
python setup.py install --force
2.1 Razvoj open source softvera
µAO-MPC je razvijen u labaratoriji za teoriju Sistema i automatsko upravljanje Instituta za

automatizacijsko inžinjerstvo, Oto von Guerike univerziteta, Magdeburg, Njemačka. Glavni
autori su Pablo Zometa, Markus Kögel i Rolf Findeisen. Dodatni doprinos dali su Sebastian Hörl
i Yurii Pavlovskyi.
19
2.2Pregled promjena ____________________________________________ Uvod u muAO-MPC
2.2 Pregled promjena
Verzija 0.4.0
 Nema potrebe za specificiranjem referentnog vektora koje nisu potrebne (u C kodu)
 Pojednostavljena instalacija sa opcijom koja ne dodaje kompajler
 Poboljšana kompatibilnost sa definicijom tipa integer
 Dodata mogućnost generisanja koda u jednom folderu
 Dodat Arduino primjer

Verzija 0.3.2.
 Popravljen početni unos Lagranžovih faktora
 Popravljena simulacija za primjere ulaznih ograničenja

Verzija 0.3.1.
 Popravljena greška pri izračunavanju vrijednosti krajnje težinske matrice sa 'auto'

ključnom riječi.
Verzija 0.3.0.
 Potpuna provjera ispravnosti MPC podešavanja
 Poboljšan ispis grešaka sa 'auto' ključnom riječi
 Kazneni parameter je sada opcionalan
 Provjera da je generirani QP striktno konveksan
 Dodata simulacijska klasa
 Nekoliko ispravljenih grešaka
 Neki kodovi su izbrisani

Verzija 0.2.1.
 Poboljšana dokumentacija (više primjera)
 Poboljšana Windows instalacija (podrška MSVC++ kompajlera)

Verzija 0.2.0
 Izvorno izdanje
20
3.1Kratak uvod u Python _________________________________________ Način rada softvera
Poglavlje 3
Način rada softvera
U ovom poglavlju predstavljamo vrlo jednostavan, korak po korak, tutorial koji naglašava
glavne karakteristike muaompc. Razmatraćemo dva primjera za ltidt modul. Tutorial za ovaj
modul razmatra dva tipa MPC problema:
1. Mali sistem samo sa ulaznim ograničenjima
2. Veći sistem sa mješovitim ograničenjima.
Prvi primjer pomaže pri razumjevanju same procedure automatskog generiranja koda. Drugi
primjer pokazuje najčešće karakteristike muaompc paketa. Prije nego nastavimo sa muaompc
tutorialom daćemo kratak uvod u Python vještine potrebne za pisanje sistemskog modula.
3.1 Kratak uvod u Python
Napomena: Ukoliko ste već upoznati sa Python-om možete preskočiti ovo poglavlje. Sve što
trebate znati je da se matrice koje opisuju MPC postavke unose kao liste listi ili kao
dvodimenzionalni NumPy nizovi ili NumPy matrice.
Iako poznavanje Python-a nije potrebno za korištenje ovog alata postoji nekoliko stvari za
koje bi korisnici koji nisu upoznati sa Pythonom trebali znati prije prelaska na sljedeći odlomak:
1. Prazan prostor se računa
2. Python liste pomažu u kreiranju matrica
3. NumPy obezbjeđuje neku funkcionalnost sličnu MATLAB-u
4. Indeksi nizova počinju nulom
Slijedi detaljno objašnjenje svake od ovih stavki.
21
3.1Kratak uvod u Python _________________________________________ Način rada softvera
3.1.1 Prazan prostor
Prilikom pisanja modula sistema u narednim poglavljima pazite da nema praznog prostora
(kao što je tab, space itd) na početku svake linije.
3.1.2 Python liste
Python liste predstavljaju kolekciju objekata odvojenih zarezima unutar kvadratnih zagrada.
Matrice i vektori se unose kao liste numeričkih listi. Na primjer jedinična matrica 2x2 unosi se
kao:
I = [[1, 0], [0, 1]]
Dok se 2x1 vektor kolona unosi kao:
c = [[5], [5]]
Striktno govoreći I i c nisu matrice ali se interno pretvaraju u njih uz pomoć ltdit modula.
3.1.3 NumPy
Na vrhu modula sistema piše se:
from numpy import *
Ovo omogućava korištenje nekih funkcija sličnih onima u MATLABu. Od posebnog interesa
su: diag, eye, zeros, ones. Na primjer jedinična matrica 2x2 može se unijeti kao
I = eye(2)
ili
I = diag([1, 1])
Naredbe zeros i ones imaju poseban zapis jer zahtjevaju veličinu matrice kao listu. Na
primjer, vektor kolona c odozgo može se zapisati kao
c = 5 * ones([2, 1])
22
3.2Osnovni MPC problem ________________________________________ Način rada softvera
3.1.4 Indeksiranje
Na kraju nekoliko napomena o indeksiranju. Jediničnu matricu 2x2 možemo zapisati i u

sljedećim oblicima:
I = zeros([2, 2])
I[0, 0] = 1
I[1, 1] = 1
Primjetimo da indeksiranje počinje od nule, dakle pravila su slična onim u MATLABu. Za
više informacija pogledati Python tutorial i NumPy tutorial za MATLAB korisnike.
3.2 Osnovni MPC problem
Generiranje koda opisano u ovom poglavlju sastoji se od sljedećih koraka:

1. Napisati sistemski modul sa opisom MPC problema
2. Napraviti muaompc objekt od tog problema
3. Napisati c kod za dati objekt
3.2.1 Opis MPC problema
Najjednostavniji problem koji može biti podešen za litdt modul je problem sa ograničenim
ulazima. Jedan od primjera toga nalazi se unutar tutorial foldera
muaompc_root/muaompc/_ltidt/tutorial, gdje je muaompc_root putanja za root folder u kojem
su ekstraktovani muaopc izvori (sources).
Mi kao sistem posmatramo DC-motor koji se može predstaviti sa:
 
1
y T
( Ku  y )
Gdje je T vremenska konstanta izražena u sekundama a K faktor pojačanja. Vremenski


kontinualna reprezentacija prostora stanja x  Ac x  Bc u data je sljedećom matricom
0 1  0
Ac   1  , Bc   K 
0  T   T 
23
sa vektorom stanja x  x1 x2 T , gdje su x1 i x 2 položaj rotora i ugaona brzina respektivno.

Ulaz je PWM napon što prestavlja procenat pune skale napona koji koristi motor. Samim tim
može biti između -100% i 100%. Ovaj uslov se piše kao  100  u  100 . Kako vremenski
kontinualan sistem treba biti kontrolisan od strane MPC digtalnog kontrolera, treba biti izabrana
odgovarajuća vremenska diskretizacija. Pravilo je da za nju izaberete jednu desetinu vremenske
T
konstante sistema, dt  .
10
Napomena: Za diskretizaciju sistema potrebno je instalirati SciPy.
Parametri kontrolera
Horizontalna dužina je navedena kao koraci parametra N. U ovom slučaju izaberemo
vrijednost N=10. Dodatni parametri za kontroler su težinske matrice. Obično se biraju
postupkom podešavanja. Za ovaj primjer podesit ćemo ih da budu jedinične matrice
odgovarajuće veličine, odnosno, Q  I  R 2 x 2 , i R  1. Pored toga podesit ćemo P kao “auto“ pa
će je računati kao stabilizirajuću matricu.
Napomena: za korištenje “auto“ funkcije mora biti instaliran Slycot.
Sistem modul
Sada imamo potrebne informacije za pisanje Python sistemskog modula. Jedini zahtjevi su da
sadrži odgovarajuću Python sintaksu, ime matrica treba biti kako je opisano u sekciji sistemski
modul i naziv fajla treba završavati sa .py. U svom tekst editoru otipkajte sljedeće:
T = 0.1
K = 0.2
dt = T / 10
N = 10
# continuous time system
Ac = [[0, 1], [0, -1/T]]
Bc = [[0], [K/T]]
# input constraints
u_lb = [[-100]]
u_ub = [[100]]
# weighting matrices
Q = [[1, 0], [0, 1]]
R = [[1]]
P = "auto"
Sačuvajte ga kao sys_motor.py.
3.2.2 Generiranje C koda
Sada kad smo napisali sys_motor.py modul nastavljamo sa kreiranjem mpc objekta. U
folderu koji sadrži sys_motor.py pokrenemo svoj Python interpreter i unesemo:
24
import muaompc
mpc = muaompc.ltidt.setup_mpc_problem("sys_motor")
mpc.generate_c_files()
I to je to. Ako je sve prošlo kako treba unutar trenutnog foldera trebao bi se nalaziti novi
folder pod nazivom cmpc. Kao alternativa za unošenje prethodnog koda možmo pokrenuti fajl
main_motor.py u tutorijal folderu koji sadrži upravo taj kod. Tutorijal folder već sadrži
sys_motor.py primjer. U narednom poglavlju pokazat ćemo kako se koristi generisan C kod.
Savjet: ako generisanje C koda nije bilo uspješno probajmo proslijediti ulazni parametar
verbose=True u funkciju setup_mpc_problem. Ispisat će dodatne informacije o postupku
generisanja koda. Na primjer:
mpc = muaompc.ltidt.setup_mpc_problem("sys_motor", verbose=True)
Savjet: po defoltu generisani C kod koristi dvostruku preciznost - float (64-bitni) za sve
proračune. Moguće je definisati različite numeričke reprezentacije preko ulaznog parametra
numeric funkcije generate_c_files. Na primjer za korištenje jednostruke preciznosti (32-bitni)
brojeva, utipkajte sljedeće:
mpc.generate_c_files(numeric="float32")
3.2.3 Korištenje generisanog C-koda
U cmpc folderu naći ćete sve automatski generisane kodove za trenutni primjer. Uključujući i
primjer Makefile koji kompajlira generisani kod u biblioteku koristeći GNU kompajler kolekciju
(gcc). Potrebno je prilagoditi Makefile instaliranom kompajleru.
Sada nastavljamo ka korištenju generisanog c-koda. Napravimo main_motor.c u postojećem
folderu (jedan nivo iznad cmpc foldera). Prva stvar koju trebamo uključiti je fajl zaglavlja
biblioteke koje se nalazi na putanji cmpc/include/mpc.h. Prije nego nastavimo, primjetimo
nekoliko stvari. mpc.h zaglavlje stavlja programeru na raspolaganje nekoliko korisnih konstanti,
na primjer MPC_STATES je broj stanja, MPC_INPUT je broj ulaza (sve dostupne konstante se
nalaze unutar cmpc/include/mpc_const.h). Ovo nam pomaže da na lak način definišemo za sve
varijable odgovarajuće veličine. Pored toga cmpc/include/mpc_base.h sadrži definiciju tipa
real_t, koji se koristi za sve numeričke operacije i algoritame. Na taj način je lako promijeniti
numerički tip cijelog algoritma (na primjer od jednostruke preciznosti do dvostruke preciznosti).
U ovom primjeru je po defoltu postavljen nivo dvostruke preciznosti. Imajući ovo u vidu
možemo deklarisati vektor stanja kao real_t x[MPC_STATES]; unutar naše main funkcije.
Moramo imati pristup nekim od varijabli algoritma, na primjer MPC ulazima sistema i
postavkama algoritma. To se radi kroz polja struct mpc_ctl strukture (deklarisane u mpc_base.h).
Instanca ove strukture je automatski definirana i nazvana ctl. Da bi joj pristupili u našem
programu moramo je deklarisati u našoj main funkciji kao extern struct mpc_ctl ctl.
25
Sljedeći korak je konfiguracija algoritma. U ovom slučaju imamo ograničen ulaz. Jedini
parametar koji trebamo podesiti je iteracija algoritma. Za ovaj jednostavni slučaj uzećemo deset
iteracija postavljajući ctl.conf->in_iter = 10.
Pretpostavimo da je trenutno stanje x  0.1  0.5T . Možemo riješiti naš MPC problem za
ovo stanje ako pozovemo mpc_ctl_solve_problem(&ctl, x);. Rješenje se smješta u niz
veličine MPC_HOR_INPUTS (dužina horizonta pomnožena brojem ulaza) prikazan u ctl.u_opt.
Možemo pristupiti njegovom prvom element koristeći zapis ctl.u_opt[0]. Primjer
kompletnog koda izgleda ovako:
#include <stdio.h> /* printf */
#include "cmpc/include/mpc.h"
int main(void)
{
real_t x[MPC_STATES];
extern struct mpc_ctl ctl;
ctl.conf->in_iter = 10;
x[0] = 0.1;
x[1] = -0.5;
mpc_ctl_solve_problem(&ctl, x);
printf("u[0] = %f \n", ctl.u_opt[0]);
printf("\n SUCCESS! \n");
return 0;
}
U tutorial folderu se između ostalog nalazi i main_motor.c fajl sa kodom iznad zajedno sa
makefileom. Kompajliramo kod tipkajući make motor (možda bude potrebno modifikovati
Makefile ili napraviti vlastiti). Ako je kompajliranje bilo uspješno trebali bi vidjeti novi exe fajl
pod nazivom motor. Ako ga pokrenemo na kraju teksta ispisanog na konzoli trebali bi vidjeti
riječ SUCCESS!
Napomena: Pri svakom auto generiranju C koda izbriše se cijeli cmpc folder pa se zato kao
mjera opreza preporučuje da nikakve važne fajlove ne snimamo u taj folder.
3.2.4 Testiranje sa Python-om
Python interfejs predstavlja korisnika sa gotovo jednakom funkcionalnošću kao i generisani

kod. Međutim njegova jednostavna sintaksa i jaka biblioteka za naučne proračune čini ga
odličnom podlogom za stvaranje prototipa. Uporedimo ga sa običnom C implementacijom. Baš
kao i u C tutorijalu prebacimo se na tutorial folder, pokrenimo svoj Python 3 interpreter i tu
ukucajmo:
26
3.3Složeniji MPC problem ________________________________________ Način rada softvera
import muaompc
import numpy as np
mpc = muaompc.ltidt.setup_mpc_problem("sys_motor")
Mpc objekat sadrži mnoge metode i strukture podataka koje će pomoći da testiramo svoj
kontroler prije implementacije u C-u. Već prije smo spominjali metod generate_c_files. Python
interfejs će se automatski podesiti za MPC kontoler odmah nakon što pristupimo ctl atributu
našeg mpc objekta, bez potrebe za kompajliranjem bilo čega. Stoga isto možemo dobiti kao u
prethodnom C kodu sa jednostavnijom Python sintaksom. U Python interpreter utipkamo
sljedeće:
ctl = mpc.ctl
ctl.conf.in_iter = 10
x = np.matrix([[0.1], [-0.5]])
ctl.solve_problem(x)
print(ctl.u_opt[0])
print("SUCCESS!")
Uporedimo sa prethodnim C kodom.
3.3 Složeniji MPC problem
U ovom poglavlju razmotrićemo nešto složeniji problem. Međutim postupak koji slijedimo je
isti: prvo opisati problem, zatim generisati iz njega C kod i na kraju koristiti generisani kod.
3.3.1 Opis MPC problema
Razmatrat ćemo problem koji predstavlja mnoge funkcije dostupne u ltidt modulu. Kod za
ovaj primjer može se naći unutar tutorial foldera muaompc_root/muaompc/_ltidt/tutorial, gdje je
muaompc_root putanja do root foldera muaompc.
Sljedeći je razmatran sistem u Cessna Citation 500 avionima predstavljen u ([4] strana 64).
.
Kontinuirano vremenski linearni model je dat sa x  Ac x  Bc u, y  Cx , gdje je
  1.2822 0 0.98 0  0.3

 0   0   0 1 0 0
Ac  
0 1 0  0 1 ,
, Bc   , C 
 0 0
 5.4293 0  1.8366 0   17 
     128.2 128.2 0 0
  128.2 128.2 0 0  0 
i vektor stanja je dat sa x  x1 x2 x3 x4  , gdje

T
27
x1 je upadni ugao (rad),
x 2 je ugao terena (rad),
x3 je ugaona brzina (rad/s)
x 4 je visina (m)
Jedini ulaz u1 je ugao lifta (rad). Izlazi su y1  x2 , y 2  x4 a y3  128.2 x1  128.2 x 2 je

brzina (m/s).
Sistem je podložan sljedećim ograničenjima:
Ograničenje ulaza  0.262  u1  0.262

.
Raspon stope ograničenja ulaza  0.254  u1  0.254
Ograničenje stanja  0.349  x2  0.349
Ograničenje izlaza  30.0  y3  30.0
Da bi razmatrali raspon stope ograničenja na ulaz uvodimo dodatno stanje x5 . Interval

uzorkovanja je dt=0.5s a dužina intervala iznosi N=10.
Parametri kontrolera
Knjiga ([4]) predlaže korištenje jediničnih matrica odgovarajućih dimenzija kao težinske
matrice Q i R. Umjesto toga izabraćemo ih kao dijagonalne matrice koje daju slične preformanse
kontrolera i mnogo manji broj Hessiana MPC kvadratnog programa, željena mogućnost pri bilo
kojem numeričkom algoritmu.
Sistemski modul
U ovom slučaju naš sistemski modul se naziva sys_aircraft.py. On je već diskretizovan jer je
raspon stope ograničenja lakše uključiti na ovaj način. To izgleda ovako:
from numpy import diag # similar effect with: from numpy import *
dt = 0.5
N = 10
mu = 100
# discrete-time system
Ad = [[ 0.23996015, 0., 0.17871287, 0., 0.],
[ -0.37221757, 1., 0.27026411, 0., 0.],
[ -0.99008755, 0., 0.13885973, 0., 0.],
[-48.93540655, 64.1, 2.39923411, 1., 0.],
[0., 0., 0., 0., 0.]]
Bd = [[-1.2346445 ],
[-1.43828223],
28
[-4.48282454],
[-1.79989043],
[1.]]
# Weighting matrices for a problem with a better condition number
Q = diag([1014.7, 3.2407, 5674.8, 0.3695, 471.75])
R = diag([471.65])
P = Q
# input constraints
eui = 0.262 # rad (15 degrees). Elevator angle.
u_lb = [[-eui]]
u_ub = [[eui]]
# mixed constraints
ex2 = 0.349 # rad/s (20 degrees). Pitch angle constraint.
ex5 = 0.524 * dt # rad/s * dt input slew rate constraint in discrete time
ey3 = 30.
# bounds
e_lb = [[-ex2], [-ey3], [-ex5]]
e_ub = [[ex2], [ey3], [ex5]]
# constraint matrices
Kx = [[0, 1, 0, 0, 0],
[-128.2, 128.2, 0, 0, 0],
[0., 0., 0., 0., -1.]]
Ku = [[0],
[0],
[1]]
# terminal state constraints
f_lb = e_lb
f_ub = e_ub
F = Kx
Prije nego nastavimo napravićemo nekoliko napomena. Koristimo Numpy pri formiranju
diagonalnih matrica Q i R uz pomoć funkcije diag. Konačno uporedimo naziv varijabli
korištenih u sistemskom modulu sa MPC problemom opisanom u odjeljku litdt modul. Pored
toga opcioni kazneni parameter mu je izabran koristeći procedure opisane u dijelu Osnove
tuniranja. Konačno težinske matrice Q i R su od jediničnih matrica pretvorene u matrice
prikazane iznad koristeći funkcije u odjeljku Podešavanje Hessian-a.
3.3.2 Generisanje C koda
Sada kad smo napisali system modul nastavljamo sa kreiranjem instance muaompc.ltidt
klase. Prebacimo se u folder koji sadrži fajl sys_aircraft.py i u Python interpreter utipkajmo
sljedeće:
import muaompc
mpc = muaompc.ltidt.setup_mpc_problem(’sys_aircraft’)
mpc.generate_c_files()
Ako je sve uredu pojaviće se novi folder pod nazivom cmpc. Ili jednostavnije prebacimo se u
tutorial folder i pokrenemo fajl main_aircraft.py, koji sadrži isti Python kod kao ovaj iznad.
29
3.3.3 Korištenje generisanog C koda
Unutar cmpc foldera nalazi se automatski generisan kod za prethodni primjer (ukoliko ste
prethodno generisali kod za osnovni tutorial bit će prepisan). Uključen je također i Makefile koji
kompajlira generisan kod u biblioteku koristeći GNU kolekciju kompajlera (GCC). Sljedeći
korak je iskoristiti generisani kod. Prvi dio main_aircraft.c fajla smješten u tutorial folderu
identičan je prvom djelu main_aircraft.c fajla koji se nalazi u osnovnom MPC problemu.
Konfiguracija algoritma
Sljedeći korak je konfiguracija algoritma. U ovom slučaju imamo sistem sa ulaznim
ograničenjima i ograničenjima stanja. Jedini parametar koji trebamo podesiti je broj ponavljanja
algoritma. Algoritam sa ograničenim ulazima je produžena Lagrangeova metoda što znači da
zahtjeva petlju sa dvostrukom iteracijom (unutrašnja i spoljašnja petlja).
Simulacijom utvrđujemo da sa 24 unutrašnje iteracije i dvije spoljašnje dobijamo prihvatljivu
aproksimaciju MPC problema koristeći warmstart strategiju.
ctl.conf.in_iter = 24; /* number of internal iterations */
ctl.conf.ex_iter = 2; /* number of external iterations */
ctl.conf.warmstart = 1; /* automatically warmstart algorithm */
Simulacija zatvorenom petljom

Konačno možemo simulirati naš sistem. Počinjemo sa proizvoljnim stanjem
x  (0,0,0,400,0) T , a kontroler bi trebao dovesti sistem u početno stanje. U ovom slučaju
simuliramo za s=40 koraka. Za ovo stanje problem rješavamo pozivajući se na
mpc_ctl_solve_problem(&ctl, x). Rješenje se dobiva kao niz veličine
MPC_HOR_INPUTS (broj ulaza pomnožen sa dužinom) prikazanom u ctl.u_opt. Možemo
pristupiti njegovom prvom elementu koristeći notaciju zapisivanja nizova ctl.u_opt[0].
Funkcija mpc_predict_next_state mjenja trenutno stanje sa narednim. Primjer kompletnog
koda izgleda ovako:
#include <stdio.h> /* printf */
#include "cmpc/include/mpc.h" /* the auto-generated code */
/* This file is a test of the C routines of the ALM+FGM MPC

* algorithm. The same routines can be used in real systems.
*/
int main(void)
{
real_t x[MPC_STATES]; /* current state of the system */
extern struct mpc_ctl ctl; /* already defined */
int i; /* loop iterator */
int j; /* print state iterator */
int s = 40; /* number of simulation steps */
ctl.conf->in_iter = 24; /* iterations internal loop */
30
ctl.conf->ex_iter = 2; /* iterations external loop */

ctl.conf->warmstart = 1; /* warmstart each iteration */
/* The current state */

x[0] = 0.;
x[1] = 0.;
x[2] = 0.;
x[3] = -400.;
x[4] = 0.;
for (i = 0; i < s; i++) {

/* Solve and simulate MPC problem */
mpc_ctl_solve_problem(&ctl, x); /* solve the MPC problem */
mpc_predict_next_state(&ctl, x);
/* print first element of input sequence and predicted state */
printf("\n step: %d - ", i);
printf("u[0] = %f; ", ctl.u_opt[0]);
for (j = 0; j < MPC_STATES; j++) {
printf("x[%d] = %f; ", j, x[j]);
}
}
printf("\n SUCCESS! \n");
return 0;
}
Pokretanje koda
Unutar trenutnog foldera nalazi se između ostalog i fajl main_aircraft.c koji sadrži prethodni
kod skupa sa Makefile-om. Kompajlirajte kod tipkajući make aircraft (možda će biti potrebno
urediti Makefile). Ukoliko je kompilacija bila uspješna pojaviće se novi fajl pod nazivom
aircraft. Ukoliko ga pokrenete ispisaće riječ SUCCEESS! na dnu tekst displeja u konzoli.
3.3.4 Testiranje sa Python-om
Probajmo sada sve to koristeći Python interfejs. Kao i inače pozicioniramo se u tutorial
folder, pokrenemo svoj Python interpreter i u njemu napišemo:
import muaompc
import numpy as np
mpc = muaompc.ltidt.setup_mpc_problem("sys_aircraft")
ctl = mpc.ctl
s = 40
ctl.conf.in_iter = 24
ctl.conf.ex_iter = 2
ctl.conf.warmstart = True
n, m = mpc.size.states, mpc.size.inputs
x = np.zeros([n, 1])
x[3] = -400
for i in range(s):
31
3.4Koji je sljedeći korak? _________________________________________ Način rada softvera
x = mpc.sim.predict_next_state(x, ctl.u_opt[:m])
# x = ctl.sys.Ad.dot(x) + ctl.sys.Bd.dot(ctl.u_opt[:m]) # predict
print("step:", i, "- u[0] = ", ctl.u_opt[0], "; x = ", x.T)
print("SUCCESS!")
U usporedbi sa C kodom iznad primjetićemo nekoliko stvari. Funkcija slična

mpc_predict_next_state je dostupna u Pythonu unutar objekta sim. Ova je funkcija
pogodna za C i Python jer radi upravo ono što zahtjeva linija označena sa # predict. Primjetimo
da su u Pythonu i u C-u struktura ctl.sys i mnoge druge strukture dostupne. MPC objekat (koji
nije dostupan u C-u) nudi u Pythonu dodatne strukture podataka. U ovom primjeru koristili smo
mpc.size koja sadrži veličinu svih vektora i matrica. Također primjetimo da su ctl.sys.Ad i
x NumPy nizovi pa otuda potreba za krištenje dot metode.
3.4 Koji je sljedeći korak?
Nekoliko primjera se nalazi u folderu muaompc_root/examples. Detaljnija objašnjenja 𝜇AO-

MPC funkcionalnosti su prikazani u narednim poglavljima.
32
4.1Kreiranje MPC kontrolera _________________________________________ MPC kontroleri
Poglavlje 4
MPC kontroleri
Ovo poglavlje se bavi implementacijom MPC kontrolera. Uglavnom govori o generisanju

offline koda i online pronalaženja približnog rješenja za MPC problem optimizacije. Objašnjene
su detaljno sve funkcije dostupne korisniku 𝜇AO-MPC. Primjetimo da ovo poglavlje nije
namjenjeno za predstavljanje ili kao tutorial MPC programa već se više odnosi na funkcionalnost
softvera.
4.1 Kreiranje MPC kontrolera
Ovaj odjeljak detaljno objašnjava generisanje MPC kontrolera za date MPC postavke.
4.1.1 MPC podešavanja
Sistem koji ćemo kontrolisati je dat sa x   Ad x  Bd u gdje x  Cn  R n i u  Cm  R m

predstavljaju trenutnu vrijednost i vektor ulaza a x  je stanje u sljedećem koraku uzorkovanja.
Diskretno vremenski sistem i ulazna matrica se zapisuju kao Ad i Bd respektivno.
MPC podešavanje je prikazano sa:
1 N 1
min imize  (( x j  x _ ref j )T Q( x j  x _ ref j ) 
u 2 j 0
(u j  u _ ref j ) T R(u j  u _ ref j )) 

1
( x N  x _ ref N ) T P( x N  x _ ref N )
2
Gdje je x j 1  Ad x j  Bd u j , j  0,..., N  1
33
u _ lb  u j  u _ ub, j  0,..., N  1
e _ lb  K x x j  K u u j  e _ ub, j  0,..., N  1
f _ lb  Fx N  f _ ub
x0  x
Gdje je cijeli broj N  2 predviđeni horizont. Simetrične matrice Q, R i P su trenutno stanje,

ulaz i krajnje stanje težinskih matrica respektivno. Ulazi su ograničeni sa donje strane sa u_lb i
sa gornje strane sa u_ub. Dalje, vektor trenutnog stanja i ulazni vektor su takođe ograničeni uz
pomoć Kx i Ku i omeđeni donjom i gornjom granicom e_lb i e_ub  R q . I na kraju konačno
stanje treba zadovoljiti neka ograničenja definisana sa f _ lb, f _ ub  R p i matricom F.
Sekvence x_ref i u_ref označavaju reference stanja i ulaza redom. Date su online. Po defoltu
referenca je početne vrijednosti.
4.1.2 Sistem modul
Matrice koje opisuju MPC postavke čitaju se iz system modula. U osnovi system modul se i
sastoji od matrica koje opisuju MPC postavke.
Sistem matrice mogu biti date u diskretnom ili kontinuiranom vremenu.
 u prvom slučaju nazivamo ih Ac i Bc redom i u ovom slučaju je neophodan SciPy
 u drugom slučaju kod diskretno vremenskog prostora nazivamo ih Ad i Bd redom
 vrijeme diskretizacije nultog reda definišemo sa dt u oba slučaja.

Težinske matrice trenutnog stanja i ulaza Q i R moraju biti nazvane Q i R redom
Terminalna težinska matrica P naziva se P. Može biti deklarisana kao „auto“ i u tom slučaju
će se računati kao stabilizirajuća matrica (potreban je Python paket Slycot).
Donja i gornja ograničenja ulaza u_lb, u_ub nazivaju se u_lb, u_ub redom.
MPC dužina intervala N predstavlja korake (ne vrijeme) i to je cijeli broj veći od jedan koji
nazivamo N.
Osim toga za problem ograničavanja stanja potrebno je sljedeće:
Mješovita ograničenja
- donja i gornja granica mješovitog ograničenja e _ lb, e _ ub  R q trebaju se imenovati kao

e_lb i e_ub redom.
- K x se imenuje kao Kx
34
- K u se može imenovati kao Ku. Ako nije određen postavlja se kao nulta matrica
odgovarajuće veličine.
Ako bilo koji od e_lb, e_ub ili Kx nije definisan tada se smatra da je MPC postavka bez
ograničenja trenutnog staja.
Ograničenja terminalnog stanja su opciona:
 Granice terminalnog stanja f _ lb, f _ ub  R q nazivaju se f_lb i f_ub redom.
 F, matrica ograničenja terminalnog stanja se naziva F.
 ukoliko bilo koje od F, f_lb ili f_ub nisu određeni svako od njih se postavlja kao Kx, e_lb,
e_ub redom.
Parametar odstupanja µ od proširene Lagrangeove metode je opcionalan. Ako je naveden
onda se mora nazvati mu i mora biti pozitivan realan broj. Ako nije naveden onda se računa
automatski što se i preporučuje.
Sve matrice se prihvataju kao Python liste listi ili kao numpy nizovi ili numpy matrice.
Sistem modul se može zapisati i kao MATLAB mat fajl koji se sastoji od potrebnih matrica
koristeći njihove navedene nazive.
Na primjer, ulazno ograničen vremenski kontinualan LTI sistem drugog reda može biti
opisan sljedećeim system.py Python modulom:
Ac = [[0, 1], [-1, -1]]
Bc = [[0], [1]]
dt = 0.5
N = 10
Q = [[1, 0], [0, 1]]
R = [[1]]
P = Q
u_lb = [[-10]]
u_ub = [[10]]
4.1.3 Kreiranje Python MPC objekta
Sljedeća funkcija kreira MPC objekat za sistem modul. Funkcija pripada ltidt modulu.
ltidt.setup_mpc_problem (system_name, verbose=False)
Kreiramo MPC objekat za dati sistem modul.

Parametri:
 system_name (string ili Python modul) – string sa nazivom Python modula koji sadrži
opis sistema npr. za system.py sistem_name=“system“, ili system_name=“system.py“.
35
može biti također ime MATLAB mat fajla. U tom slučaju naziv fajla mora imati
ekstenziju .mat npr za system.mat parametar je dat sa system_name=“system.mat“.
Uslovno, Python modul može biti dat kao ulaz. Pa tako ako uradimo import system onda
je system_name=system.
 verboose (bool) ukoliko je vrijednost True na ekranu prikazuje informacije vezane za

problem.
Vraća instancu odgovarajuće MPC klase za dati sistem modul.
Na primjer, pretpostavimo da system1.py i system2.mat oba sadrže iste MPC postavke, tada
možemo pisati:
import muaompc
mpcx = muaompc.ltidt.setup_mpc_problem("system1") # short way
mpcy = muaompc.ltidt.setup_mpc_problem("system1.py", verbose=True)
mpcz = muaompc.ltidt.setup_mpc_problem("system2.mat") # MATLAB way
# The three objects, mpcx, mpcy, and mpcz contain the same information
Veoma brzo možemo kreirati postavke koje se jako malo razlikuju:

from muaompc.ltidt import setup_mpc_problem
import system
system.N = 10 # set horizon length to 10 steps

mpcx = setup_mpc_problem(system) # system is a module, not a string
system.N = 5 # same setup but with a shorter horizon
mpcy = setup_mpc_problem(system) # mpcx is not the same as mpcy
4.1.4 Generisanje C koda
Sljedeća funkcija je dostupna za sve MPC objekte i generira C kod iz podataka MPC
objekata.
_MPCBase.generate_c_files(numeric=’float64’,fracbits=None,matlab
=False,singledir=False)
Napišimo na trenutnoj putanji C kod za trenutni MPC problem.

Parametri:
 numeric(string) – prikazuje numeričku reprezentaciju C varijabli, validni stringovi su:
- „float64“: prikaz duple preciznosti (64 bita)
- „float32“: jednostruka preciznost (32 bita)
36
4.2Upotreba MPC kontrolera _________________________________________ MPC kontroleri
- „accum“: tip podataka sa fiksnom tačkom C ekstenzije za podršku ugrađenih

procesora (znakovnih 32 bita). Kompajler mora podržavati ekstenzije.
- „fip“: (eksperimentalno) fiksna tačka (32 bita)
 fracbits (integer or None) – cijeli broj veći od 0 koji pokazuje broj frakcionih bita
reprezentacije sa fiksnom tačkom. (EXPERIMENTAL) samo potrebno ako je numeric
tipa „fip“.
 matlab (bool) – ako je vrijednost True generiše kod za MATLAB/Simulink interfejs.
 singledir (bool) – ako je vrijednost True, kompletan generisani kod je sačuvan u jedan
folder. Korisno u primjeru Arduino mikrokontrolera.
Na primjer, pretpostavimo da system.py sadrži validne MPC postavke i pretpostavimo da
želimo generisati kod za odgovarajući mikrokontroler za programiranje pomoću Simulinka.
import muaompc
mpc = muaompc.ltidt.setup_mpc_problem("system")
mpc.generate_c_files(numeric="float32", matlab=True)
# you will find the generated C code in the current directory
Naredno poglavlje pokazuje kako koristiti generisani kod.
4.2 Upotreba MPC kontrolera
Kao što je pokazano u tutorialima za osnovnu upotrebu µAO-MPC nije potrebno poznavati
posebno MPC teoriju. Međutim za korištenje naprednijih funkcija potrebno je bolje poznavati
MPC. Ovo poglavlje počinje osnovnim teorijama o MPC-u i nastavlja sa detaljnim opisom
nekoliko načina na koje µAO-MPC može riješiti MPC probleme.
4.2.1 Osnove MPC
MPC postavke mogu biti ekvivalentno predstavljene preko parametarskog kvadratnog

programa (QP) posebnog tipa optimizacije problema. Pod određenim uvjetima (koji su uvjek
ispunjeni uz µAO-MPC) QP je strogo konveksan. To znači da se QP može efikasno riješiti
primjenom teorije konveksne optimizacije.
37
Parametarski QP
QP zavisi od trenutnog stanja sistema i referenci putanja ukoliko postoje. Naš parametarski
QP možemo izraziti u sljedećem obliku:
1
min u T Hu  u T g ( x, x ref , u ref )
u 2
uuu
subject to
z ( x)  Eu  z ( x)
Mpc kontroler se zasniva na ponavljanju rješenja QP koji je parametrizovan sa trenutnim

stanjem x i trenutnim i ulaznim referencama putanje xref , u ref redom. Drugim riječima u svakom
trenutku uzorkovanja nalazimo približna rješenja za različite QP. Naglasimo činjenicu da je
MPC rješenje u samo gruba aproksimacija tačnog rječenja u  . U nekim aplikacijama čak i gruba
aproksimacija može donijeti prihvatljive performanse kontrolera. Ova činjenica je od izuzetne
važnosti za ugrađene aplikacije koje imaju niske računarske resurse.
Postoji još jedna bitna stvar za primjetiti. Neki algoritmi optimizacije zahtjevaju nagađanje
početnog rješenja QP. Jasno je da će bolje nagađanje koje je bliže rješenju doprinijeti boljem
približnom rješenju. Ovo se koristi kao prednost kontrolera. U osnovi postoje dva načina kako
dobro izračunati početno rješenje koje trebamo pogoditi. Prvo se naziva cold-start strategija. To
znači da je početno nagađanje uvijek isto za sve QP probleme. Ova strategija se uglavnom koristi
kad se očekuju iznenadne promjene na stanju (na primjer, visoke frekvencije električnih
aplikacija). Druga strategija se naziva warm-start. To znači da je prethodno MPC približno
rješenje korišteno za izračunavanje početnog pogotka za trenutni QP. U aplikacijama gdje se
stanje mjenja sporo u odnosu na frekvenciju uzorkovanja (npr. većina mehaničkih sistema) dva
uzastopna QP koja proizilaze iz MPC šeme imaju vrlo slična rješenja.
Posljednja stvar koju trebamo primjetiti je to da je g () jedini izraz koji zavisi od referentnih
putanja. Za poseban slučaj početne regulacije (gdje su obje reference nula) jednostavno pišemo
g(x).
4.2.2 Korištenje Python interfejsa
U ovom odjeljku opisujemo dvije glavne funkcije kontrolera dostupne korisnicima µAO-
MPC. Radi lakšeg objašnjavanja prvo ćemo razmotriti Python interfejs. Poslije toga ćemo
razmotriti ekvivalentne mada malo složenije C funkcije. Python interfejs može poslužiti za
izradu prototipa i simulaciju MPC kontrolera. C funkcije su zapravo implementacija samog
kontrolera.
38
Rješavanje MPC problema

Najjednostavniji način da se riješi MPC problem optimizacije je korištenje µAo-MPC
programa koji koristi QP.
Rješava MPC problem za dato stanje koristeći defoltni program.
Parametri x (numpy nizovi) – trenutno stanje. Mora biti dimenzije states.
Ovaj metod je interfejs za C kod. Vidite njegovu dokumentaciju za više detalja.
Ova metoda se oslanja na druga polja ctl strukture
1. conf konfiguracijska struktura
2. x_ref stanje referentne putanje
3. u_ref ulazna referentna putanja
4. u_ini početno pogađanje za varijablu optimizacije
5. l_ini početno pogađanje za Lagrangeove faktore
6. u_opt približno rješenje problema optimizacije
7. l_opt približna optimalna vrijednost Lagrangeovog faktora
8. x_trj vrijednost putanje prema trenutnom u_opt
conf sadrži osnovne parametre konfiguracije optimizacijskog algoritma. Sastoji se od

sljedećih oblasti:
 warmstart – ukoliko je vrijednost True koristi warmstart strategiju (po difoltu

vrijednost je False)
 in_iter - broj unutrašnjih iteracija (po difoltu 1)
 ex_iter – broj vanjskih iteracija, ukoliko nisu prisutna mješovita ograničenja

postavlja se na 1.
x_ref je niz dimenzija (hor_states,1) dok je u_ref niz dimenzija (hor_inputs,1).

Po difoltu x_ref i u_ref su nula vektori odgovarajće veličine. Drugim riječima smatra se da
je MPC nulte regulacije.
u_ini je niz dimenzija (hor_inputs,1). l_ini je niz dimenzija (hor_mxconstrs,1).

l_ini se odnosi samo na probleme sa mješovitim ograničenjima. Po difoltu oni su također
nule. One se uglavnom podešavaju od strane korisnika u slučaju ručnog coldsting MPC
algoritma (conf. warmstart=False). Ukoliko je conf.warmstart=True onda se
autamatski računaju na osnovu prethodnih rješenja.
39
u_opt je niz dimenzija (hor_inputs,1). l_opt je niz oblika (hor_mxconstrs,1).

l_opt se samo odnosi na probleme sa mješovitim ograničenjima. x_trj je niz dimenzija
(hor_states+states, 1).
Obično je samo prvi ulazni vektor u MPC šemi za optimalnu unosnu sekvencu u_opt
značajan, npr. prvi inputs elementi u u_opt.
Na primjer, pretpostavimo da je mpc MPC objekat sa samo ograničenjima ulaza i želimo da
sva stanja budu podešena na 2, startajući sa svim stanjima 3.
mpc.ctl.conf.in_iter = 5 # configuration done only once
mpc.ctl.conf.warmstart = True # use warmstart
mpc.ctl.x_ref = numpy.ones(mpc.ctl.x_ref.shape) * 2
# repeat the following lines for every new state x

x = numpy.ones(mpc.ctl.x_ref.shape) * 3
mpc.ctl.solve_problem(x)
u0 = mpc.ctl.u_opt[:mpc.size.inputs] # 1st input vector in sequence
Korištenje drugog solvera

Opcionalno, korisnik može koristiti druge QP solvere skupa sa µAO-MPC. Ovo se na primjer
može koristiti za izgradnju prototipa MPC algoritama ili za pronalaženje tačnog rješenja koristeći
standardni QP solver.
ctl.form_qp(x)
Računa podatke parametarskog kvadratnog programa koristeći x kao parametar.
Parametri x (numpy nizovi)- trenutna vrijednost. Mora biti veličine states.

Ovaj metod je interfejs C koda. Vidjeti njegovu dokumentaciju za više detalja.
Ova metoda se oslanja na druge oblasti ctl structure:
1. x_ref putanja reference stanja
2. u_ref putanja ulazne reference
3. qpx struktura sa kreiranim podacima kvadratnog programa
x_ref je niz dimenzija (hor_states, 1) dok je u_ref niz dimenzija (hor_inputs,1).

Po difoltu x_ref i u_ref su nula vektori odgovarajće veličine. Drugim riječima smatra se da je
MPC nulte regulacije.
qpx sadrži izračunate podatke parametarskog kvadratnog problema Parametric QP uz

korištenje datih stanja i referenci. Sastoji se od sljedećih polja:
 HoL Hessian matrica
40
 qxoL gradient vektor za trenutno stanje i reference
 u_lb donja granica varijable optimizacije
 u_ub gornja granica varijable optimizacije
 E matrica stanja zavisna od ograničenja
 zx_lb donja granica zavisnih ograničenja stanja
 zx_ub gornja granica zavisnih ograničenja stanja
Pogledajte MPC opis za detaljnije definicije ovih polja.

Na primjer, pretpostavimo da je MPC objekat sa samo jednim ograničenjem ulaza i želimo
da sva stanja budu regulirana na 2 gdje su početna stanja podešena na 3.
mpc.ctl.x_ref = numpy.ones(mpc.ctl.x_ref.shape) * 2
# repeat the following lines for every new state x

x = numpy.ones(mpc.ctl.x_ref.shape) * 3
mpc.ctl.form_qp(x)
# use mpc.ctl.qpx together with the QP solver of your preference
Primjer kako koristiti form_qp skupa sa QP programom za rješavanje CVXOPT u Pythonu

može se naći u examples/ltidt/solver_cvxopt. I na kraju primjer kako koristiti form_qp
skupa sa QP programom za rješavanje qpOASES u C-u može se naći u
examples/ltidt/solver_qpoases.
4.2.3 Korištenje C implementacije
C funkcije
Funkcije koje su dostupne korisniku opisane su u C API u mpc.h fajlu. Python i MATLAB
interfejsi nude potpuno iste funkcionalnosti kao i C interfejs ali sa pojednostavljenom sintaksom.
Na primjer, C funkcija void mpc_ctl_solve_problem(struct mpc_ctl *ctl,

real_tx[]) u C će se pozvati na sljedeći način mpc_ctl_solve_problem(&ctl, x), pod
pretpostavkom da oba argumenta postoje. U Python-u će se pozvati kao
mpc.ctl.solve_problem(x) pretpostavljajući da MPC Python objekat se naziva mpc. Slično
u MATLABu ista funkcija se poziva koristeći ctl.solve_problem(x) pod pretpostavkom da
se MPC kontroler naziva ctl.
U svim slučajevima približno rješenje u_opt se nalazi unutar ctl strukture. Na primjer u C
programu prvom elementu sekvence se pristupa uz pomoć ctl->u_opt[0], u Python-u
pomoću ctl.u_opt[0] a u MATLAB-u ctl.u_opt[1].
41
5.1Klase simulacije u Python-u ______________________________________ Dodatne funkcije
Poglavlje 5
Dodatne funkcije
Ovo poglavlje predstavlja neke dodatne funkcije koje omogućavaju kreiranje naprednijih
MPC kontrolera.
5.1 Klase simulacije u Python-u
Ovaj pododjeljak pokazuje kako se vrlo lako može napraviti simulacija ponašanja sistema.
Bilo koji napravljeni MPC objekat sadrži instancu klase simulacije MPCSim, koji se po difoltu
naziva sim.
5.1.1 Jednostepena simulacija
Najosnovniji metod jednostavno računa sljedeće stanje, npr. vrijednost stanja pri narednom
koraku uzorkovanja za dati ulaz.
MPCSim.predict_next_state(xk, uk)
Računa sljedeće stanje xk1=A*xk+B*uk
Parametri
 xk(numpy nizovi) – trenutno stanje sistema. Mora biti veličine states.
 uk (numpy nizovi) – ulaz koji se primjenjuje na sistem. Mora biti veličine inputs.
Vraća sljedeće stanje.
Povratni tip numpy niz veličine states.

Na primjer, pretpostavimo da postoji mpc objekat i x je reprezentacija trenutnog stanja
sistema, tada možemo uraditi sljedeće:
uk = mpc.ctl.u_opt[:mpc.size.inputs, 0] # use only the first input
xk1 = mpc.sim.predict_next_state(xk, uk)
42
5.1Klase simulacije u Python-u ______________________________________ Dodatne funkcije
5.1.2 Višestepena simulacija
Dodatni metod razmatra regulaciju na fiksu referencu.

MPCSim.regulate_ref(steps, x_ini)
Simulira MPC regulaciju na referentnu tačku za određeni broj koraka.
Parametri
 steps (int) – broj diskretnih koraka simulacije. Period svakog koraka je vrijeme
diskretizacije dt.
 x_ini (numpy niz) – početno stanje od kojeg simulacija počinje. Mora biti
veličine states.
Počevši u trenutku x_ini ova funkcija se primjenjuje na diskretno-vremenski sistem

(sys.Ad, sys.Bd) prvi vektor ulaza sekvence kontrolera ctl.u_opt u svakom trenutku za
dati broj koraka. Cilj kontrolera je stabilizovati sistem u trenutku određenom sa ctl.x_ref i
ctl.u_ref. Rezultati simulacije smješteni su u strukturi sim.data.
Na primjer, pretpostavimo da je mpc validan MPC objekat i mpc.ctl je već konfigurisan,

tada možemo izvršiti simulaciju regulacije početnog problema pri čemu su sve početne
vrijednosti podešene na 1 za T=10 koraka npr. t i  0 do t f  (T '1)  dt.
import numpy as np
T = 10
mpc.ctl.x_ref = np.zeros(mpc.size.hor_states)
mpc.ctl.u_ref = np.zeros(mpc.size.hor_inputs)
mpc.sim.regulate_ref(T, np.ones(mpc.size.states))
mpc.sim.data.x # contains the state evolution
mpc.sim.data.u0 # contains the applied inputs
Nakon svakog pokretanja regulate_ref, član sim.data sadržavat će podatke o

simulaciji. To je instanca sljedeće klase:
class muaompc._ltidt.simula._DataPlot(mpc, steps)
Ova klasa sadrži podatke o simulaciji nakon pokretanja regulate_ref.
Dostupni članovi su sljedeći:
J=None
Vrijednost funkcije cost u svakom trenutku uzorkovanja.
t=None
Diskretno-vremenski vektor npr. vrijeme uzorkovanja.
u=None
Ulazna sekvenca izračunata MPC kontrolerom pri svakom momentu uzorkovanja.
43
5.2Podešavanje – tuniranje __________________________________________ Dodatne funkcije
u0=None
Ulazni vektor sistema pri svakom momentu uzorkovanja.
x=None
Stanje vektora sistema pri svakom trenutku uzorkovanja.
Primjer
Primjer koji iscrtava rezultate simulacije koristeći matplotlib dostupan je na putanji
examples/ltidt/sim_matplotlib.
5.2 Podešavanje – tuniranje
5.2.1 Osnove podešavanja
Postoje samo dva parametra koja se podešavaju a to su broj unutrašnjih i broj vanjskih
iteracija. U mnogim slučajevima podešavanja to je lako i intuitivno. Za probleme bez
ograničenja stanja samo je bitan broj unutašnjih iteracija. Ovi parametri su određeni onlajn.
Trenutno, odabir tih parametara se pravi u potpunosti od strane korisnika. U mnogim
ugrađenim sistemima broj iteracija može biti ograničen snagom procesora računara. Općenitije,
korisnik mora uporediti preformanse MPC kontrolera koje dobijamo rješenjem sa pouzdanim
programom za rješavanje (kao što je CVXOPT) nasuprot rješenjima dobijenim od µAO-MPC za
dati broj iteracija. Na primjer, poređenje se može napraviti koristeći stazu troškova u svakoj tački
putanje. Na kraju tačan broj iteracija najviše zavisi od aplikacije.
5.2.2 Parametar odstupanja
Opcionalno, treća vrijednost koja se podešava je parametar odstupanja µ koji se bira oflajn
(navedeno je u sistem modulu). µAO-MPC će po difoltu automatski izračunati dobru vrijednost
za µ ako nije već specificirana što se preporučuje. Grubo rečeno, veliki parametar odstupanja
povlači mali broj spoljašnjih iteracija potrebnih za dobijanje dobrih performansi naročito kad su
aktivna ograničenja. Kako god, više unutrašnjih iteracija je potrebno jer se broj uslova
unutrašnjeg problema povećava. Također vrijedi i suprotno, mala vrijednost µ doprinosi lakšem
rješavanju unutrašnjeg problema posebno ako nisu aktivna ograničenja stanja. Kad su aktivna
ograničenja stanja potreban broj spoljašnjih iteracija je veći.
Do sada bi trebalo biti jasno da je odabir odgovarajuće vrijednosti za µ (ne previše niska i ne
previše visoka vrijednost) od presudnog značaja.
Iako se ne preporučuje, µAO-MPC dozvoljava iskusnom korisniku da eksplicitno postavi
vrijednost za µ u sistem modulu. Odabir parametra µ je olakšan uz pomoć naredbe
44
find_penalty_parameter pod objektom tun. Na primjer koristeći aircraft sistem iz

tutoriala:
import muaompc
mu = mpc.tun.find_penalty_parameter()
Sada mu sadrži vrijednost parametra odstupanja koja nije ni previše visoka ni previše niska.
Ovo je samo početna vrijednost koja nam može pomoći za finija podešavanja. Funkcija koja je
dobrodošla pri finijem podešavanju µ je calc_int_cn. Računa broj stanja unutrašnjeg
problema za listu parametara µ. Nastavimo sa primjerom:
mpc.tun.calc_int_cn([0.5 * mu, 2 * mu])
vratiće nam broj stanja za svaki parametar na listi. Ovo nam pomaže da ispitamo da li odabrani
mu ne čini naš interni problem nemogućim. Sljedeći odjeljak predstavlja proceduru koja nam
pomaže da smanjimo broj stanja Hessian od QP i isto tako internog problema dozvoljavajući
upotrebu veće vrijednosti za mu i samim tim čini rješavanje brže.
5.2.3 Podešavanje Hessian-a
Osnovni algoritam optimizacije korišten od strane µAO-MPC daje izvrsne rezultate za niže
brojeve stanja (npr ispod 100). Da bi ovo postigli posežemo za funkcijom reduce_H_cn koja u
osnovi rješava nelinearne programe (NLP).
MPCTuning.reduce_H_cn(xref,uref,stw,inw,cn_ub=100,stw0=None,
inw0=None)
Pronalazi težinske matrice za smanjenje broja Hessian-ovog uslova.
Parametri:
 xref (numpy nizovi) – putanja koju stanje treba pratiti. xref je dimenzija
(states,points).
 uref (numpy nizovi) – sekvenca ulaza za datu putanju stanja xref. uref je
dimenzija (inputs, points).
 stw (numpy niz) – relativne težine stanja date kao vektor dimenzija (states, 1).
Ovaj vektor odgovara dijagonali težinske matrice stanja Q odnosno Q=diag(stw).
 inw (numpy nizovi) – relativne težine ulaza dat kao vektor dimenzija (inputs).
Ovaj vektor odgovara dijagonali ulazne težinske matrice R odnosno R=diag(inw).
 cn_ub (skalar) – gornja granica Hessian broja stanja. Mora biti veći od 1.
45
 stw0 (none ili numpy niz) – početno nagađanje rješenja za rješenje težinskog
stanja. Ukoliko je vrijednost None računa se kao jedinična matrica odgovarajućeg
oblika.
 inw0 ( none ili numpy niz) – početno nagađanje rješenja za težinski ulaz
oblika inputs. Ako je vrijednost None računaće se kao jedinična matrica
odgovarajućih dimenzija.
Izlazi
Riječnik sa dijagonalama novopodešenih težina. Ključne riječi su sljedeće:
 „stw“ je dijagonala težinske matrice stanja
 „inw“ je dijagoala težinske matrice ulaza
Date reference putanje stanja i ulaza (xref, uref), razlika između simulirane putanje za
neograničen sistem (sa početnim uslovom prve tačke putanje (xref, uref)) mora biti
minimizirana u odnosu na dijagonalnu težinsku matricu QP-a. Problem se predstavlja kao
nelinearni program (NLP).
Ovaj NLP uzima referentnu putanju kao ulaz (za sekvence stanja i ulaza) referentne težinske
matrice koje postavljaju željene preformanse kontrolera i gornju granicu broja stanja QP
Hessian-a. NLP vraća težinske matrice koje daju slične performanse kontrolera i čini  H (broj
stanja Hessian) nižim od određene gornje granice. Kako je ovaj NLP općenito nekonveksan
možda neće biti jedinstveno rješenje, i pronalazak rješenja može zavisiti od početnog pogađanja
za težinsku matricu.
Procedura za pronalazak odgovarajuće težinske matrice koja redukuje  H je sljedeća:
1. Ručno podesimo svoj MPC kontroler kao i inače. U tom trenutku samo su prihvatljive
dijagonalne matrice. Ove matrice se koriste kao osnova NLP.
2. Generišemo putanju za stanja i odgovarajuće ulazne sekvence koja predstavlja MPC
aplikaciju.
3. Opcionalno, odredimo gornju granicu za  H .
4. Opcionalno, odredimo početno pogađanje za težinsku matricu.

5. Ponoviti za različite parametre ukoliko optimizacija nije uspjela ili ako nismo
zadovoljni rezultatima.
Uzmimo za primjer sistem iz poglavlja Složeniji MPC problem. Razmotrimo promjene u
visini da predstavimo tipično ponašanje kontroliranog sistema. Kratak primjer:
46
5.3Automatski odabir stabilizirajuće matrice ____________________________ Dodatne funkcije
from numpy import eye, diag

import muaompc
# xref, uref have been already generated via simulation
# the reference weighting matrices have been manually tuned as identity
Qref = diag(eye(5))
Rref = diag(eye(1))
r = mpc.tun.reduce_H_cn(xref, uref, Qref, Rref)
Qtun = r[’stw’]
Rtun = r[’intw’]
Kompletan primjer kako koristiti ovu funkciju nalazi se u tutorial/ltidt/turn_h_cn.
5.3 Automatski odabir stabilizirajuće matrice
5.3.1 Ključna riječ auto
Ključna riječ auto služi da se trenutno stanje težinske matrice P bira automatski tako da je
terminalna cijena kontrolna Lyapunova funkcija za postavke modela prediktivne kontrole.
Razmatramo sljedeće slučajeve:
 sistem otvorene petlje je stabilan i kod njega su samo ulazi ograničeni. Kao izlaz se
vraća matrica rješenje Lyapunoove jednačine. U ovom slučaju tačka regulacije
zatvorene petlje sistema je globalno eksponenecijalno stabilna.
 par (Ad, Bd) se također može stabilizovati s tim da postoje ograničenja i na ulazu i na
stanjima. Rješenje diskretne algebarske Riccatijeve jednačine se vreća kao izlaz.
Tačka regulacije je asimptotski (eksponencijalno) stabilna skupa sa oblasti privlačenja
X N ( X s ).
Sljedeći uvjeti se postavljaju na MPC postavku :
 Q je simetrična i pozitivno definisana
 R je simetrična i pozitivno definisana
 Par ( Ad , Bd ) je moguće stabilizovati

1
Ako je Q pozitivna polu-definisana tada par ( Ad , Q 2 ) mora biti otkriven. Ovo se ne
provjerava odmah.
Provjeravaju se sljedeći uslovi:
1. Je li problem samo sa ograničenim ulazima?
47
5.4MATLAB/Simulink interfejs ______________________________________ Dodatne funkcije
2. Ima li Ad sve svoje svojstvene vrijednosti strogo iz jediničnog kruga.
Ako su oba uslova ispunjena tada se Lyapunova jednačina može riješiti. Ako jedan od uslova
nije ispunjen tada se rješava diskretna Ricatti jednačina.
U tom slučaju X N se definiše kao skup stanja za koje je MPC problem izvodljiv. X S je tada
bilo koji podskup skupa MPC optimalnih vrijednosti.
5.4 MATLAB/Simulink interfejs
MATLAB i Simulink interfejs omogućavaju da se koristi i kontrolira prekompajliran

program za nalaženje rješenja iz MATLAB/Simulink.
5.4.1 Zavisnosti
Da bi koristili ovu pogodnost potrebni su sljedeći uslovi:
 MATLAB (testiran pomoću verzije 7.8.0 (R2009a))
 C kompajler ( testiran uz pomoć GCC verziju 4.4 (gcc4.4))
5.4.2 Kreiranje interfejsa
Za osnovnu upotrebu procedura se sastoji od pisanja sistem modula, generisanja i

kompajliranja koda i na kraju korištenja interfejsa.
Kreiranje sistem modula

Sistem modul se također može kreirati u MATLAB-u. Jednostavno definišemo potrebne
matrice (npr. Ac, Bc, Q, u_lb, e_lb) i sačuvamo ih u mat fajlu. U ovom primjeru
pretpostavićemo da je kreiran sys_motor.mat sistem modul na osnovu MPC postavki
objašnjenih u poglavlju Osnove MPC problema.
Napomena: Za učitavanja mat fajlova SciPy je potreban.
Generisanje koda
Prvo moramo generisati kod koji predstavlja MATLAB interfejs. Jedino što trebamo uraditi
je dodati opciju matlab=True pri pozivanju generatora. Sljedeće Python komande će
generisati MATLAB/Simulink interfejs za primjer sys_motor.mat:
48
import muaompc
mpc = muaompc.ltidt.setup_mpc_problem(’sys_motor.mat’)
mpc.generate_c_files(matlab=True)
Generisani cmpc folder sadrži dva nova foldera koji se nazivaju matlab i simulink pored
uobičajenih C fajlova. Sadrži sve kodove za MATLAB i Simulink interfejs. Slijedi i detaljni
opis.
5.4.3 Korištenje MATLAB interfejsa
Kompajliranje interfejsa
Kada se jednom napravi kod interfejsa sljedeći korak je kompajliranje MATLAB interfejsa.
Startamo MATLAB, postavimo generisan cmpv/matlab folder kao radni folder i pozovemo
naredbu make koja izvršava make.m skriptu. Na primjer pretpostavimo da smo u folderu gdje
smo generisali podatke, unutar MATLABA unesimo:
>> cd cmpc/matlab
>> make
Nakon toga kompajlirani kod je smješten unutar @mpc_ctl foldera.
Dodavanje interfejsa u MATLAB putanju

Posljednji korak je dodati matlab folder PATH okruženju u MATLAB-u
Korištenje interfejsa
Sada možemo koristiti interfejs koji je enkapsuliran unutar klase nazvane mpc_ctl koja
predstavlja MPC kontroler. Jednostavno deklarišemo instancu te klase koju obično zovemo ctl
(kontroler). Na primjer:
ctl = mpc_ctl; % create an instance of the class
ctl.conf.in_iter = 10; % configure the algorithm
x = [0.1; -0.5]; % current state
ctl.form_qp(x) % form the QP for the current state
qpx = ctl.qpx; % qpx contains the QP in standard form
u = quadprog(qpx.HoL, qpx.gxoL, [], [], [], [], qpx.u_lb, qpx.u_ub);
ctl.solve_problem(x); % solve the MPC problem for current state
ctl.u_opt % display the computed input sequence
norm(u - ctl.u_opt) % ctl.u_opt is the MPC approximation of u
Primjer
Cijeli primjer se može naći u folderu examples/ltidt/matlab_interface.
49
5.4.1 Korištenje Simulink interfejsa
Moguće je koristiti generisani kod u Simulinku za izgradnju modela simulacije i izvršenja

ciljeva u realnom vremenu koje podržava MATLAB koder uključujući kompajliranje ugrađenih
ciljeva.
Simulink karakteristika koja ovo omogućava je nazvana S-funkcije. S-funkcije (sistemske
funkcije) obezbjeđuju moćan mehanizam za proširenje mogućnosti Simulinka. One
dozvoljavaju izvršenje C koda kao Simulink bloka.
Kompajliranje interfejsa
Kao što je već objašnjeno, za generaciju prekonfigurisanog Simulink modela moramo
postaviti parametar matlab=True pri pozivanju generatora. Ovaj model se nalazi u
cmpc/simulink folderu. Da bi pokrenuli dati model moramo uraditi sljedeće:
1. U MATLAB-u promjenimo trenutni folder u cmpc/simulink
2. Otvorimo cmpc/simulink/simulinkmpc.mdl u Simulinku
3. Dupli klik na S-Function Builder blok za otvaranje prozora postavki
4. Kliknemo na Build za pravljenje S-funkcije.

Sada je model spreman za proširivanje i upotrebu u našem dizajnu.
Primjer
Primjer sistema simulink_example.mdl se nalazi u folderu

examples/ltidt/matlab_interface. Pokazuje jednostavnu upotrebu MPC kontrolera. Da
bi pokrenuli primjer pratimo sljedeće korake:
1. Postavimo trenutni MATLAB folder na examples/ltidt/matlab_interface.
2. Ukucamo open_simulink_example u MATLAB konzoli
3. Pritisnemo Build dugme u prozoru za postavke koji će se pojaviti na ekranu

4. Pokrenemo simulaciju
Primjer uključuje funkcionalnost rješavanja kontrolnog problema i predviđanje sljedećeg
stanja sistema. Model može raditi na principu zatvorene i otvorene petlje. Također model
pokazuje kako provjeriti izvršnu brzinu uređaja.
50
Zaključak
Implementacija linearne model prediktivne kontrole u ugrađenim platformama sa

ograničenim resurima proračuna predstavlja veliki izazov. U posljednje vrijeme razvijeno je
nekoliko alata za automatsku generaciju koda koji predstavljaju visoko efikasne algoritme
optimizacije. Bazirajući se na proširenom Lagrangeovom metodu u kombinaciji sa Nestorovim
gradijentnim metodom, moguće je eksplicitno razviti algoritam optimizacije za real-time
ugrađene aplikacije. U ovom radu, pored dobrog uvoda u osnove model prediktivne kontrole,
predstavljen je i alat za automatsku generaciju koda koji se fokusira na performanse kontrolera
kao i hardver sa niskim resursima proračuna. Generisani C kod je nezavisan od platforme.
Moguće ga je direktno koristiti u embedded aplikacijama na popularnim platformama kao što su
Arduino, Raspberry ili bilo kojim drugim aplikacijama koje podržavaju C kod poput mnogih
aktuelnih generacija programabilnih logičkih kontrolera (PLC). Primjeri koji su obrađeni u ovom
radu, osim što demonstriraju principe rada navedenog alata, imaju za cilj da potaknu krajnjeg
čitaoca da slobodno modificira algoritam prilagođavajući ga potrebama sopstvenog problema
prediktivnog upravljanja, prije nego li se pribjegne dostupnim komercijalnim produktima. Ono
što MPC čini privlačnim je njegova fleksibillnost i relativno jednostavan koncept. Kada se
usvoje principi funkcionisanja na jednom primjeru, dalje modifikacije algoritma za specifične
zahtjeve određene aplikacije postaju uglavnom vrlo jednostavne.
51
Bibliografija
[1] Zometa, P., Kögel, M. and Findeisen, R., “muAO-MPC: A Free Code Generation Tool for
Embedded˙Real-Time Linear Model Predictive Control,” Proc. American Control Conference,
Washington D.C., USA, 2013.
[2] Kögel, M., Zometa, P. and Findeisen, R., “On tailored model predictive control for low cost
embedded systems with memory and computational power constraints,” technical report, 2012.
[3] Kögel, M. and Findeisen, R., “Fast predictive control of linear, time-invariant systems using an
algorithm based on the fast gradient method and augmented Lagrange multipliers,” in Proc.
2011 IEEE Multi-conference on Systems and Control, pages 780-785, Denver, USA, 2011.
[4] Maciejowski, J. M., “Predictive Control with Constraints,” Pearson Education, 2002.
[5] Waschl, H. and Alberer, D. and del Re, L., “Numerically Efficient Self Tuning Strategies for
MPC of Integral Gas Engines,” in Proc. IFAC World Congress 2011, pp. 2482-2487.
[6] Rawlings, J., Mayne, D., “Model Predictive Control: Theory and Design,” Nob Hill Pub., 2009.
[7] Grüne, L., Pannek, J., “Nonlinear Model Predictive Control,” Springer-Verlag, 2011.
[8] J.A. Rossiter-Model-Based Predictive Control_ A Practical Approach (Control Series)-CRC

Press (2003)
52

Master Rad

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Master Rad

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERZITET U TUZLI

AUTOMATSKO GENERIRANJE KODA ZA MPC

TUZLA, SEPTEMBAR 2018. GODINE

IME I PREZIME KANDIDATA: MELIS ZULIĆ

Magistarski rad je odbranjen dana: 28.09.2018.

Sastav komisije za odbranu rada:

Dr.sc. Lejla Banjanović-Mehmedović, vanr. prof., predsjednik

Redni broj iz matične evidencije: I-4-IIC/12

Ključne riječi: μAO-MPC, C kod, MPC, Python, Arduino, Raspberry, PLC.

Keywords: μAO-MPC, C kod, MPC, Python, Arduino, Raspberry, PLC.

Sl. 1.1 Osnovna struktura MPC-a ................................................................................................... 9

Model prediktivno upravljanje ( MPC ) je napredna metoda kontrole procesa koja se

1.1 Teorija i principi MPC-a

Većina zakona o kontroli, recimo PID (proporcionalni, integralni i derivativni), ne razmatraju

1.1.1 Baziranje predikcije na modelu

Sl. 1.1 Osnovna struktura MPC-a

1.1.2 Odabir trenutnog ulaza i smanjenje horizonta

1.1.3 Optimalne ili performanse sigurnosti

Postojalo je historijsko zanimanje za temu tuniranja (podešavanja) prediktivnih zakona o

1.1.5 Manipulisanje ograničenjima

1.1.6 Sistematska upotreba budućih zahtjeva

1.1.7 Sistematski dizajn upravljanja za multivarijabilne sisteme

1.1.8 Matematički opis MPC problema

MPC se zasniva na iterativnoj optimizaciji konačnog horizonta modela sistema. U vremenu

Sl. 1.2 Diskretna šema MPC-a

Model Predictive Control (MPC) je multivarijantni algoritam upravljanja koji koristi:

 interni dinamički model procesa

 historiju prošlih kontrolnih poteza i

 funkciju troškova optimizacije J nad povlačućim predviđenim horizontom, da bi

𝐽 = ∑ 𝑤𝑥𝑖 (𝑟𝑖 − 𝑥𝑖 ) + ∑ 𝑤𝑢𝑖 ∆𝑢𝑖 2

bez narušavanja ograničenja (donja, gornja granica) sa:

𝑥𝑖 : 𝑖 𝑡ℎ kontrolna varijabla (npr. mjerena temperatura)

𝑟𝑖 : 𝑖 𝑡ℎ referentna varijabla (npr. zahtjevana temperatura)

𝑢𝑖 : 𝑖 𝑡ℎ manipulirana varijabla (npr. kontrolisani ventil)

𝑤𝑥𝑖 : težinski koeficijent koji preslikava relativnu važnost 𝑥𝑖

𝑤𝑢𝑖 : težinski koeficijent koji kažnjava relativno velike promjene na 𝑢𝑖 itd.

2.1 Šta je muAO-MPC

 AO-MPC je skraćenica od riječi microcontroller applications online model predictive

Osim toga, za generirani kod obezbjeđuje se i MATLAB / Simulink inerfejs.  AO-MPC je

2.1.1 ltidt modul

gdje je cijeli broj N  2 predviđena horizontala. Simetričme matrice Q, R i P su redom

2.2 Instaliranje softverskih paketa

2.2.1 Zahtjevi instalacije

Potrebna je instalacija sljedećih paketa :

2.2.2 Bildanje i instalacija

Instalacija muaompc se vrši direktno iz source koda.

python setup.py install –user --force

Opcija --user naglašava da nisu potrebne administratorske privilegije. Opcija --force će

sudo python setup.py install --force

Instaliramo Anacondu. Pobrinuti se da je Anaconda konfigurisana ispravno da koristi

python setup.py install --force

python setup.py install --force

2.1 Razvoj open source softvera

µAO-MPC je razvijen u labaratoriji za teoriju Sistema i automatsko upravljanje Instituta za

2.2 Pregled promjena

 Nema potrebe za specificiranjem referentnog vektora koje nisu potrebne (u C kodu)

 Pojednostavljena instalacija sa opcijom koja ne dodaje kompajler

 Poboljšana kompatibilnost sa definicijom tipa integer

 Dodata mogućnost generisanja koda u jednom folderu

 Dodat Arduino primjer

 Popravljen početni unos Lagranžovih faktora

 Popravljena simulacija za primjere ulaznih ograničenja

 Popravljena greška pri izračunavanju vrijednosti krajnje težinske matrice sa 'auto'