Sumar

Transmiterea datelor achiziţionate de la
senzorii robotului NXT la un PC prin
conexiune Bluetooth ®
Cod Student: Huma Karina Elena
Grupa: 152 IC
Îndrumător: Conf. dr. ing. Constantin Ilaş
Iunie 2017

Sinteza
Pornind de la prevederile temei proiectului de diplomă am urmărit să aplic eficient
elementele existente (suportul LEGO Mindstorms NXT), în scopul dezvoltării platformei de
comunicaţii a acestora cu elemente soft care să ofere un mediu favorabil şi fiabil potenţialelor
aplicaţii.
Pentru îndeplinirea cerinţelor şi detaliilor impuse prin temă am realizat următoarele etape
principale ale proiectării:
1. Determinarea resurselor hardware şi software necesare comunicării prin Bluetooth
dintre PC şi robotul LEGO NXT;
2. Configurarea software a PC-ului pentru conexiunea Bluetooth cu robotul NXT;
3. Stabilirea conexiunii Bluetooth la robotul NXT folosind unul dintre porturile seriale ale
PC-ului prin limbajul de programare C# (C Sharp);
4. Conceperea şi implementarea algoritmului de achiziţie a datelor de la senzorii NXT
prin metoda interogării de la PC în limbajul C# (Metoda 1);
5. Aplicaţie practică la Metoda 1, Determinarea poziţiei obiectelor cu senzorul de
ultrasunete, cu prezentarea şi analiza rezultatelor obţinute;
6. Conceperea şi implementarea algoritmului de transmisie a datelor de la senzorii NXT
sub comanda unui program pe robot, în limbajul NXC (Not eXactly C), şi algoritmul de
recepţionare şi interpretare a datelor pe PC în limbajul C# (Metoda 2);
7. Aplicaţie practică la Metoda 2, Evoluţia în timp a mărimilor măsurate de către senzorii
NXT, cu prezentarea şi analiza rezultatelor obţinute;
8. Compararea celor două metode prin elaborarea şi rularea unei aplicaţii speciale.
În afară de elementele consistente menţionate mai sus, pentru realizarea proiectului a fost
necesar să realizez şi o documentare extinsă asupra domeniului roboţilor mobili şi a celorlalte
domenii conexe temei (comunicaţii, programare, senzori, servomotoare), utilizând atât Internetul
cât şi alte surse reflectate în detaliu în bibliografia de la sfârşitul lucrării.

Cuprins
1 Introducere................................................................................................................... 1
2 Roboţi mobili ................................................................................................................ 2
2.1 Definiţii, caracteristici şi structură ........................................................................... 2
2.1.1 Scurt istoric. Definiţii ........................................................................................ 2
2.1.2 Concepte privind existenţa roboţilor................................................................. 2
2.1.3 Roboţi mobili. Elemente de structură ............................................................... 4
2.2 Sisteme de procesare utilizate în roboţi mobili (microcontrolere)............................ 5
2.2.1 Caracterizare generală a microprocesoarelor şi microcontrolerelor ................. 5
2.2.2 Utilizări şi aplicaţii ale microcontrolerelor ......................................................... 7
2.2.3 Clasificări şi arhitecturi constructive ................................................................. 8
2.2.4 Tipuri de memorii folosite în microcontrolere .................................................. 10
2.2.5 Sistemul de intrări-ieşiri .................................................................................. 12
2.2.6 Familii reprezentative de microcontrolere ....................................................... 14
2.2.7 Limbaje de programare şi compilatoare .......................................................... 17
2.3 Senzori ................................................................................................................ 20
2.3.1 Caracteristici generale şi clasificări ale principalelor tipuri de senzori ............ 20
2.3.2 Senzori cu ultrasunete ................................................................................... 22
2.3.2.1 Caracteristici generale ....................................................................................... 22
2.3.2.2 Principiul de funcţionare al senzorului cu ultrasunete ......................................... 23
2.3.2.3 Senzorul cu ultrasunete Parallax PING))) ........................................................... 24
2.3.3 Senzori de contact ......................................................................................... 27
2.4 Servomotoare ...................................................................................................... 28
2.5 Metode de comunicare fără fir (wireless) ............................................................. 32
2.5.1 Comunicaţii în Infraroşu ................................................................................. 33
2.5.2 Comunicaţii prin Bluetooth ® ........................................................................... 34
3 Tehnologia Bluetooth ® ............................................................................................... 36
3.1 Prezentare generală ............................................................................................ 36
3.2 Principalele caracteristici ale standardului Bluetooth / IEEE 802.15.1 .................. 38
3.2.1 Clasele de putere / acoperire şi securitatea Bluetooth ................................... 38
3.2.2 Stiva de protocoale Bluetooth ........................................................................ 39
3.2.3 Descoperirea dispozitivelor Bluetooth ............................................................ 40
3.3 Versiuni în evoluţia Bluetooth ® ............................................................................. 41
3.3.1 Evoluţia specificaţiilor Bluetooth la standardul IEEE ...................................... 41

3.3.2 Bluetooth 1.0 ................................................................................................. 42
3.3.3 Bluetooth 1.1 ................................................................................................. 42
3.3.4 Bluetooth 1.2 (Ratificată ca IEEE Standard 802.15.1-2005) .......................... 42
3.3.5 Bluetooth 2.0 (SIG-2004) ............................................................................... 42
3.3.6 Bluetooth 2.1 (SIG-2007) ............................................................................... 43
3.3.7 Bluetooth 3.0 (SIG-2009) ............................................................................... 43
3.4 Modele şi arhitecturi de utilizare ........................................................................... 43
4 Robotul LEGO Mindstorms NXT ................................................................................. 46
4.1 Generalităţi ........................................................................................................... 46
4.2 Sistemul de procesare al robotului NXT ............................................................... 47
4.3 Senzorii robotului NXT ......................................................................................... 48
4.3.1 Senzorul cu ultrasunete NXT ......................................................................... 48
4.3.2 Protocolul de comunicare I 2 C ........................................................................ 49
4.3.3 Servomotorul NXT ......................................................................................... 49
4.4 Metode de comunicare ......................................................................................... 52
4.5 Programarea robotului LEGO NXT ....................................................................... 52
4.5.1 Limbajul de programare NXC (Not eXactly C) ............................................... 53
5 Citirea datelor achiziţionate de la senzorii NXT prin interogare de la PC .................... 53
5.1 Obiectivele programului de pe PC ........................................................................ 54
5.2 Resurse hardware şi software necesare .............................................................. 54
5.3 Limbajul de programare C# (C Sharp) .................................................................. 56
5.4 Proiectarea şi implementarea aplicaţiei de pe PC ................................................ 59
5.4.1 Iniţierea conexiunii Bluetooth dintre PC şi NXT în C# .................................... 59
5.4.2 Comunicarea PC – NXT prin interogare ........................................................ 60
5.4.3 Implementarea protocolului de control prin „comenzi directe” ........................ 60
5.4.4 Algoritmul metodei de interogare de la PC .................................................... 63
5.5 Aplicaţie la metoda de citire a datelor achiziţionate de la senzorii NXT prin interogare
de la PC ...................................................................................................................... 64
5.5.1 Determinarea poziţiei obiectelor cu senzorul de ultrasunete .......................... 64
5.5.2 Interfaţa grafică şi analiza datelor obţinute .................................................... 66
6 Citirea datelor achiziţionate de la senzorii NXT sub comanda programului NXC ........ 67
6.1 Proiectarea şi implementarea programului de pe NXT (emiţătorul) ...................... 68
6.1.1 Obiectivele programului de pe NXT ............................................................... 68
6.1.2 Achiziţia datelor de la senzorii NXT ............................................................... 68
6.1.3 Serializarea datelor achiziţionate ................................................................... 69
6.1.4 Transmisia datelor prin Bluetooth de la NXT la PC ........................................ 70
6.1.5 Algoritmul programului NXC .......................................................................... 70
6.2 Proiectarea şi implementarea programului de pe PC (receptorul) ........................ 71
6.2.1 Algoritmul programului de pe PC ................................................................... 71

6.2.2 Interfaţa grafică a programului de pe PC ....................................................... 72
6.3 Aplicaţie la metoda de citire a datelor achiziţionate de la senzorii NXT sub comanda
programului NXC ........................................................................................................ 74
6.3.1 Evoluţia în timp a mărimilor măsurate de către senzorii NXT ......................... 74
6.3.2 Rezultatele obţinute ....................................................................................... 75
7 Analiza rezultatelor obţinute ....................................................................................... 77
7.1 Rezultatele obţinute la aplicaţiile implementate .................................................... 77
7.2 Compararea celor două metode ............................................................................ 77
8 Concluzii ..................................................................................................................... 79
9 Anexe ........................................................................................................................ 82
9.1 Anexa 1. Metoda 1. Clasa OperatorNXT .............................................................. 82
9.2 Anexa 2. Metoda 1. Modul de afisare a datelor de la senzorul cu ultrasunete ...... 88
9.3 Anexa 3. Metoda 1. Programul principal al aplicatiei ............................................ 91
9.4 Anexa 4. Metoda 2. Programul NXC .................................................................... 95
9.5 Anexa 5. Metoda 2. Clasa ReceptorNXT .............................................................. 97
9.6 Anexa 6. Metoda 2. Modul de listare şi export date ............................................ 101
9.7 Anexa 7. Metoda 2. Programul principal al aplicatiei .......................................... 102

Lista de figuri
Figura 1. Schiţa microcontrolerului PIC16F84 pe 8 biţi cu arhitectură RISC ..................... 6
Figura 2. Robotul humanoid Johnnie ............................................................................... 8
Figura 3. AIBO ................................................................................................................. 8
Figura 4. ASIMO .............................................................................................................. 8
Figura 5. Arhitecturile Harvard şi von-Neumann ............................................................. 10
Figura 6. Sensibilitatea senzorului Devantech SRF08 .................................................... 22
Figura 7. Sensibilitatea senzorului Devantech SRF10 .................................................... 22
Figura 8. Principiul de funcţionare al senzorului cu ultrasunete ...................................... 23
Figura 9. Senzorul cu ultrasunete Parallax PING))) ....................................................... 24
Figura 10. Cazuri în care obiectul nu este detectat de senzorul cu ultrasunete .............. 25
Figura 11. Test senzor Parallax PING))) pentru un paravan paralel din carton ............... 26
Figura 12. Zona de sensibilitate a senzorului Parallax PING))) pentru testul cu paravan 26
Figura 13. Activarea senzorilor bumper în momentul ciocnirii robotului cu un obiect ...... 27
Figura 14. Componentele unui servomotor. Servomotorul Futaba S3151 ...................... 28
Figura 15. Comanda prin PWM. Servomotor standard şi digital ..................................... 29
Figura 16. Caracteristicile cuplu-timp pentru servomotoarele standard şi digitale .......... 30
Figura 17. Schema bloc a unui sistem de acţionare cu servomotoare de c.c. ................ 31
Figura 18. Sistem de comunicaţii în infraroşu................................................................. 33
Figura 19. Dispozitiv şi retea Bluetooth Piconet ............................................................. 35
Figura 20. Reţele Bluetooth Scatternet .......................................................................... 37
Figura 21. Stiva de protocoale Bluetooth ....................................................................... 39
Figura 22. Arhitecturi Bluetooth ...................................................................................... 42
Figura 23. Structura pachetelor şi asocierea canalelor pentru master/slave ................... 43
Figura 24. Diagrama sistemului de procesare NXT ........................................................ 46

Figura 25. Servomotor NXT. Structura interna ............................................................... 49
Figura 26. Servomotor NXT. Encoder de rotaţie ............................................................ 50
Figura 27. Servomotor NXT. Dispozitiv de protecţie la supracurent ............................... 50
Figura 28. Configurarea conexiunii Bluetooth dintre PC şi NXT ..................................... 55
Figura 29. Arhitectura generala a protocolului de comunicare NXT ................................ 60
Figura 30. Structura unei comenzi trimise prin Bluetooth ............................................... 61
Figura 31. Diagrama simplificata a algoritmului de citire a datelor achiziţionate prin
interogare de la PC ................................................................................................................... 63
Figura 32. Aplicaţie la metoda de citire a datelor de la senzori prin interogare de la PC 64
Figura 33. Interfaţa grafică a aplicaţiei ........................................................................... 65
Figura 34. Diagrama simplificată a algotitmului programului NXC (emiţător) .................. 70 Figura
35. Diagramă simplificată a algoritmului de citirea a datelor de la senzorii NXT transmise la PC de
către programul scris în NXC ...................................................................... 71
Figura 36. Interfaţa grafică a programului. Iniţierea conexiunii Bluetooth ....................... 72
Figura 37. Interfaţa grafică a programului. Datele achiziţionate ...................................... 72
Figura 38. Aplicaţie la metoda de citire a datelor achiziţionate sub comanda programului
NXC .......................................................................................................................................... 74
Figura 39. Evoluţia distanţei parcurse de robot .............................................................. 75
Figura 40. Evoluţia distanţei până la obstacol ................................................................ 75
Figura 41. Rezultatele comparării celor două metode .................................................... 77

1 Introducere
Studiile din domeniu roboticii arată că pentru a putea implementa concepte din domenii
precum inteligenţa artificială, este necesară construirea unor arhitecturi modulare, scalabile şi
eficiente, atât pentru componentele hardware ale robotului cât şi pentru platformele software pe
care acesta le utilizează.
Pentru eficientizarea cercetării pe baza modularităţii şi scalabilităţii amintite mai sus, s-au
dezvoltate produse cu părţi mecanice care respectă binecunoscutul principiu LEGO al
interconexiunii dintre elemente modularizate.
LEGO Mindstorms este o serie de componente LEGO care cuprinde unităţi programabile,
senzori, servomotoare şi alte părţi constructive. Produsul LEGO Mindstorms NXT a fost lansat în
iulie 2006 şi este succesorul primului model, Robotics Invention System (RCX), care a stârnit
interesul unui număr mare de amatori. Succesul setului NXT este argumentat în special de
uşurinţa cu care se poate personaliza şi extinde platforma.
Robotul mobil nu ar fi însă nici pe departe la fel de eficient, dacă nu ar fi susţinut de o
platformă software adecvată aplicaţiilor tot mai complexe şi performante din punctul de vedere al
informaţiilor procesate.
În acest context, tema actualului proiect de diplomă vizează să aplice eficient elementele
existente (suportul LEGO Mindstorms NXT), în scopul dezvoltării platformei de comunicaţii a
acestora cu elemente soft care să ofere un mediu favorabil şi fiabil potenţialelor aplicaţii.
Datorită nevoii tot mai ridicate de transmitere fiabilă a datelor cu viteze mari, tehnologiile
performante utilizate în prezent în diverse domenii ale comunicaţiilor au pătruns şi în roboţii mobili.
Astfel, LEGO Mindstorms NXT conţine ca suport de comunicaţii tehnologia Bluetooth®.
Performanţele, ca tehnologie fiabilă de acces de bandă largă pe distanţe mici, precum şi eficienţa
sa economică şi constructivă (dispozitive cu cost redus şi cele mai mici dimensiuni), au determinat
adoptarea, pe baza specificaţiilor Bluetooth®, a standardului IEEE 802.15.1, care a consacrat şi
a dat un gir corespunător tehnologiei.
Odată creată platforma mecatronică cu suportul de comunicaţii performant oferit de
Bluetooth®, se pune problema dezvoltării unui mediu soft adecvat aestui suport, care să permită
comunicarea datelor în diverse configuraţii cerute de aplicaţii scientifice sau didactice specifice, în
condiţii de viteză şi fiabilitate optimizabile.
Pe această linie proiectul îşi propune studiul şi elaborarea unor elemente soft care să
permită abordarea mai eficientă a sistemului de comunicaţie PC – robot mobil didactic, vizând
realizarea optimă a proceselor de comandă, achiziţie de date şi execuţie.
1

2 Roboţi mobili
2.1 Definiţii, caracteristici şi structură
2.1.1 Scurt istoric. Definiţii
Termenul de "robotics" (în traducere liberă robotică) se referă la ştiinţa care se ocupă de studiul
şi utilizarea roboţilor. Acest termen a fost prima dată folosit de scriitorul şi omul de ştiinţă american
de origine rusă, Isaac Asimov, într-o scurtă povestioară numită "Runaround" în anul 1950.
Primii roboţi s-au numit Unimates şi au apărut în anii '50, fiind dezvoltaţi de George Devol
şi Joe Engelberger. Acesta din urmă a format Unimation şi a fost primul care a vândut roboţi, fiind
considerat de unii „părintele roboticii” [10].
Conform enciclopediei Webster, un robot este "un dispozitiv automat, care execută funcţii
normal atribuite oamenilor, sau o maşină cu asemănare de om".
În timp ce această definiţie ar putea fi satisfăcătoare pentru unii dintre noi, nu este însă
neapărat şi completă. O altă definiţie a fost dată de Institutul de Robotică din America, în anul
1979. Conform acestei definiţii, un robot este "o maşină reprogramabilă, multifuncţională creată
pentru a muta diverse materiale, bucăţi, unelte sau alte dispozitive specializate prin diverse mişcări
programate, pentru realizarea unei varietăţi mari de sarcini".
O definiţie mai scurtă şi larg acceptată la ora actuală este următoarea: un robot este un
sistem inteligent care interacţionează cu mediul fizic înconjurător, prin intermediul unor senzori
efectori.
Pentru a modela lumea încojurătoare este necesar ca un robot să adune date prin
intermediul senzorilor de-a lungul unei perioade de timp. Orice tip de senzor este bineînţeles
predispus la erori.
Prin prisma acestei definiţii, s-ar putea spune că şi omul este un robot. Omul
"interacţionează" cu lumea înconjurătoare prin intermediul unor senzori şi a unor efectori,
reprezentate în lumea biologică de terminaţii nervoase respectiv muşchi. Bineînţeles, diferenţa
cea mai semnificativă între robot şi om, este că robotul a fost creat de om şi nu invers.
2.1.2 Concepte privind existenţa roboţilor
Binecunoscutul autor de literatură Science Fiction, Isaac Asimov, a propus trei "legi ale
roboticii" sau mai bine zis ale existenţei unui robot. Mai târziu acesta a adăugat încă o lege, numită
legea zero. Cu toate că aceste legi au fost privite la început ca fiind o pură ficţiune, ele au fost
2

preluate mai târziu atât de alţi scriitori de Science Fiction cât şi de oameni de ştiinţă, ca şi principii
de bază pentru existenţa unui robot. Astfel, Isaac Asimov este recunoscut de unii ca fiind printre
oamenii care au pus bazele (fie ele pur abstracte) ale ştiinţei pe care astăzi o numim robotică.
Legile existenţei unui robot sunt [10]:
I. Un robot nu are voie să provoace vreun rău umanităţii, sau prin inactivitate, să permită
vreun rău umanităţii.
II. Un robot nu are voie să rănească o persoană umană, sau să permită rănirea unei
persoane umane prin inactivitatea acestuia, cu excepţia cazului când această lege
contravine cu vreo lege anterioară.
III. Un robot trebuie să respecte toate ordinele date de o persoană umană, cu excepţia
acelor reguli care intră în conflict cu vreo lege anterioară.
IV. Un robot trebuie să-şi protejeze propria existenţă atâta timp cât această activitate nu
intră în conflict cu legile anterioare.
Dezvoltarea explozivă a tehnologiilor, incluzând în primul rând pe cele electronice, a
determinat utilizarea roboţilor în majoritatea industriilor. Astfel există atât de multe tipuri de roboţi
folosiţi pentru diverse servicii, încât o enumerare a tuturor tipurilor acestora ar fi aproape
imposibilă. O clasificare aproximativă a celor mai întâlnite tipuri de roboţi ar putea fi:
• Androizi, roboţi construiţi ca să mimeze comportamentul şi înfăţişarea umană;
• Roboţi statici, roboţi folosiţi în diverse fabrici şi laboratoare ca de exemplu braţe robot;
• Roboţi mobili, roboţi care se deplasează într-un anumit mediu fără intervenţie umană
şi realizează anumite obiective;
• Roboţi autonomi, roboţi care îşi îndeplinesc sarcinile fără intervenţie din partea unui
operator uman şi îşi obţin energia necesară funcţionării din mediul înconjurător;
• Tele-roboţi, care sunt ghidaţi prin dispozitive gen telecomandă de un operator uman;
• Linii autonome de producţie în fabrici, sunt tot un fel de roboţi, chiar dacă nu sunt mobili,
deoarece au toate facilităţile definiţiei noastre.
Dintre toate aceste tipuri menţionate mai sus, în proiect se studiază doar roboţii mobili, de
aceea ori de câte ori se va face referire la termenul de robot, se va înţelege de fapt un robot mobil.
3

2.1.3 Roboţi mobili. Elemente de structură
Un robot mobil ar putea fi descris ca un robot care trebuie să se deplaseze într-un anumit mediu,
fără ajutorul unui operator uman şi să execute anumite sarcini date de acesta. Deci principala
caracteristică este mobilitatea.
Roboţii mobili au întrebuinţări multiple. De-a lungul timpului au existat şi există roboţi mobili
cu funcţii diverse, de la aspirator pentru casă la explorator spaţial, de la vehicul ghidat automat
(AGV) folosit în industrie la robot didactic folosit doar pentru scopuri ştiinţifice.
Un robot mobil este alcătuit dintr-o serie de componente, unele de natură fizică (hardware),
iar altele de natură logică, computaţională (software). Din punct de vedere al componentelor
hardware, un robot mobil poate fi considerat ca o colecţie de sisteme pentru [13]:
‣ Locomoţie şi acţiune – modalitatea prin care robotul se mişcă în mediul său ambiant;
‣ Sesizare prin sistem senzorial – modalitatea prin care robotul măsoară proprietăţile
lui şi ale mediului înconjurător;
‣ Procesare – modalitatea prin care robotul procesează şi ia decizii în legătură cu
informaţiile primite de la sistemul senzorial;
‣ Comunicare – modalitatea prin care robotul comunică cu alţi roboţi sau cu un operator
din mediu.
În ce priveşte locomoţia şi acţiunea, pentru a se putea deplasa în mediul ambiant şi a
executa anumite acţiuni prin intermediul organelor sale mobile, roboţii mobili au nevoie de anumite
componente electro-mecanice care să le permită o mişcare precisă, bazate pe transformarea
energiei electrice în energie mecanică de către motoare şi servomotoare specifice.
Printre aceste componente, cele mai reprezentative sunt:
- Motoare, servomotoare, electromagneţi;
- Angrenaje, sisteme de transmisie;
- Roţi, şenile, picioare, perne de aer sau perne magnetice, elice.
4

2.2 Sisteme de procesare utilizate în roboţi mobili (microcontrolere)
2.2.1 Caracterizare generală a microprocesoarelor şi microcontrolerelor
În general se poate considera că şi controlerele fac parte din familia largă a calculatoarelor,
fiind o structură electronică destinată controlului unui proces sau, mai general, unei interacţiuni
caracteristice cu mediul exterior, fără să fie necesară intervenţia operatorului uman.
Primele controlere au fost realizate în tehnologii pur analogice, folosind componente
electronice discrete şi/sau componente electromecanice (de exemplu relee). Cele care fac apel la
tehnica numerică modernă au fost realizate iniţial pe baza logicii cablate (cu circuite integrate
numerice standard SSI şi MSI ) şi a unei electronici analogice uneori complexe, motiv pentru care
"străluceau" prin dimensiuni mari, consum energetic pe măsură şi, nu de puţine ori, o fiabilitate
care lăsa de dorit.
Pe măsură ce procesul de miniaturizare a continuat, a fost posibil ca majoritatea
componentelor necesare realizării unei astfel de structuri să fie încorporate (integrate) la nivelul
unui singur microcircuit (cip). Astfel că un microcontroler ar putea fi descris ca fiind şi o soluţie a
problemei controlului cu ajutorul unui singur dispozitiv integrat (aproximativ).
O definiţie, cu un sens foarte larg de cuprindere, ar fi aceea că un microcontroler este un
microcircuit care încorporează o unitate centrală (CPU) şi o memorie împreună cu resurse care-i
permit interacţiunea cu mediul exterior.
Resursele integrate la nivelul microcircuitului ar trebui să includă, cel puţin, următoarele
componente [15]:
a. o unitate centrală (CPU), cu un oscilator intern pentru ceasul de sistem;
b. o memorie locală tip ROM/PROM / EPROM / FLASH şi eventual una de tip RAM;
c. un sistem de întreruperi;
d. I/O – intrări / ieşiri numerice (de tip port paralel);
e. un port serial de tip asincron şi / sau sincron, programabil;
f. un sistem de timere-temporizatoare / numărătoare programabile.
Este posibil ca la acestea să fie adăugate, la un preţ de cost avantajos, caracteristici
specifice sarcinii de control care trebuie îndeplinite:
g. un sistem de conversie analog numerică (una sau mai multe intrări analogice);
h. un sistem de conversie numeric analogic şi / sau ieşiri PWM (cu modulare în durată);
i. un comparator analogic;
j. memorie de date nevolatilă de tip EEPROM;
k. facilităţi suplimentare pentru sistemul de temporizare / numărare (captare şi
comparare);
5

