UNIVERSIDADE FEDERAL DO RIO GRANDE DO NORTE

CENTRO DE TECNOLOGIA
DEPARTAMENTO DE ENGENHARIA DE COMPUTAO E AUTOMAO
CURSO DE ENGENHARIA DE COMPUTAO E AUTOMAO

RELATRIO DO 3 PROJETO

Andr Henrique Matias Pires

Bruno Bagyo de Medeiros Ramos

Natal-RN
2014

Controlador de Velocidade
Utilizando Algoritmos Genticos

Relatrio d disciplina de Inteligncia Artificial

Aplicada, correspondente ao projeto da 2 unidade do
semestre 2014.1 do curso de Engenharia de Computao
da Universidade Federal do Rio Grande do Norte, sob
orientao

do

Prof.

Fernandes.

Professor: Marcelo Augusto Costa Fernandes

Natal-RN
2014

Marcelo

Augusto

Costa

1 Resumo
O projeto tem como objetivo encontrar um controle adequado a velocidade de
um veculo simulado, utilizando-se da tcnica do algoritmo gentico. Prope-se dois
mtodos de controle um baseado na otimizao de um sistema especialista com
representao de conhecimento fuzzy, utilizando o algoritmo gentico, responsveis por
buscar e otimizar o sistema atravs de buscas baseadas em mecanismos de seleo
natural e gentica, buscando valores adequados aos parmetros do controlador fuzzy. O
outro se baseia na aplicao do algoritmo gentico para o clculo direto e do ajuste dos
valores de transmisso e torque do motor para gerar menor variao de velocidade a
cada instante, mesmo durante o surgimento de inclinaes em seu percurso, mantendo a
velocidade do veculo aproximadamente constante.

2 - Descrio do Problema
Para otimizar o sistema responsvel pelo controle de velocidade foram
utilizados algoritmos que baseiam-se em codificaes do conjunto das solues
possveis e no nos parmetros de otimizao em si, alm de no necessitarem de
conhecimentos derivados do problema (apenas necessitam de uma forma para avaliar os
resultados obtidos) ainda utilizam transies probabilsticas e no determinsticas.
Os seguintes parmetros tiveram de ser adaptados para cada algoritmo
desenvolvido, afim de se obter os melhores valores de otimizao: tamanho da
populao, tipos de indivduos, populao inicial, taxa de elitismo, taxa de cruzamento,
taxa de mutao alm de selecionar as funes de cruzamento e de seleo.
Cada indivduo possui cromossomos, responsveis por guardar os valores a
serem otimizados, cada um dos algoritmos possui indivduos com valores e quantidades
diferentes de cromossomos e uma populao um conjunto de indivduos.

3 Estratgias Utilizadas
Foram desenvolvidos dois tipos de algoritmos genricos, o primeiro que
funciona de forma online, minimiza o erro ponto a ponto, recalculando os valores de Tm
e Tr. O segundo se trata de um algoritmo off-line que adapta um controlador fuzzy que
possui um acumulador em sua sada, os parmetros do sistema so sintonizados pelo
algoritmo gentico minimizando o erro mdio em cada percurso.
O primeiro tipo de algoritmo possui dois valores representados em seus
cromossomos (Tm e Tr) enquanto o algoritmo que utiliza uma rede fuzzy possui um

vetor de valores para os parmetros fuzzy, alm disso o algoritmo com fuzzy possui
duas funes de entrada e sada, cada funo de entrada possui 5 funes de pertinncia
e cada uma destas funes possui trs parmetros prprios, sendo uma fuzzy do tipo
Sugeno com sada linear, cada um desses parmetros ser ajustado com o algoritmo
gentico.
Foi utilizado o toolbox optimtools-ga pertencente a ferramenta Matlab para o
desenvolvimento dos algoritmos genticos.

4 Cdigos Utilizados

4.1 Algoritmo Gentico

%Parmetros que podem ser alterados
global tFinal ;
tFinal= 10*60; % Tempo final de simulao
%tr = 1; %Transmisso
global d;
d= [0 3000 6000 9000 12000 15000 18000];%Pontos da pista
que tero inclinaes
global vtheta;
vtheta= [0 -10 10 -5 5 4 0] *(pi/180);%Inclinaes
%vtheta = [0] *(pi/180); %Inclinaes
%d = [0];
%Parmetros que no podem ser alterados
global step;
step = 1;
global t;
t= [0:step:tFinal];
global tm;
tm= zeros(1, length(t));
tm(1) = 200;
%tm = 200; %Torque do motor
global tr;
tr= zeros(1, length(t));
tr(1) = 1;
erro = zeros(1,length(t));
global x;
x= zeros(1,length(t));%Velocidade do veculo em m/s
global sAux;

