Modlisation d'un systme Vehicle Dynamics

Ouvrez Cet exemple

Cet exemple montre non linaire modlisation de la dynamique du vhicule bote grise.
Beaucoup de nouvelles caractristiques du vhicule (comme les programmes de stabilit
lectronique (ESP), pression indirecte des pneus Systmes d'exploitation (TPMS), des
systmes de surveillance de route friction des pneus, etc.) de surveillance reposent sur des
modles de la dynamique du vhicule sous-jacents. Le modle dit vhicule de la bicyclette est
une structure de modle relativement simple qui est frquemment utilis dans la littrature de
la dynamique du vhicule. Dans cet exemple, nous allons commencer pied avec cette
structure de modle et essayer d'estimer le sens longitudinal et la rigidit latrale d'un
pneumatique. Le travail de modlisation relle a t ralise par Erik Narby dans son travail
de matrise NIRA Dynamics AB, Sude.

La dynamique du vhicule Modlisation

IDNLGREY vhicule Modle

Les donnes entres-sorties

A. Systme d'identification utilisant simul Haute Tire Rigidit donnes

B. Identification System Utilisation simule pneu faible rigidit donnes

C. Identification System Utilisation mesure Volvo V70 donnes

Remarques finales

Information Supplmentaire

La dynamique du vhicule Modlisation

La figure suivante illustre la situation de modlisation du vhicule pour tre considr.

Figure 1: Vue schmatique d'un systme de dynamique de vhicule.

Par l'utilisation de la loi du mouvement de Newton et de certaines relations gomtriques de
base, l'v_x (t)de vitesse longitudinale, le v_y (t) de vitesse latrale et le r (t) de taux de lacet
mesure autour du centre de gravit (COG) du vhicule peut sera dcrit par les trois quations
diffrentielles suivantes:
d
-- v_x(t) = v_y(t)*r(t) + 1/m*( (F_x,FL(t)+F_x,FR(t))*cos(delta(t))
dt
- (F_y,FL(t)+F_y,FR(t))*sin(delta(t))
+ F_x,RL(t)+F_x,RR(t)
- C_A*v_x(t)^2)
d
-- v_y(t) = -v_x(t)*r(t) + 1/m*( (F_x,FL(t)+F_x,FR(t))*sin(delta(t))
dt
+ (F_y,FL(t)+F_y,FR(t))*cos(delta(t))
+ F_y,RL(t)+F_y,RR(t))
d
-- r(t)
= 1/J*( a*( (F_x,FL(t)+F_x,FR(t))*sin(delta(t))
dt
+ (F_y,FL(t)+F_y,FR(t))*cos(delta(t)))
- b*(F_y,RL(t)+F_y,RR(t)))

o indice x est utilis pour indiquer que la force F agit dans la direction longitudinale et y qui
agit dans la direction latrale. Les abrviations FL, FR, RL et tiquettes de RR les pneus:
avant gauche, avant droit, arrire gauche et droite, respectivement arrire. La premire
quation dcrivant l'acclration longitudinale contient galement un terme de rsistance
l'air qui est suppose tre une fonction quadratique de la vitesse longitudinale du vhicule v_x
(t). En outre, delta (t) (e entre) est l'angle de braquage, J le moment d'inertie, et a et b la
distance entre les centre de gravit de l'essieux avant et arrire, respectivement.

Supposons que les forces de pneus peuvent tre modliss travers les approximations
linaires suivantes:
F_x,i(t) = C_x*s_i(t)
F_y,i(t) = C_y*alpha_i(t)

for i = {FL, FR, RL, RR}

o C_x et C_y sont la rigidit longitudinale et latrale des pneus, respectivement. Ici, nous
avons suppos que ces paramtres de rigidit sont les mmes pour tous les 4 pneus. s_i (t) est
le soi-disant (longitudinale) glissement de pneu i et alpha_i (t) un angle de patinage du pneu.
Pour un vhicule conduit la roue avant (comme considr ici), la glisse s_FL (t) et s_FR (t)
sont drives partir des vitesses de roues individuelles (mesure) en supposant que les roues
arrire ne montrent pas de glissement (c.--s_RL ( t) = s_RR (t) = 0). Par consquent, les
bulletins sont entres la structure de notre modle. Pour les roues avant, le pneu glissement
anges alpha_Fj (t) peut tre approche par (lorsque v_x (t)> 0)
alpha_Fj(t) = delta(t) - arctan((v_y(t) + a*r(t))/v_x(t))
~ delta(t) - (v_y(t) + a*r(t))/v_x(t)
for j = {L, R}

