INFORMAȚIEI AUTOMATICĂ, ELECTRONICĂ ȘI MECATRONICĂ [627528]
UNIVERSITATEA DIN CRAIOVA
FACULTATEA DE AUTOMATICĂ, CALCULATOARE ȘI
ELECTRONICĂ
DEPARTAMENTUL DE [CALCULATOARE ȘI TEHNOLOGIA
INFORMAȚIEI / AUTOMATICĂ, ELECTRONICĂ ȘI MECATRONICĂ ]
PROIECT DE DIPLOMĂ
Mihail -Drago ș Spirea
COORDONATOR ȘTIINȚIFIC
Dr.Ing.Diaconu Ilie
Iulie 2018
CRAIOVA
ii
UNIVERSITATEA DIN CRAIOVA
FACULTATEA DE AUTOMATICĂ, CALCULATOARE ȘI
ELECTRONICĂ
DEPARTAMENTUL DE [CALCULATOARE ȘI TEHNOLOGIA
INFORMAȚIEI / AUTOMATICĂ, ELECTRONICĂ ȘI
MECATRONICĂ]
Simulator 3D pentru avion cu controller homemade
Mihail -Drago ș Spirea
COORDONATOR ȘTIINȚIFIC
Dr.Ing. Diaconu Ilie
Iulie 2018
CRAIOVA
iii
„Cunoașterea îți dă aripi, iar imaginția te-nalță”
Henri Coandă
iv
DECLARAȚIE DE ORIGINALITATE
Subsemnatul Spirea Mihail -Drago ș student: [anonimizat], Calculatoare și Electronică a Universității din Craiova, certific prin prezenta că am l uat la
cunoștință de cele prezentate mai jos și că îmi asum, în acest context, originalitatea proiectului meu de
licență:
cu titlul “Simulator 3d pentru avion cu controller homemade”
coordonată de Prof.Univ.Dr.Ing Diaconu Ilie
prezentată în sesiunea Iulie 2018
La elaborarea proiectului de licență, se consideră plagiat una dintre următoarele acțiuni:
reproducerea exactă a cuvintelor unui alt autor, dintr -o altă lucrare, în limba română sau prin
traducere dintr -o altă limbă, dacă se omit ghilimele și r eferința precisă,
redarea cu alte cuvinte, reformularea prin cuvinte proprii sau rezumarea ideilor din alte
lucrări, dacă nu se indică sursa bibliografică,
prezentarea unor date experimentale obținute sau a unor aplicații realizate de alți autori fără
menționarea corectă a acestor surse,
însușirea totală sau parțială a unei lucrări în care regulile de mai sus sunt respectate, dar care
are alt autor.
Pentru evitarea acestor situații neplăcute se recomandă:
plasarea între ghilimele a citatelor directe și indicarea referinței într -o listă corespunzătoare la
sfărșitul lucrării,
indicarea în text a reformulării unei idei, opinii sau teorii și corespunzător în lista de referințe
a sursei originale de la care s -a făcut preluarea,
precizarea sursei de la care s -au preluat date experimentale, descrieri tehnice, figuri, imagini,
statistici, tabele et caetera,
precizarea referințelor poate fi omisă dacă se folosesc informații sau teorii arhicunoscute, a
căror patern itate este unanim cunoscută și acceptată.
Data, Semnătura candidat: [anonimizat],
v
UNIVERSITATEA DIN CRAIOVA
Facultatea de Automatică, Calculatoare și Electronică
Departamentul de [Calculatoare și Tehnologia Informației /
Automatică, Electronică și Mecatronică]
Aprobat la data de
…………………
Șef de departament,
Prof. dr. ing.
Marius BREZOVAN /
Emil PETRE
PROIECTUL DE DIPLOMĂ
Numele și prenumele student: [anonimizat]:
Mihail -Dragoș Spirea
Enunțul temei:
„Simulator 3d pentru avion cu controller homemade” -este o
aplicație interactivă, care permite interfațarea unui sistem
electromecanic față de un spațiu virtual tridimensional.
Datele de pornire:
Prezentare metode numerice pentru ecuații diferențiale.
Conținutul proiectului :
Capitolul 1.Introducere -aspecte privind simulatoarele.
Capitolul 2. Fizica computațională avion – concepte teoretice,
prezentare metode numerice, diagrama de forțe.
Capitolul 3.Proiectare asistată pe calculator ,proiectarea
mecanică a pieselor.
Capitolul 4: Motorul grafic unity , programarea în C#
Capitolul 5: Chipkit uno32 , prezentare arhitecutră, program.
Material grafic obligatoriu:
Prezentare PowerPoint, Figuri, Cod sursă.
Consultații:
Periodice
Conducătorul științific
(titlul, nume și prenume, semnătura): Prof.Univ.Dr.Ing Diaconu Ilie
Data eliberării temei:
09.01.2018
Termenul estimat de predare a
proiectului :
24.07.2018
Data predării proiectului de către
student și semnătura acestuia:
vi
UNIVERSITATEA DIN CRAIOVA
Facultatea de Automatică, Calculatoare și Electronică
Departamentul de [Calculatoare și Tehnologia Informației /
Automatică, Electronică și Mecatronică]
REFERATUL CONDUCĂTORULUI ȘTIINȚIFIC
Numele și prenumele candidatului/ -ei: Spirea Mihail -Dragoș
Specializarea: Robotică
Titlul proiectului :
„Simulator 3D pentru avion cu controller homemade ”
Locația în care s -a realizat practica de
documentare (se bifează una sau mai
multe din opțiunile din dreapta): În facultate □
În producție □
În cercetare □
Altă locație: [se detaliază ]
În urma analizei lucrării candidatului au fost constatate următoarele:
Nivelul documentării Insuficient
□ Satisfăcător
□ Bine
□ Foarte bine
□
Tipul proiectului Cercetare
□ Proiectare
□ Realizare
practică □ Altul
[se detaliază ]
Aparatul matematic utilizat Simplu
□ Mediu
□ Complex
□ Absent
□
Utilitate Contract de
cercetare □ Cercetare
internă □ Utilare
□ Altul
[se detaliază ]
Redactarea lucrării Insuficient
□ Satisfăcător
□ Bine
□ Foarte bine
□
Partea grafică, desene Insuficientă
□ Satisfăcătoare
□ Bună
□ Foarte bună
□
Realizarea
practică Contribuția autorului Insuficientă
□ Satisfăcătoare
□ Mare
□ Foarte mare
□
Complexitatea
temei Simplă
□ Medie
□ Mare
□ Complexă
□
Analiza cerințelor Insuficient
□ Satisfăcător
□ Bine
□ Foarte bine
□
vii
Arhitectura Simplă
□ Medie
□ Mare
□ Complexă
□
Întocmirea
specificațiilor
funcționale Insuficientă
□ Satisfăcătoare
□ Bună
□ Foarte bună
□
Implementarea Insuficientă
□ Satisfăcătoare
□ Bună
□ Foarte bună
□
Testarea Insuficientă
□ Satisfăcătoare
□ Bună
□ Foarte bună
□
Funcționarea Da
□ Parțială
□ Nu
□
Rezultate experimentale Experiment propriu
□ Preluare din bibliografie
□
Bibliografie Cărți
Reviste
Articole
Referințe web
Comentarii
și
observații
În concluzie, se propune:
ADMITEREA PROIECTULUI
□ RESPINGEREA PROIECTULUI
□
Data, Semnătura conducătorului științific,
REZUMATUL PROIECTULUI
Această aplicație interactivă demonstr ează posibilitatea formării unui ansamblu alcătuit dintr –
un bloc electromecanic , care îi servește utilizatorului ca element de interacțiune sau de comandă cu
scena virtuală și un joc electronic , și anume, o interfața grafică care descrie scena virtuală, menită să
imite lumea reala , care de asemenea certifică comenzile primite, prin aplicarea unor modele fizice.
Aplicația este dezvoltată în motorul grafic Unity, scris în limbajele de nivel înalt, C++, C
sharp , permițând dezvoltatorului , programarea într -un limbaj orientat pe obiecte intuitiv (C
sharp). Acest motor grafic comunică prin intermediul interfeței seriale cu microcontroler -ul chipKIT
Uno32, care la rândul său primește comenzi prin intrările analogice de la blocul electromecanic
acționat de utilizator. Ansamblu care definește un simulator încadrat în domeniul de Realitate virtuală
(Virtual reality sau VR).
Acest simulator adoptă criterii de realitate virtuală enunțate de Michael R.Heim, și se
adresează tuturor persoanelor pentru folosirea în scop educativ sau recreațional.Utilizatorii acestui
simulator vor benificia de lămurirea unor păreri subiective pr ivind pilotarea unui avion real.
Simulatorul de zbor nu este desti nat pentru reformarea sau îmbună tățirea simulatoarelor de
zbor industriale.În schimb este axat pe piața utilizatorului de rând care promite un raport preț/calitate
bun.Pentru testarea modelel or fizico -matematice s -a folosit programul Matlab, destinate aproximării
fenomenelor reale prin metode numerice de rezolvare a ecuațilo r diferențiale, care nu garantează o
experiență reală.
Termenii cheie : Unity, C#, Matlab, chipKIT,VR
ii
CUPRINSUL
1 INTRODUCERE ………………………….. ………………………….. ………………………….. ………………………….. ……… 4
1.1 SCOPUL ………………………….. ………………………….. ………………………….. ………………………….. ……………….. 5
1.2 MOTIVAȚIA ………………………….. ………………………….. ………………………….. ………………………….. …………… 5
2 CAPITOLUL 2.FIZICA C OMPUTAȚIONALĂ AVION. ………………………….. ………………………….. ………………… 6
2.1 RUNGE -KUTTA ………………………….. ………………………….. ………………………….. ………………………….. ………. 6
2.2 DIAGRAMA D E FORȚE ………………………….. ………………………….. ………………………….. ………………………….. .. 7
2.3 MATLAB ………………………….. ………………………….. ………………………….. ………………………….. ………………. 8
2.3.1. Istorie Matlab ………………………….. ………………………….. ………………………….. ………………………….. ……. 9
2.4 PROGRAMAREA ÎN MATLAB . ………………………….. ………………………….. ………………………….. …………………… 9
3 CAPITOLUL 3 PROIECTA RE ASISTATĂ PE CALCU LATOR ………………………….. ………………………….. ……….. 14
3.1 ISTORIE SOLIDWORKS ………………………….. ………………………….. ………………………….. …………………………. 14
3.1.1 Descriere material folosit și mașină de comandă numerică folosită : ………………………….. ………… 15
3.2 PROIECTARE P IESĂ MANȘA AVION : ………………………….. ………………………….. ………………………….. ………….. 16
3.3 PROIECTAREA MECANISMU LUI CREMALIERĂ –PINION PENTRU ANGREN AREA AXULUI POTENTIO METRULUI ……………… 19
4 CAPITOLUL 4: MOTORUL GRAFIC UNITY ………………………….. ………………………….. ………………………….. 22
4.1 SCENA GRAFIC Ă ȘI COMPONENTE : ………………………….. ………………………….. ………………………….. ……………. 22
4.2 PROGRAMAREA AVIONULUI ÎN MOTORUL GRAFIC FO LOSIND SCRIPTURI SCR ISE IN C# ………………………….. ………….. 24
4.3 INTERFAȚAREA MOT ORULUI GRAFIC UNITY CU MICROCONTROL ER-UL CHIP KIT UNO32 UTILIZÂND .NET FRAMEWORK .. 32
4.4 DIAGNOZĂ COMUNICAȚIEI SERIALE FOLOSIND PUTTY. ………………………….. ………………………….. ………………… 39
5 CAPITOLUL 5: CHIPKIT UNO32 ………………………….. ………………………….. ………………………….. …………… 41
5.1 CHIPKIT UNO32 SPECIFICAȚII HARDWAR E ………………………….. ………………………….. ………………………….. …… 42
5.2 CHIPKIT UNO32 SCHEMA ELECTRONICĂ ………………………….. ………………………….. ………………………….. …….. 44
5.3 PROGRAMAREA ÎN MEDIUL MPIDE ………………………….. ………………………….. ………………………….. …………… 48
5.4 INTERFAȚARE CHIP KIT UNO32 – UNITY ………………………….. ………………………….. ………………………….. …….. 51
6 CONCLUZII ………………………….. ………………………….. ………………………….. ………………………….. …………. 55
7 BIBLIOGRAFIE ………………………….. ………………………….. ………………………….. ………………………….. …….. 56
8 REFERINȚE WEB ………………………….. ………………………….. ………………………….. ………………………….. ….. 57
CODUL SURSĂ ………………………….. ………………………….. ………………………….. ………………………….. ……………. 58
C. CD / DVD ………………………….. ………………………….. ………………………. ERROR! BOOKMARK NOT DEFINED.
iii
LISTA FIGURILOR
FIGURA 2.1 ………………………….. ………………………….. ………………………….. ………………………….. ………….. 7
FIGURA 2.2 ………………………….. ………………………….. ………………………….. ………………………….. ………… 13
FIGURA 2.3 ………………………….. ………………………….. ………………………….. ………………………….. ………… 13
FIGURA 3.1 ………………………….. ………………………….. ………………………….. ………………………….. ………… 15
FIGURA 3.2 ………………………….. ………………………….. ………………………….. ………………………….. ………… 18
FIGURA 3.3 ………………………….. ………………………….. ………………………….. ………………………….. ………… 19
FIGURA 3.4 ………………………….. ………………………….. ………………………….. ………………………….. ………… 20
FIGURA 3.5 ………………………….. ………………………….. ………………………….. ………………………….. ………… 20
FIGURA 3.6 ………………………….. ………………………….. ………………………….. ………………………….. ………… 21
FIGURA 4.1 ………………………….. ………………………….. ………………………….. ………………………….. ………… 23
FIGURA 4.2 ………………………….. ………………………….. ………………………….. ………………………….. ………… 23
FIGURA 4.3 ………………………….. ………………………….. ………………………….. ………………………….. ………… 24
FIGURA 4.4 ………………………….. ………………………….. ………………………….. ………………………….. ………… 25
FIGURA 4.5 ………………………….. ………………………….. ………………………….. ………………………….. ………… 25
FIGURA 4.6 ………………………….. ………………………….. ………………………….. ………………………….. ………… 27
FIGURA 4.7 ………………………….. ………………………….. ………………………….. ………………………….. ………… 31
FIGURA 4.8 ………………………….. ………………………….. ………………………….. ………………………….. ………… 34
FIGURA 4.9 ………………………….. ………………………….. ………………………….. ………………………….. ………… 35
FIGURA 4.10 ………………………….. ………………………….. ………………………….. ………………………….. ………. 39
FIGURA 4.11 ………………………….. ………………………….. ………………………….. ………………………….. ………. 40
FIGURA 4.12 ………………………….. ………………………….. ………………………….. ………………………….. ………. 40
FIGURA 5.1 ………………………….. ………………………….. ………………………….. ………………………….. ………… 41
FIGURA 5.2 ………………………….. ………………………….. ………………………….. ………………………….. ………… 42
FIGURA 5.3 ………………………….. ………………………….. ………………………….. ………………………….. ………… 44
FIGURA 5.4 ………………………….. ………………………….. ………………………….. ………………………….. ………… 45
FIGURA 5.5 ………………………….. ………………………….. ………………………….. ………………………….. ………… 46
FIGURA 5.6 ………………………….. ………………………….. ………………………….. ………………………….. ………… 47
FIGURA 5.7 ………………………….. ………………………….. ………………………….. ………………………….. ………… 47
FIGURA 5.8 ………………………….. ………………………….. ………………………….. ………………………….. ………… 48
FIGURA 5.9 ………………………….. ………………………….. ………………………….. ………………………….. ………… 48
FIGURA 5.10 ………………………….. ………………………….. ………………………….. ………………………….. ………. 49
1 INTRODUCERE
Mecatronica , fiind una din știintele exacte , care a luat naște re la î nceputul secolului 20, rămâne în
continuare o enigmă pentru omenire din cauza caracterului pluridisciplinar al științei . Mecatronica se
împarte în mai multe domenii:mecanică, electronică, informatică , matematică , fizică, chimie .
Evoluția acestor domenii ștințifice a permis dezvoltarea unor noi tehnologii : militare, civile ,
aerospațiale , medicină, robotice etc.
În acest conte xt, o parte din aceste tehnolog i pot fi integrate în diferite aplicații pentru dezvoltarea
morală a oamenilor de pretutindeni. Procesul mecatronic a facilitat această remarcă, reflectând asupr a
următoarelor aspecte :cost, fiabilitate, adaptabil, favorabil, simplu.
Domenile in care sunt folosite simulatorele se regăsesc în automobile, biomecanica, dezvoltare
urbană, economie, robot ică, militar și multe altele .Indiferent de scopul servit, acestea au avut mereu
ca front comun , simularea unei experiențe , pe cât de real ă posibil ă.
Dimensiunile tranzistoarelor au evoluat exponențial conform legii lui Moore, fapt ce a permis
realizarea u nor programe graf ice care sunt capabile să redea un nivel de fotorealism promițator ,
dinamică înaltă (HDR), randarea în timp real a unor obiecte tridimensionale care sunt formate din
milioane de poligoane , cu texturi de înaltă rezoluție, atingând nivelul d e fotorealism folosind doar
performanțele calculatoarelor personale , grafica stereo 3D care a introdus realitatea virtuală. De
asemenea, ș i procesoarele au evoluat din această privință, fapt ce a dispus : o inteligența artificială mai
complexă, algoritmi de aproximare mai buni pentru calcularea ecuațiilor diferențiale care pot genera
sau permite introdu cerea unor noi femomene fizice î n lumea virtuală, evitarea algoritmului de
aproximare folosit original în Quake2 Fast inverse square root pentru calcularea unghiului de reflexie.
În principiu un simulator dispune de urmatoarele componenete indispensabile:
Interfața Om -Mașină, uti lizatorul poate vizualiza informați referitoare la scena virtuală, starea
intrarilor/ieșirilor ale sistemului.
Scena de operare, utilizatorul are posibilitatea de a explora liber scena virtuală
Periferic de intrare , dispozitivul de intrare -ieșire, presupune modalitate de interacțiune a
utilizatorului cu dispozitivul de calcul, de regulă calculator personal (Tastat ura,Mose –
ul,Trackball,Creion optic, Tabletă grafică, Scanner, JoyStick, Microfon etc.)
Periferic de ieșire, permit extragerea informațiilor dintr -un system de calcul (Monitor, Plotter,
Difuzor, Scanner etc.)
5
Funcțiile componentei hardware, formată din echi pamentele fizice în care circuitele electronice
asigură prelucrarea automată a informației (Funcția de memorare, Funcția de prelucrare, Funcția
de comandă și de control)
1.1 Scopul
Majoritatea simulatoarelor sunt de tip joc video, care propun un cont roler standard (Mouse –
Tastastură ) sau manetă.Cele mai populare simulatoare sunt cele de avioane însă controler -ul ramâne
tot cel tradițional, omițând principul esențial al unei experiențe reale, controller -ul specific.Din acest
punct de ve dere, putem vorbi de o lipsă a utilizării tehnologiei la un potențial punct culminant.
Evoluția componentelor electronice fizice edifică senzația de spațiul real prin implementarea unor noi
modele de periferice standard : ochelari 3D, manuși VR , costum cu senzori de mișcare e tc. Aceste
periferice sunt folosite în jocurile video standard având posibilitatea (dacă oferă suport SDK) de a
comunica la rândul lor cu sistemul mecatronic.
1.2 Motivația
Am dobândit aceasta motivație din dorința , de a acepta o provocare interesantă, integrarea unor
tehnologi mecatronice (controller -ul) într -un mediu virtual (jocul video), iar misiunea a fost
construirea unui sistem ieftin și open -source. Dimensiunea, accesibilitate, prețul ieftin, produs open –
source‚ calitatea materialel or alese, sunt factori critici de succes pentru dezvoltarea une i comunitați
care pot contribui î n mod pozitiv la dezvoltarea produsului .Pe langă modificarile software, pot fi
aduse și modificări hardware în configurația simulatorului, interconectare comput er-controller este
realizată de microcontroler -ul chipKIT care este disponibil open -source , de asemnea , se află într -o
configurație minimalistă.Majoritatea intrarilor și a ieșirilor sunt nefolosite, și pot fi programate, după
o anumită configurație hardwar e (senzori, led -uri, amplificări semnale, condiționări semnale
analogice, motoare electrice, sursă referință etc) . Văzând majoritatea simulatoarelor industriale , care
sunt costisitoare și necesită un spațiu dedicat, iar modul de configurare al lor necesită personal cu
experiență in domeniu, din acest motiv am considerat realizarea unui astfel de proiect .
6
2 CAPITOLUL 2 .FIZICA COMPUTAȚIONALĂ A VION.
2.1 Runge -Kutta
Studiul comportamentului dinamic al sistemelor fizice , unde modelele matematematice sunt
sub forma ecuațiilor sau sistemelor de ecuații diferențiale ordinare,liniare sau neliniare se pot
aproxima folosind o metoda numerică.Câteva din metodele numerice de aproximare ar fi : Runge –
Kutta, Adams -Moulton, Metoda Euler, Gauss -Radau etc.
Metoda Runge -Kutta are avantajul unei aproximari bune ale unei ecuatii diferentiale
neliniare, prin incrementarea cu un pas de regulă mic (ex 0.01) , obținându -se integrarea ecuației
diferențiale o rdinare.Răspunsul (ieșirea) se îmbună tațește cu micșorarea pasului de
incrementare .Metoda este simplă de implementat și eficientă din punct de vedere al timpului necesar
de calcul.Rezolvarea necesită cunoașterea unor condiți inițiale la un anumit timp.
Rezolvarea ecuațiilor diferențiale aplicând această metodă (Runge -Kutta) se obține di ntr-un
set de ecua ții liniare, cinci ca numar, combinarea rezultatelor , determină răspunsul neliniar dorit.
Aceste ecuaț ii sunt :
∆𝑥1=𝑣(𝑥𝑛𝑡𝑛)∆𝑡 (2.00a)
∆𝑥2=𝑣(𝑥𝑛+1
2∆𝑥1,𝑡𝑛+1
2∆𝑡)∆𝑡 (2.00b)
∆𝑥3=𝑣(𝑥𝑛+1
2∆𝑥2,𝑡𝑛+1
2∆𝑡)∆𝑡 (2.00c)
∆𝑥4=𝑣(𝑥𝑛+∆𝑥3,𝑡𝑛+∆𝑡)∆𝑡 (2.00d)
𝑥𝑛+1=𝑥𝑛+ ∆𝑥1
6+∆𝑥2
3+∆𝑥3
3+∆𝑥4
6 (2.00e)
Ecuațiile 2.00(a,b,c,d) sunt o serie de estimări liniare și pornesc având condițile inițiale la un
moment de timp t.O primă estimare se obține pentru 𝑥𝑛+1 , din funcția v în punctele ( 𝑥𝑛 𝑡𝑛), aceasta
este metoda lui Euler (2.00a). În ecuația (2.00b) s e obține din rezult atul ecuației (2.00a) evaluând î n
punctele (𝑥𝑛+1
2∆𝑥1,𝑡𝑛+1
2∆𝑡) unde 𝑥𝑛 și 𝑡𝑛 sunt condițile inițiale cunoscute, ∆𝑥1 obținut din
prima ecuație, ∆𝑡 reprezin tă pasul care se adaugă continuu, acest pas trebuie sa fie mic pentru o
estimare mai bună.
7
În acest context, această metoda rezolvă ecuațiile diferențiale de ordin I. Rezolvarea ecuațiilor
de ordin superior se poate realiza printr -o serie de ecuații de ordin I. Pentru calcularea forțelor se va
folosi această metodă.
2.2 Diagrama de forțe
Întrucât este un simulator didactic , se va folosi diagrama simplificată de forțe și se vor omite
următoarele aspecte:
În simulator nu exista vânt , densitatea aerului are valoare constantă în timp.
Coeficientul de urcare Cl, coefient de rezistivitatea al aerului Cd este static, valoare care nu este
influențată de unghiul de planare
Nu există un control absolut asupra flapsuri lor, utilizatorul va controla in mod direct unghiul de
atac
Nu există forță de frecare între roți și suprafața de contact
Coeficientul de urcare , este preluat din da tele experimentale modelul NACA 0015
Randamentul elicei este fix
Figura 2.1
Principalele forțe urmarite sunt : Portanța (Lift), Tracțiunea(Thrust), Gr eutatea(Weight), Rezistența la
înaintare (Drag) .
Ecuația generală a tracțiunii ca o funcție față de motor ș i randamentul elicei:
𝐹𝑇= 𝑃𝑇
𝑣=𝑛𝑝∙𝑃𝑒
𝑣=𝑛𝑝∙𝑃𝑒
𝑛𝑑 (2.10)
8
𝐹𝑇 – tracțiunea (Thrust), 𝑃𝑡 – puterea totala , 𝐹𝐷- rezistența la înaintare (Drag)
v-viteza absolută, 𝑛𝑝 – randamentul elicei, n – numarul de rotații pe secundă, d – diametru elicei
Ecuația (2.10) poate fi exprim ată ca o funcție de timp, viteză , numarul de rotații pe secundă, puterea
motorului notată (2.11) :
𝐹𝑇=𝑃𝑒
𝑛𝑑∙𝑣
𝑛2𝑑22 (2.11)
Modelul matematic al rezistenței la înaintare este greu de computaționat, din cauza particularitaților
pe care le poate avea fluidul, se va recurge la o formă mai generală:
𝐹𝐷 = 𝐶𝐷 ∙𝜌∙𝑣2
2•𝑆 (2.12)
2.3 Matlab
MATLAB (de la Matrix Laborator y) este un mediu de dezvoltare pentru calcul numeric și
analiză statistică ce conține limbajul de programare cu același nume, creat de MathWorks . MATLAB
permite manipularea matricilor , vizualizarea funcțiilor, implementarea algoritmilor, crearea de
interfețe și poate interacționa cu alte aplicații. Chiar dacă e specializat în calcul numeric, există
pachete care îi permit să interacționeze cu motoarele de calcul simbolic gen Maple . Un pachet
adițional, Simulink , oferă posibilitatea de a realiza simulă ri ale sistemelor dinamice și îmbarcate
utilizând modele matematice. MATLAB e utilizat pe larg in industrie, în universitați și e
disponibil cross -platform , sub diverse sisteme de operare : Windows , GNU/Linux , UNIX și Mac OS .
9
2.3.1 . Istorie Matlab
Abrevierea MATLAB a fost creată la sfârșitul anilor ' 70 de către Cleve Moler , președintele
departamentului de informatică al Universității din New Mexico. Inițial creat pentru a permite accesul
studenților săi la librăriile LINPACK și EISPACK , fără necesi tatea de a studia limbajul FORTRAN ,
în curand s -a răspândit în alte universități, dobândind un public larg în domeniul matematicii aplicate.
Jack Little, de formație inginer, a intrat în contact cu MATLAB în 1983, în timpul unei vizite a lui
Moler la Unive rsitatea Stanford . Recunoscând imediat potențialul său comercial, a început o
colaborare cu Cleve Moler și Steve Bangert rescriindu -l în limbajul C . În anul 1984 au
fondat MathWorks , continuând dezvoltarea aplicației.
2.4 Programarea în Matlab.
În programul M atlab se va putea urmări graficul de evoluție al forței de tracțiune asupra timpului.
Ecuația diferențială de ordin I se va rezolva cu ajutorul metodei Runge -Kutta , un alt avantaj pe lângă
cele enumerate anterior, este flexibilitatea în programarea orienta tă pe obiecte.Metoda scrisă într -o
clasă poate fi preluată prin moștenire de alte clase, unde se vor deosebi modul de implementarea al
metodei și condițile inițiale .
Din principiul al II-lea al mecanicii :
𝐹⃗=𝑚𝑎⃗ (2.21)
𝑎⃗ – acelerația , în contextul de față este variabilă în timp, fapt pentru care ecuația (2.21) se va rescrie:
𝐹= 𝑑(𝑚𝑣⃗⃗)
𝑑𝑡 = m 𝑑𝑣
𝑑𝑡 (2.22)
Ecuația (2.21) sub formă liniar ă, a fost rescrisă ca ecuație diferențială ordinară (2.22) , urmând a fi
rezolvată aplicând metoda numerică de rezolvare Runge -Kutta.
Expresile (2.11) și (2.12) compun forța generală 𝐹⃗, întrucât spațiul de operare este tridimensional, 𝐹⃗
va fi împă rțită în componentele (𝐹𝑥, 𝐹𝑦, 𝐹𝑧) folosind matricile de rotație.Subiectul va fi dezvoltat in
capitolul Unity.
𝐹𝑇=𝑃𝑒
𝑛𝑑∙𝑣
𝑛2𝑑22 (2.11)
𝐹𝐷 = 𝐶𝐷 ∙𝜌∙𝑣2
2∙𝑆 (2.12)
𝐹⃗=𝑚𝑎⃗ = (Ft – Fd) = 𝑃𝑒
𝑛𝑑∙𝑣
𝑛2𝑑22 – 𝐶𝐷 ∙𝜌∙𝑣2
2∙𝑆 (2.23)
10
Folosind (2.22) se obține ecuația diferențială:
𝑑𝑣
𝑑𝑡 = 𝑃𝑒
𝑛𝑑∙𝑣
𝑛2𝑑22 − 𝐶𝐷 ∙𝜌∙𝑣2
2∙𝑆
𝑚 (2.24)
Acum putem aplica metoda numerică, folosind RHS (right -hand side), astfel (2.24) devine :
𝑑𝑣 =dt 𝑃𝑒
𝑛𝑑∙𝑣
𝑛2𝑑22 − 𝐶𝐷 ∙𝜌∙𝑣2
2∙𝑆
𝑚 (2.24’)
Specificații avion Cessna 172 Skyhawk :
𝑃𝑒 = 1140 [Cp]= 850097 [Wati]
n = 2400 [rpm] = 40 𝑟𝑒𝑣
𝑠
d = 75 [in] = 1.905 [m]
S = 37.2 [ 𝑚2] , S – suprafața aripii
m = 5000 [kg]
𝜑=1.225 [𝑘𝑔
𝑚3], 𝜑 – densitatea aerului
%Program rezolvare ODE
clc;
Specificații avion Cessna 172 Skyhawk , Cd – coeficientul de rezistenta a aerului, np randamentul
elicei, propDiameter – 1.905 [m] diametru elicei , thrust enunța (2.11), throttle este un factor
prezumtiv pe post de regulator variabil între (0.1 și 1.0) care nu influențează in mod direct programul
fiind doar o constantă, dar va fi implementat mai târziu în simulator.
enginePower = 850000;
np = 0.85;
throttle = 1.0;
engineRps = 40;
propDiameter = 1.905;
thrust = (throttle * enginePower * np)/(engineRps * propDiameter);
mass = 50000;
S = 30;
Cd = 0.045;
h – pasul de incrementare al timpului t, x – vector de tip double cu pasul h,
conține 3001 elemente -> 3001 increment ări în bucla for, y – inițializare vector de lungime x cu
valori 0
11
0.1; % pasul functiei
x = 0:h:300;
y = zeros(1,length(x));
y(1) = 0.0;
F_xy – constituie imple mentarea propriei metode de ecuație diferențiale (2.24 ’) și respectă ordinea
RHS
F_xy = @(t,v) t*(thrust -(Cd*(S*v*v/2)*1.225))/mass;
for i=1:(length(x) -1)
% rutina de calcul Runge -Kutta
k_1 = F_xy( x(i),y(i));
k_2 = F_xy(x(i)+0.5*h,y(i)+0.5*h*k_1);
k_3 = F_xy((x(i)+0.5*h),(y(i)+0.5*h*k_2));
k_4 = F_xy((x(i)+h),(y(i)+k_3*h));
y(i+1) = y(i) + (1/6)*(k_1+2*k_2+2*k_3+k_4)*h; % Integrarea
%si plasare valorii pe pozitia i +1
end
plot(x,y);
Următoarele observați , ca urmare a rulă rii programului de mai sus se pun în evidenția :
Viteza depinde explicit de variabila indepentă t (timpul) și se obține prin integrare acelerației la
terminarea unui ciclu for .
Programul a pornit execuția, cu două condiții inițiale pentru a respecta metoda Runge -Kutta :
viteza ini țială „y(1)=0.0” și timpul inițial, variabila de tip vector „x” care se inițializ ează
premeditar cu valoarea 0.
Timpul este incrementat sucind, viteza nu poate fi determinată ocazional.
12
Cele 2 marimi unidimensionale (x,y) vor fi plotate având graficul urmator:
(Figura 2.3)
În graficul de mai sus est e prezentat evoluția vitezei( axa ordonatei) asupra timpului (axa abscisei)
obținută în urma ecuației diferențiale. Graficul evolueza asupra timpului t pe o durată de 300 de
secunde cu pasul h = 0.1 și se observă la timpu aproximativ 50 de secunde se saturează, dovadă ca
ecuația diferenți ală și -a atins scopul.
Coeficientul de urcare poate fi aproximat folosind un polinom de grad 2.Se poate face o aproximație
mai bună folosind interpolarea polinomială, urmărind obținerea unui polinom de grad 4 insă această
metodă este costisitoare.
Programu rezolvare polinom de grad 2
sym Cl,x
x = 0:0.1:90
13
Cl= -0.0013571 .* x .* x + 0.122143 .* x + 0.1
plot (x,Cl)
Polinomul se obține după formula de interpolare Lagrange:
∏𝑥𝑖−𝑥𝑚
𝑥𝑗−𝑥𝑚
Profil aerodinamic NACA 0015
Figura 2.2
Figura 2.4
14
3 CAP ITOLUL 3 PROIECTARE ASISTATĂ PE
CALCULATOR
3.1 Istorie SolidWorks
Solidworks este un program CAD (Proiectarea asis tată de calculator) care rulează pe sistemul
de operare dezvoltat de Microsoft Windows. Solidworks este dezvoltat de Dassault Systémes care a
dezvoltat anterior și software -ul CATIA (1977) și este folosit de aproximativ de peste 2 milioane
ingineri și designeri la cele peste 165,000 companii de-a lungul lumii
În noiembrie 1995 apare SolidWorks95 primul produs dezvoltat de Jon Hirschtick care a
continu at să contribute la dezvoltarea software de -a lungul a 14 ani.Sub conducerea sa, SolidWorks a
crescut la o companie de venituri de 100 de milioane de dolari.
SolidWorks este folosit în Arhitectură, Construcții, Drumuri și poduri, Industria aeronaturica,
Industria de automobile,Electronică și electrotehnică, Design Industrial, Inginerie Mecanică.
SolidWorks ut ilizează metodă generării corpu rilor solide prin caracteristici, una dintre cele
mai utilizate tehnici de modelare a corpurilor 3D. Se pornește de la un contur desenat în 2D, din care
se generează blocul grafic de conctructie de bază.Un bloc grafic de construcție este de o formă de
bază căreia i se aplică caracteristicile constructiv -tehnologice.Blocurile sunt de două tipuri : cu
geometrie implicită (racordări, rotunjiri) și cu geometrie epxplicita (elementul de bază fiind forma
secțiunii).Blocurile grafice de contructie cu geometrie exp licită definesc forma de bază a piesei, care
se obține intodeauna prin adăugarea de material.Un astfel de bloc se creează prin extrudarea și
rotunjirea în jurul unei axe a unei secțiuni .După realizarea formei de bază a piesei urmează crearea
celorlalte bl ocuri grafice de contructie, care pot fi de tipul adăugare sau inalturare de material.Aceste
se leagă de formă de bază, după o structură arborescentă și apoi se adaugă celalalte elemente de
contructie necesare finalizării modelului.Operațiile principale pr in care se realizează elementul de
bază sunt extrudarea (pentru corpuri prismatice) și rotația unui contur în jurul unei axe (pentru corpuri
de revoluție).
15
Activitatea de proiectare începe cu generarea modelului geometric al produsului. Pe tot
parcursul ac estei activități trebuie avuta în vedere și posibilitatea fabricării produsului respectiv. Se
stabilește în ce măsură piesă respectivă este dependența sau nu de alte piese în cadrul ansamblului. Se
poate începe cu proiectare a ansamblului (proiectare de tip ul de "sus în jos") și apoi extragerea
reperelor sau se proiectează piesele (proiectare "de jos în sus") și apoi se asamblează. Înainte de a se
începe proiectarea unei piese trebuie luate în considerare următoarele .
Figura 3.1
3.1.1 Descriere material folosit și mașină de comandă numerică folosită :
Piesă țintă este o manșă de avion care nu impune anumite standarde ergonomice.Această va
fi desenată ca un sketch 2D folosid programul SolidWorks, unde va fi exporata ca și format univ ersal
de tip schița 2D în software -ul de design intern cu care vine respectivul cnc(TRUMPH TruLa ser 5030
Fiber).Odată importat această schița 2D, laserul folosit tăie numai piese 2D deci comandă de extrude
este exclusă.
16
Materialul folosit este alumiuniu e lectrotehnic de 4 mm (Mild Steel) că și proprietăți acest
aluminiu conține : carbon 0.16 – 0.18% , mangan 0.70 -0.90%, silicon 0.40%, sulf 0.04%, fosfor
0.04%.
Procesul de execuție (tăierea) s -a făcut sub mediu de azot, tehnologia de tăiere este de tip
laser, modelul TRUMPH TruLaser 5030 Fiber având o putere de 3kW pe dioda laser.Această
tehnologie p ermite tăierea materialului extrem de rapid, având o durată de aproximativ 4 minute.
3.2 Proiectare p iesă manșa avion :
Pentru prima dată când se lansează programul SolidWorks, apare un mesaj de dialog “Units
and Dimension Standard ” ca și unități, prestabilit SolidWorks lucraeza în inch, s -a modificat în
MMGS ( millimeter, gram , second) și Dimension standard (ISO), aceste setări se pot modifică în
orice moment din meniul ToolsOptionsDocument Properties
Mediul de lucru în solidworks trebuie să conțină un sketch, aceasta este scena de lucru grafică
prin care se va proiectă manșa de avion.Se v a acesa FileNewPart și confirmare.Apare o fereastră de
dialog “Select a plane on which to create a sketch file for the entity ”, aceast tip fereastă de dialog
impune utilizatorului să aleagă o opțiune specifică, în contextul de față are nevoie de selecția unui
plan de lucru pe 2 axe (Front Plane, Top Plane, Right Plane), se va lucra pe axa YX deci opțiunea va
fi Front Plane.
Com enzile în SolidWorks se bazează numai pe interfața vizuală spre diferență de AutoCAD
unde se utilizează funcții cu parametrii specifici pentru generarea primitivelor 2D.Aceste figuri
geometrice sunt acesibile în tab -ul Sketch, originiea axelor YX pornește din mijloc, unde sunt figurate
ca 2 săgeți de culoare roșie.
Ca și reper de orientare pentru manșa de avion s -a ales dimensiunile unei coli A4 (210X297)
mm.Din originea axei YX se desenează un cerc cu rază de 140 mm, folosind LINE se împarte în 4
cadrane, lungimea fiecărei LINE având deci dimensiunea razei cercului.Acest process va permite
demararea comenzii TRIM Entities apoi se va selecționa arcele de cerc din cadranul 1 și cadranul 4 ,
17
din ac est process obținem un semicerc.De asemenea important de menți onat este faptul că întrucât
manșa de avion este o structură simetrică se va lucra numai cu o anumită extremitate.
Urma asimilată este un semicerc și cele 4 LINE de delimitare a cadranelor, se dorește
conservarea celor 4 LINE -uri. LINE -ul situat între cad ranul 2 și 3 din midpoint se trage vertical 2
LINE -uri care să atingă arc -ul cadranului 2 și arcul cadranului 3.Se selectează Trim Entities și se
decupează partea dreaptă a LINE -ului arcele coli niare.Tot din acest punct pornește un cerc de rază 75,
din Lin e-ul situat între cadranul 1 și 2 se trage perpendiculara pe arcul cercului de rază 75 folosind
TRIM entities în continu u se decupează din arcul de cer obținând un unghi de arc de 30 grade. Aces t
arc de cerc este coliniar, cu respectivul cerc de rază 75. F olosind comandă trim se vor înlătura arcele
de cerc din cadranele 1 2 și 4 astfel încât vom avea 2 arce de cerc.
Pornind din mijlocul LINE -ului situat între cadranul 3 și 4 se folosește centerpoint arc cu
rază 37 și un unghi de 25, în coordonate cartezien e (-sin(25) * 37 , -cos (25) * 37) apoi se unește
folosind LINE cu arc -ul situat în cadranul 3.
Cele 4 arce situate pe scenă formează un cadru 2D care conturează manșa avionului.Există 2
soluții din punct de vedere a complexitătii, una dintre ele ar fi off set 20 mm spre origine iar a 2 a
opțiune ar fi repetarea procesului dar cu parametri diferiți.Pentru opțiunea cu offset trebuie selectate
toate en titătile (cele 4 arce) urmând apelarea comenzii Offset Entities de 20 mm, rezultatul obținut
este un cadru cop ie a cărei dimensiune are același raport dar cu 20mm mai mic.
Arcele din cadranul 2 se vor racorda folosind 3 Point Arc, extremitătile și se vor atribui că și
parametrii A=67 grade R = 18.Rezultatul exhaustiv completează cadrul propus, din acest punct se
poate la de Mirror Entities pentru recompune .
De-a lungul arcului de cerc aparținând celui de al 2 -lea cadru se va desenă folosind CIRCLE
cu o rază de 5 mm, se vor desena 4 cercuri pentru spatierea degetelor.Folosind TRIM se înlătură
diametru și respective arcul exterior astfel se obțin 4 decupaturi sub formă de semicerc. Semicercurile
toate 4 pot fi offsetate folosind comm anda OffsetEntitie s spre axă OX.Rezultatul obținut este un
contur ca re dă un scop esthetic manșei avionului, formează o coardă unde plecând de la extrimitati
folosind LINE și ARC se va completă profilul întrucât este un detaliu estetic nu se vor ține cont de
cote.
Pentru î mbunătățirea manșei avionului în mod plăcut, s -au desenat 3 cercuri cu diametru de
18 mm pe cadrul inferior al manșei avionului, laserul TRUMPH TruLaser 5030 Fiber lucrează pe 2
18
axe, așadar va recunoaște aceste cercuri ca pe niște deschizături.Același caz se aplică și profilului
realizat prin comandă Offs etEntities.
Pregătirea pentru mirror constrânge un punct de reper care trebuie să provină dintr -un
LINE.Partea inferioară a manșei de avion nu a fost racordată deoarece oricum urmă a fi unită prin
operația de mirror.Plecând din acest punct se trage un LINE temporal care unește cele 2 cadre.
Urmează folosind comandă Mirror Entities, apare în tab -ul numit “feature -tree” un dialog “Select
entities to mirror and a sketch line or linear model edge to mirror abou t” urmând 2 câmpuri de
selecție.Câmpul numit “Entities to mirror : ” se selectează câmpul în primul apoi cu click stânga
fiecare entitate în parte aflată pe scena cu excepția ultimului LINE creat, pentru fiecare entitate
selec tate că și confirmare avem pars at în câmp numele ei.Se selectează câmpul “Mirror about:” unde
se va selectă LINE -ul temporal apoi se confirmă “OK”.Cadrul manșei avion este complet, LINE -ul
temporal se șterge selectând și apoi DEL.
La bază manșei avionului în centru trebuie atașat ghidaj ul, întocmit dintr -o țeava de cupru
folosită la instalații sanitare a cărui diametru este de 10 mm, se va folosi CIRCLE cu rază de 6
mm.Pentru fixarea mai bună a ghidajului se va folosi un support în formă de cruce, din acest motiv
sunt trase 4 găuri de 3mm folosind CIRCLE pentru șuruburi cu cap Philips (M3) 3mm.
Desenul obținut este finalizat și gata de execuție.Chiar și în acest stadiu, desenul poate fi
modificat folosind opțiunea Smart Dimension, se execută această opțiune apoi selectând extremitățile
dorite se ivește fereastra de dialog “Modify” u nde se poate acorda o valoare dorită confirmarea “OK”
afișează pe scenă grafică valoarea cotei și mărginirea grafică.
Figura 3.2
Mode lul manșei de avion obținut va fi exportat sub formă unui desen tehnic, compatibil cu
toate sofwarele de proiectare asistată de calculator CAD, având formatul DXF dezvoltat de compania
Autodesk , a cărei extensie, a fost dezvoltată în Decembrie 1982. Filă D XF va fi imporatat în CAD 3
Punch 5 sofware CAD specific CNC TRUMPH TruLaser 5030 Fiber.
19
Figura 3.3
3.3 Proiectarea mecanismului cremalieră –pinion pentru angrenarea
axului potentiometrului
Date inițiale :
-cursa : aproximativ 190mm
-modulul angenajului 2 (s -a ales un mod ul mai mare deoarece este mai uș or de executat tehnologic.)
(Modulul e o marime convențională notată cu m și definită ca raportul între pasul roții desfăș urate și π
și standardizat într -o serie 1, 1.25, 1.5, 2, 2.5 …)
Dimensionarea cremalierei :
1. Pasul cremalierei va fi p=m ∙ π
2. Unghiul profilului cremalierei este 200 (unghiul standard pentru cremaliere)
3. Numarul de dinți Z= 190/(m*) =190/(2*3.14)=30.25 Se alege Z=30 dinti
Cursa reala o sa fi e doar de 75% din aceasta marime. (Poten țiometrul are un unghi de rotaț ie
de 270 grade)
20
Profilul dintelui de cremalieră este :
Desenul rezultat pentru cremaliera (tinând cont și de celelalte elemente ale ansamblului este:
Dimensionarea rotii dințate :
Deoarece raportul va fi 1:1 (roata efectuează o singură ro tație a axului pentru o deplasare liniară pe
întreaga cursă). De aici rezultă z=30 dinti
Diametrul de angrenare: D=m*z=30*2=60mm
Diametrul de cap : Dc=m*(z+2)=64mm
Diametrul de fund : Df=m*(z -2)=56mm
Figura 3.4
Figura 3.5
21
Diametrul axului de potențiome tru e de Φ=6mm -> se ale ge diametru Φ=5.9mm (presare 0.1mm
deoarece e material m oale (aluminiu ) iar axul poten țiometrului este crestat la mijloc si deci este
elastic)
Pentru o stabilitate buna pe axul potentiometrului s -a ales un material cu grosimea de 10mm
Pentru o greutate cât mai mi că s-au practicat orificii de ușurare . Astfel forma finală rezultată este :
Figura 3.6
22
4 CAPITOLUL 4: MOTORUL GRAFIC UNITY
4.1 Scena grafic ă și componente:
Un motor grafic este un sistem conceput pentru crearea și dezvoltarea de jocuri video . Există mai
multe motoare de joc, care sunt proiectate să funcționeze pe console de jocuri video și calculatoare
personale . Funcționalitatea de bază oferită de obicei de un motor grafic include un motor de randare
(engleză renderer ) pentru grafică 2D sau 3D, un motor de fizică sau de detectare a coliziunilor (și
răspunsul la coliziune), sunet, scripting, animație, inteligență artificială, în rețea, streaming, memorie
de management, suport de loca lizare, etc. Procesul de dezvoltare a jocului este de multe ori
economisit, în mare parte, prin reutilizarea / adaptarea unui motor asemănător pentru a crea jocuri
diferite.
Unity este un motor de jocuri pe platforme dezvoltat de Unity Technologies, folosit în primul rând
pentru a dezvolta atât jocuri video tridimensionale cât și bidimensionale și simulări pentru computere,
console și dispozitive mobile. Prima versiunea beta a fost anunțată doar pentru platforma OS X la
Conferința Mondială din 2005 a dezvoltatorilor Apple , de atunci motorul grafic a fost dezvoltat
oferind un suport cross platform pentru până la 27 de platforme . Au fost eliberate șase versiuni majore
ale unității
Obiectele folosite sunt urmă toarele :
-Teren 20 000×20 000 m ¼ poligoane pe metru.
-Avion 40652 poligoane (model high -poly,modelat special pentru performanțele calculatoarelor).
-Copaci aproximativ 5000 poligoane, folosind programul SpeedTree.
-Iluminarea global ă (Direcțional Light, Intensitate 1.23, SkyBox standard)
Pentru modelarea avionului am folosit programul Maya 3D dezvoltat de firma Autodesk, software
specializat pentru generare de obiecte în industria jocurilor .
Maya este o aplicație software, destinată modelării grafice tridimensionale și animaței. Produs de
firma Alias , dar aflat acum în posesia firmei Autodesk Media & Entertainment . Este utilizat pe scară
largă în producția efectelor speciale în cinematografie , în animație , cât și în producția jocurilor de
calculator. Firma Autodesk Media & Entertainment a achiziț ionat acest program în octombrie 2005,
după cumpărarea firmei Alias Systems Corporation .
23
Maya oferă un set de unelte pentru modelare, unelele principale folosite, Split selected edge ring
(separă folosind o linie modelul, oferind detalii geometrice noi pen tru a putea fi manipulate ), Bevel
(folosit pentru adaugarea unui contru geometric spațiat printr -o lungime), Extrude ( unealtă de
extrudare a modelului geometric) Merge verticies ( unește 2 puncte geometrice, vertexi)
Figura 4.1
Date tehnice model avion :
Figura 4.2
Motorul grafic Unity aceptă format -ul standard fbx, folosit în general de toate motoarele grafice cum
ar fi Unreal Engine, Crysis.Textu ra a fost rea lizată in GIMP, program asemnător cu Photoshop, dar
are licență gratis.Generarea Normal Map -ului este facută online ( cpetry.github ).Astfel sha der-ul final
va conține o textură normală și una difuză. Textura normal map conferă rugozitate, iar di fusal culorile
preluate din textură.
24
4.2 Programarea avionului în motorul grafic folosind scripturi scrise in
C#
Unity sup ortă nativ limbajul C# și dispune de un API care ajută utilizatorul să cre eze scripturi
puternice folosind metodele standard . Proiectul conține 5 clase, întrucât proiectul respectiv conține
aprox 400 lini de cod, se vor fi explicita doar aspectele importante.
Figura 4.3
Modelul de avion este declarat gameobject , dar nu are proprietatea de solid -rigid momentan . Folosind :
GameObject Create Empty . Inspector Se selectează obiectul dorit și se populează celula
gameobject creată in Unity folosind Drag&Drop
Aceste 2 proprietați permit utilizarea unor librari specializate, cel e mai importante referitoare la fizica
obiectului și execuția mișcărilor de rotație sau translație.
Folosind :” public GameObject avion; “ inițializăm o variabilă de tip gameobject prin care o putem
apela, folosind metodele Unity.Acest fapt permite apelarea oricarui obiect cu adresă dacă obiectul este
declart gameObject și are o variabilă asignată.
25
Comparație sisteme de refereința pentru diferite motoare grafice (Unreal, Unity, 3ds Max) :
Figura 4.4
Sistemul de coordonate respectă regula mâinii stângi.În primul capitol s -a discutat despre calcularea
forței de tracțiune și a rezistivitații aerului, de asemenea, s -a menționat cum forța generală rezultată 𝐹⃗
din 𝐹𝑇 , 𝐹𝐷, va fi împărțită în component ele ( 𝐹𝑥, 𝐹𝑦, 𝐹𝑧), cum este impărțită oricare tip de forță. Aceste
componente sunt obținute, făcâ operația de inmponente sunt obținute, făcând operația de înmulțire, cu
cele 3 matrici de rotație.
Sunt definite 3 unghiuri de rotație 𝜃 ax de rotație (p itch), ax de înclinare față -spate 𝜑(yaw), ax de
înclinare laterală 𝜔(roll)
Figura 4.5
Componentele ( 𝐹𝑥, 𝐹𝑦, 𝐹𝑧) reperezintă aceste unghiuri și se obțin din matrici de rotație standardizate .
26
Iar coordonatele noului punct se pot scrie : 𝑥′=𝑥cos𝜃 – y sin 𝜃 (4.10a)
𝑦′ = y sin 𝜃 + y cos 𝜃 (4.10b)
Figura (5.30) prezintă o matrice de rotație standard , (x’,y’,z’) descriu coordonatele ca rteziene ale
unui punct nou in spațiu, substituind cu componentele forțelor se vor obține urmatoarele relații s e pot
scrie componentele forțelor :
𝐹𝑥 = cos 𝜃 cos 𝜑(𝐹𝑡 -𝐹𝑑) + (sin 𝜃sin 𝜑 – cos 𝜃 sin 𝜔 cos 𝜑) (𝐹𝑡 -𝐹𝑑) (4.11a)
𝐹𝑦 = sin 𝜃cos 𝜑(𝐹𝑡 -𝐹𝑑) + (-cos𝜃 sin 𝜔 – sin 𝜃sin 𝜔 cos 𝜑)( 𝐹𝑡 -𝐹𝑑) (4.11b)
𝐹𝑧 = sin 𝜑 (𝐹𝑡 -𝐹𝑑) + cos 𝜔 cos 𝜑 (𝐹𝑡 -𝐹𝑑) (4.11c)
Unity3d dispune de o gamă largă de librarii pentru manipularea obiectelor î n spațiul tridimensional,
folosind variabila de tip GameObject se pot apela aceste tipuri de metode în limbajul C#.Metoda
Quaternion facilitează această implementare
Quaternion tractionAirplaneArduino( Quaternion q) {
Quaternion qx = Quaternion .AngleAxis(anglePot2 * Time .deltaTime , transform.forward.normalized)
;
q = qx * q;
qx = Quaternion .AngleAxis(anglePot1 * Time .deltaTime , transform.right.normalized);
q = qx * q;
return q;
}
27
Pentru implementarea de mai sus se pot remarca urmatoarele aspect e: tractionAirplane Arduino
(Quaternion q) este o funcție de tip quaternion, qx este o variabila locală de tip
Quaternion,Quaternion.AngleAxis este o metodă componenta a clasei Quaternion care primește 2
parametri : unghiul de rotație (anglePot2 respe ctiv anglePot1) și un Vector3 normalizat care are
magnitudinea 1 ( transform.forward.normalized respectiv transform.right.normalized),
transform.forward/right îngheată o axă specifică, permițând desfașurarea unei rotiri cu un anumit
unghi, același procedeu a fost aplicat și matricilor de rotație care aveau o axă înghețată sau mai formal
spus axei respective îi se atribuie valoarea 0, metoda Time.deltaTime execută rotație în funcție de
timp, în lipsa acestei metode obiectul s -ar roti în funcție de cadrele pe secundă care diferă în funcție
de performanțele de care dispune fiecare configurație în parte.
Acum obiectul dispune de proprietăți rotative, în momentul de față obiectul se rotește într -un punct fix
prin modificarea unghiului dorit din variabilele anglePot1, anglePot2 care sunt cuprinse ca și valori
între ( -30,30) grade.Variabilele de tip float anglePot1, anglePot2 sunt intrări furnizate de
microcontroler, intrări care sunt mapate din intrările analogice la care se află senzorii cu rezistența
variab ilă. Acest subiect va fi revizuit în secțiunea ChipKit.În momentul de față obiectul nu are
proprietatea de a fi acționat de vreo forța anume, și deci este considerat static.
GameObject -ul (avion) este declarat solid -rigid folosi
Add Component Physics RigidBody
Motorul grafic Unity oferă un simulator robust de fizică , un obiect declarat solid -rigid adoptă
proprietăți din mecanica clasică având acces la clasa RigidBody, această clasă tratează fenomenele
fizice, clasa RigidBody este complexă, oferă meto de de control pentru o mișcare ordonată.
Figura 4.6
Avionul are 6 grade de libertate, din acest motiv în submeniul „Constraints” , vor fi debifa te
constrângerile prezumtiv bifate.
28
Un program unity are urmatoarea structură obligatorie :
//Declarare variabile globale
void Start ()
{
//Linile de cod sunt executate o singură dată de la rularea programului după inițializarea obiectelor
}
void Update () {
//Bucla Update() execută frame to frame linile de cod-
}
Concomitent cu bucla Update(), se mai pot executa și bucle auxiliare cum ar fi FixedUpdate () care
execută un cod la cadre fixe (ex :30fps, 60fps etc), r ecomandată de dezvoltatorii acestui motor grafic
pentru întrebuințarea forțelor către obiecte de tip solidrigid. Sau corutine Ienumerator care se execută
independent la un anumit moment. Funcția Awake() se execută înaintea funcției Start().
În clasa Quaternions p rogramul debutează prin declararea variabilei „rb” de tip solidrigid (RigidBody)
public Rigidbody rb;
Apoi în funcția void Start () se inițializează variabila de tip solidrigid, linia de cod nu va funcționa
dacă gameobject -ul respectiv nu este declara t RigidBody. Nota bene, inițializarea variabilei rb în
funcția Start( ) este crucială, obiectul trebuie sa fie inițializat în scenă pentru a -i putea fi atribuit apoi,
variabilei rb.
rb = GetComponent< Rigidbody > ();
În bucla FixedUpdate() {
tempTime += Time .deltaTime;
tempTime = float.Parse (tempTime.ToString ("F2"));
avion.rungeKutta ();
-Time.deltaTime incrementeaz ă variabila tempTime la 0.1 s, tempTime rotunjește variabile la 2
zecimale pentru evitarea erorii de reprezentare a numerelor float în virugulă (floating point numbe r).
29
-avion este un obiect de tip ODEavion.ODEavion este clasa principală care tratează operația
matematică de rezolvare a ecuației diferențiale de ordin I, acest obiect apelează metoda rungeKutta()
din clasa ODEavion.
public void ruggeKutta() { Velocity = odeIteration (); }
Velocity este un setter intern pentru variabila locală velocity.În continuare, programul apelează
metoda odeIteration():
private double odeIteration() {
double dt = time; // temporal getTime..
double newVelocity;
dq[0] = odeSolver(dt,velocity);
dq[1] = odeSolver((dt + 0.5*0.1), (velocity + 0.5 * 0.1 * dq[0]));
dq[2] = odeSolver((dt + 0.5*0.1), (velocity + 0.5 * 0.1 * dq[1]));
dq[3] = odeSolver((dt + 0.1),(velocity + dq[2] * 0.1));
newVelocity = velocity + 0.16 * (dq [0] + 2 * dq [1] + 2 * dq [2] + dq [3]) * 0.1; //0.1 ptr step-
ul sau dt
return newVelocity;
}
Metoda odeIteration este universală, implimentând na tiv doar ordinea de rezolvare a ecuaților liniare,
simila ră ca structură cu cea prezent ă în programul Matlab.Urmează execuția prin apelare simultană a
metodei odeSolver, metodă specifică pentru returnarea forței generale.Această metodă returnează
variabila locală velocityAirplane de tip double, urmând a fi integrată în metoda odeIteration().
double odeSolver( double dt, double v)
double velocityAirplane = dt * (thrust (Cd * (30 * v * v / 2)
* 1.225))/mass;
return velocityAirplane;
}
30
Urmând iterația din metoda odeIteration(), va returna acelerația integrată asupra timpului
incrementată sucit return velocityAirplane;.Valoarea rezultată se setează variabilei locale velocity.
rb.velocity =transform.forward.normalized * ((float)avion.Velocity);
Variabila de tip r igidbody rb acesează metoda internă oferită de Unity API :Rigidbody, setează viteza
solidului rigid. Viteza este preluată din clasa ODEsolver, următorul getter anume avion.velocity
(float)avion.Velocity , iar (float) convertește valoarea din double în float .
Principalele idei , în urma execuției acestui fragment de cod vor fi consa crate :
Viteza față de timp va fi integrat ă în spațiu prin apelarea metodei rb.velocity, absența acestei
metode oferite de api -ul intern, ar necesita construirea unui Vector3 care va fi obținut printr -o
a 2 a metoda de iterație odeIteration(), de asemenea, o astfel de aboradare ar necesita
impleme ntarea unei noi metode de potrivite de felul odeSolver.
Metoda odeSolver() reprezintă o implementație universală, care poate fi apelată prin
polymorphism de alte clase care necesită rezolvarea unei ecuați diferențiale.
Metoda transform.forward returnează a xa de referință al unui obiect de tip GameObject
globală.
Metoda rb.velocity integrează viteza in (m/s).
Estimările locale, în urma execuției odeIterațion sunt plaste într -un vector de tip double dq cu
dimensiunea de 4.
Computaționare a ccelerației grav itaționale nu mai este necesară, un obiect declarat solid –
rigid , predefinit, prezintă accelerație gravitațională nativă.
Un obiect declarat solid rigid, este interpretat ca fiind un punct material și este văzut ca fiind
mobil, având proprietatea unei accel erații variabile in timp.
Metoda rb.velocity este apelată în interiorul funcției fixedUpdate(), aplicarea forței necesită
cadre pe secundă stabile.
31
Centrul de greutate al solidului rigid de tip RigidBody și GameObject Figura 4.7
Implementarea vitezei unghiulare pentru elicea avionului este consacrată în clasa Wheels.cs, linile
urmatoare de cod prezint ă un rezumat de implementare.
public GameObject propeller;
public Quatornions quatScript ;
void Start(){ InvokeRepeating("updateThrottle", 0.1f, 0.1f); …..}
void FixedUpdate()
{ …..
propeller.transform.Rotate(Vector3.forward * ((2 * quatScript.avion.Velocity * Mathf.PI) * throttle *
57f));
}
Obiectul quatScript este de tip Quatornions, clasa car e tratează forțele aernoavei în secțiunea de sus.
Se declară obiectul propeller de tip GameObject. Linia de cod propeller.transform.rotate execută o
rotație in unghiuri euler,Vector3.forward este prescurtarea pentru scrierea unui vector (0,0,1) care face
un produs scalar cu valoarea 2 𝜋 𝜔, unde 𝜔 reprezintă acelerația unghiulara.
Variabila throttle r eprezintă regulatorul avionului, marime care variază între (0.1 -1.0) definit
prezumtiv pe post de regulator real. Într -un final viteza unghiulară 2 𝜋 𝜔 se exprimă in radiani/sec, se
execută o împărțire la valoarea 57 pentru a converti valoarea în unghiuri euler.Rezultatul finală este
un scalar exprimat în grade eurler care inmulțeste cu Vector3.forward sau un vector a cărui
dimensiuni și orientări este ( 0,0,1).
Metoda InvokeRepeating("updateThrottle", 0.1f, 0.1f); apelează corutina updateThrottle o dată la 0.1
secunde , având un delay de la apelarea funcției void start() de 0.1 secunde.Corutina updateThrottle
este un getter pentru variabila throttle obți nută din clasa Quatrons.
32
4.3 Interfațarea motorului grafic Unity cu microcontroler -ul chipKIT
uno32 utilizând .NET Framework
Limbajul C# este un limbaj de programare orientat -obiect conceput de Microsoft la sfârșitul anilor 90.
A fost conceput ca un concurent pentru limbajul Java . Ca și acesta, C# este un derivat al limbajului de
programare C++.
Visual Studio include un set complet de instrumente de dezvoltare pentru generarea de aplicații
ASP.NET, Servicii Web XML, aplicații desktop și aplicații mob ile. Visual Basic, Visual C++, Visual
C# și Visual J# toate folosesc același mediu de dezvoltare integrat (IDE) care le permite partajarea
instrumentelor și facilitează crearea de soluții folosind mai multe limbaje de programare. Aceste
limbaje permit să b eneficieze de caracteristicile .NET Framework care oferă acces la tehnologii cheie
care simplifica dezvoltarea de aplicații web ASP și XML Web Services cu Visual Web Developer.
Visual Studio 2005
Visual Studio 2005 are numele de cod Whidbey. Versiunea supo rtă Windows 2000 sau versiuni mai
noi.] Pe data de 14 decembrie 2006 Microsoft a lansat primul Service Pack pentru Visual Studio 2005.
Visual C + + 2 005 susține compilarea pentru x86 -64 (AMD64 și Intel 64) și IA -64 (Itanium).
Visual Studio 2008
Visual Studio 2008 are numele de cod Orcas și este prima versiune care permite dezvoltatorilor să
folosească versiuni de .NET Framework. Visual Studio este baza t pe platforma de design .NET
Framework 3.5, setul de instrumente .NET 3.0 a introdus versiuni actualizate ale ASP.NET,
ADO.NET, Visual Basic, C# și CLR. Pentru interoperabilitatea și gestionarea codului mașină, Visual
C++ introduce STL/CLR, care este un p ort de C++ Standard Template Library (STL) conține
containere și algoritmi pentru gestionarea codului.[15]Microsoft a lansat primul Service Pack pent ru
Visual Studio 2008 pe data de 11 august 2008.
Visual Studio 2010
Visual Studio 2010 are numele de cod Dev10 și a fost lansat pe 12 aprilie 2010 alături de .NET
Framework 4. Visual Studio 2010 are un editor nou care utilizează WPF (Windows Presentation
Foundation), sprijină interfața de tip Ribbon, suportă monitoare multiple, Windows 7 multitouch,
funcționalitatea SharePoint, instrumente de Windows Azure și IntelliTrace, un nou produs care ajută
la eradicarea bug -urilor irepetabile. Va veni furnizată împ reună cu Expression Studio, Business &
Enterprise Servers și Microsoft Office și în versiunile Ultimate și Premium.
33
Pentru folosirea clasei SerialPort Class din libăria .NET Framework se poate invoca folosind :
using System.IO.Ports;
public SerialPort serial = new SerialPort ("COM3" ,250000 );
Acesarea metodelor din aceast ă clasă se realizează prin instanțierea unui obiect „serial” de tip
SerialPort, care primește 2 parametri în constructor (String, Int32). Maparea portului se poate face din
windows Sys tem properties Device Manager COM PORTS Selectează COM dorit sau din
microcontroller, portul folosit este COM 3. Al doilea parametru de tip Int32 semnifică Baud/rate (Bd
folosit ca simbol în schemele electronice ) sau viteza de transfer de date, reprezintă numarul biților de
transfer pe secundă. În capitolul programarea în chipKIT vor fi detaliate aceste aspecte.
𝑣𝑡𝑟𝑎𝑛𝑠𝑓𝑒𝑟 =𝑚𝑑𝑎𝑡𝑒
𝑡𝑡𝑟𝑎𝑛𝑠𝑓𝑒𝑟 (4.30)
1 kilobit = 1.024 bit [SI] = > 1 kbps = 1.024 bps [SI]
Viteza este de 250.000 bps, aproximativ 244 kbps. Microncontrolerul chipKIT uno32 până la un 1
megaByte pe secundă, însă această practică poate oferi instabilități și transferulu de date
eronate în interfața serial. De asemenea baud -rate poate fi mapat, în meniul dev ice manager,
COM ports.
Kilobitul pe secundă nu trebuie confundat cu kilo octetul (sau kilo baitul ) pe secundă (kBps), care
este egal cu 8 kilobit pe secundă sau 8 kbps. Tot așa, megabitul pe secundă, Mbps, nu trebuie
confundat cu megabaitul pe secundă, MBps, care este de 8 ori mai mare decât un Mbps.
Tabel de transfer pentru diferite frecvențe de oscillator, chipKIT uno32 suport ă o frecventă de
80mhz, însă este programat ca și refereință asimilară cu Arduino uno în materie de baud -rate.
34
Figura 4.8
Acum obiectul cu proprietățile inițializate, poate acesa clasa serială parte a librariei .NET
FRAMEWORK. Totuși aceste interogări provoacă întârzieri, într -o rutină de rulare normală a unui
program, deoarece programul nu execută simultan aceste lini de cod pentru diferite calcule, folosirea
fiecărei dintre aceste comenzi de pildă ser ial.Open(), serial.Close() sau serial.Write()/serial.Read() ,
provoacă întarzieri prin așteptarea unui raspuns pentru confirmare, de la microcontroller de interogare
, unde viteza sa de calcul este evident mai lentă decât un calculator personal.
Biblioteca .NET FRAMEWORK oferă un sistem de procesare paralelă, ( threading în engleză),
accesul la această clasă se face invocând comanda :
using System.Threading;
Conceptul de thread (fir de execuție) definește cea mai mică unitate de procesare ce poate fi
programată spre execuție de către sistemul de operare . Este folosit în programare pentru a eficientiza
execuția programelor, executând porțiuni distincte de cod în paralel în interiorul aceluiași proces .
Câteodata însă, aceste portiuni de cod care constituie corpul threadurilor, nu sunt complet
independente și în anumite momente ale execuției, se poate întampla ca un thread să trebuiască să
aștepte execuția unor instructiuni din alt thread, pentru a putea continua execuția propriilor
35
instrucțiuni. Această tehnică prin care un thread asteaptă execuția altor threaduri înainte de a continua
propria execuție, se numește sincronizarea threadurilor
Figura 4.9
Folosind urm ătoarea linie de execuție, se declară un obiect de tipul Thread:
Thread chipKit ;
Folosirea direct ă a thread -urilor în motorul grafic Unity este periculoasă, și poate cauza rezultate
nedeterministe. Din această privintă nu se folosesc acest concept de threading, doar în cazuri speciale
recomandate, unde se pot executa rutine de calcul, interogarea proceselor independentă. Din păcate
motorul grafic Unity nu are acces complet asupra librariei .NET, o modalitate mai bună de interogare
ar fi folosirea event -urilor de date.Se declanșează un eveniment la o eventuală primire de date,
ignorând complet rutina de rulare void Update(), FixedUpdate() etc urmân d a fi tratată independent
această întrerupere. Cele 4 evenimente disponibile de libraria .NET sunt DataReceived ,
Disposed,ErrorReceived,PinChanged .
În clasa ThreadArduino u rmătorul bloc de cod, verifică disponibilitatea serială pe portul COM 3:
36
void Awake () {
try
{
if(serial.IsOpen)
{
serial.Close();
serial.Open();
}
else
{
serial.Open();
}
}
Instrucțiunea try -catch previne ieșirea din simulator, în cazul în care microcontroller -ul nu este
conectat sau nu este accesibil (COM3 Busy) , consecința este o eroare de tipul System .Type care
întrerupe imediat rularea programului.Această eroare provoacă confuzii în rândul utilizatorului de
rând, care poate interpreta eronat, pe motiv de bug software, pentru acest tip de crash. În schimb
utilazatorului îi este furnizat un mesaj de atenționare „Nu se poate deschide portul COM3”, acest
mesaj poate să ajute i ntr-o eventuală diagnoză.
Folosirea catch are două scopuri. În primul rând orice structură de tipul try, obligatoriu trebuie sfârșită
cu o structură catch. În al doilea rând „System” simbolizează larga librarie .NET, folosirea
System.Excepțion aruncă orice tip de eroare, de proveniență .NET, în variabila ex. Eșecul execuției
structurii try, forțează interpretorul execuția lui catch atribuind lui ex, mesajul de excepție.
catch (System. Exception ex)
{
Debug .Log ("Nu se poate deschide portul COM3" + ex.Message);
}
În cazul în care nu se reusește execuția lui try , se face salt la adresa catch pentru execuție. Debug.Log
afiseză în consola unity mesajul „Nu se…COM3” urmat de mesajul de excepție, System.IO.Ports
În structura try, se verfica disponibilitatea portului respectiv (serial.IsOpen), dacă acest port este
deschis se încearcă inchiderea și deschiderea lui. În caz contrar, doar se deschide (serial.Open).
Execuția se face în Awake(), această rutină se execută înaintea funcției Start() și înainte ca obiectele
să apară pe scenă.
De remarcat faptul că obiectul ch ipKIT declarat de tip Thread, încă nu a fost instanțiat. În mome ntul
de față execuția s -a făcut complet în rutina standard , procesul de threading nu a început.
37
Pornirea procesului de threading :
chipKit = new Thread (new ThreadStart (chipKitThread ));
chiptKit .Start ();
Obiectul chipKit este instanțiat și parsează în constructor numele rutinei de rulare chipKitThread,
procesul de threading pornește prin apelarea comenzii chipKit.Start(). Acest apel, face salt la adresa
funcției chipKitThread.
private void getArduino () {
while (chipKit .IsAlive)
{
try
{
serial.WriteLine (avionVelocity);
serial.Basestream.flush() ;
}
catch (System. Exception ex)
{….}
try
{
SetStreamRead = serial.ReadLine();
}
catch (System. Exception ex)
{ …}
}
}
Obiectul serial aceseaz ă metoda WriteLine, încearcă scrierea în interfața seriala unui mesaj de tip
string. Referitor la avionVelocity, este un getter care preia din clasa Quatorns viteza avionului, de tip
float, folosind (string) valoarea respectivă este convertită în șiruri de caractere pentru a fi compatibilă
cu metoda WriteLine.Mesajul scris va fi scris în interfața serială cu linie nouă,
serial.Basestream.flush() asigură primirea mesajului de către microcontroler -ul chipKit. Instrucțiunea
WriteLine și WriteLine sunt încapsulate în structura try, această abordar e previne scrierea haotică în
interfața serială atunci când microcontroler -ul are alte sarcini de realizat, și deci interfața serială nu
poate răspunde.
38
Scrierea pe interfața serială se face caracter cu caracter, spre exemplu serial.WriteLine („Bla”), va
executa de 3 ori instrucțiunea serial.Write(„B”, „l”, „a”), apoi o instrucțiune serial.WriteLine();.
A doua structură try, citeșteste eventuale date trmise de micrcontroller, serial.ReadLine() citește daca
există vreo linie nouă aparaută ca mesaj în inte rfața serială . Mesajul trimis este de tip string, șirurile
de caractere furnizate de microcontroler oferă informații referitoare la senzori rezitvi potențiometrici.
Variabilele anglePot1 și anglePot2, urmează a fi actualizate prin setter -ul SetStreamRead. Variabila
streamRead este de tipul string și este statică .
public static string streamRead;
private string SetStreamRead{ set{ streamRead = value ; }}
Înapoi în clasa Quartons se declară , și insta nțiază un obiect de tipul ThreadArduino, care are un
contructor default:
ThreadArduino threadInfo = new ThreadArduino ();
Metoda updateAnglesAvion(), condiționează șirul string furnizat de microcontroler, in subșiruri. Un
astfel de mesaj trimis de micrcontroler vine sub forma (X|X|X), unde X – reprezintă un subșir (ex
unghi, regulator) iar caracterul „|” este folosit pentru d elimitare. Folosind
threadInfo.GetStreamRead.Split ('|'), obiectul threadInfo aceseaz ă getter -ul din interiorul clasei
ThreadArduino.
Pentru fiecare delimitat cu simbolul „|”, folosind .Split( '|'), mesajul va fi imparțit de la început până la
sfârșit în c uvinte sau fragmente de mesaje, în acest context, se elimină caracterul nedorit „|”.Partea
relevantă este atribuită fiecarui elemnt din vectorul string [] values, care are rol de listă, deoarece nu
are o dimensiune stabilită.
void updateAnglesAvion()
{
try {
string [] values = threadInfo.GetStreamRead.Split ('|');
anglePot1 = (float.Parse(values[ 0]));
anglePot2 = (float.Parse(values[ 1]));
throtlePot = (float.Parse(values[ 2]));
}
39
catch (System. Format. Exception ex)
{
Debug .Log ("Format problem" + ex.Message);
}
}
Variablele anglePot1, anglePot2,throtlePot sunt de tipul float, elementele din vectorul de tip string
values [] sunt castate în float. Conversia nu poate fi realizată în toate cazurile cu succes, interfața
serială poate exprima erori de scriere, din acest motiv se apelează la o structură try – catch. Parametru
din interiorul structuri catch este „System.Format.Exception” , special p entru erori unde conversia nu a
fost realizată cu succes.Catch tratează numai erori de tipul Format.Exception, o problemă de
particularitate diferită nu va fi tratată, iar programul se poate opri neașteptat.
4.4 Diagnoză comunicației seriale folosind PuTTY.
PuTTY este un program gratuit și open -source ce emulează un terminal fiind un client
pentru SSH, Telnet, rlogin, și raw TCP protocol precum și client pentru serial console. Numele
"PuTTY" nu are o semnificație anume acesta reflectând procedura "prin TTY" u nde "TTY" se referă
la "terminal" în terminologia UNIX (TTY este prescurtare pentru Teletype).
PuTTY a fost scris original pentru Microsoft Windows dar ulterior a fost portat și pe alte sisteme de
operare. Există versiuni oficiale disponibile pentru unele platforme Unix -like și se lucrează constant și
pentru versiuni ale Mac OS și Mac OS X. Versiuni neoficiale pot fi găsite pentru sisteme
ca Symbian și Windows Mobile.
Folosind PuTTY se poate interfața prin interfața foarte ușor cu micrcontroler -ul chipKIT , programul
nu necesită programarea unei metode similare cu cea programată în C #
.
Figura 4.10
40
Figura 4.11
Configurarea este simplă, în câmpul Serial line se scrie numele portului mapat (COM3) cazul de față.
Apoi se setează baud -rate, se populează câmpul Speed cu viteza configurației dorite.
Figura 4.12
41
Acesând terminalul PuTTY, se pot da comenzi seriale către microcontroler
5 CAPITOLUL 5: CHIPKIT UNO32
Figura 5.1
ChipKIT Uno32 este bazat pe proiectul open -source Arduino, însă din punct de vedere al arhitecturii
hardware este complet diferit. Procesorul este de tipul Microchip PIC32. Placa de circuit este aceiași
cu Arduino, astfel permite folosirea unor shield -uri proiectate pentru arduino. Un dezavantaj major al
acestei placi de dezvoltare constitue lipsa bibliotecilor disponibile, în comparație cu Arduino, ac est
microcontroler nu este la fel de popular.Microcontroler -ul chipKIT uno32 dispune de un procesor pe
32-biti, care operează la frecvența de 80 mhz, 128K memorie flash program, 16K memorie SRAM.
Mediul de programare folosit pentru acest microcontroler Uno32, poate fi atât MPIDE(Multi -Platform
Integrated Developement Environment) bazat pe mediul Arduino, însă modificat pentru a susține
arhitectura PIC32. Acest tip de arhitectură permite programarea și în mediul dezvoltat de Microchip
MPLAB. Placa de dezvolt are dispune de un debugger integrat.
Microcontroler -ul oferă 42 intrări/ieșiri, unde 12 sunt intrări analogice iar restul 30, pot fi configurate
ca intrări sau ieșiri digitale. Un mare dezavantaj al acestui micrcontroler, repezintă tensiunea limitată
42
de op erare, 3.3v, adoptă modelul arhitecturilor noi, însă modelul de 5v standard întâlnite la
arhitecturile mai vechi, de asemenea adoptat și arduino dispune de o comunitate mai mare, atât a
producatorilor hardware cât și software.
5.1 chipKit Uno32 specificații hardware
Figura 5.2
1. Conector USB pentru convertor serial USB
43
Aceasta se conectează la un port USB al calculatorului personal, pentru a oferi posibilitatea portului
de comunicații pentru MPIDE să vorbească cu placa Uno32. Acest lucru poate fi de asemenea folosit
pentru alimentarea plăcii Uno32 când este conectat la PC.
2. JP3 – Microchip Debug Tool Connector
Acest conector este utilizat pentru a conecta une lte de programare / depanare Microchip, cum ar fi
PICkit ™ 3. Acest lucru permite placii Uno32 să fie folosită ca o placă de dezvoltare a
microcontrolerului tradițional, utilizând Microchip MPLAB® IDE.
3. J4 – Conector extern de alimentare
Acesta este un c onector de baril de 5,5 mm x 2,1 mm folosit pentru alimentarea plăcii Uno32 de la o
sursă externă de alimentare. Este conectat la borna centrală ca tensiune de alimentare pozitivă.
Tensiunea de alimentare trebuie s ă fie cuprinsă între 7V și 15V.
4. Sursă d e alimentare – regulator de 3.3V
Regulator de tensiune pentru sursa de alimentare de 3.3V. Această sursă de alimentare poate f urniza
până la 500mA de curent.
5. JP2 – Jumper de selectare a puterii
Acest jumper este utilizat pentru a direcționa alimentarea de la conectorul de alimentare externă prin
intermediul regulatorului de tensiune 5V la bord sau pentru a ocoli regulatorul de 5V. Poziția REG
traversează puterea prin intermediul regulatorului de 5V. Poziția BYP ocolește regulatorul de 5 V de
la bord. Cu acest jumper în poziția BYP, tensiunea maximă de intrare care poate fi aplicată la
conectorul e xtern de alimentare este de 6V.
6. Sursă de alimentare – Regulator 5V
Acest regulator de tensiune la 5V reglează tensiunea de intrare aplicată la conectorul de a limentare
extern la 5V. Acesta este folosit pentru alimentarea regulatorului de 3.3V și pentru asigurarea unei
puteri de 5V pentru scuturile de expansiune. Acest regulator poate oferi până la 800m A de curent.
7. J2 – Conector de putere ecranat
Acest conect or asigură alimentarea scuturilor de expan siune I / O conectate la placă.
8. Microcontroler PIC32
44
Microcontrolerul PIC32MX320F128H este procesorul principal al plăcii.
9. J7 – Conector semnal analogic
Acest conector asigură accesul la pinii I / O analogic / digital de pe microcontroler.
10. JP6 / JP7 – Selectați jumperi A4 / A5 Signal
Aceste jumperi sunt utilizate pentru a comuta pinii 9 și 11 pe conectorul J7 între intrările analogice A4
și A5 sau semnalele I²C SDA și SCL.
11. J8 – Conector de semnal SPI
Acest conector oferă acces alternativ la semnalele SPI. Acest lucru este folosit de unele scuturi pentru
accesul la magistrala SPI.
5.2 chipKit Uno32 schema electronică
Componentele electronice folosite în schema electronică:
Figura 5.3
45
3 x P ontențiometru 10k [ohm]. Folosite pentru a oferi valori de tensiune în raport cu
deplasarea mecanică liniară a cremalierei și al axului rotativ(throttle).
LCD 16×2 (16 coloane, 2 lini) model Hitachi HD44780
Fire de cup ru tata -tata, fir e de cupru flexibil e (folosite la impriminta cu cerneală )
Tens iunea de alimentare 3.3 v, sursa de tensiune suportă un curent de 500 mA , cu excepția
LCD -ului care este alimentat pe portul background la 5V.
CAN sau Convertor analogic -numeric (convertor analogic -digital) reprezintă un bloc sau un circuit
care poate accepta o mărime analogică (curent, tensiune) la intrare, furnizând la ieșire un număr care
constituie o aproximare (mai mult sau mai puțin exactă) a valorii analogice a semnalului de la intrare.
Spre deosebire de o mărime analogică ale cărei valori se pot găsi în orice punct din domeniul său de
variație, mărimea numerică (sau digitală) posedă numai o variație în trepte. Astfel, întreg domeniul de
variație este divizat într -un număr finit de „cuante” (trepte elementare) de mărime determinată de
rezoluția sistemului, în acest mod, diferența între cele mai apropiate valori numerice nu poate fi făcută
mai mică decât această treaptă elementară, ceea ce face ca, principial, reprezentarea i nformației sub
forma numerică să fie legată de introducerea unei erori, numită eroare de cuantificare .
Figura 5.4
Microchip -PIC32F -PIC32MX320F032H
46
Convertorul analog numeric are 16 pini de intrare analogică.AN0..AN15, acești pini sunt multiplexați
și selecționați, în funcție de prioritatea de conversie (Channel Scan), important de menționat mai este
faptul că, conversia poarte porni și forțat prin punerea lui Vrefl pe 1, doar pentru pinul AN1, aceas tă
abordare este prioritară. Semnalul analogic trece printr -un buffer de comparare, în cele din urmă
conversia pornește în circuitul de memorare S/H (sample -hold). Rezultatul final este pus în stivă care
conține registri respectivi. Colectarea rezultatului final, necesită resetarea registrului respectiv , prin
aplicarea în maparea de registru, o comandă pe 4 biți care resetează un registru de stoacare al adc
specific.
Comunicația între uno32 și motorul grafic Unity3D se poate realiza prin interfața UART, ca re este un
tip de comunicație asincronă.Interfața UART funcționează corect doar atunci când ambele dispozitive
au același Baud rate/Bitrate. Protocolul de comuncație UART se bazează pe arhitectura Peer -to-peer
(P2P), în traducerea liberă egal -la egal.
Figura 5.5
Pini de comunicare sunt TX(trimitere date), RX(recepționare date) .Microcontroler -ul chipKIT uno32
prezintă leduri înseriate, pentru cele două porturi de comunicație.Astfel o comunicație UART, poate fi
vizualizată, din punct de vedere al manifestării hardware.
47
Figura 5.6
Din schema de cuplare , a două interfețe UART , acestea asincrone, se deduce absența pinului CLK,
folosit în interfețele sincrone I2C, SPI . O interfață serial nu folosește un ceas de tact, iar cuplarea se
face prin baud/rate. Ca și avantaj, acest tip de interfață, admite un număr nelimitat de dispozitive
cuplate, însă vi teza este limitată, inferioară interfețelor sincrone.
Protocolul de comunicație al acestei interfețe asincrone este urmatorul :
Figura 5.7
48
1. Pe TX se pornește cu 1 bit de START, urmat de un buffer care con ține datele relevante,
buffer -ul se transmite printr -o stivă FIFO, bit cu bit. Pentru o fiabilitate mai bună, în stiva
FIFO, se poate introduce un bit de paritate (Odd sau Even), la fiecare 7-biti de date . Pentru o
configurație de paritate pară spre exempl u, se vor verifica cați biti se află pe pozitia 1 LOGIC,
totalitatea biților rezultată un numar care poate fi par sau impar, în această configurație pară,
un numar de biți par, presupune trecerea în 1 LOGIC, a bitului pentru paritate. Această
configurație trebuie facută pe ambele module daca se dorește.
2. Tranzacția realizată (toți biți din buffer au fost trimiși), presupune un bit de întrerupere a
comunicației seriale, 1 STOP Bit, comunicația asincronă trece în starea Bus Idle. Un mesaj de
string este conve rtit în cod ASCII, care este în baza 16, apoi se convertește în baza 2.
Figura 5.8
O structură de date pe 7 biți cu 1 bit de paritate.
5.3 Programarea în mediul Mpide
Figura 5.9
49
Mediul de dezvoltare integrat MpiIDE este similar cu ArduinoIDE, crearea unui fișer sursă se face
selectând în secțiunea Menu FileNew. Fișerul sursă se salvează acesând secțiunea Toolbar
buttonsSave, fișerul sursă se denumește conform preferințelor. În mod implicit, un fișer compilat
este salvat în folderul %temp.
Incluziunea unor libari în codul sursă, necesită plasarea lor în folderul libraries sau folosirea unui fișer
de tip MakeFile, care poate clarifica o cale pentru Linker , și în cazul unor incluziuni de librări cu
același nume. Nerespectarea acestei reguli, declanșează o eroare de tip Linker . Linker -ul asigură
incluziunea corectă a bibliotecilor, mapează memoria pentru un micrcontroler specific, leagă fișere
multiple de tip obj (fișere compilate pentru o arhitectură de procesor) într -un .exe, .dll,lib.
Figura 5.10
Elementele comune se definesc de obicei în fișiere antet (de tip H), care se includ în compilar ea
fișierelor sursă cu prototipuri de funcții (de tip C sau CPP). În general fișerele de tip H, nu conțin
instrucțiuni scrise în limbajul C sau C++. În industria automotive, sunt folosite pe post de a suprima
un cod anex, de asemena, se pot declara variabile globale în aceste fișere. Compi lrea condiționată unei
expresie are structura : #if expresie_constanta else #endif . Definirea unei constante simbolice are
structura : #define NUME <valoare > <opțional>
50
#ifndef
__MOT_QUASAR2E_H
#define __MOT_QUASAR2E_H
#define VARIABLE_PARAMETER_START 0x00020000
#define VAR_PARM_SIZE 0x0080000
#if (VARIABLE_PARAMETER_START != 0)
PARAMETER_SECTION : org = VARIABLE_PARAMETER_START len =
(VAR_PARM_SIZE )
# endif
#endif /* __MOT_QUASAR2E_H */
Un exemplu de mapare a memoriei pentru un sistem înglobat freescale , mcu MOT_Quasar, folosind
un fișer de tip header.
Structura unui program chipKIT :
1.Declarare variabile, incluziune header, expresi simbolice de tip macrointrucțiune, funcții
implementate.
void setup()
{
2. Rutina de setup se execută o singură dată după apăsarea butonului de RESET, urmatoarele
operațiuni se pot face în această buclă:inițializare intrări/ieșiri pentru pini microcontrolerului,
configurare timer, inițializare variabile.
}
void loop()
{
3. Rutina loop() se execută la infinit, dacă nu este supusă unei întreruperi (Timer, periferic,
CAN, eveniment serial etc.). Fosită pentru execuția unui bloc de cod înscapsulat cu adrese de
funcții, sau nu.
}
51
5.4 Interfațare chi pKIT uno32 – Unity
Folosind structura unui program chiKIT, limbajul de programare folosit este C. C este un limbaj de
programare relativ minimalist ce operează în strânsă legătură cu hardware -ul, fiind cel mai apropiat
de limbajul de asamblare față de majoritatea celorlalte limbaje de programare.
Pornind cu secțiunea 1, se declară 3 variabile de tip byte pe 8 -biti, cuprinse ca valori între ( -128,128),
un vector de tip char[7] care are o dimensiune de 8 elemente pornind de la indicele 0, o variabil ă de
tip String pentru stocarea mesajului provenit de pe interfața serială.
#include <LiquidCrystal.h>
int senzorValue1 = 0;
int senzorValue2 = 0;
int senzorValue3 = 0;
char buffer[7];
String textVelocity;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
De asemenea , în secțiunea 1 , se include și libraria standard LiquidCrystal dispusă de dezvoltatorii
chipKIT . Respectând schema electronică LiquidCrystal(12,11,5,4,3,2), reprezintă pini digitali în
modul 4 -bit mode (D7,D6,D5,D4) pini fizici lcd.
void setup()
{
pinMode(A0,INPUT);
pinMode(A1,INPUT);
pinMode(A2,INPUT);
Serial.begin(250000);
while (!Serial) {}
52
lcd.begin(16, 2);
}
În rutina setup, respectând schema electronică, se declară intrările analogice (A0, A1, A2) pentru
potențiometrii de 10k , tensi unea electrică al acestor intrări, variază între (0V -3.3V) în funcție de
culisarea cursorului potențiometric. Pini sunt mapați ca și intrări, automat, a căror port corespund.
Instrucțiunea Serial.begin(250000), configură interfața serială UART, emulată de microcontroler, pe
un bus de 250000 biti/s. Instrucțiunea while(!Serial), verifică disponibilitatea porului serial, condiția
nevalidată nu poate trece mai departe în bucla loop().Se apelează funcția lcd.begin(16,2) pentru
inițializarea unui lcd 16×2.
void loop()
{
senzorValue2 = (map(analogRead(A0),0,1024, -45,45));
senzorValue1 = (map(analogRead(A1),0,1024,30, -30));
senzorValue3 = (map(analogRead(A2),550,800,10,1));
sprintf(buffer,"%d|%d|%d", senzorValue1,senzorValue2,senzorValue3);
Serial.print ln(buffer);
Serial.flush();
lcdPrintAndRecive();
}
Exemplu:
Serial.println(„test”) Conversie ASCII (116 101 115 116 ) Conversie Hex (31 31 36 20 31
30 31 20 31 31 35 20 31 31 36 20 ) Conversie Binar
([S*4]1100010011000100110110001000000011000100110000001100010010000011000100110001
0011010100100000 [T])
Perifericul CAN suportă o rezoluție de 212 biți, asta înseamnă 1024 unități CAN pentru tensiuni între
(0V-3.3V). Utilizarea CAN -ului excesiv pentru preluarea semnalelor analogice nu este recomandată,
53
utilizarea unei funcții delay(10), permite recuperarea perifericului CAN. Această funcție este
incorpor tă în funcția lcdPrintAndRecive().Funcția analogRead este mapată în valori între ( -45,45) sau
(30,-30) care simbolizează unghiul de urcare și virarj, pentru senzorValue3 valorile unităților CAN
flucuează între (555,800) din cauza restricților mecanice, potențiometru execută o rotație de maximă
de 30 grade și pornește defazat cu 60 grade.
Buffer -ul de tip char, este încărcat cu valorile decimale „(senzorValue1,senzorValue2,senzorValue3)”
și converit în șiruri de caractere folosind operatorul %d , separat de caracterul „|” .Funcția sprintf
plasează mesajul rezultat din stream în variabila buffer.
Configurația serială nu folosește bit de paritate, structura try -catch utilizată în unity tratează
eventualele eorori de scriere.Funcția Serial.prinln(buffer), desc arcă buffer -ul în buffer -ul de trimitere
date TX , în format ASCII, acesti pini folosesc logica TTL (3.3v).
Codul sursă original pentru funcția Serial.Flush (), preluat din librăria SoftwareSerial, prezintă o stivă
FIFO , _tx_buffer pointează catre adresa ul timului elemnt din stivă și o plasează pe prima poziție spre
trimitere :
void HardwareSerial::flushTX ()
{
_tx_buffer ->tail = _tx_buffer ->head;
}
Funcția lcdPrintAndRecive, afișează pe lcd viteza avionului :
void lcdPrintAndRecive()
{
delay(10) ; //recuperare CAN
while (Serial.available() > 0)
{
textVelocity = Serial.read line().substring(4) ;
char c = Serial.read(); //flush rx_buffer
}
lcd.setCursor(0,0);
lcd.print("V:(m/s)");
lcd.setCursor(0,1);
lcd.print(textVelocity);
54
lcd.print(" ");
}
Cât timp î n buffer -ul rx, există date prezente (șiruri de caractere) „while(Serial.available() > 0)”,
atunci se citește interfața serială „serial.readline()”, iar „.substring(4)” trunchiază șirul de caractere ,
cu până la 4 caractere. Restul datelor stocate în buffer -ul rx sunt epuizate, folosind serial.Read().
Derularea comenzilor (serial.Read, serialWrie etc.) prezintă un eveniment Serial și întrerupe execuția
buclei loop pentru moment.
Pentru afișor, comenzile sunt simple. Bibliote ca standard liquidcrystal este bine documentată, pentru
un programator fără o experiență considerabilă, utilizarea funcților liquidcrysta, sunt similare cu cele
din limbajul c standard. Folosind lcd.setCursor(0,1) , setăm poziția cursorului linia 1 (0) și coloana 2
(1).Oricum această procedură este opțională, întrucâ formatarea se face automat . Afișarea mesajului
sau al unui numar decimal, hexa, binar (prin adăugirea parametrului HEX,BIN,DEC) cu sau fară
lcd.setCursor, se face prin funcția lcd.print().
Cara cterele speciale (cum ar fi ASCII extended table) nu sunt integrate în biblioteca standard, liquid
crystal și necesită o bibliotecă proprie.În mod normal, actualizarea afișorului se face folosind
comanda lcd.Clear(), însă are ca și consec ință, întârzierea rutinei de execuție.
55
6 CONCLUZII
Pe parcusul dezvoltării acest ei aplicații de simulare am întâlnit multe dificultății, întrucât eram
începător pentru toate tehnologi ile prezentate în proiect (Maya, Unity, Matlab, C sharp, GIMP, C,
SolidWorks ), care au provocat frustrări neașteptate , și automat o teamă de neîndeplinire a cerințelor
propuse . Oricum aceste frustrări nu au reprezentat un motiv spre a -mi m odifica tema de licentă
propusă , în schimb am luat -o ca pe o provocoare.
Conștientizez nivelul redus de complexitate al proiectului, dar, în același timp sunt mulțumit de ce
am realizat. Un simulator complex necesită mult timp, mână de lucru specializată , rezultate
experimentale, buget , testări software .
Pornind de la începător cu mențiunea timpul ui de acomodare, am urmărit înțelegerea unor soft -uri de
actualitate folosite frecvent industrie , realizarea unui proiect practic . Consider această abordare
metodică , întrucât noile tehnologi care vor apărea, mereu, vor necesita o pregătire continuă în
domeniu și disciplină . Dacă voi continua să aloc răbdare, să invăț din adversitate, să acept noi
provocări … consider că voi ajunge un viitor inginer productiv.
56
7 BIBLIOGRAFIE
[DB02] – Physics for Game Developers, Editura O’REILLY, 2002
[DOOM05] – Dicționarul ortografic, ortoepic și morfologic al limbii române , Editura Univers
Enciclopedic, București, 2005
[DI75] –Comanda Optimală cu criterii de tip Mayer obiecte de ordin superior , Editura
Universității din Craiova, 1975
[FB04] – Curs de Fizică generală, în format electronic, pentru invățământul tehnic
timișorean, Editura Politehnică, Timișoara 2004
[GP05] – Physics for Game Programmers, Editura Apress, 2005
[LJ15] – Fizică pentru nepoți vol 1, Colecția ALMA MASTER STUDIORUM București,
2015
[LJ15] – Fizică pentru nepoți vol 2, Colecția ALMA MASTER STUDIORUM București,
2015
[NB11] – Modelarea matematică prin Matlab , 2011
57
8 REFERINȚE WEB
[ANCI] Programarea calculatoarelor Limbajul C –
http://andrei.clubcisco.ro/cursuri/1pc/co/curs13.pdf
[Alm08] – Pedro de Almeida, Patrik F uhrer, Documentation Guidelines for Diploma and
Master Thesis, Universitatea din Fribourg, Elveția, 2008, disponibil on -line la adresa
http://diuf.unifr.ch/drupal/softeng/teaching/guidelines
[BW15] C# programming guide, Bill Wagner 2015
https://docs.microsoft.com/en -us/dotnet/csharp/programming -guide/
[CAN] – https://ro.wikipedia.org/wiki/Convertor_ana logic -numeric
[chipKIT] – chipKIT Uno32 Reference Manual –
https://reference.digilentinc.com/chipkit_uno32/refmanual
[JF03] Jeff Scott, 16 November 2003 Airfoils at High Angle of Attack
http://www.aerospaceweb.org/question/airfoils/q0150b.shtml
[ODE] Numerical methods for ordinary differential equations –
https://en.wikipedia.org/wiki/Numerical_methods_for_ordinary_differential_equations
[Olt07] – Th. Olteanu, C. Albu, Ghid pentru redactarea lucrării de diplomă sau a disertației
de masterat , Universitatea Română de Arte și Științe „Gheorghe Cristea”, 2007, disponibil
via web la adresa http://www.ugc.ro/tpl/GHID REDACTARE DIPLOMA LICENTA.pdf
[PuTTY] – Intel® Edison Board User Guide 2017
https://software.intel.com/en -us/setting -up-serial -terminal -on-system -with-windows
https://www.mccdaq.com/PDFs/Manuals/D T7816_WebHelp/Installing_Putty.htm
[PIC] 2011 Microchip Tehnology Inc. PIC 32MX/3XX/4XX Data sheet
http://ww1.microchip.com/downloads/en/DeviceDoc/61143H.pdf
[TB15 ] The Drag Equ ation NASA Official : Tom Benson 2015
https://spaceflightsystems.grc.nasa.gov/education/rocket/drageq.html
[VSD] – Microsoft visual studio https://ro.wikipedia.org/wiki/Microsoft_Visual_Studio
[UART] Posted by Circuit Basics – http://www.circuitbasics.com/basics -uart-
communication/
[UNITY] – 2018 Unity Scripting Reference https://docs.unity3d.com/ScriptReference/
58
CODUL SURSĂ
// ARDUINO
#include <LiquidCrystal.h>
int senzorValue1 = 0;
int senzorValue2 = 0;
int senzorValue3 = 0;
byte isIn;
char buffer[7];
String textVelocity;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup()
{
pinMode(A0,INPUT);
pinMode(A1,INPUT);
pinMode(A2,INPUT);
Serial.begin (250000);
while (!Serial) {}
lcd.begin(16, 2);
}
void loop()
{
senzorValue2 = (map(analogRead(A0),0,1024, -45,45));
senzorValue1 = (map(analogRead(A1),0,1024,30, -30));
senzorValue3 = (map(analogRead(A2),550,800,10,1));
sprintf(buffer,"%d|%d|%d", senzorValue1,senzorValue2,senzorValue3);
Serial.println(buffer);
lcdPrintAndRecive();
}
59
void lcdPrintAndRecive()
{
while (Serial.available() > 0)
{
textVelocity = Serial.read();
}
lcd.setCursor(0,0);
lcd.print("V:(m/s)");
lcd.setCursor(0,1);
lcd.print(textVelocity);
lcd.print(" ");
}
// ARDUINO
//C#
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class ODEavion : MonoBehaviour {
int enginePower;
int engineRps;
int mass;
double np;
double propDiameter = 1.905 ;
double Cd = 0.045 ;
double [] dq = new double [4];
double throttle;
double thrust;
double time;
double velocity = 0.1;
public ODEav ion(int i) {
60
Debug .Log ("No.Box" +i);
enginePower = 850000 ;
np = 0.85;
engineRps = 40;
propDiameter = 1.905 ;
mass = 50000 ; //5 t * g
throttle = 1.0;
thrust = (throttle * enginePower * np) / (engineRps * propDiameter);
}
double odeSolver( double dt, double v) {
double velocityAirplane = dt * (thrust – (Cd * (30 * v * v / 2) * 1.225 ))/mass;
return velocityAirplane;
}
private double odeIteration() {
double dt = time; // temporal getTime..
double newVelocity;
dq[0] = odeSolver(dt,velocity);
dq[1] = odeSolver((dt + 0.5*0.1), (velocity + 0.5 * 0.1 * dq[0]));
dq[2] = odeSolver((dt + 0.5*0.1), (velocity + 0.5 * 0.1 * dq[1]));
dq[3] = odeSolver((dt + 0.1),(velocity + dq[2] * 0.1));
newVelocity = velocity + 0.16 * (dq [0] + 2 * dq [1] + 2 * dq [2] + dq [3]) * 0.1; //0.1 ptr step-ul sau dt
return newVelocity;
}
public void ruggeKutta() {
double checkVelocity = velocity; // verificare daca velocity e saturat
61
time += 0.1;
Velocity = odeIteration ();
}
//intre 0 si 90 max (45) 2.8482 min 0.1
public float anglePower (int x) {
try
{
if(x<90) return -0.0013571f * x * x + 0.122143f * x + 0.1f;
else{ x -= 90; return -0.0013571f * x * x + 0.122143f * x + 0.1f;}
}
catch {Debug .Log ("––- ");}
return 0.1f;
}
//get / set
public double Time {
get{ return time; }
set{ time = value ; }
}
public double Velocity {
get{ return velocity; }
set{ velocity = value ; }
}
62
public void setThrottle( double value) {
throttle = value;
thrust = (throttle * enginePower * np) / (engineRps * propDiameter);
}
public double Throttle { get { return throttle; } }
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO.Ports;
using System.Threading;
public class ThreadArduino : MonoBehaviour {
Thread arduino;
public static string streamRead;
public SerialPort serial = new SerialPort ("COM3" ,250000 );
public static string avionVelocity;
void Start () {
try
{
if(serial.IsOpen)
{
serial.Close();
serial.Open();
}
else
{
serial.Open();
}
}
catch (System. Exception ex)
63
{
Debug .Log ("Can not open serial port" + ex.Message);
}
arduino = new Thread (new ThreadStart (getArduino));
arduino.Start ();
}
private void getArduino () {
while (arduino.IsAlive)
{
try
{
serial.WriteLine (avionVelocity);
}
catch (System. Except ion ex)
{
Debug .Log ("?????????????????" );
}
try
{
SetStreamRead = serial.ReadLine();
}
catch (System. Exception ex)
{
throw ;
}
}
}
public string GetStreamRead {get{ return streamRead; }}
private string SetStreamRead{ set{ streamRead = value ; }}
64
public string SetAvionVelocity{ set { avionVelocity = value ; } }
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Wheels : MonoBehaviour {
public GameObject Wheel_object;
public GameObject propeller;
public Quatornions schimb ;
public Vector3 startPosition;
publi c Vector3 throttleDeltaRot;
public Vector3 throttlePosition;
public float angle;
float throttle;
float diferentaThrottle;
bool verificaDiferenta = false ;
void Start ()
{
startPosition = transform.position;
InvokeRepeating( "updateThrottle" , 0.1f, 0.1f);
schimb = Wheel_object.GetComponent< Quatornions > ();
}
void FixedUpdate()
{
if (verificaDiferenta)
{
propeller.transform.Rotate (throttleDeltaRot);
}
else
{
65
propeller.transform.Rotate( Vector3 .forward * ((2 * 40 * Mathf .PI) * throttle * 57f));
}
}
void updateThrottle() {
if (throttle != schimb .avionThrottle ())
{
verificaDiferenta = true;
throttleDeltaRot = new Vector3 (transform.rotation.x,
transform.rotation.y,
((2*40 * Mathf .PI) * schimb .avionThrottle ()) * 57f );
}
else
{
verificaDiferenta = false ;
}
throttle = schimb .avionThrottle ();
}
}
using UnityEngine;
using System.Collections;
using System.IO.Ports;
public class Quatornions : MonoBehaviour {
public GameObject other;
float angle= 20;
float throttle;
Vector3 aripaUnghi = new Vector3 (0f, 0.5f, 0.866f );
66
Quaternion q = new Quaternion (0, 0, 0, -1);
public static ODEavion avion = new ODEavion (2);
ThreadArduino threadInfo = new ThreadArduino ();
float tempTime;
public Rigidbody rb;
public float Cl = 1.5f;
float lift;
float drag;
static float altitude;
bool vStall = true;
static bool isGrounded = true;
static int stareAvion = 3;
string StreamRead;
float anglePot1;
float anglePot2;
float throtlePot;
void Start () {
rb = GetComponent< Rigidbody > ();
InvokeRepeating( "getAltitude" , 0.3f, 0.5f);
}
void FixedUpdate ()
{
if (throttle >= 0.2f) {
tempTime += Time .deltaTime;
tempTime = float.Parse (tempTime.ToString ("F2" ));
if (tempTime >= 0.1f) {
avion.ruggeKutta ();
tempTime = 0;
}
}
67
lift = (Cl *1.5f*1.225f *(float)avion.Velocity*( float)avion.Velocity* 15.2f )/50000f ;
if (lift > 0)
{
rb.velocity = transform.forward.normalized * (-(float)avion.Velocity);
}
else
{
}
updateAnglesAvion ();
//Debug.Log("Lift : m/s "+lift);
switch (stareAvion) {
case 1:
{
q = tractionAi rplaneArduino(q);
transform.rotation = q;
Debug .Log ("avionul se afla in aer unghiul pitch -yaw e valabil…Default quaternion function" );
break ;
}
case 2:
{
Debug .Log (" avionul se afla in aer dar e in stallspeed" );
break ;
}
case 3:
{
q = tractionAirplaneOnGroundArduino(q);
transform.rotation = q;
Debug .Log ("avionu l necesita un thrust mai mare pentru decolare." );
break ;
}
case 4:
{
68
q = tractionAirplaneOnGroundArduino(q);
transform.rotation = q;
Debug .Log ("avionul poate decola dar unghiul pitch -yaw nu e valabil" );
break ;
}
default :
break ;
}
throttle = throtlePot/ 10f;
if (throttle != avion.Throttle)
{
tempTime = 0f;
avion.Time = 0;
}
avion.setThrottle(throttle);
}
void Update () {
StreamRead = threadInfo.GetStreamRead;
Debug .Log(threadInfo.GetStreamRead);
threadInfo.SetAvionVelocity = avion.Velocity.To String ("F1" );
int angleofRotation = (int)Vector3 .Angle (aripaUnghi, transform.forward.normalized);
Cl = avion.anglePower(angleofRotation);
}
Quaternion tractionAirplane( Quaternion q) {
if(Input .GetKey( KeyCode .D)) {
69
Quaternion qx = Quaternion .AngleAxis(angle * Time .deltaTime , transform.forward);
q = qx * q;
}
if(Input .GetKey( KeyCode .A)) {
Quaternion qx = Quaternion .AngleAxis(angle * Time .deltaTime , -transform.for ward);
q = qx * q;
}
if(Input .GetKey( KeyCode .S)) {
Quaternion qx = Quaternion .AngleAxis(angle * Time .deltaTime , transform.right);
q = qx * q;
}
if(Input .GetKey( KeyCode .W)) { Quaternion qx = Quaternion .AngleAxis(angle * Time .deltaTime , –
transform.right);
q = qx * q;
}
return q;
}
Quaternion tractionAirplaneOnGround( Quaternion q) {
if(Input .GetKey( KeyCode .D)) {
Quaternion qx = Quaternion .AngleAxis( 5 * Time .deltaTime , transform.up);
q = qx * q;
}
if(Input .GetKey( KeyCode .A)) {
Quaternion qx = Quaternion .AngleAxis( 5 * Time .deltaTime , -transform.up);
q = qx * q;
}
if((Input .GetKey( KeyCode .S) && stareAvion == 4)) {
Quaternion qx = Quaternion .AngleAxis(angle * Time .deltaTime , transform.right);
q = qx * q;
}
return q;
}
Quaternion tractionAirplaneArduino( Quatern ion q) {
70
Quaternion qx = Quaternion .AngleAxis(anglePot2 * Time .deltaTime , transform.forward.normalized);
q = qx * q;
qx = Quaternion .AngleAxis(anglePot1 * Time .deltaTime , transform.right.normalized);
q = qx * q;
return q;
}
Quaternion tractionAirplaneOnGroundArduino( Quaternion q)
{
Quaternion qx = Quaternion .AngleAxis (anglePot2 * Time .deltaTime, transform.up.normalized);
q = qx * q;
if (stareAvion == 4) {
qx = Quaternion .AngleAxis (anglePot1 * Time .deltaTime, transform.right.normalized);
q = qx * q;
}
return q;
}
float getThrottleValue( float throttle1) {
var d = Input.GetAxis( "Mouse ScrollWheel" );
if (d > 0f && throttle < 1.0f) {
throttle += d;
throttle = float.Parse(throttle.ToString ("F1" ));
}
else if (d < 0f && throttle > 0.0f) {
throttle += d;
71
throttle = float.Parse(throttle.ToString ("F1" ));
}
return throttle;
}
public void getAltitude () {
altitude = transform.position.y;
if (avion.Velocity > 50f) {
vStall = false ;
}
else
{
vStall = true;
}
if (altitude > 1.0f) {
isGrounded = false ;
}
else
{
isGrounded = true;
}
if (!vStall && !isGrounded)
{
stareAvion = 1; //avionul se afla in aer unghiul pitch -yaw e valabil…Default quaternion function
}
else if (vStall && !isGrounded )
{
stareAvion = 2; // avionul se afla in aer dar e in stallspeed
}
else if (vStall && isGrounded)
{
stareAvion = 3; //avionul necesita un thrust mai mare pentru decolare.
}
else if (!vSt all && isGrounded)
72
{
stareAvion = 4; // avionul poate decola dar unghiul pitch -yaw nu e valabil
}
}
void updateAnglesAvion()
{
try {
string [] values = threadInfo.GetStreamRead.Split ('|');
anglePot1 = (float.Parse(values[ 0]));
anglePot2 = (float.Parse(values[ 1]));
throtlePot = (float.Parse(values[ 2]));
}
catch (System. Exception ex)
{
Debug .Log ("Format problem" + ex.Message);
}
}
public double avionVelocity() { return avion.Velocity;}
public Vector3 avionPositie() { return transform.position;}
public float avionThrottle() { return throttle;}
}
Copyright Notice
© Licențiada.org respectă drepturile de proprietate intelectuală și așteaptă ca toți utilizatorii să facă același lucru. Dacă consideri că un conținut de pe site încalcă drepturile tale de autor, te rugăm să trimiți o notificare DMCA.
Acest articol: INFORMAȚIEI AUTOMATICĂ, ELECTRONICĂ ȘI MECATRONICĂ [627528] (ID: 627528)
Dacă considerați că acest conținut vă încalcă drepturile de autor, vă rugăm să depuneți o cerere pe pagina noastră Copyright Takedown.