Lucrare de Finalizare a studiilor a studentului ______________________________________ Tema lucrării de finalizare a studiilor:… [308038]

PROIECT DE DIPLOMĂ

COORDONATOR ȘTIINȚIFIC

Conf. dr. ing. Barabás Tiberiu

ABSOLVENT: [anonimizat]

2018

COORDONATOR ȘTIINȚIFIC

Conf. dr. ing. Barabás Tiberiu

ABSOLVENT: [anonimizat]

2018

UNIVERSITATEA DIN ORADEA

FACULTATEA __________________________________________________

DEPARTAMENTUL ______________________________________________

TEMA_________

Lucrare de Finalizare a studiilor a student: [anonimizat] ______________________________________

Tema lucrării de finalizare a studiilor: ______________________________________
______________________________________________________________________________________________________________________________________________________

Termenul pentru predarea lucrării __________________________________________

Elemente inițiale pentru elaborarea lucrării de finalizare a studiilor________________ ____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

Conținutul lucrării de finalizare a studiilor: __________________________________
________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

Material grafic: ________________________________________________________
_____________________________________________________________________________________________________________________________________________________

Locul de documentare pentru elaborarea lucrării:_____________________________
______________________________________________________________________________________________________________________________________________________

Data emiterii temei _____________________________________________________

Coordonator științific

Conf. dr. ing. Barabás Tiberiu

Capitolul I : Introducere

Istoria roboților

Ca o umbră a [anonimizat], [anonimizat], [anonimizat].

În jurul anului 400 Î.H. [anonimizat], a construit o [anonimizat] a putea înțelege mai bine cum zboară păsările. Deasemenea în anul 1495, Leonardo DaVinci a publicat un model de proiectare pentru un calaver mecanic (fig. 1.1.1), urmând ca pe parcursul a 400 de ani câteva exemplare să fie construite ca jucărie pentru cei de neam regesc.

Fig. 1.1.1 Calaverul mecanic de Leonardo DaVinci