sAux= zeros(1,length(t)); %Vetor auxiliar

global s;
s= zeros(1,length(t)); %Distncia em metros
global e;
e= zeros(1,length(t)); %Energia gasta em Watts
global theta;
theta = zeros(1,length(t)); %Valores de inclinao
trag=0;
tmag=0;
erro(1)=0;
%global error;
%error=0;
global j;
j=2;
for k=2:length(t)
[x(k),e(k)]=vehicleRun(tm(k-1),tr(k-1),theta(k-1),x(k1),e(k-1),t(k-1),t(k));
[theta(k),s(k),sAux(k)]=vehiclePista(x(k),sAux(k1),t(k-1),t(k),vtheta,d);
disp(t(k));
j=k+1;
%disp (theta(k-1))
% erro(k)= 120 - (x(k)*3.6);
%error=erro(k);

options = gaoptimset(@ga);
options. PopulationType = 'doubleVector'; %tipo dos
indivduos
options.PopulationSize = 20; %tamanho da populao
options.PopInitRange = [0;1]; %Matriz ou vetor que
determina o range da populao inicial
options.EliteCount = 0; %Elitismo
options.CrossoverFraction = 0.8 ;%Taxa de cruzamento
options.Mutation=0.01;%mutao
options.CrossoverFcn = @crossoversinglepoint; %nico ponto
no crossover
options.Generations = 30;
[l fval exitflag output population
scores]=ga(@teste,2,[],[],[],[],[],[],[],options)
tmag=200*l(1)+200;
trag=1.5*l(2)+0.5;

%saida = evalfis([erro(k) (theta(k-1)*(180/pi)/180.0)],

BC);
%disp(saida);
tm(k)=tmag;
tr(k) =trag;
if(tr(k)<0.5)
tr(k)=0.5;
end
if(tr(k)>2)
tr(k)=2;
end
if(tm(k)<-400)
tm(k)=-400;
end
if(tm(k)>400)
tm(k)=400;
end
end
plot(t, x*3.6)

4.1.2 Funo de Avaliao do Algoritmos Gentico

function z=teste(l,a)
tmag=200*l(1)+200;
trag=1.5*l(2)+0.5;
global theta;
global x;
global e;
global t;
global j;
if(trag<0.5)
trag=1/2;
end
if(trag>2)
trag=2;
end
if(tmag<-400)
tmag=-400;
end
if(tmag>400)

tmag=400;
end
[calc,qlqr]=vehicleRun(tmag,trag,theta(j-1),x(j-1),e(j-1),t(j1),t(j));
%disp(t(j));
%disp (theta(k-1))
if(100 - calc*3.6>=0)
z=100 - calc*3.6;
end
if(100 - calc*3.6<0)
z=calc*3.6-100;
end
end

4.2 Algoritmos Gentico com Fuzzy

options = gaoptimset(@ga);
options. PopulationType = 'doubleVector'; %tipo dos
indivduos
options.PopulationSize = 15; %tamanho da populao
options.PopInitRange = [0;1]; %Matriz ou vetor que
determina o range da populao inicial gerada
automaticamente
options.EliteCount = 1; %Elitismo
options.CrossoverFraction = 0.8 ;%Taxa de cruzamento
options.Mutation=0.01;
options.CrossoverFcn = @crossoversinglepoint; %nico ponto
no crossover
options.Generations = 25;
[l fval exitflag output population
scores]=ga(@testgambiarra,48,[],[],[],[],[],[],[],options)
%Parmetros que podem ser alterados
tFinal = 10*60; % Tempo final de simulao
%tr = 1; %Transmisso
d = [0 3000 6000 9000 12000 15000 18000];%Pontos da pista
que tero inclinaes
vtheta = [0 -10 10 -5 5 4 0] *(pi/180);%Inclinaes

%vtheta = [0] *(pi/180); %Inclinaes