l. facilităţi pentru optimizarea consumului propriu.
Un microcontroler tipic mai are, la nivelul unităţii centrale, facilităţi de prelucrare a
informaţiei la nivel de bit, de acces direct şi uşor la intrări / ieşiri şi un mecanism de prelucrare a
întreruperilor rapid şi eficient.
Utilizarea unui microcontroler constituie o soluţie prin care se poate reduce dramatic
numărul componentelor electronice precum şi costul proiectării şi al dezvoltării unui produs.
Utilizarea unui microcontroler, oricât de evoluat, nu elimină unele componente ale interfeţei
cu mediul exterior (atunci când ele sunt chiar necesare): subsisteme de prelucrare analogică
(amplificare, redresare, filtrare, protecţie-limitare), elemente pentru realizarea izolării galvanice
(optocuploare, transformatoare), elemente de comutaţie de putere (tranzistoare de putere, relee
electromecanice sau statice).
În Figura 1 se prezintă ca exemplu o structură tipică de microcontroler [15]:
Figura 1. Schiţa microcontrolerului PIC16F84 pe 8 biţi cu arhitectură RISC
În Figura 1 sunt introduse următoarele elemente:
✓ Memorie program (FLASH) - pentru memorarea unui program scris. Pentru că memoria ce
este făcută în tehnologia FLASH poate fi programată şi ştearsă mai mult decât odată, aceasta
face microcontrolerul potrivit pentru dezvoltarea de componentă;
✓ EEPROM - memorie de date ce trebuie să fie salvate când nu mai este alimentare. Este în
mod uzual folosită pentru memorarea de date importante ce nu trebuie pierdute dacă sursa
de alimentare se întrerupe dintr-o dată. De exemplu, o astfel de dată este o temperatură
prestabilită în regulatoarele de temperatură. Dacă în timpul întreruperii alimentării această
6

dată se pierde, va trebui să facem ajustarea încă o dată la revenirea alimentării. Astfel
componenta noastră pierde în privinţa auto-menţinerii;
✓ RAM - memorie de date folosită de un program în timpul executării sale. În RAM sunt
memorate toate rezultatele intermediare sau datele temporare ce nu sunt cruciale la
întreruperea sursei de alimentare;
✓ PORTUL A şi PORTUL B sunt conexiuni fizice între microcontroler şi lumea de afară. Portul
A are 5 pini, iar portul B are 8 pini;
✓ TIMER-UL LIBER (FREE-RUN) este un registru de 8 biţi în interiorul microcontrolerului ce
lucrează independent de program. La fiecare al patrulea impuls de ceas al oscilatorului îşi
încrementează valoarea lui până ce atinge maximul (255), şi apoi începe să numere tot din
nou de la zero;
✓ UNITATEA DE PROCESARE CENTRALĂ are rolul unui element de conectivitate între
celelalte blocuri ale microcontrolerului. Coordonează lucrul altor blocuri şi execută programul
utilizatorului.
2.2.2 Utilizări şi aplicaţii ale microcontrolerelor
Toate aplicaţiile în care se utilizează microcontrolere fac parte din categoria aşa ziselor
sisteme încapsulate-integrate (“embedded systems”), la care existenţa unui sistem de calcul
incorporat este (aproape) transparentă pentru utilizator.
Pentru că utilizarea lor este de foarte multe ori sinonimă cu ideea de control,
microcontrolerele sunt utilizate masiv în robotică şi mecatronică. Conceptul de mecatronică este
până la urmă indisolubil legat de utilizarea microcontrolerelor.
Automatizarea procesului de fabricaţie-producţie este un alt mare beneficiar,(CNC
Computerised Numerical Controls - comenzi numerice pentru maşinile unelte, automate
programabile - PLC, linii flexibile de fabricaţie, etc.). Indiferent de natura procesului automatizat
sarcinile specifice pot fi eventual distribuite la un mare număr de microcontrolere integrate întrun
sistem unic prin intermediul uneia sau mai multor magistrale.
Printre numeroasele domenii unde utilizarea microcontrolerelor este practic un standard
industrial se pot menţiona: în industria de automobile (controlul aprinderii /motorului, climatizare,
diagnoză, sisteme de alarmă, etc.), în aşa zisa electronică de consum (sisteme audio, televizoare,
camere video şi videocasetofoane, telefonie mobilă, GPS-uri, jocuri electronice, etc.), în aparatura
electrocasnică (maşini de spălat, frigidere, cuptoare cu microunde, aspiratoare), în controlul
mediului şi climatizare (sere, locuinţe, hale industriale), în industria aerospaţială, în mijloacele
moderne de măsurare - instrumentaţie (aparate de măsură, senzori şi traductoare inteligente), la
realizarea de periferice pentru calculatoare, în medicină.
7

În Figura 2, Figura 3, Figura 4 se prezintă câteva exemple de roboţi [14]:
Figura 3. AIBO
Figura 2. Robotul humanoid Johnnie
Figura 4. ASIMO
„Johnnie” (Figura 2), un robot umanoid destul de simplu, construit la Universitatea
Tehnică din Munchen în 1998, utilizează 5 microcontrolere, conectate prin intermediul unei
magistrale CAN la un calculator PC.
Un număr foarte mare de microcontrolere sunt folosite şi de aşa zisele jucării inteligente,
din care „capetele de serie” cele mai cunoscute sunt cei doi roboţi, unul canin şi altul umanoid:
AIBO (Sony, Figura 3) şi ASIMO (Honda, Figura 4).
ASIMO foloseşte 26 de microcontrolere numai pentru controlul individual al celor 26 de
elemente de acţionare inteligente (motoare).
Ca exemple din industria de automobile, numai la nivelul anului 1999, un BMW seria 7
utiliza 65 de microcontrolere, iar un Mercedes din clasa S utiliza 63 de microcontrolere.
2.2.3 Clasificări şi arhitecturi constructive
Există la ora actuală un număr extrem de mare de tipuri constructive de microcontrolere.
Un criteriu de clasificare care se poate aplica întotdeauna este lungimea (dimensiunea) cuvântului
de date. Funcţie de puterea de calcul dorită şi de alte caracteristici se pot alege variante având
dimensiunea cuvântului de date de 4, 8, 16 sau 32 de biţi (există chiar şi variante de 64 de biţi).
8

Practic, toate microcontrolerele se realizează la ora actuală în tehnologie CMOS
(tehnologii similare celor utilizate la seriile standard CMOS de circuite numerice: HC, AC, ALV,
etc.). Se pot realiza astfel structuri cu o mare densitate de integrare, cu un consum redus (care va
depinde de frecvenţa de lucru), permiţând eventual alimentarea de la baterie.
Logica internă este statică (total sau în cea mai mare parte) permiţând astfel, în anumite
condiţii, micşorarea frecvenţei de ceas sau chiar oprirea ceasului în ideea optimizării consumului.
Tehnologia este caracterizată şi de o imunitate mai mare la perturbaţii, esenţială într-un mare
număr de aplicaţii specifice. Se realizează variante pentru domeniu extins al temperaturii de
funcţionare (de ex.- 40 +85 0 C).
Arhitectura unităţii centrale de calcul (CPU) este unul din elementele cele mai importante
care trebuie avut în vedere în analiza oricărui sistem de calcul. Principalele concepte sunt
următoarele:
1) Arhitecturi de tip "von Neumann"
Cele mai multe microcontrolere sunt realizate pe baza acestei arhitecturi de sistem.
Microcontrolerele bazate pe această arhitectură au o unitate centrală (CPU) caracterizată de
existenţa unui singur spaţiu de memorie utilizat pentru memorarea atât a codului instrucţiunilor cât
şi a datelor ce fac obiectul prelucrării.
2) Arhitecturi de tip "Harvard"
La această arhitectură există spaţii de memorie separate pentru program şi date. În
consecinţă ar trebui să existe şi magistrale separate (de adrese şi date) pentru codul instrucţiunilor
şi respectiv pentru date. Este arhitectura standard pentru procesoarele numerice de semnal
(DSP).
3) CISC
Aproape toate microcontrolerele au la baza realizării CPU conceptul CISC (Complex
Instruction Set Computer). Aceasta înseamnă un set uzual de peste 80 instrucţiuni, multe din ele
foarte puternice şi specializate. De obicei multe din aceste instrucţiuni sunt foarte diferite între ele:
unele operează numai cu anumite spaţii de adrese sau registre, altele permit numai anumite
moduri de adresare, etc.
4) RISC (Reduced Instruction Set Computer)
Este un concept de realizare a CPU care a început să fie utilizat cu succes de ceva timp şi
la realizarea microcontrolerelor. Prin implementarea unui set redus de instrucţiuni care se pot
executa foarte rapid şi eficient, se obţine o reducere a complexităţii microcircuitului, suprafaţa
disponibilizată putând fi utilizată în alte scopuri.
9

În Figura 5 se prezintă o comparaţie între arhitecturile Harvard şi von-Neuman [15].
Figura 5. Arhitecturile Harvard şi von-Neumann
Arhitectura Harvard este un concept mai nou decât von-Neumann. S-a născut din nevoia
de mărire a vitezei microcontrolerului. În arhitectura Harvard, bus-ul de date şi bus-ul de adrese
sunt separate. Astfel este posibil un mare debit de date prin unitatea de procesare centrală, şi
bineînţeles, o viteză mai mare de lucru. Microcontrolerele cu arhitectură Harvard sunt de
asemenea numite "microcontrolere RISC". Microcontrolerele cu arhitectura von-Newmann sunt
numite "microcontrolere CISC".
2.2.4 Tipuri de memorii folosite în microcontrolere
În afară de memoria locală de tip RAM, de dimensiuni relativ reduse (uzual de la x10 octeţi
la x1k), implementată ca atare sau existentă sub forma unui set de registre şi destinată memorării
datelor (variabilelor), mai există o serie de aspecte specifice, marea majoritate a acestora fiind
legată de implementarea fizică a memoriei de program (şi eventual a unei părţi a memoriei de
date) cu ajutorul unor memorii nevolatile. Clasic, memoria de program era implementată într-o
variantă de tip ROM: EPROM pentru dezvoltare şi producţie pe scară mică/medie sau mask-ROM
pentru producţia de masă.
Principalele concepte noi apărute de a lungul timpului în legătură cu implementarea
memoriei de program sau date sunt enumerate în continuare [15].
10

a. OTP - majoritatea producătorilor oferă variante de microcontrolere la care memoria locală de
program este de tip OTP (One Time Programmable), practic o memorie PROM identică intern
cu varianta EPROM, dar fără fereastra de cuarţ pentru ştergere (deci şi mai ieftine); aceste
variante pot fi utilizate ca o alternativă pentru o producţie limitată, până în momentul testării şi
validării finale a codului, moment în care pot fi comandate variantele (mask) ROM propriu-zise,
cele mai economice pentru o producţie de masă.
b. FLASH EPROM - este o soluţie mai bună decât EPROM-ul propriu-zis atunci când este
necesar un volum mare de memorie program (nevolatilă); mai rapidă şi cu un număr garantat
suficient de mare (x10000) de cicluri de programare (de ştergere/scriere), este caracterizată
şi prin modalităţi mai flexibile de programare; este utilizată numai ca memorie de program.
c. EEPROM - multe microcontrolere au şi o memorie de acest tip, de dimensiune limitată (de la
x10 octeţi la x K octeţi), destinată memorării unui număr limitat de parametric (memorie de
date) care eventual trebuie modificaţi din timp în timp; este o memorie relativ lentă (la scriere),
dar cu un număr de cicluri de ştergere/scriere mai mare ca FLASH-ul (x100000).
d. NOVRAM (RAM nevolatil) - realizat prin alimentarea locală (baterie, acumulator) a unui masiv
RAM CMOS atunci când este necesar un volum mare de memorie de program şi date
nevolatilă; mult mai rapidă decât toate celelalte tipuri şi fără limitări ca număr de cicluri.
e. Programarea "În System" (ISP-În System Programming) - folosirea unor memorii nevolatile
de tip FLASH face posibilă şi "programarea" unui astfel de microcontroler fără a-l scoate din
sistemul în care este încorporat (programare on-line, În System Programming); programarea
se face de regulă prin intermediul unei interfeţe seriale dedicate de tip ISP (poate avea nume
diferite) sau a unei interfeţe standard JTAG. Există microcontrolere la care această
programare se poate face prin intermediul portului serial asincron sau al interfeţei CAN
(Controller Area Network).
f. Bootloader - multe din microcontrolerele recente la care memoria de program este de tip
FLASH au şi facilitatea (au de fapt instrucţiuni dedicate acestui scop) de a putea şi scrie în
această memorie de program fără a utiliza un circuit de programare extern. Astfel în
microcontroler poate exista permanent (rezident) un cod de mici dimensiuni (denumit şi
bootloader) care pur şi simplu va încărca prin intermediul portului serial (este doar un exemplu)
codul utilizator sau constantele pe care acesta vrea eventual să le actualizeze. Bootloader-ul
este şi cel care lansează în execuţie programul utilizator după încărcarea acestuia.
g. Protejarea codului - protejarea codului program dintr-o memorie locală nevolatilă împotriva
accesului neautorizat (la citire –deoarece pirateria soft există şi aici) este oferită ca o opţiune
(ea mai trebuie şi folosită!) la variantele FLASH, EPROM sau OTP. Codul poate fi protejat atât
la citire cât şi la scriere (practic circuitul trebuie şters, înainte de a se mai putea scrie ceva în
el). Este eliminată astfel posibilitatea de a se realiza, în acest caz, de patch-uri (alterări cu un
anumit scop) ale codului original. La variantele mask-ROM propriu-zis protecţia este de cele
mai multe ori implicită.
11

h. Memoria externă de program sau date - marea majoritate a familiilor de microcontrolere
permit şi utilizarea de memorie externă de program (tipic ROM) sau date (tipic RAM). Aceasta
presupune existenţa şi utilizarea unor magistrale externe de adrese şi date.
Conexiunile externe necesare pentru acestea sunt disponibile ca funcţii alternative ale pinilor.
Din păcate, în această situaţie numărul de conexiuni exterioare disponibile pentru interfaţa cu
exteriorul se reduce dramatic, reducând mult din versatilitatea microcontrolerului.
2.2.5 Sistemul de intrări-ieşiri
Toate microcontrolerele au un număr oarecare de intrări / ieşiri numerice (de la x1 la x10)
organizate sub forma unor porturi I/O; conexiunile exterioare sunt bidirecţionale sau
unidirecţionale, unele sunt multifuncţionale (se oferă funcţii alternative pe acelaşi pin), unele pot
avea o capacitate sporită de a absorbi curent, etc.
În afară de acest set de intrări/ieşiri de uz general, pentru interfaţa cu mediul exterior se
oferă o serie de alte facilităţi importante de intrare/ieşire cum ar f [15]i:
a. UART (Universal Asynchronous Receiver Transmitter) este un port serial
bidirecţional destinat implementării unui protocol clasic de comunicaţie asincron; USART
(Universal Synchronous Asynchronous Receiver Transmitter) este un port similar, dar care
permite implementarea şi a unui protocol sincron cu obţinerea unor viteze mai mari de
comunicaţie; SCI (Serial Communications Interface) este un circuit de tip UART îmbunătăţit, definit
şi utilizate de firma Freescale(Motorola). LIN (Local Interconnect Network) reprezintă o
implementare particulară a unui protocol de comunicaţie asincron, utilizată în industria de
automobile ca o alternativă de mică viteză dar cu preţ scăzut pentru magistrala şi protocolul CAN
.
b. Porturi seriale sincrone dedicate - sunt destinate transferului serial de date de
mare viteză cu unele periferice specializate (sisteme de afişare, convertoare analog-numerice,
etc.) sau care permit conectarea într-o reţea de comunicaţie. Presupun existenţa, împreună cu
datele, a unui semnal de ceas (implicit sau explicit) pentru sincronizarea acestora. Implică şi
implementarea unor protocoale mai mult sau mai puţin complexe de transfer al informaţiei, fiind
de fapt vorba de o magistrală serială. Există câteva implementări răspândite (sunt prezentate în
ordinea crescătoare a complexităţii):
- SPI (Serial Peripheral Interface) este un port serial sincron definit de firma Motorola
12

- Microwire / Microwire Plus este o interfaţă serială bidirecţională sincronă definită
şi utilizată de firma National Semiconductors
- I2C (Inter Integrated Circuits bus) este o interfaţă serială bidirecţională (pe numai
2 fire), dezvoltată de Philips, destinată aplicaţiilor de 8 biţi. Există şi multe circuite "periferice" care
sunt prevăzute cu o astfel de interfaţă. Este cunoscută şi sub denumirea TWI (Two Wire Interface)
- CAN (Controller Area Network) proprietate intelectuală a firmei Bosch, foarte
utilizat în Europa şi Japonia, oarecum similar ca funcţionalitate lui SAE J1850 care este utilizat în
America de Nord (SAE -Society of Automotive Engineers), este un standard (o magistrală şi un
protocol) de comunicaţie serială sincronă utilizat în industria de automobile, permiţând
interconectarea într-o reţea a diverselor componente inteligente (senzori, elemente de execuţie,
indicatoare, etc.) omniprezente într-un automobil modern.
În ultimul timp magistrala CAN a început să fie utilizată şi în alte domenii decât industria
de automobile (automatizări industriale, robotică, acţionări electrice).
c. Conectivitate Ethernet/Web – implică existenţa unor resurse care să permită
integrarea cu uşurinţă într-o reţea de tip Ethernet, pentru a face posibilă, în final, implementarea
unui protocol TCP/IP (a unei stive TCP/IP). Resursele respective pot fi de natură software (stivă
soft) care presupun o viteză de prelucrare (putere de calcul) a CPU suficient de mare pentru a nu
afecta vizibil operarea propriu-zisă a controlerului, sau hardware (stivă hardware). Pe baza acestei
stive se poate realiza o conectivitate tip HTTP, FTP, STMP, POP3, etc.
d. Conectivitate USB - magistrala serială USB (Universal Serial Bus) a fost creată
pentru conectarea cu uşurinţă a diverselor periferice la un calculator PC (cu rolul de gazdă - host).
Conexiunea permite şi furnizarea tensiunii de alimentare. Varianta USB 1.1 permite atingerea unei
rate de transfer maxime a datelor de 12Mbytes/sec, iar varianta USB 2.0 a unei rate maxime de
cca. 480MBytes/sec.
e. Conectivitate Wireless- se referă la existenţa unor resurse hardware şi/sau
software care să permită integrarea cu uşurinţă şi la un preţ de cost avantajos într-o reţea de tip
wireless, pentru a face posibilă, în final, implementarea unui protocol (a stivei aferente
protocolului). Exemplele cele mai cunoscute de astfel de reţele, protocoale şi stive sunt Bluetooth
(IEEE 802.15.1) şi Zigbee (IEEE 802.15.4).
f. Convertoarele Analog Numerice (CAN, ADC) Convertoarele utilizate fac parte
de regulă dintr-un sistem de achiziţie de date, existând şi un multiplexor analogic cu mai multe
canale de intrare. Rezoluţia disponibilă este tipic de 8, 10 sau 12 biţi, uneori cu precizia (rezoluţia
adevărată) corespunzătoare unui număr mai mic de biţi. Timpul minim de conversie este în plaja
x µsec la x10 µsec.
13

g. Convertoarele Numeric Analogice (CNA, DAC)
Cea mai răspândită tehnică de conversie numeric analogică folosită este bazată pe
modulaţia în factor de umplere (PWM- Pulse Width Modulation). Există unul sau mai multe canale
pe care se poate genera un tren de impulsuri cu factor de umplere programabil (de la 0 la 100%).
2.2.6 Familii reprezentative de microcontrolere
Cele mai reprezentative familii de microcontrolere de 8 biţi şi 16 biţi sunt următoarele[15]:
a. 8048 (Intel MCS-48 - www.intel.com )
Este considerat "bunicul" microcontrolerelor pe 8 biţi, iar unele dintre caracteristicile sale
arhitecturale se regăsesc la următoarea generaţie (MCS-51, 8051).
b. 8051 (Intel MCS-51 şi mulţi alţii: Atmel, Philips- www.semiconductor.philips.com,
Infineon, Atmel, Dallas-Maxim - www.maxim-ic.com, Cygnal – www.cygnal.com , etc.)
A doua generaţie de microcontrolere de 8 biţi a firmei Intel care, deşi apărută acum 20 de
ani, încă ocupă un segment semnificativ de piaţă. Cu o arhitectură destul de ciudată, este suficient
de puternic şi uşor de programat. Arhitectura sa are spaţii de memorie separate pentru program
şi date. Poate adresa 64KBytes memorie de program, din care primii 4(8..32)KBytes locali (ROM).
Poate adresa 64KBytes memorie de date externă, adresabilă doar indirect. Are 128 (256) octeţi
de RAM local, plus un număr de registre speciale pentru lucrul cu periferia locală. Are facilităţi de
prelucrare la nivel de bit (un procesor boolean, adresare pe bit). Intel a dezvoltat şi un “super 8051”
numit generic 80151.
c. 80C196 (Intel MCS-96)
Este un microcontroler pe 16 biţi făcând parte din generaţia a treia de microcontrolere a
firmei Intel. Destinat iniţial unor aplicaţii din industria de automobile, are o arhitectură von
Neumann, cu un spaţiu de adresare de 64KBytes, o unitate de intrări/ieşiri numerice de mare
viteză (destinată iniţial controlului injecţiei la un motor cu ardere internă), ieşiri PWM, convertor
analog numeric, timer watchdog. Există multe variante, ultimele cronologic apărute, fiind mult
superioare variantei iniţiale. Există şi o dezvoltare recentă sub forma familiei MCS-296 (80C296).
d. 80C186, 80C188 (Intel, AMD)
Derivate din clasicele 8086/88 prin includerea pe acelaşi microcircuit a 2 canale DMA, 2
numărătoare/timere, un sistem de întreruperi şi un controler pentru DRAM. Marele avantaj al
acestor cvasi(aproape) microcontrolere (ele nu au memorie integrată) este legat de utilizarea ca
mediu de dezvoltare a unor platforme de calcul tip IBM-PC, compatibile 80x86, cu tot softul aferent.
14

e. 68HC05 (Freescale - www.freescale.com, ex Motorola )
Are un spaţiu de memorie unic (64Kbytes) în care sunt plasate şi registrele perifericelor
(I/O, timere) cu un indicator de stivă (SP) hard pe 5biţi (stivă de maxim 32 octeţi !). Există variante
cu memorie EEPROM, CAN, port serial, etc. Este unul din cele mai răspândite microcontrolere
(comparabil cu 8051).
f. 68HC11, 68HC12, 68HC16 (Freescale)
68HC11 a fost unul din cele mai puternice microcontrolere pe 8 biţi, foarte răspândit în
ciuda faptului că Motorola a fost un timp singurul producător. Are un set de instrucţiuni asemănător
cu alte produse ale firmei (6801, 6805, 6809). Are un spaţiu de adrese unic de 64K. Nenumărate
variante ca resurse: EEPROM, OTP, CAN, PWM, etc. Prezintă ca particularitate existenţa unui
program de încărcare rezident (bootstrap loader în ROM intern) cu care, la reset, un segment din
memoria RAM externă poate fi încărcat cu cod program prin intermediul portului serial.
g. 683xxx (Freescale)
Microcontrolere pe 32 de biţi construite în jurul unui CPU analog microprocesorului M68020
(CPU32), denumite şi "procesoare integrate". Putere de calcul comparabilă sau mai mare ca a lui
Intel 80386.
h. PIC (Microchip- www.microchip.com )
Primul microcontroler din această familie (PIC1650) a apărut acum mai bine de 20 de ani
pe vremea când firma era proprietatea General Instruments. Este o familie de microcontrolere
care, în ultimii ani, a cunoscut o dezvoltare explozivă. Sunt disponibile actualmente sub forma a 6
serii: PIC10, PIC12, PIC14, PIC16, PIC17 şi PIC18. În seriile respective există variante cu
memorie de program de tip OTP(C) sau FLASH(F). Au fost primele microcontrolere de 8 biţi cu
arhitectură RISC: PIC16C5x avea un set de doar 33 instrucţiuni (Intel 8048 avea 90). Arhitectura
este de tip Harvard şi, ca o particularitate, dimensiunea cuvântului pentru program este de 12, 14
sau 16 biţi, cuvântul de date fiind tot de 8 biţi. Cronologic, ultimul produs al firmei Microchip este
seria dsPIC30F, de fapt un procesor numeric de semnal, de 16 biţi, cu o periferie specifică
optimizată pentru controlul acţionărilor electrice (motoare electrice). Firma Ubicom (ex Scenix,
www.ubicom.com) produce nişte clone ale familiei PIC, mult mai rapide decât originalele. Modulele
Basic Stamp ale firmei Parallax (www.parallax.com) sunt bazate şi pe astfel de microcontrolere
(sunt foarte utilizate, şi nu numai de hobbiştii din robotică).
i. AVR (Atmel- www.atmel.com )
Un concurent puternic al seriei PIC este familia numită AVR, a firmei ATMEL, familie
apărută în ultimii ani, care oferă variante de microcontrolere oarecum asemănătoare ca resurse
15