Termenul de „robot” este folosit pentru prima dată într-o [anonimizat], în anul 1920 intitulată R.U.R. (Rossum's Universal Robots) în care este vorba despre o fabrică ce construiește oameni artificiali pentru a fi slujitorii oamenilor.

Începând din anul 1928, când primul robot (fig. 1.1.2. și 1.1.3.) a luat viață, tehnologia, în ceea ce privește robotica, a evoluat enorm, astfel că, pornind de la un robot care putea fi controlat să își miște mâinile și capul, în ziua de azi avem umanoid cu inteligență artificială, pe nume Sophia (fig. 1.1.4.), fiind primul robot care să primească cetățenie, care este capabil să afișeze mai mult de 62 de expresii faciale, să păstreze contact vizual, să recunoască persoanele și să poarte o conversație.

Fig. 1.1.2 și 1.1.3. Earl și George, primii roboți umanoizi

Fig. 1.1.4. Robotul Sophie

Primul robot autonom electric cu comportament complex a fost creat de William Grey Walter în 1948-1949. El a vrut sa dovedească că bogatele conexiuni dintre un mic număr de celule din creier pot conduce la comportamente foarte complexe și că secretul funcționarii creierului constă în felul în care acesta e legat.

Primul robot digital și programabil a fost inventat în 1954 de George Devol, robotul primind numele de Unimate(fig. 1.1.5.). Acesta a așezat fundația industriei roboților moderni.

Fig. 1.1.5. Robotul Unimate

Primul robot paletizare a fost introdus în 1963 de firma Fuji Yusoki Kogyo. În 1973, un robot cu șase axe acționate electromecanic a fost patentat de către KUKA, iar brațul robotic programabil a fost inventat de Victor Scheinman în 1976, acesta fiind mai apoi vândut lui Unimation.

Roboții comerciali și industriali, în momentul de față duc la îndeplinire o gamă largă de sarcini, mai ieftin și cu o acuratețe și fiabilitate mult mai ridicată decât oamenii. De asemenea sunt folosiți la munci ce sunt prea murdare, pericoloase sau plictisitoare pentru un om. Roboții sunt folosiți la manufacturare, asamblare și ambalare, transport, explorare spațială sau terestră, intervenții chirurgicale, armament, cercetare și producție în masă.

Definire și clasificare

Un robot este un manipulator multifuncțional, programabil, proiectat să mute materiale, compomente, scule, sau dispozitive specializate prin mișcari programate pentru a îndeplini diferite cerințe.

Roboții sunt folosiți în multe domenii și cu diferite scopuri, această ramură fiind foarte vastă. Ei pot fi clasificați în funcție de diferite criterii:

După gradul de libertate – un manipulator ar trebui să fie compus din șase grade de libertate pentru a putea manipula un obiect în spațiul tridimensional. Tipuri de roboți după gradul de libertate:

Robot standard (fig. 1.2.1.) : compus din șase grade de libertate;

Robot redundant : compus din mai mult de șase grade de mobilitate; oferă o libertate mai mare de mișcare în jurul obstacolelor și posibilitatea de a lucra într-un spațiul de lucru restrâns;

Robot deficient : are mai puțin de șase grade de libertate.

fig.1.2.1. mișcările realizabile de un robot standard cu șase grade de libertate

După structura cinematică:

Robot serial sau în buclă deschisă (ex: adept-one robot);

Robot paralel : are structură în buclă închisă; e caracterizat prin duritate ridicată, poate manipula o sarcină mai mare și inerție mai mică la manipulare spre diferență de cel serial, însă cu un spațiu mai mic de lucru și mecanism mai complex;

Robot hibrid : este o combinație între robotul serial și cel paralel (ex: Fanuc S -900 W).

După tipul de acționare:

Robot cu acționare electrică : majoritatea manipulatoarelor utilizează fie servomotoare de curent continuu, fie motoare pas cu pas, acestea fiind mai ușor de acționat;

Robot cu acționare hidraulică : folosit pentru viteze și sarcini ridicate; dezavantajul este că prezintă riscul scurgerilor de ulei;

Robot cu acționare pneumatică : deasemenea este folosit în cazul în care dorim viteze ridicate la sarcini mari, însă este greu de controlat datorită faptului că aerul este compresibil.

După geometria spațiului de lucru – spațiul de lucru al unui manipulator poate fi definit ca totalul punctelor din spațiu pe care efectorul final le poate atinge:

Robot cartezian (fig. 1.2.2.): acest tip de robot e compus din trei cuple liniare;

Robot cilindric (fig. 1.2.3.): una din primele doua cuple este rotativă, iar celelalte rămân cuple liniare;

Robot sferic (fig. 1.2.4.): primele două cuple sunt rotative, iar cea de a treia e liniară;

Robot articular (fig 1.2.5.): un robot este articulat dacă toate cele trei cuple sunt rotative.

Fig. 1.2.2. robot cartezian fig. 1.2.3. robot cilindric

Fig. 1.2.4. robot sferic fig, 1.2.5. robot articulat

După tipul mișcarii :

Robot planar;

Robot sferic;

Robot spațial.

După domeniul de utilizare:

Roboți mobili : au capabilitatea de a se mișca nefiind fixați într-o locație anume. Un exemplu ar fi vehiculele ghidate automat care pot urmării diferiți markeri sau fire din podea;

Roboți industriali : consistă de obicei dintr-un braț articulat și dintr-un efector final. Roboții industriali sunt folosiți la procesul de manufacturare. Ei sunt automați, programabili și capabili să se miște pe două sau mai multe axe. Aplicațiile generale includ sudură, vopsire, asamblare, împachetare și etichetare, inspecție a produselor și testare, toate realizate cu o rezistență, viteză și precizie ridicată.

Roboți de servciu : un robot care funcționează semi sau total autonom pentru a duce la indeplinire anumite servicii utile omului, fiind exclus procesul de manufacturare;

Roboți educaționali : sunt utilizați ca asistenți educaționali pentru profesori;

Roboți modulari : sunt proiectați pentru a crește utilizarea roboților modularizând arhitectura acestora;

Roboți colaborativi : sunt acei roboți care în mod eficient și sigur interacționează cu operatorii umani în timp ce indeplinesc simple sarcini.

Paramentrii ce caracterizează un robot industrial:

Numarul de axe;

Gradul de libertate;

Zona de lucru;

Cimenatică;

Sarcina maximă suportată: sarcina maximă la care robotul poate funcționa fără să afecteze performanța acestuia;

Viteză;

Accelerare;

Acuratețe: cât de mult se apropie robotul de punctul impus;

Repetabilitate: capacitatea robotului de a se apropia cât mai mult de un punct atins anterior;

Controlul mișcării;

Tipul de acționare.

Structura generală și funcțiile sistemelor componente ale unui robot

În figură alăturată (fig. 1.3.1) se prezintă schema bloc a unui robotului unde se pot observa componentele unui robot și legaturile ce se formează între acestea.

Fig. 1.3.1. schema bloc a unui robot

Traductoarele au scopul de a furniza sistemului de comandă informații cu privire la starea internă a robotului: poziții și mișcări relative ale elementelor sistemului mecanic, parametri funcționali ai sistemului de acționare.

Senzorii au scopul de a furniza informații despre starea externă a robotului: parametri din mediu (temperature, presiune, etc) și acțiunea acestuia asupra robotului. Corespondentul acestora la corpul uman ar fi organele de simț.

Deplasarea roboțiior mobili se realizează prin intermediul sistemului mecanic, care e prevăzut cu o platform mobile și joacă rolul sistemului locomotor al omului.

Mediul se poate defini ca fiind spațiul în care un robot evoluează cu obiectele conținute și fenomenele ce au loc în acest spațiu.

Sistemul de comandă trimite comenzi sistemului de acționare, acesta acționează cuplele cinematice conducătoare sistemului mecanic, care la rândul său acționează asupra mediului.

Sistemul mecanic al robotului:

Acesta are rolul de a asigura realizarea mișcăriilor acestuia și transmiterea energiei mecanice neceasre interacțiunii cu mediul.

Structura acestuia e reprezentată în figura următoare:

Fig. 1.3.2. Schema bloc a sistemului mecanic

Pentru definirea situării unui corp în spațiu tridimensional folosim poziția punctului caracteristic și orientările dreptei caracteristice, restectiv a dreptei auxiliare.

Punctul caracteristic se poate defini ca un punct al obiectului, folosit pentru definirea acestuia. Dreapta caracteristică este o dreaptă care trece prin punctul caracteristic, iar dreapta auxiliară este o dreaptă perpendiculară în punctul caracteristic pe dreapta caracteristică. Cu ajutorul acestor doua drepte se definește orientarea obiectului, care aparține de aceste drepte.

Dispozitivul de ghidare

Dispozitivul de ghidare asigură efectorului final mișcările și energia mecanică necesară acestor mișcări. Ele pot fi cu topologie serială, paralelă, sau mixtă.

Dispozitive de ghidare cu topologie serială:

mecanismele dispozitivului de ghidare care au la bază lanțuri cinematice deschise, sunt definite ca având topologie serială.

în această topologie, mecanismele generatoare de traiectorie și orientare sunt definite separat: mecanismul generator de traiectorie are baza ca și element fix, iar mecanismul generator de orientare e în continuarea ultimului element al mecanismului generator de traiectorie.

schema structurală a dispozitivului de ghidare:

Fig. 1.3.3. schema structurală a unui dispozitiv de ghidare

Dispozivitul de ghidare cu topologie paralelă:

când dispozitivul de ghidare are la bază un lanț cinematic închis, acesta se definește ca având topologie paralelă.

această denumire este dată chiar de structura lor: prezintă două elemente numite și platforme, de regulă una fixă și alta mobilă, acestea fiind legate între ele printr-un număr de lanțuri cinematice deschise, numite conexiuni sau brațe.

Dispozitivul de ghidare cu topologie mixtă:

dispozitivul de ghidare cu topologie mixtă constă în înlănțuiri de mecanisme de ghidare cu topologie paralelă, legate în serie.

legătura dintre acestea se face prin platforme, care pentru partea anterioară e platformă mobilă, iar pentru partea superioară este platformă fixă.

Structura mecanismului generator de traiectorie

Modificarea poziției unui obiect se face cu o parte constructivă a dispozitivului de ghidare, și anume mecanismul generator de traiectorie (MGT).

În principal, mecanismul generator de traiectorie trebuie să fie compus din trei cuple mecanice, respectiv să aibă trei grade de mobilitate, pentru a putea realiza modificarea fiecăreia dintre cele trei coordonate carteziene (X,Y,Z) ale punctului caracteristic.

În cazul unui robot cu șase grade de mobilitate, primele trei sunt parte a mecanismului generator de traiectorie.

Structurile posibile de mecanisme generatoare de traiectorie:

TTT – trei cuple cinematice de translație;

TTR – primele două cuple cinematice de translație, iar cea de-a treia de rotație;

RRT – primele doua cuple cinematice de roație, iar cea de-a treia de translație;

RTT – o cuplă de rotație, și următoarele două cuple sunt de translație;

TRR – o cuplă de translație, urmată de două cuple de rotație;

RRR – cele trei cuple cinematice sunt de roție;

TRT – o cuplă de rotație, care are de-o parte și de alta, o cuplă de translație:

RTR – două cuple de rotație, așezate de-o parte și de alta a unei cuple de translație.

Din toate aceste opt posibile combinări, se folosesc doar patru, și anume:

Fig. 1.3.4. robot TTT fig. 1.3.5. robot RTT

Fig. 1.3.6. RRT fig. 1.3.7. RRR

Structura mecanismului de orientare

Modificarea orientării unui obiect manipulat se face cu ajutorul mecanismului de orientare, care face parte din dispozitivul de orientare, împreună cu mecanismul generator de traiectorie.

Ca și în cazul mecanisnului generator de traiectorie, acesta trebuie să aibă trei grade de mobilitate, acestea reprezentând ultimele trei cuple cinematice a robotului, iar cuplele cinematice a mecanismului de orientare sunt doar cuple de rotație.

Dacă se atașează ultimului element al mecanisnului generator de traiectorie un sistem de coordonate carteziene, atunci cele trei mișcări de rotație realizate de mecanismul de orientare primesc următoarele denumiri convenționale:

Pronație – supinație (ROLL): mișcare în jurul axei OX

Flexie – extensie (PITCH): mișcare în jurul axei OY

Aducție – abducție (YAW): mișcare în jurul axei OZ

Efectorul final

Acesta reprezintă partea robotului care acționează asupra mediului.

În cazul roboțiilor industriali, acesta poate fi folosit în două moduri: de manipulare a obiectelor, sau de prelucrare a acestora.

Pentru manipularea obiectelor, efectorul final este un dispozitiv de prehensiune, iar pentru prelucrarea acestora, efectorul final este o sculă sau un cap de fortă cu sculă.

Legatura dintre efectorul final și ultimul element al dispozitivului de ghidare se realizează prin intermediul unui element de cuplare.

Sistemul de coordonate atașat efectorului final este format din versorii n,o,a, unde n este versorul normal, o este versorul de orientare și a este versorul de apropiere.

Fig.1.3.8. tipuri de scule ca si efector final

Fig. 1.3.9. Gripper

Element de cuplare:

Acesta realizează legatura dintre efectorul final și ultimul element al dispozitivului de ghidare, astfel fiind stabilită poziția relativă a acestuia față de ultimul element al dispozitivului de ghidare.

Prin realizarea unei legături imobile între cele două părți ale elementului de cuplare care ar fi partea prinsă de ultimul element al dispozitivului de ghidare si elementul fix al efectorului final se cuplează efectorul final de ultimul element al dispozitivului de ghidare.

Dispozitiv de prehensiune si funcțiile acestuia:

Funcția acestuia este de a situa relativ obiectul manipulat, în funcție de ultimul element al dispozitivului de ghidare.

Funcții principale:

Funcția de adaptare: aceasta face legatura fizică între robot, obiectul de lucru și mediul de lucru, depinzând de comezile din program;

Funcția senzorială: primește informații despre obiectul manipulat și mediu prin diferite compomente cum ar fi senzori sau traductoare, cu scopul de a fi transmise mai departe spre sistemul de comandă.

Sistemul de comandă:

Traductoare:

Traductoarele au rolul de a măsura deplasarea, poziția, viteza și accelerația cuplelor magnetice ale unui robot, și totalitatea acestor semnale sunt transmise mai departe sistemului de comandă.

Clasificare:

La construcția roboților, cele mai utilizate traductoare sunt traductoarele numerice.

Traductorul numeric incremental liniar: o sursă emite un fascicol de lumină, care cu ajutorul unei lentile transformă fascicolul din unul divergent în unul paralel, astfel încât să cadă perpendicular pe rigla incrementală divizoare care prezintă zone opace și zone transparente dispuse succesiv. Fluxul luminos e captat de un fotoelement și este transformat în semnale periodice de perioadă egală cu pasul incremental, care la rândul lor sunt transformate în semnale digitale, care sunt amplificate, apoi numărate și afișate.

Fig. 1.3.10. traductor numeric incremental liniar

Parțile componente sunt:

lampa (4)

lentila convergenta (3)

diafragma cu fanta (5)

obiectivul (6)

fotodioda (1)

rigla (2)

Traductorul numeric incremental rotativ este compus din:

Sursă de lumină

Lentilă condensator

Disc incremental divizor

Disc incremental vernier

Fotodiodă

Fig. 1.3.11. traductor numeric incremental rotativ

Traductorul numeric absolut: transformă deplasarea ce urmează a fi măsurată într-un număr binar scris într-un cod, în acest caz măsurarea fiind mult mai precisă. Principiul de măsurare este același ca în cazul traductoarelor incrementale, însă se folosesc mai multe trenuri de impulsuri. El este compus din: sursă luminoasă, lentilă condensator, riglă codificată și corpul fotoelectric de citire.

Traductorul optoelectric absolut de situare rotativ: este asemănător cu cel numeric absolut cu specificarea că pistele sunt materializate pe un disc și pe un vervier de forma unui sector circular.

Traductorul potenționetric liniar absolut: este alcătuit dintr-o rezistență variabilă legată de un element al cuplei cinematice și un cursor cu mișcare de translație, legat de celălalt element al cuplei cinematice

Traductorul potențiometric rotativ absolut: are rezistența variabilă dispusă circular, iar cursorul poate realiza o mișcare de rotație.

Traductorul de viteză generalizată: culege informații despre parametrii cinematici pentru mișcările relative a elementelor cuplelor cinematice.

Traductorul inductiv de viteză unghiulară relativă: acesta este un generator de curent continuu, rotorul fiind legat de un elementul al cuplei cinematice, iar statorul de cealalt element al cuplei cinematice.

Traductorul de accelerație liniară absolută: este compus dintr-un arc de care e suspendată o masă pe care este lipit un timbru tensometric rezistiv. Toată această construcție este fixat pe elementul aflat în mișcare.

Fig. 1.3.12. traductor de viteză

Traductorul de forță generalizată are scopul de a aduna informații despre forțele și momentele care acționează într-un element al cuplei cinematice, rezultând că acest traductor culege informații despre forțe interioare.

Senzori: aceștia joacă rolul pe care îl au organele de simț la un om, respectiv rolul de a comunica cu mediul înconjurător și de a se adapta la acesta.

Senzori tactili: realizează când are loc un contact dintre elementele cuplelor cinematice cu un obiect din mediu. Semnalul transmis ce acest tip de senzori este unul analogic binar ( există contact, respectiv nu există contact).

După modul de realizare a contactului aceștia de clasifică în felul următor:

Mecanic, prin apăsarea unui microîntrerupător

Cu membrană pocnitoare

Cu contact prin folie piezorezistivă

Optic

Inductiv

Capacitiv

Piezoelectric

Senzori vizuali: structura generală a unui sistem vizual este cumpusă din:

Camera de captare a imaginii care generează un semnal video analog ce e transmis mai apoi digitizorului, pe baza unei informații luminoase receptate;

Digitizorul realizează corespondența între datele transmise calculatorului și adresele corespunzătoare acestuia.

Comanda robotului: prin comandă se înțelege un set de instrucțiuni care fac referire la pornirea sau oprirea unui anumit motor al robotului, respectiv a sistemului de acționare.

Sistemul de comandă împreună cu sistemul de acționare formează sistemul de conducere a unui robot. Acesta poate fi clasificat în felul următor:

Conducere grosieră (fără contact între mediu și efectorul final);

Conducere fină (cu contact între mediu și efector final).

Conducerea grosieră se dizivează în următoarele componente:

Conducere în spațiul cuplelor;

Conducere în spațiul cartezian;

Conducere globală.

Conducerea fină, și ea se divizează la randul ei, în:

Conducere utilizând complianța pasivă;

Conducere utililzând complianța activă.

Sarcina comenzii unui robot este de a afla vectorul mărimii predefinite astfel încât să asigure punctului caracteristic poziții și deplasări cu viteză și accelerație impusă, fără coliziuni, și cu o traiectorie lină.

Sistemul de acționare

Acționarea electrică:

În ultima perioadă, se preferă tot mai mult acționarea roboților electric datorită anumitor avantaje rezultate din noi soluții de comandă, dar și datorită dezvoltării unor tipuri noi de mașini electrice și comandarea acestora.

Acest tip de acționare este preferată doar pentru aplicații mici și medii, astfel încât puterea necesară acestora să nu depășească 3-5kW. Folosirea acționării electrice depinde și de condițiile de mediu, nefiind potrivită pentru un mediu exploziv, umed, etc.

Tipuri de acționări electrice:

Acționare electrică cu mașini de curent continuu:

Avantaje: turația motorului de curent continuu se modifică ușor, prin modificarea tensiunii de alimentare și de asemenea valorile limită de modificare a turației sunt mari

Acționare electrcă cu mașini de curent alternativ:

Avantaje: reglare precisă a rotorului ceea ce asigură o poziționare precisă a elementului acționat; posibilitatea reglării turației la fel ca în cazul mașinilor de curent continuu, și de asemenea mașina este mai robustă și preț mai redus.

Oferă posibilitatea de acționare prin două modalități: în curent sau în tensiune.

Acționare electrică cu mașini pas cu pas:

Avantaje: posibiliatea memorării poziției cu o plajă mare de comandă în frecvență; precizie și o rezoluție mare permițând porniri, opriri și inversări de sens, fără a pierde pași.

Deazvantaje: viteza de mișcare scăzută, putere scăzută și randament energetic scăzut. Cel mai mare dezavantaj este că odată cu creșterea frecvenței, scade cuplul motorului, rezultând în restrângerea gamei de frecvență a motorului.

Acționarea hidraulică a roboților:

Avantaje:

Uleiul hidraulic poate fi utilizat la presiuni mari de până la 200 de bari, ceea ce rezultă în dezvoltarea unor forțe mari;

În medii de lucru cu temperatură ridicată, se pot realiza sisteme de acționare puternice, dar în același timp și simple, pentru a manipula sarcini grele;

Datorită faptului că uleiul are un grad mic de a se compresa sub presiune, asigură o rigiditare crescută sistemului de acționare;

Uleiul fiind și un bun lubrifiant, uzura elementelor componente este redusă, astfel îmbunătățind și fiabilitatea acestuia;

Viteza asigurată este una variabilă, iar mișcările sunt caracterizate de precizie ridicată cu posibilitatea opririi în puncte fixe.

Însă acest tip de acționare prezintă și dezavantaje, cum ar fi:

Randament total mai scăzut față de acționarea electrică;

Sistemul de acționare trebuie să fie dotat cu instalații de pregătire a uleiului, ceea ce mărește complexitatea sistemului și crește și prețul acestuia;

Din cauza presiunilor ridicate, necesită etanșări rezistente, ceea ce impune nevoia personalului calificat pentru reparații și mentenanță;

Pentru ca uleiul să nu își modifice proprietățiile, cum ar fi vâscozitatea, necesită instalarea unei instalații de răcire a uleiului.

Acționarea pneumatică a roboților:

Avantajele acestui tip de acționare:

Prezența unei surse de aer comprimat în majoritatea fabricilor;

Scheme de comandă reglaj mai simple;

Prezintă avantajul supraîncărcării motoarelor fără ca acestea să se avarieze;

Acest tip de acționare poate fi folosit în medii cu temperaturi ridicate, cu risc de explozie, umede, cu câmpuri magnetice fără riscul unor accidente;

Motoarele pneumatice au un volum mult mai mic față de motoare acționate în alt fel dar cu aceeași putere.

Dezavantajele acționarii pneumatice:

Dezvoltă forțe mai reduse;

Necesită aparate suplimentare pentru a oprii în anumite poziții motorul, ceea ce crește prețul acestei acționări;

Destinderea subită a aerului comprimat duce la condensarea acestuia și depunerea apei pe pereții motorului, ducând la coroziunea părții mecanice.

Conducerea mauală. Conducerea automată a roboților

Conducerea manuală: aceasta se poate realiza de către un operator uman prin diferite componente, cum ar fi: butoane, manete, întrerupătoare sau prin copiere.

Conducerea cu ajutorul butoanelor, manetelor sau întrerupătoarelor are ca scop acționarea sau oprirea unui motor, sau modificarea parametrilor cinematici.

Conducerea prin copiere se bazează pe principiul master-slave. Construcțiile de gen master-slave sunt compuse din două lanțuri cinematice de structură identică. Unul din acestea este acționat de un operator uman, cel de-al doilea imitând mișcările realizate de primul robot.

fig. 1.4.1. conducerea prin copiere a unui robot

Conducerea automată:

Atunci când sistemul de conducere al robotului este cel ce planifică și generează traiectoria, printr-un control nemijlocit al mișcării, spunem că are loc conducerea automată a robotului.

Etapele realizării conducerii unui robot:

Pentru ca un robot să realizeze orice fel de mișcare, este nevoie ca mai întâi să se realizeze două etape, acestea fiind: etapa de specificare a mișcărilor și etapa de generare a mișcărilor.

Etapa de specificare a mișcărilor:

Mișcările unui robot trebuie mai întâi explicate matematic.

În această primă etapă se vor alege funcțiile de conducere și se va impune condiția ca la anumite momente de timp, funcțiile de conducere alese, să ia anumite valori. Condițiile impuse se calculează valorile coeficienților funcțiilor de conducere.

Această etapă poate fi realizată și offline, însă este necesar să se cunoască complet mișcarea ce urmează a fi efectuată.

Etapa de generare a mișcărilor

În etapa a doua se generează prin calcul, punctele traiectoriei ce trebuie parcursă.

Sistemul de conducere a robotului are un bloc generator de traiectorie, care calculează, fie în coordonate carteziene, fie în coordonatele cuplelor cinematice conducătoare, valorile numerice a funcțiior de conducere, la un anumit interval de timp, constant. Aceste valori sunt de fapt punctele relative pe care dispozitivul de ghidare le ocupa succesiv.

De fapt, acest generator de traiectorie realizează corespondența dintre spațiu si timp în mișcare. Se asigură trecerea trecerea atât prin punctele țintă cât și prin punctele via, astfel încât mișcarea să fie lină și fără șocuri.

Programarea roboților industriali:

Printr-un soft de conducere se poate realiza partea de planificare și generare a traiectoriei pentru sistemele de conducere automată, care este în același timp și dialogul dintre robot și om, respectiv procesul prin care operatorul uman transmite spre robot anumite comenzi care urmează a fi interpretate și realizate de către robot.

Toate aceste comenzi transmise spre robot pot fi executate direct, sau pot fi salvate în memoria sistemului, pentru ca acestea să fie apelate mai târziu, sub formă de program de aplicație.

Programul de aplicație poate fi definit ca un set de informații codificate, acesta fiind compus din comenzi și operații ce urmează a fi executate de robot.

Programul de aplicație este la rândul lui împărțit în linii de program, care la momentul apelării programului lansează în execuție liniile de program, ordinea depinzând de logica programului.

După modul de lucru al unui robot, programarea poate fi clasificată în:

programare secvențială;

programare punct cu punct (PTP);

programarea multipunct (MTP);

programarea cu traiectorie continuă (CP).

Programarea secvențială: permite mișcări doar pe o anumită cuplă cinematică conducătoare la un moment dat, astfel că mișcările pe mai multe cuple se realizează succesiv.

Pentru un exemplu de programare secvențială, putem lua un robot de tip TTT care trebuie să parcurgă distanța de la punctul 1 la punctul 2, trecând prin punctele via 1’ și 1”. Pentru a realiza această mișcare, pleacă din punctul 1 spre 1’ deplasarea fiind paralelă cu axa OX, apoi continuă cu translație paralelă cu axa OY până în punctul 1”, iar apoi ultima mișcare de translație paralelă față de axa OZ pentru a ajunge în punctul 2. Mișcările realizate se pot observa în figura următoare (fig. 1.6.1):

Fig. 1.6.1. Exemplu traseu programare secvențială

Programarea punct cu punct (PTP): este folosită atunci când nu intervin anumite condiții de parcurgere a unei traiectorii, astfel ca traiectoria să nu fie una de coliziune și cu mișcări simultate pe toate axele.

Fig. 1.6.3. traseul unui robot programat PTP

Programarea multipunct (MTP): atunci când traiectoria are anumite condiții impuse legate de drumul pe care să îl parcurgă robotul. Acestea pot apărea în cazul unei traiectorii de coliziune, și se dorește ca robotul să parcurgă traseul prin anumite puncte astfel evitând punctele critice.

Limbajele de programare a unui robot industrial pot fi împărțite pe mai multe categorii, în funcție de gradul de complexitate:

limbaj de programare de nivel 1 (de bază) – hardware;

limbaj de programare de nivel 2 (punct cu punct);

limbaj de programare de nivel 3 (de mișcare);

limbaj de programare de nivel 4 (structurate);

limbaj de programare de nivel 5 (orientate pe task-uri).

Exemple de limbaje:

De nivel 1: limbaje de asamblare;

De nivel 2: Funky, T3;

De nivel 3: VAL, SIGLA, ANORAD, EMILY;

De nivel 4: ALGOL, PL/1;

De nivel 5: AUTOPASS.

Domenii de utilizare și aplicații ale roboților industriali

Cea mai importantă tendință în procesul de mecanizare și automatizare a producției este folosirea roboților în industrie. Chiar dacă la începutul dezvoltării roboților industriali, folosirea acestora în industrie era o raritate, în momentul acesta e ceva la ordinea zilei.

Utilizarea roboților în anumite industrii depinde de țara în care se utilizează, difereanță care se poate observa în randurile următoare.

În Japonia, domeniul de utilizarea a roboților industiali este: industria automobilelor, industria mașinilor electrice, prelucrarea materialelor plastice, prelucrarea metalelor, mecanică, fabricarea mașinilor, alte domenii.

În SUA, domeniul de utilizare este constituit din următoarele industrii: prelucrarea metalelor, industria mașinilor electrice, industria automobilelor, fabricarea mașinilor, alte domenii.

Precum se poate observa, domeniile de utilizare a roboților industriali în Japonia și SUA sunt destul de asemănătoare, însă în Suedia se observă o diferență mai mare: presarea pulberior, vopsirea și acoperirea suprafețelor, sudare, turnătorie, turnare sub presiune, ștanțare, servicii, educație, cercetare, etc.

De asemenea, Marea Britanie are domenii de utilizare a roboților industriali, o parte dintre acestea regăsindu-se în lista de domenii a altor țări: turnare continuă, sudare, vopsire, asamblare, manipulare, testare.

Aplicațiile de utilizare a roboților industriali:

Prelucrarea suprafețelor;

Sudare cu flacără;

Sudare cu arc;

Găurire, așchiere;

Asamblare;

Presare;

Turnare sub presiune;

Turnare prin injecție;

Mașini unelte;

Manipulare;

Control de calitate, testate;

Transport;

Cercetare.

Aplicațiile roboților industriali se împart în trei mari grupe:

Manipulare si stocare – din această grupă fac parte operațiile de: încărcare, descărcare a mașinilor unelte semiautomatizate, (din care putem aminti: mașini de găurire, mașini de tarodare, mașini de broșare, strunguri, freze, prese, mașini de rectificat) , sau cu comandă numerică (strung, freză), paletizare și depaletizare;

Fabricația – aduce problema integrării robotului industrial în lanțul de producție. Din această grupă putem specifica operațiile de: sudare, pulverizare, tăiere a țesăturilor, materialelor plastice, a metalelor, precum și lucrările de terminare (decuparea maselotelor de turnare, debavurarea pieselor brute, debavurare piese după prelucrare, polizare);

Asamblare piese: necesită utilizarea unor traductoare senzoriale și o mare precizie de poziționare.

Utilizari industriale ale manipulatoarelor

Domeniile de utilizare a manipulatoarelor este versatil, acestea regăsindu-se în industria ceasurilor, ca și micromanipulatoare, electronică, în industria nucleară ( asamblarea țintelor de deuteriu și titriu pentru fuziunea cu laser), și chiar ca și megatelemanipulatoare instalați pe rachetele spațiale pentru a recupera sateliții spațiali defecți, sau construirea stațiilor orbitale.

Telemanipulatoare : sunt utilizare în medii periculoare în care omul nu intervine, cum ar fi: atmosferă rece, sau caldă, produse chimice, fum, materiale în topire, industria nucleară, etc.

Manipulatoare cu ciclu manual asistat: acest tip de manipulatoare sunt utilizate pentru reducerea greutății, a cărui geometrie e bazată pe modelul pantografului, care îmbină suplețea cu manevrabilitatea. Energia de acționare este generată de un motor electric, pe post de contra-greutate.

Manipulatoare cu cicluri prestabilite: pentru ca productivitatea să crească, s-a realizat automatizarea manipulatoarelor manipulatoare, și introducerea manipulatoarelor automate cu cicluri prestabilite. Cele mai recunoscute manipulatoare ce acest fel, ar fi roboți de transfer (pick and place). Activitatea acestor manipulatoare este compusă din prinderea piesei într-un anumit loc și depozitatea acestuia într-un alt loc.

Manipulatoare automate cu cicluri programate

Capitolul 2 Prezentarea robotului din cadrul proiectului

Sistemul mecanic al robotului

Acest robot este de tipul ROT2U 6DOF Aluminium Robot Arm. Are structura unui braț, cu șase grade de mobilitate, fiecare dintre cuplele cinematice conducătoare fiind rotative, respectiv RRRRRR.

Structura părții mecanice după asamblare se poate observa în figura fig. 2.1.1.

Fig. 2.1.1. Structura mecanică a robotului, asamblată

La achiziționare, partea mecanică a robotului a fost neasamblată, aceasta necesitând asamblare (fig. 2.1.2.). Materialul pieselor componente este de aluminiu.

Fig. 2.1.2. partea mecanică a robotului neasamblată

Pentru ca mișcarea de rotație a cuplelor cinematice conducătoare să fie cât mai fină, la cuplajul dintre piese se pozitionează un rulment.

Primele trei cuple cinematice conducătoare constituie mecanismul generator de traiectorie cu ajutorul căruia se poziționează robotul în punctul dorit, iar ultimele trei cuple cinematice conducătoare fac parte din mecanismu de orientare, care se ocupă strict de orientarea efectorului final, respectiv, pronație – supinație (ROLL): mișcare în jurul axei OX, flexie – extensie (PITCH): mișcare în jurul axei OY, aducție – abducție (YAW): mișcare în jurul axei OZ.

Efectorul final (figura 2.1.3.) al robotului este de tip gripper, cu ajutorul căruia se pot apuca obiecte, ca mai apoi acestea să fie manipulate de către robot.

2.1.3. Efectorul final al robotului

Sistemul de acționare

Servo motoare

Un servo motor poate fi atât un actuator rotativ, cât și liniar, care asigură o prezicie ridicată a controlului poziției unghiulare, sau liniare, a vitezei și a accelerației.

Fig. 2.2.1 Servo motoare

Per ansamblu, servo motoarele sunt relativ standardizare, avand cam aceeași formă, fiind echipate cu mecanisme de montare pe laterale. Acestora li se mai pot atașa diferite componente la axul motorului, cum ar fi rotițe sau elice (fig. 2.2.2), pentru a se adapta procesului pentru care sunt folosite.

Fig. 2.2.2. componente atașabile axului motorului

Majoritatea servo motoarelor au o formă standardizată a conectorului (fig. 2.2.3) compus din trei cabluri. Cele trei cabluri din conector sunt: alimentarea, conexiunea la masă și semnalul de control, PWM. Conector este de tip mamă. Deși codul culorilor nu este identic la toate tipurile de servo motoare, de regulă maniera de așezare a acestora în conector este la fel.

Fig. 2.2.3 Conector servo motor

Primul pin reprezentând conexiunea la masă, cel din mijloc fiind alimentare, iar cel de-al treilea pin din conector corespunde semnalului de control a motorului, prin care i se comunică motorului în ce poziție să meargă.

Semnalele PWM (pulse width modulation) sunt semnale dreptunghiulare, a căror durată și/sau frecvență este modificată. Acest tip de semnale este folosit pentru a codifica anumite mesaje într-un semnal pulsator.

Deși semnalele PWM pot fi folosite pentru a codifica informații cu scopul de a fi transmise, ele sunt în principal folosite pentru a controla alimentare unor anumite dispozitive, în special la motoare.

Parametrii care caracterizează un semnal PWM sunt: durata minimă a impulsului, durata maximă a impulsului, și perioada. Impulsurile apar într-un interval de 20 de milisecunde (în 50Hz) iar lungimea unui impuls variază între 1-2 milisecunde.

În figura următoare se poate observa cum influențează durata semnalului PWM (fig. 2.2.4). Pentru poziția neutră, semnalul PWM trebuie să aibă durata de aproximativ 1.5 ms. Pentru ca motorul să se poziționeze la +90 de grade, acesta trebuie să primească un semnal PWM cu durata de aproximativ 2 ms, iar pentru ca acesta să se poziționeze la -90 de grade, semnalul PWM trebuie să aibă durata de aproximativ 1 de ms.

Poziția neutră

+90 de grade

-90 de grade

Fig. 2.2.4 durata semnalului PWM

De fapt, un servo motor este compus din următoarele componente: un potenționetru atașat axului pentru a putea stabili poziția acestuia, un motor de curent continuu și o placă de dezvoltare care pe de-o parte are un microcontroler, iar de cealaltă parte are tranzistori dispuși în punte H, pentru a face posibilă alimentarea cu curent în două direcții pentru ca motorul să poate fi acționat în ambele sensuri.

În figura 2.2.5 se pot observa piesele componente a unui servo motor.

Fig. 2.2.5 Piesele componente a unui servo motor

Potenționetrul are rolul de a măsura durata impulsului primit și să aplice un curent motorului, pentru a învârti axul acestuia, până potențiometrul indică faptul că motorul a ajuns în poziția cerută. Acesta este un fel de control cu reacție negativă.

Partea mecanică a robotului este pusă în mișcare de un grup de sașe servo motoare de tip MG996R, de la firma TowerPro (fig. 2.2.6.).

Fig.2.2.6. Servo motor MG996R

Tensiunea de alimentare a motorului este între 4.8V si 7.2V, cuplul acestuia depinzând de tensiunea de alimentare, astfel că la limita inferioară de 4.8V, acesta are un cuplu de 9.4 kgf*cm, iar la tensiunea de 6V, cuplul crește până la 11 kgf*cm.

Curentul maxim pe care acest motor îl poate absoarbe de la rețea este de 2.5A, iar cel nominal este de 500-900 mA la 6V.

Conexiunile necesare motorului sunt: alimentare cu tensiune pozitivă, conexiunea la masă și semnalul PWM.

Specificațiile tehnice ale motorului MG996R sunt:

greutate: 55 g;

dimensiune: 40.7 x 19.7 x 42.9 mm;

Cuplu: 9.4 kgf·cm (4.8 V ), 11 kgf·cm (6 V) ;

Viteza 0.17 s/60ș (4.8 V), 0.14 s/60ș (6 V) ;

Tensiunea admisă: 4.8 V a 7.2 V;

Curentul consumat 500 mA;

Curentul consumat la sarcină maximă 2.5 A (6V);

Stabil la șocuri, cu un design ce utilizează rulmenți.

Semnalul PWM pentru mișcarea motoarelor MG996R, se face cu ajutorul plăcii de dezvoltare Arduino Mega 2560.

Arduino Mega 2560

Placa de dezvoltare Arduino Mega 2560 (fig. 2.2.7.) este o placă cu microcontroler ce se bazează pe modelul ATmega2560. Are 54 de I/O digitale, dintre care 15 pot fi folosite ca și ieșiri PWM, 16 intrări analogice, 4 porturi UART, un oscilator de 16 MHz, port USB, soclu de alimentare și buton de reset.

Fig. 2.2.7. Arduino Mega 2560

Specificațiile tehnice:

Microcontroler: ATmega2560;

Tensiunea de ieșire: 5V;

Tensiunea de intrare (recomandată): 7-12V;

Limitele tensiunii de intrare: 6-20V;

Pini I/O digitali: 54 (din care 15 pot fi folosiți ca ieșiri PWM);

Pini de ieșire analogică: 16;

Curentul continuu furnizat la pinii I/O: 40 mA;

Curentul continuu pentru pinii de 3.3V: 50 mA;

Memorie Flash: 256;

SRAM 8 KB;

EEPROM 4 KB;

Frecvența ceasului 16 MHz.

Microcontrolere

Un microcontroler este de fapt un calculator în miniatură, pe un singur circuit integrat. El este compus dintr-un procesor, memorie și periferice și sunt folosite ca sisteme încorporate.

Microcontrolerul este un circuit integrat, care are de regulă următoarele componente:

Unitate de procesare centrală: pornind de la procesoare pe patru biți, până la procesoare pe 64 de biți;

Memorie RAM pentru stocare de date;

Memorie ROM, EPROM, EEPROM sau Flash;

Intrări și ieșiri discrete;

Port serial UART;

Alte interfețe de comunicare, cum ar fi: IIC, interfață periferică serială;

Temporizatoare, numărătoare, generatoare de semnal PWM și watchdog;

Oscilator;

Convertor analog – digital, sau digital – analog.

Fig. 2.2.1 Schema bloc generalizată a unui microcontroler

Aria de utilizare a microcontrolelor este foarte vastă, acesta fiind folosit în produse și dispozitive controlate automat.

Un microcontroler trebuie să aibă un răspuns în timp real pentru sistemul controlat. Când anumite procese au loc, un sistem de întreruperi poate semnala procesorului pentru a întrerupe instrucțiunea în curs pentru a rula o rutină de întrerupere, specifică întreruperii apărute, iar după rulare să se întoarcă în program la instrucțiunea rămasă pentru a continua execuția.

Programele rulate de un microcontroler trebuie să fie de așa dimensiuni astfel încât să poată fi salvat pe memoria acestuia. În funcție de dispozitiv, memoria acestuia poate fi fie permanentă (doar citire), sau memorie flash poate poate fi modificată.

Microcontrolere dispun de un număr de intrări/ieșiri (GPIO). Pinii acestora sunt configurabili software, astfel încât să fie de intrare sau de ieșire.

Unele microcontrolere dispun și de un convertor analogic – digital, pentru acele semnale analogice care nu pot fi interpretate de procesor care procesează în digital.

Pe lângă un convertor analogic – digital, unele microcontrolere au și temporizatoare, cel mai comun tip de temporizator fiind PIT (programmable interval timer). Acesta poate număra crescător sau descrezcător, odată ce ajunge la finalul numărării transmițând o întrerupere, anuntând astfel procesorul că a terminat numărătoarea.

Capitolul 3 Proiectarea sistemului de comandă

Alimentare servo motoare

Alimentarea servo motoarelor se face de la o sursă de calculator de la firma ALINE modelul PX – 450 care poate genera o tensiune de 5V necesară servo motoarelor. Curentul maxim asigurat de această sursă, la tensiunea de 5V este de 15 A, care este îndeajuns pentru servo motoarele utilizare. Valorile tensiunii de ieșire și a curentului generat de aceasta se poate observa în figura următoare (fig. 3.1.1).

Fig. 3.1.1 specificațiile sursei PX – 450, ALINE

Sursa aceasta a fost proiectată cu un mecanism de protecție, astfel că pentru a furniza la ieșire tensiune, și pentru a funcționa, a trebuit să se scurtcircuiteze pinul de culoare verde la masă.

Pinul de ieșire ce furnizează tensiune de 5V este de culoare roșie, iar conexiunea la masă este de culoare neagră.

Sistemul de comadă

S-a realizat comanda manuală a fiecărui servo motor, în ambele direcții și de asemenea mișcarea automată a brațului robotic astfel încât acesta să se deplaseaze din orice punct în care se află, spre primul punct țintă 1, cu gripper-ul deschis, ca acesta să prindă obiectul așezat la punctul 1 și își continuă mișcarea spre punctul final 2 unde depozitează obiectul luat din punctul anterior. Modalitățile în care s-au realizat aceste comenzi, sunt cu ajutorul mediului de programare Arduino IDE, și cu programul Matlab, prespectiv interfața Guide.

Arduino IDE

Comanda servo motoarelor se face cu ajutorul păcii de dezvoltare Arduino Mega 2560, în momentul acționării unui buton conectat la un pin digital al plăcii de dezvoltare, care este declarat în program ca și pin de intrare. Când acest buton e acționat, programul trimite semnal PWM motorului servo în cauză, incrementând sau decrementând poziția motorului. Conexiunile dintre acestea se pot observa în figura 3.2.1.1.

Fig. 3.2.1.1 Schema de legatură dintre buton, servo motor, Arduino și sursa de alimentare

Conexiunile electrice ale butoanelor s-au realizat pe un cablaj imprimat, câte un set de două butoane pentru fiecare servo motor, respectiv fiecare direcție de mișcare a motorului.

Fig. 3.2.1.2 Cablajul imprimat cu butoanele cositorite pe acesta

În partea de sus a cablajului (fig. 3.2.1.2), s-au cositorit pini de legătură între un pin al butonului și cablul de legătură cu intrarea Arduino.

În partea de jos (fig. 3.2.1.2), dreapta, s-a plasat un cablu conectat la masa butoanelor, reprezentând masa comună a butoanelor, cablu care urmează a fi conectat la unul din pinii de masă ai placii de dezvoltare Arduino.

Câte un set de două butoane pentru fiecare direcție a motorului a fost plasat pentru fiecare motor, precum se poate observa în figura 3.2.1.2. Un set de două butoane este neutilixat, datorită motorului șase care a fost scos din construcția bratului robotic. Se poate observa de asemenea setul de butoane pentru comanda automată a robotului, respectiv START/STOP.

Fig. 3.2.1.3 Conexiunea dintre pinii de legatură, pinii butoanelor și masa.

Rândul de jos al cablajului (fig. 3.2.1.3) este de fapt conexiunea la masă a fiecărui buton.

Butoanele utilizate au patru pini, legătura internă dintre aceștia fiind în ‚x’ precum se poate observa și în figura următoare (fig. 3.2.1.4), aceasta fiind de tip normal deschis. Din pinii unui buton s-a utilizat doar doi, deoarece acționarea fiecărui motor se dorește a se realiza separat.

Fig. 3.2.1.4 conexiunea internă a unui buton

Fiecare buton este conectat la un pin digital al placii Arduino, ca mai apoi acesta să fie declarat în program ca și intrare, în felul următor:

pinMode(34, INPUT_PULLUP);

Se folosește instrucțiunea pinMode() pentru declararea unui pin. Aceasta necesită doi parametrii, respectiv pinul în cauză, care poate fi precizat direct, adică numarul la care se află, sau ca o variabilă care este declarată anterior căreia îi este atribuit numarul pinului, și cel de-al doilea parametru care precizează modul în care acesta urmează a fi utilizat, respectiv ca pin de intrare sau de ieșire.

Termenul de ‚INPUT_PULLUP’ nu doar că declară pinul ca pin de intrare (INPUT), ci și specifică faptul că pinul de intrare va fi conectat la o rezistență internă de 10kOhmi, care e conectată la alimentare (PULLUP). Motivul pentru care se utilizează rezistența internă este de a stabiliza situații ce pot produce instabilitate, cum ar fi momentul în care nu este semnal pe intrare. Ceaa ce determină ca programul să citească prezența unui semnal (HIGH) pe pinul de intrare când acesta nu e apăsat, respectiv să nu aibă semnal (LOW) pe pinul de intrare cand butonul e apăsat, ceea ce modifică modul de funcționare al butonului, acesta funcționând ca un buton de tip normal închis.

Conexiunea dintre buton, pinul de intrare de la Arduino și rezistența internă se poate observa în figura următoare (fig. 3.2.1.5):

Fig. 3.2.1.5 conexiunea cu rezistența internă

După declararea modului de utilizare a pinului, acesta se poate folosi în program oridecâte ori de dorește, cu precizarea că starea acestuia trebuie continuu citită, folosind instrucțiunea digitalRead(), care are ca și parametrul pinul dorit.

int Start = digitalRead(34);

Pentru ca mediul de programare să poată recunoaște instrucțiunile specifice motoarelor servo, acesta necesită apelarea unei librării caracteristice servo motoarelor, care este:

#include<Servo.h>

La fel ca în cazul unui pin de intrare/ieșire, și pinii pentru semnalele PWM trebuie să fie declarare, și să li se asigneze numărul pinului:

servo1.attach(2);

Pentru a trimite un servo motor într-o poziție se folosește instrucțiunea [nume].write(), care are ca și parametrul fie un număr între 0 și 180, fie o variabilă căreia i se atribuie anterior o valoare.

servo2.write(150); / servo2.write(n); -unde anterior s-a declarat int n=150.

Mediul de programare Arduino IDE are și o instrucțiune pentru citirea poziției servo motorului, însă aceasta nu primește un semnal de la motor care să îi arate poziția, ci pur și simplu accesează valoarea ultimei poziții scrise de către utilizator. În cazul în care cerem să citim poziția fără ca să se introducă anterior, în primul ciclu al programului, mediul pe programare setează fiecare servo motor la o poziție standard (100), și astfel el știe să afișeze poziția motorului.

n1=servo1.read();

Liniile de cod ce asigură acționarea unui motor în cele două direcții în funcție de butonul apăsat, pentru primul servo motor, se vor lua ca exemplu pentru a putea urmări modul de funcționare:

if(plusOne==LOW) // se verifică starea butonului pentru incrementarea motorului;

{ n1=servo1.read(); // se citește poziția actuală a motorului;

if(n1<180) // se verifică dacă motorul nu este deja la limita superioară;

{n1=n1+1; // dacă nu, se continuă incrementarea motorului;

if(minusOne==LOW) // se verifică starea butonului pentru decrementarea motorului;

{n1=servo1.read(); // se citește poziția actuală a motorului;

if(n1>0) // se verifică dacă motorul nu este deja la limita inferioară;

{n1=n1-1; // dacă nu, se continuă decrementarea motorului;

servo1.write(n1); // se trimite motorul la noua poziție;

delay(50);}} // se dă timp motorului de a ajunge în poziție.

Se procedează în această manieră pentru fiecare din servo motoare, pentru a realiza intrementarea, respectiv decrementarea poziției unui motor.

Pentru comanda automată, s-a atribuit o poziție pentru fiecare din servo motoare, rularea acestora depinzând de starea pinilor de intrare corespondenți butonului START și STOP. Condițiile de rulare se pot observa din următoarea secvență de cod, specifică unei singure mișcări.

if (Start==LOW) //dacă butonul de START este acționat;

{ Stop = digitalRead(35); //se citește butonului de STOP;

if (Stop==HIGH) //dacă butonul de STOP nu e apăsat;

{n5=servo5.read(); //se citește poziția servo motorului;

if(n5 !=30) //dacă motorul nu se află deja în poziția dorită;

{servo5.write(30); //se trimite motorul în poziția dorită;

delay(700);}}} //se oferă timp motorului de a ajunge în poziția cerută.

Pentru ca orice mișcare din cadrul comenzii automate să aibă loc este necesar ca butonul de START să fi fost acționat la un moment dat, fără ca butonul de STOP să fie acționat. Dacă se acționează butonul de STOP, pentru a relua funcționarea modului automat, este neceasră acționarea butonului START ceea ce rezultă prin rularea secvenței automate de cod de la început, aceasta nefiind continuată din punctul în care a rămas.

Pentru ca mișcările brațului robotic să nu fie sacadate, s-a pus condiția ce verifică poziția motorului înainte de scriere a poziției dorite. Astfel că, dacă el se află deja în poziție se sare peste partea de scriere și peste timpul de așteptare și trece mai departe la următoarea poziție, ceea ce face întreaga mișcare mult mai legată.

Listare cod Arduino IDE:

//librarie specifica servo motoarelor

#include<Servo.h>

//declararea servo motoarelor

int n1,n2,n3,n4,n5;

Servo servo1,servo2,servo3,servo4,servo5;

//functia setup() este rulata o singura data, la inceperea pargurgerii programului pentru prima data

void setup()

//declararea pinilor de intrare pentru butoane

{pinMode(13, OUTPUT);

pinMode(34, INPUT_PULLUP);

pinMode(35, INPUT_PULLUP);

pinMode(22, INPUT_PULLUP);

pinMode(23, INPUT_PULLUP);

pinMode(24, INPUT_PULLUP);

pinMode(25, INPUT_PULLUP);

pinMode(26, INPUT_PULLUP);

pinMode(27, INPUT_PULLUP);

pinMode(28, INPUT_PULLUP);

pinMode(29, INPUT_PULLUP);

pinMode(30, INPUT_PULLUP);

pinMode(31, INPUT_PULLUP);

pinMode(32, INPUT_PULLUP);

pinMode(33, INPUT_PULLUP);

//asignarea pinilor servo motoarelor

servo1.attach(2);

servo2.attach(3);

servo3.attach(4);

servo4.attach(5);

servo5.attach(6);

//scrierea servo motorului 2 la pozitia 150

servo2.write(150);}

//functia void este rulata in mod repetitiv

void loop()

{

// citirea pozitiei fiecarui servo motor

n1=servo1.read();

n2=servo2.read();

n3=servo3.read();

n4=servo4.read();

n5=servo5.read();

//citirea starii butoanelor, si asignarea acestora unor variabile

int Start = digitalRead(34);

int Stop = digitalRead(35);

int plusOne = digitalRead(22);

int minusOne = digitalRead(23);

int plusTwo = digitalRead(24);

int minusTwo = digitalRead(25);

int plusThree = digitalRead(26);

int minusThree = digitalRead(27);

int plusFour = digitalRead(28);

int minusFour = digitalRead(29);

int plusFive = digitalRead(30);

int minusFive = digitalRead(31);

//realizarea miscarii servo motorului 1 in functie de starea butoanelor

if(plusOne==LOW)

{ n1=servo1.read();

if(n1<180)

{n1=n1+1;}}

if(minusOne==LOW)

{n1=servo1.read();

if(n1>0)

{n1=n1-1;}}

servo1.write(n1);

delay(50);

//realizarea miscarii servo motorului 2 in functie de starea butoanelor

if(plusTwo==LOW)

{n2=servo2.read();

if(n2<180)

{n2=n2+1;}}

if(minusTwo==LOW)

{n2=servo2.read();

if(n2>0)

{n2=n2-1;}}

servo2.write(n2);

delay(50);}}

//realizarea miscarii servo motorului 3 in functie de starea butoanelor

if(plusThree==LOW)

{n3=servo3.read();

if(n3<179)

{n3=n3+1;}}

if(minusThree==LOW)

{n3=servo3.read();

if(n3>1)

{n3=n3-1;}}

servo3.write(n3);

delay(50);}}