%Parmetros que no podem ser alterados
step = 0.5;
t = [0:step:tFinal];
tm = zeros(1, length(t));
tm(1) = 200;
%tm = 200; %Torque do motor
tr = zeros(1, length(t));
tr(1) = 1;
tri=0;
tmi=0;
erro = zeros(1,length(t));
x = zeros(1,length(t));%Velocidade do veculo em m/s
sAux = zeros(1,length(t)); %Vetor auxiliar
s = zeros(1,length(t)); %Distncia em metros
e = zeros(1,length(t)); %Energia gasta em Watts
theta = zeros(1,length(t)); %Valores de inclinao
BC = readfis('IA2.fis');
BC.input(1).mf(1).type='gaussmf';
BC.input(1).mf(2).type='gaussmf';
BC.input(1).mf(3).type='gaussmf';
BC.input(1).mf(4).type='gaussmf';
BC.input(1).mf(5).type='gaussmf';
BC.input(2).mf(1).type='gaussmf';
BC.input(2).mf(2).type='gaussmf';
BC.input(2).mf(3).type='gaussmf';
BC.input(2).mf(4).type='gaussmf';
BC.input(2).mf(5).type='gaussmf';
BC.input(1).mf(1).params=[l(1) l(2) l(3)];
BC.input(1).mf(2).params=[l(4) l(5) l(6)];
BC.input(1).mf(3).params=[l(7) l(8) l(9)];
BC.input(1).mf(4).params=[l(10) l(11) l(12)];
BC.input(1).mf(5).params=[l(13) l(14) l(15)];
BC.input(2).mf(1).params=[l(16) l(17) l(18)];
BC.input(2).mf(2).params=[l(19) l(20) l(21)];
BC.input(2).mf(3).params=[l(22) l(23) l(24)];
BC.input(2).mf(4).params=[l(25) l(26) l(27)];
BC.input(2).mf(5).params=[l(28) l(29) l(30)];
BC.output(1).mf(1).params=[l(31) l(32) l(33)];
BC.output(1).mf(2).params=[l(34) l(35) l(36)];
BC.output(1).mf(3).params=[l(37) l(38) l(39)];
BC.output(2).mf(1).params=[l(40) l(41) l(42)];
BC.output(2).mf(2).params=[l(43) l(44) l(45)];
BC.output(2).mf(3).params=[l(46) l(47) l(48)];
writefis(BC,'IA2.fis');
erroavaliacao=0;

cont=0;
for k=2:length(t)
tr(k) =saida(2);
tr(k)=tri+tr(k);
if(tr(k)<0.5)
tr(k)=0.5;
end
if(tr(k)>2)
tr(k)=2.5;
end
tri=tr(k);
tm(k)= saida(1);
tm(k)=tm(k)+tmi;
if(tm(k)<-400)
tm(k)=-400;
end
if(tm(k)>400)
tm(k)=400;
end
tmi=tm(k);
[x(k),e(k)]=vehicleRun(tm(k-1),tr(k-1),theta(k-1),x(k1),e(k-1),t(k-1),t(k));
try
[theta(k),s(k),sAux(k)]=vehiclePista(x(k),sAux(k1),t(k-1),t(k),vtheta,d);
catch exception
continue
end
disp(t(k));
erro(k)= 80 - (x(k)*3.6);
saida = evalfis([erro(k) (theta(k-1)*(180/pi)/180.0)],
BC);
disp(saida);
erroavaliacao=erroavaliacao+erro(k);
cont=cont+1;
end
plot(t, x*3.6)

4.1.2 Funo de Avaliao do Algoritmos Gentico com Fuzzy

function z=testn(l,a)
tFinal = 10*60; % Tempo final de simulao
%tr = 1; %Transmisso
d = [0 3000 6000 9000 12000 15000 18000];%Pontos da pista que
tero inclinaes
vtheta = [0 -10 10 -5 5 4 0] *(pi/180);%Inclinaes
%vtheta = [0] *(pi/180); %Inclinaes
%d = [0];
%Parmetros que no podem ser alterados
step = 1;
t = [0:step:tFinal];
tm = zeros(1, length(t));
tm(1) = 200;
%tm = 200; %Torque do motor
tr = zeros(1, length(t));
tr(1) = 1;

