Interfata Grafica pentru sisteme robotizate [308589]

FUNDAȚIA PENTRU CULTURĂ ȘI ÎNVĂȚĂMÂNT “IOAN SLAVICI” TIMIȘOARA

UNIVERSITATEA “IOAN SLAVICI” [anonimizat]. [anonimizat]: [anonimizat] 2017 –

FUNDAȚIA PENTRU CULTURĂ ȘI ÎNVĂȚĂMÂNT “IOAN SLAVICI” TIMIȘOARA

UNIVERSITATEA “IOAN SLAVICI” [anonimizat]. [anonimizat]: [anonimizat]

2017

UNIVERSITATEA DIN ORADEA

FACULTATEA de Inginerie Electrică și Tehnologia Informației

DEPARTAMENTUL Calculatoare și tehnologia informației

TEMA _________________

Proiectul de Finalizare a studiilor a student: [anonimizat]________________________

1). Tema proiectului de finalizare a studiilor:_________________________________________

_______________________________________________________________________________

_______________________________________________________________________________

2). Termenul pentru predarea proiectului de diplomă__________________________________

3). Elemente inițiale pentru elaborarea proiectului de finalizare a studiilor ________________

________________________________________________________________________________

4). Conținutul proiectului de finalizare a studiilor :____________________________________

________________________________________________________________________________

________________________________________________________________________________

5). Material grafic:________________________________________________________________

6). Locul de documentare pentru elaborarea proiectului de diplomă:

________________________________________________________________________________

7). Data emiterii temei_____________________________________________________________

Coordonatori științifici

(titlul științific și numele),

REFERAT

PRIVIND PROIECTUL DE DIPLOMĂ

A

ABSOLVENT: [anonimizat] / ABSOLVENT: [anonimizat] : [anonimizat] 2017

Titlul proiectului Interfață Grafică pentru sisteme robotizate

Structura proiectului ………………………………………………………………..

…………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………………………………………………………

Aprecieri asupra conținutului proiectului de DIPLOMĂ (finalizare a studiilor), mod de abordare, complexitate, actualitate, deficiențe

………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………

Aprecieri asupra proiectului (se va menționa: numărul titlurilor bibliografice consultate, frecvența notelor de subsol, calitatea și diversitatea surselor consultate; modul în care absolventul a prelucrat informațiile din surse teoretice)

………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………

(se va menționa: opțional locul de documentare și modul în care absolventul a realizat cercetarea menționându-se contribuția autorului)

………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………

Concluzii (coordonatorul proiectului trebuie să aprecieze valoarea proiectului întocmit, relevanța studiului întreprins, competențele absolventului, rigurozitatea pe parcursul elaborării proiectului, consecvența și seriozitatea de care a dat dovadă absolventul pe parcurs)

……………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………

Redactarea proiectului respectă ………………………………………………….cerințele academice de redactare (părți, capitole, subcapitole, note de subsol și bibliografie).

Consider că proiectul îndeplinește/ nu îndeplinește condițiile pentru susținere în sesiunea de Examen de LICENȚĂ (finalizare a studiilor) din IULIE 2017 și propun acordarea notei ………………

Oradea,

Data Conducător științific

Introducere

Într-o lume modernă care este tot mai automatizată și cererea pentru sisteme robotizate este mare, o problemă din ce în ce mai întalnită este depozitarea produselor finite intr-un mod eficient fără a fi nevoie de personal specializat pentru a menține aceste depozite. În felul acesta costul produsului vândut este mult mai mic, deoarece costurile pentru depozitare sunt considerabil mai mici.

În sprijinul acestei idei lucrarea prezentată este întocmită pentru a ajuta astfel de firme. În lucrare fiind vorba despre un sistem de depozitare robotizat și modular, această soluție fiind ușor adaptată pentru o gamă largă de clienți.

Pe lângă partea tehnică unde este necesară prezența personalului calificat pentru a menține sau pentru a dezvolta, în acest pachet există și o parte ce face legătura între utilizator și sistemul de depozitare.Această interfață trebuie să fie intuitivă pentru a putea fi folosită de personalul non-tehnic dar in același timp să fie o reprezentare reală a sistemului.

Pentru dezvoltrea acestei lucrari a fost folosit ca interfata de programare(IDE) Visual Studio 2012 Express Edition iar ca limbaj de programare C++.

Cap 1 : Noțiuni teoretice: În acest capitol avem detalii teoretice despre cum trebuie dezvoltată o interfață grafică pentru a fi ușor de utilizat, procesul de dezvoltare,conceptele necesare implementarii și o scurtă istorie a dezvoltării interfețelor grafice de-a lungul timpului in felul acesta vom avea o vedere de ansamblu al teoriei despre procedura de dezvoltare și implementare a unei interfețe grafice intr-un sistem automatizat.

Cap 2: Descrierea Sistemului: În acest capitol vom discuta despre generalitățile tuturor subansamblelor sistemului de depozitare pentru a vedea din ce este format și cum este conceput pentru a fi cât mai modular posibil.Acest capitol reprezinta o baza pentru a avea un punct comun de dezvoltare pentru sitemele adicacente si explicarea conceptului unui deposit automatizat.

Cap 3: Generalități GUI : În acest capitol avem descrise puncte generale ale interfeței grafice, modul și mediul de dezvoltare.Tot in acest capitol se explica modul de comunicare a interfeței grafice cu server-ul, acesta fiind un punct cheie pentru asigurarea unei independețe a GUI-ului față de celelete sisteme integrate in unitatea de depozitare robotizată.

Cap 4: Descrierea Interfeței: În acest capitol avem descrise toate opțiunile interfeței grafice precum și modul de implementare al acestora.

Se va detalia toate sub-opțiunile ale interfeței despre rolul lor in ansablu, de asemenea modul de implementare pentru fiecare optiune in parte.

Capitolul 1

Noțiuni teoretice

1.1 Definiție

Graphical User Interface (prescurtat GUI) este un tip de interfață ce permite utilizatorilor să interacționeze cu diferite echipamente electronice prin icoane grafice și indicatori vizuali, în loc de interfața bazată pe text în care comenzile sunt tastate sau este navigat meniul text.GUI-urile au fost introduse ca reacție la interfețele bazate pe comanda (CLI- Command Line Interface) ce obligă comenzile să fie tastate de la tastatură.

Acțiunile într-un GUI sunt executate prin manipularea directă a elementelor grafice. Mai departe de calculatoare,GUI-urile sunt folosite la dispozitive mobile,MP3-Players, dispozitive de jocuri, telefoane inteligente sau industrie.

1.2 Istorie:

1.2.1 Precursori

Precursorul interfețelor grafice a fost inventat de către cercetătorii de la Institutul de Cercetare Stanford, SRI, condus de Douglas Engelbart. Ei au dezvoltat folosirea hiperlinkurilor bazate pe text, manipulate cu un mouse. Conceptul de hiperlinkuri, realizat prin așa-numite „texte active” (care conduc la altă pagină web atunci când sunt „apăsate” cu mouse-ul pe ecran), a fost rafinat și extins și spre elemente grafice, formând astfel interfața primară pentru computerul „Xerox Alto”. Majoritatea interfețelor grafice cu scop general sunt derivate din acest sistem. Ca rezultat, unii numesc această clasă de interfețe „interfața PARC” (PUI).

În 1963 Ivan Sutherland a dezvoltat un dispozitiv de indicare și desenare pe ecran numit sketchpad. Sistemul utiliza un light-pen (un fel de creion electronic care în locul minei de grafit avea în vârf un senzor de lumină) pentru a conduce crearea și manipularea obiectelor din desenele inginerești de pe ecran.

