Curs 13-14

RIM

Control si reglare

În acest capitol sunt prezentate şi analizate cele mai des întâlnite tipuri de regulatoare -
regulatoarele cu structură fixă de tip: P - proporţional, PI - proporţional, integral, PID -
proporţional, integral, derivativ,
Pentru acestea se detaliază modul de acordare (proiectare), utilizând metoda alocării (plasării)
polilor, în funcţie de performanţele dinamice dorite pentru sistem.
Proiectarea regulatorului automat se face pe baza datelor iniţiale furnizate de caracteristicile
sistemului şi ale elementului de execuţie, cât şi pe baza performanţelor de regim tranzitoriu şi
staţionar ce se urmăresc a fi realizate.
Pentru regimul tranzitoriu, se impun prin datele iniţiale de proiectare valori maxime pentru
suprareglaj, durata regimului tranzitoriu, în special pentru procesele rapide, timpul de creştere, ş.a.
Referitor la regimul staţionar, se impune de obicei valoarea erorii staţionare pentru un anumit tip de
mărime de intrare (treaptă, rampă) şi/sau de perturbaţie.

1. Analiza regulatoarelor cu structură fixă de tip P, PI, PID

Regulatorul cu structură fixă este un sistem al cărui elementele necunoscute sunt doar
coeficienţii polinomului funcţiei sale de transfer. Operaţia de determinare a acestora se numeşte
acordare a regulatorului cu structură fixă, realizată astfel încât sistemul rezultant să satisfacă cerinţele
impuse unui sistem de reglare automată (SRA).
Printre cele mai utilizate în practică regulatoarele cu structură fixă se pot enumera
următoarele: P care conţine componentă proporţională, PI - componentă proporţională şi integrală,
PID - componentă proporţională, integrală şi derivativă.
În tabela 14.1 sunt prezentate: relaţia de calculul a mărimii de ieşire din regulator - u (t ) -
mărimea de comandă pentru proces şi a funcţiei de transfer H R s  , specifică fiecărui tip de regulator
cu structură fixă.
Tabela 14.1 Relaţiile pentru calculul mărimii de ieşire (a comenzii) u (t ) şi al funcţiilor de
transfer H R s  , pentru regulatoarele cu structură fixă

Regulator Relaţia de calcul Funcţia de transfer

de tip a comenzii u (t ) H R s   U s  /  s 

P u (t )  K P   (t ) H R s   K P

KI
PI u (t )  K P   (t )  K I    (t )dt H R s   K P 
s

1
Conf. S.Paturca
 d (t ) KI
PID u(t )  K P   (t )  K I    (t )dt  K D HR s  KP   KD  s
dt s

unde se pot identifica coeficienţii (constante), corespunzatori fiecărei componente:

 coeficient proporţional (amplificarea) - K P ,
 coeficient integral - K I
 coeficient derivativ K D .
Răspunsul regulatorului este controlat prin acesti coeficienţii, utilizaţi pentru a mări/micşora
ponderea fiecărei componente a acestuia în răspunsul de ansamblu al sistemului ce este reglat.

Figura 14.1 Schema de reglare a unui proces cu regulator PID

Efectul fiecăreia componentele a regulatorului este ilustrat în figura 14.2. Acţiunea fiecărei
componente a regulatorului poate fi descrisă astfel:
 proporţională – asigură un răspuns proporţional (liniar) cu eroarea;
 integrală – ţine evidenţa erorilor acumulate în timp, avand efect de filtrare;
 derivativă – mărimea de comandă este proportională cu viteza de variaţie a erorii (sau a
abaterii).

u (t )

timp (s.)
Figura 14.2 Acţiunea proporţională - P, integrală - I şi derivativă - D asupra mărimii de comandă în proces

2
Conf. S.Paturca
Problema 14.1
A.14.1.1 Un sistemul de reglare automată trebuie să permită reglarea continuă a vitezei unui motor
de curent continuu în toată plaja de valori posibile. Se considera un motor cu următoarele date: R =
1Ω, L = 0.5H, K = 0.01Nm/A, F = 0.1Nm/rad/s, J=0.01Kgm2. Se va aplica o intrare de tip trepata de
valoare 1 [rad/sec]. Se urmareste analiza:
a) răspunsului in viteza al motorului atunci cand sistemul de reglare este buclă deschisă şi
respectiv în buclă închisă fiind comandat cu un regulator P şi PID.
b) efectul componentelor unui regulator P şi PID asupra răspunsului in viteză al motorului de
curent continuu, folosind funcţii Matlab. Se vor considera pentru regimul dinamic
următoarele valori pentru mărimile ce-l caracterizează: timp de stabilizarea mai redus de 2
sec, ; suprareglaj   5% ; eroarea de regim stationar  ss  1% .
Soluţie:
%------------------------------------------------------------
% Date initiale al motorului de curent continuu
R = 1; %[ohm] Rezistenta rotorului
L = 0.5; %[H] Inductivitatea rotorului
J = 0.01; %[kgm2] Momentul de inertie al rotorului
K = 0.01; %[Nm/A] Constanta de cuplu
F = 0.1; %[Nms] Coef. de frecari vascose
% Functia de transer a motorului de c.c. - procesul
num = K; % numarator
den = [(J*L) ((J*R)+(L*F)) ((F*R)+K^2)]; % numitor
functie_motor = tf(num,den)
subplot(3,1,1);
t = 0:0.01:2; % timpul de simulare
step(functie_motor,t); % raspunsul sistemului in bucla deschisa
title('Raspunsul sistemului in bucla deschisa'); grid;
K_p = 700;
num_Kp = K_p*num;
den_Kp = den;
[numf,denf] = cloop(num_Kp,den_Kp);
subplot(3,1,2);
step(numf,denf,t);
title('Raspunsul sistemului in bucla inchisa -regulator P');
grid;

3
Conf. S.Paturca
 % Determinarea functiei de transfer a regulatorului
kp = 200;
ki = 200;
kd = 10;
regulator = tf([kd kp ki],[1 0]);
sys = feedback(regulator*motor,1);
subplot(3,1,3);
step(sys,t);
title('Raspunsul sistemului in bucla inchisa -regulator PID');
grid;
%------------------------------------------------------------
Transfer function:
0.01
---------------------------
0.005 s^2 + 0.06 s + 0.1001

Raspunsul sistemului in bucla deschisa

0.1
Amplitude

0.05

0
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
Time (sec)
Raspunsul sistemului in bucla inchisa -regulator P
2
Amplitude

0
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
Time (sec)
Raspunsul sistemului in bucla inchisa -regulator PID
2
Amplitude

0
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
Time (sec)

