Documente Academic
Documente Profesional
Documente Cultură
Nr. 1
Cuprins
Cuprins ............................................................................................................................................................... 2
1. INTRODUCERE ....................................................................................................................................... 3
2. Robot care urmeaz un traseu predefinit - Line Following Robot (LFR)................................................ 11
2.1 Senzori .............................................................................................................................................. 16
2.1.1 Senzor IR QRE1113 ................................................................................................................. 16
2.1.2 Senzor IR QTR-1RC, QTR-L-1RC, QTR-3RC, QTR-8RC ..................................................... 17
2.1.3 Senzor infrarou QRB1114 ...................................................................................................... 18
2.1.4 Senzor infrarou QRD1114 ...................................................................................................... 20
2.2 Logica algoritmului .......................................................................................................................... 23
2.3 Cod surs .......................................................................................................................................... 27
3. MODELARE PROGRAM LINE FOLLOWING ROBOT - SIMULINK .............................................. 31
4. CONSTRUIREA UNUI MODEL SIMPLU ........................................................................................... 34
5. EXPERIMENT - exemplificare............................................................................................................... 39
6. REZULTATE EXPERIMENTALE ........................................................................................................ 42
6.1 Line Following cu senzor IR ............................................................................................................ 42
6.2 Forma grafic a rezultatelor ............................................................................................................. 44
6.3 Interpretarea rezultatelor .................................................................................................................. 46
7. BIBLIOGRAFIE ..................................................................................................................................... 47
8. FIGURI .................................................................................................................................................... 48
9. ABREVIERI ............................................................................................................................................ 49
1. INTRODUCERE
Roboii mobili sunt roboii capabili s-i modifice poziia elementului de baz n raport cu un
sistem de referin considerat fix, legat de suprafaa de susinere.
Acest tip de roboi permit intervenia n diferite puncte ale mediului n care lucreaz, n acest
fel obinndu-se o considerabil mrire a spaiului de lucru ceea ce conduce la transformarea acestuia
ntr-un adevrat cmp de lucru.
n principiu, roboii mobili pot asigura evitarea sau chiar depirea obstacolelor de pe
suprafaa de susinere, deplasarea pe scri i alte suprafee artificiale precum i navigaia n preajma
sau peste denivelri majore ale acesteia, n mod independent.
Locomoia este deplasarea n care corpul, considerat ca un ntreg, se mic pe suprafee de
sprijin naturale sau artificiale. Deplasarea pe suprafee trebuie s ia n considerare reaciunile acestora.
Comportarea suprafeei de sprijin depinde n principal de forele aplicate asupra ei n cursul
locomoiei. Reaciunea exercitat de substratul de sprijin depinde de asemenea de forma precum i
de natura suprafeei. Suprafeele naturale sunt continue, prezint obstacole, denivelri, pante, guri,
etc. i pot fi ferme sau alunecoase, n timp ce suprafeele artificiale, dei de cele mai multe ori ferme,
pot prezenta discontinuiti.
Analiza global a problemei locomoiei pe suprafee conduce la identificarea a patru tipuri de
fore, printre acestea incluzndu-se i fora de propulsie:
propulsia fora de mpingere exercitat asupra substratului n direcia micrii;
adeziune fora care s permit ancorarea pentru faza de propulsie;
coeziunea fora care s permit rezistena mobilului fa de tendinele de detaare a
acestuia de substrat;
susinere fora care s compenseze tendina unor fore exterioare de prbuire a mobilului
pe suprafaa de sprijin.
Analiza condiiilor de mediu n care are loc locomoia mobilului are o importan deosebit,
deoarece acestea impun restricii de gabarit, structurale, cinematice i dinamice asupra acestora.
Pentru a realiza configurarea geometric a unui propulsor trebuie luat n calcul influena pe care o
au caracteristicile geometrice ale acestuia asupra:
mobilitii robotului pe terenuri cu configuraii i consistene diverse;
stabilitii robotului pe timpul deplasrii i pe timpul executrii misiunii specifice.
Pentru toate aceste situaii, interaciunea dintre robot i mediu se restrnge la interaciunea
dintre propulsorul i teren. Efectele terenului asupra robotului pot fi grupate n categoriile prezentate
n (Fig. 1-1). Configurarea platformei i a propulsorului trebuie s fie rezultatul studierii atente a
Modul de funcionare este de tipul bucl nchis. Este un model simplificat, dar reprezint
bazele sistemelor de astzi. Abordarea simplificat are avantajul c parametrii fizici pot fi reglai uor
pentru a obine comportamentul dinamic dorit. Controlerul funcioneaz ca un generator de micare.
Nu realizeaz reglri suplimentare, iar navigaia se efectueaz pe baza unor modele prestabilite, fr
ca acestea s fie modificabile.
Controlerul n cauz genereaz traiectorii sau funcioneaz pe principiul navigrii reactive.
Ecuaiile (1.1) care permit reglarea caracteristicilor de dinamicitate ale robotului sunt:
2bd2
(Izz + m s2 ) 2 m s v + = F (h s) sin
r
{ 2b
(1.1)
m v 2 + m s 2 + m g + r v = F cos
unde: F - modul de ; m - masa robotului; Izz - momentul de inerie n jurul axei verticale; b -
coeficientul de frecare vscoas; - coeficientul de frecare Coulomb.
Dup cteva simplificri legate de termenii neglijabili (s - se consider a fi nul sau destul de
mic), ecuaiile anterioare se vor transforma n ecuaii difereniale liniare, care pot fi exprimate ca o
ecuaie spaial de tipul: = + .
2b 1
mr 0 0
m F cos
x = [ 2bd 2 ] x + [ h][ ] (1.2)
0 0 I F sin
rIzz zz
Acest model de ecuaie diferenial de micare a unui robot mobil se datoreaz aciunii forei
. Modelul prezentat, aa cum am mai amintit are avantajul c ine cont i de constrngerile
cinematice dar i de cele dinamice. Se poate constata c modelul de referin poate determina analitic
poziia robotului: = ( , , , ) , valoare care este comparat cu poziia msurat: =
(, , , ) . ntotdeauna exist erori ntre valorile calculate i cele msurate. n cazul de fa eroarea
este notat cu ( ). Avnd introdus elementul de eroare pentru o aproximare ct mai bun, schema
de control se poate simplifica.
n ipoteza c robotul mobil are un sistem de control al vitezei ncorporat, acesta va ncerca s
controleze viteza robotului n baza ecuaiei: = ( , ) .
Aceast ecuaie este valabil doar dac:
viteza de reacie a controlerului este mult mai mare dect a ntregului sistem de control;
acceleraiile care pot fi impuse prin controller se regsesc n intervalul de accelerare al
robotului.
Cu alte cuvinte, funciile de transfer pentru vitezele controlate au valoarea 1. Modelul de
referin n sine poate fi folosit ca un controler n bucl direct. n acest caz, eroarea (, ), ntre
robotul de locaie () i locaia calculat ( ), este = 0, iar apoi sistemul de control final este cel
reprezentat n blocul cu dubl aliniere. Ecuaiile de micare utilizate de controler sunt obinute din
modelul:
= +
= (( , )) = ( cos , sin )
= (( , )) (1.3)
y yA
= = arctan xgoal x
{ goal A
Stabilitatea traiectoriei se bazeaz pe modele predictive liniare i neliniare ale dinamicii unui
vehicul terestru - MPC (Model Predictive Control), modele care se valideaz prin experimente:
algoritmi de orientare i navigare;
controlul robust al dinamicii robotului Following Line Robot;
realizarea unui model virtual pentru controlul orientrii acestuia;
implementarea unui NLMPC (Model Predictiv de Control Neliniar);
implementarea unui LTV-MPC (Model Predictiv de Control Liniar);
validarea modelului prin obinerea de rezultate experimentale.
= [] (1.7)
Pentru a scoate n eviden existena forei de rezisten la rulare, trebuie studiat echilibrul
roii motoare (Fig. 1-9), aplicnd metoda izolrii corpurilor. Astfel, n articulaia de legtur cu puntea
asupra roii acioneaz dou fore perpendiculare: -G greutatea repartizat pe roat; F fora cu care
puntea mpinge roata. Ca urmare a aciunii acestor fore n suprafaa de contact a roii cu calea de
rulare, apar reaciunile drumului asupra roii: -Zr reaciunea normal; -X reaciunea tangenial.
Contactul dintre roat i cale se face pe lungimea l, iar fora Zr este rezultanta forelor de presiune
dintre anvelop i cale.
Ecuaiile de echilibru de fore i momente ale roii motoare, la deplasarea robotului 6x6 cu
vitez uniform, sunt:
FX 0
FY 0 (1.8)
Mo 0
Relaia (3.20) este echivalent cu:
X Ft 0
Z r Gr 0 (1.9)
X r Z a M 0
d r R
Din (1.9) se poate determina expresia forei Rr, numit rezisten la rulare, care apare la roat
i care se opune naintrii sale:
a
F X Zr f Z r Rr [N] (1.10)
rD
n mod convenional se definete fora la roat FR fora rezultant a eforturilor de frecare dintre
pneu i calea de rulare, care ar produce asupra roii acelai efect pe care-l produce momentul la roat
MR, adic:
MR
FR [N] (1.11)
rd
Din analiza relaiilor (1.10) i (1.11) se ajunge la expresia:
Ft FR f Gr FR Rr [N] (1.12)
Putem concluziona c fora de traciune Ft , cu care roata motoare mpinge puntea robotului,
este dat de diferena dintre fora la roat FR , generat de momentul la roat MR i rezistena la rulare
Rr proprie roii motoare.
MPC reprezint modele predictive de control on-line (Fig. 1-10). Acestea din cauza
controlului optimal care trebuie aplicat n fiecare moment, limiteaz aplicabilitatea, astfel nct se
produc ncetiniri ale calculelor privind dinamica robotului.
Prin urmare teoria controlului optimal a condus la urmtorul algoritm de NLMPC:
funcia obiectiv sau cost;
funcia de optimizare;
dinamica vehiculului neliniar;
constrngeri iniiale;
varianta constrngerilor iniiale.
Dup cum se poate constata controlerul NLMPC trebuie s poat rezolva simultan
urmtoarele:
probleme de optimizare non-liniare;
s rezolve neliniaritile din cadrul operaiilor de optimizare;
s posede o putere mare de calcul;
s poat compara rezultatele analitice cu cele obinute pe cale experimental pentru validarea;
s funcioneze stabil.
2 1 2
((), ) = =1 +, +, + =1 +,
min ( , )
+1, = , (, , , )
|, = (, )
(1.13)
, = ()
| =
, +1, + ,
= , , +
, , ,
{, , , : = , , ( + 1)
n principiu modelul prezentat trebuie s rezolve aproximativ 83 de ecuaii difereniale.
Teoria conform creia stabilitatea unui sistem neliniar presupune o abordare robust, n care
numrul de iteraii ales s fie optim, astfel nct secvena de eantionare s acopere ct mai mult din
rezultatele reale. Pentru un sistem MIMO foarte rapid:
NLMPC nu se poate implementa cu metodologiile/tehnologiile actuale;
MPC liniare nu sunt stabile;
modelul empiric PWA d soluii aproximative ().
LFR este un sistem robotizat autonom, care are drept scop s urmeze o cale vizibil, ntr-un
spectru de culoare. Cele mai frecvente soluii utilizeaz o linie neagr trasat pe o suprafa alb.
Cnd folosim noiunea de culoare neagr trebuie s amintim de corpul negru, care msoar
cldura i dinamica acesteia (termodinamica). Energia degajat de corpurile negre este produs de
radiaia electromagnetic. Conform legii lui Max Planck distribuia spectral a energiei radiate de un
corp negru este dat de:
= ( ) , 2.1
2
unde: distribuia spectral a energiei; h constanta lui Plank = 6.626068 1034 [ ]; c
viteza de propagare a undelor electromagnetice n vid = 300000 [ ]; lungimea de und
[]; k constanta lui Boltzmann, T temperatura [].
De aceea lumina ambiental la o scanare simpl, n funcie de nivelul de vibraii al suportului dar i
al mediului (aer spre exemplu), are citiri diferite. Msurarea este un capitol aparte.
Similitudinea i segmentarea imaginilor se realizeaz prin nivelul de calibrare al senzorilor
respectivi. Robotul va efectua sarcinile n funcie de capacitatea acestor senzori, dar i n funcie de
timpul de reacie (viteza de analiz a controlerelor). Urmrirea unei linii albe/negre pe un fond
negru/alb presupune calibrarea fotorezistorului la valorile analogice de 95 pentru podea gri, 112
pentru o linie de culoare alb, iar valoarea de adevr, c robotul se afl pe linie este de 108.
(95+112)
Segmentarea imaginii (thresholding) se realizeaz prin media aritmetic a celor dou valori: ,
2
care va decela informaia legat de linia alb pe o podea gri. n cazul c terenul de lucru conine mai
multe culori, pragul se va stabili prin metoda similitudinii:
abs(new_reading - calibrating_reading)/calibrated_reading * 100 = similarity
now using our numbers:
grey floor = (108 - 95)/95 * 100 = 13.7% different
white line = (108 - 112)/112 * 100= 3.6% different
compare: white line < grey floor
therefore the sensor sees a white line
Senzorii sunt limitai de intensitatea cu care lumineaz LED-ul, respectiv de ordinul [cm].
Acest inconvenient se poate diminua prin utilizarea unui laser (vezi semnalul telecomenzilor TV).
Alimentarea unui led la o tensiune mai mare poate conduce la o intensitate a luminii mai mare, cu
riscul de a arde led-ul. Dar dac secvena de alimentare ca puls de tensiune se poate gestiona de ctre
controler, n funcie de capacitatea de rcire a led-ului, atunci putem crete capacitatea de aciune a
robotului.
LFR este util pentru c permite folosirea unui mecanism de feedback simplu de tip bucl
nchis. Astfel, programul introdus n controler rspunde la stimulii exteriori prin intermediul unor
senzori. Este un preconcept de roboi ce pot fi utilizai n hale industriale, magazine, depozite etc.
Este un robot din clasa roboilor paraleli ce poate fi autonom dar care poate controlat prin
intermediul unui joystick sau direct din calculator n regim wireless. Clasificarea n cadrul roboilor
paraleli este dat de modul de conectare a senzorilor la pinii de date.
numrul de senzori;
anten Inverted VEE antene orizontale, cu dipol inversat pentru orientare n
spaii nguste;
modul de transmitere a informaiilor: analog sau digital;
PROCESS: MPU/CPU urmeaz s decid cum trebuie modificat turaia motoarelor astfel nct
LFR s i poat modifica direcia i viteza de deplasare, concomitent cu rmnerea
pe linia neagr.
Ce procesor se utilizeaz (PIC18F8680), limbajul de programare (asamblare) C++.
OUTPUT: transmite noile semnale de control n funcie de vitez i direcie, conine informaii
despre motoarele DC, sursa de alimentare tensiune/curent, numrul de roi (de regul
dou), rola de alunecare, tipul de PID pentru controlul direciei.
STORAGE: programul i datele prelevate de senzori, viteza de deplasare, direcie de mers etc.
trebuie stocate, pentru a putea relua procedurile de luare a deciziilor, fa de o referin
fix i una variabil.
ALGORITM:
1. L = senzor care citete 0 pentru lateral stnga; R = senzor care citete 0 pentru lateral dreapta.
Dac nu exist un senzor L/R este 0, atunci L/R sunt egale cu 0.
L4 L3 L2 L1 R1 R2 R3 R4
1 0 0 1 1 1 1 1
Stnga Centru Dreapta
L=3 R=0
L4 L3 L2 L1 R1 R2 R3 R4
1 1 0 0 0 0 0 0
Stnga Centru Dreapta
L=2 R=4
4. Goto step 1
2.1 Senzori
Senzorii de reflectani IR1 pentru detecia caracteristicilor cu privire la suprafaa de sub Line
Follower, funcioneaz prin emiterea unui fascicul de lumin n infrarou (IR) n jos spre suprafaa
podelei i msurarea semnalului reflectat. Senzorul IR este constituit din dou elemente de lucru: un
emitor (Transmiter IR LED) i un receptor (Receive IR Detector) (Fig. 2-9).
Senzorii IR (model QRE1113) funcioneaz cel mai bine atunci cnd sunt aproape de
suprafaa de contact, distana optim fiind de aproximativ 3,175 [].
#include <RedBot.h>
RedBotSensor IRSensor1 = RedBotSensor(A3); // initialize a sensor object on A3
RedBotSensor IRSensor2 = RedBotSensor(A6); // initialize a sensor object on A6
RedBotSensor IRSensor3 = RedBotSensor(A7); // initialize a sensor object on A7
void setup()
{
Serial.begin(9600);
Serial.println("Welcome to experiment 6!");
Serial.println("------------------------");
}
void loop()
{
Serial.print("IR Sensor Readings: ");
Serial.print(IRSensor1.read());
Serial.print("\t"); // tab character
Serial.print(IRSensor2.read());
Serial.print("\t"); // tab character
Serial.print(IRSensor3.read());
Serial.println();
delay(100);
}
1
https://learn.sparkfun.com/tutorials/sparkfun-inventors-kit-for-redbot/experiment-6-line-following-
with-ir-sensors
Senzorul IR acioneaz prin transmiterea unui fascicul de lumin IR n jos spre suprafa. n
cazul n care detectorul este de peste o suprafa alb, lumina reflectat este recepionat de detector
i emite un semnal LOW. Cnd senzorul este pe o suprafa neagr n care lumina este absorbit sau
nu reflectat, detectorul IR emite un semnal HIGH. Senzorul IR furnizeaz o valoare analogic
01023 invers dependent de cantitatea de lumin reflectat IR. Valorile analogice citite n mediul
Arduino variaz 01023, deoarece Arduino utilizeaz Converter analog digital (ADC) pe 10 [bit],
vom citi urmtoarele: 0 pentru 0 [V] i 1023 pentru 5 [V].
Configurare cu Arduino setup(), implic utilizarea comenzii: Serial.begin (9600); 9600 se
refer la o rat de transfer sau numrul de bii pe secund [bps]. 9600 este o rat bun de date
moderat pentru majoritatea aplicaiilor. Cu toate acestea, alte viteze, inclusiv: 300, 1200, 2400, 4800,
9600, 14400, 19200, 28800, 38400, 57600 i 115200 sunt suportate de placa de dezvoltare Arduino.
= [] , 2.2
Funcionarea acestui senzor pentru detecia liniei de urmat este n principiu urmtoarea:
urmeaz o linie dreapt;
urmeaz o linie dreapt i se rotete la stnga sau la dreapta;
urmeaz un labirint trasat cu band izolatoare de culoare neagr.
Senzorii IR QTR-3RC, QTR-1RC, QTR-L-1RC, QTR-8RC sunt senzori de reflexie tip matrice de
senzori, concepui ca un senzor de linie. Modulul este realizat ca un suport bloc, att pentru emitor
ct i receptor (fototranzistor) n perechi de IR egal distanate la intervale de 0.375" (9.525 mm).
Pentru a utiliza un senzor, trebuie aplicat o tensiune la pinul OUT. Citirea datelor indic timpul de
reflexie, care poate fi mai mare sau mai mic n funcie de tensiunea de ieire. Acest lucru este necesar
pentru a putea regla reacia robotului, astfel nct, corelarea cu viteza motoarelor s permit
parcurgerea traseului i apoi reducerea timpului pn la ncheierea cursei. Multiplicarea numrului
de senzori IR QTR de la 1 la 8 va asigura un consum mai redus de energie, att pentru consumul
aferent IR, dar mai ales pentru cel al motoarelor, ntruct timpul de reglare stnga-dreapta fa de
linie se reduce. Citirea simultan a unui numr ct mai mare de senzori este permis de plcile
Arduino, n comparaie cu driverele obinuite care erau integrate pe o plac ATmega128RFA12.
Plcile Arduino nu mai necesit convertoare analog digitale (ADC), au o sensibilitate mrit fa de
citirea analogic i poate citi n paralel toi senzorii care sunt implementai pe robot.
Ieirile de pe IR QTR sunt independente, iar LED-urile sunt perechi pentru a reduce consumul
de energie. LED-urile sunt controlate de un MOSFET. Oprirea alimentrii LED-urile este
avantajoas, mai ales pe timpul ct acestea nu funcioneaz.
2
https://www.robofun.ro/platforme/avr/ATmega128RFA1
Tensiunea de alimentare este limitat la5 [V], pentru a permite funcionarea la 3.3 [V] i un
curent de aproximativ 20 25 [mA].
Pentru acest proiect vom monitoriza cantitatea de 5v a revenit la una dintre intrri analogice Arduino
lui. Vom utiliza mai degrab analogic apoi digital, deoarece digitale este fie pornit sau oprit, i
analogic este o scara de alunecare. Senzorii raporteaz o valoare 0-1024 (pentru 5v). Noi calibra codul
astfel nct s tim c = alb i negru X = X. De exemplu, atunci cnd senzorul este pe o suprafa alb
senzor primete o valoare de 500 de la senzor. O suprafa neagr poate raporta 100.
Se folosesc regulile urmtoare: X <300 = linia neagr, X > 300 = suprafa alb
Pentru acurateea informaiei se utilizeaz minim 2 senzori, astfel nct linia s fie permanent
aflat ntre emisiile celor doi senzori.
Codul de calibrare de configurare pentru Arduino, cu valori ideale n cazul utilizrii unei linii de
culoare neagr. Dac totul este conectat corect trebuie s avem:
Stnga: XXX
Dreapta: XXX
Se poziioneaz partea din fa a robotului pe o suprafa de lumin clar / alb i ateptm repetarea
informaiei reflectate. Apoi se mut senzorii de pe linia neagr, din nou se ateapt o secund i apoi
se nregistreaz numrul care apare pe monitor. Al doilea set de numere trebuie s fie mai mare dect
primul set de numere.
// Bot builder BoxBot line follower code for the Photoreflector sensor bar calibration.
int LeftOpto = 0; // Create a variable called LeftOpto on analog pin 0 so we can read the value of the Left Photosensor.
int RightOpto = 1; // Create a variable called RightOpto on analog Pin 1 so we can read the value of the Right Photosensor.
int lval = 0; // Initialise a variable called lval, this is used to store the Left sensors value, set it to 0.
int rval = 0; // Initialise a variable called rval, this is used to store the Left sensors value, set it to 0.
void setup() {
Serial.begin(9600); // Start the serial service @ 9600 baud rate.
}
void loop() {
lval = analogRead(LeftOpto); // Read the value incoming from the photoreflector on pin 0 and assign it to the variable lval.
Serial.print("Left");
Serial.println(lval); // Print to the serial port the lval value so you can see what it is.
rval = analogRead(RightOpto); // Read the value incoming from the photoreflector on pin 1 and assign it to the variable rval.
Serial.print("Right:");
Serial.println(rval); // Print to the serial port the rval value so you can see what it is.
}
delay(1000); // Delay 1 second on each read so you have a chance to see the value.
}
int LeftOpto = 0; // Create a variable called LeftOpto on analog pin 0 so we can read the value of the Left Photosensor.
int RightOpto = 1; // Create a variable called RightOpto on analog Pin 1 so we can read the value of the Right Photosensor.
int TurnLED = 13; // We need to declare that we are using pin 13 for our turn indicator LED.
int lval = 0; // Initialise a variable called lval, this is used to store the Left sensors value, set it to 0.
int rval = 0; // Initialise a variable called rval, this is used to store the Left sensors value, set it to 0.
#include <Servo.h> // Include the servo library, so we can easily use servos.
Servo LeftServo; // Tell the library that we want to create a servo called LeftServo.
Servo RightServo; // Tell the library that we want to create a servo called RightServo.
void setup() {
pinMode(TurnLED, OUTPUT); // Set the turn LED pin to be an output (so we can turn it on and off).
LeftServo.attach(9); // Tell the servo object to attach the LeftServo to Pin 9.
RightServo.attach(10); // Tell the servo object to attach the LeftServo to Pin 10.
}
void loop() {
lval = analogRead(LeftOpto); // Read the value incoming from the photoreflector on pin 0 and assign it to the variable lval.
if (lval > 550) { // If lval is greater that the threshold of what we determined the black line is - ie. we are on white.
digitalWrite(TurnLED, HIGH); // Turn on the Turn LED on pin 13.
LeftServo.write(90); // Stop the left servo by centering it.
} else {
digitalWrite(TurnLED, LOW); // Turn off the turn LED on pin 13.
LeftServo.write(120); // Drive the left servo forward.
}
rval = analogRead(RightOpto); // Read the value incoming from the photoreflector on pin 1 and assign it to the variable rval.
if (rval > 550) { // If rval is greater that the threshold of what we determined the black line is - ie. we are on white.
digitalWrite(TurnLED, HIGH); // Turn on the Turn LED on pin 13.
RightServo.write(90); // Stop the right servo by centering it.
} else {
digitalWrite(TurnLED, LOW); // Turn off the turn LED on pin 13.
RightServo.write(50); // Drive the right servo in reverse (makes the bot go forward, as the servos are inverted).
}
delay(200); // Delay 200 microseconds, just to smooth out any jerky movements.
}
3
http://bildr.org/2011/03/various-proximity-sensors-arduino/
Att semnalul incident (de la emitor) ct i cel detectat (de fototranzistor) sunt
perpendiculare pe faa senzorului. QRD11144 este capabil s sesizeze obiecte aflate la o distan
cuprins ntre 0 30 [] , iar pe Arduino vom citi valori cuprinse ntre 600 1024 . Pentru o
funcionare corect sunt necesare adugarea unor rezistene (Fig. 2-16) de 200 2000 [] i 4,7
5,6 [k] .
4
http://www.robotshop.com/letsmakerobots/hooking-qrd1114-line-sensor
ntruct suprafeele albe reflect mai mult lumin dect cele negre, este posibil ca n funcie
de alte surse externe de lumin (flash aparat fotografiat, lmpi, lumina solar etc.) s obinem rezultate
false.
Logica acestui algoritm are urmtoarea reprezentare grafic5 a prii din fa a liniei urmtoare
bot pentru referin.
Fig. 2-18 Reprezentarea schemei logice de funcionare a unui Line Follower Robot
*/
#include <SoftPWMServo.h>
//Here we set up variable that will hold the ADC value representing the line sensor values
int leftSees = 0; //A2 ADC value (0 to 1023)
int rightSees = 0; //A3 ADC value (0 to 1023)
void setup()
{
5
http://chipkit.net/arduino-mc-line-follower/
6 http://www.chipkit.org/wiki/index.php?title=Library_Status#SoftPWMServo_library
pinMode(leftDIR, OUTPUT);
pinMode(rightDIR, OUTPUT);
pinMode(leftBrake, OUTPUT);
pinMode(rightBrake, OUTPUT);
void loop()
{
//Start by reading the left sensor on A2
int leftEye = analogRead(irLeft);
//If both sensors see black (ADC value greater than 1000), then back up
if ((leftEye >= 1000)&&(rightEye >= 1000)) reverse();
//Otherwise, if only the left sensor sees black, then turn off the left motor
//so the robot veer to the left
else if ((leftEye >= 1000)&&(rightEye < 1000)) turnLeft();
//Otherwise, if only the right sensor sees black, then turn off the right motor
//so the robot veer to the right
else if ((leftEye < 1000)&&(rightEye >= 1000)) turnRight();
digitalWrite(leftDIR, HIGH);
digitalWrite(rightDIR, HIGH);
SoftPWMServoPWMWrite(leftPWM, bothSpeed);
SoftPWMServoPWMWrite(rightPWM, bothSpeed);
}
Un exemplu foarte rspndit este acela care utilizeaz cip-ul Atmel AT89C517 pe 8 bii cu
4kB de memorie Flash programabil. Acesta ofer o soluie flexibil pentru aplicaiile de embedded
control. n exemplul nostru robotul urmrete o linie neagr folosind senzori IR.
7
http://embedded-electronics.blogspot.ro/p/at89c51-programming.html
/*****************************************************
Project : http://files.spogel.com/miniprojectsin-ece/p-0026--line_follower_robot.pdf
*****************************************************/
//#define debug 1
#include <mega16.h>
#include <delay.h>
#ifdef debug
#include <stdio.h>
#endif
#define
FWD 0xAA
#define REV 0x55
#define R 0x22
#define L 0x88
#define CW 0x99
#define CCW 0x66
#define STOP 0x00
#define B 0xFF
#define RSPEED OCR1AL
#define LSPEED OCR1BL
#define SPEED0 255
#define SPEED1 0
#define SPEED2 0
#define SPEED3 0
#define MAX 3
#define HMAX 1
#ifdef debug
unsigned char rep=0,prev=0;
#endif
void
main(void)
{
// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTB=0x00;
DDRB=0x00;
// Port C initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTC=0x00;
DDRC=0xFF;
// Port D initialization
// Func7=In Func6=In Func5=Out Func4=Out Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=0 State4=0 State3=T State2=T State1=T State0=T
PORTD=0x00;
DDRD=0x30;
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=FFh
// OC0 output: Disconnected
TCCR0=0x00;
TCNT0=0x00;
OCR0=0x00;
// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 921.600 kHz
// Mode: Fast PWM top=00FFh
// OC1A output: Non-Inv.
// OC1B output: Non-Inv.
// Noise Canceler: Off
// Input Capture on Falling Edge
TCCR1A=0xA1;
TCCR1B=0x0A;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0xFF;
OCR1BH=0x00;
OCR1BL=0xFF;
// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;
#ifdef debug
// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud rate: 57600
UCSRA=0x00;
UCSRB=0x18;
UCSRC=0x86;
UBRRH=0x00;
UBRRL=0x07;
#endif
while (1){
#ifdef debug
if(rep<255)
rep++;
if(prev!=PINA) {
prev=PINA;
printf("%u\r",rep);
for(i=0;i<8;i++)
printf("%u\t",(prev>>i)&0x01);
rep=0;
}
#endif
if
(PINA!=255){
rotpow=255;
ldev=rdev=0;
if(PINA.3==0)
rdev=1;
if(PINA.2==0)
rdev=2;
if(PINA.1==0)
rdev=3;
if(PINA.0==0)
rdev=4;
if(PINA.4==0)
ldev=1;
if(PINA.5==0)
ldev=2;
if(PINA.6==0)
ldev=3;
if(PINA.7==0)
ldev=4;
if(rdev>ldev)
move(R,0,195+12*rdev);
if(rdev<ldev)
move(L,0,195+12*ldev);
if(rdev==ldev)
move(FWD,0,200);
}
else {
for(i=0,dirl=0;i<MAX;i++) {
if(history[i]==L)
{dirl++;}
}
if(rotpow<160) {rotpow=160;}
if(rotpow<255) {rotpow++;}
if(dirl>HMAX)
{move(CW,0,rotpow);}
else
{move(CCW,0,rotpow);}
}
};
}
Modelul accept viteza V i unghiul de rotire , ca variabile pentru cele dou intrri
privind roata din stnga i cea din dreapta. Subsistemul care se ocup cu conversia celor dou mrimi
de intrare V i , implementeaz sistemul de relaii matematice (3.1):
_ = /2
{ . 3.2
_ = + /2
8
https://learn.adafruit.com/line-following-zumo-robot-programmed-with-simulink?view=all
ntruct parametri descrii mai sus difer de la Robot la Robot, valorile implicite cu care sunt
livrate kit-urile de roboi de linie este bine s fie ajustate de fiecare dat.
Utilizarea contrastului dintre o linie neagr i un teren alb este benefic, ntruct lina de culoare
neagr reflect mai puin lumin dect culoarea alb. Cei 6 senzori (n funcie de tipul de robot)
permit determinarea poziiei robotului fa de linia neagr. Senzorii ntorc o valoare cuprins ntre
{0 5000} ().
Fig. 3-4 Poziia relativ a robotului detectat de senzorii de linie, fa de o linie de culoare neagr
Se consider valoarea de 2.500 ca fiind reprezentarea poziiei LFR fa de linia neagr. Orice
valoare mai mic sau mai mare dect 2.500 reflect poziiei LFR n stnga , respectiv dreapta liniei
negre. Diferenele dintre valoarea de referin i cele reale se numesc erori, sau semnale de eroare.
Semnalul de eroare odat determinat (prin nsumarea la valoarea de 2.500), putem trece la
repoziionarea LFR.
https://www.youtube.com/watch?v=EF8ds1fm7x8
https://www.youtube.com/watch?v=KgjF3KVV_X0
https://www.pololu.com/product/961
Construirea unui LFR cu ajutorul controlerelor ALU (Arithmetic Logic Unit) este foarte
facil, deoarece acesta poate efectua calcule matematice ce se regsesc n PID. n acest caz se vor
aplica standardele PID cu parametri de reglaj flexibili folosind AVR ATMega periferic i cu stocarea
informaiilor pe EEPROM de 521 Bytes.
Aceste soluii de BRAM (Beginners Robot Autonomous Mobile - roboi mobili autonomi
pentru iniiere) cu un control proporional, integral i derivat (PID) este de fapt doar una dintre
metodele de control care pot fi aplicate sistemului embedded. Cealalt metod de control include
teoria bang-bang9 i logica fuzzy, de asemenea, utilizat pe scar larg n sistemele ncorporate.
Fig. 4-4 Reprezentarea schemei funcionale a unui PID pentru LFR cu senzori QRB1114.
http://www.ermicro.com/blog/?p=1163
9
Un controller bang-bang (controler on-off), cunoscut ca un controler de histerezis, este un controler de feedback care
comut brusc ntre cele dou stri. Aceste controlere pot fi realizate n ceea ce privete orice element care ofer histerezis
. Funcia pas Heaviside n forma sa discret este un exemplu de un semnal de control bang-bang. Datorit
semnalului de control discontinuu, sisteme care includ controllere bang-bang sunt sisteme de structur variabil.
n cazul n care rspunsul este 0 nseamn c ar robotul se poate deplasa cu viteza maxim,
astfel nct am putea apela funcia BRAM_DriveMotor () dup cum urmeaz:
BRAM DriveMotor(Left Max PWM, Right Max PWM. 4.4
Rspunsul negativ nseamn c trebuie s se ntoarc sau s efectueze un arc de cerc spre
stnga pentru a face corecia, acest lucru ar putea fi realizat prin reducerea valorii PWM a motorului
din stnga, n timp ce pstreaz valoarea PWM a motorului din dreapta la valoarea maxim:
BRAM DriveMotor(Left Max PWM + RESPONSE, Right Max PWM. 4.6
Rspunsul pozitiv nseamn c trebuie s se ntoarc sau s efectueze un arc de cerc spre
dreapta pentru a face corecia, acest lucru ar putea fi realizat prin reducerea valorii PWM a motorului
din dreapta, n timp ce pstreaz valoarea PWM a motorului din dstnga la valoarea maxim:
BRAM DriveMotor(Left Max PWM, Right Max PWM RESPONSE. 4.8
Valoarea constantei Kp ar putea fi orice numr care va spori valoarea de rspuns, ca urmare
este partea de cod C a funciei BRAM_PIDControl () care implementeaz urmtoarea explicaie:
...
...
// Negative result mean BRAM is on the right, so we need to adjust to the left
// Positive result mean BRAM is on the left, so we need to adjust to the right
if (motor_res < 0)
BRAM_DriveMotor(MaxSpeed + motor_res,MaxSpeed); // Left less speed, Right full speed
else
BRAM_DriveMotor(MaxSpeed,MaxSpeed - motor_res); // Left full speed, Right less speed
Control integral este utilizat pentru a reduce eroarea acumulat produs de controlul
proporional asupra timpului eroare a strii de echilibru, altfel spus, dac robotul produce o eroare
fa de centrul liniei negre, atunci cu aceeai valoare se modific rspunsul de ieire dat de control
integrat.
Control derivat este utilizat pentru a accelera rspunsul de eroare al control proporional,
deoarece un robot mai rapid produce sigur erori, cum ar fi micarea n zigzag ceea ce impune un
rspuns dat de control derivat pentru valoarea de ieire. Funcia de control derivat va ajuta la
reducerea comportamentului de deplasare n zigzag a robotului.
PID utilizeaz ca metod de rezolvare a ecuaiei (4.9) regula trapezoidal10:
( + )
= 1 + ( 1 ) + 21 + ( 21 + 2 ) 4.10
int motor_res,err_func;
float KP,KI,KD,cont_res;
// Get the Error Function
err_func=sensor_val - TARGET_VAL;
// Divide all the PID parameters for decimal value
KP=Kp * 0.1;
KI=Ki * 0.01;
KD=Kd * 0.01;
// Calculate the Motor Response using PID Control Equation
cont_res=(float)(prev_res + KP * (err_func - prev_err_1) + KI * (err_func + prev_err_1)/2.0
+ KD * (err_func - 2.0 * prev_err_1 + prev_err_2));
// Now we have to Limit the control response to the Maximum of our motor PWM Motor Value
motor_res=(int)cont_res;
if (motor_res > MaxSpeed)
motor_res = MaxSpeed;
if (motor_res < -MaxSpeed)
motor_res = -MaxSpeed;
// Save the Motor Response and Error Function Result
prev_res=motor_res;
prev_err_2=prev_err_1;
prev_err_1=err_func;
Dup ce programul este rulat se poate regla parametrul de control PID, prin modulul de setare
BRAM II i conectarea ATMega la portul RS232 pentru a salva programul pe computer
10
http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.474.8129&rep=rep1&type=pdf , pg. 56
5. EXPERIMENT - exemplificare
https://www.instructables.com/id/Line-following-robot-with-PID-algorithm/
#include <QTRSensors.h>
void calculateIntegral();
void calculateProportional();
void readValues();
#define NUM_SENSORS 8
#define TIMEOUT 2500
#define EMITTER_PIN 0
#define avgSpeed 255
int time = 0;
int pwmA = 3;
int pwmB = 11;
int dirA = 12;
int dirB = 13;
int kp = 1;
int kd = 1;
int ki = 1;
int error = 0;
int lastError = 0;
int proportional = 0;
int derivative = 0;
int integral = 0;
void setup(){
Serial.begin(9600);
pinMode(pwmA, OUTPUT);
pinMode(pwmB, OUTPUT);
pinMode(dirA, OUTPUT);
pinMode(dirB, OUTPUT);
pinMode(1, OUTPUT);
for (int i=0; i<5; i++){
digitalWrite(1, HIGH);
delay(50);
digitalWrite(1, LOW);
delay(950);
}
analogWrite(pwmA, avgSpeed);
analogWrite(pwmB, avgSpeed);
void loop(){
readValues();
calculateProportional();
derivative = error-lastError;
integral += proportional;
if(turn>=255)
turn=255;
if(turn<=-255)
turn=-255;
int speedA=0;
int speedB=0;
if(turn>=0){
speedA=avgSpeed;
speedB=avgSpeed-turn;
}
else{
speedA=avgSpeed+turn;
speedB=avgSpeed;
}
Serial.print("P=");
Serial.print(proportional);
Serial.print('\t');
Serial.print("I=");
Serial.print(integral);
Serial.print('\t');
Serial.print("D=");
Serial.print(derivative);
Serial.print('\t');
Serial.print("Turn=");
Serial.print(turn);
Serial.print('\t');
Serial.print("speedA=");
Serial.print(speedA);
Serial.print('\t');
Serial.print("speedB=");
Serial.print(speedB);
Serial.print('\t');
analogWrite(pwmA, speedA);
analogWrite(pwmB, speedB);
lastError=error;
Serial.println();
}
void readValues(){
qtrrc.read(sensorValues);
for (int i=0; i<NUM_SENSORS; i++){
// Serial.print(sensorValues[i]);
// Serial.print('\t');
if(sensorValues[i]>400)
sensorValues[i]=1;
else
sensorValues[i]=0;
}
}
void calculateProportional(){
int sum = 0;
int posLeft = 10;
int posRight = 10;
if(sum>=3){
sum=2;
}
if(sum==0){
if(lastError<0){
error=-8;
}
else{
error=8;
}
}
else if((posLeft!=10)&&(posRight!=10)){
error=0;
}
else if(posLeft!=10){
error=posLeft*2+sum;
}
else if(posRight!=10){
error=posRight*2-sum;
}
proportional = error;
6. REZULTATE EXPERIMENTALE
#include <RedBot.h>
RedBotSensor left = RedBotSensor(A3); // initialize a left sensor object on A3
RedBotSensor center = RedBotSensor(A6); // initialize a center sensor object on A6
RedBotSensor right = RedBotSensor(A7); // initialize a right sensor object on A7
// constants that are used in the code. LINETHRESHOLD is the level to detect
// if the sensor is on the line or not. If the sensor value is greater than this
// the sensor is above a DARK line.
//
// SPEED sets the nominal speed
RedBotMotors motors;
int leftSpeed; // variable used to store the leftMotor speed
int rightSpeed; // variable used to store the rightMotor speed
void setup()
{
Serial.begin(9600);
Serial.println("Welcome to experiment 6.2 - Line Following");
Serial.println("------------------------------------------");
delay(2000);
Serial.println("IR Sensor Readings: ");
delay(500);
}
void loop()
{
Serial.print(left.read());
Serial.print("\t"); // tab character
Serial.print(center.read());
Serial.print("\t"); // tab character
Serial.print(right.read());
Serial.println();
// if on the line drive left and right at the same speed (left is CCW / right is CW)
if(center.read() > LINETHRESHOLD)
{
leftSpeed = -SPEED;
rightSpeed = SPEED;
}
// if the line is under the right sensor, adjust relative speeds to turn to the right
else if(right.read() > LINETHRESHOLD)
{
leftSpeed = -(SPEED + 50);
rightSpeed = SPEED - 50;
}
// if the line is under the left sensor, adjust relative speeds to turn to the left
else if(left.read() > LINETHRESHOLD)
{
leftSpeed = -(SPEED - 50);
rightSpeed = SPEED + 50;
}
}
delay(0); // add a delay to decrease sensitivity.
}
Pentru studiul din materialul de fa s-au utilizat cele mai simple modele funcionale de LFR.
Programul cel mai simplu presupune ca robotul s se ntoarc mereu la centrul liniei negre de pe
podea. n funcie de constanta de proporionalitate, suma, cu care robotul transform pentru o anumit
valoare a semnalului de eroare, va fi variabil. Aceast constant de proporionalitate P este un
parametru al modelului, care trebuie s fie reglat n funcie de cerinele beneficiarului.
Limitrile acestui tip de PID sunt date de constrngerile de a sta pe centrul liniei negre.
Acestea introduc n sistem oscilaii datorate ineriei. Aceasta este explicaia faptului c LFR oscileaz
n mod continuu n jurul axului liniei negre. Componenta derivativ a PID-ului ajut la amortizarea
oscilaiilor. n acest caz, vom calcula derivata instantanee a semnalului de eroare care ar servi pentru
a amortiza oscilaiile. Astfel, constanta este multiplicat cu rezultatul derivrii i produsul este
adugat la semnalul de control. Aceast constant este cunoscut sub numele de ctig derivat i
corespunde componentei D a controlerului PID.
Fig. 6-3 Funcia bloc din toolbox-ul Simulink pentru un controler PID.
7. BIBLIOGRAFIE
8. FIGURI
9. ABREVIERI
ADC Analog-Digital-Convertor
bps Numrul de bii pe secund viteza de transfer date
BRAM Beginners Robot Autonomous Mobile
CPU Central Processor Unit
DC Motor de curent continuu
EO Electro-optic
IR Infrarou
LED Light-Emitting Diode
LFR Line Following Robot
LTV-MPC Model Predictiv de Control Liniar
MIMO Multiple-Input and Multiple-Output
MOSFET MetalOxideSemiconductor Field-Effect Transistor
MPC Model Predictive Control
MPU Micro Processor Unit
NLMPC Model Predictiv de Control Neliniar
PID ProportionalIntegralDerivative controller
https://www.youtube.com/watch?v=EIpPDZY8BPw&list=PLhoXNQqrCmEfAaTf0AfQ1Ztxmz2D
oZiCk&index=27
http://people.ece.cornell.edu/land/courses/ece4760/FinalProjects/f2016/ak634_jmw483_dm797/ak634_jmw4
83_dm797/ak634_jmw483_dm797/index.html
https://www.mathworks.com/help/supportpkg/arduino/examples/arduino-robot-line-follower-
application.html