1.2.2 Interfața grafică PARC

Interfața grafică PARC este formată din widget-uri grafice pentru ecran (ferestre, meniuri, butoane rotunde ca la radiourile vechi, cutii de bifat, liste și alte pictograme). Interfața grafică PARC utilizează pe lângă tastatură și un dispozitiv de indicat (mouse).

1.2.3 Evoluție

După PARC, primul computer centrat pe GUI a fost Xerox 8010 Star Information System, în 1981.

Interfețele grafice familiare majorității utilizatorilor de astăzi sunt Microsoft Windows, Mac OS X și interfețele X Windows System. Companiile Apple, IBM și Microsoft au utilizat numeroase idei ale companiei Xerox pentru a dezvolta specificațiile IBM Common User Access care au format baza interfeței grafice care se găsește în Microsoft Windows, IBM OS/2 Presentation Manager, toolkit-ul și managerul de ferestre Motif de la Unix. Aceste idei au dus la interfața din versiunile curente ale sistemelor de operare Windows, Mac OS X și multe medii de desktop pentru sisteme Unix sau de tip Unix.

1.3 Procesul de dezvoltare al Interfețelor de Utilizator:

Dezvoltarea componentelor vizuale și temporare ale unei interfețe grafice este o parte importantă a programării aplicaților software în domeniul interacțiunii om-computer. Scopul este îmbunătățirea eficienței și ușurarea folosirii logicii unui program fiind o disciplină a design-ului numită usability. Metodele de design centrate pe user sunt folosite pentru asigurarea limbajului vizual introdus,croite pentru acțiunile ce trebuie îndeplinite.

Caracteristicile interfeței grafice vizibile ale unei aplicații sunt referite uneori ca Chrome sau GUI( pronunțat gooey).În mod tipic utilizatorii interacționează cu informația prin manipularea vizuală a widget-urilor ce permit interacțiunea aferentă tipului de date ce sunt memorate.Widget-urile unei interfețe grafice bine dezvoltate sunt selectate pentru a ajuta utilizatorul în acțiunile sale de a îndeplini o acțiune în aplicație. Un MCV(model-view-controller) permite o structură flexibilă în care interfața este independentă de funcția aplicație, în felul acesta interfața grafică este ușor de adaptat. Acest lucru permite utilizatorilor să adapteze sau să dezvolte alte fețe ale interfeței și ușurează munca dezvoltatorului de a ajusta interfața pe măsură ce nevoile utilizatorilor se schimbă. O dezvoltare bună a unei interfețe grafice relaționează mai mult cu utilizatorii și mai puțin cu arhitectura sistemului.

Widget-uri mai mari precum ferestrele, furnizează de obicei un cadru pentru prezentarea conținutului principal precum pagini web sau desene. Cele mici acționează în funcție de input-ul utilizatorului.

Un GUI poate fi dezvoltat pentru cerințele unei pieți verticale. Exemple includ bancomate, POS-uri , aplicații pentru restaurante.

Începând cu anii 1990 , telefoanele mobile și sistemele de joc mobile au introdus aplicație specfică GUI-urilor cu touch-screen. Automobilele noi folosesc GUI-uri în sistemul de navigație și multimedia.

(Figura nr. 1.1 procesarea unei acțiuni de la utilizator la GUI )

Interfața grafică este prezentată pe monitorul computerului. Este rezultatul procesării input-ului utilizatorului și a interfeței principale.

1.4 Componente:

Un GUI folosește o combinație de tehnologii și dispozitive pentru a furniza o platformă cu care utilizatorii pot interacționa pentru îndeplinirea sarcinilor dorite.O serie de elemente conforme unui limbaj vizual au evoluat pentru a reprezenta informațiile stocate în calculatoare. Acest lucru ușurează pentru oamenii ce au capacități slabe de a folosi computerele să poată lucra și folosi software-ul calculatorului. Cele mai întâlnite elemente ale unui astfel de GUI sunt ferestrele, meniurile,icoanele.

Stilul WIMP de interacțiune utilizează un dispozitiv de intrare virtuală pentru a reprezenta poziția unui dispozitiv de indicare, cel mai adesea un mouse, și prezintă informații organizate în ferestre și reprezentate cu pictograme. Comenzile disponibile sunt compilate împreună în meniuri și acțiuni sunt efectuate făcând gesturi cu dispozitivul de indicare. Un manager de ferestre facilitează interacțiunile dintre ferestre, aplicații și sistemul windowing. Sistemul windowing gestionează dispozitive hardware, cum ar fi dispozitive de indicare grafica,hardware și poziționarea cursorului.

În calculatoarele personale, toate aceste elemente sunt modelate printr-o metaforă desktop pentru a produce o simulare numita un mediu de desktop, în care afișajul reprezintă un desktop, pe care pot fi plasate documente și dosare de documente, manageri de ferestre și alte tipuri de software se combină pentru a simula mediul desktop cu diferite grade de realism.scw

(Figura nr. 1.2 Straturile unui GUI bazat pe un sistem de operare Windows.)

1.5 Interfețe Post-Wimp:

Dispozitivele mobile mai mici, cum ar fi asistenți personali digitali (PDA-uri) și smartphone-urile folosesc de obicei elementele WIMP cu diferite metafore unificatoare, din cauza constrângerilor în spațiu și dispozitivelor de intrare disponibile. Aplicatile pentru care WIMP nu este potrivit pot utiliza tehnici de interacțiune mai noi, denumite în mod colectiv interfețe utilizator post-WIMP.

Din 2011, unele sisteme de operare bazate pe touchscreen, cum ar fi Apple iOS (iPhone) și Android folosesc clasa GUI numit post-WIMP. Aceste stiluri de suport de interacțiune folosesc mai mult un deget în contact cu un ecran, care permit acțiuni cum ar fi ciupit și rotirea, care nu sunt suportate de un pointer și mouse.

1.6 Interacțiunea:

Dispozitivele Interfață-Umană folosesc pentru interacțiunea eficientă cu o interfață grafică o tastatură de calculator, în special utilizat împreună cu comenzi rapide de la tastatură, dispozitive de indicare a cursorului (sau mai degrabă indicatorul) de control: mouse-ul, arătând stick-ul, touchpad-ul, trackball, joystick, tastaturi virtuale, și display head-up (informații despre dispozitivele translucide, la nivelul ochilor).

Există, de asemenea, acțiunile realizate de programe care afectează GUI-ul. De exemplu, există componente, cum ar fi Inotify sau D-Bus pentru a facilita comunicarea între programe de calculator.

1.7 Interfețe grafice tridimensioanle

Pentru afișajele tipice ale computerului, tridimensionalul este un nume greșit – afișajele sunt bidimensionale. Semantic, cu toate acestea, cele mai multe interfețe grafice de utilizator folosesc trei dimensiuni. Cu înălțimea și lățimea, ele oferă o a treia dimensiune a elementelor de stratificare sau de stivuire unul peste celălalt. Aceasta poate fi reprezentată vizual pe ecran printr-un efect transparent iluzoriu, care oferă avantajul că informațiile din ferestrele de fundal pot fi citite, dacă nu sunt interacționate. Sau mediul poate pur și simplu să ascundă informația de fundal, făcând posibilă distincția aparentă prin desenarea unui efect de umbră asupra ei.

