lucrare de licenta aplicatie grafica pentru controlul unui ... · combina minimizarea functiei cu...
TRANSCRIPT
1
LUCRARE DE LICENTA
Aplicatie grafica pentru controlul unui pendul
dublu neliniar
Absolvent
Alexandru Stefan
Coordonator
Asist.Ing. Dr. Valentin Tanasa
Bucuresti, 2013
Cuprins:
2
Capitolul 1: Introducere ................................................................................................................................ 4
Capitolul 2: Modelul matematic, modelare neliniara ..................................................................................11
2.1. Prezentare generala .....................................................................................................................11
2.2. Studiul problemei .........................................................................................................................12
2.3. Exemplificare ................................................................................................................................20
2.4. Tipuri de frecari ............................................................................................................................22
Capitolul 3: Controlul sistemului (strategii de comanda) ............................................................................24
3.1. Strategii de control ............................................................. Ошибка! Закладка не определена.
3.2. Aspecte preliminare ............................................................ Ошибка! Закладка не определена.
3.3. Proiectarea schemei de control ...................................................................................................28
3.4. CLF (Controler de Logica Fuzzy)....................................................................................................29
Capitolul 4: Aplicatie ....................................................................................................................................34
4.1. Continutul aplicatiei ..........................................................................................................................34
4.2. Sistemul de ecuatii ............................................................................................................................34
4.3. Metoda Dormand-Prince ..................................................................................................................35
4.4. Interfata .............................................................................................................................................36
Capitolul 5: Concluzii ....................................................................................................................................38
Anexa A: Codul aplicatiei ..............................................................................................................................39
A.1. Controler Fuzzy .................................................................................................................................39
A.2. Pendulul invers ..................................................................................................................................43
A.3. Pendulul invers dublu .......................................................................................................................46
A.4. Starea sistemului ...............................................................................................................................49
A.5. Metoda Dormand-Prince ..................................................................................................................50
A.6. Engine-ul aplicatiei: ...........................................................................................................................51
Anexa B: Interfata aplicatiei .........................................................................................................................54
B.1. Pendulul simplu .................................................................................................................................54
B.2. Pendulul dublu ..................................................................................................................................54
3
Bibliografie ...................................................................................................................................................55
4
Capitolul 1: Introducere
Scopul acestei lucrari este de a realiza o aplicatie grafica interactiva prin
intermediul carora studentii sa poata dezvolta si testa tehnici de control liniar sau neliniar
pentru sisteme de tip pendul invers. Sistemele de tip pendul sunt sisteme mecanice simple dar cu
dinamici neliniare si care sunt dificil de stabilizat. Sunt multe exemple din natura sau industrie
care se pot explica pe baza analogiilor cu un system de tip pendul. Prin urmare aceste sisteme
sunt adeseori folosite atat in scop educativ cat si in cercetare pentru a se ilustra concepte
specifice.
Aceasta aplicatie grafica este dedicata studiului unui pendul simplu sau a unui pendul
dublu invers cu carucior. Aplicatia permite simularea traiectoriilor unui asemenea pendul, avand
cunoscute setul de conditii initiale. De asemenea lucrarea permite implementarea de legi de
comanda potrivite.
În acestă lucrare sunt derivate ecuaţiile de mişcare pentru un pendul invers multiplu.
Sistemul pendulului este mai general şi include frecări de tip neliniar pentru a se potrivi
diverselor aplicaţii inginereşti. Ecuaţiile generalizate sunt dezvoltate în sistemul de coordonate
absolut folosind tehnicile lui Lagrange, apoi o transformare liniară simplă se propune pentru a
obţine setul de ecuaţii neliniare în sistemul de coordinate Devanit-Hartenberg.
1.1 Aspecte preliminare stabilizare sisteme de pendul invers
Stabilizarea sistemelor de pendul invers reprezinta o metodă aplicată in majoritatea
ariilor de control. Importanţa si frecvenţa analizelor acestor sisteme este definită de faptul că
acestea reprezintă mai multe aspecte. Sistemul de pendul invers este necostisitor si poate fi
construit si instalat cu usurinta in laboratoare in scop educational sau pentru activitatile de
cercetare.
Acestea sunt dezvoltate pentru a dezvolta teorii de control si algoritmi, intrucat sunt
in analogie cu numeroase sisteme din viata reala.
Un propulsor de racheta la lansare poate fi simulate ca un pendul invers cu o singura
conexiune rigida montat pe un carucior mobil. Studiul unui sistem cu trei conexiuni poate
5
contribui la dezvoltarea unor masini de locomotive bipede deoarece aceasta poate fi considerat un
model simplificat al omului stand intr-un picior. Sistemul de pendul invers cu multiconexiuni
poate fi tratat ca o aproximare bidimensionala pentru manipulatoare de roboti cu capacitate de
control redusa. Din cauza ca aceste sisteme sunt foarte instabile, multi-variabile si prezinta
neliniaritati care nu pot fi neglijate date de structura lor dinamica si fortele de frecare, pendulul
inversat este adeseori utilizat in obtinerea performantelor simularilor si in validarea tehnicilor de
control.
Figura 1.1 Lansare racheta Apollo 11 – exemplu pendru pendul simplu
Figura 1.2. Robot umanoid Asimo – exemplu pentru pendul dublu
6
In continuare, bazat pe lucrarea Eltohamy si Kuo (1999) s-a preluat studiul
bibliografic legat de controlul sistemelor de pendul invers care este redat in continuare.
Lucrarile publicate legate de stabilizarea si controlul sistemelelor de tip pendul invers
simplu, dublu si triplu pot fi separate in doua categorii principale:
Lucrari de cercetare care se bazeaza in totalitate pe simulari computerizate in
vederea validarii abordarilor;
Lucrari experimentale care investigheaza incertitudinile fizice cauzatoare de
aparitia unor diferente de performanta substantiale intre rezultatele simularii
pe computer si implementarile de control in timp real.
Dintre aceste lucrari care dezbat stabilizarea pendulului invers cu o conexiune bazat
pe simulari computerizate Chung si Litt (1986) au folosit o tehnica de estimare de tipul least
squares recursiva pentru a identifica dinamicile sistemului. Un controller de raspuns autoreglabil
si adaptiv utilizeaza aceasta informatie pentru a stabiliza sistemul in vederea starii de echilibru
verticale instabile. Un controller de raspuns PD (proportional si derivativ) este de asemenea
conceput pe baza modelului dinamic liniarizat al sistemului. Comparatia simularilor
computerizate a ambelor controllere, decalajele unghiulare initiale, perturbatiile de tip treapta si
sinusoidale dovedesc perfomanta superioara a primului controller. In locul rezolvarii unei
probleme neliniare cu doua puncte limita prin calculul variational, Andersin si Grantham (1989)
combina minimizarea functiei cu metoda de stabilitate Lyapunov si o aplica unui pendul neliniar
cu o singura conexiune pentru a produce un controller de raspuns optimal.
O constrangere asupra cuplului de control il limiteaza la mai putin de cuplul gravitational
al modelului. Simularile computerizate promit rezultate de succes si un controller care aduce
aproape toate traiectoriile la puncte de stabilitate.
Henders si Soudak (1992) studiaza comportamentul sistemului anterior cu ajutorul
unui controller liniar prin analiza planului de faza. Acestia au dezvaluit existenta atractoarelor cu
doua stari in sistem. Primul bazin de atractie este de o forma complexa si intindere limitata. Cu
toate astea sistemul de control creaza un punct stabil pentru acest atractor la originea planului de
faza. Al doilea atractor este un ciclu cu limita stabila si trage toate starile de sistem din afara
bazinului primului atractor. Pentru sistemele de pendul invers cu doua conexiuni Sahba (1983)
formuleaza criteriul de stabilitate al sistemului ca o constrangere de inegalitate infinit
dimensionala pentru a folosirea metodei Lyapunov.
7
Pentru a obtine stabilitate asimptotica, functia Lyapunov a sistemelor neliniare
permite incrementarea pe interval scurt in locul descresterii continue de-a lungul traiectoriilor de
stare. In final Sinha si Joseph (1994) utilizeaza transformarea Lyapuno-Floquet pentru a reduce
sistemul de pendul invers cu trei conexiuni variant in timp, fara carucior mobil, la o forma
potrivita pentru aplicatia metodelor de control invariante in timp. Tehnicile lor rezulta intr-un
model de controller simulat pe computer prin trei intrari de control. Cu toate acestea majoritatea
tehnicilor dicutate anterior sunt dificil de implementat deoarece formei controllerelor care duc in
timp real la un volum de calcul extensiv.
Pe de alta parte in experimentele in timp real un pendul invers cu o singura conexiune
poate fi stabilizat in starea verticala de echilibru instabil folosind un controller PD simplu. Mori
et al. (1976) a extins asta la modelul unui controller complex pentru a aduce la pozitie verticala
un pendul cu o conexiune si a-l mentine acolo. In primul rand un controller de tipul feedforward
este folosit in timpul perioadei de balans spre pozitia verticala apoi un regulator analog de tipul
observator pentru stabilizarea dinamica proiectat folosindu-se plasamentul polilor care este
activat in faza de stabilizare.
O tehnica mai simpla este folosita de Smith si Blackburn (1992). Acestia supun
pivotul pendulului la oscilatii verticale de frecventa inalta si obtin stari inversate stabile. Ostertag
si Carvalho – Ostertag (1993) compenseaza fortele de frecare din sistem folosind un compensator
fuzzy, apoi dezvolta un controller fuzzy stabil. De aici inainte, un controller de raspuns de stare
este folosit in concordanta cu un intrerupator de prag constant ca o compensare a frecarii.
Rezultatele de la ambele controllere sunt comparabile. Cu toate astea, controllerul de logica fuzzy
arata o stabilizare usor mai buna.
Pentru sistemele de pendul dublu invers care sunt mai complicate controllerul poate fi
proiectat liniarizand modelul sistemului si gasind un regulator care minimizeaza un index de
performanta patratica. Furuta el al. (1978) si Zu-ren et al. (1984) folosesc controllere de stare
analogice pentru a stabiliza astfel de sisteme in experimente. Zu-ren et al. (1987) a folosit un
controller digital care da o mai buna stabilizare. Maletinsky et al. (1981) nu masoara unghiul
conexiunii secundare in mod direct si tot reusesc sa controleze pendulul dublu invers intr-o
pozitie stabila. Un sistem cu doua conexiuni pe o sine inclinata este de asemenea controlat de
Furuta et al.(1980).
8
Desi toate controllerele in timp real listate mai sus pentru pendulul invers dublu sunt
proiectate linear, ele difera in filosofia care se afla in spatele deciziilor luate de catre regulator si
tipul de observatori folositi.
Problema mai dificila a stabilizarii unui pendul invers triplu in experimente a fost
studiata de Furuta et al. (1984), Meier zu Farwyg si Unbehauen (1990), Medrano-Cerda (1997)
and Eltohamy si Kuo (1997, 1998). In primele doua lucrari problema este simplificata prin
folosirea a doua motoare pentru a furniza intrari de control si controllere sunt din nou proiectate
prin minimizarea indexului de performata patratic bazat pe modele liniarizate ale sistemelor lor.
Cu toate astea sistemul triplu conectat al lui Furuta nu include un carucior mobil. In schimb
conexiunea de la baza este ascunsa la sol si controlabilitatea sistemului este incrementata fixand
bare orizontale pe conexiuni pentru a le incrementa inertia inertia si a facilita controlul. Desi
Meier zu Farwig si Unbenhauen au implementat un sistem care nu include un carucior mobil un
alt doilea motor este localizat in apropierea conexiunii de sus pentru a incrementa inertia si a
asigura cupluri stabilizatoare pentru conexiunile mijlocii si de sus. In Medrano-Cerda (1997) un
pendul invers triplu fixat pe un carucior care se poate misaca orizontal este stabilizat in pozitia
verticala folosind un singur actuator, adica, un motor DC care conduce caruciorul. In Eltohamy si
Kuo (1997-1998) un pendul invers triplu similar cu cel folosit in Medrano-Cerda (1997) este de
asemenea stabilizatfolosind o singura intrare pentru control. Trebuie de asemenea mentionat ca
un observator de ordin redus este folosit in Medrano-Cerda (1997) pentru a reconstrui acele
variabile de stare care nu sunt direct masurate. Pe de alta parte toate variabilele de stare sunt
furnizate direct de senzori digitali cu zgomot foarte redus, in Eltohamy si Kuo (1997-1998).
Din rezultatele experimentelor in timp real raportate in aceste lucrari se pare ca
stabilitatea unui sistem de control de tip feedback pentru pendul invers cu mai multe conexiuni
poate fi afectat foarte puternic de urmatorii factori:
1. Zgomotul in timpul masuratorilor care poate fi ocolit prin mai multe metode.
Prima metoda, se pot folosi filtre de zgomot desi adauga complexitate
sistemului. Observatori pot sa fie de asemenea folositi pentru a estima unele
din stari fara zgomot. Cu toate astea rata de testare a unui sistem de control
de multe ori depinde de tipul de observator folosit datorita extra
computatiilor necesare pentru ecuatiile observatorului. O solutie alternativa
este sa foloseasca senzori digitali aproape lipsiti de zgomot. Eltohamy si Kuo
9
(1997-1998). Astfel de senzori pot avea mase comparabile cu ale
conexiunilor.
2. Incertitudini care se manifesta in mare parte in coeficientii de frecare.
Estimand valorile acestora prin date experimentale si modelare, efectul lor
asupra sistemului poate fi vizualizat in simulare. Desi amelioreaza modelul
sistemului unii din termenii de frecare nu pot fi liniarizati deci nu au o
influenta directa asupra proiectarii regulatorului liniar.
3. In Eltohamy si Kuo (1997-1998) s-a gasit ca viteza de rotatie inalta a
conexiunii de top a unui pendul invers triplu poate afecta foarte mult efectul
de control prin saturarea amplificatorului analog. Aceasta poate fi depasita
redistribuind masa conexiunii de top pentru a cobori centrul de greutate mai
aproape de punctul pivotului.
Cu toate acestea pana acum, aceste probleme practice nu au fost adresate suficient in
lucrarile de cercetare precedente care se bazeaza pe simulare computerizata. Pentru a face
rezultatele care au fost cercetate pe baza simularii pe computer mai substantiale, acesti factori ar
trebui de asemenea inclusi in aceste simulari folosite in cercetarea controlului pentru pendulul
invers. In Larcombe (1991-1992) ecuatiile de miscare pentru un pendul invers multiplu sunt
formulate in sisteme de doua coordonate bazate pe presupuneri de distributie a masei in
conexiuni uniforme si fara frecare. Primul este sistemul de coordonate absolut in care unghiurile
conexiunilor sunt calculate tinand cont de pozitia pe verticala. Al doilea sistem de coordonate se
numeste Devanit-Hartenberg sau sistemul de coordonate alternativ, care este o metoda standard
pentru descrierea sistemelor kinematice a manipulatoarelor robotice. Larcombe si Torsney (1992)
au gasit o formulare matematica pentru enumerarea si identificarea starilor de echilibru ale
sistemelor de pendul multiplu. Intr-o alta lucrare Larcombe (1993) a aplicat manipularea
algebricii simbolice ecuatiilor dinamice liniarizate de bucla deschisa ale sistemului de pendul
dublu si au computat simbolic ecuatia sistemului caracteristic si polilor in bucla deschisa ca
functii ale parametrilor sistemului (masa, lungime, etc.).
Dupa cum am indicat mai sus modelele de sistem hardware folosite in majoritatea
experimentelor in timp real in general au distributie de masa a conexiunilor neuniforma datorita
folosirii actuatoarelor, a senzorilor si alte consideratii. De asemenea existenta frecarii poate afecta
performanta oricarui proiect de control al sistemului intr-un mod semnificativ. Cu toate astea
ecuatiile de miscare furnizate de Larcombe (1991-1992) pentru un sistem general de pendul
10
invers multiplu nu contin in mod explicit acesti factori. In plus, ecuatiile lui Larcombe, desi
elegante din punct de vedere matematic nu sunt scrise in mod direct in termeni de parametri
fizici, cum ar fi masa si lungimea conexiunilor.
In aceasta lucrare o formulare mai generala a ecuatiilor de miscare pentru un sistem
de pendul invers multiplu va fi aratata. Ecuatiile derivate aici sunt formulate in termeni de
parametri fizici ca cei din Tabelul 1 de mai jos si pot fi folositi in mod direct cu scopul simularii
computerizate. Includ factori cum ar fi ajustarea locatiilor centrelor de gravitate pentru conexiuni
plus modele de frecare vascoasa si Coulomb.
11
Capitolul 2: Modelul matematic, modelare neliniara
2.1. Prezentare generala
Consideram un pendul bidimensional cu n conexiuni montat pe un carucior mobil,
dupa cum este aratat in figura 1. Caruciorul este miscat orizontal de forta ±𝐹(𝑡). Nomenclatura
sistemului este data in tabelul 1.
Tabel 1. Nomenclatura sistemului
Simbol Descriere
M Masa carutului.
mi Masa conexiunii i.
li Distanta de la cea mai joasa conexiune la centrul de gravitate al conexiunii i.
Li Lunigimea totala a conexiunii i.
μi Unghiul conexiunii i fata de pozitia verticala.
gi Unghiul relativ dintre conexiunea (i + 1) si conexiunea i.
r Pozitia carutului fata de referintat.
Ii Momentul de inertie al conexiunii i.
cr Coeficientul de frecare vascoasa intre carut si sina.
ci Coeficientul de frecare vascoasa al conexiunii .
¹r Coeficientul dee frecare Coulomb intre carut si sina.
¹i Coeficientul de frecare al conexiunii i.
Conexiunile se presupun ca sunt rigide in formularile ce urmeaza. Pentru un astfel de sistem este
nevoie de n + 1 ecuatii. Modelul matematic este construit folosind metoda lui Lagrange
(Greenwood 1988) dupa cum urmeaza:
12
Figura 1 Pendul invers multi-link
(1)
𝑑
𝑑𝑡 𝜕𝑇
𝜕𝑞𝑗 −
𝜕𝑇
𝜕𝑞𝑗+𝜕𝑉
𝜕𝑞𝑗= 𝑈𝑗 𝑗 = 1,… , 𝑛 + 1 ,𝑈 = [𝐹, 0,0,… ,0]𝑇
Unde T si V sunt energia cinetica si respectiv potentiala ale sistemului. Starile sistemului,
q, depind de sistemul de coordonate ales. Daca unghiurile conexiunilor sunt masurate in
concordanta cu pozitia verticala starile vor fi:
(2)
𝑞 = (𝑟 𝜃1 …𝜃𝑛)𝑇
2.2. Studiul problemei
Furuta et al. (1980) a sugerat ca frecarile dintre carucior si sinele acestuia si cele dintre
conexiuni sunt o combinatie de frecari Coulomb si frecari vascoase. Coeficientii de frecare se pot
afla minimizand diferenta dintre raspunsurile experimentelor in timp real si modelelor simulate.
Efectul frecarii vascoase care amortizeaza pentru un sistem cu un coeficient de libertate n, este
prin forta totala de amortizare care actioneaza asupra sistemului si este egala cu - 𝑐𝑖𝑗𝑞𝑖𝑛
𝑖=1
unde 𝑐𝑖𝑗 sunt coeficientii de amortizare. Amortizarea este inclusa in ecuatia lui Lagrange prin
13
Functia de disipare Raleigh, D=1
2 𝑞𝑖𝑞𝑗
𝑛𝑗=1
𝑛𝑖=1 . Pentru sisteme care se disipeaza D este o forma
patratica semidefinita sau definita, pozitiva, a velocitatilor si este egala cu o jumatate din rata de
disipare a energiei mecanice instantanee a sistemului. Pentru a acomoda nevoia de variatie a
masei de distributie in sistemul hardware centrul de gravitate pentru fiecare conexiune nu va fi
presupus a fi in mijloc, i.e. 𝑙𝑖 ≠1
2𝐿𝑖 in tabelul 1. Folosind masuratoarea absoluta a unghiurilor,
energia de disipare cinetica, potentiala si de frecare sunt dupa cum urmeaza.
Energia cinetica:
(3)
𝑇 =1
2 𝐼𝑖𝜃𝑖
2 + 𝑚𝑖
𝑛
𝑖=1
∗ 𝑑
𝑑𝑡 𝑟 + 𝐿𝑘 sin 𝜃𝑘 + 𝑙𝑖sin(𝜃𝑖)
𝑖−1
𝑘=𝑖−𝑛
2
+ 𝑑
𝑑𝑡 𝐿𝑘 cos 𝜃𝑘 + 𝑙𝑖cos(𝜃𝑖)
𝑖−1
𝑘=𝑖−𝑛
2
+1
2𝑀𝑟′2
Energie potentiala:
(4)
𝑉 = 𝑚𝑖𝑔 𝑙𝑖cos(𝜃𝑖 + 𝐿𝑘cos(𝜃𝑘)
𝑖−1
𝑘=𝑖−𝑛
𝑛
𝑖=1
Energia de disipare:
(5)
𝐷 =1
2 𝑐𝑖(𝜃𝑖 − 𝜃𝑖−1)2
𝑛
𝑖=1
+1
2𝑐𝑟𝑟
′2
Ecuatiile Lagrange ale sistemului sunt date dupa cum urmeaza:
14
(6)
𝑈𝑗 =
𝑑
𝑑𝑡 𝜕𝑇
𝜕𝑞𝑗 −
𝜕𝑇
𝜕𝑞𝑗+𝜕𝑉
𝜕𝑞𝑗+𝜕𝐷
𝜕𝑞𝑗, (𝑗 = 1,… , 𝑛 + 1 )
𝑈 = [𝐹 − 𝑠𝑖𝑔𝑛 𝑟 𝜇𝑟𝑁𝑟 ,−𝑠𝑖𝑔𝑛 𝜃1 𝜇𝜃1𝑁𝜃1
,… ,−𝑠𝑖𝑔𝑛 𝜃𝑛 𝜇𝜃𝑛𝑁𝜃𝑛 ]𝑇
Pentru coordonata r, manipularea matematica a ecuatiilor ne da:
(7)
𝑑
𝑑𝑡 𝜕𝑇
𝜕𝑟 = 𝑀 + 𝑚𝑖
𝑛
𝑖=1
𝑟′′ + 𝑚𝑖
𝑛
𝑖=1
𝐿𝑘 cos 𝜃𝑘 𝜃𝑘′′ − sin 𝜃𝑘 𝜃𝑘
2 +
𝑖−1
𝑘=𝑖−𝑛
𝑚𝑖 𝑙𝑖 cos 𝜃𝑖 𝜃𝑖′′ − sin 𝜃𝑖 𝜃𝑖
2
𝑛
𝑖=1
𝜕𝑇
𝜕𝑟= 0
𝜕𝑉
𝜕𝑟= 0
𝜕𝐷
𝜕𝑟= 𝑐𝑟𝑟
Ecuatia dinamica neliniara este data de:
(8)
𝑀 + 𝑚𝑖
𝑛
𝑖=1
𝑟′′ + 𝐿𝑘 cos 𝜃𝑘 𝜃𝑘′′ − sin 𝜃𝑘 𝜃𝑘
2
𝑖−1
𝑘=𝑖−𝑛
𝑛
𝑖=1
𝑚𝑖
+ 𝑚𝑖𝑙𝑖 cos 𝜃𝑖 𝜃𝑖′′ − sin 𝜃𝑖 𝜃𝑖
2
𝑛
𝑖=1
+ 𝑐𝑟𝑟 = 𝐹 − 𝑠𝑖𝑔𝑛 𝑟 𝜇𝑟𝑁𝑟
Aplicatia ecuatiei lui Lagrange pentru coordonata 𝜃𝑖 da urmatoarele rezultate:
15
(9)
𝜕𝑇
𝜕𝜃𝑗= 𝐼𝑖𝜃𝑖 + 𝑚𝑖𝑙𝑖 + 𝑚𝑗𝐿𝑖
𝑛
𝑗=𝑖+1
cos 𝜃𝑖 𝑟 + 𝑚𝑖 𝐿𝑘 𝑙𝑖cos(𝜃𝑘 − 𝜃𝑖)𝜃𝑘
𝑖−1
𝑘=𝑖−𝑛
+ 𝑚𝑖𝑙𝑖2 + 𝑚𝑗𝐿𝑖
𝑛
𝑗=𝑖+1
𝜃𝑖
+ 𝐿𝑝cos(𝜃𝑝 − 𝜃𝑖)𝜃𝑝
𝑖−1
𝑝=𝑗−𝑛
𝑚𝑗𝐿𝑖 + 𝑚𝑗 𝑙𝑗𝐿𝑖cos(
𝑛
𝑗=𝑖+1
𝑛
𝑗=𝑖+1
𝜃𝑗 − 𝜃𝑖)𝜃𝑗
(10)
𝑑
𝑑𝑡 𝜕𝑇
𝜕𝜃𝑖 = 𝐼𝑖𝜃𝑖
′′ + 𝑚𝑖𝑙𝑖 + 𝑚𝑗𝐿𝑖
𝑛
𝑗=𝑖+1
cos 𝜃𝑖 𝑟′′ − 𝑚𝑖𝑙𝑖 + 𝑚𝑗𝐿𝑖
𝑛
𝑗=𝑖+1
sin 𝜃𝑖 𝜃𝑖𝑟′
+ 𝑚𝑖𝑙𝑖2 + 𝑚𝑗𝐿𝑖
𝑛
𝑗=𝑖+1
𝜃′′
+ 𝐿𝑘 cos 𝜃𝑘 − 𝜃𝑖 𝜃𝑘′′ − sin 𝜃𝑘 − 𝜃𝑖 (𝜃𝑘 − 𝜃𝑖)𝜃𝑘
𝑖−1
𝑘=𝑖−𝑛
𝑚𝑖𝑙𝑖
+ 𝑚𝑗 𝑙𝑗 cos 𝜃𝑗 − 𝜃𝑖 𝜃𝑗′′ − sin 𝜃𝑗 − 𝜃𝑖 (𝜃𝑗 − 𝜃𝑖)𝜃𝑗
𝑛
𝑗=𝑖+1
𝐿𝑖
+ 𝐿𝑝[cos 𝜃𝑝 − 𝜃𝑖 𝜃𝑝′′ − sin 𝜃𝑝 − 𝜃𝑖 (𝜃𝑝 − 𝜃𝑖)𝜃𝑝
𝑖−1
𝑝=𝑗−𝑛
] 𝑚𝑗
𝑛
𝑗=𝑖+1
𝐿𝑖
(11)
𝜕𝑇
𝜕𝜃𝑖= − 𝑚𝑖𝑙𝑖 + 𝑚𝑗𝐿𝑖
𝑛
𝑗=𝑖+1
sin 𝜃𝑖 𝜃𝑖𝑟′ + 𝑚𝑖 𝐿𝑘 𝑙𝑖sin(𝜃𝑘 − 𝜃𝑖)𝜃𝑖𝜃𝑘
𝑖−1
𝑘=𝑖−𝑛
+ 𝐿𝑚𝐿𝑖sin(𝜃𝑝 − 𝜃𝑖)𝜃𝑖𝜃𝑝
𝑖−1
𝑝=𝑗−𝑛
𝑚𝑗 + 𝑚𝑗 𝑙𝑗𝐿𝑖sin(𝜃𝑗 − 𝜃𝑖)𝜃𝑖𝜃𝑗
𝑛
𝑗=𝑖+1
𝑛
𝑗=𝑖+1
16
(12)
𝜕𝑉
𝜕𝜃𝑖= −𝑔 𝑚𝑖 𝑙𝑖 + 𝑚𝑗𝐿𝑖
𝑛
𝑗=𝑖+1
sin 𝜃𝑖
(13)
𝜕𝑇
𝜕𝜃𝑖= (𝑐𝑖 + 𝑐𝑖+1)𝜃𝑖
′ − 𝑐𝑖−1𝜃𝑖+1′ + 𝑐𝑖𝜃𝑖−1
′
In final cele n ecuatii neliniare corespondente unghiurilor absolute 𝜃𝑖 sunt:
(14)
𝑈𝑖+1 = 𝑚𝑖𝑙𝑖 + 𝑚𝑗𝐿𝑖
𝑛
𝑗=𝑖+1
cos 𝜃𝑖 𝑟′′ 𝐼𝑖 + 𝑚𝑖𝑙𝑖
2 + 𝑚𝑗𝐿𝑖
𝑛
𝑗=𝑖+1
𝜃𝑖′′
+ 𝐿𝑘[cos 𝜃𝑘 − 𝜃𝑖 𝜃𝑘′′ − sin 𝜃𝑘 − 𝜃𝑖 𝜃𝑘
′′ ]
𝑖−1
𝑘=𝑖−𝑛
𝑚𝑖𝑙𝑖
+ 𝑚𝑗 𝑙𝑗 [cos 𝜃𝑗 − 𝜃𝑖 𝜃𝑗′′ − sin 𝜃𝑗 − 𝜃𝑖 𝜃𝑗
′′ ]
𝑛
𝑗=𝑖+1
𝐿𝑖
+ 𝐿𝑝 [cos 𝜃𝑝 − 𝜃𝑖 𝜃𝑝′′ − sin 𝜃𝑝 − 𝜃𝑖 𝜃𝑝
2]
𝑗−1
𝑝=𝑗−𝑛
𝑚𝑗
𝑛
𝑗=𝑖+1
𝐿𝑖
− 𝑔 𝑚𝑖𝑙𝑖 + 𝑚𝑗𝐿𝑖
𝑛
𝑗=𝑖+1
sin 𝜃𝑖 + (𝑐𝑖 + 𝑐𝑖+1)𝜃𝑖′ − 𝑐𝑖−1𝜃𝑖+1
′ + 𝑐𝑖𝜃𝑖−1′
(i = 1, ..., n)
Ecuatiile pot fi rearanjate in forma dupa stare dupa cum urmeaza:
(15)
𝐹 𝑞 𝑞′′ + 𝐺 𝑞, 𝑞′ 𝑞′ + 𝐻 𝑞 = 𝐿(𝑞,𝑢)
17
Unde F si G sunt matrice patratice astfel:
(16)
𝐹𝑤𝑤 𝑞 =
𝑀 + 𝑚𝑖 ,𝑤 = 1
𝑛
𝑖=1
𝐼𝑤−1 + 𝑚𝑤−1𝐼𝑤−12 + 𝑚𝑗𝐿𝑤−1, 1 < 𝑤 ≤ 𝑛 + 1
𝑛
𝑗=𝑤
(17)
𝐹𝑤𝑣 𝑞 =
𝑚𝑖 𝐿𝑘cos(𝜃𝑘)
𝑣−2
𝑘=𝑣−𝑛−1
+
𝑛
𝑖=𝑣−1
𝑚𝑖𝑙𝑖cos(𝜃𝑖)
𝑛
𝑖=𝑣−1
,𝑤 = 1, 1 < 𝑣 ≤ 𝑛 + 1
𝑚𝑖 𝐿𝑘cos(𝜃𝑘)
𝑛−2
𝑘=𝑤−𝑛−1
𝑛
𝑖=𝑤−1
+ 𝑚𝑖𝑙𝑖cos(𝜃𝑖)
𝑛
𝑖=𝑤−1
, 𝑣 = 1, 1 < 𝑤 ≤ 𝑛 + 1
𝐿𝑘 cos 𝜃𝑘 − 𝜃𝑣−1
𝑤−2
𝑘=𝑤−𝑛−1
𝑚𝑤−1𝑙𝑤−1 + 𝑚𝑗 𝑙𝑗 cos 𝜃𝑗 − 𝜃𝑣−1
𝑛
𝑗=𝑤
𝐿𝑤−1
+ 𝐿𝑝 [cos 𝜃𝑝 − 𝜃𝑣−1 ]
𝑗−1
𝑝=𝑗−𝑛
𝑛
𝑗=𝑤
𝑚𝑗 𝐿𝑤−1
,𝑎𝑙𝑡𝑓𝑒𝑙
(18)
𝐺𝑤𝑣 𝑞, 𝑞′ = 𝑐𝑟 ,𝑤 = 1
𝑐𝑤−1 + 𝑐𝑤 , 1 < 𝑤 ≤ 𝑛 + 1
(19)
𝐺𝑤𝑣 𝑞, 𝑞′
=
0, 𝑣 = 1, 1 < 𝑤 ≤ 𝑛 + 1
− 𝑚𝑖𝑙𝑖 sin 𝜃𝑣−1 𝜃𝑣−1 − 𝐿𝑘sin(𝜃𝑣−1)𝜃𝑣−1
𝑤−2
𝑘=𝑤−𝑛−1
𝑛
𝑖=𝑤−1
𝑛
𝑖=𝑤−1
− 𝐿𝑘 sin 𝜃𝑘 − 𝜃𝑣−1 𝜃𝑣−1
𝑤−2
𝑘=𝑤−𝑛−1
𝑚𝑤−1𝑙𝑤−1 − 𝑚𝑗 𝑙𝑗 sin 𝜃𝑗 − 𝜃𝑣−1 𝜃𝑣−1
𝑛
𝑗=𝑤
𝐿𝑤−1
− 𝐿𝑝sin(𝜃𝑝 − 𝜃𝑣−1)𝜃𝑣−1
𝑗−1
𝑝=𝑗−𝑛
𝑛
𝑗=𝑤
𝑚𝑗 𝐿𝑤−1
,𝑎𝑙𝑡𝑓𝑒𝑙
18
H si L sunt vectori n X 1 si pot fi gasiti astfel:
(20)
𝐻𝑤 𝑞 =
0,𝑤 = 1
−𝑔 𝑚𝑤−1𝑙𝑤−1 + 𝑚𝑗𝐿𝑤−1
𝑛
𝑗=𝑤
sin 𝜃𝑤−1 ,𝑎𝑙𝑡𝑓𝑒𝑙
(21)
𝐿𝑤 𝑞,𝑢 = 𝐹 − 𝑠𝑖𝑔𝑛 𝑟 𝜇𝑟𝑁𝑟 ,𝑤 = 1
−𝑠𝑖𝑔𝑛 𝜃𝑤−1 𝜇𝜃𝑤−1𝑁𝜃𝑤−1
,𝑎𝑙𝑡𝑓𝑒𝑙
Pentru a rezolva ecuatiile dinamice neliniare forma spatiului de stare este extinsa pentru a
include starile si primelelor derivate dupa cum urmeaza:
Ecuatia (15) va deveni:
(22)
(1) 𝐹 𝑞 𝑞′′ = −𝐺 𝑞, 𝑞′ 𝑞′ −𝐻 𝑞 + 𝐿 𝑞,𝑢 𝑢𝑛𝑑𝑒 𝑞 = (𝑟 𝜃1 … 𝜃𝑛)𝑇
(2) 𝑋 = 𝑞𝑖𝑞𝑖 , 𝑖 = 1,… ,𝑛 + 1
Noua forma a spatiului de stare este data de:
(3) 𝐼 00 𝐹
𝑋′ = 0 𝐼0 −𝐺
𝑋 + 0−𝐻 + 0
𝐿
Sau
(23)
𝑋′ = 0 𝐼0 −𝐹−1𝐺
𝑋 + 0
−𝐹−1𝐻 +
0
𝐹−1𝐿
Sau
(24)
𝑋′ 𝑡 = 𝑓(𝑋 𝑡 ,𝑢 𝑡 )
Fiind data o stare initiala𝑋0 si folosind metoda de integrare numerica Runge-Kutta de
orice ordin, vectorul de stare 𝑋 𝑡 este usor de simulat.
19
Din motive practice ecuatiile de miscare neliniare pot fi formulate in sisteme de
coordonate diferite. In general senzorii de miscare unghiulara masoara unghiurile relative dintre
diferite conexiuni consecutive. Astfel, dinamica sistemului poate fi reformulata in sistemul de
coordonate Devanit-Hartenberg, in care starile cunt:
(25)
𝑞 = (𝑟 𝜃1 𝛾1 …𝛾𝑛−1)𝑇
Stiind ca:
(26)
𝛾𝑖 = 𝜃𝑖+1 − 𝜃𝑖 , 𝑖 = 1,… ,𝑛 − 1
𝜃𝑖 = 𝛾𝑘 + 𝜃𝑖
𝑖−1
𝑘=1
, 𝑖 = 2,… ,𝑛
Larcombe (1991) a reusit asta inlocuind 𝜃𝑖 cu γk + θ1(i = 2,… , n)𝑖−1
𝑘=1in ecuatiile de miscare
formulate in coordonate absolute. Din moment ce ecuatiile obtinute pot fi foarte complicate se
sugereaza ca ar fi mai simplu sa se rezolve ecuatia (23) mai intai dupa care se va transforma
vectorul de stare 𝑋 𝑡 in celalalt sistem de coordonate folosind o matrice de transformare T
definita ca:
(27)
𝑇𝑤𝑣 = 1,𝑤 = 𝑣,
−1,𝑤 = 𝑣 + 1,2 < 𝑤 ≤ 𝑛 + 1,𝑛 + 3 < 𝑤 ≤ 2𝑛 + 2,0,𝑎𝑙𝑡𝑓𝑒𝑙
Ca exemplu pentru un sistem de pendul invers dublu pentru a transforma de la vectorul de stare
X=(𝑟 𝜃1𝜃2 𝑟 𝜃1𝜃2)𝑇 la 𝑋𝑛𝑜𝑢 =(𝑟 𝜃1𝛾1 𝑟 𝜃1𝛾1)𝑇, matricea de transformare va fi:
𝑇 =
1 0 00 1 00 −1 1
0 0 00 0 00 0 0
0 0 00 0 00 0 0
1 0 00 1 00 −1 1
Si
𝑋𝑛𝑒𝑤 = 𝑇𝑋
20
2.3. Exemplificare
Ca validare a ecuatiilor prezentate anterior, ecuatiile de miscare pentru pendulul invers
dublu si triplu sunt extrase din setul de ecuatii dinamice neliniare generale si verificate cu ecuatii
specificate anterior derivate specific pentru fiecare sistem. Ecuatiile dinamice neliniare pentru un
sistem de pendul invers cu doua conexiuni, incluzand modelele de frecare vascoasa si Coulomb,
sunt dupa cum urmeaza:
(28)
𝑚 + 𝑚1 + 𝑚2 𝑟 + 𝑚1𝑙1 + 𝑚2𝐿1 cos 𝜃1 𝜃1 +𝑚2𝑙2 cos 𝜃2 𝜃2
+ 𝑐𝑟
− 𝑚1𝑙1 + 𝑚2𝐿1 sin 𝜃1 𝜃12 −𝑚2𝑙2sin 𝜃2 𝜃2
2 = 𝐹 − 𝑠𝑖𝑔𝑛 𝑟 µ𝑟𝑁𝑟
𝑚1𝑙1 + 𝑚2𝐿1 𝑟 + 𝐼1 + 𝑚1𝑙12 + 𝑚2𝐿1
2 𝜃1 + 𝑚2𝑙2𝐿1 cos 𝜃1 − 𝜃2 𝜃2
+ 𝑐1 + 𝑐2 𝜃1 − 𝑐2𝜃2
+ 𝑚2𝑙2𝐿1 sin 𝜃1 − 𝜃2 𝜃22 − 𝑔 𝑚1𝑙1 + 𝑚2𝐿1 sin𝜃1 = −𝑠𝑖𝑔𝑛 𝜃1 µ𝜃1
𝑁𝜃1
𝑚2𝑙2 cos 𝜃2 𝑟 + 𝑚2𝑙2𝐿1 cos 𝜃1 − 𝜃2 𝜃1 + 𝐼2 + 𝑚2𝑙2
2 𝜃2 − 𝑚2𝑙2𝐿1 sin 𝜃1 − 𝜃2 𝜃1
2 − 𝑐2𝜃1
+ 𝑐2𝜃2 − 𝑔𝑚2𝑙2 sin 𝜃2 = −𝑠𝑖𝑔𝑛(𝜃2)µ𝜃2𝑁𝜃2
Ecuatiile corespund cu cele prezentate in Furuta et al. (1987, 1980) care sunt derivate specific
pentru configurarea sistemelor lor hardware. Pentru sistemul cu trei conexiuni, ecuatiile dinamice
neliniare pot fi scrise in forma ecuatiei (15) in care:
F 𝑞 =
𝐴1 𝐴2 cos 𝜃1 𝐴3 cos 𝜃2 𝐴4 cos 𝜃3
𝐴9 cos 𝜃1 𝐴10 𝐴11 cos 𝜃1 − 𝜃2 𝐴12 cos 𝜃1 − 𝜃3
𝐴18 cos 𝜃2 𝐴19 cos 𝜃1 − 𝜃2 𝐴20 𝐴21 cos 𝜃2 − 𝜃3
𝐴28 cos 𝜃3 𝐴29 cos 𝜃1 − 𝜃3 𝐴30 cos 𝜃2 − 𝜃3 𝐴31
G(q,𝑞 )
=
𝐴5 𝐴6 sin 𝜃1 𝜃2 𝐴7 sin 𝜃2 𝜃2 𝐴8 sin 𝜃3 𝜃3
0 𝐴13 𝐴14 sin 𝜃1 − 𝜃2 𝜃2 + 𝐴15 𝐴16 sin 𝜃1 − 𝜃3 𝜃3
0 𝐴22 sin 𝜃1 − 𝜃2 𝜃1 + 𝐴23 𝐴24 𝐴25 sin 𝜃2 − 𝜃3 𝜃3 + 𝐴26
0 𝐴33 sin 𝜃1 − 𝜃3 𝜃1 𝐴35 sin 𝜃2 − 𝜃3 𝜃2 + 𝐴36 𝐴31
𝐻 𝑞 =
0𝐴17 sin 𝜃1
𝐴27 sin 𝜃2
𝐴34 sin 𝜃3
21
Tabel 2. Constantele sistemului
Constanta Valoare Constanta Valoare
𝐴1 M + 𝑚1+𝑚2 + 𝑚3 𝐴19 𝑚2𝑙2 + 𝑚3𝐿2 𝐿1
𝐴2 𝑚1𝑙1 + 𝑚2 + 𝑚3 𝐿1 𝐴20 𝐼2 + 𝑚2𝑙22 + 𝑚3𝐿2
2
𝐴3 𝑚2𝑙2 + 𝑚3𝑙2 𝐴21 𝑚3𝑙3𝐿2
𝐴4 𝑚3𝑙3 𝐴22 −𝐿1 𝑚2𝑙2 + 𝑚3𝐿2
𝐴5 𝑐𝑟 𝐴23 −𝑐2
𝐴6 −𝑚1𝑙1 − 𝑚2 + 𝑚3 𝐿1 𝐴24 𝑐2 + 𝑐3
𝐴7 − 𝑚2𝑙2 + 𝑚3𝑙2 𝐴25 𝑚3𝑙3𝐿2
𝐴8 −𝑚3𝑙3 𝐴26 −𝑐3
𝐴9 𝑚1𝑙1 + 𝑚2 + 𝑚3 𝐿1 𝐴27 −𝑔 𝑚2𝑙2 + 𝑚3𝐿2
𝐴10 𝐼1 + 𝑚1𝑙12 + (𝑚2 + 𝑚3)𝐿1
2 𝐴28 𝑚3𝑙3
𝐴11 𝑚2𝑙2 + 𝑚3𝐿2 𝐿1 𝐴29 𝑚3𝑙3𝐿1
𝐴12 𝑚3𝑙3𝐿1 𝐴30 𝑚3𝑙3𝐿2
𝐴13 𝑐1 + 𝑐2 𝐴31 𝐼3 + 𝑚3𝑙32
𝐴14 𝑚2𝑙2 + 𝑚3𝐿2 𝐿1 𝐴32 𝑐3
𝐴15 −𝑐2 𝐴33 −𝑚3𝑙3𝐿1
𝐴16 𝑚3𝑙3𝐿1 𝐴34 −𝑔𝑚3𝑙3
𝐴17 −𝑔 𝑚1𝑙1 + 𝑚2𝐿 + 𝑚3𝐿1 𝐴35 −𝑚3𝑙3𝐿1
𝐴18 𝑚2𝑙2 + 𝑚3𝑙2 𝐴36 −𝑐3
𝐿 𝑞, 𝑢 =
𝐹 − 𝑠𝑖𝑔𝑛(𝑟)µ𝑟𝑁𝑟−𝑠𝑖𝑔𝑛(𝜃1)µ𝜃1
𝑁𝜃1
−𝑠𝑖𝑔𝑛(𝜃2)µ𝜃2𝑁𝜃2
−𝑠𝑖𝑔𝑛(𝜃3)µ𝜃3𝑁𝜃3
22
𝐴𝑖-urile sunt constante ale sistemului si sunt date in tabelul 2. Aceste ecuatii sunt conform
celor procesate in Meier zu Farwig si Unbehauen (1990) cand masa motorului superior al
sistemului lor este combinata cu masa conexiunii.
2.4. Tipuri de frecari
Desi frecarea, care disipeaza energie intr-un sistem, ar parea sa fie o forta stabilizatoare s-
a aratat ca subestimarea marimii coeficientului de frecare poate cateodata sa duca la instabilitate
intr-un sistem de control cu feedback. Deasemenea frecarea a fost asociata cu un comportament
oscilatoriu. Cicluri de limitare generate de frecare au fost aratate intr-un sistem de carucior
simplu, simulat, si au fost observata experimental intr-un aparat pentru balansare.
Comportamentul oscilatoriu a fost prevazut teoretic intr-un sistem de balansare cu reactie.
Un model de frecare mai precis intre carucior si sina include frecare statica si Coulomb
(alunecare) cat si frecare vascoasa. Frecarea statica este frecarea care trebuie depasita pentru a
incepe miscarea, este astfel prezenta numai cand obiectul nu se misca. Frecarile Coulomb si
vascoasa sunt prezente doar cand sistemul se misca. Astfel cel mai simplu model care
incorporeaza toate acestea este:
𝐹𝑓𝑟𝑖𝑐 = 𝐹𝑠𝑡𝑎𝑡𝑖𝑐
𝐹𝐶𝑜𝑢𝑙𝑜𝑚𝑏 + 𝐹𝑣𝑎𝑠𝑐𝑜𝑎𝑠𝑎 𝑑𝑎𝑐𝑎 𝑥 = 0𝑑𝑎𝑐𝑎 𝑥 ≠ 0
Componentele vascoase au modele bine cunoscute:
𝐹𝑓𝑟𝑖𝑐 = −𝐹𝑎𝑝𝑙𝑖𝑐𝑎𝑡𝑎
µ𝑠𝐹𝑠𝑔𝑛 𝐹𝑎𝑝𝑙𝑖𝑐𝑎𝑡𝑎 𝑑𝑎𝑐𝑎 𝐹𝑎𝑝𝑙𝑖𝑐𝑎𝑡𝑎 < µ𝑠𝐹𝑁
𝑑𝑎𝑐𝑎 𝐹𝑎𝑝𝑙𝑖𝑐𝑎𝑡𝑎 ≥ µ𝑠𝐹𝑁
𝐹𝐶𝑜𝑢𝑙𝑜𝑚𝑏 = µ𝑐𝐹𝑠𝑔𝑛 𝑥 ,
𝐹𝑣𝑎𝑠𝑐𝑜𝑎𝑠𝑎 = −𝜀𝑥
Unde µ𝑠 , µ𝑐 , 𝜀sunt coeficientii frecarilor statice, Coulomb si vascoase, iar 𝐹𝑁este magnitudinea
fortei normale. In modelul nostru obiectul se misca orizontal deci 𝐹𝑁 = 𝑚 + 𝑀 𝑔. Valoarea a
diversi parametrii se pot determina experimental ca in tebelul urmator:
23
Parametrii Descriere Estimare
𝜇𝑠 coeficient frecare statica 0,08328
𝜇𝑐 coeficient frecare Coulomb 0,04287
𝜀 coeficient frecare vascoasa 0,3156
24
Capitolul 3: Controlul sistemului (strategii de comanda)
3.1. Strategii de control
Datorita faptului ca pendulul invers prezinta un sistem instabil este deseori folosit ca un
punct de reper pentru a verifica performantele si eficienta unui algoritm pentru reglare. Pendulul
invers este o combinatie de diverse arii de studiu, robotica, teoria controlului etc. Scopul este de
a aduce pendulul din pozitia de stare vertical jos in pozitia vertical sus si sa il mentinem acolo
odata atinsa. Caruciorul va trebui de asemenea sa fie pozitionat in pozitia initiala. Toate astea
trebuie facuta miscand caruciorul stanga si dreapta pe sinele acestuia evident fara a depasi
marginile. In teorie putem gasi o multime de algoritmi pentru stabilizare pe verticala. Wei et al a
prezentat un model de strategie neliniara pentru control prin descompunerea legii de control intr-
o secventa de pasi. Chung si Houser au propus o lege de stare neliniara bazata pe feedback pentru
a regla pozitia caruciorului cat si energia de balansare a pendulului. Zhao si Spong au aplicat o
strategie de control hibrida care stabilizeaza asimptotic global pentru toate conditiile initiale.
Metoda lor nu necesita sa ia in considerare lungimea sinei. Chatterjee et al. propune o lege de
control bazata pe energie care ridica si stabilizeaza un sistem carucior-pendul cu lungime a sinei
limitata si de asemenea forta de control limitata in simulare cat si in sistem real. O problema
majora cu metoda lor este proiectarea potentialelor si coeficientilor folosind intuitia si iteratii care
consuma timp. Toate aceste metode necesita o cunoastere amanuntita a dinamicii sistemului.
Folosirea logicii de control Fuzzy nu necesita cunoasterea amanuntita a sistemului ceea ce
devine foarte importand cand avem de aface cu sisteme neliniare complexe. Mai mult decat asta
modelarea dinamica a sistemelor arata o dependenta de parametrii mecanici ai acestora, acestia
fiind supusi multor modificari pe percursul vietii (unele din cauza micilor deteriorari), si
deasemenea o dependenta de parametrii dinamici care variaza odata cu actiunea performata.
Aceste considerente dau controlului fuzzy un avantaj asupra altor metode neliniare. S-au propus
mai multe tehnici de control fuzzy. Wong a adoptat algoritmul genetic pentru a tuna toate
functiile membre ale sistemului fuzzy pentru a mentine un pendul invers erect. Yamakawa a
proiectat un sistem hardware de control fuzzy foarte rapid si a folosit numai sapte reguli de
control pentru a regla un pendul invers. Dar aceste metode nu iau in considerare lungimea sinei.
Matsuura si Yasunobu au folosit amandoi informatia venita de la carucior pentru a construi un set
de 49 de reguli pentru a controla unghiul virtual dorit si apoi au folosit informatii despre unghiul
virtual si informatiile despre pendul pentru a construi un alt set de 49 de reguli fuzzy pentru
25
stabilizare totala. Majoritatea algoritmilor pentru control si stabilizare fuzzy folosesc un numar
mare de functii membru. Parametrii acestor functii sunt greu de gasit. Mai mult, numarul mare de
functii membru creste dificultatea gasirii regulilor.Ca o alternativa la abordarea conventionala de
control controlul fuzzy introduce informatii lingvistice. Cea mai dificila parte e controlului fuzzy
este constructia regulilor bazate pe experienta si intuitia operatorului. De asemenea ajustarea
functiilor membru ale controlului fuzzy este un pas important in strategia de control.
In aceasta lucrare se va prezenta o noua structura de control pentru conducerea unui
sistem cu un pendul invers neliniar cu frecare. Pentru a simplifica design-ul controlerului fuzzy
pentru balansarea controlerului si miscarea caruciorului la origine, sistemul de pendul invers este
descompus in doua sub sisteme unul pentru pendul si unul pentru carucior. Pentru aceste
subsisteme doua controlere pentru stabilizare sunt propuse, tinand cont de forma neliniara a
sistemului parinte. Schema de stare are o structura simpla care scade numarul de reguli fuzzy.
3.2. Aspecte preliminare
Figura 2 este desenul schematic al sistemului de pendul invers si carucior. Caruciorul este
capabil sa se miste pe o sina cu dimensiune limitata.
26
Figura 2. Sistem pendul invers si carut
Figura 3 arata diagrama a celor doua componente ale sistemului, pendulul si carutul,
separate.
Figura 3. Carut si pendul separate
In acest sistem tija pendulului este considerata fara masa, F este forta aplicata pentru
control, x este deplasarea carutului, θ este unghiul dintre pozitia pendulului curenta si cea
27
verticala, g este acceleratia gravitationala. Alti parametri sunt masa carutului M, masa pendulului
m, coeficientul de frecare al carutului b, lungimea de la centrul pendulului la ax si inertia
pendulului I.
Pentru simulare ecuatiile dinamice ale pendulului invers sunt dupa cum urmeaza:
𝑀𝑑2𝑥
𝑑𝑡2= 𝐹
𝑐𝑎𝑟𝑡
F = M𝑥 + b𝑥 + N
Unde N si P sunt fortele de interactune dintre carut si pendul.
𝑑2𝑥
𝑑𝑡2=
1
𝑀 𝐹 − 𝑁 − 𝑏
𝑑𝑥
𝑑𝑡
Pentru pendul
𝐼𝑑2𝜃
𝑑𝑡2= 𝜏
𝑝𝑒𝑛𝑑
𝑑2𝜃
𝑑𝑡2=
1
𝐼 𝑁𝑙 cos 𝜃 + 𝑃𝑙 sin𝜃
Este necesar sa introducem fortele de interactiune N si P intre carut si pendul pentru a
modela dinamica sistemului corect. Includerea acestor forte necesita modelarea dinamicilor x si y
ale pendulului in plus fata de theta. Astfel ecuatiile aditionale x si y pentru pendul sunt modelate
astfel:
𝑚𝑑2𝑥𝑝
𝑑𝑡2= 𝐹𝑥 = 𝑁
𝑝𝑒𝑛𝑑
𝑁 = 𝑚𝑑2𝑥𝑝
𝑑𝑡2
𝑚𝑑2𝑦𝑝
𝑑𝑡2= 𝐹𝑦 = 𝑃 −𝑚𝑔
𝑝𝑒𝑛𝑑
𝑃 = 𝑚(𝑑2𝑦𝑝
𝑑𝑡2+ 𝑔)
Cu toate astea 𝑥𝑝 𝑠𝑖 𝑦𝑝 sunt functii exacte ale lui theta. Astfel derivatele lor sunt
prezentate in functie de derivatele lui theta.
28
𝑥𝑝 = 𝑥 − 𝑙 sin 𝜃
𝑑𝑥𝑝
𝑑𝑡=
𝑑𝑥
𝑑𝑡− 𝑙 cos𝜃
𝑑𝜃
𝑑𝑡
𝑑2𝑥𝑝
𝑑𝑡2=
𝑑2𝑥
𝑑𝑡2+ 𝑙 sin𝜃
𝑑𝜃
𝑑𝑡
2
− 𝑙 cos 𝜃𝑑2𝜃
𝑑𝑡2
Si
𝑦𝑝 = 𝑙 cos𝜃
𝑑𝑦𝑝
𝑑𝑡= −𝑙 sin 𝜃
𝑑𝜃
𝑑𝑡
𝑑2𝑦𝑝
𝑑𝑡2= − 𝑙 cos𝜃
𝑑𝜃
𝑑𝑡
2
− 𝑙 sin𝜃𝑑2𝜃
𝑑𝑡2
Dupa inlocuirea in ecuatiile 7 si 9, avem:
N = m𝑑2𝑥𝑝
𝑑𝑡2= 𝑚
𝑑2𝑥
𝑑𝑡2+ 𝑙 sin𝜃
𝑑𝜃
𝑑𝑡
2
− 𝑙 cos𝜃𝑑2𝜃
𝑑𝑡2
P = m𝑑2𝑦𝑝
𝑑𝑡2= 𝑚 − 𝑙 cos 𝜃
𝑑𝜃
𝑑𝑡
2
− 𝑙 sin𝜃𝑑2𝜃
𝑑𝑡2
Folosind aceste ecuatii neliniare am simulat un sistem de pendul invers cu carucior intr-o
aplicatie vizuala.
3.3. Proiectarea schemei de control
Design-ul controlerului este un factor cheie al sistemului de pendul inversat. Controlerele
sunt folosite pentru a stabiliza un sistem instabil si pentru a-l face robust impotriva perturbatiilor.
Framework-ul acestui controler fuzzy este prezentat in figura urmatoare.
29
Figura 4. Diagrama bloc controler fyzzy
In figura numarul 4 sistemul de pendul invers cu carucior este controlat de doua
controllere separate, controlerul pentru unghiul pendulului si cel pentru pozitia carutului. Din
ecuatiile dinamice pentru acest sistem descoperim ca sunt doua obiecte dinamice, unul este
pendulul iar celalalt este carutul. Sa consideram controlul pentru carut si pentru pendul separate
ar facilita dezvoltarea controlerului cu un mecanism de reguli.
Cu toate astea este permisa o singura actiune pentru sistemul de pendul invers cu carucior
si anume forta aplicata asupra carutului. Astfel forta Fp a pendulului si forta Fc a caruciorului vor
trebui sa fie combinate intr-o singura forta de control F pentru sistem. Putem observa ca pentru a
suplimenta o forta de actiune pentru a impinge carutul in partea stanga va misca pendulul in
partea dreapta. Din aceasta cunostinta instinctiva este usor de vazut ca cele doua forte Fp si
respectiv Fc au semne opuse. Tinand cont ca scopul principal al acestui experiment este de a
balansa pendulul in stare erecta combinatia de forte va fi reprezentata astfel, F = Fp – Fc.
3.4. CLF (Controler de Logica Fuzzy)
CLF este una dintre cele mai de succes aplicatii din setul de teorii fuzzy, introdus de catre
Zadeh in 1965, caracteristicile sale majore fiind utilizarea variabilelor lingvistice in locul celor
30
numerice. Variabilele lingvistice sunt definite in limbaj normal (cum ar fi “mic” sau “mare”) si
pot fi reprezentate inseturi fuzzy.
Un set fuzzy este o extensie a unui se de tip crisp unde un element poate apartine numai
unui singur set (apartenenta totala) sau a nu apartine nici unui set (zero apartenenta). Un set fuzzy
permite apartenenta partiala ceea ce inseamna ca un element poate apartine mai multor seturi
concomitent.
Un set fuzzy A este caracterizat printr-o functie de apartenenta µ𝐴 care asigneaza fiecarui
obiect al unei clase o nota de apartenenta care poate varia intre 0 (zero apartenenta) si 1
(apartenenta totala) astfel vom avea:
µ𝐴 ∶ 𝑋 → 0,1
Ceea ce inseamna ca setul fuzzy A apartine unui set universal X (numit in general univers de
tratare) definit intr-o problema specifica. Un set fuzzy A este numit un singleton fuzzy unde este
un singur element 𝑥0 cu µ𝐴(𝑥0) = 1 in timp ce gradul de apartenenta al tuturor celorlalte va fi
zero.
Aceasta abordare permite caracterizarea comportamentului sistemului prin relatii simple
(reguli fuzzy) intre variabile lingvistice. In general regulile fuzzy sunt exprimate in forma
expresiilor conditionale fuzzy de tipul:
If x mic THEN y este mare
Unde x si y sunt variabile fuzzy si mic sau mare sunt etichete ale setului fuzzy. Daca sunt de la i
= 1 la n reguli setul de regult reprezentat de uniunea acestor reguli ar fi:
R = R1 else R2 else ...Rn
Un controler de logica fuzzy este bazat pe o colectie de R reguli de control. Executia
acestor reguli este guvernata de catre regula de inferenta compozitionala.
Structura generala a unui CLF este reprezentata in Figura 5 si este compusa din
componentele principale:
- O interfata de fuzzyficare care converteste date de intrare in variabile lingvistice
corespunzatoare,
- O baza de cunostinte care consta in o baza de date cu definitii lingvistice generale si
un set de reguli de control,
31
- O logica de decizie care face folos de cunostintele dini baza de date si de definitiile
lingvistice pentru a crea controlul fuzzy,
- Si in final o interfata de defuzzyficare care interpreteaza actiunea data de catre logica
de decizie pentru a spacifica o actiune sictemului.
Figura 5. Comfigurare de baza CLF
In aceasta lucrare vom creea doua controlere de tip fuzzy pentru pendul respectiv
carucior, fiecare controler va folosi doua variabile de intrare: controlerul pentru unghiul
pendulului va folosi doua erori una pentru unghiul fata de verticala si una care reiese din derivata
acesteia edot, iar carutul va folosi deasemenea doua erori una cu referinta la pozitia fata de starea
initiala x si una formata prin derivarea acesteia xdot. Iesirea acestor controlere ne vor da forta cu
care vom actiona asupra caruciorului.
Controlerele de logica fuzzy propuse pentru a controla pendulul invers folosesc functii de
apartenenta conventionale triunghiulare. Mai mult motorul de inferenta fuzzy implementeaza un
set de reguli IF-THEN-ELSE pentru eroarea unghiulara e si cea edot pentru forta Fp si eroarea de
pozitie a carutului x si respectiv cea edot pentru forta Fc. Toate sase universele de tratare sunt
32
impartite in trei seturi de valori fuzzy care se intrepatrund N (negativ), Z (zero) si P (pozitiv).
Figura 5 care urmeaza arata un exemplu luat dintr-o simulare Mathlab care arata functiile de
apartenenta si universurile de tratare pentru pendul. Pentru carucior vor fi similare. Crearea
regulilor este bazata pe cunostinta euristica a comportamentului sistemului si criterii teoretice.
Pentru a genera regulile acestei lucrari criteriul de baza este considerat ca: daca pendulul cade
intr-o anumita directie, impinge carutul in aceeasi directie pentru a contracara miscarea
pendulului. Noua reguli sunt definite pentru fiecare controler si tinute intr-o matrice. Matricea de
reguli pentru controlul unghiului pendulului este aratata in Tabelul 3 si este similara cu cea
pentru carucior.
Figura 6 Functiile de apartenenta pendul
33
Tabel 3 Exemplu reguli control fuzzy
edot
e
N Z P
N
N N Z
Z
N Z P
P
Z P P
34
Capitolul 4: Aplicatie
Aceasta aplicatie are scopul de a simula intr-un mediu digital un sistem cu pendul invers
cu carucior cu una sau doua conexiuni (simplu sau dublu). Un beneficiu al acestei aplicatii este ca
permite studiul implementarii unui regulator de tip fuzzy/ dar si a altor controllere pentru
conducerea sistemului cu pendul invers fara a necesita componentele experimentale costisitoare
ale unui astfel de mecanism sau diverse licente pentru programele folosite ca mediu de reglare.
4.1. Continutul aplicatiei
Aplicatia este construita in jurul unui Engine (de vazut anexa A.6.) care face legatura intre
diverse componente. Acesta initializeaza programul si imparte executia intr-un numar predefinit
de frame-uri per secunda, repetand anumiti pasi in fiecare frame.
Primul pas este de a transmite controlerului de logica fuzzy (clasa FuzzyController, de
vazut anexa A.1.) starea curenta a sistemului. Controlerul fuzzy va calcula in functie de aceasta
stare un raspuns, sub forma unei forte care va fi aplicata asupra carutului.
Engine-ul va prelua raspunsul si il va transmite in functie de caz uneia dintre clasele
InvertedPendulum (anexa A.2.) sau DoubleInvertedPendulum (anexa A.3.), acestea urmand sa
calculeze evolutia sistemului.Pentru a determina schimbarile in starea sistemului, vor fi
rezolvatesisteme de ecuatii diferentiale obtinute din modelul matematic al pendului invers,
prezentat in capitolul 2.Pentru rezolvarea sistemelor de ecuatii este folosita metoda Dormand-
Prince.
4.2. Sistemul de ecuatii
Inlocuind constantele si variabilele cunoscute din modelul matematic al pendului invers se
obtin sisteme de ecuatii diferentiale de forma:
Pendulul simplu:
𝑐11𝑟 + 𝑐12Ө = 𝐴
𝑐21𝑟 + 𝑐22Ө = 𝐵
Pendulul dublu:
𝑐11𝑟 + 𝑐12Ө1 + 𝑐13Ө2
= 𝐴
𝑐21𝑟 + 𝑐22Ө1 + 𝑐23Ө2
= 𝐵
𝑐31𝑟 + 𝑐32Ө1 + 𝑐33Ө2
= 𝐶
35
Pentru a obtine 𝑟 si Ө in cazul pendulului simplu, se rezolva sistemul prin a elimina pe
rand cate una dintre variabile. Rezultatul:
𝑟 =𝐴𝑐22 − 𝐵𝑐12
𝑐11𝑐22 − 𝑐21𝑐12
Ө =𝐵𝑐11 − 𝐴𝑐21
𝑐11𝑐22 − 𝑐21𝑐12
In cazul pendului dublu ecuatia se rescrie ca:
𝑐11 𝑐12 𝑐13
𝑐21 𝑐22 𝑐23
𝑐31 𝑐32 𝑐33
𝑟 Ө1
Ө2 =
𝐴𝐵𝐶
Notand matricea de coeficienti cu 𝑀 si inmultind la stanga cu 𝑀−1, se obtine:
𝑟 Ө1
Ө2 = 𝑀−1
𝐴𝐵𝐶
Starea sistemului este definita de multimea (𝑟, 𝑟 ,Ө1, Ө1 ,Ө2, Ө2
) – in cazul pendului
simplu este folosit un singur Ө – si se poate defini functia incrementala de schimbare a starii
sistemului astfel:
𝑟′ = 𝑟 𝑟′ = 𝑟 Ө1
′ = Ө1
Ө1′ = Ө1
Ө2′ = Ө2
Ө2′ = Ө2
Folosind acest sistem si metoda Dormand-Prince se va putea obtine starea urmatoare a
sistemului.
In ultimul pas dintr-un frame, starea sistemului este transmisa clase de desenare pentru a
putea observa schimbarile si in interfata aplicatiei.
4.3. Metoda Dormand-Prince
Numita si metoda DOPRI, metoda Domand-Prince este folosita in rezolvarea ecuatiilor
diferentiale ordinare. Metoda este membru al familiei de solutii Runge-Kutta, si foloseste sase
evaluari de functii pentru a calcula solutii de precizie de ordin 4 si 5. Diferentele intre aceste
solutii este apoi considerata ca fiind eroare solutiei (de ordin 4). Estimarea acestei erori
36
esteconvenabila pentru algoritmii de integrare adaptiva prin pasi. Cele 6 evaluari de functii sunt
executate folosind coeficientii din tabelul urmator:
Tabelul Butcher
0 1/5 1/5
3/10 3/40 9/40 4/5 44/45 -56/ 15 32/9
8/9 19372/6561 -25360/
2187 64448/6561 -212/729
1 9017/3168 -355/33 46732/5247 49/176 -5103/18656 1 35/384 0 500/113 125/192 -2187/6784 11/84
35/384 0 500/113 125/192 -2187/6784 11/84 5179/57600 0 7571/16695 393/640 -92097/ 339200 187/2100 1/40
Iar functia de evolutie va arata astfel:
K1 = f(stare initiala, F)
K2 = f(stare initiala + DormandPrince1(k1) * delta, F);
K3 = f(stare initiala + DormandPrince2(k1, k2) * delta, F);
K4 = f(stare initiala + DormandPrince3(k1, k2, k3) * delta, F);
K5 = f(stare initiala + DormandPrince4(k1, k2, k3, k4) * delta, F);
K6 = f(stare initiala + DormandPrince5(k1, k2, k3, k4, k5) * delta, F);
K7 = f(stare initiala + DormandPrince6(k1, k2, k3, k4, k5, k6) * delta, F);
Stare finala = stare initiala + DormandPrince7(k1, k2, k3, k4, k5, k6, k7) * delta;
Unde Ki sunt stari intermediare, f functie incrementara folosita de algoritmul de evolutie, delta
timpul trecut de la pasul anterior si F forta aplicata de controlerul fuzzy.
4.4. Interfata
In interfata aplicatiei se pot observa schimbarile din sistemul pendulului invers. Utilizatorului i se
da posiblitatea de a interactiona cu procesul in timp real, modificand parametrii in care functioneaza
sistemul. Parametrii configurabili sunt: masa si coeficientii de frecare ai caruciorului, masele si
coeficientii de frecare ale pendulelor, starea initiala a sistemului, precum si perturbari in sistem
actionand cu un anumit impuls asupra pendulelor. De asemenea exista posibilitatea de a schimba din
37
sistem dublu in sistem simplu si invers, sau de a reporni sistemul din starea initiala si utilizatorului poate
observa evolutia sistemului fara reglare sau cu reglare.
38
Capitolul 5: Concluzii
Crearea unui mediu digital pentru studiul aplicarii unuei logici de reglare de tip fuzzy
unui sistem de pendul(e) invers(e) prezinta diverse probleme si trebuie tratat systematic pentru a
le rezolva pe fiecare in parte. Una dintre probleme este implementarea unui set de ecuatii
dinamice generalizat cu care sa se poata intocmi modelul matematic pentru sistemul nostru de
pendul invers cu carucior. Pentru a face asta se va folosi metoda lui Lagrange (Greenwood 1988).
Trebuie de asemenea sa luam in considerare diversele tipuri de frecare ce vor aparea intr-un
sistem real si sa le implementam ca atare, iar aceasta poate prezenta propriile ei dificultati. Desi
frecarea este un tip de forta care disipa energie intr-un sistem si ar parea sa fie o forta
stabilizatoare, subestimarea marimii coeficientului de frecare poate cateodata sa duca la
instabilitate intr-un sistem de control cu feedback.
Referitor la design-ul controlerului, acesta este un factor cheie al sistemului de pendul
invers si prezinta propriile lui probleme la implementare. Pentru a integra un tip de control fuzzy
in aplicatia noastra vor trebui izolati factorii de interes care ne vor permite sa manipulam sistemul
creat. Pentru aceasta observam ca vor fi necesare patru intrari si anume unghiul pendulului cu
referinta la verticala, viteza unghiulara a pendulului, distanta dintre referinta carutului si pozitia
curenta a acestuia (pe sina de dimensiune finita) si viteza carutului. Pentru fiecare dintre acesti
factori va trebui definit cate un univers de tratare. Actiunea propriu zisa asupra sistemului se va
face cu ajutorul unei forte aplicata asupra carutului, care este calculata cu ajutorul celor patru
factori mentionati mai devreme.
Aplicatia, desi nu prezinta gradul de flexibilitate al mediilor de reglare oferite de
programe profesionale, este de sjuns pentru a studia si a testa reglarea fuzzy (pentru un sistem cu
pendul invers) si permite o buna intelegere a felului in care diferite forte (frecari, greutate, forta
care actioneaza asupra carutului etc.) actioneaza asupra sistemului.
39
Anexa A: Codul aplicatiei
A.1. Controler Fuzzy
publicclassFuzzyController { constbool DEBUG_FUZZY_CONTROLLER = false; constuint DEFAULT_THETA_FUZZY_STATE_GRADE = 3; constuint DEFAULT_D_THETA_FUZZY_STATE_GRADE = 2; constuint DEFAULT_X_FUZZY_STATE_GRADE = 2; constuint DEFAULT_D_X_FUZZY_STATE_GRADE = 3; constuint DEFAULT_FORCE_PENDULUM_FUZZY_STATE_GRADE = 4; constuint DEFAULT_FORCE_CART_FUZZY_STATE_GRADE = 4; constdouble DEFAULT_THETA_MAX_RANGE = 0.02; constdouble DEFAULT_D_THETA_MAX_RANGE = 0.4; constdouble DEFAULT_X_MAX_RANGE = 2.0; constdouble DEFAULT_D_X_MAX_RANGE = 0.03; constdouble DEFAULT_FORCE_PENDULUM_MAX_RANGE = 150.0; constdouble DEFAULT_FORCE_CART_MAX_RANGE = 80.0; staticuint theta_fuzzy_state_grade; staticuint d_theta_fuzzy_state_grade; staticuint x_fuzzy_state_grade; staticuint d_x_fuzzy_state_grade; staticuint force_pendulum_fuzzy_state_grade; staticuint force_cart_fuzzy_state_grade; staticdouble theta_max_range; staticdouble d_theta_max_range; staticdouble x_max_range; staticdouble d_x_max_range; staticdouble force_pendulum_max_range; staticdouble force_cart_max_range; staticFuzzyController instance = null; staticint [] debug_fuzzy_states = newint [6]; staticint [] saved_debug_fuzzy_states = newint [6]; staticint debug_same_result_count; staticdouble [] debug_input_values = newdouble [4]; public FuzzyController() { theta_fuzzy_state_grade = DEFAULT_THETA_FUZZY_STATE_GRADE; d_theta_fuzzy_state_grade = DEFAULT_D_THETA_FUZZY_STATE_GRADE; x_fuzzy_state_grade = DEFAULT_X_FUZZY_STATE_GRADE; d_x_fuzzy_state_grade = DEFAULT_D_X_FUZZY_STATE_GRADE; force_pendulum_fuzzy_state_grade = DEFAULT_FORCE_PENDULUM_FUZZY_STATE_GRADE; force_cart_fuzzy_state_grade =
40
DEFAULT_FORCE_CART_FUZZY_STATE_GRADE; theta_max_range = DEFAULT_THETA_MAX_RANGE; d_theta_max_range = DEFAULT_D_THETA_MAX_RANGE; x_max_range = DEFAULT_X_MAX_RANGE; d_x_max_range = DEFAULT_D_X_MAX_RANGE; force_pendulum_max_range = DEFAULT_FORCE_PENDULUM_MAX_RANGE; force_cart_max_range = DEFAULT_FORCE_CART_MAX_RANGE; for (int i = 0; i < 6; i++) { saved_debug_fuzzy_states[i] = 0; } debug_same_result_count = 0; } privatestaticint GetFuzzyState(double value, uint grade, double max_range) { System.Diagnostics.Debug.Assert(max_range > 0.0 && grade > 0); double fuzzy_state = value * (double)grade / max_range; int result; if (fuzzy_state > 0) { if (fuzzy_state > (double)grade - 0.5) { return (int)grade; } result = 0; while (fuzzy_state > 0.5) { result++; fuzzy_state -= 1.0; } return result; } else { if (fuzzy_state < -(double)grade + 0.5) { return -(int)grade; } result = 0; while (fuzzy_state < -0.5) { result--; fuzzy_state += 1.0; } return result; } } privatestaticint GetThetaFuzzyState(double theta) { return GetFuzzyState(theta, theta_fuzzy_state_grade, theta_max_range);
41
} privatestaticint GetDThetaFuzzyState(double d_theta) { return GetFuzzyState(d_theta, d_theta_fuzzy_state_grade, d_theta_max_range); } privatestaticint GetXFuzzyState(double x) { return GetFuzzyState(x, x_fuzzy_state_grade, x_max_range); } privatestaticint GetDXFuzzyState(double d_x) { return GetFuzzyState(d_x, d_x_fuzzy_state_grade, d_x_max_range); } privatestaticdouble GetForcePendulum(double theta, double d_theta) { System.Diagnostics.Debug.Assert(force_pendulum_fuzzy_state_grade >= Math.Max(theta_fuzzy_state_grade, d_theta_fuzzy_state_grade)); int theta_fuzzy_state = GetThetaFuzzyState(theta); int d_theta_fuzzy_state = GetDThetaFuzzyState(d_theta); int sum = theta_fuzzy_state + d_theta_fuzzy_state; int force_pendulum_fuzzy_state = (sum> 0) ? (sum> (int)force_pendulum_fuzzy_state_grade ? (int)force_pendulum_fuzzy_state_grade : sum) : (sum< -(int)force_pendulum_fuzzy_state_grade ? -(int)force_pendulum_fuzzy_state_grade : sum); if (DEBUG_FUZZY_CONTROLLER) { debug_fuzzy_states[0] = theta_fuzzy_state; debug_fuzzy_states[1] = d_theta_fuzzy_state; debug_fuzzy_states[4] = force_pendulum_fuzzy_state; } return force_pendulum_max_range * (double)force_pendulum_fuzzy_state / (double)force_pendulum_fuzzy_state_grade; } privatestaticdouble GetForceCart(double x, double d_x) { System.Diagnostics.Debug.Assert(force_cart_fuzzy_state_grade >= Math.Max(x_fuzzy_state_grade, d_x_fuzzy_state_grade)); int x_fuzzy_state = GetXFuzzyState(x); int d_x_fuzzy_state = GetDXFuzzyState(d_x); int sum = x_fuzzy_state + d_x_fuzzy_state; int force_cart_fuzzy_state = (sum> 0) ? (sum> (int)force_cart_fuzzy_state_grade ?
42
(int)force_cart_fuzzy_state_grade : sum) : (sum< -(int)force_cart_fuzzy_state_grade ? -(int)force_cart_fuzzy_state_grade : sum); if (DEBUG_FUZZY_CONTROLLER) { debug_fuzzy_states[2] = x_fuzzy_state; debug_fuzzy_states[3] = d_x_fuzzy_state; debug_fuzzy_states[5] = force_cart_fuzzy_state; } return force_cart_max_range * (double)force_cart_fuzzy_state / (double)force_cart_fuzzy_state_grade; } publicstaticdouble GetForce(SystemStatus s, double dt) { /* Make sure FuzzyController is initialized */ if (instance == null) { instance = newFuzzyController(); } if (DEBUG_FUZZY_CONTROLLER) { debug_input_values[0] = s.theta; debug_input_values[1] = s.d_theta; debug_input_values[2] = s.x; debug_input_values[3] = s.d_x; } double force_pendulum = GetForcePendulum(s.theta, s.d_theta); double force_cart = GetForceCart(s.x, s.d_x); if (DEBUG_FUZZY_CONTROLLER) { bool same = true; for (int i = 0; i < 6; i++) { if (saved_debug_fuzzy_states[i] != debug_fuzzy_states[i]) { same = false; break; } } if (same) { debug_same_result_count++; Console.Out.Write("."); Console.Out.Write("Input: Theta = "); Console.Out.Write(debug_input_values[0]); Console.Out.Write(", DTheta = "); Console.Out.Write(debug_input_values[1]); Console.Out.Write(", X = "); Console.Out.Write(debug_input_values[2]); Console.Out.Write(", DX = "); Console.Out.Write(debug_input_values[3]); Console.Out.Write(", NEXT_DT = "); Console.Out.Write(dt);
43
Console.Out.WriteLine(); } else { Console.Out.Write(debug_same_result_count); Console.Out.WriteLine(); Console.Out.WriteLine(); Console.Out.Write("Input: Theta = "); Console.Out.Write(debug_input_values[0]); Console.Out.Write(", DTheta = "); Console.Out.Write(debug_input_values[1]); Console.Out.Write(", X = "); Console.Out.Write(debug_input_values[2]); Console.Out.Write(", DX = "); Console.Out.Write(debug_input_values[3]); Console.Out.Write(", NEXT_DT = "); Console.Out.Write(dt); Console.Out.WriteLine(); Console.Out.Write("Fuzzy States: Theta = "); Console.Out.Write(debug_fuzzy_states[0]); Console.Out.Write(", DTheta = "); Console.Out.Write(debug_fuzzy_states[1]); Console.Out.Write(", X = "); Console.Out.Write(debug_fuzzy_states[2]); Console.Out.Write(", DX = "); Console.Out.Write(debug_fuzzy_states[3]); Console.Out.Write(", FP = "); Console.Out.Write(debug_fuzzy_states[4]); Console.Out.Write(", FC = "); Console.Out.Write(debug_fuzzy_states[5]); Console.Out.WriteLine(); Console.Out.Write("Force = "); Console.Out.Write(force_pendulum - force_cart); Console.Out.WriteLine(); for (int i = 0; i < 6; i++) { saved_debug_fuzzy_states[i] = debug_fuzzy_states[i]; } } } return force_pendulum - force_cart; } }
A.2. Pendulul invers
classInvertedPendulum { constdouble DEFAULT_CART_MASS = 2.0; constdouble DEFAULT_CART_VISCOUS_FRICTION = 0.0; constdouble DEFAULT_CART_COULOMB_FRICTION = 0.0;
44
constdouble DEFAULT_PENDULUM_MASS = 0.1; constdouble DEFAULT_PENDULUM_LENGTH = 2.0; constdouble DEFAULT_PENDULUM_DISTANCE_TO_CENTER = 0.5; constdouble DEFAULT_PENDULUM_INERTIA_MOMENTUM = DEFAULT_PENDULUM_MASS * DEFAULT_PENDULUM_LENGTH * DEFAULT_PENDULUM_LENGTH / 3.0; constdouble DEFAULT_PENDULUM_VISCOUS_FRICTION = 0.0; constdouble G = 9.8; // Let's note: // Constants: // M = cart mass // m = pendulum mass // l = distance from pendulum base to center of gravity // I = pendulum moment of inertia // cc = cart viscous friction // cp = pendulum viscous friction // u = cart Coulomb friction // G = gravity // // Variables: // pA = pendulum angular position // pDA = pendulum angular velocity (derived position) // pDDA = pendulum angular acceleration (derived velocity) // cX = cart position // cDX = cart velocity (derived position) // cDDX = cart acceleration (derived velocity) // cos = cos(pA) // sin = sin(pA) // // The next differential equations must be solved: // (M+m) * cDDX + (m * l * cos) * pDDA = // -cc * cDX + (m * l * sin) * pDA * pDA - (sgn(cDX) * u * (M + m) * G)) // + F; // (m * l * cos) * cDDX + (I + m * l * l) * pDDA = // -cp * pDA + G * m * l * sin; // // By noting: // A = M+m // B = (m * l * cos) // C = -cc * cDX + (m * l * sin) * pDA * pDA - (sgn(cDX) * u * (M + m) * G)) // D = (m * l * cos) // E = I + m * l * l // H = -cp * pDA + G * m * l * sin // The next system is obtained: // A * cDDX + B * pDDA = C + F // D * cDDX + E * pDDA = H // So cDDX and pDDA can be computed as: // cDDX = ((C + F) * E - H * B) / (A * E - D * B) // pDDA = ((C + F) * D - H * A) / (B * D - E * A) // These results are used when computing system evolution staticdouble cart_mass; staticdouble pendulum_mass; //static double length; // unused for single inverted pendulum staticdouble l; staticdouble inertia; staticdouble cc;
45
staticdouble uc; staticdouble cp; staticdouble total_mass; staticdouble m_l; staticdouble i_and_m_l_l; staticdouble u_total_mass_G; staticdouble m_l_G; staticInvertedPendulum instance = null; private InvertedPendulum() { cart_mass = DEFAULT_CART_MASS; pendulum_mass = DEFAULT_PENDULUM_MASS; l = DEFAULT_PENDULUM_DISTANCE_TO_CENTER; inertia = DEFAULT_PENDULUM_INERTIA_MOMENTUM; cc = DEFAULT_CART_VISCOUS_FRICTION; uc = DEFAULT_CART_COULOMB_FRICTION; cp = DEFAULT_PENDULUM_VISCOUS_FRICTION; ComputeConstants(); } privatestaticvoid ComputeConstants() { total_mass = cart_mass + pendulum_mass; m_l = pendulum_mass * l; i_and_m_l_l = inertia + m_l * l; u_total_mass_G = uc * total_mass * G; m_l_G = m_l * G; } privatestaticvoid check() { if (instance == null) { instance = newInvertedPendulum(); } } privatestaticSystemStatus EvolutionHelper(SystemStatus s, double f) { SystemStatus result = newSystemStatus(); double sin = System.Math.Sin(s.theta); double cos = System.Math.Cos(s.theta); double sgn = (s.d_x == 0.0) ? 0 : ((s.d_x > 0) ? 1.0 : -1.0); // A = M+m // B = (m * l * cos) // C = -cc * cDX + (m * l * sin) * pDA * pDA - (sgn(cDX) * u * (M + m) * G)) // D = (m * l * cos) // E = I + m * l * l // H = -cp * pDA + G * m * l * sin double a = total_mass; double b = m_l * cos; double c =
46
-cc * s.d_x + m_l * sin * s.d_theta * s.d_theta - sgn * u_total_mass_G; double d = b; double e = i_and_m_l_l; double h = -cp * s.d_theta + m_l_G * sin; // cDDX = ((C + F) * E - H * B) / (A * E - D * B) // pDDA = ((C + F) * D - H * A) / (B * D - E * A) double c_and_f = c + f; double ae_minus_bd = a * e - b * d; result.x = s.d_x; result.d_x = (c_and_f * e - h * b) / ae_minus_bd; result.theta = s.d_theta; result.d_theta = (h * a - c_and_f * d) / ae_minus_bd; return result; } publicstaticSystemStatus Evolution(SystemStatus s, double f, double dt) { check(); // Use Dormand–Prince method SystemStatus [] temp = newSystemStatus [7]; temp[0] = EvolutionHelper(s, f); temp[1] = EvolutionHelper(s + dt * DormandPrince.DP1(temp), f); temp[2] = EvolutionHelper(s + dt * DormandPrince.DP2(temp), f); temp[3] = EvolutionHelper(s + dt * DormandPrince.DP3(temp), f); temp[4] = EvolutionHelper(s + dt * DormandPrince.DP4(temp), f); temp[5] = EvolutionHelper(s + dt * DormandPrince.DP5(temp), f); temp[6] = EvolutionHelper(s + dt * DormandPrince.DP6(temp), f); return s + dt * DormandPrince.DP7(temp); } publicstaticdouble GetPendulumLength() { return DEFAULT_PENDULUM_LENGTH; } }
A.3. Pendulul invers dublu
classDoubleInvertedPendulum { constdouble DEFAULT_CART_MASS = 2.0; constdouble DEFAULT_CART_VISCOUS_FRICTION = 0.0; constdouble DEFAULT_CART_COULOMB_FRICTION = 0.0; constdouble DEFAULT_PENDULUM_MASS_1 = 0.1; constdouble DEFAULT_PENDULUM_LENGTH_1 = 2.0; constdouble DEFAULT_PENDULUM_DISTANCE_TO_CENTER_1 = 0.5; constdouble DEFAULT_PENDULUM_INERTIA_MOMENTUM_1 = DEFAULT_PENDULUM_MASS_1 * DEFAULT_PENDULUM_LENGTH_1 * DEFAULT_PENDULUM_LENGTH_1 / 3.0; constdouble DEFAULT_PENDULUM_VISCOUS_FRICTION_1 = 0.0;
47
constdouble DEFAULT_PENDULUM_MASS_2 = 0.1; constdouble DEFAULT_PENDULUM_LENGTH_2 = 2.0; constdouble DEFAULT_PENDULUM_DISTANCE_TO_CENTER_2 = 0.5; constdouble DEFAULT_PENDULUM_INERTIA_MOMENTUM_2 = DEFAULT_PENDULUM_MASS_2 * DEFAULT_PENDULUM_LENGTH_2 * DEFAULT_PENDULUM_LENGTH_2 / 3.0; constdouble DEFAULT_PENDULUM_VISCOUS_FRICTION_2 = 0.0; constdouble G = 9.8; staticdouble cart_mass; staticdouble cart_vf; staticdouble cart_cf; staticdouble m1; staticdouble L1; staticdouble l1; staticdouble I1; staticdouble vf1; staticdouble m2; staticdouble L2; staticdouble l2; staticdouble I2; staticdouble vf2; private DoubleInvertedPendulum() { cart_mass = DEFAULT_CART_MASS; cart_vf = DEFAULT_CART_VISCOUS_FRICTION; cart_cf = DEFAULT_CART_COULOMB_FRICTION; m1 = DEFAULT_PENDULUM_MASS_1; L1 = DEFAULT_PENDULUM_LENGTH_1; l1 = DEFAULT_PENDULUM_DISTANCE_TO_CENTER_1; I1 = DEFAULT_PENDULUM_INERTIA_MOMENTUM_1; vf1 = DEFAULT_PENDULUM_VISCOUS_FRICTION_1; m2 = DEFAULT_PENDULUM_MASS_2; L2 = DEFAULT_PENDULUM_LENGTH_2; l2 = DEFAULT_PENDULUM_DISTANCE_TO_CENTER_2; I2 = DEFAULT_PENDULUM_INERTIA_MOMENTUM_2; vf2 = DEFAULT_PENDULUM_VISCOUS_FRICTION_2; ComputeConstants(); } staticDoubleInvertedPendulum instance = null; privatestaticvoid check() { if (instance == null) { instance = newDoubleInvertedPendulum(); } } staticdouble Mt; staticdouble mt; staticdouble I1t;
48
staticdouble I2t; staticdouble m2l2; staticdouble ml2L1; privatestaticvoid ComputeConstants() { Mt = cart_mass + m1 + m2; mt = m1 * l1 + m2 * L1; I1t = I1 + m1 * l1 * l1 + m2 * L1 * L1; I2t = I2 + m2 * l2 * l2; m2l2 = m2 * l2; ml2L1 = m2 * l2 * L1; } privatestaticSystemStatus EvolutionHelper (SystemStatus s, double f) { SystemStatus result = newSystemStatus(); double sin = System.Math.Sin(s.theta); double cos = System.Math.Cos(s.theta); double sin2 = System.Math.Sin(s.theta2); double cos2 = System.Math.Cos(s.theta2); double sin_diff = System.Math.Sin(s.theta - s.theta2); double cos_diff = System.Math.Cos(s.theta - s.theta2); double sign = (s.x == 0.0) ?0 : (s.x > 0.0 ? 1.0 : -1.0); Matrix3x3 coefficients = newMatrix3x3(Mt, mt * cos, m2l2 * cos2, mt, I1t, ml2L1 * cos_diff, m2l2, ml2L1 * cos_diff, I2t); result.x = s.d_x; result.d_x = 0; result.theta = s.d_theta; result.d_theta = 0; result.theta2 = s.d_theta2; result.d_theta2 = 0; coefficients.Invert(); coefficients.RightMultiplyWithVector( -cart_vf * s.d_x + mt * sin * s.d_theta * s.d_theta + m2l2 * sin2 * s.d_theta2 * s.d_theta2 - sign * cart_cf * Mt * G, -(vf1 + vf2) * s.d_theta + vf2 * s.d_theta2 - ml2L1 * sin_diff * s.d_theta2 * s.d_theta2 + G * mt * sin, ml2L1 * sin_diff * s.d_theta * s.d_theta + vf2 * (s.d_theta - s.d_theta2) + G * m2l2 * sin2, ref result.d_x, ref result.d_theta, ref result.d_theta2); return result; } publicstaticSystemStatus Evolution(SystemStatus s, double f, double dt) { check(); // Use Dormand–Prince method SystemStatus[] temp = newSystemStatus[7]; temp[0] = EvolutionHelper(s, f); temp[1] = EvolutionHelper(s + dt * DormandPrince.DP1(temp), f); temp[2] = EvolutionHelper(s + dt * DormandPrince.DP2(temp), f);
49
temp[3] = EvolutionHelper(s + dt * DormandPrince.DP3(temp), f); temp[4] = EvolutionHelper(s + dt * DormandPrince.DP4(temp), f); temp[5] = EvolutionHelper(s + dt * DormandPrince.DP5(temp), f); temp[6] = EvolutionHelper(s + dt * DormandPrince.DP6(temp), f); return s + dt * DormandPrince.DP7(temp); } publicstaticdouble GetFirstPendulumLength() { return L1; } publicstaticdouble GetSecondPendulumLength() { return L2; } }
A.4. Starea sistemului
publicclassSystemStatus { publicdouble x; /* the position of the cart */ publicdouble d_x; /* velocity of the cart */ publicdouble theta; /* angular position of pendulum */ publicdouble d_theta; /* angular velocity of pendumul */ publicdouble theta2; publicdouble d_theta2; publicstaticSystemStatusoperator+(SystemStatus x, SystemStatus y) { SystemStatus result = newSystemStatus (); result.x = x.x + y.x; result.theta = x.theta + y.theta; result.theta2 = x.theta2 + y.theta2; result.d_x = x.d_x + y.d_x; result.d_theta = x.d_theta + y.d_theta; result.d_theta2 = x.d_theta2 + y.d_theta2; return result; } publicstaticSystemStatusoperator -(SystemStatus x, SystemStatus y) { SystemStatus result = newSystemStatus(); result.x = x.x - y.x; result.theta = x.theta - y.theta; result.theta2 = x.theta2 - y.theta2; result.d_x = x.d_x - y.d_x; result.d_theta = x.d_theta - y.d_theta; result.d_theta2 = x.d_theta2 - y.d_theta2; return result;
50
} publicstaticSystemStatusoperator *(SystemStatus x, double a) { SystemStatus result = newSystemStatus(); result.x = x.x * a; result.theta = x.theta * a; result.theta2 = x.theta2 * a; result.d_x = x.d_x * a; result.d_theta = x.d_theta * a; result.d_theta2 = x.d_theta2 * a; return result; } publicstaticSystemStatusoperator *(double a, SystemStatus x) { return x * a; } }
A.5. Metoda Dormand-Prince
classDormandPrince { staticdouble[] DP = { // DP1 (0): (double)1/5, // DP2 (1-2): (double)3/40, (double)9/40, // DP3 (3-5) (double)44/45, -(double)56/15, (double)32/9, // DP4 (6-9) (double)19372/6561, -(double)25360/2187, (double)64448/6561, -(double)212/729, // DP5 (10-14) (double)9017/3168, -(double)355/33, (double)46732/5247, (double)49/176,
-(double)5103/18656, // DP 6 (15-20) (double)35/384, (double)0, (double)500/1113, (double)125/192, -(double)2187/6784, (double)11/84, // DP 7 (21-27) (double)5179/57600, (double)0, (double)7571/16695, (double)393/640, -(double)92097/339200, (double)187/2100, (double)1/40 }; publicstaticSystemStatus DP1(SystemStatus[] k) { return DP[0] * k[0]; } publicstaticSystemStatus DP2(SystemStatus[] k) { return DP[1] * k[0] + DP[2] * k[1]; } publicstaticSystemStatus DP3(SystemStatus[] k)
51
{ return DP[3] * k[0] + DP[4] * k[1] + DP[5] * k[2]; } publicstaticSystemStatus DP4(SystemStatus[] k) { return DP[6] * k[0] + DP[7] * k[1] + DP[8] * k[2] + DP[9] * k[3]; } publicstaticSystemStatus DP5(SystemStatus[] k) { return DP[10] * k[0] + DP[11] * k[1] + DP[12] * k[2] + DP[13] * k[3] + DP[14] * k[4]; } publicstaticSystemStatus DP6(SystemStatus[] k) { return DP[15] * k[0] + DP[16] * k[1] + DP[17] * k[2] + DP[18] * k[3] + DP[19] * k[4] + DP[20] * k[5]; } publicstaticSystemStatus DP7(SystemStatus[] k) { return DP[21] * k[0] + DP[22] * k[1] + DP[23] * k[2] + DP[24] * k[3] + DP[25] * k[4] + DP[26] * k[5] + DP[27] * k[6]; } }
A.6. Engine-ul aplicatiei:
publicclassEngine { publicstaticSystemStatus systemStatus; privatestaticEngine instance = null; staticbool use_double; long lastFrameTime; constlong FRAME_RATE = 60; constlong FRAME_LENGTH = 1000 / FRAME_RATE; publicconstdouble WORLD_HEIGHT = 8.0; publicconstdouble WORLD_WIDTH = 32.0; public Engine() { if (instance != null) { return; } instance = this; use_double = true; systemStatus = newSystemStatus (); systemStatus.x = 0.0;
52
systemStatus.d_x = 0.0; systemStatus.theta = 0.4; systemStatus.d_theta = 0.0; systemStatus.theta2 = 0.0; systemStatus.d_theta2 = 0.0; // start thread Thread thread = newThread(newThreadStart(run)); thread.Start(); } publicvoid run() { // start a stopwatch to count time Stopwatch stopwatch = Stopwatch.StartNew(); stopwatch.Start(); // initialize last frame time lastFrameTime = stopwatch.ElapsedMilliseconds; while (true) { long frameTime; do { // wait for at least frameLength Thread.Sleep(0); frameTime = stopwatch.ElapsedMilliseconds; } while (frameTime - lastFrameTime < FRAME_LENGTH); // get elapsed time double elapsedTime = (double)(frameTime - lastFrameTime) / 1000; lastFrameTime = frameTime; /* just for debug */ //elapsedTime = 0.016; if (use_double) { systemStatus = DoubleInvertedPendulum.Evolution(systemStatus, FuzzyController.GetForce(systemStatus, elapsedTime), elapsedTime); } else { systemStatus = InvertedPendulum.Evolution(systemStatus, FuzzyController.GetForce(systemStatus, elapsedTime), elapsedTime); } Main.Draw(); } } publicstaticSystemStatus GetSystemStatus() { return systemStatus;
53
} publicstaticvoid GetLengths(refdouble length1, refdouble length2) { if (use_double) { length1 = DoubleInvertedPendulum.GetFirstPendulumLength(); length2 = DoubleInvertedPendulum.GetSecondPendulumLength(); } else { length1 = InvertedPendulum.GetPendulumLength(); length2 = 0.0; } } }
54
Anexa B: Interfata aplicatiei
B.1. Pendulul simplu
B.2. Pendulul dublu
55
Bibliografie
ANDERSON, M. J., and GRANTHAM, W. J., 1989, Lyapunov optimal feedback control
of a nonlinear inverted pendulum.Transactionsof the ASME, 111, 554± 558.
CHUNG, J. C. H., and ITT,M., 1986, Self-tuning control of an invertedpendulum. ISA,
517± 533.
ELTOHAMY, K. G., and KUO, C. Y., 1997, Real time stabilization of atriple link
inverted pendulum using single control input. IEEProceedings± Control Theory and
Applications, 144, 498± 504; 1998,Nonlinear optimal control of a triple link inverted pendulum
withsingle control input. International Journal of Control, 69, 239± 256.
FURUTA, K., OCHIAI, T., and ONO, N., 1984, Attitude control of atriple inverted
pendulum.International Journal of Control, 39,1351± 1356.
FURUTA, K., OKUTANI, T., and SONE, H., 1978, Computer control of adouble
inverted pendulum.Computer & Electrical Engineering, 5,67± 84.FURUTA, K., HIROYUKI, K.,
and KOSUGE, K., 1980, Digital control ofa double inverted pendulum on an inclined
rail.International Journalof Control, 32, 907± 924.
GREENWOOD, D. T., 1988, Principles of Dynamics (Prentice Hall).
HENDERS,M. G., and SOUDAK, A. C., 1992, In-the-large behaviour ofan inverted
pendulum with linear stabilization. International Journalof Non-linear Mechanics, 27, 129± 138.
LARCOMBE, P. J., and TORSNEY, B., 1992, On the control of a twodimensionalmulti-
link inverted pendulum: the enumeration andidentification of equilibrium states. International
Journal ofSystems Science, 23, 2291± 2308.
MALETINSKY, W., SENNING, M. F., and WIEDERKEHR, F., 1981,Observer based
control of a double pendulum. Proceedings of the8th IFAC Triennial World Congress, Kyoto, pp.
3383± 3387.
MEDRANO-CERDA, G. A., 1997, Robust stabilization of a tripleinverted pendulum-
cart.International Journal of Control, 68, 849±865.
K. Tanaka and M. Sugeno , “Stability analysis and design of fuzzy Control systems”,
Fuzzy sets and systems, Vol. 45. pp. 135-156, 1992.
56
C.W. Tao, et al., “Fuzzy hierarchical swing- Up and sliding position Controller for the
inverted pendulum–cart system”, Fuzzy Sets and Systems (2008),ScienceDirect
L. A. Zadeh, “Outline of a new approach of the analysis of complex system and decision
processes,” IEEE Trans. Syst., Man, Cybern.,vol. SMCJ, no. 1, pp. 28-44, 1963.
T. J. ROSS, Fuzzy Logic with Engineering Applications, McGraw-Hill, Inc., 1991.
K.G. Eltohamy, C.-Y. Kuo, Nonlinear generalized equations of motion for multi-link
inverted pendulum systems , International Journal of Systems Science , Vol. 30, Iss. 5, 1999