4
Conf. S.Paturca
A.14.1.2 Studiul efectului componentelor unui regulator P şi PID asupra răspunsului in viteză al
motorului de curent continuu
- Control proportional
Kp = 100;
C = pid(Kp);
sys_cl =
feedback(C*P_motor,1);
t = 0:0.01:5;
step(sys_cl,t)
grid
title('Step Response
with Proportional
Control')

- Control PID
Kp = 75;
Ki = 1;
Kd = 1;
C = pid(Kp,Ki,Kd);
sys_cl =
feedback(C*P_motor,1);
step(sys_cl,[0:1:200])
title('Control PID')

Kp = 100;
Ki = 200;
Kd = 1;
C = pid(Kp,Ki,Kd);
sys_cl =
feedback(C*P_motor,1);
step(sys_cl, 0:0.01:4)
grid
title('Control PID')

5
Conf. S.Paturca
Kp = 100;
Ki = 200;
Kd = 10;
C = pid(Kp,Ki,Kd);
sys_cl =
feedback(C*P_motor,1);
step(sys_cl, 0:0.01:4)
grid
title('Control PID’)

Concluzie: Acordarea unui regulator cu structură fixă P, PI, PID implică determinarea coeficienţilor
K P , K I , K D astfel încât sistemul rezultant să aibă un comportament cât mai apropiat de cel dorit.

2. Metode de acordare a regulatoarelor cu structură fixă

2.1 Acordarea regulatoarelor PI cu metoda alocării polilor

Studiul algoritmului de acordare necesită determinarea funcţiei de transfer echivalente (în buclă închisă) a SRA prezentat în
figura 12.3.

Regulator PROCES
y*  u y
H PI   H p  

Figura 14.1 Reglarea unui sistem de ordinul I cu regulator PI

 
H P  , este comandat printr-un regulator de tip PI. Sunt cunoscute:
Sistemul liniar de ordinul I cu funcţia de transfer generală
1. funcţia de transfer a sistemului (procesul), de ordinul 1 ce va fi reglat, poate fi scrisă sub forma:
 b
 s t  R
H P     b a în care:  (14.1)
 d z t  Z
   a d
unde  reprezinta operatorul transformatei Laplace pentru sistemele cu timp continuu, respectiv operatorul transformatei Z
pentru sistemele cu timp discret, iar coeficienţii a d ,bd sistemului cu timp discret pot fi calculati cu relatiile:

 b  h , dacã a  0  ah
b şi ad  e
bd  

 
bd   1  e ah dacã a  0
a
, (14.2)

2. funcţia de transfer a regulatorului ce va fi acordat, se poate determina utilizand relatiile:

6
Conf. S.Paturca
  KI
 KP  
H PI     (14.3)
K
K p  i
  1
Note: 1. Echivalentul discret al funcţiei de transfer pentru procesul controlat a fost obţinut prin aplicarea transformatei Z, utilizand
relaţia:
z  1  H P (s) z  unde T este perioada de eşantionare
H P ( z)      T  h 
z  s ze 
2. Funcţia de transfer a regulatorului PI discret s-a obţinut alegând echivalentului discret al integratorului 1 / s de forma:
1 T T Ki
 => H PI ( z )  K P  K I  Kp 
s z 1 z 1 z 1
în care funcţia de transfer a regulatorului discret are următorii coeficienţii proporţionali şi integrali: K p  K P şi K i  K I T .

Observaţie: Pentru cazul sistemelor de ordinul I, utilizarea unui regulator PI permite alocarea polilor sistemului rezultant, prin
alegerea corespunzătoare a componentelor KP şi KI .

2.1.1. Etape necesare pentru acordarea regulatorului PI

Etapa 1: Determinarea funcţiei de transfer echivalente a SRA

Deoarece regulatorul PI şi sistemul de ordinul 1 sunt două sisteme legate în serie funcţia de transfer echivalentă serie este
următoarea: H ech serie s   H PI  H P   . Astfel, sistemul echivalent cu bucla de reacţie închisă are funcţia de
transfer:

H PI H P
H ech   
1  H PI H P
de unde rezultă pentru cazul:
b  s  K P  K I 
 continuu: H ech s   2
(14.4)
s  sK P  b  a   K I  b

 discret: H ech ( z) 
K p  z  Ki  Kp bd (14.5)
z 2  z  K p  bd  ad  1  bd  K i K p   ad
Etapa 2 : Impunerea performanţelor SRA implică stabilirea răspunsului acestuia

Întrucât atât stabilitatea unui sistem cât şi performanţele sale dinamice depind de poziţia polilor functiei de transfer rezultă să este
necesară alegerea valorilor dorite pentru rădăcinile numitorului (polii) funcţiei de transfer în buclă închisă H ech () pe baza
performanţelor dorite pentru sistemul de reglare.

Construirea polinomului dorit pentru numitorul funcţiei de transfer H ech () cunoscând rădăcinile acestuia

Se impune ca pentru acordarea regulatorului PI poziţiile poliilor să corespundă unui sistem de ordin egal cu ordinul polinomului de
la numitorul functiei de transfer a sistemului echivalent H ech () (ordin II).

Pentru cazul continuu: Se consideră răspunsul unui sistem standard de ordin II, descris de funcţia:

2
H 2( s )  (14.6)
s 2  s  2     2

7
Conf. S.Paturca
 definit prin factorul de amortizare  şi de pulsaţia proprie  . Mărimea  determină frecvenţa oscilaţiilor ce apar, şi se alege
corelat cu pulsaţia proprie a sistemului de reglat   p  sist de reglat . Impunerea performanţelor unui sistem de ordinul doi
înseamnă impunerea perechii de valori (  ,), adică a polilor funcţiei de transfer de ordinul II, H 2 (s) :
s1,2      j 1   2 .

Pentru cazul discret: Ţinând cont că unui punct s1 din planul complex Laplace, îi corespunde în planul complex Z punctul
s1h
z1  e , unde h – pasul de eştantionare, echivalentul discret pentru polii s1, 2 este:

   
z1,2  e h cos   h  1   2  j sin   h  1   2  (14.7)

Observaţie: Pentru acordarea regulatoarelor este necesară determinarea coeficienţilor regulatorului K P , K I , astfel încât sistemul
rezultant să aibă un comportament cât mai apropiat de cel dorit. Se va ţine cont de suprareglajul maxim acceptat şi banda de trecere
dorită pentru sistemul rezultant.

Etapa 3: Determinarea coeficienţilor K P şi K I ai regulatorului

 Cazul continuu: Prin egalarea numitorilor funcţiilor (12.4) şi (12.6) rezultă un sistem de două ecuaţii ale cărui necunoscute
sunt KP , KI :

s 2  s K P  b  a   K I  b  s 2  2s  2
din care se obţine soluţia sistemului, adică coeficienţii regulatorului PI cu timp continuu, notaţi K P _ c, K I _ c :

 2  a
2  K P b  a K P _ c  b
 2 =>  2
  K I b K _  
 I c b
 Cazul discret: Polinomul dorit pentru funcţia de transfer în buclă închisă este:

Pdoritz   z2  z  p1 p2 unde:

 1 2 
p1  (z  z )  2 eh  cos h  1 2 
 p2  z1  z2  e2h

Egalând numitorul funcţiei (12.5) cu polinomul dorit al funcţiei de transfer echivalente Pdoritz , rezultă sistemul de două
ecuaţii ale cărui necunoscute sunt coeficienţii regulatorului PI., K P , K I :

  p1  ad  1
KP  bd  ad 1  p1  K P d  bd

 => 
KI  KP   bd  ad  p2 K _   p2  ad   Kp
 I d bd

Note: A) Atât în cazul continuu cât şi în cel discret trebuie să obţinem coeficienţi K P , K I  0 . Dacă în urma procesului de
acordare K I rezultă negativ, trebuie impusă o bandă de trecere dorită  mai mare.

8
Conf. S.Paturca
 B) În general însă dimensiunea n a SRA este mai mare de doi. Alocarea a mai multor poli doriţi se face astfel: se aleg 2 poli
principali care vor influenţa în cea mai mare măsură răspunsul sistemului rezultant şi următorii poli secundari - cu o
contribuiţie aproape neglijabilă. În acest caz, comportamentul sistemului rezultant va fi foarte asemănător cu cel al unui
sistem de ordinul II. Deci, pentru cazul sistemelor de ordin mai mare decât 2, pentru polinomul dorit se impun 2 poli exact ca
la un sistem de ordinul 2 ( s1 şi s2 ), impunând perechea (  ,), iar ceilalţi poli ( s3 , s4 , s5 , ..., sn - pentru cazul
polinomului de ordin n) se aleg egali între ei, pe axa reală, cu partea reală de 10 ori mai mare decât partea reală a polului s1 .

În figura 14.4 este ilustrată

modalitatea de plasare pe axa
reală negativă a polilor secundari,  p1
Polii
la o distantă mult mai mare faţă dominanti
de origine comparativ cu polii  p3
principali.

 p2

Figura 14.4 Prezenţa unui pol suplimentar

Se obţine un sistem cu cei 2 poli dominanţi ( s1 şi s2 ), iar efectul polilor s3 , s4 , s5 , ..., sn asupra răspunsului sistemului poate fi
neglijat, forma polinomului dorit fiind:


Pdorit s   s  s3 s  s 4 s  s5 ...s  s n   s 2  s  2     2 

2.2. Acordarea regulatoarelor PID

În cazul sistemelor de ordinul II, utilizarea unui regulator PID permite alocarea polilor sistemului rezultant, prin determinarea
coeficienţilor K P , K I şi K D .
Exact ca în cazul acordării sistemelor de ordinul I sunt cunoscute:

1. funcţia de transfer a sistemului (procesului) ce va fi reglat

b
 pentru procese cu timp continuu poate avea forma: H p s   2
s  a1 s  a0
 iar echivalentul discret al funcţiei de transfer a procesului este:

b1d  z  b0d
H P (z)  2
z  z  a1d  a0 d

2. funcţia de transfer a regulatorului PID ce va fi acordat

 pentru cazul continuu are forma standard:

KI _ c
H PID s   K P _ c   KD _ cs
s
unde KP _c,KI _c, KD _c coeficienţii proporţional, intregral şi derivativ;

În figura 14.7.a se prezintă schema de reglare a unui proces de ordinul II, comandat printr-un regulator PID cu timp continuu.

9
Conf. S.Paturca
 y*  u y
H PID s   K P _ c 
KI _ c
 KD _ cs H p s 
s