Pour les roues arrire, le glissement des pneus anges alpha_Rj (t) sont aussi tire et calcule
comme
alpha_Rj(t) = - arctan((v_y(t) - b*r(t))/v_x(t))
~ - (v_y(t) - b*r(t))/v_x(t)

for j = {L, R}

Avec J = 1 / ((0,5 * (a + b)) ^ 2 * m), nous pouvons mettre en place prochaine d'une structure
d'espace d'tat dcrivant la dynamique du vhicule. Prsentez les tats:
x1 (t) = v_x (t) la vitesse longitudinale [m / s].
x2 (t) = v_y (t) la vitesse latrale [m / s].
x3 (t) = r (t) Taux Yaw [rad / s].

les cinq signaux d'entre mesures ou calcules

U1 (t) = s_FL (t) Slip du pneu avant gauche [rapport].
u2 (t) = s_FR (t) Slip du pneu avant droit [rapport].
U3 (t) = s_RL (t) Slip du pneu arrire gauche [rapport].
U4 (t) = s_RR (t) Slip du pneu arrire droit [du rapport].
U5 (t) = delta (t) Angle de braquage [rad].

et les paramtres du modle:

m Masse du vhicule [kg].
a une Distance de l'essieu avant au COG [m].
b Distance l'essieu arrire pour COG [m].
Cx rigidit longitudinale du pneu [N].
La rigidit du pneu Cy latrale [N / rad].
CA coefficient de rsistance de l'air [1 / m].

Les sorties du systme sont les longitudinal de la vitesse du vhicule y1 (t) = x1 (t),
l'acclration du vhicule latral (mesure par un acclromtre):
y2(t) = a_y(t) = 1/m*( (F_x,FL(t)+F_x,FR(t))*cos(delta(t))
- (F_y,FL(t)+F_y,FR(t))*sin(delta(t))
+ F_x,RL(t)+F_x,RR(t))

et la vitesse de lacet y3 (t) = r (t) (mesure par un gyromtre).

Mettez-les ensemble, nous arrivons la structure du modle d'espace d'tat suivants:

