Subsistemul software Obinerea preciziei maxime n poziionarea unui robot SCARA Programarea n virgul fix.

Sistemul de conducere al robotului, reunete

sistemul de comand, sistemul de acionare elementele de inteligent artificial.

 Sarcina principal a sistemului de comand este de a transpune programele de aplicaie n micri relative al elementelor cuplelor cinematice conductoare ale dispozitivului de ghidare.

Comanda micrii este prima sarcina a sistemului de comand i const n: coordonarea i supravegherea (controlul) micrii efectorului final prin siturile programate, sau a punctului caracteristic M pe traiectoriile programate; sincronizarea desfurrii micrilor robotului ce evenimentele care au loc la periferia robotului prin prelucrarea semnalelor externe preluate din procesul de producie (maini unelte, dispozitive de lucru etc.) prelucrarea datelor de la senzorii externi (sisteme de prelucrarea imaginilor) i transpunerea rezultatelor prelucrate n reaciile dorite.

Se impune a doua sarcin a sistemului de comand - programarea robotului. Prin programarea robotului se realizeaz n primul rnd dialogul cu operatorul uman, cruia i se pun la dispoziie comenzile i funciile pentru conceperea, corectarea i testarea programului de micare, precum i dispozitivele de: introducere, scoatere i arhivare a programului.

Sarcinile sistemului de comand sunt realizate de cele dou componente ale sale: subsistemul hardware bazat pe microprocesor; subsistemul software.

Programarea n virgul fix. Obinerea preciziei maxime n poziionarea unui robot SCARA

 Modul n care se reprezint datele numerice ntr-un calculator are legtur direct cu structura UCP, avnd influen asupra dimensiunii registrelor de uz general locale, al dimensiunii magistralei interne i al complexitii unitii de execuie.

Reprezentarea n virgul fix

Reprezentarea n virgul fix este folosit de majoritatea calculatoarele numerice de uz general. Acestea lucreaz cu numere ntregi n virgul fix, datorit avantajelor n ceea ce privete structura hardware a circuitelor pentru operaii aritmetice i logice. Reprezentarea n virgul fix cu numere subunitare are avantaje din punctul de vedere al operaiilor de nmulire, pentru c aceast operaie nu va duce la depirea capacitii de reprezentare pentru produs.

Reprezentarea cu virgul fix

Pozitia virgulei este fix fa de irul de bii prin care se reprezint data numeric. Reprezentarea numerelor n virgul fix sub form de numere ntregi cu semn sau fr semn. Exist de asemenea posibilitatea de a reprezenta datele n virgul fix sub forma de numere subunitare. Daca procesorul calculatorului lucreaz n virgul fix cu numere subunitare, la introducerea datelor, fiecrui numr i se ataeaz un factor de scar, care s-l transforme ntr-un numr subunitar. Acest aliniament este fcut de programul de ncrcare n memorie. n compilatoarele scrise pentru virgul fix, factorul de scar este tratat de compilator, astfel nct utilizatorul limbajelor de nivel nalt nu trebuie s ia n considerare acest aspect la efectuarea operaiilor.

 Inconvenientul acestor procesoare:

un volum mai mare de munc i o atenie sporit din partea programatorului care trebuie s manipuleze numerele n aa fel nct procesorul s poat face operaii cu numere preluate din lumea real, n gama proprie de reprezentare .

 Interpretarea numerelor n virgul fix ca numere fracionare

Programatorul plaseaz o virgul imaginar, care-l separ ntr-o component ntreag i una fracionar Sunt fixe att numrul de poziii ale prii ntregi ct i numrul de poziii ale prii fracionare Virgula nu se reprezint fizic n registrele procesorului, dar poziia sa este cunoscut i fixat de ctre programator pentru a putea interpreta numerele ntr-un mod mult mai intuitiv i mai apropiat de lumea real

 Pentru reprezentarea numerelor pozitive i negative se aloc un bit suplimentar, care indic semnul.

(a)

(b)