Unele medii folosesc metodele de grafică 3D pentru proiectarea obiectelor virtuale tridimensionale ale interfeței utilizator pe ecran. Acestea sunt adesea folosite în filme science fiction. Pe măsură ce crește puterea de procesare a hardware-ului pentru calculatoare, acest lucru devine mai puțin un obstacol în calea unei experiențe netede a utilizatorului.

Grafica tridimensională este utilizată în principal în jocuri pe calculator, artă și proiectare asistată de calculator (CAD). Un mediu de calcul tridimensional poate fi de asemenea util în alte utilizări, cum ar fi grafica moleculară și proiectarea aeronavelor.

Au fost făcute mai multe încercări de a crea un mediu tridimensional pentru mai mulți utilizatori, inclusiv proiectul Croquet și proiectul Sun Looking Glass.

Utilizarea graficelor tridimensionale a devenit din ce în ce mai frecventă în sistemele de operare obișnuite, de la crearea unor interfețe atractive, numite bomboane pentru ochi, în scopuri funcționale, posibile doar prin utilizarea a trei dimensiuni. De exemplu, comutarea utilizatorilor este reprezentată prin rotirea unui cub care se confruntă cu spațiul de lucru al fiecărui utilizator, iar gestionarea ferestrelor este reprezentată printr-un mecanism de răsturnare în stilul Rolodex în Windows Vista. În ambele cazuri, sistemul de operare transformă fereastra continuând să actualizeze conținutul acestoar.

Interfețele pentru sistemul X Window au implementat, de asemenea, interfețe avansate tridimensionale pentru utilizatori prin compilarea managerilor de ferestre, cum ar fi Beryl, Compiz și KWin, utilizând arhitecturile AIGLX sau XGL, permițând utilizarea OpenGL pentru a anima interacțiunile utilizatorilor cu desktopul.

O altă ramură în mediul de lucru tridimensional este desktop-urile tridimensionale care iau metafora desktop-ului un pas mai departe, cum ar fi BumpTop, unde utilizatorii pot manipula documente și ferestre ca și cum ar fi documente fizice, cu mișcări realiste și fizică.

Interfața de utilizare cu zoom (ZUI) este o tehnologie conexă care promite să livreze avantajele de reprezentare a mediilor 3D, fără a avea deficiențe de utilizare a problemelor de orientare și de obiecte ascunse. Este un avans logic pe GUI, amestecând o mișcare tridimensională cu obiecte vectoriale bidimensionale sau 2.5D. În 2006, Hillcrest Labs a introdus prima interfață utilizator pentru zoom, pentru televiziune,literatură și filme, înainte ca acestea să fie fezabile din punct de vedere tehnic sau în uz comun.

De exemplu; Filmul american din 1993, Jurassic Park, dispune de un manager de fișiere tridimensionale, File System Navigator, un manager de fișiere din domeniul real-life pentru sistemele de operare Unix. Raportul privind minoritățile filmului are scene ale ofițerilor de poliție care utilizează sisteme de date 3D specializate. În proza ​​ficțiune, interfețele tridimensionale ale utilizatorilor au fost portretizate ca medii imersibile precum Cyberspace-ul lui William Gibson sau Metaverse de la Neal Stephenson. Multe imaginări futuriste ale interfețelor utilizator se bazează în mare măsură pe stilul interfață cu utilizatorul orientat pe obiect (OOUI) și în special pe stilul OOGUI .

Capitolul 2

Descrierea Sistemului

2.1 Sistemul Roverlog

Este un sistem automat de depozitare bazat pe conceptul mărfurilor la persoană. Acesta este conceput pentru a permite stocarea și culegerea de bunuri intr-un mod usor, flexibil și eficient. În sistemul Roverlog automat Roverlogs (vehicule de stocare și recuperare) transportă bunurile solicitate din spațiile de depozitare pentru angajații ce lucrează la Port-uri. Această dispoziție dinamică a mărfurilor este o economie mare de timp.

Sistemul Roverlog este construit conform unui sistem modular. În funcție de spațiul disponibil și spațiul de stocare necesar, componentele de bază pot fi puse împreună în diferite moduri. Acesta este motivul pentru care instalațiile pot arăta diferit. Cu toate acestea, structura, interacțiunea componentelor individuale și conceptul de siguranță sunt întotdeauna aceleași. Structura de bază a sistemului de stocare și componentele sale prezintă următoarele cifre:

(Figura nr. 2.1 Vedere de ansamblu a sistemului de depozitare RoverLog)

(Tabelul nr. 2.1 descrierea generală a sistemului)

În tabelul de mai sus avem descris fiecare subansamblu al unui sistem Roverlog.

2.2 Prezentarea generală a serverului și a rețelei

Sistemul Roverlog este controlat de software-ul de management al depozitului (LVS / WMS). Acesta comunică cu calculatoarele de punere în funcțiune din rețeaua WMS și controlează software-ul sistemului Roverlog. Software-ul de sistem Roverlog, pe de altă parte, controlează porturile de punere în funcțiune și jurnalele Rover prin intermediul rețelei Roverlog de sine stătătoare pentru a îndeplini comenzile.

(Figura nr. 2.2 Reprezentarea infrastructurii RoverLog)

Serviciul de servere rulează în fundal și controlează toate componentele sistemului. Setările pot fi efectuate prin interfața grafică.

Starea serviciului poate fi extrasă din GUI, în plus, o consolă este afișată pe serverul fizic, în care sunt afișate ieșirile de jurnal ale sistemului. Serviciile sunt dezvoltate in limbaj C++ iar baza de date este MySQL.

(Figura nr. 2.3 Consola aplicației server-ului.)

Serverul Roverlog în cabinetul principal sau în funcție de condițiile locale sunt, de asemenea, disponibile într-o cameră de server dedicată. În mod similar, integrarea în zona de întreținere este posibilă. La locul de instalare, în orice caz, cerințele tehnice trebuie îndeplinite.

Instrucțiuni de instalare pentru Roverlog Server:

• Trebuie să existe o conexiune de rețea la cabinetul principal.

• Trebuie să fie configurată o soluție de rezervă pentru baza de date.

• Recomandat este o sursă independentă de alimentare care oprită în mod adecvat în caz de pană de curent a serverului, protejând astfel bazele de date.

2.3 Consola de control

De asemenea, naveta poate fi acționată manual pe raft utilizând o consolă de control. Controlul automat de către sistemul de gestionare a depozitului este apoi suspendat temporar. Consola de control este utilizată pentru a verifica funcțiile de transfer sau pentru sarcini care pot fi efectuate numai cu control manual, de exemplu, sarcini de inspecție cu echipament extins sau pentru a corecta pozițiile rezervorului de depozitare.

Consola de control face parte din programul de control al stocării, care este necesar pentru activități de întreținere și control pe un calculator din zona de întreținere.

Capitolul 3

Descrierea Generală a Interfeței

RoverLog GUI

GUI (Graphical User Interface) este principalul instrument pentru interacțiunea utilizatorului cu sistemul de stocare.

Sistemul este dezvoltat în Visual C++ folosind Visual Studio 2012,iar culoarea și animațiile sunt dezvoltate cu ajutorul OpenGL si Blender.

Acesta are două scopuri principale:

1 Simulare în timp real a sistemului de stocare.

GUI-ul oferă utilizatorului o reprezentare 3D a sistemului de stocare fizic. Aceasta face o simulare animată în timp real a componentelor sistemului: roboți, cutii, coșuri, șine, porturi, zona de mentenanță.

Display-ul de stocare în GUI este extrem de personalizabil.