Figura 14.7 Reglarea unui proces de ordinul II cu regulator PID cu timp continuu
De multe ori în practică aplicarea părţii derivative se face numai asupra semnalului de reacţie, obţinându-se schema de reglare din
figura 14.7.b. Aceasta are ca principal efect evitarea obţinerii unor variaţii mari ale comenzii cauzate de partea derivativă când apar
modificări bruşte ale referinţei. Formulele de acordare se aplică în continuare şi pentru schema de reglare 14.7.b.

H PI (s)
*
y   KI _ c  u y
KP _ c 
s
H p s 
 
HD(s)
KD _ cs

Figura 14.7.b Utilizarea unui regulator PID cu timp continuu,

cu partea derivativă aplicată doar pe reacţie

 pentru cazul discret se obţine folosind echivalentul discret al integratorului şi echivalentul discret al derivatorului:
T z 1 1 z 1
H R ( z)  K p _ d  Ki _ d  Kd _ d  KP _ d  KI _ d  KD _ d
z 1 zT z 1 z
unde: K P _ d  K p _ d , K I _ d  Ki _ dT şi K D _ d  K d _ d / T sunt coeficienţii proporţional, intregral şi

derivativ ai regulatorului discret. În acest caz, regulatorul şi procesul au numitorul funcţiei de transfer de ordin 2, deci
sistemul rezultant va fi de ordinul IV. Prin aplicarea metodei de alocare a polilor se obţine la un sistem de 4 ecuaţii cu 4
necunoscute - coeficienţii KP _ d , KI _ d şi KD _ d şi constanta filtrului pe partea derivativă. Din acest considerent
pentru cazul discret filtrul se ia în considerare, şi funcţia de transfer a regulatorului PID cu timp discret va avea forma:
1 z 1
H R ( z)  K P _ d  K I _ d  KD _ d
z 1 zr
unde r  [0,1] depinde de constanta  D a filtrului şi K D _ d  K D _ d ' (1  r ) .
In figura 14.8.a prezintă schema de reglare a unui proces de ordinul II, comandat printr-un regulator PID cu timp discret.

y*   KI _ d u y
z 1
HR (z)  KP _ d 
z 1
 KD _ d
z r
H P (z )


10
Conf. S.Paturca
 Figura 14.8.a Reglarea unui proces de ordinul II cu regulator PID cu timp discret

În cazul când partea derivativă se aplică numai pe semnalul de reacţie, se obţine schema de reglare din figura 14.8.b. Ca şi în cazul
regulatoarelor PID cu timp continuu, această soluţie are ca principal efect evitarea obţinerii unor variaţii mari ale comenzii cauzate de
partea derivativă când apar modificări bruşte ale referinţei.

H PI (z )
*
y   K I_d  u y
K p_d 
z 1 H p s 
 
H D (z )
z 1
K I_d
zr

Figura 14.8.b Utilizarea unui regulator PID cu timp discret cu partea D numai pe reacţie

2.2.1. Etape necesare pentru acordarea regulatorului PID

Etapa 1: Determinarea funcţiei de transfer echivalente a SRA

Sistemul echivalent rezultant, de ordin III, va avea funcţia de transfer:

H PID    H P  
H ech   
1  H PID    H P  

de unde rezultă:

 pentru cazul continuu :

H ech s  
K D_c  s2  KP_c  s  KI _c b 
   
s 3  s 2 K D _ c  b  a1  s K P _ c  b  a0  K I _ c  b

 pentru cazul discret :

b1d  z  b0d   2 z 2  1 z  0

Hech(z) 
z 1  z  r  z 2  a1d  z  a0d  b1d  z  b0d   2  z 2  1 z  0
num_H ech z   z 4  z 3  a1d  1  r    2  b1d  
 z 2  a0d  r  a1d  1  r    2  b0d  1  b1d  
 z  r  a1d  a0d  1  r   0  b1d  1  b0d  
 r  a 0d   0d  b0d
în care s-au facut notaţiile:

2  K P _ d  K D _ d ;
1  K I _ d  K P _ d  1  r   2  K D _ d ;
0  K P _ d  r  K I _ d  r  K D _ d

Etapa 2: Impunerea performanţelor SRA

11
Conf. S.Paturca
Pentru cazul continuu alocarea poliilor de la numitorul funcţiei de transfer echivalente se face prin alegerea a 2 poli principali - care
vor influenţa în cea mai mare măsură răspunsul sistemului rezultant prin impunerea perechii (  ,), la fel ca în cazul regulatorului PI
şi un al treilea pol secundar – cu o contribuţie aproape neglijabilă, care se plasează pe axa reală negativă la o distantă mult mai mare

faţă de origine comparativ cu polii principali: s1, 2       j 1   2

Numitorul dorit se poate exprima astfel:

s  s3 s 2  2s  2   s    Re{ s1,2 }s 2  2s  2 , unde s3      ,

care pentru simplitate poate fi aproximat astfel: s3     , în care se alege valoarea  în intervalul   5  10 .

Pentru cazul discret comportamentul sistemului rezultant de ordin IV va fi foarte asemănător celui din cazul sistemului de ordinul II.
Alocarea poliilor este şi în acest caz analogă cazului continuu, prin alegerea a:
 2 poli pricipali cu influenţa în cea mai mare aspura răspunsului sistemului rezultant, astfel încât să corespundă în planul s
polilor unui sistem cu timp continuu de ordinul II, definit prin factorul de amortizare  şi pulsaţia naturală 

 doi poli secundari cu o contribuţie aproape neglijabilă, spre exemplu z3, 4  e  h   , unde   5  10 .
Numitorul dorit pentru funcţia de transfer rezultantă va fi de forma: z  2  z 2  p1  z  p 0, unde p1 şi p2 .

Etapa 3: Determinarea coeficienţilor KP , KI şi K D , ai regulatorului

Prin egalarea numitorilor funcţiilor rezultă un sistem de ecuaţii a căror necunoscute sunt coeficienţii KP , KI şi K D , pentru cazul
sistemelor cu timp continuu, de forma:

2 1  2   a0 3 2     a1

Kp _c  , KI _ c  , KD _ c 
b b b
şi in cazul sistemelor cu timp discret:

Kp_d 
2  0  K I _ d  r , K 
2  1  0 ; K  2  K p _ d
I_d D_d
1  r  1  r 
unde pentru simplificare s-au facut următoarele notaţiile:

 2  c3  a1d  1  r  b1d ; 1     r   b1d 2 ; 0  c0  r  a 0d  b0d

c1  a0 d    b0 d / b12d  c0  b1d / b0 d
r
a1d  a0 d    b0 d / b12d  a0 d  b1d / b0 d

c3  p1  2  ; c 2  p 2   2  2    p1;
c1   2  p1  2    p 2; c0   2  p 2
  b1d  c 2  a0 d  a1d   b0 d  c3  a1d  1;   b1d  1  a1d   b0 d

Observaţie: Toţi coeficienţii regulatorului KP,KI , KD trebuie să fie  0 . Dacă în urma procesului de acordare K P sau

K D rezultă negativi, se impune o bandă de trecere  mai mare.

12
Conf. S.Paturca
În cele ce urmează se prezintă un exemplu de proiectare a unui sisteme de reglare automată, pentru care se indică cerinţele şi se
parcurg etapele principale ale fazei de proiectare: modelarea matematică a procesului, proiectarea regulatorului şi implementarea
sistemului de reglare.

A.14.3 CONTROLUL VITEZEI UNUI MOTOR DE CURENT CONTINUU

A) Cerinţe
Un sistemul de reglare automată trebuie să permită reglarea continuă a vitezei unui motor de curent
continuu cu magneţi permanenţi în toată plaja de valori posibile. Se consideră un motor cu
următoarele date: rezistenţa rotorului R = 10Ω, inductivitatea rotorului L = 1mH, constanta de cuplu
k = 0,05 Nm/A, momentul de inerţie total (include şi sarcina) J = 5*10-7 kgm2. Motorul este
alimentat printr-un amplificator care furnizează o tensiune de maxim 24V. Tensiunea furnizată este
proporţională cu o tensiune de comandă în plaja 10V. Motorul este cuplat cu un tahogenerator care
furnizează o tensiune proporţională cu viteza motorului. Relaţia de proporţionalitate este dată de
constanta tahogeneratorului – K TG = 4V/1000rpm (rpm = rotaţii pe minut). Referinţa de viteză se
impune printr-o tensiune ce poate varia în plaja 10V.
Solutia de obţinere a modelului matematic a fost analizata în capitolul 2.
B) Proiectarea regulatorului
Pentru proiectarea regulatorului este necesară stabilirea modelului matematic ale procesului, adică al
motorului de curent continuu.