erro = zeros(1,length(t));
x = zeros(1,length(t));%Velocidade do veculo em m/s
sAux = zeros(1,length(t)); %Vetor auxiliar
s = zeros(1,length(t)); %Distncia em metros
e = zeros(1,length(t)); %Energia gasta em Watts
theta = zeros(1,length(t)); %Valores de inclinao
BC = readfis('IA2.fis');
BC.input(1).mf(1).type='gaussmf';
BC.input(1).mf(2).type='gaussmf';
BC.input(1).mf(3).type='gaussmf';
BC.input(1).mf(4).type='gaussmf';
BC.input(1).mf(5).type='gaussmf';
BC.input(2).mf(1).type='gaussmf';
BC.input(2).mf(2).type='gaussmf';
BC.input(2).mf(3).type='gaussmf';
BC.input(2).mf(4).type='gaussmf';
BC.input(2).mf(5).type='gaussmf';
BC.input(1).mf(1).params=[l(1) l(2) l(3)];
BC.input(1).mf(2).params=[l(4) l(5) l(6)];
BC.input(1).mf(3).params=[l(7) l(8) l(9)];
BC.input(1).mf(4).params=[l(10) l(11) l(12)];
BC.input(1).mf(5).params=[l(13) l(14) l(15)];
BC.input(2).mf(1).params=[l(16) l(17) l(18)];
BC.input(2).mf(2).params=[l(19) l(20) l(21)];
BC.input(2).mf(3).params=[l(22) l(23) l(24)];
BC.input(2).mf(4).params=[l(25) l(26) l(27)];
BC.input(2).mf(5).params=[l(28) l(29) l(30)];
BC.output(1).mf(1).params=[l(31) l(32) l(33)];

BC.output(1).mf(2).params=[l(34)
BC.output(1).mf(3).params=[l(37)
BC.output(2).mf(1).params=[l(40)
BC.output(2).mf(2).params=[l(43)
BC.output(2).mf(3).params=[l(46)

l(35)
l(38)
l(41)
l(44)
l(47)

l(36)];
l(39)];
l(42)];
l(45)];
l(48)];

%setfis('IA2.fis');
writefis(BC,'IA2.fis');
erroavaliacao=0;
cont=0;
for k=2:length(t)
[x(k),e(k)]=vehicleRun(tm(k-1),tr(k-1),theta(k-1),x(k1),e(k-1),t(k-1),t(k));
try
[theta(k),s(k),sAux(k)]=vehiclePista(x(k),sAux(k-1),t(k1),t(k),vtheta,d);
catch exception
continue
end
disp(t(k));
%disp (theta(k-1))
erro(k)= 120 - (x(k)*3.6);
saida = evalfis([erro(k) (theta(k-1)*(180/pi)/180.0)], BC);
%disp(saida);
if (erro(k)>=0)
erroavaliacao=erroavaliacao+erro(k);
end
if (erro(k)<0)
erroavaliacao=erroavaliacao-erro(k);
end
cont=cont+1;
tr(k) =saida(2);
if(tr(k)<0.5)
tr(k)=0.5;
end
if(tr(k)>2)
tr(k)=2.5;
end
tm(k)= saida(1);
if(tm(k)<-400)
tm(k)=-400;
end
if(tm(k)>400)
tm(k)=400;
end
end
z=erroavaliacao/cont;
end

5 Resultados
Foram obtidos os seguintes resultados para as simulaes testadas, de um sistema de
controle de velocidade utilizando os algoritmos genticos desenvolvidos:
Algoritmo gentico 1, com velocidade em 80 km/h e com inclinaes em [0 3000 6000
9000 12000 15000 16000] km

Algoritmo gentico 1, com velocidade em 120 km/h e com inclinaes em [0 3000

6000 9000 12000 15000 16000] km

Algoritmo gentico com fuzzy, velocidade em 120 km/h e com inclinaes em

[0 3000 6000 9000 12000 15000 16000] km

Algoritmo gentico com fuzzy, com velocidade em 80 km/h e com inclinaes

em [0 1500 3000 4500 6000 7500 8000] km

6 Concluso
Observando as simulaes obtidas sobre os sistemas de controle otimizados com
algoritmos genticos, percebe-se que utilizando o primeiro algoritmo obtivemos timos
meios de otimizao pois o veculo em questo foi capaz de estabilizar sua velocidade
em um bom intervalo de tempo, porm com o algoritmo que foi construdo em conjunto
com o controlado fuzzy mostrou-se mais susceptvel as inclinaes, mostrando um
controle mais lento e menos estvel. Conforme foi observado o aumento do nmero de
indivduos e de geraes torna o controle mais suave, e com uma convergncia em
menor tempo.
Para que se fizesse uma comparao realmente justa entre o Algoritmo Gentico
e a proposta hibrida com o fuzzy, seria necessrio um maio nmero de indivduos e
populaes. Deste modo provavelmente se obteria um melhor resultado para a tcnica
hibrida. Observou-se que a tcnica hibrida realiza o processamento off-line
apresentando a vantagem que aps a sintonia ter sido finalizada ter o controle com
pouca demanda de processamento.
O uso do Algoritmo Gentico puro, por outro lado possui uma grande
demanda por processamento durante o controle, por ser on-line.