Numr cu semn reprezentat n virgul fix (a) interpretat fracionar, (b) interpretat intreg
bitul de semn S partea ntreag partea fracionar, format din Q bii

 Notaia utilizata n mod curent pentru reprezentarea n virgul fix n reprezentarea unui numr semn Qi.q, unde: i - numrul de bii al componentei ntregi a numrului, q - numrul de bii al componentei fracionare. Suma i + q + 1 este numrul total de bii disponibil pentru a reprezinta valoarea a lungimii cuvntului. Limitele maxime i minime de reprezentare n virgul fix a unui numr cu semn sunt date de relatia:

2i + q 2i + q 1 q n 2 2q
Pentru reprezentarea unui numr ntreg, pe n bii fr semn se utilizeaz notaia UQi.q, unde U indic o reprezentare fr bit de semn

Cteva dintre formatele reprezentare n virgul fix

Exemplificarea reprezentrii unui format care include att parte ntreag ct i fracionar, Q3.12, pentru numerele cu semn

Exemplu de nmulirire a dou numere pe 16 bii cu semn, in format Q.15

a = nr . 16 biti
b = nr . 16 biti

*
32 biti

<< 1
>> 16

rezultat =
nr. 16 biti

Probleme specifice programrii n virgul fix i soluii uzuale

Posibilitatea de depire a limitelor de reprezentare n timpul execuiei programului Adunarea i scderea numerelor n virgul fix returneaz rezultate corecte atta vreme ct nu se depesc limitele precizate. n cazul n care apare o depire a limitelor (overflow) rezultatul este greit, cu eroare foarte mare.

32768 32767

 Ca prim soluie general, de siguran, se limiteaz forat rezultatul la limita pozitiv sau negativ, operaie numit saturare. n general, procesoarele n virgul fix permit saturarea automat a rezultatului, prin setarea de ctre programator a unui anumit bit de control.

 O alt problem este necesitatea transpunerii numerelor din lumea real n formatul specific (nativ) al procesorului numere ntregi pe 8, 16 sau 32 de bii, utiliznd ct mai bine puterea de reprezentare a formatului existent. Soluia este scalarea mrimilor

 Reprezentarea n virgul fix cu numere subunitare are avantajul important c prin operaia de nmulire nu se depete capacitatea de reprezentare (produsul a dou numere subunitare este tot subunitar).
Limitele de reprezentare pentru numere pe 16 bii, cu semn
Intervalul de reprezentare la nivelul procesorului, ca numere intregi [-3276832767]
0

Intervalul de reprezentare n interpretarea fracionar de ctre programator [-1, 1)

0

(mai precis [-1...0.9999695])

( )
16384

(+)
16384

( )

(+ )

0.5

0.5

32768

32767

1 1

Reprezentarea numerelor ntregi cu semn pe 16 bii: (a) cu numere ntregi i (b)formatul echivalent Q.15, n interpretare fracionar

Exemplul 2. Poziionarea robotului SCARA folosind reprezentarea n virgul fix

Transformarea de coordonate din sistemul de coordonate cartezian n sistemul de coordonate polar Calcul distanta r1, de la origine pn la punctul caracteristic din planul de lucru
2 2 ri2 = l1 + l2 2l1 l2 cos 2
y

2 2 2 l1 l r + 2 i 2 = arccos l1l2 2 2 2 2 l1 l2 + ri + 1 = arccos 2l1ri

l2
l1 1 2

A( xi , yi )
yi xi

ri

Relaia de calcul a unghiului

 Relaiile ce definesc poziia final a braului robotului reprezint ecuaia ce permite calculul unghiurilor
l 2 l 2 + x2 + y2 xi 1 2 i i 1 = arccos + arccos 2l x 2 + y 2 x2 + y2 1 i i i i
2 2 2 2 l1 + l x y 2 i i 2 = arccos 2 l l 1 2

 Rescrierea relatiilor de calcul

2 2 2 l1 l + r xi 2 i + arccos 1 = + = arccos 2 l r r 1 i i 4 14 24 3 144 2444 3 = =
y

l2
l1 2