yref
u y

Figura 14.13.a Structura SRA

Se reaminteşe faptul că în lucrarea 2 a fost construit modelul maşinii de curent continuu, şi s-a
calculat constantele electrică  el  0.1ms şi electromecanică  em  2ms ale motorului. Întrucât se oservă
că  el   em , produsul el  em se poate neglija, astfel încât funcţia de transfer specifică motorului
se poate simplifica de la ordinul II, considerând-o cu o bună aproximaţie ca fiind de ordinul I, de
forma:

1/ k
H U  s  
1  s   em
Astfel, considerând că procesul este de ordinul I, pentru acordare se va utiliza un regulator cu
structură fixă de tip PI.
În figura 14.13.b se prezintă schema bloc a sistemului de reglare a vitezei maşinii de curent continuu.

13
Conf. S.Paturca
 PROCES ms

Regulator Motor c.c.


*  U 1 i m 1 
  H R s  KA
  k
 

Ls  R sJ


K TG
KTG

Figura 14.13.b Schema bloc a sistemului de reglare a vitezei maşinii de curent continuu

În afară de motor şi de regulatorul propriu-zis, schema mai include:

 Amplificatorul de tensiune prin care motorul este comandat, care este caracterizat prin constanta
de amplificare K A

 Tahogeneratorul necesar pentru măsurarea vitezei, care are constanta K TG

 Adaptarea de semnal de la ieşirea tahogeneratorului la intrarea în regulator, dată de constanta

K .
Toate aceste elemente trebuiesc luate în considerarea la acordarea regulatorului PI.
Conform cerinţelor de proiectare, referinţa de viteză este dată sub forma unei tensiuni în plaja 10V.
Pentru a putea compara mărimi de acelaşi tip şi dimensiune, rezultă că şi mărimea de feedback
trebuie să fie tot o tensiune în plaja de valori 10V.
Tipic regulatoarele analogice pot avea plaja de intrare şi cea de ieşire cuprinsă între 10V. La
intrarea regulatorului se aplică o tensiune proporţională cu eroarea  şi la ieşirea regulatorului se
obţine o tensiune de comandă Uc proporţională cu tensiunea care trebuie aplicată pe motor.
Notă: Când referinţa şi feedback-ul variază în plaja 10V, eroarea rezultă în plaja 20V. Pentru a o
aduce în gama 10V se practică 2 metode:
a) erorile se limitează la plaja de 10V

b) calculul erorii se face cu relaţia:   1 / 2  ( *  V ) care reduce plaja erorii de la 20V la

10V. Această atenuare de ½ trebuie însă luată în calcul la proiectarea regulatorului.
În cele ce urmează se va folosi metoda b).
Conform cerinţelor, amplificatorul poate furniza motorului o tensiune U în plaja 24V. Pentru a
acoperii întreaga gamă de tensiuni admisibile, 10V tensiune de comandă trebuie să conducă la
24V
24V tensiune pe motor. Prin urmare amplificatorul are constanta de amplificare K A   2,4 .
10V

14
Conf. S.Paturca
Rezultă că atunci când un motor este comandat cu tensiunea U , poate atinge teoretic o viteza
U 24V
maximă  max    480rad / s . Ţinând cont şi de polaritatea negativă aceasta
k 0.05 Nm / A
înseamnă o plajă de valori de 480 rad/s.
Notă: În practică această limită nu este atinsă deoarece totdeauna există un cuplu de frecări nenul.
Tahogeneratorul cu constanta:

4V  60 s
K TG  4V / 1000rpm   0,0382V / rad / s
1000  2
va furniza o tensiune proporţională cu turaţia motorului în plaja TG  480  0.038  18.33V .
Cum acest semnal depăşeşte plaja de intrare în regulator de 10V, el trebuie atenuat, factorul de
10
divizare fiind K    0.545 .
18.33
Regulatorul citeşte reacţia procesului prin eroarea  , şi trimite o comanda Uc , ambele mărimi fiind
în plaja 10V. Pentru regulator funcţia de transfer a procesului este tot ceea ce există în afara lui. În
acest context, funcţia de transfer reală a procesului pe baza căreia se va face proiectarea regulatorului
devine:

K ech
K ech  em b => K ech  1 / 2  K A 1 / k  KTG  K   0.5
H real s    
1  s   em 1 sa
s K 1
 em b  250 ; a   500
 em  em

Pentru acordarea regulatorului se aleg:

 Factorul de amortizare –   0,707
1
 Pulsaţia naturală    500 rad/s
 em
Coeficienţii Kp şi Ki rezultă cu formulele:
2  a
KP   0.828
b
2
KI   1000
b

Pentru verificare s-a folosit schema de simulare din figura 14.16.a, care include 2 subblocuri pentru
motorul de curent continuu (figurile 14.16.b şi 14.16.c) şi pentru regulatorul PI (figurile 14.16.d).

15
Conf. S.Paturca
 Mux
ms ms omg
omg*, omg
omg* +/-20 [V] +/-10 [V] +/-10 [V] +/-24 [V]
-K- 1/2 eps Uc K_A U i
omg* omg
KA1 Regulator PI KA motor c.c curent omg
+/- 480 [rad/s]
+/-10 [V]
comanda

+/-18.3 [V] +/-480 [rad/s]

-K- Ktg

Komg KTG

Figura 14.16.1 Schema de reglarea vitezei unui motor de c.c. cu un regulator PI

Figura 14.16.b Schema Simulink pentru motorul de curent continuu, modelat ca subsistem
1
ms
1 1 omg
2 i
k 1
J.s
U L.s+R Sum3 omg
Sum2 k
T ransfer Fcn T ransfer Fcn1 2
i
omg
k

Figura 14.16.c Schema Simulink pentru motorul de curent continuu, detaliu

Kp Uc [V]
1
1 Kp Saturation Uc
eps
1/s Ki

Integrator Ki

Figura 14.16.d Schema regulatorului PI analogic cu limitarea comenzii

16
Conf. S.Paturca
S-a aplicat o referinţă treaptă egală cu jumătate din viteza maximă posibilă a motorului. Pentru a
testa şi capacitatea de-a rejecta efectul perturbaţiilor, după 25ms de la aplicarea referinţei s-a aplicat
şi un cuplu de sarcină ms  20mNm . Evoluţia vitezei şi curentului motorului este prezentată în
figura 14.16.e şi arată evoluţia comenzii date de regulatorul PI în plaja 10V.

Varatia în timp a vitezei motorului Variatia în timp a curentului prin motor

Figura 14.16.e Vizualizarea grafică a variaţiei vitezei şi a curentului prin
motor, la aplicarea unei referinţă treaptă de 240 rad/s, după 25 ms s-a
introdus un cuplu de sarcină de valoare 20mNm.

A.14.4 CONTROLUL POZIŢIEI UNUI MOTOR DE CURENT CONTINUU – SISTEM DE

REGLARE CU TIMP DISCRET

A) Cerinţe:
 Sistemul de reglare automată trebuie să permită reglarea poziţiei unui motor de curent continuu cu
magneţi permanenţi în toată plaja 10 rotaţii. Motorul are aceleaşi date ca cel din exemplul
precedent
 Motorul este alimentat printr-un amplificator care furnizează o tensiune de maxim 24V.
Tensiunea furnizată este proporţională cu o tensiune de comandă în plaja 10V.
 Motorul este cuplat cu un encoder incremental de 500 linii pe rotaţie. El permite măsurarea
poziţiei motorului cu rezoluţia de 2000 pulsuri pe rotaţie.
 Sistemul numeric de comandă include:
 o interfaţă de encoder care permite citirea directă a variaţiei de poziţie
 un convertor numeric analogic de 10 biţi şi un circuit de adaptare de semnal prin care
ieşirea convertorului este adusă în plaja 10V
 o interfaţa utilizator prin care acesta poate introduce referinţa de poziţie

17
Conf. S.Paturca
B) Obţinerea modelului matematic al procesului
Funcţia de transfer a procesului de la tensiunea de comanda
U la poziţia motorului  se obţine adăugând un integrator, 1/ k
deoarece poziţia motorului se obţine integrând viteza lui: H U   s  
s 1  s   em 
C).Proiectarea regulatorului numeric
Ţinând cont că procesul este de ordinul II, se va utiliza un regulator cu structură fixă de tip PID care
trebuie acordat. În figura 14.17.a este prezentată schema bloc a SRA, tipul şi plaja de valori pentru
semnale care fac legătura între blocurile componente.