cu familia PIC, la performanţe similare sau mai bune. Sunt bazate pe o arhitectură diferită, dar
unitatea centrală este tot de tip RISC, cu cuvântul de date de 8 biţi. La fel ca la PIC dimensiunea
cuvântului de program este mai mare, fiind de 16 biţi. Există cel puţin 3 subfamilii mari, în ordinea
complexităţii resurselor, acestea fiind: AT Tiny, AT90 şi ATMega.
j. COP4(00) şi COP8(00) (NS -National Semiconductors - www.national.com )
COP4 este un microcontroler pe 4 biţi, categorie de microcontrolere care, în general,
departe de a fi învechite, ocupă un segment relativ important al pieţii. Printre caracteristici: până
la 2K ROM local, 32x4 până la 160x4 RAM local, Microwire, numărătoare/timere, tensiune de
alimentare 2.3-6V, număr mic de pini.
COP8 reprezintă o serie de microcontrolere pe 8 biţi, versatilă, cu preţ scăzut, disponibilă
în multe variante. Arhitectura este similară lui 8051, dar setul de instrucţiuni este similar lui Z80. k.
Z8 (Zilog, - www.zilog.com )
Un derivat al microprocesorului Z80, reprezintă un compozit al mai multor arhitecturi
diferite. Nu este compatibil cu setul de instrucţiuni şi nici cu perifericele standard Z80. Are trei
spaţii de adrese: program, date şi un masiv de registre. Resurse locale tipice: UART, timere, DMA,
sistem de întreruperi cu până la 37 de surse. Există o variantă cu un interpreter Tiny Basic în
ROM-ul local (analog 8052AH Basic de la Intel) precum şi o variantă cu resurse îmbunătăţite
numită Super-8.
l. Z180(Zilog), Rabbit ( Rabbit Semiconductors- www.rabbitsemiconductor.com )
Z180 -ul firmei Zilog are un CPU similar cu Z80 dar îmbunătăţit, cu resurse locale cum ar
fi: management de memorie (memorie paginată de maxim 1MB), USART (numit SIO), 2 canale
DMA, timere, sistem de întreruperi, eventual PIO. Instrucţiuni suplimentare faţă de setul standard
Z80, printre care şi înmulţirea. Diversele sale variante nu includ memorie locală.
m. TMS370 (Texas Instruments- www.ti.com )
Microcontrolerul standard pe 8 biţi al firmei TI realizat în multe variante (de ordinul zecilor),
prezintă unele asemănări cu 8051 (memoria de date locală, stiva, modurile de adresare). O
varietate extrem de mare a resurselor locale.
n. 80386EX (Intel)
Un 80386 destinat aplicaţiilor de tip controler. Resurse locale: I/O seriale,
timere/numărătoare, DMA, optimizarea consumului, controler de întreruperi, controler pentru RAM
dinamic. Nu au memorie locală. Marele avantaj al unui astfel de microcontroler este că se poate
16

utiliza ca platformă de dezvoltare un sistem de tip IBM PC împreună cu tot mediul de programare
aferent.
o. SC 3/4/5xx, Elan (AMD- www.amd.com )
O serie de microcontrolere deosebit de performante realizate în jurul unei unităţi centrale
de tip 386/486. Permit practic, doar prin adăugarea de memorie externă, obţinerea unui sistem de
calcul compatibil PC, destinat unor aplicaţii de control încapsulate-integrate ("embedded PC").
p. 80C16x (Infineon, ex Siemens www.infineon.com )
Unul din microcontrolerele de 16 biţi foarte utilizat în Europa. Arhitectură deosebit de
performantă a CPU, de tip RISC, are diverse variante, cu resurse complexe: 80C165, 80C166,
80C167, etc.
q. MSP430 (Texas Instruments)
Firma TI oferă şi o familie de microcontrolere de 16 biţi cu arhitectura RISC, cu posibilitatea
controlului compromisului viteză de calcul/consum propriu, destinată aplicaţiilor portabile (şi nu
numai), denumită MSP 430. Cu un spaţiu de adresare de 64KBytes, are diverse variante de
realizare a memoriei interne de program (OTP, FLASH), resurse diverse (printre care şi o interfaţă
pentru un sistem de afişare LCD).
r. ARM (Advanced RISC Machine, www.arm.com ) - este de fapt o unitate
centrală de 32 de biţi (sau de 16/32 biţi) care face parte din categoria structurilor IP
(“Intelectual Property”). Consorţiul ARM a oferit licenţe ale acestei micro arhitecturi (nucleu
ARM) pentru numeroşi producători de circuite (Atmel, Philips, TI, OKI – www.okisemi.com
, etc.).
Pe baza acestor licenţe se realizează şi microcontrolere de mare performanţă. Cele mai
cunoscute şi răspândite variante de nuclee sunt ARM7 şi ARM9, cu implementările lor simplificate
numite ARM7T, ARM9T (T-“Thumb”).
2.2.7 Limbaje de programare şi compilatoare
Limbajul maşină (instrucţiunile maşină) este singura formă de reprezentare a informaţiei
pe care un microcontroler o "înţelege".
Din păcate această formă de reprezentare a informaţiei este total nepractică pentru un
programator, care va utiliza cel puţin un limbaj de asamblare, în care o instrucţiune (o mnemonică
17

cu operanzii aferenţi) are drept corespondent o instrucţiune în limbaj maşină (excepţie fac
macroinstrucţiunile disponibile la unele asambloare).
Un program în limbaj de asamblare este rapid şi compact. Aceasta nu înseamnă că un
astfel de program, prost scris, nu poate fi lent şi de mari dimensiuni, programatorul având controlul
total pentru execuţia programului şi gestiunea resurselor.
Limbajul de asamblare este primul care trebuie învăţat, chiar sumar, atunci când dorim să
proiectăm o aplicaţie hard/soft cu un anume microcontroler (familie), el permiţând înţelegerea
arhitecturii acestuia şi utilizarea ei eficientă.
Un compilator combină uşurinţa în programare oferită de un interpreter (de fapt de limbajul
de nivel înalt) cu o viteză mai mare de execuţie a codului. Pentru aceasta programul, în limbaj de
nivel înalt, este translatat (tradus) direct în limbaj maşină sau în limbaj de asamblare (urmând a fi
apoi asamblat). Codul maşină rezultat are dimensiuni relativ mari (dar mai mici decât cel
interpretat) şi este executat direct, ca un tot, de microcontroler. De regulă codul generat poate fi
optimizat fie ca dimensiune, fie ca timp de execuţie.
Se pot enumera compilatoare pentru limbajele: C, BASIC, Pascal, Forth.
Cele mai populare şi utilizate sunt cele pentru limbajul C, un limbaj universal folosit atât
pentru super computere, cât şi de microcontrolerele de 4 biţi. Este un limbaj puternic şi flexibil,
care deşi de nivel înalt, poate permite şi accesul direct la resursele sistemului de calcul. Un
program bine scris generează un cod rapid şi compact. Totuşi, de multe ori, porţiuni critice din
punct de vedere al vitezei de execuţie, trebuie încă scrise în limbaj de asamblare. Există
numeroase implementări, pentru majoritatea familiilor de microcontrolere. Cu anumite limitări
legate de arhitectură şi mai ales resursele microcontrolerului, asigură portabilitatea unei aplicaţii
scrisă pentru un anumit tip (familie) de microcontroler la un alt tip (familie).
Referitor la asamblor şi compilator, trebuie precizat că pentru acestea codul este obţinut
cu ajutorul unui mediu integrat de dezvoltare a programelor (IDE-Integrated Development
Environment) care conţine în mod tipic următoarele componente software: un editor specializat
(orientat pe codul sursă), un asamblor/compilator, un editor de legături/locator
("linkeditor/locator"), programe de gestiune a unor biblioteci de cod ("librarians"), programe de
conversie a formatelor de reprezentare a codului (de exemplu din binar în format Intel HEX sau
Motorola S) şi, nu în ultimul rând, un simulator şi/sau depanator ("debugger").
18

Codul astfel obţinut trebuie încărcat în memoria de program a maşinii ţintă unde va rula,
fiind de fapt programat într-o memorie de tip (EP)ROM/FLASH sau încărcat direct (uploaded) întro
memorie de tip RAM.
19

2.3 Senzori
2.3.1 Caracteristici generale şi clasificări ale principalelor tipuri de senzori
Senzorii sunt dispozitive componente ale roboţilor mobili care pot măsura diferite
proprietăţi ale mediului din jurul acestora, cum ar fi: temperatura, distanţa, rezistenţa fizică,
greutatea, mărimea, etc.
În cel mai general caz, senzorii pot fi grupaţi în două categorii:
• Senzori de stare internă – senzori care oferă informaţii despre starea internă a
robotului mobil, spre exemplu nivelul bateriei, poziţia roţilor sau altor componente, etc.;
• Senzori de stare externă – senzori care oferă informaţii despre mediul ambiant în
care robotul funcţionează. Senzorii de stare externă se mai pot împărţi la rândul lor în
două categorii: senzori cu contact, mai precis acei senzori care culeg informaţia din
mediu prin atingere (exemplu: senzor "bumper"), respectiv senzori fără contact , care
preiau informaţia din mediu de la distanţă (exemplu: cameră video, senzor ultrasonic)
Un senzor poate fi activ sau pasiv. Senzorii activi sunt acei senzori care emit energie
în mediu pentru a putea observa anumite caracteristici ale acestuia, spre deosebire de
senzorii pasivi care primesc energie din mediu pentru a putea prelua informaţia.
[13]:
La modul general, despre toate categoriile de senzori se pot enunţa următoarele ipoteze
• Orice senzor este afectat de interferente;
• Orice senzor oferă o informaţie incompletă a mediului în care efectuează măsurătorile;
• Nici un senzor nu poate fi modelat complet.
De asemenea, toate tipurile de senzori sunt caracterizate printr-o serie de proprietăţi, cele
mai importante fiind:
• Sensibilitatea: raportul dintre semnalul de ieşire şi semnalul de intrare;
• Liniaritatea: exprimă dacă raportul dintre intrare şi ieşire este constant;
• Intervalul de măsurare: diferenţa între distanţa minimă şi maximă măsurabilă;
• Timpul de răspuns: timpul necesar pentru ca informaţia de la intrare să fie observabilă
la ieşire;
• Acurateţea: diferenţa între semnalul măsurat şi semnalul real;
• Repetabilitatea: diferenţele între măsurători succesive ale aceleiaşi entităţi;
• Rezoluţia: exprimă cea mai mică unitate de incrementare a semnalului măsurat;
20

• Preţul senzorului;
• Puterea de calcul necesară pentru a interpreta rezultatele;
• Tipul de semnal la ieşire;
• Greutatea, mărimea şi cantitatea de energie consumată pentru a face o
măsurătoare.
Din punct de vedere tehnologic/funcţional, roboţii mobili pot fi dotaţi cu diverse tipuri de
senzori [16]:
a. Senzori interni:
- Senzori de poziţie (Incrementali/Potenţiometre);
- Senzori de forţă;
- Senzori de detecţie în infraroşu;
- Senzori de acceleraţie; - Senzori cu efect Hall.
b. Senzori externi:
- Senzori cu ultrasunete;
- Senzori de atingere;
- Senzori de forţă;
- Senzori de culoare;
- Senzori de lumină; - Camere video.
Senzorii din roboţii mobili se pot clasifica şi independent de gruparea interni-externi, numai
pe criteriul funcţional, astfel:
‣ senzori de distanţă – acei senzori care oferă informaţii despre distanţa între senzor şi
obiectul de măsurat din mediu;
‣ senzori de poziţie – acei senzori care oferă informaţii despre poziţia robotului în termeni
absoluţi;
‣ senzori de mediu – acei senzori care oferă informaţii despre diverse proprietăţi şi
caracteristici ale mediului (exemplu: temperatură, culoare);
‣ senzori inerţiali – acei senzori care măsoară proprietăţi diferenţiale ale poziţiei robotului
(exemplu: acceleraţia).
Caracterizarea generală a senzorilor se poate face pe baza relaţiei (f) dintre proprietăţile
fizice de interes ale mediului (e) şi informaţia primită de la un senzor (r) ar putea fi modelată prin
ecuaţia [13]:
21

În principiu, orice model al unui senzor ar trebui să includă şi un model intern al zgomotului
care poate afecta senzorul în momenrul citirii informaţiei. Problema de a recupera informaţia din
mediu din datele primite de la senzor poate fi destul de complexă.
Un senzor este considerat instabil dacă pentru variaţii mici ale intrării, ieşirea se schimbă
radical. În caz general, pentru un senzor cu ieşirea f(e), instabilitatea se referă la: f (e)− f (e+ h)
h h →∞
În principiu orice tip de senzor poate fi afectat de mai multe tipuri de erori.
Dintre acestea, cele mai importante sunt erorile incidentale, erorile sistematice şi erorile
stohastice. Erorile incidentale apar ocazional şi pot avea un efect neprevăzut asupra informaţiei,
ele provenind în cea mai mare parte de la măsurători efectuate greşit. Erorile sistematice au o
influenţă predictibilă asupra acurateţii informaţiei,acestea provenind de la o interpretare greşită a
parametrilor în algoritmii de estimare, sau din cauza unor neconcordanţe (incertitudini) în
modelare. În fine, erorile stohastice au un caracter aleator, ele diferind de fiecare dată când robotul
execută aceeaşi operaţie.
2.3.2 Senzori cu ultrasunete
Categoria de senzori cea mai des întâlnită la un robot mobil o constituie, fără nici o îndoială,
categoria senzorilor ultrasonici. Întâlniţi în literatura de specialitate şi sub denumirea de sonar
senzorii ultrasonici folosesc semnale acustice (sunete).
2.3.2.1 Caracteristici generale
Senzorii cu ultrasunete sunt unii dintre cei mai utili şi eficienţi senzori din dotarea roboţilor.
Ei permit măsurarea suficient de precisă, fără contact, a distanţelor faţă de alte obiecte din mediu
şi asigură astfel premizele pentru unele dintre cele mai importante activităţi ale roboţilor:
• Măsurarea distanţei faţă de unele repere, fixe sau mobile din mediu, pentru ancorarea
propriei poziţii în spaţiul de lucru;
• Identificarea obstacolelor din mediu înconjurator, cu poziţia şi configuraţia lor, în
vederea stabilirii unei strategii optime pentru ocolirea lor, dar şi pentru o eventuală
reconfigurare, în vederea abordării lor directe;
• Identificarea poziţiei şi orientării unor module, în vederea unei eventuale ataşări şi
cuplări;
Un emiţător sonar transmite un semnal acustic în mediu urmând apoi ca reflecţia acestuia
să fie recepţionată de componenta detector a senzorului. Timpul în care semnalul este receptat
înapoi de senzor precum şi atenuarea semnalului reprezintă aspecte exploatate de diferitele tipuri
de senzori sonar.
22

Sunetele transmise de senzorii sonar sunt de regulă în spectrul de sunete ultrasonice,
având o frecvenţă foarte înaltă pentru a nu putea fi detectate de urechea umană.
Principiul de funcţionare al senzorilor sonar a fost împrumutat din lumea animală, atât liliecii
cât şi delfinii folosind aceleaşi tehnici pentru a localiza şi identifica diferitele caracteristici ale unui
anumit robot.
Sensibilitatea unui senzor sonar nu este uniformă, ci consistă dintr-un lob principal şi
câteva loburi laterale mai mici. De asemenea, această sensibilitate diferă de la un senzor sonar
la altul. Diferenţele de sensibilitate ale unora dintre cei mai populari senzori sonar, şi anume
modelele Devantech SRF08 şi SRF10 pot fi observate în Figura 6 şi Figura 7 [9].
Figura 6. Sensibilitatea senzorului Devantech SRF08
Figura 7. Sensibilitatea senzorului Devantech SRF10
2.3.2.2 Principiul de funcţionare al senzorului cu ultrasunete
Principiul de funcţionare al unui senzor ultrasonic tipic este prezentat în Figura 8 (V ss, V dd
- tensiune alimentare sursa-drena).
23

Figura 8. Principiul de funcţionare al senzorului cu ultrasunete
Măsurarea distanţei constă în măsurarea timpului de propagare a undelor între reperele
considerate.
unde
• - distanţa
• - timpul măsurat
• - viteza de propagare a undei în mediul considerat
În general depinde de indicele de refracţie al mediului, care la rândul său depinde de mai
mulţi parametrii (temperatură, presiune, umiditatea aerului, lungimea de undă), iar cunoaşterea
exactă a acestui aspect poate îmbunătăţi precizia măsuratorilor.
2.3.2.3 Senzorul cu ultrasunete Parallax PING)))
Un model pentru analiza şi testarea caracteristicilor tehnice ale acestui tip de senzori poate
fi Parallax PING))), un senzor având configuraţia şi dimensiunile prezentate în Figura 9
[9].
24

Figura 9. Senzorul cu ultrasunete Parallax PING)))
Acest senzor are următoarele caracteristici [9]:
• Tensiune de alimentare – 5V cc.;
• Curent absorbit: 30 mA tipic, 35 mA maxim;
• Domeniu de măsurare – între 2 cm şi 3 m;
• Impulsul de declanşare a măsurarii: impuls pozitiv TTL, 2μs minim, 5μs tipic;
• Semnal receptat ca ecou: impuls pozitiv TTL, între 115 μs şi 18,5 ms;
• Frecvenţa de baleiere: 40 KHz pentru 200 μs;
• Timp de întârziere până la următoarea măsurare: 200 μs:
• Dimensiuni – 22 mm x 46 mm x 16 mm.
Un avantaj major al acestui senzor constă în faptul că nu necesită decât o singură linie
I/E a unui procesor numeric. Senzorul detectează un obiect şi permite măsurarea distanţei până
la el prin emiterea unui scurt impuls cu frecventa de 40 KHz (domeniul ultrasonic), care se
deplasează cu viteza sunetului în aer, de 340 m/s, şi aşteptarea şi sesizarea ecoului, determinat
de reflectarea undelor de către obstacol (Figura 8).
În practică senzorul Parallax PING))) are câteva particularităţi care evidenţiază limitările
acestei tehnologii. În Figura 10 sunt evidentiate aceste limitari.
25

Figura 10. Cazuri în care obiectul nu este detectat de senzorul cu ultrasunete
Nu poate fi măsurată corect distanţa la un obiect care: a. se află la mai mult
de 3m distanţă;
b. prezintă suprafeţe care nu reflectă undele acustice înapoi spre dispozitiv;
c. este prea mic pentru a reflecta destule unde acustice.
O sensibilitate scăzută a senzorului se constată şi în cazul în care obiectul este alcătuit din
materiale moi sau prezintă forme neregulate. Senzorul poate detecta suprafaţa apei, dar este
predispus la deteriorări din cauza umezelii şi condensaţiei, în consecinţă nu este recomandat
pentru uz în aer liber sau în preajma apei.
Deoarece viteza de propagare a sunetului prin aer este influenţată şi de temperatura
ambiantă, se poate ţine cont de această variaţie folosind următoarea formulă:
unde
• – viteza sunetului în aer [m/s]
• – temperatura aerului [ 0 C]
Eroarea de măsurare pentru o variaţie a temperaturii aerului de la 0 0 C la 70 0 C este de 11-
12%. Se recomandă folosirea unor constante de conversie în programare pentru a compensa
pentru erori.
Sensibilitatea senzorului este descrisă de testul din Figura 11.
Figura 11. Test senzor Parallax PING))) pentru un paravan paralel din carton
Testul a fost efectuat de către producător într-o cameră izolată, la temperatura uzuală.
Obiectul ţintă este un paravan din carton de dimesiuni 30.5 cm x 30.5 cm plasat la înălţimea de
1m faţă de podea pentru a elimina reflexii suplimentare ale undelor.
Rezultatele măsuratorilor au dus la următoarea reprezentare grafică a sensibilităţii
senzorului Parallax PING))):
26

Figura 12. Zona de sensibilitate a senzorului Parallax PING))) pentru testul cu paravan
De fapt zona de sensibilitate al senzorului cu ultrasunete este un con (în 3D), iar Figura 12
este o vedere perpendiculară pe generatoarea conului. Doar obiectele din interiorul conului sunt
detectate.
Din Figura 12 se poate trage concluzia că senzorul are o sensibilitate mare concentrată
pe axa acustică (generatoarea conului). Faptul că zona este îngustă este avantajos, deoarece
permite evaluarea poziţiei obiectului. Precizia mare este datorată suprafeţei drepte a paravanului
şi orientarea sa care reflectă majoritatea undelor sonore îinapoi spre senzor.
2.3.3 Senzori de contact
Cel mai des întâlnit tip de senzori de contact în roboţii mobili este reprezentat de senzorii
bumper . Aceste dispozitive pot fi simple întrerupătoare care raportează o valoare binară, 0 sau 1,
valoare corespondentă stării de fapt: deschis sau închis. Astfel, în momentul în care robotul
echipat cu senzori de acest tip se loveşte de un alt obiect, întrerupătorul se va închide semnalând
acest lucru. Un exemplu de caz în care o anumită parte a unui robot mobil se atinge de un obiect
din mediu este prezentat în Figura 13 [13].
27

Figura 13. Activarea senzorilor bumper în momentul ciocnirii robotului cu un obiect
Robotul din Figura 13 are un sistem senzorial format din 8 senzori bumper, situaţi pe robot
la circumferinţa acestuia. În momentul în care robotul se loveşte de obiectul din mediu, senzorii
aflaţi pe partea respectivă a robotului (în acest caz senzorul 4 şi 5) vor raporta acest lucru.
Cu toate că senzorii bumper sunt folosiţi pentru a evita lovirea robotului de obiecte din
mediul ambiant în caz de coliziune cu acestea, dacă forţa de impact este mare, detectarea
coliziunii nu mai este suficientă pentru a evita distrugerea anumitor părţi ale robotului.
Majoritatea roboţilor mobili folosiţi în laboratoare nu sunt echipaţi cu sisteme de frânare
active, şi chiar dacă ar fi pentru o anumită viteză, unui robot mobil tot i-ar lua o distanţă
considerabilă pentru a se opri brusc, datorită inerţiei motoarelor. Unele autovehicule au instalate
totuşi senzori bumper, nu atât pentru detectarea coliziunilor, cât pentru a absorbi din şocul produs
la impactul cu un obiect extern.
2.4 Servomotoare
Servomotoarele reprezintă componente esenţiale, de execuţie şi de precizie, în structura
unui robot mobil, utilizate în principal pentru deplasarea robotului, dar şi pentru realizarea unor
mişcări, ce pot fi complexe şi de mare precizie, ale unor organe/părţi ale robotului. Ultimele decade
au fost marcate de evoluţii remarcabile în ceea ce priveşte dimensiunile, viteza de rotaţie şi cuplul
motor al motoarelor de tip servo.
În Figura 14, se prezintă astfel (spre exemplificare, pentru servomotorul Futaba S3151) o
structură tipică, împreună cu alte caracteristici semnificative [12].
Figura 14. Componentele unui servomotor. Servomotorul Futaba S3151
28

Gabarit:
( mm )
Tabelul 1. Caracteristicile mecanice, electrice şi geometrice ale servomotorului.
Masa:
( g )
Cuplul la
4,8V
(Nmm)
Viteza:
0,16s/45° la
4,8V
Cuplul de
mentinere
(Nmm)
Tensiunea:
( V )
40,5x20x36,1 42 310 0,21 770 4,8 ÷ 6
O îmbunătăţire deosebită constituie dezvoltarea servomotoarelor digitale ce au avantaje
funcţionale semnificative faţă de servomotoarele analogice (standard). În principiu, un servomotor
digital este asemănător cu un servomotor standard, cu excepţia unui microprocesor care
analizează semnalele de intrare şi controlează motorul.
Una din diferenţe constă în modul de procesare a semnalelor de intrare şi transmiterea
puterii iniţiale de la servomotor, reducând timpul mort, crescând rezoluţia şi generând un cuplu de
menţinere superior.
La motoarele servo convenţionale, în faza de repaus, nu se alimentează servomotorul. În
cazul servomotoarelor digitale, când este primită o comandă de pornire a servomotorului, sau
când se aplică un cuplu la axul de ieşire, servo-ul răspunde prin alimentarea cu tensiune a
motorului.
Această tensiune, care este de fapt tensiunea maximă, este pulsată sau transmisă on/off
cu o rată fixă de (spre exemplu 50 de cicluri pe secunda), generând scurte impulsuri de tensiune.
Prin creşterea duratei fiecărui impuls se creează un control al vitezei, care poate creşte progresiv
când se aplică motorului tensiunea maximă fără întrerupere, accelerând servomotorul şi deci
robotul, sau organul acţionat, spre noua poziţie.
Modul concret de aplicare a acestui mecanisnm de comandă se poate realiza conform cu
diagramele prezentate în Figura 15.
29

Figura 15. Comanda prin PWM. Servomotor standard şi digital
Un impuls On de lăţime scurtă, urmat de o pauză scurtă, nu constituie pentru motor o
comandă să se întoarcă, cu condiţia să nu fie mai lungă pauza. Aceasta înseamnă un control al
mişcării, care la întoarcere trimite mici impulsuri iniţiale spre motor, este foarte ineficient, şi de
aceea este denumită banda moartă.
Din cele de mai sus rezultă câteva avantaje importante ale servomotoarelor digitale:
- prin intermediul microprocesorului este posibilă primirea de semnale de intrare de
comandă prin care durata impulsului poate fi ajustată prin programarea
microprocesorului pentru a realiza funcţiile cerute şi pentru a optimiza performanţele
servomotorului;
- la un servomotor digital se pot trimite impulsuri către motor la o frecvenţă semnificativ
mai mare, de regulă între 50 de impulsuri / secunda şi 300 impulsuri / secunda, astfel
că servomotoarele digitale vor răspunde mai rapid la comenzi.
În Figura 16 se prezintă comparativ variaţii tipice ale cuplului în timp pentru servomotoarele
standard şi servomotoarele digitale.
30

Figura 16. Caracteristicile cuplu-timp pentru servomotoarele standard şi digitale
Comanda (controlul) servomotoarelor reprezintă partea esenţială a acestora care asigură
posibilitatea interfaţării cu procesoarele prin care se execută programele şi aplicaţiile specifice
robotului.
De fapt, sistemul de comandă al servomotorului constituie elementul care se adaugă şi
face diferenţa faţă de un simplu motor. În general aceste motoare sunt de curent continuu,
obişnuite sau „pas cu pas”.
Comanda elementelor de execuţie (roboţi sau organe/părţi ale acestora) cu ajutorul
motoarelor pas cu pas şi a servomotoarelor de curent continuu, pentru a obţine o mişcare
incrementală precisă, este o problemă destul de dificilă, cu mai multe tipuri de soluţii în funcţie de
aplicaţie şi de caracteristicile urmărite.
În general, modelul comenzii pentru roboţi mobili se poate aborda şi asimila sistemelor cu
dinamică lentă, care nu sunt supuse perturbaţiilor electromagnetice (spre exemplu: acţionarea
maşinilor cu comandă numerică, a imprimantelor, plotter-elor etc.).
31