//realizarea miscarii servo motorului 4 in functie de starea butoanelor

if(plusFour==LOW)

{n4=servo4.read();

if(n4<100)

{n4=n4+1;}}

if(minusFour==LOW)

{n4=servo4.read();

if(n4>1)

{n4=n4-1;}}

servo4.write(n4);

delay(50);}}

//realizarea miscarii servo motorului 5 in functie de starea butoanelor

if(plusFive==LOW)

{n5=servo5.read();

if(n5<179)

{n5=n5+1;}}

if(minusFive==LOW)

{n5=servo5.read();

if(n5>1)

{n5=n5-1;}}

servo5.write(n5);

delay(50);}}

//secventa de cod pentru rulare automata

if (Start==LOW)

{ Stop = digitalRead(35);

if (Stop==HIGH)

{n5=servo5.read();

if(n5 !=30)

{servo5.write(30);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n4=servo4.read();

if(n4!=105)

{servo4.write(105);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n2=servo2.read();

if(n2=130)

{servo2.write(130);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n2=servo2.read();

if(n2=150)

{servo2.write(150);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n1=servo1.read();

if(n1!=70)

{servo1.write(70);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n3=servo3.read();

if(n3!=90)

{servo3.write(90);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n2=servo2.read();

if(n2!=130)

{servo2.write(130);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n2=servo2.read();

if(n2!=110)

{servo2.write(110);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{ n5=servo5.read();

if(n5!=90)

{servo5.write(90);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n2=servo2.read();

if(n2!=130)

{servo2.write(130);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n2=servo2.read();

if(n2!=150)

{servo2.write(150);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n1=servo1.read();

if(n1!=20)

{servo1.write(20);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n4=servo4.read();

if(n4!=110)

{servo4.write(110);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n2=servo2.read();

if(n2!=130)

{servo2.write(130);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n2=servo2.read();

if(n2!=110)

{servo2.write(110);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n5=servo5.read();

if(n5!=30)

{servo5.write(30);

delay(700);}}

Stop = digitalRead(35);

if (Stop==HIGH)

{n2=servo2.read();

if(n2!=150)

{servo2.write(150);

delay(700);}}

}}

Matlab (interfața Guide)

Versiunea utilizată pentru realizarea interfeței este Matlab 2018, aceasta fiind utilizată în mod de testare.

În cadrul Matlab s-a realizat o interfață în Guide care realizază aceleași mișcări ca și în cazul mediului de programare Arduino IDE, cu diferența că butoanele care în cadrul proiectării cu ajutorul Arduino IDE au fost fizice, în cazul acesta, folosindu-se în interfață reprezentări ale butoanelor, fără a fi necesară prezența butoanelor fizice, astfel ușurând semnificativ procesul nefiind necesară cositorirea butoanelor și realizarea legăturilor, și deasemenea micșorând dramatic riscul de nefuncționare a robotului din cauza unei conexiuni întrerupte, sau realizate greșit.

Modul de așezare a butoanelor în cadrul interfeței se poate observa în figura următoare (fig. 3.2.2.1):

Fig. 3.2.2.1 interfața Matlab.

S-a delimitat comanda pentru fiecare servo motor, respectiv afișazul poziției pentru fiecare motor. Fiecare bloc al unui servo motor conține blocul text unde se scrie poziția în care dorim ca motorul să meargă, și un afișor, cu ajutorul căruia vedem poziția în care se află motorul.

Problema legată de citirea poziției exacte a unui servo motor rămâne, ca și în cazul mediului de programare Arduino IDE. Această problemă s-ar putea rezolva doar cu traductoare atașate fiecărei cuple cimenatice conducătoare, astfel încât să se cunoască poziția motorului în orice moment. Diferența dintre mediul de programare Arduino și Matlab apare la modul de citire a poziției.

Precum s-a specificat legat de mediul de programare Arduino, acesta, la citirea poziției servo motorului, de fapt returnează ultima poziție trimisă motorului, pe cand în mediul Matlab poziția returnată ține cont de semnalul PWM trimis către motorul servo. Deoarece precizia de generare a semnalului PWM este mai mică, apar diferențe mici dintre valoarea cerută, și valoarea afișată.

În momentul creării unei interfețe, Matlab automat generază un cod sursă, în care utilizatorul urmează a face modificări, doar în anumite părți ale codului. Astfel au făcut ca interacțiunea dintre operator și mediul de programare să fie mult mai prietenoasă.

La fel ca în cazul Arduino, Matlab are o funcție care se rulează doar o dată și anume la începutul rulării programului. În această funcție am șters toate variabilele folosite, am declarat o variabila de tip arduino, iar mai apoi am declarat servo motoarele, respectiv pinii la care acestea sunt conetate.

clear all; //ștergerea variabilelor

global a;

a=arduino; //declararea unei variabile globale de tip arduino

global motor_s1 motor_s2 motor_s3 motor_s4 motor_s5;

motor_s1 = servo(a, 'D2'); //declararea servo motoarelor, alocarea acestora la un anumit pin

motor_s2 = servo(a, 'D3');

motor_s3 = servo(a, 'D4');

motor_s4 = servo(a, 'D5');

motor_s5 = servo(a, 'D6');

writePosition(motor_s2,150/180); // trimiterea servo motorului 2 în poziția 150.

Fiecare bloc de text din interfață are o funcție numită ‘Callback’, care în momentul editării blocului de text și apăsării tastei ‘Enter’, rulează codul din cadrul funcției respective. În acest sens, după scrierea valorii poziției dorite, în unul din blocurile de text, și apăsării tastei ‘Enter’, se extrage valoarea scrisă, ca mai apoi aceasta să fie folosită în cod pentru a mișca roboul în poziția cerută.

global a motor_s1; //accesare variabile din funcția de introducere

value=str2double(get(hObject,'String')); //citirea, convertirea sirului de caractere în număr

angle=value/180; // calcularea valorii pentru unghiul introdus

writePosition(motor_s1,angle); //scriere poziție motor

pause(1); //așteptare terminare mișcare robot

position=readPosition(motor_s1); //citire poziție servo motor

set(handles.citire_s1,'String',position*180); //afișarea poziției citite

Pentru a putea folosi variabilele trecute în funcția de inceput, sau în orice alta funcție, acestea trebuie declarate ca și variabile globate, iar apoi de fiecare dată când sunt folosite să se apeleze din nou ca și globale.

În Matlab, pentru scrierea poziției unui motor se folosesc valori între 0 și 1, unde 0 ar fi unghiul de 0 grade, iar 1 ar fi unghiul de 180 grade. La fel este și la citirea poziției motorului, returnând o valoare între 0 și 1.

În felul acesta de procedează și pentru celelalte servo motoare.

Pentru comanda în mod automat, secvența e asemănătoare cu cea din Arduino, diferențând limbajul de programare. Pentru a exemplifica se ia o secvență de cod, pentru realizarea uneia dintre mișcările robotului. Această secvență de cod se rulează la acționarea butonului de START din interfață.

if get(handles.Stop,'userdata') // se verifică starea butonului de STOP

bit=0; //dacă acesta e activat, se setează bit=0

end

if(bit==1) // în cazul în care bit=1 se poziționează motorul

angle=30/180; //calcularea valorii pentru 30 grade

writePosition(motor_s5,angle); //repoziționarea robotului

pause(0.7); //așteptare poziționare robot

angle=readPosition(motor_s5); //citirea poziției motorului servo

set(handles.citire_s5,'String',angle*180); //afișarea poziției citite

end

Datorită micilor diferențe ce apar între valoarea scrisă, și valoarea citită, nu este posibilă asigurarea unui traseu cât mai lin, astfel evitând pauzele de timp pentru dățile în care robotul este deja în poziția dorită.

În momentul acționării butonului de STOP, se setează o variabilă care nu mai lasă ca mișcarea în mod automat a robotului să se realizeze. Acest lucru se face în funcția specifică butonului de STOP, funcția Callback acestuia, prin următoarea linie de cod:

set(gcbo,'userdata',1);

În momentul reapăsării butonului de START, această variabilă setată de funcția STOP, se resetează, astfel fiind din nou posibilă rularea secvenței automate, aceasta fiind reluată de la început.

set(handles.Stop,'userdata',0);

Listare cod Matlab

function varargout = proiect_licenta(varargin)

% PROIECT_LICENTA MATLAB code for proiect_licenta.fig

% PROIECT_LICENTA, by itself, creates a new PROIECT_LICENTA or raises the existing

% singleton*.

%

% H = PROIECT_LICENTA returns the handle to a new PROIECT_LICENTA or the handle to

% the existing singleton*.

%

% PROIECT_LICENTA('CALLBACK',hObject,eventData,handles,…) calls the local

% function named CALLBACK in PROIECT_LICENTA.M with the given input arguments.

%

% PROIECT_LICENTA('Property','Value',…) creates a new PROIECT_LICENTA or raises the

% existing singleton*. Starting from the left, property value pairs are

% applied to the GUI before proiect_licenta_OpeningFcn gets called. An

% unrecognized property name or invalid value makes property application

% stop. All inputs are passed to proiect_licenta_OpeningFcn via varargin.

% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one

% instance to run (singleton)".

% See also: GUIDE, GUIDATA, GUIHANDLES

% Edit the above text to modify the response to help proiect_licenta

% Last Modified by GUIDE v2.5 23-Jun-2018 16:22:27

% incepere cod de inițializare – A NU SE EDITA

gui_Singleton = 1;

gui_State = struct('gui_Name', mfilename, …

'gui_Singleton', gui_Singleton, …

'gui_OpeningFcn', @proiect_licenta_OpeningFcn, …

'gui_OutputFcn', @proiect_licenta_OutputFcn, …

'gui_LayoutFcn', [] , …

'gui_Callback', []);

if nargin && ischar(varargin{1})

gui_State.gui_Callback = str2func(varargin{1});

end

if nargout

[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});

else

gui_mainfcn(gui_State, varargin{:});

end

% sfârșit cod de inițializare – A NU SE EDITA

% – Se execută chiar înainte ca proiectul salvat să fie vizibil

% aceasta este funcția de inițializare

function proiect_licenta_OpeningFcn(hObject, eventdata, handles, varargin)

% Această funcție nu are argumente

% hObject apelare variabila în cauză

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

handles.output = hObject;

% rescrie variabila handles

guidata(hObject, handles);

%declararea variabilei ce face referire la arduino, și a servo motoarelor.

clear all;

global a;

a=arduino;

global motor_s1 motor_s2 motor_s3 motor_s4 motor_s5;

motor_s1 = servo(a, 'D2');

motor_s2 = servo(a, 'D3');

motor_s3 = servo(a, 'D4');

motor_s4 = servo(a, 'D5');

motor_s5 = servo(a, 'D6');

writePosition(motor_s2,150/180);

% UIWAIT face ca proiectul să aștepte după răspuns

% uiwait(handles.figure1);

% – iesirile vor fi afișate în linia de comandă

function varargout = proiect_licenta_OutputFcn(hObject, eventdata, handles)

% varargout șir ce returnează argumentele de ieșire

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

% Get default command line output from handles structure

varargout{1} = handles.output;

%secvență de cod ce se rulează la introducerea unei valori în blocul text

function unghi_s1_Callback(hObject, eventdata, handles)

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

%citire și conversie șir de caractere în număr întreg

%calcularea valorii între 0-1 pentru unghiul introdus

%scriere poziție și afișare poziție citită

global a motor_s1;

value=str2double(get(hObject,'String'));

angle=value/180;

writePosition(motor_s1,angle);

pause(1);

position=readPosition(motor_s1);

set(handles.citire_s1,'String',position*180);

% – se execută la crearea obiectului

function unghi_s1_CreateFcn(hObject, eventdata, handles)

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');

end

% se execută la crearea obiectului

function citire_s1_CreateFcn(hObject, eventdata, handles)

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

function unghi_s5_Callback(hObject, eventdata, handles)

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

%citire și conversie șir de caractere în număr întreg

%calcularea valorii între 0-1 pentru unghiul introdus

%scriere poziție și afișare poziție citită

global a motor_s5;

value=str2double(get(hObject,'String'));

angle=value/180;

writePosition(motor_s5,angle);

pause(1);

position=readPosition(motor_s5);

set(handles.citire_s5,'String',position*180);

% se execută la crearea obiectului

function unghi_s5_CreateFcn(hObject, eventdata, handles)

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

% See ISPC and COMPUTER.

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');

end

function unghi_s4_Callback(hObject, eventdata, handles)

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

%citire și conversie șir de caractere în număr întreg

%calcularea valorii între 0-1 pentru unghiul introdus

%scriere poziție și afișare poziție citită

global a motor_s4;

value=str2double(get(hObject,'String'));

angle=value/180;

writePosition(motor_s4,angle);

pause(1);

position=readPosition(motor_s4);

set(handles.citire_s4,'String',position*180);

% se execută la crearea obiectului

function unghi_s4_CreateFcn(hObject, eventdata, handles)

% See ISPC and COMPUTER.

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');

end

function unghi_s3_Callback(hObject, eventdata, handles)

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

%citire și conversie șir de caractere în număr întreg

%calcularea valorii între 0-1 pentru unghiul introdus

%scriere poziție și afișare poziție citită

global a motor_s3;

value=str2double(get(hObject,'String'));

angle=value/180;

writePosition(motor_s3,angle);

pause(1);

position=readPosition(motor_s3);

set(handles.citire_s3,'String',position*180);

% se execută la crearea obiecutlui

function unghi_s3_CreateFcn(hObject, eventdata, handles)

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');

end

function unghi_s2_Callback(hObject, eventdata, handles)

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

%citire și conversie șir de caractere în număr întreg

%calcularea valorii între 0-1 pentru unghiul introdus

%scriere poziție și afișare poziție citită

global a motor_s2;

value=str2double(get(hObject,'String'));

angle=value/180;

writePosition(motor_s2,angle);

pause(1);

position=readPosition(motor_s2);

set(handles.citire_s2,'String',position*180);

% se execută la crearea unui obiect

function unghi_s2_CreateFcn(hObject, eventdata, handles)

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');

end

% se execută la acționarea butonului Start.

function Start_Callback(hObject, eventdata, handles)

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

%verificare stare buton STOP

%scrierea fiecărei poziții cu condiția ca butonul de STOP să nu fie acționat

% afișare poziție citită

global motor_s1 motor_s2 motor_s3 motor_s4 motor_s5;

bit=1;

set(handles.Stop,'userdata',0);

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

angle=30/180;

writePosition(motor_s5,angle);

pause(0.7);

angle=readPosition(motor_s5);

set(handles.citire_s5,'String',angle*180);

end

angle=105/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s4,angle);

pause(0.7);

angle=readPosition(motor_s4);

set(handles.citire_s4,'String',angle*180);

end

angle=150/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s2,angle);

pause(0.7);

angle=readPosition(motor_s2);

set(handles.citire_s2,'String',angle*180);

end

angle=70/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s1,angle);

pause(0.7);

angle=readPosition(motor_s1);

set(handles.citire_s1,'String',angle*180);

end

angle=90/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s3,angle);

pause(0.7);

angle=readPosition(motor_s3);

set(handles.citire_s3,'String',angle*180);

end

angle=130/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s2,angle);

pause(0.7);

angle=readPosition(motor_s2);

set(handles.citire_s2,'String',angle*180);

end

angle=110/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s2,angle);

pause(0.7);

angle=readPosition(motor_s2);

set(handles.citire_s2,'String',angle*180);

end

angle=90/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s5,angle);

pause(0.7);

angle=readPosition(motor_s5);

set(handles.citire_s5,'String',angle*180);

end

angle=130/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s2,angle);

pause(0.7);

angle=readPosition(motor_s2);

set(handles.citire_s2,'String',angle*180);

end

angle=150/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s2,angle);

pause(0.7);

angle=readPosition(motor_s2);

set(handles.citire_s2,'String',angle*180);

end

angle=20/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s1,angle);

pause(0.7);

angle=readPosition(motor_s1);

set(handles.citire_s1,'String',angle*180);

end

angle=110/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s4,angle);

pause(0.7);

angle=readPosition(motor_s4);

set(handles.citire_s4,'String',angle*180);

end

angle=130/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s2,angle);

pause(0.7);

angle=readPosition(motor_s2);

set(handles.citire_s2,'String',angle*180);

end

angle=110/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s2,angle);

pause(0.7);

angle=readPosition(motor_s2);

set(handles.citire_s2,'String',angle*180);

end

angle=30/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s5,angle);

pause(0.7);

angle=readPosition(motor_s5);

set(handles.citire_s5,'String',angle*180);

end

angle=150/180;

if get(handles.Stop,'userdata')

bit=0;

end

if(bit==1)

writePosition(motor_s2,angle);

pause(0.7);

angle=readPosition(motor_s2);

set(handles.citire_s2,'String',angle*180);

end

% se execută la acționarea butonului de Stop.

function Stop_Callback(hObject, eventdata, handles)

% eventdata – rezervat

% handles structură ce conține valorilor variabilei

% varargin argument de comandă

%se setează variabila userdata pe 1

set(gcbo,'userdata',1);