Regulator
*
  Uc Uc U 
 KCNA KA
 20000 [biti]  [biti]  512[biti]  10[V]  24[V]  20[rad ]

E
 20000 [biti]
K ENC
Figura 14.17.a Tipul semnalelor sistemului de reglare a poziţiei maşinii de curent continuu
Referinţa de poziţie este un număr (simbolizat prin unitatea de măsură b , adică biţi) care conform
cerinţelor trebuie să acopere plaja de valori 10 rotaţii. Având în vedere că poziţia motorului este
citită cu rezoluţia de 2000 de pulsuri/biţi pe rotaţie, plaja de valuri a referinţei este 20000 biţi.
La ieşire, regulatorul trebuie să de-a o comandă care să corespundă cu rezoluţia convertorului
numeric analogic (CNA). Dacă CNA are 10 biţi, înseamnă că poate converti într-o tensiune de orice
număr în plaja [0 210-1]. Ţinând cont că tensiunea de comandă e bipolară, corespondenţa conversiei
10
este: 512 (29) biţi corespund la 10V. Deci factorul de conversie este: K CNA  [V / biti ] .
512
Tensiunea de comandă de 10V intră în amplificatorului de putere care o converteşte în tensiunea
24V
efectivă aplicată motorului. Astfel amplificatorul are constanta de amplificare K A   2,4 .
10V
În fine, poziţia motorului este citită prin intermediul encoderului incremental, corespondenţa fiind
2000
2000 pulsuri sau biţi la o rotaţie, adică: K ENC  [biti / rad ] .
2
Pentru calculul funcţiei de transfer se consideră tot ceea ce este exterior blocului regulator discret.
Prin urmare funcţia de transfer reală a procesului pe baza căreia se va face proiectarea regulatorului
este:

K ech
K ech  em b
H real s    
s (1  s   em )  1  s( s  a)
s  s 
  em 

18
Conf. S.Paturca
unde:
10 / 512  2.4  2000 /( 2)
K ech  K CNA  K A 1 / k  K ENC    298.4
0.05
K 298.4 1 1
b   149200 ; a   500
 em 2 10  3  em 2 10  3
Dacă se consideră pasul de eşantionare T=0.1ms, echivalentul discret al funcţiei de transfer reale are
următoarea formă:

b1d  z  b0 d
H P ( z)  unde:
z 2  z  a1d  a0d

b  e  aT  1  b 1  e  aT 
b1d   T , b0 d    T  e aT  , a1d  1  e  aT , a0 d  e  aT
a  a  a  a 

Schema de simulare include două subblocuri pentru regulatorul PID şi pentru motor, prezentate în
figura 14.17.b, 14.17.c şi 14.17.d. S-a aplicat o referinţă treaptă egală cu 3 radiani. Pentru a testa şi
capacitatea de-a rejecta efectul perturbaţiilor, după 25ms de la aplicarea referinţei s-a aplicat şi un
cuplu de sarcină ms  50mNm . Evoluţia poziţiei şi curentului motorului este prezentată în figura
14,17.e, şi 14.17.f, unde se observă arată evoluţia comenzii date de regulatorul PI în plaja 512 biţi.

ms Mux
ms poz
+/-20000[biti] +/-512 [biti] +/-10 [V] +/-24 [V]
Kenc poz*, poz
er Uc -K- K_A U i
poz* Quantizer
poz* KA motor c.c curent
+/-20* [pi rad] Regulator K_CNA
PID discret

comanda
+/-20000 [biti] poz
[+/-20*pi rad]
Kenc

Quantizer Kenc

Figura 14.17.b Reglarea poziţiei unui motor de c.c. cu un regulator PID discret
alfa2.+alfa1.z-1+alfa0z-2
1
1 1
er
Discrete Filter Uc
Saturation1 Zero-Order
1 1 Hold1
r
z z
Gain Unit Delay1 Unit Delay2

-K-
Gain1

Figura 14.17.c Regulator PID discret cu limitarea comenzii

19
Conf. S.Paturca
 2
1 i
ms
1 omg 1
2 1 i 1
k
J.s s
U L.s+R Sum3 poz
Sum2 k T ransfer Fcn1 T ransfer Fcn2
Transfer Fcn

omg
k

Figura 14.17.d Motor de curent continuu cu poziţia mărime de ieşire

Figura 14.17.e Poziţionarea Figura 14.17.f Variatia în timp a curentului

motorului prin motor

3. Implemententarea regulatoarelor numerice

Regulatoarele numerice se implementează pe sisteme cu microprocesoare sau microcontrollere
care includ în mod obligatoriu un ceas de timp real. Acesta este un numărător programabil care se
resetează la zero ori de câte ori atinge o valoare programabilă numită perioada ceasului. Uzual ceasul
de bază al numărătorului este egal cu cel al procesorului. De exemplu dacă procesorul are un ceas
intern de 40 MHz, numărătorul îşi va incrementa valoarea cu 1 la fiecare 1/40MHz = 25ns.
Dacă perioada ceasului este setată la 40000 atunci ceasul se va da peste cap la fiecare 1ms. În
momentul resetării, numărătorul generează o cerere de întrerupere care dacă este acceptată va cauza
întreruperea execuţiei programului curent şi saltul în altă parte a memoriei unde se execută o funcţie
asociată numită rutina de tratare a întreruperii. La terminarea acestei funcţii, se reia execuţia
programului principal din punctul de unde a fost întrerupt.
Implementarea regulatoarelor numerice se face în rutina de tratare a întreruperii ceasului de timp
real, care este programat cu o perioadă egală cu pasul de eşantionare ales.
Pentru cazul regulatorulului cu funcţia de transfer de forma:

ui 1 z  1  2 z 2  1 z   0
H R ( z)   KP_d  KI _d  KD_d  (14.8)
i z 1 zr z 2  (1  r ) z  r

Se poate scrie relatia intre ieşirea regulatorului la pasul curent ui şi intrarea la pasul curent  i de
forma:

20
Conf. S.Paturca
  2  1 z 1   0 z 2
ui  i (14.9)
1  (1  r ) z 1  rz  2

Ţinând cont că înmulţirea cu z 1 înseamnă întârziere cu un pas de eşantionare, adică

u i  z 1  u i 1 înseamnă comanda la pasul anterior i  1 , relaţia (14.9) se poate rescrie sub forma:

ui   2 i  1 i 1   0 i  2  (1  r )ui 1  rui  2 (14.10)

Rutina de tratare a întreruperii de ceas de timp real trebuie să realizeze:

- citirea sau calculul referinţei de poziţie pentru pasul curent – *i ;

- citirea de la interfaţa de encoder a poziţiei motorului pentru pasul curent –  i ;

- calcul eroarii la pasul curent:  i  *i  i ;

- calcul actualei comenzi ui cu relaţia (14.10);

- limitarea comenzii ui la plaja de valori posibile, cere în acest caz este [-512,+511] (valorile
mai mici de –512 se limitează la –512, iar valorile mai mari de 511 se limitează la 511);
- trimiterea comenzii după limitare către proces (in acest caz, această operaţie înseamnă
scrierea comenzii în convertorul N/A);
- actualizarea variabilelor globale utilizate pentru pasul următor, astfel: ui 2  ui 1 ; ui 1  ui
;  i 2   i 1 ;  i 1   i
In structura programului la iniţializări se setează parametrii ceasului de timp real şi se iniţializează cu
zero valorile anterioare:
ui 1 , ui 2 ,  i 1 ,  i 2 .

21
Conf. S.Paturca
 4. Aplicaţie practică de testare a actuatoarelor unui robot NXT
Actuatoare - motoare şi sistem asociat pentru controlul mişcării

4.1. Caracteristici principale ale motoarelor kit-ului robot NXT

Mobilitatea robotului sau a componentelor mobile ale acestuia este oferită de trei motoare NXT
de curent continuu, cu ajutorul cărora se poate realiza sistemul de locomoţie si/sau miscări simple
până la mişcări complexe ale braţelor unui robot.
Servomotorul NXT cuprinde 4 componente:
 Motor de c.c. alimentat la 9V nominal (suportă 12V pe perioade scurte);
 Dispozitiv de protecţie la supracurent (termistor RXE065);
 Encoder incremental care returnează poziţia unghiulară relativă a motorului;
 Sistem de transmisie cu raport reductor de 48:1 de la motor la axul servomotorului.
Parametrii de funcţionare în gol şi în scurtcircuit sunt listaţi în tabelele 14.
Tabel 14.a

Tabel 14.b Parametrii de funcţionare ai motoarelor NXT