Sistemul de comandă pentru un servomotor de c.c este, practic, un sistem de acţionare
electrică, având în componenţă motorul electric (servomotorul de c.c), obiectul acţionat, transmisia
şi elementul de execuţie (Figura 17) [18].
Figura 17. Schema bloc a unui sistem de acţionare cu servomotoare de c.c.
În Figura 17 sunt făcute următoarele notaţii:
• Motorul electric – ME – realizează transformarea puterii electrice în putere mecanică.
• Obiectul acţionat – OA – este antrenat de ME şi realizează anumite mişcări impuse.
• Transmisia – T – reprezintă legatura mecanică dintre ME şi OA cu rolul de a realiza
transferul de putere mecanică şi, eventual, de a schimba parametrii acestei puteri
(viteza unghiulară, cuplu).
• Elementul de execuţie – EE – are drept scop alimentarea cu energie electrică a ME şi
comanda funcţionării în conformitate cu anumite cerinţe.
Pentru proiectarea acestui element (EE), se ţine seama de următorii factori:
• caracteristica viteza unghiulară ( ) – moment/cuplu ( ) în regim staţionar atât a
motorului, cât şi a obiectului acţionat:
•
• gama de viteze de lucru necesare, definită ca fiind raportul dintre viteza unghiulară
minimă şi maximă;
• precizia de menţinere a vitezei.
Comanda concretă a servomotoarelor de c.c. se face cu convertoare statistice de c.c. – c.c.
(chopper-e), care la rândul lor pot fi comandate în funcţie de semnalele asociate cu unul sau mai
mulţi dintre factorii menţionaţi mai sus, dar la aceştia se adaugă semnalele de comandă care
trebuie să asigure, prin procesor, execuţia programelor specifice aplicaţiei.
2.5 Metode de comunicare fără fir (wireless)
Tehnicile şi tehnologiile utilizate în domeniul tehnologiei informaţiei şi comunicaţiilor (TIC)
reprezintă baza dezvoltării societăţii informaţionale şi principalul factor de progres
tehnicoeconomic mondial, astfel explicându-se atât diversitatea, dinamica, complexitatea cât şi
importanţa în cadrul global.
32

Tehnicile de comunicaţie utilizabile pentru transmiterea datelor între un robot mobil şi PC
restrâng, în majoritatea aplicaţiilor specifice, gama tehnologiilor la cele cu o rază de acţiune mobilă
dar limitată, care sunt reprezentate de standardele wireless (fără fir), radio sau infraroşu. Până
acum proiectarea sistemelor de comunicaţie fără fir s-a axat mai mult pe creşterea performanţelor
de transmisie prin aer. În acest context atenuarea şi interferenţele sunt privite ca şi zgomote
inevitabile unui astfel de mediu de transmisie. Ultimele tendinţe au arătat că acum accentul se
pune prepondernt pe creşterea eficienţei spectrale.
2.5.1 Comunicaţii în Infraroşu
Comunicaţiile wireless în infraroşu se referă la propagarea undelor de lumină emisă în
banda infraroşu, unde radiaţa electromagnetica are o lungime de unda mai lunga decat cea a
luminii vizibila, dar mai scurta decat a undelor radio.
O modalitate de caracterizare a unei conexiuni wireless se face în funcţie de tipul legăturii
care se stabileşte: sistemele punct-la-punct şi sistemele cu difuzie.
Cel mai simplu tip de legătură care se poate stabili este cel punct-la-punct (Fig.18, [25]). În
acest caz, atât transmiţătorul cât şi receptorul trebuie “să se vadă reciproc”, deci să existe o cale
neopturată. Aceste legături pot fi stabilite temporar pentru a se putea realiza o sesiune de
schimburi de date între doi utilizatori sau se poate stabili o legătură permanentă atunci când se
foloseşte o unitate mobilă ca şi „base point” în cadrul unei reţele LAN.
Figura 18. Sistem de comunicaţii în infraroşu Un emiţător (T) converteşte
un semnal electric într-unul optic. LED-ul şi dioda semiconductoare laser sunt două dintre cele
mai apropiate soluţii tehnice pentru acest scop. LED-urile au caracteristici de transmisie care
permit un câmp larg de aplicabilitate, în special în cazurile în care se folosesc legăturile indirecte.
LED-urile mai au încă un avantaj în faţa diodelor semiconductoare laser, şi anume că ele
protejează ochiul uman.
Receptorul (R) sau detectorul de semnal converteşte semnalul optic recepţionat de la
emiţător şi îl transpune într-un curent electric. Fotodiodele din siliciu de tip p-i-n sunt cele mai
recomandate pentru astfel de aplicaţii fără fir, ele având o eficienţă sporită în această bandă de
comunicaţie precum şi un preţ destul de bun.
33

În cazul unui sistem de comunicaţii optice care se află într-un mediu deschis, aşa cum este
cazul tipic, detectorul este iluminat şi de alte surse de lumină decât cea de la emiţător, astfel că
ele se manifestă ca nişte zgomote aditive care fac ca la fotodetector curentul generat de către
acesta să nu mai fie cel exact.
În comunicatiile optice partea de spectru de infrarosu care este folosita este impartita în
cateva benzi bazate pe disponibilitatea surselor de lumina, materiale de transmisie şi absorbţie şi
detectori.
Banda C (1530–1565 nm) este banda dominanta pentru retelele de telecomunicatii de
distanta lunga, U cu lungimea de undă ultralungă (1625–1675 nm) iar banda O (1260–1360 nm)
este banda originală IR (lungimea de undă cea mai scurtă) [21].
Transmisia de date prin IR este o comunicare de raza scurta între perfericelele
calculatorului şi asistenti digitali personalizati. Aceste dispozitive se conformeaza standardului
IRDA (Infrared Data Association). Controalele la distanta şi dispozitivele IrDa folosesc LED-uri
(Light Emitting Diodes) infrarosii pentru a emite radiatie infrarosie care este focalizata de o lentila
de plastic într-o raza ingusta. Raza este modulata, pornita sau oprita, pentru a codifica datele.
Receptorul foloseste o fotodioda siliconica pentru a converti radiatia infrarosie în curent electric.
IrDa (Infrared Data Association, asociere de date prin infrarosu) defineste specificatii fizice
pentru standarde de protocale de comunicatii pentru schimbul de date prin lumina infrarosie pe
distanta mica, pentru utilizarea în PAN-uri (Personal Area Networks).
Standardele IrDa includ o serie largă de specificaţii şi protocoale: IrPHY, IrLAP, IrLMP,
IrCOMM, Tiny TP, IrOBEX, IrLAN şi IrSimple.
2.5.2 Comunicaţii prin Bluetooth ®
Comunicaţiile Bluetooth sunt un standard de comunicaţie pentru dispozitive mobile,
standard care se aplică pe distanţe ceva mai mari decât în cazul comunicaţiilor în infraroşu.
Sistemul Bluetooth este cel mai adecvat atunci când distanţa dintre emiţător/receptor este
scurtă, rata de transfer este mare, iar puterea consumată trebuie menţinută cât mai scăzută.
Ideea ce a dat nastere tehnologiei wireless Bluetooth a aparut în 1994 cand compania
Ericsson Mobile Communications a decis investigarea fezabilitatii unei interfete radio de mica
putere şi cost redus între telefoanele mobile şi accesoriile acestora.
Specificaţiile Bluetooth sunt practic acoperite de standardul IEEE 802.15.1(astfel se
justifică termenul „standardul Bluetooth”) şi reprezinta una dintre cele mai avansate tehnologii de
comunicatie fara fir. Cu putere mare de transfer al datelor şi consum foarte scazut de energie,
actionand pe distante mici, de la 1m pana la 100m şi numai "indoor", Bluetooth se afirma ca fiind
mijlocul prin care toate echipamentele care ne inconjoara pot interactiona.
Bluetooth prezinta o tehnologie pentru distante scurte cu costuri reduse, vizând crearea
unor reţele personale (PAN-Personal Area Nework).
34

Principalele tipuri de aplicatii ale Bluetooth sunt:
• controlul wireless al comunicarii între telefonul celular şi castile hands free sau car kitul.
Aceasta aplicatie a devenit cea mai populara.
• retea wireless între calculatoare într-un spatiu limitat şi cerinte mici de lungime de
banda, aici putând include şi cazul PC-robot.
• comunicatie wireless între dispozitivele de intrare şi ieşire ale unui calculator, cele mai
intalnite fiind mouse-ul,tastatura sau imprimanta.
• inlocuirea comunicarii traditionale seriale prin fir în echipamentele de test, receptoeul
GPS şi echipamente medicale.
• pentru controale unde infrarosul era folosit.
• controlul wireless al consolei de jocuri – Nintendo’s Wii şi Sony’s PlayStation 3 folosesc
tehnologia Bluetooth pentru consolele lor wireless.
Pentru a putea analiza eficient soluţiile fără fir (wireless), este utilă comparaţia cu alte
tehnologii [21]:
1) Bluetooth
a) este indreptata către aplicatii de voce şi date;
b) opereaza în spectrul 2.4GHz;
c) functioneaza pe o distanta de la 1m la 100 m;
d) este capabila sa treaca prin obiecte solide, este omnidirectionala şi nu necesita o
pozitionare în linie cu celelalte dispozitive pentru conectare;
e) securitatea este şi va fi o prioritate în dezvoltare;
f) costul unui chip este mic, nu necesita adrese de retea, aprobări şi celelalte setari pentru o
retea tipica de Internet;
2) IrDA
a) este folosit pentru a oferi conectivitate wireless pentru dispozitivele care în mod normal
folosesc cablu pentru conectare;
b) opereaza pe distanţe mici (câţiva metri), la viteze între 9600 bps şi 16 Mbps;
c) nu poate trece prin obiecte solide şi aplicatiile de schimb de date sunt limitate;
d) este mai des folosit în sistemele de plata, în controlul la distanta sau pentru sincronizarea
a 2 PDA-uri;
3) Wi-Fi
a) este mai analog retelei traditionale de Internet şi necesita configurari pentru a impartii
resursele , transmite fisiere, realize legaturi audio;
b) foloseste aceleasi frecvente radio ca şi Bluetooth-ul , dar cu un consum de putere mai
mare, rezultand o conexiune mai puternica;
c) necesita mai multe configurari, dar este cel mai potrivit pentru o retea, realizandu-se o
conexiune mai rapida, o raza de actiune mult mai mare şi o securitate mai ridicata, dar
costul este relativ mare;
Sistemul de comunicaţie Bluetooth a fost proiectat cu scopul de a conecta mai multe
dispozitive pentru a implenta o reţea mică şi de aceea protocolul care dictează regulile de
comunicaţie are în vedere o arhitectură de tip master-slave.
35

În Figura 19 se prezintă un dispozitiv şi o reţea Blutooth (Piconet) [21].
Figura 19. Dispozitiv şi retea Bluetooth Piconet
Având în vedere cerinţele temei proiectului şi caracteristicile generale avantajoase, care
au determinat deja utilizarea sa frecventă la comunicaţiile PC-roboţi mobili, detalii privind structura
şi elementele principale ale standardului Bluetooth (IEEE 802.15.1), precum şi a versiunilor
acestuia, se vor prezenta în Capitolul 3.
3 Tehnologia Bluetooth ®
3.1 Prezentare generală
Tehnologia wireless Bluetooth reprezintă una dintre cele mai avansate şi răspândite
tehnologii de comunicatie fără fir.
Bluetooth prezintă următoarele avantaje principiale:
✓ facilitează atât comunicaţiile de date cât şi pe cele vocale;
✓ oferă posibilitatea implementării unor reţele ad-hoc şi a sincronizării între diverse
dispozitive electronice şi echipamentele periferice ale computerelor care se afla la
distanţe de ordinul a 10 m;
✓ asigură soluţii pentru comunicaţii vocale şi de date fără cabluri, utilizând alimentări
standard low-power, tehnologii de cost redus ce pot fi cu uşurinţă integrate în orice
dispozitiv şi deschide calea unei mobilităţi totale.
Specificaţiile Bluetooth definesc capabilităţi de legături radio pe distanţe scurte
(aproximativ 10m) sau opţional pe distanţe medii (aproximativ 20m) pentru transmisii vocale sau
de date de capacitate maximă 720kbps pe canal [20].
Gama de frecvenţe de operare o constituie banda nelicenţiată industrială, ştiinţifică şi
medicală (ISM) de la 2.4GHz la 2.48Hz, utilizând tehnici de împrăştiere a spectrului (frequency
hopping spread spectrum), cu salturi de frecvenţă ale semnalului duplex de până la 1600 salturi
36

pe secundă. Semnalul execută salturi prin 79 intervale de frecvenţă de 1MHz, pentru a realiza o
bună imunitate la interferenţe. Puterea emisă este conform specificaţiilor 0dBm (1mW) pentru
implementările pentru acoperiri reduse (10m) şi maxim 20dBm (100mW) pentru versiunile pentru
domenii mai extinse (100m).
Când s-au alcătuit specificaţiile radio, un mare accent s-a pus pe posibilitatea implementării
design-ului într-un singur chip CMOS, în consecinţă reducându-se costul, puterea consumată şi
dimensiunile necesare pentru implementarea în dispozitivele mobile.
Comunicaţiile vocale: Sunt utilizate până la trei canale vocale sincrone simultan sau un
canal care suportă simultan transmisie de date asincronă şi transmisie vocală sincronă. Fiecare
canal vocal suportă sincron 64kb/s în fiecare sens.
Comunicaţii de date: Un canal de date asincron poate suporta maxim 723.2kbps în sens
direct în conexiune asimetrică (şi până la 57.6kbps în sens invers), sau 433.9kbps în conexiune
simetrică.
Structura master-slave: Deorece sistemul de comunicaţie Bluetooth a fost proiectat cu
scopul de a conecta mai multe dispozitive pentru a implementa o reţea de tip LAN, protocolul de
sincronizare se bazează pe o structură de tip master-slave.
Fiecare dispozitiv Bluetooth poate stabili conexiuni cu încă 7 alte dispozitive. Numai o
singură conexiune este activă la un moment de timp, restul fiind într-o stare semi-activă. Pe scurt
aceste dispozitive au un număr de adresă fix, dar nu au acees la mediul de transmisie decât atunci
când le vine rândul sau li se cere să comunice cu un master. Sincronizarea frecvenţelor presupune
definirea unor intervale de timp de 625 de microsecunde, unde masterul îşi va transmite pachetele
în intervalele de timp cu număr par, iar slave-urile în intervalele de timp cu număr impar.
Unităţile Bluetooth aflate în acelaşi domeniu spaţial de acţiune radio pot realiza ad-hoc
conexiuni punct-la-punct şi/sau punct-la-multipunct. Unităţile pot fi adăugate sau deconectate în
mod dinamic la reţea. Două sau mai multe unităţi pot utiliza în comun un canal al unui piconet.
Se pot forma mai multe picoreţele şi acestea se pot lega ad-hoc împreună formând scatternet
(Figura 20 [24]), pentru a realiza configuraţii flexibile de comunicaţii şi schimburi de date.
Dacă într-un acelaşi domeniu spaţial se află mai multe pico-reţele, fiecare lucrează
independent şi fiecare are acces la întreaga bandă de frecvenţe. Fiecare pico-reţea este stabilită
pe un canal diferit, cu salt în frecvenţă. Toţi utilizatorii participanţi la aceeaşi pico-reţea sunt
sincronizaţi pe acest canal. Spre deosebire de dispozitivele cu infraroşu (IR), unităţile Bluetooth
nu sunt limitate de necesitatea vederii directe între ele.
37

Figura 20. Reţele Bluetooth Scatternet
Pentru a se respecta normele de imunitate la coliziuni între date, un scatternet poate
cuprinde până la 10 piconet-uri.
3.2 Principalele caracteristici ale standardului Bluetooth / IEEE 802.15.1
Legătura între Bluetooth şi IEEE s-a făcut prin faptul că primele specificaţii Bluetooth (1.0)
-1999 au devenit baza IEEE Standard 802.15.1-2002 (prin care se ratifica Bluetooth 1.1),
consacrând astfel importanţa şi forţa noii tehnologii.
Deşi, în mod firesc, Bluetooth a urmat o evoluţie ascendantă (mai multe versiuni detaliate
la paragraful 3.3), marcată şi de standarde IEEE, principalele caracteristici ale standardului iniţial
(1.0) se păstrează ca majoritare şi definitorii, după cum se prezintă în continuare.
3.2.1 Clasele de putere / acoperire şi securitatea Bluetooth
În funcţie de puterea maximă emisă s-au standardizat 3 clase principale în care se pot
fabrica dispozitivele Bluetooth, acestora corespunzându-le şi diferite acoperiri (raze de acţiune)
maxime (Tabelul 2).
Tabelul 2. Clase Bluetooth
Clasa Puterea maximă permisă Puterea maximă permisă Raza
(mW)
(dBm)
(aproximativă)
Clasa 1 100 mW 20 dBm 100 m
Clasa 2 2.5 mW 4 dBm 10 m
Clasa 3 1 mW 0 dBm 1 m
Deoarece semnalele radio pot fi uşor interceptate, dispozitivele Bluetooth au încorporate
proceduri de securizare, pentru prevenirea receptorilor rău-intenţionaţi şi nevizaţi de mesaj. Trei
sunt metodele de securizare a informaţiei:
38

1. Rutina de interpelare pentru autentificare;
2. Cifrarea fluxului informaţional, ca metodă de criptare;
3. Generarea unor chei de sesiune – aceste chei pot fi oricând schimbate pe parcursul
unei conexiuni stabilite.
În algoritmii de securizare sunt utilizate trei entităţi:
1. Adresa dispozitivului Bluetooth (BD_ADDR pe 48 biţi), care este o entitate publică
unică pentru fiecare dispozitiv (această adresă se obţine prin procedura Inquire);
2. cheie privată specifică utilizatorului (128 biţi), care este o entitate secretă (cheia privată
derivă din procedura de iniţializare şi nu este dezvăluită niciodată);
3. Un număr aleator (128 biţi), care diferă la fiecare nouă tranzacţie. Acest număr este
derivat dintr-un proces pseudo-aleator în unitatea Bluetooth.
În plus faţă de aceste funcţii la nivel de legătură, salturile de frecvenţă şi transmisia limitată
spaţial ajută şi ele la prevenirea recepţionărilor neautorizate.
3.2.2 Stiva de protocoale Bluetooth
O caracteristică cheie a Bluetooth este aceea de a permite dispozitivelor realizate de diverşi
producători să lucreze împreună. Pentru acest scop, Bluetooth nu defineşte doar un sistem radio,
ci şi o stivă de protocoale pentru ca aplicaţiile respective să poată sesiza prezenţa altor dispozitive
Bluetooth, să descopere ce servicii pot acestea oferi şi să utilizeze aceste servicii.
Stiva de protocoale este definită ca o serie de straturi, deşi unele caracteristici nu pot fi
delimitate ca aparţinând unui anumit strat. În Figura 21 este evidenţiat acest aspect [20].
39

Figura 21. Stiva de protocoale Bluetooth
Profilurile Bluetooth ghidează aplicaţiile în utilizarea stivei de protocoale Bluetooth. TCS
(Telephony Control Protocol Specification) oferă servicii telefonice.
SDP (Service Discovery Protocol) lasă dispozitivele Bluetooth să descopere ce servicii
suportă celelalte dispozitive. RFCOMM oferă o interfaţă serială asemănătoare cu RS232. L2CAP
multiplexează date de la straturile superioare şi converteşte dimensiunile pachetelor
informaţionale, după necesităţi. HCI manipulează comunicaţiile între modulul Bluetooth şi aplicaţia
gazdă. LM controlează şi configurează legăturile cu alte dispozitive. BB/LC controlează legăturile
fizice prin radio, asamblează pachetele şi controlează salturile în frecvenţă. Stratul Radio
modulează şi demodulează datele pentru transmisia şi recepţia aeriană.
3.2.3 Descoperirea dispozitivelor Bluetooth
Presupunem că avem de-a-face cu două dispozitive echipate Bluetooth, un telefon celular
şi un laptop. Celularul este capabil să se comporte ca un modem, folosind profilul Dial-Up
Networking şi scanează periodic să vadă dacă cineva doreşte să-l utilizeze. Utilizatorul laptop-ului
deschide o aplicaţie care necesită o legătură Bluetooth dial-up.
Pentru a utiliza această aplicaţie, laptop-ul ştie că are nevoie să stabilească o legătură Bluetooth
cu un dispozitiv ce suportă profilul Dial-Up Networking. Primul pas în stabilirea unei astfel de
40

conexiuni este de a afla ce dispozitive Bluetooth se află în zonă, aşa că laptop-ul iniţiază o
procedură Inquiry pentru a sonda vecinătatea cu alte dispozitive.
Pentru aceasta, laptop-ul transmite o serie de pachete de interogare (inquiry) şi eventual
telefonul celular răspunde cu un pachet FHS (Frequency Hop Synchronisation). Pachetul FHS
conţine toate informaţiile de care laptop-ul are nevoie pentru crearea unei legături cu celularul.
Acesta conţine de asemenea şi informaţii despre clasa dispozitivului, informaţii structurate pe două
nivele: părţi majore – a fost descoperit un telefon şi părţi minore – telefonul descoperit este un
telefon celular.
În acelaşi mod, orice dispozitiv Bluetooth din zonă, care scanează mediul în căutarea de
mesaje Inquiry, va răspunde cu un pachet FHS, astfel încât laptop-ul acumulează o listă cu
dispozitive.
Ceea ce se întâmplă mai departe depinde de proiectantul aplicaţiei. Laptop-ul poate
prezenta utilizatorului o listă a tuturor dispozitivelor descoperite şi îl poate lăsa pe acesta să decidă
cum să continue; de menţionat că în acest stadiu laptop-ul nu-i poate prezenta utilizatorului decât
informaţii referitoare la tipul dispozitivelor descoperite.
3.3 Versiuni în evoluţia Bluetooth ®
3.3.1 Evoluţia specificaţiilor Bluetooth la standardul IEEE
Numele Bluetooth vine de la Harald I Blåtand ("the blue-toothed"), regele Viking al
Danemarcei între anii 940 şi 981 [23]. Ideea ce a dat naştere tehnologiei wireless Bluetooth a
apărut în 1994 când compania Ericsson Mobile Communications a decis investigarea fezabilităţii
unei interfeţe radio de mică putere şi cost redus între telefoanele mobile şi accesoriile acestora.
În februarie 1998 a luat fiinţă Grupul de Interes Special (SIG). Astăzi Bluetooth SIG include
companiile promotoare 3Com, Ericsson, IBM, Intel, Lucent, Microsoft, Motorola, Nokia şi Toshiba,
şi mii de companii – membri asociaţi sau adoptori.
Iniţial misiunea SIG a fost de a monitoriza dezvoltarea tehnologiei radio pentru domenii
restrânse şi de a crea un standard global deschis, prevenind astfel devenirea acestei tehnologii
proprietatea unei singure companii. Acest lucru a avut ca rezultat apariţia primei specificaţii
Bluetooth (1.0) 1999.
În martie 2000 IEEE şi SIG au convenit crearea unui standard IEEE pe baza versiunii
1.1-Bluetooth.
41

În 2002 Bluetooth 1.1 este ratificat ca IEEE Standard 802.15.1-2002.
3.3.2 Bluetooth 1.0
Prima versiune Bluetooth (1.0) apare în 1999. Versiunile 1.0 şi 1.0B au avut multe
probleme şi mai mulţi producatori au avut multe dificultati în a face produsele interoperabile.
Versiunile 1.0 şi 1.0B de asemenea au avut prin regula BD_ADDR(Bluetooth Hardware Device
Address) o adresa de recunoastere, ceea ce crea o imposibilitate a anonimatului la nivelul de
protocol, ducând la o incetinire a procesului de introducere a noi servicii în mediul Bluetooth.
3.3.3 Bluetooth 1.1
Multe din erorile descoperite în versiunea 1.0B au fost corectate:
- a fost adaugat suport pentru canalele necriptate;
- a fost introdus RSSI (Receiver Signal Strenght Indicator) – Indicator de nivel al
semnalului recepţionat;
3.3.4 Bluetooth 1.2 (Ratificată ca IEEE Standard 802.15.1-2005)
Aceasta versiune este compatibila cu 1.1 iar imbunatatirile majore includ:
- AFH (Adaptive Frequency Hopping), care imbunatateste rezistenta la interferentele
frecventei radio, evitand utilizarea frecventelor aglomerate în secventa de salt;
- viteza da transmitere mai mare (maxim 721 kbit/s);
- eSCO(extended Syncronius Connections), care imbunatateste calitatea vocii în
conexiunile audio prin permiterea retransmisiei de pachete alterate.
3.3.5 Bluetooth 2.0 (SIG-2004)
Aceasta versiune este compatibila cu versiunile 1.x. Principala imbunatatire este
introducerea EDR-ului (Enhanced Data Rate) de 3.0 Mbps.
Acest lucru are urmatoarele efecte:
- o viteza de transmitere de 3 ori mai mare, în unele cazuri de 10 ori mai mare raza
de acţiune 100m;
- consum de putere mai mic;
- latime de banda mai mare (important la portabile-PDA, laptop, telefon);
- imbunatatirea BER-ul (Bit Error Rate)
- mai bună gestionare a conexiunii între mai mult de două dispozitive.
42