Utilizatorul poate seta manual orice punct de vedere. Pornind de la o afișare implicită, utilizatorul poate viziona practic sistemul din orice poziție atât în ​​afară cât și în interiorul zonei de depozitare.

De asemenea, utilizatorul este capabil să schimbe componentele sistemului în simulare care sunt afișate.

2 Gestionarea setărilor,controalelor serverului și ale roboților.

GUI-ul, de asemenea, este instrumentul care permite utilizatorului să opereze cu sistemul de stocare. Următoarele operațiuni pot fi efectuate prin GUI de către utilizator: setarea modului de operare pentru servere, controlul manual al robotului, controalele de siguranță, operațiunile de întreținere, de recuperare de la erori.

Mai multe puncte de vedere incluse în GUI va permite utilizatorului să seteze sau să verifice configurația sistemului: setările de conexiune la baze de date, vizualizarea tabelelor bazei de date și ecranul de configurare a serverului.

3.1 Generarea mediului:

Mediul animat al interfeței este format din mai multe clase de obiecte pentru a avea un ambient cât mai realist și cat mai aproape de actiunea ce se petrece in timp real in sistemul de depozitare.

3.1.1 Roboți :

Roboții sunt tratați ca o clasă ce poate fi instanțiată de câte ori avem nevoie, fiecare prin inițializarea numărului necesar de roboți configurați, acesta fiind citit din fișierul de configurare RoverLogConfig.ini .

In felul acesta clientul poate adauga sau reduce numarul de roboți în funcție de necesitățile sale pentru a face față volumului de comenzi sau de lucru pe care aceștia trebuie sa le îndeplineasca.

void Initialize()

{

//1.1) Robot bodies

bodies = new GraphicsTexObj(0);

ObjLoader::LoadModel(bodies, "models//robotBody.obj", scale);

bodies->texture = CGraphicsBase::LoadBmpTexture("textures//ironTexture3.bmp",

TransparencyMode::TRANSP_TLC, 255);

//1.2) Robot wheels

wheels = new GraphicsTexObj(0);

ObjLoader::LoadModel(wheels, "models//robotWheel.obj", scale);

wheels->texture = CGraphicsBase::LoadBmpTexture("textures//simpleWheel.bmp",

TransparencyMode::TRANSP_TLC, 255);

#if 1

//1.3) Robot wheels Supports

wheelsSup = new GraphicsTexObj(0);

ObjLoader::LoadModel(wheelsSup, "models//robotWheelSup2.obj", scale);

wheelsSup->texture = CGraphicsBase::LoadBmpTexture("textures//ironTextureWS.bmp",

TransparencyMode::TRANSP_ALL, 0);

#endif

}

//###################################################################################

void CreateInstances()

{

bodies->CreateInstances(robotData->robotNum);

wheels->CreateInstances(robotData->robotNum * 4);

wheelsSup->CreateInstances(robotData->robotNum * 4);

}

//###################################################################################

Din funcțiile de mai sus se poate observa cum se instanțiează un robot care este format dintr-un corp(bodies) , patru roți(wheels) și patru suporturi de roți(wheelsSup).

Toate aceste subansamble sunt încărcate în memoria alocată și formează un robot.Roboții sunt folosiți în soluție printr-un pointer către fiecare instanțiere.Modelele subansamblelor sunt obiecte desenate în programul de design Blender și salvate ca fișiere de tip .obj, în felul acesta se pot incărca in interfață.

3.1.2 Spațiul de lucru:

Pentru a crea spațiul de lucru sau harta zonei de depozitare, se vor încarcă datele dintr-un fișier de tip .CSV pentru a lua informațiile necesare creării spațiului aferent. Acest fișier este declarat în fișierul de configurare al aplicației.

void LoadCsvFile(const char *csvFileName)

{

std::ifstream data(csvFileName);

std::string line;

int curWidth = 0;

int x, y;

nPassableCells = 0;

width = 0; //actual width of current cellCode, make it zero, will increase…

bakCellInfo.clear(); //annul all previous backups

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//1) First, get cellCode width and height by scanning the max line

height = 0;

while(std::getline(data,line))

{

curWidth = 0;

height++;

std::stringstream lineStream(line);

std::string cell;

while(std::getline(lineStream,cell,','))

{

// You have a cell!!!!

curWidth++;

}

if(curWidth >= width)

width = curWidth;

}

//CRITICAL: EOF reached, must clear stream

data.clear();

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//2) Can allocate storage now

if(cellCode) delete [] cellCode;

if(dbFlags) delete [] dbFlags;

if(cellColor) delete [] cellColor;

if(stackBarPos) delete [] stackBarPos;

cellCode = new char [ width * height];

dbFlags = new uint16_t[ width * height];

cellColor = new Vec4 [ width * height];

stackBarPos = new Vec3 [(width+1) * (height+1)]; //alloc for worst case scenario

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//3) Read the cells

data.seekg(0); //rewind file

y=0;

while(std::getline(data,line))

{

std::stringstream lineStream(line);

std::string cell;

for(x=0; x<width; x++)

{

std::getline(lineStream,cell,',');

// You have a cell !!!

if(cell.size())

{

cellCode [y*width+x] = cell.at(0); //get first char !

cellColor[y*width+x] = GetCellColor(cellCode [y*width+x]);

dbFlags [y*width+x] = 0 ;//gets filled later…

//Look for center map marker (optional)

if(cell.find("(0)") != std::string::npos){

oX = x;

oY = y;

}

//If not wall, will have power rails (TBD add a method here)

if(cellCode[y*width+x] != 'W')

nPassableCells++;

}

else {

//if missing data, assume WALL

cellCode[y*width+x] = 'W';

}

}

y++;//moving to next line

}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

ComputeStackBarPos();

SaveCsvFile("dbgLoadedMap.csv");

}

În funcția de mai sus se citește fișierul (care este primit ca parametru de intrare al funcției) și este citit intr-o buclă iar în funcție de ce caractere avem in fișierul .CSV se va instanția tipul de celulă aferent.

3.1.3 Camera:

Una dintre cele mai importante propietăti este transpunerea informațiilor pentru a fi folosite de utilizator, acest lucru este îndeplinit cu clasa Camera.

void CCamera::Look(const Vec3 &Position, const Vec3 &Reference, bool RotateAroundReference)

{

this->Position = Position;

this->Reference = Reference;

Z = normalize(Position – Reference);

X = normalize(Cross(Vec3(0.0f, 1.0f, 0.0f), Z));

Y = Cross(Z, X);

if(!RotateAroundReference)

{

this->Reference = this->Position;

this->Position += Z * 0.05f;

}

CalculateViewMatrix();

}

//############################################################################

Cum se vede în funcția de mai sus,pentru a interpola imaginea este nevoie de valori de tip vectoriale pentru a calcula pe cele trei axe poziția camerei fața de obiectul vizualizat.

3.2 Descrierea ansablelor periferice :

Interfata grafică comunică cu server-ul principal prin doua metode: printr-un socket deschis prin intermediul rețelei de internet locală și prin baza de date MySQL cu tabele aferente.

3.2.1 Comunicarea prin socket:

Pentru a trimte comenzi de la GUI la server și invers este folosit un socket deschis prin intermediul rețelei de internet.

IP-urile celor doi participanți la comunicare fiind citite din fișierul de configurare RoverLog.ini.

public ref class RlsSocket