Tabel 14.c
Tensiune Curent Curent Turaţie maximă Turaţie la încărcare
maximă minim maxim (fără încărcare) normală
Servomotor 9V c.c. 60 mA 2A 170 rpm 100-130 rpm
Servomotorul este protejat la supracurenţi cu un termistor, modelul RAYCHEM RXE065.
Dispozitivul suportă un curent maxim de 40A şi o tensiune maximă de 60V.
Pentru a mări cuplul servomotorului,
transmisia se face printr-un angrenaj cu raport
reductor de 48:1 – figura 14.17. Deşi
randamentul scade, cuplul mare este un avantaj
în construcţia unui robot mobil NXT.
Figura 14.17 Servomotorul kit-ul robot NXT

22
Conf. S.Paturca
4.2. Comanda tensiunii motoarelor electrice NXT
Fiecare motor din kit-ul NXT este alimentat de câte un chopper de tensiune continuă, conectat
la bateria de acumulatoare. Controlul mişcării motoarelor electrice, indiferent dacă este vorba de
poziţie sau viteză, se materializează în final prin modificarea adecvată a tensiunii continue aplicate la
bornele motorului.
Blocul de alimentare a motoarelor NXT
utilizează modularea în durată a semnalului de
tensiune (PWM Pulse Width Modulation) pentru
a modifica nivelul tensiunii la bornele motorului.
Tensiunea rezultată are forma unui semnal
rectangular, cu amplitudine şi frecvenţă
constantă, dar cu factor de umplere variabil.
În figura 14.18 este ilustrată forma
tensiunii comandate prin PWM, cu pulsuri având
Figura 14.18 Semnale de tensiune de
factorul de umplere de 25%, 50% şi respectiv
frecvenţă constantă, aplicate prin
75%. Astfel, dacă se creşte factorul de umplere al
modulare în durată (PWM)
semnalului rectangular, creşte valoarea medie, pe
o perioada PWM, a tensiunii la borne.
În cazul unei comenzi de viteză fără feedback, în buclă deschisă, factorul de umplere este
furnizat direct semnalului de comandă a tensiunii. Referitor la această comandă, este de reţinut faptul
că în limbajul NXC există funcţii de mişcare care au un parametru cu denumirea generică „pwr”
(power). Acesta nu este altceva decât factorul de umplere al tensiunii aplicate.
Notă: Chopper-ul care alimentează motorul conectat la portul A (Sanyo LB1930M) este diferit
de cele folosite pentru porturile B şi C (LB1836M). De aceea este recomandat ca pentru locomoţie să
se utilizeze porturile B şi C, pentru a nu avea răspunsuri diferite la aceeaşi comandă.

4.3. Traductoarele de poziţie ale robotului

Traductoarele de poziţie oferă informaţii legate de poziţia robotului (odometrie), şi informaţii
referitoare la vitezele motoarelor. Prin odometrie se calculează distanţa parcursă de un robot mobil în
funcţie de cât de mult s-au rotit roţile acestuia. De asemenea, în cazul unui robot manipulator poziţia
braţului se poate calcula pe baza poziţiei unghiulare a fiecărui motor care acţionează segmentele
braţului.
Motoarele robotului NXT sunt echipate cu traductoare de poziţie de tip encoder incremental
optic, care oferă informaţii despre poziţia relativă a axului motorului faţă de o poziţie aleasă ca
referinţă. În momentul în care motorul se roteşte, encoderul indică sensul şi incrementul poziţiei.
Unghiul de rotaţie a axului motor se poate măsura relativ la momentul de început de rotire al
roţilor (momentul de start din program), sau relativ la momentul de reset software.

23
Conf. S.Paturca
4.4. Controlul vitezei şi poziţiei motoarelor robotului
În cea mai simplă formă, un robot mobil poate funcţiona în buclă deschisă. Operatorul sau
algoritmul de control alege o viteză dorită pentru locomoţie iar viteza este transformată într-o
comandă în tensiune dată către motoare. Existenţa senzorilor montaţi la motoare permite observarea
erorii între viteza dorită şi viteza reală.
Dezavantajele buclei deschise sunt evidente: în momentul în care condiţiile din mediu se
modifică, eroarea dintre viteza măsurată şi viteza dorită va creşte. În acest caz, algoritmul de control
nu va face o compensare, deoarece el nu primeşte nici o informaţie din partea sistemului senzorial.
Din acest motiv, bucla de reglare trebuie închisă prin introducerea informaţiilor de la senzori înapoi
în algoritmul de control, astfel încât eroarea să poată fi minimizată.
Pentru a putea menţine şi regla viteza impusă de către utilizator este necesară informaţia despre
viteza actuală. Rutina de reglaj automat al vitezei este implementată la nivelul firmware-ului NXT.
Firmware-ul NXT implementează un control în buclă închisă printr-un regulator proporţional,
integral, derivativ (PID), pentru reglarea vitezei şi a poziţiei motoarelor NXT, prin citirea feedback-
ului de poziţie de la encodere.
Câteva caracteristici ale buclei de reglaj al poziţiei unghiulare sunt date în tabelul 4.d.
Tabel 4.d
Senzor Ieşire Unitate de Tip de date Număr maxim de
măsură eşantioane/sec [1/sec.]
Encoder Poziţie unghiulară grade Int32 1000
relativă

4.5. Unitatea centrală de procesare a robotului NXT

Unitatea centrală de procesare a robotului NXT (CPU-NXT) – este centrul operaţional al sistemului
robot, prin execuţia programelor utilizatorului şi controlul servomotoarelor, comunicaţie cu senzorii,
cu PC-ul sau cu alte unităţi NXT.
Unitatea centrală a sistemului NXT include două microcontrolere:
 Microcontroler principal, care execută programele utilizatorului: Atmel ARM7,
AT91SAM7S256, pe 32 biţi (arhitecturǎ RISC), 48 MHz, 256 KB memorie High-
speed FLASH (organizatǎ în 1024 de pagini de 256 Byte), 64 KB High-speed
SRAM;
 Microcontroler auxiliar, destinat controlului PWM al servomotoarelor: Atmel
AVR, ATmega48, pe 8 biţi (arhitecturǎ RISC), 4 MHz, 4 KB memorie FLASH,
512 Byte SRAM, 6 canale PWM.
În figura 14.19 este ilustrat modalitatea de comunicaţie specifică kit-ului NXT. Astfel între
senzori/servomotoare aceasta este realizată prin intermediul microcontrolerului Atmel AVR, excepţie
făcând senzorul ultrasonic şi sistemul de achiziţie a datelor de la servomotoare, acestea conectându-
se direct la microcontrolerul principal.

24
Conf. S.Paturca
 Figura 14.19 Conexiuni între CPU-NXT şi PC, motoare, senzori

Semnalele furnizate de senzorii analogici sunt direcţionate către un Convertor Analog - Digital
(CAD), cu rezoluţie de 10 biţi, valorile numerice fiind deci cuprinse în intervalul 0-1023.
Semnalele digitale sunt transmise la microcontrolerul principal prin interfaţa de comunicaţie I2C.
CPU-NXT dispune de patru porturi de intrare (marcate pe echipament prin cifre de la 1 la 4), şi de
trei porturi intrare-ieşire de 9 volţi (marcate fizic prin literele A, B, C), utilizate pentru comanda
motoarelor şi citirea encoderelor. Astfel, roboţii NXT primesc informaţii/date atât de la senzori de
percepţie externǎ, despre mediul înconjurător în care aceştia funcţionează, cât şi de la traductoare
(encodere montate la motoarele NXT), care măsoară poziţia elementelor mobile cu care sunt
echipaţi. Datele furnizate de senzori sunt citite şi procesate de CPU-NXT, iar ulterior sunt transferate
cǎtre PC.
Având în vedere sarcinile specifice pentru sistemul robot, precum:
 manipulare de obiecte din mediu, iar în anumite cazuri conlucrarea între doi sau mai
mulţi roboţi cu bază fixă şi/sau mobili,
 evitarea coliziunilor cu obiectele din mediu sau cu alte sisteme robot,
o componentă importantă a sistemului senzorial care va fi studiată este aceea de asigurare a
capacităţii de monitorizare a mediului în zonele de interes.

4.6. Limbajul de programare NXC (Not eXactly C)