2 l12 l2 + ri2 = arccos 2l r 1 i

2 2 l1 l2 1 arg1 = 2l1 r i 1 4 2 4 3 C1

A( xi , yi )

ri xi

yi
x

1 1 r C + = + C2ri 1 i 2l ri 1 1 2 3
C2

2 2 2 l1 + l r 2 i 2 = arccos 2l1l2

2 l12 +l2 1 2 arg2 = ri = C3 C4ri2 2l l 1 2 2l1l2 2 3 1 4 2 4 3 1 C3 C4

coeficienii C1, C2, C3, C4 vor fi folosii n programul scris n NXC, care se va rula pe microcontrolerul robotului

Procedeul de scalare pentru a trece n formatul Q15.

Pasul 1. Raportarea tuturor mrimilor de intrare. Raportarea tuturor mrimilor de intrare i de ieire la nite valori maxime, alese astfel nct mrimile s devin subunitare. Marimile de iesire nu s-au raportat la nimic, fiind argumente ale functiei arccos. Valorile raportate sunt: y real x real yr = xr = DIM _ MAX DIM _ MAX

Pasul 2. Aceste rapoarte se pun n eviden n expresia de calcul a ieirii, i se modific coeficienii astfel nct s se pastreze echivalena expresiei (cu cea iniial). ri DIM _ MAX C1 ( ) arg 1 = + C DIM _ MAX = 2 DIM _ MAX DIM _ MAX ri
1 C1 = + (C 2 DIM _ MAX ) rr DIM _ MAX rr

Pasul 3. Noii coeficieni (pentru simplitate nu s-a schimbat notaia), obinui la pasul anterior, se raporteaz la (cel puin) maximul lor, pentru a deveni subunitari. C1 Expresia devine:
(C 2 DIM _ MAX ) DIM _ MAX 1 arg 1 = + rr COEF _ MAX COEF _ MAX r r COEF _ MAX