{

public: Socket * sc;

private: BackgroundWorker ^ bgWorker; //for (re)connection process

private: const char * srvIp;

private: const char * srvPort;

public : bool connectedEvent;

//##################################################################################

public: RlsSocket(const char *serverIp, const char *serverPort)

{

sc = new Socket();

this->srvIp = serverIp;

this->srvPort = serverPort;

this->connectedEvent = false;

bgWorker = gcnew BackgroundWorker();

bgWorker->DoWork += gcnew DoWorkEventHandler (this, &RlsSocket::DoWork );

bgWorker->RunWorkerCompleted += gcnew RunWorkerCompletedEventHandler(this, &RlsSocket::RunWorkerCompleted);

}

//################################################################################

//Socket connection to Server moved here, so I can scan incomming messages

//else the connection is only valid when RobotCtrlForm was opened

rvsGuiConn   = gcnew RlsSocket(cfgReader->getRoverLogSrvIp(),

cfgReader->getRoverLogSrvGuiPort());

Funcția de mai sus este apelata la inițializarea aplicației si in felul acesta se creeaza o plaforma de comunicare intre server si GUI.

Aceasta fiind folosita la trimiterea si primirea de comenzi.

3.2.2 Comunicarea prin baza de date:

Un alt mod de comunicare construit intre server si GUI este prin baza de date MySQL.

Prin aceasta metoda sunt citite anumite valori intr-un mod ciclic in care server-ul va scrie in baza de date iar GUI-ul va citi valoarea respective pentru a fi afisata.

Poziția robot-ului este citită prin această metodă dupa cum se observa in functia de ma jos.

public: //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

DbRobotFdbk(String ^conString, RobotData *rData): DbBase(conString)

{

robotData = rData;

}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#define EN_FILE_LOG 0

void Update()

{

//basic checks, anyway, try-catch is the key here

if(connected)

{

/*DBG*/#if(EN_FILE_LOG)

/*DBG*/FILE *f = fopen("GUI_ROBOT_STATUS.txt", "wb");

/*DBG*/#endif

if(nullptr == myConnection)

return;

MySqlDataReader^ myReader;

MySqlCommand^ queryStmt;

try

{

int rowCount = 0;

int ip;

uint64_t curBinFullId; //64bit ID form DB

//Select proper table (could move in init ?)

MySqlCommand^ mysqlCmd = gcnew MySqlCommand("USE RoverLog", myConnection);

mysqlCmd->ExecuteNonQuery();

//Query

queryStmt = gcnew MySqlCommand("SELECT Ip, PositionX, PositionY, PositionWheels, CurrentBinID, Weight, Action, ActionSeqNo, ActionParam, LastAction, BaterryStatus, Status, ErrCode FROM RobotFeedback", myConnection);

myReader = queryStmt->ExecuteReader();

//stupid sql-data-reader doesn't have a row-count property, so incrementing counter

while(myReader->Read())

{

//String^ msg = "ID=" + myReader->GetInt32(0) + " Value=" + myReader->GetInt32(1);

//MessageBox::Show(msg);

ip = myReader->GetInt16(0);

robotData->robotFdbk[ip].xPosition = myReader->GetInt16(1);

robotData->robotFdbk[ip].yPosition = myReader->GetInt16(2);

robotData->robotFdbk[ip].wheelsPosition = myReader->GetInt16(3);

curBinFullId = myReader->GetInt64(4);

robotData->robotFdbk[ip].currentBinIdLo = (curBinFullId ) & 0xFFFFFFFFLL;

robotData->robotFdbk[ip].currentBinIdHi = (curBinFullId >> 32 ) & 0xFFFFFFFFLL;

robotData->robotFdbk[ip].Weight = myReader->GetInt16( 5);

robotData->robotFdbk[ip].executingAction = myReader->GetInt16( 6);

robotData->robotFdbk[ip].seqNo = myReader->GetInt32( 7);

robotData->robotFdbk[ip].actionParam = myReader->GetInt32( 8);

robotData->robotFdbk[ip].lastExecutedAction = myReader->GetInt16( 9);

robotData->robotFdbk[ip].voltageStatus = myReader->GetInt16(10);

robotData->robotFdbk[ip].Status = myReader->GetInt16(11);

robotData->robotFdbk[ip].errorCode = myReader->GetInt32(12);

/*DBG*/#if(EN_FILE_LOG)

/*DBG*/ fprintf(f, "IP = %d (x=%d, y=%d)\n", ip, gRobotFdbk[ip].xPosition, gRobotFdbk[ip].yPosition); //debug

/*DBG*/#endif

rowCount++;

}

myReader->Close();

robotData->robotNum = rowCount;

//after 1st valid query, init robot drawing pos

if(robotData->feedbackValid == false){

robotData->InitDrawPositions();

//If this is the 1st feedback ever received, then init lastSeqNo to be seqNo

//current command executed by robot (if any) will not be animated in GUI

for(ip=1; ip<=robotData->robotNum; ip++)

robotData->lastSeqNo[ip] = robotData->robotFdbk[ip].seqNo;

robotData->feedbackValid = true;

}

/*DBG*/#if(EN_FILE_LOG)

/*DBG*/ fclose(f);

/*DBG*/#endif

}

catch(Exception^ ex)

{

// if any error occurred, abandon current update step !

// MessageBox::Show(ex->Message);

errMsg = ex->Message;

connected = false;

}

//TBD: all went well, commit new positions !

}//if(connected)

}

};

Această funcție este apelata de câte ori avem nevoie pentru a vedea poziția robotului sau alte informatii legate de acesta.

În acelaș mod se face si creearea traseului pe care robotul il va parcurge.

public: void Update()

{

//basic checks, anyway, try-catch is the key here

if(connected)

{

if(nullptr == myConnection)

return;

//Before coloring the cells based on robotPaths info,

//restore previous frame true cell colors before alteration

fMap->UndoPreviousPathColouring();

MySqlDataReader^ myReader;

MySqlCommand^ queryStmt;

try

{

int x,y;

uint16_t flags;

//Select proper table (could move in init ?)

MySqlCommand^ mysqlCmd = gcnew MySqlCommand("USE RoverLog", myConnection);

mysqlCmd->ExecuteNonQuery();

//Cleanup: remove leftover flag-less cells

mysqlCmd->CommandText = "DELETE FROM RobotPaths WHERE ColorIdx = 0";

mysqlCmd->ExecuteNonQuery();

//Clear old data before reading new:

memset(fMap->dbFlags, 0, sizeof(fMap->dbFlags[0]) * fMap->width * fMap->height);

//Query

queryStmt = gcnew MySqlCommand("SELECT * FROM RobotPaths", myConnection);

myReader = queryStmt->ExecuteReader();

//stupid sql-data-reader doesn't have a row-count property, so incrementing counter

while(myReader->Read())

{

x = myReader->GetInt16(0) + fMap->oX; //PositionX

y = myReader->GetInt16(1) + fMap->oY; //PositionY

flags = myReader->GetInt16(2); //ColorIdx

//Safety check: make sure coords are within map boundaries

if((y<fMap->height) && (x<fMap->width))

{

fMap->BackupCellColor(x, y); //backup original color before setting new one

fMap->cellColor [y*fMap->width+x] = getColorMapping(flags, fMap->cellCode[y*fMap->width+x]);

fMap->dbFlags [y*fMap->width+x] = flags;

}

}

myReader->Close();

}

catch(Exception^ ex)

{

// if any error occurred, abandon current update step !

// MessageBox::Show(ex->Message);

errMsg = ex->Message;

connected = false;

}

}//if(connected)

}