d
-- x1(t) = x2(t)*x3(t) + 1/m*( Cx*(u1(t)+u2(t))*cos(u5(t))
dt
- 2*Cy*(u5(t)-(x2(t)
+a*x3(t))/x1(t))*sin(u5(t))
+ Cx*(u3(t)+u4(t))
- CA*x1(t)^2)
d
-- x2(t) = -x1(t)*x3(t) + 1/m*( Cx*(u1(t)+u2(t))*sin(u5(t))
dt
+ 2*Cy*(u5(t)-(x2(t)
+a*x3(t))/x1(t))*cos(u5(t))
+ 2*Cy*(b*x3(t)-x2(t))/x1(t))
d
-- x3(t) = 1/((0.5*(a+b))^2)*m)*( a*( Cx*(u1(t)+u2(t)*sin(u5(t))
dt
+ 2*Cy*(u5(t) - (x2(t)
+a*x3(t))/x1(t))*cos(u5(t)))
- 2*b*Cy*(b*x3(t)-x2(t))/x1(t))
y1(t) = x1(t)
y2(t) = 1/m*( Cx*(u1(t)+u2(t))*sin(u5(t))
+ 2*Cy*(u5(t)-(x2(t)+a*x3(t))/x1(t))*cos(u5(t))
+ 2*Cy*(b*x3(t)-x2(t))/x1(t))
y3(t) = x3(t)

IDNLGREY vhicule Modle

Comme base de nos expriences d'identification des vhicules, nous devons d'abord crer un
fichier de modle de IDNLGREY dcrivant ces quations de vhicules. Ici, nous comptons
sur la modlisation C-MEX et crer un fichier de modle de vehicle_c.c, dans lequel NY est
fix 3. Les fonctions de l'tat et de mise jour de sortie de vehicle_c.c, compute_dx et
compute_y, sont quelque peu complexe et comprend plusieurs norme C-dfini fonctions
mathmatiques, comme cos (.) et le pch (.) ainsi que pow (.) pour calculer la puissance de
son argument.
La fonction de mise jour de l'tat compute_dx retourne dx (argument 1) et utilise 3
arguments d'entre: le vecteur d'tat x, le vecteur d'entre u, et les six paramtres scalaires
encods en P (T et auxvar du fichier de modle modle C-MEX ont t enlevs ici):
/ * quations de l'tat. * /
compute_dx void (doubles, doubles dx * * x, double * u, double **p)
{
/ * Rcuprer les paramtres du modle. * /
double * m, * a, b *, * Cx, Cy *, * CA;
m = p [0]; / * La masse du vhicule. * /
a = p [1]; / * Distance de l'essieu avant au COG. * /
b = p [2]; / * Distance l'essieu arrire pour COG. * /
Cx = p [3]; / * La rigidit du pneu longitudinale. * /
Cy = p [4]; / * Rigidit latrale du pneu. * /
CA = p [5]; / * Coefficient de rsistance de l'air. * /
/ * X [0]: vitesse longitudinal du vhicule. * /
/ * X [1]: vitesse de vhicule latrale. * /
/ * X [2]: vitesse de lacet. * /
dx[0] = x[1]*x[2]+1/m[0]*(Cx[0]*(u[0]+u[1])*cos(u[4])
-2*Cy[0]*(u[4]-(x[1]+a[0]*x[2])/x[0])*sin(u[4])
+Cx[0]*(u[2]+u[3])-CA[0]*pow(x[0],2));
dx[1] = -x[0]*x[2]+1/m[0]*(Cx[0]*(u[0]+u[1])*sin(u[4])
+2*Cy[0]*(u[4]-(x[1]+a[0]*x[2])/x[0])*cos(u[4])
+2*Cy[0]*(b[0]*x[2]-x[1])/x[0]);
dx[2] = 1/(pow(((a[0]+b[0])/2),2)*m[0])

*(a[0]*(Cx[0]*(u[0]+u[1])*sin(u[4])
+2*Cy[0]*(u[4]-(x[1]+a[0]*x[2])/x[0])*cos(u[4]))
-2*b[0]*Cy[0]*(b[0]*x[2]-x[1])/x[0]);
}

La fonction de mise jour de sortie compute_y retourne y (argument 1) et utilise 3 arguments

d'entre: le vecteur d'tat x, le vecteur d'entre u, et cinq des six paramtres (la rsistance de
l'air CA est pas ncessaire) encods en p:
/ * quations de sortie. * /
compute_y void (double * y, double * x, double * u, double p **)
{
/ * Rcuprer les paramtres du modle. * /
double * m = p [0]; / * La masse du vhicule. * /
double * a = p [1]; / * Distance de l'essieu avant au COG. * /
double * b = p [2]; / * Distance l'essieu arrire pour COG. * /
double * Cx = p [3]; / * La rigidit du pneu longitudinale. * /
double * Cy = p [4]; / * Rigidit latrale du pneu. * /
/ * Y [0]: vitesse longitudinale du vhicule. * /
/ * Y [1]: l'acclration du vhicule latral. * /
/ * Y [2]: vitesse de lacet. * /
y[0] = x[0];
y[1] = 1/m[0]*(Cx[0]*(u[0]+u[1])*sin(u[4])
+2*Cy[0]*(u[4]-(x[1]+a[0]*x[2])/x[0])*cos(u[4])
+2*Cy[0]*(b[0]*x[2]-x[1])/x[0]);
y[2] = x[2];
}

Avoir un bon fichier de structure du modle, l'tape suivante consiste crer un objet de
IDNLGREY refltant la situation de modlisation. Pour faciliter la comptabilit, nous
prcisons galement les noms et units des entres et sorties.
Filename = 'vehicle_c';% fichier dcrivant la structure du modle.
Afin = [3 5 3];% des commandes de modles [nx ny nu].
Paramtres = [1,700; 1,5; 1,5; 1.5e5; 4e4; 0,5];% de paramtres
initiaux.
InitialStates = [1; 0; 0];% des tats initiaux initiaux.
Ts = 0;% systme en temps continu.
nlgr = idnlgrey (FileName, Ordre, Paramtres, InitialStates, Ts, ...
'Nom', 'Vlo modle de vhicule', 'TimeUnit', 's');
nlgr.InputName = {'Slip sur pneu avant gauche';% u ... (1).
'Slip sur pneu avant droit';% u ... (2).
'Slip sur le pneu arrire gauche';% u ... (3).
'Slip sur pneu arrire droit';% u ... (4).
'Angle de braquage'};% u ... (5).
nlgr.InputUnit = {'ratio'; 'ratio'; 'ratio'; 'ratio'; 'rad'};
nlgr.OutputName = {'Long. vitesse '; ...% y (1); Vitesse
longitudinale du vhicule
Lat. accl ';.% y ... (2); L'acclration du
vhicule latral
Taux de lacet '}; ...% y (3).
nlgr.OutputUnit = {'m / s'; 'm / s ^ 2'; 'rad / s'};

Les noms et les units des tats (initiaux) et les paramtres du modle sont spcifis via
SETINIT. Nous utilisons aussi cette commande pour spcifier que le premier tat initial (la

vitesse longitudinale) devrait tre strictement positif pour le modle soit valide et de prciser
que tous les paramtres du modle doivent tre strictement positif. Ces contraintes seront
ensuite honors lors de l'excution estimation initiale de l'Etat et / ou les paramtres du
modle.
nlgr = SETINIT (nlgr, 'Nom', {'vitesse du vhicule longitudinale' ... x%
(1).
Vitesse latrale du vhicule ...% x (2).
Taux de lacet '}); ... x% (3).
nlgr = SETINIT (nlgr, unit, {'m / s , M / S , rad / s'});
nlgr.InitialStates (1) .Minimum = eps (0);% la vitesse longitudinale> 0
pour le modle soit valide.
nlgr = setpar (nlgr, 'Nom', {masse du vhicule; ...% m.
'Distance de l'essieu avant au COG'; ...% un
'Distance l'essieu arrire pour COG'; ...% b.
Rigidit longitudinale du pneu '; ...% Cx.
La rigidit latrale des pneus '; ... Cy%.
Coefficient de rsistance de l'air '}); ...% CA.
nlgr = setpar (nlgr, unit, {kg; m, m, N, N / rad ';' 1 / m
'});
nlgr = setpar (nlgr, minimum, num2cell (eps (0) * ceux (6, 1)));% Tous
les paramtres> 0!

Quatre des six paramtres de cette structure du modle peut facilement tre obtenu travers la
feuille de donnes du vhicule en question:
m =1700 kg
a = 1,5 m
b = 1,5 m
CA = 0,5 ou 0,7 1 / m (voir ci-dessous)

Par consquent, nous ne serons pas estimer ces paramtres:

nlgr.Parameters (1) .Fixed = true;
nlgr.Parameters (2) .Fixed = true;
nlgr.Parameters (3) .Fixed = true;
nlgr.Parameters (6) .Fixed = true;

Grce cela, un rsum du texte de la structure du modle de IDNLGREY entre est obtenue
par prsenter comme suit.
prsente (nlgr);
nlgr =
Continu temps non linaire modle gris-case dfinie par 'vehicle_c'
(MEX-file):
dx / dt = F (t, u (t), x (t), p1, ..., P6)
y (t) = H (t, u (t), x (t), p1, ..., P6) + e (t)
avec 5 entres, 3 tats, 3 sorties, et 2 paramtres libres (sur 6).
Entres:
u (1)
u (2)
u (3)
u (4)

Slip sur pneu avant gauche (t) [rapport]

Slip sur pneu avant droit (t) [rapport]
Slip sur le pneu arrire gauche (t) [rapport]
glissement sur le pneu arrire droit (t) [rapport]

u (5) Angle de braquage (t) [rad]

Unis: valeur initiale
x (1) la vitesse du vhicule longitudinale (t) [m / s] xinit @ exp1 1
(fix) dans] 0, Inf]
x (2) la vitesse du vhicule latral (t) [m / s] xinit @ exp1 0 (fix)
dans [-Inf, Inf]
x (3) le taux de lacet (t) [rad / s] xinit @ exp1 0 (fix) dans [-Inf,
Inf]
Les sorties:
y (1) Long. la vitesse (t) [m / s]
y (2) Lat. accl. (t) [m ^ / s 2]
y (3) le taux de lacet (t) [rad / s]
Paramtres: valeur
la masse du vhicule p1 [kg] 1700 (correction) dans] 0, Inf]
p2 Distance de l'essieu avant au COG [m] 1,5 (fix) dans] 0, Inf]
p3 Distance l'essieu arrire pour COG [m] 1,5 (fix) dans] 0, Inf]
la rigidit du pneu p4 longitudinale [N] 150000 (est) dans] 0, Inf]
p5 latral rigidit du pneu [N / rad] 40000 (est) dans] 0, Inf]
coefficient de rsistance p6 Air [1 / m] 0,5 (fix) dans] 0, Inf]
Nom: modle de vhicule de vlos
Statut:
Cre par la construction ou la transformation directe. Non estim.
Plus d'informations dans le "Rapport" la proprit de modle.