3.3.6 Bluetooth 2.1 (SIG-2007)
Compatibilă cu 1.2, iar imbunatatirile majore includ:
- Perfecţonarea procedurii “inquire” (Extended Inquiry Response).
- Reducerea consumului în “low-power mode”
- Permite schimbarea cheilor de criptare (Encryption Pause Resume) în cazul legăturilor
lungi peste 23.3 h(one Bluetooth day).
- Creşte nivelul de cunoaştere între dispozitivele reţelei (Secure Simple Pairing +Near
Field Communication -NFC), ducând la creşterea securităţii şi vitezei de conectare;
3.3.7 Bluetooth 3.0 (SIG-2009)
Specificaţia 3.0 a fost adoptată de Bluetooth SIG pe 21 aprilie 2009. Principala noutate
introdusă este AMP (Alternate MAC/PHY), adică adăugarea lui 802.11 (asociat de regulă cu WiFi)
ca un mod de transport de mare viteză. Această extindere măreşte considerabil importanţa şi
potenţialul Bluetooth (Wi-Fi era principalul competitor tehnic şi economic).
3.4 Modele şi arhitecturi de utilizare
Unităţile Bluetooth aflate în acelaşi domeniu spaţial de acţiune radio pot realiza ad-hoc
conexiuni punct-la-punct şi/sau punct-la-multipunct. Unităţile pot fi adăugate sau deconectate în
mod dinamic la reţea. Două sau mai multe unităţi pot utiliza în comun un canal al unui piconet.
Se pot forma mai multe picoreţele şi acestea se pot lega ad-hoc împreună formând scatternet,
pentru a realiza configuraţii flexibile de comunicaţii şi schimburi de date (Figura 22)[22].
Figura 22. Arhitecturi Bluetooth
Pentru a regula traficul pe canal, unul dintre participanţi devine master în piconet, în timp
ce restul unităţilor devin slave.
Dacă într-un acelaşi domeniu spaţial se află mai multe pico-reţele, fiecare lucrează
independent şi fiecare are acces la întreaga bandă de frecvenţe. Fiecare pico-reţea este stabilită
pe un canal diferit, cu salt în frecvenţă. Toţi utilizatorii participanţi la aceeaşi pico-reţea sunt
43

sincronizaţi pe acest canal. Spre deosebire de dispozitivele cu infraroşu (IR), unităţile Bluetooth
nu sunt limitate de necesitatea vederii directe între ele.
În conformitate cu Specificaţiile actuale ale Bluetooth, pot comunica cu un master, simultan
active, până la şapte dispozitive slave. Totuşi, numărul unităţilor virtual ataşate unui master,
capabile să între în comunicaţie este aproape nelimitat.
Nucleul sistemului tehnologiei Bluetooth este format dintr-un dispozitiv emisie/receptie RF,
baseband şi o stiva de protocoale. Sistemul ofera servicii care activeza conexiunea dispozitivelor
şi schimbul de diferite de clase de date între aceste dispozitive.
RF-ul foloseste o modulatie de frecventa binara pentru a minimize complexitatea
emitatorului/receptorului . Rata simbolului este de 1 Megasimbol/sec(Msps) care suporta o rata
de bit de 1 Megabit/sec(Mbps) sau cu EDR(Enhanced Data Rate) o rata de bit în aer de 2 la 3
Mb/s.
Pentru a facilita procesul de transmisie, datele sunt împărţite în entităţi mai mici, numite
pachete. În Figura 23 se prezintă structura pachetelor şi asocierea canalelor pentru master şi
respectiv slave.
Figura 23. Structura pachetelor şi asocierea canalelor pentru master/slave
Saltul în frecvenţă nu este o tehnologie nouă, dar comparativ cu alte dispozitive ce
utilizează banda de 2.4GHz, pentru dispozitivele cu Bluetooth, acesta este rapid şi utilizează
pachete mici. Ţinând cont de faptul că dispozitivele radio Bluetooth lucrează conform unui model
FHSS, acest canal de comunicaţie constă dintr-o secvenţă bine definită de frecvenţe la care se
face transmisiunea, alese pseudo-aleator dintr-un set posibil de valori(79 de frecvenţe între
2.402MHz şi 2.480MHz, cu pasul de 1 MHz) şi care se schimbă de 1600 de ori pe secundă, fapt
pentru care spunem că se face un salt al frecvenţei-frequency hop.
Acest lucru este posibil asignându-le un canal de salt în frecvenţă, determinat de secvenţa
“frequency hopping” (ordinea în care fiecare frecvenţă este folosită) şi de perioda frecvenţei. Întro
reţea “piconet”(pico reţea), succesiunea este determinată de ceasul sistemului dispozitivului
master. În esenţă, dispozitivul slave sincronizează ceasul său intern cu cel al dispozitivului master
, care setează aceeaşi succesiune salturilor în frecvenţă.
Bluetooth utilizează mecanismele Inquiry şi Paging şi SDP (Service Discovery Protocol).
44

Pentru stabilirea unei conexiuni prin tehnologia wireless Bluetooth condiţia principală este
ca ambele terminale să dorească realizarea acestei legături. Unele dispozitive pot fi setate să nu
realizeze scanări pentru mesaje Inquiry; în acest caz, celelalte dispozitive nu le pot descoperi şi
vor fi practic invizibile. În mod similar, unele dispozitive pot fi setate să nu realizeze scanări pentru
mesaje Page; în acest caz, aceste dispozitive pot iniţia legături, dar nu vor auzi încercările altor
dispozitive de a se conecta la ele. Aplicaţiile pot alege dacă să facă dispozitivele conectabile sau
descoperibile. O conexiune nu poate fi realizată forţat cu un dispozitiv care nu este setat pentru a
o accepta.
45

4 Robotul LEGO Mindstorms NXT
4.1 Generalităţi
LEGO Mindstorms este o serie de componente LEGO care cuprinde unităţi programabile,
senzori, servomotoare şi alte părţi constructive.
Produsul LEGO Mindstorms NXT a fost lansat în iulie 2006 şi este succesorul primului
model, Robotics Invention System (RCX), care a stârnit interesul unui număr mare de amatori.
Succesul setului NXT este argumentat în special de uşurinţa cu care se poate personaliza şi
extinde platforma. Au fost dezvoltate numeroase concepte, multe dintre care s-au evidenţiat în
diverse concursuri de robotică din întreaga lume.
Având la dispoziţie elemente mecanice cu care se pot construi structuri şi mecanisme,
elemente electronice cum ar fi senzori, servomotoare şi microcontrolere, rezultă că setul NXT
permite construirea şi programarea unui robot mobil reconfigurabil deosebit de versatil.
Elementele mecanice ale sistemului respectă binecunoscutul principiu LEGO al
interconexiunii dintre elemente modularizate. Utilizarea acestor elemente are ca scop realizarea
subansamblului mecanic al sistemului mecatronic: mecanismul care va fi acţionat şi controlat în
scopul îndeplinirii unui task. Aceste elemente cuprind diferite tipuri de articulaţii (cilindrice, sferice
de translaţie), roţi dinţate (cilindrice şi conice), came, transmisii prin curele, reductoare planetare
etc.
Echipamentul NXT cuprinde:
Unitatea centrală de procesare, caramida
Este centrul operaţional al sistemului. Execută
programele utilizatorului şi controlează
comunicarea cu senzorii, servomotoarele, cu PC-ul
sau cu alte unităţi NXT
3 servomotoare Motoare electrice de curent continuu alimentate la
9V sau 12V (pe perioade scurte).
Senzor cu ultrasunete
Determină distanţa de la senzor până la cel mai
apropiat obiect folosind un sistem similar sonarului
Senzor de contact
Este practic un întreruptor, având două stări:
apăsat sau eliberat
Senzor optic
Senzor fotosensibil capabil să distingă 4 culori sau
variaţii în intensitatea luminii ambiente
Senzor acustic
Măsoară intensitatea sonoră în decibeli (microfon)
Cabluri de interconectare
Servomotoarele şi senzorii se conectează la
unitatea centrală de procesare prin cabluri cu câte
6 fire care suportă interfaţa analoga şi digitala
Cablu USB
Robotul se poate conecta la PC prin USB sau prin
Bluetooth
Suita software pentru PC
Conţine driverele necesare şi mediul de
programare proprietar NXT-G
Alimentarea robotului se face prin 6 baterii standard AA de 1,5V sau se poate achiziţiona
un acumulator dedicat de 1400mAH [4].
46

4.2 Sistemul de procesare al robotului NXT
Sistemul de procesare al robotului cuprinde două microcontrolere, cel principal execută
programele utilizatorului, iar cel auxiliar este destinat controlului prin PWM al servomotoarelor şi
menţinerea vitezei în funcţie de sarcină.
Sub aceeaşi carcasă sunt găzduite şi interfeţele de comunicare cu senzorii, microcontrolerul
de comunicare Bluetooth, afişajul cu cristale lichide, butoanele de navigare prin meniu, un difuzor
şi porturile de conectare cu senzorii şi servomotoarele.
Figura 24. Diagrama sistemului de procesare NXT
Specificaţiile sistemului de procesare [1]:
Main processor Atmel® 32-bit ARM® processor, AT91SAM7S256 -
256 KB FLASH
- 64 KB RAM
- 48 MHz
Co-processor
Atmel® 8-bit AVR processor, ATmega48
- 4 KB FLASH
- 512 Byte RAM - 8 MHz
Bluetooth wireless communication
CSR BlueCoreTM 4 v2.0 +EDR System
- Supporting the Serial Port Profile (SPP)
- Internal 47 KByte RAM
- External 8 MBit FLASH - 26 MHz
USB 2.0 communication
Full speed port (12 Mbit/s)
4 input ports 6-wire interface supporting both digital and analog
interface
- 1 high speed port, IEC 61158 Type 4/EN 50170
compliant
47

3 output ports 6-wire interface supporting input from encoders
Display
100 x 64 pixel LCD black & white graphical display
- View area: 26 X 40.6 mm
Loudspeaker
Sound output channel with 8-bit resolutio
- Supporting a sample rate of 2-16 KHz
4 button user-interface Rubber buttons
Power source
6 AA batteries
- Alkaline batteries are recommended
- Rechargeable Lithium-Ion battery 1400
mAH is available
Connector
6-wire industry-standard connector, RJ12 Right
side adjustment
4.3 Senzorii robotului NXT
Robotului NXT i se pot ataşa 4 senzori la porturile de intrare (1, 2, 3, 4). Senzorii standard
cu care este dotat robotul NXT sunt capabili să măsoare distanţa, intensitatea luminii şi
intensitatea sonoră. Împreună cu posibilitatea de a determina rotaţia fiecărui servomotor (cu
ajutorul unui encoder încorporat), aceşti senzori alcătuiesc un sistem senzorial foarte cuprinzător.
Mai mult, dezvoltatori particulari au îmbogăţit seria de senzori cu diverse intrumente de
măsurare cum ar fi: accelerometru, compas, giroscop, termometru, camera video şi altele.
4.3.1 Senzorul cu ultrasunete NXT
Măsurarea distanţei până la un obiect se poate face cu senzorul cu ultrasunete.
Senzorul cu care este echipat robotul LEGO Mindstorms NXT este similar cu Parallax
PING, prezentat în Figura 9, şi permite citirea distanţei până la cel mai apropiat obiect care se
încadrează în raza de detecţie a senzorului.
Pot fi detectate obiecte aflate la distanţe de la 1-2 cm la aproximativ 255 cm cu o precizie
ridicată. Cel mai uşor de detectat sunt obiectele mari care au forma regulată şi suprafaţa dură.
Obiectele din materiale moi, cu forme neregulate sau foarte subiri nu sunt bine detectate rezultând
în valori alternante ale distanţei până la obiect.
Este recomandat să nu se folosească mai mulţi senzori cu ultrasunete în aceeaşi cameră
deoarece ei se pot preturba reciproc.
Undele ultrasonice se propagă sub forma unui con, astfel încât sensibilitatea senzorului
este maximă de-a lungul axei conului (axa acustică) şi descreşte odată cu apropierea de
generatoare. Pentru a fi perceput, un obiect trebuie să se găsească în interiorul acestui con.
48

4.3.2 Protocolul de comunicare I 2 C
Citirea informaţiei furnizate de către senzorii NXT este realizată prin intermediul
protocolului I2C. Acest protocol a fost inventat de Philips şi este folosit pentru comunicarea dintre
periferice “low-speed” şi sisteme centrale (placa de bază, telefon mobil, etc.).
Protocolul constă în transmisia de message sub forma binară dintre un dispozitiv master
şi unul slave. Pentru comunicarea cu senzorul de ultrasunete al robotului LEGO NXT sunt definite
o serie de comenzi care returnează valoarea senzorului sau iniţiază un anumit mod de funcţionare
al senzorului, printre care:
“Single shot command”: În acest mod de funcţionare, senzorul va măsura de fiecare
dată când se va trimite comanda, iar ultimele 8 valori măsurate vor fi stocate în variabilele “Read
measurement byte 0 – 7”.
“Continuous measurement command”: Acesta este modul de funcţionare implicit, în
care senzorul măsoară la un interval de timp prestabilit şi stochează valoarea în variabila “Read
measurement byte 0”
“Event capture command”: Acest mod de funcţionare permite detectarea altor senzori
cu ultrasunete care sunt în raza de sensibilitate. Astfel se poate decide când să se efectueze o
măsuratoare pentru a nu apărea interferenţe între senzori. [2]
4.3.3 Servomotorul NXT
Setul NXT este dotat cu 3 servomotoare alimentate la 9V. Ele se conectează, prin cablurile
furnizate, la cele 3 porturi de ieşire (A, B, C) ale unităţii centrale. Mufele cablurilor sunt special
proiectate să nu poată fi introduse invers şi să aibă alte dimensiuni decât mufele standard ale
liniilor telefonice.
Spre deosebire de servomotoarele modelului precedent, RCX, noile servomotoare sunt
mai puternice şi au încorporate un sistem de transmisie reductor menit să crească cuplul la ieşire.
De asemenea a fost încorporat şi un encoder de rotaţie care oferă informaţii despre poziţia relativă
a axului motorului faţă de momentul de referinţă.
49

NXT cuprinde 4 componente:
Figura 25. Servomotor NXT. Structura interna Servomotorul
• Motor de c.c. alimentat la 9V nominal (suportă 12V pe perioade scurte)
• Dispozitiv de protecţie la supracurent (termistor RXE065)
• Encoder care returnează rotaţia relativă a motorului
• Sistem de transmisie cu raport reductor de 48:1 de la motor la axul servomoturului
Componentele sunt introduse într-o carcasă rigidă care poate fi uşor ataşată unei structuri
mecanice din elemente LEGO.
Motorul a fost analizat de către amatori LEGO NXT de la www.philohome.com şi au fost
determinaţi următorii parametrii de funcţionare [11]:
Tensiune de
alimentare
Sarcina Turaţie Curent
Putere
debitată
Putere
absorbită
Randament
(mecanică) (electrică)
4.5 V 16.7 Ncm 33 rpm 0.6 A 0.58 W 2.7 W 21.4 %
7 V 16.7 Ncm 82 rpm 0.55 A 1.44 W 3.85 W 37.3 %
9 V 16.7 Ncm 117 rpm 0.55 A 2.03 W 4.95 W 41 %
12 V 16.7 Ncm 177 rpm 0.58 A 3.10 W 6.96 W 44.5 %
Parametrii de funcţionare în gol şi în scurt sunt listaţi în tabelul următor:
Tensiune de
alimentare
Sarcina Turaţie Curent
9 V 0 170 rpm 0,06 A
9 V 50 Ncm 0 2 A
50

Pentru a mări cuplul servomotorului, transmisia se face printr-un angrenaj cu raport
reductor de 48:1. Deşi randamentul scade, cuplul mare este un avantaj în construcţia unui robot
mobil NXT.
Encoderul cu care este echipat servomotorul este un encoder rotativ incremental optic
capabil să depisteze direcţia de rotaţie (quadrature encoder). Este un sistem bine cunoscut care
se bazează pe numărarea impulsurilor optice primite de către o diodă fotosensibilă. Impulsurile
sunt create prin trecerea luminii de la un LED prin fantele unui disc care se roteşte.
Discul prezintă 12 fante şi este antrenat de motor cu raportul de transmisie 10:32 de la
motor la encoder. Considerând şi raportul de transmisie de la motor la axul servomoturului (de
48:1) reiese că pentru o revoluţie completă a axului servomotorului, encoderul detectează 360 de
impulsuri. Astfel se poate măsura o rotaţie de 1 0 a axului servomotorului.
Figura 26. Servomotor NXT. Encoder de rotaţie
Deoarece servomotorul poate fi folosit de către persoane neavizate, el este protejat la
supracurenţi cu un termistor, modelul RAYCHEM RXE065, ilustrat în Figura 27. Dispozitivul
suportă un curent maxim de 40A şi o tensiune maximă de 60V. [11]
Figura 27. Servomotor NXT. Dispozitiv de protecţie la supracurent
51

4.4 Metode de comunicare
Legătura fizică dintre PC şi robotul NXT se poate realiza prin cablu USB sau prin conexiune
Bluetooth 2.0. Avantajele comunicării prin cablul USB se restrâng la o viteză de transfer superioară
şi compatibilitate garantată cu PC-ul. Avantajele conexiunii Bluetooth:
• Nu limitează mobilitatea robotului sau raza de acţiune • Robotul NXT se poate conecta
la maxim 10 alte dispozitive Bluetooth, fie că sunt tot roboti NXT sau PC • Comunicaţia
este rezistentă la interferenţe radio datorită tehnicii spread spectrum (salt de frecvenţă) •
Este omnidirecţională şi nu necesită o poziţionare în linie cu celelalte dispozitive pentru
conectare
Ca atare, pentru dezvoltarea programelor care asigură comunicarea dintre robotul NXT şi
PC, am ales conexiunea Bluetooth.
4.5 Programarea robotului LEGO NXT
Suita software cu care este prevăzut setul NXT conţine atât drivere necesare comunicării
PC-ului cu robotul NXT cât şi un program de tipul IDE (Intergrated Development Environment)
numit NXT-G. Pentru a permite programarea robotului cu o deosebită uşurintă, programarea în
NXT-G este vizuală (graphical programming) similar cu programele LabVIEW şi Microsoft
Robotics Studio.
Programarea în NXT-G prezintă următoarele avantaje:
✓ Este uşor de instalat atât pe Windows cât şi pe Mac OS X
✓ Configurarea calculatorului pentru comunicarea prin USB sau Bluetooth este asigurată
de la instalare
✓ Programarea vizuală este foarte intuitivă şi reprezintă un pas de iniţiere în programarea
clasică
Totuşi, programarea în NXT-G are şi dezavantaje, cum ar fi faptul că nu se poate valorifica
complet varietatea de instrucţiuni ale firmware-ului rezident pe robot.
Deşi produsul LEGO Mindstorms NXT a fost lansat relativ recent, amatorii de robotică au
văzut în acest produs o platformă de dezvoltare versatilă. Printre „pionieri” se regăseşte John
Hansen, creatorul limbajului de programare NXC (Not eXactly C) despre a cărui realizare voi
detalia la punctul 4.5.1.
Alte limbaje de programare / compilere au fost create sau adaptate să suporte arhitectura
robotului NXT. Printre cele mai importante se află: Next Byte Codes şi NXC, RobotC, leJOS NXT,
Matlab, Lua, etc.
52

4.5.1 Limbajul de programare NXC (Not eXactly C)
După cum îi sugerează şi numele, limbajul NXC este un derivat al popularului limbaj de
programare C. NXC a fost creat de către John Hansen (principal software engineer, Nashville, TN,
USA) şi foloseşte compiler-ul NBC (Next Byte Codes). Compiler-ul traduce codul NXC în
instrucţiuni NXT bytecodes care sunt executate direct pe robot. [7]
Fiind un limbaj specific programării pentru robotul NXT, NXC este structurat pe măsură.
Codul este împărţit în seturi de instrucţiuni numite task-uri care pot fi rulate în paralel. De asemena
instrucţiunile se pot grupa în proceduri (metode) sau funcţii, la fel ca în limbajul C.
Sintaxa limbajului NXC este familiară datorită trăsăturilor comune cu limbajul C. Partea
specifică limbajului NXC constă în API (Application Programming Interface) care reprezintă o
colecţie de proceduri şi funcţii (o librărie) care sunt disponibile programatorului pentru a realiza
operaţii specifice robotului NXT.
Documentaţia limbajului NXC este cuprinzătoare şi clarifică rapid setul de operaţii care se
pot executa folosind limbajul NXC.
Avantajele limbajului de programare NXC:
✓ Alternativă la programarea vizuală LEGO NXT-G ✓ Similar limbajului C, dar este
specific programării NXT
Limitări importante:
✓ Nu suportă valori numerice cu zecimale
✓ Nu suportă recursivitate
În ciuda limitărilor, limbajul NXC este competent şi acoperă majoritatea funcţionalităţilor
propuse în lucrarea de faţă. Ca atare, voi folosi acest limbaj pentru programarea robotului NXT.
5 Citirea datelor achiziţionate de la senzorii NXT prin
interogare de la PC
Prima metoda de transmisie a datelor achiziţionate de la senzorii robotului NXT la PC pe
care am implementat-o se bazează pe principiul interogării. De obicei comunicarea prin Bluetooth
dintre două dispozitive presupune stabilirea unui terminal master care iniţiază şi controlează
conexiunea şi unui terminal slave care este subordonat master-ului. În această metodă folosesc
PC-ul ca master şi robotul NXT ca slave.
Practic, am realizat un program pe PC care emite comenzi către robotul NXT, prin
intermediul conexiunii Bluetooth, şi aşteaptă un răspuns la comanda emisă. Interpretarea şi
executarea comenzii se face automat de către firmware-ul rezident în robotul NXT, fără o
53

programare suplimentară. În funcţie de tipul comenzii, răspunsul poate să confirme execuţia
comenzii şi chiar să returneze date achiziţionate de la senzori. Avantajele acestei metode sunt:
✓ Nu necesită programare suplimentară pe robotul NXT
✓ Pot fi folosite diverse limbaje de programare pe PC
✓ Resursele PC-ului sunt nelimitate în comparaţie cu cele ale robotului NXT Dezavantaje:
‣ Prin această metodă nu pot fi valorificate toate funcţionalităţile puse la dispoziţie de
firmware-ul NXT
‣ Apar mici întârzieri între comandă, achiziţie date şi răspuns
5.1 Obiectivele programului de pe PC
Programul care rulează pe PC trebuie să:
✓ Iniţieze şi controleze conexiunea Bluetooth dintre PC şi robotul NXT;
✓ Obţină date achiziţionate de la senzorii NXT în timp real;
✓ Interpreteze datele obţinute pentru a putea fi prelucrate programatic;
✓ Afişeze datele prelucrate într-o formă grafică intuitivă;
✓ Permită exportul lor într-un format compatibil Microsoft Excel
Prelucrarea datelor achiziţionate sau afişarea lor depinde de scopul aplicaţiei şi pot lua
diverse forme. De aceea, eu mi-am propus să asigur o funcţionalitate importantă şi anume, aceea
de a exporta datele achiziţionate într-un format comun, care poate fi apoi uşor procesat. Datele
achiziţionate pot fi salvate în format tabelar (pe rânduri şi coloane) Tab delimited text (.txt) care
este compatibil cu orice versiune de Microsoft Excel.
5.2 Resurse hardware şi software necesare
Pentru realizarea aplicaţiilor prezentate în această lucrare, resursele hardware şi software
necesare sistemului PC-NXT sunt următoarele:
- PC (desktop, laptop, notebook, netbook) care rulează Windows XP şi Microsoft .NET
Framework 2;
- Adaptor pentru conectare Bluetooth 2.0 (intern sau extern);
- Drivere (software) necesare adaptorului Bluetooth;
- Realizarea procesului de împerechere (pairing) Bluetooth dintre PC şi NXT;
- Robotul LEGO NXT cu senzorul cu ultrasunete şi un servomotor ataşate
Un pas important în configurarea PC-ului pentru conexiunea Bluetooth cu robotul NXT este
împerecherea Bluetooth. Procesul presupune recunoaşterea (discovery) reciprocă a celor două
dispozitive PC şi NXT şi cuplarea lor software după introducerea pe fiecare dintre dispozitive a
aceluiaşi cod PIN (Personal Identification Number). În urma confirmării codului PIN fiecare dintre
54

dispozitive stochează adresa MAC (Media Access Control) a corespondentului pentru
recunoaştere ulterioară.
Acest proces se realizează o singură dată pentru aceleaşi două dispozitive, cât timp
înregistrările adreselor MAC sunt păstrate de către fiecare parte. Împerecherea este o măsură de
securitate care poate restricţiona accesul la anumite dispozitive (prin codul PIN).
Pe PC, împerecherea Bluetooth se face folosind soft-ul care este instalat o dată cu diverele
adaptorului Bluetooth.
Comunicarea Bluetooth suportă anumite protocoale numite services specializate pentru
transferul anumitor formate de date. Există un protocol pentru transfer de semnal audio, transfer
de fişiere, transfer de agendă telefonică, etc.
Pentru comunicarea PC-ului cu robotul NXT trebuie configurat protocolul de comunicare
prin port serial. Aceasta se poate face din software de pe PC şi realizează o alocare a conexiunii
Bluetooth cu un anumit dispozitiv la un anumit port serial al PC-ului (exemplu: COM1, COM2,
etc.).
În Figura 28 sunt ilustraţi paşii tipici de configurare a conexiunii Bluetooth dintre PC şi un
robot NXT:
55

Figura 28. Configurarea conexiunii Bluetooth dintre PC şi NXT
Configurarea conexiunii Bluetooth duce la stabilirea unui port serial al calculatorului
dedicat comunicării dintre PC şi robotul NXT (exemplu: COM6). Numele portului rezervat pentru
conexiunea Bluetooth cu robotul NXT poate să difere de la PC la PC. Cu această informaţie se
poate implementa programatic o metodă de iniţiere şi control a conexiunii Bluetooth dintre PC şi
robotul NXT.
În continuare voi prezenta o metodă de iniţiere şi control a conexiunii Bluetooth dintre PC
şi robotul NXT folosind un algoritm scris în limbajul de programare C#.
5.3 Limbajul de programare C# (C Sharp)
Limbajul de programare C# (se citeşte C Sharp) este un limbaj creat de Microsoft pentru
dezvoltarea aplicaţiilor bazate pe .Net Framework. Similar au fost dezvoltate şi limbajele VB.NET,
J#, F#.
Motivele pentru care am ales acest limbaj de programare pentru realizarea aplicaţiilor pe
PC din aceasta lucrare sunt următoarele:
56