Celula citită din baza de date va fi setată ca traseu și va fi colorata in verde pentru a reprezenta culoarul pe care robotul îl va parcurge către destinația lui. Pe masaură ce robotul va parcurge traseul designat de server celula de culoare verde de care acesta a trecut nu va mai fi rezervata si va reveni la culoarea precedent.Culoarea rămânand verde pana la ajungerea la destianție a robotului.

Dupa cum se vede in funcțiile de mai sus se citesc valoriile prin baza de date MySQL si se evită scrierea de catre GUI in aceasta. In felul acesta menținând independența interfeței fața de server-ul sistemului.

Capitolul 4

Descrierea Interfeței

4.1 Forma Principală

(Figura nr. 4.1 Vederea din față a GUI-ului)

În imaginea de mai sus avem vederea din față a GUI-ului,în mijloc putem vedea unitatea cu elementele sale iar în părțile laterale informații generale ale sistemului activ.

Ea este construită dintr-un Maine Windows Form si din doua paneluri.Una în care vedem animațiile in timp real ale sistemului de depozitare, iar în ce de-a doua se află debug-log-ul care este optional. In acest Windows Form sunt adăugate pentru vizualizarea stărilor sistemelor periferice în timp real un ToolStrip care are un timer alocat pentru fiecare status,acestea citind ciclic starea lor prin diferite metode .

Debug-Log-ul este construit cu ajutorul unui Rich Text Box în interiorul căreia serverul va trimite anumite loguri necesare pentru a putea fi vizualizate de către utilizator pentru a face verificarea in timp real a acțiunilor server-ului.

Meniul superior este construit cu ajutorul unui ToolStrip cu mai multe sub-opțiuni,pentru descrierea meniului avem tabelul cu numerele aferente:

(Tabelul nr. 4.1 Descrierea butoanelor formei de control a roboților)

4.2 File menu

(Figura nr. 4.2 Vederea tabelei File )

În meniul de fișier găsiți intrarea cu ajutorul căreia se poate ieși și închide GUI-ul.

Comanda rapidă pentru ieșire este Ctrl + X.

La declanșarea acestei opțiuni pornește event-ul de exit descris în cod mai jos care oprește într-un mod echilibrat toate funcțiile generale și iese din aplicație.

private: System::Void exitToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)

{

SaveUserPreferences();

StopRenderThread();

Application::Exit();

}

4.3 Edit Menu

(Figura nr. 4.3 Vedera tabelei de editare)

Tabela Edit contine mai multe sub-optiuni:

4.3.1: Options

Forma Options este formată din două Tab-uri dar același header OptionsForm.h în care avem clasa pentru conexiunea la baza de date MySQL iar noi o inițializăm printr-un pointer ce conține string-ul cu informațiile necesare creării unei conexiuni active la baza de date MySQL.

MySqlConnection^ myConnection;

BuildConnectionString(); //update conn string from controls

myConnection = gcnew MySqlConnection(dbConnectionString);

(Figura nr. 4.3.1 Vederea opțiunilor MySQL)

Data Soruce: Addresa IP a mașinii unde baza de date este localizată.

User Name: Identificarea utilizatorului bazei de date.

Password: Parola pentru conectarea la baza de date.

Port: Portul prin care server-ul se conectează la baza de date.

Database: Numele bazei de date.

Check Connection: Daca butonul este apăsat se va verifica conexiunea cu baza de date MySQL

(Figura nr. 4.3.2 Rezultatul unei acțiuni Check Connection)

Save: Salvează modificările făcute.

(Figura nr. 4.3.3 Vederea opțiunilor RoverLogServer cu IP-urile configurate)

Robot Subnet Addres : Adresa subnet a robotului.

roverLog Server : Adresa IP a Serverului

roverLog Gui Port : Adresa Ip a GUI-uli.

RoverLog Robot Port : Adresa IP a port-ului.

In acest tab putem vedea doar informațiile în cauză fără a le putea schimba.Funcția de citire a valorilor necesare din fișierul de configurare al aplicației este descrisă în funcția de mai jos.

//Update controls (Read-only mode really) with data from .ini file

public: System::Void UpdateControls(ConfigReader *cfg)

{

dbTextBoxServer->Text = gcnew String(cfg->szDbDataSource);

dbTextBoxDatabase->Text = gcnew String(cfg->szDbName);

dbTextBoxUser->Text = gcnew String(cfg->szDbUser);

dbTextBoxPort->Text = gcnew String(cfg->szDbPort);

dbTextBoxPass->Text = gcnew String(cfg->szDbPass);

rvsTextBoxRobotSubnet->Text = gcnew String(cfg->szRobotSubnet);

rvsIP->Text = gcnew String(cfg->szRoverLogSrvIP);

rvsGuiPort->Text = gcnew String(cfg->roverLogSrvGuiPort);

rvsRobotPort->Text = gcnew String(cfg->roverLogSrvRobotPort);

}

4.4 Robot Manual Control

(Figura nr. 4.4 Vederea formei de control a roboților)

Opțiunea de mai sus este construită ca un Windows Form fiind dezvoltată în RobotControlForm.h. În formă sunt incluse mai multe Goup Box-uri cu butoane și acțiunile aferente. Fiind astfel ordonate, este mult mai ușor pentru editare și control în cod.

Utilizatorul are drepturi restricționate în funcție de modul în care se află robotul sau dacă robotul este în cursul unei acțiuni. Acest lucru este realizat prin dezactivarea sau activarea butoanelor pentru fiecare caz în parte.În felul acesta se pot elimina erori precum trimiterea aceleași comenzi de două ori din greșeala,care pot determina comportamente neașteptate prin generarea unui thread de două ori.

(Tabelul nr. 4.4 Descrierea butoanelor Robot Control Form)

4.5 Port Control

(Figura nr. 4.5 Vederea formei de control a port-ului)

Controlul Port-ului este un Windows Form cu ajutorul căruia se poate interacționa cu port-ul unității de depozitare.

Port No: Se selectează numărul port-ului cu care dorim să interacționăm.

Open : Se deschide port-ul pentru a primi comenzi de la sistemul extern VMS.

Close : Se închide port-ul. Comenzile nu vor mai fi procesate.

Fiecare dintre acțiuni trimite ca o comandă la Server-ul principal al aplicației numărul port-ului și acțiunea dorită, adică de deschidere a port-ului sau închiderea acestuia.

4.6 Server Commands

(Figura nr. 4.6 Vederea formei de control a server-ului RoverLog)

Forma ServerCommands.h este o formă ce poate trimite comenzi la Server-ul principal pentru a seta modurile server-ului .

Dupa cum se vede în imagine accesul la butoane este restricționat pentru utilizator.Dacă server-ul se află într-un mod butonul se va dezactiva. Acest lucru este făcut pentru a evita trimiterea aceleiași comenzi de două ori ca să nu pornească același thread de două ori și să avem comportamente neașteptate sau erori și pentru a restricționa accesul utilizatorului.

Reload Server DB : Va reîncărca baza de date MySQL.

Set Manual Mode : Va seta server-ul în modul manual.

Set Planner Mode : Va seta server-ul în modul planner.

Open Door: Va deschide ușa de siguranță.

Close Door : Va închide ușa de siguranță.

Fiecare comandă este trimisă la server cu ajutorul unei structuri definite și prin socket-ul deschis prin rețea după cum se vede în exemplul de mai jos.