Les donnes entres-sorties

ce stade, nous chargeons les donnes d'entre-sortie disponibles. Ce fichier contient des
donnes provenant de trois expriences diffrentes:
A. donnes simules avec des pneus de haute rigidit [Y1 de U1].
B. Donnes simules avec des pneus de faible raideur [Y2 u2].
C. Les donnes mesures partir d'une Volvo V70 [Y3 U3].

Dans tous les cas, les temps d'chantillonnage Ts = 0.1 secondes.

charge (fullfile (matlabroot, bote outils, ident, iddemos ','
donnes ',' vehicledata '));

A. Systme d'identification utilisant simul Haute Tire Rigidit donnes

Dans notre premire exprience d'identification du vhicule nous considrons donnes
simules de rigidit leve de pneus. Une copie de la structure du modle nlgr et une z1 objet
IDDATA refltant cette situation particulire de modlisation est d'abord cr. 5 Les signaux
d'entre sont stocks dans u1 et les signaux de sortie y1 3. Les entres de glissement
(gnrs partir des signaux de vitesse de roue) pour les roues avant ont t choisis pour tre
sinusodale avec un dcalage constant; la vitesse de lacet est aussi sinusodale mais avec une
amplitude et une frquence diffrente. En ralit, la situation est quelque peu artificielle, parce
que l'on excite rarement le vhicule tant dans la direction latrale.
nlgr1 = nlgr;
nlgr1.Name = 'modle de vhicule vlo avec une grande rigidit du pneu';
z1 = iddata (Y1, U1, 0,1, 'Nom', 'haute rigidit pneu donnes du vhicule
simul');
z1.InputName = nlgr1.InputName;

z1.InputUnit = nlgr1.InputUnit;
z1.OutputName = nlgr1.OutputName;
z1.OutputUnit = nlgr1.OutputUnit;
z1.Tstart = 0;
= z1.TimeUnit 'S';

Les entres et sorties sont prsents dans deux figures de l'intrigue.

h_gcf = gcf;
ensemble (h_gcf, 'DefaultLegendLocation', 'sud');
h_gcf.Position = [100 100 795 634];
pour i = 1: z1.Nu
subplot (z1.Nu, 1, i);
terrain (z1.SamplingInstants, z1.InputData (:, i));
titre ([num2str (i) 'entre #' ':' z1.InputName {i}]);
xlabel ('');
axe serr;
fin
xlabel ([z1.Domain '(' z1.TimeUnit ')']);

Figure 2: Entres un systme de vhicule avec une grande rigidit du pneu.

pour i = 1: z1.Ny
subplot (z1.Ny, 1, i);
terrain (z1.SamplingInstants, z1.OutputData (:, i));
titre ([num2str (i) 'sortie' # ':' z1.OutputName {i}]);
xlabel ('');
axe serr;
fin
xlabel ([z1.Domain '(' z1.TimeUnit ')']);

Figure 3: Sorties d'un systme de vhicule avec une grande rigidit du pneu.
La prochaine tape est d'tudier la performance du modle initial et pour cela nous effectuer
une simulation. Notez que l'tat initial a t fix une valeur non nulle que le premier tat (la

vitesse du vhicule longitudinale) est utilis comme dnominateur dans la structure du

modle. Une comparaison entre le vrai et les sorties simules (avec le modle initial) est
reprsent dans une fentre de trac.
CLF
comparer (z1, nlgr1, [], CompareOptions ('InitialCondition', 'modle'));

Figure 4: Comparaison entre les vrais rsultats et les sorties simules du modle de vhicule
initial avec une grande rigidit du pneu.
Afin d'amliorer l'ajustement du modle, les deux paramtres de rigidit du pneu Cx et Cy
sont ensuite estims, et une nouvelle simulation avec le modle estim est effectue.
nlgr1 = nlgreyest (z1, nlgr1);

Une comparaison entre le vrai et les sorties simules (avec le modle estim) est reprsent
dans une fentre de trac.
comparer (z1, nlgr1, [], CompareOptions ('InitialCondition', 'modle'));

Figure 5: Comparaison entre les vrais rsultats et les sorties simules du modle de vhicule
estime avec une grande rigidit du pneu.
La performance de simulation du modle estim est assez bonne. Les paramtres de rigidit
estims sont galement proches de ceux utiliss dans Simulink pour gnrer la vraie
donnes de sortie:
disp ('True estime');

fprintf (rigidit longitudinale:% 6.0f% 6.0f \ n ', 2e5, nlgr1.Parameters

(4) .Value);
fprintf (rigidit latrale:% 6.0f% 6.0f \ n ', 5E4, nlgr1.Parameters
(5) .Value);
Vrai estim
Rigidit longitudinale: 200000 198517
La rigidit latrale: 50000 53752

B. Identification System Utilisation simule pneu faible rigidit donnes

Dans la deuxime exprience on rpte la modlisation de la premire exprience, mais
maintenant avec des donnes simules de rigidit du pneumatique basse.
nlgr2 = nlgr;
nlgr2.Name = 'modle de vhicule de vlos avec une faible rigidit du
pneu';
Z2 = iddata (Y2, u2, 0,1, 'Nom', 'pneu faible rigidit donnes du
vhicule simul');
z2.InputName = nlgr2.InputName;
z2.InputUnit = nlgr2.InputUnit;
z2.OutputName = nlgr2.OutputName;
z2.OutputUnit = nlgr2.OutputUnit;
z2.Tstart = 0;
= z2.TimeUnit 'S';

Les entres et sorties sont prsents dans deux figures de l'intrigue.

CLF
pour i = 1: z2.Nu
subplot (z2.Nu, 1, i);
terrain (z2.SamplingInstants, z2.InputData (:, i));
titre ([num2str (i) 'entre #' ':' z2.InputName {i}]);
xlabel ('');
axe serr;
fin
xlabel ([z2.Domain '(' z2.TimeUnit ')']);

Figure 6: Entres un systme de vhicule avec une faible rigidit du pneu.

CLF
pour i = 1: z2.Ny
subplot (z2.Ny, 1, i);
terrain (z2.SamplingInstants, z2.OutputData (:, i));
titre ([num2str (i) 'sortie' # ':' z2.OutputName {i}]);
xlabel ('');
axe serr;
fin
xlabel ([z2.Domain '(' z2.TimeUnit ')']);

Figure 7: Sorties d'un systme de vhicule avec une faible rigidit du pneu.

Ensuite, nous tudions la performance du modle initial (qui a les mmes paramtres que le
modle initial de grande rigidit du pneu). Une comparaison entre le vrai et les sorties
simules (avec le modle initial) est reprsent dans une fentre de trac.
CLF
comparer (Z2, nlgr2, [], CompareOptions ('InitialCondition', 'modle'));

Figure 8: Comparaison entre les vrais rsultats et les sorties simules du modle de vhicule
initial avec une faible rigidit du pneu.
Les deux paramtres de rigidit sont ensuite estims.
nlgr2 = nlgreyest (z2, nlgr2);

Une comparaison entre le vrai et les sorties simules (avec le modle estim) est reprsent
dans une fentre de trac.
comparer (Z2, nlgr2, [], CompareOptions ('InitialCondition', 'modle'));

Figure 9: Comparaison betweentrue sorties et les sorties simules du modle de vhicule

estime avec une faible rigidit du pneu.
La performance de simulation du modle estim est de nouveau trs bon. Mme avec le mme
point de dpart que le paramtre a t utilis dans le cas d'une grande rigidit du pneu, les
paramtres de rigidit estims sont ici aussi proches de ceux utiliss dans Simulink pour
gnrer la vraie donnes de sortie:
disp ('True estime');

fprintf (rigidit longitudinale:% 6.0f% 6.0f \ n ', 1e5, nlgr2.Parameters

(4) .Value);
fprintf (rigidit latrale:% 6.0f% 6.0f \ n ', 2.5e4, nlgr2.Parameters
(5) .Value);
Vrai estim
Rigidit longitudinale: 100000 99573
La rigidit latrale: 25000 26117

C. Identification System Utilisation mesure Volvo V70 donnes

Dans la dernire exprience nous considrons les donnes recueillies dans un Volvo V70.
Comme ci-dessus, nous faisons une copie du modle gnrique du vhicule objet nlgr et crer
un nouvel objet de IDDATA contenant les donnes mesures. Ici, nous avons galement
augment le coefficient de rsistance l'air de 0,50 0,70 pour mieux reflter la situation de
Volvo V70.
nlgr3 = nlgr;
nlgr3.Name = 'Volvo V70 modle de vhicule ;
nlgr3.Parameters (6) .Value = 0,70;% Utilisez un autre CA initial pour les
donnes Volvo.
Z3 = iddata (Y3, U3, 0,1, 'Nom', 'donnes Volvo V70');
z3.InputName = nlgr3.InputName;
z3.InputUnit = nlgr3.InputUnit;
z3.OutputName = nlgr3.OutputName;
z3.OutputUnit = nlgr3.OutputUnit;
z3.Tstart = 0;
= z3.TimeUnit 'S';

Les entres et sorties sont prsents dans deux figures de l'intrigue. Comme on peut le voir,
les donnes mesures sont assez bruyant.
CLF
pour i = 1: z3.Nu
subplot (z3.Nu, 1, i);
terrain (z3.SamplingInstants, z3.InputData (:, i));
titre ([num2str (i) 'entre #' ':' z3.InputName {i}]);
xlabel ('');
axe serr;
fin
xlabel ([z3.Domain '(' z3.TimeUnit ')']);

Figure 10: entres mesures partir d'un vhicule Volvo V70.

CLF
pour i = 1: z3.Ny
subplot (z3.Ny, 1, i);
terrain (z3.SamplingInstants, z3.OutputData (:, i));
titre ([num2str (i) 'sortie' # ':' z3.OutputName {i}]);
xlabel ('');
axe serr;
fin
xlabel ([z3.Domain '(' z3.TimeUnit ')']);

Figure 11: sorties mesures partir d'un vhicule Volvo V70.

Ensuite, nous tudions la performance du modle initial avec les tats initiaux tant estims.
Une comparaison entre le vrai et les sorties simules (avec le modle initial) est reprsent
dans une fentre de trac.
nlgr3 = SETINIT (nlgr3, 'Valeur', {18,7; 0; 0});% tats initiaux
initiaux.
CLF
comparer (Z3, nlgr3);

Figure 12: Comparaison entre les rsultats mesurs et les sorties simules du modle initial
du vhicule Volvo V70.
Les paramtres de rigidit du pneu Cx et Cy sont ensuite estim, dans ce cas, l'aide de la
mthode de recherche de Levenberg-Marquardt, aprs quoi une nouvelle simulation avec le

modle estim est effectue. En outre, nous estimons ici la valeur initiale de la vitesse
longitudinale, alors que les valeurs initiales de la vitesse latrale et de la vitesse de lacet sont
tenus fixs.
nlgr3 = SETINIT (nlgr3, 'fixe', {false; vrai; true});
nlgr3 = nlgreyest (z3, nlgr3, nlgreyestOptions ('SearchMethod', 'lm'));

Une comparaison entre le vrai et les sorties simules (avec le modle estim) est reprsent
dans une fentre de trac.
comparer (Z3, nlgr3);

Figure 13: Comparaison entre les rsultats mesurs et les rsultats simuls du premier
modle de vhicule estime Volvo V70.

Les paramtres de rigidit estims du modle final Volvo V70 sont raisonnables, mais il est ici
inconnue ce que leurs valeurs relles sont.
DISP (estime);
fprintf (rigidit longitudinale:% 6.0f \ n", nlgr3.Parameters (4)
.Value);
fprintf (rigidit latrale:% 6.0f \ n", nlgr3.Parameters (5) .Value);
Estimation
Rigidit longitudinale: 108873
La rigidit latrale: 29964

Plus d'informations sur le modle de vhicule Volvo V70 estime est obtenue par PRESENT.
Il est ici intressant de noter que l'incertitude lie la rigidit du pneu latrale estime est
assez lev (et sensiblement plus lev que pour la rigidit longitudinale du pneu). Cette
incertitude provient en partie de ce que l'acclration latrale est modifie si peu au cours de
l'essai routier.
prsente (nlgr3);
nlgr3 =
Continu temps non linaire modle gris-case dfinie par 'vehicle_c'
(MEX-file):
dx / dt = F (t, u (t), x (t), p1, ..., P6)
y (t) = H (t, u (t), x (t), p1, ..., P6) + e (t)
avec 5 entres, 3 tats, 3 sorties, et 2 paramtres libres (sur 6).
Entres:
u (1) Slip sur pneu avant gauche (t) [rapport]
u (2) Slip sur pneu avant droit (t) [rapport]
u (3) Slip sur le pneu arrire gauche (t) [rapport]
u (4) glissement sur le pneu arrire droit (t) [rapport]
u (5) Angle de braquage (t) [rad]
Unis: valeur initiale
x (1) la vitesse du vhicule longitudinale (t) [m / s] xinit @ exp1
17,6049 (est) dans] 0, Inf]
x (2) la vitesse du vhicule latral (t) [m / s] xinit @ exp1 0 (fix)
dans [-Inf, Inf]
x (3) le taux de lacet (t) [rad / s] xinit @ exp1 0 (fix) dans [-Inf,
Inf]
Les sorties:
y (1) Long. la vitesse (t) [m / s]
y (2) Lat. accl. (t) [m ^ / s 2]
y (3) le taux de lacet (t) [rad / s]
Paramtres: dev standard de valeur
p1 masse du vhicule [kg] 1,700 0 (Fix) dans] 0, Inf]
p2 Distance de l'essieu avant au COG [m] 1,5 0 (fix) dans] 0, Inf]
p3 Distance l'essieu arrire pour COG [m] 1,5 0 (fix) dans] 0, Inf]
p4 longitudinale rigidit du pneu [N] 108873 26,8501 (est) dans] 0,
Inf]
p5 latral rigidit du pneu [N / rad] 29963,5 217,877 (est) dans] 0,
Inf]
coefficient de rsistance p6 Air [1 / m] 0,7 0 (fix) dans] 0, Inf]
Nom: modle de vhicule Volvo V70
Statut:

Condition de terminaison: nombre maximum d'itrations atteint.

Nombre d'itrations: 20, Nombre d'valuations de fonction: 41
Estim l'aide Solver: ode45; Recherche: lm sur le temps des donnes de
domaine "donnes de Volvo V70".
Monter des donnes d'estimation: [-374,2; 29,74; 34,46]%
FPE: 2.362e-07, MSE: 0,3106
Plus d'informations dans le "Rapport" la proprit de modle.

Remarques finales
Estimer les paramtres de rigidit des pneus est dans la pratique un problme assez complexe.
Tout d'abord, les approximations introduites dans la structure du modle ci-dessus sont
valables pour une rgion de fonctionnement plutt troite, et les donnes au cours de fortes
acclrations, freinage, etc., ne peuvent pas tre utiliss. La raideur varie galement en
fonction de l'tat de l'environnement, par exemple, la temprature environnante, la
temprature dans les pneus et les conditions de surface de la route qui ne sont pas pris en
compte dans la structure du modle utilis. Deuximement, l'estimation des paramtres de
rigidit repose fortement sur le style de conduite. Lorsque vous allez tout droit la plupart du
temps comme dans la troisime exprience de l'identification, il devient difficile d'estimer les
paramtres de rigidit (notamment la une latrale), ou, autrement dit, les incertitudes des
paramtres deviennent assez lev.

Information Supplmentaire
Pour plus d'informations sur l'identification des systmes dynamiques avec System
Identification Toolbox visiter le System Identification Toolbox page d'information du
produit.