• C# este un limbaj destinat RAD (Rapid Application Development)
• Librăriile din Microsoft .Net Framework sunt robuste şi permit implementarea
comunicării prin port serial
• Din punctul de vedere al sintaxei, C# este similar cu popularul C şi C++ cu care mam
familiarizat pe parcursul facultăţii
C# este un limbaj pur Object Oriented şi are la bază conceptul de clasă (class). O clasă
reprezintă un obiect virtual care are proprietăţi, metode, constante, „constructori”, evenimente, etc.
În programare, obiectele virtuale sunt utile deoarece pot reprezenta corespondente ale unor
obiecte din realitate. Aceste obiecte virtuale pot fi folosite pentru a simula sau a controla obiectele
din realitate.
Pentru a descrie acest concept (clasă sau obiect virtual) am ales să consider un exemplu
din realitate care poate fi reprezentat în programare: automobilul. Obiectul sau clasa se va numi
Automobil şi poate fi definit astfel:
Clasa
Automobil
Proprietăţi
Metode
Constante
Sunt parametrii care caracterizează starea sau
tipul clasei: kilometrajul curent, viteza cu care
rulează, turaţia
Se referă la secvenţe de acţiuni pe care le poate
executa clasa: mers înainte, sau mers în
marşarier, sau aprinderea farurilor
Valori folosite frecvent care nu pot fi schimbate:
numărul de roţi, sau volan pe partea stângă sau
dreaptă, sau marca automobilului
„Constructori”
Evenimente
Sunt metode care definesc parametrii iniţiali şi
crează o reprezentare (instance) a clasei. Similar
producătorul construieşte automobilul în funcţie
de speficicaţiile posesorului.
Sunt acţiuni invocate de către clasa care reflectă
o anumită schimbare ţn starea sa şi necesită
intervenţia utilizatorului (posesorului): avertizare
de combustibil redus, sau avertizare faruri aprinse
Este evidentă asemănarea unui automobil cu un robot mobil. Observaţia rămâne valabilă
şi pentru conceptele corespondente din programare.
În C# clasa Automobil ar putea fi definită astfel:
57

public class Automobil
{
// constante
public const int NumarDeRoti = 4;
public const string Marca = "Suzuki";
public const bool VolanPeStanga = true;
// constructor
public Automobil() {
VitezaCurenta = 0;
Kilometraj = 0;
}
// constructor
public Automobil(int km) {
Kilometraj = km;
}
// proprietate
public int VitezaCurenta { // in km / ora
get {return _VitezaCurenta;}
set {_VitezaCurenta = value;}
}
private int _VitezaCurenta;
// proprietate public int
Kilometraj {
get {return
_Kilometraj;}
set
{_Kilometraj = value;}
}
private int _Kilometraj;
// proprietate public int
TuratieCurenta {
get {return
_TuratieCurenta;}
set {_TuratieCurenta = value;}
}
private int _TuratieCurenta;
// metoda
public void PornesteMotorul() {
TuratieCurenta = 900; //rpm
}
// metoda
public void OpresteMotorul() {
TuratieCurenta = 0; //rpm
}
}
// metoda
public int RuleazaInainte(int Durata) {// Durata in ore
Kilometraj = Kilometraj + (VitezaCurenta * Durata);
return Kilometraj;
}
Similar cu exemplul de mai sus am creat o clasă numită OperatorNXT care controlează
robotul NXT. Mai concret, clasa OperatorNXT controlează conexiunea Bluetooth cu robotul NXT
şi citirea datelor achiziţionate de la senzori. Codul care defineşte clasa OperatorNXT
prezentat în Anexa 9.1.
58
este

5.4 Proiectarea şi implementarea aplicaţiei de pe PC
5.4.1 Iniţierea conexiunii Bluetooth dintre PC şi NXT în C#
Urmând paşii de configurare al PC-ului descrişi la sub-capitolul 5.2 rezultă stabilirea unui
port serial (COM1, COM2, etc) prin care se realizează conexiunea Bluetooth cu robotul NXT.
În limbajul de programare C#, clasa SerialPort din librăria System.IO.Ports,
inclusă în Microsoft .Net Framework, supervizează operaţiile de citire sau scriere de date la un
port serial al calculatorului. Am folosit această clasă pentru a iniţia şi controla conexiunea cu
dispozitivul Bluetooth asignat acelui port serial, adică robotul NXT.
La iniţializare, clasa SerialPort primeşte ca parametru numele portului serial. Acest
parametru este un şir de caractere (string) care reprezintă numele portului serial stabilit pentru
comunicarea Bluetooth cu robotul NXT. În aplicaţiile prezentate în acestă lucrare, numele portului
serial folosit este COM6. În consecinţă clasa SerialPort este iniţializată cu parametrul
”COM6”.
private SerialPort PortSerial = new SerialPort("COM6");
În exemplul de mai sus am creat o reprezentare (instance) a clasei SerialPort.
Aceasta reprezentare este o variabilă definită pe baza clasei SerialPort şi dispune de toate
atributele clasei SerialPort.
Pentru a putea comnica prin portul serial al PC-ului trebuie ca acesta să fie deschis.
Deschiderea conexiunii se face apelând metoda Open.
Clasa SerialPort dispune de metodele Write şi Read pe care le folosesc pentru
transmisia de date dintre PC şi NXT. Metoda Write realizează transmisia informaţiei de la PC la
NXT şi primeşte ca parametru un vector de tip byte care conţine seria de octeţi ce va fi trimisă
prin portul serial. Metoda Read este folosită pentru citirea unui vector de tip byte care reprezintă
seria de octeţi primită de la robotul NXT.
59

5.4.2 Comunicarea PC – NXT prin interogare
În calitate de master, PC-ul va iniţia şi controla conexiunea Bluetooth şi va emite comenzi către
robotul NXT. Recepţionarea, interpretarea şi executarea comenzilor pe robotul NXT se face
automat de către firmware-ul rezident, fără o programare suplimentară [2].
În funcţie de tipul comenzii, răspunsul poate să confirme execuţia comenzii sau chiar să
returneze date achiziţionate de la senzori. Acest protocol este numit control prin „comenzi directe”.
Protocolul de control prin „comenzi directe” poate furniza date achiziţionate de la orice senzor
NXT.
Un ciclu de interogare şi răspuns cuprinde următoarele etape generale:
1. Formularea comenzii
2. Trimiterea comenzii la portul serial al PC
3. Transmisia prin Bluetooth de la PC la NXT
4. Interpretarea comenzii pe NXT
5. Executarea comenzii / Achiziţia de date de la senzor
6. Formularea răspunsului
7. Trimiterea răspunsului
8. Transmisia prin Bluetooth de la NXT la PC
9. Recepţionarea răspunsului la portul serial al PC
10. Interpretarea răspunsului
Prin interogări succesive, la un anumit interval de timp, se poate acumula pe PC o serie
de „măsuratori” de la senzorii NXT care reflectă evoluţia în timp a mărimilor respective.
Un aspect important pentru valorificarea datelor achiziţionate este fixarea lor în timp.
Deoarece timpul este măsurat pe PC şi datele sunt achiziţionate de la senzori pe unitatea NXT,
apar întârzieri şi o desincronizare a datelor faţă de momentul achiziţiei. Fiecare etapă din procesul
descris mai sus reprezintă o întârziere. Din fericire suma acestor întârzieri este relativ mică, de
ordinul zecilor de milisecunde. Mai mult, aceste întârzieri sunt în general constante şi se poate
compensa efectul lor din programare.
Deşi subiectul este discutabil, în final voi demonstra experimental că aceste întârzieri sunt
neglijabile în raport cu aplicaţiile prezentate în această lucrare.
În consecinţă, metoda prin interogare de la PC asigură acurateţea şi consistenţa datelor
achiziţionate şi este o metodă fiabilă şi performantă.
5.4.3 Implementarea protocolului de control prin „comenzi directe”
Acest set de instrucţiuni face posibilă comanda robotului NXT de la dispozitive externe.
60

Astfel robotul NXT poate fi controlat de la PC, de la alţi roboţi NXT sau orice dispozitiv capabil de
comunicare Bluetooth sau USB prin port serial.
Protocolul acoperă funcţionalităţile de bază ale robotului NXT, dar permite şi extinderea sa
prin trimiterea unor comenzi personalizate care ar putea fi interpretare de un program suplimentar
care rulează pe robot.
Utilizând “comenzi directe” se poate:
• Comanda un servomotor NXT (turaţie, sens, oprire, frână)
• Citi date de la senzori sau de la encoderul unui servomotor
• Trimite / primi de mesaje tip SMS (Short Message Service) care pot fi preluate /
generate de către un program ce rulează pe NXT
• Executa un anumit program rezident pe robot
• Alte operaţii specifice
Protocolul se bazează pe protocolul standard de comunicare LEGO Mindstorms NXT, şi
anume prin transmisia de „telegrame” cu arhitectura prezentată în Figura 29 [3].
Figura 29. Arhitectura generala a protocolului de comunicare NXT
Primul octet (byte 0) va conţine tipul de comandă. Dacă seria de octeţi este un răspuns,
atunci primul octet va reprezenta tot un tip de comandă (reply) şi va avea valoarea 0x02 în
hexadecimal. Lista completă de tipuri de comandă este prezentată în Tabelul 3.
Tabelul 3. Lista tipurilor de comandă NXT
0x00 Comanda directă, necesită răspuns
0x01 Comanda de sistem, necesită răspuns
0x02 Răspuns
0x80 Comanda directă fără răspuns
0x81 Comanda de sistem fără răspuns
Comenzile de sistem nu fac parte din protocolul de „comenzi directe” şi nu sunt folosite
pentru comanda uzuală a robotului NXT.
61

Al doilea octet (byte 1) va determina care comandă va fi executată, adică va conţine codul
comenzii, iar restul de octeţi vor descrie parametrii specifici respectivei comenzi.
Lungimea maximă a unei „telegrame” care reprezintă o comandă directă este de 64 de
octeţi, începând de la primul octet (byte 0).
Pentru „telegrame” transmise prin Bluetooth ® se adaugă doi octeţi la începutul structurii
conform Figura 30. Acesti doi octeţi descriu lungimea telegramei.
Figura 30. Structura unei comenzi trimise prin Bluetooth
Unde LSB (Least Semnificant Byte) şi MSB (Most Semnificant Byte) descriu lungimea
totală a comenzii.
În C#, formularea comenzilor presupune completarea unui vector de valori byte cu
parametrii specifici comenzii:
byte[] comanda = new byte[3];
comanda[0] = 0x00; // comanda directa, necesita raspuns
comanda[1] = (comanda[2] = (bytebyte))port_motor; CodMesajDirect// portul la care este
atasat servomotorul.CitesteStareMotor; // 0x06 codul comenzii
Comanda este apoi procesată, se construieşte telegrama şi se „scrie” (Write) la portul serial al
PC-ului:
int lungime_comanda = comanda.Length;
byte[] telegrama = new byte[lungime_comanda + 2]; // creeaza telegrama
telegrama[0] = (byte)(lungime_comanda & 0xFF); // calculeaza LSB telegrama[1] =
(byte)((lungime_comanda & 0xFF00) >> 8); // calculeaza MSB
comanda.CopyTo(telegrama, 2); // completeaza telegrama cu continutul comenzii
PortSerial.Write(telegrama, 0, telegrama.Length);
// trimite telegrama
În funcţie de tipul comenzii se aşteaptă apoi un răspuns şi se citeşte de la portul serial al
PC-ului:
62

if (comanda[0] < 0x80) // in cazul in care comanda directa necesita raspuns
{
int lsb = PortSerial.ReadByte(); // citeste primul byte
int msb = PortSerial.ReadByte(); // citeste al doilea byte
int lungime_raspuns = lsb + msb * 256; // calculeaza lungimea raspunsului
byte[] raspuns = new byte[lungime_raspuns];
}
PortSerial.Read(raspuns, 0, lungime_raspuns); // citeste raspunsul
5.4.4 Algoritmul metodei de interogare de la PC
Folosind metodele prezentate la punctele 5.4.1, 5.4.2 şi 5.4.3 am construit programul
propus, implementând un algoritm care presupune citirea datelor de la senzorii NXT prin interogări
succesive.
Pe scurt, algoritmul metodei de citire a datelor achiziţionate prin interogare de la PC
cuprinde următorii paşi:
1. Deschiderea portului serial (iniţierea conexiunii cu NXT)
2. Cât timp se doreşte interogarea:
2.1. Formularea unui vector de valori byte care reprezintă o comandă directă
2.2. Scrierea seriei de byte la portul serial al calculatorului
2.3. Aşteptarea unui răspuns din partea robotului NXT sub forma de serie byte
2.4. Interpretarea răspunsului şi a datelor ataşate
2.5. Stocarea datelor primite
3. Închiderea portului serial (anularea conexiunii cu NXT)
4. Afişarea sau exportul rezultatelor
În Figura 31 este prezentată o diagramă simplificată a algoritmului metodei de citire a
datelor achiziţionate prin interogare de la PC.
63

Figura 31. Diagrama simplificata a algoritmului de citire a datelor achiziţionate prin interogare de la PC
Codul sursă complet este prezentat în Anexa 9.1, Anexa 9.2, Anexa 9.3.
5.5 Aplicaţie la metoda de citire a datelor achiziţionate de la senzorii NXT
prin interogare de la PC
5.5.1 Determinarea poziţiei obiectelor cu senzorul de ultrasunete
Deoarece senzorul cu ultrasunete are un unghi de acoperire mare (aprox. 120o) nu se
poate determina poziţia obiectelor din raza sa de măsurare sau numărul lor.
Pentru determinarea poziţiei obiectelor se poate construi un sistem din componenete
LEGO NXT care cuprinde un servomotor, unitatea centrală şi senzorul cu ultrasunete. Sistemul
funcţionează ca radarul de pe vasele maritime şi scanează împrejurimile pentru construirea unui
contur virtual al obiectelor din jur.
64

Figura 32. Aplicaţie la metoda de citire a datelor de la senzori prin interogare de la PC
Senzorul este ataşat rotorului servomotorului şi se roteşte stânga-dreapta pentru a acoperi
cât mai mult din spaţiul înconjurător. Pe măsură ce senzorul se roteşte, datele colectate de la
senzor sunt asociate cu poziţiile rotorului faţă de unghiul iniţial. Pentru un control mai precis al
rotaţiei se foloseşte un raport de transmisie între servomotor şi suportul senzorului.
În principiu, astfel se poate determina atât poziţia unui obiect cât şi dimensiunile acestuia
(lăţimea sau înălţimea).
Controlul servomotorului şi citirea senzorului cu ultrasunete se face de pe PC prin
Bluetooth folosind metoda şi algoritmul de citire a datelor achiziţionate de la senzorii NXT prin
interogare de la PC descrise mai sus.
Aplicaţia prezintă o interfaţă grafică facilă prin intermediul căreia se poate iniţia conectarea
sau deconectarea prin Bluetooth a PC-ului la NXT.
Aplicaţia realizează următoarele operaţii:
✓ realizează conectarea prin Bluetooth a celor două sisteme: PC şi robot NXT;
✓ setează modul de funcţionare al senzorului cu ultrasunete (“Continous read mode”);
✓ efectuează la un anumit interval de timp citiri ale valorii furnizate de senzorul cu
ultrasunete;
✓ înregistrează fiecare valoare a distanţei citite şi o asociază cu valoarea rotaţiei
motorului (unghiul) din momentul respectiv;
✓ afişează în interfaţă grafică valoarea curentă a distanţei măsurate, a rotaţiei motorului
şi a rotaţiei relative faţă de momentul pornirii procesului;
✓ în funcţie de poziţia rotorului, se decide schimbarea sensului de rotaţie sau continuarea
mişcării în sensul curent;
✓ controlează viteza şi rotaţia motorului după fiecare măsurare a distanţei;
65

Deoarece măsurarea distanţei şi transmisia informaţiei prin Bluetooth cauzează o
întârziere considerabilă din momentul trimiterii comenzii până în momentul returnării rezultatului,
nu se poate măsura în timp ce senzorul cu ultrasunete se roteşte cu viteză constantă.
În consecinţă, măsurarea distanţei se face la intervale de timp precise, sincronizate cu
staţionarea motorului după parcurgerea unei anumite rotaţii. Astfel procesul de colectare a datelor
este sacadat şi lent, dar conferă o precizie superioară.
5.5.2 Interfaţa grafică şi analiza datelor obţinute
Analiza datelor obţinute se poate face în chiar timpul colectării lor datorită interfeţei grafice
care prezintă în mod vizual o hartă virtuală a conturului spaţiului înconjurător Figura 33.
Figura 33. Interfaţa grafică a aplicaţiei
Intuitiv, zonele cu negru reprezintă “umbre” ale obiectelor situate în zona scanată (la
distante mici), iar roşu reprezintă spaţiul gol (distante mari).
În urma diferitelor încercari şi optimizări am ajuns la concluzia ca rezultatele obţinute ofera
o vaga imagine a spatiului scanat. Desi pozitia obiectelor poate fi determinata, o incercare de a
evalua dimensiunile obiectului nu ar oferi rezultate precise.
Consider ca deficienţele sunt în mare parte datorate metodei de control şi comanda prin
Bluetooth care adauga o intarziere semnificativa intre diferite masuratori şi faptului ca prin aceasta
metoda nu se pot accesa anumite functionalitati software ale robotului NXT care ar permite o mai
buna manevrare a servomotorului.
66