public: System::Void btnSetPlannerMode_Click(System::Object^ sender, System::EventArgs^ e) {

userToRvsCmd->cmdCode = PLANNER_MODE;

userToRvsCmd->robotCmd = 0;//UNUSED

userToRvsCmd->param = 0;//UNUSED

userToRvsCmd->robotCmdParam = 0;//UNUSED

int status;

status = rvsGuiConn->sc->Send((const char *)userToRvsCmd, sizeof(RoverLogSrvCmd));

errCheck(status);

Sleep(500);

4.7 Pagina View

(Figura nr. 4.7 Opțiunea View)

În această pagină avem structurate toate opțiunile de vizionare posibile utilizatorului.

4.7.1 DataBase View

Este o sub-opțiune prin care putem vedea anumite tabele din baza de date MySQL.

//Query

queryStmt = gcnew MySqlCommand("SELECT * FROM Ports ORDER BY PortID", dbConn->myConnection);

myReader = queryStmt->ExecuteReader();

//Populate table…

row = 0;

while(myReader->Read())

{

//add rows progresivelly to table if locations don't already exist

if(this->dataGridPortView->Rows->Count < (row+1))

dataGridPortView->Rows->Add();

////Port ID

this->dataGridPortView->Rows[row]->Cells[0]->Value=myReader->GetInt32( 0); //PortID

this->dataGridPortView->Rows[row]->Cells[1]->Value=myReader->GetInt32( 1); //Type

this->dataGridPortView->Rows[row]->Cells[2]->Value=myReader->GetInt32( 2); //Mode

this->dataGridPortView->Rows[row]->Cells[3]->Value=myReader->GetInt32( 3); //Available

this->dataGridPortView->Rows[row]->Cells[4]->Value=myReader->GetInt32( 4); //PosX

this->dataGridPortView->Rows[row]->Cells[5]->Value=myReader->GetInt32( 5); //PosY

this->dataGridPortView->Rows[row]->Cells[6]->Value=myReader->GetString( 6); //ReqTime

#if 0 //hex display

this->dataGridPortView->Rows[row]->Cells[0]->Value=Convert::ToString(Int64(myReader->GetInt64( 0)), 8);

#else //dec display

this->dataGridPortView->Rows[row]->Cells[7]->Value = Convert::ToString(Int64(myReader->GetInt64( 7)), 10); //SelBin

#endif

this->dataGridPortView->Rows[row]->Cells[8]->Value = myReader->GetInt32( 8); //SelTask

this->dataGridPortView->Rows[row]->Cells[9]->Value = myReader->GetInt32( 9); //SelTg

this->dataGridPortView->Rows[row]->Cells[10]->Value=myReader->GetInt32( 10); //SelShip

if(row > 150)

break;

}

myReader->Close();

}

//Catch all types of exceptions to avoid crashes !

//catch(MySqlException^ ex)

catch(Exception^ ex)

{

dbConn->connected = false;

dbConn->errMsg = ex->Message;

MessageBox::Show(ex->Message);

dataGridPortView->ForeColor = Color::Red;

}

Pentru desenarea temporizatorului se apleaza funcția următoare prin care se animează.

//Write in title bar a spinning bar to indicate refresh

private: System::Void ShowUpdateProgress()

{

static int progressIdx = 0;

static char progressChar[] = {'-', '\\' , '|' , '/'};

if(languageValue == EN){

this->Text = "DatabaseViewForm " + gcnew Char(progressChar[progressIdx]);

}

else if(languageValue == DE){

this->Text = "Datenbank " + gcnew Char(progressChar[progressIdx]);

}

progressIdx++;

if(progressIdx > 3)

progressIdx = 0;

}

4.7.2 FloorPlan View

(Figura nr. 4.7.2 Vederea spațiului de depozitare configurat)

În această filă avem informațiile legate de planul depozitului.

În secțiunea legendă, avem toate tipurile de celule și culorile posibile ce sunt folosite în proiect.

4.7.3 Danger Zone

(Figura nr. 4.7.3 Vederea cu celule setate ca periculoase)

În această secțiune se poate adăuga o zona de pericol manual. Această opțiune poate fi folosită în cazul în care avem o defecțiune într-o anumită regiune și vrem ca roboții să nu activeze acolo.

4.7.4 Shipping Limits:

(Figura nr. 4.7.4 Vederea stivelor cu activitate limitată)

În această secțiune se pot pune limite pe anumite celule în care robotul să nu scoată sau să adauge cutii. Acest lucru se poate în cazul în care avem o defecțiune sau vrem să rezervăm stocul.

Toate cele trei opțiuni descrise mai sus (FloorPlan , DangerZone, ShippingLimits) sunt de fapt o singură forma FloorPlan.h . Diferența fiind în momentul în care opțiunea este selectată din MainForm se declanșează un case pentru fiecare tip.

switch(ctx){

case FLOORPLAN : what = 0; break;

case DNGR_EDIT : what = CF_DANGER_A|CF_DANGER_M; break;

case SHIP_EDIT : what = CF_SHIP_OFF|CF_SHIP_OUT; break;

4.7.5 Scene Mode

(Figura nr. 4.7.5 Vederea tabelei de Scene Mode)

În modul scenă avem 3 opțiuni de vizionare a camerelor dintre care putem alege:

3D side:

(Figura nr. 4.7.5.1 Vedere 3D laterală)

3D top:

(Figura nr. 4.7.5.2 Vedere 3D de sus)

2D Top:

(Figura nr. 4.7.5.3 Vedere 2D de sus)

4.7.6 Camera Options

(Figura nr. 4.7.6 Vederea opțiunilor de cameră)

(Tabela nr. 4.7.6 Descrierea opțiunilor camerei View)

4.8 Options Menu

(Figura nr. 4.8 Vederea tabelei Options)

În această filă sunt structurate toate opțiunile extra ce pot fi folosite de a adăuga sau scoate din GUI.

4.9 Antialiasing

Este opțiunea ce activează sau dezactivează procedura de antialiasis al animației.

private: System::Void toolStripMenuAntialiasing_Click(System::Object^ sender, System::EventArgs^ e)

{

graphics->enAntiAliasing = !graphics->enAntiAliasing; //toggle flag

toolStripMenuAntialiasing->Checked = graphics->enAntiAliasing;

}

Antialiasingul este o tehnică software pentru diminuarea jaggilor – liniilor de tip stairstep care ar trebui să fie netede. Jaggiile apar deoarece dispozitivul de ieșire, monitorul sau imprimanta nu are o rezoluție suficient de mare pentru a reprezenta o linie netedă. Antialiasing reduce preeminența jaggilor prin înconjurarea treptelor cu nuanțe intermediare de gri (pentru dispozitivele de scalare gri) sau de culoare (pentru dispozitivele color).

4.10 Smooth robot movement

Comută între afișarea continuă și discretă a mișcării robotului.

private: System::Void smoothRobotMovementToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)

{

robotData->interpolateRobotPos = !robotData->interpolateRobotPos;

smoothRobotMovementToolStripMenuItem->Checked = robotData->interpolateRobotPos;

}

4.11 Draw Drive- Rail

Șinele vor fi adăugate la imaginea de ansamblu la activarea opțiunii de catre utlizaror.

(Tabelul nr. 4.11 Conține cele două stări posibile pentru vederea șinelor)

private: System::Void drawDriveRailToolStripMenuItem1_Click(System::Object^ sender, System::EventArgs^ e){

graphics->cellDrawMask ^= CELL_DRAW_DRIVE_RAILS; //toggle

drawDriveRailToolStripMenuItem1->Checked = (graphics->cellDrawMask & CELL_DRAW_DRIVE_RAILS)?true:false;

}

4.12 Draw Power-Rail

Linile de tensiune vor fi adăugate la imaginea de ansamblu.

(Tabelul nr. 4.12 Prezintă șinelor de alimentare)