Limbajul de programare NXC este un limbaj open source, de nivel înalt, având la bază limbajul C.
Limbajul respectă caracteristicile de bază a limbajului C (cicluri, decizii, selecţii, operatori logici,
etc.), iar instrucţiunile se pot grupa în proceduri (metode) sau funcţii. Fiind un limbaj specific
programării roboţilor include, în plus, o varietate largă de macrouri, constante şi funcţii predefinite,
utile pentru comanda şi controlul motoarelor, citirea senzorilor; afişarea de informaţii şi grafice pe
display, necesară interfaţării cu utilizatorul; comunicaţia Bluetooth şi altele. Limbajul oferă astfel
flexibilitate programatorului în vederea implementării unor sarcini specifice aplicaţiilor roboticii,
precum: menţinerea direcţiei şi orientării specificate, determinarea poziţiei în scopul calculului
odometriei, achiziţia de informaţii de la senzori, etc.
Aplicaţiile scrise în acest limbaj rulează peste firmware-ul standard al robotului.

25
Conf. S.Paturca
Programele se editează, compilează şi link-editează în mediul de dezvoltare integrat (IDE) Bricx
Command Center (BricxCC) pe PC, după care se încărcă, prin USB, sau Bluetooth, în memoria
program a unităţii de comandă NXT, unde se execută şi testează. Programele sunt rulate pe robot
atunci când pe display-ul brick-ului este selectat meniul MY files. Acesta este fişierul în care sunt
memorate programele descărcate pe brick-ul NXT.
Orice program este structurat pe task-uri. Task-ul principal (main) trebuie să fie obligatoriu prezent.

Etapele ce se parcurg pentru realizarea programelor în limbajul NXC

 Se lansează mediul de dezvoltare Bricx Command Center şi se va edita
programul într-o fereastră de lucru.
 Se selectează, din meniul principal Tools, submeniul Find Brick, unde se
alege conexiunea USB şi tipul de brick – NXT, pas necesar pentru stabilirea
conexiunii PC-ului cu robotul.
 Se salvează programul cu nume şi extensia .nxc; numele programului nu
trebuie să depăşească 15 caractere.
 Pentru compilarea programului se selectează opţiunea Compile (din
meniulcu acelaşi nume)
 Se depanează programul, se descarcă şi se rulează programul pe brick-ul
NXT. Programul se descarcă pe brick atunci când pe display-ul LCD este
selectat meniul MY files. Este fişierul în care sunt memorate programele
descărcate şi rulate pe brick-ul NXT.
 Se utilizeazǎ butoanele laterale pentru navigare prin meniul NXT, iar pentru
selectarea fişirelor descǎrcate pe robot se apasǎ butonul portocaliu central.
 Execuţia programului se opreşte selectând opţiunea Stop din meniul
principal al mediului de programare BricxCC.
.

4.7. Programe demonstrative rulabile pe MCU robotului NXT

4.7.1. Determinarea preciziei encoderului

Este cunoscut faptul că precizia maximă care se poate obţine într-un sistem de reglare a
poziţiei/vitezei este dată de rezoluţia encoderului. Întrucât rezoluţia encoderelor montate pe
motoarele kit-ului NXT nu este specificată de producător, aceasta se va determina experimental în
cadrul acestei aplicaţii.
Observaţie: În comenzile din API-ul NXC, cea mai mică valoare a poziţiei dorite sau citite este
de 1grad. Aceasta este stabilită la nivelul firmware-ului şi nu trebuie să se confunde cu precizia
encoderului.
În această aplicaţie se va determina precizia encoderului prin măsurare experimentală. Această
se va face prin rotirea manuală a rotorului 360 grade, având în prealabil marcate cu un marker partea
fixă şi cea mobilă a motorului. Pentru a minimiza erorile umane de citire, se vor realiza cel puţin 10
rotaţii complete. Pe baza valorii finale se va calcula apoi media.

26
Conf. S.Paturca
 Programul următor permite citirea valorii finale pe display-ul brick-ului la apăsarea butonului
central portocaliu.
Program demonstrativ
/*****************************************************************************
Determinarea preciziei encoderului
*****************************************************************************/
// Macro-ul pt "breakpoint", realizat in lucrarea 2.
#define BREAKPOINT_AFISARE_VAR(string_x,x){\
TextOut(0,LCD_LINE1,string_x,true);\
NumOut(0,LCD_LINE2,x);\
TextOut(0,LCD_LINE4,"BUTON CENTRU >>");\
Wait(1000);\
while(ButtonPressed(BTNCENTER,true)==0)\
{\
}\
}
/*****************************************************************************/
// Variabile
/*****************************************************************************/
long unghi;

task main()
{
while(ButtonPressed(BTNCENTER,true)==0)
{
}
/* Functia ce permite citirea in variabila unghi a pozitiei de la contorul asociat encoderului este
urmatoarea: */
unghi = MotorTachoCount(OUT_A);
TextOut(0,LCD_LINE1,"unghi=");
NumOut(0,LCD_LINE2,unghi);
Wait(5000); //functie prin care se introduce un timp de aşteptare, argumentul este in ms.
}
/*****************************************************************************************************/
Software-ul de dezvoltare oferă facilităţi în achiziţia de date de la senzorii interni şi permite
controlul vitezei motoarelor (de translatie, rotatie), şi al roţilor în mod independent, acceleratiei,
deceleratiei, pozitiei.

4.7.2. Controlul poziţiei motoarelor

Motoarele pot fi rotite utilizând funcţii predefinite ce permit specificarea unghiului de rotaţie
a axului motor în grade. Aceste funcţii utilizează implicit regulatorul de poziţie al firmware-ului.

27
Conf. S.Paturca
  RotateMotor('port', pwr, grade) - roteşte motoarele conectate la porturile de
ieşire, cu viteza „pwr” (aleasa în intervalul 0-100), un număr de grade specificat.
Direcţia de rotire a motoarelor se poate specifica prin semnul argumentului viteză şi unghi,
astfel: dacă viteza şi unghiul au acelaşi semn motorul se roteşte înainte, altfel dacă semnul este diferit
motorul se va roti înapoi.
Pentru testare va rula următorul program
/*****************************************************************************************************/
task main()
{
RotateMotor ( OUT_BC , 50 , 360 );
RotateMotor ( OUT_C , 50 ,- 360 );
}
/*****************************************************************************************************/
 RotateMotorPID(port, viteza, grade, kp, ki, kd)- permite rotirea
motoarelor ca şi funcţia de mai sus, specificând şi coeficienţii regulatorului.
În aplicaţia următoare se va poziţiona motorul la un număr de grade dorit folosind comenzi de
poziţionare în buclă închisă. Se va analiza influenţa coeficienţilor regulatorului asupra erorii
staţionare şi suprareglajului. Pentru a putea vizualiza variaţia în timp a poziţiei, se va rula următorul
program NXC. Cu ajutorul acestuia sunt citite, într-un vector, valorile intermediare ale poziţiei până
la stabilizare, după care vectorul este salvat într-un fişier text.
Fişierul conţinând datele înregistrate se va descărca apoi pe PC, prin USB, cu ajutorul tool-
ului „NXT Explorer” din meniul „Tools” al BricxCC. Reprezentarea grafică a variaţiei poziţiei se
poate face de exemplu în Matlab, după ce se importă fişierul text.
Program demonstrativ
/******************************************************************************
Test reglaj de pozitie unghiulara.
Se inregistreaza intr-un vector variatia in timp a pozitiei pentru diferite viteze si coeficienti ai regulatorului PID.
Vectorul se salveaza intr-un fisier care va fi uploadat pe PC prin USB si apoi importat in Matlab pentru
reprezentare grafica.
Task-uri:
Task-uri simultane: citire encoder, pozitionare
Task final: salvare date in fisier
*********************************************************************************************************/
// Constante
/****************************/
#define NUME_FISIER „RaspPoz120.txt” /*fisierul in care se va salva evolutia pozitiei*/
#define POZITIA_DORITA 120 // pozitia unghiulara de atins [grade]
#define PWR 50 // „viteza” maxima de rotatie [%]
// Coeficientii regulatorului
#define KP 40 // Coef. Proportional (default 40)
#define KI 10 // Coef. Integral (default 20)
#define KD 40 // Coef. Derivativ (default 100)

28
Conf. S.Paturca
#define DIM_VECTOR_POZITIE 2000 // numarul de inregistrari ale pozitiei

#define BREAKPOINT_AFISARE_VAR(string_x,x){\
TextOut(0,LCD_LINE1,string_x,true);\
NumOut(0,LCD_LINE2,x);\
TextOut(0,LCD_LINE4,”BUTON CENTRU >>”);\
Wait(1000);\
while(ButtonPressed(BTNCENTER,true)==0)\
{\
}\
}
/*****************************************************************************/
// Variabile
/*****************************************************************************/
short Kp; // Coef. Proportional
short Ki; // Coef. Integral
short Kd; // Coef. Derivativ
short Pozitie[DIM_VECTOR_POZITIE]; /* vector in care este stocata pozitia pe durata rotatiei
*/
unsigned long dt; // pasul de timp intre doua esantioane ale pozitiei
unsigned long CrtTick, OldTick; /* valoarea curenta / anterioara a ceasului de sistem */
short tmp;