6 Citirea datelor achiziţionate de la senzorii NXT sub
comanda programului NXC
Ca alternativă la prima metodă, prezentată la Capitolul 0, am elaborat o a doua metodă
prin care se poate face transmisia datelor achiziţionate de la senzorii NXT la PC.
Această a doua metodă presupune realizarea a două programe:
‣ Programul emiţător care rulează pe robotul NXT (în limbajul de programare NXC) –
acest program stochează date achiziţionate de la senzori, le serializează şi le trimite
prin conexiune Bluetooth către PC;
‣ Programul receptor care rulează pe PC (în limbajul de programare C#) – acest
program monitorizează portul serial al PC-ului, citeşte datele primite de la NXT şi
interpretează datele achiziţionate de la senzori.
Cele două programe conlucrează pentru a realiza transmisia datelor achiziţionate de la
NXT la PC, dar este evident faptul că programul de pe NXT are comanda operaţiunilor.
Deşi rolurile par inversate, din punctul de vedere al conexiunii Bluetooth, cel care iniţiază
conexiunea Bluetooth este tot programul de pe PC-ul, iar acest lucru se face în acelaşi mod descris
la punctul 5.4.1.
Avantajele acestei metode sunt:
✓ Posibilitatea valorificării tuturor funcţiilor robotului prin programarea robotului în
limbajul NXC;
✓ Acces la funcţii care permit control mai precis al robotului;
✓ Întârzieri minime între momentele de achiziţie ale datelor;
✓ Comunicarea se desfăşoară într-un singur sens (de la NXT la PC), ca atare transmisia
datelor durează mai puţin şi este mai sigură;
✓ Posibilitatea transmiterii de date cu scop de depanare (debugging) a aplicatiilor NXC;
Dezavantaje:
‣ Resurse hardware şi software limitate pentru programul în NXC
‣ Necesită programare şi pe partea NXT şi pe partea PC
În continuare voi prezenta pe larg fiecare dintre cele două programe şi o aplicaţie la
această metodă.
67

6.1 Proiectarea şi implementarea programului de pe NXT (emiţătorul)
6.1.1 Obiectivele programului de pe NXT
Programul care rulează pe robotul NXT are rolul de a achiziţiona date de la senzorii NXT
şi de a le transmite prin Bluetooth către PC.
Pe scurt programul în NXC trebuie să:
- Achiziţioneze date de la anumiţi senzori ai robotului NXT;
- Stocheze datele într-un format care permite asocierea valorii achiziţionate de la senzor
cu momentul achiziţiei;
- Serializeze datele achiziţionate pentru transmisia prin Bluetooth;
- Segmenteze calupul de date în pachete pentru a fi transmise prin Bluetooth;
- Expedieze pachetele de date achiziţionate către PC;
Programul va colecta date achiziţionate şi le va trimite la PC în salve (pachete).
6.1.2 Achiziţia datelor de la senzorii NXT
În limbajul de programare NXC sunt disponibile câteva funcţii (metode) destinate citirii datelor de
la senzorii NXT. Pentru aplicaţiile prezentate în această lucrare voi folosi două funcţii pentru a citi
datele de la doi senzori NXT: MotorTachoCount şi SensorUS [7].
Funcţia MotorTachoCount returnează rotaţia axului servomotorului faţă de poziţia
iniţială. Valoarea returnată este în grade şi este un număr întreg stocat pe 16 biţi care poate fi şi
negativ, adică de tipul short. Această informaţie poate fi folosită pentru calcularea distanţei
parcurse de robotul NXT. Encoderul care furnizează această informaţie este descris la punctul
4.3.3. Funcţia SensorUS returnează ultima măsurătoare efectuată de senzorul cu ultrasunete
NXT. Valoarea returnată reprezintă distanţa de la senzor până la cel mai apropiat obiect şi este în
centimetri. Distanţa maximă care poate fi măsurată de către senzorul cu ultrasunete este de 255
cm, adică un număr stocat pe 8 biţi, un octet (byte). Senzorul cu ultrasunete NXT este prezentat
la punctul 2.3.2 şi 4.3.1.
Datele achiziţionate sunt semnificative numai dacă se păstrează şi momentul la care au
fost achiziţionate. Practic trebuie asociată o valoare măsurată cu momentul în care a fost
măsurată. Pentru a realiza acest lucru în programare se poate folosi un vector cu 2 dimensiuni (o
matrice) sau se poate folosi un tip de date numit structura (struct). Am ales varianta a doua
68

deoarece tipul de date struct este similar cu conceptul de obiect virtual întâlnit în programarea
Object Oriented din C# (punctul 5.3). Un alt avantaj al tipului de date struct este că permite mai
uşor serializarea sa.
Tipul de date struct folosit în programul dezvoltat pentru această lucrare este numit
masuratoare şi se defineşte astfel:
struct masuratoare
{
unsigned short timp;
};
short valoare;
Pentru exemplificare, achiziţia de date de la encoderul unui servomotor şi crearea unei
variabile de tipul masuratoare se poate face în felul următor:
masuratoare m; // declararea variabilei de tip masuratoare
m.valoare = MotorTachoCount(OUT_C); // achizitie date encoder
m.timp = CurrentTick(); // nr de milisecunde
Instrucţiunile de mai sus sunt incluse într-o metodă numită SalveazaMasuratoare care
primeşte ca parametru valoarea unui senzor, iar fixarea în timp se face independent de tipul de
senzor care a furnizat valoarea sau de valoare în sine. Mai mult, metoda construieşte un vector
de tip masuratoare în care sunt stocate achiziţiile de date efectuate. Practic, fiecare
masuratoare efectuată este păstrată într-un vector numit SerieMasuratori. Acest vector
va fi serializat şi transmis prin Bluetooth la PC.
Codul complet al programului scris în NXC este prezentat în Anexa 9.4.
6.1.3 Serializarea datelor achiziţionate
Pentru a putea transmite date prin conexiunea Bluetooth şi apoi la PC, datele achiziţionate
de la senzorii NXT de către programul NXC trebuie serializate. Serializarea este folosită
pretutindeni în transmisia informaţiei şi poate fi o tehnică de compresie sau criptare a informaţiilor
transmise.
În programul NXC serializarea datelor achiziţionate de la senzorii NXT se face prin
intermediul unei funcţii native limbajului NXC numite FlattenVar. Funcţia FlattenVar
transformă orice variabilă în reprezentarea sa sub forma de şir de caractere ASCII, adică de tip
69

string. Tipul de date string ascunde în spate un vector de tip byte în care fiecare element
conţine codul ASCII al caracterului reprezentat. [7]
Folosind funcţia FlattenVar se poate transforma un vector de tip masuratoare întro
variabilă de tip string care poate fi trimisă apoi prin Bluetooth la PC.
6.1.4 Transmisia datelor prin Bluetooth de la NXT la PC
În programul NXC dezvoltat pentru această lucrare, trimiterea datelor serializate în
prealabil prin conexiune Bluetooth se face apelând metoda BluetoothWrite care este nativă
limbajului NXC.
Metoda BluetoothWrite primeşte ca parametru o variabilă de tip string care
reprezintă un şir de caractere ASCII, sau mai exact un vector de tip byte. Această metodă
realizează transmisia de date de la NXT la PC prin intermediul conexiunii Bluetooth. Parametrul
ataşat metodei, sub formă de string, reprezintă un „mesaj” care va fi transmis la PC-ului.
6.1.5 Algoritmul programului NXC
Pe scurt, algoritmul programului NXC este definit de următoarele etape:
1. Iniţierea măsurătorii (salvarea momentului iniţial)
2. Cât timp se măsoară:
2.1. Achiziţia valorii unui senzor
2.2. Stocarea valorii într-un tip de date structura numită măsuratoare care permite
asocierea valorii cu momentul măsurării (4 octeţi)
2.3. Adăugarea măsurătorii curente la un vector tip coada de măsurători
3. Încheierea procesului de măsurare
4. Serializarea vectorului de măsurători într-un string numit buffer
5. Segmentarea buffer-ului în pachete de câte 200 octeţi, adică 50 de măsurători
6. Trimiterea pachet cu pachet a datelor serializate către PC
În Figura 34 este prezentată o diagramă simplificată a algoritmului de achiziţionare a
datelor de la senzorii NXT şi transmisia lor la PC de către programul scris în NXC.
70

Figura 34. Diagrama simplificată a algotitmului programului NXC (emiţător)
Codul sursă complet este prezentat în Anexa 9.4.
6.2 Proiectarea şi implementarea programului de pe PC (receptorul)
Programul care rulează pe PC are rolul de a recepţiona datele transmise de către
programul NXC. Această funcţionalitate este similară cu cea îndeplinită de către programul PC de
la Capitolul 5, adică citirea datelor prin interogare de la PC. Ca atare am folosit aceleaşi principii
şi metode perfecţionate pentru comanda robotului prin interogare. De acestă dată accentul a fost
pus pe citirea datelor de la portul serial al calculatorului, interpretarea şi stocarea lor.
Clasa pe care am creat-o pentru acest scop se numeşte ReceptorNXT, iar codul complet
se găseste în Anexa 9.5.
6.2.1 Algoritmul programului de pe PC
Pe scurt, algoritmul programului care rulează pe PC (receptorul) este definit de
următoarele etape:
1. Deschiderea portului serial (conexiune cu NXT)
2. Cât timp se doreşte monitorizarea:
2.1. Citirea seriei de bytes de la SerialPort
2.2. Stabilirea capetelor pachetelor
2.3. Interpretarea fiecărui pachet primit
71

2.4. Conversia de la bytes la tipuri de date utilizabile în C# short, ushort
2.5. Construirea unui vector de tip de date Masuratoare
2.6. Stocarea vectorului de măsurători
3. Afişare sau export măsurători
În Figura 35 este prezentată o diagramă simplificată a algoritmului de citire a datelor de la
senzorii NXT transmise la PC de către programul scris în NXC.
Figura 35. Diagramă simplificată a algoritmului de citirea a datelor de la senzorii NXT transmise la PC de către
programul scris în NXC
Codul sursă complet este prezentat în Anexa 9.5.
6.2.2 Interfaţa grafică a programului de pe PC
Interfaţa grafică a programului de pe PC este ilustrată în figurile de mai jos:
72

Figura 36. Interfaţa grafică a programului. Iniţierea
conexiunii Bluetooth
Figura 37. Interfaţa grafică a programului. Datele
achiziţionate
Primul pas care trebuie efectuat pentru citirea datelor de la robotul NXT este iniţierea conexiunii
Bluetooth. În Figura 36 este evidenţiată zona dedicată iniţierii conexiunii Bluetooth. Aceasta se
face alegând portul serial rezervat pentru comunicarea Bluetooth cu robotul NXT. Pentru rapiditate
este disponibilă o listă cu porturile seriale uzuale (COM1, COM2, COM6, COM13), dar este
posibilă şi introducerea manuală a numelui portului.
Apăsarea butonului Conectează! realizează deschiderea portului serial. Dacă operaţiunea a avut
succes, butonul este iluminat, iar pe afişajul robotului NXT se poate observa că dispozitivelele
sunt cuplate Bluetooth.
În continuare se poate porni monitorizarea portului serial prin apăsarea butonului Start din stânga.
Astfel se porneşte o execuţie repetitivă care verifică portul serial în aşteptarea unui transfer de
date.
Dacă portul serial al PC-ului recepţionează date transmise prin Bluetooth de la robotul NXT,
atunci acestea sunt rapid interpretate şi listate în interfaţa programului (Figura 37).
Odată primite şi interpretate, datele pot fi salvate într-un fişier în format Tab delimited text pentru
postprocesare.
73

6.3 Aplicaţie la metoda de citire a datelor achiziţionate de la senzorii NXT
sub comanda programului NXC
6.3.1 Evoluţia în timp a mărimilor măsurate de către senzorii NXT
Pentru testarea celor două programe prezentate la punctele 6.1 şi 6.2, am realizat robotul
din Figura 38 care face uz de un servomotor NXT şi senzorul cu ultrasunete NXT.
Scopul aplicaţiei este să furnizeze date achiziţionate de la senzorii NXT sub comanda
programului NXC pentru a obţine graficul evoluţiei mărimilor măsurate în timp.
Se va analiza evoluţia în timp a distanţei parcurse de către robot şi a distanţei până la cel
mai apropiat obiect măsurate de către senzorul cu ultrasunete.
Comanda robotului este de partea programului NXC care va executa următoarele
instrucţiuni pentru a pune în mişcare robotul:
task motion()
{
}
// roteste ax servomotor 500 de grade cu viteza 20
RotateMotor(OUT_C, 20, 500);
// asteapta 3000 de ms (3 secunde)
Wait(3000);
// roteste ax servomotor 500 de grade cu viteza -60
// (sens invers)
RotateMotor(OUT_C, -60, 500);
Instrucţiunea RotateMotor(OUT_C, 20, 500) va produce o rotire cu 500 de grade
în sensul acelor de ceasornic a axului servomotorului conectat la portul OUT_C al robotului NXT.
Viteza de rotaţie (20 în prima instrucţiune) este o mărime derivată cu valori între -100 şi 100 şi
se traduce de fapt în tensiunea aplicată bornelor servomotorului (-9V şi +9V).
Având în vedere construcţia robotului prezentat în Figura 38, cu tracţiunea suportată de
către un singur servomotor, este evident faptul că robotul nu se poate deplasa decât pe o singură
direcţie (înainte şi înapoi), iar distanţa parcursă este direct proporţională cu unghiul de rotaţie al
axului servomotorului.
Ca atare, robotul se va deplasa înainte cu o viteză relativ mică pe o distanţă de aprox.
20cm, apoi se va opri timp de 3 secunde şi se va întoarce la poziţia iniţială cu o viteză de 3 ori mai
mare.
74

Pentru evaluarea datelor de la senzorul cu ultrasunete se va plasa în faţa robotului, la
aproximativ 40cm, un obstacol. Pe măsură ce robotul se apropie de obstacol, senzorul cu
ultrasunete ar trebui să înregistreze scăderea distanţei, iar evoluţia acestei mărimi să corespundă
cu evoluţia distanţei parcurse măsurată de către encoderul servomotorului.
Figura 38. Aplicaţie la metoda de citire a datelor achiziţionate sub comanda programului NXC
6.3.2 Rezultatele obţinute
În urma executării aplicaţiei şi a transmisiei datelor achiziţionate la PC, rezultatele au fost
exportate într-un fişier Tab delimited text care a fost apoi introdus în programul Microsoft Excel
pentru interpretare.
75

Figura 39. Evoluţia distanţei parcurse de robot
Figura 40. Evoluţia distanţei până la obstacol
76

7 Analiza rezultatelor obţinute
7.1 Rezultatele obţinute la aplicaţiile implementate
Lucrarea de faţă prezintă două metode de transmisie a datelor achiziţionate de la senzorii
NXT la PC:
1. Citirea datelor achiziţionate de la senzorii NXT prin interogare de la PC (cap. 5)
2. Citirea datelor achiziţionate de la senzorii NXT sub comanda unui program scris în
limbajul NXC care rulează pe NXT (cap. 6)
La fiecare dintre cele două metode elaborate am realizat şi câte o aplicaţie practică.
Aplicaţiile respective au fost:
1) Determinarea poziţiei obiectelor cu senzorul de ultrasunete (punctul 5.5)
2) Evoluţia în timp a mărimilor măsurate de către senzorii NXT (punctul 6.3)
Deoarece aplicaţiile implementate au obiective distincte şi modalităţi de interpretare
specifice, rezultatele obţinute la fiecare dintre cele două aplicaţii sunt prezentate la capitolele
respective, adică punctul 5.5 şi punctul 6.3.
7.2 Compararea celor două metode
Pentru compararea celor două metode am realizat o aplicaţie similară cu aplicaţia de la
punctul 6.3 (Evoluţia în timp a mărimilor măsurate de către senzorii NXT).
Aplicaţia realizează monitorizarea senzorilor NXT folosind simultan ambele metode în
timpul executării unui set de instrucţiuni NXC care determină mişcarea robotului NXT astfel încât
mărimile monitorizate să varieze în timp.
Se va analiza evoluţia unghiului de rotire al axului servomotorului. Având în vedere
construcţia robotului prezentat în Figura 38, cu tracţiunea suportată de către un singur servomotor,
este evident faptul că robotul nu se poate deplasa decât pe o singură direcţie (înainte şi înapoi),
iar distanţa parcursă este direct proporţională cu unghiul de rotaţie al axului servomotorului.
Instrucţiunile de mişcare sunt: mers înainte cu viteza 20 pe o distanţă corespunzătoare
unei rotiri cu 500 de grade a axului servomotorului, oprire 1 secundă, revenire la poziţia iniţială
(rotire 500 grade înapoi) cu viteză de 3 ori mai mare.
Rulând aplicaţia am obţinut graficul comparativ din Figura 41.
77

Figura 41. Rezultatele comparării celor două metode
După cum se observă în graficul din Figura 41, cele două metode furnizează rezultate
aproape identice. Acestă concluzie a constituit o surpriză, deoarece mă aşteptam ca metoda 1
(achiziţia datelor prin interogare de la PC) să sufere întârzieri datorate unui algoritm mai complex
şi traficului mai frecvent prin conexiune Bluetooth, iar curba să se decaleze faţă de curba metodei
2.
Ambele metode au presupus efectuarea de măsurători (achiziţii de date de la senzori) la
intervale de 100ms. Prin reducerea intervalelor este posibilă apariţia decalajului menţionat mai
sus, dar o rezoluţie atât de mare a datelor achiziţionate nu reprezintă un beneficiu considerabil în
aplicaţiile uzuale ale robotului NXT.
Fiecare dintre cele două metode elaborate în lucrarea de faţă prezintă avantaje şi
dezavantaje. Având în vedere că rezultatele furnizate de către cele două metode sunt aproape
identice, diferenţierea acestora în proiectare se poate face în funcţie de impactul specific aplicaţiei
cu avantajele/dezavantajele menţionate.
78

8 Concluzii
Tema proiectului de diplomă se referă la un domeniu de actualitate, vizând valorificarea
eficientă a unor elemente disponibile în domeniul roboţilor mobili de uz ştiinţific şi didactic (suportul
LEGO Mindstorms NXT) în scopul dezvoltării platformei de comunicaţii prin Bluetooth a acestora
cu elemente soft care să ofere un mediu favorabil şi fiabil potenţialelor aplicaţii.
Acest scop a fost realizat, conform cerinţelor şi detaliilor impuse prin temă, prin elaborarea
a două metode de transmitere a datelor achiziţionate de la senzorii NXT, de la robotul mobil la PC.
Pentru fiecare metodă s-a realizat un program-soft corespunzător, precum şi câte o aplicaţie care
să concretizeze şi să verifice eficienţa metodei, iar acest aspect a fost confirmat, atât prin
rezultatele aplicaţiilor asociate, cât şi prin rezultatele unei aplicaţii elaborată special pentru
compararea celor două metode.
Dificultăţile întâlnite în elaborarea proiectului au fost legate de particularităţile programării
robotului LEGO NXT. Limitările software cât şi cele hardware ale robotului NXT m-au motivat să
gasesc modalităţi inedite de a realiza obiectivele propuse. În final eforturile mele au dus la
obţinerea unor algoritmi şi programe performante care utilizează în mod optim resursele
disponibile.
Faptul că, la compararea rezultatelor aplicării celor două metode, s-au obţinut date
aproape identice determină concluzia că ambele metode sunt caracterizate de un nivel ridicat de
acurateţe în domeniul timp. Întârzierea transferului de date prin conexiune Bluetooth este
neglijabilă în raport cu reacţia în timp a elementelor de execuţie ale robotului (servomotorul) sau
reacţia în timp a anumitor senzori.
Ca urmare, metodele şi programele create asigură un nivel de performanţă ridicat şi oferă
o rezervă considerabilă în perspectiva unor aplicaţii cu elemente de execuţie mai rapide.
Este important de menţionat că cele două metode nu exclud, pentru viitor, elaborarea şi a
altor programe (îmbunătăţite) cu acelaşi scop, iar programele pe care le-am realizat reprezintă o
bază flexibilă pentru rularea unei diversităţi de aplicaţii ştiinţifice sau didactice.
Bibliografie
[1] ***, LEGO® Mindstorms® NXT® Hardware Developer Kit.
79

[2] ***, LEGO® Mindstorms® NXT® Bluetooth Developer Kit
[3] ***, LEGO® Mindstorms® NXT® Direct commands
[4] ***, Mindstorms® Education NXT® User Guide
[5] Dave Astolfo, Mario Ferrari, Giulio Ferrari, Building Robots with LEGO® Mindstorms® NXT®
[6] Michael Gasperi, Philippe “Philo” Hurbain, Isabelle Hurbain, Extreme NXT® Extending the
LEGO® MINDSTORMS® NXT® to the Next Level
[7] John Hansen, Not eXactly C (NXC) Programmer's Guide.
[8] Daniele Benedettelli, Programming LEGO® NXT® Robots using NXC [9] *** ,
www.parallax.com
[10] Radu Bogdan Rusu, Robotux - a multiagent robot security system. Master's Thesis, Faculty
of Automation and Computer Science, Technical University of Cluj-Napoca, Romania, 2004. [11]
*** http://www.philohome.com/nxt.htm
[12] *** , http://me.mecatronica.pub.ro/romar/etape/etapa_3/Legatura%202_1.pdf
[13] Radu Bogdan Rusu, Modern architectures for mobile robots: Javaclient and ZeeRO.
Advanced Master's Thesis, Faculty of Automation and Computer Science, Technical
University of Cluj-Napoca Romania, 2005
[14] *** , http://yo9hnh.files.wordpress.com/2008/10/introducere-în-microcontrollere.pdf
[15] *** , www.mikroe.com/ro/product/books/PICbook/2_01Poglavlje.htm
[16] Dumitriu, A., Bucşan, C., Demian, T., Sisteme senzoriale pentru roboţi, Editura MEDRO,
Bucureşti, 1996.
[17] Dumitriu, A., Mecatronică, volumul I, Editura Universităţii „Transilvania” din Braşov, 2006.
[18] Grigore, O., An Incremental Motion Tracking Controller for on Board Directly Platform, În:
Rev. Roum. Sci. Techn. – Electrotehn. Et Energ., 3, Bucharest, 2000.
[19] *** , www.LegoDacta.com
[20] *** , http://telecom.etc.tuiasi.ro/telecom/staff/ccomsa/Lucru/
Introducere_în_Bluetooth.pdf
[21] *** , http://stst.elia.pub.ro/RIC/Teme_RIC_2006_7/AlexandraAlmasan/
RETELE%20WIRELESS%20DE%20MICI%20DIMENSIUNI.doc
[22] *** , ftp.utcluj.ro/pub/users/cmil/rwcm/week3/bluetooth01.ppt
[23] *** , http://en.wikipedia.org/wiki/Bluetooth
[24] *** , IEEE Oregon bluetooth seminar-2001
[25] *** , http://me.mecatronica.pub.ro/romar/etape/etapa_2/Legatura%203.pdf
80

[26] *** , http://www.bluetooth.com/
[27] Jon Inouye, Introduction to BluetoothWireless Technology -Mobile Platforms Group Intel
Corporation
[28] *** , Ericsson Mobile Communications AB „Users Manual – Bluetooth PC Reference Stack
by Ericsson”, 2000
[29] Muller, Nathan J., „Bluetooth Demistified” – McGraw-Hill Telecom, 2001
[30] Coiffet, P., La robotique – principles et applications, Editions Hermes Paris, 1986,
81

Anexe
9 Anexe
9.1 Anexa 1. Metoda 1. Clasa OperatorNXT
using System;
using System.Collections.Generic;
using System.Text; using
System.IO.Ports; using
Bram.Utilities;
namespace PC2NXT
{
public class OperatorNXT {
public OperatorNXT(string portname){
_portName = portname;
}
private string _portName;
private SerialPort port = null;
public void Connect(){
if(port != null){
Disconnect();
}
port = new SerialPort(_portName);
port.Open();
IsConnected = true;
}
public void Disconnect(){
IsConnected = false;
if(port.IsOpen){
port.Close();
port.Dispose();
}
port = null;
}
///
/// semafor care marcheaza conexiune activa sau nu
///
public bool IsConnected {
get {
return _isConnected;
}
private set {
_isConnected = value;
}
}
bool _isConnected = false;
82

/// trimite serie bytes la portul serial
///
private byte[] TrimiteComanda(byte[] comanda){
if(!IsConnected){
throw new InvalidOperationException("trebuie conectat");
} else {
lock(this){
int length = comanda.Length;
byte[] btMessage = new byte[comanda.Length + 2];
btMessage[0] = (byte)(length & 0xFF);
btMessage[1] = (byte)((length & 0xFF00) >> 8);
comanda.CopyTo(btMessage, 2);
port.Write(btMessage, 0, btMessage.Length);
if(comanda[0] < 0x80){
// A reply is
expected. Check it. int lsb =
port.ReadByte();
int msb = port.ReadByte();
int size = lsb + msb * 256;
byte[] reply = new byte[size];
port.Read(reply, 0, size);
return reply;
} else { return
null;
}
}
}
}
///
/// seteaza starea unui motor
///
public void SetStareMotor(PortNxtMotor port, sbyte power, ModNxtMotor
mode, RegModNxtMotor regulationMode, sbyte turnRatio, FunctNxtMotor runState, uint
tachoLimit){
byte[] comanda = new byte[12];
comanda[0] = 0x80;
comanda[1] = (byte)CodMesajDirect.SetOutputState;
comanda[2] = (byte)port;
comanda[3] = (byte)power; comanda[4] =
(byte)mode; comanda[5] =
(byte)regulationMode; comanda[6] =
(byte)turnRatio; comanda[7] =
(byte)runState;
Util.SetUInt32(comanda,
8, tachoLimit);
TrimiteComanda(comanda);
}
///
/// returneaza starea unui motor
///
public StareMotor GetStareMotor(PortNxtMotor port){
byte[] comanda = new byte[3];
comanda[0] = 0x00;
comanda[1] = (byte)CodMesajDirect.GetOutputState;
comanda[2] = (byte)port;
byte[]
reply = TrimiteComanda(comanda);
StareMotor
raspuns = new StareMotor(); raspuns.Power =
(sbyte)reply[4]; raspuns.Mode =
(ModNxtMotor)reply[5]; raspuns.RegulationMode =
(RegModNxtMotor)reply[6];
raspuns.TurnRatio = (sbyte)reply[7];
raspuns.RunState = (FunctNxtMotor)reply[8];
83

aspuns.TachoLimit = Util.GetUInt32(reply, 9);
raspuns.TachoCount = Util.GetInt32(reply, 13);
raspuns.BlockTachoCount = Util.GetInt32(reply, 17);
raspuns.RotationCount = Util.GetInt32(reply, 21);
return raspuns;
}
///
/// seteaza modul de functionare al unui senzor
///
public void SetInputMode(PortNxtSenzor port, TipNxtSenzor type,
ModNxtSenzor mode){
byte[] comanda = new byte[5];
comanda[0] = (byte)NxtCommandType.DirectCommandWithResponse;
comanda[1] = (byte)CodMesajDirect.SetInputMode;
comanda[2] = (byte)port;
comanda[3] = (byte)type;
comanda[4] = (byte)mode;
TrimiteComanda(comanda);
}
///
/// citeste date achiziţionate de la un senzor
///
public StareSenzor GetInputValues(PortNxtSenzor port){
StareSenzor raspuns = new StareSenzor();
byte[] comanda = new byte[3]; comanda[0] = 0x00;
// Expect an answer
comanda[1] = (byte)CodMesajDirect.GetInputValues;
comanda[2] = (byte)port;
byte[] reply
= TrimiteComanda(comanda); raspuns.Valid = (reply[4]
== 1) ? true : false; raspuns.Calibrated = (reply[5]
== 1) ? true : false; raspuns.Type =
(TipNxtSenzor)reply[6]; raspuns.Mode =
(ModNxtSenzor)reply[7]; raspuns.RawAD =
Util.GetUInt16(reply, 8); raspuns.NormalizedAD =
Util.GetUInt16(reply, 10); raspuns.ScaledValue =
Util.GetInt16(reply, 12);
raspuns.CalibratedValue = Util.GetInt16(reply, 14);
return raspuns;
}
///
/// citeste numarul de bytes disponibil la magistrala I2C (Low speed)
///
public int LSGetStatus(PortNxtSenzor port){
byte[] comanda = new byte[3];
comanda[0] = (byte)NxtCommandType.DirectCommandWithResponse;
comanda[1] = (byte)CodMesajDirect.LSGetStatus;
comanda[2] = (byte)port;
byte[] reply = TrimiteComanda(comanda);
return reply[3];
}
///
/// scrie un mesaj la magistrala I2C (low speed)
///
public void LSWrite(PortNxtSenzor port, byte[] data, int
returnMessageLength){
if(data.Length < 1 || data.Length > 16){
throw new InvalidOperationException("data length must be between 1 and 16 bytes");
}
byte[] comanda = new byte[5 + data.Length];
comanda[0] = (byte)NxtCommandType.DirectCommandWithResponse;
comanda[1] = (byte)CodMesajDirect.LSWrite;
comanda[2] = (byte)port; comanda[3] =
(byte)data.Length; comanda[4] =
84

(byte)returnMessageLength; Array.Copy(data,
0, comanda, 5, data.Length);
TrimiteComanda(comanda);
}
///
/// citeste tot de la magistrala I2C (low speed)
///
public byte[] LSRead(PortNxtSenzor port){
byte[] comanda = new byte[3];
comanda[0] = (byte)NxtCommandType.DirectCommandWithResponse;
comanda[1] = (byte)CodMesajDirect.LSRead;
comanda[2] = (byte)port;
byte[] reply = TrimiteComanda(comanda);
int length = (int)reply[3];
byte[] raspuns = new byte[length];
Array.Copy(reply, 4, raspuns, 0, length);
return raspuns;
}
///
/// scrie un byte de la interfata I2C (low speed)
///
public void I2CSetByte(PortNxtSenzor port, byte address, byte value){
byte[] i2cCmd = new byte[3]; i2cCmd[0] = 0x02;
i2cCmd[1] = address;
i2cCmd[2] = value;
LSWrite(port, i2cCmd, 0);
}
///
/// citeste un byte de la interfata I2C (low speed)
///
public byte I2CGetByte(PortNxtSenzor port, byte address){
byte[] i2cCmd = new byte[2];
i2cCmd[0]
= 0x02; i2cCmd[1] = address;
int bytesRead = 0;
do {
LSWrite(port, i2cCmd, 1);
try {
bytesRead = LSGetStatus(port);
}
catch(Exception){
bytesRead = 0;
}
} while(bytesRead < 1);
return LSRead(port)[0];
}
}
public struct StareMotor {
public sbyte Power;
public
ModNxtMotor Mode;
public RegModNxtMotor
RegulationMode;
public sbyte TurnRatio;
public FunctNxtMotor RunState;
public uint TachoLimit;
public int
TachoCount;
public int BlockTachoCount;
public int RotationCount;
}
public struct StareSenzor {
public bool Valid; public
bool Calibrated; public
TipNxtSenzor Type; public
ModNxtSenzor Mode; public
UInt16 RawAD; public
85

UInt16 NormalizedAD;
public Int16 ScaledValue;
public Int16
CalibratedValue;
}
public enum CodMesajDirect : byte {
StartProgram = 0x00,
StopProgram = 0x01,
PlaySoundFile = 0x02,
PlayTone = 0x03,
SetOutputState = 0x04,
SetInputMode = 0x05,
GetOutputState = 0x06,
GetInputValues = 0x07,
MessageWrite = 0x09,
ResetMotorPosition = 0x0A,
GetBatteryLevel = 0x0B,
KeepAlive = 0x0D,
LSGetStatus = 0x0E,
LSWrite = 0x0F,
LSRead = 0x10,
MessageRead = 0x13,
OpenRead = 0x80,
OpenWrite = 0x81,
Read = 0x82,
Write = 0x83,
SetBrickName = 0x98
}
public enum CodRaspuns : byte {
OK = 0x00,
PendingCommunicationInProgress = 0x20,
SpecifiedMailBoxEmpty = 0x40,
RequestFailed = 0xBD,
UnknownCommand = 0xBE,
InsanePacket = 0xBF,
publicOfRangeData = 0xC0,
CommBusError = 0xDD,
publicOfMemoryInCommunicationBuffer = 0xDE,
ChannelInvalid = 0xDF,
ChannelBusy = 0xE0,
NoActiveProgram = 0xEC,
IllegalSizeSpecified = 0xED,
IllegalMailboxID = 0xEE,
InvalidFieldAccess = 0xEF,
BadData = 0xF0,
publicOfMemory = 0xFB,
BadArguments = 0xFF
}
[Flags()]
public enum ModNxtMotor : byte {
None = 0x00,
MotorOn = 0x01,
Brake = 0x02,
Regulated = 0x04
}
[Flags]
public enum RegModNxtMotor : byte {
Idle = 0x00,
MotorSpeed = 0x01,
MotorSynchronization = 0x02
86

}
[Flags]
public enum FunctNxtMotor : byte {
Idle = 0x00,
RampUp = 0x10,
Running = 0x20,
Rampdown = 0x40
}
public enum PortNxtMotor {
PortA = 0x00,
PortB = 0x01,
PortC = 0x02,
None = 0xFE,
All = 0xFF
}
public enum PortNxtSenzor {
Port1 = 0x00,
Port2 = 0x01,
Port3 = 0x02,
Port4 = 0x03,
None = 0xFE
}
public enum TipNxtSenzor {
None = 0x00,
Switch = 0x01,
Temperature = 0x02,
Reflection = 0x03,
Angle = 0x04,
LightActive = 0x05,
LightInactive = 0x06,
SoundDB = 0x07,
SoundDBA = 0x08,
Custom = 0x09,
LowSpeed = 0x0A,
LowSpeed_9V = 0x0B
}
public enum ModNxtSenzor {
Raw = 0x00,
Boolean = 0x20,
TransitionCounter = 0x40,
PeriodCounter = 0x60,
Percentage = 0x80,
Celsius = 0xA0,
Fahrenheit = 0xC0,
AngleStep = 0xE0
}
public enum NxtCommandType {
DirectCommandWithResponse = 0x00,
SystemCommandWithResponse = 0x01,
Reply,
DirectCommandNoResponse = 0x80,
SystemCommandNoResponse = 0x81
}
}
87