private: System::Void drawPowerRailToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)

{

graphics->enDrawPwrRails = !graphics->enDrawPwrRails; //toggle flag

drawPowerRailToolStripMenuItem->Checked = graphics->enDrawPwrRails;

}

La activarea acestei opțiunii se va incarca in memorie și reprezentat in imagine prin functia de mai jos.

if(enDrawPwrRails)

powerRails->RenderInstances();

void RenderInstances(int numInstances)

{

Vec4 progMatDiffuseA(0,0,0,alpha); //equivalent for LIGHTS-OFF

Vec4 progMatSpecular(0,0,0, 0); //equivalent for LIGHTS-OFF

//Uniforms specific to current type of ojects

if(enLights){

progMatDiffuseA = Vec4(materialDiffuse, alpha);

progMatSpecular = materialSpecular;

}

glUniform4fv(GraphicsSolidObj::material_diffuse_loc, 1, &progMatDiffuseA);

glUniform4fv(GraphicsSolidObj::material_specular_loc, 1, &progMatSpecular);

glBindVertexArray(mVao);

glDrawArraysInstanced(GL_TRIANGLES, 0, nVertices, numInstances);

glBindVertexArray(0); }

4.13 Draw Bins

(Figura nr 4.13.1 În această figură sunt reprezentate toate opțiunile de vizualizare ale cutiilor)

În această opțiune avem mai multe sub-opțiuni. Toate reprezintă tipuri în care se pot vedea cutiile în imaginea de ansamblu a GUI-ului.

(Figura 4.13.2 Se poate vedea opțiunea cu toate cutiile vizibile)

4.13 Draw Hall

În această opțiune se poate adăuga în imaginea de ansamblu vederea cu hala și zidurile aferente citite din fișierul harta de tip .CSV

4.14 DrawInfo

Prin aplicarea acestei opțiuni se afișează informații despre roboți (odată ce se face click pe el). Se afișeaza informațiile despre cutiile în momentul în care trecem cu mouse-ul peste ele.

4.15 Lang

Se va face click pe opțiunea Limbă pentru a schimba limba GUI. În momentul de față există doar engleza și germana.

Pentru realizarea acestei opțiuni a fost nevoie de două fișiere de tip .resix pentru fiecare limbă în parte.

În aceste fișiere am introdus fiecare label din GUI și traducerea aferentă.

În momenul în care o opțiune este selectată se declanșează un eveniment în care se memorează valoarea opțiunii selectate într-o variabilă de tip boolean.

Acestă funcție de verificare a opțiunii este necesară pentru a nu verifica ciclic valoarea opțiunii prin baza de date.

În momentul în care a fost activat evenimentul în toate formele există o funcție care încarcă fișierul de resurse. În felul acesta toate label-urile iși vor schimba propietatea text cu text-ul din fișier.

private: System::Void dEToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) {

LangOption = 1;

// graphicGold->LanguageOption= 1;

UpdadeLanguageOption(DE);

DEtranslateOption();

}

}

private: System::Void eNToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) {

// extern int LangOption;

LangOption= 0;

UpdadeLanguageOption(EN);

ENtranslateOption();

}

//=================================================================================================

private: System::Void ENtranslateOption()

{

Assembly ^a = Assembly::Load("RoverLogGui");

ResourceManager ^rm = gcnew ResourceManager("RoverLogGui.Lang.LangRes",a);

MainFormFileTabChange(rm);

MainFormEditTabChange(rm);

MainFormViewTabChange(rm);

MainFormOptionsTabChange(rm);

MainFormHelpTabChange(rm);

}

//=================================================================================================

private: System::Void DEtranslateOption()

{

Assembly ^a = Assembly::Load("RoverLogGui");

ResourceManager ^rm = gcnew ResourceManager("RoverLogGui.Lang.LangResDE",a);

MainFormFileTabChange(rm);

MainFormEditTabChange(rm);

MainFormViewTabChange(rm);

MainFormOptionsTabChange(rm);

MainFormHelpTabChange(rm);

}

//======================================================================

private: System::Void MainFormOptionsTabChange( ResourceManager ^rm )

{

optionsToolStripMenuItem->Text= rm->GetString("OptionsTab");

toolStripMenuAntialiasing->Text= rm->GetString("Options.Anti");

smoothRobotMovementToolStripMenuItem->Text= rm->GetString("Options.SmoothRobotMovment");

drawDriveRailToolStripMenuItem->Text= rm->GetString("Options.DrawStacks");

allToolStripMenuItem->Text= rm->GetString("Options.DrawStack.All");

noneToolStripMenuItem->Text= rm->GetString("Options.DrawStack.None");

pilarsToolStripMenuItem->Text= rm->GetString("Options.DrawStack.Pillars");

holdersToolStripMenuItem->Text= rm->GetString("Options.DrawStack.Holders");

guidesToolStripMenuItem->Text= rm->GetString("Options.DrawStack.Guides");

drawDriveRailToolStripMenuItem1->Text= rm->GetString("Options.DrawDriveRail");

drawPowerRailToolStripMenuItem->Text= rm->GetString("Options.DrawPoweRail");

drawBinsToolStripMenuItem->Text= rm->GetString("Options.DrawBins");

drawBinNoneToolStripMenuItem->Text= rm->GetString("Options.DrawBins.None");

Concluzii

Din proiectul de mai sus se poate observa cum noțiunile teoretice exprimate în

introducere sunt implementate în partea practică. Interfața Grafica pentru

sistemul de depozitare fiind modular.

Server-ul fiind cel ce analizaza comenzile si indeplineste actiunile.GUI-ul doar preia anumite informatii de la acesta pentru vizulaizarea sistemului de catre utilizator intr-un mod usor de inteles si predictibil.

Pentru implementarea acestui proiect se folosesc mai multe platforme de dezvoltrare.

Blender este folosit pentru design-ul corpurilor. Aceasta aplicatie prezinta avantajul ca este foarte usor de adaptat iar obiectele se pot salva in orice forma pentru a putea fi folosite in aplicatia principala.

MySQL este cea mai folosita baza de date iar sintaxa si integrarea in interfata grafica fiind usor de realizat cu ajutorul connectorilor la instalarea MySQL Workbench si prin libariile deja dezvoltate in visual studio 2012.

Toate aceste medii de dezvoltare sunt integrate intr-un mod armonios pentru a forma un intreg.

Deoarece soulția este construită in limbajul de programare C++ permite în primul rand integrarea ușoara a librăriilor OpenGL, acest lucru ajută la dezvoltarea aplicației la dezvoltarea scheletului pentru animație dar si la scaderea costurilor de dezvoltare deoarece din 2006 este sustinut de o organziatie non-profit.

Acest proiect se preteaza pentru o gama larga de posibili de clienti deoarece costurile de instalare sunt mici, fiind modular si usor de integrat intr-un spatiu comercial.

Bibliografie

[1] Evolution of Graphical User Interface in last 50 years by Raj Lal

[2] The men who really invented the GUI by Clive Akass

[3] Graphical User Interface Gallery, screenshots of various GUIs

[4] Marcin Wichary's GUIdebook, Graphical User Interface gallery: over 5500 screenshots of GUI, application and icon history

[5] The Real History of the GUI by Mike Tuck

[6] In The Beginning Was The Command Line by Neal Stephenson

[7] 3D Graphical User Interfaces (PDF) by Farid BenHajji and Erik Dybner, Department of Computer and Systems Sciences, Stockholm University

[8] https://www.opengl.org/

[9] http://wikivisually.com/