byte fileHandle;
unsigned short fileSize;
unsigned short nBytes;
short bytesWritten;
string tmp_string;
task RotesteMotor()
{
//Roteste motorul B cu viteza maxima PWR catre pozitia dorita folosind regulatorul de
//pozitie cu coeficientii Kp, Ki, Kd impliciţi
//RotateMotor(OUT_B, PWR, POZITIA_DORITA);
//Roteste motorul B cu viteza maxima PWR catre pozitia dorita folosind regulatorul de
//pozitie cu coeficientii Kp, Ki, Kd specificati ca parametri
RotateMotorPID(OUT_B, PWR, POZITIA_DORITA, KP, KI, KD);
}
task CitesteEncoder()
{
short k;
for (k=0;k<DIM_VECTOR_POZITIE;k++)
{
// Citeste date de la encoder

29
Conf. S.Paturca
 Pozitie[k] = MotorTachoCount(OUT_B);
// Calculeaza durata intre ultimele doua esantioane si o insumeaza la durata anterioara
CrtTick = CurrentTick();
dt += CrtTick – OldTick;
OldTick = CrtTick;
}
// Calculeaza pasul de esantionare mediu, in [us]
dt = 1000*dt/(k+1);
}
task Salveaza()
{
short k;
// specifica faptul ca acest task urmeaza dupa task-ul ”CitesteEncoder”.
Follows(CitesteEncoder);
// Salveaza in fisier variatia in timp a pozitiei
// ---------------------------------------------------------
DeleteFile(NUME_FISIER);
CreateFile(NUME_FISIER, 65536, fileHandle); /* Aloca 64KB pt fisier */
// Scrie un titlu pt fisier
WriteLnString(fileHandle,”Raspunsul in timp al pozitiei
unghiulare”, bytesWritten);
// Scrie pozitia dorita
WriteString(fileHandle,”Pozitia dorita [grade] = „,
bytesWritten);
tmp_string = NumToStr(POZITIA_DORITA);
WriteLnString(fileHandle,tmp_string, bytesWritten);
WriteString(fileHandle,”viteza maxima [%] = „, bytesWritten);
tmp_string = NumToStr(PWR);
WriteLnString(fileHandle,tmp_string, bytesWritten);
// Scrie parametrii actuali ai regulatorului de pozitie
WriteLnString(fileHandle,”Parametrii regulatorului de
pozitie:”, bytesWritten);
Kp = MotorRegPValue(OUT_B);
tmp_string = NumToStr(Kp);
WriteString(fileHandle,”Kp = „, bytesWritten);
WriteLnString(fileHandle,tmp_string, bytesWritten);
Ki = MotorRegIValue(OUT_B);
tmp_string = NumToStr(Ki);
WriteString(fileHandle,”Ki = „, bytesWritten);
WriteLnString(fileHandle,tmp_string, bytesWritten);
Kd = MotorRegDValue(OUT_B);
tmp_string = NumToStr(Kd);
WriteString(fileHandle,”Kd = „, bytesWritten);
WriteLnString(fileHandle,tmp_string, bytesWritten);

30
Conf. S.Paturca
 //Scrie pasul mediu de esantionare
WriteString(fileHandle,”pasul de esantionare dt ~= „,
bytesWritten);
tmp_string = NumToStr(dt);
WriteString(fileHandle,tmp_string, bytesWritten);
WriteLnString(fileHandle,”[us]”, bytesWritten);
// Salveaza datele in fisier
for (k=0;k<DIM_VECTOR_POZITIE;k++)
{
WriteString(fileHandle,” „, bytesWritten);
tmp_string = NumToStr(Pozitie[k]);
WriteLnString(fileHandle,tmp_string, bytesWritten);
}
CloseFile(fileHandle);
// Afiseaza pozitia finala pe display:
//tmp = Pozitie[DIM_VECTOR_POZITIE-1];
//BREAKPOINT_AFISARE_VAR(„Pozitia finala = „, tmp);
}
task main()
{
ResetTachoCount(OUT_B);
OldTick = CurrentTick();
dt = 0;
// Specifica faptul ca task-ul principal precede execuţia task-urilor „CitesteEncoder” si „RotesteMotor”
Precedes(CitesteEncoder,RotesteMotor);
}
/************************************************************************************************************/
Programul se descarcǎ în memoria unitǎţii centale a robotului, unde este rulează şi testează. Pentru
programul anterior date măsurate de la encoder şi stocate în memoria MCU sunt utile pentru
prelucrări ulterioare. Altfel spus, la încheierea rulării programului de către robot, acesta se poate
reconecta la PC, prin USB pentru descǎrcarea fişierului cu datele salvate în memoria
microcontrolerului robotului.
Paşi necesari pentru descărcarea datelor salvate de robot:
 Se deschide ecranul NXT Explorer din meniul „Tools” al BricxCC IDE, care conţine fişiere
şi programe existente în memoria robotului NXT, aflate în zona stângǎ a ecranului şi fişerele
dupǎ PC - în dreapta. Se poziţionează cursorul mouse-ului deasupra elementelor din bara cu
unelte a ferestrei NeXT Explorer, evidenţiate în figura 14.20, pentru a se afişa mesajul care
informează despre denumirea uneltei.
 Se identifică şi selectează fişierul text, salvat ca text, prin nume şi extensie "nume.txt“. Se
alege din meniul principal butonul de descărcare către PC a fişierului dorit.
Pentru reprezentarea grafică a semnalului măsurat se va lua în calcul intervalul de timp în care s-au
preluat eşanitioanele.

31
Conf. S.Paturca
 Buton de descărcare a fişierelor cǎtre PC

Programe
şi fişiere
existente
pe în
memoria Fişiere
robotului existente
Fişierul de descărcat pe PC
nume.txt
Figura 14.20 Ecranul NXT Explorer necesar pentru vizualizarea pe PC, a programelor şi
fişerelor salvate în memoria MCU robotului

În figura 14.21 este prezentată evoluţia în timp a poziţiei unghiulare, obţinută experimental.

Figuar 14.21 Evoluţia în timp a poziţiei unghiulare pentru “pwr”=50, Kp=40, Ki=20, Kd=100

Aplicaţie cerută: Să se scrie un program pentru controlul deplasării liniare a robotului mobil
autonom tribot (cu două roţi motoare şi cea de-a treia tractată, doar cu rol de susţinere), până la
întâlnirea unui obstacol, pe care-l ocoleşte prin viraj pe o roată. Deplasarea se va testa software
pentru două situaţii: mişcare contolată şi liberă. Pentru cazul deplasării robotului cu control al
mişcǎri liniare se implementează un regulator proporţional construit software.
Note: Motoarele vor fi rotite utilizând doar funcţii predefinite simple, precum:
 OnFwd(OUT_n,p) – funcţie pentru pornire şi rotire înainte cu o putere p (exprimată
în procente din puterea maximă), a motorului/motoarelor conectate la portul
(porturile) n;
 OnRev(OUT_n,p) – funcţie pentru pornire şi rotire înapoi cu o putere p (exprimată
în procente din puterea maximă), a motorului/motoarelor conectate la portul
(porturile) n;

32
Conf. S.Paturca
  Off(OUT_n) – funcţie pentru oprirea motorului (motoarelor) conectat la portul n,
prin frână electrică;
 Float(OUT_n) sau Coast(OUT_n) – funcţii pentru oprirea motoarelor prin
întreruperea alimentării;
Notǎ: Adresele porturilor de ieşire pot fi definite ca variabile sau constante.
Indicaţie: În figurile 14.22 sunt ilustrate exemple de teste efectuate cu robotul mobil autonom. În
fiecare imagine robotul pivoteazǎ pe o roatǎ pentru a evita un obstacol. Momentul schimbǎrii
direcţiei de mers este evidenţiat în ambele cazuri. Rezultatele testelor reflectǎ efectul regulatorului
software construit pentru mişcarea linearǎ.
Mers liniar fără control al mişcării Mers liniar cu control în buclă închisă
al mişcării

Figura 14.22.a.Variaţia în timp a unghiului Figura 14.22.b Variaţia în timp a

din jurul axului motorului fără un unghiului din jurul axului motorului în
control al mişcării cazul controlului mişcării
Fereastra de timp este 8s.

33
Conf. S.Paturca