9.2 Anexa 2. Metoda 1. Modul de afisare a datelor de la senzorul cu
ultrasunete
using
System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing; using
System.Data; using System.Text;
using System.Windows.Forms; using
System.Collections; using
System.Drawing.Drawing2D;
namespace PC2NXT
{
public partial class SonarMap : UserControl
{
private Brush brush1 = new SolidBrush(Color.Red);
private Brush brush2 = new SolidBrush(Color.Black);
private
Brush brush3 = new SolidBrush(Color.AliceBlue);
public int
RotationRange = 0;
public SonarMap()
{
InitializeComponent();
}
private void SonarMap_Load(object sender, EventArgs e)
{
}
public void Init(int RotationRange)
{
this.RotationRange = RotationRange;
this.Clear();
label1.Text = "";
label2.Text = "";
}
private ArrayList _FoundObjects;
public ArrayList FoundObjects
{
get
{
return _FoundObjects;
}
set
{
_FoundObjects = value;
}
}
public void Clear()
{
panel1.CreateGraphics().Clear(panel1.BackColor);
}
public void Draw(SomeObject obj)
{
Draw(obj, panel1.CreateGraphics());
}
public void Draw(SomeObject obj, Graphics graphics)
{
int W = panel1.Width;
int H = panel1.Height - 10;
88

int w = (int)(W / RotationRange);
int h = (int)(H * obj.Distance / 255);
int x = (int)(w * obj.Rotation);
graphics.FillRectangle(brush1, x, 10 + H - h, 4, h);
graphics.FillRectangle(brush2, x, 10, 4, H - h);
graphics.FillRectangle(brush3, 0, 0, W, 10);
graphics.FillPolygon(brush1, new Point[] {new Point(x - 3, 0), new
Point(x, 8), new Point(x + 4, 0)});
}
private void DrawAll(Graphics graphics)
{
if (this.FoundObjects != null)
for (int i = 0; i < this.FoundObjects.Count; i++)
Draw((SomeObject)this.FoundObjects[i], graphics);
}
public void DrawAll(ArrayList PartiallyFoundObjects)
{
this.FoundObjects = PartiallyFoundObjects;
DrawAll(panel1.CreateGraphics());
}
private void panel1_Paint(object sender, PaintEventArgs e)
{
DrawAll(e.Graphics);
}
private void SonarMap_Resize(object sender, EventArgs e)
{
panel1.Width = this.Width;
}
private int? SelectionStart = null;
private void panel1_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
if (SelectionStart != null)
{
SelectionStart = null;
panel1.Cursor = Cursors.Default;
}
else
{
SelectionStart = e.X;
panel1.Cursor = Cursors.VSplit;
}
}
}
private void panel1_MouseMove(object sender, MouseEventArgs e)
{
if (SelectionStart != null)
{
label1.Text = "Distanta minima: " +
GetMinDistanceBetween((int)SelectionStart, e.X);
label1.Text = "intre " + SelectionStart + " şi " + e.X;// +
GetWidthBetween((int)SelectionStart, e.X);
}
else
{
89

label1.Text = "Distanta: " + GetDistanceAround(e.X);
label2.Text = "";
}
}
private int GetDistanceAround(int x)
{
if (FoundObjects == null) return 0; int
r = XToRotation(x); ArrayList vals = new
ArrayList(); for (int i = 0; i <
FoundObjects.Count; i++)
{
int R = ((SomeObject)FoundObjects[i]).Rotation;
if (R == r)
{
return ((SomeObject)FoundObjects[i]).Distance;
}
else if (Math.Abs(R - r) < 3)
{
vals.Add(((SomeObject)FoundObjects[i]).Distance);
}
}
if (vals.Count > 0)
{
int sum = 0;
for (int i = 0; i < vals.Count; i++)
{
sum += (int)vals[i];
}
return (int)(sum / vals.Count);
}
return 0;
}
private int GetMinDistanceBetween(int StartX, int x)
{
if (FoundObjects == null) return 0;
int r1 = XToRotation(StartX);
int r2 = XToRotation(x);
if (r1 > r2){
int a = r1; r1 =
r2; r2 = a;
}
ArrayList vals = new ArrayList();
for (int i = 0; i < FoundObjects.Count; i++)
{
int R = ((SomeObject)FoundObjects[i]).Rotation;
if (r1

}
}
private int XToRotation(int x)
{
return (int)(x / (panel1.Width / RotationRange));
}
}
9.3 Anexa 3. Metoda 1. Programul principal al aplicatiei
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data; using
System.Drawing; using
System.Text; using
System.Windows.Forms; using
System.Collections;
namespace PC2NXT
{
public partial class Form1 : Form
{
private const int SonarConeAngle = 100;
private const int SonarConeAngleInDegrees = 90;
public Form1()
{
InitializeComponent();
}
private OperatorNXT nxt = new OperatorNXT("COM6");
private PortNxtSenzor SonarPort = PortNxtSenzor.Port1;
private PortNxtMotor MotorPort = PortNxtMotor.PortC;
private ArrayList FoundObjects = new ArrayList();
private int RotationDirection = 1;
private int RotationReference = 0;
private int RotationDiff = 0;
private
int RotationLimit = 400;
private bool
scanning = false;
private void button1_Click(object sender, EventArgs e)
{
if (nxt.IsConnected)
Disconnect();
else
Connect();
}
private void button2_Click(object sender, EventArgs e)
{
if (scanning)
{
scanning = false;
button2.Text = "Start";
}
else
{
FoundObjects.Clear();
RotationLimit = Int32.Parse(textBox1.Text);
MotorInit();
sonarMap.FoundObjects = this.FoundObjects;
sonarMap.Init(RotationLimit);
sonarGauge.Init(RotationToAngle(RotationReference), 0);
button2.Text = "Stop";
91

scanning = true;
}
}
private void Connect()
{
nxt.Connect();
if (nxt.IsConnected)
{
SonarInit();
MotorInit();
timer1.Enabled = true;
timer1.Interval = 1600;
button1.Text = "Disconnect";
}
}
private void Disconnect()
{
timer1.Enabled = false;
nxt.Disconnect();
button1.Text = "Connect";
}
private void SonarInit()
{
nxt.SetInputMode(SonarPort, TipNxtSenzor.LowSpeed_9V,
ModNxtSenzor.Raw);
if (nxt.LSGetStatus(SonarPort) > 0)
{
nxt.LSRead(SonarPort);
}
nxt.I2CSetByte(SonarPort, (byte)NxtSonarRegister.Mode, 0x02);
}
private int SonarGetDistance()
{
return SonarGetDistance(NxtSonarRegister.MeasurementByte0);
}
private int SonarGetDistance(NxtSonarRegister meas)
{
try
{
return nxt.I2CGetByte(SonarPort, (byte)meas);
}
catch (Exception ex)
{
return -1;
}
}
private void timer1_Tick(object sender, EventArgs e){
if (nxt.IsConnected == false) return;
int
Rotation = MotorGetRotation(); int Distance =
SonarGetDistance();
int RelativeRotation = Rotation
- RotationReference; lblSonar.Text = "Distanta: " +
Distance;
lblRotation.Text = "Rotatie: " + Rotation + " : " +
(RelativeRotation);
lblRotationReference.Text = "Rotatie de referinta: " +
RotationReference;
if (!scanning) return;
// log info
txtLog.AppendText(RelativeRotation + " : " + Distance + "\r\n");
92

store distance
ObjectCheckNew(Distance, RelativeRotation);
// what to do next?
if (RelativeRotation > RotationLimit)
{
RotationDirection = -1;
RotationDiff++;
}
else if (RelativeRotation < 0)
{
RotationDirection = 1;
RotationDiff++;
}
else if (RelativeRotation == 0)
{
RotationDirection = 1;
RotationDiff++;
}
sonarMap.FoundObjects = this.FoundObjects;
sonarMap.Draw(new ObiectDetectat(Distance, RelativeRotation));
//sonarGauge.Angle = RotationToAngle(Rotation);
//sonarGauge.Distance = Distance;
//sonarGauge.Draw();
RotesteServo(10, 20 + RotationDiff);
}
private void ObjectCheckNew(int Distance, int Rotation){
ObiectDetectat CurrentObject = new ObiectDetectat(Distance,
Rotation);
if (FoundObjects.Count == 0)
ObjectAdd(CurrentObject);
else
{
//ObiectDetectat PreviousObject =
(ObiectDetectat)FoundObjects[FoundObjects.Count - 1];
//if (PreviousObject.CompareDistance(CurrentObject) != 0)
ObjectAdd(CurrentObject);
}
}
private void ObjectAdd(ObiectDetectat obj){
// parcurge valorile existente pentru a asigura ordinea crescatoare
for (int i = 0; i < FoundObjects.Count; i++){
if (((ObiectDetectat)FoundObjects[i]).Rotation > obj.Rotation){
FoundObjects.Insert(i, obj);
return;
}
}
FoundObjects.Add(obj);
}
private void MotorInit(){
RotationReference = MotorGetRotation();
}
private int MotorGetRotation(){
StareMotor motorState = nxt.GetStareMotor(MotorPort);
return motorState.TachoCount;
}
private int RotationToAngle(int rotation){
double angle = ((180.00 / 420.00) * (rotation -
RotationReference));
double offset = ((180.00 / 420.00) * ((double)RotationLimit / 2));
return (int)(angle + offset);
93

}
///
/// porneste motorul
///
public void RotesteServo(int speed, int degrees){
SetStareMotor(
speed,
ModNxtMotor.MotorOn | ModNxtMotor.Brake,
RegModNxtMotor.MotorSpeed,
0,
FunctNxtMotor.Running,
degrees
);
}
///
/// opreste motorul prin compensarea inertiei
///
public void Frana(){
SetStareMotor(
0,
ModNxtMotor.MotorOn | ModNxtMotor.Brake |
ModNxtMotor.Regulated,
RegModNxtMotor.MotorSpeed,
0,
FunctNxtMotor.Running,
0
);
}
///
/// seteaza starea motorului
///
public void SetStareMotor(int power, ModNxtMotor mode, RegModNxtMotor
regulationMode, int turnRate, FunctNxtMotor runState, int tachoLimit){
nxt.SetStareMotor(
MotorPort,
(sbyte)(power * RotationDirection),
mode,
regulationMode,
(sbyte)turnRate,
runState,
(uint)tachoLimit
);
}
}
public class ObiectDetectat
{
public int Distance = 0;
public int Rotation = 0;
public ObiectDetectat(int Distance, int Rotation)
{
this.Distance = Distance;
this.Rotation = Rotation;
}
public int CompareDistance(ObiectDetectat other)
{
if (this.Distance < other.Distance)
return -1;
else if (this.Distance > other.Distance)
return 1;
else
return 0;
94

}
}
public enum NxtSonarRegister {
MeasurementUnits = 0x14,
PollInterval = 0x40,
Mode = 0x41,
MeasurementByte0 = 0x42,
MeasurementByte1 = 0x43,
MeasurementByte2 = 0x44,
MeasurementByte3 = 0x45,
MeasurementByte4 = 0x46,
MeasurementByte5 = 0x47,
MeasurementByte6 = 0x48
}
}
9.4 Anexa 4. Metoda 2. Programul NXC
#define BT_CONN 0
#define BT_PACKET_LEN 200 //bytes struct
masuratoare
{
unsigned short timp;
short valoare;
};
masuratoare SerieMasuratori1[], SerieMasuratori2[];
unsigned long MasuratoareLastTime1,
MasuratoareLastTime2; bool SeMasoara; int
VerificaStatusBT()
{
CommBTCheckStatusType StatusArgs;
StatusArgs.Connection = BT_CONN;
TextOut(0, LCD_LINE2, "SysCommBTCheckStatus", true);
SysCommBTCheckStatus(StatusArgs);
switch(StatusArgs.Result)
{ case
LDR_SUCCESS:
break;
TextOut(0, LCD_LINE2, "LDR_SUCCESS", true);
case STAT_COMM_PENDING:
TextOut(0, LCD_LINE2, "STAT_COMM_PENDING", true);
Wait(100);
break;
case
ERR_INVALID_PORT:
TextOut(0, LCD_LINE2, "ERR_INVALID_PORT", true);
Wait(1000);
break;
case
ERR_COMM_CHAN_NOT_READY:
TextOut(0, LCD_LINE2, "ERR_COMM_CHAN_NOT_READY", true);
Wait(1000);
break;
default:
string str = NumToStr(StatusArgs.Result);
TextOut(0, LCD_LINE2, StrCat("other err = ", str), true);
Wait(2000);
break;
}
return StatusArgs.Result;
}
95

ool TrimitePrinBT(string str)
{
until (VerificaStatusBT() == LDR_SUCCESS);
BluetoothWrite(BT_CONN, str); until
(VerificaStatusBT() == LDR_SUCCESS);
return true;
}
void StartMasuratori()
{
MasuratoareLastTime1 = CurrentTick();
MasuratoareLastTime2 = CurrentTick();
SeMasoara = true;
}
void StopMasuratori()
{
SeMasoara = false;
}
void SalveazaMasuratoare(byte SeriesNumber, short valoare)
{
if (!SeMasoara){
return; }
unsigned long now = CurrentTick();
masuratoare m, tmp[];
m.valoare = valoare;
switch(SeriesNumber)
{
case 1:
m.timp = now - MasuratoareLastTime1;
//MasuratoareLastTime1 = now; tmp =
SerieMasuratori1;
ArrayBuild(SerieMasuratori1, tmp, m);
break; case 2:
m.timp = now - MasuratoareLastTime2;
//MasuratoareLastTime2 = now; tmp =
SerieMasuratori2;
ArrayBuild(SerieMasuratori2, tmp, m);
break;
} }
string SerializeazaVectorMasuratori(masuratoare ms[])
{
return FlattenVar(ms);
}
bool TrimiteMasuratori(byte SeriesNumber)
{
masuratoare clear_series[];
string buffer, sn, packet; buffer
= "";
sn = FlattenVar(SeriesNumber);
switch(SeriesNumber)
{
case 1:
buffer = SerializeazaVectorMasuratori(SerieMasuratori1);
SerieMasuratori1 = clear_series;
break; case 2:
96

uffer = SerializeazaVectorMasuratori(SerieMasuratori2);
SerieMasuratori2 = clear_series;
break;
} int i, len;
len = StrLen(buffer);
for (i = 0; i < len; i += BT_PACKET_LEN)
{
packet = SubStr(buffer, i, BT_PACKET_LEN);
packet = StrCat(sn, packet);
TrimitePrinBT(packet);
} return
true;
} task
motion()
{
RotateMotor(OUT_C, 20, 500);
Wait(3000);
RotateMotor(OUT_C, -60, 500);
}
task masuratori()
{
while (SeMasoara && ButtonPressed(BTNCENTER, true) == false)
{ short i = 0;
i = MotorTachoCount(OUT_C);
SalveazaMasuratoare(1, i);
i = SensorUS(IN_1);
SalveazaMasuratoare(2, i);
Wait(100);
}
StopMasuratori();
int i = 0; string
s = "";
i = ArrayLen(SerieMasuratori1);
s = NumToStr(i);
TextOut(0, LCD_LINE1, StrCat("Series1 ", s), true);
i = ArrayLen(SerieMasuratori2);
s = NumToStr(i);
TextOut(0, LCD_LINE2, StrCat("Series2 ", s), false);
Wait(5000);
TrimiteMasuratori(1);
TrimiteMasuratori(2);
Stop(true);
} task
main()
{
SetSensorLowspeed(IN_1);
StartMasuratori(); start
masuratori; start
motion;
}
9.5 Anexa 5. Metoda 2. Clasa ReceptorNXT
using System;
97

using System.Collections.Generic;
using System.Text; using System.IO;
using System.IO.Ports; using
System.Windows.Forms; using
System.Runtime.InteropServices;
namespace NXT2PC
{
public class Masuratoare
{
public ushort Timp;
public short Valoare;
}
public class ReceptorNXT
{
public ReceptorNXT()
{
}
private SerialPort PortSerial = new SerialPort();
public string NumePort
{
get
{
return PortSerial.PortName;
}
set
{
if (!EsteConectat)
PortSerial.PortName = value;
}
}
public bool EsteConectat
{
get
{
return PortSerial.IsOpen;
}
}
public bool Conecteaza()
{
if (!EsteConectat)
{
PortSerial.ReadBufferSize = 1024 * 10; //10 KB
PortSerial.Open();
PortSerial.DiscardInBuffer();
}
return EsteConectat;
}
public void Deconecteaza()
{
if (EsteConectat)
PortSerial.Close();
}
public byte[] CitesteDeLaPortSerial()
{
byte[] reply = {};
if (EsteConectat)
{
int size = PortSerial.BytesToRead;
if (size > 0)
98

{
}
}
return reply;
reply = new byte[size];
PortSerial.Read(reply, 0, size);
PortSerial.DiscardInBuffer();
}
public void CitesteMasuratoriInSeriile(ref SerieMasuratori Series1, ref
SerieMasuratori Series2)
{
byte[] data = CitesteDeLaPortSerial();
if (data.Length > 2)
{
int Offset, SeriesNumber;
Offset = 0;
Masuratoare[] ms = CitesteMasuratori(ref data, ref Offset,
out SeriesNumber);
while (ms != null && ms.Length > 0)
{
if (SeriesNumber == 1)
Series1.AfiseazaMasuratorile(ms);
if (SeriesNumber == 2)
Series2.AfiseazaMasuratorile(ms);
ms = CitesteMasuratori(ref data, ref Offset, out
SeriesNumber);
}
}
}
public Masuratoare[] CitesteMasuratori(ref byte[] data, ref int offset, out int
NumarSerie)
{
Masuratoare[] ms = null;
NumarSerie = 0;
if (data.Length > offset + 2)
{
short data_count = BytesToShort(data, offset + 0);
if (data.Length >= offset + 2 + data_count)
{
byte struct_len = 4;
byte struct_start = 2 + 1;
short struct_count = 0;
NumarSerie = data[offset + 2];
if (Math.IEEERemainder(data_count - 2, struct_len) ==
0)
{
struct_count = (short)((data_count - 2) /
struct_len);
ms = new Masuratoare[struct_count];
for (int i = 0; i < struct_count; i++)
{
ms[i] = BytesToMasuratoare(data, offset
+ struct_start + (i * struct_len));
}
offset += 2 + data_count;
}
else
MessageBox.Show(String.Format("Transfer corupt
(2): \ndata.Length = {0}\ndata_count = {1}\noffset = {2}", data.Length, data_count,
offset));
99

}
else
MessageBox.Show(String.Format("Transfer corupt (1):
\ndata.Length = {0}\ndata_count = {1}\noffset = {2}", data.Length, data_count,
offset));
}
return ms;
}
public string BytesToList(byte[] data){
if (data != null && data.Length > 0){
StringBuilder str = new StringBuilder();
for (int i = 0; i < data.Length; i++){
str.AppendLine(data[i].ToString());
}
return str.ToString();
}
return string.Empty;
}
public Masuratoare BytesToMasuratoare(byte[] data, int offset){
Masuratoare m = new Masuratoare();
m.Timp = BytesToUShort(data, offset);
m.Valoare = BytesToShort(data, offset +
Marshal.SizeOf(m.Timp.GetType()));
return m;
}
public int BytesToInt(byte[] data, int offset){
int len = Marshal.SizeOf(typeof(int)); //4 bytes
IntPtr i = Marshal.AllocHGlobal(len);
Marshal.Copy(data, offset, i, len);
int val = (int)Marshal.PtrToStructure(i, typeof(int));
Marshal.FreeHGlobal(i);
return val;
}
public uint BytesToUInt(byte[] data, int offset){
int len = Marshal.SizeOf(typeof(uint)); //4 bytes
IntPtr i = Marshal.AllocHGlobal(len);
Marshal.Copy(data, offset, i, len);
uint val = (uint)Marshal.PtrToStructure(i, typeof(uint));
Marshal.FreeHGlobal(i);
return val;
}
public ushort BytesToUShort(byte[] data, int offset){
int len = Marshal.SizeOf(typeof(ushort)); //2 bytes
IntPtr i = Marshal.AllocHGlobal(len);
Marshal.Copy(data, offset, i, len);
ushort val = (ushort)Marshal.PtrToStructure(i, typeof(ushort));
Marshal.FreeHGlobal(i);
return val;
}
public short BytesToShort(byte[] data, int offset){
int len = Marshal.SizeOf(typeof(short)); //2 bytes
IntPtr i = Marshal.AllocHGlobal(len);
Marshal.Copy(data, offset, i, len);
short val = (short)Marshal.PtrToStructure(i, typeof(short));
Marshal.FreeHGlobal(i);
return val;
}
}
}
100

9.6 Anexa 6. Metoda 2. Modul de listare şi export date
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing; using
System.Data; using System.Text;
using System.Windows.Forms; using
System.IO; using NXT2PC;
namespace NXT2PC
{
public partial class SerieMasuratori : UserControl
{
public SerieMasuratori() {
InitializeComponent();
}
public Masuratoare[] Masuratori {
get {
return _Masuratori;
}
set {
if (value != null) {
int len = _Masuratori.Length;
Array.Resize(ref _Masuratori,
_Masuratori.Length + value.Length);
Array.Copy(value, 0, _Masuratori, len, value.Length);
Salvat = false;
}
}
}
private Masuratoare[] _Masuratori = new Masuratoare[0];
public string TitluSerie {
get {
return _TitluSerie;
}
set {
_TitluSerie = value;
groupBox1.Text = _TitluSerie;
groupBox1.Text += String.Format(" ({0})",
_Masuratori.Length);
groupBox1.Text += Salvat ? "" : " *";
}
}
private string _TitluSerie;
public bool Salvat {
get {
return _Salvat;
}
private set {
_Salvat = value;
TitluSerie = TitluSerie;
}
}
private bool _Salvat;
public void AfiseazaMasuratorile() {
if (Masuratori != null) {
textBox1.Text = "se incarca ...";
string txt = MasuratoriConcatenate();
101

textBox1.Text = "Timp\tValoare" + Environment.NewLine;
textBox1.AppendText("---------------" +
Environment.NewLine);
textBox1.AppendText(txt);
}
}
public string MasuratoriConcatenate() {
StringBuilder str = new StringBuilder();
if (Masuratori != null && Masuratori.Length > 0){
Masuratoare m;
string line;
for (int i = 0; i < Masuratori.Length; i++) {
m = Masuratori[i];
line = m.Timp.ToString() + "\t" +
m.Valoare.ToString();
str.AppendLine(line);
}
}
return str.ToString();
}
public void AfiseazaMasuratorile(Masuratoare[] ms) {
this.Masuratori = ms;
AfiseazaMasuratorile();
}
private void button1_Click(object sender, EventArgs e) {
SaveFileDialog FereastraSave = new SaveFileDialog();
FereastraSave.DefaultExt = "txt";
FereastraSave.Filter = "Tab delimited text file (*.txt)|*.txt|All files (*.*)|*.*";
FereastraSave.AddExtension = true;
FereastraSave.RestoreDirectory = true;
FereastraSave.Title = "Salveaza pe disk: " + this.TitluSerie;
FereastraSave.InitialDirectory =
System.Environment.GetEnvironmentVariable("desktop"); ;
if (FereastraSave.ShowDialog() == DialogResult.OK) {
string filepath = FereastraSave.FileName;
StreamWriter writer = new StreamWriter(filepath);
writer.Write(MasuratoriConcatenate());
writer.Close();
Salvat = true;
}
FereastraSave.Dispose();
FereastraSave = null;
}
}
}
9.7 Anexa 7. Metoda 2. Programul principal al aplicatiei
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data; using
System.Drawing; using
System.Text; using
System.Windows.Forms;
namespace NXT2PC
{
public partial class Form1 : Form
{
102

public Form1(){
InitializeComponent();
}
private ReceptorNXT nxt2pc = new ReceptorNXT();
private void button1_Click(object sender, EventArgs e){
if (nxt2pc.EsteConectat)
nxt2pc.Deconecteaza();
else {
nxt2pc.NumePort = comboBox1.Text;
nxt2pc.Conecteaza();
}
if (nxt2pc.EsteConectat){
button1.Text = "Deconecteaza";
button1.BackColor = Color.PaleGreen;
}
else {
button1.Text = "Conecteaza!";
button1.BackColor = Color.LimeGreen;
}
}
private void button2_Click(object sender, EventArgs e){
timer1.Interval = 1000;
timer1.Enabled = !timer1.Enabled;
if
(timer1.Enabled)
button2.Text = "Stop";
else
button2.Text = "Start!";
}
private void timer1_Tick(object sender, EventArgs e){
if (nxt2pc.EsteConectat){
nxt2pc.CitesteMasuratoriInSeriile(ref measurementSeries1, ref measurementSeries2);
}
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e){
if (nxt2pc.EsteConectat){
if
(MessageBox.Show("Aplicatia este conectata la robot.
Sigur doriti sa abandonati conexiunea?", "Conexiune activa", MessageBoxButtons.YesNo,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == DialogResult.No){
e.Cancel = true;
return;
}
timer1.Enabled = false;
nxt2pc.Deconecteaza();
}
}
}
}
103