C1 COEF _ MAX = max , (C 2 DIM _ MAX DIM _ MAX

Se va construi un bra de robot alctuit din cele dou elemente mobile, articulate, acionate separat de cte un motor NXT exemplificarea unei structuri mecanice Se stabilesc originea i cele dou axe ale sistemului de coordonate; Orientarea braului robotului se va realiza n plan; Considernd modelul cinematic al sistemului, se va concepe programul care s permit realizarea pozitionrii braului robotului SCARA n sistemul (XOY). Testarea programului: Pentru fiecare punct de coordonate xi,yi dorit (inta de atins), se compar coordonatele atinse cu cele dorite.

Programul Matlab pentru scalare coeficienti

% Scalarea coeficientilor C1, C2, C3 si C4 din exemplul SCARA, in Matlab % Coeficientii C1...C4 apar in expresiile de calculul al argumentelor arg1 si arg2 %============================================================ % Constantele date %============================================================ % Pasul 2. Alegerea coeficientului maxim COEF_MAX (putere a lui 2) astfel % incat coeficientii sa devina subunitari prin raportarea la COEF_MAX. %================================================================== % pentru C1 si C2:

L1 = 12; L2 = 8;

% [cm] Lungimea primului segment, articulat in punctul de sprijin al bratului

COEF_C1C2 = 2^(ceil(log2(max(C1,C2)))); SH_C1C2 = (ceil(log2(max(C1,C2))))

% COEF_C1C2 = ceil(max(C1,C2)) % pentru C3 si C4:
% pt varianta fara puteri ale lui 2

% [cm] Lungimea celui de-al doilea segment %============================================================ % Pasul 1. Stabilirea limitelor maxime in care se pot incadra variabilele de intrare si iesire. % In cazul de fata variabilele de intrare se folosesc in programul NXC pentru calculul % argumentelor functiei arccos. Aceste argumente trebuie sa rezulte in intervalul [-1, 1), % deci nu e nevoie sa le raportam la o limita maxima. %============================================================ % Limita maxima a zonei de acoperire a bratului robotului este un cerc cu raza data % de cele doua brate in prelungire, deci egala cu DIM_MAX = L1+L2.

COEF_C3C4 = 2^(ceil(log2(max(C3,C4)))); SH_C3C4 = (ceil(log2(max(C3,C4))))

% COEF_C3C4 = ceil(max(C3,C4))
% pt varianta fara puteri ale lui 2 %================================================================== % Pasul 3. Calculul coeficientilor scalati %================================================================== % pentru C1 si C2:

DIM_MAX = L1 + L2
% Se alege o putere a lui 2 imediat urmatoare: % DIM_MAX = 2^(ceil(log2(DIM_MAX))) % Coef C1 si C2 intra in calculul argumentului arg1 % Prin raportarea variabilelor de intrare x si y la valoarea DIM_MAX, % coeficientii C1 si C2 se modifica astfel:

C1_sc = C1 * 32767/COEF_C1C2; C1_sc = floor(C1_sc + 0.5) % rotunjire C2_sc = C2 * 32767/COEF_C1C2; C2_sc = floor(C2_sc + 0.5) % rotunjire
% pentru C3 si C4:

C1 = (L1^2 - L2^2)/(2*L1) / DIM_MAX C2 = 1/(2*L1) * DIM_MAX

% Coef C3 si C4 intra in calculul argumentului arg2 % Coef rezultati:

C3 = (L1^2 + L2^2)/(2*L1*L2) C4 = 1/(2 * L1 * L2) * (DIM_MAX)^2

C3_sc = C3 * 32767/COEF_C3C4; C3_sc = floor(C3_sc + 0.5) % rotunjire C4_sc = C4 * 32767/COEF_C3C4; C4_sc = floor(C4_sc + 0.5) % rotunjire
disp('---------------------------------') %--------------------------------------------------------------------------------------

Program NXC
/**************************************************************************************/ // Constante /*************************************************************************************/ // Valoarea de raportare a marimilor de intrare. // TREBUIE SA FIE IDENTICA CU CEA INTRODUSA IN FISIERUL // IN CARE S-AU SCALAT COEFICIENTII #define DIM_MAX 20 // [cm] // Coeficientii scalati #define C1 5461 #define C2 27306 #define C3 8874 #define C4 17066 #define SH_C1C2 0 #define SH_C3C4 2 //#define COEF_C1C2 1 //#define COEF_C3C4 3 // macro pentru scalarea variabilelor de intrare #define Ks (32767/DIM_MAX) #define SCAL(x) (x*Ks) // "viteza" stabilita pentru rotirea motoarelor #define pwr 20 /************************************************************************************/ // Macrouri pentru multiplicare si impartire in C, pentru formatul Q15 /************************************************************************************/ #define MUL(a,b) ((a*b)>>15) #define DIV(a,b) ((a<<15)/b) // Macro pt trecerea din fractionar Q15 in procente, folosit pentru argumentele functiei acos din NXC #define SCALARE_100(a) (((a*100)>>14)+1*sign(a))>>1 /* cu rotunjire, tinand cont de semn */

Program NXC (continuare)

// Macro-ul pt "breakpoint", realizat in lucrarea 2. #define BREAKPOINT_AFISARE_VAR(string_x,x){\ TextOut(0,LCD_LINE1,string_x,true);\ NumOut(0,LCD_LINE2,x);\ Wait(1000);\ while(ButtonPressed(BTNCENTER,true)==0)\ {\ }\ } short x_real, y_real; // coordonatele reale, introduse in aceeasi // unitate de masura folosita pentru DIM_MAX short x, y; // coordonatele scalate short r; // modulul vectorul de pozitie al punctului tinta short r_patrat; // r la patrat // Unghiurile, calculate cu functia acos din NXC rezulta in [grade]. // Tot in grade se vor introduce si unghiurile corespunzatoare pozitiei initiale short arg1, arg2; // argumente ale functiei Acos, pt calculul unghiurilor gama si theta2 short theta1, theta2; // unghiurile celor doua segmente ale bratului short theta1_ant, theta2_ant; // valorile unghiurlor coresp. pozitiei anterioare short D_theta1, D_theta2; // unghiurile cu care tb. rotite cele doua motoare pt // a muta capatul bratului in poz ceruta short theta, gama; // unghiuri auxiliare short temp; // variabila pentru calcule intermediare long temp_long; // variabila pentru calcule intermediare

Program NXC (continuare)

task main() { // initializare unghiuri coresp. pozitiei initiale a bratului theta1_ant = 0; //[grade] theta2_ant = 180; //[grade] // variabilele de intrare: coordonatele dorite, in [cm] x_real = 4; y_real = 0; // Scalare variabile de intrare x = SCAL(x_real); y = SCAL(y_real); // r^2 = x^2 + y^2 // Variabila r^2 se pastreaza intr-o variabila, pt ca se va folosi mai multe ori in program. // Operatia trebuie facuta in doi pasi, pt a putea fi compilata. r_patrat = MUL(x,x); r_patrat = r_patrat + MUL(y,y); temp_long = r_patrat<<15; r = Sqrt(temp_long); //BREAKPOINT_AFISARE_VAR("r= ",r); // Calcul theta = arccos(x/r) // Inainte de impartirea x/r se testeaza daca x>=r. // Aceasta deoarece numaratorul trebuie sa fie mai mic decat numitorul, // pt a nu avea depasire in formatul Q15. if (x>=r) // daca x>=r temp = 32767; // rezultatul se satureaza la ~1, ie 32767 else temp = DIV(x,r); // altfel, se face impartirea temp = SCALARE_100(temp); // scalare in procente (arg functiei Acos din NXC) theta = Acos(temp); //BREAKPOINT_AFISARE_VAR("theta= ",theta);

Program NXC (continuare)

//Calcul argument arg1 = C1/r + C2*r (pentru unghiul gama) // Ca sa evitam depasirea la impartire rearanjam expresia astfel: // arg1 = (C1+C2*r^2)/r, adica facem impartirea la sfarsit, stiind ca arg1 trebuie sa rezulte natural, // geometric, in intervalul [-1,1]. temp = MUL(r,r); temp = MUL(C2,temp); temp = temp + C1; // In situatia, posibila, in care numaratorul si numitorul ar fi egali, rezultatul ar trebui sa fie ~1. // Facem deci acelasi test ca la impartirea anterioara: if (temp>=r) // daca x>=r temp = 32767; // rezultatul se satureaza la ~1, ie 32767 else temp = DIV(temp,r); // altfel, se face impartirea arg1 = temp; // Inmultirea directa a argumentului arg1 cu coeficientul COEF_C1C2 folosit la scalare. /* Daca COEF_C1C2 s-a ales ca putere a lui 2, se face deplasare (shift) la stanga, in loc de inmultire directa */ arg1 = arg1 << SH_C1C2; //arg1 = arg1 * COEF_C1C2; // calcul unghi gama arg1 = SCALARE_100(arg1); // scalare in procente (arg functiei Acos din NXC) gama = Acos(arg1); //BREAKPOINT_AFISARE_VAR("gama= ",gama);

Program NXC (continuare)

//Calcul arg2 = C3 - C4*r^2, pt unghiul theta2 temp = MUL(r,r); temp = MUL(C4,temp); arg2 = C3 - temp; arg2 = arg2 << SH_C3C4; //arg2 = arg2 * COEF_C3C4; // calcul theta2 arg2 = SCALARE_100(arg2); theta2 = Acos(arg2);

// scalare in procente (arg functiei Acos din NXC)

BREAKPOINT_AFISARE_VAR("theta2= ",theta2); // calcul theta1 = gama + theta theta1 = gama + theta; BREAKPOINT_AFISARE_VAR("theta1= ",theta1); // Calcul unghiurilor cu care trebuie rotite motoarele, fata de pozitia anterioara D_theta1=theta1-theta1_ant; D_theta2=theta2-theta2_ant; // Miscare brat catre pozitia impusa RotateMotor(OUT_A,pwr,D_theta1); RotateMotor(OUT_B,pwr,-D_theta2); // Actualizare unghiuri coresp. pozitiei anterioare, pentru urmatorul punct de atins (daca e cazul) // Pentru a evita cumularea erorilor de pozitionare de la un punct la altul, unghiurile anterioare // se actualizeaza cu unghiurile cu care s-au rotit efectiv motoarele intre ultimele doua pozitii, // si nu cu ultimele valori calculate ale unghiurilor theta1 si theta2. theta1_ant = MotorTachoCount(OUT_A); theta2_ant = MotorTachoCount(OUT_B); // Numaratoarele asociate trebuie sa fie resetate dupa fiecare pozitionare // ---> de completat in laborator, pentru situatia in care se va face o succesiune de pozitionari. }

// Programul in NXC /***************************************************************************************************************** Prin acest program se pozitioneaza capatul bratului de robot SCARA, format din doua segmente, intr-un punct din planul de lucu. Coordonatele carteziene ale punctului sunt introduse in linii de program in task-ul main(), pentru a fi citite de catre robot in timpul rularii programului. Aceasta pentru a executa pozitionarea si in situatia in care coordonatele ii sunt date din exterior, fara a fi necesara reprogramarea robotului pentru fiecare punct in parte. Programul cuprinde doua parti principale: - Calculul unghiurilor cu care trebuie rotite cele doua segmente ale bratului, in functie de coordonatele introduse - Trimiterea acestor comenzi de miscare catre firmware-ul microcontrolerului, prin intermediul functiilor predefinite. Inainte de a rula programul, trebuie sa se stabileasca orientarea fizica a celor doua axe ale planului de lucru si sa se pozitioneze manual bratul in pozitia initiala stabilita: cu cele doua segmente in prelungire, de-a lungul axei OX. In acest program demonstrativ se pozitioneaza bratul in cadranul I. Precizari referitoare la scalare ----------------------------------------Calculul unghiurilor se va face exclusiv de catre microcontrolerul robotului. Pentru a folosi formatul numeric nativ al acestuia (16 biti, in virgula fixa), trebuie ca toate marimile de intrare, precum si coeficientii din expresiile in care apar marimi de intrare sau de iesire sa fie scalate. Se va lucra cu numere intregi pe 16 biti, cu semn, in interpretarea fractionara Q15, explicata in partea introductiva a platformei. Pentru scalare s-a folosit o dimensiune maxima, notata DIM_MAX, la care s-au raportat marimile de intrare - coordonatele punctului tinta. Marimile de iesire nu s-au raportat la nimic, fiind argumente ale functiei arccos. Procedeul de scalare este explicat in platforma lucrarii. Tinand cont raza de actiune a bratului, se poate alege DIM_MAX cel putin egala cu suma lungimilor celor doua brate. Este recomandat sa se aleaga o putere a lui 2. Pentru acest program: - Coeficientii introdusi trebuie sa fie scalati separat. Desi se pot scala si in programul NXC, la preprocesare, este recomandat sa fie scalati separat, in afara programului, pentru a-i putea vedea si valida (daca se incadreaza pe 16 biti, daca au semnul asteptat), inainte de a fi introdusi in program. Coeficientii sunt scalati fisierul MATLAB "scalare_SCARA.m". - Marimile de intrare, introduse in orice unitate de masura (stabilita de la inceput), sunt scalate in timpul executiei, imediat ce sunt citite.

Precizari referitoare la operatiile aritmetice in virgula fixa ------------------------------------------------------------------------------Depasirile -------------------------Depasirile sunt specifice programarii in virgula fixa, indiferent daca numerele intregi cu care lucreaza microcontrolerul sunt interpretate de catre programator ca fractionare sau intregi. Totusi, se poate elimina problema depasirii la inmultire daca se foloseste interpretarea fractionara, subunitara, prin formatul Q15 ( produsul a doua numere subunitare este tot subunitar si nu apare nici o depasire). Scrierea operatiilor in acest format: - Operatiile de adunare si scadere se scriu direct - Pentru operatiile de inmultire si impartire se vor folosi macro-urile definite la inceputul programului Depasirile posibile ramase sunt cele date de adunare, scadere si impartire. Acestea trebuie avute permanent in vedere si pe cat posibil evitate. O metoda generala este aranjarea convenabila a ordinii operatiilor in expresii. In acest program sunt comentate liniile unde s-a procedat astfel. Nota: Compilatorul NXC folosit de BricxCC poate sa nu "inteleaga" expresiile complexe semnaland o eroare la compilare: "error parsing expression". Din acest motiv e nevoie ca astfel de expresii sa se descompuna in expresii simple si sa se faca in mai multi pasi.*/

Extinderea i testarea programului

Prelund construcia realizat i urmrind programul demonstrativ prezentat, se vor parcurge urmtoarele etape: Se va realiza poziionarea braului robotului n planul (XOY). Robotul se afl ntr-o poziie de referin (cunoscut); Se vor alege puncte de coordonate tina in zona de actiune a robotului. Se va realiza o rutina pentru calculul unghiurilor de control ale bratului in Matlab. Rezultatele obtinute in Matlab se vor compara cu cele obtinute la robot, prin rularea programului demonstrativ din NXC. Pornind de poziia iniial cunoscut, de start, a braului robotului, se aleg mai multe puncte int de atins, consecutive Micrile braului robotului se vor executa ntr-un singur plan, de exemplu planul orizontal; Se va modifica programul astfel nct s se permit poziionarea elementului efector al braului n tot domeniul spaiului de operare posibil . Indicaie: Se poate modifica programul astfel nct s funcioneze corect n toate cadranele. Programul va realiza o poziionare a braului robotului SCARA n planul de lucru ct mai precis Robotul se oprete n punctele (locaiile) programate pentru un timp stabilit Dup atingerea unui punct se trece la urmtorul punct de coordonate impuse. Testarea programului: Pentru fiecare punct de coordonate xi,yi dorit (inta de atins), se va verifica corectitudinea datelor obinute. Se msoar coordonatele atinse i se compar cu cele dorite.

Secvene complexe pentru manipulator

Se va completa programul demonstrativ pentru ca braul s execute o secven de mutri preprogramate, date printr-un ir de coordonate. Se va muta obiectul oriunde n mediul de operare. Robotul se oprete n punctele (locaiile) programate, obiectul este plasat 5sec. n fiecare poziia aleas. Se memoreaz locaiile atinse. Manipulatorul-robot a rspuns corect la comenzi? Se va ntreprinde un schimb de experien ntre studeni, privind codurile realizate, testele efectuate i construciile mecanice dezvoltate.

Prin analogie cu o situaie real, n care o sarcin cerut unui robot SCARA este manipularea unor obiecte, se va completa structura mecanic a braului de robot cu un element terminal care s permit mutarea unor obiecte n spaiul de operare. Se va ataa construciei mecanice un al treilea motor NXT care va permite deschiderea i nchiderea efectorului Se poate construi un element efector de tip clete; Se aleg puncte de coordonate int din spaiul de lucru, n care se va muta piesa Micrile braului robotului se vor executa n plan; Se va adaug o secven de cod care va deschide i respectiv nchide cletele n funcie de necesiti; Paii de executat de braul robotului:
n poziia iniial braul este aliniat dup o ax, iar cletele deschis; Se deplaseaz braul robotului ctre obiectul de mutat. Braul s-a poziionat la o distan minim de obiect, astfel nct piesa nu este lovit. Micarea de prindere a obiectului din spaiul de operare se va realiza cu o vitez redus. Cletele apuc piesa i se nchide. ATENTIE: Pentru a nu suprasolicita motorul n poziia blocat s se opreasc rotirea acestuia n momentul n care nu se mai citete nicio variaie a unghiului acestuia, de la encoder (adic atunci cnd cletele este strns). Cletele va transfera obiect n punctul de coordonate dorit Se deschide cletele, braul se retrage cu o distan minim fa de obiect i se nchide.